Cách áp dụng một hàm cho hai cột của khung dữ liệu Pandas

Giả sử tôi có một dfcái có cột 'ID', 'col_1', 'col_2'. Và tôi định nghĩa một hàm:

f = lambda x, y : my_function_expression.

Bây giờ tôi muốn áp dụng fđể df's hai cột 'col_1', 'col_2'để tính toán yếu tố khôn ngoan một cột mới 'col_3', có phần như:

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

Làm thế nào để làm gì?

** Thêm mẫu chi tiết như dưới đây ***

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

Đây là một ví dụ sử dụng applytrên khung dữ liệu mà tôi đang gọi axis = 1.

Lưu ý sự khác biệt là thay vì cố gắng truyền hai giá trị cho hàm f, hãy viết lại hàm để chấp nhận đối tượng Sê-ri gấu trúc, sau đó lập chỉ mục Sê-ri để nhận các giá trị cần thiết.

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

Tùy thuộc vào trường hợp sử dụng của bạn, đôi khi rất hữu ích để tạo một groupđối tượng gấu trúc , và sau đó sử dụng applytrên nhóm.

Có một cách rõ ràng, một dòng để làm điều này trong Pandas:

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

Điều này cho phép flà một hàm do người dùng xác định có nhiều giá trị đầu vào và sử dụng các tên cột (an toàn) thay vì các chỉ số số (không an toàn) để truy cập các cột.

Ví dụ với dữ liệu (dựa trên câu hỏi ban đầu):

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)

Đầu ra của 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]

Nếu tên cột của bạn chứa khoảng trắng hoặc chia sẻ tên với thuộc tính khung dữ liệu hiện có, bạn có thể lập chỉ mục bằng dấu ngoặc vuông:

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

Một giải pháp đơn giản là:

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

Một câu hỏi thú vị! câu trả lời của tôi như dưới đây:

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

Đầu ra:

  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]

Tôi đã thay đổi tên cột thành ID, J1, J2, J3 để đảm bảo ID <J1 <J2 <J3, để cột hiển thị theo đúng trình tự.

Một phiên bản ngắn gọn hơn:

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

Phương pháp bạn đang tìm kiếm là Series.combine. Tuy nhiên, có vẻ như một số chăm sóc phải được thực hiện xung quanh các kiểu dữ liệu. Trong ví dụ của bạn, bạn sẽ (như tôi đã làm khi kiểm tra câu trả lời) gọi một cách ngây thơ

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

Tuy nhiên, điều này ném lỗi:

ValueError: setting an array element with a sequence.

Dự đoán tốt nhất của tôi là dường như hy vọng kết quả sẽ cùng loại với chuỗi gọi phương thức (df.col_1 ở đây). Tuy nhiên, các công việc sau đây:

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]

Cách bạn đã viết f nó cần hai đầu vào. Nếu bạn nhìn vào thông báo lỗi, nó báo rằng bạn không cung cấp hai đầu vào cho f, chỉ một. Thông báo lỗi là chính xác.
Sự không phù hợp là do df [['col1', 'col2']] trả về một khung dữ liệu duy nhất có hai cột, không phải hai cột riêng biệt.

Bạn cần thay đổi f của mình để nó có một đầu vào duy nhất, giữ khung dữ liệu trên làm đầu vào, sau đó chia nó thành x, y bên trong thân hàm. Sau đó làm bất cứ điều gì bạn cần và trả lại một giá trị duy nhất.

Bạn cần chữ ký hàm này vì cú pháp là .apply (f) Vì vậy, f cần lấy điều duy nhất = dataframe chứ không phải hai điều đó là điều mà f hiện tại của bạn mong đợi.

Vì bạn chưa cung cấp phần thân của tôi nên tôi không thể giúp chi tiết nữa - nhưng điều này sẽ cung cấp lối thoát mà không thay đổi cơ bản mã của bạn hoặc sử dụng một số phương pháp khác thay vì áp dụng

Tôi sẽ bỏ phiếu cho np.vectorize. Nó cho phép bạn chỉ bắn qua x số cột và không xử lý khung dữ liệu trong hàm, vì vậy thật tuyệt vời cho các chức năng bạn không kiểm soát hoặc thực hiện một số việc như gửi 2 cột và hằng số vào một hàm (ví dụ: 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]

Trả về danh sách từ applylà một hoạt động nguy hiểm vì đối tượng kết quả không được đảm bảo là Sê-ri hoặc Khung dữ liệu. Và ngoại lệ có thể được nêu ra trong một số trường hợp nhất định. Hãy đi qua một ví dụ đơn giản:

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

Có ba kết quả có thể xảy ra với việc trả về một danh sách từ apply

1) Nếu độ dài của danh sách được trả về không bằng số lượng cột, thì một loạt danh sách được trả về.

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) Khi độ dài của danh sách được trả về bằng số lượng cột thì DataFrame được trả về và mỗi cột nhận giá trị tương ứng trong danh sách.

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) Nếu độ dài của danh sách được trả về bằng số lượng cột cho hàng đầu tiên nhưng có ít nhất một hàng trong đó danh sách có số phần tử khác với số cột mà ValueError được nâng lên.

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)

Trả lời vấn đề mà không áp dụng

Sử dụng applyvới trục = 1 là rất chậm. Có thể có được hiệu suất tốt hơn nhiều (đặc biệt là trên các bộ dữ liệu lớn hơn) với các phương pháp lặp cơ bản.

Tạo khung dữ liệu lớn hơn

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

Thời gian

# 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 trả lời

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

Tôi chắc chắn rằng điều này không nhanh bằng các giải pháp sử dụng các thao tác Pandas hoặc Numpy, nhưng nếu bạn không muốn viết lại chức năng của mình, bạn có thể sử dụng bản đồ. Sử dụng dữ liệu mẫu ban đầu -

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

Chúng ta có thể chuyển nhiều đối số như chúng ta muốn vào hàm theo cách này. Đầu ra là những gì chúng tôi muốn

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]

Ví dụ của tôi cho câu hỏi của bạn:

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

Nếu bạn có một tập dữ liệu khổng lồ, thì bạn có thể sử dụng một cách dễ dàng nhưng nhanh hơn (thời gian thực hiện) để thực hiện việc này bằng cách sử dụng swifter:

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)

Tôi cho rằng bạn không muốn thay đổi get_sublistchức năng và chỉ muốn sử dụng applyphương thức của DataFrame để thực hiện công việc. Để có được kết quả bạn muốn, tôi đã viết hai hàm trợ giúp: get_sublist_listvà unlist. Như tên hàm gợi ý, đầu tiên hãy lấy danh sách danh sách con, trích xuất danh sách phụ đó từ danh sách đó. Cuối cùng, chúng ta cần gọi applyhàm để áp dụng hai hàm đó chodf[['col_1','col_2']] DataFrame sau đó.

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

Nếu bạn không sử dụng []để đóng get_sublisthàm, thì get_sublist_listhàm sẽ trả về một danh sách đơn giản, nó sẽ tăng lên ValueError: could not broadcast input array from shape (3) into shape (2), như @Ted Petrou đã đề cập.