Bir işlev Panda'nın veri çerçevesinin iki sütununa nasıl uygulanır?

Diyelim ki dfsütunları olan bir tane var 'ID', 'col_1', 'col_2'. Ve bir fonksiyon tanımlarım:

f = lambda x, y : my_function_expression.

Şimdi uygulamak istediğiniz fiçin dfbireyin iki sütun 'col_1', 'col_2'öğeye göre hesapla yeni bir sütun 'col_3'biraz gibi:

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

Nasıl yapılır ?

** Aşağıdaki gibi detay örnek ekleyin ***

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

İşte applyben veriyorum veri çerçevesi üzerinde kullanarak bir örnek axis = 1.

Aradaki fark, işleve iki değer iletmeye çalışmak yerine, fbir pandalar Series nesnesini kabul etmek için işlevi yeniden yazmak ve sonra gerekli değerleri almak için Diziyi dizinlemek olduğunu unutmayın.

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

Kullanım durumunuza bağlı olarak, bazen bir panda groupnesnesi oluşturmak ve sonra applygrup üzerinde kullanmak yararlı olabilir .

Pandalar'da bunu yapmanın temiz, tek satırlı bir yolu var:

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

Bu, fbirden çok giriş değeri olan kullanıcı tanımlı bir işlev olmasını sağlar ve sütunlara erişmek için (güvenli olmayan) sayısal dizinler yerine (güvenli) sütun adları kullanır.

Verilere sahip örnek (orijinal soruya dayanarak):

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)

Çıktı 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]

Sütun adlarınız boşluk içeriyorsa veya mevcut bir veri çerçevesi özniteliğiyle bir ad paylaşıyorsa, köşeli parantezlerle dizinleyebilirsiniz:

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

Basit bir çözüm:

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

İlginç bir soru! cevabım aşağıdaki gibi:

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

Çıktı:

  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]

Ben ID <J1 <J2 <J3 sağlamak için sütun adını ID, J1, J2, J3 olarak değiştirdim, böylece sütun doğru sırayla görüntülenir.

Bir kısa versiyon daha:

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

Aradığınız yöntem Series.combine'dir. Ancak, veri tiplerinin etrafına biraz özen gösterilmesi gerektiği görülmektedir. Örneğinizde, (yanıtı test ederken yaptığım gibi) naif olarak

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

Ancak, bu hatayı atar:

ValueError: setting an array element with a sequence.

En iyi tahminim, sonucun yöntemi çağıran diziyle aynı türden olmasını beklediği gibi görünüyor. Ancak, aşağıdakiler çalışır:

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]

Yazdığınız şekilde iki giriş gerekir. Hata mesajına bakarsanız, f'ye iki giriş sağlamadığınızı söyler, sadece bir tane. Hata mesajı doğrudur.
Uyumsuzluk, df [['col1', 'col2']] 'nin iki ayrı sütun değil, iki sütun içeren tek bir veri çerçevesi döndürmesidir.

F'nizi tek bir giriş alacak şekilde değiştirmeniz, yukarıdaki veri çerçevesini giriş olarak tutmanız, sonra işlev gövdesinin içinde x, y olarak ayırmanız gerekir . Sonra ihtiyacınız olanı yapın ve tek bir değer döndürün.

Sözdizimi .apply (f) olduğu için bu işlev imzasına ihtiyacınız vardır. Bu nedenle f, geçerli f'nizin beklediği iki şeyi değil, tek şey = veri çerçevesi almalıdır.

F gövdesini sağlamadığınız için artık ayrıntılı olarak yardım edemem - ancak bu, kodunuzu temelde değiştirmeden veya uygulamak yerine başka yöntemler kullanmadan çıkış yolu sağlamalıdır.

Np.vectorize için oy vereceğim. Sadece x sütun sayısını aşmanıza ve işlevdeki veri çerçevesiyle uğraşmanıza izin vermez, bu nedenle kontrol etmediğiniz veya bir işleve 2 sütun ve sabit gönderme gibi bir şey (ör. 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]

Bir listenin applydöndürülmesi tehlikeli bir işlemdir, çünkü ortaya çıkan nesnenin Seri veya DataFrame olduğu garanti edilmez. Ve bazı durumlarda istisnalar olabilir. Basit bir örneği inceleyelim:

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

Bir liste döndürerek üç olası sonuç vardır: apply

1) Döndürülen listenin uzunluğu sütun sayısına eşit değilse, bir dizi dizi döndürülür.

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) Döndürülen listenin uzunluğu sütun sayısına eşit olduğunda, bir DataFrame döndürülür ve her sütun listede karşılık gelen değeri alır.

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) Döndürülen listenin uzunluğu ilk satır için sütun sayısına eşitse, ancak listenin bir ValueError öğesinin yükseltildiği sütun sayısından farklı sayıda öğeye sahip olduğu en az bir satıra sahipse.

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)

Sorunu başvurmadan cevaplama

applyEksen = 1 ile kullanmak çok yavaştır. Temel yinelemeli yöntemlerle (özellikle daha büyük veri kümelerinde) daha iyi performans elde etmek mümkündür.

Daha büyük veri çerçevesi oluştur

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

zamanlamalar

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

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

Eminim ki bu, Pandalar veya Numpy işlemlerini kullanan çözümler kadar hızlı değildir, ancak işlevinizi yeniden yazmak istemiyorsanız haritayı kullanabilirsiniz. Orijinal örnek verileri kullanma -

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

Fonksiyona bu şekilde istediğimiz kadar argüman aktarabiliriz. Çıktı istediğimiz şey

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]

Sorularınıza örnek:

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

Çok büyük bir veri kümeniz varsa, bunu daha hızlı ve kolay bir şekilde (yürütme süresi) kullanarak bunu hızlı bir şekilde yapabilirsiniz:

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_sublistFonksiyonu değiştirmek istemediğinizi ve sadece applyişi yapmak için DataFrame'in yöntemini kullanmak istediğinizi varsayalım . İstediğiniz sonucu elde etmek için iki yardım işlevi yazdım: get_sublist_listve unlist. İşlev adından da anlaşılacağı gibi, önce alt listenin listesini alın, ikinci olarak o listeden o listeyi çıkarın. Son olarak, applybu iki işlevi daha sonra df[['col_1','col_2']]DataFrame'e uygulamak için işlevi çağırmamız gerekir .

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

İşlevi []kapsamak için kullanmazsanız , get_sublistişlev get_sublist_listdüz bir liste döndürür ValueError: could not broadcast input array from shape (3) into shape (2), @Ted Petrou'nun belirttiği gibi yükselir.