De naam van het Python-script of de module die momenteel wordt uitgevoerd, wordt opgeslagen in de speciale variabele __name__ van Python. Python 3.0 introduceerde de variabele __name__, die afwezig is in Python 2. x. De waarde van het huidige Python-script of de module, __main__, wordt toegewezen aan de variabele __name__ terwijl deze wordt uitgevoerd.
Wat betekent _naam_?
Python heeft een ingebouwde variabele genaamd __name__ die de naam opslaat van het script of de module die momenteel wordt uitgevoerd. De script- of modulenaam wordt opgeslagen in de variabele __name__, tenzij de huidige module actief is. In dat geval wordt de waarde __main__ eraan toegewezen.
Wanneer een Python-script wordt uitgevoerd, moet de waarde van de variabele __name__ daarom altijd __main__ zijn als deze in een ander Python-script wordt geïmporteerd. Als dit niet het geval is, verschijnt de naam van de module.
voor lus in Java
Voorbeeld :
Laten we een voorbeeld gebruiken om dit beter te begrijpen. Maak een script in Python genaamd testen.py, en voeg daar de volgende code aan toe:
# Code to define a function def anything(): print('Value of the __name__ : ', __name__) anything()
Uitgang:
Value of the __name__ : __main__
Uitleg:
Het script draait onmiddellijk als hoofdprogramma, zoals aangegeven door de uitvoer 'Waarde van de naam: main.' In Python wordt de waarde van de variabele __name__ van het script automatisch ingesteld op '__main__' wanneer het script rechtstreeks wordt uitgevoerd. Deze uitvoer bevestigt dat het script rechtstreeks wordt uitgevoerd in plaats van als module in een ander script te worden geïmporteerd
Laten we nu een ander Python-script bouwen met de naam netvoeding.py en importeer de vorige erin.
Voorbeeld :
# importing testing.py import testing testing.anything()
Uitgang:
Value of the __name__ : testing
Uitleg:
tekenreeks in Java-formaat
testen. alles() is de methode die wordt uitgevoerd wanneer het script testen.py wordt geïmporteerd in een ander Python-script met behulp van importtesten. In deze situatie wordt de naam van de module, in dit geval 'testing', ingesteld als de waarde van de variabele __name__ in testen.py in plaats van '__main__'. Om deze reden is de output van testen. any() is 'Waarde van de __name__: testen.' Dit illustreert hoe het rechtstreeks uitvoeren van het script versus het importeren ervan als een module de waarde van de variabele __name__ beïnvloedt.
De voorwaarde gebruiken als naam == hoofd:
Wij gebruiken de als verklaring en de toestand __naam__ == __hoofd__ om dat te verklaren bepaalde Python-code zou alleen moeten zijn uitgevoerd wanneer het script rechtstreeks wordt uitgevoerd .
Voorbeeld :
# importing testing.py import testing if __name__ == __main__: testing.anything()
In dit geval wordt het vermogen van de huidige module of het huidige script om onafhankelijk te draaien vastgesteld met behulp van de string __main__. Om aan de Python-interpreter aan te geven dat een trefwoord in de variabele __name__ gereserveerd of speciaal is, staan er twee onderstrepingstekens aan weerszijden van de term.
toevoegen aan een array in Java
Codevoorbeeld voor naam in Python:
Zoals eerder gezegd, wanneer we een codebestand uitvoeren, wordt de code direct uitgevoerd (deze wordt niet eens in een ander bestand geïmporteerd) en als gevolg daarvan verandert de waarde van de variabele __name__ in __main__.
# defining a function def anything(): print('It is a function in the ScriptP1.') if __name__=='__main__': anything() print('Called from the ScriptP1.') else: print('ScriptP1 is imported into another file.')
Uitgang:
It is a function in the ScriptP1. Called from the ScriptP1.
Uitleg:
De functie Anything() gespecificeerd in het script ScriptP1 wordt direct uitgevoerd als het hoofdprogramma, zoals blijkt uit de uitvoer 'Het is een functie in ScriptP1.' gevolgd door 'Geroepen vanuit ScriptP1.' Wanneer het script rechtstreeks in Python wordt uitgevoerd, wordt de variabele __name__ ingesteld op '__main__'; bijgevolg resulteert de voorwaarde if __name__=='__main__': in True, waarbij de functie alles() wordt aangeroepen. De printinstructie die volgt verifieert dat het script inderdaad rechtstreeks wordt uitgevoerd.
Laten we nu een nieuw Python-scriptbestand maken met de naam ScriptP2.py, ScriptP1.py erin importeren en proberen de ScriptP1-methode any() aan te roepen.
Code: De ScriptP2.py code wordt hier gegeven:
import ScriptP1 if __name__=='__main__': ScriptP1.anything() print('Called from the ScriptP2.')
Uitgang:
schakelkast java
ScriptP1 is imported into another file. It is a function in the ScriptP1. Called from the ScriptP2.
Uitleg:
Het meegeleverde Python-script laat zien hoe u de 'ScriptP1'-module in het actieve script importeert. De methode 'anything()' is aanwezig in 'ScriptP1' en wordt aangeroepen in het hoofdscript. Deze functie wordt aangeroepen en het script geeft als uitvoer 'Called from the ScriptP2.' om aan te geven dat de functieaanroep is voltooid. Deze stroom gebeurtenissen geeft aan dat de functie die is opgegeven in 'ScriptP1' toegankelijk was en met succes werd uitgevoerd in de context van het script dat nu wordt uitgevoerd en dat wordt geïdentificeerd als 'ScriptP2'.
Toen de importinstructie voor ScriptP1 binnen ScriptP2 werd uitgevoerd, had de variabele __name__ de waarde ScriptP1 (de modulenaam); maar aangezien ScriptP2 het eerste script was dat werd uitgevoerd, heeft het nu de waarde __main__.
De waarde van __name__ afdrukken:
Laten we de waarde van de variabele __name__ in elke uitvoeringsfase afdrukken, zodat u deze beter kunt begrijpen.
Voorbeeld : De broncode van het Python-script ScriptP1.py vindt u hieronder:
print('Value or the variable __name__ : ' + __name__)
Uitgang:
Value or the variable __name__ : __main__
Uitleg:
Het voorbeeld van de Python-code dat wordt geleverd, levert de waarde van de variabele __name__ op, die, wanneer het script rechtstreeks wordt uitgevoerd, resulteert in 'main'. Het betekent dat wanneer het script rechtstreeks wordt gestart, het codeblok dat na de voorwaarde if __name__ == '__main__': komt, wordt uitgevoerd in plaats van dat het als module in een ander script wordt geïmporteerd. Dit soort gedrag wordt vaak gebruikt om onderscheid te maken tussen het uitvoeren van een script als de primaire toepassing en het importeren ervan in een ander script als een module.
Voorbeeld 2: En hier is de broncode van het script ScriptP2.py:
Java-filterstream
# importing the file ScriptP1.py import ScriptP1 print('Value or the variable __name__ : ' + __name__)
Uitgang:
Value or the variable __name__ : __main__
Uitleg:
Het meegeleverde Python-script gebruikt de importinstructie om het bestand 'ScriptP1.py' te importeren. ' Wanneer het wordt uitgevoerd, wordt 'main' afgedrukt als de waarde van de variabele __name__. Dit betekent dat het script niet als module in een ander script wordt geïmporteerd, maar direct als primaire applicatie wordt uitgevoerd. Bij het uitvoeren van Python-scripts is dit het gebruikelijke gedrag; de uitvoeringscontext van het script wordt weerspiegeld in de variabele __name__.
Samenvatting :
In de meeste programmeertalen wordt meestal de hoofdmethode of -functie gebruikt als het punt waarop een programma wordt uitgevoerd. Maar hoe zit het met Python? De uitvoering van een Python-programma (script) begint normaal gesproken op regel nul of op het inspringniveau van het programma 0. Het aanmaken van een variabele __name__ gebeurt echter voordat een Python-programma wordt uitgevoerd. Deze variabele kan worden gebruikt om de hoofdmethode in Python te vervangen.