A kulcsszavak a Pythonban foglalt szavak. Kulcsszót nem használhatunk változónévként, függvénynévként vagy más azonosítóként.

Itt van az összes kulcsszó listája a Python programozásban

.

.

.

.

A fenti kulcsszavak a Python különböző verzióiban módosulhatnak. Néhány extra hozzáadódhat, vagy néhány eltávolítható. A kulcsszavak listáját az aktuális verzióban mindig megkaphatja, ha a következőt írja be a promptba.

>>> import keyword>>> print(keyword.kwlist)

A kulcsszavak leírása Pythonban példákkal

Az igaz, a hamis

True és a False a Pythonban igazságértékek. Ezek az összehasonlító műveletek vagy logikai (Boolean) műveletek eredményei a Pythonban. Például:

>>> 1 == 1True>>> 5 > 3True>>> True or FalseTrue>>> 10 <= 1False>>> 3 > 7False>>> True and FalseFalse

Itt láthatjuk, hogy az első három állítás igaz, így az értelmező True-et ad vissza, a fennmaradó három állításra pedig False-t ad vissza. A True és False pythonban ugyanaz, mint a 1 és 0. Ezt a következő példával igazolhatjuk:

>>> True == 1True>>> False == 0True>>> True + True2

None

None egy speciális konstans a Pythonban, amely az érték hiányát vagy a null értéket jelöli.

Ez egy saját adattípusú objektum, a NoneType. Több None objektumot nem tudunk létrehozni, de változóhoz rendelhetjük. Ezek a változók egyenlőek lesznek egymással.

Különösen ügyelnünk kell arra, hogy a None ne jelentsen False, 0 vagy bármilyen üres listát, szótárt, stringet stb. Például:

>>> None == 0False>>> None == False>>> None == FalseFalse>>> x = None>>> y = None>>> x == yTrue

Az üres függvények, amelyek nem adnak vissza semmit, automatikusan egy None objektumot adnak vissza. A None objektumot azok a függvények is visszaadják, amelyekben a programfolyamat nem találkozik visszatérési utasítással. Például:

def a_void_function(): a = 1 b = 2 c = a + bx = a_void_function()print(x)

Kimenet

None

Ez a program egy olyan függvényt tartalmaz, amely nem ad vissza értéket, bár néhány műveletet végez benne. Tehát amikor kiírjuk az x-et, akkor None kapjuk, ami automatikusan (implicit módon) visszakerül. Hasonlóképpen, itt egy másik példa:

def improper_return_function(a): if (a % 2) == 0: return Truex = improper_return_function(3)print(x)

Kimenet

None

Bár ennek a függvénynek van egy return utasítása, azt nem minden esetben éri el. A függvény csak akkor adja vissza True, ha a bemenet páros.

Ha páratlan számot adunk meg a függvénynek, akkor implicit módon None kapjuk vissza.

és, vagy , nem

and, or, not a logikai operátorok a Pythonban. Az and csak akkor eredményez True-et, ha mindkét operandus True. Az and igazságtáblázatát az alábbiakban adjuk meg:

igazságtáblázata.

.

or True lesz az eredmény, ha bármelyik operandus True. A or igazságtáblázatát az alábbiakban adjuk meg:

igazságtáblája.

not operátor az igazságérték megfordítására szolgál. A not igazságtáblázatát az alábbiakban adjuk meg:

.

alább néhány példa a használatukra

>>> True and FalseFalse>>> True or FalseTrue>>> not FalseTrue

as

as egy modul importálása során alias létrehozására szolgál. Ez azt jelenti, hogy importálás közben egy másik (felhasználó által meghatározott) nevet adunk egy modulnak.

A Pythonban például van egy math nevű szabványos modul. Tegyük fel, hogy ki akarjuk számolni, hogy mi a koszinusz pi egy alias segítségével. Ezt a következőképpen tehetjük meg: as:

>>> import math as myAlias>>>myAlias.cos(myAlias.pi)-1.0

Itt a math modult importáltuk úgy, hogy a myAlias nevet adtuk neki. Most már ezzel a névvel hivatkozhatunk a math modulra. Ezt a nevet használva kiszámítottuk a cos(pi)-t, és -1.0 kaptuk meg a választ.

