Question

我有一个（7.5MM，17）数据框，其中有50万个我正在“取消透视”的唯一项，原因是缺少更好的词：每个唯一项可以有N个与各种特征相关联的行，这就是汇总成列，以便每个唯一项只有一行。

为此，我有一个for循环，遍历数据帧中的每个唯一项。它将数据帧分类为一个临时数据帧，该数据帧仅过滤到由所述唯一项表示的行。然后，我申请

df.loc[df['trait']=='xyz'].sum()

表示8个特征，每个特征生成一个聚合变量。然后将这些变量附加到临时列表（内部循环）中，该列表又附加到输出列表（外部循环）中。

在每个循环结束时，基本数据帧都会删除与唯一项相关的所有行，以便随着输出列表的增加，基本数据帧的存储大小会减少（约15倍）。

我希望它运行得非常快，因为据我所知，for循环内部的操作是矢量化的实现。但是，一个小时后，它仅经过约7000行。这将运行时期望值设置为不到3天。我可以接受，但希望能对更有效的解决方案有所了解。

我在其上运行的计算机具有32GB RAM，0.5TB存储。该程序仅占用约5GB的RAM。有没有办法使用更多的RAM但移动得更快？

任何见识将不胜感激。

编辑-

wolst = []
cnt = 0

for i in wodf['WON'].unique().tolist():
    tlst = []
    wo = i

    tdf = wodf.loc[wodf['WON']==i]

    matsum = tdf.loc[tdf['LIT']=="M",'LIC'].sum()
    labsum = tdf.loc[tdf['LIT']=="L", 'LIC'].sum()
    labhrs = tdf.loc[tdf['LIT']=="L", 'Q'].sum()
    tcsum = tdf.loc[tdf['LIT']=="T", 'LIC'].sum()
    numtrp = tdf.loc[tdf['LIT']=="T", 'Q'].sum()
    pmusum = tdf.loc[tdf['LIT']=="PM", 'LIC'].sum()
    prtsum = tdf.loc[tdf['LIT']=="P", 'LIC'].sum()
    stdsum = tdf.loc[tdf['LIT']=="S", 'LIC'].sum()
    stdhrs = tdf.loc[tdf['LIT']=="S", 'Q'].sum()

    labsum = labsum+stdsum
    labhrs = labhrs+stdhrs

    if labsum is None:
        labsum = 0
    if labhrs is None:
        labhrs = 0
    if matsum is None:
        matsum=0
    if tcsum is None:
        tcsum=0
    if numtrp is None:
        numtrp=0
    if pmusum is None:
        pmusum=0
    if prtsum is None:
        prtsum=0

    tlst.append([wo,labsum,labhrs,matsum,tcsum,numtrp,pmusum,prtsum])
    wolst.append(tlst)

    print(cnt)
    cnt+=1

wodf在（7.5MM，17）处

Answer 1

您实际上是按“ WON”和“ LIT”分组，并汇总“ LIC”和“ Q”？

以下是groupby可以执行类似操作的示例。

In [42]: df = pd.DataFrame({'WON' : ['foo', 'bar', 'foo', 'bar', 
    ...:    ...:                           'foo', 'bar', 'foo', 'foo'], 
    ...:    ...:                    'LIT' : ['one', 'one', 'two', 'three', 
    ...:    ...:                           'two', 'two', 'one', 'three'], 
    ...:    ...:                    'LIC' : np.random.randn(8), 
    ...:    ...:                    'Q' : np.random.randn(8)})                             

In [43]: df                                                                                
Out[43]: 
   WON    LIT       LIC         Q
0  foo    one  0.148776  1.963984
1  bar    one  0.008530 -0.494986
2  foo    two  0.218419  0.384919
3  bar  three  0.944845 -0.185242
4  foo    two  0.218473  1.505220
5  bar    two  0.669328  0.146424
6  foo    one -0.861758  0.482464
7  foo  three -0.627680  1.604041

In [44]: df.groupby(['WON', 'LIT'])['LIC', 'Q'].sum().unstack()                            
Out[44]: 
          LIC                             Q                    
LIT       one     three       two       one     three       two
WON                                                            
bar  0.008530  0.944845  0.669328 -0.494986 -0.185242  0.146424
foo -0.712981 -0.627680  0.436891  2.446449  1.604041  1.890139

In [45]: df.groupby(['WON', 'LIT'])['LIC', 'Q'].sum()                                      
Out[45]: 
                LIC         Q
WON LIT                      
bar one    0.008530 -0.494986
    three  0.944845 -0.185242
    two    0.669328  0.146424
foo one   -0.712981  2.446449
    three -0.627680  1.604041
    two    0.436891  1.890139

如果出现RAM使用问题，您可以查看dask项目，该项目可以使用类似熊猫的API处理内存不足的计算

我会把你指向：

excellent Pandas documentation
Wes McKinney（《熊猫人》的作者）Python for Data Analysis

在矢量化循环实现中使用Pandas提高速度和效率

1 个答案: