blocks|key|208316|text|这是一个在数据帧上使用apply的示例，我用axis+=+1调用它。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|208317|请注意，不同之处在于，不是尝试将两个值传递给函数f，而是重写该函数以接受pandas+Series对象，然后对Series进行索引以获取所需的值。|208318|In+[49]:+df
Out[49]:+
++++++++++0+++++++++1
0++1.000000++0.000000
1+-0.494375++0.570994
2++1.000000++0.000000
3++1.876360+-0.229738
4++1.000000++0.000000

In+[50]:+def+f(x):++++
+++....:++return+x[0]+%2B+x[1]++
+++....:++

In+[51]:+df.apply(f,+axis=1)+#passes+a+Series+object,+row-wise
Out[51]:+
0++++1.000000
1++++0.076619
2++++1.000000
3++++1.646622
4++++1.000000|code-block|syntax|javascript|208319|根据您的用例，有时创建一个pandas+group对象，然后在组上使用apply会很有帮助。|208320|entityMap^0|B|5|M|8|0|O|1|0|0|K|5|Z|5|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|Y|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|P|$]]

Here's an example using <code>apply</code> on the dataframe, which I am calling with <code>axis = 1</code>. 

Note the difference is that instead of trying to pass two values to the function <code>f</code>, rewrite the function to accept a pandas Series object, and then index the Series to get the values needed. 

<pre><code>In [49]: df
Out[49]: 
 0 1
0 1.000000 0.000000
1 -0.494375 0.570994
2 1.000000 0.000000
3 1.876360 -0.229738
4 1.000000 0.000000

In [50]: def f(x): 
 ....: return x[0] + x[1] 
 ....: 

In [51]: df.apply(f, axis=1) #passes a Series object, row-wise
Out[51]: 
0 1.000000
1 0.076619
2 1.000000
3 1.646622
4 1.000000
</code></pre>

Depending on your use case, it is sometimes helpful to create a pandas <code>group</code> object, and then use <code>apply</code> on the group.

blocks|key|209877|text|你写的方式需要两个输入。如果您查看错误消息，它会指出您没有为f提供两个输入，只提供了一个输入。错误消息是正确的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|209878|不匹配是因为df['col1'，'col2']返回一个包含两列的单个数据帧，而不是两个单独的列。|209879|你需要改变你的f，让它只接受一个输入，保持上面的数据框作为输入，然后在函数体中把它分解成x，y。然后执行所需的任何操作并返回单个值。|209880|您需要这个函数签名，因为它的语法是.apply(f)，所以f需要接受单个元素=+dataframe，而不是当前的f所期望的两个元素。|209881|由于您没有提供f的主体，所以我不能提供更多细节-但这应该提供了一条出路，而不需要从根本上更改您的代码或使用其他方法，而不是应用|209882|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

The way you have written f it needs two inputs. If you look at the error message it says you are not providing two inputs to f, just one. The error message is correct. 
The mismatch is because df[['col1','col2']] returns a single dataframe with two columns, not two separate columns.

You need to change your f so that it takes a single input, keep the above data frame as input, then break it up into x,y inside the function body. Then do whatever you need and return a single value.

You need this function signature because the syntax is .apply(f)
So f needs to take the single thing = dataframe and not two things which is what your current f expects. 

Since you haven't provided the body of f I can't help in anymore detail - but this should provide the way out without fundamentally changing your code or using some other methods rather than apply

blocks|key|209884|text|您要查找的方法是Series.combine。但是，似乎必须对数据类型进行一些处理。在您的示例中，您将(正如我在测试答案时所做的那样)天真地调用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|209885|df['col_3']+=+df.col_1.combine(df.col_2,+func=get_sublist)|code-block|syntax|javascript|209886|但是，这会抛出错误：|209887|ValueError:+setting+an+array+element+with+a+sequence.|209888|我最好的猜测是，它似乎期望结果与调用该方法的序列具有相同的类型(这里是df.col_1)。但是，以下方法可以正常工作：|209889|df['col_3']+=+df.col_1.astype(object).combine(df.col_2,+func=get_sublist)

df

+++ID+++col_1+++col_2+++col_3
0+++1+++0+++1+++[a,+b]
1+++2+++2+++4+++[c,+d,+e]
2+++3+++3+++5+++[d,+e,+f]|209890|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

The method you are looking for is Series.combine. 
However, it seems some care has to be taken around datatypes. 
In your example, you would (as I did when testing the answer) naively call 

<pre><code>df['col_3'] = df.col_1.combine(df.col_2, func=get_sublist)
</code></pre>

However, this throws the error: 

<pre><code>ValueError: setting an array element with a sequence.
</code></pre>

My best guess is that it seems to expect the result to be of the same type as the series calling the method (df.col_1 here). However, the following works:

<pre><code>df['col_3'] = df.col_1.astype(object).combine(df.col_2, func=get_sublist)

df

 ID col_1 col_2 col_3
0 1 0 1 [a, b]
1 2 2 4 [c, d, e]
2 3 3 5 [d, e, f]
</code></pre>

