*args и **kwargs

Введение

Примеры

  • 6

    Использование * args при написании функций

    Вы можете использовать звездочку * при написании функции, чтобы собрать все позиционные (т.е. безымянные) аргументы в кортеже:

     def print_args(farg, *args):
       print("formal arg: %s" % farg)
       for arg in args:
           print("another positional arg: %s" % arg)
    
     

    Метод вызова:

     print_args(1, "two", 3)
    
     

    В этом вызове farg будет назначен как всегда, а два других будут переданы в кортеж args в порядке их получения.

  • 9

    Использование ** kwargs при написании функций

    Вы можете определить функцию , которая принимает произвольное количество ключевых слов (называемые) аргументов, используя двойную звезду ** перед именем параметра:

     def print_kwargs(**kwargs):
        print(kwargs)
    
     

    При вызове метода Python создаст словарь всех аргументов ключевого слова и сделает его доступным в теле функции:

     print_kwargs(a="two", b=3)
    # prints: "{a: "two", b=3}"
    
     

    Обратите внимание, что параметр ** kwargs в определении функции всегда должен быть последним параметром, и он будет соответствовать только аргументам, переданным после предыдущих.

     def example(a, **kw):
        print kw
    
    example(a=2, b=3, c=4) # => {'b': 3, 'c': 4}
    
     

    Внутри тела функции, kwargs манипулируют таким же образом , как словарь; для того , чтобы получить доступ к отдельным элементам в kwargs вы просто цикл через них , как вы бы с нормальным словарем:

     def print_kwargs(**kwargs):
        for key in kwargs:
            print("key = {0}, value = {1}".format(key, kwargs[key])) 
    
     

    Теперь, вызывая print_kwargs(a="two", b=1) показывает следующий вывод:

     print_kwargs(a = "two", b = 1)
    key = a, value = "two"
    key = b, value = 1 
  • -3

    Использование * args при вызове функций

    Общий случай использования *args в определении функции является делегирование обработки либо обернутой или унаследованной функции. Типичный пример может быть в классе по __init__ методы

     class A(object):
        def __init__(self, b, c):
            self.y = b
            self.z = c
    
    class B(A):
        def __init__(self, a, *args, **kwargs):
            super(B, self).__init__(*args, **kwargs)
            self.x = a
    
     

    Здесь параметр обрабатывается дочерний класс после того, как все другие аргументы (позиционные и ключевые слова) передаются на - и обрабатываются - базового класса. a

    Например:

     b = B(1, 2, 3)
    b.x  # 1
    b.y  # 2
    b.z  # 3
    
     

    То , что происходит здесь , класс B __init__ функция видит аргументы 1, 2, 3 . Он знает , что необходимо принимать один позиционный аргумент ( a ), так что она захватывает первый аргумент , передаваемый в ( 1 ), так что в области действия функции a == 1 .

    Далее, он видит , что она должна принять произвольное число позиционных аргументов ( *args ) поэтому она занимает остальную часть позиционных аргументов , передаваемых в ( 1, 2 ) и набивает их в *args . Теперь (в области видимости функции) args == [2, 3] .

    Затем он называет класс «s A __init__ функция *args . Python видит * перед арг и «распаковывает» список в аргументах. В этом примере, когда класс B 's __init__ вызовов функций класса A ' s __init__ функцию, оно будет передано аргументы 2, 3 (т.е. A(2, 3) ).

    Наконец, он устанавливает свое собственное x свойство первого позиционного аргумент a , который равен 1 .

  • 1

    Использование ** kwargs при вызове функций

    Вы можете использовать словарь для присвоения значений параметрам функции; используя имя параметра в качестве ключей в словаре и значение этих аргументов, привязанных к каждому ключу:

     def test_func(arg1, arg2, arg3): # Usual function with three arguments
       print("arg1: %s" % arg1)
       print("arg2: %s" % arg2)
       print("arg3: %s" % arg3)
    
    # Note that dictionaries are unordered, so we can switch arg2 and arg3. Only the names matter.
    kwargs = {"arg3": 3, "arg2": "two"}
    
    # Bind the first argument (ie. arg1) to 1, and use the kwargs dictionary to bind the others
    test_var_args_call(1, **kwargs)  
  • 0

    Использование * args при вызове функций

    Эффект использования * оператора на аргумент при вызове функции является то , что распаковывать списка или кортежа аргумент

     def print_args(arg1, arg2):
        print(str(arg1) + str(arg2))
    
    a = [1,2]
    b = tuple([3,4])
    
    print_args(*a)
    # 12
    print_args(*b)
    # 34
    
     

    Обратите внимание, что длина помеченного аргумента должна быть равна числу аргументов функции.

    Обычный Python идиомы является использование оператора распаковки * с zip функции ликвидировать ее последствия:

     a = [1,3,5,7,9]
    b = [2,4,6,8,10]
    
    zipped = zip(a,b)
    # [(1,2), (3,4), (5,6), (7,8), (9,10)]
    
    zip(*zipped)
    # (1,3,5,7,9), (2,4,6,8,10) 
  • 1

    Только ключевые слова и ключевые слова обязательные аргументы

    Python 3 позволяет вам определять аргументы функции, которые могут быть назначены только по ключевому слову, даже без значений по умолчанию. Это делается с помощью звезды , чтобы потреблять дополнительные позиционные параметры без установки параметров ключевых слов. Все аргументы после того , как это ключевое слово-только (т.е. не позиционные) аргументы. Обратите внимание, что если для аргументов только для ключевых слов не задано значение по умолчанию, они все равно необходимы при вызове функции.

     def print_args(arg1, *args, keyword_required, keyword_only=True):
        print("first positional arg: {}".format(arg1))
        for arg in args:
            print("another positional arg: {}".format(arg))
        print("keyword_required value: {}".format(keyword_required))
        print("keyword_only value: {}".format(keyword_only))
    
    print(1, 2, 3, 4) # TypeError: print_args() missing 1 required keyword-only argument: 'keyword_required'
    print(1, 2, 3, keyword_required=4) 
    # first positional arg: 1
    # another positional arg: 2
    # another positional arg: 3
    # keyword_required value: 4
    # keyword_only value: True 
  • 4

    Заполнение значений kwarg словарем

     def foobar(foo=None, bar=None):
        return "{}{}".format(foo, bar)
    
    values = {"foo": "foo", "bar": "bar"}
    
    foobar(**values) # "foobar" 
  • 0

    ** kwargs и значения по умолчанию

    Использовать значения по умолчанию с ** kwargs

     def fun(**kwargs):
        print kwargs.get('value', 0)
    
    fun()
    # print 0
    fun(value=1)
    # print 1 

Синтаксис

Параметры

Примечания