Tartalomjegyzék
PYTHON nyelvi alapjai ............................................................................................................. 3
Aritmetikai operátorok ........................................................................................................... 3
Kiíratás ................................................................................................................................... 3
Változók ................................................................................................................................. 3
Alapvető adattípusok .............................................................................................................. 4
Beépített adattípusok .............................................................................................................. 5
Az adattípus beállítása ........................................................................................................ 5
Az adott adattípus beállítása ............................................................................................... 5
Gyűjtő adattípusok ................................................................................................................. 6
Tuple................................................................................................................................... 6
Dictionary ........................................................................................................................... 7
Beolvasás, típuskonverziók .................................................................................................... 8
PYTHON vezérlési szerkezetek ................................................................................................. 9
Szelekció ................................................................................................................................ 9
Ismétléses vezérlés (Ciklusok)¶ ........................................................................................... 10
A while utasítás¶ .............................................................................................................. 10
A for utasítás .................................................................................................................... 11
PYTHON függvények .............................................................................................................. 14
Függvénydefiníció ................................................................................................................ 14
Függvényhívás¶ .................................................................................................................... 14
Default paraméterek ............................................................................................................. 14
Nevesített paraméterátadás ................................................................................................... 15
A None érték¶....................................................................................................................... 16
PYTHON stringek .................................................................................................................... 17
Stringek megadása................................................................................................................ 17
Stringek összefűzése ............................................................................................................ 17
Stringek hossza¶ ................................................................................................................... 17
Karakterek indexelése¶ ........................................................................................................ 17
String megfordítása .............................................................................................................. 19
Immutable adattípus¶ ........................................................................................................... 19
Részstring előfordulása¶ ...................................................................................................... 19
Stringkezelő függvények¶ .................................................................................................... 20
Beépített függvények ................................................................................................................ 21
Stringkezelő beépített függvények ....................................................................................... 21
Listakezelő beépített függvények ......................................................................................... 22
PYTHON nyelvi alapjai
Aritmetikai operátorok
Pythonban is használhatók a szokásos aritmetikai operátorok: + (összeadás), - (kivonás), *
(szorzás), / (osztás).
Itt is van az operátorok között egy precedencia (fontossági sorrend). Például a szorzás és
osztás "erősebb", mint az összeadás és kivonás. A műveletek végrehajtási sorrendjét szokásos
módon, zárójelekkel szabályozhatjuk.
Pythonban a / operátor minden esetben lebegőpontos osztást végez. Egészosztásra a //
operátort használhatjuk.
Maradékos osztásra a % operátort használjuk itt is. A ** operátorral hatványozást is
végezhetünk.
Kiíratás
Pythonban a print() beépített függvényt használjuk a konzolra való kiíratáshoz. A függvény
paramétereként megadjuk a kiírandó kifejezést (vagy kifejezéseket).
Változók
A változó átmeneti tárolóhely, amire a nevével hivatkozunk. A tárolóhely a Pythonban az első
használatkor automatikusan létrejön. Egészen addig elérhető, míg fut a program.
A val = 42 létrehozásánál nem adtuk meg expliciten a val változó típusát. Ennek az az oka,
hogy a Python értelmező automatikusan, dinamikusan "ki tudja találni" a változók típusát a
bennük tárolt érték alapján. Ezt úgy is mondjuk, hogy a Python egy dinamikusan típusos
nyelv.
A dinamikusan típusosság egyik érdekes következménye, hogy ugyanabban a változóban akár
eltérő típusú adatokat is tárolhatunk. A type() függvénnyel lekérdezhetjük egy változó típusát.
Alapvető adattípusok




