30 trucchi Python fantastici per un codice migliore con esempi

Le competenze di programmazione in Python sono sempre più richieste negli ultimi anni. Per aiutarti a svilupparle, abbiamo selezionato 30 trucchi Python che puoi usare per migliorare il tuo codice. Prova a impararne uno al giorno per i prossimi 30 giorni e dai un'occhiata al nostro post sulle migliori pratiche Python per assicurarti che il tuo codice sia al top. 

Se le tue competenze in Python non sono ancora solide, puoi affinarle anche con il nostro percorso Python Programming.

Trucchi su sequenze e strutture dati

#1 Slicing

a = "Hello World!"
print(a[::-1])

"""
!dlroW olleH
"""

Lo slicing è una funzionalità di Python che si basa sull'indicizzazione per consentire di accedere a un sottoinsieme di una sequenza. Un indice è semplicemente la posizione di un elemento in una sequenza. Se il tipo di sequenza è mutabile, puoi usare lo slicing per estrarre e modificare i dati. 

Nota: Possiamo usare lo slicing anche su una sequenza immutabile, ma provare a modificare lo slice genererà un TypeError. 

Il formato con cui si implementano gli slice è: sequence[start:stop:step]. Se non vengono specificati valori per i parametri start, stop e step, la sequenza userà i default. I valori predefiniti sono: 

• "start" vale 0 per impostazione predefinita 
• "stop" vale la lunghezza della sequenza
• "step" vale 1 se non specificato. 

Con sequence[start:stop] gli elementi restituiti vanno dall’indice di partenza fino a stop - 1 (l’indice stop non è incluso). 

Possiamo anche passare indici negativi, utili per invertire la sequenza. Per esempio, in una lista di 4 elementi, l’indice 0 è anche l’indice -4, e l’ultimo indice è anche -1. Nell’esempio sopra, questa logica è stata applicata al parametro step della sequenza. Di conseguenza, la stringa è stata stampata al contrario, partendo dalla fine della sequenza fino all’indice 0.   

#2 Scambio in place / assegnazione simultanea

a = 10
b = 5
print(f"First: {a, b}")

"""
First: (10, 5)
"""

a, b = b, a + 2
print(f"Second: {a, b}")

"""
Second: (5, 12)
"""

Se la tua prima impressione era che il valore di b sarebbe stato 7 invece di 12, sei caduto nella trappola dello scambio in place. 

In Python, possiamo decomprimere gli iterabili in variabili in un’unica assegnazione usando l’unpacking automatico. Per esempio: 

a, b, c = [1, 2, 3]
print(a)
print(b)
print(c)

"""
1
2
3
"""

Possiamo anche raccogliere più valori in un’unica variabile usando * – questo trucco Python si chiama packing. Ecco un esempio di packing.  

a, *b = 1, 2, 3
print(a, b)
"""
1 [2, 3]
"""

Combinare packing e unpacking automatici dà origine a una tecnica nota come assegnazione simultanea. Possiamo usarla per assegnare una serie di valori a una serie di variabili.

#3 Liste vs. tuple 

import sys

a = [1, 2, 3, 4, 5]
b = (1, 2, 3, 4, 5)

print(f"List size: {sys.getsizeof(a)} bytes")
print(f"Tuple size: {sys.getsizeof(b)} bytes")

"""
List size: 52 bytes
Tuple size: 40 bytes
"""

La maggior parte dei programmatori Python conosce la struttura dati lista. Lo stesso non si può dire delle tuple. Entrambe sono iterabili, consentono l’indicizzazione e permettono di memorizzare tipi eterogenei. Ma ci sono situazioni in cui può essere preferibile usare una tupla rispetto a una lista. 

Innanzitutto, le liste sono mutabili, il che significa che possiamo modificarle a piacere: 

a = [1,2,3,4,5]
a[2] = 8
print(a)

"""
[1,2,8,4,5]
"""

