So wenden Sie eine Funktion auf zwei Spalten des Pandas-Datenrahmens an

Angenommen, ich habe eine, dfdie Spalten von hat 'ID', 'col_1', 'col_2'. Und ich definiere eine Funktion:

f = lambda x, y : my_function_expression.

Jetzt möchte ich die beiden Spalten von to anwenden f, um eine neue Spalte elementweise zu berechnen , ähnlich wie: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)'

Wie macht man ?

** **. Fügen Sie ein Detailbeispiel wie unten hinzu ***.

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

Hier ist ein Beispiel applyfür den Datenrahmen, mit dem ich anrufe axis = 1.

Beachten Sie, dass der Unterschied darin besteht, anstatt zu versuchen, zwei Werte an die Funktion zu übergeben f, die Funktion neu zu schreiben, um ein Pandas-Serienobjekt zu akzeptieren, und dann die Serie zu indizieren, um die erforderlichen Werte zu erhalten.

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

Abhängig von Ihrem Anwendungsfall ist es manchmal hilfreich, ein Pandas- groupObjekt zu erstellen und es dann applyfür die Gruppe zu verwenden.

In Pandas gibt es eine saubere, einzeilige Methode:

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

Dies erlaubt f eine benutzerdefinierte Funktion mit mehreren Eingabewerten und verwendet (sichere) Spaltennamen anstelle von (unsicheren) numerischen Indizes, um auf die Spalten zuzugreifen.

Beispiel mit Daten (basierend auf der ursprünglichen Frage):

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)

Ausgabe von 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]

Wenn Ihre Spaltennamen Leerzeichen enthalten oder einen Namen mit einem vorhandenen Datenrahmenattribut teilen, können Sie mit eckigen Klammern indizieren:

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

Eine einfache Lösung ist:

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

Eine interessante Frage! meine Antwort wie folgt:

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

Ausgabe:

  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]

Ich habe den Spaltennamen in ID, J1, J2, J3 geändert, um sicherzustellen, dass ID <J1 <J2 <J3 ist, sodass die Spalte in der richtigen Reihenfolge angezeigt wird.

Noch eine kurze Version:

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

Die Methode, nach der Sie suchen, ist Series.combine. Es scheint jedoch, dass bei Datentypen einige Vorsicht geboten ist. In Ihrem Beispiel würden Sie (wie beim Testen der Antwort) naiv anrufen

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

Dies löst jedoch den Fehler aus:

ValueError: setting an array element with a sequence.

Ich vermute, dass das Ergebnis vom selben Typ zu sein scheint wie die Reihe, die die Methode aufruft (df.col_1 hier). Folgendes funktioniert jedoch:

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]

Die Art und Weise, wie Sie geschrieben haben, benötigt zwei Eingänge. Wenn Sie sich die Fehlermeldung ansehen, heißt es, dass Sie nicht zwei Eingänge für f bereitstellen, sondern nur einen. Die Fehlermeldung ist korrekt.
Die Nichtübereinstimmung liegt daran, dass df [['col1', 'col2']] einen einzelnen Datenrahmen mit zwei Spalten und nicht zwei separaten Spalten zurückgibt.

Sie müssen Ihr f so ändern, dass es eine einzelne Eingabe benötigt, den obigen Datenrahmen als Eingabe beibehalten und ihn dann innerhalb des Funktionskörpers in x, y aufteilen . Tun Sie dann alles, was Sie brauchen, und geben Sie einen einzelnen Wert zurück.

Sie benötigen diese Funktionssignatur, da die Syntax .apply (f) lautet. F muss also das einzelne Ding = Datenrahmen und nicht zwei Dinge verwenden, was Ihr aktuelles f erwartet.

Da Sie den Textkörper von f nicht angegeben haben, kann ich nicht mehr im Detail helfen - aber dies sollte den Ausweg bieten, ohne Ihren Code grundlegend zu ändern oder andere Methoden zu verwenden, anstatt ihn anzuwenden

Ich werde für np.vectorize abstimmen. Es ermöglicht Ihnen, nur über x Spalten zu schießen und sich nicht mit dem Datenrahmen in der Funktion zu befassen. Dies ist ideal für Funktionen, die Sie nicht steuern oder beispielsweise 2 Spalten und eine Konstante in eine Funktion senden (z. B. 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]

Das Zurückgeben einer Liste von applyist eine gefährliche Operation, da nicht garantiert wird, dass das resultierende Objekt entweder eine Serie oder ein DataFrame ist. In bestimmten Fällen können Ausnahmen auftreten. Lassen Sie uns ein einfaches Beispiel durchgehen:

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

Es gibt drei mögliche Ergebnisse bei der Rückgabe einer Liste von apply

1) Wenn die Länge der zurückgegebenen Liste nicht der Anzahl der Spalten entspricht, wird eine Reihe von Listen zurückgegeben.

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) Wenn die Länge der zurückgegebenen Liste gleich der Anzahl der Spalten ist, wird ein DataFrame zurückgegeben und jede Spalte erhält den entsprechenden Wert in der Liste.

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) Wenn die Länge der zurückgegebenen Liste der Anzahl der Spalten für die erste Zeile entspricht, jedoch mindestens eine Zeile enthält, in der die Liste eine andere Anzahl von Elementen als die Anzahl der Spalten enthält, wird ein ValueError ausgelöst.

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)

Beantwortung des Problems ohne Anwendung

Die Verwendung applymit Achse = 1 ist sehr langsam. Mit grundlegenden iterativen Methoden ist es möglich, eine viel bessere Leistung (insbesondere bei größeren Datenmengen) zu erzielen.

Erstellen Sie einen größeren Datenrahmen

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

Timings

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

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

Ich bin sicher, dass dies nicht so schnell ist wie die Lösungen, die Pandas- oder Numpy-Operationen verwenden, aber wenn Sie Ihre Funktion nicht neu schreiben möchten, können Sie map verwenden. Verwendung der ursprünglichen Beispieldaten -

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

Auf diese Weise konnten wir so viele Argumente wie wir wollten in die Funktion übergeben. Die Ausgabe ist das, was wir wollten

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]

Mein Beispiel für Ihre Fragen:

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

Wenn Sie über einen großen Datensatz verfügen, können Sie dies mit swifter auf einfache, aber schnellere Weise (Ausführungszeit) tun:

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)

Ich nehme an, Sie möchten die get_sublistFunktion nicht ändern und nur die DataFrame- applyMethode verwenden, um die Aufgabe zu erledigen. Um das gewünschte Ergebnis zu erzielen, habe ich zwei Hilfefunktionen geschrieben: get_sublist_listund unlist. Wie der Funktionsname andeutet, rufen Sie zuerst die Liste der Unterlisten ab und extrahieren Sie dann die Unterliste aus dieser Liste. Schließlich müssen wir die applyFunktion aufrufen , um diese beiden Funktionen anschließend auf den df[['col_1','col_2']]DataFrame anzuwenden.

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

Wenn Sie []die get_sublistFunktion nicht einschließen , gibt die get_sublist_listFunktion eine einfache Liste zurück und wird ValueError: could not broadcast input array from shape (3) into shape (2)ausgelöst, wie @Ted Petrou erwähnt hat.