Ugrás a tartalomhoz

Python

A Wikiszótárból, a nyitott szótárból

Főnév

Python (tsz. Pythons)

  1. (informatika) Python nyelv

A Python egy általános célú, magas szintű programozási nyelv, melyet Guido van Rossum holland programozó tervezett meg az 1980-as évek végén. 1989 decemberében kezdte el a fejlesztését a CWI kutatóintézetben, majd az első nyilvános verzió 1991 februárjában jelent meg 0.9.0 kódszámon a Usenet hírcsoportjaiban. A nyelv nevét nem a kígyóról, hanem a Monty Python Repülő Cirkusza című brit televíziós komédiasorozatról kapta.

A Python gyorsan népszerű lett a fejlesztők körében, köszönhetően egyszerűségének és hatékonyságának. Az 1994-ben megjelent 1.0-s verzió után 2000 októberében kiadták a Python 2.0-t, majd 2008-ban a Python 3.0 verziót. A Python 3 számos fejlesztést és újítást hozott, ugyanakkor nem volt visszafelé kompatibilis a korábbi 2-es ág programjaival. A két fő verziósorozat egy ideig párhuzamosan létezett, de a Python 2 utolsó hivatalos kiadása (2.7.18) 2020-ban jelent meg, azóta hivatalosan csak a Python 3 vonalat fejlesztik és támogatják. Napjainkban a Python a világ egyik legnépszerűbb programozási nyelve, aktív felhasználói és fejlesztői közösséggel.

A Python nyelv főbb jellemzői

A Python tervezési filozófiájának középpontjában az átlátható, könnyen olvasható kód áll. Szintaxisa egyszerű és könnyen tanulható, lehetővé teszi tömör, de mégis jól olvasható programok írását. A Python nyílt forráskódú és ingyenesen hozzáférhető, bármilyen platformon szabadon használható (Windows, Linux, macOS stb.). A forráskód futtatásához a nyelv egy interpreter programot alkalmaz, így nincs szükség külön fordítási lépésre: a Python kód közvetlenül futtatható a megírása után.

A legfontosabb jellemzők összefoglalva:

  • Dinamikus típusosság: A Python dinamikus típusozású nyelv, ami azt jelenti, hogy a változók típusát nem kell előre megadni. Minden adatnak futásidőben van egy meghatározott típusa, amely az értékhez kapcsolódik, nem magához a változóhoz. Ennek köszönhetően a kód rugalmasabb, de a program futása közben derülnek ki a típushibák (ellentétben a statikusan típusos nyelvekkel, ahol már fordításkor). Megjegyzés: a Python erősen típusos nyelv, tehát például nem végez automatikus típuskonverziót – nem adható össze szöveg és szám anélkül, hogy a megfelelőket kifejezetten át ne alakítanánk.
  • Többparadigmás szemlélet: A Python több programozási paradigmát is támogat. Lehetőség van az objektumorientált programozásra (osztályok és objektumok használatával), de éppúgy írhatunk strukturált, eljárásorientált programokat is (függvényekkel és modulokkal). Emellett a nyelv tartalmaz funkcionális programozási elemeket is (pl. első osztályú függvények, lambda kifejezések, list comprehension-ök), lehetővé téve a deklaratív stílus alkalmazását.
  • Gazdag standard könyvtár: A Python “akkumulátorokat is tartalmaz” filozófiája azt jelenti, hogy egy kiterjedt szabványos könyvtár tartozik hozzá, mely rengeteg hasznos modult biztosít a különféle feladatokhoz. A standard könyvtár része például a matematikai műveleteket tartalmazó math modul, a véletlen számokat generáló random modul, az operációs rendszer műveleteit segítő os és sys modulok, a dátumokat kezelő datetime modul és még számos egyéb komponens. A “batteries included” szemléletnek köszönhetően sok alapvető feladatra azonnal rendelkezésre áll megoldás a standard könyvtárban, anélkül hogy külső csomagokat kellene telepíteni.
  • Olvashatóság és egyszerű szintaxis: A Python szintaxisa könnyen olvasható, nagyban támaszkodik a központozás helyett a kód szerkezetét jelölő behúzásra. A kód blokkokat kapcsos zárójelek helyett indentálással jelöljük, ami kötelező jellegű – így a kód egységesen formázott és érthető lesz. Emellett a Pythonban sok, más nyelvekben szükséges elem (pl. pontosvessző a sorok végén, típusdeklarációk) elhagyható, ami tovább csökkenti a kód “zajosságát”. Az egyszerű nyelvtan és a beszédes kulcsszavak segítik a kezdőket a nyelv gyors elsajátításában.

Telepítés és első lépések

A Python telepítése

A Python használatához először telepítenünk kell a nyelv interpreterét a számítógépünkre. A legfrissebb Python verzió telepítőcsomagjai letölthetők a hivatalos weboldalról (python.org) Windows, macOS és Linux rendszerekre egyaránt. Windows rendszeren a telepítő futtatása során érdemes bejelölni az “Add Python to PATH” opciót, hogy a Python parancssorból is elérhető legyen. macOS esetén a Python 3 telepítő futtatásával pár kattintással telepíthető a nyelv. Linux disztribúcióknál gyakran már előre telepítve van valamilyen Python verzió, vagy a csomagkezelő (pl. apt, dnf) segítségével egyszerűen telepíthető.

