Du måste ha stött på if __name__ == "huvud"-konstruktionen i Python. Men vet du dess exakta syfte?

I vissa programmeringsspråk fungerar huvudmetoden som den enda startpunkten för exekvering av ett program. Under övergången från andra språk till Python, formspråket om __namn__ == "__huvud__" kan tyckas utföra samma uppgift. I Python är detta inte fallet.

De om __namn__ == "__huvud__" idiom tillåter att en specifik kod körs när filen körs som ett skript. Det ser också till att samma kod inte körs när du importerar filen som en modul.

Förstå __namn__ Variabelt beteende

De __namn__ variabeln är inbyggd i Python. Det representerar namnet på modulen eller skriptet där det används. När ett skript körs som huvudprogram sätts dess värde till __huvud__. Om du importerar skriptet som en modul sätts variabelns värde till det faktiska namnet på modulen.

Detta kan vara förvirrande till en början, men ta en titt på följande exempel:

Skapa ett skript och namnge det hälsningar.py. Detta skript kommer att innehålla en funktion som hälsar en användare och skriver ut värdet på

instagram viewer
__namn__ variabel. Det kommer också att be användaren att ange sitt namn.

defhälsa(namn):
 skriva ut(f "Hej, {namn}!")
skriva ut("Värde på __namn__:", __namn__)


om __namn__ == "__huvud__":
 användarnamn = input("Vänligen fyll i ditt namn: ")
 hälsa (användarnamn)
annan:
 skriva ut("Modulen 'hälsningar' har importerats.")

Kör hälsningar.py skript kommer att visa följande utdata:

Värdet av __namn__ rörlig avkastning som __huvud__ eftersom skriptet körs direkt.

Skapa nu ett annat skript och namnge det script2.py. Importera sedan hälsningar skript som en modul.

importera hälsningar
skriva ut("Kör hälsningsskriptet...")
greetings.greet("Alice")

Ringer till hälsa funktion från hälsning modulen ger följande utdata.

Värdet av __namn__ variabeländringar av det faktiska namnet på den importerade modulen. I detta fall, hälsningar.

Detta värde är vad formspråket om __namn__ == "__huvud__" letar efter för att avgöra om en fil körs som ett skript eller är importerad som en modul.

När ska man använda if __name__ == "__main__"-konstruktionen?

Du kan lägga till om __namn__ == "__huvud__" konstruera i vilket skript som helst. Men det finns vissa scenarier där det kan vara mest fördelaktigt att använda det. Du kommer att lära dig om dessa scenarier med hjälp av det enkla kalkylatorprogrammet nedan.

# calculator.py
defLägg till(a, b):
lämna tillbaka a + b


defsubtrahera(a, b):
lämna tillbaka a - b


defmultiplicera(a, b):
lämna tillbaka a * b


defdela upp(a, b):
om b != 0:
lämna tillbaka a/b
annan:
lämna tillbaka"Fel: division med noll!"


om __namn__ == "__huvud__":
 skriva ut("Välkommen till miniräknaren!")
 skriva ut("Välj en operation:")
 skriva ut("1. Lägg till")
 skriva ut("2. Subtrahera")
 skriva ut("3. Multiplicera")
 skriva ut("4. Dela upp")


 val = int (ingång("Ange ditt val (1-4): "))


 num1 = float (ingång("Ange den första siffran:"))
 num2 = float (ingång("Ange det andra numret: "))
om val == 1:
 resultat = lägg till (nummer1, nummer2)
 skriva ut(f" Summan av {num1} och {num2} är: {resultat}")
elif val == 2:
 resultat = subtrahera (tal1, antal2)
 skriva ut(f "Skillnaden mellan {num1} och {num2} är: {resultat}")
elif val == 3:
 resultat = multiplicera (tal1, tal2)
 skriva ut(f "Produkten av {num1} och {num2} är: {resultat}")
elif val == 4:
 resultat = dividera (tal1, tal2)
 skriva ut(f"Indelningen av {num1} förbi {num2} är: {resultat}")
