** kwargs의 목적과 사용은 무엇입니까?

** kwargs의 목적과 사용은 무엇입니까?

---

**kwargs파이썬 에서 용도는 무엇입니까 ?

나는 당신 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 3을 사용하는 사람들은 iteritems () 대신 items ()를 사용하십시오.

---

사전 압축 풀기

** 사전의 압축을 풉니 다.

이

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)

함수의 패키징 매개 변수

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입니다. 좋아, 이것이 방법입니다.

무엇을위한 것은 그렇게 간단하지 않습니다.

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

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

이제 새로운 방법 인 "drive"를 얻습니다.

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

하지만 잠깐만 요. "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가 도움이 될 수있는 좋은 예입니다.

---

좋은 샘플이 때때로 긴 담론보다 낫다는 것을 바탕으로 모든 파이썬 변수 인수 전달 기능 (위치 및 명명 된 인수 모두)을 사용하여 두 개의 함수를 작성합니다. 직접 수행하는 작업을 쉽게 볼 수 있어야합니다.

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

이제 *args위에 정의 된 함수를 호출하는 데 사용 합니다.

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

결과:

arg1 : 두 개의
arg2 : 3
arg3 : 5

---

이제 **kwargs같은 함수를 호출하는 데 사용

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

결과:

arg1 : 5
arg2 : 두 개의
arg3 : 3

요점 : *args지능이 없으며 전달 된 인수를 매개 변수 (왼쪽에서 오른쪽 순서로)에 단순히 보간 **kwargs하고 필요한 위치에 적절한 값을 배치하여 지능적으로 작동합니다.

---

• kwargsin **kwargs은 변수 이름입니다. 당신은 아주 잘 가질 수 있습니다**anyVariableName
• kwargs"키워드 인수"를 의미합니다. 그러나 나는 그것들이 단순히 이름과 함께 전달되는 인수이기 때문에 "명명 된 인수"라고 부르는 것이 더 낫다고 생각합니다 ( "키워드 인수"라는 용어에서 "키워드"라는 단어는 의미가 없습니다. "키워드"는 일반적으로 프로그래밍 언어에 의해 예약 된 단어이므로 프로그래머가 변수 이름으로 사용하지 않습니다. kwargs의 경우에는 그런 일이 일어나지 않습니다.). 따라서 값만 전달하는 대신 다음과 같이 함수에 전달 된 두 개의 매개 변수 값 param1과 이름을 제공합니다 .. 따라서 이러한 매개 변수를 얼마 든지 지정할 수 있으므로 "임의의 명명 된 인수" 라고 적절하게 호출해야한다고 생각합니다 (즉,param2func(param1="val1",param2="val2")func(val1,val2)funcfunc(**kwargs)

그래서 먼저 "명명 된 인자"를 설명하고 "명명 된 인자의 임의의 수"를 설명하겠습니다 kwargs.

명명 된 인수

• 명명 된 인수는 위치 인수를 따라야합니다.
• 명명 된 인수의 순서는 중요하지 않습니다.

• 예

  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
  

사용자 지정 인수에 대한 튜플 및 dict 변수 전달

끝내기 위해 우리가 통과 할 수 있다는 것을

• 튜플 변수로 "임의의 인수를 캡처하는 형식 매개 변수"및
• dict 변수로 "임의의 명명 된 매개 변수를 캡처하는 형식 매개 변수"

따라서 위와 동일한 호출을 다음과 같이 만들 수 있습니다.

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

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

Finally note * and ** in function calls above. If we omit them, we may get ill results.

Omitting * in tuple args:

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

prints

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

Above tuple ('custom param1', 'custom param2', 'custom param3') is printed as is.

Omitting dict args:

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

gives

dictCustomNamedArgs
         ^
SyntaxError: non-keyword arg after keyword arg

---

As an addition, you can also mix different ways of usage when calling kwargs functions:

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


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

test( a=1, **args )

gives this output:

1
2
3

Note that **kwargs has to be the last argument

---

kwargs are a syntactic sugar to pass name arguments as dictionaries(for func), or dictionaries as named arguments(to func)

---

Here's a simple function that serves to explain the usage:

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

Any arguments that are not specified in the function definition will be put in the args list, or the kwargs list, depending on whether they are keyword arguments or not:

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

If you add a keyword argument that never gets passed to a function, an error will be raised:

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

---

Here is an example that I hope is helpful:

#! /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] )

When you run the program, you get:

$ 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

The key take away here is that the variable number of named arguments in the call translate into a dictionary in the function.

---

This is the simple example to understand about python unpacking,

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

eg1:

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

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