Python: változók

Kezdjük a kommentekkel, még mielőtt belemélyednénk a változók használatába. A kommentek hasznosak, mert segítik a későbbi munkánkat, könnyebb rájönni mit, miért csináltunk mikor megírtunk egy programot. A komment jele a #. Alapvetően minden sor elé ki kell írni, ahová kommentet írunk. Esetleg használhatjuk a tripla idézőjelet több soros kommenthez. Nyilván nem kell kisregényt írni, nem erről szól.

#Ez itt egy komment például. A következő sor egy kiíratás:
print("Üdvözöllek, ez egy Python példa program")

1 2	#Ez itt egy komment például. A következő sor egy kiíratás: print("Üdvözöllek, ez egy Python példa program")

Mi az a változó? Egy azonosítóval (névvel) ellátott adattároló. Alapvetően azért változó, mert változhat az értéke programunk futása közben. Természetesen nem ennyire egyszerű, a változóknak több típusa is van.

A Pythonban nem kell deklarálni a változót. (névhez típust rendelni) Elég neki értéket adni. pl: x=5 vagy nev=”tesztelek”. A Python egy dinamikusan tipizált nyelv. Ez azt jelenti, hogy a változó típusa a hozzárendeléskor dől el, és az int(), str(), float(), stb. beépített függvények arra szolgálnak, hogy egy már létező értéket átalakítsanak egy másik típussá.

#változók
a=5
nev="Teszt Elek"
#lehet egyszerre többet is:
b,c=6,7
_vezeteknev, _keresztnev="Kovács", "Béla"
#lehet több változónak ugyanaz az értéke
i=j=k=2022
#adhatunk típust is
x=int(2022)
y=int(1990)
szoveg=str(Ez egy szöveg)
#felül is írhatjuk az értékület
a=10
#értékük kiíratása
print(a)
print(szoveg)

#változók

a=5

nev="Teszt Elek"

#lehet egyszerre többet is:

b,c=6,7

_vezeteknev, _keresztnev="Kovács", "Béla"

#lehet több változónak ugyanaz az értéke

i=j=k=2022

#adhatunk típust is

x=int(2022)

y=int(1990)

szoveg=str(Ez egy szöveg)

#felül is írhatjuk az értékület

a=10

#értékük kiíratása

print(a)

print(szoveg)

Változók elnevezésének szabályai

aláhúzással vagy betűvel kell kezdőnie, kis és nagybetűket, számokat tartalmazhat. Hagyományosan nem használunk ékezetes betűket, mert az informatika nyelve az angol.
nem kezdődhet tehát számmal, egyéb írásjellel
megkülönbözteti a kis és nagybetűket, ezzel lehet szívni ha valaki nem figyel rá
hagyományosan a következő módszereket használjuk:

Kiíratáshoz a print() függvényt használjuk. Még később visszatérünk rá.

Konstansok elnevezése (bár a Pythonban nincs külön ilyen típus) Konstansnak azokat a változókat tekintjük, amelyek értékét a program futása közben nem szabad megváltoztatni. A konvenció szerint a konstansok nevét csupa NAGYBETŰVEL és aláhúzással (snake case) írjuk.
PI_ERTEKE = 3.14159
MAX_ELEM_SZAM = 100

Változó törlése: del A del csak a nevet törli. Maga az objektum addig marad a memóriában, amíg a Python szemétgyűjtője (Garbage Collector) el nem távolítja, mert már semmilyen név nem hivatkozik rá.

x = 42
print(x)  # 42
del x
# print(x) # Ekkor már NameError hibát kapnánk

x = 42

print(x) # 42

del x

# print(x) # Ekkor már NameError hibát kapnánk

Globális és lokális változók

Alapvetően egy változó globális, azaz bárhol használható a programon belül. Tehát ki tudjuk olvasni a tartalmát, vagy meg tudjuk változtatni.

Ha egy változót például egy függvényen belül hozunk létre, az egy lokális változó lesz, csak a függvényen belül fog létezni. Tehát ha van egy globális változóm, és egy ugyanolyan nevűt használok egy függvényben és még értéket is adok neki, az új értéket csak a függvényen belül veszi fel, azon kívűl a korábbi értéket fogja tárolni. Ha mégis változtatni akarunk rajta akkor a global kulcsszóval tehetjük meg. Nézzük meg a következő példákat:

#Létrehozok egy Valtozo nevű változót. Később a függvényben megpróbálom módosítani
Valtozo = "érthető"
def peldafuggveny():
  Valtozo = "egyszerű"
  print("A Python programozás " + Valtozo)
#függvény futtatása
peldafuggveny()
#amint látjuk a Valtozo értéke megmaradt az eredeti
print("Eredeti értéke " + Valtozo)
#létrehozok egy másik függvényt, amiben használom a global kulcsszót
def peldafuggveny2():
  global Valtozo#tehát itt megmondom neki, hogy a globális változót akarom használni
  Valtozo = "egyszerű"
  print("A Python programozás " + Valtozo)
