Il est également intéressant de noter que vous pouvez utiliser * et ** lors de l'appel de fonctions. C'est un raccourci qui vous permet de passer plusieurs arguments à une fonction directement en utilisant une liste/tuple ou un dictionnaire. Par exemple, si vous avez la fonction suivante:

def foo(x,y,z):
    print("x=" + str(x))
    print("y=" + str(y))
    print("z=" + str(z))

vous pouvez faire des choses comme:

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

Remarque: Les touches mydict être nommé exactement comme les paramètres de la fonction foo . Sinon il lancera un 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'

le simple * signifie qu'il peut y avoir n'importe quel nombre d'arguments de position supplémentaires. foo() peut être invoqué comme foo(1,2,3,4,5) . Dans le corps de foo () param2 est une séquence contenant 2-5.

le double ** signifie qu'il peut y avoir n'importe quel nombre de paramètres nommés supplémentaires. bar() peut être invoqué comme bar(1, a=2, b=3) . Dans le corps de bar() param2 est un dictionnaire contenant {'a':2, 'b':3 }

avec le code suivant:

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)

la sortie est

1
(2, 3, 4, 5)
1
{'a': 2, 'b': 3}

Quoi ** (étoile double) et * (l'étoile) à faire pour les paramètres

ils permettent aux fonctions d'être défini pour accepter et pour utilisateurs de passer n'importe quel nombre d'arguments, de position ( * ) et de mot-clé ( ** ).

Définition Des Fonctions

*args permet un nombre quelconque d'options arguments de position (paramètres), qui seront assignés à un tuple nommé args .

**kwargs permet pour n'importe quel nombre d'arguments (paramètres) de mot-clé optionnel, qui sera dans un dict nommé kwargs .

vous pouvez (et devriez) choisir n'importe quel nom approprié, mais si l'intention est que les arguments soient de sémantique non-spécifique, args et kwargs sont des noms standard.

Expansion, Passer un certain nombre d'arguments

vous pouvez également utiliser *args et **kwargs pour passer dans les paramètres des listes (ou n'importe quel itérable) et dicts (ou n'importe quel mapping), respectivement.

la fonction recevant les paramètres n'a pas besoin de savoir qu'ils sont élargis.

par exemple, xrange de Python 2 n'attend pas explicitement *args , mais puisqu'il prend 3 entiers comme arguments:

>>> x = xrange(3) # create our *args - an iterable of 3 integers
>>> xrange(*x)    # expand here
xrange(0, 2, 2)

comme autre exemple, nous pouvons utiliser l'expansion de dict dans str.format :

>>> foo = 'FOO'
>>> bar = 'BAR'
>>> 'this is foo, {foo} and bar, {bar}'.format(**locals())
'this is foo, FOO and bar, BAR'

nouveau en Python 3: définition de fonctions avec des arguments mot-clé seulement

vous pouvez avoir arguments mot-clé seulement après le *args - par exemple, ici, kwarg2 doit être donné comme un argument mot-clé - pas positionnellement:

def foo(arg, kwarg=None, *args, kwarg2=None, **kwargs): 
    return arg, kwarg, args, kwarg2, kwargs

Utilisation:

>>> foo(1,2,3,4,5,kwarg2='kwarg2', bar='bar', baz='baz')
(1, 2, (3, 4, 5), 'kwarg2', {'bar': 'bar', 'baz': 'baz'})

aussi, * peut être utilisé par lui-même pour indiquer que le mot-clé seulement les arguments suivent, sans permettre des arguments de position illimités.

def foo(arg, kwarg=None, *, kwarg2=None, **kwargs): 
    return arg, kwarg, kwarg2, kwargs

ici, kwarg2 encore une fois doit être un argument de mot-clé explicitement nommé:

>>> foo(1,2,kwarg2='kwarg2', foo='foo', bar='bar')
(1, 2, 'kwarg2', {'foo': 'foo', 'bar': 'bar'})

et nous ne pouvons plus accepter les arguments de position illimités parce que nous n'avons pas *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

encore une fois, plus simplement, nous avons besoin kwarg à donner par nom, et non positionnellement:

def bar(*, kwarg=None): 
    return kwarg

dans cet exemple, nous voyons que si nous essayons de passer kwarg positionnellement, nous obtenons une erreur:

>>> bar('kwarg')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: bar() takes 0 positional arguments but 1 was given

nous devons explicitement passer le paramètre kwarg comme un argument de mot-clé.

>>> bar(kwarg='kwarg')
'kwarg'

Python 2 compatible demos

*args (typiquement dit" star-args") et **kwargs (les étoiles peuvent être impliquées par dire "kwargs", mais être explicite avec" double étoile kwargs") sont des idiomes courants de Python pour utiliser la notation * et ** . Ces noms de variables spécifiques ne sont pas nécessaires (par exemple, vous pouvez utiliser *foos et **bars ), mais une dérogation à la convention est susceptible d'enrager vos codeurs Python.

généralement, Nous utilisons lorsque nous ne savons pas ce que notre fonction va recevoir ou combien d'arguments on peut passer, et parfois même en nommant chaque variable séparément serait très confus et redondant (mais c'est un cas où généralement explicite est mieux qu'implicite).

exemple 1

la fonction suivante décrit comment ils peuvent être utilisés, et démontre le comportement. Remarque le nom b argument sera consommée par la deuxième position argument avant :

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

nous pouvons vérifier l'aide en ligne pour la signature de la fonction, avec help(foo) , qui nous dit

foo(a, b=10, *args, **kwargs)

appelons cette fonction avec foo(1, 2, 3, 4, e=5, f=6, g=7)

qui imprime:

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}

