assignment in lambda function

Lambda Expressions

A guide to programming lambda expressions in C++, C#, Java, Javascript, and Python by JoshData .

A lambda expression is a convenient syntax available in many programming languages for writing short functions. Lambda expressions do for functions what object-oriented programing does for objects: It makes a function something you can assign to a variable.

Lambda expressions are also sometimes called anonymous functions, lambda functions, and closures. The capabilities of lambda expressions differs across programming languages, and some programming languages have multiple ways of writing lambda expressions. The concept originates in philosophy.

Background Concepts

Let’s cover some general programming concepts first.

Statements versus expressions

All programming languages with lambda expressions distinguish statements from expressions :

• A statement is typically a line of code. Statements control the flow of the program , like if statements, for loops, calling subroutines, and return statements in functions. An assignment to a variable (e.g. x = y ) is also a statement.
• An expression is code within a statement that computes a value . Expressions are made up of constants, variables, arithmetic operators, function calls, method calls, property accesors, and so on. An expression encodes a set of instructions that results in the computation of one value.

if x > y is a statement. x > y is an expression — it computes one value, in this case either true or false. The if statement takes an action based on the value of the expression.

Statically versus dynamically typed languages

This guide covers a few common programming languages, and if you are reading it to learn about multiple languages it may be helpful to distinguish:

• Statically typed languages, meaning all variables are defined with a type in source code that is known to the compiler. C, C++, C#, and Java are statically typed languages using types such as int , double , string , etc.
• Dynamically typed languages, meaning any variable can hold any type of value. Variable declarations with types do not occur in these languages. Python and Javascript are dynamically typed. These languages still have types, usually the same types as in the C-family languages, but they’re only for the values computed in memory, not for variables in source code.

Lambda Syntax

A lambda expression is a function written in a shorthand syntax, and we’ll start by looking at the syntax of lambda expressions.

Here is a regular function (not a lambda function, just a normal function) that adds one to a number as it would be written in C, C++, C#, and Java (they all happen to be identical in this case) and in Javascript. We’ll look at how the same function would be written as a lambda expression.

In this example, there is a single argument x , the expression x + 1 is computed, and that expression is returned to the caller.

It can be written shorter as a lambda expression in modern versions of many languages, including C++ (starting in C++11), C# (starting in C# 9.0), Java (since Java 8), Javascript (starting in ECMAScript 6), and Python (since around Python 2.2):

C#, Java, and Javascript use an arrow symbol (made up of an equal sign or dash plus a greater than sign) to separate the arguments from the expression body. The C# and Javascript syntaxes happen to be identical in this case. (In Javascript, an “anonymous function” refers to a different but related syntactic structure — the technical name for the Javascript syntax discussed here is the “arrow function expression.”)

In the academic discipline of philosophy, the function would be written with the Greek lowercase letter lambda λ denoting the start of a lambda expression:

Here’s a function that returns the maximum value of two numbers, first written as a regular function:

and then as a lambda expression in various languages:

Lambda expressions can also have zero arguments:

Lambda expressions have most of the same components as a normal function:

• An argument list: Zero or more variables separated with commas, usually in parentheses. C#, Java, and Javascript allow omitting parentheses if there is only one argument. C++ requires the arguments to have types, but the other statically typed languages allow it without making it required.
• A body: Statements to execute or an expression to evaluate and return. When using statements, they are surrounded with braces, and a return statement can be used to return a value. When the body is just an expression, braces are omitted. (C++ only allows using statements and Python only allows using expressions. In C#, braces can be omitted when the body is a single statement.)

In the body of the lambda expression, some languages allow both statement blocks and expressions (C#), some only support statements (C++), and some only support expressions (Python). The add_one examples above used expressions as lambda function bodies where possible: x + 1 in C#, Python, etc. No braces are used in those languages when the body is an expression:

The max examples above used statement blocks as lambda function bodies, and when statements are used these languages require that they be surrounded in braces:

This last example could be turned into an expression-bodied lambda by using the ternary operator condition ? then : else . Expression bodies are usually easier to read because they are more compact.

The one thing missing from lambda expressions is a function name. Lambda expressions don’t have a place for a name in their syntax.

(No type is given for the return value in any of the examples above either. It is optional in C++ and not permitted in other languages. In statically typed languages, the lambda expression does have a return type but the compiler figures it out from what you return.)

Lambda Expressions are Expressions

The key difference between a regularly defined function and a lambda expression is where they occur in source code. Regular functions are normally defined either at the top-level of your source code file or in a class. All of the statements in your source code are contained within a function.

A lambda expression is exactly the opposite. It occurs not outside of statements but inside statements. It actually is an expression , which means it occurs within statements wherever an expression can be used.

Assigning a lambda expression to a variable

It can be assigned to a variable. Variable assignment normally looks like this of course:

(C++ and C# are a statically typed language so the variable must be declared first with its type, but we will omit the variable declaration for now.)

Now instead of 10 , the variable will be assigned a lambda expression:

The lambda expression is assigned to the variable f . Note that the f = at the start and the semicolon ; at the end belong to the variable assignment statement . The lambda expression appears in the middle as the expression. Since the lambda expression is multiple lines, it pushes the semicolon ; down a few lines to its end.

After the variable assignment, the variable actually holds the lambda function defined by the lambda expression.

Quick look at the type of lambda expressions in the statically typed languages

You can also make a variable declaration with an explicit type, and in C# ≤9 and Java it’s required, even though both have var keywords. The variable types to use in C++, C# and Java are:

• C++: std::function<double(double, double)> (with #include <functional> )
• C#: System.Func<double, double, double>
• Java: java.util.function.BinaryOperator<Double>

For example, in Java:

We’ll come back to the type of lambda expressions later.

No type is needed in dynamically typed languages like Javascript and Python.

Few meaningful operators are defined for lambda expressions

Lambda expressions are expressions, but most operators don’t have any meaning with the value that a lambda expression computes. You can’t add two lambda functions together with + : It doesn’t make sense and that isn’t defined in any language.

The first operator that can be used with lambda expressions are grouping parentheses. Lambda expressions can always be wrapped in parentheses for clarity:

Be sure you see where the open and closing parens were added here.

Calling Lambda Expressions

The most important operator that works with lambda functions is the call operator. The next example starts with the same variable assignment as above, but it follows with a new statement that invokes the lambda function by calling it:

It is just like calling a function, but instead of f being the name of a function it is the name of a variable holding a lambda function.

When f(10, 20) is called, control flow moves to the lambda expression. The statements of the lambda expression are evaluated until the return statement is executed. Then control flow moves back the assignment of the value to z .

Assigning a lambda expression to a variable and then, some time later, using the call operator on the variable is the main thing lambda expressions do.

Java does not support the call operator — this is unusual for a language that has lambda expressions. To invoke the lambda function, in this example we use .apply(...) which is the correct method to use with BinaryOperator<Double>. (The method name depends on the runnable interface type that the expression is assigned to.)

In the next toy example, f is first set to a lambda expression that computes the maximum value of two arguments and then later it is set to a different lambda expression that computes the minimum value of two arguments. Although the same code f(10, 20) is called identically after each assignment, f returns a different value each time because it executes the two lambda functions:

Although f(10, 20) appears twice, it computes a different value each time. In the first call to f , control flow goes to the first lambda expression. In the second call to f , control flow goes to the second lambda expression.

In some languages, the call operator (10, 20) can occur after any expresson that evaluates to a lambda function. In C++, Javascript, and Python, it can be right after the lambda expression itself:

Make sure you see where the lambda expression begins and ends and where the call operator begins and ends.

This pattern is commonly seen in Javascript for reasons related to scope and not really about the lambda expression. It isn’t generally useful because you can always write an expression like this without the complex lambda expression syntax.

C# and Java do not allow this.

Passing lambda expressions as arguments to other functions

The last meaningful thing that you can do with lambda expressions is passing the lambda expresson as an argument to a function. In the next set of examples, a new function foo is defined that takes one argument. The program calls foo and passes a lambda expression as the argment.

Here are additional examples using the more complex lambda functions with statement bodies:

When passing lambda expressions with statement bodies in function calls, the triple of symbols brace-paren-semicolon } ); is a common line ending. The close brace belongs to the lambda expression: It is the close-brace that ends the lambda expression’s body. The close parenthesis belongs to the function call: It is the close parethesis at the end of the argument list. The semicolon marks the end of the statement as in all C++, C#, Java, and Javascript statements.

The most common way to use a lambda expression is passing it to another function and then calling it within that function. Here is the same function call example again, plus calling the lambda function within foo :

Finally, we look at a lambda expression with no return value. Lambda expressions without a return value are typically used with statement-block bodies to take an action.

This lambda expression has a void return type in C++, C#, and Java. (Javascript and Python do not support void return types — if there is no return value, the lambda expression returns undefined (Javascript) or None (Python).)

In C++, C#, Java, Javascript, and Python, any regular function name or class method can also be assigned to a variable and passed to a function, like lambda expressions. In the statically typed languages, the variable or function argument must have the right type. But in dynamically typed languages, that’s not an issue and passing around functions can be very natural:

Terminology

In this guide, lambda expression and lambda function mean slightly different things, although I can’t promise that anyone else makes this distinction:

A lambda expression is the code you type to define a short function. It is source code text that goes into the compiler and is recognized with a particular syntax. (In Javascript, technically they are called arrow function expressions/declarations.)

The expression evaluates at run time to a lambda function in memory. In memory during program execution, the f variable in the preceding examples holds a lambda function . It doesn’t hold the source code text that you typed in — that’s been compiled into some other more efficient representation. So it doesn’t hold an expression. Instead it probably holds a pointer to a memory location that has the compiled code.

The difference between a lambda expression and a lambda function is similar to the difference between a class and an instance of the class (an object). A class is a definition of a type of object. At run time, variables whose types are classes don’t hold classes: they hold pointers to objects. Similarly, variables that are assigned lambda expressions in code hold pointers to lambda functions at run time, not lambda expressions. (In fact, in many languages the lambda expression actually compiles to a new instance of a hidden class!)

Standard Library Routines that Use Lambda Functions

The standard library in each programming language has some methods that are convenient to use with lambda expressions.

Across programming languages, lambda functions are commonly used with the language’s standard library sort function to create sort orders for user-defined data types. In C++, a lambda expression can be passed to std::sort for this purpose.

std::sort ’s third argument is a function that compares two items in the list and returns whether the first item should come first. The arguments to the comparison function must be const references.

In this example, a user-defined class is sorted first by its name field and then, when there are any instances with the same name, by its value field.

std::sort will call the lambda function for each pair of elements in the list and will use its return value to sort the elements according to the order that the lambda function defines. The comparison function always looks something like this to achieve a sort order over multiple fields.

The standard library has a handful of functions that take comparison functions like sort does, including min_element / max_element — another common use of lambda functions across languages. This example finds the MyClass instance in a vector with the smallest value .

This is more compact than writing a for loop to iterate over the elements and track which one has the minimum value.

A comparison function can be used to create set and map containers for user-defined data types. (A hash code generator can also be used with unordered_set and unordered_map .)

You can also put lambda functions inside containers:

Across programming languages, lambda functions are commonly used with the language’s container sort functions to create sort orders for user-defined data types. In C#, a lambda expression can be passed to List.Sort(...) for this purpose.

List.Sort() ’s optional argument is a function that compares two items in the list and returns which should be first in the list. The comparison function returns -1 if the first item should come first, 1 if the second item should come first, or 0 if the items can have either order.

List.Sort will call the lambda function for each pair of elements in the list and will use its return value to sort the elements according to the order that the lambda function defines. The comparison function always looks something like this to achieve a sort order over multiple fields. String.CompareTo and Double.CompareTo have the same sematics as the function expected by Sort: They return -1, 0, or 1.

List.ForEach is another helpful method with a lambda expression — it simply runs the function on each element of the list. Here’s how you can print out each item in the list:

You could of course also write a regular foreach loop, but the lambda expression syntax might be clearer or cleaner in some cases.

You can also put lambda functions inside lists:

The extension methods in System.Linq.Enumerable ( reference ) provide other utility methods on collections that are helpful when used with lambda expressions. For example, Count can be used to count the items in a list that pass a test:

Lambda expressions are also commonly used with C# events, such as in System.Windows.Forms applications.

Rather than subscribing methods to event handlers (which are often hooked up by the Visual Studio designer automatically):

A lambda expression could be used instead:

Don’t subscribe to events directly with lambda expressions if the event handler (the lambda function) needs to be unsubscribed from the event later. To do that, you would need to assign the lambda expression to a variable first and then later use the variable to unsubscribe from the event.

System.Threading.Tasks.Task can be used to launch a background task that runs asynchronously on a thread pool and System.Threading.Tasks.Parallel can launch many tasks at once on the thread pool. Lambda expressions are convenient for both.

First, a single background task:

Next, a background task is launched for each item in an array:

The lambda expression is run multiple times, possibly simultaneously, for each item in the array, and the order in which the array elements are seen might be unpredictable. The first argument to ForEach can be any IEnumerable container. Unlike Task.Run which returns immediately, Parallel.ForEach waits until all of the loop iterations complete.

See https://ddc-java-10.github.io/2020/04/28/lambdas-key-functional-interfaces/ for some examples.

Lambda expressions and anonymous functions are used extensively in Javascript, in two ways:

• When a lambda expression (let’s call it L) is passed as an argument to a function (let’s call it F) and the lambda L is executed by function F immediately, before the function F returns, the call to the lambda L is synchronous . All of the Javascript examples in this guide so far have been synchronous.
• When the function F stores the lambda L to be called later, so that F can return before L is executed, the call to the lambda L is asynchronous . It often happens after other stored lambda functions are executed, creating a sort of concurrent execution of multiple tasks. An asynchronously executed lambda expression is often called a “callback.”

Asynchronous callbacks are so pervasive in Javascript that I can’t even begin here to provide key examples. The async package and the Promise design concept are the key places to look next.

Across programming languages, lambda functions are commonly used with the language’s list sorting function to create sort orders for user-defined classes for which the language doesn’t provide any built-in ordering. In Python, a lambda expression can be passed to list.sort() and sorted(...) for this purpose.

You might have seen this error when trying to sort user-defined classes:

MyClass , in this example, is not a sortable data type. You could implement the < operator on MyClass to make it sortable, but often the easier solution is to call list.sort with a lambda expression.

list.sort() ’s optional keyword argument key takes a function that takes an item of the list and returns a sortable value to use in place of the item . It can return anything sortable (a number, string, etc.). The items in the list will be sorted according to how their correponding return values from the key function would be sorted amongst each other.

Returning a tuple of sortable values is a convenient way to create a function that sorts on multiple fields. In this example, the user-defined class is sorted first by its name field and then, when there are any instances with the same name, by its value field.

Variable Capture

Besides a lambda expression’s arguments, a lambda expression can also access variables of the outer function that the lambda expression is contained within. This is called capture or closure.

For example:

In the above examples the captured variable is text . You can tell because it is a variable in the lambda expression that is not an argument (in these examples there are no arguments). The variable type is simply a string, but any data type including objects or other lambda functions can be captured:

If the variable holds an object, that object remains valid — it won’t be garbage-collected or destroyed — until the outer function exits and the lambda function is no longer referenced anywhere.

Lambda expressions are typically small, reusable, and self-contained, but capture makes lambda expressions less reusable and not self-contained, so excessive use of capture should be avoided.

How this works varies subtly across languages, and there are three types of variable capture that you need to be aware of.

Capture by Reference

Capture by reference means that the outer variable is shared with the lambda expression.

If the outer variable changes after the lambda expression is defined but before the lambda function is executed , the lambda function will get the updated value:

Conversely, the lambda expression can change the value of the outer variable so that when the lambda function finishes, the outer function sees the updated value:

Here’s a complex case. Can you figure out what will be printed?

In C#, Javascript, and Python, capture is always by reference.

In C++, there is no capture by default. To enable capture by reference, the & symbol can be put in the brackets that start the lambda expression. The brackets are for declaring capture.

When inside non-static methods of a class, the this variable is captured automatically in C#, Java, and Javascript and can be captured by value by adding this to the brackets in C++. That makes all of the current class instance’s fields, properties, methods, etc. available within the lambda expression as well.

In Python and Javascript, the capture rules apply to local function definitions the same as it does to lambda expressions. For example:

In Javascript, use the newer let keyword rather than var to declare variables to avoid for-loop scope mistakes.

Capture by Copy (C++)

Capture by copy means the lambda function gets a copy of the value in the capture variable at the time the lambda expression is defined . It cannot modify the outer variable and does not see changes to the outer variable.

In C++, capture can be either by reference or by copy. Using = in the capture brackets, capture is by copy.

Because a copy is made at the point where the lambda expression is declared, it will not see subsequent changes to the variable:

Variables captured by copy are const inside the lambda expression to prevent confusion about which variable is being edited:

Capture by copy is less prone to coding mistakes than capture by reference so it should be preferred, but it may come at a cost if the variable holds a complex data type that is expensive to copy.

Capture by copy should generally be used when capturing std::shared_ptr or other smart pointers because the copy will ensure the target object is not destroyed before the lambda function finishes. If that’s not a concern, capture by reference may be more efficient.

(In C#, Java, Javascript, and Python capture is always by reference (or by value in Java), so this section on capture by copy does not apply to those languages.)

Caveats and Capture by Value

It can become very difficult to track what captured variables will hold inside lambda expressions when the variable’s value changes, like in some of the examples in the previous section! It is especially hard in some specific cases:

• When the variable’s value changes between the lambda expression’s definition and its invocation.
• Capturing for -loop variables and variables within loops because their value may change on every iteration — in fact, they may be considered different variables on each iteration, which may or may not be what you expect.
• When lambda functions are executed asynchronously, as is often the case in Javascript, because the order of execution is opposite to the source code order and may be unpredictable.

Avoid using capture by reference in these circumstances whenever possible. especially capturing for -loop variables and variables within loops.

Modifying the captured variable either inside or outside the lambda expression is not possible in Java, which requires that captured variables be final or assigned once, so that it only ever has one value. That’s nice! It prevents complex situations that are prone to error. Since the captured variable cannot be changed, capture by reference is probably not the right term: capture by value might be a more appropriate term.

To get around these issues in all of the languages, you can sometimes make the captured variable a container (e.g. a list) and modify what is inside the container. Although the variable should not (or in Java cannot) be assigned a new value, its methods can be called and its fields and properties can be modified freely.

In addition to the captured variable’s value, it is can also be very hard to track its lifetime . Objects stored in captured variables may remain in memory so long as the lambda function remains stored in a variable. The lifetime of captured variables is dependent on the lifetime of the lambda function. If the lambda function is stored in a global variable, for example, any objects in variables captured by the lambda expression may hold onto system resources indefinitely.

Or, worse, those captured objects may become invalid in some way (due to their own semantics), leading to a crash or error the next time the lambda function is called. Lambda functions must be careful that nothing intervenes between definition and execution that would violate expectations the function has about the captured variables.

Capturing loop variables

The type of lambda expressions.

If you are writing your own functions that take lambda functions as arguments in statically typed languages, or if you are using C# ≤9 or Java and want to assign a lambda expression to a variable, you will need to know the correct types to use.

The type for lambda functions in C++ is std::function<return_type(arg_type_1, arg_type_2, ...)> which is defined in the functional standard header.

The template argument return_type(arg_type_1, arg_type_2, ...) is a little unusual, but it makes sense and pretty clearly indicates what’s what.

Three types in C# are generally used with lambda expressions.

System.Action is the usual type for lambda functions that do not return anything (like a void return type function). Without any generic arguments, it is the type for lambda functions that take no arguments and have no return value.

When System.Action has generic arguments, they are the lambda function’s argument types. For example, Action<string> is the type of a lambda function that takes a string and performs an action without returning a value. Action<string,Object> is the type of a lambda function that takes a string and an object as arguments (in that order) and performs an action without returning a value.

System.Func is the usual type for lambda functions that have a return value. The first (zero or more) generic arguments are the argument types. The last generic argument is always the type of the return value of the lambda function. So, for example, Func<string> is the type of a lambda function that takes no arguments and returns a string. Func<Object,string,int> is the type of a lambda function that takes an object and a string as arguments (in that order) and returns integer.

System.Predicate is a special case of Func where the return type is bool . So, for example, Predicate<string> is the type of a lambda function that takes a string argument and returns a boolean. Predicate<Object,string,int> is the type of a lambda function that takes those three argument types and returns a bool .

These types are used throughout the built-in .NET assemblies.

Actually any delegate type can be the type of a lambda expression, but there is generally no practical reason to use any type other than the three above unless the length of the names of these types becomes too cumbersome to type or read in the source code.

The var keyword can only be used with lambda expressions starting in C# 10, and only for some lambda expressions. Otherwise, you must give a full type.

In Java, there is no fixed type that must be used with a lambda expression. The pre-defined interface classes in java.util.function ( reference ) define some commonly used types, such as Function<T,R> which can be assigned a lambda function that takes a T as an argument and returns an R -type value. The Runnable ( reference ) interface can be used for lambda expressions that take no arguments and return nothing.

Any interface with a single method (a functional interface type) can be the type of a lambda expression, so long as the method has the same return type and arguments as the lambda expression. See the language reference .

Unfortunately, to invoke the lambda function, you must know the name of the method in the particular functional interface that is being used. Consult the interface documentation for the name of the method used to invoke the lambda function.

Dynamically Typed Languages

Although dynamically typed languages like Javascript and Python still have types at runtime , the types are generally not specified in source code.

Metaprogramming

In C#, lambda expressions can be used for metaprogramming. See System.Linq.Expressions.Expression .

Language-Specific Notes

In C++, capture can also be explicit: The brackets can contain a comma-separated list of variables to capture. Variables not mentioned in the list are not captured and not available to the lambda expression. Capture is by copy by default, unless the variable name is preceded with & . The this variable can also be listed when in a non-static class member function, and it is always captured by reference. ( refreence )

Use _ as the name of lambda expression arguments to indicate they are not used, rather than dummy1, dummy2, etc. _ is a lambda discard parameter when it is the name of more than one argument.

Capture can be turned off to avoid accidental capture or if you want to have a variable the same name as a variable in the outer scope by placing the static keyword immediately before the lambda expression.

Lambda expressions can use async .

Nothing yet.

Javascript has a longer, older quasi-alternative syntax to lambda expressions (called function expressions or anonymous functions) that looks like this:

They are almost equivalent. If you don’t use this , arguments , yield , and a few other rarely used keywords, the two syntaxes are pretty much the same.

As noted previously, the capture rules apply to function expressions the same as they do with lambda expressions.

As noted earlier, the capture rules apply to local function definitions the same as they do with lambda expressions.

Because Python variable scope is determined by the nearest assignment, variables in the outer scope cannot be assigned to:

The text variable in the inner function is a different variable than the one in the outer funtion because there is an assignment to text in the inner function. A trick is to make the outer variable a contaier:

Although Python capture is always by reference, there is a trick for achieving capture by value: assigning default values to lambda expression arguments.

It’s a weird and neat trick.

• C++: Lambda expressions
• C#: Lambda expression
• Java: Lambda expressions
• Javascript: Arrow function expressions/definitions
• Python: Lambda expressions

Python Enhancement Proposals

• Python »
• PEP Index »

PEP 572 – Assignment Expressions

The importance of real code, exceptional cases, scope of the target, relative precedence of :=, change to evaluation order, differences between assignment expressions and assignment statements, specification changes during implementation, _pydecimal.py, datetime.py, sysconfig.py, simplifying list comprehensions, capturing condition values, changing the scope rules for comprehensions, alternative spellings, special-casing conditional statements, special-casing comprehensions, lowering operator precedence, allowing commas to the right, always requiring parentheses, why not just turn existing assignment into an expression, with assignment expressions, why bother with assignment statements, why not use a sublocal scope and prevent namespace pollution, style guide recommendations, acknowledgements, a numeric example, appendix b: rough code translations for comprehensions, appendix c: no changes to scope semantics.

This is a proposal for creating a way to assign to variables within an expression using the notation NAME := expr .

As part of this change, there is also an update to dictionary comprehension evaluation order to ensure key expressions are executed before value expressions (allowing the key to be bound to a name and then re-used as part of calculating the corresponding value).

During discussion of this PEP, the operator became informally known as “the walrus operator”. The construct’s formal name is “Assignment Expressions” (as per the PEP title), but they may also be referred to as “Named Expressions” (e.g. the CPython reference implementation uses that name internally).

Naming the result of an expression is an important part of programming, allowing a descriptive name to be used in place of a longer expression, and permitting reuse. Currently, this feature is available only in statement form, making it unavailable in list comprehensions and other expression contexts.

Additionally, naming sub-parts of a large expression can assist an interactive debugger, providing useful display hooks and partial results. Without a way to capture sub-expressions inline, this would require refactoring of the original code; with assignment expressions, this merely requires the insertion of a few name := markers. Removing the need to refactor reduces the likelihood that the code be inadvertently changed as part of debugging (a common cause of Heisenbugs), and is easier to dictate to another programmer.

During the development of this PEP many people (supporters and critics both) have had a tendency to focus on toy examples on the one hand, and on overly complex examples on the other.

The danger of toy examples is twofold: they are often too abstract to make anyone go “ooh, that’s compelling”, and they are easily refuted with “I would never write it that way anyway”.

The danger of overly complex examples is that they provide a convenient strawman for critics of the proposal to shoot down (“that’s obfuscated”).

Yet there is some use for both extremely simple and extremely complex examples: they are helpful to clarify the intended semantics. Therefore, there will be some of each below.

However, in order to be compelling , examples should be rooted in real code, i.e. code that was written without any thought of this PEP, as part of a useful application, however large or small. Tim Peters has been extremely helpful by going over his own personal code repository and picking examples of code he had written that (in his view) would have been clearer if rewritten with (sparing) use of assignment expressions. His conclusion: the current proposal would have allowed a modest but clear improvement in quite a few bits of code.

Another use of real code is to observe indirectly how much value programmers place on compactness. Guido van Rossum searched through a Dropbox code base and discovered some evidence that programmers value writing fewer lines over shorter lines.

Case in point: Guido found several examples where a programmer repeated a subexpression, slowing down the program, in order to save one line of code, e.g. instead of writing:

they would write:

Another example illustrates that programmers sometimes do more work to save an extra level of indentation:

This code tries to match pattern2 even if pattern1 has a match (in which case the match on pattern2 is never used). The more efficient rewrite would have been:

Syntax and semantics

In most contexts where arbitrary Python expressions can be used, a named expression can appear. This is of the form NAME := expr where expr is any valid Python expression other than an unparenthesized tuple, and NAME is an identifier.

The value of such a named expression is the same as the incorporated expression, with the additional side-effect that the target is assigned that value:

There are a few places where assignment expressions are not allowed, in order to avoid ambiguities or user confusion:

This rule is included to simplify the choice for the user between an assignment statement and an assignment expression – there is no syntactic position where both are valid.

Again, this rule is included to avoid two visually similar ways of saying the same thing.

This rule is included to disallow excessively confusing code, and because parsing keyword arguments is complex enough already.

This rule is included to discourage side effects in a position whose exact semantics are already confusing to many users (cf. the common style recommendation against mutable default values), and also to echo the similar prohibition in calls (the previous bullet).

The reasoning here is similar to the two previous cases; this ungrouped assortment of symbols and operators composed of : and = is hard to read correctly.

This allows lambda to always bind less tightly than := ; having a name binding at the top level inside a lambda function is unlikely to be of value, as there is no way to make use of it. In cases where the name will be used more than once, the expression is likely to need parenthesizing anyway, so this prohibition will rarely affect code.

This shows that what looks like an assignment operator in an f-string is not always an assignment operator. The f-string parser uses : to indicate formatting options. To preserve backwards compatibility, assignment operator usage inside of f-strings must be parenthesized. As noted above, this usage of the assignment operator is not recommended.

An assignment expression does not introduce a new scope. In most cases the scope in which the target will be bound is self-explanatory: it is the current scope. If this scope contains a nonlocal or global declaration for the target, the assignment expression honors that. A lambda (being an explicit, if anonymous, function definition) counts as a scope for this purpose.

There is one special case: an assignment expression occurring in a list, set or dict comprehension or in a generator expression (below collectively referred to as “comprehensions”) binds the target in the containing scope, honoring a nonlocal or global declaration for the target in that scope, if one exists. For the purpose of this rule the containing scope of a nested comprehension is the scope that contains the outermost comprehension. A lambda counts as a containing scope.

The motivation for this special case is twofold. First, it allows us to conveniently capture a “witness” for an any() expression, or a counterexample for all() , for example:

Second, it allows a compact way of updating mutable state from a comprehension, for example:

However, an assignment expression target name cannot be the same as a for -target name appearing in any comprehension containing the assignment expression. The latter names are local to the comprehension in which they appear, so it would be contradictory for a contained use of the same name to refer to the scope containing the outermost comprehension instead.

For example, [i := i+1 for i in range(5)] is invalid: the for i part establishes that i is local to the comprehension, but the i := part insists that i is not local to the comprehension. The same reason makes these examples invalid too:

While it’s technically possible to assign consistent semantics to these cases, it’s difficult to determine whether those semantics actually make sense in the absence of real use cases. Accordingly, the reference implementation [1] will ensure that such cases raise SyntaxError , rather than executing with implementation defined behaviour.

This restriction applies even if the assignment expression is never executed:

For the comprehension body (the part before the first “for” keyword) and the filter expression (the part after “if” and before any nested “for”), this restriction applies solely to target names that are also used as iteration variables in the comprehension. Lambda expressions appearing in these positions introduce a new explicit function scope, and hence may use assignment expressions with no additional restrictions.

Due to design constraints in the reference implementation (the symbol table analyser cannot easily detect when names are re-used between the leftmost comprehension iterable expression and the rest of the comprehension), named expressions are disallowed entirely as part of comprehension iterable expressions (the part after each “in”, and before any subsequent “if” or “for” keyword):

A further exception applies when an assignment expression occurs in a comprehension whose containing scope is a class scope. If the rules above were to result in the target being assigned in that class’s scope, the assignment expression is expressly invalid. This case also raises SyntaxError :

(The reason for the latter exception is the implicit function scope created for comprehensions – there is currently no runtime mechanism for a function to refer to a variable in the containing class scope, and we do not want to add such a mechanism. If this issue ever gets resolved this special case may be removed from the specification of assignment expressions. Note that the problem already exists for using a variable defined in the class scope from a comprehension.)

See Appendix B for some examples of how the rules for targets in comprehensions translate to equivalent code.

The := operator groups more tightly than a comma in all syntactic positions where it is legal, but less tightly than all other operators, including or , and , not , and conditional expressions ( A if C else B ). As follows from section “Exceptional cases” above, it is never allowed at the same level as = . In case a different grouping is desired, parentheses should be used.

The := operator may be used directly in a positional function call argument; however it is invalid directly in a keyword argument.

Some examples to clarify what’s technically valid or invalid:

Most of the “valid” examples above are not recommended, since human readers of Python source code who are quickly glancing at some code may miss the distinction. But simple cases are not objectionable:

This PEP recommends always putting spaces around := , similar to PEP 8 ’s recommendation for = when used for assignment, whereas the latter disallows spaces around = used for keyword arguments.)

In order to have precisely defined semantics, the proposal requires evaluation order to be well-defined. This is technically not a new requirement, as function calls may already have side effects. Python already has a rule that subexpressions are generally evaluated from left to right. However, assignment expressions make these side effects more visible, and we propose a single change to the current evaluation order:

• In a dict comprehension {X: Y for ...} , Y is currently evaluated before X . We propose to change this so that X is evaluated before Y . (In a dict display like {X: Y} this is already the case, and also in dict((X, Y) for ...) which should clearly be equivalent to the dict comprehension.)

Most importantly, since := is an expression, it can be used in contexts where statements are illegal, including lambda functions and comprehensions.

Conversely, assignment expressions don’t support the advanced features found in assignment statements:

• Multiple targets are not directly supported: x = y = z = 0 # Equivalent: (z := (y := (x := 0)))
• Single assignment targets other than a single NAME are not supported: # No equivalent a [ i ] = x self . rest = []
• Priority around commas is different: x = 1 , 2 # Sets x to (1, 2) ( x := 1 , 2 ) # Sets x to 1
• Iterable packing and unpacking (both regular or extended forms) are not supported: # Equivalent needs extra parentheses loc = x , y # Use (loc := (x, y)) info = name , phone , * rest # Use (info := (name, phone, *rest)) # No equivalent px , py , pz = position name , phone , email , * other_info = contact
• Inline type annotations are not supported: # Closest equivalent is "p: Optional[int]" as a separate declaration p : Optional [ int ] = None
• Augmented assignment is not supported: total += tax # Equivalent: (total := total + tax)

The following changes have been made based on implementation experience and additional review after the PEP was first accepted and before Python 3.8 was released:

• for consistency with other similar exceptions, and to avoid locking in an exception name that is not necessarily going to improve clarity for end users, the originally proposed TargetScopeError subclass of SyntaxError was dropped in favour of just raising SyntaxError directly. [3]
• due to a limitation in CPython’s symbol table analysis process, the reference implementation raises SyntaxError for all uses of named expressions inside comprehension iterable expressions, rather than only raising them when the named expression target conflicts with one of the iteration variables in the comprehension. This could be revisited given sufficiently compelling examples, but the extra complexity needed to implement the more selective restriction doesn’t seem worthwhile for purely hypothetical use cases.

Examples from the Python standard library

env_base is only used on these lines, putting its assignment on the if moves it as the “header” of the block.

• Current: env_base = os . environ . get ( "PYTHONUSERBASE" , None ) if env_base : return env_base
• Improved: if env_base := os . environ . get ( "PYTHONUSERBASE" , None ): return env_base

Avoid nested if and remove one indentation level.

• Current: if self . _is_special : ans = self . _check_nans ( context = context ) if ans : return ans
• Improved: if self . _is_special and ( ans := self . _check_nans ( context = context )): return ans

Code looks more regular and avoid multiple nested if. (See Appendix A for the origin of this example.)

• Current: reductor = dispatch_table . get ( cls ) if reductor : rv = reductor ( x ) else : reductor = getattr ( x , "__reduce_ex__" , None ) if reductor : rv = reductor ( 4 ) else : reductor = getattr ( x , "__reduce__" , None ) if reductor : rv = reductor () else : raise Error ( "un(deep)copyable object of type %s " % cls )
• Improved: if reductor := dispatch_table . get ( cls ): rv = reductor ( x ) elif reductor := getattr ( x , "__reduce_ex__" , None ): rv = reductor ( 4 ) elif reductor := getattr ( x , "__reduce__" , None ): rv = reductor () else : raise Error ( "un(deep)copyable object of type %s " % cls )

tz is only used for s += tz , moving its assignment inside the if helps to show its scope.

• Current: s = _format_time ( self . _hour , self . _minute , self . _second , self . _microsecond , timespec ) tz = self . _tzstr () if tz : s += tz return s
• Improved: s = _format_time ( self . _hour , self . _minute , self . _second , self . _microsecond , timespec ) if tz := self . _tzstr (): s += tz return s

Calling fp.readline() in the while condition and calling .match() on the if lines make the code more compact without making it harder to understand.

• Current: while True : line = fp . readline () if not line : break m = define_rx . match ( line ) if m : n , v = m . group ( 1 , 2 ) try : v = int ( v ) except ValueError : pass vars [ n ] = v else : m = undef_rx . match ( line ) if m : vars [ m . group ( 1 )] = 0
• Improved: while line := fp . readline (): if m := define_rx . match ( line ): n , v = m . group ( 1 , 2 ) try : v = int ( v ) except ValueError : pass vars [ n ] = v elif m := undef_rx . match ( line ): vars [ m . group ( 1 )] = 0

A list comprehension can map and filter efficiently by capturing the condition:

Similarly, a subexpression can be reused within the main expression, by giving it a name on first use:

Note that in both cases the variable y is bound in the containing scope (i.e. at the same level as results or stuff ).

Assignment expressions can be used to good effect in the header of an if or while statement:

Particularly with the while loop, this can remove the need to have an infinite loop, an assignment, and a condition. It also creates a smooth parallel between a loop which simply uses a function call as its condition, and one which uses that as its condition but also uses the actual value.

An example from the low-level UNIX world:

Rejected alternative proposals

Proposals broadly similar to this one have come up frequently on python-ideas. Below are a number of alternative syntaxes, some of them specific to comprehensions, which have been rejected in favour of the one given above.

A previous version of this PEP proposed subtle changes to the scope rules for comprehensions, to make them more usable in class scope and to unify the scope of the “outermost iterable” and the rest of the comprehension. However, this part of the proposal would have caused backwards incompatibilities, and has been withdrawn so the PEP can focus on assignment expressions.

Broadly the same semantics as the current proposal, but spelled differently.

Since EXPR as NAME already has meaning in import , except and with statements (with different semantics), this would create unnecessary confusion or require special-casing (e.g. to forbid assignment within the headers of these statements).

(Note that with EXPR as VAR does not simply assign the value of EXPR to VAR – it calls EXPR.__enter__() and assigns the result of that to VAR .)

Additional reasons to prefer := over this spelling include:

• In if f(x) as y the assignment target doesn’t jump out at you – it just reads like if f x blah blah and it is too similar visually to if f(x) and y .
• import foo as bar
• except Exc as var
• with ctxmgr() as var

To the contrary, the assignment expression does not belong to the if or while that starts the line, and we intentionally allow assignment expressions in other contexts as well.

• NAME = EXPR
• if NAME := EXPR

reinforces the visual recognition of assignment expressions.

This syntax is inspired by languages such as R and Haskell, and some programmable calculators. (Note that a left-facing arrow y <- f(x) is not possible in Python, as it would be interpreted as less-than and unary minus.) This syntax has a slight advantage over ‘as’ in that it does not conflict with with , except and import , but otherwise is equivalent. But it is entirely unrelated to Python’s other use of -> (function return type annotations), and compared to := (which dates back to Algol-58) it has a much weaker tradition.

This has the advantage that leaked usage can be readily detected, removing some forms of syntactic ambiguity. However, this would be the only place in Python where a variable’s scope is encoded into its name, making refactoring harder.

Execution order is inverted (the indented body is performed first, followed by the “header”). This requires a new keyword, unless an existing keyword is repurposed (most likely with: ). See PEP 3150 for prior discussion on this subject (with the proposed keyword being given: ).

This syntax has fewer conflicts than as does (conflicting only with the raise Exc from Exc notation), but is otherwise comparable to it. Instead of paralleling with expr as target: (which can be useful but can also be confusing), this has no parallels, but is evocative.

One of the most popular use-cases is if and while statements. Instead of a more general solution, this proposal enhances the syntax of these two statements to add a means of capturing the compared value:

This works beautifully if and ONLY if the desired condition is based on the truthiness of the captured value. It is thus effective for specific use-cases (regex matches, socket reads that return '' when done), and completely useless in more complicated cases (e.g. where the condition is f(x) < 0 and you want to capture the value of f(x) ). It also has no benefit to list comprehensions.

Advantages: No syntactic ambiguities. Disadvantages: Answers only a fraction of possible use-cases, even in if / while statements.

Another common use-case is comprehensions (list/set/dict, and genexps). As above, proposals have been made for comprehension-specific solutions.

This brings the subexpression to a location in between the ‘for’ loop and the expression. It introduces an additional language keyword, which creates conflicts. Of the three, where reads the most cleanly, but also has the greatest potential for conflict (e.g. SQLAlchemy and numpy have where methods, as does tkinter.dnd.Icon in the standard library).

As above, but reusing the with keyword. Doesn’t read too badly, and needs no additional language keyword. Is restricted to comprehensions, though, and cannot as easily be transformed into “longhand” for-loop syntax. Has the C problem that an equals sign in an expression can now create a name binding, rather than performing a comparison. Would raise the question of why “with NAME = EXPR:” cannot be used as a statement on its own.

As per option 2, but using as rather than an equals sign. Aligns syntactically with other uses of as for name binding, but a simple transformation to for-loop longhand would create drastically different semantics; the meaning of with inside a comprehension would be completely different from the meaning as a stand-alone statement, while retaining identical syntax.

Regardless of the spelling chosen, this introduces a stark difference between comprehensions and the equivalent unrolled long-hand form of the loop. It is no longer possible to unwrap the loop into statement form without reworking any name bindings. The only keyword that can be repurposed to this task is with , thus giving it sneakily different semantics in a comprehension than in a statement; alternatively, a new keyword is needed, with all the costs therein.

There are two logical precedences for the := operator. Either it should bind as loosely as possible, as does statement-assignment; or it should bind more tightly than comparison operators. Placing its precedence between the comparison and arithmetic operators (to be precise: just lower than bitwise OR) allows most uses inside while and if conditions to be spelled without parentheses, as it is most likely that you wish to capture the value of something, then perform a comparison on it:

Once find() returns -1, the loop terminates. If := binds as loosely as = does, this would capture the result of the comparison (generally either True or False ), which is less useful.

While this behaviour would be convenient in many situations, it is also harder to explain than “the := operator behaves just like the assignment statement”, and as such, the precedence for := has been made as close as possible to that of = (with the exception that it binds tighter than comma).

Some critics have claimed that the assignment expressions should allow unparenthesized tuples on the right, so that these two would be equivalent:

(With the current version of the proposal, the latter would be equivalent to ((point := x), y) .)

However, adopting this stance would logically lead to the conclusion that when used in a function call, assignment expressions also bind less tight than comma, so we’d have the following confusing equivalence:

The less confusing option is to make := bind more tightly than comma.

It’s been proposed to just always require parentheses around an assignment expression. This would resolve many ambiguities, and indeed parentheses will frequently be needed to extract the desired subexpression. But in the following cases the extra parentheses feel redundant:

Frequently Raised Objections

C and its derivatives define the = operator as an expression, rather than a statement as is Python’s way. This allows assignments in more contexts, including contexts where comparisons are more common. The syntactic similarity between if (x == y) and if (x = y) belies their drastically different semantics. Thus this proposal uses := to clarify the distinction.

The two forms have different flexibilities. The := operator can be used inside a larger expression; the = statement can be augmented to += and its friends, can be chained, and can assign to attributes and subscripts.

Previous revisions of this proposal involved sublocal scope (restricted to a single statement), preventing name leakage and namespace pollution. While a definite advantage in a number of situations, this increases complexity in many others, and the costs are not justified by the benefits. In the interests of language simplicity, the name bindings created here are exactly equivalent to any other name bindings, including that usage at class or module scope will create externally-visible names. This is no different from for loops or other constructs, and can be solved the same way: del the name once it is no longer needed, or prefix it with an underscore.

(The author wishes to thank Guido van Rossum and Christoph Groth for their suggestions to move the proposal in this direction. [2] )

As expression assignments can sometimes be used equivalently to statement assignments, the question of which should be preferred will arise. For the benefit of style guides such as PEP 8 , two recommendations are suggested.

• If either assignment statements or assignment expressions can be used, prefer statements; they are a clear declaration of intent.
• If using assignment expressions would lead to ambiguity about execution order, restructure it to use statements instead.

The authors wish to thank Alyssa Coghlan and Steven D’Aprano for their considerable contributions to this proposal, and members of the core-mentorship mailing list for assistance with implementation.

Appendix A: Tim Peters’s findings

Here’s a brief essay Tim Peters wrote on the topic.

I dislike “busy” lines of code, and also dislike putting conceptually unrelated logic on a single line. So, for example, instead of:

instead. So I suspected I’d find few places I’d want to use assignment expressions. I didn’t even consider them for lines already stretching halfway across the screen. In other cases, “unrelated” ruled:

is a vast improvement over the briefer:

The original two statements are doing entirely different conceptual things, and slamming them together is conceptually insane.

In other cases, combining related logic made it harder to understand, such as rewriting:

as the briefer:

The while test there is too subtle, crucially relying on strict left-to-right evaluation in a non-short-circuiting or method-chaining context. My brain isn’t wired that way.

But cases like that were rare. Name binding is very frequent, and “sparse is better than dense” does not mean “almost empty is better than sparse”. For example, I have many functions that return None or 0 to communicate “I have nothing useful to return in this case, but since that’s expected often I’m not going to annoy you with an exception”. This is essentially the same as regular expression search functions returning None when there is no match. So there was lots of code of the form:

I find that clearer, and certainly a bit less typing and pattern-matching reading, as:

It’s also nice to trade away a small amount of horizontal whitespace to get another _line_ of surrounding code on screen. I didn’t give much weight to this at first, but it was so very frequent it added up, and I soon enough became annoyed that I couldn’t actually run the briefer code. That surprised me!

There are other cases where assignment expressions really shine. Rather than pick another from my code, Kirill Balunov gave a lovely example from the standard library’s copy() function in copy.py :

The ever-increasing indentation is semantically misleading: the logic is conceptually flat, “the first test that succeeds wins”:

Using easy assignment expressions allows the visual structure of the code to emphasize the conceptual flatness of the logic; ever-increasing indentation obscured it.

A smaller example from my code delighted me, both allowing to put inherently related logic in a single line, and allowing to remove an annoying “artificial” indentation level:

That if is about as long as I want my lines to get, but remains easy to follow.

So, in all, in most lines binding a name, I wouldn’t use assignment expressions, but because that construct is so very frequent, that leaves many places I would. In most of the latter, I found a small win that adds up due to how often it occurs, and in the rest I found a moderate to major win. I’d certainly use it more often than ternary if , but significantly less often than augmented assignment.

I have another example that quite impressed me at the time.

Where all variables are positive integers, and a is at least as large as the n’th root of x, this algorithm returns the floor of the n’th root of x (and roughly doubling the number of accurate bits per iteration):

It’s not obvious why that works, but is no more obvious in the “loop and a half” form. It’s hard to prove correctness without building on the right insight (the “arithmetic mean - geometric mean inequality”), and knowing some non-trivial things about how nested floor functions behave. That is, the challenges are in the math, not really in the coding.

If you do know all that, then the assignment-expression form is easily read as “while the current guess is too large, get a smaller guess”, where the “too large?” test and the new guess share an expensive sub-expression.

To my eyes, the original form is harder to understand:

This appendix attempts to clarify (though not specify) the rules when a target occurs in a comprehension or in a generator expression. For a number of illustrative examples we show the original code, containing a comprehension, and the translation, where the comprehension has been replaced by an equivalent generator function plus some scaffolding.

Since [x for ...] is equivalent to list(x for ...) these examples all use list comprehensions without loss of generality. And since these examples are meant to clarify edge cases of the rules, they aren’t trying to look like real code.

Note: comprehensions are already implemented via synthesizing nested generator functions like those in this appendix. The new part is adding appropriate declarations to establish the intended scope of assignment expression targets (the same scope they resolve to as if the assignment were performed in the block containing the outermost comprehension). For type inference purposes, these illustrative expansions do not imply that assignment expression targets are always Optional (but they do indicate the target binding scope).

Let’s start with a reminder of what code is generated for a generator expression without assignment expression.

• Original code (EXPR usually references VAR): def f (): a = [ EXPR for VAR in ITERABLE ]
• Translation (let’s not worry about name conflicts): def f (): def genexpr ( iterator ): for VAR in iterator : yield EXPR a = list ( genexpr ( iter ( ITERABLE )))

Let’s add a simple assignment expression.

• Original code: def f (): a = [ TARGET := EXPR for VAR in ITERABLE ]
• Translation: def f (): if False : TARGET = None # Dead code to ensure TARGET is a local variable def genexpr ( iterator ): nonlocal TARGET for VAR in iterator : TARGET = EXPR yield TARGET a = list ( genexpr ( iter ( ITERABLE )))

Let’s add a global TARGET declaration in f() .

• Original code: def f (): global TARGET a = [ TARGET := EXPR for VAR in ITERABLE ]
• Translation: def f (): global TARGET def genexpr ( iterator ): global TARGET for VAR in iterator : TARGET = EXPR yield TARGET a = list ( genexpr ( iter ( ITERABLE )))

Or instead let’s add a nonlocal TARGET declaration in f() .

• Original code: def g (): TARGET = ... def f (): nonlocal TARGET a = [ TARGET := EXPR for VAR in ITERABLE ]
• Translation: def g (): TARGET = ... def f (): nonlocal TARGET def genexpr ( iterator ): nonlocal TARGET for VAR in iterator : TARGET = EXPR yield TARGET a = list ( genexpr ( iter ( ITERABLE )))

Finally, let’s nest two comprehensions.

• Original code: def f (): a = [[ TARGET := i for i in range ( 3 )] for j in range ( 2 )] # I.e., a = [[0, 1, 2], [0, 1, 2]] print ( TARGET ) # prints 2
• Translation: def f (): if False : TARGET = None def outer_genexpr ( outer_iterator ): nonlocal TARGET def inner_generator ( inner_iterator ): nonlocal TARGET for i in inner_iterator : TARGET = i yield i for j in outer_iterator : yield list ( inner_generator ( range ( 3 ))) a = list ( outer_genexpr ( range ( 2 ))) print ( TARGET )

Because it has been a point of confusion, note that nothing about Python’s scoping semantics is changed. Function-local scopes continue to be resolved at compile time, and to have indefinite temporal extent at run time (“full closures”). Example:

This document has been placed in the public domain.

Source: https://github.com/python/peps/blob/main/peps/pep-0572.rst

Last modified: 2023-10-11 12:05:51 GMT

Python Tutorial

File handling, python modules, python numpy, python pandas, python matplotlib, python scipy, machine learning, python mysql, python mongodb, python reference, module reference, python how to, python examples, python lambda.

A lambda function is a small anonymous function.

A lambda function can take any number of arguments, but can only have one expression.

The expression is executed and the result is returned:

Add 10 to argument a , and return the result:

Lambda functions can take any number of arguments:

Multiply argument a with argument b and return the result:

Summarize argument a , b , and c and return the result:

Advertisement

Why Use Lambda Functions?

The power of lambda is better shown when you use them as an anonymous function inside another function.

Say you have a function definition that takes one argument, and that argument will be multiplied with an unknown number:

Use that function definition to make a function that always doubles the number you send in:

Or, use the same function definition to make a function that always triples the number you send in:

Or, use the same function definition to make both functions, in the same program:

Use lambda functions when an anonymous function is required for a short period of time.

Test Yourself With Exercises

Create a lambda function that takes one parameter ( a ) and returns it.

Start the Exercise

Lambda Functions in map() Functions

COLOR PICKER

Report Error

If you want to report an error, or if you want to make a suggestion, do not hesitate to send us an e-mail:

[email protected]

Top Tutorials

Top references, top examples, get certified.

• Documentation »
• Correctness »
• Assigning a lambda expression to a variable
• View page source

Assigning a lambda expression to a variable ¶

The sole advantage that a lambda expression has over a def is that the lambda can be anonymously embedded within a larger expression. If you are going to assign a name to a lambda , you are better off just defining it as a def .

From the PEP 8 Style Guide:

The first form means that the name of the resulting function object is specifically ‘f’ instead of the generic ‘<lambda>’. This is more useful for tracebacks and string representations in general. The use of the assignment statement eliminates the sole benefit a lambda expression can offer over an explicit def statement (i.e. that it can be embedded inside a larger expression)

Anti-pattern ¶

The following code assigns a lambda function which returns the double of its input to a variable. This is functionally identical to creating a def .

Best practice ¶

Use a def for named expressions ¶.

Refactor the lambda expression into a named def expression.

References ¶

• PEP 8 Style Guide - Programming Recommendations
• Stack Overflow - Do not assign a lambda expression

Learn to Code. Shape Your Future

Python: Using a Lambda as a Class Method

You can use Python lambdas in different contexts, from simple one-liners to more complex applications. One question that sometimes comes up among developers is whether a Python lambda can be used as a class method.

This article answers this question. We will start with a recap of the basic structure of a lambda function, and then dive into a practical example using a Python class.

If you are not familiar with lambda functions, read the first three sections of the Codefather tutorial about lambda functions . Then come back to this article.

Table of Contents

Lambda Functions in Python

Before we see how to use lambda functions as class methods, let’s take a quick moment to explore what lambda functions are and how they work in Python.

Lambda functions (also known as anonymous functions) are a type of function defined with the lambda keyword. Unlike regular functions declared with the def keyword, lambda functions are used for small, one-line tasks where defining a full function might be too verbose.

In Python, a lambda function can take one or more arguments and can only have one expression. Below you can see the syntax of a lambda:

The expression is evaluated and returned when the lambda function is called. The inline nature of lambda functions makes them a popular choice for short operations.

Now let’s talk about utilizing lambda functions within classes. Typically, methods within a class are defined using the def keyword, as they often involve more complex operations and benefit from the structure of a regular function .

But what if you have a class method that is simple enough and hence you can express it with a single line of code? Is it worth using a lambda function instead of a traditional method?

In the next section, we will explore this idea further with a practical example.

Lambda Function Applied to a Class Method

Let’s examine what it means to replace a standard class method with a lambda function and what syntax you will have to use.

This will help us understand not only how to use lambda functions as class methods but also when they might be a suitable choice for your Python classes.

We will define a class called Character that contains a constructor and the run() method that prints a message:

Create an instance of this class called Spartacus and execute the run() method on it:

Here is the output you get when executing the method:

Now, let’s replace the run() method with a lambda function:

An important aspect of the line of code above is that we assign the function object returned by the lambda function to the variable run .

Notice also that:

• We have removed the def keyword because it applies to a regular method but not to a lambda.
• The argument of the lambda is the instance of the class ( self ) .
• The expression of the lambda is the body of the original class method that prints a message.

This is the updated class:

Execute the run() method again on the instance of the Character class. Then confirm that the output message is the same.

The output is correct and this shows that you can use a lambda as a class method.

It’s up to you to choose which one you prefer depending on what makes your code easy to maintain and to understand.

Advantages and Disadvantages of Lambdas as Class Methods

So far, we have introduced the concept of lambda functions and seen their basic application in our class. Now, let’s look at the potential advantages of using lambdas as class methods.

Lambda functions are concise, which means that they can make your code shorter and more Pythonic when you can express the method’s functionality in a single line.

However, a disadvantage is that this comes at a cost as one of the key aspects to keep in mind is the readability and maintainability of your code. While lambdas can reduce the length of the code, they can also make it less readable for developers who are not familiar with functional programming.

Another disadvantage is that lambdas are not suitable when a class method requires the following

• complex logic
• multiple statements
• any kind of branching logic (like if-else statements)
• annotations

Here are some common questions about using Python lambda functions as class methods.

• A: Lambda functions as class methods are best suited for simple operations that don’t require complex logic or multiple statements. Use them when you have a short, one-line method that executes a single action or calculation. If your method requires complex logic, it’s better to use a regular method.
• A: No, you do not use the def keyword when defining a lambda function, including when using it as a class method. Lambda functions are defined using the lambda keyword, which differentiates them from regular functions.
• A : No, docstrings are not supported when using a lambda function as a class method. Lambda functions do not support this Python feature.

In this tutorial, you have seen how to write code that uses a Python lambda as a class method.

Now you should have a clearer understanding of when and if to use lambda functions in your class methods. Make sure that this aligns with Python’s philosophy of writing clear and readable code.

Related article : Do you want to know more about lambdas? If you haven’t already, go through the Codefather tutorial about Python lambda functions .

How useful was this post?

Click on a star to rate it!

Average rating 0 / 5. Vote count: 0

No votes so far! Be the first to rate this post.

Claudio Sabato is an IT expert with over 15 years of professional experience in Python programming, Linux Systems Administration, Bash programming, and IT Systems Design. He is a professional certified by the Linux Professional Institute .

With a Master’s degree in Computer Science, he has a strong foundation in Software Engineering and a passion for robotics with Raspberry Pi.

Related posts:

• Compare Strings in Python: Everything You Need to Know
• Python Class Definition: Object Oriented Programming Made Easy
• Python args And kwargs Explained: All You Need to Know
• Ternary Operator in Python: To Use or Not to Use?

Leave a Comment Cancel reply

Save my name, email, and website in this browser for the next time I comment.

• Privacy Overview
• Strictly Necessary Cookies

This website uses cookies so that we can provide you with the best user experience possible. Cookie information is stored in your browser and performs functions such as recognising you when you return to our website and helping our team to understand which sections of the website you find most interesting and useful.

Strictly Necessary Cookie should be enabled at all times so that we can save your preferences for cookie settings.

If you disable this cookie, we will not be able to save your preferences. This means that every time you visit this website you will need to enable or disable cookies again.

How to use lambda functions in Pandas

Learn how to use lambda functions in pandas to run small anonymous custom functions using apply() and assign() using method chaining..

Lamdba functions are small anonymous functions that don’t need to be defined with a name. If you’re creating a function to solve a specific problem in Pandas and there’s little likelihood that you’ll need to re-use the function, you may want to consider using a lambda function in Pandas.

In this simple tutorial we’ll cover the basics of using lambda functions in Pandas and show how you can use them using the Pandas apply() function and the Pandas assign() function , both individually and via the Pandas method chaining technique.

Create a Pandas dataframe

Open a Jupyter notebook, import the Pandas library, and create a dataframe . I’ve created a dummy dataframe based on a series of dates and some ecommerce website metrics. We’ll use lambda functions to perform some calculations on these data next.

Use apply to run a lambda function

One of the most commonly used ways to run a lambda function is via the Pandas apply() method. While the apply() method works fine, it isn’t vectorised, so it’s slower than some other techniques, and you may wish to use a different method instead.

The lambda function itself is the section of code that reads lambda x: x['revenue'] / x['transactions'] . This takes x (which is the Pandas dataframe), and then divides the value in the transactions column by the value in the revenue column. The axis=1 argument is part of apply() and tells the function to look at the row level data.

Use assign() to run a lambda function on two columns

The Pandas assign() method has some benefits over apply() . It can be used on multiple columns, works well with chaining, and avoids the dreaded SettingWithCopyWarning error. It’s one of the best ways to add a new Pandas column .

Since assign() returns a dataframe, you need to save the output back to the original dataframe in order to keep the column you’ve added. Here, we’re running the same lambda function to create an aov column and then saving it back to the original df .

Use method chaining to run multiple lambda functions

The other neat thing about the Pandas assign() method is that it can be used to run a series of lambda functions via a modern Pandas technique called method chaining.

To use method chaining we first wrap the chain up in parentheses to allow us to incorporate whitespace to aid visibility, and then we’ll run a series of lambda functions on various columns within a single assign() function call.

Matt Clarke, Sunday, January 01, 2023

How to use sort_values() to sort a Pandas DataFrame

How to select, filter, and subset data in Pandas dataframes

How to use Category Encoders to encode categorical variables

How to prefix or suffix Pandas column names and values

How to create an ABC XYZ inventory classification model

How to calculate abandonment and completion rates using the Google Analytics API

How to use Pandas from_records() to create a dataframe

How to calculate an exponential moving average in Pandas

How to use the Pandas map() function

How to use Pandas pipe() to create data pipelines

How to use Pandas assign() to create new dataframe columns

How to measure Python code execution times with timeit

Other posts you might like.

How to use the Pandas truncate() function

Have you ever needed to chop the top or bottom off a pandas dataframe, or extract a specific section from the middle if so, there’s a pandas function called truncate()....

How to use Spacy for noun phrase extraction

Noun phrase extraction is a natural language processing technique that can be used to identify and extract noun phrases from text. noun phrases are phrases that function grammatically as nouns....

How to use the Pandas filter() function

The pandas filter() function is used to filter a dataframe based on the column names, rather than the column values, and is useful in creating a subset dataframe containing only..., get the newsletter.

Browser out of date.

It appears you're running on a very old web browser that we're unable to support. If you would like to view the site you'll need to update your browser. Please choose from any of the following modern browsers. Thanks!

Google Chrome

Mozilla Firefox

Internet Explorer

Oct 23, 2023 Snowflake has announced its intent to acquire Ponder.

Professional Pandas: The Pandas Assign Method and Chaining

Matt Harrison

Aug 24, 2022 15 min read

This article on the Pandas assign method is the first in a series of Professional Pandas blog posts that we will put out over the coming months. The goal of this series is to teach best practices about writing professional-grade pandas code. If you have questions or topics that you would like to dive into, please reach out on Twitter to @ponderdata or @__mharrison__ , and if you’d like to see the notebook version of this blogpost, you can find it on Github here .

Try Ponder Today

Start running pandas and NumPy in your database within minutes!

Get started

• You get around the dreaded SettingWithCopyWarning
• It enables chaining
• It forces you to write readable code that you, your future self, and your colleagues will appreciate
• It eases otherwise difficult operations

For those still reading, let’s jump in!

This data set has some descriptive columns and some daily facts:

• PRCP  – liquid precipitation (inches)
• SNOW  – snowfall (inches)
• SNWD  – snow on the ground (inches)
• TMAX  – maximum temperature (F)
• TMIN  – minimum temperature (F)
• TOBS  – temperature (F) at observation time

Create a new column

A common operation is adding a column to a dataframe.

Most create a column by using index assignment. This is convenient because:

• It looks like a dictionary operation that Python users are used to
• It (usually) overwrites the data making it a low overhead operation

There are also some disadvantages:

• It might cause a SettingWithCopyWarning
• It does not return a dataframe. Hence it cannot be used in a chain of operations
• Many users create intermediate variables (and call .copy on the dataframe), thus removing the low overhead benefit

Using Pandas assign instead

• It returns a new dataframe so you can chain operations
• It sidesteps the  SettingWithCopyWarning  completely. (As in, you will NEVER see it or deal with it).
• It makes your code read like a recipe
• It forces you to think about the order of column creation for dependent columns
• It allows you to create multiple columns
• It lets you merge in a dataframe
• It copies the dataframe (in the Pandas implementation)
• Because it uses keyword parameters, you are limited to column names that are valid Python parameter names (unless you do ** unpacking with a dictionary that has the column stored as a key)
• It requires knowledge of lambda functions if you want to work on intermediate dataframes

Chaining interlude

This section might be controversial. My advice is to hold back your cringe reflex and hear me out. (Also, I would advise you to try out this style on your own code. My experience is that many who initially are repulsed by this have a wonderful epiphany when they try it, and it completely changes the way they write Pandas code.)

Folks who read my book, Effective Pandas , or follow my Pandas content know that I’m a big proponent of chaining .

What is chaining?

Chaining is writing a series of operations to a dataframe to manipulate it. Each operation works on the result of the previous operation.

One complaint I have against the many “learn to use Pandas” blog posts scattered about the internet is that they teach a method in isolation. In practice, you almost never perform an operation to data in isolation. There are multiple operations that are required to change column types, update values, deal with missing data, aggregate, plot, etc. But generally, you only care about the end result. The intermediate data along the way is not important.

Let’s assume that you wanted to summarize the Alta data by week. You might:

• Filter out columns
• Group by the date
• Aggregate different columns (by different functions)
• Create a new column with the NAME of the ski resort
• Create a new column with the weekly range

Let’s also assume that the resort was named “Alta Ski Resort” before year 2000 and just “Alta” after.

Most folks would write code like this:

They would find that the lines:

don’t really work and would probably change them to this (after searching around on the internet):

Now let’s add a ski season to the rows. Generally a ski season starts in November and ends in April.

Finally, let’s add a year to the  SEASON :

This looks ok, and you have probably seen code like this. You’ve probably written code like this if you are reading this post.

It does have some issues. It spans multiple cells, creates unneeded intermediate variables, and might be buggy (note that the  LOCATION  column initially failed silently).

A false positive issue

I beg to differ. It is written as a chain. But I didn’t write out all the code at once. I wrote one operation at a time. Then I ran the code and validated (debugged) that it was doing what I wanted.

Also, this chain reads like a recipe of steps:

• Pull out the columns
• Groupby by the date with a weekly ( 'W' ) frequency
• Aggregate the columns as indicated
• Push the index (the week date) into a column
• Add a temperature range ( T_RANGE ) column
• Add columns for LOCATION and SEASON
• Update the LOCATION and SEASON columns with logic

In fact, writing chains forces you to think about each step that you will perform on the data. It is a constraint that I find allows me to write better code. (Again, you might think I’m spewing crazy talk. Try it out and see how it helps with your code.)

This code is also easy to execute. It is all in one place. Another struggle with notebooks is cells strewn with data manipulation logic (that can be executed in arbitrary order). With the chained code, you can come back to this notebook in the future and run this cell with confidence, knowing that you weren’t missing running other random cells from the notebook.

Real issues with Pandas assign

However, I think if you want to be a serious user of Pandas, it pays off to take a few minutes to understand lambda functions.

We use lambda expressions to create anonymous functions. These are just functions that we can inline in a call. In fact, we don’t really need to use them. We can define a normal function instead. I could write the line:

Complaints that this code is “complicated” are valid, in my opinion. But the complication comes from Pandas’ lack of providing a clean interface for if else logic, not from the chain.

Further refactoring

To address the “complicated” nature of creating the  LOCATION  and  SEASON  columns, you might consider refactoring the logic to create these columns into a function:

Create a plot

Ok, a weekly summary is nice. But the goal of most manipulating data is not the individual step but creating a result that we can use to inspire, inform, or take action. Let’s use Matplotlib to create a plot of snow on the ground during a season.

Ponder is the company that lets you run your Python data workflows (in Pandas or NumPy) securely, seamlessly, and scalably in your data warehouse or database. Sign up for a free trial !

Start running your Python data science workflows in your database within minutes!

Oct 23, 2023

We are excited to announce Snowflake’s intent to acquire Ponder to bring Ponder’s Python data science innovations to its customers and to accelerate the growth of the Modin community.

Oct 3, 2023

Professional Pandas: Handling Missing Data With Pandas Dropna

This is the fifth in a series of blog posts that teach how to write professional-quality pandas code. We start by discussing pandas dropna generally and going over a simple example. Then we talk about identifying missing values, when to drop data, and how to drop entire rows that are missing.

Sep 19, 2023

How To Use pandas resample on a Database

In this article, we describe pandas resample + provide some examples, and then show how you can use it at scale in your database.

Ready to level up your Pandas game?

Fill out the form and we'll be in touch as soon as possible!

cppreference.com

Lambda expressions (since c++11).

Constructs a closure : an unnamed function object capable of capturing variables in scope.

[ edit ] Syntax

[ edit ] lambda expressions without an explicit template parameter list (possibly non-generic), [ edit ] lambda expressions with an explicit template parameter list (always generic) (since c++20), [ edit ] explanation.

• If operator ( ) satisfy all constexpr function requirements, operator ( ) will be constexpr even if constexpr is not present.
• consteval and constexpr cannot be specified at the same time.
• static and mutable cannot be specified at the same time.
• Cannot be used if captures is not empty, or an explicit object parameter is present.

A variable __func__ is implicitly defined at the beginning of body , with semantics as described here .

The lambda expression is a prvalue expression of unique unnamed non- union non- aggregate non- structural class type, known as closure type , which is declared (for the purposes of ADL ) in the smallest block scope, class scope, or namespace scope that contains the lambda expression. The closure type has the following members, they cannot be explicitly instantiated , explicitly specialized , or (since C++14) named in a friend declaration :

ClosureType:: operator()( params )

Executes the body of the lambda-expression, when invoked. When accessing a variable, accesses its captured copy (for the entities captured by copy), or the original object (for the entities captured by reference).

The parameter list of operator ( ) is params if it is provided, otherwise the parameter list is empty.

The return type of operator ( ) is the type specified in trailing-type .

Unless the keyword mutable was used in the lambda specifiers , or an explicit object parameter is present (since C++23) , the cv-qualifier of operator ( ) is const and the objects that were captured by copy are non-modifiable from inside this operator ( ) . Explicit const qualifier is not allowed. operator ( ) is never virtual and cannot have the volatile qualifier.

The exception specification exception on the lambda-expression applies to operator ( ) .

For the purpose of name lookup , determining the type and value of the this pointer and for accessing non-static class members, the body of the closure type's operator ( ) is considered in the context of the lambda-expression.

Dangling references

If a non-reference entity is captured by reference, implicitly or explicitly, and operator ( ) of the closure object is invoked after the entity's lifetime has ended, undefined behavior occurs. The C++ closures do not extend the lifetimes of objects captured by reference.

Same applies to the lifetime of the current * this object captured via this .

ClosureType:: operator ret (*)( params )()

This user-defined conversion function is only defined if the capture list of the lambda-expression is empty. It is a public, constexpr, (since C++17) non-virtual, non-explicit, const noexcept member function of the closure object.

ClosureType:: ClosureType()

The copy constructor and the move constructor are declared as defaulted and may be implicitly-defined according to the usual rules for copy constructors and move constructors .

ClosureType:: operator=(const ClosureType&)

Closuretype:: ~closuretype().

The destructor is implicitly-declared.

ClosureType:: Captures

If the lambda-expression captures anything by copy (either implicitly with capture clause [=] or explicitly with a capture that does not include the character &, e.g. [a, b, c] ), the closure type includes unnamed non-static data members, declared in unspecified order, that hold copies of all entities that were so captured.

Those data members that correspond to captures without initializers are direct-initialized when the lambda-expression is evaluated. Those that correspond to captures with initializers are initialized as the initializer requires (could be copy- or direct-initialization). If an array is captured, array elements are direct-initialized in increasing index order. The order in which the data members are initialized is the order in which they are declared (which is unspecified).

The type of each data member is the type of the corresponding captured entity, except if the entity has reference type (in that case, references to functions are captured as lvalue references to the referenced functions, and references to objects are captured as copies of the referenced objects).

For the entities that are captured by reference (with the capture-default [&] or when using the character &, e.g. [&a, &b, &c] ), it is unspecified if additional data members are declared in the closure type , but any such additional members must satisfy LiteralType (since C++17) .

[ edit ] Lambda capture

The captures is a comma-separated list of zero or more captures , optionally beginning with the capture-default . The capture list defines the outside variables that are accessible from within the lambda function body. The only capture defaults are

• & (implicitly capture the used variables with automatic storage duration by reference) and
• = (implicitly capture the used variables with automatic storage duration by copy).

The current object ( * this ) can be implicitly captured if either capture default is present. If implicitly captured, it is always captured by reference, even if the capture default is = . The implicit capture of * this when the capture default is = is deprecated. (since C++20)

The syntax of an individual capture in captures is

If the capture-default is & , subsequent simple captures must not begin with & .

If the capture-default is = , subsequent simple captures must begin with & or be *this (since C++17) or this (since C++20) .

Any capture may appear only once, and its name must be different from any parameter name:

Only lambda-expressions defined at block scope or in a default member initializer may have a capture-default or captures without initializers. For such lambda-expression, the reaching scope is defined as the set of enclosing scopes up to and including the innermost enclosing function (and its parameters). This includes nested block scopes and the scopes of enclosing lambdas if this lambda is nested.

The identifier in any capture without an initializer (other than the this -capture) is looked up using usual unqualified name lookup in the reaching scope of the lambda. The result of the lookup must be a variable with automatic storage duration declared in the reaching scope , or a structured binding whose corresponding variable satisfies such requirements (since C++20) . The entity is explicitly captured .

If a capture list has a capture-default and does not explicitly capture the enclosing object (as this or * this ), or an automatic variable that is odr-usable in the lambda body , or a structured binding whose corresponding variable has atomic storage duration (since C++20) , it captures the entity implicitly if the entity is named in a potentially-evaluated expression within an expression (including when the implicit this - > is added before a use of non-static class member).

For the purpose of determining implicit captures, typeid is never considered to make its operands unevaluated.

If the body of a lambda odr-uses an entity captured by copy, the member of the closure type is accessed. If it is not odr-using the entity, the access is to the original object:

If a lambda odr-uses a reference that is captured by reference, it is using the object referred-to by the original reference, not the captured reference itself:

Within the body of a lambda with capture default = , the type of any capturable entity is as if it were captured (and thus const-qualification is often added if the lambda is not mutable ), even though the entity is in an unevaluated operand and not captured (e.g. in decltype ):

Any entity captured by a lambda (implicitly or explicitly) is odr-used by the lambda-expression (therefore, implicit capture by a nested lambda triggers implicit capture in the enclosing lambda).

All implicitly-captured variables must be declared within the reaching scope of the lambda.

If a lambda captures the enclosing object (as this or * this ), either the nearest enclosing function must be a non-static member function or the lambda must be in a default member initializer :

If a lambda expression (or a specialization of a generic lambda's function call operator) (since C++14) ODR-uses * this or any variable with automatic storage duration, it must be captured by the lambda expression.

Class members cannot be captured explicitly by a capture without initializer (as mentioned above, only variables are permitted in the capture list):

When a lambda captures a member using implicit by-copy capture, it does not make a copy of that member variable: the use of a member variable m is treated as an expression ( * this ) . m , and * this is always implicitly captured by reference:

Members of anonymous unions members cannot be captured. Bit-fields can only be captured by copy.

If a nested lambda m2 captures something that is also captured by the immediately enclosing lambda m1 , then m2 's capture is transformed as follows:

• if the enclosing lambda m1 captures by copy, m2 is capturing the non-static member of m1 's closure type, not the original variable or * this ; if m1 is not mutable, the non-static data member is considered to be const-qualified.
• if the enclosing lambda m1 captures by reference, m2 is capturing the original variable or * this .

[ edit ] Notes

The rule for implicit lambda capture is slightly changed by defect report P0588R1 . As of 2023-10, some major implementations have not completely implemented the DR, and thus the old rule, which detects odr-using , is still used in some cases.

• odr-used by the body of the lambda.

[ edit ] Example

This example shows how to pass a lambda to a generic algorithm and how objects resulting from a lambda expression can be stored in std::function objects.

Possible output:

[ edit ] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[ edit ] See also

[ edit ] external links.

• Recent changes
• Offline version
• What links here
• Related changes
• Upload file
• Special pages
• Printable version
• Permanent link
• Page information
• In other languages
• This page was last modified on 3 April 2024, at 15:08.
• This page has been accessed 4,901,629 times.
• Privacy policy
• About cppreference.com
• Disclaimers

This browser is no longer supported.

Upgrade to Microsoft Edge to take advantage of the latest features, security updates, and technical support.

Lambda expressions and anonymous functions

• 6 contributors

You use a lambda expression to create an anonymous function. Use the lambda declaration operator => to separate the lambda's parameter list from its body. A lambda expression can be of any of the following two forms:

Expression lambda that has an expression as its body:

Statement lambda that has a statement block as its body:

To create a lambda expression, you specify input parameters (if any) on the left side of the lambda operator and an expression or a statement block on the other side.

Any lambda expression can be converted to a delegate type. The delegate type to which a lambda expression can be converted is defined by the types of its parameters and return value. If a lambda expression doesn't return a value, it can be converted to one of the Action delegate types; otherwise, it can be converted to one of the Func delegate types. For example, a lambda expression that has two parameters and returns no value can be converted to an Action<T1,T2> delegate. A lambda expression that has one parameter and returns a value can be converted to a Func<T,TResult> delegate. In the following example, the lambda expression x => x * x , which specifies a parameter that's named x and returns the value of x squared, is assigned to a variable of a delegate type:

Expression lambdas can also be converted to the expression tree types, as the following example shows:

You can use lambda expressions in any code that requires instances of delegate types or expression trees, for example as an argument to the Task.Run(Action) method to pass the code that should be executed in the background. You can also use lambda expressions when you write LINQ in C# , as the following example shows:

When you use method-based syntax to call the Enumerable.Select method in the System.Linq.Enumerable class, for example in LINQ to Objects and LINQ to XML, the parameter is a delegate type System.Func<T,TResult> . When you call the Queryable.Select method in the System.Linq.Queryable class, for example in LINQ to SQL, the parameter type is an expression tree type Expression<Func<TSource,TResult>> . In both cases, you can use the same lambda expression to specify the parameter value. That makes the two Select calls to look similar although in fact the type of objects created from the lambdas is different.

Expression lambdas

A lambda expression with an expression on the right side of the => operator is called an expression lambda . An expression lambda returns the result of the expression and takes the following basic form:

The body of an expression lambda can consist of a method call. However, if you're creating expression trees that are evaluated outside the context of the .NET Common Language Runtime (CLR), such as in SQL Server, you shouldn't use method calls in lambda expressions. The methods have no meaning outside the context of the .NET Common Language Runtime (CLR).

Statement lambdas

A statement lambda resembles an expression lambda except that its statements are enclosed in braces:

The body of a statement lambda can consist of any number of statements; however, in practice there are typically no more than two or three.

You can't use statement lambdas to create expression trees.

Input parameters of a lambda expression

You enclose input parameters of a lambda expression in parentheses. Specify zero input parameters with empty parentheses:

If a lambda expression has only one input parameter, parentheses are optional:

Two or more input parameters are separated by commas:

Sometimes the compiler can't infer the types of input parameters. You can specify the types explicitly as shown in the following example:

Input parameter types must be all explicit or all implicit; otherwise, a CS0748 compiler error occurs.

You can use discards to specify two or more input parameters of a lambda expression that aren't used in the expression:

Lambda discard parameters may be useful when you use a lambda expression to provide an event handler .

For backwards compatibility, if only a single input parameter is named _ , then, within a lambda expression, _ is treated as the name of that parameter.

Beginning with C# 12, you can provide default values for parameters on lambda expressions. The syntax and the restrictions on default parameter values are the same as for methods and local functions. The following example declares a lambda expression with a default parameter, then calls it once using the default and once with two explicit parameters:

You can also declare lambda expressions with params arrays as parameters:

As part of these updates, when a method group that has a default parameter is assigned to a lambda expression, that lambda expression also has the same default parameter. A method group with a params array parameter can also be assigned to a lambda expression.

Lambda expressions with default parameters or params arrays as parameters don't have natural types that correspond to Func<> or Action<> types. However, you can define delegate types that include default parameter values:

Or, you can use implicitly typed variables with var declarations to define the delegate type. The compiler synthesizes the correct delegate type.

For more information on see the feature spec for default parameters on lambda expressions .

Async lambdas

You can easily create lambda expressions and statements that incorporate asynchronous processing by using the async and await keywords. For example, the following Windows Forms example contains an event handler that calls and awaits an async method, ExampleMethodAsync .

You can add the same event handler by using an async lambda. To add this handler, add an async modifier before the lambda parameter list, as the following example shows:

For more information about how to create and use async methods, see Asynchronous Programming with async and await .

Lambda expressions and tuples

The C# language provides built-in support for tuples . You can provide a tuple as an argument to a lambda expression, and your lambda expression can also return a tuple. In some cases, the C# compiler uses type inference to determine the types of tuple components.

You define a tuple by enclosing a comma-delimited list of its components in parentheses. The following example uses tuple with three components to pass a sequence of numbers to a lambda expression, which doubles each value and returns a tuple with three components that contains the result of the multiplications.

Ordinarily, the fields of a tuple are named Item1 , Item2 , and so on. You can, however, define a tuple with named components, as the following example does.

For more information about C# tuples, see Tuple types .

Lambdas with the standard query operators

LINQ to Objects, among other implementations, has an input parameter whose type is one of the Func<TResult> family of generic delegates. These delegates use type parameters to define the number and type of input parameters, and the return type of the delegate. Func delegates are useful for encapsulating user-defined expressions that are applied to each element in a set of source data. For example, consider the Func<T,TResult> delegate type:

The delegate can be instantiated as a Func<int, bool> instance where int is an input parameter and bool is the return value. The return value is always specified in the last type parameter. For example, Func<int, string, bool> defines a delegate with two input parameters, int and string , and a return type of bool . The following Func delegate, when it's invoked, returns Boolean value that indicates whether the input parameter is equal to five:

You can also supply a lambda expression when the argument type is an Expression<TDelegate> , for example in the standard query operators that are defined in the Queryable type. When you specify an Expression<TDelegate> argument, the lambda is compiled to an expression tree.

The following example uses the Count standard query operator:

The compiler can infer the type of the input parameter, or you can also specify it explicitly. This particular lambda expression counts those integers ( n ) which when divided by two have a remainder of 1.

The following example produces a sequence that contains all elements in the numbers array that precede the 9, because that's the first number in the sequence that doesn't meet the condition:

The following example specifies multiple input parameters by enclosing them in parentheses. The method returns all the elements in the numbers array until it finds a number whose value is less than its ordinal position in the array:

You don't use lambda expressions directly in query expressions , but you can use them in method calls within query expressions, as the following example shows:

Type inference in lambda expressions

When writing lambdas, you often don't have to specify a type for the input parameters because the compiler can infer the type based on the lambda body, the parameter types, and other factors as described in the C# language specification. For most of the standard query operators, the first input is the type of the elements in the source sequence. If you're querying an IEnumerable<Customer> , then the input variable is inferred to be a Customer object, which means you have access to its methods and properties:

The general rules for type inference for lambdas are as follows:

• The lambda must contain the same number of parameters as the delegate type.
• Each input parameter in the lambda must be implicitly convertible to its corresponding delegate parameter.
• The return value of the lambda (if any) must be implicitly convertible to the delegate's return type.

Natural type of a lambda expression

A lambda expression in itself doesn't have a type because the common type system has no intrinsic concept of "lambda expression." However, it's sometimes convenient to speak informally of the "type" of a lambda expression. That informal "type" refers to the delegate type or Expression type to which the lambda expression is converted.

Beginning with C# 10, a lambda expression may have a natural type . Instead of forcing you to declare a delegate type, such as Func<...> or Action<...> for a lambda expression, the compiler may infer the delegate type from the lambda expression. For example, consider the following declaration:

The compiler can infer parse to be a Func<string, int> . The compiler chooses an available Func or Action delegate, if a suitable one exists. Otherwise, it synthesizes a delegate type. For example, the delegate type is synthesized if the lambda expression has ref parameters. When a lambda expression has a natural type, it can be assigned to a less explicit type, such as System.Object or System.Delegate :

Method groups (that is, method names without parameter lists) with exactly one overload have a natural type:

If you assign a lambda expression to System.Linq.Expressions.LambdaExpression , or System.Linq.Expressions.Expression , and the lambda has a natural delegate type, the expression has a natural type of System.Linq.Expressions.Expression<TDelegate> , with the natural delegate type used as the argument for the type parameter:

Not all lambda expressions have a natural type. Consider the following declaration:

The compiler can't infer a parameter type for s . When the compiler can't infer a natural type, you must declare the type:

Explicit return type

Typically, the return type of a lambda expression is obvious and inferred. For some expressions that doesn't work:

Beginning with C# 10, you can specify the return type of a lambda expression before the input parameters. When you specify an explicit return type, you must parenthesize the input parameters:

Beginning with C# 10, you can add attributes to a lambda expression and its parameters. The following example shows how to add attributes to a lambda expression:

You can also add attributes to the input parameters or return value, as the following example shows:

As the preceding examples show, you must parenthesize the input parameters when you add attributes to a lambda expression or its parameters.

Lambda expressions are invoked through the underlying delegate type. That is different than methods and local functions. The delegate's Invoke method doesn't check attributes on the lambda expression. Attributes don't have any effect when the lambda expression is invoked. Attributes on lambda expressions are useful for code analysis, and can be discovered via reflection. One consequence of this decision is that the System.Diagnostics.ConditionalAttribute cannot be applied to a lambda expression.

Capture of outer variables and variable scope in lambda expressions

Lambdas can refer to outer variables . These outer variables are the variables that are in scope in the method that defines the lambda expression, or in scope in the type that contains the lambda expression. Variables that are captured in this manner are stored for use in the lambda expression even if the variables would otherwise go out of scope and be garbage collected. An outer variable must be definitely assigned before it can be consumed in a lambda expression. The following example demonstrates these rules:

The following rules apply to variable scope in lambda expressions:

• A variable that is captured won't be garbage-collected until the delegate that references it becomes eligible for garbage collection.
• Variables introduced within a lambda expression aren't visible in the enclosing method.
• A lambda expression can't directly capture an in , ref , or out parameter from the enclosing method.
• A return statement in a lambda expression doesn't cause the enclosing method to return.
• A lambda expression can't contain a goto , break , or continue statement if the target of that jump statement is outside the lambda expression block. It's also an error to have a jump statement outside the lambda expression block if the target is inside the block.

You can apply the static modifier to a lambda expression to prevent unintentional capture of local variables or instance state by the lambda:

A static lambda can't capture local variables or instance state from enclosing scopes, but may reference static members and constant definitions.

C# language specification

For more information, see the Anonymous function expressions section of the C# language specification .

For more information about these features, see the following feature proposal notes:

• Lambda discard parameters
• Static anonymous functions
• Lambda improvements (C# 10)
• Use local function instead of lambda (style rule IDE0039)
• C# operators and expressions
• LINQ (Language-Integrated Query)
• Expression trees
• Local functions vs. lambda expressions
• LINQ sample queries
• XQuery sample
• 101 LINQ samples

Coming soon: Throughout 2024 we will be phasing out GitHub Issues as the feedback mechanism for content and replacing it with a new feedback system. For more information see: https://aka.ms/ContentUserFeedback .

Submit and view feedback for

Additional resources

• Free Python 3 Tutorial
• Control Flow
• Exception Handling
• Python Programs
• Python Projects
• Python Interview Questions
• Python Database
• Data Science With Python
• Machine Learning with Python
• Pandas Tutorial

Introduction

• Pandas Introduction
• How to Install Pandas in Python?
• How To Use Jupyter Notebook - An Ultimate Guide

Creating Objects

• Creating a Pandas DataFrame
• Python Pandas Series
• Creating a Pandas Series

Viewing Data

• Python | Pandas Dataframe/Series.head() method
• Python | Pandas Dataframe/Series.tail() method
• Pandas DataFrame describe() Method

Selection & Slicing

• Dealing with Rows and Columns in Pandas DataFrame
• Python | Pandas Extracting rows using .loc[]
• Extracting rows using Pandas .iloc[] in Python
• Indexing and Selecting Data with Pandas
• Boolean Indexing in Pandas
• Python | Pandas DataFrame.ix[ ]
• Python | Pandas Series.str.slice()
• How to take column-slices of DataFrame in Pandas?
• Python | Pandas.apply()
• Apply function to every row in a Pandas DataFrame
• Python | Pandas Series.apply()
• Python | Pandas dataframe.aggregate()
• Pandas DataFrame mean() Method
• Python | Pandas Series.mean()
• Python | Pandas dataframe.mad()
• Python | Pandas Series.mad() to calculate Mean Absolute Deviation of a Series
• Python | Pandas dataframe.sem()
• Python | Pandas Series.value_counts()
• Python | Pandas Index.value_counts()

Applying Lambda functions to Pandas Dataframe

Manipulating data.

• Adding new column to existing DataFrame in Pandas
• Python | Delete rows/columns from DataFrame using Pandas.drop()
• Python | Pandas DataFrame.truncate
• Python | Pandas Series.truncate()
• Iterating over rows and columns in Pandas DataFrame
• Python | Pandas Dataframe.sort_values() | Set-1
• Python | Pandas Dataframe.sort_values() | Set-2
• How to add one row in an existing Pandas DataFrame?

Grouping Data

• Pandas GroupBy
• Grouping Rows in pandas
• Combining multiple columns in Pandas groupby with dictionary

Merging, Joining, Concatenating and Comparing

• Python | Pandas Merging, Joining, and Concatenating
• Python | Pandas Series.str.cat() to concatenate string
• Python - Pandas dataframe.append()
• Python | Pandas Series.append()
• Python | Pandas Index.append()
• Python | Pandas Series.combine()
• Add a row at top in pandas DataFrame
• Python | Pandas str.join() to join string/list elements with passed delimiter
• Join two text columns into a single column in Pandas
• How To Compare Two Dataframes with Pandas compare?
• How to compare the elements of the two Pandas Series?

Working with Date and Time

• Python | Working with date and time using Pandas
• Python | Pandas Timestamp.timestamp
• Python | Pandas Timestamp.now
• Python | Pandas Timestamp.isoformat
• Python | Pandas Timestamp.date
• Python | Pandas Timestamp.replace
• Python | Pandas.to_datetime()
• Python | pandas.date_range() method

Working With Text Data

• Python | Pandas Working With Text Data
• Python | Pandas Series.str.lower(), upper() and title()
• Python | Pandas Series.str.replace() to replace text in a series
• Python | Pandas Series.replace()
• Python | Pandas Series.str.strip(), lstrip() and rstrip()
• Python | Pandas tseries.offsets.DateOffset

Working with CSV and Excel files

• Pandas Read CSV in Python
• Saving a Pandas Dataframe as a CSV
• Loading Excel spreadsheet as pandas DataFrame
• Creating a dataframe using Excel files
• Python | Working with Pandas and XlsxWriter | Set - 1
• Python | Working with Pandas and XlsxWriter | Set – 2
• Python | Working with Pandas and XlsxWriter | Set – 3

Visualization

• Data Visualization with Pandas
• Data analysis and Visualization with Python
• Data Analysis and Visualization with Python | Set 2
• Box plot visualization with Pandas and Seaborn

Applications and Projects

• How to Do a vLookup in Python using pandas
• Convert CSV to HTML Table in Python
• KDE Plot Visualization with Pandas and Seaborn
• Analyzing selling price of used cars using Python
• Add CSS to the Jupyter Notebook using Pandas

In Python Pandas, we have the freedom to add different functions whenever needed like lambda function , sort function, etc. We can apply a lambda function to both the columns and rows of the Pandas data frame.

Syntax: lambda arguments: expression An anonymous function which we can pass in instantly without defining a name or any thing like a full traditional function.

Applying Lambda Functions to Pandas

Below are some methods and ways by which we can apply lambda functions to Pandas :

Dataframe.assign() on a Single Column

Dataframe.assign() on Multiple Columns

Dataframe.apply() on a Single Row

Dataframe.apply() on Multiple Rows

Lambda Function on Multiple Rows and Columns Simultaneously

In this example, we will apply the lambda function Dataframe.assign() to a single column. The function is applied to the ‘Total_Marks’ column, and a new column ‘Percentage’ is formed with its help.

In this example, we will apply the lambda function Dataframe.assign() to multiple columns. The lambda function is applied to 3 columns i.e., ‘Field_1’, ‘Field_2’, and ‘Field_3’.

In this example, we will apply the lambda function Dataframe.apply() to single row. The lambda function is applied to a row starting with ‘d’ and hence square all values corresponding to it.

In this example, we will apply the lambda function to multiple rows using Dataframe.apply() . The lambda function is applied to 3 rows starting with ‘a’, ‘e’, and ‘g’.

In this example, we will apply the lambda function simultaneously to multiple columns and rows using dataframe.assign() and dataframe.apply().

Please Login to comment...

• Python pandas-dataFrame
• Python Pandas-exercise
• Python-pandas
• 10 Best Tools to Convert DOC to DOCX
• How To Summarize PDF Documents Using Google Bard for Free
• Best free Android apps for Meditation and Mindfulness
• TikTok Is Paying Creators To Up Its Search Game
• 30 OOPs Interview Questions and Answers (2024)

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

4.4   Functions (Procedures): lambda 🔗 ℹ

A lambda expression creates a function. In the simplest case, a lambda expression has the form

( lambda   ( arg-id   ... )    body   ...+ )

A lambda form with n arg-id s accepts n arguments:

> ( ( lambda   ( x )   x )      1 ) 1 > ( ( lambda   ( x   y )   ( +   x   y ) )      1   2 ) 3 > ( ( lambda   ( x   y )   ( +   x   y ) )      1 ) arity mismatch;   the expected number of arguments does not match the given number    expected: 2    given: 1

4.4.1   Declaring a Rest Argument 🔗 ℹ

A lambda expression can also have the form

( lambda   rest-id    body   ...+ )

That is, a lambda expression can have a single rest-id that is not surrounded by parentheses. The resulting function accepts any number of arguments, and the arguments are put into a list bound to rest-id .

> ( ( lambda   x   x )      1   2   3 ) '(1 2 3) > ( ( lambda   x   x ) ) '() > ( ( lambda   x   ( car   x ) )      1   2   3 ) 1

Functions with a rest-id often use apply to call another function that accepts any number of arguments.

The apply Function describes apply .

( define   max-mag    ( lambda   nums      ( apply   max   ( map   magnitude   nums ) ) ) ) > ( max   1   -2   0 ) 1 > ( max-mag   1   -2   0 ) 2

The lambda form also supports required arguments combined with a rest-id :

( lambda   ( arg-id   ...+   . rest-id )    body   ...+ )

The result of this form is a function that requires at least as many arguments as arg-id s, and also accepts any number of additional arguments.

( define   max-mag    ( lambda   ( num   . nums )      ( apply   max   ( map   magnitude   ( cons   num   nums ) ) ) ) ) > ( max-mag   1   -2   0 ) 2 > ( max-mag ) max-mag: arity mismatch;   the expected number of arguments does not match the given number    expected: at least 1    given: 0

A rest-id variable is sometimes called a rest argument , because it accepts the “rest” of the function arguments. A function with a rest argument is sometimes called a variadic function, with elements in the rest argument called variadic arguments.

4.4.2   Declaring Optional Arguments 🔗 ℹ

Instead of just an identifier, an argument (other than a rest argument) in a lambda form can be specified with an identifier and a default value:

( lambda   gen-formals    body   ...+ )   gen-formals   =   ( arg   ... )     |   rest-id     |   ( arg   ...+   . rest-id )           arg   =   arg-id     |   [ arg-id   default-expr ]

An argument of the form [ arg-id default-expr ] is optional. When the argument is not supplied in an application, default-expr produces the default value. The default-expr can refer to any preceding arg-id , and every following arg-id must have a default as well.

( define   greet    ( lambda   ( given   [ surname   "Smith" ] )      ( string-append   "Hello, "   given   " "   surname ) ) ) > ( greet   "John" ) "Hello, John Smith" > ( greet   "John"   "Doe" ) "Hello, John Doe"

( define   greet    ( lambda   ( given   [ surname   ( if   ( equal?   given   "John" )                                "Doe"                                "Smith" ) ] )      ( string-append   "Hello, "   given   " "   surname ) ) )   > ( greet   "John" ) "Hello, John Doe" > ( greet   "Adam" ) "Hello, Adam Smith"

4.4.3   Declaring Keyword Arguments 🔗 ℹ

A lambda form can declare an argument to be passed by keyword, instead of position. Keyword arguments can be mixed with by-position arguments, and default-value expressions can be supplied for either kind of argument:

Keyword Arguments introduces function calls with keywords.

( lambda   gen-formals    body   ...+ )   gen-formals   =   ( arg   ... )     |   rest-id     |   ( arg   ...+   . rest-id )           arg   =   arg-id     |   [ arg-id   default-expr ]     |   arg-keyword   arg-id     |   arg-keyword   [ arg-id   default-expr ]

An argument specified as arg-keyword arg-id is supplied by an application using the same arg-keyword . The position of the keyword–identifier pair in the argument list does not matter for matching with arguments in an application, because it will be matched to an argument value by keyword instead of by position.

( define   greet    ( lambda   ( given   #:last   surname )      ( string-append   "Hello, "   given   " "   surname ) ) )   > ( greet   "John"   #:last   "Smith" ) "Hello, John Smith" > ( greet   #:last   "Doe"   "John" ) "Hello, John Doe"

An arg-keyword [ arg-id default-expr ] argument specifies a keyword-based argument with a default value.

( define   greet    ( lambda   ( #:hi   [ hi   "Hello" ]   given   #:last   [ surname   "Smith" ] )      ( string-append   hi   ", "   given   " "   surname ) ) ) > ( greet   "John" ) "Hello, John Smith" > ( greet   "Karl"   #:last   "Marx" ) "Hello, Karl Marx" > ( greet   "John"   #:hi   "Howdy" ) "Howdy, John Smith" > ( greet   "Karl"   #:last   "Marx"   #:hi   "Guten Tag" ) "Guten Tag, Karl Marx"

The lambda form does not directly support the creation of a function that accepts “rest” keywords. To construct a function that accepts all keyword arguments, use make-keyword-procedure . The function supplied to make-keyword-procedure receives keyword arguments through parallel lists in the first two (by-position) arguments, and then all by-position arguments from an application as the remaining by-position arguments.

The apply Function introduces keyword-apply .

( define   ( trace-wrap   f )    ( make-keyword-procedure     ( lambda   ( kws   kw-args   . rest )       ( printf   "Called with ~s ~s ~s\n"   kws   kw-args   rest )       ( keyword-apply   f   kws   kw-args   rest ) ) ) ) > ( ( trace-wrap   greet )   "John"   #:hi   "Howdy" ) Called with (#:hi) ("Howdy") ("John") "Howdy, John Smith"

Procedure Expressions: lambda and case-lambda in The Racket Reference provides more on function expressions.

4.4.4   Arity-Sensitive Functions: case-lambda 🔗 ℹ

The case-lambda form creates a function that can have completely different behaviors depending on the number of arguments that are supplied. A case-lambda expression has the form

( case-lambda    [ formals   body   ...+ ]    ... )   formals   =   ( arg-id   ... )     |   rest-id     |   ( arg-id   ...+   . rest-id )

where each [ formals body ...+ ] is analogous to ( lambda formals body ...+ ) . Applying a function produced by case-lambda is like applying a lambda for the first case that matches the number of given arguments.

( define   greet    ( case-lambda      [ ( name )   ( string-append   "Hello, "   name ) ]      [ ( given   surname )   ( string-append   "Hello, "   given   " "   surname ) ] ) ) > ( greet   "John" ) "Hello, John" > ( greet   "John"   "Smith" ) "Hello, John Smith" > ( greet ) greet: arity mismatch;   the expected number of arguments does not match the given number    given: 0

A case-lambda function cannot directly support optional or keyword arguments.