blocks|key|207796|text|一个有趣的问题！我的回答如下：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|207797|import+pandas+as+pd

def+sublst(row):
++++return+lst[row['J1']:row['J2']]

df+=+pd.DataFrame({'ID':['1','2','3'],+'J1':+[0,2,3],+'J2':[1,4,5]})
print+df
lst+=+['a','b','c','d','e','f']

df['J3']+=+df.apply(sublst,axis=1)
print+df|code-block|syntax|javascript|207798|输出：|207799|++ID++J1++J2
0++1+++0+++1
1++2+++2+++4
2++3+++3+++5
++ID++J1++J2++++++J3
0++1+++0+++1+++++[a]
1++2+++2+++4++[c,+d]
2++3+++3+++5++[d,+e]|207800|我将列名改为ID、J1、J2、J3，以确保ID+<+J1+<+J2+<+J3，这样列就可以按正确的顺序显示。|207801|一个更简短的版本：|207802|import+pandas+as+pd

df+=+pd.DataFrame({'ID':['1','2','3'],+'J1':+[0,2,3],+'J2':[1,4,5]})
print+df
lst+=+['a','b','c','d','e','f']

df['J3']+=+df.apply(lambda+row:lst[row['J1']:row['J2']],axis=1)
print+df|207803|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

A interesting question! my answer as below:

<pre><code>import pandas as pd

def sublst(row):
 return lst[row['J1']:row['J2']]

df = pd.DataFrame({'ID':['1','2','3'], 'J1': [0,2,3], 'J2':[1,4,5]})
print df
lst = ['a','b','c','d','e','f']

df['J3'] = df.apply(sublst,axis=1)
print df
</code></pre>

Output:

<pre><code> ID J1 J2
0 1 0 1
1 2 2 4
2 3 3 5
 ID J1 J2 J3
0 1 0 1 [a]
1 2 2 4 [c, d]
2 3 3 5 [d, e]
</code></pre>

I changed the column name to ID,J1,J2,J3 to ensure ID &lt; J1 &lt; J2 &lt; J3, so the column display in right sequence.

One more brief version:

<pre><code>import pandas as pd

df = pd.DataFrame({'ID':['1','2','3'], 'J1': [0,2,3], 'J2':[1,4,5]})
print df
lst = ['a','b','c','d','e','f']

df['J3'] = df.apply(lambda row:lst[row['J1']:row['J2']],axis=1)
print df
</code></pre>

blocks|key|205591|text|我要投票给np.vectorize。它允许你只处理x列的数量而不处理函数中的数据帧，所以对于你不能控制的函数或者像发送2列和一个常量到一个函数(即col_1，col_2，'foo')这样的事情，它是非常棒的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|205592|import+numpy+as+np
import+pandas+as+pd

df+=+pd.DataFrame({'ID':['1','2','3'],+'col_1':+[0,2,3],+'col_2':[1,4,5]})
mylist+=+['a','b','c','d','e','f']

def+get_sublist(sta,end):
++++return+mylist[sta:end%2B1]

#df['col_3']+=+df[['col_1','col_2']].apply(get_sublist,axis=1)
#+expect+above+to+output+df+as+below+

df.loc[:,'col_3']+=+np.vectorize(get_sublist,+otypes=["O"])+(df['col_1'],+df['col_2'])


df

ID++col_1+++col_2+++col_3
0+++1+++0+++1+++[a,+b]
1+++2+++2+++4+++[c,+d,+e]
2+++3+++3+++5+++[d,+e,+f]|code-block|syntax|javascript|205593|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I'm going to put in a vote for np.vectorize. It allows you to just shoot over x number of columns and not deal with the dataframe in the function, so it's great for functions you don't control or doing something like sending 2 columns and a constant into a function (i.e. col_1, col_2, 'foo').

<pre><code>import numpy as np
import pandas as pd

df = pd.DataFrame({'ID':['1','2','3'], 'col_1': [0,2,3], 'col_2':[1,4,5]})
mylist = ['a','b','c','d','e','f']

def get_sublist(sta,end):
 return mylist[sta:end+1]

#df['col_3'] = df[['col_1','col_2']].apply(get_sublist,axis=1)
# expect above to output df as below 

df.loc[:,'col_3'] = np.vectorize(get_sublist, otypes=["O"]) (df['col_1'], df['col_2'])


df

ID col_1 col_2 col_3
0 1 0 1 [a, b]
1 2 2 4 [c, d, e]
2 3 3 5 [d, e, f]
</code></pre>

blocks|key|205601|text|我敢肯定这没有使用Pandas或Numpy操作的解决方案那么快，但是如果你不想重写你的函数，你可以使用map。使用原始示例数据-|type|unstyled|depth|inlineStyleRanges|entityRanges|data|205602|import+pandas+as+pd

df+=+pd.DataFrame({'ID':['1','2','3'],+'col_1':+[0,2,3],+'col_2':[1,4,5]})
mylist+=+['a','b','c','d','e','f']

