différence pour les pandas

Un simple pandas question:

Est-il un drop_duplicates() de la fonctionnalité drop chaque ligne impliqués dans la reproduction?

Un équivalent question est la suivante: est-ce pandas ont une différence pour dataframes?

Par exemple:

In [5]: df1 = pd.DataFrame({'col1':[1,2,3], 'col2':[2,3,4]})

In [6]: df2 = pd.DataFrame({'col1':[4,2,5], 'col2':[6,3,5]})

In [7]: df1
Out[7]: 
   col1  col2
0     1     2
1     2     3
2     3     4

In [8]: df2
Out[8]: 
   col1  col2
0     4     6
1     2     3
2     5     5

alors peut-être quelque chose comme df2.set_diff(df1) produira ce:

   col1  col2
0     4     6
2     5     5

Cependant, je ne veux pas compter sur les indices car dans mon cas, je dois traiter avec dataframes qui ont des indices.

En passant, j'ai d'abord pensé à une extension de la drop_duplicates() méthode, mais maintenant je me rends compte que la seconde approche utilisant les propriétés de la théorie des ensembles serait beaucoup plus utile en général. Les deux approches pour résoudre mon problème actuel, cependant.

Merci!

  • oui, il est drop_duplicates méthode... voir la documentation pandas.pydata.org. Selon la façon dont les données sont structurées, vous devriez être en mesure de faire ensemble des opérations de trop. peut certainement remplacer des éléments dans l'image avec des éléments à partir d'une autre image. Pas sûr désinvolte si il est possible de vérifier l'unicité sur toutes les colonnes
  • Pouvez-vous montrer comment effectuer des opérations définies?
  • Pouvez-vous fournir un échantillon de données et dites-nous ce que vous essayez d'accomplir?
  • Assurez-vous. Je vais mettre à jour en quelques minutes.
  • s'il y a des doublons... qui dataframe a l'exacte ones. C'est à dire que vous voulez simplement pour trouver des pièces uniques ou avez-vous besoin de fusionner avec de la logique supplémentaire?
  • Si il n'y a pas de doublons, différence renvoie le premier dataframe (par exemple df2.set_diff(df1) renvoie df2)

InformationsquelleAutor Robert Smith | 2013-08-12
  1. 24
    from pandas import  DataFrame

df1 = DataFrame({'col1':[1,2,3], 'col2':[2,3,4]})
df2 = DataFrame({'col1':[4,2,5], 'col2':[6,3,5]})

print df2[~df2.isin(df1).all(1)]
print df2[(df2!=df1)].dropna(how='all')
print df2[~(df2==df1)].dropna(how='all')
    • Je crois que cette solution ne fonctionne que si cet index sont identiques sur les deux DataFrames. @Joop a une réponse qui fonctionne sans cette condition.
    • Je souhaite que cette réponse a été expliqué un peu plus pour ceux d'entre nous qui essayons de suivre. Je pense que tous les trois réponses sont les mêmes, mais ils donnent différents types de données dans les résultats. Je pense que le ~ nie l'opération, mais quel est le but de .tous les(1)?
    • axe : {0, 1}. 0 de ligne, sage, 1 pour les colonnes.Afin de vérifier si toutes les colonnes (axis=1) sont nuls.. .tous les(1) est utilisé. résultat de la vérification sans .tous(1)
    InformationsquelleAutor aerokite
  2. 38

    Peu compliqué, mais si vous voulez ignorer totalement les données d'index. Convertir le contenu de la dataframes à des ensembles de tuples contenant les colonnes:

    ds1 = set([tuple(line) for line in df1.values])
