**kwargs의 목적과 용도는 무엇입니까?

**kwargs의 목적과 용도는 무엇입니까?

이 질문에는 이미 답변이 있습니다.

**(이중 별/별 디스크) 및 *(별/별 디스크)는 파라미터에 어떤 역할을 합니까? (24 회답)

닫힘작년.

★★★★★★★★★★★★★★★의 용도는 무엇입니까?**kwargsPython?

가 할 수 걸 objects.filter**kwargs★★★★★★ 。

시간 델타 지정에도 이 작업을 수행할 수 있습니까? timedelta(hours = time1)

확히히 ?떻 ?? ????' 풀기됩니까?장풀로로로로로로로로로?맘에 들다a,b=1,2

하시면 됩니다.**kwargs함수에 임의의 수의 키워드 인수("kwargs"는 "인수"를 의미합니다).

>>> def print_keyword_args(**kwargs):
...     # kwargs is a dict of the keyword args passed to the function
...     for key, value in kwargs.iteritems():
...         print "%s = %s" % (key, value)
... 
>>> print_keyword_args(first_name="John", last_name="Doe")
first_name = John
last_name = Doe

이 경우에도 하실 수 있습니다.**kwargs키워드 인수 사전을 작성하여 함수에 전달함으로써 함수를 호출할 때 구문:

>>> kwargs = {'first_name': 'Bobby', 'last_name': 'Smith'}
>>> print_keyword_args(**kwargs)
first_name = Bobby
last_name = Smith

Python Tutorial에는 동작 방법에 대한 좋은 설명과 몇 가지 좋은 예가 포함되어 있습니다.

Python 3 업데이트

3이 Python 3의 iteritems(), 사용

사전의 포장을 해제하는 중

**전의의포포포풀풀

이것.

func(a=1, b=2, c=3)

와 같다

args = {'a': 1, 'b': 2, 'c':3}
func(**args)

이는 매개 변수를 구성해야 하는 경우에 유용합니다.

args = {'name': person.name}
if hasattr(person, "address"):
    args["address"] = person.address
func(**args)  # either expanded to func(name=person.name) or
              #                    func(name=person.name, address=person.address)

---

함수의 패킹 매개 변수

• .items().iteritems() 3 33 33 경

def setstyle(**styles):
    for key, value in styles.iteritems():      # styles is a regular dictionary
        setattr(someobject, key, value)

이렇게 하면 다음과 같은 기능을 사용할 수 있습니다.

setstyle(color="red", bold=False)

---

메모들

• kwargs는 키워드 인수에 사용되는 변수 이름입니다.하다중요한 부분은 사전이고 이중 아스타리스크 연산자로 압축이 풀렸다는 것입니다.**.
• 다른 반복 가능한 파일은 하나의 별표 연산자로 압축 해제됩니다.*
• 혼동을 이름인 '알 수 있는 변수 이름'을 것 .kwargs ★★★★★★★★★★★★★★★★★」args 및 한 경우 각각 을 참조하십시오

---

자원.

• PEP 448: 기타 포장의 일반화
• 실제 Python:Python arg 및 kwargs:디미스테이트
• 함수 시그니처의 변수 이름 앞의 * 및 **는 무엇을 의미합니까?

kwargs는 파라미터에 추가된 사전일 뿐입니다.

사전에는 키와 값의 쌍을 포함할 수 있습니다.그게 콰르그야.좋아, 이렇게 하자.

그 이유는 그렇게 간단하지 않다.

예를 들어 (매우 가상적인) 다른 루틴을 호출하여 작업을 수행하는 인터페이스가 있습니다.

def myDo(what, where, why):
   if what == 'swim':
      doSwim(where, why)
   elif what == 'walk':
      doWalk(where, why)
   ...

이제 새로운 방법 "드라이브"를 사용할 수 있습니다.

elif what == 'drive':
   doDrive(where, why, vehicle)

하지만 잠깐만요, "차량"이라는 새로운 매개 변수가 있습니다. 이전에는 몰랐습니다.이제 myDo 함수의 서명에 추가해야 합니다.

여기서 kwargs를 사용할 수 있습니다. 서명에 kwargs를 추가합니다.

def myDo(what, where, why, **kwargs):
   if what == 'drive':
      doDrive(where, why, **kwargs)
   elif what == 'swim':
      doSwim(where, why, **kwargs)

이렇게 하면 호출된 루틴이 변경될 때마다 인터페이스 기능의 시그니처를 변경할 필요가 없습니다.

이것은 Kwargs가 도움이 될 수 있는 좋은 예 중 하나일 뿐입니다.

