Uso degli asterischi in Python

La maggior parte di noi usa gli asterischi come operatori di moltiplicazione e potenza, ma in Python hanno anche un’ampia gamma di utilizzi come operatori di prefisso. Dopo aver letto questo articolo, conoscerai tutti gli usi degli asterischi.

Gli asterischi hanno molti casi d’uso particolari in Python. In generale, conosciamo gli operatori di moltiplicazione e potenza. Possono svolgere anche altre operazioni come unpacking, passaggio di argomenti, ecc., in situazioni diverse. Prima, vediamo l’uso generale degli asterischi.

Uso generale di * e **

* è usato come operatore di moltiplicazione, mentre ** è usato come operatore di potenza.

## declaring variables
a, b = 2,3

## multiplication
print("Multiplication of 2 and 3 is {}".format(a * b))

## as power operator
print("2 power 3 is {}".format(a ** b))

Multiplication of 2 and 3 is 6
2 power 3 is 8

Ora hai visto l’uso più comune degli asterischi. Ci sono però casi d’uso degli asterischi che potresti non conoscere. Passiamo a scoprire gli utilizzi nascosti degli asterischi.

1. Unpacking con *

Effettuare l’unpacking degli elementi da una list/tuple/set usando *. Useremo l’unpacking nel codice successivo per implementare altre funzionalità degli asterischi. L’unpacking è l’idea di base dietro l’uso degli asterischi come operatori di prefisso.

Supponiamo di voler assegnare il primo elemento della list/tuple/set ad a e gli elementi rimanenti a b. In generale, lo faremmo usando lo slicing.

## general approach
nums = [i for i in range(1, 6)]
a = nums[0]
b = nums[1:]
print(a, b)

print("--------------------------")

## hard approach
squares = [i ** 2 for i in range(1, 6)]
a = squares[0]
b = []
for i in range(1, len(squares)):
    b.append(squares[i])
print(a, b)

1 [2, 3, 4, 5]
--------------------------
1 [4, 9, 16, 25]

Ora useremo l’operatore * per implementare questo in una sola riga di codice.

nums = [i for i in range(1, 6)]

## a will be 1 and b will be a list containing remaining elements
a, *b = nums
print(a, b)

1 [2, 3, 4, 5]

Qui a è una variabile che prende il primo elemento dalla lista e b è una lista. L’unpacking funziona su tuple e set allo stesso modo che con le liste. Vediamo alcuni esempi.

## using tuple
## here first element will assign to a and last element to c
a, *b, c = (1, 2, 3, 4, 5)
print(a, b, c)

print("--------------------------")

## using sets
a, *b, c = {1, 4, 9, 16, 25}
print(a, b, c)

1 [2, 3, 4] 5
--------------------------
1 [4, 9, 16] 25

1.1. Combinare iterabili diversi

Possiamo aggiungere due iterabili diversi in liste/set/tuple usando l’unpacking. In generale, dovremmo convertire gli iterabili e combinarli in uno solo. Non è necessario però se usiamo *. Vediamo un esempio.

## combining a tuple, list, set
nums = [1, 2, 3]
nums2 = (4, 5, 6)
nums3 = {7, 8, 9}

## we convert the combined elements into any iterable we want
## here i am converting into a list
_list = [*nums, *nums2, *nums3]
_tuple = (*nums, *nums2, *nums3)
_set = {*nums, *nums2, *nums3}

print(type(_list))
print(_list)
print("------------------------")
print(type(_tuple))
print(_tuple)
print("------------------------")
print(type(_set))
print(_set)

<class 'list'>
[1, 2, 3, 4, 5, 6, 8, 9, 7]
------------------------
<class 'tuple'>
(1, 2, 3, 4, 5, 6, 8, 9, 7)
------------------------
<class 'set'>
{1, 2, 3, 4, 5, 6, 7, 8, 9}

1.2. Unpacking annidato

L’unpacking annidato consiste nell’estrarre gli elementi dal primo livello degli elementi già estratti. Guarda l’esempio per capire a cosa mi riferisco.

languages = ["Python", "HTML", "CSS", "JS"]

## unpacking
[[first_letter, *remaining], *other] = languages

print(first_letter, remaining, other)

P ['y', 't', 'h', 'o', 'n'] ['HTML', 'CSS', 'JS']

2. Unpacking con **

Come abbiamo visto prima, ** si usa per fare l’unpacking degli elementi da un dizionario. Dobbiamo conoscere le chiavi del dizionario per estrarre i valori durante l’unpacking. Vediamo un esempio.

## sample dictionary
person = {"name":"John", "age":19, "year_of_passing":"2021"}
string = "Name:-{name} Year Of Graduation:-{year_of_passing} Age:-{age}".format(**person)
print(string)

Name:-John Year Of Graduation:-2021 Age:-19

Non è comune usare ** per estrarre gli elementi da un dizionario.

3. Asterischi nelle funzioni

Possiamo passare e catturare gli argomenti usando gli asterischi nelle funzioni per ridurre le righe di codice.

3.1. Unpacking nelle funzioni

L’operatore * si usa per chiamare una funzione facendo l’unpacking di un iterabile. Diciamo che abbiamo una lista e dobbiamo passare tutti i suoi elementi alla funzione print() separatamente. Cosa faresti? Probabilmente stai pensando a un ciclo. Ma * ci semplifica molto la vita.

Passa semplicemente l’iterabile come *nome_iterabile. Fa l’unpacking dell’iterabile e passa tutti gli elementi separatamente.

