Trăn lambda xy

Môn lịch sử

Nhà thờ Alonzo đã chính thức hóa phép tính 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 hàm lambda còn được gọi là trừu tượng lambda, một tham chiếu trực tiếp đến mô hình trừu tượng trong sáng tạo ban đầu của Alonzo Church

Phép tính Lambda có thể mã hóa bất kỳ phép tính nào. Nó là Turing hoàn chỉnh, nhưng trái ngược với khái niệm về máy Turing, nó thuần túy và không giữ bất kỳ trạng thái nào

Các ngôn ngữ hàm có nguồn gốc từ logic toán học và phép tính lambda, trong khi các ngôn ngữ lập trình mệnh lệnh sử dụng mô hình tính toán dựa trên trạng thái do Alan Turing phát minh. Hai mô hình tính toán, phép tính lambda và máy Turing, có thể dịch sang nhau. Sự tương đương này được gọi là giả thuyết Church-Turing

Các ngôn ngữ hàm kế thừa trực tiếp triết lý tính toán lambda, áp dụng cách tiếp cận lập trình khai báo nhấn mạnh tính 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 mệnh lệnh được tìm thấy trong các ngôn ngữ như Fortran, C hoặc Python

Phong cách mệnh lệnh bao gồm lập trình với các câu lệnh, điều khiển dòng chảy 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 họ thể hiện 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 tính năng chức năng đã thấm vào họ ngôn ngữ bắt buộc, đặc biệt với việc giới thiệu các hàm lambda trong Java hoặc Python

Python vốn dĩ không phải là một ngôn ngữ chức năng, nhưng nó đã sớm áp dụng một số khái niệm chức năng. Vào tháng 1 năm 1994,

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Ví dụ đầu tiên

Dưới đây là một vài ví dụ để giúp bạn cảm thấy ngon miệng với 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 thể hiện bằng định nghĩa hàm Python tiêu chuẩn bằng cách sử dụng từ khóa

def add_one(x):
    return x + 1

>>>

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

def add_one(x):
    return x + 1

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

Ngược lại, nếu bạn sử dụng cấu trúc lambda Python, bạn sẽ nhận được thông tin sau

>>>

def add_one(x):
    return x + 1

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

• từ khóa.

  def add_one(x):
      return x + 1
  

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

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

  0
• Một cơ thể.

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

  0

Ghi chú. Trong ngữ cảnh của bài viết này, một biến bị ràng buộc là một đối số cho hàm lambda

Ngược lại, một biến tự do không bị ràng buộc và có thể được tham chiếu trong phần thân của biểu thức. Một biến miễn phí có thể là một hằng số hoặc một biến được xác định trong phạm vi kèm theo của hàm

Bạn có thể viết một ví dụ phức tạp hơn một chút, một hàm thêm

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

>>>

def add_one(x):
    return x + 1

Bạn có thể áp dụng hàm ở trên cho một đối số bằng cách bao quanh hàm và đối số của nó bằng dấu ngoặc đơn

>>>

def add_one(x):
    return x + 1

Giảm là một chiến lược tính toán lambda để tính giá trị của biểu thức. Trong ví dụ hiện tại, nó bao gồm việc thay thế biến ràng buộc

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

def add_one(x):
    return x + 1

Vì hàm lambda là một biểu thức nên nó có thể được đặt tên. Do đó, bạn có thể viết mã trước đó như sau

>>>

def add_one(x):
    return x + 1

Hàm lambda ở trên tương đương với việc viết cái này

def add_one(x):
    return x + 1