Le tuple, invece, sono immutabili, quindi tentare di modificarle genererà un TypeError. 

Per questo motivo, le tuple sono più efficienti in memoria, perché Python può allocare esattamente il blocco necessario ai dati. Al contrario, in una lista deve essere allocata memoria extra nel caso in cui venga estesa: questo è chiamato allocazione dinamica della memoria. 

In breve: negli scenari in cui non vuoi che i dati vengano modificati, per motivi di memoria è meglio preferire una tupla a una lista. Le tuple sono anche più veloci delle liste. 

Scopri di più sulle strutture dati in Python in questo tutorial. 

#4 Generator

a = [x * 2 for x in range(10)]
b = (x * 2 for x in range(10))

print(a)
print(b)

"""
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
<generator object <genexpr> at 0x7f61f8808b50>
"""

Le list comprehension sono il modo “pythonic” di creare una lista da un altro iterabile: sono molto più veloci di un ciclo for. Ma cosa succede se cambi accidentalmente le parentesi da [] a ()? Ottieni un oggetto generator.

In Python, le parentesi tonde con la logica di una list comprehension creano quello che è noto come generator object. I generator sono un tipo speciale di iterabile. A differenza delle liste, non memorizzano gli elementi; conservano invece le istruzioni per generare ogni elemento in ordine e lo stato corrente dell’iterazione.

Ogni elemento viene generato solo su richiesta tramite una tecnica chiamata valutazione pigra. Il principale vantaggio di questo trucco con i generator è l’uso ridotto di memoria, dato che l’intera sequenza non viene costruita tutta insieme. 

#5 Aliasing 

a = [1, 2, 3, 4 ,5]
b = a

# Change the 4th index in b
b[4] = 7

print(id(a))
print(id(b))
print(a) # Remember we did not explicitly make changes to a.

"""
15136008
15136008
[1, 2, 3, 4, 7]
"""

Python è un linguaggio orientato agli oggetti: tutto è un oggetto. Assegnare un oggetto a un identificatore significa creare un riferimento all’oggetto. 

Quando assegniamo un identificatore a un altro identificatore, otteniamo due identificatori che fanno riferimento allo stesso oggetto. Questo concetto si chiama aliasing. Le modifiche in un alias influenzeranno l’altro. A volte questo comportamento è desiderato, ma spesso ci coglie di sorpresa. 

Un modo per evitarlo è non fare aliasing quando si usano oggetti mutabili. Un’altra soluzione è creare un clone dell’oggetto originale invece di un riferimento. 

Il modo più semplice per creare un clone è usare lo slicing: 

b = a[:] 

Questo creerà un nuovo riferimento a un oggetto lista nell’identificatore b. 

Puoi ideare molte altre soluzioni, come chiamare list(a) durante l’assegnazione a un altro identificatore o usare il metodo copy(). 

#6 L’operatore ‘not’

a = []
print(not a)

"""
True
"""

Il modo più semplice per verificare se una struttura dati è vuota è usare l’operatore not. Il not integrato di Python è un operatore logico che restituisce True se l’espressione non è vera, altrimenti restituisce False: inverte il valore di verità di espressioni booleane e oggetti.  

Un altro modo in cui potresti vederlo usato è in un’istruzione if: 

if not a:
    # do something... 

Quando a è True, l’operatore not restituirà False, e viceversa. 

All’inizio può confondere: fai qualche prova.

Trucchi su stringhe e output

#7 F-string

first_name = "John"
age = 19

print(f"Hi, I'm {first_name} and I'm {age} years old!")

"""
Hi, I'm John and I'm 19 years old!
"""

A volte dobbiamo formattare una stringa; Python 3.6 ha introdotto una funzione molto comoda chiamata f-string per semplificare questo processo. Aiuta capire come si formattavano le stringhe prima della nuova versione per apprezzare meglio il nuovo metodo. 

