Xem bây giờ hướng dẫn này có một khóa học video liên quan được tạo bởi nhóm Python thực sự. Xem nó cùng với hướng dẫn bằng văn bản để hiểu sâu hơn về sự hiểu biết của bạn: Cách sử dụng các chức năng của Python Lambda This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: How to Use Python Lambda Functions
Python và các ngôn ngữ khác như Java, C#và thậm chí C ++ đã có các hàm Lambda được thêm vào cú pháp của chúng, trong khi các ngôn ngữ như Lisp hoặc họ ngôn ngữ ML, Haskell, OCAML và F#, sử dụng Lambdas làm khái niệm cốt lõi.
Python Lambdas là rất ít, các hàm ẩn danh, chịu một cú pháp hạn chế hơn nhưng ngắn gọn hơn so với các hàm trăn thông thường.
Đến cuối bài viết này, bạn sẽ biết:
- Python Lambdas đã trở thành như thế nào
- Cách lambdas so sánh với các đối tượng chức năng chính quy
- Cách viết các chức năng Lambda
- Chức năng nào trong Thư viện tiêu chuẩn Python Tận dụng Lambdas
- Khi nào nên sử dụng hoặc tránh các chức năng của Python Lambda
Hướng dẫn này chủ yếu dành cho các lập trình viên Python trung bình đến có kinh nghiệm, nhưng nó có thể truy cập được cho bất kỳ tâm trí tò mò nào với sự quan tâm đến lập trình và tính toán Lambda.
Tất cả các ví dụ bao gồm trong hướng dẫn này đã được thử nghiệm với Python 3.7.
Tính toán Lambda
Các biểu thức Lambda trong Python và các ngôn ngữ lập trình khác có nguồn gốc từ Lambda Tính toán, một mô hình tính toán được phát minh bởi Alonzo Church. Bạn sẽ phát hiện ra khi tính toán Lambda được giới thiệu và tại sao nó lại là một khái niệm cơ bản kết thúc trong hệ sinh thái Python.
Lịch sử
Nhà thờ Alonzo chính thức hóa Tính toán Lambda, một ngôn ngữ dựa trên sự trừu tượng thuần túy, vào những năm 1930. Các chức năng của Lambda cũng được gọi là Trừu tượng Lambda, một tài liệu tham khảo trực tiếp đến mô hình trừu tượng của sáng tạo ban đầu của Alonzo Church.
Tính toán Lambda có thể mã hóa bất kỳ tính toán nào. Nó hoàn thành, nhưng trái với khái niệm về một cỗ máy Turing, nó là tinh khiết và không giữ bất kỳ trạng thái nào.
Các ngôn ngữ chức năng có nguồn gốc từ logic toán học và tính toán Lambda, trong khi các ngôn ngữ lập trình bắt buộc nắm lấy mô hình tính toán dựa trên trạng thái được phát minh bởi Alan Turing. Hai mô hình tính toán, máy tính Lambda và máy Turing, có thể được dịch sang nhau. Sự tương đương này được gọi là giả thuyết của nhà thờ.
Các ngôn ngữ chức năng trực tiếp thừa hưởng triết lý tính toán Lambda, áp dụng một cách tiếp cận tuyên bố của lập trình nhấn mạnh sự trừu tượng, chuyển đổi dữ liệu, thành phần và độ tinh khiết [không có trạng thái và không có tác dụng phụ]. Ví dụ về các ngôn ngữ chức năng bao gồm Haskell, Lisp hoặc Erlang.
Ngược lại, máy Turing đã dẫn đến lập trình bắt buộc được tìm thấy bằng các ngôn ngữ như Fortran, C hoặc Python.
Phong cách bắt buộc bao gồm lập trình với các tuyên bố, thúc đẩy luồng của chương trình từng bước với các hướng dẫn chi tiết. Cách tiếp cận này thúc đẩy đột biến và yêu cầu quản lý trạng thái.
Sự tách biệt trong cả hai gia đình trình bày một số sắc thái, vì một số ngôn ngữ chức năng kết hợp các tính năng bắt buộc, như OCAML, trong khi các đặc điểm chức năng đã thấm vào gia đình ngôn ngữ bắt buộc nói riêng với việc giới thiệu các hàm Lambda trong Java hoặc Python.
Python vốn không phải là ngôn ngữ chức năng, nhưng nó đã áp dụng một số khái niệm chức năng từ rất sớm. Vào tháng 1 năm 1994,
>>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
9, >>> lambda x, y: x + y
0, >>> lambda x, y: x + y
1 và toán tử >>> lambda x, y: x + y
2 đã được thêm vào ngôn ngữ.Ví dụ đầu tiên
Dưới đây là một vài ví dụ để cung cấp cho bạn sự thèm ăn cho một số mã python, kiểu chức năng.
Hàm nhận dạng, một hàm trả về đối số của nó, được biểu thị bằng định nghĩa hàm Python tiêu chuẩn bằng cách sử dụng từ khóa
>>> lambda x, y: x + y
3 như sau:>>>
>>> def identity[x]:
... return x
>>> lambda x, y: x + y
4 lấy một đối số >>> lambda x, y: x + y
5 và trả lại khi gọi.Ngược lại, nếu bạn sử dụng cấu trúc Python Lambda, bạn sẽ nhận được những điều sau:
Trong ví dụ trên, biểu thức bao gồm:
- Từ khóa:
2>>> lambda x, y: x + y
2>>> lambda x, y: x + y
- Một biến ràng buộc:
5>>> lambda x, y: x + y
5>>> lambda x, y: x + y
- Một cơ thể:
5>>> lambda x, y: x + y
5>>> lambda x, y: x + y
Bạn có thể viết một ví dụ được xây dựng hơn một chút, một hàm thêm
>>> lambda x, y: x + y
9 vào một đối số, như sau:Bạn có thể áp dụng chức năng ở trên cho một đối số bằng cách xung quanh hàm và đối số của nó với dấu ngoặc đơn:
>>>
>>> [lambda x: x + 1][2]
3
>>> lambda x, y: x + y
4 lấy một đối số >>> lambda x, y: x + y
5 và trả lại khi gọi.[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
Ngược lại, nếu bạn sử dụng cấu trúc Python Lambda, bạn sẽ nhận được những điều sau:
>>>
>>> add_one = lambda x: x + 1
>>> add_one[2]
3
>>> lambda x, y: x + y
4 lấy một đối số >>> lambda x, y: x + y
5 và trả lại khi gọi.def add_one[x]:
return x + 1
Ngược lại, nếu bạn sử dụng cấu trúc Python Lambda, bạn sẽ nhận được những điều sau:
>>>
>>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
Hàm Lambda được gán cho
>>> [lambda x, y: x + y][2, 3]
5
3 lấy hai đối số và trả về một chuỗi nội suy hai tham số >>> [lambda x, y: x + y][2, 3]
5
4 và >>> [lambda x, y: x + y][2, 3]
5
5. Đúng như dự đoán, định nghĩa của Lambda liệt kê các đối số không có dấu ngoặc đơn, trong khi việc gọi hàm được thực hiện giống hệt như hàm Python bình thường, với dấu ngoặc đơn xung quanh các đối số.Chức năng ẩn danh
Các thuật ngữ sau đây có thể được sử dụng thay thế cho nhau tùy thuộc vào loại ngôn ngữ lập trình và văn hóa:
- Chức năng ẩn danh
- Chức năng Lambda
- Biểu thức Lambda
- Lambda trừu tượng
- Hình thức Lambda
- Chức năng nghĩa đen
Đối với phần còn lại của bài viết này sau phần này, bạn sẽ thấy thuật ngữ chức năng Lambda.lambda function.
Theo nghĩa đen, một hàm ẩn danh là một hàm không có tên. Trong Python, một hàm ẩn danh được tạo bằng từ khóa
>>> lambda x, y: x + y
2. Một cách lỏng lẻo hơn, nó có thể hoặc không được gán một tên. Hãy xem xét một hàm ẩn danh hai đối tượng được xác định với >>> lambda x, y: x + y
2 nhưng không bị ràng buộc với một biến. Lambda không được đặt tên:>>>
>>> lambda x, y: x + y
Hàm ở trên xác định một biểu thức Lambda có hai đối số và trả về tổng của chúng.
Khác với việc cung cấp cho bạn phản hồi rằng Python hoàn toàn ổn với hình thức này, nó không dẫn đến bất kỳ việc sử dụng thực tế nào. Bạn có thể gọi chức năng trong trình thông dịch Python:
Ví dụ trên là tận dụng tính năng chỉ dành cho trình thông dịch tương tác được cung cấp thông qua dấu gạch dưới [
>>> [lambda x, y: x + y][2, 3]
5
8]. Xem ghi chú dưới đây để biết thêm chi tiết.Bạn không thể viết mã tương tự trong mô -đun Python. Hãy xem xét
>>> [lambda x, y: x + y][2, 3]
5
8 trong phiên dịch viên là một tác dụng phụ mà bạn đã tận dụng. Trong một mô -đun Python, bạn sẽ gán một tên cho Lambda hoặc bạn sẽ chuyển Lambda cho một chức năng. Bạn sẽ sử dụng hai cách tiếp cận đó sau trong bài viết này.Một mẫu khác được sử dụng trong các ngôn ngữ khác như JavaScript là ngay lập tức thực hiện hàm Python Lambda. Điều này được gọi là một biểu thức chức năng được gọi ngay lập tức [iife, phát âm là iff iffy]. Đây là một ví dụ:Immediately Invoked Function Expression [IIFE, pronounce “iffy”]. Here’s an example:
>>>
>>> [lambda x, y: x + y][2, 3]
5
Hàm Lambda ở trên được xác định và sau đó được gọi ngay lập tức với hai đối số [
>>> [lambda x, y: x + y][2, 3]
5
1 và >>> high_ord_func = lambda x, func: x + func[x]
>>> high_ord_func[2, lambda x: x * x]
6
>>> high_ord_func[2, lambda x: x + 3]
7
1]. Nó trả về giá trị >>> high_ord_func = lambda x, func: x + func[x]
>>> high_ord_func[2, lambda x: x * x]
6
>>> high_ord_func[2, lambda x: x + 3]
7
2, là tổng của các đối số.Một số ví dụ trong hướng dẫn này sử dụng định dạng này để làm nổi bật khía cạnh ẩn danh của hàm Lambda và tránh tập trung vào
>>> lambda x, y: x + y
2 trong Python như một cách ngắn hơn để xác định hàm.Python không khuyến khích sử dụng các biểu thức Lambda được gọi ngay lập tức. Nó chỉ đơn giản là kết quả từ một biểu thức lambda có thể gọi được, không giống như cơ thể của một chức năng bình thường.
Các hàm Lambda thường được sử dụng với các hàm bậc cao hơn, lấy một hoặc nhiều hàm làm đối số hoặc trả về một hoặc nhiều hàm.
Hàm Lambda có thể là hàm bậc cao hơn bằng cách lấy hàm [bình thường hoặc lambda] như một đối số như trong ví dụ sau:
>>>
>>> high_ord_func = lambda x, func: x + func[x]
>>> high_ord_func[2, lambda x: x * x]
6
>>> high_ord_func[2, lambda x: x + 3]
7
Python phơi bày các hàm bậc cao hơn là các hàm tích hợp hoặc trong thư viện tiêu chuẩn. Các ví dụ bao gồm
>>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
9, >>> lambda x, y: x + y
0, >>> high_ord_func = lambda x, func: x + func[x]
>>> high_ord_func[2, lambda x: x * x]
6
>>> high_ord_func[2, lambda x: x + 3]
7
6, cũng như các chức năng chính như >>> high_ord_func = lambda x, func: x + func[x]
>>> high_ord_func[2, lambda x: x * x]
6
>>> high_ord_func[2, lambda x: x + 3]
7
7, >>> high_ord_func = lambda x, func: x + func[x]
>>> high_ord_func[2, lambda x: x * x]
6
>>> high_ord_func[2, lambda x: x + 3]
7
8, >>> high_ord_func = lambda x, func: x + func[x]
>>> high_ord_func[2, lambda x: x * x]
6
>>> high_ord_func[2, lambda x: x + 3]
7
9 và >>> import dis
>>> add = lambda x, y: x + y
>>> type[add]
>>> dis.dis[add]
1 0 LOAD_FAST 0 [x]
2 LOAD_FAST 1 [y]
4 BINARY_ADD
6 RETURN_VALUE
>>> add
0. Bạn sẽ sử dụng các hàm Lambda cùng với các hàm bậc cao của Python trong việc sử dụng các biểu thức Lambda thích hợp.Python Lambda và các chức năng thường xuyên
Trích dẫn này từ Câu hỏi thường gặp về thiết kế và lịch sử Python dường như tạo nên giai điệu về kỳ vọng chung liên quan đến việc sử dụng các chức năng Lambda trong Python:
Không giống như các hình thức Lambda trong các ngôn ngữ khác, nơi chúng thêm chức năng, Python Lambdas chỉ là một ký hiệu tốc ký nếu bạn quá lười biếng để xác định một hàm. [Nguồn]
Tuy nhiên, don lồng cho phép tuyên bố này ngăn bạn sử dụng Python từ
>>> lambda x, y: x + y
2. Thoạt nhìn, bạn có thể chấp nhận rằng hàm Lambda là một hàm với một số đường cú pháp rút ngắn mã để xác định hoặc gọi một hàm. Các phần sau đây nêu bật sự tương đồng và sự khác biệt tinh tế giữa các hàm Python bình thường và các hàm Lambda.Chức năng
Tại thời điểm này, bạn có thể tự hỏi điều gì về cơ bản phân biệt hàm Lambda bị ràng buộc với một biến từ một hàm chính quy với một dòng
>>> import dis
>>> add = lambda x, y: x + y
>>> type[add]
>>> dis.dis[add]
1 0 LOAD_FAST 0 [x]
2 LOAD_FAST 1 [y]
4 BINARY_ADD
6 RETURN_VALUE
>>> add
2: dưới bề mặt, hầu như không có gì. Hãy để xác minh cách Python nhìn thấy một hàm được xây dựng với một câu lệnh trả về duy nhất so với một hàm được xây dựng dưới dạng biểu thức [>>> lambda x, y: x + y
2].Mô -đun
>>> import dis
>>> add = lambda x, y: x + y
>>> type[add]
>>> dis.dis[add]
1 0 LOAD_FAST 0 [x]
2 LOAD_FAST 1 [y]
4 BINARY_ADD
6 RETURN_VALUE
>>> add
4 hiển thị các chức năng để phân tích mã byte Python được tạo bởi trình biên dịch Python:>>>
>>> import dis
>>> add = lambda x, y: x + y
>>> type[add]
>>> dis.dis[add]
1 0 LOAD_FAST 0 [x]
2 LOAD_FAST 1 [y]
4 BINARY_ADD
6 RETURN_VALUE
>>> add
Bạn có thể thấy rằng
>>> import dis
>>> add = lambda x, y: x + y
>>> type[add]
>>> dis.dis[add]
1 0 LOAD_FAST 0 [x]
2 LOAD_FAST 1 [y]
4 BINARY_ADD
6 RETURN_VALUE
>>> add
5 hiển thị một phiên bản có thể đọc được của mã byte Python cho phép kiểm tra các hướng dẫn cấp thấp mà trình thông dịch Python sẽ sử dụng trong khi thực hiện chương trình.Bây giờ hãy xem nó với một đối tượng chức năng thông thường:
>>>
>>> [lambda x: x + 1][2]
3
0Mã byte được giải thích bởi Python là giống nhau cho cả hai chức năng. Nhưng bạn có thể nhận thấy rằng việc đặt tên là khác nhau: tên hàm là
>>> import dis
>>> add = lambda x, y: x + y
>>> type[add]
>>> dis.dis[add]
1 0 LOAD_FAST 0 [x]
2 LOAD_FAST 1 [y]
4 BINARY_ADD
6 RETURN_VALUE
>>> add
6 cho một hàm được xác định bằng >>> lambda x, y: x + y
3, trong khi hàm Python Lambda được xem là >>> lambda x, y: x + y
2.Tìm lại
Bạn đã thấy trong phần trước rằng, trong bối cảnh của hàm Lambda, Python không cung cấp tên của hàm, mà chỉ
>>> import dis
>>> add = lambda x, y: x + y
>>> type[add]
>>> dis.dis[add]
1 0 LOAD_FAST 0 [x]
2 LOAD_FAST 1 [y]
4 BINARY_ADD
6 RETURN_VALUE
>>> add
9. Đây có thể là một hạn chế để xem xét khi một ngoại lệ xảy ra và một dấu vết chỉ hiển thị >>> import dis
>>> add = lambda x, y: x + y
>>> type[add]
>>> dis.dis[add]
1 0 LOAD_FAST 0 [x]
2 LOAD_FAST 1 [y]
4 BINARY_ADD
6 RETURN_VALUE
>>> add
9:>>>
>>> [lambda x: x + 1][2]
3
1TraceBack của một ngoại lệ được nêu ra trong khi hàm Lambda được thực thi chỉ xác định hàm gây ra ngoại lệ là
>>> import dis
>>> add = lambda x, y: x + y
>>> type[add]
>>> dis.dis[add]
1 0 LOAD_FAST 0 [x]
2 LOAD_FAST 1 [y]
4 BINARY_ADD
6 RETURN_VALUE
>>> add
9.Ở đây, một ngoại lệ tương tự được nâng lên bởi một chức năng bình thường:
>>>
>>> [lambda x: x + 1][2]
3
2Hàm bình thường gây ra lỗi tương tự nhưng dẫn đến một dấu vết chính xác hơn vì nó cho tên hàm,
>>> [lambda x: x + 1][2]
3
02.Cú pháp
Như bạn đã thấy trong các phần trước, một biểu mẫu lambda thể hiện sự phân biệt cú pháp từ một hàm bình thường. Cụ thể, một hàm Lambda có các đặc điểm sau:
- Nó chỉ có thể chứa các biểu thức và có thể bao gồm các câu trong cơ thể của nó.
- Nó được viết như một dòng thực thi duy nhất.
- Nó không hỗ trợ chú thích loại.
- Nó có thể được gọi ngay lập tức [iife].
Không có tuyên bố
Một hàm Lambda có thể chứa bất kỳ câu lệnh nào. Trong hàm Lambda, các câu như
>>> import dis
>>> add = lambda x, y: x + y
>>> type[add]
>>> dis.dis[add]
1 0 LOAD_FAST 0 [x]
2 LOAD_FAST 1 [y]
4 BINARY_ADD
6 RETURN_VALUE
>>> add
2, >>> [lambda x: x + 1][2]
3
04, >>> [lambda x: x + 1][2]
3
05 hoặc >>> [lambda x: x + 1][2]
3
06 sẽ tăng ngoại lệ >>> [lambda x: x + 1][2]
3
07. Ở đây, một ví dụ về việc thêm >>> [lambda x: x + 1][2]
3
05 vào thân máy Lambda:>>>
>>> [lambda x: x + 1][2]
3
3Ví dụ giả định này dự định
>>> [lambda x: x + 1][2]
3
05 rằng tham số >>> lambda x, y: x + y
5 có giá trị >>> [lambda x, y: x + y][2, 3]
5
1. Nhưng, trình thông dịch xác định >>> [lambda x: x + 1][2]
3
07 trong khi phân tích mã liên quan đến câu lệnh >>> [lambda x: x + 1][2]
3
05 trong phần thân của >>> lambda x, y: x + y
2.Biểu thức đơn
Trái ngược với một hàm bình thường, hàm Python lambda là một biểu thức duy nhất. Mặc dù, trong phần thân của
>>> lambda x, y: x + y
2, bạn có thể truyền biểu thức trên một số dòng bằng dấu ngoặc đơn hoặc chuỗi đa dòng, nó vẫn là một biểu thức duy nhất:>>>
>>> [lambda x: x + 1][2]
3
4Ví dụ trên trả về chuỗi
>>> [lambda x: x + 1][2]
3
16 khi đối số lambda là số lẻ và >>> [lambda x: x + 1][2]
3
17 khi đối số là chẵn. Nó trải trên hai dòng vì nó được chứa trong một tập hợp các dấu ngoặc đơn, nhưng nó vẫn là một biểu thức duy nhất.Loại chú thích
Nếu bạn đã bắt đầu áp dụng gợi ý loại, hiện có sẵn trong Python, thì bạn có một lý do chính đáng khác để thích các chức năng bình thường hơn các chức năng của Python Lambda. Kiểm tra kiểm tra loại Python [hướng dẫn] để tìm hiểu thêm về gợi ý loại Python và kiểm tra loại. Trong hàm Lambda, không có tương đương cho các điều sau:
>>> [lambda x: x + 1][2]
3
5Bất kỳ loại lỗi nào với
>>> [lambda x: x + 1][2]
3
18 đều có thể bị bắt bởi các công cụ như >>> [lambda x: x + 1][2]
3
19 hoặc >>> [lambda x: x + 1][2]
3
20, trong khi đó >>> [lambda x: x + 1][2]
3
07 với chức năng Lambda tương đương được nâng lên trong thời gian chạy:>>>
>>> [lambda x: x + 1][2]
3
6Giống như cố gắng bao gồm một tuyên bố trong Lambda, việc thêm chú thích loại ngay lập tức dẫn đến
>>> [lambda x: x + 1][2]
3
07 khi chạy.Iife
Bạn đã thấy một số ví dụ về thực thi chức năng được gọi ngay lập tức:
>>>
>>> [lambda x: x + 1][2]
3
7Bên ngoài phiên dịch viên Python, tính năng này có thể không được sử dụng trong thực tế. Nó có một hậu quả trực tiếp của một chức năng Lambda được gọi là được xác định. Ví dụ: điều này cho phép bạn chuyển định nghĩa của biểu thức Lambda Python cho hàm bậc cao hơn như
>>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
9, >>> lambda x, y: x + y
0 hoặc >>> high_ord_func = lambda x, func: x + func[x]
>>> high_ord_func[2, lambda x: x * x]
6
>>> high_ord_func[2, lambda x: x + 3]
7
6 hoặc chức năng chính.Tranh luận
Giống như một đối tượng hàm bình thường được xác định với
>>> lambda x, y: x + y
3, các biểu thức Python Lambda hỗ trợ tất cả các cách khác nhau để truyền đối số. Điêu nay bao gôm:- Lập luận vị trí
- Đối số được đặt tên [đôi khi được gọi là đối số từ khóa]
- Danh sách biến các đối số [thường được gọi là Varargs]varargs]
- Danh sách biến các đối số từ khóa
- Đối số chỉ từ khóa
Các ví dụ sau đây minh họa các tùy chọn mở cho bạn để chuyển các đối số cho các biểu thức Lambda:
>>>
>>> [lambda x: x + 1][2]
3
8Trang trí
Trong Python, một người trang trí là việc thực hiện một mẫu cho phép thêm một hành vi vào một chức năng hoặc một lớp. Nó thường được biểu thị bằng tiền tố cú pháp
>>> [lambda x: x + 1][2]
3
27 một hàm. Đây là một ví dụ giả định:>>> [lambda x: x + 1][2]
3
9Trong ví dụ trên,
>>> [lambda x: x + 1][2]
3
28 là một hàm thêm hành vi vào >>> [lambda x: x + 1][2]
3
29, do đó việc gọi >>> [lambda x: x + 1][2]
3
30 dẫn đến kết quả đầu ra sau:[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
0>>> [lambda x: x + 1][2]
3
29 chỉ in >>> [lambda x: x + 1][2]
3
32, nhưng người trang trí thêm một hành vi bổ sung cũng in >>> [lambda x: x + 1][2]
3
33.Một người trang trí có thể được áp dụng cho một lambda. Mặc dù nó không thể trang trí Lambda với cú pháp
>>> [lambda x: x + 1][2]
3
27, một người trang trí chỉ là một chức năng, vì vậy nó có thể gọi hàm Lambda:[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
1>>> [lambda x: x + 1][2]
3
35, được trang trí với >>> [lambda x: x + 1][2]
3
36 trên dòng 11, được gọi bằng đối số >>> high_ord_func = lambda x, func: x + func[x]
>>> high_ord_func[2, lambda x: x * x]
6
>>> high_ord_func[2, lambda x: x + 3]
7
1 trên dòng 15. Ngược lại, trên dòng 18, một hàm Lambda ngay lập tức được liên quan và nhúng vào một cuộc gọi đến >>> [lambda x: x + 1][2]
3
38, người trang trí. Khi bạn thực thi mã ở trên, bạn có được những điều sau:[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
2Xem cách, như bạn đã thấy, tên của hàm Lambda xuất hiện là
>>> import dis
>>> add = lambda x, y: x + y
>>> type[add]
>>> dis.dis[add]
1 0 LOAD_FAST 0 [x]
2 LOAD_FAST 1 [y]
4 BINARY_ADD
6 RETURN_VALUE
>>> add
9, trong khi >>> [lambda x: x + 1][2]
3
40 được xác định rõ ràng cho hàm bình thường.Trang trí chức năng Lambda theo cách này có thể hữu ích cho mục đích gỡ lỗi, có thể để gỡ lỗi hành vi của hàm Lambda được sử dụng trong bối cảnh chức năng bậc cao hoặc chức năng chính. Hãy cùng xem một ví dụ với
>>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
9:[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
3Đối số đầu tiên của
>>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
9 là một lambda nhân lên đối số của nó với >>> [lambda x, y: x + y][2, 3]
5
1. Lambda này được trang trí với >>> [lambda x: x + 1][2]
3
38. Khi được thực thi, ví dụ trên xuất ra sau:[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
4Kết quả
>>> [lambda x: x + 1][2]
3
45 là một danh sách thu được từ việc nhân mỗi phần tử của >>> [lambda x: x + 1][2]
3
46. Hiện tại, hãy xem xét >>> [lambda x: x + 1][2]
3
46 tương đương với danh sách >>> [lambda x: x + 1][2]
3
48.Bạn sẽ được tiếp xúc với
>>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
9 chi tiết hơn trong bản đồ.Một lambda cũng có thể là một người trang trí, nhưng nó không được khuyến khích. Nếu bạn thấy mình cần phải làm điều này, hãy tham khảo PEP 8, các khuyến nghị lập trình.
Để biết thêm về trang trí Python, hãy xem Primer trên trang trí Python.
Khép kín
Đóng là một hàm trong đó mọi biến miễn phí, mọi thứ ngoại trừ các tham số, được sử dụng trong hàm đó được liên kết với một giá trị cụ thể được xác định trong phạm vi kèm theo của hàm đó. Trong thực tế, đóng cửa xác định môi trường mà chúng chạy, và do đó có thể được gọi từ bất cứ đâu.
Các khái niệm về lambdas và đóng cửa không nhất thiết phải liên quan, mặc dù các hàm Lambda có thể đóng cửa giống như cách các chức năng bình thường cũng có thể là đóng cửa. Một số ngôn ngữ có các cấu trúc đặc biệt để đóng hoặc lambda [ví dụ, Groovy với một khối mã ẩn danh là đối tượng đóng] hoặc biểu thức lambda [ví dụ, biểu thức Java Lambda với tùy chọn giới hạn để đóng].
Ở đây, một đóng cửa được xây dựng với chức năng Python bình thường:
[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
5>>> [lambda x: x + 1][2]
3
50 Trả về >>> [lambda x: x + 1][2]
3
51, một hàm lồng nhau tính tổng của ba đối số:
5 được thông qua như một đối số cho>>> lambda x, y: x + y
50. is passed as an argument to>>> [lambda x: x + 1][2] 3
50.>>> [lambda x: x + 1][2] 3
54 là một biến cục bộ đến>>> [lambda x: x + 1][2] 3
50. is a variable local to>>> [lambda x: x + 1][2] 3
50.>>> [lambda x: x + 1][2] 3
56 là một đối số được chuyển đến>>> [lambda x: x + 1][2] 3
51. is an argument passed to>>> [lambda x: x + 1][2] 3
51.>>> [lambda x: x + 1][2] 3
Để kiểm tra hành vi của
>>> [lambda x: x + 1][2]
3
50 và >>> [lambda x: x + 1][2]
3
51, >>> [lambda x: x + 1][2]
3
50 được gọi ba lần trong vòng lặp >>> [lambda x: x + 1][2]
3
61 in như sau:[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
6Trên dòng 9 của mã,
>>> [lambda x: x + 1][2]
3
51 được trả về bởi lời mời của >>> [lambda x: x + 1][2]
3
50 được liên kết với tên >>> [lambda x: x + 1][2]
3
64. Trên dòng 5, >>> [lambda x: x + 1][2]
3
51 nắm bắt >>> lambda x, y: x + y
5 và >>> [lambda x: x + 1][2]
3
54 vì nó có quyền truy cập vào môi trường nhúng của nó, do đó khi gọi đóng cửa, nó có thể hoạt động trên hai biến miễn phí >>> lambda x, y: x + y
5 và >>> [lambda x: x + 1][2]
3
54.Tương tự, một
>>> lambda x, y: x + y
2 cũng có thể là một đóng cửa. Ở đây, ví dụ tương tự với chức năng Python Lambda:[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
7Khi bạn thực thi mã ở trên, bạn có được đầu ra sau:
[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
8Trên dòng 6,
>>> [lambda x: x + 1][2]
3
50 trả về một lambda và gán nó cho biến >>> [lambda x: x + 1][2]
3
64. Trên dòng 3, phần thân của hàm Lambda tham chiếu >>> lambda x, y: x + y
5 và >>> [lambda x: x + 1][2]
3
54. Biến >>> [lambda x: x + 1][2]
3
54 có sẵn tại thời điểm định nghĩa, trong khi >>> lambda x, y: x + y
5 được xác định trong thời gian chạy khi >>> [lambda x: x + 1][2]
3
50 được gọi.Trong tình huống này, cả chức năng bình thường và Lambda đều hoạt động tương tự. Trong phần tiếp theo, bạn sẽ thấy một tình huống trong đó hành vi của Lambda có thể bị lừa dối do thời gian đánh giá của nó [thời gian định nghĩa so với thời gian chạy].
Thời gian đánh giá
Trong một số tình huống liên quan đến các vòng lặp, hành vi của một chức năng Python Lambda như một sự đóng cửa có thể phản trực giác. Nó đòi hỏi sự hiểu biết khi các biến miễn phí bị ràng buộc trong bối cảnh của một lambda. Các ví dụ sau đây cho thấy sự khác biệt khi sử dụng hàm thông thường so với sử dụng Lambda Python.
Kiểm tra kịch bản trước bằng cách sử dụng chức năng thông thường:
>>>
[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
9Trong một hàm bình thường,
>>> [lambda x: x + 1][2]
3
78 được đánh giá ở thời điểm định nghĩa, trên dòng 9, khi hàm được thêm vào danh sách: >>> [lambda x: x + 1][2]
3
79.Bây giờ, với việc thực hiện cùng một logic với chức năng Lambda, hãy quan sát hành vi bất ngờ:
>>>
>>> add_one = lambda x: x + 1
>>> add_one[2]
3
0Trong một hàm bình thường,
>>> [lambda x: x + 1][2]
3
78 được đánh giá ở thời điểm định nghĩa, trên dòng 9, khi hàm được thêm vào danh sách: >>> [lambda x: x + 1][2]
3
79.Bây giờ, với việc thực hiện cùng một logic với chức năng Lambda, hãy quan sát hành vi bất ngờ:
>>>
>>> add_one = lambda x: x + 1
>>> add_one[2]
3
1Trong một hàm bình thường,
>>> [lambda x: x + 1][2]
3
78 được đánh giá ở thời điểm định nghĩa, trên dòng 9, khi hàm được thêm vào danh sách: >>> [lambda x: x + 1][2]
3
79.Hàm Python Lambda được gọi mà không có bất kỳ đối số nào trên dòng 7 và nó sử dụng giá trị mặc định
>>> [lambda x: x + 1][2]
3
78 được đặt tại thời điểm định nghĩa.Thử nghiệm Lambdas
Python Lambdas có thể được kiểm tra tương tự như các chức năng thông thường. Nó có thể sử dụng cả
>>> [lambda x: x + 1][2]
3
89 và >>> [lambda x: x + 1][2]
3
90.
89>>> [lambda x: x + 1][2]
3
Mô -đun
>>> [lambda x: x + 1][2]
3
89 xử lý các hàm Python Lambda tương tự như các chức năng thông thường:>>> add_one = lambda x: x + 1
>>> add_one[2]
3
2>>> [lambda x: x + 1][2]
3
93 Xác định một trường hợp thử nghiệm với ba phương pháp thử nghiệm, mỗi phương pháp trong số họ thực hiện một kịch bản thử nghiệm cho >>> [lambda x: x + 1][2]
3
94 được thực hiện như một hàm Lambda. Việc thực hiện tệp Python >>> [lambda x: x + 1][2]
3
95 có chứa >>> [lambda x: x + 1][2]
3
93 tạo ra những điều sau:>>> add_one = lambda x: x + 1
>>> add_one[2]
3
3Đúng như dự đoán, chúng tôi có hai trường hợp thử nghiệm thành công và một lỗi cho
>>> [lambda x: x + 1][2]
3
97: kết quả là >>> high_ord_func = lambda x, func: x + func[x]
>>> high_ord_func[2, lambda x: x * x]
6
>>> high_ord_func[2, lambda x: x + 3]
7
2, nhưng kết quả dự kiến là >>> [lambda x: x + 1][2]
3
99. Thất bại này là do một sai lầm có chủ ý trong trường hợp thử nghiệm. Thay đổi kết quả dự kiến từ >>> [lambda x: x + 1][2]
3
99 thành >>> high_ord_func = lambda x, func: x + func[x]
>>> high_ord_func[2, lambda x: x * x]
6
>>> high_ord_func[2, lambda x: x + 3]
7
2 sẽ đáp ứng tất cả các bài kiểm tra cho >>> [lambda x: x + 1][2]
3
93.
90>>> [lambda x: x + 1][2]
3
Mô -đun
>>> [lambda x: x + 1][2]
3
90 trích xuất mã Python tương tác từ [lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
05 để thực hiện các thử nghiệm. Mặc dù cú pháp của các hàm Lambda Python không hỗ trợ [lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
05 điển hình, nhưng có thể gán một chuỗi cho phần tử [lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
07 của Lambda có tên:>>> add_one = lambda x: x + 1
>>> add_one[2]
3
4>>> [lambda x: x + 1][2]
3
90 trong nhận xét DOC của Lambda >>> [lambda x: x + 1][2]
3
94 mô tả các trường hợp thử nghiệm tương tự như trong phần trước.Khi bạn thực hiện các bài kiểm tra qua
[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
10, bạn sẽ nhận được như sau:>>> add_one = lambda x: x + 1
>>> add_one[2]
3
5Các kết quả kiểm tra thất bại từ cùng một lỗi được giải thích trong việc thực hiện các thử nghiệm đơn vị trong phần trước.
Bạn có thể thêm một
[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
05 vào Python Lambda thông qua một bài tập cho [lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
07 để ghi lại hàm Lambda. Mặc dù có thể, cú pháp Python tốt hơn [lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
05 cho các chức năng bình thường so với các hàm Lambda.Để biết tổng quan toàn diện về thử nghiệm đơn vị trong Python, bạn có thể muốn tham khảo bắt đầu với thử nghiệm trong Python.
Biểu hiện Lambda lạm dụng
Một số ví dụ trong bài viết này, nếu được viết trong bối cảnh mã Python chuyên nghiệp, sẽ đủ điều kiện là lạm dụng.
Nếu bạn thấy mình đang cố gắng vượt qua một cái gì đó mà một biểu thức Lambda không hỗ trợ, thì đây có lẽ là một dấu hiệu cho thấy một chức năng bình thường sẽ phù hợp hơn.
[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
05 cho biểu thức lambda trong phần trước là một ví dụ tốt. Cố gắng khắc phục thực tế rằng chức năng Python Lambda không hỗ trợ các câu lệnh là một lá cờ đỏ khác.Các phần tiếp theo minh họa một vài ví dụ về việc sử dụng Lambda nên tránh. Những ví dụ đó có thể là các tình huống, trong bối cảnh của Python Lambda, mã thể hiện mô hình sau:
- Nó không theo hướng dẫn phong cách Python [PEP 8]
- Nó cồng kềnh và khó đọc.
- Nó thông minh không cần thiết với chi phí của khả năng đọc khó.
Nâng cao một ngoại lệ
Cố gắng nâng cao một ngoại lệ trong một chiếc Python Lambda sẽ khiến bạn suy nghĩ hai lần. Có một số cách thông minh để làm như vậy, nhưng ngay cả một cái gì đó như sau là tốt hơn để tránh:
>>>
>>> add_one = lambda x: x + 1
>>> add_one[2]
3
6Bởi vì một tuyên bố không chính xác về mặt cú pháp trong cơ thể Python Lambda, cách giải quyết trong ví dụ trên bao gồm trừu tượng hóa cuộc gọi tuyên bố với chức năng chuyên dụng
[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
15. Sử dụng loại cách giải quyết này nên tránh. Nếu bạn gặp loại mã này, bạn nên xem xét việc tái cấu trúc mã để sử dụng chức năng thông thường.Phong cách mật mã
Như trong bất kỳ ngôn ngữ lập trình nào, bạn sẽ tìm thấy mã Python có thể khó đọc vì phong cách được sử dụng. Các chức năng của Lambda, do sự đồng nhất của chúng, có thể có lợi cho việc viết mã khó đọc.
Ví dụ Lambda sau đây chứa một số lựa chọn kiểu xấu:
>>>
>>> add_one = lambda x: x + 1
>>> add_one[2]
3
7Bởi vì một tuyên bố không chính xác về mặt cú pháp trong cơ thể Python Lambda, cách giải quyết trong ví dụ trên bao gồm trừu tượng hóa cuộc gọi tuyên bố với chức năng chuyên dụng
[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
15. Sử dụng loại cách giải quyết này nên tránh. Nếu bạn gặp loại mã này, bạn nên xem xét việc tái cấu trúc mã để sử dụng chức năng thông thường.>>>
>>> add_one = lambda x: x + 1
>>> add_one[2]
3
8Bởi vì một tuyên bố không chính xác về mặt cú pháp trong cơ thể Python Lambda, cách giải quyết trong ví dụ trên bao gồm trừu tượng hóa cuộc gọi tuyên bố với chức năng chuyên dụng
[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
15. Sử dụng loại cách giải quyết này nên tránh. Nếu bạn gặp loại mã này, bạn nên xem xét việc tái cấu trúc mã để sử dụng chức năng thông thường.>>>
>>> add_one = lambda x: x + 1
>>> add_one[2]
3
9Bởi vì một tuyên bố không chính xác về mặt cú pháp trong cơ thể Python Lambda, cách giải quyết trong ví dụ trên bao gồm trừu tượng hóa cuộc gọi tuyên bố với chức năng chuyên dụng
[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
15. Sử dụng loại cách giải quyết này nên tránh. Nếu bạn gặp loại mã này, bạn nên xem xét việc tái cấu trúc mã để sử dụng chức năng thông thường.Phong cách mật mã
Như trong bất kỳ ngôn ngữ lập trình nào, bạn sẽ tìm thấy mã Python có thể khó đọc vì phong cách được sử dụng. Các chức năng của Lambda, do sự đồng nhất của chúng, có thể có lợi cho việc viết mã khó đọc.
def add_one[x]:
return x + 1
0Chạy một công cụ như
[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
26, một công cụ thực thi hướng dẫn kiểu, sẽ hiển thị các lỗi sau cho [lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
22 và [lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
28:def add_one[x]:
return x + 1
1Mặc dù
[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
26 không chỉ ra một vấn đề cho việc sử dụng các chức năng của Python Lambda trong các thuộc tính, nhưng chúng rất khó đọc và dễ bị lỗi vì sử dụng nhiều chuỗi như [lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
30 và [lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
31.Việc thực hiện đúng
[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
22 sẽ được dự kiến như sau:def add_one[x]:
return x + 1
2[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
24 sẽ được viết như sau:def add_one[x]:
return x + 1
3Theo nguyên tắc chung, trong bối cảnh mã được viết bằng Python, thích các chức năng thường xuyên hơn các biểu thức Lambda. Tuy nhiên, có những trường hợp được hưởng lợi từ cú pháp Lambda, như bạn sẽ thấy trong phần tiếp theo.
Việc sử dụng phù hợp của các biểu thức Lambda
Lambdas trong Python có xu hướng là chủ đề của những tranh cãi. Một số lập luận chống lại Lambdas trong Python là:
- Các vấn đề với khả năng đọc
- Việc áp đặt một cách suy nghĩ chức năng
- Cú pháp nặng với từ khóa
2>>> lambda x, y: x + y
Mặc dù các cuộc tranh luận sôi nổi đặt câu hỏi về sự tồn tại đơn thuần của tính năng này trong Python, các chức năng của Lambda có các thuộc tính đôi khi cung cấp giá trị cho ngôn ngữ Python và cho các nhà phát triển.
Các ví dụ sau đây minh họa các kịch bản trong đó việc sử dụng các hàm Lambda không chỉ phù hợp mà còn được khuyến khích trong mã Python.
Cấu trúc chức năng cổ điển
Các hàm Lambda thường xuyên được sử dụng với các hàm tích hợp
>>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
9 và >>> lambda x, y: x + y
0, cũng như >>> high_ord_func = lambda x, func: x + func[x]
>>> high_ord_func[2, lambda x: x * x]
6
>>> high_ord_func[2, lambda x: x + 3]
7
6, được phơi bày trong mô-đun [lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
38. Ba ví dụ sau đây là minh họa tương ứng về việc sử dụng các chức năng đó với các biểu thức Lambda làm bạn đồng hành:>>>
def add_one[x]:
return x + 1
4Bạn có thể phải đọc mã giống với các ví dụ ở trên, mặc dù có dữ liệu có liên quan hơn. Vì lý do đó, điều quan trọng là phải nhận ra các cấu trúc đó. Tuy nhiên, những cấu trúc đó có các lựa chọn thay thế tương đương được coi là Pythonic hơn. Trong các lựa chọn thay thế cho Lambdas, bạn sẽ học cách chuyển đổi các chức năng bậc cao và Lambdas đi kèm của chúng thành các hình thức thành ngữ khác.
Chức năng chính
Các chức năng chính trong Python là các hàm bậc cao hơn lấy tham số
[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
39 làm đối số được đặt tên. [lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
39 nhận được một hàm có thể là >>> lambda x, y: x + y
2. Hàm này ảnh hưởng trực tiếp đến thuật toán được điều khiển bởi chính hàm chính. Dưới đây là một số chức năng chính:
7: Phương pháp liệt kê list method>>> high_ord_func = lambda x, func: x + func[x] >>> high_ord_func[2, lambda x: x * x] 6 >>> high_ord_func[2, lambda x: x + 3] 7
8,>>> high_ord_func = lambda x, func: x + func[x] >>> high_ord_func[2, lambda x: x * x] 6 >>> high_ord_func[2, lambda x: x + 3] 7
9,>>> high_ord_func = lambda x, func: x + func[x] >>> high_ord_func[2, lambda x: x * x] 6 >>> high_ord_func[2, lambda x: x + 3] 7
0: Các chức năng tích hợp built-in functions>>> import dis >>> add = lambda x, y: x + y >>> type[add] >>> dis.dis[add] 1 0 LOAD_FAST 0 [x] 2 LOAD_FAST 1 [y] 4 BINARY_ADD 6 RETURN_VALUE >>> add
46 và[lambda x: x + 1][2] = lambda 2: 2 + 1 = 2 + 1 = 3
47: Trong mô -đun thuật toán hàng đợi heap[lambda x: x + 1][2] = lambda 2: 2 + 1 = 2 + 1 = 3
48 in the Heap queue algorithm module[lambda x: x + 1][2] = lambda 2: 2 + 1 = 2 + 1 = 3
48[lambda x: x + 1][2] = lambda 2: 2 + 1 = 2 + 1 = 3
Hãy tưởng tượng rằng bạn muốn sắp xếp một danh sách các ID được thể hiện dưới dạng chuỗi. Mỗi ID là sự kết hợp của chuỗi
[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
49 và một số. Theo mặc định, sắp xếp danh sách này với chức năng tích hợp >>> high_ord_func = lambda x, func: x + func[x]
>>> high_ord_func[2, lambda x: x * x]
6
>>> high_ord_func[2, lambda x: x + 3]
7
8, sử dụng thứ tự từ vựng vì các yếu tố trong danh sách là chuỗi.Để ảnh hưởng đến việc thực thi sắp xếp, bạn có thể gán Lambda cho đối số được đặt tên
[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
39, sao cho việc sắp xếp sẽ sử dụng số được liên kết với ID:>>>
def add_one[x]:
return x + 1
5Bạn có thể phải đọc mã giống với các ví dụ ở trên, mặc dù có dữ liệu có liên quan hơn. Vì lý do đó, điều quan trọng là phải nhận ra các cấu trúc đó. Tuy nhiên, những cấu trúc đó có các lựa chọn thay thế tương đương được coi là Pythonic hơn. Trong các lựa chọn thay thế cho Lambdas, bạn sẽ học cách chuyển đổi các chức năng bậc cao và Lambdas đi kèm của chúng thành các hình thức thành ngữ khác.
Chức năng chính
Các chức năng chính trong Python là các hàm bậc cao hơn lấy tham số
[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
39 làm đối số được đặt tên. [lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
39 nhận được một hàm có thể là >>> lambda x, y: x + y
2. Hàm này ảnh hưởng trực tiếp đến thuật toán được điều khiển bởi chính hàm chính. Dưới đây là một số chức năng chính:def add_one[x]:
return x + 1
6>>> high_ord_func = lambda x, func: x + func[x]
>>> high_ord_func[2, lambda x: x * x]
6
>>> high_ord_func[2, lambda x: x + 3]
7
7: Phương pháp liệt kê>>> high_ord_func = lambda x, func: x + func[x]
>>> high_ord_func[2, lambda x: x * x]
6
>>> high_ord_func[2, lambda x: x + 3]
7
8, >>> high_ord_func = lambda x, func: x + func[x]
>>> high_ord_func[2, lambda x: x * x]
6
>>> high_ord_func[2, lambda x: x + 3]
7
9, >>> import dis
>>> add = lambda x, y: x + y
>>> type[add]
>>> dis.dis[add]
1 0 LOAD_FAST 0 [x]
2 LOAD_FAST 1 [y]
4 BINARY_ADD
6 RETURN_VALUE
>>> add
0: Các chức năng tích hợp[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
46 và [lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
47: Trong mô -đun thuật toán hàng đợi heap [lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
48Hãy tưởng tượng rằng bạn muốn sắp xếp một danh sách các ID được thể hiện dưới dạng chuỗi. Mỗi ID là sự kết hợp của chuỗi [lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
49 và một số. Theo mặc định, sắp xếp danh sách này với chức năng tích hợp >>> high_ord_func = lambda x, func: x + func[x]
>>> high_ord_func[2, lambda x: x * x]
6
>>> high_ord_func[2, lambda x: x + 3]
7
8, sử dụng thứ tự từ vựng vì các yếu tố trong danh sách là chuỗi.
[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
>>> high_ord_func = lambda x, func: x + func[x]
>>> high_ord_func[2, lambda x: x * x]
6
>>> high_ord_func[2, lambda x: x + 3]
7
Để ảnh hưởng đến việc thực thi sắp xếp, bạn có thể gán Lambda cho đối số được đặt tên
[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
39, sao cho việc sắp xếp sẽ sử dụng số được liên kết với ID:[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
55
[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
Khung UI
>>>
def add_one[x]:
return x + 1
7Bạn có thể phải đọc mã giống với các ví dụ ở trên, mặc dù có dữ liệu có liên quan hơn. Vì lý do đó, điều quan trọng là phải nhận ra các cấu trúc đó. Tuy nhiên, những cấu trúc đó có các lựa chọn thay thế tương đương được coi là Pythonic hơn. Trong các lựa chọn thay thế cho Lambdas, bạn sẽ học cách chuyển đổi các chức năng bậc cao và Lambdas đi kèm của chúng thành các hình thức thành ngữ khác.
Một cách tiếp cận khác là sử dụng
>>> lambda x, y: x + y
2:>>>
def add_one[x]:
return x + 1
8Giải pháp này là sạch hơn, dễ đọc hơn và nhanh hơn để gõ trình thông dịch. Mặc dù thời gian thực hiện ít hơn một chút đối với phiên bản
>>> lambda x, y: x + y
2, việc thực thi các chức năng một lần nữa có thể hiển thị một lợi thế nhỏ cho phiên bản [lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
62. Thời gian thực hiện của [lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
63 được loại trừ khỏi thời gian thực hiện chung và không nên có bất kỳ tác động nào đến kết quả.Khỉ vá
Để thử nghiệm, đôi khi nó cần phải dựa vào kết quả lặp lại, ngay cả khi trong quá trình thực hiện bình thường một phần mềm nhất định, các kết quả tương ứng dự kiến sẽ khác nhau hoặc thậm chí là hoàn toàn ngẫu nhiên.
Hãy nói rằng bạn muốn kiểm tra một chức năng, trong thời gian chạy, xử lý các giá trị ngẫu nhiên. Nhưng, trong quá trình thực hiện thử nghiệm, bạn cần khẳng định chống lại các giá trị có thể dự đoán theo cách lặp lại. Ví dụ sau đây cho thấy làm thế nào, với chức năng
>>> lambda x, y: x + y
2, việc vá khỉ có thể giúp bạn:def add_one[x]:
return x + 1
9Trình quản lý bối cảnh giúp cách điện cách cách điện cho khỉ vá một hàm từ thư viện tiêu chuẩn [
[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
65, trong ví dụ này]. Hàm Lambda được gán cho [lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
66 thay thế hành vi mặc định bằng cách trả về giá trị tĩnh.Điều này cho phép kiểm tra bất kỳ chức năng nào tùy thuộc vào
[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
67 theo kiểu có thể dự đoán được. Trước khi rời khỏi Trình quản lý bối cảnh, hành vi mặc định của [lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
67 được thiết lập lại để loại bỏ bất kỳ tác dụng phụ bất ngờ nào có ảnh hưởng đến các lĩnh vực khác của thử nghiệm có thể phụ thuộc vào hành vi mặc định của [lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
67.Các khung kiểm tra đơn vị như
>>> [lambda x: x + 1][2]
3
89 và [lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
71 đưa khái niệm này đến mức độ tinh vi cao hơn.Với
[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
71, vẫn sử dụng hàm >>> lambda x, y: x + y
2, cùng một ví dụ trở nên thanh lịch và súc tích hơn:>>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
0Với trận đấu pytest
[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
74, [lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
66 được ghi đè bằng một lambda sẽ trả về giá trị xác định, [lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
76, cho phép xác thực thử nghiệm. Lịch trình pytest [lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
74 cho phép bạn kiểm soát phạm vi ghi đè. Trong ví dụ trên, việc gọi [lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
66 trong các thử nghiệm tiếp theo, mà không sử dụng việc vá khỉ, sẽ thực hiện việc thực hiện bình thường của chức năng này.Thực hiện kiểm tra
[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
71 cho kết quả sau:>>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
1Bài kiểm tra vượt qua khi chúng tôi xác nhận rằng
[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
80 đã được thực hiện và kết quả là những kết quả được mong đợi trong bối cảnh thử nghiệm.Giải pháp thay thế cho Lambdas
Mặc dù có những lý do tuyệt vời để sử dụng
>>> lambda x, y: x + y
2, nhưng có những trường hợp sử dụng nó được cau mày. Vậy các lựa chọn thay thế là gì?Các chức năng bậc cao như
>>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
9, >>> lambda x, y: x + y
0 và >>> high_ord_func = lambda x, func: x + func[x]
>>> high_ord_func[2, lambda x: x * x]
6
>>> high_ord_func[2, lambda x: x + 3]
7
6 có thể được chuyển đổi thành các hình thức thanh lịch hơn với sự xoắn ốc nhẹ của sự sáng tạo, đặc biệt là với sự hiểu biết danh sách hoặc biểu thức máy phát.Để tìm hiểu thêm về toàn bộ danh sách, hãy xem khi nào nên sử dụng danh sách hiểu trong Python. Để tìm hiểu thêm về các biểu thức máy phát, hãy xem cách sử dụng trình tạo và mang lại trong Python.
Bản đồ
Hàm tích hợp
>>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
9 có chức năng như một đối số đầu tiên và áp dụng nó cho từng phần tử của đối số thứ hai, một điều không thể sử dụng được. Ví dụ về các vòng lặp là chuỗi, danh sách và bộ dữ liệu. Để biết thêm thông tin về Iterables và iterators, hãy xem Iterables và Iterators.iterable. Examples of iterables are strings, lists, and tuples. For more information on iterables and iterators, check out Iterables and Iterators.>>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
9 trả về một trình lặp tương ứng với bộ sưu tập được chuyển đổi. Ví dụ, nếu bạn muốn chuyển đổi danh sách các chuỗi thành một danh sách mới với mỗi chuỗi được viết hoa, bạn có thể sử dụng >>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
9, như sau:>>>
>>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
2Bạn cần gọi
[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
88 để chuyển đổi trình lặp được trả về bởi >>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
9 thành một danh sách mở rộng có thể được hiển thị trong trình thông dịch shell python.Sử dụng danh sách hiểu loại bỏ sự cần thiết phải xác định và gọi chức năng Lambda:
>>>
>>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
3Lọc
Hàm tích hợp
>>> lambda x, y: x + y
0, một cấu trúc chức năng cổ điển khác, có thể được chuyển đổi thành một sự hiểu biết danh sách. Nó lấy một vị từ như một đối số đầu tiên và một điều có thể là một đối số thứ hai. Nó xây dựng một trình lặp có chứa tất cả các yếu tố của bộ sưu tập ban đầu thỏa mãn chức năng vị ngữ. Dưới đây, một ví dụ đã lọc tất cả các số chẵn trong một danh sách các số nguyên nhất định:>>>
>>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
4Lưu ý rằng
>>> lambda x, y: x + y
0 trả về một trình lặp, do đó cần phải gọi loại [lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
92 tích hợp xây dựng một danh sách được đưa ra một trình lặp.Việc thực hiện thúc đẩy cấu trúc hiểu danh sách đưa ra như sau:
>>>
>>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
5Giảm
Kể từ Python 3,
>>> lambda x, y: x + y
1 đã chuyển từ hàm tích hợp sang hàm mô-đun [lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
38. Như >>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
9 và >>> lambda x, y: x + y
0, hai đối số đầu tiên của nó lần lượt là một hàm và có thể lặp lại. Nó cũng có thể lấy một bộ khởi tạo làm đối số thứ ba được sử dụng làm giá trị ban đầu của bộ tích lũy kết quả. Đối với mỗi yếu tố của ITEBLE, >>> lambda x, y: x + y
1 áp dụng chức năng và tích lũy kết quả được trả về khi có thể cạn kiệt.Để áp dụng
>>> lambda x, y: x + y
1 vào danh sách các cặp và tính tổng của mục đầu tiên của mỗi cặp, bạn có thể viết bài này:>>>
>>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
6Một cách tiếp cận thành ngữ hơn khi sử dụng biểu thức trình tạo, làm đối số với
[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
99 trong ví dụ, là như sau:>>>
Một cách tiếp cận thành ngữ hơn khi sử dụng biểu thức trình tạo, làm đối số với[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
99 trong ví dụ, là như sau:>>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
7>>>
>>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
8Một cách tiếp cận thành ngữ hơn khi sử dụng biểu thức trình tạo, làm đối số với
[lambda x: x + 1][2] = lambda 2: 2 + 1
= 2 + 1
= 3
99 trong ví dụ, là như sau:>>> full_name = lambda first, last: f'Full name: {first.title[]} {last.title[]}'
>>> full_name['guido', 'van rossum']
'Full name: Guido Van Rossum'
7Một giải pháp hơi khác và có thể làm sạch sẽ loại bỏ sự cần thiết phải truy cập rõ ràng phần tử đầu tiên của cặp và thay vào đó sử dụng giải nén:
Việc sử dụng dấu gạch dưới [
>>> [lambda x, y: x + y][2, 3]
5
8] là một quy ước Python chỉ ra rằng bạn có thể bỏ qua giá trị thứ hai của cặp.99 có một đối số duy nhất, vì vậy biểu thức máy phát không cần phải ở trong ngoặc đơn.[lambda x: x + 1][2] = lambda 2: 2 + 1 = 2 + 1 = 3
Lambdas Pythonic có hay không?
PEP 8, là hướng dẫn kiểu cho mã Python, có nội dung:
Luôn sử dụng câu lệnh DEF thay vì câu lệnh gán liên kết biểu thức Lambda trực tiếp với định danh. [Nguồn]
Điều này không khuyến khích sử dụng Lambda ràng buộc với một định danh, chủ yếu là nơi các chức năng nên được sử dụng và có nhiều lợi ích hơn. PEP 8 không đề cập đến các cách sử dụng khác của >>> lambda x, y: x + y
2. Như bạn đã thấy trong các phần trước, các chức năng của Lambda chắc chắn có thể sử dụng tốt, mặc dù chúng bị hạn chế.
>>> lambda x, y: x + y
Một cách có thể để trả lời câu hỏi là các chức năng Lambda là hoàn toàn pythonic nếu không có gì có sẵn thêm pythonic. Tôi tránh xa việc xác định ý nghĩa của Pythonic, để lại cho bạn định nghĩa phù hợp nhất với suy nghĩ của bạn, cũng như phong cách mã hóa cá nhân hoặc nhóm của bạn.
- Ngoài phạm vi hẹp của Python
2, cách viết mã Python tuyệt đẹp với PEP 8 là một tài nguyên tuyệt vời mà bạn có thể muốn kiểm tra về phong cách mã trong Python.>>> lambda x, y: x + y
- Sự kết luận
- Bây giờ bạn biết cách sử dụng các chức năng Python
2 và có thể:>>> lambda x, y: x + y
- Viết Python Lambdas và sử dụng các chức năng ẩn danh
Chọn một cách khôn ngoan giữa các chức năng của Lambdas hoặc Python bình thường
Tránh sử dụng quá nhiều lambdas
Sử dụng lambdas với các chức năng bậc cao hoặc các chức năng khóa Python This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: How to Use Python Lambda Functions