nums = [i for i in range(1, 6)]
## passsing list using the *
print(*nums)

1 2 3 4 5

nums = (i for i in range(1, 6))
## passsing tuple using the *
print(*nums, sep = ", ")

1, 2, 3, 4, 5

3.2. Packing degli elementi

Packing significa catturare più elementi in una volta. Usiamo questa funzionalità nelle chiamate di funzione.

def average(*nums):
    return sum(nums) / len(nums)

Ora possiamo passare un numero qualsiasi di interi per calcolare la media. La funzione average cattura tutti gli argomenti come una lista.

## calling the average with some numbers
print(average(1, 2, 3, 4, 5))

3.0

Abbiamo visto come catturare più elementi in una lista usando *. Ora vedremo come catturare diverse coppie chiave-valore usando **.

def _object(name, **properties):
    print(name, properties)

_object("Car", color="Red", cost=999999, company="Ferrari")

Car {'ceo': 'Louis', 'color': 'Red', 'cost': 999999, 'company': 'Ferrari'}

4. Argomenti solo keyword con argomenti posizionali

Gli argomenti con nome si chiamano argomenti keyword. Gli altri argomenti si chiamano posizionali. Per prima cosa, devi capire la differenza tra argomenti keyword e posizionali. Vediamo un esempio.

## name is a positional argument
## color and cost are keyword arguments
def sample(car, color = None, cost = None):
    print("Car:-{} Color:-{}, Cost:-{}".format(car, color, cost))

Possiamo usare il nome del parametro per passare gli argomenti quando chiamiamo una funzione per gli argomenti keyword. Se non specifichiamo nulla per gli argomenti keyword, prenderanno il valore predefinito indicato nella definizione della funzione.

Possiamo specificare gli argomenti keyword usando le parole chiave o la posizione degli argomenti.

sample("Ferrari", "Red", 999999)

Car:-Ferrari Color:-Red, Cost:-999999

sample("Ferrari", cost = 999999, color = "Red")

Car:-Ferrari Color:-Red, Cost:-999999

L’ordine degli argomenti keyword non è importante se li passiamo usando i nomi definiti nella funzione.

sample("Ferrari", color = "Green")

Car:-Ferrari Color:-Green, Cost:-None

Ora hai un’idea degli argomenti posizionali e keyword. Entriamo nell’argomento principale.

Gli argomenti Keyword-Only si specificano solo tramite keyword. Non possiamo impostarli posizionalmente come visto prima. Dobbiamo dichiarare gli argomenti keyword dopo gli argomenti * per catturare quelli solo keyword.

def keyword_only(*items, _list, default = False):
    print(items)
    print(_list)
    print(default)

Dobbiamo usare le keyword _list e default quando chiamiamo la funzione, perché vengono dopo *items. Se non usiamo le keyword per chiamarli, otterremo un errore. Vediamo entrambi i casi.

nums = [i ** 2 for i in range(1, 6)]
## calling the function
keyword_only(1, 2, 3, 4, 5, _list = nums, default = True)

(1, 2, 3, 4, 5)
[1, 4, 9, 16, 25]
True

E se chiamassimo la funzione keyword_only usando argomenti posizionali.

nums = [i ** 2 for i in range(1, 6)]
## calling the function will raise an error
keyword_only(1, 2, 3, 4, 5, nums, False)

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-85-bf737d8a8bfc> in <module>()
      1 nums = [i ** 2 for i in range(1, 6)]
----> 2 keyword_only(1, 2, 3, 4, 5, nums, False)


TypeError: keyword_only() missing 1 required keyword-only argument: '_list'

Abbiamo un errore che indica che manca un argomento obbligatorio solo keyword. Quindi dobbiamo usare le keyword quando chiamiamo gli argomenti solo keyword. Gli argomenti Keyword-Only si definiscono solo dopo gli argomenti * nelle funzioni.

5. Argomenti solo keyword senza argomenti posizionali

Se vogliamo accettare solo argomenti solo keyword senza alcun argomento posizionale, Python ci permette di usare * nei parametri di funzione per ottenerlo. Vediamo un esempio.

def _sample(*, name):
    print(name)

La funzione sopra accetta solo argomenti solo keyword. Dobbiamo passare l’argomento con la relativa keyword. Altrimenti otterremo un errore. * nella definizione della funzione serve ad assicurare che la funzione accetti argomenti solo tramite le keyword. Qualsiasi parametro definiamo dopo il parametro * nella funzione deve essere specificato con le keyword durante la chiamata.

## calling the function using keyword 'name'
_sample(name = "Datacamp")

Datacamp

## calling the function without using keyword 'name'
## we will get a TypeError
_sample("Datacamp")

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-12-fe0d3718b56c> in <module>()
      1 ## calling the function without using keyword 'name'
      2 ## we will get a TypeError
----> 3 samp("Datacamp")


TypeError: samp() takes 0 positional arguments but 1 was given

È chiaro che la funzione _sample() accetta solo argomenti solo keyword*.

Conclusione

Gli sviluppatori aggiungono nuove funzionalità a ogni nuova versione di Python. Gli asterischi sono particolari e riducono alcune parti del codice. Non possiamo accettare più argomenti posizionali senza *, e anche gli argomenti solo keyword richiedono * per implementare questa funzionalità. Altre operazioni con gli asterischi possono essere ottenute con più righe di codice. Fai pratica per capirle a fondo. Grazie per la lettura!

Se vuoi saperne di più su Python, segui il corso Python Data Science Toolbox (Parte 1) di DataCamp.

Buon coding :)