def+get_sublist(sta,end):
++++return+mylist[sta:end%2B1]

df['col_3']+=+list(map(get_sublist,df['col_1'],df['col_2']))
#In+Python+2+don't+convert+above+to+list|code-block|syntax|javascript|205603|我们可以通过这种方式向函数传递任意数量的参数。输出结果就是我们想要的|205604|ID++col_1++col_2++++++col_3
0++1++++++0++++++1+++++[a,+b]
1++2++++++2++++++4++[c,+d,+e]
2++3++++++3++++++5++[d,+e,+f]|205605|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I'm sure this isn't as fast as the solutions using Pandas or Numpy operations, but if you don't want to rewrite your function you can use map. Using the original example data -

<pre><code>import pandas as pd

df = pd.DataFrame({'ID':['1','2','3'], 'col_1': [0,2,3], 'col_2':[1,4,5]})
mylist = ['a','b','c','d','e','f']

def get_sublist(sta,end):
 return mylist[sta:end+1]

df['col_3'] = list(map(get_sublist,df['col_1'],df['col_2']))
#In Python 2 don't convert above to list
</code></pre>

We could pass as many arguments as we wanted into the function this way. The output is what we wanted

<pre><code>ID col_1 col_2 col_3
0 1 0 1 [a, b]
1 2 2 4 [c, d, e]
2 3 3 5 [d, e, f]
</code></pre>

blocks|key|208353|text|一个简单的解决方案是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|208354|df['col_3']+=+df[['col_1','col_2']].apply(lambda+x:+f(*x),+axis=1)|code-block|syntax|javascript|208355|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

A simple solution is:

<pre><code>df['col_3'] = df[['col_1','col_2']].apply(lambda x: f(*x), axis=1)
</code></pre>

blocks|key|2845637|text|我举个例子来回答你的问题：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2845638|def+get_sublist(row,+col1,+col2):
++++return+mylist[row[col1]:row[col2]%2B1]
df.apply(get_sublist,+axis=1,+col1='col_1',+col2='col_2')|code-block|syntax|javascript|2845639|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

My example to your questions:

<pre><code>def get_sublist(row, col1, col2):
 return mylist[row[col1]:row[col2]+1]
df.apply(get_sublist, axis=1, col1='col_1', col2='col_2')
</code></pre>

blocks|key|209924|text|从apply返回列表是一个危险的操作，因为不能保证结果对象是Series或DataFrame。在某些情况下可能会引发异常。让我们来看一个简单的例子：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|209925|df+=+pd.DataFrame(data=np.random.randint(0,+5,+(5,3)),
++++++++++++++++++columns=['a',+'b',+'c'])
df
+++a++b++c
0++4++0++0
1++2++0++1
2++2++2++2
3++1++2++2
4++3++0++0|code-block|syntax|javascript|209926|从apply返回列表有三种可能的结果|209927|1)如果返回列表的长度不等于列数，则返回一系列列表。|BOLD|209928|df.apply(lambda+x:+list(range(2)),+axis=1)++#+returns+a+Series
0++++[0,+1]
1++++[0,+1]
2++++[0,+1]
3++++[0,+1]
4++++[0,+1]
dtype:+object|209929|2)当返回列表的长度等于列数时，返回一个DataFrame，每一列都会得到列表中的相应值。|209930|df.apply(lambda+x:+list(range(3)),+axis=1)+#+returns+a+DataFrame
+++a++b++c
0++0++1++2
1++0++1++2
2++0++1++2
3++0++1++2
4++0++1++2|209931|3)如果返回列表的长度等于第一行的列数，但至少有一行的元素数不同于ValueError引发的列数，则返回。|209932|i+=+0
def+f(x):
++++global+i
++++if+i+==+0:
++++++++i+%2B=+1
++++++++return+list(range(3))
++++return+list(range(4))

df.apply(f,+axis=1)+
ValueError:+Shape+of+passed+values+is+(5,+4),+indices+imply+(5,+3)|209933|回答问题时不应用|209934|在axis=1中使用apply非常慢。使用基本的迭代方法可以获得更好的性能(特别是在更大的数据集上)。|209935|创建更大的数据帧|209936|df1+=+df.sample(100000,+replace=True).reset_index(drop=True)|209937|计时|209938|#+apply+is+slow+with+axis=1
%25timeit+df1.apply(lambda+x:+mylist[x['col_1']:+x['col_2']%2B1],+axis=1)
2.59+s+±+76.8+ms+per+loop+(mean+±+std.+dev.+of+7+runs,+1+loop+each)

