다음의 메소드 정의에서 무엇을 *하고 **무엇을 param2하는가?

def foo(param1, *param2):
def bar(param1, **param2):

*args와 **kwargs절에 설명 된 함수의 인수의 임의의 수 있도록 공통적 인 관용구 이상의 기능 정의에 파이썬 문서.

는 *args당신에게 모든 함수 매개 변수 줄 것이다 튜플 등을 :

def foo(*args):
    for a in args:
        print(a)        

foo(1)
# 1

foo(1,2,3)
# 1
# 2
# 3

는 **kwargs당신에게 모든 줄 것이다 키워드 인수를 사전과 같은 형식 매개 변수에 해당하는 사람을 제외하고.

def bar(**kwargs):
    for a in kwargs:
        print(a, kwargs[a])  

bar(name='one', age=27)
# age 27
# name one

두 관용구를 일반 인수와 함께 사용하여 고정 및 일부 가변 인수 세트를 사용할 수 있습니다.

def foo(kind, *args, **kwargs):
   pass

다른 방법으로 이것을 사용할 수도 있습니다.

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

obj = {'b':10, 'c':'lee'}

foo(100,**obj)
# 100 10 lee

*l관용구 의 또 다른 사용법은 함수를 호출 할 때 인수 목록의 압축 을 푸는 것입니다.

def foo(bar, lee):
    print(bar, lee)

l = [1,2]

foo(*l)
# 1 2

파이썬 3에서는 *l할당의 왼쪽에서 ( Extended Iterable Unpacking ) 사용할 수 있지만이 컨텍스트에서는 튜플 대신 목록을 제공합니다.

first, *rest = [1,2,3,4]
first, *l, last = [1,2,3,4]

또한 Python 3은 새로운 의미를 추가합니다 ( PEP 3102 참조 ).

def func(arg1, arg2, arg3, *, kwarg1, kwarg2):
    pass

이러한 함수는 3 개의 위치 인수 만 허용하며 이후의 모든 항목 *은 키워드 인수로만 전달 될 수 있습니다.

당신이 사용할 수있는 지적 가치 또한 그것의 *와 **도 같은 기능을 호출 할 때가. 리스트 / 튜플 또는 사전을 사용하여 여러 인수를 함수에 직접 전달할 수있는 바로 가기입니다. 예를 들어, 다음 기능이있는 경우 :

def foo(x,y,z):
    print("x=" + str(x))
    print("y=" + str(y))
    print("z=" + str(z))

다음과 같은 작업을 수행 할 수 있습니다.

>>> mylist = [1,2,3]
>>> foo(*mylist)
x=1
y=2
z=3

>>> mydict = {'x':1,'y':2,'z':3}
>>> foo(**mydict)
x=1
y=2
z=3

>>> mytuple = (1, 2, 3)
>>> foo(*mytuple)
x=1
y=2
z=3

참고 : 키의 mydict이름은 function의 매개 변수와 정확히 동일해야합니다 foo. 그렇지 않으면 TypeError:

>>> mydict = {'x':1,'y':2,'z':3,'badnews':9}
>>> foo(**mydict)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: foo() got an unexpected keyword argument 'badnews'

단일 *는 추가 위치 인수가 여러 개있을 수 있음을 의미합니다. foo()처럼 호출 할 수 있습니다 foo(1,2,3,4,5). foo ()의 본문에서 param2는 2-5를 포함하는 시퀀스입니다.

이중 **은 추가로 명명 된 매개 변수가 여러 개있을 수 있음을 의미합니다. bar()처럼 호출 할 수 있습니다 bar(1, a=2, b=3). bar () 본문에 param2는 { 'a': 2, 'b': 3}을 포함하는 사전입니다.

다음 코드로

def foo(param1, *param2):
    print(param1)
    print(param2)

def bar(param1, **param2):
    print(param1)
    print(param2)

foo(1,2,3,4,5)
bar(1,a=2,b=3)

