Cosa fa il costrutto if __name__ == "__main__" in Python?

In alcuni linguaggi di programmazione, il metodo principale funge da unico punto di ingresso per l'esecuzione di un programma. Durante la transizione da altri linguaggi a Python, idiom se __nome__ == "__principale__" potrebbe sembrare svolgere lo stesso compito. In Python, questo non è il caso.

IL se __nome__ == "__principale__" idiom consente l'esecuzione di un codice specifico quando il file viene eseguito come script. Si assicura inoltre che lo stesso codice non venga eseguito quando si importa il file come modulo.

Comprensione del comportamento della variabile __name__

IL __nome__ la variabile è incorporata in Python. Rappresenta il nome del modulo o dello script in cui viene utilizzato. Quando uno script viene eseguito come programma principale, il suo valore è impostato su __principale__. Se importi lo script come modulo, il valore della variabile viene impostato sul nome effettivo del modulo.

Questo potrebbe creare confusione all'inizio, ma dai un'occhiata al seguente esempio:

Crea uno script e assegnagli un nome saluti.py. Questo script conterrà una funzione che accoglie un utente e stampa il valore del file __nome__ variabile. Chiederà inoltre all'utente di inserire il proprio nome.

defsalutare(nome):
 stampa(f"Ciao, {nome}!")
stampa("Valore di __name__:", __nome__)
Se __nome__ == "__principale__":
 nome_utente = input("Per favore inserisci il tuo nome: ")
 saluta (nome_utente)
altro:
 stampa("Il modulo 'saluti' è stato importato.")

Esecuzione del saluti.py script visualizzerà il seguente output:

Il valore del __nome__ variabile restituisce come __principale__ perché lo script viene eseguito direttamente.

Ora crea un altro script e assegnagli un nome script2.py. Quindi, importa il file Saluti script come modulo.

importare Saluti
stampa("Esecuzione dello script dei saluti...")
saluti.greet("Alice")

Chiamando il salutare funzione dal saluto module fornisce il seguente output.

Il valore del __nome__ la variabile cambia nel nome effettivo del modulo importato. In questo caso, Saluti.

Questo valore è ciò che l'idioma se __nome__ == "__principale__" cerca per determinare se un file è in esecuzione come script o è importato come modulo.

Quando utilizzare il costrutto if __name__ == "__main__"?

Puoi aggiungere il se __nome__ == "__principale__" costruire in qualsiasi script. Ma ci sono alcuni scenari in cui il suo utilizzo può essere più vantaggioso. Imparerai a conoscere questi scenari utilizzando il semplice programma di calcolo di seguito.

# calcolatrice.py
defaggiungere(a, b):
ritorno un + b
defsottrarre(a, b):
ritorno a - b
defmoltiplicare(a, b):
ritorno a*b
defdividere(a, b):
Se b != 0:
ritorno a/b
altro:
ritorno"Errore: divisione per zero!"
Se __nome__ == "__principale__":
 stampa("Benvenuti nella Calcolatrice!")
 stampa("Seleziona un'operazione:")
 stampa("1. Aggiungere")
 stampa("2. Sottrarre")
 stampa("3. Moltiplicare")
 stampa("4. Dividere")
 scelta = int (input("Inserisci la tua scelta (1-4): "))
 num1 = float (input("Inserisci il primo numero: "))
 num2 = float (input("Inserisci il secondo numero: "))
Se scelta == 1:
 risultato = aggiungi (num1, num2)
 stampa(f"La somma di {num1} E {num2} È: {risultato}")
elif scelta == 2:
 risultato = sottrazione (num1, num2)
 stampa(f"La differenza tra {num1} E {num2} È: {risultato}")
elif scelta == 3:
 risultato = moltiplica (num1, num2)
 stampa(f"Il prodotto di {num1} E {num2} È: {risultato}")
elif scelta == 4:
 risultato = dividere (num1, num2)
 stampa(f"La divisione di {num1} di {num2} È: {risultato}")
altro:
 stampa("Scelta non valida!")

Il primo scenario è quando si desidera eseguire uno script in modo indipendente ed eseguire azioni specifiche. Ciò consente allo script di funzionare come un programma autonomo. IL se __nome__ == "__principale__" costrutto consente agli utenti di interagire con la calcolatrice utilizzando l'interfaccia della riga di comando. Ciò offre agli utenti la possibilità di utilizzare le funzionalità del programma senza dover comprendere o modificare il codice sottostante.

È ancora possibile eseguire il programma senza il file se __nome__ == "__principale__" costruisci e ottieni lo stesso risultato, ma il tuo codice perderebbe l'organizzazione del codice modulare.

Il secondo scenario è quando vuoi il tuo codice per avere un design modulare. Ciò consente ad altri programmi di importare il tuo script come modulo e utilizzare le sue funzioni senza attivare funzionalità non necessarie.

Nel caso del programma calcolatrice, altri programmi possono importare il file calcolatrice modulo senza attivare l'interfaccia CLI e le richieste di input dell'utente. Ciò garantisce la riusabilità del codice e il design modulare. Quindi, consentendo alla calcolatrice di essere perfettamente integrata in applicazioni più grandi.

importare calcolatrice
# Utilizzo delle funzioni del modulo calcolatrice
result_add = calcolatrice.add(5, 3)
stampa("Risultato addizione:", risultato_aggiungi)
risultato_sottrazione = calcolatrice.sottrazione(10, 4)
stampa("Risultato sottrazione:", risultato_sottrazione)

Il terzo scenario è quando vuoi testare ed eseguire il debug del tuo script Python indipendentemente da altri moduli o script che potrebbero importarlo. Nell'esempio della calcolatrice, è più facile concentrarsi sul test della funzionalità della calcolatrice senza interferenze da codice esterno.

importare calcolatrice
# Testare le funzioni della calcolatrice
Se __nome__ == "__principale__":
# Prova addizione
 risultato = calcolatrice.add(5, 3)
 stampa("Risultato addizione:", risultato)
# Prova la sottrazione
 risultato = calcolatrice.sottrazione(8, 4)
 stampa("Risultato sottrazione:", risultato)
# Prova la moltiplicazione
 risultato = calcolatrice.moltiplica(2, 6)
 stampa("Risultato della moltiplicazione:", risultato)

Il codice precedente mostra come eseguire il debug dello script della calcolatrice in modo indipendente.

Quando non è necessario utilizzare il costrutto if __name__ == "__main__"?

Come hai visto negli scenari sopra, l'uso di se __nome__ == "__principale__" costruire è differenziare lo script che stai eseguendo come programma principale e quello che stai importando come modulo. Ci sono tuttavia alcuni casi in cui non è necessario utilizzarlo.

Il primo caso è quando il tuo script è semplice e non ha funzioni o moduli riutilizzabili e non lo intendi per l'importazione. In questo caso, dovresti omettere questo costrutto poiché l'intero script viene eseguito quando viene eseguito. Questo è comune per gli script monouso che eseguono uno scopo specifico e non sono pensati per il riutilizzo o l'importazione.

L'altro caso è quando lavori in una sessione Python interattiva, ad es. quando si utilizza Jupyter Notebook. In una sessione interattiva, digiti ed esegui il codice direttamente nel prompt dei comandi o in una shell Python interattiva. Come Python REPL (Read-Eval-Print Loop). Ciò ti consente di sperimentare il codice e testare piccoli frammenti, ottenendo risultati immediati.

In questi ambienti interattivi, il concetto di uno script eseguito come programma principale o importato come modulo non si applica. Stai eseguendo direttamente frammenti di codice senza la necessità di un punto di ingresso di script tradizionale.

Come si diventa un maestro in Python?

Per diventare un maestro in qualsiasi linguaggio di programmazione, devi capire come funzionano i concetti alla base delle funzioni o degli strumenti. Proprio come hai imparato a conoscere il costrutto if __name__ == "__main__" in questo articolo.

Comprendere i concetti sottostanti ti aiuterà a sapere esattamente come si comporterà il tuo programma quando li usi. Non c'è fretta, imparare i concetti uno alla volta ti aiuterà ad approfondire ognuno di essi.