Cosa significa * e ** in Python? Ha a che fare con puntatori e indirizzi?

Ci sono diversi usi di * e ** :

• * è l'operatore di moltiplicazione (o nel caso delle stringhe un operatore di ripetizione). Classi in altre librerie possono usare '*' per altre ragioni, ma quasi sempre si tratta di moltiplicazione in qualche forma.
• ** è un operatore esponenziale tale che nei numeri normali x ** y è il metodo matematico per calcolare [math]x^y[/math]

Ma questi sono gli usi non sorprendenti - quelli che ogni sviluppatore potrebbe ben conoscere; ma penso che la domanda abbia quasi certamente a che fare con i luoghi comunemente visti, ma meno attesi (almeno per il principiante) :

Gli argomenti variabili nelle funzioni

Gli operatori * e ** appaiono nelle definizioni delle funzioni - per esempio :

1. def func(*args, **kwargs): 
2. print(args, kwargs) 

To understand what they do, you need to know about positional and keyword arguments.

keyword arguments to a function are the easiest to explain, in that any argument that is passed to a function in the form = is a keyword argument. Ne consegue che gli argomenti posizionali sono tutti gli argomenti di una chiamata di funzione che non sono argomenti di parole chiave.

Tornando quindi alla nostra definizione di funzione (come quella sopra) *args è un'istruzione per raccogliere tutti gli argomenti posizionali in una singola tupla (chiamata args), e **kwargs è un'istruzione per raccogliere tutti gli argomenti di parole chiave in un singolo dizionario chiamato kwargs. The names args and kwargs are a common convention - you can call them anything you want.

an example of calling this function is:

1. >>> func(1,2,3,a=4,b=5,c=6) 
2. (1, 2, 3) {'a':4, 'b':5, 'c':6} 

Come potete vedere gli argomenti 1, 2 & 3 sono raccolti nella tupla chiamata args, e gli argomenti parola chiave a, b & c sono raccolti nel dizionario chiamato kwargs.

Potete anche mischiare *args e **kwargs insieme ai normali argomenti posizionali e parola chiave :

1. def func2(a,b, *args, c=None, d=None, **kwargs): 
2. print( a,b, args) 
3. print( 'c=',c, 'd=', d, kwargs) 

Here the first two positional arguments are passed to a & b respectively - and any remaining positional arguments are packed into the args tuple.
Anche gli argomenti delle parole chiave c & d sono catturati normalmente (con i default se non forniti), e ogni altro argomento di parola chiave è impacchettato nel dizionario kwargs.

For example :

1. >>> func2(1, 2, 3, 4, c=6, d=7, e=8, f=9) 
2. 1 2 (3, 4) 
3. c= 6 d= 7 {'e':8, 'f':9} 

In all cases args and kwargs (or whatever you have called them) can be empty - for example - using the func2 function as above :

1. >>> func2(1, 2, c=6, d=7) 
2. 1 2 () 
3. c= 6 d= 7 {} 

In questa chiamata, ci sono solo due argomenti posizionali, e sono catturati nei parametri a & b, quindi non ce ne sono da mettere nella tupla args. Allo stesso modo ci sono solo due argomenti di parole chiave (c & d), quindi non ci sono altri argomenti di parole chiave da impacchettare nel dizionario kwargs.

Stampare

Così come potete usare gli operatori * e ** in una definizione di funzione per impacchettare gli argomenti della funzione in una tupla o in un dizionario (come sopra), potete anche usarli per scompattare una tupla o un dizionario negli argomenti della funzione. Per esempio con questa funzione:

1. def func3( a, b): 
2. print(a, b) 

This function expects two positional arguments - and if you already have those two arguments in a tuple you can do one of two things :

1. >>> t0 = (0,1) 
2. >>> func3(t0[0],t0[1]) 
3. 0 1 
4. >>> func3( *t0 ) 
5. 0 1 

Here the * operator is unpacking the tuple into positional arguments. Although the two are functionally equivalent, the method with the * operator is around 60% of the execution time of the other version and is more readable (less likely to get wrong too).

Similarly a dictionary can be unpacked into keyword arguments - taking this function which accepts keyword arguments :

1. def func4(kw1=0, kw2 = 1): 
2. print(kw1, kw2} 

If you have a dictionary that contains the values you need, you again have two options :

1. >>> d0 = {'kw1':10, 'kw2':11} 
2. >>> func4(kw1=d0['kw1'], kw2=d0['kw2']) 
3. 10 11 
4. >>> func4(**d0) 
5. 10 11 

The second option - with dictionary unpacking is simpler to read, less likely to get wrong, and around 70% quicker.