#+zip+-+similar+to+@Thomas
%25timeit+[mylist[v1:v2%2B1]+for+v1,+v2+in+zip(df1.col_1,+df1.col_2)]++
29.5+ms+±+534+µs+per+loop+(mean+±+std.+dev.+of+7+runs,+10+loops+each)|209939|@Thomas回答|209940|%25timeit+list(map(get_sublist,+df1['col_1'],df1['col_2']))
34+ms+±+459+µs+per+loop+(mean+±+std.+dev.+of+7+runs,+10+loops+each)|209941|entityMap^0|1|5|0|0|1|5|0|0|2|0|0|0|2|0|0|0|1G|0|0|0|A|5|0|0|8|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1H|8|@$9|1I|A|1J|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1K|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1L|8|@$9|1M|A|1N|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|1O|8|@$9|1P|A|1Q|B|O]]|D|@]|E|$]]|$1|P|3|Q|5|H|7|1R|8|@]|D|@]|E|$I|J]]|$1|R|3|S|5|6|7|1S|8|@$9|1T|A|1U|B|O]]|D|@]|E|$]]|$1|T|3|U|5|H|7|1V|8|@]|D|@]|E|$I|J]]|$1|V|3|W|5|6|7|1W|8|@$9|1X|A|1Y|B|O]]|D|@]|E|$]]|$1|X|3|Y|5|H|7|1Z|8|@]|D|@]|E|$I|J]]|$1|Z|3|10|5|6|7|20|8|@]|D|@]|E|$]]|$1|11|3|12|5|6|7|21|8|@$9|22|A|23|B|C]]|D|@]|E|$]]|$1|13|3|14|5|6|7|24|8|@$9|25|A|26|B|O]]|D|@]|E|$]]|$1|15|3|16|5|H|7|27|8|@]|D|@]|E|$I|J]]|$1|17|3|18|5|6|7|28|8|@]|D|@]|E|$]]|$1|19|3|1A|5|H|7|29|8|@]|D|@]|E|$I|J]]|$1|1B|3|1C|5|6|7|2A|8|@]|D|@]|E|$]]|$1|1D|3|1E|5|H|7|2B|8|@]|D|@]|E|$I|J]]|$1|1F|3|-4|5|6|7|2C|8|@]|D|@]|E|$]]]|1G|$]]

Returning a list from <code>apply</code> is a dangerous operation as the resulting object is not guaranteed to be either a Series or a DataFrame. And exceptions might be raised in certain cases. Let's walk through a simple example:

<pre><code>df = pd.DataFrame(data=np.random.randint(0, 5, (5,3)),
 columns=['a', 'b', 'c'])
df
 a b c
0 4 0 0
1 2 0 1
2 2 2 2
3 1 2 2
4 3 0 0
</code></pre>

There are three possible outcomes with returning a list from <code>apply</code>

1) If the length of the returned list is not equal to the number of columns, then a Series of lists is returned.

<pre><code>df.apply(lambda x: list(range(2)), axis=1) # returns a Series
0 [0, 1]
1 [0, 1]
2 [0, 1]
3 [0, 1]
4 [0, 1]
dtype: object
</code></pre>

2) When the length of the returned list is equal to the number of
 columns then a DataFrame is returned and each column gets the
 corresponding value in the list.

<pre><code>df.apply(lambda x: list(range(3)), axis=1) # returns a DataFrame
 a b c
0 0 1 2
1 0 1 2
2 0 1 2
3 0 1 2
4 0 1 2
</code></pre>

3) If the length of the returned list equals the number of columns for the first row but has at least one row where the list has a different number of elements than number of columns a ValueError is raised.

<pre><code>i = 0
def f(x):
 global i
 if i == 0:
 i += 1
 return list(range(3))
 return list(range(4))

df.apply(f, axis=1) 
ValueError: Shape of passed values is (5, 4), indices imply (5, 3)
</code></pre>

<h3>Answering the problem without apply</h3>

Using <code>apply</code> with axis=1 is very slow. It is possible to get much better performance (especially on larger datasets) with basic iterative methods.

Create larger dataframe 

<pre><code>df1 = df.sample(100000, replace=True).reset_index(drop=True)
</code></pre>

<h3>Timings</h3>

<pre><code># apply is slow with axis=1
%timeit df1.apply(lambda x: mylist[x['col_1']: x['col_2']+1], axis=1)
2.59 s ± 76.8 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

# zip - similar to @Thomas
%timeit [mylist[v1:v2+1] for v1, v2 in zip(df1.col_1, df1.col_2)] 
29.5 ms ± 534 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
</code></pre>

@Thomas answer

<pre><code>%timeit list(map(get_sublist, df1['col_1'],df1['col_2']))
34 ms ± 459 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
</code></pre>

blocks|key|208375|text|我想您并不想更改get_sublist函数，而只是想使用DataFrame的apply方法来完成这项工作。为了获得您想要的结果，我编写了两个帮助函数：get_sublist_list和unlist。顾名思义，首先获取子列表列表，然后从该列表中提取该子列表。最后，我们需要调用apply函数，以便随后将这两个函数应用于df[['col_1','col_2']]+DataFrame。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|208376|import+pandas+as+pd

df+=+pd.DataFrame({'ID':['1','2','3'],+'col_1':+[0,2,3],+'col_2':[1,4,5]})
mylist+=+['a','b','c','d','e','f']

def+get_sublist(sta,end):
++++return+mylist[sta:end%2B1]

def+get_sublist_list(cols):
++++return+[get_sublist(cols[0],cols[1])]