Ecco come si formattavano le stringhe prima: 

first_name = "John"
age  = 19

print("Hi, I'm {} and I'm {} years old!".format(first_name, age))

"""
Hi, I'm John and I'm 19 years old!
"""

In sostanza, il nuovo modo è più veloce, più leggibile, più conciso e meno soggetto a errori.

Un altro uso delle f-string è stampare il nome dell’identificatore insieme al valore. Questo è stato introdotto in Python 3.8.

x = 10
y = 20
print(f"{x = }, {y = }")

"""
x = 10, y = 20
"""

Dai un’occhiata a questo tutorial su F-string Formatting in Python per saperne di più. 

#8 Il parametro ‘end’ della funzione print()

languages = ["english", "french", "spanish", "german", "twi"]
print(' '.join(languages))

"""
english french spanish german twi
"""

È abbastanza comune usare una print senza definire i suoi parametri opzionali. Di conseguenza, molti Pythonisti non sanno che puoi controllare l’output fino a un certo punto.

Un parametro opzionale che possiamo modificare è end. Il parametro end specifica cosa mostrare alla fine di una chiamata a print. 

Il valore predefinito di end è "\n", che dice a Python di andare a capo. Nel codice sopra l’abbiamo cambiato in uno spazio. Quindi l’output stampa tutti gli elementi della lista sulla stessa riga.

#9 Aggiungere a una tupla

a = (1, 2, [1, 2, 3])
a[2].append(4)
print(a)

"""
(1, 2, [1, 2, 3, 4])
"""

Sappiamo già che le tuple sono immutabili – vedi trucco #3 Liste vs. Tuple. Tentare di cambiarne lo stato genera un TypeError. Ma se pensi a una tupla come a una sequenza di nomi con collegamenti a oggetti che non possono essere cambiati, potresti vederla diversamente.

I primi due elementi della nostra tupla sono interi, cioè immutabili. L’ultimo elemento è una lista, un oggetto mutabile in Python.

Se consideriamo la lista come un altro nome in una sequenza con un collegamento a un oggetto che non può essere cambiato, allora ci rendiamo conto che la lista può comunque essere modificata dall’interno della tupla.

Lo consiglieremmo in pratica? Probabilmente no, ma è una di quelle cose utili da sapere!

#10 Unire dizionari

a = {"a": 1, "b": 2}
b = {"c": 3, "d": 4}

a_and_b = a | b
print(a_and_b)

"""
{"a": 1, "b": 2, "c": 3, "d": 4}
"""

In Python 3.9 e successivi, è possibile unire i dizionari usando | (OR bit a bit). Non c’è molto altro da dire su questo trucco se non che è una soluzione molto più leggibile! 

Trucchi di stile e sintassi

#11 Operatore ternario / espressioni condizionali 

condition = True
name = "John" if condition else "Doe"

print(name)

"""
John
"""

Nel codice sopra vedi quello che è noto come operatore ternario – anche chiamato espressione condizionale. Usiamo gli operatori ternari per valutare qualcosa in base al fatto che una condizione sia True o False.

Un altro modo per scrivere il codice sopra è il seguente:

condition = True
if condition:
    name = "John"
else:
    name = "Doe"

print(name)
"""
John
"""

Anche se entrambi i blocchi producono lo stesso output, nota come il ternario ci permetta di scrivere codice molto più breve e chiaro. È il modo più “Pythonico” di scrivere il codice. 

#12 Rimuovere duplicati dalle liste

a = [1, 1, 2, 3, 4, 5, 5, 5, 6, 7, 2, 2]
print(list(set(a)))

"""
[1, 2, 3, 4, 5, 6, 7]
"""

Il modo più semplice per rimuovere gli elementi duplicati da una lista è convertirla in un set (e poi di nuovo in lista se vuoi).

Per quanto riguarda la mutabilità, set e liste sono abbastanza simili in Python. Possiamo aggiungere e rimuovere elementi da entrambe le strutture a piacere, ma restano molto diverse.