exemple 2

nous pouvons également l'appeler en utilisant une autre fonction, dans laquelle nous venons de fournir 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) gravures:

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}

exemple 3: usage pratique dans les décorateurs

OK, donc peut-être que nous ne voyons pas encore l'utilité. Alors imaginez que vous ayez plusieurs fonctions avec du code redondant avant et/ou après le code de différenciation. Les fonctions nommées ci-dessous ne sont que du pseudo-code à titre indicatif.

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

nous pourrions être en mesure de gérer cela différemment, mais nous pouvons certainement extraire la redondance avec un décorateur, et donc notre exemple ci-dessous montre comment *args et **kwargs peuvent être très utiles:

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

et maintenant chaque fonction enveloppée peut être écrite beaucoup plus succinctement, comme nous avons supprimé la redondance:

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

et en factorisant notre code, que *args et **kwargs nous permet de faire, nous réduisons les lignes de code, améliorer la lisibilité et la maintenabilité, et ont des emplacements canoniques uniques pour la logique dans notre programme. Si nous avons besoin de modifier une partie de cette structure, nous avons une place pour chaque changement.

commençons par comprendre ce que sont les arguments de position et les arguments de mots clés. Voici un exemple de définition de fonction avec des arguments de position .

def test(a,b,c):
     print(a)
     print(b)
     print(c)

test(1,2,3)
#output:
1
2
3

il s'agit donc d'une définition de fonction avec des arguments de position. Vous pouvez l'appeler avec des mots-clés/arguments nommés aussi bien:

def test(a,b,c):
     print(a)
     print(b)
     print(c)

test(a=1,b=2,c=3)
#output:
1
2
3

maintenant, étudions un exemple de définition de fonction avec mots clés arguments :

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

vous pouvez aussi appeler cette fonction avec des arguments de position:

def test(a=0,b=0,c=0):
    print(a)
    print(b)
    print(c)
    print('-------------------------')

test(1,2,3)
# output :
1
2
3
---------------------------------

ainsi nous connaissons maintenant des définitions de fonction avec des arguments de position aussi bien que des mots-clés.

étudions maintenant l'opérateur ' * 'et'**'.

veuillez noter que ces opérateurs peuvent être utilisés dans 2 zones:

a) appel de fonction

b) définition de la fonction

L'utilisation de '*' et '**' opérateur appel de fonction.

allons droit à un exemple et discutons-en.

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.

, Donc n'oubliez pas

lorsque l'opérateur " * " ou "* * "est utilisé dans un appel de fonction 151990920" -

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