梅林的答案更好，也非常简单，但我们不需要lambda函数。字典的评估可以通过以下两种方式之一安全地忽略，如下所示：
方法1：两步

# step 1: convert the `Pollutants` column to Pandas dataframe series

df_pol_ps = data_df['Pollutants'].apply(pd.Series)

df_pol_ps:
    a   b   c
0   46  3   12
1   36  5   8
2   NaN 2   7
3   NaN NaN 11
4   82  NaN 15

# step 2: concat columns `a, b, c` and drop/remove the `Pollutants`

df_final = pd.concat([df, df_pol_ps], axis = 1).drop('Pollutants', axis = 1)

df_final:
    StationID   a   b   c
0   8809    46  3   12
1   8810    36  5   8
2   8811    NaN 2   7
3   8812    NaN NaN 11
4   8813    82  NaN 15

方式2：以上两个步骤可以一次完成：

df_final = pd.concat([df, df['Pollutants'].apply(pd.Series)], axis = 1).drop('Pollutants', axis = 1)

df_final:
    StationID   a   b   c
0   8809    46  3   12
1   8810    36  5   8
2   8811    NaN 2   7
3   8812    NaN NaN 11
4   8813    82  NaN 15

你可以用 join 具有 pop + tolist . 性能可与 concat 具有 drop + tolist ，但有些人可能会发现这种语法更简洁：

res = df.join(pd.DataFrame(df.pop('b').tolist()))

采用其他方法进行基准测试：

df = pd.DataFrame({'a':[1,2,3], 'b':[{'c':1}, {'d':3}, {'c':5, 'd':6}]})

def joris1(df):
    return pd.concat([df.drop('b', axis=1), df['b'].apply(pd.Series)], axis=1)

def joris2(df):
    return pd.concat([df.drop('b', axis=1), pd.DataFrame(df['b'].tolist())], axis=1)

def jpp(df):
    return df.join(pd.DataFrame(df.pop('b').tolist()))

df = pd.concat([df]*1000, ignore_index=True)

%timeit joris1(df.copy())  # 1.33 s per loop
%timeit joris2(df.copy())  # 7.42 ms per loop
%timeit jpp(df.copy())     # 7.68 ms per loop

>>> df

   Station ID                        Pollutants
0        8809  {"a": "46", "b": "3", "c": "12"}
1        8810   {"a": "36", "b": "5", "c": "8"}
2        8811              {"b": "2", "c": "7"}
3        8812                       {"c": "11"}
4        8813            {"a": "82", "c": "15"}

1000万行的大型数据集的速度比较

>>> df = pd.concat([df]*100000).reset_index(drop=True)
>>> df = pd.concat([df]*20).reset_index(drop=True)
>>> print(df.shape)
(10000000, 2)

def apply_drop(df):
    return df.join(df['Pollutants'].apply(pd.Series)).drop('Pollutants', axis=1)  

def json_normalise_drop(df):
    return df.join(pd.json_normalize(df.Pollutants)).drop('Pollutants', axis=1)  

def tolist_drop(df):
    return df.join(pd.DataFrame(df['Pollutants'].tolist())).drop('Pollutants', axis=1)  

def vlues_tolist_drop(df):
    return df.join(pd.DataFrame(df['Pollutants'].values.tolist())).drop('Pollutants', axis=1)  

def pop_tolist(df):
    return df.join(pd.DataFrame(df.pop('Pollutants').tolist()))  

def pop_values_tolist(df):
    return df.join(pd.DataFrame(df.pop('Pollutants').values.tolist()))

>>> %timeit apply_drop(df.copy())
1 loop, best of 3: 53min 20s per loop
>>> %timeit json_normalise_drop(df.copy())
1 loop, best of 3: 54.9 s per loop
>>> %timeit tolist_drop(df.copy())
1 loop, best of 3: 6.62 s per loop
>>> %timeit vlues_tolist_drop(df.copy())
1 loop, best of 3: 6.63 s per loop
>>> %timeit pop_tolist(df.copy())
1 loop, best of 3: 5.99 s per loop
>>> %timeit pop_values_tolist(df.copy())
1 loop, best of 3: 5.94 s per loop

