"""VAriable Scope, avagy a változók láthatósága és élettartama
A pythonban vannak a lokális és vannak a globális változók.
A lokális azok általában egy függvényhez, vagy osztályhoz tartoznak.
Tehát ún. funciton scope vagy class scope.
A globális változók azok a modulhoz tartoznak. Modulnak számít
pl egy python fájl, pl ez a 19scope.py ez egy python modulnak számít,
és ennek a fájlnak ennek a modulnak megvan a saját scope-ja, un. modul scope.
Ezen a scope-n belül, bármilyen változót, amit létrehozunk, az globál
is változónak számít a modulon belül.
Elsőnek nézzük meg a funciton scope működését: a két változónk az a
és a b a function scope-hoz tartozik, tehát a függvénynek a scope-jához.
Ez az a és b kizárólagosan ennek a függvénynek a testén belül látható
és elérhető"""
def test():
a = 12
b = 15
print(a, b)
test() #meghívom, lefuttatom
print(a, b) # függvény testén való kiíratás nem fog lefutni
""", az a és b kizárólag ennek a függvénynek a testén belül látható és
elérhető, ha megpróbálom a fv.testén kívül kiíratni,hibát is jelez vissza
pirossal alá is húzza, mert nem találja ezt a két értéket az a és b-t,
mert el vannak rejtve a függvénynek a testében. "a is not definied "
Élettartam: Amikor létre hoztam az a és b változót, és amikor a
függvény meghívjuk, akkor ez a függvény létre hozza az a és b nevezetű
változót, majd hozzá rendeli ezt a két értéket a 12-t és a 15-öt,
majd kiprinteli őket. Amint ez a függvény véget ért, tehát lefutott,
ez az a és b változó törlésre kerül a memóriából. Tehát ezek csak
addig élnek amíg ez a függvény le nem fut. Amint vége ennek a
függvénynek ez a két változó törlődik.
Tehát csak a függvény testén belül léteznek, láthatók, és az
élettartam, csak addig léteznek, amíg a függvény le nem fut,
abba nem hagyja a végrehajtást.Ez volt a function scope, most
pedig nézzük meg a modul scope - t """
"""Modulscope az a az egész modulon belül látható és ez az a
nem egyenlő az előzőekben látott a-val, ami a függvény testében
helyezkedik el."""
a = 78 #ez az a az egész modulon belül látható,
"""modulnak számít minden egyes python file, aminek a fájl
kiterjesztése py, tehát ez az a bárhol a modulon azaz a fájlon
belül elérhető, de fontos, hogy ez az a=78 nem egyenlő a függvény
testében elhelyezkedő a=12-vel."""
def test():
a = 12
b = 15
print(a, b)
test()
print(a)
"""a kiíratom a globális a-t, kiírja, hogy 78, mert a lokalis
a az még mindig 12 lesz, tehát a függvényben lévő a nem írta felül,
a globalis változót. Tehát a lokális függvényben elhelyezkedő a az
egy külön változónak számít. Ha ezt a globális a=78-at akarom átírni
a függvény testén belül, akkor meg lehet neki mondani a függvényen belül,
hogy global=a:"""
a = 78
def test():
global a
"""itt azt mondjuk ezzel a paranccsal, hogy a globalis a-t irja
felül és ne hozzon létre egy új változót a memóriában, hanem a már
meglévő a változót írja felül. """
a = 12
b = 15
print(a)
test()
print(a) #ha most kiíratjuk, most a globalis a erték felveszi a lokál értéket
#Futtasuk le:
a = 78
def test():
global a
a = 12
b = 15
test()
print(a)
#adjunk hozzá egy b változót is:
a = 78
b = 47
def test():
global a, b
a = 12
b = 15
print(a, b)
test() #meghívjuk kiírja, hogy 12 és 17
print(a, b)#szintén 12, 15öt ír ki, de amint elveszem a
global a,b-t 78-at,47-et
""" Ez volt a modul scope.
Fontos megemlíteni, hogy a for és while ciklusoknak nincs
saját scope-juk,
ha létre hozok egy for ciklust, akkor az i átfolyik a globalis
scope-ba. Más nyelvekben, ha létre hozunk egy for loopot azon
belül az indexet, vagyis az index változót, -ami lokális a for loophoz, tehát amint lefutott a for loop ez az i törlődik a memóriából - ez a pythonban átfolyik a globális névtérbe úgymond a modul scope-ba és azután, hogy lefutott a for loop az i még mindig elérhető"""
for i in range(5):
pass
print(i)
"""tehát, ha ezt lefuttatjuk kiírja a 4-et, nem is ad hibát.
Ha ebben létre hozok egy b változót b=54,más program nyelvekben ez
lokális lenne a for loophoz, de a pythonban ez a b ugyanúgy ahogyan
az i átfolyt a globális névtérbe, vagyis a modul scope-ba, és a for loop
testén kívül is elérhető: ha lefuttajuk kiírja 54"""
for i in range(5):
b=54
pass
print(i)
print(b)
"""ugyanez érvényes a while ciklusokra is, tehát, ha a while ciklus
testében lértre hozunk egy változót, az ugynaúgy átfolyik a globalis
vagy a modul scope-ba, és szintén elérhető, ezt a legjobban úgy
tudjuk kijavítani , ha ezeket bele tesszük egy függvénybe"""
def test2():
for i in range(5):
b = 54
pass
print(i)
print(b)
test2()
"""itt már hibát jelez, mert az i b aláhúzásra került, ha a printet
behúzom akkor is elérhető a for loop testén kívül"""
#Akárcsak a for illetve a while esetében az if condicionálisnak
sincsen saját scope - ja:
if True:
c = 10
print(c)
"""A 10 elérhető, noha az if kondicionális testében hoztuk létre,
de úgy néz ki, hogy az if kondicionálisnak sincs saját scopja,
tehát ez a c változó átfolyik továbbra is a modul scope-ba,
akárcsak a for illetve a while ciklusnál.
Viszont itt is kiküszöbölhető, hogy az if-et bele tesszük egy függvénybe."""
def test():
if True:
c = 78
print(c)
"""Így már nem fog működni, mert ez a c benne van ennek a
függvénynek a scope-jába. Ha megpróbáljuk lefuttatni hibát fog jelezni.
Tehát a függvény scope, modul scope és az osztály scope amik a
legfontosabbak lesznek. Amint a függvény lefutott, a függvény testében
létrehozott változók megszűnnek létezni, törlődnek a memóriából,
ezt fontos megjegyezni. Ugyanakkor a modul scope-on belül létrehozott
változók, csak a modulon belül elérhetők, (kivéve, ha importáljuk
a modult egy másik modulba)."""
Nincsenek megjegyzések:
Megjegyzés küldése