Le liste sono ordinate, indicizzate a partire da zero e mutabili. I set sono non ordinati e non indicizzati. Gli elementi di un set devono essere di tipo immutabile, anche se il set in sé è mutabile: provare a recuperare un elemento via indice o a modificarlo genererà un errore.

Un’altra differenza chiave è che i set non possono contenere duplicati. È ciò che ci ha permesso di rimuovere i duplicati dalla nostra lista.

#13 Underscore standalone 

>>> print(_)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>

>>> 1 + 2
3

>>> print(_)
3

L’underscore (_) è un identificatore valido in Python, quindi è possibile usarlo per fare riferimento a un oggetto. Ma ha anche un’altra responsabilità: memorizzare il risultato dell’ultima valutazione.

La documentazione dice che «l’interprete interattivo rende disponibile il risultato dell’ultima valutazione nella variabile _. (È memorizzato nel modulo builtins, insieme a funzioni built-in come print).»

Poiché non avevamo assegnato nulla a underscore prima di richiamarlo sulla prima riga, abbiamo ottenuto un errore. Quando però abbiamo calcolato 1 + 2, l’interprete interattivo ha memorizzato il risultato nell’identificatore _ per noi. 

#14 Usare underscore per ignorare valori

for _ in range(100):
    print("The index doesn't matter")

"""
The index doesn't matter
The index doesn't matter
...
"""

Nel trucco #13 abbiamo visto che l’interprete interattivo rende disponibile l’ultimo risultato in (_), ma non è il suo unico caso d’uso.

Possiamo anche usarlo per rappresentare oggetti di cui non ci importa o che non useremo più avanti nel programma. Questo è importante perché usare un identificatore al posto di underscore (_) genererà un errore F841 durante il linting. Un errore F841 indica semplicemente che a una variabile locale è stato assegnato un valore ma non è stata usata nel programma, il che è una cattiva pratica.

#15 Underscore finale

list_ = [0, 1, 2, 3, 4]
global_ = "Hi there" 

Proseguendo con l’uso dell’underscore (_), un altro scopo è evitare conflitti con le parole chiave di Python. 

PEP 8 menziona che un underscore finale (_) dovrebbe essere «usato per convenzione per evitare conflitti con le parole chiave di Python». Aggiunge anche che «in generale è meglio aggiungere un underscore finale singolo piuttosto che usare un’abbreviazione o una storpiatura. Quindi list_ è meglio di lst.»

#16 Underscore iniziale

class Example:
    def __init__(self):
        self._internal = 2
        self.external = 20

Spesso vedrai programmatori Python esperti che antepongono un underscore al nome di un identificatore o di un metodo, e per una buona ragione.

L’underscore prefisso a un identificatore o metodo ha un significato implicito: questa variabile o metodo è pensato solo per uso interno. In sostanza, è un disclaimer per altri programmatori definito in PEP 8, ma non è imposto da Python. Quindi gli underscore iniziali sono un indicatore debole.

A differenza di Java, Python non ha una distinzione forte tra variabili private e pubbliche. In altre parole, ha significato solo perché la community Python ha concordato che lo abbia. La loro presenza non influisce sul comportamento dei tuoi programmi.

#17 Underscore visivo

Ecco l’ultimo consiglio sugli underscore. Finora abbiamo coperto tre casi d’uso diversi, ma puoi consultare il nostro tutorial per saperne di più sul ruolo dell’underscore (_) in Python. 

number = 1_500_000
print(number)

"""
15000000
"""

Un altro modo di usare l’underscore è come separatore visivo per raggruppare cifre nei letterali interi, in virgola mobile e complessi – introdotto in Python 3.6. 

L’idea è aiutare la leggibilità di numeri lunghi o di letterali il cui valore dovrebbe essere chiaramente separato in parti – puoi leggere di più in PEP 515.

