Python,Теорія

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

  ⇑

Зв’язані теми

  ⇑