bool: logikai adattípus - True vagy False értéke lehet (ezek a kulcsszavak mindketten
érzékenyek a kis- és nagybetűkre!)
int: egész szám
float: lebegőpontos ("valós") szám
str: szöveges adattípus, string
o megadás: idézőjelek vagy aposztrófok között
o a szokásos escape-szekvenciák itt is működnek
o összefűzés: + operátor
o többszörözés: * operátor
Beépített adattípusok
A változók különböző típusú adatokat tárolhatnak, és a különböző típusok is képesek
különböző dolgok.
A Python alapértelmezés szerint a következő beépített adattípusokkal rendelkezik ezekben a
kategóriákban:
Szöveg típusa:
Numerikus típusok:
Szekvencia típusok:
Leképezés típusa:
Készlettípusok:
Logikai típus:
Bináris típusok:
Nincs Típus:
str
int, , float complex
list, , tuplerange
dict
set, frozenset
bool
bytes, , bytearraymemoryview
NoneType
Az adattípus beállítása
A Pythonban az adattípus akkor van beállítva, amikor értéket rendel egy változóhoz:
Example
x = "Hello World"
x = 20
x = 20.5
x = 1j
x = ["apple", "banana", "cherry"]
x = ("apple", "banana", "cherry")
x = range(6)
x = {"name" : "John", "age" : 36}
x = {"apple", "banana", "cherry"}
x = frozenset({"apple", "banana", "cherry"})
x = True
x = b"Hello"
x = bytearray(5)
x = memoryview(bytes(5))
x = None
Data Type
str
int
float
complex
list
tuple
range
dict
set
frozenset
bool
bytes
bytearray
memoryview
NoneType
Az adott adattípus beállítása
Ha meg szeretnénk adni az adattípust, a következőket kell használni: Konstruktor
függvények:
Example
x = str("Hello World")
x = int(20)
Data Type
str
int
x = float(20.5)
x = complex(1j)
x = list(("apple", "banana", "cherry"))
x = tuple(("apple", "banana", "cherry"))
x = range(6)
x = dict(name="John", age=36)
x = set(("apple", "banana", "cherry"))
x = frozenset(("apple", "banana", "cherry"))
x = bool(5)
x = bytes(5)
x = bytearray(5)
x = memoryview(bytes(5))
float
complex
list
tuple
range
dict
set
frozenset
bool
bytes
bytearray
memoryview
Gyűjtő adattípusok
A Python programozási nyelvben négy gyűjtő adattípus létezik:
 A List egy rendezett és módosítható gyűjtemény. Engedélyezi a tagok duplikálását.
 A Tuple egy rendezett és megváltoztathatatlan gyűjtemény. Engedélyezi a tagok
duplikálását.
 A Set olyan gyűjtemény, amely rendezetlen, megváltoztathatatlan* és indexeletlen.
Nincsenek duplikált tagok.
 A Dictionary egy megrendelt gyűjtemény** és változékony. Nincsenek duplikált tagok.
Tuple
A rekordok több elem tárolására szolgálnak egyetlen változóban.
A Tuple egyike annak a 4 beépített adattípusnak a Pythonban, amelyet a adatok, a másik 3 a
List, Set és Dictionary, mindegyik különböző tulajdonságokkal és használattal.
A tuple egy olyan gyűjtemény, amely rendezett és megváltoztathatatlan.
A tuples kerek zárójelekkel van írva.
A rekordelemek rendezettek, megváltoztathatatlanok, és lehetővé teszik az ismétlődő
értékeket.
A rekordelemek indexelve vannak, az első elem indexelt, a második elem index ...[0][1]
A tuples megváltoztathatatlan, ami azt jelenti, hogy a rekord létrehozása után nem
módosíthatunk, nem adhatunk hozzá vagy távolíthatunk el elemeket.
Mivel a rekordok indexelve vannak, azonos értékű elemeket tartalmazhatnak:
Annak meghatározásához, hogy egy rekord hány elemmel rendelkezik, használja a függvényt:
len()
A beállított elemek megváltoztathatatlanok, de eltávolíthat és/vagy hozzáadhat elemeket amikor csak tetszik.
A Python 3.7-es verziójától kezdve a szótárak sorrendben vannak. A Python 3.6-os és korábbi verzióiban a
szótárak rendezetlenek.
*
**
Ha csak egy elemet tartalmazó rekordot szeretne létrehozni, vesszőt kell hozzáadnia az elem
után, különben a Python nem ismeri fel tuple-ként.
A rekordelemek bármilyen adattípusúak lehetnek. A rekordok különböző adattípusokat
tartalmazhatnak:
Beépített eljárások:
Method
Description
count()
Returns the number of times a specified value occurs in a tuple
index()
Searches the tuple for a specified value and returns the position of where it
was found
Dictionary
A szótárak az adatértékek key:value párokban való tárolására szolgálnak.
A szótár olyan gyűjtemény, amely rendezett, változtatható és nem megengedettek az
ismétlődések.
Az ismétlődő értékek felülírják a meglévő értékeket:
Annak meghatározásához, hogy egy szótár hány elemet tartalmaz, használjuk a függvényt:
len()
Method
clear()
copy()
fromkeys()
get()
items()
keys()
pop()
popitem()
setdefault()
update()
values()
Description
Removes all the elements from the dictionary
Returns a copy of the dictionary
Returns a dictionary with the specified keys and value
Returns the value of the specified key
Returns a list containing a tuple for each key value pair
Returns a list containing the dictionary's keys
Removes the element with the specified key
Removes the last inserted key-value pair
Returns the value of the specified key. If the key does not exist: insert
the key, with the specified value
Updates the dictionary with the specified key-value pairs
Returns a list of all the values in the dictionary
Beolvasás, típuskonverziók
Pythonban az input() függvénnyel olvashatunk be adatot a konzolról.
A függvény paramétereként megadható egy szöveg, ami az input beolvasásakor fog
megjelenni.
A függvény visszatér a beolvasott értékkel, így lementhetjük azt egy változóba.
Az input() függvény minden esetben egy stringet olvas be. Szükség esetén más típusra kell
konvertálnunk a beolvasott értéket!
A típuskonverziókhoz általában a következő függvényeket használjuk:
 int(): egész számra konvertálás
 float(): valós számra konvertálás
 str(): stringre konvertálás.
