Fonction df.loc() de Pandas

Pandas 常用函数 Fonctions courantes de Pandas

loc[]C’est une méthode d’indexation basée sur les étiquettes dans Pandas, utilisée pour sélectionner des données via les étiquettes de lignes et de colonnes. C’est l’une des méthodes d’indexation de DataFrame les plus intuitives et les plus couramment utilisées, permettant de localiser précisément les données dont nous avons besoin.

Contrairement à l’indexation basée sur la position (telle queiloc[]),loc[]il utilise les étiquettes d’index définies dans les données elles-mêmes. Cela signifie que même si la position des données change, tant que les étiquettes restent inchangées, nous pouvons toujours sélectionner avec précision les données cibles.

Syntaxe de base et paramètres

loc[]C'est l'indexeur de DataFrame, accessible via des crochets[]pour accéder. Diverses formes de paramètres peuvent être passées à l’intérieur des crochets pour sélectionner des lignes, des colonnes ou des cellules spécifiques.

Format de syntaxe

# 选择单行（返回 Series）
DataFrame.loc[行标签]

# 选择多行（返回 DataFrame）
DataFrame.loc[[行标签1, 行标签2, ...]]

# 选择行和列
DataFrame.loc[行标签, 列标签]
DataFrame.loc[行切片, 列切片]
DataFrame.loc[行条件, 列条件]

Description du paramètre

Position des paramètres	Type de paramètre	Description
Premier paramètre (lignes)	Étiquette, liste d’étiquettes, tranche d’étiquettes, tableau booléen	Utilisé pour sélectionner des lignes ; peut être une étiquette unique, plusieurs étiquettes, une tranche ou une expression conditionnelle.
Deuxième paramètre (colonnes)	Étiquette, liste d’étiquettes, tranche d’étiquettes	Facultatif, utilisé pour sélectionner des colonnes ; la syntaxe est identique à celle de la sélection de lignes.

Description de la valeur de retour

Élément unique: Renvoie une valeur scalaire (une valeur unique).
Ligne unique: Renvoie une Series.
Plusieurs lignes: Renvoie un DataFrame.
Combinaison de lignes et de colonnes: Retourne une Series ou un DataFrame selon le résultat de la sélection.

Exemples

Maîtrisons pleinement à travers des exemples richesloc[]l'utilisation de ...

Exemple 1 : Utilisation de base - Utilisation de l'index par défaut

Lorsque le DataFrame utilise l'index entier par défaut,loc[]le comportement de ...iloc[]est similaire, mais utilise des étiquettes plutôt que des positions.

Exemple

import pandas as pd

# Créer un DataFrame d'exemple
data = {
'name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
'age': [18, 19, 17, 18, 20],
'score': [85, 92, 78, 90, 88],
'grade': ['A', 'A', 'B', 'A', 'B']
}
df = pd.DataFrame(data)

print("DataFrame d'origine :")
print(df)
print()

# Utiliser loc pour sélectionner une seule ligne (via l'étiquette d'index)
print("Sélectionner la ligne 0 :")
print(df.loc[0])
print()

# Sélectionner plusieurs lignes
print("Sélectionner les lignes 1, 3, 4 :")
print(df.loc[[1, 3, 4]])
print()

# Utiliser le slicing pour sélectionner des lignes consécutives (remarque : le slicing loc est inclusif aux deux extrémités)
print("Sélectionner les lignes 1 à 3 (bornes incluses) :")
print(df.loc[1:3])

Sortie :

原始 DataFrame:
      name  age  score grade
0    Alice   18     85     A
1      Bob   19     92     A
2  Charlie   17     78     B
3    David   18     90     A
4      Eve   20     88     B

选择第 0 行:
name      Alice
age          18
score        85
grade         A
Name: 0, dtype: object

选择第 1、3、4 行:
    name  age  score grade
1    Bob   19     92     A
3  David   18     90     A
4      Eve   20     88     B

选择第 1 行到第 3 行（包含两端）:
      name  age  score grade
1      Bob   19     92     A
2  Charlie   17     78     B
3    David   18     90     A

Explication du code :

Par défaut, l'index du DataFrame correspond aux entiers 0, 1, 2, 3, 4.
df.loc[0]La sélection de la ligne avec l'étiquette d'index 0 renvoie une Series.
df.loc[[1, 3, 4]]Sélectionne plusieurs lignes avec des indices spécifiques.
Important：loc[]Son slicing est inclusif aux deux extrémités (contrairement au slicing Python),1:3y compris les indices 1, 2, 3.

