À mon avis, la réponse acceptée prête à confusion, car elle utilise un DataFrame avec uniquement des valeurs manquantes. Je n'aime pas non plus le terme basé sur la position .iloc
et préfère plutôt l' emplacement entier car il est beaucoup plus descriptif et exactement ce qui .iloc
signifie. Le mot clé est INTEGER - a .iloc
besoin d'INTÉGRATEURS.
Voir ma série de blogs extrêmement détaillée sur la sélection de sous-ensembles pour en savoir plus
.ix est obsolète et ambigu et ne doit jamais être utilisé
Parce qu'il .ix
est obsolète, nous nous concentrerons uniquement sur les différences entre .loc
et .iloc
.
Avant de parler des différences, il est important de comprendre que les DataFrames ont des étiquettes qui aident à identifier chaque colonne et chaque index. Jetons un coup d'œil à un exemple de DataFrame:
df = pd.DataFrame({'age':[30, 2, 12, 4, 32, 33, 69],
'color':['blue', 'green', 'red', 'white', 'gray', 'black', 'red'],
'food':['Steak', 'Lamb', 'Mango', 'Apple', 'Cheese', 'Melon', 'Beans'],
'height':[165, 70, 120, 80, 180, 172, 150],
'score':[4.6, 8.3, 9.0, 3.3, 1.8, 9.5, 2.2],
'state':['NY', 'TX', 'FL', 'AL', 'AK', 'TX', 'TX']
},
index=['Jane', 'Nick', 'Aaron', 'Penelope', 'Dean', 'Christina', 'Cornelia'])
Tous les mots en gras sont les étiquettes. Les étiquettes, age
, color
, food
, height
, score
et state
sont utilisés pour les colonnes . Les autres étiquettes, Jane
, Nick
, Aaron
, Penelope
, Dean
, Christina
, Cornelia
sont utilisés pour l' indice .
Les principaux moyens de sélectionner des lignes particulières dans un DataFrame sont avec les indexeurs .loc
et .iloc
. Chacun de ces indexeurs peut également être utilisé pour sélectionner simultanément des colonnes, mais il est plus facile de se concentrer uniquement sur les lignes pour l'instant. De plus, chacun des indexeurs utilise un ensemble de crochets qui suivent immédiatement leur nom pour effectuer leurs sélections.
.loc sélectionne les données uniquement par des étiquettes
Nous parlerons d'abord de l' .loc
indexeur qui sélectionne uniquement les données par les étiquettes d'index ou de colonne. Dans notre exemple DataFrame, nous avons fourni des noms significatifs comme valeurs pour l'index. De nombreux DataFrames n'auront pas de noms significatifs et seront, par défaut, uniquement des entiers de 0 à n-1, où n est la longueur du DataFrame.
Vous pouvez utiliser trois entrées différentes pour .loc
- Un string
- Une liste de chaînes
- Notation de tranche utilisant des chaînes comme valeurs de début et de fin
Sélection d'une seule ligne avec .loc avec une chaîne
Pour sélectionner une seule ligne de données, placez l'étiquette d'index à l'intérieur des crochets suivants .loc
.
df.loc['Penelope']
Cela renvoie la ligne de données sous forme de série
age 4
color white
food Apple
height 80
score 3.3
state AL
Name: Penelope, dtype: object
Sélection de plusieurs lignes avec .loc avec une liste de chaînes
df.loc[['Cornelia', 'Jane', 'Dean']]
Cela renvoie un DataFrame avec les lignes dans l'ordre spécifié dans la liste:
Sélection de plusieurs lignes avec .loc avec notation par tranche
La notation de tranche est définie par des valeurs de début, d'arrêt et de pas. Lors du découpage par étiquette, pandas inclut la valeur d'arrêt dans le retour. Les tranches suivantes d'Aaron à Dean, inclusivement. Sa taille de pas n'est pas explicitement définie mais définie par défaut sur 1.
df.loc['Aaron':'Dean']
Les tranches complexes peuvent être prises de la même manière que les listes Python.
.iloc sélectionne les données uniquement par emplacement entier
Passons maintenant à .iloc
. Chaque ligne et colonne de données dans un DataFrame a un emplacement entier qui le définit. Ceci s'ajoute au libellé affiché visuellement dans la sortie . L'emplacement entier est simplement le nombre de lignes / colonnes à partir du haut / gauche commençant à 0.
Vous pouvez utiliser trois entrées différentes pour .iloc
- Un nombre entier
- Une liste d'entiers
- Notation de tranche utilisant des entiers comme valeurs de début et de fin
Sélection d'une seule ligne avec .iloc avec un entier
df.iloc[4]
Cela renvoie la 5ème ligne (emplacement entier 4) en tant que série
age 32
color gray
food Cheese
height 180
score 1.8
state AK
Name: Dean, dtype: object
Sélection de plusieurs lignes avec .iloc avec une liste d'entiers
df.iloc[[2, -2]]
Cela renvoie un DataFrame des troisième et avant-dernière lignes:
Sélection de plusieurs lignes avec .iloc avec notation par tranche
df.iloc[:5:3]
Sélection simultanée de lignes et de colonnes avec .loc et .iloc
Une excellente capacité des deux .loc/.iloc
est leur capacité à sélectionner simultanément les lignes et les colonnes. Dans les exemples ci-dessus, toutes les colonnes ont été renvoyées à partir de chaque sélection. Nous pouvons choisir des colonnes avec les mêmes types d'entrées que pour les lignes. Nous devons simplement séparer la sélection des lignes et des colonnes par une virgule .
Par exemple, nous pouvons sélectionner les lignes Jane et Dean avec juste la hauteur, le score et l'état des colonnes comme ceci:
df.loc[['Jane', 'Dean'], 'height':]
Cela utilise une liste d'étiquettes pour les lignes et une notation de tranche pour les colonnes
Nous pouvons naturellement effectuer des opérations similaires en .iloc
utilisant uniquement des entiers.
df.iloc[[1,4], 2]
Nick Lamb
Dean Cheese
Name: food, dtype: object
Sélection simultanée avec étiquettes et emplacement entier
.ix
a été utilisé pour effectuer des sélections simultanément avec des étiquettes et un emplacement entier, ce qui était utile mais parfois déroutant et ambigu et heureusement, il a été déconseillé. Dans le cas où vous devez effectuer une sélection avec un mélange d'étiquettes et d'emplacements entiers, vous devrez effectuer à la fois vos étiquettes de sélections ou des emplacements entiers.
Par exemple, si nous voulons sélectionner des lignes Nick
et Cornelia
avec les colonnes 2 et 4, nous pourrions utiliser .loc
en convertissant les entiers en étiquettes avec ce qui suit:
col_names = df.columns[[2, 4]]
df.loc[['Nick', 'Cornelia'], col_names]
Ou bien, convertissez les étiquettes d'index en entiers avec la get_loc
méthode d'index.
labels = ['Nick', 'Cornelia']
index_ints = [df.index.get_loc(label) for label in labels]
df.iloc[index_ints, [2, 4]]
Sélection booléenne
L'indexeur .loc peut également effectuer une sélection booléenne. Par exemple, si nous voulons trouver toutes les lignes dont l'âge est supérieur à 30 ans et renvoyer uniquement les colonnes food
et, score
nous pouvons procéder comme suit:
df.loc[df['age'] > 30, ['food', 'score']]
Vous pouvez répliquer cela avec .iloc
mais vous ne pouvez pas lui passer une série booléenne. Vous devez convertir la série booléenne en un tableau numpy comme celui-ci:
df.iloc[(df['age'] > 30).values, [2, 4]]
Sélection de toutes les lignes
Il est possible d'utiliser .loc/.iloc
uniquement pour la sélection de colonnes. Vous pouvez sélectionner toutes les lignes en utilisant deux points comme ceci:
df.loc[:, 'color':'score':2]
L'opérateur d'indexation,, []
peut également sélectionner des lignes et des colonnes, mais pas simultanément.
La plupart des gens connaissent le but principal de l'opérateur d'indexation DataFrame, qui est de sélectionner des colonnes. Une chaîne sélectionne une seule colonne en tant que série et une liste de chaînes sélectionne plusieurs colonnes en tant que DataFrame.
df['food']
Jane Steak
Nick Lamb
Aaron Mango
Penelope Apple
Dean Cheese
Christina Melon
Cornelia Beans
Name: food, dtype: object
L'utilisation d'une liste sélectionne plusieurs colonnes
df[['food', 'score']]
Ce que les gens connaissent moins, c'est que, lorsque la notation par tranche est utilisée, la sélection se fait par étiquettes de ligne ou par emplacement entier. C'est très déroutant et quelque chose que je n'utilise presque jamais, mais cela fonctionne.
df['Penelope':'Christina'] # slice rows by label
df[2:6:2] # slice rows by integer location
L'explication de la .loc/.iloc
sélection de lignes est hautement préférée. L'opérateur d'indexation seul ne peut pas sélectionner simultanément des lignes et des colonnes.
df[3:5, 'color']
TypeError: unhashable type: 'slice'