Figyeljünk arra, hogy Pythonban stringet csak stringgel lehet összefűzni! Ha az összefűzés
operátor valamelyik operandusa nem string típusú, akkor először szöveggé kell azt
alakítanunk az str() függvénnyel!
PYTHON vezérlési szerkezetek
Szelekció
Pythonban a szelekciós vezérlés megvalósítására az if, else és elif utasítások használatosak.
A feltételek megadásakor használható fontosabb feltételes és logikai operátorok:
Példa: Egy program, amely beolvas egy egész számot a standard inputról és kiírja, hogy az
pozitív, nulla vagy negatív
Példa: Logikai operátorok használata
Ismétléses vezérlés (Ciklusok)¶
Pythonban a while és for utasításokat tudjuk használni ismétléses vezérlés megvalósításra.
A while utasítás¶
A while utasítás a klasszikus kezdőfeltételes ismétléses vezérlést valósítja meg.
Szintaxisa:
Ciklus futásának befolyásolása:
 break: megszakítja az aktuális ismétlést és a szerkezetet követő utasításra ugrik
 continue: megszakítja az aktuális ismétlést és a következő iterációra ugrik
A for utasítás
Pythonban a for ciklus nem a klasszikus számlálásos ismétléses vezérlést valósítja meg.
Pythonban ugyanis úgynevezett listaszerű for ciklus van, ami egy elemsorozat bejárására
szolgál. Ekkor a ciklusváltozó rendre felveszi a bejárni kívánt elemsorozat összes értékét.
Nézzünk néhány példát a for utasítás használatára!
Szövegek bejárása
A fenti példában a bejárni kívánt elemsorozatunk egy szöveg ("alma"). A szöveg
karakterekből áll, ezeken a karaktereken iterálunk végig. A betu névre hallgató
ciklusváltozónk minden iterációban felveszi az aktuális karakter értékét, amit kiírunk a
konzolra.
Listák bejárása¶
A for ciklus egy másik gyakori használata a listák bejárása. A listákról egy későbbi
gyakorlaton tanulunk részletesebben, de tulajdonképpen tekinthetünk rájuk úgy, mint a
tömbökre - ők is elemek sorozatát tárolják.
A lista elemeinek bejárása hasonlóképpen történik, mint a szövegek karaktereinek bejárása.
Hagyományos for ciklus szimulálása¶
Felmerülhet bennünk a kérdés, hogy van-e lehetőségünk Pythonban a for ciklust a
"hagyományos" módon, számlálásos ismétléses vezérlésre használnunk. A válasz igen.
Ahhoz, hogy a klasszikus módon tudjuk használni a for ciklust, először egy számokból álló
elemsorozatot kell generálnunk, aminek az elemein végig fogunk iterálni.
A range(start, end, step) függvénnyel egyszerűen generálható ilyen számokból álló
elemsorozat. Ez a függvény legyártja nekünk az egész számokat start-tól end-ig (az end már
nincs benne az elemsorozatban), step lépésközzel.
A start, illetve step paraméterek elhagyhatók. Alapértelmezett módon 0-tól indulunk (start
alapértéke), és 1-esével lépkedünk (step alapértéke).
A step értékeként negatív számot is megadhatunk, ekkor "visszafelé lépkedünk".
Példa: Az egész számok kiíratása 0-tól 10-ig (a 10 már nincs benne)
Példa: Az egész számok kiíratása 1-től 100-ig, 3-as lépésközzel (a 100 már nincs benne)
Példa: Az egész számok kiíratása 20-tól 10-ig ("visszafelé lépkedés", a 10 már nincs benne)
Természetesen a for ciklusban is használhatjuk a break és continue utasításokat.
Példa: Elkezdjük kiíratni az 1 és 100 közötti egész számokat, majd 42-nél kilépünk
Példa: Kiíratjuk egy pizzafeltéteket tároló lista elemeit, viszont ha ananászt látunk, azt
átugorjuk (ízlés kérdése...)
PYTHON függvények
Függvénydefiníció
Pythonban is van lehetőségünk saját függvényeket definiálnunk, majd ezeket később
használnunk, meghívnunk.
A függvénydefiníció szintaxisa a következő (a szögletes zárójelek közötti részek
elhagyhatók):
Itt is használjuk a Python blokkszintaxist, és a függvény törzsét beljebb indentáljuk.
A függvényeink vissza is térhetnek valamilyen értékkel. Ezt a visszatérési értéket a return
kulcsszó után adhatjuk meg.
Függvényhívás¶
A függvények meghívásakor a szokásos szintaxist használjuk:
A függvényhívás során átadjuk a függvénynek a bemeneti paramétereket (feltéve ha a
kérdéses függvény vár paramétert).
Default paraméterek
Azonos nevű függvények esetén a kódban legkésőbb definiált függvény lesz hívható.
Mivel a fenti kódban két hello névre hallgató függvényünk is van, ezért ezek közül a
legutoljára definiált, 1 paramétert váró hello(nev) függvény lesz hívható. Ha a korábban
definiált, 0 paraméteres hello() függvényt próbáljuk meghívni, hibát kapunk.
A gyakorlatban viszont sokszor felmerül az igény arra, hogy egy függvényt akár eltérő
paraméterszámmal is meg tudjunk hívni. Szerencsére a Python biztosít erre egy megoldást,
mégpedig a default függvényparamétereket.
A default paraméterek lényege, hogy a függvény bizonyos paramétereinek alapértelmezett
értéket adunk a függvénydefiníció során. Ha a függvényhíváskor nem adjuk meg az adott
paraméter értékét, akkor az az alapértelmezett értéket veszi fel.
A fenti kódban először paraméter nélkül hívjuk meg a hello függvényt. Mivel a
paraméterváltozónknak nem adtunk át értékét, ezért az az alapértelmezett "Senki" szöveget
fogja felvenni. A második függvényhívásnál már megadtuk a paraméter értékét ("Béla"),
ebben az esetben természetesen ezt fogjuk használni a függvényen belül (nem a default
értéket).
A default paraméterek kapcsán van egy fontos szabály, amit be kell tartanunk: ha nem minden
függvényparaméternek adunk alapértelmezett értéket, akkor mindig az utolsó néhány
paraméternek kell default értéket adnunk (azaz a default paraméterek mindig a paraméterlista
jobb oldalán szerepelnek).
Nevesített paraméterátadás
Default paraméterek használata esetén lehetőségünk van nevesített paraméterátadásra is a
függvényhíváskor. Ekkor az elhagyható paraméterek közül expliciten megmondjuk, hogy
melyiknek az értékét akarjuk megadni (név=érték formában).
Ez alapvetően akkor lehet hasznos, ha nem olyan sorrendben szeretnénk megadni a
paramétereket, mint ahogy azok a függvény paraméterlistájában szerepelnek, vagy esetleg
valahány paraméter értékének megadását ki szeretnénk hagyni a függvényhíváskor.
A fenti példában a függvényhíváskor értéket adtunk az egyetlen kötelező paraméternek
(felhasznalonev), majd nevesített paraméterátadással a legutolsó (szak) paraméternek az
értékét állítottuk be. A középső (jelszo) paraméternek nem adtunk értéket, így az az
alapértelmezett None értéket veszi fel.
A None érték¶
A fenti példában szereplő None egy speciális beépített kulcsszó Pythonban. Ez az "üres
érték", amit más nyelvekben gyakran null-nak neveznek.
PYTHON stringek
Stringek megadása
A stringeket leggyakrabban aposztrófok ('...') vagy idézőjelek ("...") között szoktuk megadni.
A két megadási mód között lényegi különbség nincs.
Több soros szövegeket három darab idézőjel között adhatunk meg. Az így megadott szövegek
megőrzik a sortöréseket. Több soros, internetről kimásolt tartalmakat (pl. dalszövegeket) így
szoktunk megadni.
Stringek összefűzése
A stringek összefűzése a + (plusz) operátorral történik.
Stringek hossza¶
Pythonban a len() beépített függvény segítségével egyszerűen lekérdezhetjük egy tetszőleges
string hosszát (vagyis a szövegben szereplő karakterek számát).
A len() függvény egyébként nem csak stringek, hanem egyéb adattípusok (pl. lista, tuple,
dictionary) hosszát is le tudja kérdezni. A len()-nel még fogunk találkozni a későbbiek során.
Karakterek indexelése¶
Pythonban is van lehetőségünk a stringek karaktereinek az indexelésére. Erre a más
nyelvekből ismerős szögletes zárójel operátort használjuk: szoveg[index].
A karakterek indexelése itt is 0-tól kezdődik (tehát a legelső karakter indexe itt is 0 lesz).
A Python támogatja a negatív indexeket is. Ekkor a string végétől kezdünk el számolni (tehát
az utolsó karakter indexe -1, az utolsó előtti karakteré -2 stb.).
Ha Pythonban nem csak egyetlen karaktert, hanem egy komplett részstringet szeretnénk
lekérdezni, akkor használjuk az intervallumos indexelést.
A szoveg[index] konstrukcióban most index helyén egy intervallumot adhatunk meg,
mettől:meddig:lépésköz formában (a meddig indexű karakter már nem lesz benne a
kihasított részstringben). A három kettősponttal elválasztott érték közül bármelyik
tetszőlegesen elhagyható: alapból a 0. karaktertől megyünk az utolsó karakterig, 1-es
lépésközzel.
String megfordítása
Pythonban, ha egy stringet meg szeretnénk fordítani, akkor az intervallumos indexelést
felhasználva ezt egyszerűen megtehetjük: vesszük a teljes szöveget, csak most nem előrefelé,
hanem visszafelé lépkedve "olvassuk" azt (-1-es lépésköz).
Immutable adattípus¶
Pythonban minden string immutable. Ez azt jelenti, hogy a stringek kezdeti értéke nem
változhat meg. Tehát Pythonban például nem csinálhatunk olyat, hogy egy szöveg adott
karakterét módosítjuk. Ha ezt megpróbáljuk, hibaüzenetet kapunk.
Részstring előfordulása¶
Pythonban, ha le akarjuk ellenőrizni, hogy egy szöveg részstringként szerepel-e egy másik
szövegben, akkor ezt az in kulcsszóval egyszerűen meg tudjuk tenni.
Az s1 in s2 kifejezés igazat ad vissza, ha az s1 szöveg benne van az s2 szövegben.
Stringkezelő függvények¶
A Python rengeteg beépített stringkezelő függvényt biztosít. Ezek közül a legfontosabbakat:
 s.lower(): csupa kisbetűssé alakítja az s stringet
 s.upper(): csupa nagybetűssé alakítja az s stringet
 s.startswith(v): igazat ad vissza, ha az s string a v értékkel kezdődik
 s.endswith(v): igazat ad vissza, ha az s string a v értékre végződik
 s.count(v): visszaadja, hogy az s stringben hányszor szerepel a v érték
 s.strip(): eltávolítja az s string elején és végén lévő helyközöket
 s.lstrip(): csak az s string elején lévő helyközöket távolítja el (left strip)
 s.rstrip(): csak az s string végén lévő helyközöket távolítja el (right strip)
 s.replace(old, new): lecseréli az s stringben az összes old részstringet new-ra
 s.split(delim): feldarabolja az s stringet delim karakterek mentén (listát ad vissza)
 s.isalpha(): igazat ad vissza, ha az s stringben csak betűk szerepelnek
 s.isdigit(): igazat ad vissza, ha az s stringben csak számjegyek szerepelnek
 ...