annan:
 skriva ut("Ogiltigt val!")

Det första scenariot är när du vill köra ett skript självständigt och utföra specifika åtgärder. Detta gör att skriptet kan fungera som ett fristående program. De om __namn__ == "__huvud__" konstruktion låter användarna interagera med räknaren med hjälp av kommandoradsgränssnittet. Detta ger användarna möjlighet att använda programmets funktionalitet utan att behöva förstå eller ändra den underliggande koden.

Det är fortfarande möjligt att köra programmet utan om __namn__ == "__huvud__" konstruera och uppnå samma resultat, men din kod skulle förlora modulär kodorganisation.

Det andra scenariot är när du vill ha din kod för att ha en modulär design. Detta gör att andra program kan importera ditt skript som en modul och använda dess funktioner utan att utlösa onödiga funktioner.

När det gäller kalkylatorprogrammet kan andra program importera kalkylator modul utan att utlösa CLI-gränssnittet och användarinmatningsmeddelanden. Detta säkerställer kodåteranvändbarhet och modulär design. Detta gör att räknaren sömlöst kan integreras i större applikationer.

importera kalkylator
# Använda funktionerna från kalkylatormodulen
result_add = calculator.add(5, 3)
skriva ut("Tilläggsresultat:", resultat_lägg till)
resultat_subtrahera = calculator.subtract(10, 4)
skriva ut("Subtraktionsresultat:", resultat_subtrahera)

Det tredje scenariot är när du vill testa och felsöka ditt Python-skript oberoende av andra moduler eller skript som kan importera den. I räknarexemplet gör det det lättare att fokusera på att testa räknarens funktionalitet utan störningar från extern kod.

importera kalkylator
# Testa räknarens funktioner
om __namn__ == "__huvud__":
# Testtillägg
 resultat = calculator.add(5, 3)
 skriva ut("Tilläggsresultat:", resultat)


# Testa subtraktion
 resultat = calculator.subtract(8, 4)
 skriva ut("Subtraktionsresultat:", resultat)
# Testmultiplikation
 resultat = calculator.multiply(2, 6)
 skriva ut("Multiplikationsresultat:", resultat)

Ovanstående kod visar hur man felsöker kalkylatorns skript oberoende av varandra.

När är det onödigt att använda if __name__ == "__main__"-konstruktionen?

Som du har sett i scenarierna ovan är användningen av om __namn__ == "__huvud__" konstruktion är att skilja skriptet du kör som huvudprogram och det du importerar som en modul. Det finns dock vissa fall där det är onödigt att använda det.

Det första fallet är när ditt skript är enkelt och inte har några återanvändbara funktioner eller moduler och du inte avser att det ska importeras. I det här fallet bör du utelämna denna konstruktion eftersom hela skriptet körs när det körs. Detta är vanligt för engångsskript som har ett specifikt syfte och inte är avsedda för återanvändning eller import.

Det andra fallet är när du arbetar i en interaktiv Python-session t.ex. när du använder Jupyter Notebook. I en interaktiv session skriver och kör du kod direkt i kommandotolken eller i ett interaktivt Python-skal. Såsom Python REPL (Read-Eval-Print Loop). Detta låter dig experimentera med kod och testa små utdrag, vilket ger dig omedelbara resultat.

I dessa interaktiva miljöer gäller inte konceptet med ett skript som körs som huvudprogram eller importeras som en modul. Du kör kodavsnitt direkt utan att behöva en traditionell skriptingångspunkt.

Hur blir du en mästare i Python?

För att bli en mästare i något programmeringsspråk måste du förstå hur de underliggande koncepten för funktionerna eller verktygen fungerar. Precis som du lärde dig om konstruktionen if __name__ == "__main__" i den här artikeln.

Att förstå de underliggande koncepten hjälper dig att veta exakt hur ditt program kommer att bete sig när du använder dem. Det är ingen brådska, att lära dig begreppen ett i taget hjälper dig att dyka djupare in i var och en av dem.