एक शब्दकोश के लिए एक पांडस DataFrame कन्वर्ट

Question

मेरे पास चार कॉलम के साथ एक DataFrame है। मैं इस DataFrame को एक अजगर शब्दकोश में बदलना चाहता हूं। मैं चाहता हूं कि पहले कॉलम keysके तत्व हों और एक ही पंक्ति के दूसरे कॉलम के तत्व हों values।

डेटा ढांचा:

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

आउटपुट इस तरह होना चाहिए:

शब्दकोश:

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

Comments

Dataframe.to_dict()?

— अंजेल

Dataframe.to_dict()A,B,Cp,q,r

— प्रिंस भट्टी

@ जेज़रेल को निम्नलिखित आउटपुट कैसे प्राप्त करना है? {2: {'p': [1,3]}, 2: {'q': [4,3]}, 9: {'r': [4,0]}} समान डेटासेट के लिए?

— पांडा

उपरोक्त प्रश्न के @Jzrael कॉलम समकक्ष {'c': {'ID': 'A', 'B'}}

— पांडा

Answer 1

इस to_dict()विधि में कॉलम नाम को शब्दकोश कीज़ के रूप में सेट किया गया है ताकि आपको अपने डेटाफ़्रेम को थोड़ा फेरबदल करना पड़े। सूचकांक के रूप में 'आईडी' कॉलम सेट करना और फिर डेटाफ़्रेम को ट्रांसपोज़ करना इसे प्राप्त करने का एक तरीका है।

to_dict()प्रत्येक कॉलम के लिए मानों की सूची का उत्पादन करने के लिए आपको एक 'ओरिएंट' तर्क भी स्वीकार करना होगा । अन्यथा, {index: value}प्रत्येक कॉलम के लिए फॉर्म का एक शब्दकोश लौटा दिया जाएगा।

इन चरणों को निम्न पंक्ति के साथ किया जा सकता है:

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

---

यदि एक अलग शब्दकोश प्रारूप की आवश्यकता होती है, तो यहां संभावित उन्मुख तर्कों के उदाहरण हैं। निम्नलिखित सरल डेटाफ़्रेम पर विचार करें:

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

फिर विकल्प निम्नानुसार हैं।

तानाशाही - डिफ़ॉल्ट: स्तंभ नाम कुंजी हैं, मान सूचकांक के शब्दकोश हैं: डेटा जोड़े

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

सूची - कुंजी स्तंभ नाम हैं, मान स्तंभ डेटा की सूची हैं

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

श्रृंखला - 'सूची' की तरह, लेकिन मूल्य श्रृंखला हैं

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

विभाजन - स्तंभों / डेटा / इंडेक्स को कुंजी के रूप में विभाजित करता है जिसमें क्रमशः कॉलम के नाम, डेटा मान पंक्ति और सूचकांक लेबल के होते हैं

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

रिकॉर्ड्स - प्रत्येक पंक्ति एक शब्दकोष बन जाती है जहां कुंजी कॉलम नाम है और मान सेल में डेटा है

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

सूचकांक - 'रिकॉर्ड' की तरह, लेकिन सूचकांक लेबल के रूप में कुंजी के साथ शब्दकोशों का एक शब्दकोश (एक सूची के बजाय)

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

Comments

यह एक लाइनर होगा:df.set_index('ID').T.to_dict('list')

— Anzel

डेटा फ़्रेम में एक रिकॉर्ड के लिए। df.T.to_dict () [0]

— कामरान कौसर

Answer 2

उपयोग करने का प्रयास करें 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

आउटपुट:

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

Answer 3

इन कदमों का अनुसरण करें:

मान लीजिए कि आपका डेटाफ्रेम इस प्रकार है:

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

1. डेटाफ़्रेम इंडेक्स के रूप में कॉलम set_indexसेट करने के लिए उपयोग करें ID।

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

2. orient=indexइंडेक्स की डिक्शनरी के रूप में पैरामीटर का उपयोग करें ।

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

परिणाम निम्नानुसार होंगे:

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

3. यदि आपको सूची के रूप में प्रत्येक नमूने की आवश्यकता है तो निम्नलिखित कोड चलाएं। स्तंभ क्रम का निर्धारण करें

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]

Comments

अंतिम बिट के लिए लगता है कि आप लूप + लिस्ट कॉम्प्रिहेंशन (3 लाइन - 1) के लिए बदलने के लिए एक तानाशाह समझ का उपयोग करके सरल हो जाएंगे। किसी भी तरह से, हालांकि विकल्प होना अच्छा है, शीर्ष उत्तर बहुत छोटा है।

— 1

यह आसान है क्योंकि यह स्पष्ट रूप से बताता है कि सूचकांक के रूप में किसी विशिष्ट कॉलम या हेडर का उपयोग कैसे किया जाए।

— ट्रॉपट्रैम्बलर

Answer 4

यदि आपको शब्दकोश मानों के तुपलों से ऐतराज नहीं है, तो आप itertuples का उपयोग कर सकते हैं:

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

Answer 5

एक शब्दकोश की तरह होना चाहिए:

{'red': '0.500', 'yellow': '0.250, 'blue': '0.125'}

डेटाफ्रेम से बाहर होना आवश्यक है जैसे:

        a      b
0     red  0.500
1  yellow  0.250
2    blue  0.125

सबसे सरल तरीका होगा:

dict(df.values.tolist())

नीचे काम स्निपेट:

import pandas as pd
df = pd.DataFrame({'a': ['red', 'yellow', 'blue'], 'b': [0.5, 0.25, 0.125]})
dict(df.values.tolist())

Answer 6

मेरे उपयोग के लिए (xy पदों के साथ नोड नाम) मुझे सबसे उपयोगी / सहज ज्ञान युक्त @ user4179775 का उत्तर मिला:

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

---

परिशिष्ट

मैं बाद में अन्य, लेकिन संबंधित, काम के लिए इस मुद्दे पर लौट आया। यहाँ एक दृष्टिकोण है जो अधिक बारीकी से [उत्कृष्ट] स्वीकृत उत्तर को दर्शाता है।

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

पंडों डेटाफ्रेम को एक [सूची], {तानाशाह}, {तानाशाह की {तानाशाही}, ... में परिवर्तित करें।

प्रति स्वीकृत उत्तर:

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

मेरे मामले में, मैं यही काम करना चाहता था, लेकिन पंडों के डेटाफ्रेम से चयनित कॉलम के साथ, इसलिए मुझे कॉलम को स्लाइस करने की आवश्यकता थी। दो दृष्टिकोण हैं।

1. सीधे:

(देखें: प्रमुख मूल्यों के लिए इस्तेमाल किए गए स्तंभों को परिभाषित करने के लिए पांडा को कन्वर्ट करें )

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

2. "अप्रत्यक्ष रूप से:" सबसे पहले, पंडों डेटाफ़्रेम (फिर, दो दृष्टिकोण) से वांछित कॉलम / डेटा को स्लाइस करें,

node_df_sliced = node_df[['kegg_cid', 'name', 'wt', 'vis']]

या

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

तब शब्दकोश का एक शब्दकोश बनाने के लिए इस्तेमाल किया जा सकता है

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

Answer 7

DataFrame.to_dict() DataFrame को शब्दकोश में परिवर्तित करता है।

उदाहरण

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

विवरण के लिए यह दस्तावेज़ देखें

Comments

हां, लेकिन ओपी ने स्पष्ट किया कि वे चाहते हैं कि पंक्ति सूचकांक कुंजी हो, न कि कॉलम लेबल।

— विकी बी