Telepítés után érdemes ellenőrizni, hogy minden rendben van-e. Nyissunk meg egy terminál/Parancssor ablakot, és írjuk be a python --version (vagy esetleg python3 --version) parancsot. Ha a telepítés sikeres volt, a parancs kiírja a Python verziószámát (pl. “Python 3.12.0”).

A Pythonhoz tartozik egy egyszerű integrált fejlesztői környezet, az IDLE, amelyet a telepítő csomag Windowson automatikusan feltesz. Az IDLE vagy akár a rendszertől függően Python Shell segítségével azonnal kipróbálhatjuk a nyelvet interaktív módban. Ezen kívül számos fejlettebb fejlesztői eszköz (IDE) létezik Pythonhoz, például a PyCharm, a Visual Studio Code vagy a Jupyter Notebook, de kezdésnek az IDLE és egy egyszerű szövegszerkesztő is megteszi.

Első program: “Hello, World!”

Hagyomány a programozás oktatásban, hogy az első programunk egy üdvözlő üzenetet jelenít meg. Hozzunk létre egy fájlt pl. hello.py néven, vagy nyissuk meg az IDLE felületét, és írjuk be a következő kódot:

print("Hello, World!")

Mentés és futtatás után a program kimenete:

Hello, World!

Gratulálunk, elkészült az első Python programod! A print() függvény kiírja a zárójelben megadott szöveget a kimenetre. Írhatunk más üzenetet is a kiíratásba, vagy kipróbálhatjuk, mi történik, ha a print függvénynek számokat adunk át.

Ha a programunkat fájlban írtuk meg (pl. hello.py), akkor azt parancssorban a python hello.py parancs kiadásával tudjuk futtatni. Interaktív módban pedig a Python promptjánál (>>>) közvetlenül is beírhatjuk a fenti print("Hello, World!") utasítást, ami azonnal végrehajtódik.

Szintaxis alapjai: változók, adattípusok, operátorok

A Python szintaxisa sok szempontból letisztult és egyszerű. Nézzük meg a legalapvetőbb elemeket: hogyan kezelhetünk változókat és adattípusokat, valamint milyen operátorokat használhatunk.

Változók és adattípusok: A változó egy név, amely egy adott értékre (objektumra) mutat. Pythonban a változókat nem kell előre deklarálni és a típusukat sem kell megadni – a változó akkor jön létre, amikor értéket rendelünk hozzá. Például:

# Változók létrehozása különböző típusú értékekkel
szam = 10        # egész szám (int)
pi = 3.14        # lebegőpontos szám (float)
nev = "Python"   # szöveg (string)
logikai = True   # logikai érték (bool)

Megjegyzések (kommentek): A kódba fűzött megjegyzések segítik a kód érthetőségét. Pythonban a # jellel kezdődő rész egy sorban kommentnek számít, azaz azt a részt a Python nem hajtja végre. Például:

# Ez egy komment, a Python ezt figyelmen kívül hagyja.
szam = 42  # A sor végén is lehet komment

Megjegyzés: Létezik többsoros komment lehetőség is, ha három idézőjel („triple quotes”) közé írjuk a szöveget, de ezt a gyakorlatban leginkább dokumentációs sztringek (docstring) készítésére használjuk.

A fenti példában látható, hogy a szam változónak egy egész számot adtunk értékül, míg a pi változó egy valós (lebegőpontos) számot tartalmaz. A nev egy szöveget (sztringet), a logikai pedig egy boolean (logikai) értéket tartalmaz. Pythonban ezek alapvető beépített típusok. További fontosabb típusok például: komplex számok (complex), nincsen érték (NoneType, amit a None literállal jelölünk), stb. A változók aktuális típusát a beépített type() függvénnyel kérdezhetjük le, például type(szam) kimenete <class 'int'> lesz.

A változók neve tetszőleges betűkkel és számokkal alkotható meg (de nem kezdődhet számmal), és érdemes beszédes neveket használni, hogy a kód érthető maradjon. Pythonban fontos, hogy a kód elrendezése (behúzás) jelzi a blokkstruktúrát, így például egy függvény törzsében a sorokat azonos mértékben behúzva kell írni. A behúzás mértékére általában 4 szóközt használunk.

Operátorok: A Pythonban a szokásos aritmetikai operátorok elérhetők: + (összeadás), - (kivonás), * (szorzás), / (osztás). Figyeljük meg, hogy a / operátor mindig lebegőpontos eredményt ad (még akkor is, ha a két operandus egész), például 5/2 eredménye 2.5. Ha egész osztási eredményt szeretnénk (maradék nélkül osztás), használjuk a // operátort: 5//2 eredménye 2. A ** operátor hatványozást jelent, pl. 2**3 == 8. A + operátor sztringeken alkalmazva konkatenációt (egymás utáni fűzést) végez: "Py" + "thon" == "Python". Emellett a Python 3-ban elérhetők ún. f-stringek (formázott sztringek) is, amelyek segítségével a szöveg literálba közvetlenül beilleszthetjük változók értékét. Például:

nev = "Python"
print(f"Üdv, {nev}!")  # Üdv, Python!

Ez az f"..."" szintaxis a kapcsos zárójelek közé írt változók vagy kifejezések értékét a helyére illeszti a kiíráskor.

