python pandas: 将一个带参数的函数应用到一个系列上

224 人关注

我想在Python pandas中把一个带参数的函数应用于一个系列。

x = my_series.apply(my_function, more_arguments_1)
y = my_series.apply(my_function, more_arguments_2)
The 文件描述了对一个apply方法的支持，但它不接受任何论据。  是否有一个不同的方法可以接受参数？  或者，我是否错过了一个简单的解决方法？
更新（2017年10月）。  Note that since this question was originally asked that pandas apply() has been updated to handle positional and keyword arguments and the 文件 link above now reflects that and shows how to include either type of argument.


         2
         
         个评论


           
            Joel Cornett
           
           ：


           
            Why not just use
            
             functools.partial
            
            , or
            
             starmap
            
            ?


           
            Martin Thoma
           
           ：


           
            See
            
             
              DataFrame.apply
             
             docs
            
            和
            
             
              Series.apply
             
             docs


         python


         pandas


         apply


        7
        
        个回答


          已采纳


         0
         
         人赞同


          
           较新版本的pandas
           
            do
           
           允许你传递额外的参数（见
           
            新文件
           
           ).因此，现在你可以做到。
          
          my_series.apply(your_function, args=(2,3,4), extra_kw=1)
位置参数被添加之后 the element of the series.
对于老版本的pandas。
文档中对此有明确的解释。apply方法接受一个Python函数，它应该有一个参数。如果你想传递更多的参数，你应该使用functools.partial，正如Joel Cornett在他的评论中建议的那样。
一个例子。
>>> import functools
>>> import operator
>>> add_3 = functools.partial(operator.add,3)
>>> add_3(2)
>>> add_3(7)
你也可以使用partial传递关键字参数。
另一种方法是创建一个lambda。
my_series.apply((lambda x: your_func(a,b,c,d,...,x)))
But I think using partial is better.


           
            
             
              
               Wouter Overmeire
              
              ：


           
            
             
              
               对于一个DataFrame来说，apply方法接受
               
                args
               
               参数，它是一个持有额外位置参数的元组，或者是命名参数的**kwds。我创建了一个问题，希望Series.apply()也能这样。
               
                github.com/pydata/pandas/issues/1829


           
            
             
              
               Wes McKinney
              
              ：


           
            
             
              
               该功能已经实现，将在即将发布的pandas中出现。


           
            
             
              
               这是一个很好的答案，但它的前2/3部分现在确实已经过时了。  我认为，这个答案可以很好地更新，只需提供一个新文档的链接，再加上一个如何使用位置和/或关键字参数的简短例子。  我只是随便说说，并不是对原始答案的批评，只是希望能从更新中受益，尤其是这是一个经常被阅读的答案。


           
            
             
              
               @watsonic 文档后来被更新了，点击旧的链接就可以看到现在的文档，现在已经很好地回答了这个问题。


           
            
             
              
               注意：如果你传递的是一个字符串参数，例如
               
                'abc'
               
               ，那么
               
                args=('abc')
               
               将被评估为三个参数
               
                ('a', 'b', 'c')
               
               。为了避免这种情况，你必须传递一个包含字符串的元组，为了做到这一点，请在后面加上一个逗号。【替换代码3


          
           
            
             
              
               Steps:
              
             
             
              Create a dataframe
             
             
              Create a function
             
             
              Use the named arguments of the function in the apply statement.
             
             x=pd.DataFrame([1,2,3,4])  
def add(i1, i2):  
    return i1+i2
x.apply(add,i2=9)
这个例子的结果是，数据框中的每个数字都将被加到数字9上。  
0  10
1  11
2  12
3  13
解释一下。
添加 "函数有两个参数：i1，i2。  第一个参数将是数据框中的值，第二个参数是我们传递给 "apply "函数的任何内容。  在本例中，我们使用关键字参数 "i2 "将 "9 "传递给apply函数。


           
            
             
              
               
                这正是我在寻找的。值得注意的是，这不需要创建一个自定义函数来处理一个系列（或df）。太完美了!


           
            
             
              
               
                唯一剩下的问题是：如何在add（i1）中向第一个参数传递一个关键字参数，并以i2进行迭代？


           
            
             
              
               
                赞同@Connor的评论，当第一个参数必须被指定时，如何处理两个位置参数？


          
           
            
             
              Series.apply(func, convert_dtype=True, args=(), **kwds)