def+unlist(list_of_lists):
++++return+list_of_lists[0]

df['col_3']+=+df[['col_1','col_2']].apply(get_sublist_list,axis=1).apply(unlist)

df|code-block|syntax|javascript|208377|如果您不使用[]来封装get_sublist函数，那么get_sublist_list函数将返回一个普通列表，它将引发ValueError:+could+not+broadcast+input+array+from+shape+(3)+into+shape+(2)，正如@Ted+Petrou所提到的。|208378|entityMap^0|8|B|12|5|23|G|2K|6|3T|5|4E|L|0|0|6|2|B|B|R|G|1N|21|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|12|8|@$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|1B|8|@]|D|@]|E|$]]]|N|$]]

I suppose you don't want to change <code>get_sublist</code> function, and just want to use DataFrame's <code>apply</code> method to do the job. To get the result you want, I've wrote two help functions: <code>get_sublist_list</code> and <code>unlist</code>. As the function name suggest, first get the list of sublist, second extract that sublist from that list. Finally, We need to call <code>apply</code> function to apply those two functions to the <code>df[['col_1','col_2']]</code> DataFrame subsequently.

<pre><code>import pandas as pd

df = pd.DataFrame({'ID':['1','2','3'], 'col_1': [0,2,3], 'col_2':[1,4,5]})
mylist = ['a','b','c','d','e','f']

def get_sublist(sta,end):
 return mylist[sta:end+1]

def get_sublist_list(cols):
 return [get_sublist(cols[0],cols[1])]

def unlist(list_of_lists):
 return list_of_lists[0]

df['col_3'] = df[['col_1','col_2']].apply(get_sublist_list,axis=1).apply(unlist)

df
</code></pre>

If you don't use <code>[]</code> to enclose the <code>get_sublist</code> function, then the <code>get_sublist_list</code> function will return a plain list, it'll raise <code>ValueError: could not broadcast input array from shape (3) into shape (2)</code>, as @Ted Petrou had mentioned.

blocks|key|208380|text|在Pandas中有一种简洁的、一行的方式来完成这项工作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|208381|df['col_3']+=+df.apply(lambda+x:+f(x.col_1,+x.col_2),+axis=1)|code-block|syntax|javascript|208382|这允许f成为具有多个输入值的用户定义函数，并使用(安全的)列名而不是(不安全的)数字索引来访问列。|offset|length|style|CODE|208383|带数据的示例(基于原始问题)：|208384|import+pandas+as+pd

df+=+pd.DataFrame({'ID':['1',+'2',+'3'],+'col_1':+[0,+2,+3],+'col_2':[1,+4,+5]})
mylist+=+['a',+'b',+'c',+'d',+'e',+'f']

def+get_sublist(sta,end):
++++return+mylist[sta:end%2B1]

df['col_3']+=+df.apply(lambda+x:+get_sublist(x.col_1,+x.col_2),+axis=1)|208385|print(df)的输出|208386|++ID++col_1++col_2++++++col_3
0++1++++++0++++++1+++++[a,+b]
1++2++++++2++++++4++[c,+d,+e]
2++3++++++3++++++5++[d,+e,+f]|208387|如果您的列名包含空格或与现有的dataframe属性共享一个名称，则可以使用方括号进行索引：|208388|df['col_3']+=+df.apply(lambda+x:+f(x['col+1'],+x['col+2']),+axis=1)|208389|entityMap^0|0|0|3|1|0|0|0|0|9|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@$I|13|J|14|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|16|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|17|8|@$I|18|J|19|K|L]]|9|@]|A|$]]|$1|S|3|T|5|D|7|1A|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1B|8|@]|9|@]|A|$]]|$1|W|3|X|5|D|7|1C|8|@]|9|@]|A|$E|F]]|$1|Y|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|Z|$]]

There is a clean, one-line way of doing this in Pandas:

<pre><code>df['col_3'] = df.apply(lambda x: f(x.col_1, x.col_2), axis=1)
</code></pre>

This allows <code>f</code> to be a user-defined function with multiple input values, and uses (safe) column names rather than (unsafe) numeric indices to access the columns.

Example with data (based on original question):

<pre><code>import pandas as pd

df = pd.DataFrame({'ID':['1', '2', '3'], 'col_1': [0, 2, 3], 'col_2':[1, 4, 5]})
mylist = ['a', 'b', 'c', 'd', 'e', 'f']

def get_sublist(sta,end):
 return mylist[sta:end+1]

df['col_3'] = df.apply(lambda x: get_sublist(x.col_1, x.col_2), axis=1)
</code></pre>

Output of <code>print(df)</code>:

<pre><code> ID col_1 col_2 col_3
0 1 0 1 [a, b]
1 2 2 4 [c, d, e]
2 3 3 5 [d, e, f]
</code></pre>

If your column names contain spaces or share a name with an existing dataframe attribute, you can index with square brackets:

<pre><code>df['col_3'] = df.apply(lambda x: f(x['col 1'], x['col 2']), axis=1)
</code></pre>

