if __name__ == "__main__" in Python: spiegazione completa

Capire __name__ e "__main__"

L’idioma if __name__ == "__main__" è un if statement che verifica l’uguaglianza.

Il primo operando a sinistra dell’operatore di uguaglianza == è l’attributo __name__. I nomi Python con doppi underscore iniziali e finali sono identificatori speciali. Ogni modulo ha un attributo __name__. Python assegna a questa variabile il nome del modulo, che il sistema di import utilizza per identificare in modo univoco ciascun modulo.

Tuttavia, se il modulo si trova nell’ambiente di codice di livello superiore, cioè è il modulo usato come punto di ingresso del programma, Python imposta l’attributo __name__ sulla stringa "__main__".

Vediamo alcuni esempi. Creiamo uno script chiamato exploring_name_main.py:

# exploring_name_main.py
import random
print(__name__)
print(random.__name__)

Questo script può essere eseguito direttamente con il seguente comando nel terminale:

$ python exploring_name_main.py

__main__
random

Lo script exploring_name_main.py si trova nell’ambiente di codice di livello superiore poiché è il punto di ingresso del programma. Pertanto, la variabile __name__ è impostata sulla stringa "__main__".

Il modulo random, invece, è importato e non si trova nell’ambiente di codice di livello superiore. Il suo attributo __name__ è impostato sul nome del modulo.

Ora creiamo un nuovo script chiamato more_exploration.py, che importa il primo script:

# more_exploration.py
import exploring_name_main

Esegui questo script con il seguente comando nel terminale:

$ python more_exploration.py

exploring_name_main
random

Il codice di un modulo viene eseguito quando il modulo è importato. Quindi, eseguendo more_exploration.py, il codice mostra l’output delle due chiamate a print() in exploring_name_main.py. Poiché exploring_name_main.py non è più il punto di ingresso del programma, il suo attributo __name__ è impostato sul nome dello script invece che su "__main__".

Il blocco condizionale if __name__ == "__main__"

La variabile __name__ può essere usata per determinare se un modulo è il punto di ingresso principale di un programma. Di conseguenza, un modulo può includere codice che viene eseguito solo quando è lanciato direttamente come script ma non quando è importato. Qualsiasi codice che dovrebbe essere eseguito solo quando lo script è eseguito direttamente va incluso nel blocco condizionale if __name__ == "__main__":

# exploring_name_main.py
import random
print(__name__)
print(random.__name__)
number = random.randint(1, 10)
if __name__ == "__main__":
    print("This script is in the top-level code environment")
    print(f"The number is {number}")

Il codice in exploring_name_main.py ora include un blocco condizionale if __name__ == "__main__". Vediamo se questo fa differenza quando eseguiamo lo script:

$ python exploring_name_main.py

__main__
random
This script is in the top-level code environment
The number is 10

Quando lo script è eseguito direttamente, la variabile __name__ è impostata sulla stringa "__main__". Quindi, la condizione nell’istruzione if risulta True e Python esegue il codice nel blocco if.

Tuttavia, quando il modulo è importato, __name__ è impostato sul nome del modulo e il programma non esegue il blocco if. Ricorda che lo script more_exploration.py importa exploring_name_main:

$  python more_exploration.py

exploring_name_main
random

Il programma non richiama le funzioni print() in exploring_name_main.py. Si trovano nel blocco condizionale che non viene eseguito perché __name__ non è uguale a "__main__".

Best practice e consigli quando usi l’idioma di Python if __name__ == "__main__"

L’idioma if __name__ == "__main__" in Python si usa quando il codice deve essere eseguito solo se un file è lanciato come script, e non quando è importato come modulo. La distinzione tra i termini script e modulo riguarda solo il modo in cui il file è usato. Entrambi i termini si riferiscono a file con estensione .py.

Un caso d’uso comune è quando uno script contiene variabili, funzioni e classi che potrebbero essere utilizzate in altri programmi. Ecco un esempio con uno script chiamato shapes.py:

