Лямбда питона без переменных?

Подчеркивание-это соглашение Python для обозначения неиспользуемой переменной (например, инструменты статического анализа не сообщают о ней как о неиспользуемой переменной). В вашем случае лямбда-аргумент не используется, но созданный объект является функцией с одним аргументом, которая всегда возвращает True. Таким образом, ваша лямбда в некоторой степени аналогична постоянной функции в математике.

Похоже, что это функция, которая возвращает True независимо от этого.

Да, это функция (или лямбда), которая возвращает True. Подчеркивание , которое обычно является заполнителем для игнорируемой переменной, в этом случае не требуется.

Пример случай использования для такой функции (которая почти ничего не делает):

dd = collections.defaultdict(lambda: True)

При использовании в качестве аргумента к defaultdict, вы можете иметь True в качестве общего значения по умолчанию.

Лямбда означает функцию. Приведенное выше утверждение то же самое, что и написание

def f(_):
    return True

Для лямбды переменная должна присутствовать. Таким образом, вы передаете ему переменную с именем _(аналогично вы могли бы передать x, y..)

Подчеркивание _ является допустимым идентификатором и используется здесь в качестве имени переменной. Он всегда возвращает True для аргумента, переданного функции.

>>>a('123') 
True

Ниже приводится строка кода, о которой идет речь:

a = lambda _:True

Он создает функцию, имеющую один входной параметр: _. Подчеркивание-довольно странный выбор имени переменной, но это всего лишь имя переменной. Вы можете использовать _ где угодно, даже если не используете лямбда-функции. Например, вместо....

my_var = 5
print(my_var)

Вы могли бы написать:

_ = 5
print(_)

Однако была причина, по которой _ использовалось в качестве имени параметра name вместо чего-то вроде x или input. Мы получим к этому через мгновение. Во-первых, мы должны знать, что лямбда-ключевое слово создает функцию, подобную def, но с другим синтаксисом. Определение лямбда-функции, a = lambda _:True, аналогично записи:

def a(_):
    return True

Он создает функцию с именем a с входным параметром _ и возвращает True. Можно было бы так же легко написать a = lambda x:True, с x вместо подчеркивания. Однако соглашение заключается в использовании _ в качестве имени переменной, когда мы не намерены чтобы использовать эту переменную. Рассмотрим следующее:

for _ in range(1, 11):
    print('pear')

Обратите внимание, что индекс цикла никогда не используется внутри тела цикла. Мы просто хотим, чтобы цикл выполнялся определенное количество раз. Как написал winklerrr, " имя переменной _ является [...] как "выбрасываемая переменная", просто заполнитель, который бесполезен. "

Аналогично, с `a = lambda x: True входной параметр не используется внутри тела функции. На самом деле не имеет значения, какой ввод аргумент есть, пока он есть. Автор этой лямбда-функции написал _ вместо чего-то вроде x, чтобы указать, что переменная не будет использоваться.

Обратите внимание, что лямбда действительно имеет аргумент; поэтому написание

a(), вызовет ошибку.

Если вам нужна лямбда без аргумента, напишите что-нибудь вроде этого:

 bar = lambda: True

Теперь вызов bar(), без args, будет работать просто отлично. Лямбда, которая не принимает аргументов, нужна не всегда. возвращает то же значение:

import random
process_fruit = lambda : random.random()

Лямбда-функция выше является более сложной, чем просто нечто, которое всегда возвращает одну и ту же константу. Одна из причин, по которой программисты иногда используют ключевое слово lambda вместо def, - это функции, которые особенно коротки и просты. Обратите внимание, что определение lambda обычно может поместиться все на одной строке, в то время как, трудно сделать то же самое с оператором def. Еще одна причина использовать lambda вместо def sf, когда функция не будет быть использованным снова. Если мы не хотим вызывать функцию позже, то нет необходимости давать ей имя. Например, рассмотрим следующий код:

Def apply_to_each (transform, in_container): out_container = список() для idx элемент в enumerate (контейнер, 0): out_container[индекс] = преобразовать(пункт) return out_container

Теперь мы делаем следующий вызов:

squares  = apply_to_each(lambda x: x**2 range(0, 101))

Обратите внимание, что lambda x: x**2 не имеет метки. Это потому, что мы, вероятно, не будем Позвоните позже, это было просто что-то короткое и простое, что нам нужно было временно. Тот факт, что лямбда-функциям не нужно давать имя, является источником другого имени для их описания: "анонимные функции."

Также обратите внимание, что лямбда-операторы подобны вызову функции в том, что они возвращают ссылку на созданную ими функцию. Следующее является незаконным:

apply_to_each(def foo(x): x**2 ,  range(0, 101))

В то время как, apply_to_each(lambda x: x**2 range(0, 101)) просто прекрасно.

Итак, мы используем lambda вместо def и _ вместо длинного имени переменной, когда мы хотим что-то короткое, сладкое и, вероятно, не захотим использовать снова позже.