# Functions
Functions in Python provide organized, reusable and modular code to perform a set of specific actions. Functions simplify the coding process, prevent redundant logic, and make the code easier to follow. This topic describes the declaration and utilization of functions in Python.
Python has many built-in functions like print() , input() , len() . Besides built-ins you can also create your own functions to do more specific jobs—these are called user-defined functions.
# Defining a function with an arbitrary number of arguments
# Arbitrary number of positional arguments:
Defining a function capable of taking an arbitrary number of arguments can be done by prefixing one of the arguments with a *
You can’t provide a default for args , for example func(*args=[1, 2, 3]) will raise a syntax error (won’t even compile).
You can’t provide these by name when calling the function, for example func(*args=[1, 2, 3]) will raise a TypeError .
But if you already have your arguments in an array (or any other Iterable ), you can invoke your function like this: func(*my_stuff) .
These arguments ( *args ) can be accessed by index, for example args[0] will return the first argument
# Arbitrary number of keyword arguments
You can take an arbitrary number of arguments with a name by defining an argument in the definition with two * in front of it:
You can’t provide these without names, for example func(1, 2, 3) will raise a TypeError .
kwargs is a plain native python dictionary. For example, args[‘value1’] will give the value for argument value1 . Be sure to check beforehand that there is such an argument or a KeyError will be raised.
# Warning
You can mix these with other optional and required arguments but the order inside the definition matters.
The positional/keyword arguments come first. (Required arguments).
Then comes the arbitrary *arg arguments. (Optional).
Then keyword-only arguments come next. (Required).
Finally the arbitrary keyword **kwargs come. (Optional).
- arg1 must be given, otherwise a TypeError is raised. It can be given as positional ( func(10) ) or keyword argument ( func(arg1=10) ).
- kwarg1 must also be given, but it can only be provided as keyword-argument: func(kwarg1=10) .
- arg2 and kwarg2 are optional. If the value is to be changed the same rules as for arg1 (either positional or keyword) and kwarg1 (only keyword) apply.
- *args catches additional positional parameters. But note, that arg1 and arg2 must be provided as positional arguments to pass arguments to *args : func(1, 1, 1, 1) .
- **kwargs catches all additional keyword parameters. In this case any parameter that is not arg1 , arg2 , kwarg1 or kwarg2 . For example: func(kwarg3=10) .
- In Python 3, you can use * alone to indicate that all subsequent arguments must be specified as keywords. For instance the math.isclose function in Python 3.5 and higher is defined using def math.isclose (a, b, *, rel_tol=1e-09, abs_tol=0.0) , which means the first two arguments can be supplied positionally but the optional third and fourth parameters can only be supplied as keyword arguments.
Python 2.x doesn’t support keyword-only parameters. This behavior can be emulated with kwargs :
# Note on Naming
The convention of naming optional positional arguments args and optional keyword arguments kwargs is just a convention you can use any names you like but it is useful to follow the convention so that others know what you are doing, or even yourself later so please do.
# Note on Uniqueness
Any function can be defined with none or one *args and none or one **kwargs but not with more than one of each. Also *args must be the last positional argument and **kwargs must be the last parameter. Attempting to use more than one of either will result in a Syntax Error exception.
# Note on Nesting Functions with Optional Arguments
It is possible to nest such functions and the usual convention is to remove the items that the code has already handled but if you are passing down the parameters you need to pass optional positional args with a * prefix and optional keyword args with a ** prefix, otherwise args with be passed as a list or tuple and kwargs as a single dictionary. e.g.:
# Defining and calling simple functions
Using the def statement is the most common way to define a function in python. This statement is a so called single clause compound statement with the following syntax:
function_name is known as the identifier of the function. Since a function definition is an executable statement its execution binds the function name to the function object which can be called later on using the identifier.
parameters is an optional list of identifiers that get bound to the values supplied as arguments when the function is called. A function may have an arbitrary number of arguments which are separated by commas.
statement(s) – also known as the function body – are a nonempty sequence of statements executed each time the function is called. This means a function body cannot be empty, just like any indented block
Here’s an example of a simple function definition which purpose is to print Hello each time it’s called:
Now let’s call the defined greet() function:
That’s an other example of a function definition which takes one single argument and displays the passed in value each time the function is called:
After that the greet_two() function must be called with an argument:
Also you can give a default value to that function argument:
Now you can call the function without giving a value:
You’ll notice that unlike many other languages, you do not need to explicitly declare a return type of the function. Python functions can return values of any type via the return keyword. One function can return any number of different types!
As long as this is handled correctly by the caller, this is perfectly valid Python code.
A function that reaches the end of execution without a return statement will always return None :
As mentioned previously a function definition must have a function body, a nonempty sequence of statements. Therefore the pass statement is used as function body, which is a null operation – when it is executed, nothing happens. It does what it means, it skips. It is useful as a placeholder when a statement is required syntactically, but no code needs to be executed.
# Lambda (Inline/Anonymous) Functions
The lambda keyword creates an inline function that contains a single expression. The value of this expression is what the function returns when invoked.
Consider the function:
which, when called as:
This can be written as a lambda function as follows:
See note at the bottom of this section regarding the assignment of lambdas to variables. Generally, don’t do it.
This creates an inline function with the name greet_me that returns Hello . Note that you don’t write return when creating a function with lambda. The value after : is automatically returned.
Once assigned to a variable, it can be used just like a regular function:
lambda s can take arguments, too:
returns the string:
They can also take arbitrary number of arguments / keyword arguments, like normal functions.
lambda s are commonly used for short functions that are convenient to define at the point where they are called (typically with sorted , filter and map ).
For example, this line sorts a list of strings ignoring their case and ignoring whitespace at the beginning and at the end:
Sort list just ignoring whitespaces:
Examples with map :
Examples with numerical lists:
One can call other functions (with/without arguments) from inside a lambda function.
This is useful because lambda may contain only one expression and by using a subsidiary function one can run multiple statements.
NOTE
Bear in mind that PEP-8
(opens new window) (the official Python style guide) does not recommend assigning lambdas to variables (as we did in the first two examples):
Always use a def statement instead of an assignment statement that binds a lambda expression directly to an identifier. Yes:
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).
# Defining a function with optional arguments
Optional arguments can be defined by assigning (using = ) a default value to the argument-name:
Calling this function is possible in 3 different ways:
Warning
# Defining a function with optional mutable arguments
There is a problem when using optional arguments with a mutable default type (described in Defining a function with optional arguments
(opens new window) ), which can potentially lead to unexpected behaviour.
# Explanation
This problem arises because a function’s default arguments are initialised once, at the point when the function is defined, and not (like many other languages) when the function is called. The default values are stored inside the function object’s __defaults__ member variable.
For immutable types (see Argument passing and mutability
(opens new window) ) this is not a problem because there is no way to mutate the variable; it can only ever be reassigned, leaving the original value unchanged. Hence, subsequent are guaranteed to have the same default value. However, for a mutable type, the original value can mutate, by making calls to its various member functions. Therefore, successive calls to the function are not guaranteed to have the initial default value.
Note: Some IDEs like PyCharm will issue a warning when a mutable type is specified as a default attribute.
# Solution
If you want to ensure that the default argument is always the one you specify in the function definition, then the solution is to always use an immutable type as your default argument.
A common idiom to achieve this when a mutable type is needed as the default, is to use None (immutable) as the default argument and then assign the actual default value to the argument variable if it is equal to None .
# Argument passing and mutability
First, some terminology:
- argument (actual parameter): the actual variable being passed to a function;
- parameter (formal parameter): the receiving variable that is used in a function.
In Python, arguments are passed by assignment (as opposed to other languages, where arguments can be passed by value/reference/pointer).
In Python, we don’t really assign values to variables, instead we bind (i.e. assign, attach) variables (considered as names) to objects.
- Immutable: Integers, strings, tuples, and so on. All operations make copies.
- Mutable: Lists, dictionaries, sets, and so on. Operations may or may not mutate.
# Returning values from functions
Functions can return a value that you can use directly:
or save the value for later use:
or use the value for any operations:
If return is encountered in the function the function will be exited immediately and subsequent operations will not be evaluated:
You can also return multiple values (in the form of a tuple):
A function with no return statement implicitly returns None . Similarly a function with a return statement, but no return value or variable returns None .
# Closure
Closures in Python are created by function calls. Here, the call to makeInc creates a binding for x that is referenced inside the function inc . Each call to makeInc creates a new instance of this function, but each instance has a link to a different binding of x .
Notice that while in a regular closure the enclosed function fully inherits all variables from its enclosing environment, in this construct the enclosed function has only read access to the inherited variables but cannot make assignments to them
Python 3 offers the nonlocal statement (Nonlocal Variables
(opens new window) ) for realizing a full closure with nested functions.
# Forcing the use of named parameters
All parameters specified after the first asterisk in the function signature are keyword-only.
In Python 3 it’s possible to put a single asterisk in the function signature to ensure that the remaining arguments may only be passed using keyword arguments.
# Defining a function with arguments
Arguments are defined in parentheses after the function name:
The function name and its list of arguments are called the signature of the function. Each named argument is effectively a local variable of the function.
When calling the function, give values for the arguments by listing them in order
or specify them in any order using the names from the function definition:
# Recursive functions
A recursive function is a function that calls itself in its definition. For example the mathematical function, factorial, defined by factorial(n) = n*(n-1)*(n-2)*. *3*2*1 . can be programmed as
the outputs here are:
as expected. Notice that this function is recursive because the second return factorial(n-1) , where the function calls itself in its definition.
Some recursive functions can be implemented using lambda
(opens new window) , the factorial function using lambda would be something like this:
The function outputs the same as above.
# Recursion limit
There is a limit to the depth of possible recursion, which depends on the Python implementation. When the limit is reached, a RuntimeError exception is raised:
It is possible to change the recursion depth limit by using sys.setrecursionlimit(limit) and check this limit by sys.getrecursionlimit() .
From Python 3.5, the exception is a RecursionError , which is derived from RuntimeError .
# Nested functions
Functions in python are first-class objects. They can be defined in any scope
Functions capture their enclosing scope can be passed around like any other sort of object
# Recursive Lambda using assigned variable
One method for creating recursive lambda functions involves assigning the function to a variable and then referencing that variable within the function itself. A common example of this is the recursive calculation of the factorial of a number — such as shown in the following code:
# Description of code
The lambda function, through its variable assignment, is passed a value (4) which it evaluates and returns 1 if it is 0 or else it returns the current value ( i ) * another calculation by the lambda function of the value — 1 ( i-1 ). This continues until the passed value is decremented to 0 ( return 1 ). A process which can be visualized as:
# Defining a function with multiple arguments
One can give a function as many arguments as one wants, the only fixed rules are that each argument name must be unique and that optional arguments must be after the not-optional ones:
When calling the function you can either give each keyword without the name but then the order matters:
Or combine giving the arguments with name and without. Then the ones with name must follow those without but the order of the ones with name doesn’t matter:
# Iterable and dictionary unpacking
Functions allow you to specify these types of parameters: positional, named, variable positional, Keyword args (kwargs). Here is a clear and concise use of each type.
Introduction
For loops are the antithesis of efficient programming. They’re still necessary and are the first conditional loops taught to Python beginners but in my opinion, they leave a lot to be desired.
These for loops can be cumbersome and can make our Python code bulky and untidy. But wait — what’s the alternative solution? Lambda functions in Python!
Lambda functions offer a dual boost to a data scientist. You can write tidier Python code and…
Лямбда-функция в Python простыми словами
В этой статье вы подробнее изучите анонимные функции, так же называемые «лямбда-функции». Давайте разберемся, что это такое, каков их синтаксис и как их использовать ( с примерами).
Лямбда-функции в Python являются анонимными. Это означает, что функция безымянна. Как известно, ключевое слов def используется в Python для определения обычной функции. В свою очередь, ключевое слово lambda используется для определения анонимной функции.
Лямбда-функция имеет следующий синтаксис.
Лямбда-функции могут иметь любое количество аргументов, но у каждой может быть только одно выражение. Выражение вычисляется и возвращается. Эти функции могут быть использованы везде, где требуется объект-функция.
1.1. Пример лямбда-функции.
Ниже представлен пример лямбда-функции, удваивающей вводимое значение.
Вывод:
В вышеуказанном коде lambda x: x*2 — это лямбда-функция. Здесь x — это аргумент, а x*2 — это выражение, которое вычисляется и возвращается.
Эта функция безымянная. Она возвращает функциональный объект с идентификатором double . Сейчас мы можем считать её обычной функцией.
Эта функция может иметь любое количество аргументов, но вычисляет и возвращает только одно значение
Лямбда-функции применимы везде, где требуются объекты-функции
Вы должны помнить, что синтаксически лямбда-функция ограничена, позволяет представить всего одно выражение
Они имеют множество вариантов применения в конкретных областях программирования, наряду с другими типами выражений, используемых в функциях.
2. Различие между обычной функцией и лямбда-функцией
Рассмотрим пример и попробуем понять различие между определением ( Def ) для обычной функции и lambda —функции. Этот код возвращает заданное значение, возведенное в куб:
Как показано в примере выше, обе представленные функции, defined_cube() и lambda_cube() , ведут себя одинаково, как и предполагалось.
Разберем вышеуказанный пример подробнее:
Без использования лямбды: Здесь обе функции возвращают заданное значение, возведенное в куб. Но при использовании def , нам пришлось определить функцию с именем и defined_cube() дать ей входную величину. После выполнения нам также понадобилось возвратить результат, из того места, откуда была вызвана функция, и мы сделали это, используя ключевое слово return .
С применением лямбды: Определение лямбды не включает оператор return , а всегда содержит возвращенное выражение. Мы также можем поместить определение лямбды в любое место, где ожидается функция, и нам не нужно присваивать его переменной. Так выглядят простые лямбда-функции.
3. Лямбда-функции и функции высшего порядка
Мы используем лямбда-функцию, когда нам ненадолго требуется безымянная функция.
В Python мы часто используем их как аргумент функции высшего порядка (функции, которая принимает другие функции в качестве аргументов). Лямбда-функции используют вместе с такими встроенными функциями как filter() , map() , reduce() и др.
Давайте рассмотрим еще несколько распространенных вариантов использования лямбда-функций.
3.1. Пример с filter()
Функция filter() в Python принимает в качестве аргументов функцию и список .
Функция вызывается со всеми элементами в списке, и в результате возвращается новый список, содержащий элементы, для которых функция результирует в True .
Вот пример использования функции filter() для отбора четных чисел из списка.
Вывод:
3.2. Пример с map()
Функция map() принимает в качестве аргументов функцию и список.
Функция вызывается со всеми элементами в списке, и в результате возвращается новый список, содержащий элементы, возвращенные данной функцией для каждого исходного элемента.
Ниже пример использования функции map() для удвоения всех элементов списка.
Вывод:
3.3. Пример с reduce()
Функция reduce() принимает в качестве аргументов функцию и список. Функция вызывается с помощью лямбда-функции и итерируемого объекта и возвращается новый уменьшенный результат. Так выполняется повторяющаяся операцию над парами итерируемых объектов. Функция reduce() входит в состав модуля functools .
Вывод:
Здесь результаты предыдущих двух элементов суммируются со следующим элементом, и это продолжается до конца списка, вот так:
4. Лямбда и списковое включение
В этом примере мы будем использовать лямбда-функцию со списковым включением и лямбда-функцию с циклом for . Мы выведем на экран таблицу из 10 элементов.
Вывод:
5. Лямбда и условные операторы
Давайте рассмотрим использование условий if-else в лямбда-функции. Как вы знаете, Python позволяет нам использовать однострочные условия, и именно их мы можем помещать в лямбда-функцию для обработки возвращаемого результата.
Например, есть две цифры, и вы должны определить, какая из них представляет наибольшее число.
Вывод:
Этот метод позволяет вам добавлять условия в лямбда-функции.
6. Лямбда и множественные операторы
Лямбда-функции не допускают использования нескольких операторов, однако мы можем создать две лямбда-функции, а затем вызвать вторую лямбда-функцию в качестве параметра для первой функции. Давайте попробуем найти второй по величине элемент, используя лямбду.
Вывод:
В предыдущем примере, мы создали лямбда-функцию, которая сортирует каждый вложенный список в заданном списке. Затем этот список проходит как параметр для второй лямбда-функции, которая возвращает элемент n-2 из отсортированного списка, где n — длина вложенного списка.
Лямбда (анонимные функции) в Python
В Python лямбда-функция (или «анонимная функция») — это особый тип функции без имени. Например:
Здесь мы создали лямбда-функцию, которая выводит текст Hello, World! .
Объявление лямбда-функции в Python
Ключевое слово lambda (вместо def ) используется для создания лямбда-функции. Синтаксис объявления лямбда-функции:
аргумент(ы) — любое значение, переданное лямбда-функции;
выражение — данный стейтмент выполняется и возвращается.
Здесь мы определили лямбда-функцию, которую присвоили переменной с именем greet .
Чтобы выполнить эту лямбда-функцию, нам нужно ее вызвать. Вот как мы можем вызвать лямбда-функцию:
Вышеприведенная лямбда-функция просто выводит текст Hello, World! .
Примечание: У этой лямбда-функции нет аргументов.
Рассмотрим пример вызова лямбда-функции в Python:
Здесь мы определили лямбда-функцию и присвоили ее переменной greet . Когда мы вызываем лямбда-функцию, выполняется функция print() внутри лямбда-функции.
Лямбда-функция с аргументами в Python
Подобно обычным функциям, лямбда-функция также может принимать аргументы. Например:
Hey there, Delilah
Здесь мы присвоили лямбда-функцию переменной greet_user . name после ключевого слова lambda указывает, что лямбда-функция принимает аргумент с именем name .
Обратите внимание на вызов лямбда-функции:
Здесь мы передали строковое значение Delilah нашей лямбда-функции, которое соответствует аргументу name .
Как использовать лямбда-функцию с filter()?
Функция filter() в Python принимает функцию и итерируемый объект (списки, кортежи и строки) в качестве аргументов. Функция вызывается со всеми элементами в списке, и возвращается новый список, содержащий элементы, для которых функция определила значение True .