blocks|key|2845668|text|如果你有一个庞大的数据集，那么你可以使用一种简单但更快(执行时间)的方式来实现这一点，使用swifter：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2845669|import+pandas+as+pd
import+swifter

def+fnc(m,x,c):
++++return+m*x%2Bc

df+=+pd.DataFrame({"m":+[1,2,3,4,5,6],+"c":+[1,1,1,1,1,1],+"x":[5,3,6,2,6,1]})
df["y"]+=+df.swifter.apply(lambda+x:+fnc(x.m,+x.x,+x.c),+axis=1)|code-block|syntax|javascript|2845670|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you have a huge data-set, then you can use an easy but faster(execution time) way of doing this using swifter: 

<pre><code>import pandas as pd
import swifter

def fnc(m,x,c):
 return m*x+c

df = pd.DataFrame({"m": [1,2,3,4,5,6], "c": [1,1,1,1,1,1], "x":[5,3,6,2,6,1]})
df["y"] = df.swifter.apply(lambda x: fnc(x.m, x.x, x.c), axis=1)
</code></pre>

blocks|key|207841|text|另一种选择是df.itertuples()+(通常更快，docs和user+testing推荐使用df.iterrows()+)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|207842|import+pandas+as+pd

df+=+pd.DataFrame([range(4)+for+_+in+range(4)],+columns=list("abcd"))

df
++++a+++b+++c+++d
0+++0+++1+++2+++3
1+++0+++1+++2+++3
2+++0+++1+++2+++3
3+++0+++1+++2+++3


df["e"]+=+[sum(row)+for+row+in+df[["b",+"d"]].itertuples(index=False)]

df
++++a+++b+++c+++d+++e
0+++0+++1+++2+++3+++4
1+++0+++1+++2+++3+++4
2+++0+++1+++2+++3+++4
3+++0+++1+++2+++3+++4|code-block|syntax|javascript|207843|由于itertuples返回的Iterable为namedtuples，因此您可以通过列名(也称为点符号)和索引将元组元素作为属性进行访问：|207844|b,+d+=+row
b+=+row.b
d+=+row[1]|207845|entityMap|0|LINK|mutability|MUTABLE|url|https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.itertuples.html|1|https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.iterrows.html#pandas.DataFrame.iterrows|2|https://google.com/search?q=pandas%2520iterrow%2520vs%2520itertuples|3|https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.iterrows.html|4|https://docs.python.org/3/library/collections.html#collections.namedtuple^0|6|F|1D|D|6|F|0|S|4|1|X|C|2|1D|D|3|0|0|2|A|F|8|O|A|O|A|4|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@$9|19|A|1A|1|1B]|$9|1C|A|1D|1|1E]|$9|1F|A|1G|1|1H]|$9|1I|A|1J|1|1K]]|E|$]]|$1|F|3|G|5|H|7|1L|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1M|8|@$9|1N|A|1O|B|C]|$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]]|D|@$9|1T|A|1U|1|1V]]|E|$]]|$1|M|3|N|5|H|7|1W|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|1X|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]|W|$5|R|S|T|E|$U|X]]|Y|$5|R|S|T|E|$U|Z]]|10|$5|R|S|T|E|$U|11]]|12|$5|R|S|T|E|$U|13]]]]

Another option is <a href="https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.itertuples.html" rel="nofollow noreferrer"><code>df.itertuples()</code></a> (generally faster and recommended over <a href="https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.iterrows.html" rel="nofollow noreferrer"><code>df.iterrows()</code></a> by <a href="https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.iterrows.html#pandas.DataFrame.iterrows" rel="nofollow noreferrer">docs</a> and <a href="https://google.com/search?q=pandas%20iterrow%20vs%20itertuples" rel="nofollow noreferrer">user testing</a>):
<pre class="lang-py prettyprint-override"><code>import pandas as pd

df = pd.DataFrame([range(4) for _ in range(4)], columns=list(&quot;abcd&quot;))

df
 a b c d
0 0 1 2 3
1 0 1 2 3
2 0 1 2 3
3 0 1 2 3


df[&quot;e&quot;] = [sum(row) for row in df[[&quot;b&quot;, &quot;d&quot;]].itertuples(index=False)]

df
 a b c d e
0 0 1 2 3 4
1 0 1 2 3 4
2 0 1 2 3 4
3 0 1 2 3 4
</code></pre>
Since <code>itertuples</code> returns an <code>Iterable</code> of <a href="https://docs.python.org/3/library/collections.html#collections.namedtuple" rel="nofollow noreferrer"><code>namedtuple</code></a>s, you can access tuple elements both as attributes by column name (aka dot notation) and by index:
<pre class="lang-py prettyprint-override"><code>b, d = row
b = row.b
d = row[1]
</code></pre>

blocks|key|2845693|text|这里有一个更快的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2845694|def+func_1(a,b):
++++return+a+%2B+b

