A változók címkéket adnak értékeknek. A sztring karakterek sorozata, idézőjelek között. Az f-stringek lehetővé teszik, hogy változókat használjunk sztringekben dinamikus üzenetekhez.
print("Hello világ!")uzenet = "Hello világ!"
print(uzenet)keresztnev = 'albert'
vezeteknev = 'einstein'
teljes_nev = f"{keresztnev} {vezeteknev}"
print(teljes_nev)A lista egy sor elemet tárol meghatározott sorrendben. Az elemek index segítségével vagy ciklusban érhetők el.
biciklik = ['trek', 'redline', 'giant']elso_bicikli = biciklik[0]utolso_bicikli = biciklik[-1]for bicikli in biciklik:
print(bicikli)biciklik = []
biciklik.append('trek')
biciklik.append('redline')
biciklik.append('giant')negyzetek = []
for x in range(1, 11):
negyzetek.append(x**2)További műveletek listákkal: listakomprehenziók, szeletelés és másolás.
Egyszerű módja új lista létrehozásának egy kifejezésből.
negyzetek = [x**2 for x in range(1, 11)]A lista egy részének kiválasztása indexek alapján.
befutok = ['sam', 'bob', 'ada', 'bea']
elso_ketto = befutok[:2]Új lista létrehozása a meglévő másolataként.
masolat_biciklik = biciklik[:]A tuple hasonló a listához, de az elemei nem módosíthatók. Hasznos, ha fix értékeket szeretnénk tárolni.
meretek = (1920, 1080)felbontasok = ('720p', '1080p', '4K')Az if utasításokat feltételek vizsgálatára használjuk. Az alábbi példák bemutatják az alapvető feltételes teszteket.
# egyenlő
x == 42
# nem egyenlő
x != 42
# nagyobb mint
x > 42
# nagyobb vagy egyenlő
x >= 42
# kisebb mint
x < 42
# kisebb vagy egyenlő
x <= 42'trek' in biciklik
'surly' not in biciklikjatek_aktiv = True
szerkesztheto = FalseAz if utasítások kombinálhatók összetettebb szerkezetekben, például if‑elif‑else ágakkal.
kor = 18
if kor >= 18:
print("Szavazhatsz!")kor = 20
if kor < 4:
jegyar = 0
elif kor < 18:
jegyar = 10
elif kor < 65:
jegyar = 40
else:
jegyar = 15A szótárak információk közötti kapcsolatokat tárolnak. Minden elem egy kulcs‑érték pár.
alien = {'color': 'green', 'points': 5}print(f"A földönkívüli színe: {alien['color']}.")alien['x_position'] = 0A szótárakon könnyen végig lehet iterálni, akár a kulcsokat, akár az értékeket vizsgálva.
kedvenc_szamok = {'eric': 7, 'ever': 4, 'erin': 47}
for nev, szam in kedvenc_szamok.items():
print(f"{nev} kedvenc száma a {szam}.")kedvenc_szamok = {'eric': 7, 'ever': 4, 'erin': 47}
for nev in kedvenc_szamok.keys():
print(f"{nev} rendelkezik egy kedvenc számmal.")kedvenc_szamok = {'eric': 7, 'ever': 4, 'erin': 47}
for szam in kedvenc_szamok.values():
print(f"{szam} egy kedvenc szám.")A programok képesek bekérni adatokat a felhasználótól. Minden input alapértelmezetten sztringként kerül eltárolásra.
nev = input("Mi a neved? ")
print(f"Hello, {nev}!")Számok bekérésekor az inputot át kell alakítani megfelelő típusra (int vagy float).
kor = input("Hány éves vagy? ")
kor = int(kor)pi = input("Mi a pi értéke? ")
pi = float(pi)A while ciklus addig ismétel egy kódrészletet, amíg egy feltétel igaz. Különösen hasznos, ha előre nem tudjuk, hányszor kell lefutnia a ciklusnak.
aktualis_ertek = 1
while aktualis_ertek <= 5:
print(aktualis_ertek)
aktualis_ertek += 1A while ciklus segítségével a felhasználó döntheti el, mikor lépjen ki a programból.
uzenet = ''
while uzenet != 'quit':
uzenet = input("Mi az üzeneted? ")
if uzenet != 'quit':
print(uzenet)A függvények elnevezett kódrészletek, amelyek egy adott feladatot hajtanak végre. A függvénynek átadott információt argumentumnak, a függvény által fogadott információt pedig paraméternek nevezzük.
def koszont_felhasznalo():
"""Egyszerű üdvözlés megjelenítése."""
print("Hello!")
koszont_felhasznalo()def koszont_felhasznalo(felhasznalonev):
"""Személyre szabott üdvözlés megjelenítése."""
print(f"Hello, {felhasznalonev}!")
koszont_felhasznalo('jesse')A függvények paramétereihez alapértelmezett értékeket is rendelhetünk, valamint visszaadhatnak értéket.
def keszit_pizza(feltet='ananász'):
"""Egyszerű, egyfeltétes pizza készítése."""
print(f"Készítettem egy {feltet} pizzát!")
keszit_pizza()
keszit_pizza('gomba')def osszead_szamok(x, y):
"""Két szám összeadása és az összeg visszaadása."""
return x + y
osszeg = osszead_szamok(3, 5)
print(osszeg)Az osztály meghatározza egy objektum viselkedését és azokat az információkat, amelyeket tárolhat. Az osztályban tárolt információkat attribútumoknak nevezzük, az osztályhoz tartozó függvényeket pedig metódusoknak.
class Kutya:
"""Egy kutya reprezentálása."""
def __init__(self, nev):
"""Kutya objektum inicializálása."""
self.nev = nev
def ul(self):
"""Ülés szimulálása."""
print(f"{self.nev} leült.")
en_kutyam = Kutya('Peso')
print(f"{en_kutyam.nev} egy nagyszerű kutya!")
en_kutyam.ul()A gyermekosztály örökli a szülőosztály attribútumait és metódusait, de új viselkedést is hozzáadhat.
class MentesKutya(Kutya):
"""Mentőkutyát reprezentál."""
def __init__(self, nev):
"""Mentőkutya inicializálása."""
super().__init__(nev)
def keres(self):
"""Keresés szimulálása."""
print(f"{self.nev} keresést végez.")
en_kutyam = MentesKutya('Willie')
print(f"{en_kutyam.nev} egy mentőkutya.")
en_kutyam.ul()
en_kutyam.keres()A programok képesek fájlokból olvasni és fájlokba írni.
A pathlib könyvtár megkönnyíti a fájlokkal és könyvtárakkal való munkát.
Ha van egy definiált útvonal, használhatjuk a read_text() és write_text() metódusokat.
from pathlib import Path
path = Path('siddhartha.txt')
contents = path.read_text()
lines = contents.splitlines()
for line in lines:
print(line)path = Path('journal.txt')
uzenet = "Szeretem a programozást."
path.write_text(uzenet)A kivételek segítenek megfelelően reagálni a hibákra.
A hibát okozó kódot a try blokkba tesszük.
A hibára reagáló kód az except blokkban van.
Az a kód, amely csak akkor fut le, ha nem történt hiba, az else blokkban található.
prompt = "Hány jegyre van szükséged? "
jegyek_szama = input(prompt)
try:
jegyek_szama = int(jegyek_szama)
except ValueError:
print("Kérlek próbáld újra.")
else:
print("A jegyek nyomtatásra kerülnek.")A sort() metódus véglegesen megváltoztatja a lista sorrendjét.
A sorted() függvény egy másolatot ad vissza, így az eredeti lista változatlan marad.
Rendezhetünk betűrendben, fordított betűrendben, vagy megfordíthatjuk az eredeti sorrendet.
Fontos megjegyezni, hogy a kis- és nagybetűk befolyásolhatják a rendezés sorrendjét.
felhasznalok.sort()felhasznalok.sort(reverse=True)print(sorted(felhasznalok))
print(sorted(felhasznalok, reverse=True))felhasznalok.reverse()Elemeket eltávolíthatunk a pozíciójuk alapján vagy az értékük szerint. Ha érték alapján távolítunk el egy elemet, a Python csak az első előfordulást törli.
del felhasznalok[-1]felhasznalok.remove('mia')A pop() metódus eltávolítja és visszaadja a listából az adott elemet.
Alapértelmezés szerint az utolsó elemet adja vissza, de bármely pozícióból kipoppolhatunk.
legutobbi_felhasznalo = felhasznalok.pop()
print(legutobbi_felhasznalo)elso_felhasznalo = felhasznalok.pop(0)
print(elso_felhasznalo)A len() függvény visszaadja a lista elemeinek számát.
felhasznalok_szama = len(felhasznalok)
print(f"Összesen {felhasznalok_szama} felhasználónk van.")Ha szeretnénk egyszerűen végigmenni a lista minden elemén, használhatunk egy for ciklust.
A ciklus minden elemet egyesével kiír, így könnyen ellenőrizhetjük vagy feldolgozhatjuk a tartalmat.
for felhasznalo in felhasznalok:
print(felhasznalo)A ciklus törzsében minden elemhez személyre szabott üzenetet írhatunk ki. A ciklus után pedig egy összefoglaló üzenetet jeleníthetünk meg, amely mindenkit együtt üdvözöl.
for felhasznalo in felhasznalok:
print(f"\nÜdvözlünk, {felhasznalo}!")
print("Nagyon örülünk, hogy csatlakoztál!")
print("\nÜdvözlünk mindenkit, örülünk, hogy itt vagytok!")A range() függvény segítségével könnyen generálhatunk számokat egy adott tartományban.
Az alábbi példa 0-tól 1000-ig írja ki a számokat.
for szam in range(1001):
print(szam)A range() függvény kezdőértéket is megadhat, így az első szám 1 lesz.
Az alábbi példa 1-től 1000-ig írja ki a számokat.
for szam in range(1, 1001):
print(szam)A list() függvény és a range() kombinációjával létrehozhatunk egy listát, amely tartalmazza az összes számot 1-től egymillióig.
Ez hatékony módja nagy számhalmazok előállításának.
szamok = list(range(1, 1_000_001))A min() függvény visszaadja a lista legkisebb értékét.
Hasznos például a legfiatalabb kor meghatározására.
korok = [93, 99, 66, 17, 85, 1, 35, 82, 2, 77]
legfiatalabb = min(korok)A max() függvény visszaadja a lista legnagyobb értékét.
Hasznos például a legidősebb kor meghatározására.
korok = [93, 99, 66, 17, 85, 1, 35, 82, 2, 77]
legidosebb = max(korok)A sum() függvény visszaadja a lista összes elemének összegét.
Hasznos például az összes életkor évszámának kiszámítására.
korok = [93, 99, 66, 17, 85, 1, 35, 82, 2, 77]
ossz_ev = sum(korok)A listákból könnyen kiemelhetünk részeket a szeletelés (slicing) segítségével. A szögletes zárójelekben megadott kezdő és végindex határozza meg, mely elemek kerülnek a részlistába. A szeletelés rugalmas: megadhatjuk az első néhány elemet, a középső elemeket, vagy az utolsókat.
befutok = ['kai', 'abe', 'ada', 'gus', 'zoe']
elso_harom = befutok[:3]kozepso_harom = befutok[1:4]utolso_harom = befutok[-3:]Ha szeretnénk egy meglévő listáról másolatot készíteni, használhatjuk a szeletelés (slicing) szintaxisát. Ez biztosítja, hogy az új lista független legyen az eredetitől, így a módosítások nem hatnak vissza rá.
befutok = ['kai', 'abe', 'ada', 'gus', 'zoe']
masolat_befutok = befutok[:]Egy for ciklus segítségével lépésről lépésre kiszámíthatjuk a számok négyzetét, majd hozzáadhatjuk egy listához.
negyzetek = []
for x in range(1, 11):
negyzet = x**2
negyzetek.append(negyzet)A list comprehension rövidebb és elegánsabb módja ugyanannak a feladatnak: egy sorban létrehozhatjuk a négyzetek listáját.
negyzetek = [x**2 for x in range(1, 11)]Egy for ciklus segítségével minden nevet külön-külön nagybetűssé alakíthatunk, majd hozzáadhatjuk egy új listához.
nevek = ['kai', 'abe', 'ada', 'gus', 'zoe']
nagybetus_nevek = []
for nev in nevek:
nagybetus_nevek.append(nev.upper())A list comprehension itt is rövidebb megoldást kínál: egy sorban átalakíthatjuk az összes nevet nagybetűssé.
nevek = ['kai', 'abe', 'ada', 'gus', 'zoe']
nagybetus_nevek = [nev.upper() for nev in nevek]Egy üres listát fokozatosan feltölthetünk elemekkel az append() metódus segítségével.
Ezután egy for ciklussal végigmehetünk rajta, és minden elemhez kiírhatunk üzenetet.
A lista szeletelésével ([:2]) kiválaszthatjuk az első néhány elemet, majd külön kiírhatjuk őket.
Az elemek törlésére használhatjuk a del utasítást pozíció alapján, vagy a remove() metódust érték alapján.
kutyak = []
kutyak.append('willie')
kutyak.append('hootz')
kutyak.append('peso')
kutyak.append('goblin')
for kutya in kutyak:
print(f"Hello {kutya}!")
print("Szeretem ezeket a kutyákat!")
print("\nAz első két kutyám:")
regi_kutyak = kutyak[:2]
for regi_kutya in regi_kutyak:
print(regi_kutya)
del kutyak[0]
kutyak.remove('peso')
print(kutyak)A szótárakban (dict) tárolt adatokat kulcs-érték párok alkotják.
Ha egy adott kulcsot törlünk a del utasítással, akkor az ahhoz tartozó érték is eltűnik a szótárból.
Ez hasznos, ha már nincs szükségünk egy bizonyos információra.
alien_0 = {'color': 'green', 'points': 5}
print(alien_0)
del alien_0['points']
print(alien_0)A .keys() metódus segítségével végigmehetünk egy szótár összes kulcsán.
Ez hasznos például akkor, ha szeretnénk kiírni, kik vettek részt egy felmérésben.
A ciklus minden kulcsot egyesével ad át a változónak, amelyet felhasználhatunk a törzsben.
# Mutassuk meg, kik vettek részt a felmérésben.
for nev in kedvenc_nyelvek.keys():
print(nev)A sorted() függvény segítségével rendezhetjük a szótár kulcsait.
Ha a reverse=True paramétert adjuk meg, akkor a kulcsok fordított sorrendben jelennek meg.
Így például kiírhatjuk minden személy kedvenc nyelvét név szerinti visszafelé rendezve.
# Mutassuk meg mindenki kedvenc nyelvét,
# a nevek fordított sorrendjében.
for nev in sorted(kedvenc_nyelvek.keys(), reverse=True):
nyelv = kedvenc_nyelvek[nev]
print(f"{nev}: {nyelv}")A szótárak (dict) különböző adatokat tárolhatnak kulcs-érték párokban.
Ha több ilyen szótárt szeretnénk együtt kezelni, elhelyezhetjük őket egy listában.
Így könnyen végigmehetünk rajtuk, és kiírhatjuk minden felhasználó összes adatát.
# Üres lista létrehozása
felhasznalok = []
# Új felhasználó hozzáadása
uj_felhasznalo = {
'vezeteknev': 'fermi',
'keresztnev': 'enrico',
'felhasznalonev': 'efermi',
}
felhasznalok.append(uj_felhasznalo)
# Másik felhasználó hozzáadása
uj_felhasznalo = {
'vezeteknev': 'curie',
'keresztnev': 'marie',
'felhasznalonev': 'mcurie',
}
felhasznalok.append(uj_felhasznalo)
# Összes információ kiíratása
print("Felhasználói összegzés:")
for felhasznalo_dict in felhasznalok:
for k, v in felhasznalo_dict.items():
print(f"{k}: {v}")
print("\n")A szótárakat nem csak append() segítségével adhatjuk hozzá egy listához, hanem közvetlenül is definiálhatjuk őket a lista létrehozásakor.
Ez egyszerűbb és átláthatóbb, ha előre ismert adatokkal dolgozunk.
Ezután egy for ciklussal végigmehetünk a listán, és kiírhatjuk minden felhasználó összes adatát.
# Felhasználók listájának közvetlen definiálása
felhasznalok = [
{
'vezeteknev': 'fermi',
'keresztnev': 'enrico',
'felhasznalonev': 'efermi',
},
{
'vezeteknev': 'curie',
'keresztnev': 'marie',
'felhasznalonev': 'mcurie',
},
]
# Összes információ kiíratása
print("Felhasználói összegzés:")
for felhasznalo_dict in felhasznalok:
for k, v in felhasznalo_dict.items():
print(f"{k}: {v}")
print("\n")A szótárakban nemcsak egyszerű értékeket, hanem listákat is tárolhatunk.
Ez lehetővé teszi, hogy egy kulcshoz több értéket rendeljünk, például egy személy kedvenc nyelveit.
A .items() metódussal végigmehetünk a szótár minden kulcs-érték párján, majd egy belső ciklussal kiírhatjuk a lista elemeit.
# Több nyelv tárolása minden személyhez
kedvenc_nyelvek = {
'jen': ['python', 'ruby'],
'sarah': ['c'],
'edward': ['ruby', 'go'],
'phil': ['python', 'haskell'],
}
# Összes válasz kiíratása
for nev, nyelvek in kedvenc_nyelvek.items():
print(f"{nev}: ")
for nyelv in nyelvek:
print(f"- {nyelv}")A szótárakban nemcsak egyszerű értékeket vagy listákat, hanem más szótárakat is tárolhatunk. Ez lehetővé teszi, hogy összetett adatstruktúrákat hozzunk létre, például felhasználói profilokat, ahol minden felhasználónévhez egy külön szótár tartozik.
felhasznalok = {
'aeinstein': {
'keresztnev': 'albert',
'vezeteknev': 'einstein',
'helyszin': 'princeton',
},
'mcurie': {
'keresztnev': 'marie',
'vezeteknev': 'curie',
'helyszin': 'paris',
},
}
for felhasznalonev, felhasznalo_dict in felhasznalok.items():
teljes_nev = f"{felhasznalo_dict['keresztnev']} {felhasznalo_dict['vezeteknev']}"
helyszin = felhasznalo_dict['helyszin']
print(f"\nFelhasználónév: {felhasznalonev}")
print(f"\tTeljes név: {teljes_nev.title()}")
print(f"\tHelyszín: {helyszin.title()}")Ha sok, hasonló adatszerkezetet szeretnénk létrehozni, hatékonyan megtehetjük egy ciklus segítségével.
Ebben a példában egymillió "alien" szótár készül, mindegyik azonos kezdőértékekkel.
A ciklus minden iterációban új szótárt hoz létre, majd hozzáadja egy listához.
A végén a len() függvénnyel ellenőrizhetjük, hogy valóban egymillió elem került a listába.
alienek = []
# Egymillió zöld alien létrehozása, mindegyik 5 pontot ér
# és egy sorban indul
for alien_szam in range(1_000_000):
uj_alien = {
'szin': 'zold',
'pont': 5,
'x': 20 * alien_szam,
'y': 0
}
alienek.append(uj_alien)
# Bizonyítsuk, hogy a lista egymillió alien-t tartalmaz
alienek_szama = len(alienek)
print("Létrehozott alienek száma:")
print(alienek_szama)A függvényhívásnál az argumentumokat sorrendben kell megadni.
Az első érték az animal változóhoz, a második a name változóhoz kerül.
Ez egyszerű és gyors, de figyelni kell a helyes sorrendre.
def describe_pet(allat, nev):
"""Információ kiíratása egy kedvencről."""
print(f"\nVan egy {allat}.")
print(f"A neve {nev}.")
describe_pet('hörcsög', 'harry')
describe_pet('kutya', 'willie')A függvényhívásnál megadhatjuk az argumentumok nevét is. Így nem számít a sorrend, mert a Python a kulcs alapján párosítja az értéket a paraméterhez. Ez átláthatóbb, különösen sok paraméter esetén.
def describe_pet(allat, nev):
"""Információ kiíratása egy kedvencről."""
print(f"\nVan egy {allat}.")
print(f"A neve {nev}.")
describe_pet(allat='hörcsög', nev='harry')
describe_pet(nev='willie', allat='kutya')A függvények a return utasítással adhatnak vissza értéket.
Ebben a példában a függvény egy teljes nevet formáz meg és adja vissza.
A visszatérési értéket változóban tárolhatjuk, majd kiírhatjuk.
def get_full_name(keresztnev, vezeteknev):
"""Formázott teljes név visszaadása."""
teljes_nev = f"{keresztnev} {vezeteknev}"
return teljes_nev.title()
zenesz = get_full_name('jimi', 'hendrix')
print(zenesz)A függvények nemcsak egyszerű értékeket, hanem összetettebb adatstruktúrákat is visszaadhatnak. Ebben a példában a függvény egy szótárt ad vissza, amely egy személy adatait tartalmazza. Így több információt kezelhetünk egyetlen visszatérési értékben.
def build_person(keresztnev, vezeteknev):
"""Szótár visszaadása egy személyről."""
szemely = {'keresztnev': keresztnev, 'vezeteknev': vezeteknev}
return szemely
zenesz = build_person('jimi', 'hendrix')
print(zenesz)A függvények rugalmasabbá tehetők opcionális paraméterekkel.
Ha az age paramétert megadjuk, bekerül a szótárba, ha nem, akkor kihagyjuk.
Így ugyanaz a függvény különböző mennyiségű adatot tud visszaadni.
def build_person(keresztnev, vezeteknev, kor=None):
"""Szótár visszaadása egy személyről, opcionális korral."""
szemely = {'keresztnev': keresztnev, 'vezeteknev': vezeteknev}
if kor:
szemely['kor'] = kor
return szemely
# Példák
zenesz = build_person('jimi', 'hendrix', 27)
print(zenesz)
zenesz = build_person('janis', 'joplin')
print(zenesz)A függvények segítségével dinamikusan hozhatunk létre adatokat a felhasználó beviteléből. Ebben a példában a program bekéri a nevet, az osztály betűjelét és a kezdési évet, majd ezekből összeállít egy e-mail címet.
def email():
nev = input("Adj meg nevet: ")
osztaly = input("Add meg az osztályod betűjét: ")
ev = input("Add meg a kezdési éved: ")
return f"{nev}.tech{ev}{osztaly}@bolyaimovar.com"
print(email())A program beolvassa az autok.txt fájlt, feldolgozza az autók adatait, majd különböző statisztikákat számol.
Ezután létrehoz egy új fájlt (sotetkek.csv), amelybe a sötétkék autók adatai kerülnek, év szerint rendezve.
with open("autok.txt", "r", encoding="utf-8") as f:
autok = [sor.strip().split(";") for sor in f]
# 5 ajtós autók száma
ajto = sum(int(auto[2]) == 5 for auto in autok)
# Toyota típusok száma
toyota = sum("Toyota" in auto[0] for auto in autok)
# Legfiatalabb autó típusa
lft = max(autok, key=lambda x: int(x[1]))[0]
# Homok színű autók életkora
hsz = [(2023 - int(auto[1])) for auto in autok if auto[3] == "Homok"]
# Átlag életkor
hae = sum(hsz) / len(hsz)
print("5 ajtós autóból:", ajto)
print("Ennyi Toyota van:", toyota)
print("Legfiatalabb típusa:", lft)
print("Életkor:", hsz)
print("Átlag életkor:", round(hae, 2))
# Sötétkék autók kiírása CSV fájlba, év szerint rendezve
with open("sotetkek.csv", "w", encoding="utf-8") as file:
autok.sort(key=lambda x: int(x[1]))
for auto in autok:
if auto[3] == "Sotetkek":
print(";".join(auto), file=file)A program bekéri az autók nevét, fogyasztását és évjáratát, majd szótárban tárolja az adatokat.
Ezután egy függvény segítségével kiszámolja az összes autó átlagfogyasztását.
Az None értékek és hibás évszámok kezelése is be van építve.
def atlag_fogyasztas(adatok):
"""Számolja ki az autók átlagfogyasztását."""
osszeg = 0
for auto in adatok.values():
osszeg += auto["fogyasztas"]
return osszeg / len(adatok)
adat = {}
while True:
auto = input("Adja meg az autó nevét (vege = kilépés): ")
if auto == "vege":
break
fogyasztas = int(input("Adja meg az autó fogyasztását: "))
evj = int(input("Adja meg az autó évjáratát: "))
if evj > 2023:
print("Hamis évszám!")
evj = int(input("Adja meg az autó évjáratát újra: "))
adat[auto] = {"fogyasztas": fogyasztas, "evjarat": evj}
print(adat)
print("\nFeladat b)")
for auto, info in adat.items():
print(f"{auto} -> fogyasztás: {info['fogyasztas']}")
print("Az autók átlagfogyasztása:", atlag_fogyasztas(adat))Eredmény:
Opel fogyasztás: 7
Ford fogyasztás: 6
Az autók átlagfogyasztása: 6.5
Az átlag kiszámítása nagyon egyszerű: összeadjuk az összes értéket, majd elosztjuk az elemek számával. Így kapunk egyetlen számot, amely jellemzi az egész adathalmazt.
szamok = [4, 6, 8]
osszeg = sum(szamok) # 4 + 6 + 8 = 18
darab = len(szamok) # 3 elem van
atlag = osszeg / darab # 18 / 3 = 6
print("Az átlag:", atlag)Eredmény: Az átlag 6.
szamok = [4, 6, 8]
atlag = avg(szamok)
print("Az átlag:", atlag)Eredmény: Az átlag 6.
A program bekéri a tanulók nevét és jegyeit öt tantárgyból. Ezeket egy szótárban tárolja, majd egy függvény kiszámolja az átlagot. Az átlagot úgy kapjuk meg, hogy összeadjuk az öt jegyet, majd elosztjuk öttel.
osztaly = {}
def atlag(M, MA, A, T, I):
"""Visszaadja az öt jegy átlagát."""
osszeg = M + MA + A + T + I
return osszeg / 5
nev = input("Adja meg a nevet (Finish = kilépés): ")
while nev != 'Finish':
_Magyar = int(input("Magyar jegy: "))
_Matek = int(input("Matek jegy: "))
_Angol = int(input("Angol jegy: "))
_Tori = int(input("Töri jegy: "))
_Info = int(input("Infó jegy: "))
osztaly[nev] = {
"Magyar": _Magyar,
"Matek": _Matek,
"Angol": _Angol,
"Töri": _Tori,
"Infó": _Info,
"Átlag": atlag(_Magyar, _Matek, _Angol, _Tori, _Info)
}
print(f"{nev} átlaga: {osztaly[nev]['Átlag']:.2f}")
nev = input("\nAdja meg a következő nevet (Finish = kilépés): ")
print("\nOsztály adatai:")
for tanulo, adatok in osztaly.items():
print(tanulo, "->", adatok)Eredmény:
Péter átlaga: 4.20
Anna átlaga: 3.60
A .items() metódus a szótár minden kulcs-érték párját adja vissza.
Ez különösen hasznos, ha egyszerre szeretnénk hozzáférni a kulcshoz (pl. név) és az értékhez (pl. jegyek).
A ciklusban két változót használunk: az első a kulcsot, a második az értéket tárolja.
osztaly = {
"Péter": {"Magyar": 4, "Matek": 5},
"Anna": {"Magyar": 3, "Matek": 4}
}
for nev, adatok in osztaly.items():
print(f"{nev} jegyei: {adatok}")Eredmény:
Péter jegyei: {'Magyar': 4, 'Matek': 5}
Anna jegyei: {'Magyar': 3, 'Matek': 4}