무엇을 **(더블 스타)와 *(별은) 매개 변수 위해 할

그들은 허용에 대한 기능을 허용하도록 정의 할 과 사용자가 전달하는 인수의 수, 위치 ( *) 및 키워드를 ( **).

함수 정의

*args라는 이름의 튜플에 할당되는 선택적 위치 인수 (매개 변수)를 얼마든지 허용합니다 args.

**kwargs이라는 이름의 dict에있는 선택적 키워드 인수 (매개 변수)를 얼마든지 허용합니다 kwargs.

당신은 (그리고해야) 적절한 이름을 선택하지만 인수가 아닌 특정 의미의 수에 대한 의도가있는 경우, 수 args및 kwargs표준 이름입니다.

여러 인수를 전달하여 확장

당신은 또한 사용할 수 있습니다 *args및 **kwargs각각 목록 (또는 반복자) 및 dicts (또는 맵핑)에서 매개 변수를 전달합니다.

매개 변수를받는 기능은 확장되고 있음을 알 필요가 없습니다.

예를 들어, Python 2의 xrange는 명시 적으로 기대하지 않지만 *args3 개의 정수를 인수로 사용하므로 다음과 같습니다.

>>> x = xrange(3) # create our *args - an iterable of 3 integers
>>> xrange(*x)    # expand here
xrange(0, 2, 2)

다른 예로, 다음에서 dict 확장을 사용할 수 있습니다 str.format.

>>> foo = 'FOO'
>>> bar = 'BAR'
>>> 'this is foo, {foo} and bar, {bar}'.format(**locals())
'this is foo, FOO and bar, BAR'

Python 3의 새로운 기능 : 키워드 전용 인수로 함수 정의

키워드 뒤에 인수 만 가질 수 있습니다. *args예를 들어 여기에서 kwarg2키워드 인수로 지정해야합니다.

def foo(arg, kwarg=None, *args, kwarg2=None, **kwargs):
    return arg, kwarg, args, kwarg2, kwargs

용법:

>>> foo(1,2,3,4,5,kwarg2='kwarg2', bar='bar', baz='baz')
(1, 2, (3, 4, 5), 'kwarg2', {'bar': 'bar', 'baz': 'baz'})

또한 *무제한 위치 인수를 허용하지 않고 키워드 만 인수가 따름을 나타 내기 위해 단독으로 사용할 수 있습니다.

def foo(arg, kwarg=None, *, kwarg2=None, **kwargs):
    return arg, kwarg, kwarg2, kwargs

여기서 kwarg2다시 명시 적으로 명명 된 키워드 인수 여야합니다.

>>> foo(1,2,kwarg2='kwarg2', foo='foo', bar='bar')
(1, 2, 'kwarg2', {'foo': 'foo', 'bar': 'bar'})

그리고 우리는 더 이상 무제한 위치 인수를 받아 들일 수 없습니다 *args*:

>>> foo(1,2,3,4,5, kwarg2='kwarg2', foo='foo', bar='bar')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: foo() takes from 1 to 2 positional arguments
    but 5 positional arguments (and 1 keyword-only argument) were given

다시 말하면, 여기서 간단히 말해서 kwarg위치가 아닌 이름으로 지정 해야 합니다.

def bar(*, kwarg=None):
    return kwarg

이 예제에서 우리는 kwarg위치 를 전달하려고 하면 오류가 발생합니다.

>>> bar('kwarg')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: bar() takes 0 positional arguments but 1 was given

kwarg매개 변수를 키워드 인수로 명시 적으로 전달해야합니다 .

>>> bar(kwarg='kwarg')
'kwarg'

파이썬 2 호환 데모

*args(일반적으로 “star-args”라고 함) 및 **kwargs( “kwargs”라고 말하면 별이 암시 될 수 있지만 “double-star kwargs”로 명시적임)는 *및 **표기법 을 사용하는 일반적인 파이썬 관용구입니다 . 이러한 특정 변수 이름은 필요하지 않지만 (예 : *foos및을 사용할 수 있음 **bars) 관례에서 벗어나면 동료 파이썬 코더가 분노 할 수 있습니다.

