我有下面的字典列表与datetime键和int值:

list = [{datetime.date(2022, 2, 10): 7}, {datetime.date(2022, 2, 11): 1}, {datetime.date(2022, 2, 11): 1}]

我有一个问题，将其转换为Dataframe与上面的方法，因为它创建了Dataframe与列的日期…

我的解决方案:

df = pd.DataFrame()
for i in list:
    temp_df = pd.DataFrame.from_dict(i, orient='index')
    df = df.append(temp_df)

如果ds是dicts的列表:

df = pd.DataFrame(ds)

注意:这对嵌套数据不起作用。

在pandas 16.2中，我必须执行pd. datafframe .from_records(d)才能使其工作。

你也可以使用pd.DataFrame.from_dict(d) as:

In [8]: d = [{'points': 50, 'time': '5:00', 'year': 2010}, 
   ...: {'points': 25, 'time': '6:00', 'month': "february"}, 
   ...: {'points':90, 'time': '9:00', 'month': 'january'}, 
   ...: {'points_h1':20, 'month': 'june'}]

In [12]: pd.DataFrame.from_dict(d)
Out[12]: 
      month  points  points_h1  time    year
0       NaN    50.0        NaN  5:00  2010.0
1  february    25.0        NaN  6:00     NaN
2   january    90.0        NaN  9:00     NaN
3      june     NaN       20.0   NaN     NaN

如何将字典列表转换为熊猫数据框架?

其他的答案都是正确的，但是对于这些方法的优点和局限性并没有太多的解释。这篇文章的目的是展示这些方法在不同情况下的例子，讨论什么时候使用(什么时候不使用)，并提出替代方案。

---

DataFrame()， DataFrame.from_records()和.from_dict()

根据数据的结构和格式，在某些情况下，三种方法都可以工作，或者有些方法比其他方法更好，或者有些方法根本不起作用。

考虑一个非常人为的例子。

np.random.seed(0)
data = pd.DataFrame(
    np.random.choice(10, (3, 4)), columns=list('ABCD')).to_dict('r')

print(data)
[{'A': 5, 'B': 0, 'C': 3, 'D': 3},
 {'A': 7, 'B': 9, 'C': 3, 'D': 5},
 {'A': 2, 'B': 4, 'C': 7, 'D': 6}]

该列表由包含每个键的“记录”组成。这是你可能遇到的最简单的情况。

# The following methods all produce the same output.
pd.DataFrame(data)
pd.DataFrame.from_dict(data)
pd.DataFrame.from_records(data)

   A  B  C  D
0  5  0  3  3
1  7  9  3  5
2  2  4  7  6

Word on Dictionary定向:orient='index'/'columns'

在继续之前，重要的是区分不同类型的字典方向，并支持pandas。有两种主要类型:“列”和“索引”。

东方=“列” 具有“columns”方向的字典将其键对应于等效DataFrame中的列。

例如，上面的数据以“列”为方向。

data_c = [
 {'A': 5, 'B': 0, 'C': 3, 'D': 3},
 {'A': 7, 'B': 9, 'C': 3, 'D': 5},
 {'A': 2, 'B': 4, 'C': 7, 'D': 6}]

pd.DataFrame.from_dict(data_c, orient='columns')

   A  B  C  D
0  5  0  3  3
1  7  9  3  5
2  2  4  7  6

注意:如果使用pd. datafame .from_records，则假定方向为“列”(不能指定其他方向)，字典将相应地加载。

东方=“指数” 在这个定向中，键被假定对应于索引值。这种数据最适合pd.DataFrame.from_dict。

data_i ={
 0: {'A': 5, 'B': 0, 'C': 3, 'D': 3},
 1: {'A': 7, 'B': 9, 'C': 3, 'D': 5},
 2: {'A': 2, 'B': 4, 'C': 7, 'D': 6}}

pd.DataFrame.from_dict(data_i, orient='index')

   A  B  C  D
0  5  0  3  3
1  7  9  3  5
2  2  4  7  6

OP中没有考虑到这种情况，但知道它仍然是有用的。

设置自定义索引

如果你需要在生成的DataFrame上创建一个自定义索引，你可以使用index=…论点。

pd.DataFrame(data, index=['a', 'b', 'c'])
# pd.DataFrame.from_records(data, index=['a', 'b', 'c'])

   A  B  C  D
