Python 什么是'；熊猫式'；要存储在数据帧中的数据结构？

我听说pandas不善于在单个单元格中存储列表或词典，但是我正在努力寻找更多关于为什么会出现这种情况的信息。在许多用例中，将更复杂的数据结构存储在Pandas单元（如字典）中对我来说非常有用，我将如何以“panda-esque”的方式来实现这一点？这是否适用于所有可变数据结构

这可能不是你想要的，因为@EdChum是对的。非常简单，将非标量对象放入

pd.Series

和

pd.DataFrame

单元格的理由很少

考虑数据帧

df

d1 = dict(a=1, b=2, c=3)
d2 = dict(d=1, e=2, f=3)
d3 = dict(g=1, h=2, i=3)
d4 = dict(j=1, k=2, l=3)
d5 = dict(m=1, n=2, o=3)
d6 = dict(p=1, q=2, r=3)

df = pd.DataFrame(dict(
    A=[d1, d2, d3],
    B=[d4, d5, d6]
))

df

                          A                         B
0  {'a': 1, 'b': 2, 'c': 3}  {'j': 1, 'k': 2, 'l': 3}
1  {'d': 1, 'e': 2, 'f': 3}  {'m': 1, 'n': 2, 'o': 3}
2  {'g': 1, 'h': 2, 'i': 3}  {'p': 1, 'q': 2, 'r': 3}

---

你最好使用嵌入式词典

d = df.to_dict()

d['A'][0]

{'a': 1, 'b': 2, 'c': 3}

---

但是，如果您想按行或列操作它们，可以编写

dict

的子类，在其中定义加法

from cytoolz.dicttoolz import merge

class dict_(dict):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

    def __add__(self, other):
        return dict_(merge(self, other))

然后您可以将值转换为这个新类并

df.applymap(dict_).sum()

A    {'a': 1, 'b': 2, 'c': 3, 'd': 1, 'e': 2, 'f': ...
B    {'j': 1, 'k': 2, 'l': 3, 'm': 1, 'n': 2, 'o': ...
dtype: object

或

甚至可以得到一个numpy对象数组

df.applymap(dict_).values.sum()

{'a': 1,
 'b': 2,
 'c': 3,
 'd': 1,
 'e': 2,
 'f': 3,
 'g': 1,
 'h': 2,
 'i': 3,
 'j': 1,
 'k': 2,
 'l': 3,
 'm': 1,
 'n': 2,
 'o': 3,
 'p': 1,
 'q': 2,
 'r': 3}

---

---

真有意思！我不知道这有多“熊猫式”，但我喜欢。

这可能不是你想要的，因为@EdChum是对的。非常简单，将非标量对象放入

pd.Series

和

pd.DataFrame

单元格的理由很少

考虑数据帧

df

d1 = dict(a=1, b=2, c=3)
d2 = dict(d=1, e=2, f=3)
d3 = dict(g=1, h=2, i=3)
d4 = dict(j=1, k=2, l=3)
d5 = dict(m=1, n=2, o=3)
d6 = dict(p=1, q=2, r=3)

df = pd.DataFrame(dict(
    A=[d1, d2, d3],
    B=[d4, d5, d6]
))

df

                          A                         B
0  {'a': 1, 'b': 2, 'c': 3}  {'j': 1, 'k': 2, 'l': 3}
1  {'d': 1, 'e': 2, 'f': 3}  {'m': 1, 'n': 2, 'o': 3}
2  {'g': 1, 'h': 2, 'i': 3}  {'p': 1, 'q': 2, 'r': 3}

---

你最好使用嵌入式词典

d = df.to_dict()

d['A'][0]

{'a': 1, 'b': 2, 'c': 3}

---

但是，如果您想按行或列操作它们，可以编写

dict

的子类，在其中定义加法

from cytoolz.dicttoolz import merge

class dict_(dict):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

    def __add__(self, other):
        return dict_(merge(self, other))

然后您可以将值转换为这个新类并

df.applymap(dict_).sum()

A    {'a': 1, 'b': 2, 'c': 3, 'd': 1, 'e': 2, 'f': ...
B    {'j': 1, 'k': 2, 'l': 3, 'm': 1, 'n': 2, 'o': ...
dtype: object

或

甚至可以得到一个numpy对象数组

df.applymap(dict_).values.sum()

{'a': 1,
 'b': 2,
 'c': 3,
 'd': 1,
 'e': 2,
 'f': 3,
 'g': 1,
 'h': 2,
 'i': 3,
 'j': 1,
 'k': 2,
 'l': 3,
 'm': 1,
 'n': 2,
 'o': 3,
 'p': 1,
 'q': 2,
 'r': 3}

---

---

真有意思！不知道这是什么“熊猫式”，但我喜欢它。

因为当数据类型不是标量值时，就不可能执行矢量化操作。它与可变数据结构无关。您所获得的只是检索列和行的灵活性，但例如，如果您想在包含列表的列中搜索值，则必须迭代每一行并进行测试，而不是简单的

df['col']==some_val

想象一下您在pandas中对一个字典执行的某种排序操作，而不是对多个具有字典元素的数据帧执行的类似操作。因为当数据类型不是标量值时，您就失去了执行向量化操作的可能性。它与可变数据结构无关。您所获得的只是检索列和行的灵活性，但例如，如果您想在包含列表的列中搜索值，则必须迭代每一行并进行测试，而不是简单的

df['col']==some_val

想象一下您在一个字典上的pandas中执行的某种排序操作，与在几个带有字典元素的数据帧上执行的类似操作相比。