[PYTHON] 일반 인수 대 키워드 인수

일반 인수 대 키워드 인수

"키워드 인수"는 정규 인수와 어떻게 다른가요? 위치 구문을 사용하는 대신 모든 인수를 name = value로 전달할 수 있습니까?

해결법

1. ==============================

   1.둘 다 관련된 개념, 둘 다 "키워드 인수"가 있습니다.

   둘 다 관련된 개념, 둘 다 "키워드 인수"가 있습니다.

   호출자 측에서는 다른 주석가들이 언급 한 바와 같이 함수 인자를 이름으로 지정할 수 있습니다. 이름 (위치 인수)없이 모든 인수 뒤에 언급해야하며 언급되지 않은 매개 변수에 대한 기본값이 있어야합니다.

   다른 개념은 함수 정의 측면입니다. 매개 변수를 이름으로 사용하는 함수를 정의 할 수 있으며 그 이름을 지정하지 않아도됩니다. 이것들은 순수한 키워드 인수이며, 위치 적으로 전달 될 수는 없습니다. 구문은 다음과 같습니다.

   def my_function(arg1, arg2, **kwargs)
   

   이 함수에 전달한 키워드 인수는 kwargs라는 사전에 저장됩니다. 다음과 같이이 사전의 키를 런타임에 검사 할 수 있습니다.

   def my_function(**kwargs):
       print str(kwargs)
   
   my_function(a=12, b="abc")
   
   {'a': 12, 'b': 'abc'}
   

2. ==============================

   2.구별이 중요한 마지막 언어 기능이 하나 있습니다. 다음 기능을 고려하십시오.

   구별이 중요한 마지막 언어 기능이 하나 있습니다. 다음 기능을 고려하십시오.

   def foo(*positional, **keywords):
       print "Positional:", positional
       print "Keywords:", keywords
   

   * 위치 인수는 foo ()에 전달 된 모든 위치 인수를 저장하며 제공 할 수있는 수에 제한이 없습니다.

   >>> foo('one', 'two', 'three')
   Positional: ('one', 'two', 'three')
   Keywords: {}
   

   ** keywords 인수는 모든 키워드 인수를 저장합니다.

   >>> foo(a='one', b='two', c='three')
   Positional: ()
   Keywords: {'a': 'one', 'c': 'three', 'b': 'two'}
   

   물론 두 가지를 동시에 사용할 수 있습니다.

   >>> foo('one','two',c='three',d='four')
   Positional: ('one', 'two')
   Keywords: {'c': 'three', 'd': 'four'}
   

   이러한 기능은 거의 사용되지 않지만 때로는 매우 유용하며 어떤 인수가 위치 또는 키워드인지 파악하는 것이 중요합니다.

3. ==============================

   3.키워드 인수를 사용하는 것은 순서가 중요하지 않다는 것을 제외하고는 일반적인 인수와 동일한 것입니다. 예를 들어 아래 두 함수 호출은 동일합니다.

   키워드 인수를 사용하는 것은 순서가 중요하지 않다는 것을 제외하고는 일반적인 인수와 동일한 것입니다. 예를 들어 아래 두 함수 호출은 동일합니다.

   def foo(bar, baz):
       pass
   
   foo(1, 2)
   foo(baz=2, bar=1)
   

4. ==============================

   4.그들 앞에는 키워드가 없습니다. 순서가 중요합니다!

   그들 앞에는 키워드가 없습니다. 순서가 중요합니다!

   func(1,2,3, "foo")
   

   그들 앞에는 키워드가 있습니다. 그들은 어떤 순서로도 될 수 있습니다!

   func(foo="bar", baz=5, hello=123)
   
   func(baz=5, foo="bar", hello=123)
   

   기본 인수를 사용하고 키워드 삽입을 방치하면 순서가 중요하다는 것도 알아야합니다!

   def func(foo=1, baz=2, hello=3): ...
   func("bar", 5, 123)
   

