En quoi iloc, ix et loc sont-ils différents?

Quelqu'un peut-il expliquer en quoi ces trois méthodes de découpage sont différentes?
J'ai vu les documents et j'ai vu ces réponses , mais je n'arrive toujours pas à expliquer en quoi les trois sont différents. Pour moi, ils semblent interchangeables en grande partie, car ils sont aux niveaux inférieurs de tranchage.

Par exemple, disons que nous voulons obtenir les cinq premières lignes de a DataFrame. Comment se fait-il que ces trois éléments fonctionnent?

df.loc[:5]
df.ix[:5]
df.iloc[:5]

Quelqu'un peut-il présenter trois cas où la distinction des usages est plus claire?

Remarque: dans les versions 0.20.0 et supérieures de pandas, ixest déconseillé et l'utilisation de locet ilocest plutôt encouragée. J'ai laissé les parties de cette réponse qui décrivent ixintactes comme référence pour les utilisateurs des versions antérieures de pandas. Des exemples ont été ajoutés ci-dessous montrant des alternatives à ix .

Tout d'abord, voici un récapitulatif des trois méthodes:

• locobtient des lignes (ou colonnes) avec des étiquettes particulières de l'index.
• ilocobtient des lignes (ou colonnes) à des positions particulières dans l'index (donc il ne prend que des entiers).
• ixessaie généralement de se comporter comme locmais revient à se comporter comme ilocsi une étiquette n'est pas présente dans l'index.

Il est important de noter certaines subtilités qui peuvent être ixlégèrement délicates à utiliser:

• si l'index est de type entier, ixn'utilisera que l'indexation basée sur les étiquettes et ne retombera pas sur l'indexation basée sur la position. Si l'étiquette n'est pas dans l'index, une erreur est générée.

• si l'index ne contient pas uniquement des entiers, alors étant donné un entier, ixutilisera immédiatement l'indexation basée sur la position plutôt que l'indexation basée sur l'étiquette. Si toutefois ixon lui donne un autre type (par exemple une chaîne), il peut utiliser une indexation basée sur les étiquettes.

Pour illustrer les différences entre les trois méthodes, considérons la série suivante:

>>> s = pd.Series(np.nan, index=[49,48,47,46,45, 1, 2, 3, 4, 5])
>>> s
49   NaN
48   NaN
47   NaN
46   NaN
45   NaN
1    NaN
2    NaN
3    NaN
4    NaN
5    NaN

Nous allons voir le découpage avec la valeur entière 3.

Dans ce cas, s.iloc[:3]nous renvoie les 3 premières lignes (car il traite 3 comme une position) et s.loc[:3]nous renvoie les 8 premières lignes (car il traite 3 comme une étiquette):

>>> s.iloc[:3] # slice the first three rows
49   NaN
48   NaN
47   NaN

>>> s.loc[:3] # slice up to and including label 3
49   NaN
48   NaN
47   NaN
46   NaN
45   NaN
1    NaN
2    NaN
3    NaN

>>> s.ix[:3] # the integer is in the index so s.ix[:3] works like loc
49   NaN
48   NaN
47   NaN
46   NaN
45   NaN
1    NaN
2    NaN
3    NaN

