Hva gjør if __name__ == "__main__"-konstruksjonen i Python?

I noen programmeringsspråk fungerer hovedmetoden som eneste inngangspunkt for utførelse av et program. Mens overgangen fra andre språk til Python, formspråket hvis __navn__ == "__main__" kan se ut til å utføre den samme oppgaven. I Python er dette ikke tilfelle.

De hvis __navn__ == "__main__" idiom lar en spesifikk kode kjøres når filen kjører som et skript. Den sørger også for at den samme koden ikke kjøres når du importerer filen som en modul.

Forstå __navn__ Variable Behavior

De __Navn__ variabel er innebygd i Python. Det representerer navnet på modulen eller skriptet den brukes i. Når et skript kjøres som hovedprogram, settes verdien til __hoved__. Hvis du importerer skriptet som en modul, settes variabelens verdi til det faktiske navnet på modulen.

Dette kan være forvirrende i begynnelsen, men ta en titt på følgende eksempel:

Lag et skript og navngi det hilsener.py. Dette skriptet vil inneholde en funksjon som hilser en bruker og skriver ut verdien av

__Navn__ variabel. Den vil også be brukeren om å skrive inn navnet sitt.

defhilse på(Navn):
 skrive ut(f "Hei, {Navn}!")
skrive ut("Verdi av __navn__:", __Navn__)
hvis __navn__ == "__hoved__":
 brukernavn = input("Vennligst skriv inn navnet ditt: ")
 hilse (brukernavn)
ellers:
 skrive ut("Modulen 'hilsen' har blitt importert.")

Kjører hilsener.py script vil vise følgende utdata:

Verdien av __Navn__ variabel avkastning som __hoved__ fordi skriptet kjøres direkte.

Lag et annet skript og navngi det script2.py. Deretter importerer du hilsener skript som en modul.

import hilsener
skrive ut("Utfører hilsenmanuset...")
greetings.greet("Alice")

Ringer til hilse på funksjon fra hilsen modulen gir følgende utgang.

Verdien av __Navn__ variable endringer i det faktiske navnet på den importerte modulen. I dette tilfellet, hilsener.

Denne verdien er hva formspråket hvis __navn__ == "__main__" ser etter for å finne ut om en fil kjører som et skript eller er importert som en modul.

Når skal jeg bruke if __name__ == "__main__"-konstruksjonen?

Du kan legge til hvis __navn__ == "__main__" konstruere i et hvilket som helst skript. Men det er noen scenarier der det kan være mest fordelaktig å bruke det. Du vil lære om disse scenariene ved å bruke det enkle kalkulatorprogrammet nedenfor.

# kalkulator.py
defLegg til(a, b):
komme tilbake a + b
deftrekke fra(a, b):
komme tilbake a - b
defmultiplisere(a, b):
komme tilbake a * b
defdele opp(a, b):
hvis b != 0:
komme tilbake a/b
ellers:
komme tilbake"Feil: Divisjon med null!"
hvis __navn__ == "__hoved__":
 skrive ut("Velkommen til kalkulatoren!")
 skrive ut("Velg en operasjon:")
 skrive ut("1. Legg til")
 skrive ut("2. Trekke fra")
 skrive ut("3. Multiplisere")
 skrive ut("4. Dele opp")
 valg = int (input("Skriv inn ditt valg (1-4): "))
 num1 = flyte (inngang("Skriv inn det første tallet: "))
 num2 = flyte (inngang("Skriv inn det andre tallet: "))
hvis valg == 1:
 resultat = legg til (tall1, tall2)
 skrive ut(f"Summen av {num1} og {num2} er: {resultat}")
elif valg == 2:
 resultat = trekke fra (tall1, tall2)
 skrive ut(f "Forskjellen mellom {num1} og {num2} er: {resultat}")
elif valg == 3:
 resultat = multipliser (tall1, tall2)
 skrive ut(f "Produktet av {num1} og {num2} er: {resultat}")
elif valg == 4:
 resultat = dividere (tall1, tall2)
 skrive ut(f "Delingen av {num1} av {num2} er: {resultat}")
ellers:
 skrive ut("Ugyldig valg!")