Trucchi di stile e sintassi

#18 __name__ == “__main__” 

if __name__ == "__main__":
    print("Read on to understand what is going on when you do this.")

"""
print("Read on to understand what is going on when you do this.")
"""

È molto probabile che tu abbia visto questa sintassi in diversi programmi Python; Python usa un nome speciale chiamato "__main__" e lo assegna all’identificatore __name__ se il file Python in esecuzione è il programma principale.

Se decidiamo di importare il modulo mostrato nello screenshot in un altro modulo (file Python) ed eseguire quel file, l’espressione nel nostro codice risulterà falsa. Questo perché quando importiamo da un altro modulo, l’identificatore __name__ è impostato al nome del modulo (file Python). 

#19 Il metodo ‘setdefault’ 

import pprint

text = "It's the first of April. It's still cold in the UK. But I'm going to the museum so it should be a wonderful day"

counts = {}
for word in text.split():
    counts.setdefault(word, 0)
    counts[word] += 1

pprint.pprint(counts)

"""
{'April.': 1,
'But': 1,
"I'm": 1,
"It's": 2,
'UK.': 1,
'a': 1,
'be': 1,
'cold': 1,
'day': 1,
'first': 1,
'going': 1,
'in': 1,
'it': 1,
'museum': 1,
'of': 1,
'should': 1,
'so': 1,
'still': 1,
'the': 3,
'to': 1,
'wonderful': 1}
"""

Potresti voler impostare un valore per varie chiavi in un dizionario. Per esempio, quando tieni il conto delle parole in un corpus. Il modo comune è il seguente: 

1. Controlla se la chiave esiste nel dizionario
2. Se esiste, incrementa il valore di 1.
3. Se non esiste, aggiungila e imposta il valore a 1.

Ecco come appare in codice:

counts = {}
for word in text.split():
    if word in counts:
        counts[word] += 1
    else:
      counts[word] = 1

Un modo più conciso è usare il metodo setdefault() sull’oggetto dizionario.

Il primo argomento passato è la chiave da verificare. Il secondo è il valore da assegnare alla chiave se non esiste già nel dizionario – se la chiave esiste, il metodo restituirà il valore della chiave e quindi non verrà cambiato.

Trucchi sulla struttura del programma

#20 Regex per il matching

import re

number = re.compile(r"(0)?(\+44)?\d{10}")
num_1 = number.search("My number is +447999999999")
num_2 = number.search("My number is 07999999999")

print(num_1.group())
print(num_2.group())

"""
'+447999999999'
'07999999999'
"""

Le espressioni regolari permettono di specificare un pattern di testo da cercare; La maggior parte delle persone sa che possiamo cercare con CTRL + F (Windows), ma se non conosci esattamente cosa stai cercando, come lo trovi? La risposta è cercare i pattern.  

Per esempio, i numeri del Regno Unito seguono un pattern simile: hanno uno zero iniziale più dieci cifre oppure +44 al posto dello zero e dieci cifre – il secondo caso indica il formato internazionale. 

Le espressioni regolari fanno risparmiare molto tempo. Se dovessimo codificare regole per catturare i casi nell’immagine invece di usare le regex, potrebbero servire più di 10 righe di codice. 

Imparare come funzionano le regex è fondamentale anche se non scrivi codice. La maggior parte degli editor di testo e word processor moderni permette di usarle nelle funzioni di trova e sostituisci.

#21 La pipe nelle regex

import re

heros = re.compile(r"Super(man|woman|human)")

h1 = heros.search("This will find Superman")
h2 =  heros.search("This will find Superwoman")
h3 = heros.search("This will find Superhuman")

print(h1.group())
print(h2.group())
print(h3.group())

"""
Superman
Superwoman
Superhuman
"""

Le espressioni regolari hanno un carattere speciale chiamato pipe (|) che permette di fare il match di una tra più espressioni, e può essere usato ovunque. È utilissimo quando hai diversi pattern simili.