assert

assert hibakeresésre használjuk.

A programozás során néha szeretnénk megismerni a belső állapotot, vagy ellenőrizni, hogy a feltételezéseink igazak-e? A assert segít nekünk ebben és a hibák kényelmesebb megtalálásában. A assert után egy feltétel következik.

Ha a feltétel igaz, akkor nem történik semmi. Ha azonban a feltétel hamis, akkor AssertionError lép fel. Például:

>>> a = 4>>> assert a < 5>>> assert a > 5Traceback (most recent call last): File "<string>", line 301, in runcode File "<interactive input>", line 1, in <module>AssertionError

A jobb megértésünk érdekében a AssertionError mellé kiírandó üzenetet is megadhatunk.

>>> a = 4>>> assert a > 5, "The value of a is too small"Traceback (most recent call last): File "<string>", line 301, in runcode File "<interactive input>", line 1, in <module>AssertionError: The value of a is too small

Ezzel a ponttal megjegyezhetjük,

assert condition, message

a

if not condition: raise AssertionError(message)

async, await

A async és await kulcsszavakat a Python asyncio könyvtára biztosítja. Egyidejű kód írására szolgálnak Pythonban. Például,

import asyncioasync def main(): print('Hello') await asyncio.sleep(1) print('world')

A program futtatásához használjuk a

asyncio.run(main())

A fenti programban a async kulcsszó azt adja meg, hogy a függvény aszinkron módon kerüljön végrehajtásra.

Itt az első Hello kiírásra kerül. A await kulcsszó hatására a program 1 másodpercet várakozik. Ezután a világ kiíródik.

break, continue

break és continue a for és while ciklusokon belül használjuk, hogy megváltoztassuk azok normál viselkedését.

break véget vet a legkisebb ciklusnak, amelyben van, és a vezérlés a közvetlenül a ciklus alatt lévő utasításhoz áramlik. A continue a ciklus aktuális iterációjának befejezését okozza, de nem az egész ciklusét.

Ezt a következő két példával szemléltethetjük:

for i in range(1,11): if i == 5: break print(i)

Kimenet

1234

Itt a for ciklus 1-től 10-ig terjedő számokat kíván kiírni. De a if feltétel teljesül, amikor i egyenlő 5-tel, és megszakítjuk a hurkot. Így csak az 1-től 4-ig terjedő tartományt nyomtatjuk ki.

for i in range(1,11): if i == 5: continue print(i)

Kimenet

1234678910

Itt a continue-t használjuk ugyanerre a programra. Tehát, ha a feltétel teljesül, akkor az az iteráció kihagyásra kerül. De nem lépünk ki a ciklusból. Ezért az 5 kivételével az összes értéket kiírjuk.

Tudjon meg többet a Python break és continue utasításról.

class

class egy új, felhasználó által definiált osztály definiálására szolgál a Pythonban.

Az osztály olyan kapcsolódó attribútumok és metódusok gyűjteménye, amelyek egy valós helyzetet próbálnak reprezentálni. Ez az ötlet, hogy az adatokat és a funkciókat egy osztályba foglaljuk, központi szerepet játszik az objektumorientált programozás (OOP) koncepciójában.

Az osztályok a programban bárhol definiálhatók. Jó gyakorlat azonban egyetlen osztályt definiálni egy modulban. Az alábbiakban egy használati példát mutatunk be:

class ExampleClass: def function1(parameters): … def function2(parameters): …

Tudjon meg többet a Python objektumokról és osztályokról.

def

def egy felhasználó által definiált függvény definiálására szolgál.

A függvény olyan összefüggő utasítások blokkja, amelyek együttesen valamilyen konkrét feladatot végeznek. Segít a kódot kezelhető darabokba szervezni, valamint bizonyos ismétlődő feladatok elvégzésében.

A def használata az alábbiakban látható:

def function_name(parameters): …

Tudjon meg többet a Python függvényekről.

del

del egy objektumra való hivatkozás törlésére szolgál. Pythonban minden objektum. A del

>>> a = b = 5>>> del a>>> aTraceback (most recent call last): File "<string>", line 301, in runcode File "<interactive input>", line 1, in <module>NameError: name 'a' is not defined>>> b5

