问题描述：

我有一个包含四列的 DataFrame。我想将此 DataFrame 转换为 Python 字典。我希望第一列的元素为 ，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]}

解决方案 1：

该to_dict()方法将列名设置为字典键，因此您需要稍微重塑 DataFrame。将“ID”列设置为索引，然后转置 DataFrame 是实现此目的的一种方法。

to_dict()还接受“orient”参数，您需要该参数来输出每列的值列表。{index: value}否则，将为每列返回以下形式的字典。

可以使用以下行完成这些步骤：

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

如果需要不同的字典格式，以下是可能的 orient 参数的示例。考虑以下简单的 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

那么选项如下。

dict - 默认值：列名是键，值是索引：数据对的字典

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

split - 将列/数据/索引拆分为键，其值分别为列名、行数据值和索引标签

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

解决方案 2：

应该有像这样的字典：

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

以下是工作片段：

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

解决方案 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]

解决方案 4：

尝试使用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]}

解决方案 5：

如果您不介意字典值是元组，那么可以使用 itertuples：

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

解决方案 6：

对于我的使用（具有 xy 位置的节点名称），我发现@user4179775 的回答最有帮助/直观：

import pandas as pd

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

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='    ')

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

将 Pandas 数据框转换为 [list]、{dict}、{dict of {dict}}、...

根据接受的答案：

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

就我而言，我想做同样的事情，但要使用 Pandas 数据框中的选定列，因此我需要对列进行切片。有两种方法。

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

1. “间接”：首先，从 Pandas 数据框中切出所需的列/数据（同样，两种方法），

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

解决方案 7：

大多数答案都没有处理 ID 在数据框中可以多次出现的情况。如果ID可以在数据框中重复，df则需要使用列表来存储值（也称为列表列表），并按以下方式分组ID：

{k: [g['A'].tolist(), g['B'].tolist(), g['C'].tolist()] for k,g in df.groupby('ID')}

解决方案 8：

也可以使用字典理解和 iterrows() 方法来获取所需的输出。

result = {row.ID: [row.A, row.B, row.C] for (index, row) in df.iterrows()}

解决方案 9：

如果 ID 是唯一的

set_index().T.to_dict()是一个非常简单的语法，但转置数据帧确实很慢。dict(zip(...))语法大约快 70 倍。例如，对于具有 1mil 行的帧，dict(zip(...))需要不到 0.5 秒，而set_index.T.to_dict需要超过 30 秒。

mydict = dict(zip(df['ID'], df.set_index('ID').values.tolist()))

另外，使用 的字典理解itertuples确实很快（由Kamil Sindi建议），但比 慢 3 倍左右dict(zip(...))。

mydict = {x[0]: list(x[1:]) for x in df.itertuples(index=False)}

如果身份证重复

itertuples`itertuples如果 ID 列具有重复值，则尤其有用。通过循环遍历数据框并使用 构建字典dict.setdefault比（由Ka Wa Yipgroupby建议）或快得多。例如，对于具有 100k 行和 60k 个唯一 ID 的数据框，比 快 250倍。1iterrowsitertuplesgroupby`

mydict = {}
for row in df.itertuples(index=False):
    mydict.setdefault(row[0], []).append(list(row[1:]))

性能基准：

正如运行时图所示，无论帧有多大，dict(zip(...))和itertuples都比dict.setdefault它们的“熊猫”同行快得多。

绘制上述图表所用的代码：

import numpy as np
from perfplot import plot

plot(
    setup=lambda n: pd.DataFrame({'ID': np.arange(n)}).join(pd.DataFrame(np.random.default_rng().choice(10, size=(n, 3)), columns=[*'ABC'])),
    kernels=[lambda df: dict(zip(df['ID'], df.set_index('ID').values.tolist())), 
             lambda df: df.set_index('ID').T.to_dict('list'), 
             lambda df: {x[0]: list(x[1:]) for x in df.itertuples(index=False)}],
    labels= ["dict(zip(df['ID'], df.set_index('ID').values.tolist()))", 
             "df.set_index('ID').T.to_dict('list')", 
             "{x[0]: list(x[1:]) for x in df.itertuples(index=False)}"],
    n_range=[2**k for k in range(18)],
    xlabel='Number of rows',
    title='Unique IDs',
    equality_check=lambda x,y: x==y);


def itertuples_(df):
    mydict = {}
    for row in df.itertuples(index=False):
        mydict.setdefault(row[0], []).append(list(row[1:]))
    return mydict
        
def groupby_(df):
    return {k: g[['A', 'B', 'C']].values.tolist() for k, g in df.groupby('ID')}

plot(
    setup=lambda n: pd.DataFrame(np.random.default_rng().choice(n, size=(n, 4)), columns=['ID','A','B','C']),
    kernels=[itertuples_, groupby_],
    labels= ["itertuples", "groupby"],
    n_range=[2**k for k in range(17)],
    xlabel="Number of rows",
    title="Duplicated IDs",
    equality_check=lambda x,y: x==y);

解决方案 10：

df = pd.DataFrame([['p',1,3,2], ['q',4,3,2], ['r',4,0,9]], columns=['ID','A','B','C'])
my_dict = {k:list(v) for k,v in zip(df['ID'], df.drop(columns='ID').values)}
print(my_dict)

带输出

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

解决方案 11：

使用此方法，数据框的列将成为键，数据框的系列将成为值。`

data_dict = dict()
for col in dataframe.columns:
    data_dict[col] = dataframe[col].values.tolist()

解决方案 12：

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

有关详细信息，请参阅此文档