Pythonban használhatunk összehasonlító operátorokat is: pl. == (egyenlő-e), != (nem egyenlő), <, >, <=, >=. Ezek logikai értéket adnak eredményül. Logikai műveletekhez az and (logikai ÉS), or (logikai VAGY) és not kulcsszavakat használjuk. Példa:

x = 7
y = 5
eredmeny = (x > 0) and (y < 0)
print(eredmeny)  # False, mert x > 0 igaz, de y < 0 hamis

A fenti példában az and operátorral kötött kifejezés akkor igaz (True), ha mindkét része igaz; különben hamis (False).

Feltételes elágazások és ciklusok

Most, hogy megismertük az alapvető nyelvi elemeket, lássuk, hogyan irányíthatjuk a program futásának menetét feltételes elágazásokkal és ciklusokkal.

Feltételes elágazás (if-elif-else)

A feltételes elágazások segítségével a program különböző útvonalakon haladhat attól függően, hogy egy feltétel teljesül-e vagy sem. Pythonban az „if” kulcsszóval vezethető be egy feltétel, amelyet egy logikai kifejezés (igaz vagy hamis értékű) követ. Az if blokk után opcionálisan „elif” („else if” rövidítése) ágakat adhatunk meg további feltételekkel, végül pedig egy „else” ágat, ami akkor fut le, ha egyetlen fenti feltétel sem teljesül. Fontos, hogy a feltétel után „colon” (:) írunk, és az alá tartozó blokkot behúzva (általában 4 szóközzel) írjuk.

Például készítsünk egy programot, ami egy szám előjelét állapítja meg:

szam = -5
if szam > 0:
    print("A szám pozitív.")
elif szam == 0:
    print("A szám nulla.")
else:
    print("A szám negatív.")

A fenti kódban, ha a szam értéke nagyobb, mint 0, a program kiírja, hogy pozitív a szám. Ha egyenlő 0-val, akkor azt jelzi, hogy a szám nulla, máskülönben (vagyis ha kisebb 0-nál) azt írja ki, hogy negatív. A feltételes ágak közül mindig csak az egyik fut le attól függően, hogy melyik feltétel igaz.

Ciklusok (ismétlés)

A ciklusok lehetővé teszik, hogy egy kódrészt többször egymás után végrehajtsunk. Pythonban két fő ciklustípus van: a for és a while ciklus.

  • for ciklus: A for ciklus bejárásra szolgál; végig tudunk vele menni egy sorozaton, listán vagy bármilyen iterálható adatszerkezeten. Szintaxisa: for <elem> in <gyűjtemény>:. Például:

    nevek = ["Anna", "Bela", "Cili"]
    for nev in nevek:
        print("Hello, " + nev + "!")
    

    A példa kimenete:

    Hello, Anna!
    Hello, Bela!
    Hello, Cili!

    Itt a nevek listának minden elemére sorban lefut a ciklus, és kiírja az adott nevet egy üdvözléssel. A for ciklus sok esetben a range() függvénnyel használható, amely egy számokból álló sorozatot generál:

    for i in range(5):
        print(i)
    

    Ez a példa 0-tól 4-ig kiírja a számokat (az alapértelmezett range(5) a 0,1,2,3,4 sorozatot adja).

  • while ciklus: A while ciklus addig ismétel egy blokkot, amíg egy feltétel igaz marad. Szintaxisa: while <feltétel>:. Például:

    szamlalo = 5
    while szamlalo > 0:
        print(szamlalo)
        szamlalo -= 1  # csökkentjük a számlálót
    print("Induljon a rakéta!")
    

    A példa előbb kiírja az 5,4,3,2,1 értékeket, majd a ciklusból kilépve kiírja az utolsó üzenetet. A while ciklusnál vigyázat: ha a feltétel soha nem válik hamissá, akkor végtelen ciklusba kerülünk. Ezért gondoskodni kell arról, hogy a ciklusban valamikor a feltétel hamisra váltson (pl. jelen esetben a számlálót csökkentjük minden iterációban).

A ciklusokból idő előtt is kiléphetünk a break utasítással, illetve a következő iterációra léphetünk a continue utasítással. Ezekkel finomabban szabályozhatjuk a ciklusok viselkedését speciális esetekben.

Függvények és modulok

Függvények definíciója és használata

A függvények olyan kódrészletek, amelyek valamilyen újrafelhasználható műveletet valósítanak meg. Fő céljuk, hogy strukturáljuk a programot, elkerüljük a kódismétlést, és átláthatóbbá tegyük a működést. Pythonban függvényt a def kulcsszóval definiálunk, majd a függvény nevét és a zárójelben felsorolt paramétereket adjuk meg. A függvény törzsét behúzással jelezzük. Például egy egyszerű függvény, ami összead két számot:

def osszead(a, b):
    eredmeny = a + b
    return eredmeny

# Függvény hívása
x = osszead(3, 4)
print(x)  # 7

A fenti osszead függvény két paramétert vár (a és b), és visszaadja (return) a két érték összegét. A függvény meghívásakor a megadott argumentumokkal fut le a törzs. Fontos: a függvény belsejében létrehozott változók (mint az fenti példában az eredmeny) csak a függvényen belül léteznek, azon kívül nem érhetők el (lokális változók). Ha egy függvény nem ad vissza értéket kifejezetten (nincs return utasítás), akkor Pythonban automatikusan a None értéket adja vissza.