df["C"]+=+func_1(df["A"].to_numpy(),df["B"].to_numpy())|code-block|syntax|javascript|2845695|这比来自@Aman的df.apply(f,+axis=1)快380倍，比来自@ajrwhite的df['col_3']+=+df.apply(lambda+x:+f(x.col_1,+x.col_2),+axis=1)快310倍。|offset|length|style|CODE|2845696|我还添加了一些基准测试：|2845697|结果：|2845698|++FUNCTIONS+++TIMINGS+++GAIN
apply+lambda++++0.7+++++x+1
apply+++++++++++0.56++++x+1.25
map+++++++++++++0.3+++++x+2.3
np.vectorize++++0.01++++x+70
f3+on+Series++++0.0026++x+270
f3+on+np+arrays+0.0018++x+380
f3+numba++++++++0.0018++x+380|2845699|简而言之：|2845700|使用apply的速度很慢。我们可以非常简单地加快速度，只需使用一个直接在Pandas+Series+(或更好的numpy数组)上操作的函数。因为我们将对Pandas+Series或numpy数组进行操作，所以我们将能够对操作进行矢量化。该函数将返回一个Pandas+Series或numpy数组，我们将其指定为新列。|2845701|下面是基准测试代码：|2845702|import+timeit

timeit_setup+=+"""
import+pandas+as+pd
import+numpy+as+np
import+numba

np.random.seed(0)

#+Create+a+DataFrame+of+10000+rows+with+2+columns+"A"+and+"B"+
#+containing+integers+between+0+and+100
df+=+pd.DataFrame(np.random.randint(0,10,size=(10000,+2)),+columns=["A",+"B"])

def+f1(a,b):
++++#+Here+a+and+b+are+the+values+of+column+A+and+B+for+a+specific+row:+integers
++++return+a+%2B+b

def+f2(x):
++++#+Here,+x+is+pandas+Series,+and+corresponds+to+a+specific+row+of+the+DataFrame
++++#+0+and+1+are+the+indexes+of+columns+A+and+B
++++return+x[0]+%2B+x[1]++

def+f3(a,b):
++++#+Same+as+f1+but+we+will+pass+parameters+that+will+allow+vectorization
++++#+Here,+A+and+B+will+be+Pandas+Series+or+numpy+arrays
++++#+with+df["C"]+=+f3(df["A"],df["B"]):+Pandas+Series
++++#+with+df["C"]+=+f3(df["A"].to_numpy(),df["B"].to_numpy()):+numpy+arrays
++++return+a+%2B+b

@numba.njit('int64[:](int64[:],+int64[:])')
def+f3_numba_vectorize(a,b):
++++#+Here+a+and+b+are+2+numpy+arrays+with+dtype+int64
++++#+This+function+must+return+a+numpy+array+whith+dtype+int64
++++return+a+%2B+b

"""

test_functions+=+[
'df["C"]+=+df.apply(lambda+row:+f1(row["A"],+row["B"]),+axis=1)',
'df["C"]+=+df.apply(f2,+axis=1)',
'df["C"]+=+list(map(f3,df["A"],df["B"]))',
'df["C"]+=+np.vectorize(f3)+(df["A"].to_numpy(),df["B"].to_numpy())',
'df["C"]+=+f3(df["A"],df["B"])',
'df["C"]+=+f3(df["A"].to_numpy(),df["B"].to_numpy())',
'df["C"]+=+f3_numba_vectorize(df["A"].to_numpy(),df["B"].to_numpy())'
]


for+test_function+in+test_functions:
++++print(min(timeit.repeat(setup=timeit_setup,+stmt=test_function,+repeat=7,+number=10)))|2845703|输出：|BOLD|2845704|0.7
0.56
0.3
0.01
0.0026
0.0018
0.0018|2845705|最后注意:使用Cython和其他numba技巧也可以优化事情。|2845706|entityMap^0|0|0|A|J|1C|1P|0|0|0|0|0|0|0|0|0|3|0|0|0^^$0|@$1|2|3|4|5|6|7|19|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1A|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1B|8|@$I|1C|J|1D|K|L]|$I|1E|J|1F|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|1G|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1H|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|1I|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|1J|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1K|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1L|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|1M|8|@]|9|@]|A|$E|F]]|$1|10|3|11|5|6|7|1N|8|@$I|1O|J|1P|K|12]]|9|@]|A|$]]|$1|13|3|14|5|D|7|1Q|8|@]|9|@]|A|$E|F]]|$1|15|3|16|5|6|7|1R|8|@]|9|@]|A|$]]|$1|17|3|-4|5|6|7|1S|8|@]|9|@]|A|$]]]|18|$]]

Here is a faster solution:
<pre><code>def func_1(a,b):
 return a + b