segítségével törölhetünk egy változóreferenciát.Itt láthatjuk, hogy az a változó hivatkozását töröltük. Tehát már nem definiált. De b még mindig létezik.

del arra is használják, hogy egy listából vagy szótárból töröljünk elemeket:

>>> a = >>> del a>>> a

if, else, elif

if, else, elif feltételes elágazásra vagy döntéshozatalra használjuk.

Ha valamilyen feltételt akarunk tesztelni, és csak akkor akarunk végrehajtani egy blokkot, ha a feltétel igaz, akkor a if és elif-t használjuk. A elif az else if rövidítése. else az a blokk, amely akkor kerül végrehajtásra, ha a feltétel hamis. Ez a következő példából világossá válik:

def if_example(a): if a == 1: print('One') elif a == 2: print('Two') else: print('Something else')if_example(2)if_example(4)if_example(1)

Kimenet

TwoSomething elseOne

Itt a függvény ellenőrzi a bemeneti számot, és kiírja az eredményt, ha az 1 vagy 2. Minden ettől eltérő bemenet a kód else részének végrehajtását eredményezi.

Tudjunk meg többet a Python if és if…else utasításról.

except, raise, try

except, raise, try a Pythonban a kivételekkel együtt használják.

A kivételek alapvetően olyan hibák, amelyek arra utalnak, hogy valami rosszul sikerült a programunk végrehajtása közben. IOError, ValueError, ZeroDivisionError, ImportError, NameError, TypeError stb. néhány példa a kivételekre Pythonban. A try...except blokkok a kivételek fogására szolgálnak Pythonban.

A raise kulcsszóval explicit módon is kivételt kelthetünk. A következő példa:

def reciprocal(num): try: r = 1/num except: print('Exception caught') return return rprint(reciprocal(10))print(reciprocal(0))

Kimenet

0.1Exception caughtNone

Itt a reciprocal() függvény a bemeneti szám reciprokát adja vissza.

Ha 10-et írunk be, akkor a normál kimenet 0,1 lesz. De amikor 0-t adunk be, akkor automatikusan ZeroDivisionError keletkezik.

Ezt a try…except blokkunk elkapja, és None-et adunk vissza. A ZeroDivisionError-t explicit módon is előidézhettük volna a bemenet ellenőrzésével, és máshol kezelhettük volna az alábbiak szerint:

if num == 0: raise ZeroDivisionError('cannot divide')

végre

finally a try…except blokkal együtt használják az erőforrások vagy fájlfolyamok lezárására.

A finally használata biztosítja, hogy a benne lévő kódblokk akkor is végrehajtásra kerüljön, ha kezeletlen kivétel lép fel. Például:

try: Try-blockexcept exception1: Exception1-blockexcept exception2: Exception2-blockelse: Else-blockfinally: Finally-block

Ez esetben, ha a Try-block-ban kivétel van, azt a except vagy else blokkban kezeljük. De mindegy, hogy milyen sorrendben folyik a végrehajtás, abban biztosak lehetünk, hogy a Finally-block hiba esetén is végrehajtásra kerül. Ez hasznos az erőforrások megtisztításánál.

Tudjon meg többet a kivételek kezeléséről a Python programozásban.

for

for a cikluskezelést használja. Általában akkor használjuk a for, ha tudjuk, hányszor akarunk hurkot csinálni.

A Pythonban bármilyen típusú szekvenciával, például listával vagy sztringgel használhatjuk. Íme egy példa, amelyben a for egy névlistán való átfutásra szolgál:

names = for i in names: print('Hello '+i)

Kimenet

Hello JohnHello MonicaHello StevenHello Robin

Tudjon meg többet a Python for loopról.

from, import

import kulcsszóval modulokat importálunk az aktuális névtérbe. A from…import kulcsszó meghatározott attribútumok vagy függvények importálására szolgál az aktuális névtérbe. Például:

import math

importálja a math modult. Most már használhatjuk a benne lévő cos() függvényt math.cos()-ként. De ha csak a cos() függvényt szeretnénk importálni, ezt megtehetjük a from as

from math import cos

most már egyszerűen cos()ként használhatjuk a függvényt, nem kell math.cos().

Tudj meg többet a Python modulokról és az import utasításról.

global

