Sélectionnez les lignes d'un DataFrame en fonction des valeurs d'une colonne dans pandas
Comment sélectionner les lignes d'un DataFrame sur la base des valeurs de certaines colonnes de pandas?
Dans SQL, je voudrais utiliser:
SELECT *
FROM table
WHERE colume_name = some_value
J'ai essayé de consulter la documentation de pandas mais je n'ai pas trouvé la réponse immédiatement.
Pour sélectionner des lignes dont la valeur de colonne est égale à un scalaire, some_value, utilisez ==:
df.loc[df['column_name'] == some_value]
Pour sélectionner les lignes dont la valeur de colonne se trouve dans un itérable, some_values, utilisez isin:
df.loc[df['column_name'].isin(some_values)]
Combinez plusieurs conditions avec &:
df.loc[(df['column_name'] >= A) & (df['column_name'] <= B)]
Notez les parenthèses. En raison de règles de priorité des opérateurs , & de Python se lie plus étroitement que <= et >=. Ainsi, les parenthèses dans le dernier exemple sont nécessaires. Sans les parenthèses
df['column_name'] >= A & df['column_name'] <= B
est analysé comme
df['column_name'] >= (A & df['column_name']) <= B
qui résulte en un la valeur de vérité d'une série est une erreur ambiguë .
Pour sélectionner des lignes dont la valeur de colonne n'est pas égale à some_value, utilisez !=:
df.loc[df['column_name'] != some_value]
isin renvoie une série booléenne. Pour sélectionner des lignes dont la valeur est et non dans some_values, annulez la série booléenne à l'aide de ~:
df.loc[~df['column_name'].isin(some_values)]
Par exemple,
import pandas as pd
import numpy as np
df = pd.DataFrame({'A': 'foo bar foo bar foo bar foo foo'.split(),
'B': 'one one two three two two one three'.split(),
'C': np.arange(8), 'D': np.arange(8) * 2})
print(df)
# A B C D
# 0 foo one 0 0
# 1 bar one 1 2
# 2 foo two 2 4
# 3 bar three 3 6
# 4 foo two 4 8
# 5 bar two 5 10
# 6 foo one 6 12
# 7 foo three 7 14
print(df.loc[df['A'] == 'foo'])
les rendements
A B C D
0 foo one 0 0
2 foo two 2 4
4 foo two 4 8
6 foo one 6 12
7 foo three 7 14
Si vous souhaitez inclure plusieurs valeurs, placez-les dans une liste (ou plus généralement, toutes les valeurs itérables) et utilisez isin:
print(df.loc[df['B'].isin(['one','three'])])
les rendements
A B C D
0 foo one 0 0
1 bar one 1 2
3 bar three 3 6
6 foo one 6 12
7 foo three 7 14
Notez cependant que si vous souhaitez le faire plusieurs fois, il est plus efficace de commencer par créer un index, puis d'utiliser df.loc:
df = df.set_index(['B'])
print(df.loc['one'])
les rendements
A C D
B
one foo 0 0
one bar 1 2
one foo 6 12
ou, pour inclure plusieurs valeurs de l'index, utilisez df.index.isin:
df.loc[df.index.isin(['one','two'])]
les rendements
A C D
B
one foo 0 0
one bar 1 2
two foo 2 4
two foo 4 8
two bar 5 10
one foo 6 12
tl; dr
Le pandas équivalent à
select * from table where column_name = some_value
est
table[table.column_name == some_value]
Conditions multiples:
table[(table.column_name == some_value) | (table.column_name2 == some_value2)]
ou
table.query('column_name == some_value | column_name2 == some_value2')
Exemple de code
import pandas as pd
# Create data set
d = {'foo':[100, 111, 222],
'bar':[333, 444, 555]}
df = pd.DataFrame(d)
# Full dataframe:
df
# Shows:
# bar foo
# 0 333 100
# 1 444 111
# 2 555 222
# Output only the row(s) in df where foo is 222:
df[df.foo == 222]
# Shows:
# bar foo
# 2 555 222
Dans le code ci-dessus, c'est la ligne df[df.foo == 222] qui donne les lignes en fonction de la valeur de la colonne, 222 dans ce cas.
Plusieurs conditions sont également possibles:
df[(df.foo == 222) | (df.bar == 444)]
# bar foo
# 1 444 111
# 2 555 222
Mais à ce stade, je recommanderais d'utiliser la fonction query , car elle est moins détaillée et donne le même résultat:
df.query('foo == 222 | bar == 444')
Il existe plusieurs façons de sélectionner des lignes dans un bloc de données pandas:
- Indexation booléenne (_
df[df['col'] == value_]) - Indexation positionnelle (_
df.iloc[...]_) - Indexation des libellés (
df.xs(...)) df.query(...)API
Ci-dessous, je vous montre des exemples de chacun, avec des conseils sur l'utilisation de certaines techniques. Supposons que notre critère est la colonne _'A'_ == _'foo'_
(Remarque sur les performances: pour chaque type de base, nous pouvons garder les choses simples en utilisant l'API pandas ou nous pouvons sortir de l'API, généralement dans numpy, et accélérer les choses.)
Configuration
La première chose dont nous aurons besoin est d’identifier une condition qui servira de critère de sélection des lignes. Commençons par le cas _column_name == some_value_ du PO, et incluons quelques autres cas d'utilisation courants.
Emprunt de @unutbu:
_import pandas as pd, numpy as np
df = pd.DataFrame({'A': 'foo bar foo bar foo bar foo foo'.split(),
'B': 'one one two three two two one three'.split(),
'C': np.arange(8), 'D': np.arange(8) * 2})
_1. Indexation booléenne
... L'indexation booléenne nécessite de trouver la valeur vraie de la colonne _'A'_ de chaque ligne égale à _'foo'_, puis d'utiliser ces valeurs de vérité pour identifier les lignes à conserver. Généralement, nous nommerions cette série, un tableau de valeurs de vérité, mask. Nous allons le faire ici aussi.
_mask = df['A'] == 'foo'
_Nous pouvons ensuite utiliser ce masque pour découper ou indexer le bloc de données
_df[mask]
A B C D
0 foo one 0 0
2 foo two 2 4
4 foo two 4 8
6 foo one 6 12
7 foo three 7 14
_C’est l’un des moyens les plus simples d’accomplir cette tâche. Si la performance ou l’intuitivité n’est pas un problème, vous devez choisir cette méthode. Toutefois, si les performances posent un problème, vous pouvez envisager une autre façon de créer la variable mask.
2. Indexation positionnelle
L'indexation positionnelle (_df.iloc[...]_) a ses cas d'utilisation, mais ce n'est pas l'un d'entre eux. Afin d'identifier où couper, nous devons d'abord effectuer la même analyse booléenne que nous avons faite ci-dessus. Cela nous laisse effectuer une étape supplémentaire pour accomplir la même tâche.
_mask = df['A'] == 'foo'
pos = np.flatnonzero(mask)
df.iloc[pos]
A B C D
0 foo one 0 0
2 foo two 2 4
4 foo two 4 8
6 foo one 6 12
7 foo three 7 14
_3. Indexation des étiquettes
L'indexation par étiquette peut s'avérer très pratique, mais dans ce cas, nous travaillons à nouveau sans aucun bénéfice.
_df.set_index('A', append=True, drop=False).xs('foo', level=1)
A B C D
0 foo one 0 0
2 foo two 2 4
4 foo two 4 8
6 foo one 6 12
7 foo three 7 14
_ 4. df.query() API
pd.DataFrame.query est un moyen très élégant/intuitif d’exécuter cette tâche, mais est souvent plus lent. Cependant , si vous faites attention aux timings ci-dessous, pour les grandes données, la requête est très efficace. Plus que l'approche standard et de la même ampleur que ma meilleure suggestion.
_df.query('A == "foo"')
A B C D
0 foo one 0 0
2 foo two 2 4
4 foo two 4 8
6 foo one 6 12
7 foo three 7 14
_Ma préférence est d'utiliser le Booleanmask
Des améliorations réelles peuvent être apportées en modifiant la façon dont nous créons notre Booleanmask.
mask alternative 1
Utilisez le tableau numpy sous-jacent et évitez la surcharge liée à la création d'un autre _pd.Series_ .
_mask = df['A'].values == 'foo'
_Je montrerai des tests horaires plus complets à la fin, mais jetons simplement un coup d'œil aux gains de performances obtenus grâce à l'exemple de base de données. Premièrement, nous examinons la différence entre la création de la mask
_%timeit mask = df['A'].values == 'foo'
%timeit mask = df['A'] == 'foo'
5.84 µs ± 195 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
166 µs ± 4.45 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
_L'évaluation de mask avec le tableau numpy est environ 30 fois plus rapide. Ceci est en partie dû au fait que numpy l'évaluation est souvent plus rapide. Cela est également dû en partie au manque de temps système nécessaire à la création d’un index et d’un objet _pd.Series_ correspondant.
Ensuite, nous examinerons le moment pour découper avec un mask par rapport à l’autre.
_mask = df['A'].values == 'foo'
%timeit df[mask]
mask = df['A'] == 'foo'
%timeit df[mask]
219 µs ± 12.3 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
239 µs ± 7.03 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
_Les gains de performance ne sont pas aussi prononcés. Nous verrons si cela résiste à des tests plus robustes.
mask alternative 2
Nous aurions aussi pu reconstruire la trame de données. Il y a une grande mise en garde lors de la reconstruction d'une trame de données — vous devez prendre soin de la dtypes en le faisant!
Au lieu de _df[mask]_ nous ferons ceci
_pd.DataFrame(df.values[mask], df.index[mask], df.columns).astype(df.dtypes)
_Si le cadre de données est de type mixte, comme dans notre exemple, lorsque nous aurons _df.values_, le tableau résultant sera de dtypeobject et, par conséquent, toutes les colonnes du nouveau cadre de données seront de dtypeobject. Cela nécessite donc la astype(df.dtypes) et annule les gains de performances potentiels.
_%timeit df[m]
%timeit pd.DataFrame(df.values[mask], df.index[mask], df.columns).astype(df.dtypes)
216 µs ± 10.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
1.43 ms ± 39.6 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
_Toutefois, si le bloc de données n'est pas de type mixte, il s'agit d'un moyen très utile de le faire.
Donné
_np.random.seed([3,1415])
d1 = pd.DataFrame(np.random.randint(10, size=(10, 5)), columns=list('ABCDE'))
d1
A B C D E
0 0 2 7 3 8
1 7 0 6 8 6
2 0 2 0 4 9
3 7 3 2 4 3
4 3 6 7 7 4
5 5 3 7 5 9
6 8 7 6 4 7
7 6 2 6 6 5
8 2 8 7 5 8
9 4 7 6 1 5
__%%timeit
mask = d1['A'].values == 7
d1[mask]
179 µs ± 8.73 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
_Versus
_%%timeit
mask = d1['A'].values == 7
pd.DataFrame(d1.values[mask], d1.index[mask], d1.columns)
87 µs ± 5.12 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
_Nous avons réduit le temps de moitié.
mask alternative 3
@ unutbu nous montre également comment utiliser _pd.Series.isin_ pour comptabiliser chaque élément de _df['A']_ dans un ensemble de valeurs. Cela revient à la même chose si notre ensemble de valeurs est un ensemble d'une valeur, à savoir _'foo'_. Mais il généralise également d'inclure de plus grands ensembles de valeurs si nécessaire. Il s'avère que c'est encore assez rapide même s'il s'agit d'une solution plus générale. La seule véritable perte réside dans l'intuitivité pour ceux qui ne connaissent pas le concept.
_mask = df['A'].isin(['foo'])
df[mask]
A B C D
0 foo one 0 0
2 foo two 2 4
4 foo two 4 8
6 foo one 6 12
7 foo three 7 14
_Cependant, comme auparavant, nous pouvons utiliser numpy pour améliorer les performances sans rien sacrifier. Nous allons utiliser _np.in1d_
_mask = np.in1d(df['A'].values, ['foo'])
df[mask]
A B C D
0 foo one 0 0
2 foo two 2 4
4 foo two 4 8
6 foo one 6 12
7 foo three 7 14
_ Calendrier
J'inclurai également d'autres concepts mentionnés dans d'autres messages.
Code ci-dessous
Chaque colonne de cette table représente un bloc de données de longueur différente sur lequel nous testons chaque fonction. Chaque colonne indique le temps relatif pris, la fonction la plus rapide étant donnée à un index de base de _1.0_.
_res.div(res.min())
10 30 100 300 1000 3000 10000 30000
mask_standard 2.156872 1.850663 2.034149 2.166312 2.164541 3.090372 2.981326 3.131151
mask_standard_loc 1.879035 1.782366 1.988823 2.338112 2.361391 3.036131 2.998112 2.990103
mask_with_values 1.010166 1.000000 1.005113 1.026363 1.028698 1.293741 1.007824 1.016919
mask_with_values_loc 1.196843 1.300228 1.000000 1.000000 1.038989 1.219233 1.037020 1.000000
query 4.997304 4.765554 5.934096 4.500559 2.997924 2.397013 1.680447 1.398190
xs_label 4.124597 4.272363 5.596152 4.295331 4.676591 5.710680 6.032809 8.950255
mask_with_isin 1.674055 1.679935 1.847972 1.724183 1.345111 1.405231 1.253554 1.264760
mask_with_in1d 1.000000 1.083807 1.220493 1.101929 1.000000 1.000000 1.000000 1.144175
_Vous remarquerez que les temps les plus rapides semblent être partagés entre _mask_with_values_ et _mask_with_in1d_
_res.T.plot(loglog=True)
_
Fonctions
_def mask_standard(df):
mask = df['A'] == 'foo'
return df[mask]
def mask_standard_loc(df):
mask = df['A'] == 'foo'
return df.loc[mask]
def mask_with_values(df):
mask = df['A'].values == 'foo'
return df[mask]
def mask_with_values_loc(df):
mask = df['A'].values == 'foo'
return df.loc[mask]
def query(df):
return df.query('A == "foo"')
def xs_label(df):
return df.set_index('A', append=True, drop=False).xs('foo', level=-1)
def mask_with_isin(df):
mask = df['A'].isin(['foo'])
return df[mask]
def mask_with_in1d(df):
mask = np.in1d(df['A'].values, ['foo'])
return df[mask]
_Test
_res = pd.DataFrame(
index=[
'mask_standard', 'mask_standard_loc', 'mask_with_values', 'mask_with_values_loc',
'query', 'xs_label', 'mask_with_isin', 'mask_with_in1d'
],
columns=[10, 30, 100, 300, 1000, 3000, 10000, 30000],
dtype=float
)
for j in res.columns:
d = pd.concat([df] * j, ignore_index=True)
for i in res.index:a
stmt = '{}(d)'.format(i)
setp = 'from __main__ import d, {}'.format(i)
res.at[i, j] = timeit(stmt, setp, number=50)
_ Timing spécial
En regardant le cas particulier où nous avons un seul non-objet dtype pour la trame de données entière. Code ci-dessous
_spec.div(spec.min())
10 30 100 300 1000 3000 10000 30000
mask_with_values 1.009030 1.000000 1.194276 1.000000 1.236892 1.095343 1.000000 1.000000
mask_with_in1d 1.104638 1.094524 1.156930 1.072094 1.000000 1.000000 1.040043 1.027100
reconstruct 1.000000 1.142838 1.000000 1.355440 1.650270 2.222181 2.294913 3.406735
_Il s'avère que la reconstruction ne vaut pas la peine de dépasser quelques centaines de rangs.
_spec.T.plot(loglog=True)
_
Fonctions
_np.random.seed([3,1415])
d1 = pd.DataFrame(np.random.randint(10, size=(10, 5)), columns=list('ABCDE'))
def mask_with_values(df):
mask = df['A'].values == 'foo'
return df[mask]
def mask_with_in1d(df):
mask = np.in1d(df['A'].values, ['foo'])
return df[mask]
def reconstruct(df):
v = df.values
mask = np.in1d(df['A'].values, ['foo'])
return pd.DataFrame(v[mask], df.index[mask], df.columns)
spec = pd.DataFrame(
index=['mask_with_values', 'mask_with_in1d', 'reconstruct'],
columns=[10, 30, 100, 300, 1000, 3000, 10000, 30000],
dtype=float
)
_Test
_for j in spec.columns:
d = pd.concat([df] * j, ignore_index=True)
for i in spec.index:
stmt = '{}(d)'.format(i)
setp = 'from __main__ import d, {}'.format(i)
spec.at[i, j] = timeit(stmt, setp, number=50)
_Je trouve la syntaxe des réponses précédentes redondante et difficile à retenir. Pandas a introduit la méthode query() dans v0.13 et je la préfère de beaucoup. Pour votre question, vous pourriez faire df.query('col == val')
Reproduit à partir de http://pandas.pydata.org/pandas-docs/version/0.17.0/indexing.html#indexing-query
In [167]: n = 10
In [168]: df = pd.DataFrame(np.random.Rand(n, 3), columns=list('abc'))
In [169]: df
Out[169]:
a b c
0 0.687704 0.582314 0.281645
1 0.250846 0.610021 0.420121
2 0.624328 0.401816 0.932146
3 0.011763 0.022921 0.244186
4 0.590198 0.325680 0.890392
5 0.598892 0.296424 0.007312
6 0.634625 0.803069 0.123872
7 0.924168 0.325076 0.303746
8 0.116822 0.364564 0.454607
9 0.986142 0.751953 0.561512
# pure python
In [170]: df[(df.a < df.b) & (df.b < df.c)]
Out[170]:
a b c
3 0.011763 0.022921 0.244186
8 0.116822 0.364564 0.454607
# query
In [171]: df.query('(a < b) & (b < c)')
Out[171]:
a b c
3 0.011763 0.022921 0.244186
8 0.116822 0.364564 0.454607
Vous pouvez également accéder aux variables de l'environnement en ajoutant un @ au début.
exclude = ('red', 'orange')
df.query('color not in @exclude')
Des résultats plus rapides peuvent être obtenus avec numpy.where .
Par exemple, avec configuration de unubt -
In [76]: df.iloc[np.where(df.A.values=='foo')]
Out[76]:
A B C D
0 foo one 0 0
2 foo two 2 4
4 foo two 4 8
6 foo one 6 12
7 foo three 7 14
Comparaisons de temps:
In [68]: %timeit df.iloc[np.where(df.A.values=='foo')] # fastest
1000 loops, best of 3: 380 µs per loop
In [69]: %timeit df.loc[df['A'] == 'foo']
1000 loops, best of 3: 745 µs per loop
In [71]: %timeit df.loc[df['A'].isin(['foo'])]
1000 loops, best of 3: 562 µs per loop
In [72]: %timeit df[df.A=='foo']
1000 loops, best of 3: 796 µs per loop
In [74]: %timeit df.query('(A=="foo")') # slowest
1000 loops, best of 3: 1.71 ms per loop
Voici un exemple simple
from pandas import DataFrame
# Create data set
d = {'Revenue':[100,111,222],
'Cost':[333,444,555]}
df = DataFrame(d)
# mask = Return True when the value in column "Revenue" is equal to 111
mask = df['Revenue'] == 111
print mask
# Result:
# 0 False
# 1 True
# 2 False
# Name: Revenue, dtype: bool
# Select * FROM df WHERE Revenue = 111
df[mask]
# Result:
# Cost Revenue
# 1 444 111
Pour sélectionner uniquement des colonnes spécifiques sur plusieurs colonnes pour une valeur donnée dans les pandas:
select col_name1, col_name2 from table where column_name = some_value.
Les options:
df.loc[df['column_name'] == some_value][[col_name1, col_name2]]
ou
df.query['column_name' == 'some_value'][[col_name1, col_name2]]
J'ai juste essayé d'éditer cela, mais je n'étais pas connecté, donc je ne sais pas où est passée mon édition. J'essayais d'intégrer la sélection multiple. Donc, je pense qu'une meilleure réponse est:
Pour une valeur unique, le plus simple (lisible par l'homme) est probablement:
df.loc[df['column_name'] == some_value]
Pour les listes de valeurs, vous pouvez également utiliser:
df.loc[df['column_name'].isin(some_values)]
Par exemple,
import pandas as pd
import numpy as np
df = pd.DataFrame({'A': 'foo bar foo bar foo bar foo foo'.split(),
'B': 'one one two three two two one three'.split(),
'C': np.arange(8), 'D': np.arange(8) * 2})
print(df)
# A B C D
# 0 foo one 0 0
# 1 bar one 1 2
# 2 foo two 2 4
# 3 bar three 3 6
# 4 foo two 4 8
# 5 bar two 5 10
# 6 foo one 6 12
# 7 foo three 7 14
print(df.loc[df['A'] == 'foo'])
les rendements
A B C D
0 foo one 0 0
2 foo two 2 4
4 foo two 4 8
6 foo one 6 12
7 foo three 7 14
Si vous souhaitez sélectionner plusieurs critères, vous pouvez les mettre dans une liste et utiliser 'isin':
print(df.loc[df['B'].isin(['one','three'])])
les rendements
A B C D
0 foo one 0 0
1 bar one 1 2
3 bar three 3 6
6 foo one 6 12
7 foo three 7 14
Notez, cependant, que si vous souhaitez le faire plusieurs fois, il est plus efficace de créer d'abord l'index, puis d'utiliser df.loc:
df = df.set_index(['A'])
print(df.loc['foo'])
les rendements
A B C D
foo one 0 0
foo two 2 4
foo two 4 8
foo one 6 12
foo three 7 14
Pour ajouter à cette fameuse question (bien qu'un peu trop tard): Vous pouvez également faire df.groupby('column_name').get_group('column_desired_value').reset_index() pour créer un nouveau cadre de données avec la colonne spécifiée ayant une valeur particulière. Par exemple.
import pandas as pd
df = pd.DataFrame({'A': 'foo bar foo bar foo bar foo foo'.split(),
'B': 'one one two three two two one three'.split()})
print("Original dataframe:")
print(df)
b_is_two_dataframe = pd.DataFrame(df.groupby('B').get_group('two').reset_index()).drop('index', axis = 1)
#NOTE: the final drop is to remove the extra index column returned by groupby object
print('Sub dataframe where B is two:')
print(b_is_two_dataframe)
Run this donne:
Original dataframe:
A B
0 foo one
1 bar one
2 foo two
3 bar three
4 foo two
5 bar two
6 foo one
7 foo three
Sub dataframe where B is two:
A B
0 foo two
1 foo two
2 bar two
Si vous trouvez des lignes basées sur un nombre entier dans une colonne, alors
df.loc[df['column_name'] == 2017]
Si vous trouvez une valeur basée sur une chaîne
df.loc[df['column_name'] == 'string']
Si basé sur les deux
df.loc[(df['column_name'] == 'string') & (df['column_name'] == 2017)]
df = pd.DataFrame({'A': 'foo bar foo bar foo bar foo foo'.split(),
'B': 'one one two three two two one three'.split(),
'C': np.arange(8), 'D': np.arange(8) * 2})
df[df['A']=='foo']
OUTPUT:
A B C D
0 foo one 0 0
2 foo two 2 4
4 foo two 4 8
6 foo one 6 12
7 foo three 7 14
Si vous êtes venus ici pour chercher à sélectionner des lignes dans un cadre de données en incluant celles dont la valeur de colonne N'EST PAS une liste de valeurs, voici comment inverser la réponse de unutbu pour une liste de valeurs ci-dessus:
df.loc[~df['column_name'].isin(some_values)]
(Pour ne pas inclure une seule valeur, bien sûr, il vous suffit d'utiliser l'opérateur régulier non égal, !=.)
Exemple:
import pandas as pd
df = pd.DataFrame({'A': 'foo bar foo bar foo bar foo foo'.split(),
'B': 'one one two three two two one three'.split()})
print(df)
nous donne
A B
0 foo one
1 bar one
2 foo two
3 bar three
4 foo two
5 bar two
6 foo one
7 foo three
Pour sous-définir uniquement les lignes qui NE SONT PAS one ou three dans la colonne B:
df.loc[~df['B'].isin(['one', 'three'])]
les rendements
A B
2 foo two
4 foo two
5 bar two
Plus de flexibilité avec .query avec pandas >= 0.25.0:
Réponse mise à jour en août 2019
Depuis pandas >= 0.25.0, nous pouvons utiliser la méthode query pour filtrer les images avec les méthodes pandas et même les noms de colonnes contenant des espaces. Normalement, les espaces dans les noms de colonnes génèrent une erreur, mais nous pouvons maintenant résoudre cela en utilisant un backtick (`) voir GitHub :
# Example dataframe
df = pd.DataFrame({'Sender email':['[email protected]', "[email protected]", "[email protected]"]})
Sender email
0 [email protected]
1 [email protected]
2 [email protected]
Utilisation de .query avec la méthode str.endswith:
df.query('`Sender email`.str.endswith("@shop.com")')
Sortie
Sender email
1 [email protected]
2 [email protected]
Nous pouvons également utiliser des variables locales en le préfixant avec un @ dans notre requête:
domain = 'shop.com'
df.query('`Sender email`.str.endswith(@domain)')
Sortie
Sender email
1 [email protected]
2 [email protected]
Vous pouvez également utiliser .apply:
df.apply(lambda row: row[df['B'].isin(['one','three'])])
Cela fonctionne réellement ligne par ligne (c'est-à-dire, applique la fonction à chaque ligne).
La sortie est
A B C D
0 foo one 0 0
1 bar one 1 2
3 bar three 3 6
6 foo one 6 12
7 foo three 7 14
Les résultats sont les mêmes que ceux mentionnés dans @unutbu.
df[[df['B'].isin(['one','three'])]]
df.loc[df['column_name'] == some_value]