les pandas - filtre dataframe par un autre dataframe par les éléments de ligne

J'ai un dataframe df1 qui ressemble à:

et un autre appelé df2 comme:

   c  l
0  A  b
1  C  a

Je voudrais filtre df1 en ne conservant que les valeurs qui ne SONT PAS dans df2. Les valeurs de filtre devrait être le (A,b) et (C,a) des n-uplets. Jusqu'à présent, j'ai essayé d'appliquer la isin méthode:

d = df[~(df['l'].isin(dfc['l']) & df['c'].isin(dfc['c']))]

À part cela me semble trop compliqué, il retourne:

   c  k  l
2  B  2  a
4  C  2  d

mais j'en attends:

   c  k  l
0  A  1  a
2  B  2  a
4  C  2  d

Comment à propos de la concaténation des valeurs des deux colonnes c et l et à l'aide de cette clé?

InformationsquelleAutor Fabio Lamanna | 2015-10-22

pandas python

31

Vous pouvez faire cela de manière efficace en utilisant isin sur un multiindex construit à partir de colonnes désirées:
```
df1 = pd.DataFrame({'c': ['A', 'A', 'B', 'C', 'C'],
                    'k': [1, 2, 2, 2, 2],
                    'l': ['a', 'b', 'a', 'a', 'd']})
df2 = pd.DataFrame({'c': ['A', 'C'],
                    'l': ['b', 'a']})
keys = list(df2.columns.values)
i1 = df1.set_index(keys).index
i2 = df2.set_index(keys).index
df1[~i1.isin(i2)]
```
Je pense que cela améliore sur @IanS la solution semblable, car il ne veut pas assumer tout type de colonne (c'est à dire qu'il va travailler avec des nombres ainsi que des chaînes de caractères).

(Réponse ci-dessus est un montage. La suite a été ma première réponse)

Intéressant! C'est quelque chose que je n'ai pas rencontré avant... je serais probablement le résoudre par la fusion des deux tableaux, puis la suppression de lignes où df2 est défini. Voici un exemple, ce qui rend l'utilisation d'un tableau temporaire:
```
df1 = pd.DataFrame({'c': ['A', 'A', 'B', 'C', 'C'],
                    'k': [1, 2, 2, 2, 2],
                    'l': ['a', 'b', 'a', 'a', 'd']})
df2 = pd.DataFrame({'c': ['A', 'C'],
                    'l': ['b', 'a']})

# create a column marking df2 values
df2['marker'] = 1

# join the two, keeping all of df1's indices
joined = pd.merge(df1, df2, on=['c', 'l'], how='left')
joined
```
```
# extract desired columns where marker is NaN
joined[pd.isnull(joined['marker'])][df1.columns]
```
Il y a peut être moyen de le faire sans l'aide du tableau temporaire, mais je ne peux pas penser à un. Aussi longtemps que vos données n'est pas énorme la méthode ci-dessus doit être rapide et de réponse suffisante.
- Merci pour la mention de la source 🙂 je pense que vous devriez faire de votre éditer une nouvelle réponse, espérons-le, a accepté un. Je n'hésiterais pas à voter pour elle!
- J'ai changé le modifier à la réponse primaire. Merci!
- Nice méthode! J'ai pensé qu'il était plus facile de le faire, merci à tous pour votre aide!
- Merci, je l'ai essayé et il fonctionne très bien pour ce cas. J'ai un peu plus compliqué schenario où df2 = pd.DataFrame({'c': ['A', *], 'l': [*, 'a']}), par * je veux dire un générique, de sorte que la valeur peut être n'importe quoi. La sortie de df1[~i1.isin(i2)] devrait être: pd.DataFrame({'c': ['C'], 'k': [2], 'l': ['d']}). Est-ce possible d'atteindre par modifiying ci-dessus?
- Votre première réponse crée un marqueur de colonne, mais en mp.merge() contient maintenant un paramètre qui est 'indicateur'. Si vous choisissez indicateur=Vrai, alors une colonne supplémentaire est ajouté (appelé "_merge') qui est un marqueur par lui-même sur le nouvellement créé fusionné df. Vous pouvez ensuite filtrer rejoint['_merge']=='left_only'.
InformationsquelleAutor jakevdp
11

C'est assez succincte et qui fonctionne bien:
```
df1 = df1[~df1.index.isin(df2.index)]
```
- Alors que ce code peut répondre à la question, en fournissant plus de contexte sur comment et/ou pourquoi il résout le problème serait d'améliorer la réponse à long terme de valeur. Veuillez lire ce comment répondre pour offrir une qualité de réponse.
InformationsquelleAutor Haroon Hassan
1

Comment sur:
```
df1['key'] = df1['c'] + df1['l']
d = df1[~df1['key'].isin(df2['c'] + df2['l'])].drop(['key'], axis=1)
```
- Je pense que votre réponse serait plus fort avec plus d'information. Pourriez-vous modifier cette réponse d'inclure certaines informations au sujet de pourquoi quelqu'un devrait utiliser cette approche, ou au moins ce que ce code accomplit? Si vous ne pouvez pas venir avec quelque chose à développer, envisager un scénario: Si je fais un copier-coller votre code à l'aveuglette dans mon application, il n'existe aucun cas je devrais m'inquiéter? Quand devrais-je éviter l'utilisation de cette approche?
InformationsquelleAutor IanS

Je pense que c'est une approche simple lorsque vous souhaitez filtrer un dataframe basé sur plusieurs colonnes à partir d'un autre dataframe ou même fondée sur une liste personnalisée.

df1 = pd.DataFrame({'c': ['A', 'A', 'B', 'C', 'C'],
                    'k': [1, 2, 2, 2, 2],
                    'l': ['a', 'b', 'a', 'a', 'd']})
df2 = pd.DataFrame({'c': ['A', 'C'],
                    'l': ['b', 'a']})

#values of df2 columns 'c' and 'l' that will be used to filter df1
idxs = list(zip(df2.c.values, df2.l.values)) #[('A', 'b'), ('C', 'a')]

#so df1 is filtered based on the values present in columns c and l of df2 
df1 = df1[pd.Series(list(zip(df1.c, df1.l)), index=df1.index).isin(idxs)]

InformationsquelleAutor dasilvadaniel

0

Une autre option qui évite de créer une colonne supplémentaire ou de faire une fusion serait de faire un groupby sur df2 pour obtenir l'distinctes (c, l) paires et ensuite il suffit de filtre df1 en les utilisant.
```
gb = df2.groupby(("c", "l")).groups
df1[[p not in gb for p in zip(df1['c'], df1['l'])]]]
```
Pour ce petit exemple, il semble en fait de courir un peu plus vite que les pandas approche fondée sur les 666 µs vs 1.76 ms sur ma machine), mais je soupçonne qu'il pourrait être plus lent sur de plus grands exemples puisque c'est de les faire tomber dans la pure Python.

InformationsquelleAutor Randy

Vous devez vous connecter pour publier un commentaire.