global arra szolgál, hogy deklaráljuk, hogy egy függvényen belüli változó globális (függvényen kívüli).

Ha egy globális változó értékét kell kiolvasnunk, nem szükséges globalként definiálni. Ez érthető.

Ha egy függvényen belül kell módosítanunk egy globális változó értékét, akkor azt global-val kell deklarálnunk. Ellenkező esetben egy ilyen nevű helyi változó jön létre.

Az alábbi példa segít ezt tisztázni.

globvar = 10def read1(): print(globvar)def write1(): global globvar globvar = 5def write2(): globvar = 15read1()write1()read1()write2()read1()

Kimenet

1055

Itt a read1() függvény csak a globvar értékét olvassa be. Tehát nem kell deklarálnunk, hogy global. A write1() függvény azonban módosítja az értéket, ezért a változót global-ként kell deklarálnunk.

A kimenetünkön láthatjuk, hogy a módosítás valóban megtörtént (a 10 5-re változott). A write2() is megpróbálja módosítani ezt az értéket. De mi nem deklaráltuk global.

Ezért egy új helyi változó globvar jön létre, ami nem látható ezen a függvényen kívül. Bár ezt a helyi változót 15-re módosítjuk, a globális változó változatlan marad. Ez jól látható a kimenetünkön.

in

in arra szolgál, hogy megvizsgáljuk, hogy egy sorozat (lista, tuple, string stb.) tartalmaz-e értéket. Ha az érték jelen van, akkor True, ellenkező esetben False értéket ad vissza. Például:

>>> a = >>> 5 in aTrue>>> 10 in aFalse

A in másodlagos felhasználása a sorozat for hurokban történő végigjárása.

for i in 'hello': print(i)

Output

hello

is

is A Pythonban az objektumok azonosságának tesztelésére használják. Míg a == operátorral azt vizsgáljuk, hogy két változó egyenlő-e vagy sem, addig a is operátorral azt vizsgáljuk, hogy a két változó ugyanarra az objektumra utal-e.

Az True értéket adja vissza, ha az objektumok azonosak, és False, ha nem.

>>> True is TrueTrue>>> False is FalseTrue>>> None is NoneTrue

Tudjuk, hogy a True, False és None csak egy példánya létezik a Pythonban, tehát azonosak.

>>> == True>>> is False>>> {} == {}True>>> {} is {}False

Egy üres lista vagy szótár egyenlő egy másik üres listával vagy szótárral. De ezek nem azonos objektumok, mivel külön-külön helyezkednek el a memóriában. Ennek az az oka, hogy a lista és a szótár mutálható (az érték megváltoztatható).

>>> '' == ''True>>> '' is ''True>>> () == ()True>>> () is ()True

A listával és a szótárral ellentétben a string és a tuple megváltoztathatatlan (az egyszer definiált érték nem változtatható). Ennélfogva két azonos string vagy tuple is azonos. Ugyanarra a memóriahelyre hivatkoznak.

lambda

lambda névtelen függvény (név nélküli függvény) létrehozására szolgál. Ez egy olyan inline függvény, amely nem tartalmaz return utasítást. Egy kifejezésből áll, amelyet kiértékel és visszaad. Például:

a = lambda x: x*2for i in range(1,6): print(a(i))

Kimenet

246810

Itt egy olyan inline függvényt hoztunk létre, amely megduplázza az értéket, a lambda utasítás használatával. Ezt arra használtuk, hogy megduplázzuk az értékeket egy 1-től 5-ig terjedő listában.

Tudjon meg többet a Python lamda függvényről.

nonlocal

A nonlocal kulcsszó használata nagyon hasonló a global kulcsszóhoz. A nonlocal annak deklarálására szolgál, hogy egy beágyazott függvényben (függvény egy függvényen belüli függvény) lévő változó nem lokális, vagyis a külső beágyazó függvényben található. Ha egy nem lokális változó értékét kell módosítanunk egy beágyazott függvényen belül, akkor azt a nonlocal-val kell deklarálnunk. Ellenkező esetben egy ilyen nevű helyi változó jön létre a beágyazott függvényen belül. A következő példa segít ennek tisztázásában.

def outer_function(): a = 5 def inner_function(): nonlocal a a = 10 print("Inner function: ",a) inner_function() print("Outer function: ",a)outer_function()