a  5  0  3  3
b  7  9  3  5
c  2  4  7  6

pd.DataFrame.from_dict不支持。

处理缺失的键/列

在处理缺少键/列值的字典时，所有方法都可以开箱即用。例如,

data2 = [
     {'A': 5, 'C': 3, 'D': 3},
     {'A': 7, 'B': 9, 'F': 5},
     {'B': 4, 'C': 7, 'E': 6}]

# The methods below all produce the same output.
pd.DataFrame(data2)
pd.DataFrame.from_dict(data2)
pd.DataFrame.from_records(data2)

     A    B    C    D    E    F
0  5.0  NaN  3.0  3.0  NaN  NaN
1  7.0  9.0  NaN  NaN  NaN  5.0
2  NaN  4.0  7.0  NaN  6.0  NaN

列的读取子集

"如果我不想每一栏都读呢"你可以使用列=…参数。

例如，从上面的data2的示例字典中，如果你想只读取列"A'， 'D'，和'F'，你可以通过传递一个列表来实现:

pd.DataFrame(data2, columns=['A', 'D', 'F'])
# pd.DataFrame.from_records(data2, columns=['A', 'D', 'F'])

     A    D    F
0  5.0  3.0  NaN
1  7.0  NaN  5.0
2  NaN  NaN  NaN

这是pd. datafame .from_dict默认定向"columns"不支持的。

pd.DataFrame.from_dict(data2, orient='columns', columns=['A', 'B'])

ValueError: cannot use columns parameter with orient='columns'

行读取子集

这些方法都不直接支持。您必须对数据进行迭代，并在迭代时就地执行反向删除。例如，要从上面的data2中只提取第0行和第2行，你可以使用:

rows_to_select = {0, 2}
for i in reversed(range(len(data2))):
    if i not in rows_to_select:
        del data2[i]

pd.DataFrame(data2)
# pd.DataFrame.from_dict(data2)
# pd.DataFrame.from_records(data2)

     A    B  C    D    E
0  5.0  NaN  3  3.0  NaN
1  NaN  4.0  7  NaN  6.0

---

灵丹妙药:json_normalize用于嵌套数据

上述方法的一个强大、健壮的替代方法是json_normalize函数，它处理字典(记录)列表，此外还可以处理嵌套字典。

pd.json_normalize(data)

   A  B  C  D
0  5  0  3  3
1  7  9  3  5
2  2  4  7  6

pd.json_normalize(data2)

     A    B  C    D    E
0  5.0  NaN  3  3.0  NaN
1  NaN  4.0  7  NaN  6.0

同样，请记住传递给json_normalize的数据需要采用字典列表(记录)格式。

如前所述，json_normalize还可以处理嵌套字典。下面是文档中的一个例子。

data_nested = [
  {'counties': [{'name': 'Dade', 'population': 12345},
                {'name': 'Broward', 'population': 40000},
                {'name': 'Palm Beach', 'population': 60000}],
   'info': {'governor': 'Rick Scott'},
   'shortname': 'FL',
   'state': 'Florida'},
  {'counties': [{'name': 'Summit', 'population': 1234},
                {'name': 'Cuyahoga', 'population': 1337}],
   'info': {'governor': 'John Kasich'},
   'shortname': 'OH',
   'state': 'Ohio'}
]

pd.json_normalize(data_nested, 
                          record_path='counties', 
                          meta=['state', 'shortname', ['info', 'governor']])

         name  population    state shortname info.governor
0        Dade       12345  Florida        FL    Rick Scott
1     Broward       40000  Florida        FL    Rick Scott
2  Palm Beach       60000  Florida        FL    Rick Scott
3      Summit        1234     Ohio        OH   John Kasich
4    Cuyahoga        1337     Ohio        OH   John Kasich

有关meta和record_path参数的更多信息，请参阅文档。

---

总结

下面是上面讨论的所有方法的表格，以及支持的特性/功能。

*使用orient='columns'，然后转置以获得与orient='index'相同的效果。

我发现的最简单的方法是这样的:

dict_count = len(dict_list)
df = pd.DataFrame(dict_list[0], index=[0])
for i in range(1,dict_count-1):
    df = df.append(dict_list[i], ignore_index=True)