Python Funkce lambda s PŘÍKLADY

V čem je funkce Lambda Python?

A Funkce lambda v Python programování je anonymní funkce nebo funkce bez názvu. Je to malá a omezená funkce, která nemá více než jeden řádek. Stejně jako normální funkce může mít funkce Lambda více argumentů s jedním výrazem.

In Pythonlambda výrazy (nebo lambda formy) se používají ke konstrukci anonymních funkcí. K tomu použijete lambda klíčové slovo (stejně jako používáte def definovat normální funkce). Každá anonymní funkce, kterou definujete Python bude mít 3 základní části:

• Klíčové slovo lambda.
• Parametry (nebo vázané proměnné) a
• Tělo funkce.

Funkce lambda může mít libovolný počet parametrů, ale tělo funkce může obsahovat pouze jedna výraz. Navíc je lambda zapsána na jediném řádku kódu a lze ji také okamžitě vyvolat. To vše uvidíte v akci v nadcházejících ukázkách.

Syntaxe a příklady

Formální syntaxe pro zápis funkce lambda je uvedena níže:

lambda p1, p2: expression

Zde jsou p1 a p2 parametry, které jsou předány funkci lambda. Můžete přidat tolik nebo málo parametrů, kolik potřebujete.

However, notice that we do not use brackets around the parameters as we do with regular functions. The last part (expression) is any valid Python expression that operates on the parameters you provide to the function.

Příklad 1

Nyní, když víte o lambdách, zkusme to na příkladu. Takže otevřete svůj IDLE a zadejte následující:

adder = lambda x, y: x + y
print (adder (1, 2))

Code Vysvětlení

Zde definujeme proměnnou, která bude obsahovat výsledek vrácený funkcí lambda.

1. Klíčové slovo lambda používané k definování anonymní funkce.

2. x a y jsou parametry, které předáváme funkci lambda.

3. Toto je tělo funkce, která přidává 2 parametry, které jsme předali. Všimněte si, že se jedná o jeden výraz. Do těla funkce lambda nelze zapsat více příkazů.

4. Zavoláme funkci a vypíšeme vrácenou hodnotu.

Příklad 2

That was a basic example to understand the fundamentals and syntax of lambda. Let us now try to print out a lambda and see the result. Again, open your IDLE a zadejte následující:

#What a lambda returns
string='some kind of a useless lambda'
print(lambda string : print(string))

Nyní uložte soubor a stisknutím klávesy F5 spusťte program. Toto je výstup, který byste měli dostat.

Výstup:

<function <lambda> at 0x00000185C3BF81E0>

What is happening here? Let us look at the code to understand further.

Code Vysvětlení:

1. Here, we define a šňůra that you will pass as a parameter to the lambda.

2. We declare a lambda that calls a print statement and prints the result.

But why does the program not print the string we pass? This is because the lambda itself returns a function object. In this example, the lambda is not being volal by the print function but is simply návratu the function object and the memory location where it is stored. That is what gets printed at the console.

Příklad 3

Pokud však napíšete program jako tento:

#What a lambda returns #2
x="some kind of a useless lambda"
(lambda x : print(x))(x)

And run it by hitting F5, you will see an output like this.

Výstup:

some kind of a useless lambda

Now, the lambda is being called, and the string we pass gets printed at the console. But what is that weird syntax, and why is the lambda definition covered in brackets? Let us understand that now.

Code Vysvětlení:

1. Here is the same string we defined in the previous example.

2. In this part, we are defining a lambda and calling it immediately by passing the string as an argument. This is something called an IIFE, and you will learn more about it in the upcoming sections of this tutorial.

Příklad 4

Let us look at a final example to understand how lambdas and regular functions are executed. So, open your IDLE a do nového souboru zadejte následující:

#A REGULAR FUNCTION
def guru( funct, *args ):
funct( *args )
def printer_one( arg ):
return print (arg)
def printer_two( arg ):
print(arg)
#CALL A REGULAR FUNCTION 
guru( printer_one, 'printer 1 REGULAR CALL' )
guru( printer_two, 'printer 2 REGULAR CALL \n' )
#CALL A REGULAR FUNCTION THRU A LAMBDA
guru(lambda: printer_one('printer 1 LAMBDA CALL'))
guru(lambda: printer_two('printer 2 LAMBDA CALL'))

Now, save the file and hit F5 to run the program. If you did not make any mistakes, the output should be something like this.

Výstup:

printer 1 REGULAR CALL

printer 2 REGULAR CALL

printer 1 LAMBDA CALL

printer 2 LAMBDA CALL

Code Vysvětlení:

1. A function called guru that takes another function as the first parameter and any other arguments following it.

2. printer_one is a simple function which prints the parameter passed to it and returns it.

3. printer_two is similar to printer_one but without the return statement.

4. In this part, we are calling the guru function and passing the printer functions and a string as parameters.

5. This is the syntax to achieve the fourth step (i.e., calling the guru function) but using lambdas.

V další části se dozvíte, jak používat funkce lambda s mapa(), snížit(), a filtr() in Python.

Použití lambd s Python vestavěné

Funkce lambda poskytují elegantní a výkonný způsob provádění operací pomocí vestavěných metod v Python. Je to možné, protože lambdy lze vyvolat okamžitě a předat jako argument těmto funkcím.

IIFE v Python Lambda

IIFE představuje okamžitě vyvolané provedení funkce. It means that a lambda function is callable as soon as it is defined. Let us understand this with an example; fire up your IDLE a zadejte následující:

 (lambda x: x + x)(2)

Zde je výstup a vysvětlení kódu:

Tato schopnost lambdas být okamžitě vyvolána vám umožňuje používat je ve funkcích jako map() a reduction(). Je to užitečné, protože tyto funkce možná nebudete chtít znovu používat.

lambda ve filtru()

Funkce filtru se používá k výběru některých konkrétních prvků ze sekvence prvků. Sekvence může být libovolný iterátor, jako jsou seznamy, množiny, n-tice atd.

The elements which will be selected are based on some pre-defined constraint. It takes 2 parameters:

• Funkce, která definuje omezení filtrování
• Sekvence (jakýkoli iterátor jako seznamy, n-tice atd.)

Například,

sequences = [10,2,8,7,5,4,3,11,0, 1]
filtered_result = filter (lambda x: x > 4, sequences) 
print(list(filtered_result))

Zde je výstup:

[10, 8, 7, 5, 11]

Code Vysvětlení:

1. V prvním příkazu definujeme seznam s názvem sekvence, který obsahuje nějaká čísla.

2. Zde deklarujeme proměnnou nazvanou filter_result, která bude ukládat filtrované hodnoty vrácené funkcí filter().

3. Funkce lambda, která běží na každém prvku seznamu a vrací true, pokud je větší než 4.

4. Vytiskněte výsledek vrácený funkcí filtru.

lambdy v mapě()

The map function is used to apply a particular operation to every element in a sequence. Like filter(), it also takes 2 parameters:

1. A function that defines the operation to perform on the elements
2. Jedna nebo více sekvencí

Zde je například program, který vytiskne druhé mocniny čísel v daném seznamu:

sequences = [10,2,8,7,5,4,3,11,0, 1]
filtered_result = map (lambda x: x*x, sequences) 
print(list(filtered_result))

Výstup:

 [100, 4, 64, 49, 25, 16, 9, 121, 0, 1]

Code Vysvětlení:

1. Here, we define a list called sequences which contains some numbers.

2. We declare a variable called filtered_result which will store the mapped values.

3. A lambda function which runs on each element of the list and returns the square of that number.

4. Print the result returned by the map function.

lambda v redukovat()

