Python alapok
nulláról kezdő szintre

00 · Előkészületek

Telepítés és szerkesztő

Két dolog kell: maga a Python, ami futtatja a kódot, és egy szerkesztő, amiben megírod.

1. Töltsd le a Pythont a python.org → Downloads oldalról az operációs rendszeredhez.
2. A telepítőben pipáld ki az „Add Python to PATH” opciót — enélkül a parancssor nem fogja megtalálni. Utána „Install Now”.
3. Ellenőrzés: nyisd meg a parancssort (Windows: cmd), és írd be, hogy python.

python
Python 3.10.5 (tags/v3.10.5) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> print("Hello")
Hello
>>> a = 10
>>> b = 20
>>> a + b
30

Ha látod a verziószámot és a >>> jelet, a telepítés sikerült. Ez a Python interaktív játszótere (REPL): soronként hajtja végre, amit beírsz. Kilépés: exit().

Szerkesztő

VS Code — egyszerűbb, testreszabható, kezdőknek ideális. Telepítés után rakd fel benne a Python bővítményt (a Bővítmények menüpont alatt keress rá, a legtöbbet letöltöttet válaszd).
PyCharm — kifejezetten Pythonra készült fejlesztői környezet, komolyabb projektekhez.

01 · Kiírás

Az első program: print()

A print függvény kiírja a konzolra azt, amit zárójelben megadsz neki.

print("Hello")
print("Hello 2")
print("Hello 3")

Hello
Hello 2
Hello 3

A szöveget idézőjelek közé tesszük. Mentés Ctrl+S, futtatás a szerkesztő lejátszás gombjával (vagy parancssorból: python main.py).

A legfontosabb tanulság a példából: a Python a kódot lineárisan, fentről lefelé hajtja végre. Amilyen sorrendben leírod az utasításokat, pontosan olyan sorrendben futnak le.

Az üres print() egy üres sort ír ki — hasznos, ha el akarod választani a kimenet részeit.

02 · Tárolás

Változók

A változó egy név, amivel lefoglalsz egy helyet a memóriában, és oda elmentesz egy értéket.

Képzeld el, hogy egy alkalmazás üdvözli a belépő felhasználót. Ha közvetlenül a nevet írod ki, mindenkinek ugyanaz jelenik meg:

print("Üdv, Miki!")   # Levi is ezt fogja látni…

Ehelyett tárold az értéket egy változóban. Az egyenlőségjel az értékadás: a bal oldali néven lefoglalt memóriaterületre elmenti a jobb oldali értéket.

felhasznalonev = "Levi"
print(felhasznalonev)

felhasznalonev = "Miki"    # ugyanaz a kulcs, új érték
print(felhasznalonev)

Levi
Miki

Amikor a print-nek idézőjelek nélkül adod át a nevet, a Python nem szövegként kezeli, hanem megkeresi az adott nevű változót, és annak az értékét adja tovább.

Azért hívjuk változónak, mert az értéke megváltoztatható: új értékadás egyszerűen felülírja a régit.

03 · Adatok

Adattípusok és kommentek

Négy alaptípussal érdemes kezdeni: szöveg, egész szám, tizedes tört és logikai érték.

szoveg = "Én egy szöveges adat vagyok"   # string  (str)
szam = 100                               # integer (int)
tizedes_tort = 3.14                      # float
logikai = True                           # boolean (bool) – True vagy False

A string szó fonalat, láncot jelent — a szöveg valójában karakterek összefűzött lánca.

Kommentek

A # jel után írt szöveget a Python nem hajtja végre. Magyarázatnak, emlékeztetőnek való. Egy kódrészletet is ki lehet vele kapcsolni („kikommentelni”): jelöld ki, majd Ctrl+/.

valtozo = 10
valtozo = True
valtozo = "most már szöveg"

04 · Bemenet

Beolvasás és f-stringek

Az input() megvárja, amíg a felhasználó beír valamit, és azt szövegként adja vissza.

Építsünk egy kis „töltsd ki a hiányzó szavakat” verset. Először a beolvasás:

szin = input("Egy szín: ")
fonev = input("Egy főnév: ")
mellekev = input("Egy melléknév: ")

