相关疑难解决方法(0)

我有一个有两列的pandas数据框.我需要更改第一列的值而不影响第二列,只需更改第一列值即可返回整个数据框.我怎么能用熊猫申请呢？

这是一个自我回答的QnA,旨在指导用户应用的缺陷和好处.

我已经看到很多关于Stack Overflow问题的答案涉及使用apply.我也看到用户评论他们说" apply很慢",应该避免".

我已经阅读了很多关于性能主题的文章,解释apply很慢.我还在文档中看到了一个关于如何apply简单地传递UDF的便利函数的免责声明(现在似乎无法找到).因此,普遍的共识是,apply如果可能,应该避免.但是,这引发了以下问题:

1. 如果apply是如此糟糕,那为什么它在API中呢？
2. 我应该如何以及何时制作我的代码apply- 免费？
3. 是否有过任何地方的情况apply是不错的(比其他可能的解决方案更好)？

将函数应用于Pandas索引的最佳方法是什么DataFrame？目前我正在使用这种冗长的方法:

pd.DataFrame({"Month": df.reset_index().Date.apply(foo)})

其中Date是索引foo的名称,是我正在应用的函数的名称.

我有一个可能如下所示的数据框:

A        B        C
foo      bar      foo bar
bar foo  foo      bar

我想查看每行的每个元素(或每列的每个元素)并应用以下函数来获取后续DF:

def foo_bar(x):
    return x.replace('foo', 'wow')

A        B        C
wow      bar      wow bar
bar wow  wow      bar

是否有一个简单的单行程可以为每个单元格应用一个函数？

这是一个简单的示例,因此除了应用函数之外,可能有更简单的方法来执行此特定示例,但我真正要问的是如何在数据帧中的每个单元格中应用函数.

我想在IPython笔记本上写一篇论文,但是遇到了显示格式的一些问题.说我有以下的数据帧df,有没有什么办法来格式化var1和var2成2位小数和var3成比例.

       var1        var2         var3    
id                                              
0    1.458315    1.500092   -0.005709   
1    1.576704    1.608445   -0.005122    
2    1.629253    1.652577   -0.004754    
3    1.669331    1.685456   -0.003525   
4    1.705139    1.712096   -0.003134   
5    1.740447    1.741961   -0.001223   
6    1.775980    1.770801   -0.001723    
7    1.812037    1.799327   -0.002013    
8    1.853130    1.822982   -0.001396    
9    1.943985    1.868401    0.005732

内部数字不会乘以100,例如-0.0057 = -0.57%.

我有这样的数据帧:

                                                    CreationDate
2013-12-22 15:25:02                  [ubuntu, mac-osx, syslinux]
2009-12-14 14:29:32  [ubuntu, mod-rewrite, laconica, apache-2.2]
2013-12-22 15:42:00               [ubuntu, nat, squid, mikrotik]

我是CreationDate列中列表的计算长度,并创建一个新Length列,如下所示:

df['Length'] = df.CreationDate.apply(lambda x: len(x))

这给了我这个:

                                                    CreationDate  Length
2013-12-22 15:25:02                  [ubuntu, mac-osx, syslinux]       3
2009-12-14 14:29:32  [ubuntu, mod-rewrite, laconica, apache-2.2]       4
2013-12-22 15:42:00               [ubuntu, nat, squid, mikrotik]       4

是否有更多的pythonic方式来做到这一点？

我已经阅读了DataFrame.apply的文档

DataFrame.apply(func,axis = 0,broadcast = False,raw = False,reduce = None,args =(),**kwds)沿DataFrame的输入轴应用函数.

那么,如何将函数应用于特定列？

In [1]: import pandas as pd
In [2]: data = {'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]}
In [3]: df = pd.DataFrame(data)
In [4]: df
Out[4]: 
   A  B  C
0  1  4  7
1  2  5  8
2  3  6  9
In [5]: def addOne(v):
...:        v += 1
...:        return v
...: 
In [6]: df.apply(addOne, axis=1)
Out[6]: 
   A  B   C …

我认为我很了解地图与应用地图,但我遇到了问题(如果有兴趣,请参阅此处了解更多背景信息).

一个简单的例子:

df  = pd.DataFrame( [[1,2],[1,1]] ) 
dct = { 1:'python', 2:'gator' }

df[0].map( lambda x: x+90 )
df.applymap( lambda x: x+90 )

这可以按预期工作 - 两者都是按元素运行,在一个系列上映射,在数据帧上运行applymap(在 btw中解释得非常好).

如果我使用字典而不是lambda,地图仍然可以正常工作:

df[0].map( dct )

0    python
1    python

但不是applymap:

df.applymap( dct )
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-100-7872ff604851> in <module>()
----> 1 df.applymap( dct )

C:\Users\johne\AppData\Local\Continuum\Anaconda\lib\site-packages\pandas\core\frame.pyc in applymap(self, func)
   3856                 x = lib.map_infer(_values_from_object(x), f)
   3857             return lib.map_infer(_values_from_object(x), func)
-> 3858         return self.apply(infer)
   3859 
   3860     #----------------------------------------------------------------------

C:\Users\johne\AppData\Local\Continuum\Anaconda\lib\site-packages\pandas\core\frame.pyc in apply(self, …

pandas中的操作是否与pyspark中的flatMap相同？

flatMap示例:

>>> rdd = sc.parallelize([2, 3, 4])
>>> sorted(rdd.flatMap(lambda x: range(1, x)).collect())
[1, 1, 1, 2, 2, 3]

到目前为止,我可以想到apply其次itertools.chain,但我想知道是否有一步到位的解决方案.

使用输入对应(可以是字典,系列或函数)映射系列的值

调用Series的值的函数.可以是ufunc(适用于整个系列的NumPy函数)或仅适用于单个值的Python函数

apply()似乎它确实做了大部分事情map(),在应用矢量化操作时矢量化标量函数.同时map()允许对空值处理进行一定程度的控制.除了Python apply()和map()函数的历史类比之外,是否有理由在一般情况下更喜欢使用其中一个？为什么这些功能不能合并？