5. ==============================

   5.함수 매개 변수에 인수 값을 할당하는 두 가지 방법이 있으며 둘 다 사용됩니다.

   함수 매개 변수에 인수 값을 할당하는 두 가지 방법이 있으며 둘 다 사용됩니다.

   위치 인수를 사용할 수 있습니다.

   위치 인수를 사용하지 않으면, 쓴 모든 것은 키워드 인수로 판명됩니다.

   함수를 호출 할 때 위치 또는 키워드 또는 혼합을 사용하기로 결정합니다. 원하는 경우 모든 키워드를 수행하도록 선택할 수 있습니다. 우리 중 일부는이 선택을하지 않고 위치 적 논증을 사용합니다.

6. ==============================

   6.저는 아무도 공식화 된 매개 변수를 만족시키는 키잉 된 인수 매개 변수의 사전을 전달할 수 있다고 지적한 적이없는 것 같습니다.

   저는 아무도 공식화 된 매개 변수를 만족시키는 키잉 된 인수 매개 변수의 사전을 전달할 수 있다고 지적한 적이없는 것 같습니다.

   >>> def func(a='a', b='b', c='c', **kwargs):
   ...    print 'a:%s, b:%s, c:%s' % (a, b, c)
   ... 
   >>> func()
   a:a, b:b, c:c
   >>> func(**{'a' : 'z', 'b':'q', 'c':'v'})
   a:z, b:q, c:v
   >>> 
   

7. ==============================

   7.Python 3을 사용하면 필수 및 필수 키워드 매개 변수를 둘 다 가질 수 있습니다.

   Python 3을 사용하면 필수 및 필수 키워드 매개 변수를 둘 다 가질 수 있습니다.

   선택 사항 : ( 'b'에 대해 정의 된 기본값)

   def func1(a, *, b=42):
       ...
   func1(value_for_a) # b is optional and will default to 42
   

   필수 ( 'b'에 대해 정의 된 기본값 없음) :

   def func2(a, *, b):
       ... 
   func2(value_for_a, b=21) # b is set to 21 by the function call
   func2(value_for_a) # ERROR: missing 1 required keyword-only argument: 'b'`
   

   이렇게하면 같은 유형의 여러 비슷한 인수가있는 경우에 유용 할 수 있습니다.이 경우 이름이 지정된 인수를 사용하는 것이 더 좋으며 인수가 함께 있으면 사용자 정의 클래스를 만들 수도 있습니다.

8. ==============================

   8.아무도 당신이 * args 및 ** kwargs (이 사이트에서)를 사용하여 이런 비열한 일을하기 위해 위치 및 키워드 인수를 혼합 할 수 있다는 사실을 언급 한 사람은 놀랍습니다.

   아무도 당신이 * args 및 ** kwargs (이 사이트에서)를 사용하여 이런 비열한 일을하기 위해 위치 및 키워드 인수를 혼합 할 수 있다는 사실을 언급 한 사람은 놀랍습니다.

   def test_var_kwargs(farg, **kwargs):
       print "formal arg:", farg
       for key in kwargs:
           print "another keyword arg: %s: %s" % (key, kwargs[key])
   

   이것은 선행을 정의하고 싶지 않은 키를 가지고있는 임의의 키워드 인수를 사용할 수있게합니다.

9. ==============================

   9.타입 어노테이션을 사용하여 기본 kwargs를 가진 예제를 찾고있었습니다.

   타입 어노테이션을 사용하여 기본 kwargs를 가진 예제를 찾고있었습니다.

   def test_var_kwarg(a: str, b: str='B', c: str='', **kwargs) -> str:
        return ' '.join([a, b, c, str(kwargs)])
   

   예:

   >>> print(test_var_kwarg('A', c='okay'))
   A B okay {}
   >>> d = {'f': 'F', 'g': 'G'}
   >>> print(test_var_kwarg('a', c='c', b='b', **d))
   a b c {'f': 'F', 'g': 'G'}
   >>> print(test_var_kwarg('a', 'b', 'c'))
   a b c {}
   

from https://stackoverflow.com/questions/1419046/normal-arguments-vs-keyword-arguments by cc-by-sa and MIT license