+---------------------+-----------+
| apply_drop          | 53min 20s |
| json_normalise_drop |    54.9 s |
| tolist_drop         |    6.62 s |
| vlues_tolist_drop   |    6.63 s |
| pop_tolist          |    5.99 s |
| pop_values_tolist   |    5.94 s |
+---------------------+-----------+
``` `df.join(pd.DataFrame(df.pop('Pollutants').values.tolist()))` 是最快的

如何使用pandas将一列词典拆分为单独的列？

dataframe（df['val'].tolist（））是用于分解字典列的规范方法

这是你用彩色图表做的证明。

基准测试代码供参考。
请注意，我只是为爆炸计时，因为这是回答这个问题最有趣的部分——结果构造的其他方面（例如是否使用 pop 或 drop )与讨论无关，可以忽略（但应注意，使用 pop 避免后续行动 drop 调用，因此最终的解决方案的性能会更好一些，但我们仍在列出该列并将其传递给 pd.DataFrame 无论如何）。
另外,， pop 破坏性地改变输入 Dataframe ，使其更难在基准测试代码中运行，而基准测试代码假定输入在测试运行期间没有改变。

对其他解决方案的批评 df['val'].apply(pd.Series) 对于大n来说非常慢，因为pandas为每一行构造系列对象，然后继续从它们构造 Dataframe 。对于较大的n，性能下降到分钟或小时的数量级。 pd.json_normalize(df['val'])) 速度变慢仅仅是因为 json_normalize 用于处理更复杂的输入数据，特别是具有多条记录路径和元数据的深度嵌套json。我们有一个简单的平板电脑 pd.DataFrame 足够了，所以如果你的口述是扁平的，就用它。

一些答案表明 df.pop('val').values.tolist() 或 df.pop('val').to_numpy().tolist() . 我不认为它有多大的区别，无论你是否列出该系列或numpy阵列。直接列出该系列只需一个操作，而且速度并不慢，因此我建议避免在中间步骤生成numpy数组。

单线解决方案如下：

>>> df = pd.concat([df['Station ID'], df['Pollutants'].apply(pd.Series)], axis=1)
>>> print(df)
   Station ID    a    b   c
0        8809   46    3  12
1        8810   36    5   8
2        8811  NaN    2   7
3        8812  NaN  NaN  11
4        8813   82  NaN  15

df = pd.concat([df['a'], df.b.apply(pd.Series)], axis=1)

my_df = pd.DataFrame.from_dict(my_dict, orient='index', columns=['my_col']) .. 将正确解析dict（将每个dict键放入单独的df列中，将键值放入df行中），这样dict就不会首先被压缩到单个列中。

我已将这些步骤连接到一个方法中，您只需传递dataframe和包含要展开的dict的列：

def expand_dataframe(dw: pd.DataFrame, column_to_expand: str) -> pd.DataFrame:
    """
    dw: DataFrame with some column which contain a dict to expand
        in columns
    column_to_expand: String with column name of dw
    """
    import pandas as pd

    def convert_to_dict(sequence: str) -> Dict:
        import json
        s = sequence
        json_acceptable_string = s.replace("'", "\"")
        d = json.loads(json_acceptable_string)
        return d    

    expanded_dataframe = pd.concat([dw.drop([column_to_expand], axis=1),
                                    dw[column_to_expand]
                                    .apply(convert_to_dict)
                                    .apply(pd.Series)],
                                    axis=1)
    return expanded_dataframe

要将字符串转换为实际的dict，可以执行以下操作 df['Pollutant Levels'].map(eval) . 然后，可以使用下面的解决方案将dict转换为不同的列。
使用一个小示例，您可以使用 .apply(pd.Series) :

In [2]: df = pd.DataFrame({'a':[1,2,3], 'b':[{'c':1}, {'d':3}, {'c':5, 'd':6}]})

In [3]: df
Out[3]:
   a                   b
0  1           {u'c': 1}
1  2           {u'd': 3}
2  3  {u'c': 5, u'd': 6}

In [4]: df['b'].apply(pd.Series)
Out[4]:
     c    d
0  1.0  NaN
1  NaN  3.0
2  5.0  6.0

要将其与 Dataframe 的其余部分结合起来，您可以 concat 具有上述结果的其他列：

In [7]: pd.concat([df.drop(['b'], axis=1), df['b'].apply(pd.Series)], axis=1)
Out[7]:
   a    c    d
0  1  1.0  NaN
1  2  NaN  3.0
2  3  5.0  6.0

使用您的代码，如果我省略 iloc 第部分：

In [15]: pd.concat([df.drop('b', axis=1), pd.DataFrame(df['b'].tolist())], axis=1)
Out[15]:
   a    c    d
0  1  1.0  NaN
1  2  NaN  3.0
2  3  5.0  6.0

我知道这个问题很老了，但我来这里是为了寻找答案。实际上，现在有一种更好（更快）的方法使用 json_normalize :

import pandas as pd

df2 = pd.json_normalize(df['Pollutant Levels'])

这避免了昂贵的应用函数。。。

规范化一列平面、一个标高的最快方法 dicts ，根据shijith在本回答中进行的时间分析： df.join(pd.DataFrame(df.pop('Pollutants').values.tolist())) 它不会解决列的其他问题 list 或 dicts 下面列出的，例如带有 NaN ，或嵌套 dicts . pd.json_normalize(df.Pollutants) 明显快于 df.Pollutants.apply(pd.Series) 见 %%timeit 在下面对于100万行， .json_normalize 它的速度是它的47倍 .apply .
无论是从文件中读取数据，还是从数据库或api返回的对象中读取数据，都可能不清楚 dict 专栏有 dict 或 str 类型。
如果列中的词典是 str 类型，则必须将其转换回 dict 类型，使用 ast.literal_eval .
使用 pd.json_normalize 转换 dicts 具有 keys 作为标题和 values 行。
还有其他参数（例如。 record_path & meta )用于处理嵌套 dicts .
使用 pandas.DataFrame.join 要组合原始 Dataframe ， df ，使用 pd.json_normalize 如果索引不是整数（如示例中所示），请首先使用 df.reset_index() 在执行规格化和联接之前，获取整数索引。
最后，使用 pandas.DataFrame.drop ，以删除不需要的列 dicts 请注意，如果该列有 NaN ，必须用空的
dict df.Pollutants = df.Pollutants.fillna({i: {} for i in df.index}) 如果 'Pollutants' 列是字符串，请使用 '{}' .
另请参见如何使用nans？规范化列？。

import pandas as pd
from ast import literal_eval
import numpy as np

data = {'Station ID': [8809, 8810, 8811, 8812, 8813, 8814],
        'Pollutants': ['{"a": "46", "b": "3", "c": "12"}', '{"a": "36", "b": "5", "c": "8"}', '{"b": "2", "c": "7"}', '{"c": "11"}', '{"a": "82", "c": "15"}', np.nan]}

df = pd.DataFrame(data)

# display(df)

   Station ID                        Pollutants
0        8809  {"a": "46", "b": "3", "c": "12"}
1        8810   {"a": "36", "b": "5", "c": "8"}
2        8811              {"b": "2", "c": "7"}
3        8812                       {"c": "11"}
4        8813            {"a": "82", "c": "15"}
5        8814                               NaN

# replace NaN with '{}' if the column is strings, otherwise replace with {}

# df.Pollutants = df.Pollutants.fillna('{}')  # if the NaN is in a column of strings

df.Pollutants = df.Pollutants.fillna({i: {} for i in df.index})  # if the column is not strings

# Convert the column of stringified dicts to dicts

# skip this line, if the column contains dicts

df.Pollutants = df.Pollutants.apply(literal_eval)

# reset the index if the index is not unique integers from 0 to n-1

# df.reset_index(inplace=True)  # uncomment if needed

# normalize the column of dictionaries and join it to df

df = df.join(pd.json_normalize(df.Pollutants))

# drop Pollutants

df.drop(columns=['Pollutants'], inplace=True)

# display(df)

   Station ID    a    b    c
0        8809   46    3   12
1        8810   36    5    8
2        8811  NaN    2    7
3        8812  NaN  NaN   11
4        8813   82  NaN   15
5        8814  NaN  NaN  NaN

%%时间

# dataframe with 1M rows

dfb = pd.concat([df]*200000).reset_index(drop=True)

%%timeit
dfb.join(pd.json_normalize(dfb.Pollutants))
[out]:
5.44 s ± 32.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%%timeit
pd.concat([dfb.drop(columns=['Pollutants']), dfb.Pollutants.apply(pd.Series)], axis=1)
[out]:
4min 17s ± 2.44 s per loop (mean ± std. dev. of 7 runs, 1 loop each)

试试这个：从sql返回的数据必须转换成dict，或者是 "Pollutant Levels" 现在是 Pollutants' ```
StationID Pollutants
0 8809 {"a":"46","b":"3","c":"12"}
1 8810 {"a":"36","b":"5","c":"8"}
2 8811 {"b":"2","c":"7"}
3 8812 {"c":"11"}
4 8813 {"a":"82","c":"15"}

df2["Pollutants"] = df2["Pollutants"].apply(lambda x : dict(eval(x)) )
df3 = df2["Pollutants"].apply(pd.Series )

a    b   c

0 46 3 12
1 36 5 8
2 NaN 2 7
3 NaN NaN 11
4 82 NaN 15

result = pd.concat([df, df3], axis=1).drop('Pollutants', axis=1)
result

StationID a b c
0 8809 46 3 12
1 8810 36 5 8
2 8811 NaN 2 7
3 8812 NaN NaN 11
4 8813 82 NaN 15

我强烈推荐提取“污染物”列的方法： df_pollutants = pd.DataFrame(df['Pollutants'].values.tolist(), index=df.index) 比以前快多了 df_pollutants = df['Pollutants'].apply(pd.Series) 当df的大小是巨大的。