Kimenet

Inner function: 10Outer function: 10

Itt a inner_function() a outer_function-be van beágyazva.

Az a változó a outer_function()-ben van. Ha tehát a inner_function()-ban akarjuk módosítani, akkor nonlocal-ként kell deklarálnunk. Vegyük észre, hogy az a nem globális változó.

A kimenetből láthatjuk, hogy a változót sikeresen módosítottuk a beágyazott inner_function()-ban. Ha nem használjuk a nonlocal kulcsszót, az eredmény a következő:

def outer_function(): a = 5 def inner_function(): a = 10 print("Inner function: ",a) inner_function() print("Outer function: ",a)outer_function()

Kimenet

Inner function: 10Outer function: 5

Itt nem deklaráljuk, hogy az a változó a beágyazott függvényen belül nonlocal. Ezért egy új, azonos nevű lokális változó jön létre, de a nem lokális a nem módosul, ahogy a kimenetünkön látható.

pass

pass a Pythonban egy null utasítás. Végrehajtásakor nem történik semmi. Helytartóként van használva.

Tegyük fel, hogy van egy függvényünk, ami még nincs implementálva, de a jövőben szeretnénk implementálni. Ha egyszerűen azt írjuk,

def function(args):

a program közepén, akkor IndentationErrorot kapunk. Ehelyett a pass utasítással üres testet építünk.

def function(args): pass

Egy üres class-ben is megtehetjük ugyanezt.

class example: pass

return

return utasítással egy függvényen belül kilépünk belőle és visszaadunk egy értéket.

Ha nem adunk vissza explicit módon értéket, akkor a None automatikusan visszatér. Ezt a következő példával igazoljuk.

def func_return(): a = 10 return adef no_return(): a = 10print(func_return())print(no_return())

A kimenet

10None

while

while a Pythonban a ciklusozásra szolgál.

Az while cikluson belüli utasítások addig folytatódnak, amíg a while ciklus feltétele False-ra nem értékelődik, vagy egy break utasítással nem találkozunk. Az alábbi program ezt szemlélteti.

i = 5while(i): print(i) i = i – 1

Kimenet

54321

Megjegyezzük, hogy a 0 egyenlő False-val.

Tudjon meg többet a Python while ciklusról.

with

with utasítás arra szolgál, hogy egy kódblokk végrehajtását a kontextuskezelő által definiált metódusokba csomagolja.

A kontextuskezelő egy osztály, amely __enter__ és __exit__ metódusokat valósít meg. A with utasítás használata biztosítja, hogy a __exit__ metódus a beágyazott blokk végén meghívásra kerüljön. Ez a koncepció hasonló a try…finally blokk használatához. Íme, egy példa.

with open('example.txt', 'w') as my_file: my_file.write('Hello world!')

Ez a példa a Hello world! szöveget írja a example.txt fájlba. A fájlobjektumokban __enter__ és __exit__ metódus van definiálva, így saját kontextuskezelőként működnek.

Először a __enter__ metódust hívjuk meg, majd a with utasításon belüli kódot hajtjuk végre, végül a __exit__ metódust hívjuk meg. A __exit__ metódus hiba esetén is meghívásra kerül. Lényegében lezárja a fájlfolyamot.

yield

yield egy függvényen belül, mint egy return utasítás. De a yield egy generátort ad vissza.

A generátor egy iterátor, amely egyszerre egy elemet generál. Egy nagy értéklista sok memóriát foglal el. A generátorok hasznosak ebben a helyzetben, mivel egyszerre csak egy értéket generál ahelyett, hogy az összes értéket a memóriában tárolná. Például,

>>> g = (2**x for x in range(100))

létrehoz egy g generátort, amely a 2-es hatványokat generálja a 99-es hatványra emelt kettes számig. A számokat a next() függvény segítségével generálhatjuk az alábbiak szerint.

>>> next(g)1>>> next(g)2>>> next(g)4>>> next(g)8>>> next(g)16

És így tovább… Ezt a típusú generátort a yield utasítás adja vissza egy függvényből. Íme, egy példa.

def generator(): for i in range(6): yield i*ig = generator()for i in g: print(i)

Kimenet