Hướng dẫn python pass lambda as argument - python vượt qua lambda làm đối số

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,

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

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

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

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

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

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

>>>

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

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

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:

Trong ví dụ trên, biểu thức bao gồm:

• Từ khóa:

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

  7

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

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

  def add_one(x):
      return x + 1
  

  0

  def add_one(x):
      return x + 1
  

  0
• Một cơ thể:

  def add_one(x):
      return x + 1
  

  0

  def add_one(x):
      return x + 1
  

  0

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

def add_one(x):
    return x + 1

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

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

def add_one(x):
    return x + 1

(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

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

def add_one(x):
    return x + 1

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'

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

def add_one(x):
    return x + 1

Hàm Lambda ở trên được xác định và sau đó được gọi ngay lập tức với hai đối số (def add_one(x): return x + 1 6 và >>> full_name = lambda first, last: f'Full name: {first.title()} {last.title()}' >>> full_name('guido', 'van rossum') 'Full name: Guido Van Rossum' 6). Nó trả về giá trị >>> full_name = lambda first, last: f'Full name: {first.title()} {last.title()}' >>> full_name('guido', 'van rossum') 'Full name: Guido Van Rossum' 7, 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

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

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.

>>>

def f(x):
    return x * 2

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:

>>>

def f(x):
    return x * 2

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 (

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

>>>

def f(x):
    return x * 2

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à

def f(x):
    return x * 2

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

>>>

def f(x):
    return x * 2

Hàm thông 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,

def f(x):
    return x * 2

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ư

>>> lambda x, y: x + y

def f(x):
    return x * 2

def f(x):
    return x * 2

def f(x):
    return x * 2

def f(x):
    return x * 2

def f(x):
    return x * 2

>>>

def f(x):
    return x * 2

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

def f(x):
    return x * 2

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def f(x):
    return x * 2

def f(x):
    return x * 2

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

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

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

>>>

def f(x):
    return x * 2

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

def f(x):
    return x * 2

def f(x):
    return x * 2

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:

def f(x):
    return x * 2

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

def f(x):
    return x * 2

def f(x):
    return x * 2

def f(x):
    return x * 2

def f(x):
    return x * 2

>>>

def f(x):
    return x * 2

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

def f(x):
    return x * 2

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:

>>>

print iterator(lambda x: x / 4 + 12, 100, 5)

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ư

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

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

>>> lambda x, y: x + y

Tranh luận

Giống như một đối tượng hàm bình thường được xác định với

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

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

>>>

print iterator(lambda x: x / 4 + 12, 100, 5)

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

def f(x):
    return x * 2

print iterator(lambda x: x / 4 + 12, 100, 5)

Trong ví dụ trên,

def f(x):
    return x * 2

def f(x):
    return x * 2

def f(x):
    return x * 2

print iterator(lambda x: x / 4 + 12, 100, 5)

def f(x):
    return x * 2

def f(x):
    return x * 2

def f(x):
    return x * 2

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

def f(x):
    return x * 2

print iterator(lambda x: x / 4 + 12, 100, 5)

def f(x):
    return x * 2

def f(x):
    return x * 2

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

def f(x):
    return x * 2

print iterator(lambda x: x / 4 + 12, 100, 5)

Xem cách, như bạn đã thấy, tên của hàm Lambda xuất hiện là

def f(x):
    return x * 2

def f(x):
    return x * 2

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

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

print iterator(lambda x: x / 4 + 12, 100, 5)

Đối số đầu tiên của

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

def add_one(x):
    return x + 1

def f(x):
    return x * 2

print iterator(lambda x: x / 4 + 12, 100, 5)

Kết quả

def f(x):
    return x * 2

def f(x):
    return x * 2

def f(x):
    return x * 2

def f(x):
    return x * 2

Bạn sẽ được tiếp xúc với

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

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:

print iterator(lambda x: x / 4 + 12, 100, 5)

def f(x):
    return x * 2

def f(x):
    return x * 2

• def add_one(x):
      return x + 1
  

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

  def f(x):
      return x * 2
  

  55. is passed as an argument to

  def f(x):
      return x * 2
  

  55.

• def f(x):
      return x * 2
  

  59 là một biến cục bộ đến

  def f(x):
      return x * 2
  

  55. is a variable local to

  def f(x):
      return x * 2
  

  55.

• def f(x):
      return x * 2
  

  61 là một đối số được chuyển đến

  def f(x):
      return x * 2
  

  56. is an argument passed to

  def f(x):
      return x * 2
  

  56.

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

def f(x):
    return x * 2

def f(x):
    return x * 2

def f(x):
    return x * 2

def f(x):
    return x * 2

print iterator(lambda x: x / 4 + 12, 100, 5)

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

def f(x):
    return x * 2

def f(x):
    return x * 2

def f(x):
    return x * 2

def f(x):
    return x * 2

def add_one(x):
    return x + 1

def f(x):
    return x * 2

def add_one(x):
    return x + 1

def f(x):
    return x * 2

Tương tự, một

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

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

Khi bạn thực thi mã ở trên, bạn có được đầu ra sau:

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

Trên dòng 6,

def f(x):
    return x * 2

def f(x):
    return x * 2

def add_one(x):
    return x + 1

def f(x):
    return x * 2

def f(x):
    return x * 2

def add_one(x):
    return x + 1

def f(x):
    return x * 2

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:

>>>

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

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

def f(x):
    return x * 2

def f(x):
    return x * 2

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

>>>

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

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

def f(x):
    return x * 2

def f(x):
    return x * 2

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

>>>

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

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

def f(x):
    return x * 2

def f(x):
    return x * 2

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

Kết quả bất ngờ xảy ra do biến miễn phí def f(x): return x * 2 83, như được triển khai, bị ràng buộc tại thời điểm thực hiện của biểu thức Lambda. Hàm Python Lambda trên dòng 4 là một đóng cửa thu thập def f(x): return x * 2 83, một biến miễn phí bị ràng buộc trong thời gian chạy. Khi chạy, trong khi gọi hàm def f(x): return x * 2 87 trên dòng 7, giá trị của def f(x): return x * 2 83 là def f(x): return x * 2 89.

Để khắc phục vấn đề này, bạn có thể chỉ định biến miễn phí theo thời gian định nghĩa như sau:

def f(x):
    return x * 2

Hàm Lambda Python hoạt động giống như một hàm bình thường liên quan đến các đối số. Do đó, tham số Lambda có thể được khởi tạo với giá trị mặc định: tham số

def f(x):
    return x * 2

def f(x):
    return x * 2

def f(x):
    return x * 2

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

def f(x):
    return x * 2

def f(x):
    return x * 2

print iterator(lambda x: x / 4 + 12, 100, 5)

def f(x):
    return x * 2

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

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

print iterator(lambda x: x / 4 + 12, 100, 5)

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

print iterator(lambda x: x / 4 + 12, 100, 5)

print iterator(lambda x: x / 4 + 12, 100, 5)

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

def f(x):
    return x * 2

def f(x):
    return x * 2

Mô -đun

def f(x):
    return x * 2

print iterator(lambda x: x / 4 + 12, 100, 5)

print iterator(lambda x: x / 4 + 12, 100, 5)

print iterator(lambda x: x / 4 + 12, 100, 5)

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

def f(x):
    return x * 2

def f(x):
    return x * 2

Khi bạn thực hiện các bài kiểm tra qua

print iterator(lambda x: x / 4 + 12, 100, 5)

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

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

print iterator(lambda x: x / 4 + 12, 100, 5)

print iterator(lambda x: x / 4 + 12, 100, 5)

print iterator(lambda x: x / 4 + 12, 100, 5)

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

>>>

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

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

print iterator(lambda x: x / 4 + 12, 100, 5)

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:

>>>

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

print iterator(lambda x: x / 4 + 12, 100, 5)

>>>

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

print iterator(lambda x: x / 4 + 12, 100, 5)

>>>

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

print iterator(lambda x: x / 4 + 12, 100, 5)

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.

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

Ví dụ Lambda sau đây chứa một số lựa chọn kiểu xấu:

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

Mặc dù

print iterator(lambda x: x / 4 + 12, 100, 5)

print iterator(lambda x: x / 4 + 12, 100, 5)

print iterator(lambda x: x / 4 + 12, 100, 5)

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

print iterator(lambda x: x / 4 + 12, 100, 5)

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

print iterator(lambda x: x / 4 + 12, 100, 5)

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

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

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

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

>>> lambda x, y: x + y

print iterator(lambda x: x / 4 + 12, 100, 5)

>>>

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

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 hàm chính trong Python là các hàm bậc cao hơn lấy tham số

print iterator(lambda x: x / 4 + 12, 100, 5)

print iterator(lambda x: x / 4 + 12, 100, 5)

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

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

  2: Phương pháp liệt kê list method

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

  3,

  >>> lambda x, y: x + y
  

  4,

  >>> lambda x, y: x + y
  

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

• print iterator(lambda x: x / 4 + 12, 100, 5)
  

  51 và

  print iterator(lambda x: x / 4 + 12, 100, 5)
  

  52: Trong mô -đun thuật toán hàng đợi heap

  print iterator(lambda x: x / 4 + 12, 100, 5)
  

  53 in the Heap queue algorithm module

  print iterator(lambda x: x / 4 + 12, 100, 5)
  

  53

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

print iterator(lambda x: x / 4 + 12, 100, 5)

>>> lambda x, y: x + y

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

print iterator(lambda x: x / 4 + 12, 100, 5)

>>>

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

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 hàm chính trong Python là các hàm bậc cao hơn lấy tham số

print iterator(lambda x: x / 4 + 12, 100, 5)

print iterator(lambda x: x / 4 + 12, 100, 5)

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

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

>>> lambda x, y: x + y

>>> lambda x, y: x + y

>>> lambda x, y: x + y

>>> lambda x, y: x + y

print iterator(lambda x: x / 4 + 12, 100, 5)

print iterator(lambda x: x / 4 + 12, 100, 5)

print iterator(lambda x: x / 4 + 12, 100, 5)

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 print iterator(lambda x: x / 4 + 12, 100, 5) 54 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 >>> lambda x, y: x + y 3, 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

print iterator(lambda x: x / 4 + 12, 100, 5)

print iterator(lambda x: x / 4 + 12, 100, 5) 60

Khung UI

>>>

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

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

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

>>>

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

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

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

print iterator(lambda x: x / 4 + 12, 100, 5)

print iterator(lambda x: x / 4 + 12, 100, 5)

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

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

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

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 (

print iterator(lambda x: x / 4 + 12, 100, 5)

print iterator(lambda x: x / 4 + 12, 100, 5)

Đ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

print iterator(lambda x: x / 4 + 12, 100, 5)

print iterator(lambda x: x / 4 + 12, 100, 5)

print iterator(lambda x: x / 4 + 12, 100, 5)

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

def f(x):
    return x * 2

print iterator(lambda x: x / 4 + 12, 100, 5)

Với

print iterator(lambda x: x / 4 + 12, 100, 5)

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

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

Với trận đấu pytest

print iterator(lambda x: x / 4 + 12, 100, 5)

print iterator(lambda x: x / 4 + 12, 100, 5)

print iterator(lambda x: x / 4 + 12, 100, 5)

print iterator(lambda x: x / 4 + 12, 100, 5)

print iterator(lambda x: x / 4 + 12, 100, 5)

Thực hiện kiểm tra

print iterator(lambda x: x / 4 + 12, 100, 5)

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

Bài kiểm tra vượt qua khi chúng tôi xác nhận rằng

print iterator(lambda x: x / 4 + 12, 100, 5)

Bản đồ

Hàm tích hợp

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

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

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

>>>

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

Bạn cần gọi

print iterator(lambda x: x / 4 + 12, 100, 5)

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

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:

>>>

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

Lọc

Hàm tích hợp

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

>>>

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

Lưu ý rằng

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

print iterator(lambda x: x / 4 + 12, 100, 5)

Việc thực hiện thúc đẩy cấu trúc hiểu danh sách đưa ra như sau:

>>>

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

Giảm

Kể từ Python 3,

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

print iterator(lambda x: x / 4 + 12, 100, 5)

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

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

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

Để áp dụng

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

>>>

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

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

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

>>>

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

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

>>>

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

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

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

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