Python. Режимы сопоставления аргументов. Аргументы переменной длины. Комбинирование разных способов сопоставления аргументов. Примеры

Данная тема есть продолжением темы:

Режимы сопоставления аргументов. Классификация. Сопоставление по позиции. Сопоставление по именам. Аргументы по умолчанию

Содержание

Поиск на других ресурсах:

1. Аргументы переменной длины. Понятие

В языке Python есть возможность передавать в функцию произвольное количество аргументов. Это обеспечивается специальным синтаксисом. Произвольное количество аргументов можно описывать в инструкции def функции одним из двух способов:

с использованием кортежа (*);
с использованием словаря (**).

Соответственно, можно вызвать функцию, которая получает произвольное количество параметров.

Для переменного количества аргументов в языке Python поддерживаются следующие режимы сопоставления:

режим получения функцией переменного количества аргументов Fn(*sequence) в виде кортежа;
режим получения функцией переменного количества аргументов Fn(**name) в виде словаря;
режим передачи переменного количества аргументов в виде кортежа: Fn(*args);
режим передачи переменного количества аргументов в виде словаря: Fn(**args).

⇑

2. Режим получения функцией переменного количества аргументов Fn(*sequence) в виде кортежа. Пример

Режим переменного количества аргументов позволяет вызвать функцию с любым количеством аргументов. Аргументы, которые передаются в функцию, объединяются в коллекцию в виде кортежа. Порядок следования аргументов в кортеже соответствует порядку, в котором эти аргументы были переданы в функцию.

Пример 1. В примере, функция Fn() получает переменное количество аргументов в виде кортежа с именем sequence. При такой передаче перед именем кортежа ставится символ *.

# Аргументы. Режимы сопоставления.
# Передача аргумента в функцию - переменное количество аргументов

# Функция, которая получает переменное количество аргументов и выводит их на экран
def Fn(*sequence):
    # в теле функции виводится значение sequence
    print('sequence = ', sequence)
    return

# Вызов функции с 3 аргументами
Fn(3, 'abcd', [2, True, 3.888]) # sequence = (3, 'abcd', [2, True, 3.888])

# Вызов функции с 1 аргументом - словарем
Fn({1: 'A', 2: 'B', 3: 'C'}) # sequence = ({1: 'A', 2: 'B', 3: 'C'},)

Результат работы программы

sequence = (3, 'abcd', [2, True, 3.888])
sequence = ({1: 'A', 2: 'B', 3: 'C'},)

Пример 2. В примере, функция Fn() получает переменное количество аргументов. В функцию аргументы передаются по именам созданных объектов (x, y, z).

# Функция, которая получает переменное количество аргументов и выводит их на экран
def Fn(*sequence):
    # в теле функции выводится значение sequence
    print('Fn.sequence = ', sequence)
    return

# Вызов функции с тремя аргументами, которые имеют имена
x = 2
y = 3
z = 'abcd'
Fn(x, y, z) # Fn.sequence = (2, 3, 'abcd')

Результат выполнения программы

Fn.sequence = (2, 3, 'abcd')

⇑

3. Режим получения переменного количества аргументов Fn(**name) в виде словаря. Преобразование аргументов, которые передаются по именам, в словарь. Пример

В функцию можно передавать именованные аргументы. Последовательность этих аргументов может быть преобразована в словарь в случае, если в объявлении функции (инструкция def) в скобках используется обозначение **

def Function(**sequence):
    # ...

Аргумент, который передается, преобразуется в отдельный элемент словаря по следующему правилу:

имя аргумента становится ключом;
значение, которое присваивается аргументу становится значением этого ключа.

Если функцию Function() вызвать с двумя именованными аргументами

Function(X = 5, Y = 'Hello world!')

то в теле функции будет создан словарь sequence со следующим значением

{ 'X' : 5, 'Y' : 'Hello world!' }

Пример. В примере демонстрируется код программы, которая передает именованные аргументы в функцию с переменным количество аргументов по синтаксису **.

# Аргументы. Режимы сопоставления.
# Передача аргумента в функцию. Переменное количество аргументов.
# Именованные аргументы преобразуются в словарь

# Функция, получающая переменное количество аргументов и выводящая их на экран
def Fn(**dictionary):
    # в теле функции выводится значение dictionary
    print('Fn.dictionary = ', dictionary)
    return

# Вызов функции с тремя именованными аргументами
Fn(x=2, y=5, z=4) # Fn.dictionary = {'x': 2, 'y': 5, 'z': 4}

После запуска, программа выдаст следующий результат

Fn.dictionary = {'x': 2, 'y': 5, 'z': 4}

Как видно из результата, вызов функции Fn() с именованными аргументами x, y, z

Fn(x=2, y=5, z=4)

в теле функции конвертируется в словарь

{'x': 2, 'y': 5, 'z': 4}

⇑

4. Аргументы переменной длины. Комбинирование обычных аргументов с переменными аргументами * и **. Пример