좋은 샘플이 때로는 긴 담화보다 더 낫다는 것을 바탕으로 나는 모든 python 변수 인수 전달 기능(위치 및 명명된 인수 모두)을 사용하여 두 가지 함수를 쓸 것이다.직접 어떤 기능을 하는지 쉽게 알 수 있을 것입니다.

def f(a = 0, *args, **kwargs):
    print("Received by f(a, *args, **kwargs)")
    print("=> f(a=%s, args=%s, kwargs=%s" % (a, args, kwargs))
    print("Calling g(10, 11, 12, *args, d = 13, e = 14, **kwargs)")
    g(10, 11, 12, *args, d = 13, e = 14, **kwargs)

def g(f, g = 0, *args, **kwargs):
    print("Received by g(f, g = 0, *args, **kwargs)")
    print("=> g(f=%s, g=%s, args=%s, kwargs=%s)" % (f, g, args, kwargs))

print("Calling f(1, 2, 3, 4, b = 5, c = 6)")
f(1, 2, 3, 4, b = 5, c = 6)

출력은 다음과 같습니다.

Calling f(1, 2, 3, 4, b = 5, c = 6)
Received by f(a, *args, **kwargs) 
=> f(a=1, args=(2, 3, 4), kwargs={'c': 6, 'b': 5}
Calling g(10, 11, 12, *args, d = 13, e = 14, **kwargs)
Received by g(f, g = 0, *args, **kwargs)
=> g(f=10, g=11, args=(12, 2, 3, 4), kwargs={'c': 6, 'b': 5, 'e': 14, 'd': 13})

: 티브: :*args ★★★★★★★★★★★★★★★★★」**kwargs.

를 사용합니다.*args ★★★★★★★★★★★★★★★★★」**kwargs를

def args_kwargs_test(arg1, arg2, arg3):
    print "arg1:", arg1
    print "arg2:", arg2
    print "arg3:", arg3

이번에는 now이용사사 now now사사다다 now를 사용하겠습니다.*args에서 한 함수를

#args can either be a "list" or "tuple"
>>> args = ("two", 3, 5)  
>>> args_kwargs_test(*args)

결과:

2arg1: 2
3⁄2: 3
5/3: 5

---

이제 now을 요.**kwargs

#keyword argument "kwargs" has to be a dictionary
>>> kwargs = {"arg3":3, "arg2":'two', "arg1":5}
>>> args_kwargs_test(**kwargs)

결과:

5/1: 5
2arg2: 2
arg3: 3

★★★★★★★★★★★★★★★*args인텔리전스가 순서로 뿐입니다.그것은 단순히 전달된 arg를 파라미터에 보간합니다(왼쪽에서 오른쪽 순서로).**kwargs합니다.

• kwargs**kwargs변수 이름일 뿐입니다. 잘 드실 수 .**anyVariableName
• kwargs포괄적 논거그러나 나는 그것들이 단순히 이름과 함께 전달되는 논쟁이기 때문에 "이름 있는 논쟁"이라고 불리는 것이 더 낫다고 생각한다(키워드 논쟁"이라는 용어의 "키워드"라는 단어에 대한 의미를 찾을 수 없다)."키워드"는 보통 프로그래밍 언어로 예약된 단어들을 의미하기 때문에 프로그래머가 변수 이름에 사용하지 않는 단어들을 의미한다고 생각합니다. kwargs의 .).param1 ★★★★★★★★★★★★★★★★★」param2되는 두 설명합니다.func(param1="val1",param2="val2")하는 것이 값만 건네주는 것이 아니라, 값만 전달한다.func(val1,val2)따라서 이러한 파라미터(즉, 인수)의 임의의 수를 지정할 수 있기 때문에, 이러한 파라미터는 「임의의 수」라고 적절히 불릴 필요가 있다고 생각합니다.funcfunc(**kwargs)

' 인수먼저 설명하고 ''를 '이름붙인 인수들의 임의수'를 설명하겠습니다.kwargs.

명명된 인수

• 이름 있는 arg는 위치 arg 뒤에 와야 합니다.
• 명명된 arg의 순서는 중요하지 않습니다.

• 예

  def function1(param1,param2="arg2",param3="arg3"):
      print("\n"+str(param1)+" "+str(param2)+" "+str(param3)+"\n")
  
  function1(1)                      #1 arg2 arg3   #1 positional arg
  function1(param1=1)               #1 arg2 arg3   #1 named arg
  function1(1,param2=2)             #1 2 arg3      #1 positional arg, 1 named arg
  function1(param1=1,param2=2)      #1 2 arg3      #2 named args       
  function1(param2=2, param1=1)     #1 2 arg3      #2 named args out of order
  function1(1, param3=3, param2=2)  #1 2 3         #
  
  #function1()                      #invalid: required argument missing
  #function1(param2=2,1)            #invalid: SyntaxError: non-keyword arg after keyword arg
  #function1(1,param1=11)           #invalid: TypeError: function1() got multiple values for argument 'param1'
  #function1(param4=4)              #invalid: TypeError: function1() got an unexpected keyword argument 'param4'
  

개수의 이름 있는 인수 " " " "kwargs

• 「 」 、 「 」 、 「 。
  1. 위치 파라미터
  2. 임의 개수의 인수를 캡처하는 형식 매개 변수(* 포함)
  3. 명명된 형식 매개 변수
  4. 이름 있는 파라미터의 임의의 개수를 캡처하는 형식 파라미터(**로 표시)

• 예

  def function2(param1, *tupleParams, param2, param3, **dictionaryParams):
      print("param1: "+ param1)
      print("param2: "+ param2)
      print("param3: "+ param3)
      print("custom tuple params","-"*10)
      for p in tupleParams:
          print(str(p) + ",")
      print("custom named params","-"*10)
      for k,v in dictionaryParams.items():
          print(str(k)+":"+str(v))
  
  function2("arg1",
            "custom param1",
            "custom param2",
            "custom param3",
            param3="arg3",
            param2="arg2", 
            customNamedParam1 = "val1",
            customNamedParam2 = "val2"
            )
  
  # Output
  #
  #param1: arg1
  #param2: arg2
  #param3: arg3
  #custom tuple params ----------
  #custom param1,
  #custom param2,
  #custom param3,
  #custom named params ----------
  #customNamedParam2:val2
  #customNamedParam1:val1
  

사용자 지정 arg에 대한 튜플 및 딕트 변수 전달

마무리를 짓기 위해, 우리가 이 일을 끝낼 수 있다는 것도 알아두죠.

• "임의의 수의 인수를 캡처하는 형식 매개 변수"는 태플 변수로,
• dict 변수로 지정된 파라미터의 임의의 수를 캡처하는 형식 파라미터

따라서, 상기의 같은 콜을 다음과 같이 발신할 수 있습니다.

tupleCustomArgs = ("custom param1", "custom param2", "custom param3")
dictCustomNamedArgs = {"customNamedParam1":"val1", "customNamedParam2":"val2"}

function2("arg1",
      *tupleCustomArgs,    #note *
      param3="arg3",
      param2="arg2", 
      **dictCustomNamedArgs     #note **
      )

으로 메모합니다.* ★★★★★★★★★★★★★★★★★」**위의 함수 호출에 있습니다.그것들을 생략하면 나쁜 결과를 얻을 수 있다.

략략 *tuple arg:

function2("arg1",
      tupleCustomArgs,   #omitting *
      param3="arg3",
      param2="arg2", 
      **dictCustomNamedArgs
      )

인쇄하다

param1: arg1
param2: arg2
param3: arg3
custom tuple params ----------
('custom param1', 'custom param2', 'custom param3'),
custom named params ----------
customNamedParam2:val2
customNamedParam1:val1

태플 위 above('custom param1', 'custom param2', 'custom param3')그대로 인쇄됩니다.

략략 dict 예:

function2("arg1",
      *tupleCustomArgs,   
      param3="arg3",
      param2="arg2", 
      dictCustomNamedArgs   #omitting **
      )

주다

dictCustomNamedArgs
         ^
SyntaxError: non-keyword arg after keyword arg

또한 kwargs 함수를 호출할 때 다양한 사용 방법을 혼재시킬 수도 있습니다.

def test(**kwargs):
    print kwargs['a']
    print kwargs['b']
    print kwargs['c']


args = { 'b': 2, 'c': 3}

test( a=1, **args )

는 다음 출력을 나타냅니다.

1
2
3

**kwargs는 마지막 인수여야 합니다.

다음은 사용법을 설명하는 간단한 기능입니다.

def print_wrap(arg1, *args, **kwargs):
    print(arg1)
    print(args)
    print(kwargs)
    print(arg1, *args, **kwargs)

함수 정의에서 지정되지 않은 인수는 모두 에 저장됩니다.args 「」의kwargs키워드 인수인지 아닌지에 따라 리스트가 표시됩니다.

>>> print_wrap('one', 'two', 'three', end='blah', sep='--')
one
('two', 'three')
{'end': 'blah', 'sep': '--'}
one--two--threeblah

함수에 전달되지 않는 키워드 인수를 추가하면 오류가 발생합니다.

>>> print_wrap('blah', dead_arg='anything')
TypeError: 'dead_arg' is an invalid keyword argument for this function

kwargs는 이름 인수를 사전(func의 경우) 또는 이름 있는 인수(func의 경우)로 전달하기 위한 구문설탕입니다.

도움이 될 만한 예를 다음에 제시하겠습니다.

#! /usr/bin/env python
#
def g( **kwargs) :
  print ( "In g ready to print kwargs" )
  print kwargs
  print ( "in g, calling f")
  f ( **kwargs )
  print ( "In g, after returning from f")

def f( **kwargs ) :
  print ( "in f, printing kwargs")
  print ( kwargs )
  print ( "In f, after printing kwargs")


g( a="red", b=5, c="Nassau")

g( q="purple", w="W", c="Charlie", d=[4, 3, 6] )

프로그램을 실행하면 다음과 같은 이점이 있습니다.

$ python kwargs_demo.py 
In g ready to print kwargs
{'a': 'red', 'c': 'Nassau', 'b': 5}
in g, calling f
in f, printing kwargs
{'a': 'red', 'c': 'Nassau', 'b': 5}
In f, after printing kwargs
In g, after returning from f
In g ready to print kwargs
{'q': 'purple', 'c': 'Charlie', 'd': [4, 3, 6], 'w': 'W'}
in g, calling f
in f, printing kwargs
{'q': 'purple', 'c': 'Charlie', 'd': [4, 3, 6], 'w': 'W'}
In f, after printing kwargs
In g, after returning from f

여기서 중요한 점은 콜 내의 이름 있는 인수 변수 수가 함수의 딕셔너리로 변환된다는 것입니다.

키워드 인수는 Python에서 kwargs로 단축되는 경우가 많습니다.컴퓨터 프로그래밍에서는

키워드 인수는 함수 호출 내의 각 파라미터의 이름을 명확하게 나타내는 함수 호출에 대한 컴퓨터 언어의 지원을 의미합니다.

파라미터명 **kwargs 앞에 2개의 아스타리스크를 사용하는 것은 함수에 전달되는 키워드 인수의 수를 모르는 경우입니다.이 경우 임의 / 와일드카드 키워드 인수라고 합니다.

한 예로 장고의 수신기 기능을 들 수 있다.

def my_callback(sender, **kwargs):
    print("Request finished!")

이 함수는 와일드카드 키워드 인수(**kwargs)와 함께 sender 인수를 사용합니다.모든 신호 핸들러는 이러한 인수를 사용할 필요가 있습니다.모든 신호는 키워드 인수를 전송하며 언제든지 해당 키워드 인수를 변경할 수 있습니다.request_finished의 경우 인수를 송신하지 않는 것으로 문서화되어 있습니다.즉, 신호 처리를 my_callback(송신자)로 쓰고 싶은 충동이 생길 수 있습니다.

이것은 틀릴 수 있습니다.실제로 그렇게 하면 장고가 에러를 던집니다.그 이유는 어떤 시점에서든 인수가 신호에 추가될 수 있고 수신기가 이러한 새로운 인수를 처리할 수 있어야 하기 때문입니다.

kwargs라고 부를 필요는 없지만 ** (kwargs라는 이름은 규칙입니다)를 사용해야 합니다.

이것은 python 언팩에 대해 이해하기 위한 간단한 예시입니다.

>>> def f(*args, **kwargs):
...    print 'args', args, 'kwargs', kwargs

예 1:

>>>f(1, 2)
>>> args (1,2) kwargs {} #args return parameter without reference as a tuple
>>>f(a = 1, b = 2)
>>> args () kwargs {'a': 1, 'b': 2} #args is empty tuple and kwargs return parameter with reference as a dictionary

Java에서는 생성자를 사용하여 클래스를 오버로드하고 여러 입력 매개 변수를 허용합니다.python에서는 kwargs를 사용하여 유사한 동작을 제공할 수 있습니다.

java의 예:https://beginnersbook.com/2013/05/constructor-overloading/

python의 예:

class Robot():
    # name is an arg and color is a kwarg
    def __init__(self,name, color='red'):
        self.name = name
        self.color = color

red_robot = Robot('Bob')
blue_robot = Robot('Bob', color='blue')

print("I am a {color} robot named {name}.".format(color=red_robot.color, name=red_robot.name))
print("I am a {color} robot named {name}.".format(color=blue_robot.color, name=blue_robot.name))

>>> I am a red robot named Bob.
>>> I am a blue robot named Bob.

그냥 다른 방법으로 생각해봐요.

언급URL : https://stackoverflow.com/questions/1769403/what-is-the-purpose-and-use-of-kwargs