Hướng dẫn call function in lambda python - chức năng gọi trong lambda 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'

>>> lambda x, y: x + y

>>> lambda x, y: x + y

>>> lambda x, y: x + y

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

>>>

>>> def identity(x):
...     return x

>>> lambda x, y: x + y

>>> lambda x, y: x + y

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:

  >>> lambda x, y: x + y
  

  2

  >>> lambda x, y: x + y
  

  2
• Một biến ràng buộc:

  >>> lambda x, y: x + y
  

  5

  >>> lambda x, y: x + y
  

  5
• Một cơ thể:

  >>> lambda x, y: x + y
  

  5

  >>> lambda x, y: x + y
  

  5

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

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

>>> lambda x, y: x + y

(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

>>> lambda x, y: x + y

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

>>> (lambda x, y: x + y)(2, 3)
5

>>> (lambda x, y: x + y)(2, 3)
5

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
 at 0x7f30c6ce9ea0>

>>> lambda x, y: x + y

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
 at 0x7f30c6ce9ea0>

>>>

>>> 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
 at 0x7f30c6ce9ea0>

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
 at 0x7f30c6ce9ea0>

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

Mã 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
 at 0x7f30c6ce9ea0>

>>> lambda x, y: x + y

>>> lambda x, y: x + y

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
 at 0x7f30c6ce9ea0>

>>> 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
 at 0x7f30c6ce9ea0>

>>>

>>> (lambda x: x + 1)(2)
3

TraceBack 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
 at 0x7f30c6ce9ea0>

Ở đâ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

Hà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

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
 at 0x7f30c6ce9ea0>

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
3

>>>

>>> (lambda x: x + 1)(2)
3

Ví dụ giả định này dự định

>>> (lambda x: x + 1)(2)
3

>>> lambda x, y: x + y

>>> (lambda x, y: x + y)(2, 3)
5

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
3

>>> lambda x, y: x + y

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

>>>

>>> (lambda x: x + 1)(2)
3

Ví dụ trên trả về chuỗi

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
3

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

Bất kỳ loại lỗi nào với

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
3

>>>

>>> (lambda x: x + 1)(2)
3

Giố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

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

Bê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'

>>> lambda x, y: x + y

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

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

• 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

Trang 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

>>> (lambda x: x + 1)(2)
3

Trong ví dụ trên,

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
3

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
3

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

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
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

>>> (lambda x: x + 1)(2)
3

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

Xem 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
 at 0x7f30c6ce9ea0>

>>> (lambda x: x + 1)(2)
3

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'

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 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'

>>> (lambda x, y: x + y)(2, 3)
5

>>> (lambda x: x + 1)(2)
3

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

Kết quả

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
3

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'

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

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
3

• >>> lambda x, y: x + y
  

  5 được thông qua như một đối số cho

  >>> (lambda x: x + 1)(2)
  3
  

  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.

Để kiểm tra hành vi của

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
3

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

Trên dòng 9 của mã,

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
3

>>> lambda x, y: x + y

>>> (lambda x: x + 1)(2)
3

>>> lambda x, y: x + y

>>> (lambda x: x + 1)(2)
3

Tương tự, một

>>> lambda x, y: x + y

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

Khi 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

Trên dòng 6,

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
3

>>> lambda x, y: x + y

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
3

>>> lambda x, y: x + y

>>> (lambda x: x + 1)(2)
3

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

Trong một hàm bình thường,

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
3

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

Trong một hàm bình thường,

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
3

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

Trong một hàm bình thường,

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
3

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

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

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
3

Mô -đun

>>> (lambda x: x + 1)(2)
3

>>> add_one = lambda x: x + 1
>>> add_one(2)
3

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
3

>>> add_one = lambda x: x + 1
>>> add_one(2)
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

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

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
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

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
3

Mô -đun

>>> (lambda x: x + 1)(2)
3

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

>>> add_one = lambda x: x + 1
>>> add_one(2)
3

>>> (lambda x: x + 1)(2)
3

>>> (lambda x: x + 1)(2)
3

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

>>> add_one = lambda x: x + 1
>>> add_one(2)
3

Cá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

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

Để 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.

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

Bở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

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

Bở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

>>>

>>> add_one = lambda x: x + 1
>>> add_one(2)
3

Bở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

>>>

>>> add_one = lambda x: x + 1
>>> add_one(2)
3

Bở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

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

Chạy một công cụ như

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

def add_one(x):
    return x + 1

Mặc dù

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

Việc thực hiện đúng

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

def add_one(x):
    return x + 1

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

def add_one(x):
    return x + 1

Theo 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.

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'

>>> lambda x, y: x + y

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

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

>>>

def add_one(x):
    return x + 1

Bạ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

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

>>> lambda x, y: x + y

• >>> 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ê 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,

  >>> 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
   at 0x7f30c6ce9ea0>
  

  0: Các chức năng tích hợp built-in functions

• (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
  

  48 in the Heap queue algorithm module

  (lambda x: x + 1)(2) = lambda 2: 2 + 1
                       = 2 + 1
                       = 3
  

  48

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

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

>>>

def add_one(x):
    return x + 1

Bạ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

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

>>> lambda x, y: x + y

def add_one(x):
    return x + 1

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

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

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

>>> 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
 at 0x7f30c6ce9ea0>

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

(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

(lambda x: x + 1)(2) = lambda 2: 2 + 1 = 2 + 1 = 3 55

Khung UI

>>>

def add_one(x):
    return x + 1

Bạ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

>>>

def add_one(x):
    return x + 1

Giả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

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

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

def add_one(x):
    return x + 1

Trì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

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

Đ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

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

Các khung kiểm tra đơn vị như

>>> (lambda x: x + 1)(2)
3

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

Với

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

>>> lambda x, y: x + y

>>> full_name = lambda first, last: f'Full name: {first.title()} {last.title()}'
>>> full_name('guido', 'van rossum')
'Full name: Guido Van Rossum'

Với trận đấu pytest

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

Thực hiện kiểm tra

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

>>> full_name = lambda first, last: f'Full name: {first.title()} {last.title()}'
>>> full_name('guido', 'van rossum')
'Full name: Guido Van Rossum'

Bà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

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'

>>> full_name = lambda first, last: f'Full name: {first.title()} {last.title()}'
>>> full_name('guido', 'van rossum')
'Full name: Guido Van Rossum'

>>> full_name = lambda first, last: f'Full name: {first.title()} {last.title()}'
>>> full_name('guido', 'van rossum')
'Full name: Guido Van Rossum'

>>>

>>> full_name = lambda first, last: f'Full name: {first.title()} {last.title()}'
>>> full_name('guido', 'van rossum')
'Full name: Guido Van Rossum'

Bạn cần gọi

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

>>> full_name = lambda first, last: f'Full name: {first.title()} {last.title()}'
>>> full_name('guido', 'van rossum')
'Full name: Guido Van Rossum'

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'

Lọc

Hàm tích hợp

>>> lambda x, y: x + y

>>>

>>> full_name = lambda first, last: f'Full name: {first.title()} {last.title()}'
>>> full_name('guido', 'van rossum')
'Full name: Guido Van Rossum'

Lưu ý rằng

>>> lambda x, y: x + y

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

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'

Giảm

Kể từ Python 3,

>>> lambda x, y: x + y

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

>>> full_name = lambda first, last: f'Full name: {first.title()} {last.title()}'
>>> full_name('guido', 'van rossum')
'Full name: Guido Van Rossum'

>>> lambda x, y: x + y

>>> lambda x, y: x + y

Để áp dụng

>>> lambda x, y: x + y

>>>

>>> full_name = lambda first, last: f'Full name: {first.title()} {last.title()}'
>>> full_name('guido', 'van rossum')
'Full name: Guido Van Rossum'

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

>>>

(lambda x: x + 1)(2) = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

>>> full_name = lambda first, last: f'Full name: {first.title()} {last.title()}'
>>> full_name('guido', 'van rossum')
'Full name: Guido Van Rossum'

>>>

>>> full_name = lambda first, last: f'Full name: {first.title()} {last.title()}'
>>> full_name('guido', 'van rossum')
'Full name: Guido Van Rossum'

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

>>> full_name = lambda first, last: f'Full name: {first.title()} {last.title()}'
>>> full_name('guido', 'van rossum')
'Full name: Guido Van Rossum'