web-dev-qa-db-fra.com

Convertir un DataFrame Pandas en dictionnaire

J'ai un DataFrame avec quatre colonnes. Je veux convertir ce DataFrame à un dictionnaire python. Je veux que les éléments de la première colonne soient keys et les éléments des autres colonnes de la même ligne soient values. 

Trame de données: 

    ID   A   B   C
0   p    1   3   2
1   q    4   3   2
2   r    4   0   9

La sortie devrait être comme ceci:

Dictionnaire:

{'p': [1,3,2], 'q': [4,3,2], 'r': [4,0,9]}
pythonpandasdictionarydataframe
88
COSTA

La méthode to_dict() définit les noms de colonne sous forme de clés de dictionnaire. Vous devrez donc légèrement remodeler votre DataFrame. Définir la colonne 'ID' comme index, puis transposer le DataFrame est un moyen d'y parvenir.

to_dict() accepte également un argument 'orient' dont vous aurez besoin pour générer un liste de valeurs pour chaque colonne. Sinon, un dictionnaire de la forme {index: value} sera renvoyé pour chaque colonne.

Ces étapes peuvent être effectuées avec la ligne suivante:

>>> df.set_index('ID').T.to_dict('list')
{'p': [1, 3, 2], 'q': [4, 3, 2], 'r': [4, 0, 9]}

Dans le cas où un dictionnaire différent est nécessaire, voici des exemples des arguments possibles orient. Considérez le simple DataFrame suivant:

>>> df = pd.DataFrame({'a': ['red', 'yellow', 'blue'], 'b': [0.5, 0.25, 0.125]})
>>> df
        a      b
0     red  0.500
1  yellow  0.250
2    blue  0.125

Ensuite, les options sont les suivantes.

dict - la valeur par défaut: les noms de colonne sont des clés, les valeurs sont des dictionnaires d'index: paires de données

>>> df.to_dict('dict')
{'a': {0: 'red', 1: 'yellow', 2: 'blue'}, 
 'b': {0: 0.5, 1: 0.25, 2: 0.125}}

list - les clés sont des noms de colonnes, les valeurs sont des listes de données de colonnes

>>> df.to_dict('list')
{'a': ['red', 'yellow', 'blue'], 
 'b': [0.5, 0.25, 0.125]}

series - comme 'liste', mais les valeurs sont Series

>>> df.to_dict('series')
{'a': 0       red
      1    yellow
      2      blue
      Name: a, dtype: object, 

 'b': 0    0.500
      1    0.250
      2    0.125
      Name: b, dtype: float64}

split - divise les colonnes/données/index en clés avec les valeurs correspondant aux noms de colonnes, aux valeurs de données par étiquettes de ligne et d'index

>>> df.to_dict('split')
{'columns': ['a', 'b'],
 'data': [['red', 0.5], ['yellow', 0.25], ['blue', 0.125]],
 'index': [0, 1, 2]}

records - chaque ligne devient un dictionnaire où clé correspond au nom de la colonne et valeur aux données de la cellule.

>>> df.to_dict('records')
[{'a': 'red', 'b': 0.5}, 
 {'a': 'yellow', 'b': 0.25}, 
 {'a': 'blue', 'b': 0.125}]

index - comme 'records', mais un dictionnaire de dictionnaires avec des clés comme étiquettes d'index (plutôt qu'une liste)

>>> df.to_dict('index')
{0: {'a': 'red', 'b': 0.5},
 1: {'a': 'yellow', 'b': 0.25},
 2: {'a': 'blue', 'b': 0.125}}
180
Alex Riley

Essayez d'utiliser Zip

df = pd.read_csv("file")
d= dict([(i,[a,b,c ]) for i, a,b,c in Zip(df.ID, df.A,df.B,df.C)])
print d

Sortie: 

{'p': [1, 3, 2], 'q': [4, 3, 2], 'r': [4, 0, 9]}
14
user4179775

Suivez ces étapes:

Supposons que votre dataframe soit comme suit:

>>> df
   A  B  C ID
0  1  3  2  p
1  4  3  2  q
2  4  0  9  r

1. Utilisez set_index pour définir les colonnes ID comme index de structure de données.

    df.set_index("ID", drop=True, inplace=True)

2. Utilisez le paramètre orient=index pour que l'index soit utilisé comme clé du dictionnaire.

    dictionary = df.to_dict(orient="index")

Les résultats seront les suivants:

    >>> dictionary
    {'q': {'A': 4, 'B': 3, 'D': 2}, 'p': {'A': 1, 'B': 3, 'D': 2}, 'r': {'A': 4, 'B': 0, 'D': 9}}

