it-swarm.com.de

Konvertieren Sie einen Pandas DataFrame in ein Wörterbuch

Ich habe einen DataFrame mit vier Spalten. Ich möchte diesen DataFrame in ein Python-Wörterbuch konvertieren. Ich möchte, dass die Elemente der ersten Spalte keys und die Elemente anderer Spalten in derselben Zeile values sind. 

Datenrahmen: 

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

Ausgabe sollte so sein:

Wörterbuch:

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

Die Methode to_dict() legt die Spaltennamen als Wörterbuchschlüssel fest, sodass Sie den DataFrame leicht umformen müssen. Das Festlegen der Spalte 'ID' als Index und anschließendes Transponieren des DataFrame ist eine Möglichkeit, dies zu erreichen.

to_dict() akzeptiert auch ein 'Orient'-Argument, das Sie zur Ausgabe eines Liste von Werten für jede Spalte benötigen. Andernfalls wird für jede Spalte ein Wörterbuch der Form {index: value} zurückgegeben.

Diese Schritte können mit der folgenden Zeile ausgeführt werden:

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

Falls ein anderes Wörterbuchformat benötigt wird, finden Sie hier Beispiele für die möglichen Orientierungsargumente. Betrachten Sie den folgenden einfachen DataFrame:

>>> 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

Dann sind die Optionen wie folgt.

dict - Standardeinstellung: Spaltennamen sind Schlüssel, Werte sind Wörterbücher von Index: Datenpaaren

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

list - Schlüssel sind Spaltennamen, Werte sind Listen von Spaltendaten

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

series - wie 'list', aber die Werte sind Serien

>>> 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 - teilt Spalten/Daten/Index als Schlüssel auf, wobei Werte Spaltennamen, Datenwerte nach Zeilen- und Indexbezeichnungen sind

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

records - jede Zeile wird zu einem Wörterbuch, in dem der Schlüssel der Spaltenname ist und der Wert die Daten in der Zelle ist

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

index - wie 'Records', aber ein Wörterbuch von Wörterbüchern mit Schlüsseln als Indexbezeichnungen (anstatt einer 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

Versuchen Sie, Zip zu verwenden

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

Ausgabe: 

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

Folge diesen Schritten:

Angenommen, Ihr Datenrahmen sieht folgendermaßen aus:

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

1. Verwenden Sie set_index, um ID-Spalten als Dataframe-Index festzulegen.

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

2. Verwenden Sie den Parameter orient=index, um den Index als Wörterbuchschlüssel festzulegen.

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

Die Ergebnisse werden wie folgt sein:

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

3. Wenn Sie jedes Beispiel als Liste benötigen, führen Sie den folgenden Code aus. Bestimmen Sie die Spaltenreihenfolge

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

Wenn Sie nichts dagegen haben, dass die Wörterbuchwerte Tupel sind, können Sie itertuples verwenden:

>>> {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

Für meine Verwendung (Knotennamen mit xy-Positionen) habe ich die Antwort von @ user4179775 auf die hilfreichsten/intuitivsten gefunden:

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),
 ... }

Nachtrag

Ich bin später auf dieses Thema für andere, aber verwandte Arbeiten zurückgekommen. Hier ist ein Ansatz, der die [ausgezeichnete] akzeptierte Antwort besser widerspiegelt.

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
...

Konvertiere Pandas Datenrahmen in eine [Liste], {Dikt}, {Dikt von {Dikt}}, ...

Per akzeptierte Antwort:

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},
 ... }

In meinem Fall wollte ich dasselbe tun, aber mit ausgewählten Spalten aus dem Pandas -Datenrahmen, also musste ich die Spalten aufteilen. Es gibt zwei Ansätze.

  1. Direkt:

(Siehe: Konvertiere pandas in ein Wörterbuch, das die Spalten definiert, die für die Schlüsselwerte verwendet werden )

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. "Indirekt:" Schneiden Sie zuerst die gewünschten Spalten/Daten aus dem Pandas-Datenrahmen (wieder zwei Ansätze).
node_df_sliced = node_df[['kegg_cid', 'name', 'wt', 'vis']]

oder

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

das kann dann verwendet werden, um ein Wörterbuch der Wörterbücher zu erstellen

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() konvertiert DataFrame in ein Wörterbuch.

Beispiel

>>> 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}}

Siehe diese Dokumentation für Details

0
Umer