相关疑难解决方法(0)

我注意到从熊猫使用iterrows时性能非常差.

这是其他人经历过的事情吗？它是否特定于iterrows,并且对于特定大小的数据(我正在使用2-3百万行),是否应该避免此功能？

关于GitHub的讨论使我相信它是在数据帧中混合dtypes时引起的,但是下面的简单示例表明它甚至在使用一个dtype(float64)时也存在.我的机器需要36秒:

import pandas as pd
import numpy as np
import time

s1 = np.random.randn(2000000)
s2 = np.random.randn(2000000)
dfa = pd.DataFrame({'s1': s1, 's2': s2})

start = time.time()
i=0
for rowindex, row in dfa.iterrows():
    i+=1
end = time.time()
print end - start

为什么矢量化操作如此快速应用？我想也必须有一些逐行迭代.

在我的情况下,我无法弄清楚如何不使用iterrows(这将为将来的问题保存).因此,如果您一直能够避免这种迭代,我将不胜感激.我正在基于单独数据帧中的数据进行计算.谢谢!

---编辑:我想要运行的简化版本已添加到下面---

import pandas as pd
import numpy as np

#%% Create the original tables
t1 = {'letter':['a','b'],
      'number1':[50,-10]}

t2 = {'letter':['a','a','b','b'],
      'number2':[0.2,0.5,0.1,0.4]}

table1 = pd.DataFrame(t1)
table2 = pd.DataFrame(t2)

#%% Create the body of the …

考虑一个小型MWE,取自另一个问题:

DateTime                Data
2017-11-21 18:54:31     1
2017-11-22 02:26:48     2
2017-11-22 10:19:44     3
2017-11-22 15:11:28     6
2017-11-22 23:21:58     7
2017-11-28 14:28:28    28
2017-11-28 14:36:40     0
2017-11-28 14:59:48     1

目标是剪切所有值的上限为1.我的答案使用np.clip,这很好.

np.clip(df.Data, a_min=None, a_max=1)
array([1, 1, 1, 1, 1, 1, 0, 1])

要么,

np.clip(df.Data.values, a_min=None, a_max=1)
array([1, 1, 1, 1, 1, 1, 0, 1])

两者都返回相同的答案.我的问题是关于这两种方法的相对表现.考虑 -

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

%timeit np.clip(df.Data, a_min=None, a_max=1)
1000 loops, best of 3: 270 µs per loop

%timeit np.clip(df.Data.values, a_min=None, a_max=1)
10000 loops, best …

我有一个看起来像这样的DF。

name    id  apps
john    1   [[app1, v1], [app2, v2], [app3,v3]]
smith   2   [[app1, v1], [app4, v4]]

我想扩展“应用程序”列，使其看起来像这样。

name    id  app_name    app_version
john    1   app1        v1
john    1   app2        v2
john    1   app3        v3
smith   2   app1        v1
smith   2   app4        v4

任何帮助表示赞赏

我有一个Pandas数据框,如下所示:

                   codes
1                  [71020]
2                  [77085]
3                  [36415]
4                  [99213, 99287]
5                  [99233, 99233, 99233]

我正在尝试将列表拆分df['codes']为列,如下所示:

                   code_1      code_2      code_3   
1                  71020
2                  77085
3                  36415
4                  99213       99287
5                  99233       99233       99233

其中没有值的列(因为列表不长)只有空格或NaN或其他东西.

我已经看到像这样的答案和其他类似的答案,虽然它们在相同长度的列表上工作,但当我尝试在不等长度的列表上使用这些方法时,它们都会抛出错误.这有什么好办法吗？

我有一个 Pandas DataFrame 列，列表中有多个列表。像这样的东西：

df
     col1
0    [[1,2], [2,3]]
1    [[a,b], [4,5], [x,y]] 
2    [[6,7]]

我想将列表拆分为多列，因此输出应类似于：

    col1    col2     col3
0   [1,2]   [2,3]   
1   [a,b]   [4,5]    [x,y]
2   [6,7]

