Hướng dẫn dùng define removing python

History

Alonzo Church formalized lambda calculus, a language based on pure abstraction, in the 1930s. Lambda functions are also referred to as lambda abstractions, a direct reference to the abstraction model of Alonzo Church’s original creation.

Lambda calculus can encode any computation. It is Turing complete, but contrary to the concept of a Turing machine, it is pure and does not keep any state.

Functional languages get their origin in mathematical logic and lambda calculus, while imperative programming languages embrace the state-based model of computation invented by Alan Turing. The two models of computation, lambda calculus and Turing machines, can be translated into each another. This equivalence is known as the Church-Turing hypothesis.

Functional languages directly inherit the lambda calculus philosophy, adopting a declarative approach of programming that emphasizes abstraction, data transformation, composition, and purity [no state and no side effects]. Examples of functional languages include Haskell, Lisp, or Erlang.

By contrast, the Turing Machine led to imperative programming found in languages like Fortran, C, or Python.

The imperative style consists of programming with statements, driving the flow of the program step by step with detailed instructions. This approach promotes mutation and requires managing state.

The separation in both families presents some nuances, as some functional languages incorporate imperative features, like OCaml, while functional features have been permeating the imperative family of languages in particular with the introduction of lambda functions in Java, or Python.

Python is not inherently a functional language, but it adopted some functional concepts early on. In January 1994,

def add_one[x]:
    return x + 1

def add_one[x]:
    return x + 1

def add_one[x]:
    return x + 1

def add_one[x]:
    return x + 1

First Example

Here are a few examples to give you an appetite for some Python code, functional style.

The identity function, a function that returns its argument, is expressed with a standard Python function definition using the keyword

def add_one[x]:
    return x + 1

>>>

>>> def identity[x]:
...     return x

def add_one[x]:
    return x + 1

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

In contrast, if you use a Python lambda construction, you get the following:

>>>

>>> lambda x: x

In the example above, the expression is composed of:

• The keyword:

  def add_one[x]:
      return x + 1
  

  2
• A bound variable:

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

  0
• A body:

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

  0

Note: In the context of this article, a bound variable is an argument to a lambda function.

In contrast, a free variable is not bound and may be referenced in the body of the expression. A free variable can be a constant or a variable defined in the enclosing scope of the function.

You can write a slightly more elaborated example, a function that adds

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

>>>

>>> lambda x: x + 1

You can apply the function above to an argument by surrounding the function and its argument with parentheses:

>>>

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

Reduction is a lambda calculus strategy to compute the value of the expression. In the current example, it consists of replacing the bound variable

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

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

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

Because a lambda function is an expression, it can be named. Therefore you could write the previous code as follows:

>>>

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

The above lambda function is equivalent to writing this:

def add_one[x]:
    return x + 1