peldafuggveny2()
print("Eredeti értéke: " + Valtozo)

#Létrehozok egy Valtozo nevű változót. Később a függvényben megpróbálom módosítani

Valtozo = "érthető"

def peldafuggveny():

Valtozo = "egyszerű"

print("A Python programozás " + Valtozo)

#függvény futtatása

peldafuggveny()

#amint látjuk a Valtozo értéke megmaradt az eredeti

print("Eredeti értéke " + Valtozo)

#létrehozok egy másik függvényt, amiben használom a global kulcsszót

def peldafuggveny2():

global Valtozo#tehát itt megmondom neki, hogy a globális változót akarom használni

Valtozo = "egyszerű"

print("A Python programozás " + Valtozo)

peldafuggveny2()

print("Eredeti értéke: " + Valtozo)

A függvényekről később lesz még szó. Alapvetően a függvény egy azonosítóval (névvel) ellátott utasítás sorozat, amit többször is felhasználhatunk, ezáltal segíti programunk hatékonyságát, áttekinthetőségét. A nevével lehet lefuttatni.

Változók típusai

Ahogy már említettem, a változók különféle típusú adatokat tárolhatnak. A típusokra mindig figyelni kell!

szöveges típus: str
numerikus típus: int (egész számok, lehet pozitív és negatív), float (tizedes tört, lehet pozitív és negatív), complex
felsorolás: lista, tuple, range
szótár: dict
logikai típus: bool
halmaz: set, frozenset
bináris típus: bytes, bytearray, memoryview
nincs típus: NoneType

Hogyan tudjuk lekérdezni egy változó típusát? print(type(ValtozoNeve))
Miért? Mert nem mindig egyértelmű. pl: ha egy számot stringként veszek fel. szam=str(2022) Sima print utasítással 2022-t ír ki, pedig az nem szám, nem lehet matematikai műveletet végezni vele ebben az esetben!

isinstance() A Python isinstance() függvény arra való, hogy ellenőrizzük, hogy adott objektum egy bizonyos osztály vagy annak alosztálya (leszármazottja) példánya-e. Ezekről később lesz szó, de azért megemlítem itt is.

Az egyes típusokat át tudjuk alakítani más típusúra.

#átalakítás int >> float:
x = float(2022)
#float >> int: levágja a tizedes részt 2-lesz az eredmény
y = int(2.8)
#int >> complex:
z = complex(1)
#írassuk ki őket
print(x)
print(y)
print(z)
#nézzük meg végül melyik milyen típus!
print(type(x))
print(type(y))
print(type(z))

#átalakítás int >> float:

x = float(2022)

#float >> int: levágja a tizedes részt 2-lesz az eredmény

y = int(2.8)

#int >> complex:

z = complex(1)

#írassuk ki őket

print(x)

print(y)

print(z)

#nézzük meg végül melyik milyen típus!

print(type(x))

print(type(y))

print(type(z))

A Python dinamikusan típusos nyelv, de a modern kódolási gyakorlatban javasolt a típusmegjelölések (type hints) használata. Ez segít az olvashatóságban, és támogatja a fejlesztői környezeteket (IDE-ket) a hibák jelzésében.Nem kötelező és nem is érvényesít típuskorlátot, de jelzi a szándékolt típust.

kor: int = 30         # A kor változó a szándék szerint egész szám
nev: str = "János"    # A nev változó a szándék szerint string

1 2	kor: int = 30 # A kor változó a szándék szerint egész szám nev: str = "János" # A nev változó a szándék szerint string

Adatok kiíratása

Visszatérve a Print függvényre. Amint láttuk használata a következőképpen működik: zárójelben megadjuk, mit szeretnénk kiíratni. Ez lehet egy változó, szöveg, szám, változó típusa… Alapvetően ha nem akartuk, hogy összeérjenek a szövegek, tettünk szóközt ide-oda. Ezt egyszerűbben a sep paraméterrel tehetjük meg. Sortörést a /n paraméterrel tudunk csinálni, de alap esetben a print() mindig sortörést csinál az adatok kiírása után. Ha szeretnénk ezt megváltoztatni, használjuk az end paramétert. pl: end=” ”

print("egy","kettő","három",sep=" ") #egy kettő három

1	print("egy","kettő","három",sep=" ") #egy kettő három

Kiíratás formázva: F-string

A legjobb megoldás a stringek formázására az F-stringek (Formatted String Literals). Python 3.6-tal került bevezetésre. Felváltotta a régebbi % és a format() metódus használatát is.
Előnyök: Rövid, olvasható, közvetlenül beágyazhatóak változók és kifejezések.

a = 2025
nev = "Pont"
# A változókat közvetlenül a stringen belül, kapcsos zárójelben hivatkozzuk meg
print(f"A változó értéke: {a}, a név pedig {nev}.")

a = 2025

nev = "Pont"