Вышеприведенные режимы передачи аргументов можно объединять, образовывая разные способы вызова функции.

Пример. В примере демонстрируется комбинированная передача аргументов разными способами:

передача обычного аргумента в сочетании с передачей переменного количества аргументов типа *;
передача обычного аргумента в сочетании с преобразованием в словарь **;
передача обычного аргумента в сочетании с обеими видами переменного количества аргументов * и **.

# Аргументы. Режимы сопоставления.
# Передача аргумента в функцию. Объединение режимов сопоставления

# 1. Функция, которая объединяет обычную передачу аргумента с переменной типа *
def Fn1(a, *sequence):
    # в теле функции выводятся значения a и sequence
    print('Fn1.a = ', a)
    print('Fn1.sequence = ', sequence)
    return

# Вызов функции Fn1()
Fn1(1, 2, 3, 4, 5) # Fn1.a = 1, Fn1.sequence = (2, 3, 4, 5)

# 2. Функция, объединяющая обычную передачу аргумента с переменной типа **
def Fn2(a, **dic):
    print('Fn2.a = ', a)
    print('Fn2.dic = ', dic)
    return

# Вызов функции Fn2()
Fn2(1, b=2, c=3, d=4, e=5) # Fn.a=1, Fn.dic={'b':2, 'c':3, 'd':4, 'e':5}

# 3. Функция, объединяющая обычную передачу аргумента с переменными * и **
def Fn3(a, b, *seq, **dic):
    print('Fn3.a = ', a)
    print('Fn3.b = ', b)
    print('Fn3.seq = ', seq)
    print('Fn3.dic = ', dic)
    return

# Вызов функции Fn3()
Fn3(20, 8.55, 9, 4, 7, abc=5, fgh=True) # Fn3.a = 20, Fn3.b = 8.55
# Fn3.seq = (9, 4, 7)
# Fn3.dic = {'abc': 5, 'fgh': True}

Результат выполнения программы

Fn1.a = 1
Fn1.sequence = (2, 3, 4, 5)
Fn2.a = 1
Fn2.dic = {'b': 2, 'c': 3, 'd': 4, 'e': 5}
Fn3.a = 20
Fn3.b = 8.55
Fn3.seq = (9, 4, 7)
Fn3.dic = {'abc': 5, 'fgh': True}

⇑

5. Режим передачи переменного количества аргументов в виде кортежа: Fn(*args). Вытягивание (распаковывание) аргументов из кортежа. Пример

В функцию можно передать кортеж с аргументами, который в функции будет распакован на отдельные аргументы. Кортеж предварительно формируется в точке вызова функции. При передаче кортежа в функцию перед именем кортежа ставится символ *.

Во избежание ошибок, необходимо, чтобы количество элементов кортежа совпадало с количеством объявленных аргументов в инструкции def функции.

Пример. В функцию Fn() передается кортеж из трех элементов. В теле функции этот кортеж распаковывается. Аргументы x, y, z в функции получают соответствующие значения кортежа. С целью демонстрации возможностей передачи аргументов, в функции описывается дополнительный аргумент по умолчанию v.

# Аргументы. Режимы сопоставления.
# Передача кортежа в функцию. Распаковывание кортежа в функции

# Функция, которая получает 4 аргумента.
# Для демонстрации возможностей, 1 аргумент передается по умолчанию.
def Fn(x, y, z, v=25):
    print('Fn.x = ', x)
    print('Fn.y = ', y)
    print('Fn.z = ', z)
    print('Fn.v = ', v)
    return

# Вызов функции с параметром кортежа
T = (5, -20.55, 'Hello')
Fn(*T, 7) # Fn.x=5, Fn.y=-20.55, Fn.z=Hello, Fn.v=7

Fn(*T) # Fn.x=5, Fn.y=-20.55, Fn.z=Hello, Fn.v=25

Результат выполнения программы

Fn.x = 5
Fn.y = -20.55
Fn.z = Hello
Fn.v = 7
Fn.x = 5
Fn.y = -20.55
Fn.z = Hello
Fn.v = 25

⇑

6. Режим передачи переменного количества аргументов в виде словаря: Fn(**args). Вытягивание (распаковывание) аргументов из словаря. Пример

Функция может получать переменное количество аргументов по синтаксису словаря Fn(**args). В этом случае, в функцию передается словарь. В теле функции этот словарь распаковывается на отдельные аргументы.

Во избежание ошибок, нужно чтобы имена ключей в словаре совпадали с именами аргументов, которые получает функция в инструкции def.

Пример. Демонстрируется передача словаря D в функцию Fn().

# Аргументы. Режимы сопоставления.
# Передача словаря в функцию. Распаковывание словаря в функции

# Функция, которая получает 4 аргументы.
def Fn(x, y, z, v):
    print('Fn.x = ', x)
    print('Fn.y = ', y)
    print('Fn.z = ', z)
    print('Fn.v = ', v)
    return