Remarque s.ix[:3]renvoie la même série s.loc[:3]car il recherche d'abord l'étiquette plutôt que de travailler sur la position (et l'index pour sest de type entier).

Et si nous essayons avec une étiquette entière qui n'est pas dans l'index (disons 6)?

Renvoie ici s.iloc[:6]les 6 premières lignes de la série comme prévu. Cependant, s.loc[:6]déclenche une erreur KeyError puisqu'elle 6n'est pas dans l'index.

>>> s.iloc[:6]
49   NaN
48   NaN
47   NaN
46   NaN
45   NaN
1    NaN

>>> s.loc[:6]
KeyError: 6

>>> s.ix[:6]
KeyError: 6

Selon les subtilités notées ci-dessus, s.ix[:6]déclenche maintenant une erreur KeyError car il essaie de fonctionner comme locmais ne peut pas trouver un 6dans l'index. Parce que notre index est de type entier ixne revient pas à se comporter comme iloc.

Si, cependant, notre index était de type mixte, étant donné qu'un entier ixse comporterait comme ilocimmédiatement au lieu de déclencher une erreur de clé:

>>> s2 = pd.Series(np.nan, index=['a','b','c','d','e', 1, 2, 3, 4, 5])
>>> s2.index.is_mixed() # index is mix of different types
True
>>> s2.ix[:6] # now behaves like iloc given integer
a   NaN
b   NaN
c   NaN
d   NaN
e   NaN
1   NaN

Gardez à l'esprit que vous ixpouvez toujours accepter des non-entiers et vous comporter comme loc:

>>> s2.ix[:'c'] # behaves like loc given non-integer
a   NaN
b   NaN
c   NaN

Comme conseil général, si vous indexez uniquement à l'aide d'étiquettes, ou uniquement à l'aide de positions entières, respectez locou ilocpour éviter des résultats inattendus - essayez de ne pas utiliser ix.

Combinaison d'une indexation basée sur la position et basée sur une étiquette

Parfois, étant donné un DataFrame, vous souhaiterez mélanger les méthodes d'indexation d'étiquette et de position pour les lignes et les colonnes.

Par exemple, considérez le DataFrame suivant. Comment découper au mieux les lignes jusqu'au «c» inclus et prendre les quatre premières colonnes?

>>> df = pd.DataFrame(np.nan, 
                      index=list('abcde'),
                      columns=['x','y','z', 8, 9])
>>> df
    x   y   z   8   9
a NaN NaN NaN NaN NaN
b NaN NaN NaN NaN NaN
c NaN NaN NaN NaN NaN
d NaN NaN NaN NaN NaN
e NaN NaN NaN NaN NaN

Dans les versions antérieures de pandas (avant 0.20.0), cela ixvous permet de le faire assez bien - nous pouvons découper les lignes par étiquette et les colonnes par position (notez que pour les colonnes, ixpar défaut, le découpage basé sur la position 4n'est pas un nom de colonne ):

>>> df.ix[:'c', :4]
    x   y   z   8
a NaN NaN NaN NaN
b NaN NaN NaN NaN
c NaN NaN NaN NaN

Dans les versions ultérieures de pandas, nous pouvons obtenir ce résultat à l'aide ilocet à l'aide d'une autre méthode:

>>> df.iloc[:df.index.get_loc('c') + 1, :4]
    x   y   z   8
a NaN NaN NaN NaN
b NaN NaN NaN NaN
c NaN NaN NaN NaN

get_loc()est une méthode d'index qui signifie "obtenir la position de l'étiquette dans cet index". Notez que puisque le découpage avec ilocest exclusif de son point de terminaison, nous devons ajouter 1 à cette valeur si nous voulons également la ligne 'c'.

Il y a d'autres exemples dans la documentation des pandas ici .

ilocfonctionne basé sur le positionnement entier. Donc, peu importe vos étiquettes de ligne, vous pouvez toujours, par exemple, obtenir la première ligne en faisant

df.iloc[0]

ou les cinq dernières lignes en faisant

df.iloc[-5:]

Vous pouvez également l'utiliser sur les colonnes. Cela récupère la 3ème colonne:

df.iloc[:, 2]    # the : in the first position indicates all rows

Vous pouvez les combiner pour obtenir des intersections de lignes et de colonnes:

df.iloc[:3, :3] # The upper-left 3 X 3 entries (assuming df has 3+ rows and columns)

D'un autre côté, .locutilisez des indices nommés. Configurons un bloc de données avec des chaînes comme étiquettes de ligne et de colonne:

df = pd.DataFrame(index=['a', 'b', 'c'], columns=['time', 'date', 'name'])

Ensuite, nous pouvons obtenir la première ligne en

df.loc['a']     # equivalent to df.iloc[0]

et les deux deuxièmes rangées de la 'date'colonne par

df.loc['b':, 'date']   # equivalent to df.iloc[1:, 1]

etc. Maintenant, il convient probablement de souligner que les indices de ligne et de colonne par défaut pour a DataFramesont des entiers de 0 et dans ce cas iloc, locils fonctionneraient de la même manière. C'est pourquoi vos trois exemples sont équivalents. Si vous aviez un index non numérique tel que des chaînes ou des heures, df.loc[:5] cela déclencherait une erreur.

En outre, vous pouvez effectuer une récupération de colonne en utilisant simplement le bloc de données __getitem__:

df['time']    # equivalent to df.loc[:, 'time']

Supposons maintenant que vous vouliez mélanger la position et l'indexation nommée, c'est-à-dire l'indexation en utilisant des noms sur les lignes et des positions sur les colonnes (pour clarifier, je veux dire sélectionner dans notre bloc de données, plutôt que de créer un bloc de données avec des chaînes dans l'index des lignes et des entiers dans l'index de la colonne). C'est là .ixqu'intervient:

df.ix[:2, 'time']    # the first two rows of the 'time' column

Je pense qu'il convient également de mentionner que vous pouvez également transmettre des vecteurs booléens à la locméthode. Par exemple:

 b = [True, False, True]
 df.loc[b] 

Renvoie les 1er et 3e rangées de df. C'est équivalent à df[b]pour la sélection, mais il peut également être utilisé pour l'affectation via des vecteurs booléens:

df.loc[b, 'name'] = 'Mary', 'John'

À 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 .ilocet préfère plutôt l' emplacement entier car il est beaucoup plus descriptif et exactement ce qui .ilocsignifie. Le mot clé est INTEGER - a .ilocbesoin 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 .ixest obsolète, nous nous concentrerons uniquement sur les différences entre .locet .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, scoreet statesont utilisés pour les colonnes . Les autres étiquettes, Jane, Nick, Aaron, Penelope, Dean, Christina, Corneliasont utilisés pour l' indice .

Les principaux moyens de sélectionner des lignes particulières dans un DataFrame sont avec les indexeurs .locet .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' .locindexeur 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/.ilocest 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 .ilocutilisant 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

.ixa é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 Nicket Corneliaavec les colonnes 2 et 4, nous pourrions utiliser .locen 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_locmé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 foodet, scorenous pouvons procéder comme suit:

df.loc[df['age'] > 30, ['food', 'score']] 

Vous pouvez répliquer cela avec .ilocmais 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/.ilocuniquement 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/.ilocsé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'