These functions all take a single argument. You may have noticed that, in the definition of the lambdas, the arguments don’t have parentheses around them. Multi-argument functions [functions that take more than one argument] are expressed in Python lambdas by listing arguments and separating them with a comma [

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

>>>

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

The lambda function assigned to

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

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

>>> lambda x, y: x + y

Functions

At this point, you may wonder what fundamentally distinguishes a lambda function bound to a variable from a regular function with a single

>>> _[1, 2]
3

def add_one[x]:
    return x + 1

The

>>> lambda x: x

>>>

>>> lambda x: x

You can see that

>>> lambda x: x

Now see it with a regular function object:

>>>

>>> lambda x: x

The bytecode interpreted by Python is the same for both functions. But you may notice that the naming is different: the function name is

>>> lambda x: x

def add_one[x]:
    return x + 1

def add_one[x]:
    return x + 1

Traceback

You saw in the previous section that, in the context of the lambda function, Python did not provide the name of the function, but only

>>> lambda x: x

>>> lambda x: x

>>>

>>> lambda x: x

The traceback of an exception raised while a lambda function is executed only identifies the function causing the exception as

>>> lambda x: x

Here’s the same exception raised by a normal function:

>>>

>>> lambda x: x

The normal function causes a similar error but results in a more precise traceback because it gives the function name,

>>> lambda x: x

Syntax

As you saw in the previous sections, a lambda form presents syntactic distinctions from a normal function. In particular, a lambda function has the following characteristics:

• It can only contain expressions and can’t include statements in its body.
• It is written as a single line of execution.
• It does not support type annotations.
• It can be immediately invoked [IIFE].

No Statements

A lambda function can’t contain any statements. In a lambda function, statements like

>>> _[1, 2]
3

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

>>>

>>> lambda x: x

This contrived example intended to

>>> lambda x: x

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

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

>>> lambda x: x

>>> lambda x: x

def add_one[x]:
    return x + 1

Single Expression

In contrast to a normal function, a Python lambda function is a single expression. Although, in the body of a

def add_one[x]:
    return x + 1

>>>

>>> lambda x: x

The example above returns the string

>>> lambda x: x

>>> lambda x: x

Type Annotations

If you’ve started adopting type hinting, which is now available in Python, then you have another good reason to prefer normal functions over Python lambda functions. Check out Python Type Checking [Guide] to get learn more about Python type hints and type checking. In a lambda function, there is no equivalent for the following:

>>> lambda x: x

Any type error with

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

>>>

>>> lambda x: x

Like trying to include a statement in a lambda, adding type annotation immediately results in a

>>> lambda x: x

IIFE

You’ve already seen several examples of immediately invoked function execution:

>>>

>>> lambda x: x + 1

Outside of the Python interpreter, this feature is probably not used in practice. It’s a direct consequence of a lambda function being callable as it is defined. For example, this allows you to pass the definition of a Python lambda expression to a higher-order function like

def add_one[x]:
    return x + 1

def add_one[x]:
    return x + 1

>>> _[1, 2]
3

Arguments

Like a normal function object defined with

def add_one[x]:
    return x + 1

• Positional arguments
• Named arguments [sometimes called keyword arguments]
• Variable list of arguments [often referred to as varargs]
• Variable list of keyword arguments
• Keyword-only arguments

The following examples illustrate options open to you in order to pass arguments to lambda expressions:

>>>

>>> lambda x: x + 1

Decorators

In Python, a decorator is the implementation of a pattern that allows adding a behavior to a function or a class. It is usually expressed with the

>>> lambda x: x

>>> lambda x: x + 1

In the example above,

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x + 1

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

A decorator can be applied to a lambda. Although it’s not possible to decorate a lambda with the

>>> lambda x: x

>>> lambda x: x + 1

>>> lambda x: x

>>> lambda x: x

>>> lambda x, y: x + y

>>> lambda x: x

>>> lambda x: x + 1

See how, as you’ve already seen, the name of the lambda function appears as

>>> lambda x: x

>>> lambda x: x

Decorating the lambda function this way could be useful for debugging purposes, possibly to debug the behavior of a lambda function used in the context of a higher-order function or a key function. Let’s see an example with

def add_one[x]:
    return x + 1

>>> lambda x: x + 1

The first argument of

def add_one[x]:
    return x + 1

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

>>> lambda x: x

>>> lambda x: x + 1

The result

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

You will be exposed to

def add_one[x]:
    return x + 1

A lambda can also be a decorator, but it’s not recommended. If you find yourself needing to do this, consult PEP 8, Programming Recommendations.

For more on Python decorators, check out Primer on Python Decorators.

Closure

A closure is a function where every free variable, everything except parameters, used in that function is bound to a specific value defined in the enclosing scope of that function. In effect, closures define the environment in which they run, and so can be called from anywhere.

The concepts of lambdas and closures are not necessarily related, although lambda functions can be closures in the same way that normal functions can also be closures. Some languages have special constructs for closure or lambda [for example, Groovy with an anonymous block of code as Closure object], or a lambda expression [for example, Java Lambda expression with a limited option for closure].

Here’s a closure constructed with a normal Python function:

>>> lambda x: x + 1

>>> lambda x: x

>>> lambda x: x

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

  0 is passed as an argument to

  >>> lambda x: x
  

  57.

• >>> lambda x: x
  

  61 is a variable local to

  >>> lambda x: x
  

  57.

• >>> lambda x: x
  

  63 is an argument passed to

  >>> lambda x: x
  

  58.

To test the behavior of

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x + 1

On line 9 of the code,

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

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

>>> lambda x: x

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

>>> lambda x: x

Similarly, a

def add_one[x]:
    return x + 1

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

When you execute the code above, you obtain the following output:

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

On line 6,

>>> lambda x: x

>>> lambda x: x

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

>>> lambda x: x

>>> lambda x: x

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

>>> lambda x: x

In this situation, both the normal function and the lambda behave similarly. In the next section, you’ll see a situation where the behavior of a lambda can be deceptive due to its evaluation time [definition time vs runtime].

Evaluation Time

In some situations involving loops, the behavior of a Python lambda function as a closure may be counterintuitive. It requires understanding when free variables are bound in the context of a lambda. The following examples demonstrate the difference when using a regular function vs using a Python lambda.

Test the scenario first using a regular function:

>>>

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

In a normal function,

>>> lambda x: x

>>> lambda x: x

Now, with the implementation of the same logic with a lambda function, observe the unexpected behavior:

>>>

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

The unexpected result occurs because the free variable

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

To overcome this issue, you can assign the free variable at definition time as follows:

>>>

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

A Python lambda function behaves like a normal function in regard to arguments. Therefore, a lambda parameter can be initialized with a default value: the parameter

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

The Python lambda function is invoked without any argument on line 7, and it uses the default value

>>> lambda x: x

Testing Lambdas

Python lambdas can be tested similarly to regular functions. It’s possible to use both

>>> lambda x: x

>>> lambda x: x

>>> lambda x: x

The

>>> lambda x: x

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

>>> lambda x: x + 1

>>> lambda x: x + 1

>>> lambda x: x + 1

>>> lambda x: x + 1

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

As expected, we have two successful test cases and one failure for

>>> lambda x: x + 1

>>> lambda x, y: x + y

>>> lambda x: x + 1

>>> lambda x: x + 1

>>> lambda x, y: x + y

>>> lambda x: x + 1

>>> lambda x: x

The

>>> lambda x: x

>>> lambda x: x + 1

>>> lambda x: x + 1

>>> lambda x: x + 1

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

The

>>> lambda x: x

>>> lambda x: x + 1

When you execute the tests via

>>> lambda x: x + 1

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

The failed test results from the same failure explained in the execution of the unit tests in the previous section.

You can add a

>>> lambda x: x + 1

>>> lambda x: x + 1

>>> lambda x: x + 1

For a comprehensive overview of unit testing in Python, you may want to refer to Getting Started With Testing in Python.

Raising an Exception

Trying to raise an exception in a Python lambda should make you think twice. There are some clever ways to do so, but even something like the following is better to avoid:

>>>

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

Because a statement is not syntactically correct in a Python lambda body, the workaround in the example above consists of abstracting the statement call with a dedicated function

>>> lambda x: x + 1

Cryptic Style

As in any programming languages, you will find Python code that can be difficult to read because of the style used. Lambda functions, due to their conciseness, can be conducive to writing code that is difficult to read.

The following lambda example contains several bad style choices:

>>>

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

The underscore [

>>> lambda x, y: x + y

>>> lambda x, y: x + y

>>>

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

Admittedly, it’s still difficult to read. By still taking advantage of a

def add_one[x]:
    return x + 1

>>>

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

This is still not optimal but shows you a possible path to make code, and Python lambda functions in particular, more readable. In Alternatives to Lambdas, you’ll learn to replace

def add_one[x]:
    return x + 1

def add_one[x]:
    return x + 1

Python Classes

You can but should not write class methods as Python lambda functions. The following example is perfectly legal Python code but exhibits unconventional Python code relying on

def add_one[x]:
    return x + 1

>>> lambda x: x + 1

def add_one[x]:
    return x + 1

>>> lambda x: x + 1

>>> lambda x: x + 1

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

Running a tool like

>>> lambda x: x + 1

>>> lambda x: x + 1

>>> lambda x: x + 1

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

Although

>>> lambda x: x + 1

>>> lambda x: x + 1

>>> lambda x: x + 1

Proper implementation of

>>> lambda x: x + 1

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

>>> lambda x: x + 1

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

As a general rule, in the context of code written in Python, prefer regular functions over lambda expressions. Nonetheless, there are cases that benefit from lambda syntax, as you will see in the next section.

Classic Functional Constructs

Lambda functions are regularly used with the built-in functions

def add_one[x]:
    return x + 1

def add_one[x]:
    return x + 1

>>> _[1, 2]
3

>>> lambda x: x + 1

>>>

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

You may have to read code resembling the examples above, albeit with more relevant data. For that reason, it’s important to recognize those constructs. Nevertheless, those constructs have equivalent alternatives that are considered more Pythonic. In Alternatives to Lambdas, you’ll learn how to convert higher-order functions and their accompanying lambdas into other more idiomatic forms.

Key Functions

Key functions in Python are higher-order functions that take a parameter

>>> lambda x: x + 1

>>> lambda x: x + 1

def add_one[x]:
    return x + 1

• >>> _[1, 2]
  3
  

  4: list method

• >>> _[1, 2]
  3
  

  5,

  >>> _[1, 2]
  3
  

  6,

  >>> _[1, 2]
  3
  

  7: built-in functions

• >>> lambda x: x + 1
  

  53 and

  >>> lambda x: x + 1
  

  54: in the Heap queue algorithm module

  >>> lambda x: x + 1
  

  55

Imagine that you want to sort a list of IDs represented as strings. Each ID is the concatenation of the string

>>> lambda x: x + 1

>>> _[1, 2]
3

To influence the sorting execution, you can assign a lambda to the named argument

>>> lambda x: x + 1

>>>

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

UI Frameworks

UI frameworks like Tkinter, wxPython, or .NET Windows Forms with IronPython take advantage of lambda functions for mapping actions in response to UI events.

The naive Tkinter program below demonstrates the usage of a

def add_one[x]:
    return x + 1

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

Clicking the button Reverse fires an event that triggers the lambda function, changing the label from Lambda Calculus to suluclaC adbmaL*:

Both wxPython and IronPython on the .NET platform share a similar approach for handling events. Note that

def add_one[x]:
    return x + 1

def add_one[x]:
    return x + 1

To explore wxPython, check out How to Build a Python GUI Application With wxPython.

Python Interpreter

When you’re playing with Python code in the interactive interpreter, Python lambda functions are often a blessing. It’s easy to craft a quick one-liner function to explore some snippets of code that will never see the light of day outside of the interpreter. The lambdas written in the interpreter, for the sake of speedy discovery, are like scrap paper that you can throw away after use.

>>> lambda x: x + 1

62

In the same spirit as the experimentation in the Python interpreter, the module

>>> lambda x: x + 1

>>> lambda x: x + 1

>>>

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

When the statement is passed as a string,

>>> lambda x: x + 1

>>> lambda x: x + 1

Another approach is to use a

def add_one[x]:
    return x + 1

>>>

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

This solution is cleaner, more readable, and quicker to type in the interpreter. Although the execution time was slightly less for the

def add_one[x]:
    return x + 1

>>> lambda x: x + 1

>>> lambda x: x + 1

Monkey Patching

For testing, it’s sometimes necessary to rely on repeatable results, even if during the normal execution of a given software, the corresponding results are expected to differ, or even be totally random.

Let’s say you want to test a function that, at runtime, handles random values. But, during the testing execution, you need to assert against predictable values in a repeatable manner. The following example shows how, with a

def add_one[x]:
    return x + 1

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

A context manager helps with insulating the operation of monkey patching a function from the standard library [

>>> lambda x: x + 1

>>> lambda x: x + 1

This allows testing any function depending on

>>> lambda x: x + 1

>>> lambda x: x + 1

>>> lambda x: x + 1

Unit test frameworks like

>>> lambda x: x

>>> lambda x: x + 1

With

>>> lambda x: x + 1

def add_one[x]:
    return x + 1

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

With the pytest

>>> lambda x: x + 1

>>> lambda x: x + 1

>>> lambda x: x + 1

>>> lambda x: x + 1

>>> lambda x: x + 1

Executing the

>>> lambda x: x + 1

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

The test passes as we validated that the

>>> lambda x: x + 1

Map

The built-in function

def add_one[x]:
    return x + 1

def add_one[x]:
    return x + 1

def add_one[x]:
    return x + 1

>>>

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

You need to invoke

>>> lambda x: x + 1

def add_one[x]:
    return x + 1

Using a list comprehension eliminates the need for defining and invoking the lambda function:

>>>

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

Filter

The built-in function

def add_one[x]:
    return x + 1

>>>

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

Note that

def add_one[x]:
    return x + 1

>>> lambda x: x + 1

The implementation leveraging the list comprehension construct gives the following:

>>>

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

Reduce

Since Python 3,

def add_one[x]:
    return x + 1

>>> lambda x: x + 1

def add_one[x]:
    return x + 1

def add_one[x]:
    return x + 1

def add_one[x]:
    return x + 1

To apply

def add_one[x]:
    return x + 1

>>>

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

A more idiomatic approach using a generator expression, as an argument to

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

>>>

def add_one[x]:
    return x + 1

A slightly different and possibly cleaner solution removes the need to explicitly access the first element of the pair and instead use unpacking:

>>>

def add_one[x]:
    return x + 1

The use of underscore [

>>> lambda x, y: x + y

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