Wat doet de constructie if __name__ == "__main__" in Python?

In sommige programmeertalen dient de hoofdmethode als het enige toegangspunt voor de uitvoering van een programma. Tijdens de overgang van andere talen naar Python, het idioom als __naam__ == "__hoofd__" lijkt misschien dezelfde taak te volbrengen. In Python is dit niet het geval.

De als __naam__ == "__hoofd__" idioom staat toe dat een specifieke code wordt uitgevoerd wanneer het bestand als een script wordt uitgevoerd. Het zorgt er ook voor dat dezelfde code niet wordt uitgevoerd wanneer u het bestand als module importeert.

Het gedrag van de __naam__ variabele begrijpen

De __naam__ variabele is ingebouwd in Python. Het vertegenwoordigt de naam van de module of het script waarin het wordt gebruikt. Wanneer een script wordt uitgevoerd als het hoofdprogramma, wordt de waarde ingesteld op __voornaamst__. Als u het script als een module importeert, wordt de waarde van de variabele ingesteld op de daadwerkelijke naam van de module.

Dit kan in het begin verwarrend zijn, maar bekijk het volgende voorbeeld eens:

Maak een script en geef het een naam groetjes.py. Dit script bevat een functie die een gebruiker begroet en de waarde van de __naam__ variabel. Het zal de gebruiker ook vragen om zijn naam in te voeren.

defbegroeten(naam):
 afdrukken(f"Hallo, {naam}!")
afdrukken("Waarde van __naam__:", __naam__)
als __naam__ == "__voornaamst__":
 gebruikersnaam = invoer("Voer uw naam in: ")
 begroeten (gebruikersnaam)
anders:
 afdrukken("De module 'begroetingen' is geïmporteerd.")

Het runnen van de groetjes.py script geeft de volgende uitvoer weer:

De waarde van de __naam__ variabel rendement als __voornaamst__ omdat het script direct wordt uitgevoerd.

Maak nu een ander script en geef het een naam script2.py. Importeer vervolgens de groeten script als een module.

importeren groeten
afdrukken("Bezig met uitvoeren van het begroetingsscript...")
groetjes.greet("Alice")

Bellen naar de begroeten functie uit de groet module geeft de volgende output.

De waarde van de __naam__ variabele wijzigingen in de daadwerkelijke naam van de geïmporteerde module. In dit geval, groeten.

Deze waarde is wat het idioom als __naam__ == "__hoofd__" zoekt om te bepalen of een bestand wordt uitgevoerd als een script of wordt geïmporteerd als een module.

Wanneer gebruik je de if __name__ == "__main__" constructie?

U kunt de als __naam__ == "__hoofd__" bouwen in elk script. Maar er zijn enkele scenario's waarin het gebruik ervan het meest voordelig kan zijn. U leert over deze scenario's met behulp van het eenvoudige rekenprogramma hieronder.

# rekenmachine.py
deftoevoegen(een, b):
opbrengst een + b
defaftrekken(een, b):
opbrengst een - b
defvermenigvuldigen(een, b):
opbrengst een * b
defverdeling(een, b):
als b!= 0:
opbrengst een / b
anders:
opbrengst"Fout: delen door nul!"
als __naam__ == "__voornaamst__":
 afdrukken("Welkom bij de rekenmachine!")
 afdrukken("Selecteer een bewerking:")
 afdrukken("1. Toevoegen")
 afdrukken("2. Aftrekken")
 afdrukken("3. Vermenigvuldigen")
 afdrukken("4. Verdeling")
 keuze = int (invoer("Vul uw keuze in (1-4): "))
 getal1 = vlotter (invoer("Vul het eerste cijfer in: "))
 num2 = vlotter (invoer("Voer het tweede cijfer in: "))
als keuze == 1:
 resultaat = optellen (getal1, aantal2)
 afdrukken(f"De som van {nummer1} En {nummer2} is: {resultaat}")
elif keuze == 2:
 resultaat = aftrekken (num1, num2)
 afdrukken(f"Het verschil tussen {nummer1} En {nummer2} is: {resultaat}")
elif keuze == 3:
 resultaat = vermenigvuldigen (num1, num2)
 afdrukken(f"Het product van {nummer1} En {nummer2} is: {resultaat}")
elif keuze == 4:
 resultaat = delen (getal1, aantal2)
 afdrukken(f"De verdeling van {nummer1} door {nummer2} is: {resultaat}")
anders:
 afdrukken("Ongeldige keuze!")

