Python Language
* args 및 ** kwargs

비고

함수를 작성할 때 * args 사용

튜플에서 모든 위치 지정 (즉, 이름없는) 인수를 수집하는 함수를 작성할 때 star *를 사용할 수 있습니다.

def print_args(farg, *args):
   print("formal arg: %s" % farg)
   for arg in args:
       print("another positional arg: %s" % arg)

전화 걸기 방법 :

print_args(1, "two", 3)

이 호출에서 farg는 항상 할당되고 두 개의 다른 인수는 인수 순서대로 인수 튜플에 공급됩니다.

함수를 작성할 때 ** kwargs 사용

매개 변수 이름 앞에 이중 별표 ** 를 사용하여 임의의 수의 키워드 (명명 된) 인수를 취하는 함수를 정의 할 수 있습니다.

def print_kwargs(**kwargs):
    print(kwargs)

메소드를 호출 할 때, 파이썬은 모든 키워드 인수의 사전을 만들고 함수 본문에서 사용할 수 있도록합니다 :

print_kwargs(a="two", b=3)
# prints: "{a: "two", b=3}"

함수 정의의 ** kwargs 매개 변수는 항상 마지막 매개 변수 여야하며 이전 매개 변수 다음에 전달 된 인수에만 일치해야합니다.

def example(a, **kw):
    print kw

example(a=2, b=3, c=4) # => {'b': 3, 'c': 4}

함수 본문 안에서 kwargs 는 사전과 같은 방식으로 조작됩니다. kwargs 개별 요소에 액세스하려면 일반 사전과 마찬가지로 루프를 반복하면됩니다.

def print_kwargs(**kwargs):
    for key in kwargs:
        print("key = {0}, value = {1}".format(key, kwargs[key])) 

이제 print_kwargs(a="two", b=1) 호출하면 다음과 같은 출력이 표시됩니다.

print_kwargs(a = "two", b = 1)
key = a, value = "two"
key = b, value = 1

함수 호출시 * args 사용하기

함수 정의에서 *args 의 일반적인 사용 사례는 랩핑되거나 상속 된 함수로 처리를 위임하는 것입니다. 일반적인 예는 클래스의 __init__ 메소드에있을 수 있습니다.

class A(object):
    def __init__(self, b, c):
        self.y = b
        self.z = c

class B(A):
    def __init__(self, a, *args, **kwargs):
        super(B, self).__init__(*args, **kwargs)
        self.x = a

여기서, a 매개 변수는 다른 모든 인수 (위치 및 키워드)가 기본 클래스로 전달되고 처리 된 후에 하위 클래스에 의해 처리됩니다.

예를 들면 :

b = B(1, 2, 3)
b.x  # 1
b.y  # 2
b.z  # 3

여기서 일어나는 일은 클래스 B __init__ 함수가 인수 1, 2, 3 입니다. 하나의 위치 인수 ( a )를 취해야한다는 것을 알고 있으므로 ( 1 )에서 전달 된 첫 번째 인수를 가져 오므로 함수 a == 1 의 범위에서 전달됩니다.

다음에, 그것이 위치 인수 (임의 수의 수행해야한다고보고 *args ) 그래서 전달 위치 나머지 인자 소요 ( 1, 2 ) 및 충전제로 *args . 이제 (함수의 범위 내에서) args == [2, 3] .

그런 다음 *args 하여 클래스 A 의 __init__ 함수를 호출합니다. 파이썬은 args 앞에 * 를두고리스트를 인수로 "언팩"합니다. 클래스 때이 예에서는, B 의 __init__ 함수 호출 클래스 S ' A __init__ 함수를, 상기 인수 전달되는 2, 3 (즉, A(2, 3) ).

마지막으로 자신의 x 속성을 첫 번째 위치 인수 a 1 과 동일)로 설정합니다.

함수 호출시 ** kwargs 사용

사전을 사용하여 함수의 매개 변수에 값을 할당 할 수 있습니다. 사전에서 키 이름으로 매개 변수 이름을 사용하고 각 키에 바인딩 된 이러한 인수의 값 :

def test_func(arg1, arg2, arg3): # Usual function with three arguments
   print("arg1: %s" % arg1)
   print("arg2: %s" % arg2)
   print("arg3: %s" % arg3)

# Note that dictionaries are unordered, so we can switch arg2 and arg3. Only the names matter.
kwargs = {"arg3": 3, "arg2": "two"}

# Bind the first argument (ie. arg1) to 1, and use the kwargs dictionary to bind the others
test_var_args_call(1, **kwargs) 

함수 호출시 * args 사용하기

함수를 호출 할 때 인수에 * 연산자를 사용하면 목록이나 튜플 인수를 푸는 효과가 있습니다

def print_args(arg1, arg2):
    print(str(arg1) + str(arg2))

a = [1,2]
b = tuple([3,4])

print_args(*a)
# 12
print_args(*b)
# 34

별표 된 인수의 길이는 함수의 인수의 수와 같아야합니다.

일반적인 파이썬 관용구는 zip 함수와 함께 언 패킹 연산자 * 를 사용하여 효과를 되돌리는 것입니다.

a = [1,3,5,7,9]
b = [2,4,6,8,10]

zipped = zip(a,b)
# [(1,2), (3,4), (5,6), (7,8), (9,10)]

zip(*zipped)
# (1,3,5,7,9), (2,4,6,8,10)

키워드 전용 및 키워드 필수 인수

Python 3에서는 디폴트 값이 없어도 키워드로만 지정할 수있는 함수 인수를 정의 할 수 있습니다. 별표 *를 사용하여 키워드 매개 변수를 설정하지 않고 추가 위치 매개 변수를 사용하면됩니다. * 뒤의 모든 인수는 키워드 전용 (즉, 위치가 정해지지 않은) 인수입니다. 키워드 전용 인수에 기본값이 제공되지 않으면 함수를 호출 할 때 키워드 인수 만 필요합니다.

def print_args(arg1, *args, keyword_required, keyword_only=True):
    print("first positional arg: {}".format(arg1))
    for arg in args:
        print("another positional arg: {}".format(arg))
    print("keyword_required value: {}".format(keyword_required))
    print("keyword_only value: {}".format(keyword_only))
    
print(1, 2, 3, 4) # TypeError: print_args() missing 1 required keyword-only argument: 'keyword_required'
print(1, 2, 3, keyword_required=4) 
# first positional arg: 1
# another positional arg: 2
# another positional arg: 3
# keyword_required value: 4
# keyword_only value: True

kwarg 값을 사전으로 채우기

def foobar(foo=None, bar=None):
    return "{}{}".format(foo, bar)

values = {"foo": "foo", "bar": "bar"}

foobar(**values) # "foobar"

** kwargs 및 기본값

** kwargs에 기본값을 사용하려면

def fun(**kwargs):
    print kwargs.get('value', 0)

fun()
# print 0
fun(value=1)
# print 1