Ml giải pháp bài tập Coursera-python

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 được phát minh bởi Alan Turing. 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 là 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,

[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

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

[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

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

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

• từ khóa.

  [lambda x: x + 1][2] = lambda 2: 2 + 1
                       = 2 + 1
                       = 3
  

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

  [lambda x: x + 1][2] = lambda 2: 2 + 1
                       = 2 + 1
                       = 3
  

  12
• Một cơ thể.

  [lambda x: x + 1][2] = lambda 2: 2 + 1
                       = 2 + 1
                       = 3
  

  12

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

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

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

>>>

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

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

[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

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

>>>

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

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

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

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 nhiều đối số [các hàm nhận nhiều hơn một đối số] được thể hiện bằng lambdas Python bằng cách liệt kê các đối số và phân tách chúng bằng dấu phẩ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

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

[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

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

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

Mô-đun

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

>>>

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

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

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

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

>>>

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

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à

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

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à

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

>>>

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

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à

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

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

>>>

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

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,

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

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 loại
• 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ư

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

>>>

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

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

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

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 nội dung của

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

>>>

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

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

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

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 bình 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

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

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

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

>>>

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

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

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

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

>>>

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

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ư

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

Tranh luận

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

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

• đố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

>>>

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

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

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

Trong ví dụ trên,

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

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

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

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

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

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

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

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

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

Kết quả

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

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

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

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

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

• [lambda x: x + 1][2] = lambda 2: 2 + 1
                       = 2 + 1
                       = 3
  

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

  class MyClass:
      my_attr = False
      def __init__[self, value]:
          self.value = value
  myinstance = MyClass[25]
  
  x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
  short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
  # ^^^ this one works only for MyClass' attributes.
  
  print[MyClass.my_attr] # output: False
  x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
  print[MyClass.my_attr] # output: True
  x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
  print[MyClass.my_attr2] # output: 5
  short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
  print[MyClass.my_attr2] # output: 123
  
  print[myinstance.value] # output: 25
  x[myinstance, 'value', 500]
  print[myinstance.value] # output: 500
  

  67

• class MyClass:
      my_attr = False
      def __init__[self, value]:
          self.value = value
  myinstance = MyClass[25]
  
  x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
  short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
  # ^^^ this one works only for MyClass' attributes.
  
  print[MyClass.my_attr] # output: False
  x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
  print[MyClass.my_attr] # output: True
  x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
  print[MyClass.my_attr2] # output: 5
  short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
  print[MyClass.my_attr2] # output: 123
  
  print[myinstance.value] # output: 25
  x[myinstance, 'value', 500]
  print[myinstance.value] # output: 500
  

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

  class MyClass:
      my_attr = False
      def __init__[self, value]:
          self.value = value
  myinstance = MyClass[25]
  
  x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
  short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
  # ^^^ this one works only for MyClass' attributes.
  
  print[MyClass.my_attr] # output: False
  x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
  print[MyClass.my_attr] # output: True
  x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
  print[MyClass.my_attr2] # output: 5
  short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
  print[MyClass.my_attr2] # output: 123
  
  print[myinstance.value] # output: 25
  x[myinstance, 'value', 500]
  print[myinstance.value] # output: 500
  

  67

• class MyClass:
      my_attr = False
      def __init__[self, value]:
          self.value = value
  myinstance = MyClass[25]
  
  x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
  short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
  # ^^^ this one works only for MyClass' attributes.
  
  print[MyClass.my_attr] # output: False
  x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
  print[MyClass.my_attr] # output: True
  x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
  print[MyClass.my_attr2] # output: 5
  short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
  print[MyClass.my_attr2] # output: 123
  
  print[myinstance.value] # output: 25
  x[myinstance, 'value', 500]
  print[myinstance.value] # output: 500
  

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

  class MyClass:
      my_attr = False
      def __init__[self, value]:
          self.value = value
  myinstance = MyClass[25]
  
  x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
  short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
  # ^^^ this one works only for MyClass' attributes.
  
  print[MyClass.my_attr] # output: False
  x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
  print[MyClass.my_attr] # output: True
  x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
  print[MyClass.my_attr2] # output: 5
  short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
  print[MyClass.my_attr2] # output: 123
  
  print[myinstance.value] # output: 25
  x[myinstance, 'value', 500]
  print[myinstance.value] # output: 500
  

  68

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

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

lst = [15, 30, 45, 60, 75, 90]

x = lambda iterable, item, value: iterable.__setitem__[item, value]

print[lst] # output: [15, 30, 45, 60, 75, 90]
x[lst, 2, 1000]
print[lst] # output: [15, 30, 1000, 60, 75, 90]

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

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

Tương tự, một

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

lst = [15, 30, 45, 60, 75, 90]

x = lambda iterable, item, value: iterable.__setitem__[item, value]

print[lst] # output: [15, 30, 45, 60, 75, 90]
x[lst, 2, 1000]
print[lst] # output: [15, 30, 1000, 60, 75, 90]

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

lst = [15, 30, 45, 60, 75, 90]

x = lambda iterable, item, value: iterable.__setitem__[item, value]

print[lst] # output: [15, 30, 45, 60, 75, 90]
x[lst, 2, 1000]
print[lst] # output: [15, 30, 1000, 60, 75, 90]

Ở dòng 6,

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

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

>>>

lst = [15, 30, 45, 60, 75, 90]

x = lambda iterable, item, value: iterable.__setitem__[item, value]

print[lst] # output: [15, 30, 45, 60, 75, 90]
x[lst, 2, 1000]
print[lst] # output: [15, 30, 1000, 60, 75, 90]

Trong một hàm thông thường,

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

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

>>>

lst = [15, 30, 45, 60, 75, 90]

x = lambda iterable, item, value: iterable.__setitem__[item, value]

print[lst] # output: [15, 30, 45, 60, 75, 90]
x[lst, 2, 1000]
print[lst] # output: [15, 30, 1000, 60, 75, 90]

Kết quả không mong muốn xảy ra do biến tự do

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

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

>>>

lst = [15, 30, 45, 60, 75, 90]

x = lambda iterable, item, value: iterable.__setitem__[item, value]

print[lst] # output: [15, 30, 45, 60, 75, 90]
x[lst, 2, 1000]
print[lst] # output: [15, 30, 1000, 60, 75, 90]

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ố

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

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

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

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ả

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

Mô-đun

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

lst = [15, 30, 45, 60, 75, 90]

x = lambda iterable, item, value: iterable.__setitem__[item, value]

print[lst] # output: [15, 30, 45, 60, 75, 90]
x[lst, 2, 1000]
print[lst] # output: [15, 30, 1000, 60, 75, 90]

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

lst = [15, 30, 45, 60, 75, 90]

x = lambda iterable, item, value: iterable.__setitem__[item, value]

print[lst] # output: [15, 30, 45, 60, 75, 90]
x[lst, 2, 1000]
print[lst] # output: [15, 30, 1000, 60, 75, 90]

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

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

Mô-đun

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

lst = [15, 30, 45, 60, 75, 90]

x = lambda iterable, item, value: iterable.__setitem__[item, value]

print[lst] # output: [15, 30, 45, 60, 75, 90]
x[lst, 2, 1000]
print[lst] # output: [15, 30, 1000, 60, 75, 90]

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

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

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

lst = [15, 30, 45, 60, 75, 90]

x = lambda iterable, item, value: iterable.__setitem__[item, value]

print[lst] # output: [15, 30, 45, 60, 75, 90]
x[lst, 2, 1000]
print[lst] # output: [15, 30, 1000, 60, 75, 90]

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

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

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

>>>

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

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

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

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

>>>

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

Dấu gạch dướ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

>>>

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

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

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

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

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 hiển thị mã Python độc đáo dựa trên

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

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

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

Mặc dù

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

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

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

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

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

>>>

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

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ố

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

• class MyClass:
      my_attr = False
      def __init__[self, value]:
          self.value = value
  myinstance = MyClass[25]
  
  x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
  short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
  # ^^^ this one works only for MyClass' attributes.
  
  print[MyClass.my_attr] # output: False
  x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
  print[MyClass.my_attr] # output: True
  x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
  print[MyClass.my_attr2] # output: 5
  short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
  print[MyClass.my_attr2] # output: 123
  
  print[myinstance.value] # output: 25
  x[myinstance, 'value', 500]
  print[myinstance.value] # output: 500
  

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

• class MyClass:
      my_attr = False
      def __init__[self, value]:
          self.value = value
  myinstance = MyClass[25]
  
  x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
  short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
  # ^^^ this one works only for MyClass' attributes.
  
  print[MyClass.my_attr] # output: False
  x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
  print[MyClass.my_attr] # output: True
  x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
  print[MyClass.my_attr2] # output: 5
  short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
  print[MyClass.my_attr2] # output: 123
  
  print[myinstance.value] # output: 25
  x[myinstance, 'value', 500]
  print[myinstance.value] # output: 500
  

  05,

  class MyClass:
      my_attr = False
      def __init__[self, value]:
          self.value = value
  myinstance = MyClass[25]
  
  x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
  short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
  # ^^^ this one works only for MyClass' attributes.
  
  print[MyClass.my_attr] # output: False
  x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
  print[MyClass.my_attr] # output: True
  x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
  print[MyClass.my_attr2] # output: 5
  short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
  print[MyClass.my_attr2] # output: 123
  
  print[myinstance.value] # output: 25
  x[myinstance, 'value', 500]
  print[myinstance.value] # output: 500
  

  06,

  class MyClass:
      my_attr = False
      def __init__[self, value]:
          self.value = value
  myinstance = MyClass[25]
  
  x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
  short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
  # ^^^ this one works only for MyClass' attributes.
  
  print[MyClass.my_attr] # output: False
  x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
  print[MyClass.my_attr] # output: True
  x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
  print[MyClass.my_attr2] # output: 5
  short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
  print[MyClass.my_attr2] # output: 123
  
  print[myinstance.value] # output: 25
  x[myinstance, 'value', 500]
  print[myinstance.value] # output: 500
  

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

• class Value:
      def __init__[self, value]:
          self.value = value
  
  x = lambda var, newvalue: setattr[var, 'value', newvalue]
  
  a = Value[15]
  print[a.value] # output: 15
  x[a, 25]
  print[a.value] # output: 25
  

  63 và

  class Value:
      def __init__[self, value]:
          self.value = value
  
  x = lambda var, newvalue: setattr[var, 'value', newvalue]
  
  a = Value[15]
  print[a.value] # output: 15
  x[a, 25]
  print[a.value] # output: 25
  

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

  class Value:
      def __init__[self, value]:
          self.value = value
  
  x = lambda var, newvalue: setattr[var, 'value', newvalue]
  
  a = Value[15]
  print[a.value] # output: 15
  x[a, 25]
  print[a.value] # output: 25
  

  65

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

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

class MyClass:
    my_attr = False
    def __init__[self, value]:
        self.value = value
myinstance = MyClass[25]

x = lambda obj, nameofvar, value: setattr[obj, nameofvar, value]
short_x = lambda nameofvar, value: setattr[MyClass, nameofvar, value]
# ^^^ this one works only for MyClass' attributes.

print[MyClass.my_attr] # output: False
x[MyClass, 'my_attr', True] # Changing MyClass' my_attr's value
print[MyClass.my_attr] # output: True
x[MyClass, 'my_attr2', 5] # Assigning new attribute to MyClass
print[MyClass.my_attr2] # output: 5
short_x['my_attr2', 123] # Setting MyClass' my_attr2 to 123
print[MyClass.my_attr2] # output: 123

print[myinstance.value] # output: 25
x[myinstance, 'value', 500]
print[myinstance.value] # output: 500

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

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

>>>

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

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 việc sử dụng 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

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

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

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

72

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

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

>>>

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

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

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

Một cách tiếp cận khác là sử dụng 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

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

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

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

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

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 [

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

Đ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

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

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

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

Với

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

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

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

Thực hiện kiểm tra

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

Thử nghiệm vượt qua khi chúng tôi xác nhận rằng

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

Bản đồ

Hàm dựng sẵ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

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

>>>

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

Bạn cần gọi

lst = [15, 30, 45, 60, 75, 90]

x = lambda iterable, item, value: iterable.__setitem__[item, value]

print[lst] # output: [15, 30, 45, 60, 75, 90]
x[lst, 2, 1000]
print[lst] # output: [15, 30, 1000, 60, 75, 90]

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

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

>>>

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

Lọc

Hàm dựng sẵ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

Lưu ý rằng

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

lst = [15, 30, 45, 60, 75, 90]

x = lambda iterable, item, value: iterable.__setitem__[item, value]

print[lst] # output: [15, 30, 45, 60, 75, 90]
x[lst, 2, 1000]
print[lst] # output: [15, 30, 1000, 60, 75, 90]

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

>>>

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

Giảm

Kể từ Python 3,

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

class Value:
    def __init__[self, value]:
        self.value = value

x = lambda var, newvalue: setattr[var, 'value', newvalue]

a = Value[15]
print[a.value] # output: 15
x[a, 25]
print[a.value] # output: 25

[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

Để áp dụng

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 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 bằng cách sử dụng biểu thức trình tạo, làm đối số cho

lst = [15, 30, 45, 60, 75, 90]

x = lambda iterable, item, value: iterable.__setitem__[item, value]

print[lst] # output: [15, 30, 45, 60, 75, 90]
x[lst, 2, 1000]
print[lst] # output: [15, 30, 1000, 60, 75, 90]

>>>

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

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

>>>

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

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

[lambda x: x + 1][2] = lambda 2: 2 + 1
                     = 2 + 1
                     = 3

lst = [15, 30, 45, 60, 75, 90]

x = lambda iterable, item, value: iterable.__setitem__[item, value]

print[lst] # output: [15, 30, 45, 60, 75, 90]
x[lst, 2, 1000]
print[lst] # output: [15, 30, 1000, 60, 75, 90]