请帮我解决一下这个。提前致谢

我有以下格式的数据框

student   marks
a         [12,12,34]
b         [34,35]
c         [23,45,23]

我希望它转换为如下所示

student marks_1  marks_2 marks_3
a       12        12      34
b       34        35      Nan
c       23        45      23

如何实现这一目标？请提供任何帮助

我有一个 Pandas DataFrame，其中一列是一系列 dicts，如下所示：

   colA  colB                                  colC
0     7     7  {'foo': 185, 'bar': 182, 'baz': 148}
1     2     8  {'foo': 117, 'bar': 103, 'baz': 155}
2     5    10  {'foo': 165, 'bar': 184, 'baz': 170}
3     3     2  {'foo': 121, 'bar': 151, 'baz': 187}
4     5     5  {'foo': 137, 'bar': 199, 'baz': 108}

我希望来自 dicts的foo,bar和baz键值对成为我数据框中的列，这样我就得到了这样的结果：

   colA  colB  foo  bar  baz
0     7     7  185  182  148
1     2     8  117  103  155
2     5    10 …

我正在熊猫数据框的行上应用一个函数。该函数返回四个值（即每行四个值）。实际上，这意味着从 apply 函数返回的对象是一个包含元组的系列。我想将这些添加到他们自己的列中。我知道我可以将该输出转换为 DataFrame，然后与旧的 DataFrame 连接，如下所示：

import pandas as pd


def some_func(i):
    return i+1, i+2, i+3, i+4

df = pd.DataFrame(range(10), columns=['start'])
res = df.apply(lambda row: some_func(row['start']), axis=1)

# convert to df and add column names
res_df = res.apply(pd.Series)
res_df.columns = ['label_1', 'label_2', 'label_3', 'label_4']

# concatenate with old df
df = pd.concat([df, res_df], axis=1)
print(df)

我的问题是是否有更好的方法来做到这一点？特别是res.apply(pd.Series)似乎多余的，但我不知道更好的选择。性能对我来说是一个重要因素。

根据要求，示例输入 DataFrame 可能如下所示

   start
0      0
1      1
2      2
3      3
4      4
5      5
6      6
7      7
8      8 …

我有一个数据框

在这里，我有一个名为“名称拆分”的列，它是一个包含列表的列。现在我想拆分列表的内容并为每个列表创建单独的列。

这是我迄今为止尝试过的：

df = pd.read_csv("C:/Users/Transorg-PC/Desktop/Training/py/datase/football.csv")

temp = df.copy()

temp['name'] = temp['name'].apply(lambda x: ' '.join(x.split()))

temp['name split'] = temp['name'].apply(lambda x: x.split())

temp['length'] = temp['name split'].str.len()

for i in range(temp['length'].max()-1):
    temp[i] = temp['name split'].apply(lambda x:x[i])

但是我无法像这样迭代，因为在某些情况下索引超出范围。那么如何在单独的列中拆分列表的内容。

我有一个包含几列的数据框，如下所示：

              Age                         G                      GS 
INDEX1  [27, 25, 22, 30, 30]    [76, 79, 80, 76, 77]    [76, 79, 80, 76, 77]    
INDEX2  [24, 23, 21, 32, 34]    [77, 76, 81, 75, 77]    [77, 76, 81, 75, 77]    

我如何将所有列表拆分为各自独立的列？理想情况下，完成后我的数据框将如下所示：

       Age   Age1  Age2   Age3   Age4   G    G1   G2   G3   G4
INDEX1  27    25    22     30     30    76   79   80   76   77  ...
... 

如果有帮助，我确实将字典转换为这个数据框。我曾尝试在堆栈上搜索和实施几种不同的类似解决方案，但似乎都没有奏效。此解决方案正确转换，但由于某种原因创建了两个 NaN 列。如果有人知道如何在整个数据帧上执行此操作，我可以删除额外的 NaN 列：

df1 = pd.DataFrame(converted['Age'].values.tolist())
df1


    0   1   2   3    4       5   6
0   27  25  22 …