A függvények paramétereinek adhatunk alapértelmezéseket is, így bizonyos argumentumokat elhagyhatunk a hívásnál. Például:

def koszont(nev, udvozlet="Helló"):
    print(f"{udvozlet}, {nev}!")
    
koszont("Zoltán")            # Helló, Zoltán!
koszont("Zoltán", "Szia")    # Szia, Zoltán!

Az első hívásnál az udvozlet paraméter alapértelmezett “Helló” értéke használódik, míg a második hívásnál felülírtuk “Szia” értékkel.

Modulok importálása

A modulok olyan Python fájlok (kiterjesztésük .py), amelyek kódot – függvényeket, osztályokat, változókat – tartalmaznak. Ha a programunk egy másik fájljából szeretnénk kódot felhasználni, vagy a Python standard könyvtárának vagy külső csomagoknak egy modulját szeretnénk használni, azt az import kulcsszóval tehetjük meg.

Például, tegyük fel, hogy van egy saját matematika.py nevű fájlunk, benne egy duplaz függvénnyel:

# matematika.py
def duplaz(x):
    return x * 2

Ezt a függvényt egy másik Python fájlban úgy tudjuk használni, hogy importáljuk a modulját:

import matematika
eredmeny = matematika.duplaz(5)
print(eredmeny)  # 10

Látható, hogy az importált modul nevét (jelen esetben matematika) prefixként használva érhető el a benne definiált duplaz függvény. Importálhatunk közvetlenül egyes komponenseket is:

from matematika import duplaz
print(duplaz(7))  # 14

Itt már közvetlenül hívhatjuk a duplaz függvényt, mert közvetlenül importáltuk.

A Python standard könyvtár moduljait ugyanígy importtal érhetjük el. Például:

import math
print(math.sqrt(16))   # 4.0, négyzetgyök
import random
print(random.randint(1, 10))  # véletlen egész 1 és 10 között

A fenti példában a math modul matematikai függvényei közül használtuk a gyökvonáshoz való sqrt függvényt, a random modulból pedig a randint függvényt egy véletlen szám generálásához.

Megjegyzés: Importálásnál lehetőség van alias használatára is az as kulcsszóval, ha rövidebb vagy más néven szeretnénk hivatkozni a modulra. Például: import math as m után a m.sqrt(16) ugyanazt eredményezi, mint a math.sqrt(16). Teljes modul helyett importálhatunk közvetlenül minden nevet is a from modul import * szintaxissal, de ez nem ajánlott, mert átláthatatlanná teheti, hogy egy név honnan származik.

Adatszerkezetek: listák, szótárak, halmazok, tuple-ök

A Python gazdag adatszerkezeteket kínál beépítve, amelyekkel könnyen tárolhatunk és kezelhetünk adathalmazokat. Itt áttekintjük a leggyakrabban használtakat: listákat, szótárakat, halmazokat és tuple-öket.

Lista

A lista elemek rendezett, módosítható sorozata. Listát a [...] szintaxissal hozhatunk létre, az elemeket vesszővel elválasztva. Egy listában bármilyen típusú objektumot tárolhatunk, és ugyanazon lista tartalmazhat különböző típusú elemeket is (de általában praktikus, ha az elemek típusa megegyezik). Példa lista létrehozására és használatára:

gyumolcsok = ["alma", "banán", "cseresznye"]
print(gyumolcsok[0])    # alma (első elem, index 0)
gyumolcsok.append("dinnye")         # új elem hozzáadása a lista végéhez
print(len(gyumolcsok))   # A lista hossza (4)
print(gyumolcsok)       # A lista tartalma: ['alma', 'banán', 'cseresznye', 'dinnye']

A listák 0-indexelésűek, azaz az első elem indexe 0, a másodiké 1, stb. A negatív indexek hátulról hivatkoznak: pl. gyumolcsok[-1] az utolsó elemet adja. A len() beépített függvény visszaadja a lista (vagy más adatszerkezet) hosszát. A listák módosíthatók: egy adott indexű elem értékét megváltoztathatjuk, vagy törölhetünk elemeket (pl. a del utasítással vagy a remove() metódussal). Számos hasznos metódus létezik listákhoz, például sort() a rendezéshez, insert() beszúráshoz, pop() az utolsó elem levételéhez stb.

A listákból részleteket (szeleteket) is ki tudunk venni a szeletelés (slicing) szintaxissal: lista[start:stop] visszaad egy új listát a megadott index-tartomány elemeivel. Például gyumolcsok[1:3] eredménye ['banán', 'cseresznye'].

A Python speciális szintaxist kínál listák átalakítására vagy generálására: a listaértelmezés (list comprehension) segítségével egy sor műveletet egyetlen kifejezésben elvégezve hozhatunk létre új listát. Például:

szamok = [1, 2, 3, 4, 5]
negyzetek = [x**2 for x in szamok]
print(negyzetek)  # [1, 4, 9, 16, 25]

Itt a list comprehension a szamok lista minden elemére kiszámolja annak négyzetét, és ezekből épít fel egy új listát.

Szótár

