Fonction Pandas df.query()

Pandas 常用函数 Fonctions courantes de Pandas

query()est une fonction de filtrage de données très pratique dans Pandas. Elle permet d'utiliser des expressions de chaîne de type SQL pour filtrer des données. Comparée aux méthodes d'indexation booléenne traditionnelles,query()sa syntaxe est plus concise et intuitive, particulièrement adaptée au traitement de conditions de filtrage complexes.

Dans le travail d'analyse de données, il est souvent nécessaire de filtrer les données en fonction de diverses conditions.query()La fonction écrit les conditions de filtrage sous forme de chaîne, comme l'écriture de requêtes SQL, ce qui est très convivial pour les utilisateurs familiers avec SQL. En même temps, elle prend également en charge l'utilisation de variables et de fonctions Python, ce qui rend possible le filtrage dynamique.

Syntaxe de base et paramètres

query()est une méthode de DataFrame, invoquée via l'opérateur point.Elle accepte un paramètre de chaîne contenant l'expression de filtrage.

Format de syntaxe

DataFrame.query(expr, inplace=False, **kwargs)

Description du paramètre

Paramètre	Type	Requis	Description	Valeur par défaut
expr	str	Requis	Expression de filtrage, similaire à la clause WHERE en SQL.	-
inplace	bool	Optional	S'il faut modifier directement le DataFrame d'origine.	False

Description de la valeur de retour

Type de valeur de retour: Renvoie un nouveau DataFrame contenant les lignes qui satisfont aux conditions de filtrage.
Les données d'origine ne sont pas modifiées: Par défaut, le DataFrame d'origine reste inchangé.

Exemples

À travers des exemples riches, maîtrisons pleinementquery()l'utilisation de

Exemple 1 : Utilisation de base - Filtrage sur condition unique

L'utilisation la plus simplequery()consiste à filtrer à l'aide d'une seule condition.

Exemple

import pandas as pd

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

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

# Filtrer les étudiants dont le score est supérieur à 85
print("Étudiants dont le score est supérieur à 85 :")
print(df.query('score > 85'))
print()

# Filtrer les étudiants dont l'âge est égal à 18
print("Étudiants dont l'âge est égal à 18 :")
print(df.query('age == 18'))
print()

# Filtrer les étudiants ayant la note A
print("Étudiants ayant la note A :")
print(df.query('grade == "A"'))

Résultat de l'exécution:

原始 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
5    Frank   19     95     A
6    Grace   18     82     B

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

年龄等于 18 的学生:
      name  age  score grade
0    Alice   18     85     A
3    David   18     90     A
6    Grace   18     82     B

等级为 A 的学生:
      name  age  score grade
0    Alice   18     85     A
1      Bob   19     92     A
3    David   18     90     A
5    Frank   19     95     A

Explication du code :

Les conditions de filtrage sont placées entre guillemets, en utilisant une syntaxe de type SQL.
Les comparaisons numériques utilisent>, ==, <et d'autres opérateurs.
Les comparaisons de chaînes utilisent des guillemets doubles ou des guillemets simples.

Exemple 2 : filtrage avec conditions composées

query()Prend en charge l'utilisation d'opérateurs logiques pour combiner plusieurs conditions.

Exemple

import pandas as pd

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

# Utiliser la condition AND : score supérieur à 85 et age inférieur à 19
print("Étudiants avec un score supérieur à 85 et un age inférieur à 19 :")
print(df.query('score > 85 and age 90'))
print()

# Utiliser la condition NOT : grade n'est pas A
print("Étudiants dont le grade n'est pas A :")
print(df.query('not grade == "A"'))
print()

# Condition composée complexe
print("Étudiants âgés de 18 à 20 ans avec un score différent de 88 :")
print(df.query('age >= 18 and age <= 20 and score != 88'))

Résultat de l'exécution:

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

等级为 A 或分数大于 90 的学生:
      name  age  score grade
1      Bob   19     92     A
3    David   18     90     A
5    Frank   19     95     A

等级不为 A 的学生:
      name  age  score grade
2  Charlie   17     78     B
4      Eve   20     88     B
6    Grace   18     82     B

