Ebből az útmutatóból meg fogja érteni az if __name__ == ‘__main__’ funkcióját és jelentőségét a Pythonban.
Átfutottál már egy Python kódbázist különböző modulokkal?
Ha igen, akkor valószínűleg találkozott volna azzal, ha a __name__ == ‘__main__’ feltételes egy vagy több modulban. A következő néhány percben tisztázzuk, mit jelent a fenti feltétel, és megnézünk egy példát, ahol hasznos lehet.
Kezdjük!
Tartalomjegyzék
Mi a __name__ jelentősége a Pythonban?
A Pythonban a modul egy .py fájl, amely függvénydefiníciókat, kiértékelendő kifejezéskészletet és egyebeket tartalmaz. Például, ha van egy hello_world.py nevű fájlunk, akkor ezt hello_world.py fájlnak vagy hello_world modulnak nevezzük.
Python-modul futtatásakor a Python-értelmező a végrehajtás előtt beállítja néhány speciális változó értékét: ezek egyike a __name__. A __name__ jelentőségének megértéséhez a kulcs az importálás működésének megértése a Pythonban.
📁 Töltse le a szakasz kódját innen.
Menjen a példa-1 mappához. Megvan a module1.py fájl. A __name__ változó az aktuális modul névterében található.
Ez a modul kiír egy sort, amelyet a __name__ változó értéke követ.
# example-1/module1.py
print("This is module1.")
print(f"The __name__ variable of module 1 is: {__name__}.")
Most futtassuk a modul1-et a parancssorból.
$ python module1.py
A kimenetben azt látjuk, hogy a __name__ változó értéke __main__.
This is module1. The __name__ variable of module 1 is: __main__.
Modulok importálása Pythonban
A Python-modul futtatása mellett néha érdemes lehet használni egy másik Python-modul funkcionalitását az aktuális modulon belül. A Python ezt importtal segíti elő.
Az importálás lehetővé teszi egy másik modul funkcióinak újrafelhasználását – az aktuális modul hatókörébe történő importálással – anélkül, hogy át kellene írnia a kódot.
A module2.py fájl a következőket tartalmazza. Az 1-es modult importáltuk. modul2.
# example-1/module2.py
import module1 # module1 is imported
print(f"This is module2")
print(f"The __name__ variable of module2 is: {__name__}.")
Futtatjuk a module2.py-t, és megfigyeljük a kimenetet.
$ python module2.py
Az alábbi kimenetben:
- Azt látjuk, hogy az 1. modul a motorháztető alatt fut, amikor importáljuk a modul2-be, és a megfelelő kimenet kinyomtatásra kerül.
- De ezúttal a __name__ változó nem __main__, hanem modul1.
- Mivel a modul2-t közvetlenül futtattuk, a modulhoz tartozó __name__ változó mostantól __main__.
Output This is module1. The __name__ variable of module 1 is: module1. This is module2 The __name__ variable of module2 is: __main__.
💡 Kulcs ötlet:
– Ha egy modult közvetlenül futtatunk, akkor a __name__ változó értéke __main__.
– Ha egy modult egy másik modulba importál, a __name__ a modul nevére lesz állítva.
Példa arra, hogy __name__==’__main__’ a Pythonban
A szakaszban az if __name__ == ‘__main__’ feltételes feltétel gyakorlati használati esetét láthatjuk. Meghatározunk egy egyszerű függvényt, majd egységteszteket írunk annak ellenőrzésére, hogy a függvény a várt módon működik-e.
📁 Töltse le a kódot, és kövesse.
Ennek a szakasznak a kódja az example-2 mappában található.
Itt az add.py egy Python-fájl, amely az add_ab() függvény definícióját tartalmazza. Az add_ab() függvény bármelyik két számot beveszi, és visszaadja azok összegét.
# example-2/add.py
def add_ab(a,b):
return a + b
A Python unittest modulját használjuk az add_ab() függvény tesztelésére.
Tesztesetek írása Python-függvényhez
Tekintse meg az alábbi kódrészletet, amely a test_add modul tartalmát tartalmazza.
# example-2/test_add.py
import unittest
from add import add_ab
class TestAdd(unittest.TestCase):
def test_add_23(self):
self.assertEqual(add_ab(2,3), 5)
def test_add_19(self):
self.assertEqual(add_ab(1,9), 10)
def test_add_1_minus7(self):
self.assertEqual(add_ab(1,-7), -6)
A fenti kód a következőket teszi:
- Importálja a Python beépített egységteszt modulját
- Importálja az add_ab() függvényt az add modulból
- Meghatározza a TestAdd tesztosztályt és a tesztesetek halmazát metódusként a tesztosztályon belül
A kód egységteszteinek beállításához először meg kell határoznia egy tesztosztályt, amely a unittest.TestCase-ből öröklődik. Minden tesztesetet metódusként kell megadni az osztályon belül, és a test_ karakterrel kell kezdődnie.
Megjegyzés: Ha nem nevezi el a metódusokat teszt_
Most próbáljuk meg futtatni a test_add modult a terminálról.
$ python test_add.py
Látni fogja, hogy nincs kimenet, és egyik teszt sem futott le.
Miért van ez így?🤔
Ennek az az oka, hogy az egységtesztek futtatásához futtassa a unittestet fő modulként a test_add.py futtatása közben, az alábbi paranccsal.
$ python -m unittest test_add.py
A fenti részletes parancs futtatásakor azt látjuk, hogy mindhárom teszt sikeresen lefutott.
Output ... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK
Azonban kényelmes lesz a tesztek futtatása, ha ez a modul test_add fut, igen? Tanuljuk meg, hogyan kell csinálni a következő részben.
Az if __name__ == ‘__main__’ használata a unittest futtatásához fő modulként
Ha az összes egységtesztet le szeretné futtatni, amikor a modul közvetlenül fut, akkor hozzáadhatja a feltételes feltételt.
# example-2/test_add.py
import unittest
from add import add_ab
class TestAdd(unittest.TestCase):
def test_add_23(self):
self.assertEqual(add_ab(2,3), 5)
def test_add_19(self):
self.assertEqual(add_ab(1,9), 10)
def test_add_1_minus7(self):
self.assertEqual(add_ab(1,-7), -6)
# Run unittest as the main module
if __name__ == '__main__':
unittest.main()
A fenti kódrészletben szereplő feltétel a Python értelmezőnek azt mondja: Ha ez a modul közvetlenül fut, akkor futtassa a kódot benne. unittest.main().
A fenti két kódsor hozzáadása után futtathatja a test_add modult.
$ python test_add.py
▶️ A teszt-hozzáadás modul közvetlen futtatása most mindhárom általunk meghatározott tesztet futtat.
Output ... ---------------------------------------------------------------------- Ran 3 tests in 0.000s OK
A fenti OK kimenet azt jelzi, hogy az összes teszt sikeresen lefutott. A három pont… azt jelzi, hogy három tesztet futtattak, és mindegyik sikeres volt.
Most változtassuk meg a test_add_1_minus7 várható visszatérési értéket 8-ra. Mivel a függvény ebben az esetben – 6-ot ad vissza, egy sikertelen tesztnek kell lennie.
def test_add_1_minus7(self):
self.assertEqual(add_ab(1,-7), 8)
Amint az alábbi kimenetben látható, .F.-t kapunk, a három teszt közül az egyik minta sikertelen volt (a második teszt), a visszakövetésben pedig egy AssertionError-t kapunk, amely – 6 != 8.
Output
.F.
======================================================================
FAIL: test_add_1_minus7 (__main__.TestAdd)
----------------------------------------------------------------------
Traceback (most recent call last):
File "test_add.py", line 12, in test_add_1_minus7
self.assertEqual(add_ab(1,-7), 8)
AssertionError: -6 != 8
----------------------------------------------------------------------
Ran 3 tests in 0.021s
FAILED (failures=1)
Fontos megjegyezni, hogy a tesztek nem feltétlenül ugyanabban a sorrendben futnak, mint a tesztosztályban. A fenti példában a teszt_add_1_minus7 a tesztosztály harmadik metódusaként van definiálva, de a megfelelő tesztet másodikként futtattuk.
Összegezve
Remélem, ez az oktatóanyag segített megérteni, hogyan működik az if __name__ == ‘__main__’ feltételes feltétel a Pythonban.
Íme egy gyors összefoglaló a legfontosabb tudnivalókról:
- A Python-értelmező beállítja a __name__ változót a Python-szkript végrehajtása előtt.
- Ha közvetlenül futtat egy modult, a __name__ értéke __main__.
- Amikor egy másik Python-szkriptbe importál egy modult, a __name__ értéke a modul neve.
- Az if __name__ == ‘__main__’ segítségével szabályozhatja a végrehajtást, és hogy a modul mely részei fussanak a közvetlen és az importált futtatások során.
Ezután tekintse meg ezt a Python-készletekről szóló részletes útmutatót. Jó tanulást!🎉