Chức năng Lambda trong việc hiểu danh sách

Tại sao đầu ra của hai cách hiểu danh sách sau đây khác nhau, mặc dù fvà lambdachức năng là như nhau?

f = lambda x: x*x
[f(x) for x in range(10)]

và

[lambda x: x*x for x in range(10)]

Tâm trí bạn, cả hai type(f)và type(lambda x: x*x)trả lại cùng một loại.

Cái đầu tiên tạo ra một hàm lambda duy nhất và gọi nó là mười lần.

Cái thứ hai không gọi hàm. Nó tạo ra 10 chức năng lambda khác nhau. Nó đặt tất cả những người trong một danh sách. Để làm cho nó tương đương với đầu tiên bạn cần:

[(lambda x: x*x)(x) for x in range(10)]

Hoặc tốt hơn:

[x*x for x in range(10)]

Câu hỏi này chạm vào một phần rất hôi thối của cú pháp Python "nổi tiếng" và "rõ ràng" - điều được ưu tiên, lambda hoặc để hiểu danh sách.

Tôi không nghĩ mục đích của OP là tạo ra một danh sách các ô vuông từ 0 đến 9. Nếu đó là trường hợp, chúng tôi có thể đưa ra nhiều giải pháp hơn nữa:

squares = []
for x in range(10): squares.append(x*x)

• đây là cách tốt của cú pháp mệnh lệnh.

Nhưng nó không phải là vấn đề. Vấn đề là W (hy) TF có phải là biểu hiện mơ hồ như vậy phản trực giác? Và tôi có một trường hợp ngu ngốc cho bạn vào cuối, vì vậy đừng bỏ qua câu trả lời của tôi quá sớm (tôi đã có nó trong một cuộc phỏng vấn xin việc).

Vì vậy, sự hiểu biết của OP đã trả về một danh sách lambdas:

[(lambda x: x*x) for x in range(10)]

Tất nhiên đây chỉ là 10 bản sao khác nhau của hàm bình phương, xem:

>>> [lambda x: x*x for _ in range(3)]
[<function <lambda> at 0x00000000023AD438>, <function <lambda> at 0x00000000023AD4A8>, <function <lambda> at 0x00000000023AD3C8>]

Lưu ý các địa chỉ bộ nhớ của lambdas - tất cả chúng đều khác nhau!

Tất nhiên bạn có thể có phiên bản "tối ưu" (haha) hơn của biểu thức này:

>>> [lambda x: x*x] * 3
[<function <lambda> at 0x00000000023AD2E8>, <function <lambda> at 0x00000000023AD2E8>, <function <lambda> at 0x00000000023AD2E8>]

Xem? 3 lần cùng lambda.

Xin lưu ý rằng tôi đã sử dụng _như là forbiến. Nó không có gì để làm với xtrong lambda(nó bị lu mờ lexically!). Hiểu rồi?

Tôi đang rời khỏi cuộc thảo luận, tại sao ưu tiên cú pháp không phải như vậy, tất cả đều có nghĩa là:

[lambda x: (x*x for x in range(10))]

có thể là : [[0, 1, 4, ..., 81]], hoặc [(0, 1, 4, ..., 81)], hoặc tôi thấy hợp lý nhất , đây sẽ là một listtrong 1 phần tử - generatortrả về các giá trị. Nó không phải là trường hợp, ngôn ngữ không hoạt động theo cách này.

NHƯNG GÌ, Nếu ...

Điều gì sẽ xảy ra nếu bạn không làm lu mờ forbiến và VÀ sử dụng nó trong lambdas ???

Vâng, sau đó tào lao xảy ra. Nhìn vào cái này

[lambda x: x * i for i in range(4)]

điều này có nghĩa là tất nhiên:

[(lambda x: x * i) for i in range(4)]

NHƯNG nó không có nghĩa là:

[(lambda x: x * 0), (lambda x: x * 1), ... (lambda x: x * 3)]

Điều này thật điên rồ!

Các lambdas trong việc hiểu danh sách là một đóng cửa trong phạm vi của sự hiểu biết này. Một đóng cửa từ vựng , vì vậy họ tham chiếu iqua tham chiếu, và không phải giá trị của nó khi chúng được đánh giá!

Vì vậy, biểu thức này:

[(lambda x: x * i) for i in range(4)]

IS đại khái là:

[(lambda x: x * 3), (lambda x: x * 3), ... (lambda x: x * 3)]

Tôi chắc rằng chúng ta có thể thấy nhiều hơn ở đây bằng cách sử dụng trình dịch ngược python (ý tôi là ví dụ như dismô-đun), nhưng đối với thảo luận về thuyết bất khả tri của Python-VM thì điều này là đủ. Quá nhiều cho câu hỏi phỏng vấn xin việc.

Bây giờ, làm thế nào để tạo ra một listsố nhân lambdas, mà thực sự nhân với số nguyên liên tiếp? Vâng, tương tự như câu trả lời được chấp nhận, chúng ta cần phá vỡ mối quan hệ trực tiếp ibằng cách gói nó vào một câu trả lời khác lambda, được gọi trong biểu thức hiểu danh sách:

