Perché la funzione "Applica" dei miei Panda che fa riferimento a più colonne funziona? [chiuso]

Ho alcuni problemi con la funzione di applicazione di Panda, quando utilizzo più colonne con il seguente frame di dati

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

e la seguente funzione

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

Quando provo ad applicare questa funzione con:

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

Ricevo il messaggio di errore:

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

Non capisco questo messaggio, ho definito correttamente il nome.

Apprezzerei molto qualsiasi aiuto su questo problema

Aggiornare

Grazie per l'aiuto. Ho fatto davvero alcuni errori di sintassi con il codice, l'indice dovrebbe essere messo ''. Tuttavia ho ancora lo stesso problema usando una funzione più complessa come:

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

Sembra che tu abbia dimenticato la ''stringa.

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

A proposito, secondo me, il modo seguente è più elegante:

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

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

Se vuoi solo calcolare (colonna a)% (colonna b), non è necessario apply, fallo direttamente:

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

Diciamo che vogliamo applicare una funzione add5 alle colonne 'a' e 'b' di DataFrame df

def add5(x):
    return x+5

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

Tutti i suggerimenti sopra riportati funzionano, ma se desideri che i tuoi calcoli siano più efficienti, dovresti trarre vantaggio dalle operazioni vettoriali intorpidite (come indicato qui) .

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

Esempio 1: looping con pandas.apply():

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

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

La corsa più lenta ha richiesto 7,49 volte di più rispetto alla più veloce. Ciò potrebbe significare che un risultato intermedio viene memorizzato nella cache. 1000 loop, meglio di 3: 481 µs per loop

Esempio 2: vettorializzare usando pandas.apply():

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

La corsa più lenta ha richiesto 458,85 volte di più rispetto alla più veloce. Ciò potrebbe significare che un risultato intermedio viene memorizzato nella cache. 10000 loop, meglio di 3: 70,9 µs per loop

Esempio 3: vettorializzare usando matrici intorpidite:

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

La corsa più lenta ha richiesto 7,98 volte di più rispetto alla più veloce. Ciò potrebbe significare che un risultato intermedio viene memorizzato nella cache. 100000 loop, meglio di 3: 6,39 µs per loop

Quindi la vettorializzazione usando array intorpiditi ha migliorato la velocità di quasi due ordini di grandezza.

Questa è la stessa della soluzione precedente ma ho definito la funzione in df.apply stessa:

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

Ho dato il confronto di tutti e tre discussi sopra.

Utilizzando i valori

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

139 µs ± 1,91 µs per ciclo (media ± deviazione standard di 7 cicli, 10000 loop ciascuno)

Senza valori

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

216 µs ± 1,86 µs per ciclo (media ± deviazione standard di 7 cicli, 1000 loop ciascuno)

Applica la funzione

% timeit df ['Value'] = df.apply (riga lambda: riga ['a']% riga ['c'], asse = 1)

474 µs ± 5,07 µs per loop (media ± deviazione standard di 7 cicli, 1000 loop ciascuno)