Det første scenariet er når du vil kjøre et skript uavhengig og utføre spesifikke handlinger. Dette gjør at skriptet kan fungere som et frittstående program. De hvis __navn__ == "__main__" konstruksjon lar brukerne samhandle med kalkulatoren ved å bruke kommandolinjegrensesnittet. Dette gir brukerne muligheten til å bruke programmets funksjonalitet uten å måtte forstå eller endre den underliggende koden.

Det er fortsatt mulig å kjøre programmet uten hvis __navn__ == "__main__" konstruere og oppnå samme resultat, men koden din vil miste modulær kodeorganisering.

Det andre scenariet er når du vil ha din kode for å ha en modulær design. Dette lar andre programmer importere skriptet ditt som en modul og bruke funksjonene uten å utløse unødvendige funksjoner.

Når det gjelder kalkulatorprogrammet, kan andre programmer importere kalkulator modul uten å utløse CLI-grensesnittet og brukerinputmeldinger. Dette sikrer gjenbruk av kode og modulær design. Dermed kan kalkulatoren integreres sømløst i større applikasjoner.

import kalkulator
# Bruke funksjonene fra kalkulatormodulen
result_add = kalkulator.add(5, 3)
skrive ut("Tilleggsresultat:", resultat_legg til)
result_subtract = kalkulator.subtract(10, 4)
skrive ut("Subtraksjonsresultat:", result_subtract)

Det tredje scenariet er når du vil test og feilsøk Python-skriptet ditt uavhengig av andre moduler eller skript som kan importere den. I kalkulatoreksemplet gjør det det lettere å fokusere på å teste kalkulatorens funksjonalitet uten forstyrrelser fra ekstern kode.

import kalkulator
# Testing av kalkulatorens funksjoner
hvis __navn__ == "__hoved__":
# Testtillegg
 resultat = kalkulator.add(5, 3)
 skrive ut("Tilleggsresultat:", resultat)
# Test subtraksjon
 resultat = kalkulator.subtract(8, 4)
 skrive ut("Subtraksjonsresultat:", resultat)
# Testmultiplikasjon
 resultat = kalkulator.multiply(2, 6)
 skrive ut("Multiplikasjonsresultat:", resultat)

Koden ovenfor viser hvordan du feilsøker kalkulatorskriptet uavhengig.

Når er det unødvendig å bruke if __name__ == "__main__"-konstruksjonen?

Som du har sett i scenariene ovenfor, er bruken av hvis __navn__ == "__main__" konstruksjon er å skille mellom skriptet du kjører som hovedprogram og det du importerer som en modul. Det er imidlertid noen tilfeller der det er unødvendig å bruke det.

Det første tilfellet er når skriptet ditt er enkelt og ikke har noen gjenbrukbare funksjoner eller moduler og du ikke har til hensikt å importere det. I dette tilfellet bør du utelate denne konstruksjonen ettersom hele skriptet kjøres når det kjøres. Dette er vanlig for engangsskript som utfører et bestemt formål og ikke er ment for gjenbruk eller import.

Det andre tilfellet er når du jobber i en interaktiv Python-økt, f.eks. når du bruker Jupyter Notebook. I en interaktiv økt skriver og kjører du kode direkte i ledeteksten eller i et interaktivt Python-skall. Slik som Python REPL (Read-Eval-Print Loop). Dette lar deg eksperimentere med kode og teste små utdrag, noe som gir deg umiddelbare resultater.

I disse interaktive miljøene gjelder ikke konseptet med et skript som kjører som hovedprogram eller importert som en modul. Du kjører kodebiter direkte uten behov for et tradisjonelt skriptinngangspunkt.

Hvordan blir du en mester i Python?

For å bli en mester i et hvilket som helst programmeringsspråk, må du forstå hvordan de underliggende konseptene til funksjonene eller verktøyene fungerer. Akkurat som du lærte om if __name__ == "__main__"-konstruksjonen i denne artikkelen.

Å forstå de underliggende konseptene vil hjelpe deg å vite nøyaktig hvordan programmet ditt vil oppføre seg når du bruker dem. Det er ingen hast, å lære konseptene ett om gangen vil hjelpe deg å dykke dypere inn i hvert av dem.