df[&quot;C&quot;] = func_1(df[&quot;A&quot;].to_numpy(),df[&quot;B&quot;].to_numpy())
</code></pre>
This is 380 times faster than <code>df.apply(f, axis=1)</code> from @Aman and 310 times faster than <code>df['col_3'] = df.apply(lambda x: f(x.col_1, x.col_2), axis=1)</code> from @ajrwhite.
I add some benchmarks too:
Results:
<pre><code> FUNCTIONS TIMINGS GAIN
apply lambda 0.7 x 1
apply 0.56 x 1.25
map 0.3 x 2.3
np.vectorize 0.01 x 70
f3 on Series 0.0026 x 270
f3 on np arrays 0.0018 x 380
f3 numba 0.0018 x 380
</code></pre>
In short:
Using apply is slow. We can speed up thing very simply, just by using a function that will operate directly on Pandas Series (or better on numpy arrays). And because we will operate on Pandas Series or numpy arrays, we will be able to vectorize the operations. The function will return a Pandas Series or numpy array that we will assign as an new column.
And here is the benchmark code:
<pre><code>import timeit

timeit_setup = &quot;&quot;&quot;
import pandas as pd
import numpy as np
import numba

np.random.seed(0)

# Create a DataFrame of 10000 rows with 2 columns &quot;A&quot; and &quot;B&quot; 
# containing integers between 0 and 100
df = pd.DataFrame(np.random.randint(0,10,size=(10000, 2)), columns=[&quot;A&quot;, &quot;B&quot;])

def f1(a,b):
 # Here a and b are the values of column A and B for a specific row: integers
 return a + b

def f2(x):
 # Here, x is pandas Series, and corresponds to a specific row of the DataFrame
 # 0 and 1 are the indexes of columns A and B
 return x[0] + x[1] 

def f3(a,b):
 # Same as f1 but we will pass parameters that will allow vectorization
 # Here, A and B will be Pandas Series or numpy arrays
 # with df[&quot;C&quot;] = f3(df[&quot;A&quot;],df[&quot;B&quot;]): Pandas Series
 # with df[&quot;C&quot;] = f3(df[&quot;A&quot;].to_numpy(),df[&quot;B&quot;].to_numpy()): numpy arrays
 return a + b

@numba.njit('int64[:](int64[:], int64[:])')
def f3_numba_vectorize(a,b):
 # Here a and b are 2 numpy arrays with dtype int64
 # This function must return a numpy array whith dtype int64
 return a + b

&quot;&quot;&quot;

test_functions = [
'df[&quot;C&quot;] = df.apply(lambda row: f1(row[&quot;A&quot;], row[&quot;B&quot;]), axis=1)',
'df[&quot;C&quot;] = df.apply(f2, axis=1)',
'df[&quot;C&quot;] = list(map(f3,df[&quot;A&quot;],df[&quot;B&quot;]))',
'df[&quot;C&quot;] = np.vectorize(f3) (df[&quot;A&quot;].to_numpy(),df[&quot;B&quot;].to_numpy())',
'df[&quot;C&quot;] = f3(df[&quot;A&quot;],df[&quot;B&quot;])',
'df[&quot;C&quot;] = f3(df[&quot;A&quot;].to_numpy(),df[&quot;B&quot;].to_numpy())',
'df[&quot;C&quot;] = f3_numba_vectorize(df[&quot;A&quot;].to_numpy(),df[&quot;B&quot;].to_numpy())'
]


for test_function in test_functions:
 print(min(timeit.repeat(setup=timeit_setup, stmt=test_function, repeat=7, number=10)))
</code></pre>
Output:
<pre><code>0.7
0.56
0.3
0.01
0.0026
0.0018
0.0018
</code></pre>
Final note: things could be optimzed with Cython and other numba tricks too.

Suppose I have a <code>df</code> which has columns of <code>'ID', 'col_1', 'col_2'</code>. And I define a function :

<code>f = lambda x, y : my_function_expression</code>.

Now I want to apply the <code>f</code> to <code>df</code>'s two columns <code>'col_1', 'col_2'</code> to element-wise calculate a new column <code>'col_3'</code> , somewhat like :

<pre><code>df['col_3'] = df[['col_1','col_2']].apply(f) 
# Pandas gives : TypeError: ('&lt;lambda&gt;() takes exactly 2 arguments (1 given)'
</code></pre>

How to do ?

** Add detail sample as below ***

<pre><code>import pandas as pd

df = pd.DataFrame({'ID':['1','2','3'], 'col_1': [0,2,3], 'col_2':[1,4,5]})
mylist = ['a','b','c','d','e','f']

def get_sublist(sta,end):
 return mylist[sta:end+1]

#df['col_3'] = df[['col_1','col_2']].apply(get_sublist,axis=1)
# expect above to output df as below 

 ID col_1 col_2 col_3
0 1 0 1 ['a', 'b']
1 2 2 4 ['c', 'd', 'e']
2 3 3 5 ['d', 'e', 'f']
</code></pre>

How to apply a function to two columns of Pandas dataframe

Python

假设我有一个包含'ID', 'col_1', 'col_2'列的df。我定义了一个函数：f = lambda x, y : my_function_expression。现在，我想将f应用于df的两个列'col_1', 'col_2'，以逐个元素地计算一个新列'col_3'，类似于：df['col_3'] = df[[...

问如何将函数应用于两列Pandas数据帧
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何将函数应用于两列Pandas数据帧EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何将函数应用于两列Pandas数据帧
EN