A szótár (dictionary) kulcs-érték párok tára. Minden kulcshoz hozzá van rendelve egy érték. A szótárakat a {kulcs: érték, ...} szintaxissal hozhatjuk létre. A kulcsok jellemzően sztringek vagy számok (bármilyen hash-elhető típus lehet kulcs), és egyedi kulcsokhoz tartoznak értékek. Példa:

telokonyv = {"Alice": 12345, "Bob": 98765}
print(telokonyv["Bob"])    # Kiírja Bob telefonszámát: 98765
telokonyv["Charlie"] = 11111    # új bejegyzés hozzáadása
print(telokonyv)
# Kimenet: {'Alice': 12345, 'Bob': 98765, 'Charlie': 11111}

A fenti példában az telokonyv szótárban neveket (kulcsokat) rendeltünk telefonszámokhoz (értékekhez). A kulcs alapján tudjuk lekérni az értéket (szögletes zárójeles indexeléssel). Ha olyan kulccsal próbálunk lekérni, ami nincs a szótárban, hiba (KeyError) keletkezik. Ezt elkerülendő használhatjuk a get() metódust, ami megadhat egy alapértelmezést arra az esetre, ha a kulcs nem létezik, pl. telokonyv.get("David", "Nincs ilyen személy").

A szótárak is módosíthatók: új kulcs-érték párokat vehetünk fel, meglévők értékét módosíthatjuk, vagy törölhetünk párt (pl. del telokonyv["Alice"]). A szótár bejárható for ciklussal is: pl. for nev, szam in telokonyv.items(): ... végigmegy az összes kulcs-érték páron.

Halmaz

A halmaz (set) egyedi elemek gyűjteménye, amelyen a matematikai halmazműveletek (metszet, unió stb.) értelmezettek. Halmazt a {elem1, elem2, ...} szintaxissal vagy a set() konstruktorral hozhatunk létre. A halmaz nem tartalmaz ismétléseket – azonos elemből csak egy példány van benne – és a halmaz elemei nincsenek sorrendben (ezért indexeléssel nem lekérdezhetők). Példa:

gyumolcs_halmaz = {"alma", "banán", "alma", "narancs"}
print(gyumolcs_halmaz)  # {'narancs', 'banán', 'alma'}
gyumolcs_halmaz.add("citrom")    # új elem hozzáadása
print(gyumolcs_halmaz)
# Megnézzük, benne van-e egy elem:
if "alma" in gyumolcs_halmaz:
    print("Az alma szerepel a halmazban.")

Látható, hogy a duplán felsorolt “alma” csak egyszer szerepel a halmazban, és a kiírásnál az elemek sorrendje nem feltétlen egyezik a megadás sorrendjével. A halmaz tipikus használata, hogy gyorsan eldönthessük, egy elem benne van-e a gyűjteményben (in operátor), illetve halmazműveleteket végezzünk: pl. A | B egyesíti két halmaz elemeit (unió), A & B metszetet, A - B különbséget képez.

Tuple (n-es)

A tuple (ejtsd: töpl vagy tjúpl, magyarul n-es) a listához hasonló, de nem módosítható (immutáns) sorozat. Tuple-t zárójelek közt felsorolt elemekkel hozhatunk létre, pl. (elem1, elem2, ...). Akkor hasznos, ha olyan elemek csoportját akarjuk összefogni, amelyeket nem akarunk megváltoztatni, vagy amikor egy függvény több értéket ad vissza (ugyanis a visszaadott több érték valójában egy tuple-ként jön ki). Például:

pont = (10, 20)
print(pont[0])  # 10
# pont[0] = 5    # Hibát eredményezne, mert a tuple értékei nem változtathatók.

A tuple is 0-indexelésű, és ugyanazokat a műveleteket sok esetben támogatja, mint a lista (lekérdezés, összefűzés, len(), stb.), azzal az eltéréssel, hogy a tartalmát nem lehet megváltoztatni. Gyakran használják a tuple-öket fix értékű csoportokra (pl. koordináta pár (x, y)), vagy például kulcs-érték párok listáiban egy-egy elemet tuple formában (pl. list of (key, value) pairs), ám a Pythonban a szótár általában jobb ilyen célra.

Objektumorientált programozás alapjai

A Python teljes mértékben támogatja az objektumorientált programozást (OOP). Az objektumorientált szemlélet középpontjában az osztályok állnak, amelyek objektumokat (példányokat) hoznak létre. Egy osztály definíciója határozza meg, hogy az abba tartozó objektumok milyen tulajdonságokkal (adatokkal) és képességekkel (metódusokkal, azaz függvényekkel) rendelkeznek.

Egy osztályt a class kulcsszóval definiálunk, majd a nevét és a kettőspontot (:) írjuk, a törzsében pedig (behúzva) felsoroljuk a tulajdonságokat és metódusokat. Pythonnál szokásos, hogy az osztály neve nagybetűvel kezdődik. Az __init__ nevű metódus az inicializáló, konstruktor-szerepű függvény, amely akkor fut le, amikor az osztályból új objektumot hozunk létre. Az self paraméter minden metódus első paramétere, és az adott példányra utal (ezt nem kell megadni híváskor, a Python automatikusan kezeli).

Nézzünk egy példát egy egyszerű osztályra:

