Pandasデータフレームの2つの列に関数を適用する方法

のdf列を持つがあるとします'ID', 'col_1', 'col_2'。そして私は関数を定義します：

f = lambda x, y : my_function_expression。

次に、の2つの列を要素ごとに適用しfて、新しい列を計算します。df'col_1', 'col_2''col_3'

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

実行する方法 ？

** 以下のように詳細サンプルを追加します ***

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']

applyこれは、で呼び出しているデータフレームでの使用例ですaxis = 1。

違いは、関数に2つの値を渡そうとする代わりにf、pandas Seriesオブジェクトを受け入れるように関数を書き直してから、Seriesにインデックスを付けて、必要な値を取得することです。

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

ユースケースによっては、pandas groupオブジェクトを作成applyしてグループで使用すると役立つ場合があります。

パンダでこれを行うためのクリーンな一行の方法があります：

df['col_3'] = df.apply(lambda x: f(x.col_1, x.col_2), axis=1)

これによりf、複数の入力値を持つユーザー定義関数になることができ、（安全でない）数値インデックスではなく（安全な）列名を使用して列にアクセスします。

データの例（元の質問に基づく）：

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)

の出力print(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]

列名にスペースが含まれている場合、または既存のデータフレーム属性と名前を共有している場合は、角括弧でインデックスを作成できます。

df['col_3'] = df.apply(lambda x: f(x['col 1'], x['col 2']), axis=1)

簡単な解決策は次のとおりです。

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

興味深い質問です！以下の私の答え：

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

出力：

  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]

列名をID、J1、J2、J3に変更して、ID <J1 <J2 <J3になるようにし、列が正しい順序で表示されるようにしました。

もう1つの簡単なバージョン：

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

あなたが探しているメソッドはSeries.combineです。ただし、データ型には注意が必要です。あなたの例では、あなたは（答えをテストするときに私がしたように）素朴に呼び出すでしょう

df['col_3'] = df.col_1.combine(df.col_2, func=get_sublist)

ただし、これはエラーをスローします。

ValueError: setting an array element with a sequence.

私の推測では、結果はメソッドを呼び出すシリーズと同じタイプであると予想されているようです（ここではdf.col_1）。ただし、以下は機能します。

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]

あなたが書いた方法は2つの入力を必要とします。エラーメッセージを見ると、fへの入力が2つではなく、1つだけであることがわかります。エラーメッセージは正しいです。
df [['col1'、 'col2']]は、2つの別々の列ではなく、2つの列を持つ単一のデータフレームを返すため、この不一致が生じます。

単一の入力を取得するようにfを変更し、上記のデータフレームを入力として保持し、関数本体内で x、yに分割する必要があります。次に、必要なことをすべて行い、単一の値を返します。

構文が.apply（f）であるため、この関数シグネチャが必要です。したがって、fは、現在のfが期待する2つのものではなく、1つのもの=データフレームを取得する必要があります。

あなたはfの本文を提供していないので、これ以上詳細にはヘルプできません。

np.vectorizeに投票します。これにより、x列だけを撮影し、関数のデータフレームを処理しないことができるため、制御できない関数や、2つの列と定数を関数に送信するような関数（col_1、col_2、 「foo」）。

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]

apply結果のオブジェクトがSeriesまたはDataFrameであることが保証されていないため、リストを返すことは危険な操作です。また、場合によっては例外が発生することもあります。簡単な例を見てみましょう：

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

からリストを返すと、3つの結果が考えられます。 apply

1）返されたリストの長さが列の数と等しくない場合、一連のリストが返されます。

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

2）返されたリストの長さが列の数と等しい場合、DataFrameが返され、各列はリスト内の対応する値を取得します。

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

3）返されたリストの長さが最初の行の列数と等しいが、リストの要素数が列数と異なる行が少なくとも1行ある場合、ValueErrorが発生します。

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)

適用せずに問題に答える

applyaxis = 1での使用は非常に低速です。基本的な反復法を使用すると、パフォーマンスが大幅に向上する可能性があります（特に大きなデータセットの場合）。

より大きなデータフレームを作成する

df1 = df.sample(100000, replace=True).reset_index(drop=True)

タイミング

# 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)

@Thomas回答

%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)

これはPandasまたはNumpyの操作を使用したソリューションほど高速ではないと思いますが、関数を書き直したくない場合は、mapを使用できます。元のサンプルデータの使用-

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

このようにして、関数に必要なだけ引数を渡すことができます。出力は私たちが欲しかったものです

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]

あなたの質問への私の例：

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')

あなたが巨大なデータセットを持っているなら、あなたはswifterを使ってこれを行うための簡単だがより速い（実行時間）方法を使うことができます：

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)

get_sublist関数を変更するのではなく、DataFrameのapplyメソッドを使用してジョブを実行したいと思います。あなたが望む結果を得るために、私は2つのヘルプ関数を書きました：get_sublist_listとunlist。関数名が示すように、最初にサブリストのリストを取得し、次にそのリストからそのサブリストを抽出します。最後に、applyこれら2つの関数をdf[['col_1','col_2']]DataFrame に適用するために関数を呼び出す必要があります。

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

関数[]を囲むために使用しない場合get_sublist、get_sublist_list関数はプレーンリストを返しますValueError: could not broadcast input array from shape (3) into shape (2)。@ Ted Petrouが述べたように、この関数はを発生させます。