Exemple 2 : Utilisation d'un index personnalisé

loc[]La vraie puissance de loc réside dans la capacité d'utiliser des étiquettes d'index personnalisées, ce qui constitue sailoc[]différence fondamentale.

Exemple

import pandas as pd

# Créer un DataFrame avec un index personnalisé
data = {
'name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
'age': [18, 19, 17, 18, 20],
'score': [85, 92, 78, 90, 88],
'grade': ['A', 'A', 'B', 'A', 'B']
}
df = pd.DataFrame(data, index=['a', 'b', 'c', 'd', 'e'])

print("DataFrame avec un index personnalisé :")
print(df)
print()

# Utiliser une étiquette personnalisée pour sélectionner une seule ligne
print("Sélectionnez la ligne avec l'index 'b' :")
print(df.loc['b'])
print()

# Utiliser des étiquettes personnalisées pour le slicing
print("Sélectionner les lignes de l'index 'b' à 'd':")
print(df.loc['b':'d'])
print()

# Sélectionner plusieurs indices non consécutifs
print("Sélectionner les lignes avec les indices 'a', 'c', 'e':")
print(df.loc[['a', 'c', 'e']])

Sortie :

带自定义索引的 DataFrame:
   name  age  score grade
a  Alice   18     85     A
b    Bob   19     92     A
c  Charlie   17     78     B
d  David   18     90     A
e    Eve   20     88     B

选择索引为 'b' 的行:
name        Bob
age          19
score        92
grade         A
Name: b, dtype: object

选择索引 'b' 到 'd' 的行:
      name  age  score grade
b    Bob   19     92     A
c  Charlie   17     78     B
d  David   18     90     A

选择索引 'a', 'c', 'e' 的行:
      name  age  score grade
a  Alice   18     85     A
c  Charlie   17     78     B
e    Eve   20     88     B

Explication du code :

L'index personnalisé utilise des chaînes 'a', 'b', 'c', 'd', 'e' au lieu d'indices entiers.
loc[]L'utilisation de ces étiquettes pour sélectionner des données est très intuitive.
La tranche 'b':'d' inclut les étiquettes 'b', 'c', 'd', et est également inclusive aux deux extrémités.

Exemple 3 : Sélection de colonnes spécifiques

loc[]Non seulement vous pouvez sélectionner des lignes, mais vous pouvez également sélectionner des colonnes en même temps.

Exemple

import pandas as pd

data = {
'name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
'age': [18, 19, 17, 18, 20],
'score': [85, 92, 78, 90, 88],
'grade': ['A', 'A', 'B', 'A', 'B']
}
df = pd.DataFrame(data, index=['a', 'b', 'c', 'd', 'e'])

# Sélectionner des colonnes spécifiques pour des lignes spécifiques
print("Sélectionner les colonnes name et score pour l'index 'b':")
print(df.loc['b', ['name', 'score']])
print()

# Sélectionner plusieurs lignes et colonnes
print("Sélectionner les colonnes name et age pour les indices 'a', 'c':")
print(df.loc[['a', 'c'], ['name', 'age']])
print()

# Sélectionner des colonnes spécifiques pour toutes les lignes
print("Les colonnes name et grade de toutes les lignes :")
print(df.loc[:, ['name', 'grade']])
print()

# Combiner le découpage des lignes et des colonnes
print("Les colonnes de name à score pour les indices 'b' à 'd' :")
print(df.loc['b':'d', 'name':'score'])

Sortie :

选择索引 'b' 的 name 和 score 列:
name     Bob
score    92
Name: b, dtype: object

选择索引 'a', 'c' 的 name 和 age 列:
    name  age
a  Alice   18
c  Charlie 17

所有行的 name 和 grade 列:
    name grade
a   Alice     A
b     Bob     A
c  Charlie   B
d    David    A
e     Eve      B

索引 'b' 到 'd' 的 name 到 score 列:
      name  age score
b    Bob   19    92
c  Charlie 17    78
d  David   18    90

Explication du code :

