Python Language
리스트 파괴 (일명 패킹 및 언 패킹)

소멸 할당

할당에서 "언 패킹"구문을 사용하여 반복 가능 항목을 값으로 나눌 수 있습니다.

값으로 분해

a, b = (1, 2)
print(a)
# Prints: 1
print(b)
# Prints: 2

iterable의 길이보다 더 압축을 풀려고하면 오류가 발생합니다.

a, b, c = [1]
# Raises: ValueError: not enough values to unpack (expected 3, got 1)

head, *tail = [1, 2, 3, 4, 5]

print(head)
# Prints: 1
print(tail)
# Prints: [2, 3, 4, 5]

l = [1, 2, 3, 4, 5]
head = l[0]
tail = l[1:]

a, b, *other, z = [1, 2, 3, 4, 5]
print(a, b, z, other)
# Prints: 1 2 5 [3, 4]

할당 소멸시 값 무시

주어진 가치에만 관심이 있다면 _ 를 사용하여 관심이 없다는 것을 나타낼 수 있습니다. 참고 : 이것은 여전히 _ 설정됩니다. 단지 대부분의 사람들이 변수로 사용하지 않습니다.

a, _ = [1, 2]
print(a)
# Prints: 1
a, _, c = (1, 2, 3)
print(a)
# Prints: 1
print(c)
# Prints: 3

a, *_ = [1, 2, 3, 4, 5]
print(a)
# Prints: 1

 a, *_, b = [1, 2, 3, 4, 5]
 print(a, b)
 # Prints: 1 5

 a, _, b, _, c, *_ = [1, 2, 3, 4, 5, 6]
 print(a, b, c)
 # Prints: 1 3 5

패킹 함수 인수

함수에서 필수 인수의 수를 정의 할 수 있습니다.

def fun1(arg1, arg2, arg3): 
    return (arg1,arg2,arg3)

3 개의 인수가 주어 졌을 때에 만 함수를 호출 가능하게합니다.

fun1(1, 2, 3)

기본값을 사용하여 인수를 선택적으로 정의 할 수 있습니다.

def fun2(arg1='a', arg2='b', arg3='c'):
    return (arg1,arg2,arg3)

그래서 당신은 다음과 같이 여러 가지 다른 방법으로 함수를 호출 할 수 있습니다 :

fun2(1)              → (1,b,c)
fun2(1, 2)           → (1,2,c)
fun2(arg2=2, arg3=3) → (a,2,3)
...

그러나 당신은 또한 인수를 팩에 destructuring 구문을 사용할 수 있습니다, 그래서 당신은 변수를 사용하여 지정할 수 있습니다 list 또는 dict .

인수 목록 패킹

값 목록이 있다고 생각해보십시오.

l = [1,2,3]

* 구문을 사용하여 값 목록이있는 함수를 인수로 호출 할 수 있습니다.

fun1(*l)
# Returns: (1,2,3)
fun1(*['w', 't', 'f'])
# Returns: ('w','t','f')

그러나 길이가 인수의 수와 일치하는 목록을 제공하지 않으면 :

fun1(*['oops'])
# Raises: TypeError: fun1() missing 2 required positional arguments: 'arg2' and 'arg3'

키워드 인수 패킹

이제 사전을 사용하여 인수를 압축 할 수 있습니다. ** 연산자를 사용하여 dict 을 매개 변수 값으로 언팩하도록 Python에 지시 할 수 있습니다.

d = {
  'arg1': 1,
  'arg2': 2,
  'arg3': 3
}
fun1(**d)
# Returns: (1, 2, 3)

함수가 위치 인수 (기본값이없는 인수) 만 가질 경우 예상되는 모든 매개 변수를 포함하고 추가 매개 변수가 없도록 사전이 필요합니다. 그렇지 않으면 오류가 발생합니다.

fun1(**{'arg1':1, 'arg2':2})
# Raises: TypeError: fun1() missing 1 required positional argument: 'arg3'
fun1(**{'arg1':1, 'arg2':2, 'arg3':3, 'arg4':4})
# Raises: TypeError: fun1() got an unexpected keyword argument 'arg4'

선택적 인수가있는 함수의 경우 인수를 같은 방식으로 사전으로 팩할 수 있습니다.

fun2(**d)
# Returns: (1, 2, 3)

그러나 기본값으로 대체되므로 값을 생략 할 수 있습니다.

fun2(**{'arg2': 2})
# Returns: ('a', 2, 'c')

이전과 동일하게 기존 매개 변수가 아닌 추가 값을 제공 할 수 없습니다.

fun2(**{'arg1':1, 'arg2':2, 'arg3':3, 'arg4':4})
# Raises: TypeError: fun2() got an unexpected keyword argument 'arg4'

실제 사용에서 함수는 위치 인수와 선택적 인수를 모두 가질 수 있으며 동일하게 작동합니다.

def fun3(arg1, arg2='b', arg3='c')
    return (arg1, arg2, arg3)

당신은 단지 반복 가능한 함수를 호출 할 수있다 :

fun3(*[1])
# Returns: (1, 'b', 'c')
fun3(*[1,2,3])
# Returns: (1, 2, 3)

또는 단지 사전으로 :

fun3(**{'arg1':1})
# Returns: (1, 'b', 'c')
fun3(**{'arg1':1, 'arg2':2, 'arg3':3})
# Returns: (1, 2, 3)

또는 동일한 호출에서 둘 다 사용할 수 있습니다.

fun3(*[1,2], **{'arg3':3})
# Returns: (1,2,3)

동일한 인수에 대해 여러 값을 제공 할 수는 없지만주의하십시오.

fun3(*[1,2], **{'arg2':42, 'arg3':3})
# Raises: TypeError: fun3() got multiple values for argument 'arg2'

함수 인자 압축 풀기

원하는 수의 인수를 허용 할 수있는 함수를 만들고 "컴파일"시간에 인수의 위치 나 이름을 적용하지 않으려는 경우 가능하며 다음과 같이하십시오.

def fun1(*args, **kwargs):
    print(args, kwargs)

*args 및 **kwargs 매개 변수는 각각 tuple 및 dict 로 설정된 특수 매개 변수입니다.

fun1(1,2,3)
# Prints: (1, 2, 3) {}
fun1(a=1, b=2, c=3)
# Prints: () {'a': 1, 'b': 2, 'c': 3}
fun1('x', 'y', 'z', a=1, b=2, c=3)
# Prints: ('x', 'y', 'z') {'a': 1, 'b': 2, 'c': 3}

충분한 파이썬 코드를 살펴 본다면, 인수를 다른 함수로 넘길 때 널리 사용된다는 것을 빨리 알 수 있습니다. 예를 들어 문자열 클래스를 확장하려면 다음과 같이하십시오.

class MyString(str):
    def __init__(self, *args, **kwarg):
        print('Constructing MyString')
        super(MyString, self).__init__(*args, **kwarg)