Funkce snížení, podobně jako map(), se používá k aplikaci operace na každý prvek v sekvenci. Od mapy se však liší svým fungováním. Toto jsou kroky, které následuje funkce reduction() pro výpočet výstupu:

Krok 1) Proveďte definovanou operaci na prvních 2 prvcích sekvence.

Krok 2) Save this result.

Krok 3) Proveďte operaci s uloženým výsledkem a dalším prvkem v pořadí.

Krok 4) Opakujte, dokud nezůstanou žádné další prvky.

Chce to také dva parametry:

1. Funkce, která definuje operaci, která má být provedena
2. Sekvence (jakýkoli iterátor jako seznamy, n-tice atd.)

Zde je například program, který vrací součin všech prvků v seznamu:

from functools import reduce
sequences = [1,2,3,4,5]
product = reduce (lambda x, y: x*y, sequences)
print(product)

Zde je výstup:

120

Code Vysvětlení:

1. Import reduce from the functools module.

2. Here, we define a list called sequences which contains some numbers.

3. We declare a variable called product which will store the reduced value.

4. A lambda function that runs on each element of the list. It will return the product of that number as per the previous result.

5. Print the result returned by the reduce function.

Proč (a proč ne) používat funkce lambda?

Jak uvidíte v další části, s lambdami se na úrovni interpretu zachází stejně jako s běžnými funkcemi. Svým způsobem by se dalo říci, že lambdy poskytují kompaktní syntaxi pro zápis funkcí, které vracejí jeden výraz.

However, you should know when it is a good idea to use lambdas and when to avoid them. In this section, you will learn some of the design principles used by Python developers when writing lambdas.

One of the most common use cases for lambdas is in functional programming, as Python podporuje paradigma (nebo styl) programování známé jako funkční programování.

It allows you to provide a function as a parameter to another function (for example, in map, filter, etc.). In such cases, using lambdas offers an elegant way to create a one-time function and pass it as the parameter.

Kdy byste neměli používat Lambdu?

Nikdy byste neměli psát složité funkce lambda v produkčním prostředí. Pro kodéry, kteří udržují váš kód, bude velmi obtížné jej dešifrovat. Pokud zjistíte, že vytváříte složité jednořádkové výrazy, bylo by mnohem lepším postupem definovat správnou funkci. Jako osvědčený postup si musíte pamatovat, že jednoduchý kód je vždy lepší než složitý kód.

Lambdy vs. běžné funkce

As previously stated, lambdas are just functions which do not have an identifier bound to them. In simpler words, they are functions with no names (hence, anonymous). Here is a table to illustrate the difference between lambdas and regular functions in Python.

lambda x : x + x

def (x) :
return x + x 

Explanation of the differences

Primární rozdíl mezi lambda a běžnou funkcí je ten, že funkce lambda vyhodnocuje pouze jeden výraz a dává funkční objekt. Následně můžeme výsledek funkce lambda pojmenovat a použít v našem programu jako v předchozím příkladu.

Běžná funkce pro výše uvedený příklad by vypadala takto:

def adder (x, y):
return x + y 
print (adder (1, 2))

Zde musíme definovat a název pro funkci, která Vrací výsledek, když jsme volání it. A lambda function does not contain a return statement because it will have only a single expression which is always returned by default. You do not even have to assign a lambda either, as it can be immediately invoked (see the previous section). As you will see, lambdas become particularly powerful when we use them with Pythonvestavěné funkce.

Možná vás však stále zajímá, jak se lambda liší od funkce, která vrací jeden výraz (jako je ten výše). Na úrovni tlumočníka není velký rozdíl. Může to znít překvapivě, ale jakákoli funkce lambda, kterou definujete Python je tlumočníkem považováno za normální funkci.

At the bytecode level, the two definitions are handled in the same way by the Python interpreter. Now, you cannot name a function lambda protože je rezervován Python, but any other function name will yield the same bytecode.

Nejčastější dotazy