우리는 일반적으로 함수가 무엇을 받거나 전달할 인수 수를 알지 못하는 경우에 사용하며 때로는 모든 변수를 개별적으로 명명하는 것이 매우 지저분하고 중복 될 수 있습니다 (그러나 일반적으로 명시 적 인 경우 암시 적보다 낫습니다).

실시 예 1

다음 함수는 사용법을 설명하고 동작을 보여줍니다. 명명 된 b인수는 다음의 두 번째 위치 인수에 의해 소비됩니다.

def foo(a, b=10, *args, **kwargs):
    '''
    this function takes required argument a, not required keyword argument b
    and any number of unknown positional arguments and keyword arguments after
    '''
    print('a is a required argument, and its value is {0}'.format(a))
    print('b not required, its default value is 10, actual value: {0}'.format(b))
    # we can inspect the unknown arguments we were passed:
    #  - args:
    print('args is of type {0} and length {1}'.format(type(args), len(args)))
    for arg in args:
        print('unknown arg: {0}'.format(arg))
    #  - kwargs:
    print('kwargs is of type {0} and length {1}'.format(type(kwargs),
                                                        len(kwargs)))
    for kw, arg in kwargs.items():
        print('unknown kwarg - kw: {0}, arg: {1}'.format(kw, arg))
    # But we don't have to know anything about them 
    # to pass them to other functions.
    print('Args or kwargs can be passed without knowing what they are.')
    # max can take two or more positional args: max(a, b, c...)
    print('e.g. max(a, b, *args) \n{0}'.format(
      max(a, b, *args)))
    kweg = 'dict({0})'.format( # named args same as unknown kwargs
      ', '.join('{k}={v}'.format(k=k, v=v)
                             for k, v in sorted(kwargs.items())))
    print('e.g. dict(**kwargs) (same as {kweg}) returns: \n{0}'.format(
      dict(**kwargs), kweg=kweg))

함께 우리는 함수의 서명에 대한 온라인 도움말을 확인할 수 있습니다 help(foo)우리에게 알려줍니다,

foo(a, b=10, *args, **kwargs)

이 함수를 호출 해 봅시다 foo(1, 2, 3, 4, e=5, f=6, g=7)

어떤 인쇄 :

a is a required argument, and its value is 1
b not required, its default value is 10, actual value: 2
args is of type <type 'tuple'> and length 2
unknown arg: 3
unknown arg: 4
kwargs is of type <type 'dict'> and length 3
unknown kwarg - kw: e, arg: 5
unknown kwarg - kw: g, arg: 7
unknown kwarg - kw: f, arg: 6
Args or kwargs can be passed without knowing what they are.
e.g. max(a, b, *args)
4
e.g. dict(**kwargs) (same as dict(e=5, f=6, g=7)) returns:
{'e': 5, 'g': 7, 'f': 6}

실시 예 2

다른 함수를 사용하여 호출 할 수도 있습니다 a.

def bar(a):
    b, c, d, e, f = 2, 3, 4, 5, 6
    # dumping every local variable into foo as a keyword argument 
    # by expanding the locals dict:
    foo(**locals()) 

bar(100) 인쇄물:

a is a required argument, and its value is 100
b not required, its default value is 10, actual value: 2
args is of type <type 'tuple'> and length 0
kwargs is of type <type 'dict'> and length 4
unknown kwarg - kw: c, arg: 3
unknown kwarg - kw: e, arg: 5
unknown kwarg - kw: d, arg: 4
unknown kwarg - kw: f, arg: 6
Args or kwargs can be passed without knowing what they are.
e.g. max(a, b, *args)
100
e.g. dict(**kwargs) (same as dict(c=3, d=4, e=5, f=6)) returns:
{'c': 3, 'e': 5, 'd': 4, 'f': 6}

예 3 : 데코레이터에서의 실제 사용법

좋아, 아마도 우리는 유틸리티를 아직 보지 못했을 것입니다. 따라서 차별화 코드 전후에 중복 코드가있는 여러 기능이 있다고 상상해보십시오. 다음의 명명 된 함수는 설명을위한 의사 코드 일뿐입니다.

def foo(a, b, c, d=0, e=100):
    # imagine this is much more code than a simple function call
    preprocess()
    differentiating_process_foo(a,b,c,d,e)
    # imagine this is much more code than a simple function call
    postprocess()