ds2 = set([tuple(line) for line in df2.values])

    Cette étape permettra de se débarrasser de tous les doublons dans la dataframes ainsi (indice ignoré)

    set([(1, 2), (3, 4), (2, 3)])   # ds1

    pouvez alors utiliser des méthodes établies pour trouver quoi que ce soit. Par exemple, pour trouver les différences:

    ds1.difference(ds2)

    donne:
    ensemble([(1, 2), (3, 4)])

    peut prendre ce retour à dataframe si nécessaire. Note transformer ensemble de la liste des 1er jeu ne peut pas être utilisé pour construire dataframe:

    pd.DataFrame(list(ds1.difference(ds2)))
    • Fantastique. Cela a fonctionné parfaitement. Évidemment, il réorganise les lignes, mais ce n'est pas un problème. Peut-être le seul problème avec ceci est que df1 doit être converti en un ensemble d'abord, donc, qui permettra de supprimer les doublons dans df1 qui pourrait ne pas être désirée. Merci beaucoup!
    • oui par définition crée un non triées de la structure de données. Vous ne savez pas si il est un pur pandas alternative, mais voyant que les données de l'indice n'est pas important pour vous, il est logique d'utiliser les méthodes intégrées. Assurez-vous de vérifier @Jeff solution. Il est un véritable pandas expert et pourrait être plus rapide que mon code. Séjournez dans les pandas structure de données permettra de préserver les données de l'indice, qui pourrait encore être utiliser pour vous.
    • Malheureusement, j'ai trouvé un petit bug. Si vous faites affaire avec des chiffres qui nécessitent une précision raisonnable, ce sera la cause de certains problèmes, car il est arrondi à la décimale près. Dans mon cas, c'est le 7ème décimal qui obtient arrondis.
    • Qu'est-ce que la complexité de calcul de cette? Cela semble exagérément lent, non?
    InformationsquelleAutor Joop
  3. 19

    Voici une autre réponse qui maintient l'index et ne nécessite pas des indices identiques dans les deux trames de données.

    pd.concat([df2, df1, df1]).drop_duplicates(keep=False)

    Il est rapide et le résultat est

       col1  col2
0     4     6
2     5     5
    • C'est intelligent. Bien sûr, il n'a pas la souplesse d'un ensemble de théorie de la fonction.
    • Pour info le lien est cassé
    InformationsquelleAutor radream
  4. 4

    Appliquer par les colonnes de l'objet que vous souhaitez mapper (df2); rechercher les lignes qui ne sont pas dans le jeu (isin est comme un opérateur)

    In [32]: df2.apply(lambda x: df2.loc[~x.isin(df1[x.name]),x.name])
Out[32]: 
   col1  col2
0     4     6
2     5     5

    Même chose, mais toutes les valeurs en df1, mais encore par colonne dans df2

    In [33]: df2.apply(lambda x: df2.loc[~x.isin(df1.values.ravel()),x.name])
Out[33]: 
   col1  col2
0   NaN     6
2     5     5

    2ème exemple

    In [34]: g = pd.DataFrame({'x': [1.2,1.5,1.3], 'y': [4,4,4]})

In [35]: g.columns=df1.columns

In [36]: g
Out[36]: 
   col1  col2
0   1.2     4
1   1.5     4
2   1.3     4

In [32]: g.apply(lambda x: g.loc[~x.isin(df1[x.name]),x.name])
Out[32]: 
   col1  col2