출력은

1
(2, 3, 4, 5)
1
{'a': 2, 'b': 3}

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

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

함수 정의

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

이제 우리는 키워드 인수뿐만 아니라 위치와 함수 정의를 알고 있습니다.

이제 '*'연산자와 '**'연산자를 연구하겠습니다.

이 연산자는 2 가지 영역에서 사용할 수 있습니다.

a) 함수 호출

b) 기능 정의

함수 호출 에서 '*'연산자 및 '**'연산자 사용

우리가 직접 예를 들어서 논의 해 보자.

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

함수 정의 에서 '**'연산자는 수신 된 인수를 사전에 압축합니다.

기억하십시오 :

(A)에 기능 호출 '*' 언팩 (unpack)의 기능 정의에 의해 수신되는 위치 또는 키워드 인자로 또는 튜플리스트의 데이터 구조.

(A)에 기능 호출 "**" 언팩 (unpack)의 기능 정의에 의해 수신되는 위치 또는 키워드 인자 사전의 데이터 구조.

A의 함수 정의 '*' 팩 터플에 위치 인수.

A의 함수 정의 '**' 팩 사전에 키워드 인자.

이 테이블은 함수 구성 및 함수 호출 에서 사용 *하고 편리합니다 .**

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

이것은 실제로 Lorin Hochstein의 답변 을 요약 하는 데 도움이되지만 도움이됩니다.

관련 : 스타 / 스 플랫 연산자에 대한 사용 이 Python 3에서 확장 되었습니다.

*그리고 **함수 인수 목록에서 특별한 사용을해야합니다. * 인수가 목록 **임을 나타내고 인수가 사전임을 나타냅니다. 이를 통해 함수는 임의의 수의 인수를 취할 수 있습니다

예를 통해 배우는 사람들을 위해!

1. 목적은 * 목록으로 제공된 임의의 수의 인수를 취할 수있는 함수를 정의 할 수있는 기능을 제공하는 것입니다 (예 :) f(*myList).
2. 목적은 **사전 (예 :)을 제공하여 함수의 인수를 제공하는 기능을 제공하는 것 f(**{'x' : 1, 'y' : 2})입니다.

두 정상 변수를받는 함수 정의에 의해 우리가 이것을 보여 주자 x, y, 등 많은 인수를 받아 들일 수 myArgs, 그리고 더 많은 인수를 사용할 수 있습니다 myKW. 나중에을 y사용하여 피드하는 방법을 보여줍니다 myArgDict.

def f(x, y, *myArgs, **myKW):
    print("# x      = {}".format(x))
    print("# y      = {}".format(y))
    print("# myArgs = {}".format(myArgs))
    print("# myKW   = {}".format(myKW))
    print("# ----------------------------------------------------------------------")

# Define a list for demonstration purposes
myList    = ["Left", "Right", "Up", "Down"]
# Define a dictionary for demonstration purposes
myDict    = {"Wubba": "lubba", "Dub": "dub"}
# Define a dictionary to feed y
myArgDict = {'y': "Why?", 'y0': "Why not?", "q": "Here is a cue!"}

# The 1st elem of myList feeds y
f("myEx", *myList, **myDict)
# x      = myEx
# y      = Left
# myArgs = ('Right', 'Up', 'Down')
# myKW   = {'Wubba': 'lubba', 'Dub': 'dub'}
# ----------------------------------------------------------------------

# y is matched and fed first
# The rest of myArgDict becomes additional arguments feeding myKW
f("myEx", **myArgDict)
# x      = myEx
# y      = Why?
# myArgs = ()
# myKW   = {'y0': 'Why not?', 'q': 'Here is a cue!'}
# ----------------------------------------------------------------------

# The rest of myArgDict becomes additional arguments feeding myArgs
f("myEx", *myArgDict)
# x      = myEx
# y      = y
# myArgs = ('y0', 'q')
# myKW   = {}
# ----------------------------------------------------------------------

