Que signifient *args et **kwargs ?

Question

Que font exactement *args y **kwargs C'est-à-dire ?

D'après la documentation de Python, il semble qu'il passe dans un tuple d'arguments.

def foo(hello, *args):
    print hello

    for each in args:
        print each

if __name__ == '__main__':
    foo("LOVE", ["lol", "lololol"])

Cela s'imprime :

LOVE
['lol', 'lololol']

Comment les utiliser efficacement ?

Answer 1

Mettez *args et/ou **kwargs comme derniers éléments de la liste d'arguments de votre définition de fonction permet à cette fonction d'accepter un nombre arbitraire d'arguments et/ou de mots-clés.

Par exemple, si vous voulez écrire une fonction qui renvoie la somme de tous ses arguments, quel que soit le nombre que vous fournissez, vous pouvez l'écrire comme suit :

def my_sum(*args):
    return sum(args)

Elle est probablement plus couramment utilisée dans la programmation orientée objet, lorsque vous remplacez une fonction et que vous souhaitez appeler la fonction originale avec les arguments que l'utilisateur lui fournit.

Vous n'avez pas besoin de les appeler args y kwargs c'est juste une convention. C'est le * y ** qui font la magie.

La documentation officielle de Python contient un regard plus approfondi .

Answer 2

Nous les utilisons également pour gérer les héritages.

class Super( object ):
   def __init__( self, this, that ):
       self.this = this
       self.that = that

class Sub( Super ):
   def __init__( self, myStuff, *args, **kw ):
       super( Sub, self ).__init__( *args, **kw )
       self.myStuff= myStuff

x= Super( 2.7, 3.1 )
y= Sub( "green", 7, 6 )

De cette façon, Sub ne sait pas vraiment (ou ne se soucie pas) de l'initialisation de la superclasse. Si vous vous rendez compte que vous devez modifier la superclasse, vous pouvez corriger les choses sans avoir à vous soucier des détails dans chaque sous-classe.

Answer 3

Remarquez le truc cool dans Commentaire de S.Lott - vous pouvez également appeler des fonctions avec *mylist y **mydict pour décompresser les arguments positionnels et les mots-clés :

def foo(a, b, c, d):
  print a, b, c, d

l = [0, 1]
d = {"d":3, "c":2}

foo(*l, **d)

Sera imprimé : 0 1 2 3

Answer 4

Une autre bonne utilisation de *args y **kwargs La fonction "catch all" : vous pouvez définir des fonctions génériques "catch all", ce qui est idéal pour les décorateurs où vous retournez un tel wrapper au lieu de la fonction originale.

Un exemple avec un décorateur de mise en cache trivial :

import pickle, functools
def cache(f):
  _cache = {}
  def wrapper(*args, **kwargs):
    key = pickle.dumps((args, kwargs))
    if key not in _cache:
      _cache[key] = f(*args, **kwargs) # call the wrapped function, save in cache
    return _cache[key] # read value from cache
  functools.update_wrapper(wrapper, f) # update wrapper's metadata
  return wrapper

import time
@cache
def foo(n):
  time.sleep(2)
  return n*2

foo(10) # first call with parameter 10, sleeps
foo(10) # returns immediately

Answer 5

Juste pour clarifier comment déballer les arguments, et prendre soin des arguments manquants, etc.

def func(**keyword_args):
  #-->keyword_args is a dictionary
  print 'func:'
  print keyword_args
  if keyword_args.has_key('b'): print keyword_args['b']
  if keyword_args.has_key('c'): print keyword_args['c']

def func2(*positional_args):
  #-->positional_args is a tuple
  print 'func2:'
  print positional_args
  if len(positional_args) > 1:
    print positional_args[1]

def func3(*positional_args, **keyword_args):
  #It is an error to switch the order ie. def func3(**keyword_args, *positional_args):
  print 'func3:'
  print positional_args
  print keyword_args

func(a='apple',b='banana')
func(c='candle')
func2('apple','banana')#It is an error to do func2(a='apple',b='banana')
func3('apple','banana',a='apple',b='banana')
func3('apple',b='banana')#It is an error to do func3(b='banana','apple')