기관사

언패킹은 반복을 사용해 list, tuple, dict 같은 컬렉션의 원소를 추출하는 작업을 말해요. 이렇게 꺼낸 값은 같은 문 안에서 변수에 할당할 수 있는데, 이를 보통 다중 할당이라고 해요.

특수 연산자 *와 **는 언패킹이나 다중 할당에서 자주 사용해요.

다중 할당

다중 할당에서는 할당 연산자(=) 왼쪽에 있는 변수의 개수와 오른쪽에 있는 값의 개수가 같아야 해요. 값을 구분하려면 쉼표 ,를 사용해요:

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

주어진 값에 비해 변수의 개수가 맞지 않으면 ValueError가 발생해요:

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

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

다중 할당은 한 가지 데이터 타입에만 국한되지 않아요:

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

>>> y
'Hello'

>>> z
True

다중 할당으로 lists의 원소를 서로 바꿀 수 있어요. 이 방법은 정렬 알고리즘에서 꽤 흔히 쓰여요. 예를 들어:

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

tuples는 불변이기 때문에 tuple의 원소는 바꿀 수 없어요.

언패킹

Python에서는 list/tuple/dictionary의 원소를 각기 다른 변수로 언패킹할 수 있어요. lists/tuples 안의 값은 정해진 순서대로 있기 때문에, 변수에도 같은 순서로 언패킹돼요:

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

필요 없는 값이 있다면 _로 표시할 수 있어요:

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

깊은 언패킹

list나 tuple 안에 들어 있는 list/tuple(_중첩 리스트/튜플_이라고도 해요)에서 값을 언패킹하고 할당하는 것은 얕은 언패킹과 같은 방식으로 동작해요. 다만 문맥이나 위치를 분명히 하기 위해 한정자를 붙여야 할 때가 많아요:

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

>>> d
"potato"

중첩된 list/tuple의 일부분만 깊게 언패킹할 수도 있어요:

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

>>> c
"carrot"

언패킹에서 변수의 위치가 잘못되었거나 값의 개수가 맞지 않으면 ValueError가 발생해요:

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

ValueError: too many values to unpack (expected 1)

*로 리스트/튜플 언패킹하기

list/tuple을 언패킹할 때 * 연산자로 "나머지" 값을 담을 수 있어요. 이 방법은 list/tuple을 슬라이싱하는 것보다 더 명확해요(어떤 상황에서는 가독성이 떨어지기도 하죠). 예를 들어, 첫 번째 원소를 꺼낸 뒤 나머지 값을 첫 번째 원소가 없는 새로운 list에 담을 수 있어요:

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

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

list의 처음과 끝에 있는 값을 꺼내고 가운데 값을 모두 묶을 수도 있어요:

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

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

깊은 언패킹에서도 *를 사용할 수 있어요:

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

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

딕셔너리 언패킹하기

딕셔너리 언패킹은 list/tuple 언패킹과는 조금 달라요. 딕셔너리를 반복하면 기본적으로 키를 대상으로 해요. 따라서 dict를 언패킹할 때는 값이 아니라 키만 언패킹할 수 있어요:

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

값을 언패킹하고 싶다면 <dict>.values() 메서드를 사용하면 돼요:

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

키와 값이 모두 필요하다면 <dict>.items() 메서드를 사용해요. <dict>.items()는 키-값 쌍을 담은 이터러블 뷰를 만들어요. 이 쌍들은 tuple로 언패킹할 수 있어요:

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

패킹

패킹은 여러 값을 하나의 list로 묶어 변수에 할당하는 기능이에요. 값을 _언패킹_해서 변경한 뒤, 그 결과를 다시 변수로 _패킹_하고 싶을 때 유용해요. 또한 두 개 이상의 lists/tuples/dicts를 병합할 수도 있어요.

*로 리스트/튜플 패킹하기

list/tuple은 * 연산자로 패킹할 수 있어요. 이렇게 하면 모든 값이 하나의 list/tuple로 패킹돼요.

>>> 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']

*를 왼쪽에 사용하는 방법에 대한 더 자세한 배경은 PEP 3132를 참고해요.

**로 딕셔너리 패킹하기

딕셔너리 패킹은 ** 연산자로 해요. 이렇게 하면 한 딕셔너리의 모든 키-값 쌍을 다른 딕셔너리로 패킹하거나, 두 딕셔너리를 하나로 합칠 수 있어요.

>>> 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}

함수에서 *와 ** 사용하기

함수 매개변수로 패킹하기

임의 개수의 인자를 받는 함수를 만들 때, 함수 정의에서 *args나 **kwargs를 사용할 수 있어요. *args는 임의 개수의 위치(비키워드) 인자를 tuple로 패킹하고, **kwargs는 임의 개수의 키워드 인자를 딕셔너리로 패킹할 때 사용해요.

*args 사용 예:

# 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")

**kwargs 사용 예:

# 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}

*args와 **kwargs는 함께 조합해서 사용할 수도 있어요:

>>> 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

*args 앞에 매개변수를 써서 특정 위치 인자를 받도록 할 수도 있어요. 이때 개별 키워드 인자는 **kwargs 앞에 와야 해요.

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

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

인자를 잘못된 순서로 작성하면 오류가 발생해요:

>>>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'

함수 호출에서 언패킹하기

*를 사용해 인자로 이루어진 list/tuple을 함수 호출에 언패킹할 수 있어요. iterable을 받지 않는 함수에 특히 유용해요:

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

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

내장 함수 zip()과 * 언패킹을 함께 사용하는 것도 흔한 활용법이에요. zip() 함수는 여러 이터러블을 받아 각 iterable의 값을 묶은 tuples의 list를 반환해요:

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