# shapes.py
import math
def find_area_of_circle(radius):
    return math.pi * radius ** 2
def find_area_of_rectangle(width, height):
    return width * height
if __name__ == "__main__":
    shape = int(input("Enter 1 for circle, 2 for rectangle: "))
    if shape == 1:
        radius = int(input("Enter radius: "))
        print(f"The area of the circle is {find_area_of_circle(radius)}")
    elif shape == 2:
        width = int(input("Enter width: "))
        height = int(input("Enter height: "))
        print(f"The area of the rectangle is {find_area_of_rectangle(width, height)}")

Enter 1 for circle, 2 for rectangle: 2
Enter width: 10
Enter height: 20
The area of the rectangle is 200

Questo codice non ha bisogno dell’idioma if __name__ == "__main__" se l’intenzione è di eseguirlo sempre come script. Tuttavia, l’inclusione di questa condizione permette di importare il codice come modulo senza eseguire le righe nel blocco if. Considera un altro script chiamato more_shapes.py:

# more_shapes.py
import shapes
radius = 5
print(f"The area of the circle defined in 'more_shapes.py' is: "
      f"{shapes.find_area_of_circle(radius)}")

The area of the circle defined in 'more_shapes.py' is: 78.53981633974483

Questo nuovo script, more_shapes.py, ha accesso alle funzioni definite in shapes.py grazie all’istruzione di import. Tuttavia, il codice nel blocco if __name__ == "__main__" in shapes.py non viene eseguito. Senza l’istruzione if in shapes.py, tutto il codice verrebbe eseguito quando il modulo è importato.

Usare il blocco if __name__ == "__main__" per l’input dell’utente è un caso d’uso comune. L’input utente viene omesso se il file è importato come modulo, ma è incluso quando è eseguito direttamente come codice di livello superiore.

Usare una funzione main()

È buona pratica includere il minor numero possibile di istruzioni nel blocco if __name__ == "__main__" perché rende il codice più leggibile. Un modo comune per ottenere questo risultato è creare una funzione, richiamata poi nel blocco condizionale. È comune chiamare questa funzione main(), ma qualsiasi nome è valido:

# shapes.py
import math
def find_area_of_circle(radius):
    return math.pi * radius ** 2
def find_area_of_rectangle(width, height):
    return width * height
def main():
    shape = int(input("Enter 1 for circle, 2 for rectangle: "))
    if shape == 1:
        radius = int(input("Enter radius: "))
        print(f"The area of the circle is {find_area_of_circle(radius)}")
    elif shape == 2:
        width = int(input("Enter width: "))
        height = int(input("Enter height: "))
        print(f"The area of the rectangle is {find_area_of_rectangle(width, height)}")
       
if __name__ == "__main__":
    main()

Il codice nella funzione main() è lo stesso che prima era incluso direttamente nel blocco if __name__ == "__main__" nella versione precedente.

In Python, la funzione main() non è obbligatoria come punto di ingresso principale del programma, a differenza di altri linguaggi. Quindi, l’uso di main() e dell’idioma if __name__ == "__main__" è opzionale e serve solo quando il codice è pensato per essere usato sia come script autonomo sia come modulo.

Un altro caso d’uso comune per if __name__ == "__main__" in Python è includere test nello script. I test verranno eseguiti quando lo script è lanciato direttamente ma non quando è importato da un altro modulo. Tuttavia, sebbene questo approccio sia adatto per casi semplici, è meglio includere i test in un modulo separato dedicato al testing.

Conclusione

L’idioma if __name__ == "__main__" di Python è utile per includere codice che viene eseguito solo quando uno script è lanciato direttamente, ma non quando è importato. L’interprete Python imposta la variabile __name__ sul nome del modulo se è importato e sulla stringa "__main__" se il modulo è il punto di ingresso principale del programma.

A differenza di altri linguaggi di programmazione, la funzione main() e l’idioma if __name__ == "__main__" non sono requisiti per eseguire codice Python, ma strumenti che il programmatore può usare quando necessario.