Mozdonyvezető

A kicsomagolás során egy gyűjtemény, például egy list, tuple vagy dict elemeit nyered ki iterációval. A kicsomagolt értékeket ezután ugyanabban az utasításban rendelheted változókhoz, amit általában többszörös értékadásnak neveznek.

A speciális * és ** operátort gyakran használjuk kicsomagolásnál és többszörös értékadásnál.

Többszörös értékadás

Többszörös értékadásnál az értékadás operátor (=) bal oldalán lévő változók számának meg kell egyeznie a jobb oldalon lévő értékek számával. Az értékek elválasztásához vesszőt , használj:

>>> a, b = 1, 2
>>> a
1

Ha a többszörös értékadásnál a megadott értékekhez nem megfelelő számú változó tartozik, ValueError hibát kapsz:

>>> x, y, z = 1, 2

ValueError: too many values to unpack (expected 3, got 2)

A többszörös értékadás nem korlátozódik egyetlen adattípusra:

>>> x, y, z = 1, "Hello", True
>>> x
1

>>> y
'Hello'

>>> z
True

A többszörös értékadást lists elemeinek felcserélésére is használhatod. Ez a gyakorlat meglehetősen elterjedt a rendezési algoritmusokban. Például:

>>> numbers = [1, 2]
>>> numbers[0], numbers[1] = numbers[1], numbers[0]
>>> numbers
[2, 1]

Mivel a tuples megváltoztathatatlan, egy tuple elemeit nem cserélheted fel.

Kicsomagolás

Pythonban kicsomagolhatod a list/tuple/dictionary elemeit különálló változókba. Mivel az értékek egy meghatározott sorrendben szerepelnek a lists/tuples-ben, ugyanabban a sorrendben csomagolódnak ki a változókba:

>>> fruits = ["apple", "banana", "cherry"]
>>> x, y, z = fruits
>>> x
"apple"

Ha vannak olyan értékek, amelyekre nincs szükséged, _ jellel jelölheted őket:

>>> fruits = ["apple", "banana", "cherry"]
>>> _, _, z = fruits
>>> z
"cherry"

Mély kicsomagolás

Egy list vagy tuple belsejében lévő list/tuple értékeinek kicsomagolása és értékadása (más néven egymásba ágyazott lista/tuple) ugyanúgy működik, mint a sekély kicsomagolás, de gyakran minősítőkre van szükség a kontextus vagy a pozíció tisztázásához:

>>> fruits_vegetables = [["apple", "banana"], ["carrot", "potato"]]
>>> [[a, b], [c, d]] = fruits_vegetables
>>> a
"apple"

>>> d
"potato"

Egy egymásba ágyazott list/tuple-nek akár csak egy részét is mélyen kicsomagolhatod:

>>> fruits_vegetables = [["apple", "banana"], ["carrot", "potato"]]
>>> [a, [c, d]] = fruits_vegetables
>>> a
["apple", "banana"]

>>> c
"carrot"

Ha a kicsomagolásnál a változók helytelenül helyezkednek el, illetve nem megfelelő számú érték van, ValueError hibát kapsz:

>>> fruits_vegetables = [["apple", "banana"], ["carrot", "potato"]]
>>> [[a, b], [d]] = fruits_vegetables

ValueError: too many values to unpack (expected 1)

Lista/tuple kicsomagolása *-gal

Amikor kicsomagolsz egy list/tuple-t, a * operátorral elkaphatod a „maradék” értékeket. Ez áttekinthetőbb, mint a list/tuple szeletelése (ami bizonyos helyzetekben kevésbé olvasható). Például az első elem kinyerhető, majd a maradék értékek egy új list-be kerülhetnek az első elem nélkül:

>>> fruits = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
>>> x, *last = fruits
>>> x
"apple"

>>> last
["banana", "cherry", "orange", "kiwi", "melon", "mango"]

Kinyerheted a list elején és végén lévő értékeket is, miközben az összes középső értéket egy csoportba fogod össze:

>>> fruits = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
>>> x, *middle, y, z = fruits
>>> y
"melon"

>>> middle
["banana", "cherry", "orange", "kiwi"]

A *-ot mély kicsomagolásnál is használhatod:

>>> fruits_vegetables = [["apple", "banana", "melon"], ["carrot", "potato", "tomato"]]
>>> [[a, *rest], b] = fruits_vegetables
>>> a
"apple"

>>> rest
["banana", "melon"]

Szótár kicsomagolása

Egy szótár kicsomagolása kicsit más, mint egy list/tuple kicsomagolása. A szótárakon való iteráció alapértelmezés szerint a kulcsokat érinti. Ezért amikor kicsomagolsz egy dict-et, csak a kulcsokat tudod kicsomagolni, az értékeket nem:

>>> fruits_inventory = {"apple": 6, "banana": 2, "cherry": 3}
>>> x, y, z = fruits_inventory
>>> x
"apple"

Ha az értékeket is ki szeretnéd csomagolni, használhatod a <dict>.values() metódust:

>>> fruits_inventory = {"apple": 6, "banana": 2, "cherry": 3}
>>> x, y, z = fruits_inventory.values()
>>> x
6

Ha egyszerre van szükséged a kulcsokra és az értékekre, használd a <dict>.items() metódust. A <dict>.items() egy iterálható nézetet hoz létre, amely kulcs-érték párokat tartalmaz. Ezek egy tuple-be csomagolhatók ki:

>>> fruits_inventory = {"apple": 6, "banana": 2, "cherry": 3}
>>> x, y, z = fruits_inventory.items()
>>> x
("apple", 6)

Becsomagolás

A becsomagolás során több értéket egyetlen list-be fogsz össze, amelyet egy változóhoz rendelsz. Ez akkor hasznos, ha ki szeretnéd csomagolni az értékeket, módosítanál rajtuk, majd az eredményeket vissza csomagolnád egy változóba. Arra is lehetőséget ad, hogy két vagy több lists/tuples/dicts összefésülését elvégezd.

Lista/tuple becsomagolása *-gal

Egy list/tuple becsomagolását a * operátorral végezheted el. Ez az összes értéket egy list/tuple-be csomagolja.

>>> fruits = ("apple", "banana", "cherry")
>>> more_fruits = ["orange", "kiwi", "melon", "mango"]

# fruits and more_fruits are unpacked and then their elements are packed into combined_fruits
>>> combined_fruits = *fruits, *more_fruits

# If there is no * on to the left of the "=" the result is a tuple
>>> combined_fruits
("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")

# If the * operator is used on the left side of "=" the result is a list.
# Note the trailing comma.
>>> *combined_fruits_too, = *fruits, *more_fruits
>>> combined_fruits_too
['apple', 'banana', 'cherry', 'orange', 'kiwi', 'melon', 'mango']

A * bal oldali használatáról bővebben lásd a PEP 3132 dokumentumot.

Szótár becsomagolása **-gal

Egy szótár becsomagolását a ** operátorral végzed el. Ez az egyik szótár összes kulcs-érték párját egy másik szótárba csomagolja, vagy két szótárt fűz össze.

>>> fruits_inventory = {"apple": 6, "banana": 2, "cherry": 3}
>>> more_fruits_inventory = {"orange": 4, "kiwi": 1, "melon": 2, "mango": 3}

# fruits_inventory and more_fruits_inventory are unpacked into key-values pairs and combined.
>>> combined_fruits_inventory = {**fruits_inventory, **more_fruits_inventory}

# then the pairs are packed into combined_fruits_inventory
>>> combined_fruits_inventory
{"apple": 6, "banana": 2, "cherry": 3, "orange": 4, "kiwi": 1, "melon": 2, "mango": 3}

A * és a ** használata függvényekkel

Becsomagolás függvényparaméterekkel

Amikor olyan függvényt hozol létre, amely tetszőleges számú argumentumot fogad el, a függvény definíciójában használhatod a *args vagy **kwargs szintaxist. A *args tetszőleges számú pozíciós (nem kulcsszavas) argumentumot csomagol egy tuple-be, a **kwargs pedig tetszőleges számú kulcsszavas argumentumot csomagol egy szótárba.

A *args használata:

# This function is defined to take any number of positional arguments

>>> def my_function(*args):
...     print(args)

# Arguments given to the function are packed into a tuple

>>> my_function(1, 2, 3)
(1, 2, 3)

>>> my_function("Hello")
("Hello")

>>> my_function(1, 2, 3, "Hello", "Mars")
(1, 2, 3, "Hello", "Mars")

A **kwargs használata:

# This function is defined to take any number of keyword arguments

>>> def my_function(**kwargs):
...   print(kwargs)

# Arguments given to the function are packed into a dictionary

>>> my_function(a=1, b=2, c=3)
{"a": 1, "b": 2, "c": 3}

A *args és a **kwargs együtt is használható:

>>> def my_function(*args, **kwargs):
...   print(sum(args))
...   for key, value in kwargs.items():
...       print(str(key) + " = " + str(value))

>>> my_function(1, 2, 3, a=1, b=2, c=3)
6
a = 1
b = 2
c = 3

A *args elé paramétereket is írhatsz, hogy meghatározott pozíciós argumentumokat engedj meg. Az egyedi kulcsszavas argumentumoknak ekkor a **kwargs előtt kell szerepelniük.

>>> def my_function(a, b, *args):
...   print(a)
...   print(b)
...   print(args)

>>> my_function(1, 2, 3, 4, 5)
1
2
(3, 4, 5)

Ha az argumentumokat helytelen sorrendben írod le, az hibát eredményez:

>>>def my_function(*args, a, b):
... print(args)

>>>my_function(1, 2, 3, 4, 5)
Traceback (most recent call last):
  File "c:\something.py", line 3, in <module>
    my_function(1, 2, 3, 4, 5)
TypeError: my_function() missing 2 required keyword-only arguments: 'a' and 'b'

Kicsomagolás függvényhívásokba

A * segítségével egy list/tuple argumentumait csomagolhatod ki egy függvényhívásba. Ez nagyon hasznos azoknál a függvényeknél, amelyek nem fogadnak el iterable-t:

>>> def my_function(a, b, c):
...   print(c)
...   print(b)
...   print(a)

numbers = [1, 2, 3]
>>> my_function(*numbers)
3
2
1

A *-os kicsomagolás a beépített zip() függvénnyel együtt szintén gyakori eset. A zip() függvény több iterálhatót vesz át, és olyan list-et ad vissza, amely tuple-okat tartalmaz, bennük az egyes iterable-ok értékei csoportosítva:

>>> values = (['x', 'y', 'z'], [1, 2, 3], [True, False, True])
>>> a, *rest = zip(*values)
>>> rest
[('y', 2, False), ('z', 3, True)]