Python 如何使用melt（）将数据框重塑为列表，从交叉表列创建索引并在其位置创建新变量？

我有一个数据矩阵29523行x 503列，其中3列是索引（下面是一个子集示例）

我将其读入一个

数据框

：

>>> df = pd.read_csv(C:\filename.csv, low_memory=False, mangle_dupe_cols=False)

然后使用

pandas.melt（）

透视数据：

df1 = pd.melt(df, id_vars=['IDX1', 'IDX2', 'IDX3'], var_name='ValueType',
              value_name = 'Value')

我也尝试过

stack（）

，但是

melt（）

在这里被证明更好

IDX1    |   IDX2    |   IDX3    |   ValueType   |   Value
---------------------------------------------------------------
A       |   A1      |   Q       |   1983 Q4     |   10
A       |   A1      |   Q       |   X           |   A
A       |   A1      |   Q       |   Y           |   F
A       |   A1      |   Q       |   Z           |   NaN
A       |   A1      |   Q       |   1984 Q1     |   110
A       |   A1      |   Q       |   X           |   A
A       |   A1      |   Q       |   Y           |   F
A       |   A1      |   Q       |   Z           |   NaN
A       |   A2      |   Q       |   1983 Q4     |   20
A       |   A2      |   Q       |   X           |   B
A       |   A2      |   Q       |   Y           |   C
A       |   A2      |   Q       |   Z           |   40

read\u csv

if

True

上的选项

mangle\u dupe\u cols

将在所有重复的

ValueType

上放置一个

.int

后缀。这并不理想，但如果没有它，就无法将变量的值链接到正确的周期

我更愿意做的是，不要将

期间

（1984 Q1）

作为

值类型

，而是给

期间

s相应的

值

一个变量

'W'

，并让每个期间构成

IDX

的一部分，如下所示：

IDX1    |   IDX2    |   IDX3 | IDX4    |    ValueType   |   Value
---------------------------------------------------------------
A       |   A1      |   Q    |  1983 Q4|    W           |   10
A       |   A1      |   Q    |  1983 Q4|    X           |   A
A       |   A1      |   Q    |  1983 Q4|    Y           |   F
A       |   A1      |   Q    |  1983 Q4|    Z           |   NaN
A       |   A1      |   Q    |  1984 Q1|    W           |   110
A       |   A1      |   Q    |  1984 Q1|    X           |   A
A       |   A1      |   Q    |  1984 Q1|    Y           |   F
A       |   A1      |   Q    |  1984 Q1|    Z           |   NaN
A       |   A2      |   Q    |  1983 Q4|    W           |   20
A       |   A2      |   Q    |  1983 Q4|    X           |   B
A       |   A2      |   Q    |  1983 Q4|    Y           |   C
A       |   A2      |   Q    |  1983 Q4|    Z           |   40

以上是熊猫还是numpy可以做到的

我的最终数据帧是14761500行x 6列。

In [189]: df
Out[189]: 
  IDX1 IDX2 IDX3  1983 Q4  X  Y    Z  1984 Q1 X.1 Y.1  Z.1
0    A   A1    Q       10  A  F  NaN      110   A   F  NaN
1    A   A2    Q       20  B  C   40      120   B   C  240
2    A   A3    Q       30  A  F  NaN      130   A   F  NaN
3    A   A4    Q       40  B  C   80      140   B   C  280
4    A   A5    Q       50  A  F  NaN      150   A   F  NaN
5    A   A6    Q       60  B  F  120      160   B   F  320

让我们首先设置

['IDX1'，'IDX2'，'IDX3']

作为索引

df = df.set_index(['IDX1', 'IDX2', 'IDX3'])

其他列对它们具有周期性质量；我们要处理每4个问题 列作为一个组。这种“集体处理”的想法自然会导致 为列索引指定新的索引级别；一些相同的值 每4列。这将是理想的：

               1983 Q4            1984 Q1           
                     W  X  Y    Z       W  X  Y    Z