# Feed extra arguments manually and append even more from my list
f("myEx", 4, 42, 420, *myList, *myDict, **myDict)
# x      = myEx
# y      = 4
# myArgs = (42, 420, 'Left', 'Right', 'Up', 'Down', 'Wubba', 'Dub')
# myKW   = {'Wubba': 'lubba', 'Dub': 'dub'}
# ----------------------------------------------------------------------

# Without the stars, the entire provided list and dict become x, and y:
f(myList, myDict)
# x      = ['Left', 'Right', 'Up', 'Down']
# y      = {'Wubba': 'lubba', 'Dub': 'dub'}
# myArgs = ()
# myKW   = {}
# ----------------------------------------------------------------------

경고

1. ** 사전 전용으로 예약되어 있습니다.
2. 비 선택적 인수 할당이 먼저 발생합니다.
3. 비 선택적 인수는 두 번 사용할 수 없습니다.
4. 해당되는 경우 항상 **와야합니다 *.

파이썬 문서에서 :

형식 매개 변수 슬롯보다 위치 인수가 더 많은 경우 "* identifier"구문을 사용하는 형식 매개 변수가 없으면 TypeError 예외가 발생합니다. 이 경우 형식 매개 변수는 초과 위치 인수를 포함하는 튜플을 수신합니다 (또는 초과 위치 인수가없는 경우 빈 튜플).

키워드 인수가 공식 매개 변수 이름과 일치하지 않으면 "** identifier"구문을 사용하는 공식 매개 변수가 없으면 TypeError 예외가 발생합니다. 이 경우 해당 형식 매개 변수는 초과 키워드 인수를 포함하는 사전 (키워드로 키워드 및 인수 값을 해당 값으로 사용)을 포함하거나 초과 키워드 키워드가없는 경우 (새) 빈 사전을 수신합니다.

* 변수 인수를 튜플로 받는다는 의미

** 변수 인수를 사전으로 받는다는 의미

다음과 같이 사용됩니다.

1) 싱글 *

def foo(*args):
    for arg in args:
        print(arg)

foo("two", 3)

산출:

two
3

2) 이제 **

def bar(**kwargs):
    for key in kwargs:
        print(key, kwargs[key])

bar(dic1="two", dic2=3)

산출:

dic1 two
dic2 3

다른 사람들이 언급하지 않은 예를 드리고 싶습니다

* 또한 발전기의 포장을 풀 수 있습니다

Python3 문서의 예

x = [1, 2, 3]
y = [4, 5, 6]

unzip_x, unzip_y = zip(*zip(x, y))

unzip_x는 [1, 2, 3]이되고 unzip_y는 [4, 5, 6]이됩니다

zip ()은 여러 개의 실행 가능한 인수를 수신하고 생성기를 리턴합니다.

zip(*zip(x,y)) -> zip((1, 4), (2, 5), (3, 6))

파이썬 3.5에서, 당신은 또한이 구문을 사용할 수 있습니다 list, dict, tuple, 및 set디스플레이 (이라고도 불리는 리터럴). PEP 488 : 추가 포장 풀기 일반화를 참조하십시오 .

>>> (0, *range(1, 4), 5, *range(6, 8))
(0, 1, 2, 3, 5, 6, 7)
>>> [0, *range(1, 4), 5, *range(6, 8)]
[0, 1, 2, 3, 5, 6, 7]
>>> {0, *range(1, 4), 5, *range(6, 8)}
{0, 1, 2, 3, 5, 6, 7}
>>> d = {'one': 1, 'two': 2, 'three': 3}
>>> e = {'six': 6, 'seven': 7}
>>> {'zero': 0, **d, 'five': 5, **e}
{'five': 5, 'seven': 7, 'two': 2, 'one': 1, 'three': 3, 'six': 6, 'zero': 0}

또한 하나의 함수 호출로 여러 iterable을 압축 해제 할 수 있습니다.

