Pandalarım neden birden çok sütuna başvuruda bulunan 'uygula' işlevi çalışmıyor? [kapalı]

Aşağıdaki dataframe ile birden çok sütun kullanırken, Pandalar uygulama işleviyle ilgili bazı sorunlar var

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

ve aşağıdaki fonksiyon

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

Bu işlevi ile uygulamaya çalıştığınızda:

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

Hata mesajını alıyorum:

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

Bu mesajı anlamıyorum, adı doğru tanımladım.

Bu konuda herhangi bir yardım için çok minnettar olurum

Güncelleme

Yardımınız için teşekkürler. Gerçekten kod ile bazı sözdizimi hataları yaptım, dizin koymak gerekir ''. Ancak yine de aynı sorunu daha karmaşık bir işlevi kullanarak alıyorum:

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

Dizeni unuttun ''.

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, bence, aşağıdaki şekilde daha zarif:

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

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

Yalnızca (sütun a)% (sütun b) 'yi hesaplamak istiyorsanız, ihtiyacınız applyyoktur, doğrudan yapın:

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

Diyelim ki DataFrame df'nin 'a' ve 'b' sütunlarına add5 fonksiyonunu uygulamak istiyoruz

def add5(x):
    return x+5

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

Yukarıdaki tüm öneriler işe yarıyor, ancak hesaplamalarınızın daha verimli olmasını istiyorsanız, (burada belirtildiği gibi) numpy vektör işlemlerinden yararlanmalısınız .

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

Örnek 1: İle döngü pandas.apply():

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

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

En yavaş koşu en hızlıdan 7,49 kat daha uzun sürdü. Bu, ara sonucun önbelleğe alındığı anlamına gelebilir. 1000 döngü, döngü başına en iyi 3: 481 µs

Örnek 2: Şunları kullanarak vektörleştirin pandas.apply():

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

En yavaş koşu en hızlıdan 458.85 kat daha uzun sürdü. Bu, ara sonucun önbelleğe alındığı anlamına gelebilir. 10000 döngü, en iyi 3: döngü başına 70,9 µs

Örnek 3: Numpy dizileri kullanarak vektörleştirin:

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

En yavaş koşu en hızlı koşunun 7.98 kat daha uzun sürdü. Bu, ara sonucun önbelleğe alındığı anlamına gelebilir. 100000 döngü, en iyisi 3: döngü başına 6,39 µs

Bu nedenle, numpy dizileri kullanarak vektörleştirme hızı neredeyse iki büyüklük düzeyinde geliştirdi.

Bu önceki çözüm ile aynıdır, ancak df.apply kendisi işlevi tanımladım:

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

Yukarıda tartışılan üçünün de karşılaştırmasını verdim.

Değerleri kullanma

% timeit df ['değer'] = df ['a']. değerler% df ['c']. değerler

Her döngü için 139 µs ± 1.91 µs (ortalama 7 std. ± 7 çalışma, her biri 10000 döngü)

Değerler olmadan

% timeit df ['değer'] = df ['a']% df ['c'] 

Loop başına 216 µs ± 1.86 µs (ortalama 7 std dev., Her biri 1000 loop)

Uygula işlevi

% timeit df ['Değer'] = df.apply (lambda satırı: satır ['a']% satır ['c'], eksen = 1)

Döngü başına 474 µs ± 5.07 µs (ortalama 7 std dev., Her biri 1000 döngü)