def bar(a, b, c=None, d=0, e=100, f=None):
    preprocess()
    differentiating_process_bar(a,b,c,d,e,f)
    postprocess()

def baz(a, b, c, d, e, f):
    ... and so on

우리는 이것을 다르게 처리 할 수 ​​있지만 데코레이터를 사용하여 중복성을 확실히 추출 할 수 있으므로 아래 예는 방법 *args과 **kwargs매우 유용한 방법을 보여줍니다 .

def decorator(function):
    '''function to wrap other functions with a pre- and postprocess'''
    @functools.wraps(function) # applies module, name, and docstring to wrapper
    def wrapper(*args, **kwargs):
        # again, imagine this is complicated, but we only write it once!
        preprocess()
        function(*args, **kwargs)
        postprocess()
    return wrapper

이제 중복성을 고려하여 모든 랩핑 된 함수를 훨씬 간결하게 작성할 수 있습니다.

@decorator
def foo(a, b, c, d=0, e=100):
    differentiating_process_foo(a,b,c,d,e)

@decorator
def bar(a, b, c=None, d=0, e=100, f=None):
    differentiating_process_bar(a,b,c,d,e,f)

@decorator
def baz(a, b, c=None, d=0, e=100, f=None, g=None):
    differentiating_process_baz(a,b,c,d,e,f, g)

@decorator
def quux(a, b, c=None, d=0, e=100, f=None, g=None, h=None):
    differentiating_process_quux(a,b,c,d,e,f,g,h)

그리고 우리의 코드, 밖으로 감안로 *args하고 **kwargs우리가 수행 할 수 있습니다를, 우리는 가독성과 유지 보수성을 향상, 코드 라인을 줄이고, 우리 프로그램의 로직 유일한 정규 위치를 가지고있다. 이 구조의 일부를 변경해야 할 경우 각 변경을 수행 할 수있는 한 곳이 있습니다.

답변

def test(a,b,c):
     print(a)
     print(b)
     print(c)

test(1,2,3)
#output:
1
2
3

def test(a,b,c):
     print(a)
     print(b)
     print(c)

test(a=1,b=2,c=3)
#output:
1
2
3

def test(a=0,b=0,c=0):
     print(a)
     print(b)
     print(c)
     print('-------------------------')

test(a=1,b=2,c=3)
#output :
1
2
3
-------------------------

def test(a=0,b=0,c=0):
    print(a)
    print(b)
    print(c)
    print('-------------------------')

test(1,2,3)
# output :
1
2
3
---------------------------------

def sum(a,b):  #receive args from function calls as sum(1,2) or sum(a=1,b=2)
    print(a+b)

my_tuple = (1,2)
my_list = [1,2]
my_dict = {'a':1,'b':2}

# Let us unpack data structure of list or tuple or dict into arguments with help of '*' operator
sum(*my_tuple)   # becomes same as sum(1,2) after unpacking my_tuple with '*'
sum(*my_list)    # becomes same as sum(1,2) after unpacking my_list with  '*'
sum(**my_dict)   # becomes same as sum(a=1,b=2) after unpacking by '**' 

# output is 3 in all three calls to sum function.

def sum(*args): #pack the received positional args into data structure of tuple. after applying '*' - def sum((1,2,3,4))
    sum = 0
    for a in args:
        sum+=a
    print(sum)

sum(1,2,3,4)  #positional args sent to function sum
#output:
10

def sum(**args): #pack keyword args into datastructure of dict after applying '**' - def sum({a:1,b:2,c:3,d:4})
    sum=0
    for k,v in args.items():
        sum+=v
    print(sum)

sum(a=1,b=2,c=3,d=4) #positional args sent to function sum

            In function construction         In function call
=======================================================================
          |  def f(*args):                 |  def f(a, b):
*args     |      for arg in args:          |      return a + b
          |          print(arg)            |  args = (1, 2)
          |  f(1, 2)                       |  f(*args)
----------|--------------------------------|---------------------------
          |  def f(a, b):                  |  def f(a, b):
**kwargs  |      return a + b              |      return a + b
          |  def g(**kwargs):              |  kwargs = dict(a=1, b=2)
          |      return f(**kwargs)        |  f(**kwargs)
          |  g(a=1, b=2)                   |
-----------------------------------------------------------------------