class Szemely:
    def __init__(self, nev, kor):
        self.nev = nev
        self.kor = kor
    
    def bemutatkozik(self):
        print(f"Sziasztok, {self.nev} vagyok, {self.kor} éves.")

# Objektum példányosítása az Szemely osztályból
ember = Szemely("Géza", 28)
ember.bemutatkozik()

A Szemely osztálynak két attribútuma (adatmezeje) van: nev és kor. A bemutatkozik nevű metódus pedig kiírja ezeket egy üdvözlésben. Az osztály használatához létrehoztunk egy ember nevű objektumot (példányt), mintha a Szemely egy függvény volna: Szemely("Géza", 28) meghívás egy új objektumot ad vissza, amit az ember változóhoz rendeltünk. Ez a hívás automatikusan meghívja a __init__ metódust, beállítva a nev és kor attribútumokat. Ezután az ember.bemutatkozik() sor a példány metódusát hívja meg, amely az adott objektumon belüli nev és kor értékekkel dolgozik.

Az objektumorientált szemlélet erőssége, hogy lehetővé teszi az öröklődést is: létrehozhatunk új osztályokat úgy, hogy közben egy már meglévő osztály tulajdonságait és metódusait is örökli. Az új osztály csak az eltérő vagy új dolgokat definiálja, a közös jellemzők az ősből jönnek. Például lehetne egy Alkalmazott osztály, amely Szemely-ből öröklődik, és hozzáad mondjuk egy munkahely attribútumot és saját metódusokat. Python többszörös öröklődést is támogat, de kezdőként elegendő az egyszeres öröklődést megérteni.

Megjegyzés: Pythonban a tagok láthatósága nincs szigorúan korlátozva (minden attribútum és metódus alapvetően publikus). A fejlesztők azonban a név eleji aláhúzással szokták jelezni, ha egy változót vagy metódust nem publikusnak szánnak (csak belső használatra). Két aláhúzással kezdve Python név-mangling mechanizmust alkalmaz, amivel elkerülhetők az öröklődésnél fellépő névütközések, de kezdőként erre ritkán van szükség.

Megjegyzés: Pythonban sok minden objektum, nem csak az, amit mi hozunk létre osztályként. Például a fenti listák, szótárak is objektumok, csak épp a beépített list illetve dict osztály példányai.

Beépített függvények és gyakori modulok használata

A Python számtalan hasznos beépített függvénnyel rendelkezik, valamint a standard könyvtár moduljainak tucatjaival. Nézzük meg néhányat, amelyekkel a kezdők gyakran találkoznak:

Gyakori beépített függvények:

  • print(obj): Kiírja a megadott objektumot (szöveget, számot stb.) a kimenetre. Ezt már sokszor láttuk a példákban.
  • input(prompt): Beolvas egy sor szöveget a felhasználótól (a konzolról), visszaadva azt stringként. Pl. nev = input("Add meg a neved: ") beolvassa a felhasználó által beírt nevet.
  • len(s): Visszaadja egy sorozat (szöveg, lista, szótár stb.) hosszát, azaz elemeinek számát.
  • type(obj): Megadja egy objektum típusát (pl. <class 'int'>).
  • int(x), float(x), str(x): Típuskonverziós függvények, melyek megpróbálják az x értékét egészszé, lebegőpontossá vagy sztringgé alakítani.
  • sum(iterable), min(iterable), max(iterable): Számokból álló iterálhatók (pl. lista) elemeinek összegét, minimumát illetve maximumát adják vissza.
  • sorted(iterable): Visszaad egy új listát az iterable elemeivel rendezett sorrendben (alapértelmezés szerint növekvően).
  • range(start, stop, step): Generál egy számsorozatot start-tól stop-ig (a stop értéket nem tartalmazza), step közzel. Ha csak egy argumentumot adunk meg, 0-tól indul és 1-es lépésközzel megy. Gyakran használjuk for ciklusokban.
  • enumerate(iterable): Egy iterálható sorozat elemeit indexekkel együtt adja vissza, gyakran hasznos for ciklusoknál. Például for i, v in enumerate(lista): ... egyszerre biztosítja az indexet és az értéket a cikluson belül.
  • list(iterable), dict(...), set(iterable), tuple(iterable): Ezek a konstruktor függvények segítségével könnyen létrehozhatunk listát, szótárat, halmazt vagy tuple-t.
  • help(obj): Nagyon hasznos interaktív módban, kiírja a dokumentációt egy objektumról (pl. függvényről vagy modulról).

Gyakori modulok és használatuk:

  • math: Matematikai függvények és konstansok (pl. math.sqrt(x) gyökvonás, math.sin(x) szinusz, math.pi π értéke stb.).
  • random: Véletlenszám-generálás (pl. random.randint(a, b) véletlen egész [a, b] intervallumból, random.choice(lista) véletlenszerűen választ egy elemet a listából).
  • datetime: Dátum és időkezelés. Pl. datetime.date és datetime.datetime osztályok, datetime.now() az aktuális dátum/idő lekérésére stb.
  • os: Operációs rendszerrel kapcsolatos műveletek (fájlrendszer, környezeti változók stb.). Pl. os.listdir(path) könyvtár tartalmának listázása.
  • sys: A Python interpreterrel kapcsolatos információk (pl. sys.argv a parancssori argumentumok listája).
  • json: JSON (JavaScript Object Notation) formátumú adatok beolvasására és írására (pl. json.loads() és json.dumps()).
  • re: Reguláris kifejezések kezelése (mintákra keresés szövegben).
  • sys: A Python futókörnyezet (interpreter) paraméterei és működése (pl. sys.argv a parancssori argumentumok listája, sys.path a modulkeresési útvonalak).