Tất cả các chức năng này có một đối số duy nhất. Bạn có thể nhận thấy rằng, trong định nghĩa của lambdas, các đối số không có dấu ngoặc đơn xung quanh chúng. Các hàm đa đối số (các hàm nhận nhiều hơn một đối số) được thể hiện trong Python lambdas bằng cách liệt kê các đối số và phân tách chúng bằng dấu phẩy (

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

Hàm lambda được gán cho

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

def add_one(x):
    return x + 1

Chức năng

Tại thời điểm này, bạn có thể thắc mắc về cơ bản điều gì phân biệt một hàm lambda được liên kết với một biến với một hàm thông thường có một dòng

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Mô-đun

def add_one(x):
    return x + 1

>>>

def add_one(x):
    return x + 1

Bạn có thể thấy rằng

def add_one(x):
    return x + 1

Bây giờ hãy xem nó với một đối tượng chức năng thông thường

>>>

def add_one(x):
    return x + 1

Mã byte được giải thích bởi Python giống nhau cho cả hai chức năng. Nhưng bạn có thể nhận thấy rằng cách đặt tên khác. tên hàm là

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Tìm lại

Bạn đã thấy trong phần trước rằng, trong ngữ cảnh của hàm lambda, Python không cung cấp tên của hàm, mà chỉ cung cấp tên của hàm là

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

>>>

def add_one(x):
    return x + 1

Truy nguyên của một ngoại lệ được đưa ra trong khi hàm lambda được thực thi chỉ xác định hàm gây ra ngoại lệ là

def add_one(x):
    return x + 1

Đây là ngoại lệ tương tự được đưa ra bởi một chức năng bình thường

>>>

def add_one(x):
    return x + 1

Hàm bình thường gây ra lỗi tương tự nhưng dẫn đến truy nguyên chính xác hơn vì nó cung cấp tên hàm,

def add_one(x):
    return x + 1

cú pháp

Như bạn đã thấy trong các phần trước, biểu mẫu lambda thể hiện sự khác biệt về cú pháp với một hàm thông 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à không thể bao gồm các câu lệnh trong phần thân của nó
• Nó được viết dưới dạng một dòng thực thi
• Nó không hỗ trợ chú thích kiểu
• Nó có thể được gọi ngay lập tức (IIFE)

không có báo cáo

Hàm lambda không được chứa bất kỳ câu lệnh nào. Trong một hàm lambda, các câu lệnh như

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

>>>

def add_one(x):
    return x + 1

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

def add_one(x):
    return x + 1

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

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Biểu thức đơn

Ngược lại với một hàm thông thường, hàm lambda trong Python là một biểu thức đơn. Mặc dù, trong phần thân của

def add_one(x):
    return x + 1

>>>

def add_one(x):
    return x + 1

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

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Loại chú thích

Nếu bạn đã bắt đầu áp dụng gợi ý kiểu, hiện đã có trong Python, thì bạn có một lý do chính đáng khác để thích các hàm thông thường hơn các hàm lambda của Python. Xem 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 một hàm lambda, không có tương đương với những điều sau đây

def add_one(x):
    return x + 1

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

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

>>>

def add_one(x):
    return x + 1

Giống như cố gắng đưa một câu lệnh vào lambda, việc thêm chú thích loại ngay lập tức dẫn đến một

def add_one(x):
    return x + 1

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

>>>

def add_one(x):
    return x + 1

Ngoài trình thông dịch Python, tính năng này có lẽ không được sử dụng trong thực tế. Đó là hệ quả trực tiếp của hàm lambda có thể gọi được khi nó được định nghĩa. Ví dụ: điều này cho phép bạn chuyển định nghĩa của biểu thức lambda Python sang một hàm bậc cao hơn như

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Tranh luận

Giống như một đối tượng hàm bình thường được định nghĩa bằng

def add_one(x):
    return x + 1

• đối số vị trí
• Đối số được đặt tên (đôi khi được gọi là đối số từ khóa)
• Danh sách biến đối số (thường được gọi là varargs)
• Danh sách biến của các đối số từ khóa
• Đối số chỉ từ khóa

Các ví dụ sau minh họa các tùy chọn mở cho bạn để chuyển đối số cho biểu thức lambda

>>>

def add_one(x):
    return x + 1

người trang trí

Trong Python, một trình trang trí là việc triển khai một mẫu cho phép thêm một hành vi vào một hàm hoặc một lớp. Nó thường được thể hiện bằng cú pháp

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Trong ví dụ trên,

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Một trình trang trí có thể được áp dụng cho lambda. Mặc dù không thể trang trí lambda bằng cú pháp

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Xem cách, như bạn đã thấy, tên của hàm lambda xuất hiện dưới dạng

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Trang trí hàm 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 ngữ cảnh của hàm bậc cao hơn hoặc hàm chính. Hãy xem một ví dụ với

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

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

def add_one(x):
    return x + 1

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

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Kết quả

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

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

def add_one(x):
    return x + 1

Lambda cũng có thể là một công cụ trang trí, nhưng nó không được khuyến khích. Nếu bạn thấy mình cần làm điều này, hãy tham khảo PEP 8, Đề xuất lập trình

Để biết thêm về trình trang trí Python, hãy xem Primer on Python Decorators

Khép kín

Bao đóng là một hàm trong đó mọi biến tự do, mọi thứ trừ 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 đó. Trên thực tế, các bao đóng xác định môi trường mà chúng chạy và do đó có thể được gọi từ bất kỳ đâu

Các khái niệm về lambda và bao đóng không nhất thiết phải liên quan với nhau, mặc dù các hàm lambda có thể đóng theo cách giống như các hàm thông thường cũng có thể đóng. Một số ngôn ngữ 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àm đố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 là một bao đóng được xây dựng bằng hàm Python bình thường

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

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

  0 được truyền dưới dạng đối số cho

  def add_one(x):
      return x + 1
  

  057

• def add_one(x):
      return x + 1
  

  061 là biến cục bộ của

  def add_one(x):
      return x + 1
  

  057

• def add_one(x):
      return x + 1
  

  063 là một đối số được truyền cho

  def add_one(x):
      return x + 1
  

  058

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

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

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

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

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

def add_one(x):
    return x + 1

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

def add_one(x):
    return x + 1

Tương tự, một

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Khi bạn thực thi đoạn mã trên, bạn nhận được đầu ra sau

def add_one(x):
    return x + 1

Ở dòng 6,

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

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

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

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

def add_one(x):
    return x + 1

Trong tình huống này, cả chức năng bình thường và lambda đều hoạt động giống nhau. Trong phần tiếp theo, bạn sẽ thấy tình huống trong đó hành vi của lambda có thể bị đánh lừa do thời gian đánh giá của nó (thời gian xác định 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 vòng lặp, hành vi của hàm lambda Python dưới dạng bao đóng 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 ngữ cảnh của lambda. Các ví dụ sau minh họa sự khác biệt khi sử dụng hàm thông thường so với sử dụng Python lambda

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

Trong một chức năng bình thường,

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Bây giờ, với việc triển khai logic tương tự với hàm lambda, hãy quan sát hành vi không mong muốn

>>>

def add_one(x):
    return x + 1

Kết quả không mong muốn xảy ra vì biến miễn phí

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Để khắc phục vấn đề này, bạn có thể gán biến tự do tại thời điểm định nghĩa như sau

>>>

def add_one(x):
    return x + 1

Một hàm lambda Python hoạt động giống như một hàm bình thường đối với các đối số. Do đó, một tham số lambda có thể được khởi tạo với giá trị mặc định. tham số

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Hàm lambda Python đượ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

def add_one(x):
    return x + 1

Kiểm tra Lambda

Lambdas Python có thể được kiểm tra tương tự như các chức năng thông thường. Có thể sử dụng cả

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Mô-đun

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Như mong đợi, chúng tôi có hai trường hợp thử nghiệm thành công và một trường hợp thất bại cho

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Mô-đun

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

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

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Kết quả kiểm tra thất bại từ lỗi tương tự được giải thích trong quá trình thực hiện kiểm tra đơn vị trong phần trước

Bạn có thể thêm một

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Để biết tổng quan toàn diện về thử nghiệm đơn vị trong Python, bạn có thể tham khảo Bắt đầu với thử nghiệm trong Python

Tăng một ngoại lệ

Cố gắng đưa ra một ngoại lệ trong Python lambda sẽ khiến bạn phải suy nghĩ kỹ. Có một số cách thông minh để làm như vậy, nhưng ngay cả những cách như sau vẫn tốt hơn để tránh

>>>

def add_one(x):
    return x + 1

Vì một câu lệnh không đúng về mặt cú pháp trong phần thân lambda của Python, nên cách giải quyết trong ví dụ trên bao gồm trừu tượng hóa lệnh gọi câu lệnh bằng một hàm chuyên dụng

def add_one(x):
    return x + 1

Phong cách mật mã

Như trong bất kỳ ngôn ngữ lập trình nào, bạn sẽ thấy mã Python khó đọc do phong cách được sử dụng. Các hàm lambda, do tính ngắn gọn của chúng, có thể thuận 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

>>>

def add_one(x):
    return x + 1

Dấu gạch dưới (

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

>>>

def add_one(x):
    return x + 1

Phải thừa nhận rằng nó vẫn còn khó đọc. Bằng cách vẫn tận dụng một

def add_one(x):
    return x + 1

>>>

def add_one(x):
    return x + 1

Điều này vẫn chưa tối ưu nhưng cho bạn thấy một đường dẫn khả thi để tạo mã và đặc biệt là các hàm lambda của Python, dễ đọc hơn. Trong Các lựa chọn thay thế cho Lambdas, bạn sẽ học cách thay thế

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Lớp học Python

Bạn có thể nhưng không nên viết các phương thức lớp dưới dạng các hàm lambda Python. Ví dụ sau đây là mã Python hoàn toàn hợp pháp nhưng thể hiện mã Python độc đáo dựa trên

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

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

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Mặc dù

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

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

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Theo nguyên tắc chung, trong ngữ cảnh mã được viết bằng Python, hãy ưu tiên các hàm thông thường hơn 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 được sử dụng với các hàm tích hợp sẵn

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

>>>

def add_one(x):
    return x + 1

Bạn có thể phải đọc mã giống như các ví dụ trên, mặc dù có nhiều dữ liệu phù hợp hơn. Vì lý do đó, điều quan trọng là phải nhận ra những 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 Lambda, bạn sẽ tìm hiểu cách chuyển đổi các hàm bậc cao hơn và các lambda đi kèm của chúng thành các dạng 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 lấy tham số

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

• def add_one(x):
      return x + 1
  

  04. phương pháp liệt kê

• def add_one(x):
      return x + 1
  

  05,

  def add_one(x):
      return x + 1
  

  06,

  def add_one(x):
      return x + 1
  

  07. Chức năng tích hợp sẵn

• def add_one(x):
      return x + 1
  

  553 và

  def add_one(x):
      return x + 1
  

  554. trong mô-đun thuật toán hàng đợi Heap

  def add_one(x):
      return x + 1
  

  555

Hãy tưởng tượng rằng bạn muốn sắp xếp danh sách ID được biểu thị dưới dạng chuỗi. Mỗi ID là phần nối của chuỗi

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Để tác động đến việc thực thi sắp xếp, bạn có thể gán lambda cho đối số có tên là

def add_one(x):
    return x + 1

>>>

def add_one(x):
    return x + 1

Khung giao diện người dùng

Các khung giao diện người dùng như Tkinter, wxPython hoặc. NET Windows Forms với IronPython tận dụng các chức năng lambda để ánh xạ các hành động để đáp ứng với các sự kiện giao diện người dùng

Chương trình Tkinter ngây thơ dưới đây minh họa cách sử dụng

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Nhấp vào nút Đảo ngược kích hoạt một sự kiện kích hoạt hàm lambda, thay đổi nhãn từ Lambda Calculus thành suluclaC adbmaL*

Cả wxPython và IronPython trên. NET chia sẻ một cách tiếp cận tương tự để xử lý các sự kiện. Lưu ý rằng

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Để khám phá wxPython, hãy xem Cách xây dựng ứng dụng GUI Python với wxPython

Trình thông dịch Python

Khi bạn đang chơi với mã Python trong trình thông dịch tương tác, các hàm lambda của Python thường là một điều may mắn. Thật dễ dàng để tạo một chức năng một lớp lót nhanh chóng để khám phá một số đoạn mã sẽ không bao giờ nhìn thấy ánh sáng ban ngày bên ngoài trình thông dịch. Lambdas được viết trong trình thông dịch, để khám phá nhanh chóng, giống như giấy vụn mà bạn có thể vứt đi sau khi sử dụng

def add_one(x): return x + 1 562

Theo tinh thần giống như thử nghiệm trong trình thông dịch Python, mô-đun

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

>>>

def add_one(x):
    return x + 1

Khi câu lệnh được truyền dưới dạng chuỗi,

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Một cách tiếp cận khác là sử dụng một

def add_one(x):
    return x + 1

>>>

def add_one(x):
    return x + 1

Giải pháp này sạch hơn, dễ đọc hơn và nhập trình thông dịch nhanh hơn. Mặc dù thời gian thực hiện ít hơn một chút đối với phiên bản

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

khỉ vá

Để thử nghiệm, đôi khi cần phải dựa vào các kết quả có thể lặp lại, ngay cả khi trong quá trình thực thi bình thường của 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

Giả sử 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. Tuy nhiên, trong quá trình thực hiện thử nghiệm, bạn cần xác nhận các giá trị có thể dự đoán theo cách có thể lặp lại. Ví dụ sau đây cho thấy cách, với hàm

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Trình quản lý ngữ cảnh giúp cách ly hoạt động của khỉ vá một hàm từ thư viện chuẩn (

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Đ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

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

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

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Với

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Với vật cố định pytest

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Thực hiện kiểm tra

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

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

def add_one(x):
    return x + 1

Bản đồ

Hàm tích hợp sẵn

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

>>>

def add_one(x):
    return x + 1

Bạn cần gọi

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Sử dụng khả năng hiểu danh sách giúp loại bỏ nhu cầu xác định và gọi hàm lambda

>>>

def add_one(x):
    return x + 1

Lọc

Hàm tích hợp sẵn

def add_one(x):
    return x + 1

>>>

def add_one(x):
    return x + 1

Lưu ý rằng

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Việc triển khai tận dụng cấu trúc hiểu danh sách đưa ra những điều sau đây

>>>

def add_one(x):
    return x + 1

Giảm

Kể từ Python 3,

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1

Để áp dụng

def add_one(x):
    return x + 1

>>>

def add_one(x):
    return x + 1

Một cách tiếp cận thành ngữ hơn bằng cách sử dụng biểu thức trình tạo, làm đối số cho

def add_one(x):
    return x + 1

>>>

def add_one(x):
    return x + 1

Một giải pháp hơi khác và có thể sạch hơn sẽ loại bỏ nhu cầu truy cập rõ ràng vào phần tử đầu tiên của cặp và thay vào đó sử dụng giải nén

>>>

def add_one(x):
    return x + 1

Việc sử dụng dấu gạch dưới (

def add_one(x):
    return x + 1

def add_one(x):
    return x + 1