# Вызов функции с параметром словаря.
# Имена ключей в словаре должны совпадать с именами аргументов в функции
D = { 'y':7, 'z':5, 'v':3, 'x':4 }
Fn(**D) # Fn.x = 4, Fn.y = 7, Fn.z = 5, Fn.v = 3

# Можно и так вызвать функцию
Fn(**{'v':3, 'y':1, 'x':2, 'z':9})

Результат выполнения программы

Fn.x = 4
Fn.y = 7
Fn.z = 5
Fn.v = 3
Fn.x = 2
Fn.y = 1
Fn.z = 9
Fn.v = 3

⇑

7. Комбинирование передачи аргументов виде кортежа * с передачей в виде словаря **. Пример

Передавать в функцию кортеж и словарь по синтаксису Fn(*T) и Fn(**D) можно в сочетании. При такой передаче важно соблюдать правильный порядок следования аргументов при вызове а также правильного указания имен аргументов в словаре.

Пример. Пусть дана функция, которая получает 5 аргументов. В функцию передается кортеж и словарь.

# Аргументы. Режимы сопоставления.
# Передача кортежа и словаря в функцию.
# Распаковывание кортежа и словаря в функции

# Функция, которая получает 5 аргументов.
def Fn(x, y, z, v, w):
    print('Fn.x = ', x)
    print('Fn.y = ', y)
    print('Fn.z = ', z)
    print('Fn.v = ', v)
    print('Fn.w = ', w)
    return

# Вызов функции с параметрами кортежа и словаря.
# Задан кортеж
T = ( 1, 2)

# Задан словарь
D = { 'z':3, 'v':4, 'w':5 }

# Вызвать функцию с передачей кортежа и словаря
Fn(*T, **D) # Fn.x=1, Fn.y=2, Fn.z=3, Fn.v=4, Fn.w=5

# Fn(**D, *T) - так нельзя, ошибка

# Еще один вызов
Fn(*(1,2), **{'z':3, 'v':4, 'w':5}) # Fn.x=1, Fn.y=2, Fn.z=3,
# Fn.v=4, Fn.w=5

Результат выполнения программы

Fn.x = 1
Fn.y = 2
Fn.z = 3
Fn.v = 4
Fn.w = 5
Fn.x = 1
Fn.y = 2
Fn.z = 3
Fn.v = 4
Fn.w = 5

⇑

8. Примеры комбинирования обычных аргументов, именованных аргументов и аргументов с переменным количеством (*, **) в вызове функции

Если функция получает ряд аргументов, то в эту функцию можно передавать аргументы разными способами. Эти способы объединяют (комбинируют) различные режимы передачи аргументов. В нижеследующем примере это продемонстрировано.

Пример.

# Передача аргументов в функцию. Объединение режимов сопоставления аргументов.

# Функция, которая получает 6 аргументов.
def Fn(x, y, z, u, v, w):
    print('x=', x, ', y=', y, ', z=', z, ', u=', u, ', v=', v, ', w=', w)
    return

# 1. Вызов функции с обычными аргументами и кортежем
T = ( 10, 20, 30, 40) # Некоторый кортеж
Fn(5, 3, *T) # x= 5 , y= 3 , z= 10 , u= 20 , v= 30 , w= 40

# Можно и так
Fn(2, 4, *(8, -1, 3, 5)) # x= 2 , y= 4 , z= 8 , u= -1 , v= 3 , w= 5

# 2. Вызов функции с обычными аргументами и словарем
D = { 'w':7, 'u':5, 'v':8, 'z':2 }
Fn(1, 3, **D) # x= 1 , y= 3 , z= 2 , u= 5 , v= 8 , w= 7

# 3. Вызов функции с обычными аргументами, именованными аргументами и словарем
Fn(8, y=4, **D) # x= 8 , y= 4 , z= 2 , u= 5 , v= 8 , w= 7

# 4. Вызов функции с обычными аргументами и кортежем
T = (7, 8, 9, 10)
Fn(5, 6, *T) # x= 5 , y= 6 , z= 7 , u= 8 , v= 9 , w= 10

# 5. Вызов функции с обычными аргументами, кортежем и словарем
T = (5, 4)
D = {'w':1, 'u':3, 'v':2 }
x = 6
Fn(x, *T, **D) # x= 6 , y= 5 , z= 4 , u= 3 , v= 2 , w= 1

Результат работы программы

x= 5 , y= 3 , z= 10 , u= 20 , v= 30 , w= 40
x= 2 , y= 4 , z= 8 , u= -1 , v= 3 , w= 5
x= 1 , y= 3 , z= 2 , u= 5 , v= 8 , w= 7
x= 8 , y= 4 , z= 2 , u= 5 , v= 8 , w= 7
x= 5 , y= 6 , z= 7 , u= 8 , v= 9 , w= 10
x= 6 , y= 5 , z= 4 , u= 3 , v= 2 , w= 1

BestProg

Python. Режимы сопоставления аргументов. Аргументы переменной длины. Комбинирование разных способов сопоставления аргументов. Примеры