>>> range(*[1, 10], *[2])
range(1, 10, 2)

(PEP 링크에 대해 mgilson에게 감사합니다.)

함수 호출 외에도 * args 및 ** kwargs는 클래스 계층에서 유용 __init__하며 Python에서 메소드 를 작성하지 않아도됩니다 . Django 코드와 같은 프레임 워크에서도 비슷한 사용법을 볼 수 있습니다.

예를 들어

def __init__(self, *args, **kwargs):
    for attribute_name, value in zip(self._expected_attributes, args):
        setattr(self, attribute_name, value)
        if kwargs.has_key(attribute_name):
            kwargs.pop(attribute_name)

    for attribute_name in kwargs.viewkeys():
        setattr(self, attribute_name, kwargs[attribute_name])

그러면 서브 클래스는

class RetailItem(Item):
    _expected_attributes = Item._expected_attributes + ['name', 'price', 'category', 'country_of_origin']

class FoodItem(RetailItem):
    _expected_attributes = RetailItem._expected_attributes +  ['expiry_date']

그런 다음 서브 클래스는 다음과 같이 인스턴스화됩니다.

food_item = FoodItem(name = 'Jam', 
                     price = 12.0, 
                     category = 'Foods', 
                     country_of_origin = 'US', 
                     expiry_date = datetime.datetime.now())

또한 해당 서브 클래스 인스턴스에만 해당되는 새로운 속성을 가진 서브 클래스는 Base 클래스 __init__를 호출 하여 속성 설정을 오프로드 할 수 있습니다 . 이것은 * args 및 ** kwargs를 통해 수행됩니다. kwargs는 주로 명명 된 인수를 사용하여 코드를 읽을 수 있도록 주로 사용됩니다. 예를 들어

class ElectronicAccessories(RetailItem):
    _expected_attributes = RetailItem._expected_attributes +  ['specifications']
    # Depend on args and kwargs to populate the data as needed.
    def __init__(self, specifications = None, *args, **kwargs):
        self.specifications = specifications  # Rest of attributes will make sense to parent class.
        super(ElectronicAccessories, self).__init__(*args, **kwargs)

로 설명 될 수있는

usb_key = ElectronicAccessories(name = 'Sandisk', 
                                price = '$6.00', 
                                category = 'Electronics',
                                country_of_origin = 'CN',
                                specifications = '4GB USB 2.0/USB 3.0')

완전한 코드는 여기에 있습니다

닉의 답 을 바탕으로 ...

def foo(param1, *param2):
    print(param1)
    print(param2)


def bar(param1, **param2):
    print(param1)
    print(param2)


def three_params(param1, *param2, **param3):
    print(param1)
    print(param2)
    print(param3)


foo(1, 2, 3, 4, 5)
print("\n")
bar(1, a=2, b=3)
print("\n")
three_params(1, 2, 3, 4, s=5)

산출:

1
(2, 3, 4, 5)

1
{'a': 2, 'b': 3}

1
(2, 3, 4)
{'s': 5}

기본적으로 임의의 수의 위치 인수 는 * args를 사용할 수 있으며 명명 된 인수 (또는 키워드 인수 인 kwargs)는 ** kwargs를 사용할 수 있습니다.

*args과 **kwargs: 당신이 함수 인수의 변수 번호를 전달할 수 있습니다.

*args: 키워드가 아닌 변수 길이 인수 목록을 함수에 보내는 데 사용됩니다.

def args(normal_arg, *argv):
    print("normal argument:", normal_arg)

    for arg in argv:
        print("Argument in list of arguments from *argv:", arg)

args('animals', 'fish', 'duck', 'bird')

생산할 것이다 :

normal argument: animals
Argument in list of arguments from *argv: fish
Argument in list of arguments from *argv: duck
Argument in list of arguments from *argv: bird

**kwargs*

**kwargs키워드로 가변 길이의 인수를 함수에 전달할 수 있습니다. **kwargs함수에서 명명 된 인수를 처리 하려면 사용해야 합니다.