A zárójelbe írt szöveg a kérdés, ami megjelenik a felhasználónak — enélkül nem tudná, mit várunk tőle. A végére tett szóköz elválasztja a kérdést a gépelt választól.

Összefűzés: a + jel

Szövegeket a + operátorral össze lehet fűzni, de ez hosszabb sorokban átláthatatlan, és külön figyelni kell a szóközökre:

print("A rózsa " + szin + ", a " + fonev + " pedig kék.")

Az elegáns megoldás: f-string

Tegyél egy f betűt az idézőjel elé, és kapcsos zárójelben hivatkozz a változókra. A Python behelyettesíti az értéküket. Ez a template literal string, röviden f-string.

szin = input("Egy szín: ")
fonev = input("Egy főnév: ")
mellekev = input("Egy melléknév: ")

print()   # üres sor elválasztásnak

print(f"A rózsa {szin},")
print(f"a {fonev} pedig kék.")
print(f"Eddig nagyon {mellekev} ez az év.")

Egy szín: rózsaszín
Egy főnév: vonat
Egy melléknév: gazdag

A rózsa rózsaszín,
a vonat pedig kék.
Eddig nagyon gazdag ez az év.

Annyi változót teszel bele, amennyit akarsz, és teljesítményben is jobb, mint a sok + jel.

05 · Aritmetika

Számműveletek

A numerikus operátorok számokkal végeznek műveletet.

szam1 = 12
szam2 = 5

