ทำไมฟังก์ชั่น 'ใช้' ของนุ่นถึงการอ้างอิงหลายคอลัมน์ทำงานไม่ได้ [ปิด]

ฉันมีปัญหาบางอย่างเกี่ยวกับฟังก์ชั่นการใช้หมีแพนด้าเมื่อใช้หลายคอลัมน์ด้วยดาต้าเฟรมต่อไปนี้

df = DataFrame ({'a' : np.random.randn(6),
                 'b' : ['foo', 'bar'] * 3,
                 'c' : np.random.randn(6)})

และฟังก์ชั่นดังต่อไปนี้

def my_test(a, b):
    return a % b

เมื่อฉันพยายามใช้ฟังก์ชั่นนี้กับ:

df['Value'] = df.apply(lambda row: my_test(row[a], row[c]), axis=1)

ฉันได้รับข้อความแสดงข้อผิดพลาด:

NameError: ("global name 'a' is not defined", u'occurred at index 0')

ฉันไม่เข้าใจข้อความนี้ฉันกำหนดชื่อไว้อย่างถูกต้อง

ฉันขอขอบคุณสำหรับความช่วยเหลือในเรื่องนี้

ปรับปรุง

ขอบคุณสำหรับความช่วยเหลือของคุณ. ฉันทำผิดพลาดทางไวยากรณ์บางอย่างกับรหัสดัชนีควรจะใส่ '' อย่างไรก็ตามฉันยังคงได้รับปัญหาเดียวกันโดยใช้ฟังก์ชั่นที่ซับซ้อนมากขึ้นเช่น:

def my_test(a):
    cum_diff = 0
    for ix in df.index():
        cum_diff = cum_diff + (a - df['a'][ix])
    return cum_diff 

ดูเหมือนว่าคุณลืม''สตริงของคุณ

In [43]: df['Value'] = df.apply(lambda row: my_test(row['a'], row['c']), axis=1)

In [44]: df
Out[44]:
                    a    b         c     Value
          0 -1.674308  foo  0.343801  0.044698
          1 -2.163236  bar -2.046438 -0.116798
          2 -0.199115  foo -0.458050 -0.199115
          3  0.918646  bar -0.007185 -0.001006
          4  1.336830  foo  0.534292  0.268245
          5  0.976844  bar -0.773630 -0.570417

BTW ในความคิดของฉันวิธีต่อไปนี้จะสวยงามมากขึ้น:

In [53]: def my_test2(row):
....:     return row['a'] % row['c']
....:     

In [54]: df['Value'] = df.apply(my_test2, axis=1)

หากคุณต้องการคำนวณ (คอลัมน์ a)% (คอลัมน์ b) คุณไม่จำเป็นต้องapplyทำโดยตรง

In [7]: df['a'] % df['c']                                                                                                                                                        
Out[7]: 
0   -1.132022                                                                                                                                                                    
1   -0.939493                                                                                                                                                                    
2    0.201931                                                                                                                                                                    
3    0.511374                                                                                                                                                                    
4   -0.694647                                                                                                                                                                    
5   -0.023486                                                                                                                                                                    
Name: a

สมมติว่าเราต้องการใช้ฟังก์ชั่น add5 กับคอลัมน์ 'a' และ 'b' ของ DataFrame df

def add5(x):
    return x+5

df[['a', 'b']].apply(add5)

ทุกคำแนะนำข้างต้นการทำงาน แต่ถ้าคุณต้องการการคำนวณของคุณไปโดยมีประสิทธิภาพมากขึ้นคุณควรใช้ประโยชน์ของการดำเนินงานเวกเตอร์ numpy (ตามที่ชี้ให้เห็นที่นี่)

import pandas as pd
import numpy as np


df = pd.DataFrame ({'a' : np.random.randn(6),
             'b' : ['foo', 'bar'] * 3,
             'c' : np.random.randn(6)})

ตัวอย่างที่ 1: วนลูปด้วยpandas.apply():

%%timeit
def my_test2(row):
    return row['a'] % row['c']

df['Value'] = df.apply(my_test2, axis=1)

การวิ่งที่ช้าที่สุดนั้นใช้เวลานานกว่าการวิ่งที่เร็วที่สุดถึง 7.49 เท่า นี่อาจหมายความว่าผลลัพธ์ระหว่างกลางถูกแคช 1,000 ลูปดีที่สุด 3: 481 pers ต่อลูป

ตัวอย่างที่ 2: ใช้ vectorize โดยpandas.apply():

%%timeit
df['a'] % df['c']

การวิ่งที่ช้าที่สุดนั้นใช้เวลานานกว่าการวิ่งที่เร็วที่สุดถึง 458.85 เท่า นี่อาจหมายความว่าผลลัพธ์ระหว่างกลางถูกแคช 10000 ลูปดีที่สุด 3: 70.9 ไมโครกรัมต่อวง

ตัวอย่างที่ 3: vectorize โดยใช้อาร์เรย์ numpy:

%%timeit
df['a'].values % df['c'].values

การวิ่งที่ช้าที่สุดนั้นใช้เวลานานกว่าการวิ่งที่เร็วที่สุด 7.98 เท่า นี่อาจหมายความว่าผลลัพธ์ระหว่างกลางถูกแคช 100,000 ลูป, ดีที่สุดคือ 3: 6.39 pers ต่อลูป

ดังนั้นการใช้เวกเตอร์ด้วย numpy arrays จึงเพิ่มความเร็วได้เกือบสองออเดอร์

นี่เป็นวิธีเดียวกับโซลูชันก่อนหน้า แต่ฉันได้กำหนดฟังก์ชันใน df.apply แล้ว:

df['Value'] = df.apply(lambda row: row['a']%row['c'], axis=1)

ฉันได้ให้การเปรียบเทียบของทั้งสามที่กล่าวถึงข้างต้น

ใช้ค่านิยม

% timeit df ['value'] = df ['a']. ค่า% df ['c']. ค่า

139 ±s± 1.91 µs ต่อลูป (หมายถึง± std. dev จากการวิ่ง 7 ครั้งแต่ละลูป 10,000 ครั้ง)

โดยไม่มีค่า

% timeit df ['value'] = df ['a']% df ['c'] 

216 ±s± 1.86 pers ต่อลูป (หมายถึง± std. dev จากการวิ่ง 7 ครั้งแต่ละลูป 1,000 ครั้ง)

ใช้ฟังก์ชั่น

% timeit df ['Value'] = df.apply (แถวแลมบ์ดา: แถว ['a']% แถว ['c'], แกน = 1)

474 ±s± 5.07 pers ต่อลูป (หมายถึง± std. dev จากการวิ่ง 7 ครั้งแต่ละลูป 1,000 ครั้ง)