Trước:

>>> a = [(lambda x: x * i) for i in (1, 2)]
>>> a[1](1)
2
>>> a[0](1)
2

Sau:

>>> a = [(lambda y: (lambda x: y * x))(i) for i in (1, 2)]
>>> a[1](1)
2
>>> a[0](1)
1

(Tôi cũng có biến lambda bên ngoài = i, nhưng tôi quyết định đây là giải pháp rõ ràng hơn - tôi đã giới thiệu yđể tất cả chúng ta có thể thấy phù thủy nào là phù hợp).

Chỉnh sửa 2019-08-30:

Theo gợi ý của @josoler, cũng có mặt trong câu trả lời của @sheridp - giá trị của "vòng lặp" hiểu danh sách có thể được "nhúng" vào bên trong một đối tượng - khóa được truy cập vào đúng thời điểm. Phần "Sau" ở trên thực hiện bằng cách gói nó vào phần khác lambdavà gọi nó ngay lập tức với giá trị hiện tại là i. Một cách khác (dễ đọc hơn một chút - nó không tạo ra hiệu ứng 'WAT') là lưu trữ giá trị ibên trong một partialđối tượng và để "bên trong" (bản gốc) lambdalấy nó làm đối số (được cung cấp bởi partialđối tượng tại thời gian của cuộc gọi), tức là:

Sau 2:

>>> from functools import partial
>>> a = [partial(lambda y, x: y * x, i) for i in (1, 2)]
>>> a[0](2), a[1](2)
(2, 4)

Tuyệt vời, nhưng vẫn có một chút thay đổi cho bạn! Giả sử chúng ta sẽ không làm cho trình đọc mã dễ dàng hơn và chuyển yếu tố theo tên (làm đối số từ khóa cho partial). Chúng ta hãy đổi tên:

Sau 2,5:

>>> a = [partial(lambda coef, x: coef * x, coef=i) for i in (1, 2)]
>>> a[0](1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: <lambda>() got multiple values for argument 'coef'

BÌNH THƯỜNG?

>>> a[0]()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: <lambda>() missing 1 required positional argument: 'x'

Đợi đã ... Chúng ta sẽ thay đổi số lượng đối số bằng 1 và chuyển từ "quá nhiều" sang "quá ít"?

Chà, nó không phải là một LỚN thực sự, khi chúng ta chuyển coefsang partialtheo cách này, nó trở thành một đối số từ khóa, vì vậy nó phải xuất hiện sau xđối số vị trí , như vậy:

Sau 3:

>>> a = [partial(lambda x, coef: coef * x, coef=i) for i in (1, 2)]
>>> a[0](2), a[1](2)
(2, 4)

Tôi thích phiên bản cuối cùng hơn lambda lồng nhau, nhưng với mỗi ...

Sự khác biệt lớn là ví dụ đầu tiên thực sự gọi lambda f(x), trong khi ví dụ thứ hai thì không.

Ví dụ đầu tiên của bạn tương đương với [(lambda x: x*x)(x) for x in range(10)]trong khi ví dụ thứ hai của bạn tương đương với [f for x in range(10)].

Cái đầu tiên

f = lambda x: x*x
[f(x) for x in range(10)]

chạy f()cho từng giá trị trong phạm vi, vì vậy nó làm f(x)cho từng giá trị

cái thứ hai

[lambda x: x*x for x in range(10)]

chạy lambda cho mỗi giá trị trong danh sách, vì vậy nó tạo ra tất cả các hàm đó.

Người đã gửi câu trả lời tốt nhưng quên đề cập đến phần quan trọng nhất trong quan điểm của tôi: Trong ví dụ thứ hai Xcủa danh sách hiểu là không giống như Xcác lambdachức năng, họ là hoàn toàn không liên quan. Vì vậy, ví dụ thứ hai thực sự giống như:

[Lambda X: X*X for I in range(10)]

Các lần lặp bên trong range(10)chỉ chịu trách nhiệm tạo 10 hàm lambda tương tự trong một danh sách (10 hàm riêng biệt nhưng hoàn toàn tương tự - trả lại công suất 2 của mỗi đầu vào).

Mặt khác, ví dụ đầu tiên hoạt động hoàn toàn khác nhau, bởi vì X của các lần lặp DO tương tác với các kết quả, với mỗi lần lặp, giá trị là X*Xdo đó kết quả sẽ là[0,1,4,9,16,25, 36, 49, 64 ,81]

Các câu trả lời khác là đúng, nhưng nếu bạn đang cố gắng tạo một danh sách các hàm, mỗi hàm có một tham số khác nhau, có thể được thực thi sau đó , đoạn mã sau sẽ thực hiện điều đó:

import functools
a = [functools.partial(lambda x: x*x, x) for x in range(10)]

b = []
for i in a:
    b.append(i())

In [26]: b
Out[26]: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Trong khi ví dụ được đặt ra, tôi thấy nó hữu ích khi tôi muốn một danh sách các hàm mà mỗi hàm in một cái gì đó khác nhau, nghĩa là

import functools
a = [functools.partial(lambda x: print(x), x) for x in range(10)]

for i in a:
    i()