0   1.2   NaN
1   1.5   NaN
2   1.3   NaN

    Remarque, dans 0.13, il y aura une isin opérateur sur le niveau des cadres, donc quelque chose comme: df2.isin(df1) devrait être possible

    • Intéressant. Pour certaines raisons, je ne pouvais pas le faire fonctionner. Il a renvoyé beaucoup de NaN, je l'ai donc besoin de voir ce qui n'allait pas.
    • Je pense qu'il y a un problème. Si vous avez quelque chose comme ceci: g = pd.DataFrame({'x': [1.2,1.5,1.3], 'y': [4,4,4]}) et que vous souhaitez supprimer g.ix[[0,2]], alors ce ne sera pas sélectionner les lignes correctes car il vérifie si chaque élément de g dans g.ix[[0,2]]. La deuxième ligne comprend un certain nombre (4) qui est égal à un.g.ix[[0,2]] (en fait, deux d'entre eux sont égaux).
    • Je ne suis pas clair sur votre commentaire, que feriez-vous attendu suite à g.set_diff(df1) (ou l'inverse)
    • g.set_diff(df1) doit retourner les lignes de g qui ne sont pas inclus dans df1.
    InformationsquelleAutor Jeff
  5. 3

    Obtenir les indices de l'intersection avec la fusion, puis déposez-les:

    >>> df_all = pd.DataFrame(np.arange(8).reshape((4,2)), columns=['A','B']); df_all
   A  B
0  0  1
1  2  3
2  4  5
3  6  7
>>> df_completed = df_all.iloc[::2]; df_completed
   A  B
0  0  1
2  4  5
>>> merged = pd.merge(df_all.reset_index(), df_completed); merged
   index  A  B
0      0  0  1
1      2  4  5
>>> df_pending = df_all.drop(merged['index']); df_pending
   A  B
1  2  3
3  6  7
    InformationsquelleAutor ignacio
  6. 3

    Il y a 3 méthodes de travail, mais deux d'entre eux ont des défauts.

    Méthode 1 (méthode de Hachage):

    Il a travaillé pour tous les cas que j'ai testé.

    df1.loc[:, "hash"] = df1.apply(lambda x: hash(tuple(x)), axis = 1)
df2.loc[:, "hash"] = df2.apply(lambda x: hash(tuple(x)), axis = 1)
df1 = df1.loc[~df1["hash"].isin(df2["hash"]), :]

    Méthode 2 (Dict méthode):

    Il échoue si DataFrames contiennent des colonnes datetime.

    df1 = df1.loc[~df1.isin(df2.to_dict(orient="list")).all(axis=1), :]

    La méthode 3 (MultiIndex méthode):

    J'ai rencontré des cas où il a échoué sur des colonnes avec Aucun ou NaN du.

    df1 = df1.loc[~df1.set_index(list(df1.columns)).index.isin(df2.set_index(list(df2.columns)).index)
    InformationsquelleAutor Piotr Zioło
  7. 2

    Hypothèse:

    1. df1 et df2 ont les mêmes colonnes
    2. c'est une opération de l'ensemble ainsi les doublons sont ignorés
    3. les jeux ne sont pas très grandes, vous ne vous inquiétez pas à propos de la mémoire
    union = pd.concat([df1,df2])
sym_diff = union[~union.duplicated(keep=False)]
union_of_df1_and_sym_diff = pd.concat([df1, sym_diff])
diff = union_of_df1_and_sym_diff[union_of_df1_and_sym_diff.duplicated()]
    InformationsquelleAutor Jacek Pliszka
  8. 1

    Je ne suis pas sûr de savoir comment pd.concat() implicitement rejoint le chevauchement des colonnes, mais j'ai dû faire un peu de tweak sur @radream de réponse.

    Sur le plan conceptuel, un ensemble de différence (symétrique) sur plusieurs colonnes est un ensemble de l'union (outer join) moins un ensemble d'intersection (ou jointure interne (inner join):

    df1 = pd.DataFrame({'col1':[1,2,3], 'col2':[2,3,4]})
df2 = pd.DataFrame({'col1':[4,2,5], 'col2':[6,3,5]})
o = pd.merge(df1, df2, how='outer')
i = pd.merge(df1, df2)
set_diff = pd.concat([o, i]).drop_duplicates(keep=False)

    Cela donne:

       col1  col2
0     1     2
2     3     4
3     4     6
4     5     5
    InformationsquelleAutor Alex Petralia
  9. 1

    Pandas MultiIndex objets ont rapidement mis les opérations mises en œuvre que les méthodes, de sorte que vous pouvez convertir le DataFrames à MultiIndexes, utilisez le difference() méthode, puis convertir le résultat en arrière à un DataFrame. Cette solution devrait être beaucoup plus rapide (par ~100 fois ou plus à partir de mon test) que les solutions données ici jusqu'à présent, et il ne dépendra pas de la ligne d'indexation des images d'origine. Comme Piotr mentionné pour sa réponse, ceci ne fonctionnera pas avec les valeurs null, depuis np.nan != np.nan. Toute ligne de df2 avec une valeur null apparaissent toujours dans la différence. Aussi, les colonnes doivent être dans le même ordre pour les deux DataFrames.

    df1mi = pd.MultiIndex.from_arrays(df1.values.transpose(), names=df1.columns)
df2mi = pd.MultiIndex.from_arrays(df2.values.transpose(), names=df2.columns)
dfdiff = df2mi.difference(df1mi).to_frame().reset_index(drop=True)
    InformationsquelleAutor Ian Kent
  10. 0

    cela devrait fonctionner même si vous avez plusieurs colonnes dans les deux dataframes. Mais assurez-vous que les noms de colonne à la fois de la dataframes sont exactement les mêmes.

    set_difference = pd.concat([df2, df1, df1]).drop_duplicates(keep=False)

    Avec plusieurs colonnes, vous pouvez également utiliser:

    col_names=['col_1','col_2']
set_difference = pd.concat([df2[col_names], df1[col_names], 
df1[col_names]]).drop_duplicates(keep=False)
    InformationsquelleAutor SummmerFort