IDX1 IDX2 IDX3                                      
A    A1   Q         10  A  F  NaN     110  A  F  NaN
     A2   Q         20  B  C  240     120  B  C  240
     A3   Q         30  A  F  NaN     130  A  F  NaN
     A4   Q         40  B  C  280     140  B  C  280
     A5   Q         50  A  F  NaN     150  A  F  NaN
     A6   Q         60  B  F  320     160  B  F  320

我们可以通过构建多索引并将其分配给

df.columns

，来实现这一点：

columns = [col for col in df.columns if col[0] not in set(list('XYZ'))]
df.columns = pd.MultiIndex.from_product([columns, list('WXYZ')])

现在，可以通过调用

df.stack

来获得所需的长格式数据帧 将列级别移动到行索引中：

df.columns.names = ['IDX4', 'ValueType']
series = df.stack(['IDX4', 'ValueType'], dropna=False)

---

还要注意，当

mangle\u dupe\u cols=False

时，重复的列，

X

，

Y

，

Z

，被覆盖。因此，使用

mangle\u dupe\u cols=False将丢失数据。对于
例如，当您使用
mangle\u dupe\u cols=False
时，最后一行的
Z
值
分配给每个
Z
列，不考虑周期

所以我们必须使用
mangle\u dupe\u cols=True
，（或者干脆不使用它，因为这是
默认）并相应地调整代码。幸运的是，这并不难做到
因为我们正在将
df.columns
重新指定给自定义的构建多索引


总而言之：

import numpy as np
import pandas as pd
df = pd.read_table('data', sep=r'\s*[|]\s*')
df = df.set_index(['IDX1', 'IDX2', 'IDX3'])
columns = [col for col in df.columns if col[0] not in set(list('XYZ'))]
df.columns = pd.MultiIndex.from_product([columns, list('WXYZ')])
df.columns.names = ['IDX4', 'ValueType']
series = df.stack(['IDX4', 'ValueType'], dropna=False)
print(series.head())

屈服

IDX1  IDX2  IDX3  IDX4     ValueType
A     A1    Q     1983 Q4  W             10
                           X              A
                           Y              F
                           Z            NaN
                  1984 Q1  W            110
dtype: object

请注意，由于我们删除了所有列级别，因此结果是一个系列。
如果您想要一个包含6列的数据帧，那么我们应该使用以下内容：

series.name = 'Value'
df = series.reset_index()
print(df.head())

产生

  IDX1 IDX2 IDX3     IDX4 ValueType Value
0    A   A1    Q  1983 Q4         W    10
1    A   A1    Q  1983 Q4         X     A
2    A   A1    Q  1983 Q4         Y     F
3    A   A1    Q  1983 Q4         Z   NaN
4    A   A1    Q  1984 Q1         W   110
...

非常感谢，格式现在是正确的，但是每个组中的值都有问题。我的数据集从1983年第4季度运行到2014年第4季度，对于每个组，我有4个值（W、X、Y、Z）。这些也会在每组重复，也可能是NaN。似乎建议的解决方案排除了NAN，并且在将值分配到正确的值类型和周期组合时也会感到困惑。我提供的示例数据应该还有几个周期组。初始df行中的最后一个值被写入存在NAN的所有位置。我们可以通过将
dropna=False
传递给调用
df.stack
来防止NAN被丢弃。值的错误分配是由于
mangle\u dupe\u cols=False
造成的。不仅列名重复，而且列值也重复。谢谢你指出这一点；我没有意识到这是使用此参数时的行为。为了解决这两个问题，我修改了上面的代码。
  IDX1 IDX2 IDX3     IDX4 ValueType Value
0    A   A1    Q  1983 Q4         W    10
1    A   A1    Q  1983 Q4         X     A
2    A   A1    Q  1983 Q4         Y     F
3    A   A1    Q  1983 Q4         Z   NaN
4    A   A1    Q  1984 Q1         W   110
...