A fenti modulok mind a Python standard részei, tehát telepítés nélkül, azonnal használhatók. Előfordul, hogy bizonyos feladatokra speciálisabb modulokat szeretnénk használni, amelyeket külső felek fejlesztettek és nem részei az alap Python terjesztésnek. Ezek a külső könyvtárak a Python csomagkezelőjével, a pip segítségével telepíthetők. Például:

pip install requests

paranccsal telepíthetjük a requests nevű HTTP kéréseket leegyszerűsítő könyvtárat, majd utána a programban import requests utasítással használhatjuk is.

Egyszerű hibakezelés (try/except)

Még a legtapasztaltabb programozóknál is előfordul, hogy a program futása közben hibák (exceptions, kivételek) lépnek fel. Ilyen lehet például egy nullával osztás, egy nem létező fájl megnyitása, vagy helytelen típusú érték használata. Ha ezeket a kivételeket nem kezeljük, a program hibaüzenettel leáll. Pythonban a kivételkezelésre a try-except szerkezet szolgál.

A try blokkba tesszük azokat az utasításokat, amelyeknél előfordulhat kivétel. Az except ágba pedig megadhatjuk, mit tegyen a program, ha az adott típusú hiba fellép. Például:

try:
    eredmeny = 10 / 0
    print("Eredmény:", eredmeny)
except ZeroDivisionError:
    print("Hiba: Nullával való osztás nem lehetséges!")

A fenti példában a 10/0 művelet ZeroDivisionError kivételt generál, ami a try blokkban keletkezik. Az except ZeroDivisionError ág elkapja ezt a konkrét kivételtípust, és a program nem omlik össze, hanem a mi általunk megadott hibaüzenetet írja ki. Lehetőség van általános except ág megadására is (kivétel típusa nélkül), ami bármilyen hiba esetén lefut. Illetve használhatunk több külön except ágat különböző kivételtípusok kezelésére.

További kiegészítő szerkezetek:

  • else ág: ami akkor fut le, ha a try blokkban nem történt kivétel.
  • finally ág: ami mindenképpen lefut, akár volt kivétel, akár nem (pl. erőforrások felszabadítására használható).

Kezdőként általában elegendő a try-except páros használata a tipikus hibák kezelésére – például felhasználói input konverziónál a ValueError (ha mondjuk egy szöveget számra próbálunk alakítani), fájlműveleteknél az IOError, stb.

További lehetőségek – könyvtárak, fejlesztési eszközök és felhasználási területek

Az eddigiekben áttekintettük a Python alapvető nyelvi eszköztárát. A Python ennél sokkal többet kínál – hatalmas ökoszisztémája van külső könyvtáraknak és keretrendszereknek, amelyek lehetővé teszik, hogy a nyelvet szinte bármilyen célra felhasználjuk.

Fejlesztési eszközök: A hatékony munka érdekében érdemes megismerkedni néhány fejlettebb eszközzel is. Népszerű Pythonhoz készült integrált fejlesztői környezetek (IDE) a korábban már említett PyCharm és a Visual Studio Code (utóbbi egy bővítőkön keresztül ad teljeskörű Python támogatást). Ezek segítségével hatékonyabban írhatsz és hibakereshetsz kódot. Adatfeldolgozási és tudományos területen a Jupyter Notebook (illetve a JupyterLab) egy különleges eszköz, amely lehetővé teszi, hogy a kódot kis részletekben (“cellákban”) futtasd, és azonnal lásd az eredményt, dokumentációval ötvözve. Ez különösen hasznos adatelemzési feladatoknál.

Webfejlesztés: A Python igen népszerű a webfejlesztés területén is. Számos keretrendszer és mikrokeretrendszer áll rendelkezésre webalkalmazások készítéséhez. A legismertebbek közül való Django, amely egy teljeskörű, “minden az egyben” keretrendszer komplex webalkalmazásokhoz, és a Flask, amely egy minimalista mikrokeretrendszer, amely nagy szabadságot ad a fejlesztőnek. Ezeken kívül érdemes megemlíteni a FastAPI keretrendszert is, amely modern megközelítéssel és kiváló teljesítménnyel segíti webes API-k fejlesztését. Webfejlesztéshez a Pythonban általában a szerver oldali logikát írjuk meg, a kliensoldali rész (böngészőben futó kód) továbbra is tipikusan HTML, CSS, JavaScript.