Het eerste scenario is wanneer u een script onafhankelijk wilt uitvoeren en specifieke acties wilt uitvoeren. Hierdoor kan het script functioneren als een op zichzelf staand programma. De als __naam__ == "__hoofd__" construct stelt de gebruikers in staat om met de rekenmachine te communiceren via de opdrachtregelinterface. Dit geeft de gebruikers de mogelijkheid om de functionaliteit van het programma te gebruiken zonder de onderliggende code te hoeven begrijpen of wijzigen.

Het is nog steeds mogelijk om het programma uit te voeren zonder de als __naam__ == "__hoofd__" construeren en hetzelfde resultaat bereiken, maar uw code zou de modulaire codeorganisatie verliezen.

Het tweede scenario is wanneer u uw wilt code om een ​​modulair ontwerp te hebben. Hierdoor kunnen andere programma's uw script als een module importeren en de functies ervan gebruiken zonder onnodige functionaliteiten te activeren.

In het geval van het rekenmachineprogramma kunnen andere programma's het rekenmachine module zonder de CLI-interface en prompts voor gebruikersinvoer te activeren. Dit zorgt voor herbruikbaarheid van code en modulair ontwerp. Hierdoor kan de rekenmachine naadloos worden geïntegreerd in grotere toepassingen.

importeren rekenmachine
# De functies van de rekenmodule gebruiken
result_add = rekenmachine.add(5, 3)
afdrukken("Toevoeging resultaat:", result_add)
resultaat_aftrekken = rekenmachine.aftrekken(10, 4)
afdrukken("Aftrekresultaat:", resultaat_aftrekken)

Het derde scenario is wanneer u dat wilt test en debug je Python-script onafhankelijk van andere modules of scripts die het zouden kunnen importeren. In het voorbeeld van de rekenmachine maakt het het gemakkelijker om je te concentreren op het testen van de functionaliteit van de rekenmachine zonder tussenkomst van externe code.

importeren rekenmachine
# Testen van de rekenmachinefuncties
als __naam__ == "__voornaamst__":
# Test toevoeging
 resultaat = rekenmachine.toevoegen(5, 3)
 afdrukken("Toevoegingsresultaat:", resultaat)
# Test aftrekken
 resultaat = rekenmachine.aftrekken(8, 4)
 afdrukken("Aftrekresultaat:", resultaat)
# Test vermenigvuldiging
 resultaat = rekenmachine.vermenigvuldigen(2, 6)
 afdrukken("Vermenigvuldigingsresultaat:", resultaat)

De bovenstaande code laat zien hoe u het script van de rekenmachine onafhankelijk kunt debuggen.

Wanneer is het niet nodig om de constructie if __name__ == "__main__" te gebruiken?

Zoals je in de bovenstaande scenario's hebt gezien, is het gebruik van de als __naam__ == "__hoofd__" construct is om onderscheid te maken tussen het script dat u uitvoert als het hoofdprogramma en het script dat u als module importeert. Er zijn echter enkele gevallen waarin het gebruik ervan niet nodig is.

Het eerste geval is wanneer uw script eenvoudig is en geen herbruikbare functies of modules heeft en u niet van plan bent het te importeren. In dit geval moet u deze constructie weglaten omdat het volledige script wordt uitgevoerd wanneer het wordt uitgevoerd. Dit is gebruikelijk voor eenmalige scripts die een specifiek doel dienen en niet bedoeld zijn voor hergebruik of import.

Het andere geval is wanneer u werkt in een interactieve Python-sessie, b.v. bij gebruik van de Jupyter Notebook. In een interactieve sessie typt en voert u code rechtstreeks in de opdrachtprompt of in een interactieve Python-shell uit. Zoals de Python REPL (Read-Eval-Print Loop). Hierdoor kunt u experimenteren met code en kleine fragmenten testen, waardoor u direct resultaat krijgt.

In deze interactieve omgevingen is het concept van een script dat wordt uitgevoerd als hoofdprogramma of geïmporteerd als module niet van toepassing. U voert direct codefragmenten uit zonder de noodzaak van een traditioneel scriptinvoerpunt.

Hoe word je een meester in Python?

Om een ​​meester te worden in welke programmeertaal dan ook, moet je begrijpen hoe de onderliggende concepten van de functies of tools werken. Net zoals je in dit artikel hebt geleerd over de constructie if __name__ == "__main__".

Als u de onderliggende concepten begrijpt, weet u precies hoe uw programma zich zal gedragen wanneer u het gebruikt. Er is geen haast bij, door de concepten één voor één te leren, kun je dieper in elk van deze concepten duiken.