# A változókat közvetlenül a stringen belül, kapcsos zárójelben hivatkozzuk meg

print(f"A változó értéke: {a}, a név pedig {nev}.")

Egész számok formázása:

szam = 42
print(f"{szam:5}")     # szélesség (jobbra igazítva)
print(f"{szam:05}")    # nullával kitöltve: 00042
print(f"{szam:<5}")    # balra igazítva
print(f"{szam:^5}")    # középre igazítva

szam = 42

print(f"{szam:5}") # szélesség (jobbra igazítva)

print(f"{szam:05}") # nullával kitöltve: 00042

print(f"{szam:<5}") # balra igazítva

print(f"{szam:^5}") # középre igazítva

Ezres tagolás:

n = 1234567
print(f"{n:,}")        # 1,234,567
print(f"{n:_}")        # 1_234_567

n = 1234567

print(f"{n:,}") # 1,234,567

print(f"{n:_}") # 1_234_567

Lebegőpontos számok:

pi = 3.1415926535
print(f"{pi:.2f}")     # 3.14
print(f"{pi:10.3f}")   # teljes szélesség + tizedesjegyek

pi = 3.1415926535

print(f"{pi:.2f}") # 3.14

print(f"{pi:10.3f}") # teljes szélesség + tizedesjegyek

Százalék:

rate = 0.875
print(f"{rate:.1%}")   # 87.5%

1 2	rate = 0.875 print(f"{rate:.1%}") # 87.5%

Dátumformázás (datetime + f-string)

from datetime import datetime
now = datetime.now()
print(f"{now}")                 # 2026-06-25 09:11:46.209274
print(f"{now:%Y-%m-%d}")        # 2026-06-25
print(f"{now:%d.%m.%Y}")        # 25.06.2026
print(f"{now:%H:%M:%S}")        # 14:30:05
print(f"{now:%Y-%m-%d %H:%M}")  # teljes

from datetime import datetime

now = datetime.now()

print(f"{now}") # 2026-06-25 09:11:46.209274

print(f"{now:%Y-%m-%d}") # 2026-06-25

print(f"{now:%d.%m.%Y}") # 25.06.2026

print(f"{now:%H:%M:%S}") # 14:30:05

print(f"{now:%Y-%m-%d %H:%M}") # teljes

Adatbevitel

Adatokat az input() függvénnyel tudunk bekérni a konzolról. A input() megállítja a program futását, és megvárja, amíg a felhasználó beír egy sort, majd lenyomja az Enter billentyűt. A függvény opcionálisan egy string argumentumot is fogadhat. Ez a string szolgál promptként (felszólításként), ami megjelenik a felhasználó számára, jelezve, hogy mit vár tőle a program. Bármit is ír be a felhasználó (legyen az szám, betű, vagy bármilyen karakter), a input() függvény mindig egy string (szöveg) típusú értéket ad vissza. Ha számokkal akarsz dolgozni, a beolvasott stringet konvertálni kell (típuskonverzióval)!

Szintaxis: valtozo = input("Prompt szövege: ")

Például kérjünk be egy nevet, és üdvözöljük!

nev=input("Kérek egy nevet!")
print("Üdvözöllek",nev,sep=" ")

1 2	nev=input("Kérek egy nevet!") print("Üdvözöllek",nev,sep=" ")

Nézzünk egy egyszerű példát! Számoljuk ki egy téglalap területét, kerületét!

a = int(input("Kérem az a oldalt! "))
b = int(input("Kérem a b oldalt! "))
t = a * b
k = 2 * ( a + b )
# print("Kerület: ",k,"Terület: ",t)
print(f"Kerület: {k} Terület: {t}")

a = int(input("Kérem az a oldalt! "))

b = int(input("Kérem a b oldalt! "))

t = a * b

k = 2 * ( a + b )

# print("Kerület: ",k,"Terület: ",t)

print(f"Kerület: {k} Terület: {t}")

Hibakezelés (Error Handling)
Mivel a felhasználók bármit beírhatnak, amit csak akarnak, mindig érdemes hibakezelést (try…except) használni, különösen a típuskonverziók környékén. Ha például a felhasználó beírja, hogy „tíz”, de a program int(input(…)) parancsot vár, akkor a program ValueError hibával leáll.

try:
    szam = int(input("Adj meg egy számot: "))
    print(f"Megadott szám: {szam}")
except ValueError:
    print("Hiba: Érvénytelen bemenet. Kérlek, számot adj meg!")

try:

szam = int(input("Adj meg egy számot: "))

print(f"Megadott szám: {szam}")

except ValueError:

print("Hiba: Érvénytelen bemenet. Kérlek, számot adj meg!")

Frissítve: 2026.06.25.

Változók elnevezésének szabályai

Globális és lokális változók

Változók típusai

Adatok kiíratása

Kiíratás formázva: F-string

Adatbevitel

Kategóriák

Friss bejegyzések

WS2022 – WDS

Playwright teszt