Per esempio, “Superman”, “Superwoman” e “Superhuman” hanno tutti lo stesso prefisso. Puoi quindi usare la pipe per mantenere la parte ricorrente del pattern e variare le parti che devono cambiare. Ancora una volta, risparmiando tempo prezioso.

Attenzione alla trappola: se tutte le espressioni che vuoi trovare compaiono nello stesso testo, verrà restituita la prima occorrenza che fa match — ad esempio, "An example text containing Superwoman, Superman, Superhuman" restituirà Superwoman.

#22 Il parametro ‘sep’ della funzione print()

day = "04"
month = "10"
year = "2022"

print(day, month, year)
print(day, month, year, sep = "")
print(day, month, year, sep = ".")

"""
04 10 2022
04/10/2022
04.10.2022
"""

Il numero di programmatori Python che non conosce tutte le potenzialità di print() è sorprendente; se “Hello World” è stato il tuo primo programma, print() è stata probabilmente una delle prime funzioni built-in che hai visto. Usiamo print() per mostrare messaggi formattati a schermo, ma c’è molto di più in print(). 

Nel codice sopra abbiamo mostrato modi diversi per visualizzare il messaggio formattato. Il parametro sep è un argomento opzionale di print() che ci permette di specificare come separare gli oggetti se ne includiamo più di uno. 

Di default vengono separati da uno spazio, ma abbiamo cambiato questo comportamento con le nostre print: una con sep impostato a "" e un’altra con sep impostato a ".".

#23 Funzioni lambda 

def square(num:int) -> int:
    return num ** 2

print(f"Function call: {square(4)}")
"""
Function call: 16
"""

square_lambda = lambda x: x**2
print(f"Lambda function: {square_lambda(4)}")
"""
Lambda functional: 16
"""

Le funzioni lambda ti portano verso aspetti più intermedi-avanzati di Python – impara Intermediate Python con questo corso. A prima vista sembrano complicate, ma sono piuttosto semplici.

Nell’esempio abbiamo usato un solo argomento, ma potremmo usarne più di uno se volessimo:

square = lambda a, b: a ** b
print(f"Lambda function: {square(4, 2)}")
"""
16
"""

In sostanza, la keyword lambda ci permette di creare piccole funzioni anonime, con limitazioni, in una sola riga. Si comportano come una funzione normale dichiarata con def, tranne per il fatto che queste funzioni non hanno nome.

#24 Il metodo ‘swapcase’

string = "SoMe RaNDoM sTriNg"
print(string.swapcase())

"""
sOmE rAndOm StRInG
"""

Il metodo swapcase() si applica a una stringa e permette di trasformare le lettere maiuscole in minuscole e viceversa in una sola riga di codice. Non ci sono molti casi d’uso per swapcase(), ma è utile conoscerlo.

#25 Il metodo ‘isalnum’

password = "ABCabc123"
print(password.isalnum())

"""
True
"""

Mettiamo che stiamo creando un programma che richiede agli utenti di inserire una password, ma deve avere una combinazione di numeri e lettere. Possiamo farlo in una riga chiamando isalnum() sull’istanza di stringa.