def who(**kwargs):
    if kwargs is not None:
        for key, value in kwargs.items():
            print("Your %s is %s." % (key, value))

who(name="Nikola", last_name="Tesla", birthday="7.10.1856", birthplace="Croatia")  

생산할 것이다 :

Your name is Nikola.
Your last_name is Tesla.
Your birthday is 7.10.1856.
Your birthplace is Croatia.

이 예제는 파이썬에서 한 번에 *args, **kwargs그리고 심지어 super상속 을 기억하는 데 도움이됩니다 .

class base(object):
    def __init__(self, base_param):
        self.base_param = base_param


class child1(base): # inherited from base class
    def __init__(self, child_param, *args) # *args for non-keyword args
        self.child_param = child_param
        super(child1, self).__init__(*args) # call __init__ of the base class and initialize it with a NON-KEYWORD arg

class child2(base):
    def __init__(self, child_param, **kwargs):
        self.child_param = child_param
        super(child2, self).__init__(**kwargs) # call __init__ of the base class and initialize it with a KEYWORD arg

c1 = child1(1,0)
c2 = child2(1,base_param=0)
print c1.base_param # 0
print c1.child_param # 1
print c2.base_param # 0
print c2.child_param # 1

함수에서 둘 다 사용하는 좋은 예는 다음과 같습니다.

>>> def foo(*arg,**kwargs):
...     print arg
...     print kwargs
>>>
>>> a = (1, 2, 3)
>>> b = {'aa': 11, 'bb': 22}
>>>
>>>
>>> foo(*a,**b)
(1, 2, 3)
{'aa': 11, 'bb': 22}
>>>
>>>
>>> foo(a,**b) 
((1, 2, 3),)
{'aa': 11, 'bb': 22}
>>>
>>>
>>> foo(a,b) 
((1, 2, 3), {'aa': 11, 'bb': 22})
{}
>>>
>>>
>>> foo(a,*b)
((1, 2, 3), 'aa', 'bb')
{}

TL; DR

아래의 6 가지 사용 사례입니다 *및 **파이썬 프로그래밍은 :

1. *args:을 사용하여 여러 개의 위치 인수를 허용하려면 def foo(*args): pass 여기 foo에서 여러 개의 위치 인수를 허용합니다. 즉, 다음 호출이 유효합니다 foo(1).foo(1, 'bar')
2. **kwargs:을 사용하여 여러 개의 키워드 인수를 허용하려면 def foo(**kwargs): pass 여기에서 'foo'는 여러 개의 키워드 인수를 허용합니다. 즉, 다음 호출이 유효합니다 foo(name='Tom').foo(name='Tom', age=33)
3. *args, **kwargs:을 사용하여 여러 위치 및 키워드 인수를 허용하려면 def foo(*args, **kwargs): pass 여기 foo에서 여러 위치 및 키워드 인수를 허용합니다. 즉, 다음 호출이 유효합니다 foo(1,name='Tom').foo(1, 'bar', name='Tom', age=33)
4. 사용하는 경우에만 인수를 키워드 적용하려면 *: def foo(pos1, pos2, *, kwarg1): pass 여기에 *따라서, 그 foo는 만 POS2 후 키워드 인수에 대한 동의로 간주 foo(1, 2, 3)형식 오류를 제기하지만 foo(1, 2, kwarg1=3)괜찮습니다.
5. 사용하여 더 많은 위치 인수에 더 관심을 표현할 수 없습니다 *_(참고 :이 대회 만) : def foo(bar, baz, *_): pass 수단 (관례) foo만을 사용 bar하고 baz그 작업의 인수 및 다른 사람을 무시합니다.
6. 사용하여 더 많은 키워드 인자에 더 관심을 표현할 수 없습니다 \**_(참고 :이 대회 만) : def foo(bar, baz, **_): pass 수단 (관례) foo만을 사용 bar하고 baz그 작업의 인수 및 다른 사람을 무시합니다.