args : tuple
x = my_series.apply(my_function, args = (arg1,))


           
            
             
              
               
                
                 谢谢!你能解释一下为什么args = (arg1,)在第一个参数后面需要一个逗号？


           
            
             
              
               
                
                 prooffreader
                
                ：


           
            
             
              
               
                
                 @MishaTeplitskiy，你需要逗号，以便让 Python 理解小括号的内容是一个长度为 1 的元组。


           
            
             
              
               
                
                 Little Bobby Tables
                
                ：


           
            
             
              
               
                
                 如何为
                 
                  func
                 
                 输入参数。那么，如果我想应用
                 
                  pd.Series.mean(axis=1)
                 
                 ，我如何输入
                 
                  axis=1
                 
                 ？


           
            
             
              
               
                
                 As a side note, you can also add a keyword argument without using the <args> parameter (e.g.: x = my_series.apply(my_function, keyword_arg=arg1), where <keyword_arg> is among the input parameters of my_function)


           
            
             
              
               
                
                 这个回答太短了，没有说明任何问题


          
           
            
             
              
               
                你可以向
                
                 apply
                
                调用的函数传递任意数量的参数，这些参数可以是未命名的参数，作为一个元组传递给
                
                 args
                
                参数，或者通过
                
                 kwds
                
                参数内部捕获的其他关键字参数作为一个字典。
               
               
                例如，让我们建立一个函数，对3和6之间的值返回True，否则返回False。
               
               s = pd.Series(np.random.randint(0,10, 10))
0    5
1    3
2    1
3    1
4    6
5    0
6    3
7    4
8    9
9    6
dtype: int64
s.apply(lambda x: x >= 3 and x <= 6)
0     True
1     True
2    False
3    False
4     True
5    False
6     True
7     True
8    False
9     True
dtype: bool
这个匿名函数不是很灵活。让我们创建一个有两个参数的普通函数，以控制我们在系列中想要的最小和最大值。
def between(x, low, high):
    return x >= low and x =< high
我们可以通过向args传递未命名的参数来复制第一个函数的输出。
s.apply(between, args=(3,6))
或者我们可以使用命名的参数
s.apply(between, low=3, high=6)
甚至是两者的结合
s.apply(between, args=(3,), high=6)


          
           
            
             
              
               
                
                 
                  
                   
                    
                     
                     
                      Shivaji fullstack
                     
                    
                    
                     发布于
                     
                     2022-08-17


          
           
            
             
              
               
                
                 
                  
                   
                    #sample dataframe
import pandas as pd
df1=pd.DataFrame({'a':[3,4,7],'b':[4,2,2]})
#my function
def add_some(p,q,r):return p+q+r
df2=df1[["a","b"]].apply(add_some, args=(3,2))
print(df2)
0   8  9
1   9  7
2  12  7


          
           
            
             
              
               
                
                 
                  
                   
                    
                     
                      
                      
                       YoungSheldon
                      
                     
                     
                      发布于
                      
                      2022-08-17


          
           
            
             
              
               
                
                 
                  
                   
                    
                     
                      大多数事情在其他答案中都有涉及，我想重复一下你可能遗漏的一件事，你需要
                      
                       加一个逗号
                      
                      在args tuple中的参数之后，见下面的例子。
                     
                     df['some_column'].apply(function_name, args=(arg1 ,) #Here comma is necessary.


          
           
            
             
              
               
                
                 
                  
                   
                    
                     
                      
                       
                       
                        Faisal shahzad
                       
                      
                      
                       发布于
                       
                       2022-08-17


          
           
            
             
              
               
                
                 
                  
                   
                    
                     
                      
                       你只需要在参数后面加上逗号，就可以对整个列表运行函数。下面是一个例子。同样的过程也可以在集合上完成。
                      
                      df = {"name" : [2,3,4,6],
      "age" : [4,10, 30, 20]
print("Before")
df = pd.DataFrame(df)
print(df)
def fun(a, b):
    for c in b:
        a +=c
    return a
[![enter image description here][1]][1]
listt = set([3,4,5])