Il metodo verifica che tutti i caratteri siano alfabetici (A-Za-z) o numerici (0-9). Uno spazio o un simbolo (!#%$&? ecc.) restituirà False.

#26 Gestione delle eccezioni

def get_ration(x:int, y:int) -> int:
    try:
        ratio = x/y
    except ZeroDivisionError:
        y = y + 1
        ratio = x/y
    return ratio

print(get_ration(x=400, y=0))

"""
400.0
"""

I programmi Python terminano quando incontrano un errore.

A volte non vogliamo questo comportamento, ad esempio quando un utente finale interagisce con il nostro codice. Quanto sarebbe spiacevole se il programma terminasse prematuramente in un caso del genere?

Ci sono diversi modi di pensare alla gestione dei casi eccezionali. Molti programmatori Python abbracciano l’idea che sia più facile chiedere perdono che chiedere permesso. Significa che preferiscono intercettare un errore sollevato fornendo un contesto in grado di gestire l’eccezione. L’idea è che non ha senso perdere tempo cercando di proteggersi da tutti i casi eccezionali possibili.

Ma questo vale solo quando esiste un meccanismo per affrontare il problema dopo che si è verificato.

#27 Identificare le differenze tra liste

list_1 = [1, 3, 5, 7, 8]
list_2 = [1, 2, 3, 4, 5, 6, 7, 8, 9]

solution_1 = list(set(list_2) - set(list_1))
solution_2 = list(set(list_1) ^ set(list_2))
solution_3 = list(set(list_1).symmetric_difference(set(list_2)))

print(f"Solution 1: {solution_1}")
print(f"Solution 2: {solution_2}")
print(f"Solution 3: {solution_3}")

"""
Solution 1: [9, 2, 4, 6]
Solution 2: [2, 4, 6, 9]
Solution 3: [2, 4, 6, 9]
"""

Ecco tre metodi diversi per confrontare la differenza tra due liste in Python. 

Nota: a meno che tu non sappia per certo che list_1 è un sottoinsieme di list_2, la soluzione 1 non è equivalente alle altre due.

#28 Args & kwargs

def some_function(*args, **kwargs):
    print(f"Args: {args}")
    print(f"Kwargs: {kwargs}")

some_function(1, 2, 3,  a=4, b=5, c=6)

"""
Args: (1, 2, 3)
Kwargs: {'a': 4, 'b': 5, 'c': 6}
"""

Usiamo *args e **kwargs come parametri di una funzione quando non sappiamo quanti argomenti aspettarci. 

Il parametro *args permette di passare un numero variabile di argomenti posizionali (cioè senza nome). Al contrario, **kwargs abilita il passaggio di un numero arbitrario di argomenti con parola chiave.

In realtà, le parole *args e **kwargs non sono magiche: la vera magia sta negli asterischi (*). Questo significa che potremmo usare qualsiasi parola dopo gli asterischi, ma l’uso di args e kwargs è prassi comune ed è consolidato tra gli sviluppatori Python. 

#29 L’ellissi

print(...)

"""
Ellipsis
"""

def some_function():
    ...

# Alternative solution
def another_function():
    pass

L’Ellipsis è un oggetto Python che può essere richiamato fornendo una sequenza di tre puntini (...) o chiamando direttamente l’oggetto (Ellipsis).

Il suo uso più noto è per accedere e fare slicing di array multidimensionali in NumPy, per esempio:

import numpy as np

arr = np.array([[2,3], [1,2], [9,8]])

print(arr[...,0])
"""
[2 1 9]
"""
print(arr[...])

"""
[[2 3]
[1 2]
[9 8]]
"""

Ma un altro uso dell’Ellipsis è come segnaposto in una funzione non ancora implementata. 

Questo significa che puoi usare Ellipsis, ..., o pass, e saranno tutti validi.

#30 List comprehension

even_numbers = [x for x in range(10) if x % 2 == 0 and x != 0]
print(even_numbers)

"""
[2, 4, 6, 8]
"""

Il nostro ultimo trucco è la list comprehension, un modo elegante per creare una lista a partire da un’altra sequenza. Permette di applicare logica e filtri sofisticati, come nel codice sopra.

Ci sono altri modi per raggiungere lo stesso obiettivo; per esempio, potremmo usare una lambda come segue:

even_numbers = list(filter(lambda x: x % 2 ==0 and x != 0, range(10)))
print(even_numbers)
"""
[0, 2, 4, 6, 8]
"""

Ma molti Pythonisti sosterrebbero che questa soluzione è molto meno leggibile della list comprehension.