3. Si vous avez besoin que chaque échantillon soit une liste, exécutez le code suivant. Déterminer l'ordre des colonnes

column_order= ["A", "B", "C"] #  Determine your preferred order of columns
d = {} #  Initialize the new dictionary as an empty dictionary
for k in dictionary:
    d[k] = [dictionary[k][column_name] for column_name in column_order]
9
Farhad Maleki

Si les valeurs de dictionnaire étant des tuples, vous pouvez utiliser itertuples:

>>> {x[0]: x[1:] for x in df.itertuples(index=False)}
{'p': (1, 3, 2), 'q': (4, 3, 2), 'r': (4, 0, 9)}
8
ksindi

Pour mon usage (noms de nœuds avec positions xy), j'ai trouvé la réponse de @ user4179775 au plus utile/intuitif:

import pandas as pd

df = pd.read_csv('glycolysis_nodes_xy.tsv', sep='\t')

df.head()
    nodes    x    y
0  c00033  146  958
1  c00031  601  195
...

xy_dict_list=dict([(i,[a,b]) for i, a,b in Zip(df.nodes, df.x,df.y)])

xy_dict_list
{'c00022': [483, 868],
 'c00024': [146, 868],
 ... }

xy_dict_tuples=dict([(i,(a,b)) for i, a,b in Zip(df.nodes, df.x,df.y)])

xy_dict_tuples
{'c00022': (483, 868),
 'c00024': (146, 868),
 ... }

Addendum

Je suis revenu plus tard à cette question, pour un travail différent, mais lié. Voici une approche qui reflète de plus près l'excellente réponse acceptée.

node_df = pd.read_csv('node_prop-glycolysis_tca-from_pg.tsv', sep='\t')

node_df.head()
   node  kegg_id kegg_cid            name  wt  vis
0  22    22       c00022   pyruvate        1   1
1  24    24       c00024   acetyl-CoA      1   1
...

Convertissez Pandas dataframe en une [liste], {dict}, {dict of {dict}}, ...

Par réponse acceptée:

node_df.set_index('kegg_cid').T.to_dict('list')

{'c00022': [22, 22, 'pyruvate', 1, 1],
 'c00024': [24, 24, 'acetyl-CoA', 1, 1],
 ... }

node_df.set_index('kegg_cid').T.to_dict('dict')

{'c00022': {'kegg_id': 22, 'name': 'pyruvate', 'node': 22, 'vis': 1, 'wt': 1},
 'c00024': {'kegg_id': 24, 'name': 'acetyl-CoA', 'node': 24, 'vis': 1, 'wt': 1},
 ... }

Dans mon cas, je voulais faire la même chose, mais avec les colonnes sélectionnées du cadre de données Pandas. Je devais donc couper les colonnes en tranches. Il y a deux approches.

  1. Directement:

(voir: Convertit pandas en dictionnaire définissant les colonnes utilisées pour les valeurs de clé) )

node_df.set_index('kegg_cid')[['name', 'wt', 'vis']].T.to_dict('dict')

{'c00022': {'name': 'pyruvate', 'vis': 1, 'wt': 1},
 'c00024': {'name': 'acetyl-CoA', 'vis': 1, 'wt': 1},
 ... }
  1. "Indirectement:" tout d’abord, découpez les colonnes/données souhaitées du Pandas dataframe (encore une fois, deux approches),
node_df_sliced = node_df[['kegg_cid', 'name', 'wt', 'vis']]

ou

node_df_sliced2 = node_df.loc[:, ['kegg_cid', 'name', 'wt', 'vis']]

qui peut ensuite être utilisé pour créer un dictionnaire de dictionnaires

node_df_sliced.set_index('kegg_cid').T.to_dict('dict')

{'c00022': {'name': 'pyruvate', 'vis': 1, 'wt': 1},
 'c00024': {'name': 'acetyl-CoA', 'vis': 1, 'wt': 1},
 ... }
0
Victoria Stuart

DataFrame.to_dict() convertit DataFrame en dictionnaire.

Exemple

>>> df = pd.DataFrame(
    {'col1': [1, 2], 'col2': [0.5, 0.75]}, index=['a', 'b'])
>>> df
   col1  col2
a     1   0.1
b     2   0.2
>>> df.to_dict()
{'col1': {'a': 1, 'b': 2}, 'col2': {'a': 0.5, 'b': 0.75}}

Voir cette Documentation pour plus de détails

0
Umer