다음의 메소드 정의에서 무엇을 *
하고 **
무엇을 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는 명시 적으로 기대하지 않지만 *args
3 개의 정수를 인수로 사용하므로 다음과 같습니다.
>>> 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에서 확장 되었습니다.
답변
*
그리고 **
함수 인수 목록에서 특별한 사용을해야합니다. *
인수가 목록 **
임을 나타내고 인수가 사전임을 나타냅니다. 이를 통해 함수는 임의의 수의 인수를 취할 수 있습니다