df.loc['b', ['name', 'score']]La sélection de colonnes spécifiques d'une ligne spécifique renvoie une Series.
df.loc[['a', 'c'], ['name', 'age']]La sélection de plusieurs lignes et colonnes renvoie un DataFrame.
df.loc[:, ['name', 'grade']]Un deux-points signifie sélectionner toutes les lignes.
df.loc['b':'d', 'name':'score']Utilisez le slicing pour les lignes et les colonnes simultanément.

Exemple 4 : Utilisation de la sélection par condition booléenne

loc[]Il prend en charge l'utilisation de tableaux booléens ou d'expressions conditionnelles pour filtrer les données, ce qui est une fonctionnalité très puissante.

Exemple

import pandas as pd

data = {
'name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
'age': [18, 19, 17, 18, 20],
'score': [85, 92, 78, 90, 88],
'grade': ['A', 'A', 'B', 'A', 'B']
}
df = pd.DataFrame(data)

# Utiliser une condition booléenne pour sélectionner les lignes avec un score supérieur à 85
print("Étudiants ayant un score supérieur à 85 :")
print(df.loc[df['score'] > 85])
print()

# Condition composée : score supérieur à 85 et age inférieur à 19
print("Étudiants ayant des scores supérieurs à 85 et un âge inférieur à 19 :")
print(df.loc[(df['score'] > 85) & (df['age'] 85, ['name', 'score']])

Sortie :

分数大于 85 的学生:
      name  age  score grade
1      Bob   19     92     A
3    David   18     90     A
4      Eve   20     88     B

分数大于 85 且年龄小于 19 的学生:
      name  age  score grade
3    David   18     90     A

使用布尔数组选择的行:
      name  age  score grade
0    Alice   18     85     A
2  Charlie   17     78     B
4      Eve   20     88     B

分数大于 85 的学生的 name 和 score:
      name  score
1      Bob     92
3    David   90
4      Eve    88

Explication du code :

df.loc[df['score'] > 85]En utilisant le filtrage par condition booléenne, renvoie les lignes qui satisfont la condition.
Les conditions composées doivent être placées entre parenthèses et reliées par&(ET) et|(OU).
Vous pouvez directement passer un tableau booléen (la longueur doit être identique au nombre de lignes) pour sélectionner des lignes.
Après la condition, vous pouvez également ajouter une sélection de colonnes pour effectuer un filtrage plus précis des données.

Notes

loc[]Il utilise l'indexation par étiquettes, et le découpage est inclusif aux deux extrémités (contrairement au découpage natif de Python).
Si l'étiquette passée n'existe pas, une KeyError sera levée.
Dans les conditions booléennes, les conditions composées doivent utiliser des parenthèses, et utilisez&et|au lieu de celui de Pythonandetor。
loc[]La lecture et la modification des données sont toutes deux très pratiques, mais dans les scénarios de big data, il convient de prêter attention aux performances.

Remarques importantes :loc[]etiloc[]Ce sont deux indexeurs différents ; bien qu'ils se ressemblent, leurs principes sont complètement différents :loc[]Basé sur les étiquettes,iloc[]Basé sur les positions.

Résumé

loc[]Il s'agit d'un sélecteur de données basé sur les étiquettes dans Pandas, offrant une manière intuitive et flexible d'accéder aux données. Grâce à la combinaison des étiquettes de lignes et de colonnes, nous pouvons sélectionner avec précision toutes les données dont nous avons besoin.

Ses principaux avantages incluent : utiliser des index personnalisés pour rendre le code plus lisible, prendre en charge la syntaxe de découpage inclusive, et pouvoir combiner des conditions booléennes pour un filtrage complexe. Dans l'analyse de données réelle,loc[]c'est l'une des méthodes d'indexation les plus fréquemment utilisées au quotidien.

Pandas 常用函数 Fonctions courantes de Pandas

Autres extensions

Lecture et écriture de données

Cœur du traitement des données

Manuel de référence

Statistiques et cas

Fonction df.loc() de Pandas

Syntaxe de base et paramètres

Format de syntaxe

Description du paramètre

Description de la valeur de retour

Exemples

Exemple 1 : Utilisation de base - Utilisation de l'index par défaut

Exemple

Exemple 2 : Utilisation d'un index personnalisé

Exemple

Exemple 3 : Sélection de colonnes spécifiques

Exemple

Exemple 4 : Utilisation de la sélection par condition booléenne

Exemple

Notes

Résumé