Cosa significano * args e ** kwargs?

Question

Che cosa significano esattamente *args e **kwargs?

Secondo la documentazione Python, da quello che sembra, passa in una tupla di argomenti.

def foo(hello, *args): 
    print hello 

    for each in args: 
     print each 

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

Questo stampa:

LOVE 
['lol', 'lololol'] 

Come si fa a utilizzare in modo efficace?

Answer 1

Inserire *args e/o **kwargs come ultimo elemento nell'elenco di argomenti della definizione della funzione consente a tale funzione di accettare un numero arbitrario di argomenti e/o argomenti di parole chiave.

Ad esempio, se si voleva scrivere una funzione che ha restituito la somma di tutti i suoi argomenti, non importa quanti si fornisce, si potrebbe scrivere in questo modo:

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

è probabilmente più comunemente usato in programmazione orientata agli oggetti, quando si sta sovrascrivendo una funzione, e si vuole chiamare la funzione originale con qualsiasi argomento l'utente passa.

in realtà non è necessario chiamarli args e kwargs, questo è solo una convenzione. È lo * e lo ** a fare la magia.

La documentazione ufficiale di Python ha a more in-depth look.

Answer 2

Inoltre, li usiamo per gestire l'ereditarietà.

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) 

In questo modo Sub non sa (o cura) cosa sia l'inizializzazione della superclasse. Se ti rendi conto che devi cambiare la superclasse, puoi aggiustare le cose senza dover sudare i dettagli in ogni sottoclasse.

Answer 3

Avviso la cosa più cool in S.Lott's comment - si può anche richiamare le funzioni con *mylist e **mydict di disfare argomenti posizionali e parole chiave:

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

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

foo(*l, **d) 

stamperà: 0 1 2 3

Answer 4

Un altro buon uso per *args e **kwargs: è possibile definire generiche funzioni "catch all", il che è ottimo per i decoratori in cui si restituisce tale wrapper anziché la funzione originale.

Un esempio con una banale caching decoratore:

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

solo per chiarire come disimballare gli argomenti, e prendersi cura di argomenti mancanti ecc

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

Answer 6

Date un'occhiata a questo http://agiliq.com/blog/2012/06/understanding-args-and-kwargs/

È proprio quello che volevi, immagino