年龄在 18 到 20 之间且分数不等于 88 的学生:
      name  age  score grade
0    Alice   18     85     A
1      Bob   19     92     A
3    David   18     90     A
5    Frank   19     95     A

Explication du code :

Utiliserandpour représenter l'opération logique ET.
Utiliserorpour représenter l'opération logique OU.
Utilisernotpour représenter l'opération logique NON.
Les conditions composées peuvent être combinées arbitrairement pour former une logique de filtrage complexe.

Exemple 3 : Utilisation de variables Python

query()Prend en charge l'utilisation de variables Python dans les expressions, ce qui est très utile dans les requêtes dynamiques.

Exemple

import pandas as pd

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

# Utiliser le symbole @ pour référencer des variables Python
min_score = 85
target_grade = 'A'

print("Filtrage avec variable - score supérieur à {} :".format(min_score))
print(df.query('score > @min_score'))
print()

print("Filtrage avec variable - la note est '{}' :".format(target_grade))
print(df.query('grade == @target_grade'))
print()

# Utiliser une liste comme variable
target_grades = ['A', 'B']
print("Étudiants ayant des notes dans {} :".format(target_grades))
print(df.query('grade in @target_grades'))
print()

# Utiliser une fonction Python
def get_average_score(df):
return df['score'].mean()

print("Étudiants ayant des scores supérieurs à la moyenne :")
print(df.query('score > @get_average_score(df)'))

Résultat de l'exécution:

使用变量筛选 - 分数大于 85:
      name  age  score grade
1      Bob   19     92     A
3    David   18     90     A
4      Eve   20     88     B
5    Frank   19     95     A

使用变量筛选 - 等级为 'A':
      name  age  score grade
0    Alice   18     85     A
1      Bob   19     92     A
3    David   18     90     A
5    Frank   19     95     A

等级在 ['A', 'B'] 中的学生:
      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
5    Frank   19     95     A
6    Grace   18     82     B

分数高于平均分的学生:
      name  age  score grade
1      Bob   19     92     A
3    David   18     90     A
5    Frank   19     95     A

Explication du code :

Utilisez la@symbole pour référencer les variables Python dans les expressions de requête.
Vous pouvez utiliser directement des listes Python pourinles vérifications avec in.
Vous pouvez appeler des fonctions Python pour calculer des seuils dynamiques.

Exemple 4 : Opérations sur les chaînes de caractères

query()Il prend également en charge certaines opérations courantes sur les chaînes.

Exemple

import pandas as pd

# Créer un DataFrame avec des colonnes de chaînes
data = {
'name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Frank', 'Grace'],
'city': ['Beijing', 'Shanghai', 'Beijing', 'Guangzhou', 'Shanghai', 'Beijing', 'Shenzhen'],
'score': [85, 92, 78, 90, 88, 95, 82]
}
df = pd.DataFrame(data)

# Filtrer les enregistrements pour une ville spécifique
print("Étudiants à Beijing :")
print(df.query('city == "Beijing"'))
print()

# Vérification de la présence d'une sous-chaîne (avec in)
print("Étudiants à Shanghai ou Beijing :")
print(df.query('city in ["Shanghai", "Beijing"]'))
print()

# Utiliser @ pour référencer une variable contenant une chaîne de caractères
target_city = 'Guangzhou'
print("Étudiants à {} :".format(target_city))
print(df.query('city == @target_city'))

Résultat de l'exécution:

在北京的学生:
      name      city  score
0    Alice   Beijing     85
2  Charlie   Beijing     78
5    Frank   Beijing     95

在上海或北京的学生:
      name      city  score
0    Alice   Beijing     85
1      Bob   Shanghai     92
2  Charlie   Beijing     78
4      Eve   Shanghai     88
5    Frank   Beijing     95

在 Guangzhou 的学生:
      name       city  score
3    David  Guangzhou     90

Explication du code :

query()Prend en charge la comparaison d'égalité des chaînes de caractères.
Vous pouvez utiliser lainmot-clé pour vérifier si un élément se trouve dans une liste.
Vous pouvez utiliser@pour référencer des variables de chaîne.