Adatfeldolgozás és tudományos célok: A Python az utóbbi években az adatelemzés, gépi tanulás és műszaki-tudományos számítás meghatározó nyelvévé vált. Ennek oka, hogy rendkívül gazdag ökoszisztéma épült ki ezen a téren. Néhány fontosabb könyvtár:

  • NumPy: Tömbök (nagy, többdimenziós mátrixok) hatékony kezelését lehetővé tevő könyvtár, amely sok mátrixműveletet C nyelvű sebességgel hajt végre.
  • Pandas: Magas szintű adatelemzési könyvtár, amely adatkeretek (DataFrame) néven egy olyan szerkezetet biztosít, ami könnyűvé teszi a táblázatos adatok kezelését, szűrését, csoportosítását stb.
  • Matplotlib és Seaborn: Adatvizualizációs csomagok, grafikonok, diagramok egyszerű készítéséhez.
  • Scikit-learn: Gépi tanulási algoritmusok hatalmas gyűjteménye, egyszerű interfésszel olyan feladatokra, mint osztályozás, regresszió, klaszterezés stb.
  • TensorFlow és PyTorch: Mélyneuróhálók és mesterséges intelligencia modellek fejlesztésére szolgáló keretrendszerek.

Asztali alkalmazások (GUI): Pythonban lehetőség van grafikus felületű programok készítésére is. A szabványos könyvtár részét képező Tkinter modul segítségével egyszerű ablakos alkalmazásokat fejleszthetünk, de léteznek több további GUI keretrendszer is (pl. PyQt/PySide, Kivy), amelyekkel nagyobb szabású asztali alkalmazások is készíthetők.

Automatizálás és egyebek: A Python nagy erőssége, hogy “ragasztónyelv” is: remekül lehet használni különböző rendszerek összekapcsolására, szkriptek írására a mindennapi feladatok automatizálására. Legyen szó fájlok tömeges átnevezéséről, weboldalak adatainak kigyűjtéséről (web scraping), rendszeradminisztrációs feladatokról vagy akár játékok készítéséről (pl. Pygame könyvtár segítségével), a Pythonra biztosan találunk megoldást.

Végül fontos megjegyezni, hogy a Python közössége hatalmas és rendkívül befogadó a kezdőkkel. Rengeteg ingyenes oktatóanyag, könyv, online kurzus, videó és fórum (pl. Stack Overflow) áll rendelkezésre. Érdemes gyakorolni minél többet – kisebb saját projekteket írni – mert programozni igazán csak programozás útján lehet megtanulni.

Gyakorlati példa: Számkitaláló játék

Most, hogy áttekintettük a Python számos alapvető tulajdonságát és eszközét, készítsünk el egy egyszerű, már-már klasszikus programot, amely a fent tanultakat alkalmazza. Legyen ez egy számkitaláló játék. A program kitalál magának egy véletlen egész számot 1 és 100 között, és a feladatunk eltalálni azt minél kevesebb próbálkozásból. Minden tipp után a program megmondja, hogy a gondolt szám nagyobb vagy kisebb, mint a mi tippünk.

Lássuk a programot:

import random

print("Gondoltam egy számra 1 és 100 között. Találd ki!")
célszám = random.randint(1, 100)
tipp = None
próbák = 0

while tipp != célszám:
    try:
        szöveg = input("Tipped: ")
        tipp = int(szöveg)
    except ValueError:
        print("Kérlek, egy egész számot adj meg!")
        continue

    próbák += 1
    if tipp < célszám:
        print("Túl kicsi!")
    elif tipp > célszám:
        print("Túl nagy!")
    else:
        print(f"Gratulálok, eltaláltad {próbák} próbából!")

Nézzük meg a programot részleteiben:

  • Először importáljuk a random modult, hogy tudjunk véletlen számot generálni.
  • Kiírunk egy üdvözlő üzenetet a játék indulásakor.
  • A random.randint(1, 100) létrehoz egy véletlen egészt 1 és 100 között, ezt eltároljuk a célszám változóban.
  • Előkészítjük a szükséges változókat: tipp = None (még nincs tipp) és próbák = 0 (hány próbálkozás volt).
  • Indul a while ciklusunk, ami addig fut, míg a tipp nem egyenlő a célszámmal.
  • A cikluson belül először megpróbálunk beolvasni egy tippet a felhasználótól az input() segítségével, majd azt int-té alakítjuk. Ha a felhasználó nem számot adott meg, ValueError kivétel keletkezik, amit lekezelünk: kiírunk egy hibaüzenetet és a continue utasítással a ciklus következő iterációjára ugrunk (tehát nem folytatjuk tovább az aktuális iterációt).
  • Ha sikerült számmá alakítani a bemenetet, növeljük a próbálkozások számlálóját (próbák += 1), majd összehasonlítjuk a tippet a célszámmal.
  • Ha a tipp kisebb, mint a célszám, kiírjuk, hogy “Túl kicsi!”. Ha nagyobb, akkor azt, hogy “Túl nagy!”. Ezek után a ciklus újra kezdődik (visszatérünk a while elejére), és a feltétel ismét ellenőrzésre kerül.
  • Végül, ha a tipp éppen egyenlő a célszámmal, akkor az else ág fut le: gratulálunk a felhasználónak, és kiírjuk, hány próbából találta el.

Ez a program átölelte a legtöbb, korábban átvett elemet: használtunk modulimportálást, véletlengenerálást, írunk-olvasunk a konzolra, dolgoztunk ciklusokkal, feltételekkel, és kivételkezeléssel is. Természetesen a program továbbfejleszthető: például korlátozhatnánk a próbálkozások számát, vagy naplózhatnánk a próbákat egy listába. Próbáld meg saját magad továbbfejleszteni, és kísérletezz más hasonló játékok vagy feladatok elkészítésével!