print(szam1 + szam2)    # összeadás      -> 17
print(szam1 - szam2)    # kivonás        -> 7
print(szam1 * szam2)    # szorzás        -> 60
print(szam1 / szam2)    # osztás         -> 2.4
print(szam1 % szam2)    # maradék        -> 2
print(szam1 ** szam2)   # hatványozás    -> 248832
print(szam1 // szam2)   # egészosztás    -> 2

Osztás: a / eredménye mindig float, akkor is, ha nincs maradék — 12 / 6 az 2.0. Ha egész számot akarsz, használd a // operátort: az megmondja, hányszor van meg maradék nélkül az egyik a másikban.

Modulusz: a % az osztás maradékát adja. 12 % 5 = 2, 12 % 6 = 0, 12 % 7 = 5. Nagyon hasznos például annak eldöntésére, hogy egy szám páros-e: szam % 2 == 0.

06 · Konverzió

Típusváltás

Az adat típusát átalakíthatod: str(), int(), float(), bool(). A type() megmondja, mi az aktuális típus.

valtozo = 1
print(type(valtozo))          # <class 'int'>

valtozo = str(valtozo)        # "1"
print(type(valtozo))          # <class 'str'>

valtozo = float(valtozo)      # 1.0
valtozo = int(valtozo)        # 1 – a tizedesjegyeket levágja, nem kerekít!

A leggyakoribb valós használat: az input() szövegét számmá alakítod, hogy tudj vele számolni.

eletkor = input("Hány éves vagy? ")
print(eletkor + 10)     # TypeError! szöveghez nem adhatsz számot

eletkor = int(input("Hány éves vagy? "))
print(f"10 év múlva {eletkor + 10} leszel.")

07 · Feltételek építőkövei

Relációs és logikai operátorok

Ezek az operátorok mindig egy logikai értéket — True-t vagy False-ot — adnak vissza.

Relációs (összehasonlító) operátorok

a = 10
b = 20

print(a == b)   # egyenlő?          -> False
print(a != b)   # nem egyenlő?      -> True
print(a < b)    # kisebb?           -> True
print(a > b)    # nagyobb?          -> False
print(a <= 10)  # kisebb vagy egyenlő -> True
print(a >= 11)  # nagyobb vagy egyenlő -> False

Logikai operátorok

Ezekkel több feltételt kapcsolhatsz össze.

print(True and True)    # ÉS  – mindkettőnek igaznak kell lennie -> True
print(True and False)   #                                        -> False
print(True or False)    # VAGY – elég, ha az egyik igaz          -> True
print(False or False)   #                                        -> False
print(not True)         # NEM – megfordítja az értéket           -> False

kor = 25
jogositvany = True
print(kor >= 18 and jogositvany)   # -> True

08 · Elágazás

if / elif / else

Ezzel tud a programod dönteni: bizonyos kód csak akkor fut le, ha egy feltétel teljesül.

valasz = input("Szereted a Pythont? ")

if valasz == "igen":
    print("Nagyszerű, akkor folytassuk!")
elif valasz == "nem":
    print("Adj neki még egy esélyt.")
elif valasz == "nem tudom":
    print("Semmi baj, majd kiderül.")
else:
    print("Erre a válaszra nem készültem.")

A szerkezet:

• if — az első feltétel. Ha igaz, lefut az alatta lévő behúzott blokk, és a többi ágat a Python átugorja.
• elif — az else és az if összevonása: „ha az előző nem teljesült, akkor nézzük meg ezt”. Annyi lehet, amennyit akarsz.
• else — ha egyik feltétel sem teljesült. Nincs mögötte feltétel.

if kor >= 18:
    print("Beléphetsz.")      # csak akkor fut le, ha igaz
print("Viszlát!")             # mindig lefut

09 · Gyűjtemények

Listák és tuple-ök

A lista egyetlen változóban több értéket tárol, sorrendben.

baratok = ["Levi", "Miki", "Viki", "Zsuzsa"]

print(baratok)          # a teljes lista
print(baratok[0])       # -> Levi   (az indexelés 0-tól indul!)
print(baratok[2])       # -> Viki
print(baratok[-1])      # -> Zsuzsa (hátulról az első)
print(len(baratok))     # -> 4      (hány elem van benne)

Lista módosítása

baratok[1] = "Máté"            # elem felülírása
baratok.append("Bence")        # hozzáfűzés a végére
baratok.insert(0, "Anna")      # beszúrás adott helyre
baratok.remove("Viki")         # elem törlése érték alapján
baratok.pop()                  # az utolsó elem kivétele
baratok.sort()                 # ábécésorrendbe rendezés

print("Miki" in baratok)       # -> benne van-e? True / False

Egy listába vegyesen is tehetsz típusokat ([1, "kettő", 3.0, True]), de a legtöbb esetben átláthatóbb, ha egyfélét tartalmaz.

Tuple — a nem módosítható lista

A tuple szinte ugyanaz, mint a lista, csak szögletes zárójel helyett kerek, és létrehozás után nem változtatható.

falu_koordinata = (120, 45)

print(falu_koordinata[0])      # olvasni lehet -> 120
falu_koordinata[0] = 999       # TypeError: 'tuple' object does not support item assignment

10 · Ismétlés

A while ciklus

A while addig ismétli a blokkját, amíg a feltétele igaz.

szam = 0

while szam < 100:
    szam = szam + 10
    print(szam)

print(f"A szám végső értéke: {szam}")

10
20
…
100
A szám végső értéke: 100

Ami történik: a Python megnézi a feltételt. Ha igaz, lefuttatja a behúzott blokkot, majd újra megnézi a feltételt. Ha hamis, kilép a ciklusból, és a mögötte lévő, már nem behúzott kóddal folytatja.

Rövidítés az értéknöveléshez: szam += 10 ugyanaz, mint szam = szam + 10. Ugyanígy létezik -=, *=, /=.

11 · Vezérlés

Végtelen ciklus és break

A while True szándékosan végtelen ciklus — addig fut, amíg a break ki nem lépteti belőle.

Ez a minta minden olyan programban ott van, ami addig várja a felhasználó parancsait, amíg ki nem lép.

szam = 0

while True:
    szam += 1
    print(szam)

    if szam == 5:
        break        # kilépés a ciklusból

1
2
3
4
5

Két kulcsszó tartozik ide:

• break — azonnal kilép a ciklusból, függetlenül a feltételtől.
• continue — kihagyja a ciklusmag hátralévő részét, és a következő körrel folytatja.

12 · Projekt

Receptkészítő alkalmazás

Az eddigiek egyben: bemenet, lista, végtelen ciklus, elágazás, f-string.

A program addig kéri az összetevőket, amíg a felhasználó azt nem írja, hogy „kilépés”, majd kiírja a kész receptet.

osszetevok = []

print("Add meg az összetevőket! (kilépéshez írd be: kilépés)")
print()

uj_osszetevo = ""

while uj_osszetevo != "kilépés":
    uj_osszetevo = input("Összetevő: ")

    if uj_osszetevo != "" and uj_osszetevo != "kilépés":
        osszetevok.append(uj_osszetevo)

print()
print("A recept összetevői:")

for osszetevo in osszetevok:
    print(f" - {osszetevo}")

print(f"\nÖsszesen {len(osszetevok)} összetevő.")

Add meg az összetevőket! (kilépéshez írd be: kilépés)

Összetevő: liszt
Összetevő: tojás
Összetevő: tej
Összetevő: kilépés

A recept összetevői:
 - liszt
 - tojás
 - tej

Összesen 3 összetevő.

Két részlet, ami könnyen elsikkad:

• Az if feltételében az and gondoskodik róla, hogy se az üres beírás (ha a felhasználó csak entert nyom), se a „kilépés” szó ne kerüljön bele az összetevők közé.
• Itt már két szinttel vagyunk behúzva: az if a while-on belül van. Minden beágyazás egy újabb behúzási szintet jelent.

13 · Szervezés

Saját függvények

A print és az input is függvény. Sajátot a def kulcsszóval írhatsz.

def koszones():
    print("Szia!")
    print("Üdv a programban.")

koszones()     # meghívás – enélkül nem történik semmi

A definíció csak leírja, mit csináljon a függvény. Attól még nem fut le — meg kell hívni, a nevével és zárójellel.

Paraméterek

A zárójelbe írt nevekkel adatot adhatsz át a függvénynek.

def koszones(nev, eletkor):
    print(f"Szia, {nev}! Te {eletkor} éves vagy.")

koszones("Levi", 25)
koszones("Viki", 30)

Szia, Levi! Te 25 éves vagy.
Szia, Viki! Te 30 éves vagy.

Visszatérési érték

A return kulcsszóval a függvény visszaad egy értéket, amit elmenthetsz egy változóba.

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

eredmeny = osszead(12, 5)
print(eredmeny)              # -> 17
print(osszead(1, 2) * 10)    # -> 30

14 · Ismétlés II.

A for ciklus és a range()

A while párja: a for előre ismert számú lépést tesz meg.

A range(1, 11) az 1-től 10-ig terjedő számokat állítja elő — a felső határ nincs benne.

szorzando = int(input("Melyik szám szorzótáblája kell? "))

print()

for szorzo in range(1, 11):
    eredmeny = szorzando * szorzo
    print(f"{szorzando} * {szorzo} = {eredmeny}")

Melyik szám szorzótáblája kell? 7

7 * 1 = 7
7 * 2 = 14
7 * 3 = 21
…
7 * 10 = 70

A szorzo az a változó, ami minden körben felveszi a következő értéket. A nevét te adod — bármi lehet, de legyen beszédes.

15 · Bejárás

for listákkal és szövegekkel

A for igazi ereje, hogy közvetlenül végig tud lépkedni egy lista vagy egy szöveg elemein.

baratok = ["Levi", "Miki", "Viki"]

for barat in baratok:
    print(f"Szia, {barat}!")

Szia, Levi!
Szia, Miki!
Szia, Viki!

Egy szövegen végiglépkedve a karaktereket kapod meg egyesével:

nev = "Python"

for betu in nev:
    print(betu)

Sorszámmal együtt

for index, barat in enumerate(baratok):
    print(f"{index + 1}. {barat}")

1. Levi
2. Miki
3. Viki

16 · Objektumok

Osztályok és objektumok

Az osztály egy sablon. Leírja, milyen adatai és képességei vannak egy dolognak — az objektum ennek egy konkrét példánya.

Ha sok felhasználót kell kezelned, mindegyikhez külön változókat gyártani reménytelen. Ehelyett készíts egy Felhasznalo sablont, és abból annyi példányt hozol létre, amennyit akarsz.

class Felhasznalo:
    def __init__(self, nev, eletkor):
        self.nev = nev
        self.eletkor = eletkor

    def bemutatkozik(self):
        print(f"Szia, {self.nev} vagyok, {self.eletkor} éves.")


felhasznalo1 = Felhasznalo("Miki", 30)
felhasznalo2 = Felhasznalo("Viki", 40)

felhasznalo1.bemutatkozik()
felhasznalo2.bemutatkozik()

print(felhasznalo1.nev)         # -> Miki
felhasznalo2.eletkor = 41       # az adat módosítható
print(felhasznalo2.eletkor)     # -> 41

Szia, Miki vagyok, 30 éves.
Szia, Viki vagyok, 40 éves.
Miki
41

Az objektumorientált programozás ennél jóval mélyebb téma (öröklődés, láthatóság, absztrakció) — kezdő szinten elég annyi, hogy az osztály összetartozó adatokat és a rájuk vonatkozó műveleteket fog egybe.

17 · Több fájl

Kód szétosztása: import

Ahogy nő a program, egy fájlban kezelhetetlen lesz. A kódot több .py fájlra bontjuk, és importáljuk egymásba.

A main.py a program belépési pontja — innen indul a vezérlés. A segédfüggvények külön fájlba kerülnek.

def egyenleg_kiiras(egyenleg):
    print(f"Aktuális egyenleg: {egyenleg} Ft")


def tranzakciok_kiirasa(tranzakciok):
    print("Tranzakciók:")
    for tranzakcio in tranzakciok:
        print(f" - {tranzakcio} Ft")


def osszesen(tranzakciok):
    return sum(tranzakciok)

from segito_fuggvenyek import egyenleg_kiiras, tranzakciok_kiirasa, osszesen

tranzakciok = [12000, -3500, -800, 25000]

tranzakciok_kiirasa(tranzakciok)
egyenleg_kiiras(osszesen(tranzakciok))

Tranzakciók:
 - 12000 Ft
 - -3500 Ft
 - -800 Ft
 - 25000 Ft
Aktuális egyenleg: 32700 Ft

Az import két formája

import segito_fuggvenyek
segito_fuggvenyek.osszesen(tranzakciok)      # a fájl nevével együtt hivatkozol

from segito_fuggvenyek import osszesen
osszesen(tranzakciok)                        # közvetlenül használhatod

Ugyanígy importálhatod a Python beépített moduljait is: import random, import time, import math.

18 · Projekt

Dobókocka

Záró projekt: modulok, függvények, végtelen ciklus és elágazás egy programban.

import random
import time

MAX_ERTEK = 6


def betoltes():
    print("Dobás", end="")
    for _ in range(3):
        time.sleep(0.4)
        print(".", end="", flush=True)
    print()


def dobas():
    return random.randint(1, MAX_ERTEK)


print("Dobókocka szimulátor")
print("Enter = dobás  |  'k' = kilépés")

while True:
    valasz = input("\nParancs: ")

    if valasz == "k":
        print("Viszlát!")
        break

    betoltes()
    eredmeny = dobas()
    print(f"Dobtál egy {eredmeny}-est!")

Néhány új elem a fenti kódban:

• random.randint(1, 6) — véletlen egész szám 1 és 6 között, a felső határ itt benne van.
• time.sleep(0.4) — 0,4 másodperc várakozás.
• print("...", end="") — a kiírás után ne kezdjen új sort.
• MAX_ERTEK — csupa nagybetűs név jelzi, hogy ezt az értéket nem szándékozunk menet közben átírni (konstans). Ha 20 oldalú kockát akarsz, itt az egyetlen helyen módosítod.
• for _ in range(3) — az aláhúzás a ciklusváltozó neve, ha az értékére nincs is szükséged.

Melléklet

Gyorsreferencia

Amit a leggyakrabban keresel majd vissza.

Beépített függvények

Hasznos szövegműveletek

Kulcsszavak

Melléklet

Gyakori hibák és mit jelentenek

A hibaüzenet nem büntetés, hanem információ. Mindig az utolsó sorát olvasd el először, és nézd meg, melyik sorszámra hivatkozik.