Exemple 5 : Gestion des noms de colonnes contenant des espaces ou des caractères spéciaux

Si les noms de colonnes contiennent des espaces ou des caractères spéciaux, les backticks `` ` `` peuvent être utilisés pour entourer les noms de colonnes.

Exemple

import pandas as pd

# Créer un DataFrame avec des noms de colonnes contenant des espaces
data = {
'student name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
'score': [85, 92, 78, 90, 88],
'pass status': [True, True, False, True, True]
}
df = pd.DataFrame(data)

print("DataFrame d'origine (les noms de colonnes contiennent des espaces) :")
print(df)
print()

# Utiliser des backticks pour entourer les noms de colonnes
print("Étudiants dont le score est supérieur à 85 :")
print(df.query('`score` > 85'))
print()

print("Étudiants avec pass status True :")
print(df.query('`pass status` == True'))
print()

# Cette méthode peut aussi gérer des mots réservés comme noms de colonnes
df2 = pd.DataFrame({
'class': ['A', 'B', 'A', 'B', 'A'],
'def': [1, 2, 3, 4, 5] # def est un mot réservé de Python
})
print("Utilisation d'un mot réservé comme nom de colonne :")
print(df2.query('`def` > 3'))

Résultat de l'exécution:

原始 DataFrame（列名包含空格）:
  student name  score  pass status
0       Alice     85        True
1         Bob     92        True
2    Charlie     78       False
3     David   90        True
4        Eve     88        True

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

通过状态为 True 的学生:
  student name  score  pass status
0       Alice     85        True
1         Bob     92        True
3       David     90        True
4        Eve     88        True

使用保留字作为列名:
  class  def
3     B    4
4     A    5

Explication du code :

En utilisant des accents graves, vous pouvez gérer les cas où les noms de colonnes contiennent des espaces ou entrent en conflit avec des mots réservés Python.
`score`et`pass status`Les accents graves sont utilisés pour faire référence aux noms de colonnes.
`def`Il montre comment gérer les mots réservés Python en tant que noms de colonnes.

Notes

query()Les noms de colonnes dans les expressions doivent être des identifiants Python valides, ou être entourés d'accents graves.
Les comparaisons de chaînes peuvent utiliser des guillemets simples ou des guillemets doubles.
Utilisez la@symbole pour faire référence aux variables Python.
Pour les DataFrames volumineux,query()la performance est généralement supérieure à l'indexation booléenne traditionnelle.
Si l'expression de filtrage contient des mots réservés ou des caractères spéciaux, des accents graves doivent être utilisés.

Astuce :query()Particulièrement adapté aux scénarios où les conditions de filtrage doivent être construites dynamiquement, comme le filtrage de données en fonction des entrées utilisateur ou des fichiers de configuration. Combiné aux capacités de formatage de chaînes de Python, des requêtes de données très flexibles peuvent être réalisées.

Résumé

query()est une puissante fonction de filtrage de données dans Pandas. Elle fournit une syntaxe de requête de type SQL, ce qui rend le filtrage conditionnel complexe plus concis et plus lisible.

Ses principaux avantages comprennent : une syntaxe concise et intuitive, la prise en charge d’opérations logiques composées, la prise en charge des variables et fonctions Python, et la capacité de gérer des noms de colonnes spéciaux. Dans l’analyse de données réelle, en particulier lorsque les conditions de filtrage doivent être construites dynamiquement,query()c’est un outil très pratique.

Pandas 常用函数 Fonctions courantes de Pandas

Autres extensions

Fonction Pandas df.filter()

Fonction df.iloc[] de Pandas

Lecture et écriture de données

Cœur du traitement des données

Manuel de référence

Statistiques et cas

Fonction Pandas df.query()

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 - Filtrage sur condition unique

Exemple

Exemple 2 : filtrage avec conditions composées

Exemple

Exemple 3 : Utilisation de variables Python

Exemple

Exemple 4 : Opérations sur les chaînes de caractères

Exemple

Exemple 5 : Gestion des noms de colonnes contenant des espaces ou des caractères spéciaux

Exemple

Notes

Résumé