Az átalakítást végző stringkezelő függvények (pl. lower(), upper(), replace()) az eredeti
stringet sosem módosítják (tudjuk, hogy a string egy immutable adattípus Pythonban), hanem
egy teljesen új szöveggel térnek vissza!
Formázott kiíratás¶
A formázott kiíratás segítségével egyszerűen és intuitíven megadhatók a behelyettesítendő
értékeket (pl. változókat) tartalmazó szövegek. Ekkor - a hagyományos stringösszefűzős
módszerrel ellentétben - nem kell megszakítanunk a szövegünk folytonosságát mindenféle
összefűzésekkel, valamint a típuskonverziókkal sem kell bajlódnunk.
Pythonban a szövegek formázott kiíratására többféle módszert is használhatunk:
format() metódus
%-formatting
f-stringek (Python 3.6-tól).
Beépített függvények
Stringkezelő beépített függvények
Method
capitalize()
casefold()
center()
count()
encode()
endswith()
expandtabs()
find()
format()
format_map()
index()
isalnum()
isalpha()
isdecimal()
isdigit()
isidentifier()
islower()
isnumeric()
isprintable()
isspace()
istitle()
isupper()
join()
ljust()
lower()
lstrip()
maketrans()
partition()
replace()
rfind()
rindex()
rjust()
rpartition()
rsplit()
rstrip()
split()
splitlines()
startswith()
Description
Converts the first character to upper case
Converts string into lower case
Returns a centered string
Returns the number of times a specified value occurs in a string
Returns an encoded version of the string
Returns true if the string ends with the specified value
Sets the tab size of the string
Searches the string for a specified value and returns the position of
where it was found
Formats specified values in a string
Formats specified values in a string
Searches the string for a specified value and returns the position of
where it was found
Returns True if all characters in the string are alphanumeric
Returns True if all characters in the string are in the alphabet
Returns True if all characters in the string are decimals
Returns True if all characters in the string are digits
Returns True if the string is an identifier
Returns True if all characters in the string are lower case
Returns True if all characters in the string are numeric
Returns True if all characters in the string are printable
Returns True if all characters in the string are whitespaces
Returns True if the string follows the rules of a title
Returns True if all characters in the string are upper case
Joins the elements of an iterable to the end of the string
Returns a left justified version of the string
Converts a string into lower case
Returns a left trim version of the string
Returns a translation table to be used in translations
Returns a tuple where the string is parted into three parts
Returns a string where a specified value is replaced with a specified
value
Searches the string for a specified value and returns the last position of
where it was found
Searches the string for a specified value and returns the last position of
where it was found
Returns a right justified version of the string
Returns a tuple where the string is parted into three parts
Splits the string at the specified separator, and returns a list
Returns a right trim version of the string
Splits the string at the specified separator, and returns a list
Splits the string at line breaks and returns a list
Returns true if the string starts with the specified value
strip()
swapcase()
title()
translate()
upper()
zfill()
Returns a trimmed version of the string
Swaps cases, lower case becomes upper case and vice versa
Converts the first character of each word to upper case
Returns a translated string
Converts a string into upper case
Fills the string with a specified number of 0 values at the beginning
Listakezelő beépített függvények
Method
append()
clear()
copy()
count()
extend()
index()
insert()
pop()
remove()
reverse()
sort()
Description
Adds an element at the end of the list
Removes all the elements from the list
Returns a copy of the list
Returns the number of elements with the specified value
Add the elements of a list (or any iterable), to the end of the current list
Returns the index of the first element with the specified value
Adds an element at the specified position
Removes the element at the specified position
Removes the item with the specified value
Reverses the order of the list
Sorts the list