보너스 : python 3.8부터 /함수 정의에 사용하여 위치 전용 매개 변수를 시행 할 수 있습니다 . 다음 예에서 매개 변수 a 및 b는 위치 전용 이며 c 또는 d는 위치 또는 키워드 일 수 있으며 e 또는 f는 키워드 여야합니다.

def f(a, b, /, c, d, *, e, f):
    pass

TL; DR

함수에 전달 된 인수를 함수 본문 내부 list와 dict내부에 압축합니다. 다음과 같이 함수 서명을 정의 할 때 :

def func(*args, **kwds):
    # do stuff

여러 개의 인수와 키워드 인수로 호출 할 수 있습니다. 키워드가 아닌 인수 args는 함수 본문 내에서 호출 된 목록으로 압축되고 키워드 인수 kwds는 함수 본문 내에서 호출 된 dict로 압축됩니다 .

func("this", "is a list of", "non-keyowrd", "arguments", keyword="ligma", options=[1,2,3])

이제 함수가 호출 함수 본체 내부에 두 개의 로컬 변수있다 args목록 갖는 값 ["this", "is a list of", "non-keyword", "arguments"]과 kwdsA는 dict데 가치{"keyword" : "ligma", "options" : [1,2,3]}

이것은 역으로, 즉 발신자 측에서 작동합니다. 예를 들어 다음과 같이 정의 된 함수가있는 경우

def f(a, b, c, d=1, e=10):
    # do stuff

호출 범위에있는 iterables 또는 맵핑을 압축 해제하여 호출 할 수 있습니다.

iterable = [1, 20, 500]
mapping = {"d" : 100, "e": 3}
f(*iterable, **mapping)
# That call is equivalent to
f(1, 20, 500, d=100, e=3)

문맥

• 파이썬 3.x
• 포장 풀기 **
• 문자열 형식과 함께 사용

문자열 형식과 함께 사용

이 스레드의 답변 외에도 다른 곳에서는 언급되지 않은 또 다른 세부 사항이 있습니다. 이것은 Brad Solomon 의 답변으로 확장됩니다.

**python을 사용할 때 압축 풀기 기능 도 유용합니다 str.format.

이것은 파이썬 f-strings f-string으로 할 수있는 것과 다소 유사 하지만 변수를 보유하도록 dict를 선언하는 오버 헤드가 추가됩니다 (f-string에는 dict가 필요하지 않음).

빠른 예

  ## init vars
  ddvars = dict()
  ddcalc = dict()
  pass
  ddvars['fname']     = 'Huomer'
  ddvars['lname']     = 'Huimpson'
  ddvars['motto']     = 'I love donuts!'
  ddvars['age']       = 33
  pass
  ddcalc['ydiff']     = 5
  ddcalc['ycalc']     = ddvars['age'] + ddcalc['ydiff']
  pass
  vdemo = []

  ## ********************
  ## single unpack supported in py 2.7
  vdemo.append('''
  Hello {fname} {lname}!

  Today you are {age} years old!

  We love your motto "{motto}" and we agree with you!
  '''.format(**ddvars)) 
  pass

  ## ********************
  ## multiple unpack supported in py 3.x
  vdemo.append('''
  Hello {fname} {lname}!

  In {ydiff} years you will be {ycalc} years old!
  '''.format(**ddvars,**ddcalc)) 
  pass

  ## ********************
  print(vdemo[-1])

• def foo(param1, *param2):에 대한 임의의 수의 값을 허용 할 수있는 방법입니다 *param2.
• def bar(param1, **param2): 키를 사용하여 임의의 수의 값을 허용 할 수있는 방법입니다. *param2
• param1 간단한 매개 변수입니다.

예를 들어, Java에서 varargs 를 구현하기위한 구문은 다음과 같습니다.

accessModifier methodName(datatype… arg) {
    // method body
}