Python
A Python egy olyan programozási nyelv, amelynek használata szinte korlátlan. A Python a szoftvertervezéstől az adatelemzésig, az alkalmazásfejlesztéstől az adatbázis-kezelésig, a webfejlesztéstől a robotikaig számos területen alkalmazható.
A Python nyelv rendkívül könnyen tanulható, és több mint 25 év alatt nagyon erős fejlesztői közösség alakult ki körülötte. Ez azt jelenti, hogy rengeteg szabadon elérhető programozási könyvtár és modul áll rendelkezésre, amelyekkel még hatékonyabbá teheted a munkádat.
Python egy modern, magas szintű programozási nyelv, amelyet egyszerű és könnyen olvasható szintaxisa jellemzi. A nyelv az 1990-es évek elején Guido van Rossum által készült, és azóta az egyik legnépszerűbb programozási nyelvvé vált a világon.
Python könnyen megtanulható és használható, ami kiváló választás azoknak, akik most kezdik a programozást. Az egyszerű és érthető szintaxis segít a kezdőknek, hogy gyorsan elkezdjenek programozni. Azonban Python egyben erőteljes és képes bonyolult feladatokra is. Egyetlen sorban sok mindent ki lehet fejezni, ami nagyon időtakarékos és eredményes lehet.
Python a modern programozási nyelvek közül a legjobbak egyike, mert széles körben használható. A Python alkalmazható adatbányászatban, webfejlesztésben, gépi tanulásban, automatizálásban, játékfejlesztésben és még sok más területen. A nyelvnek számos kiterjesztése és modulja van, ami még rugalmasabbá teszi az alkalmazását.
A Python dokumentációja rendkívül jól strukturált és áttekinthető. A dokumentációban megtalálhatóak a nyelv főbb funkciói és használati módjai, valamint rengeteg példa és forráskód is, ami megkönnyíti az elsajátítását. A dokumentáció a Python közösség által folyamatosan frissített és karbantartott, így mindig naprakész és hasznos.
Ha új programozási nyelvet szeretnél tanulni, akkor a Python egy kiváló választás lehet. A könnyen megtanulható szintaxis, a széleskörű felhasználási lehetőségek és a jó dokumentáció miatt, a Python a programozás világában egyre népszerűbb.
Python a modern programozás egyik legnépszerűbb nyelve, és számos előnnyel rendelkezik a más nyelvekkel szemben. Az egyszerű és olvasható szintaxisa révén könnyen tanulható, és gyorsan fejleszthető vele. A Python programok sokoldalúak és könnyen karbantarthatóak, és a nyelvnek számos modulja és könyvtára van, amelyek bővítik a funkcionalitását.
Python programozásra használható számos területen, beleértve a webfejlesztést, adatbányászatot, gépi tanulást, számítási fizikát, robotikát és automatizálást. A nyelv számos platformon és operációs rendszeren fut, így hordozható és alkalmazkodóképes.
A Python nyelv kódja olvasható és egyszerű, ami könnyen érthetővé teszi a programokat, és lehetővé teszi a gyorsabb fejlesztést. A nyelv magas szintű absztrakciókat tartalmaz, amelyek csökkentik a kód hosszát és egyszerűsítik a programozási folyamatot.
A Python nyelvnek számos közössége van, amelyek tagjai az új modulokat és könyvtárakat fejlesztik, és segítenek az új fejlesztőknek a programozásban. A nyelv sokféle könyvtárral és modullal rendelkezik, amelyek lehetővé teszik a fejlesztők számára, hogy nagyobb funkciókat hozzanak létre a programokban.
Összességében a Python egy könnyen tanulható és hatékony nyelv, amely sokoldalúan használható a programozás számos területén. Az olvasható és egyszerű kódja, valamint a számos elérhető modulja és könyvtára teszi a Python nyelvet egyik legkedveltebb nyelvvé a programozók körében.
Articles
Alapok
Az első lépés az izgalmas programozási világ felé.
Pythonról
Az utóbbi években a Python nyelv rendkívül dinamikusan növekvő népszerűségnek örvend a programozási nyelvek között. Ennek oka több tényezőre vezethető vissza. A Python szintaxisa egyszerű, könnyen tanulható, így gyakran ajánlják kezdő programozóknak is. Emellett a nyelven írt forráskód rövid, tömör és áttekinthető, ami nagyban megkönnyíti az olvasást és a karbantarthatóságot.
A nagy létszámú Python-közösségnek köszönhetően az interneten rengeteg ismertető, leírás és tipp található, ami nagy segítséget jelent az ismeretszerzésben és a problémamegoldásban. A nyelv sokoldalúságát és rugalmasságát jelzi, hogy számos területen használják, mint például játék- és webfejlesztés, automatizálás és adatelemzés.
A Python további népszerűségét növeli, hogy manapság az egyik legdivatosabb területeken, mint a mesterséges intelligencia és adatbányászat, szinte kizárólagosan Python nyelven készülnek a programok. Ennek köszönhetően a nyelv folyamatosan bővülő csomagjai és fejlesztői közössége, valamint az un. Tiobe-index szerinti első helyezése azt mutatja, hogy a Python egyre inkább a programozás egyik legkeresettebb és legkedveltebb nyelve.
Az egyik legnagyobb előnye a Python nyelvnek az is, hogy nagyon könnyen bővíthető más programozási nyelvekkel, így az összekötésük nem jelent nagy kihívást. Ezáltal a Python nyelv a többi nyelvvel összehasonlítva is nagyon erős programozási eszközként tud működni. Emellett a Python nyelv széles körben támogatott a különböző operációs rendszereken, így a fejlesztők számára könnyűvé válik az alkalmazások több platformon történő futtatása.
A Python nyelv további előnye, hogy nagyon hatékonyan kezeli az adatokat, ami miatt különösen előnyös a nagy adatmennyiséggel dolgozó projektekben. A Python nyelv használatával a fejlesztők egyszerűen meg tudják oldani a nagy adathalmazok elemzésének és feldolgozásának feladatát, így például az adatelemzés, a gépi tanulás és a mesterséges intelligencia fejlesztése is hatékonyabbá válik.
A Python nyelv szintén rendkívül rugalmas és könnyen alkalmazható a webfejlesztés területén, például a Django vagy a Flask keretrendszer segítségével. Az ilyen keretrendszerek lehetővé teszik a fejlesztők számára, hogy gyorsan és hatékonyan hozzanak létre webalkalmazásokat és weboldalakat.
Összességében elmondható, hogy a Python nyelv egyre inkább növekszik a programozási szektorban, és számos előnyös tulajdonsága miatt egyre inkább elterjedt. Az egyszerű szintaxis, a nagy közösség támogatása, az áttekinthető forráskód és a sokoldalúság jelentős előnyöket jelentenek a fejlesztők számára. A Python további bővülése és népszerűsége valószínűleg a jövőben is folytatódni fog, ami azt jelenti, hogy a nyelv továbbra is fontos szerepet játszik majd a programozás terén.
Kikommentelés
A kikommentelés (vagy kommentelés) a programozási nyelvekben azt jelenti, hogy a kód egy részét jelöljük meg olyan megjegyzésekkel, amelyeket a fordító vagy az értelmező program figyelmen kívül hagy. A kommentek olyan szövegek, amelyeket a programozók a forráskódjukba helyeznek el annak érdekében, hogy magyarázzák, hogy mit csinál a kód, vagy miért csinálja azt.
A kommentek fontosak lehetnek, mivel segíthetnek a kód megértésében és karbantarthatóságában, különösen akkor, ha a kód bonyolult vagy hosszú. Az értelmező programok a kommenteket általában figyelmen kívül hagyják, így azok nem befolyásolják a program futását.
A kikommentelés a programozás egy fontos gyakorlata, amely segít a kód érthetőbbé tételében és a fejlesztők közötti kommunikációban.
Megjegyzés írása
Programunkban elhelyezhetünk megjegyzéseket, kommenteket.
# Ez egy egysoros komment.
print('alma') # Így is írhatunk kommentet
# Ez egy
# többsoros komment
'''
Többsoros kommentet írhatunk
3 aposztróf vagy 3 idézőjel közé írva.
Így szoktuk megadni általában a program vagy programrészlet leírását.
'''
“Kikommentelés”: az adott utasítás elé kettőskeresztet teszünk, így az nem hajtódik végre, így segíti a tesztelést:
# print("alma")
def osszead(a, b): #két bemeneti paramétert kap, amelyek "a" és "b"
eredmeny = a + b #"eredmeny" változóban összeadjuk a két bemeneti paramétert
return eredmeny # "return" kulcsszóval visszaadjuk az eredményt
print(osszead(6, 3)) # Ez egy komment, amely megmagyarázza a kódot.
# eredmény: 9
Összefoglalva, a kommentelés vagy kikommentelés a programozási nyelvekben fontos gyakorlat, amely lehetővé teszi a programozók számára, hogy magyarázzák a kódjukat vagy megjegyzéseket fűzzenek hozzá. Az ilyen kommentek segíthetnek a kód megértésében, valamint a fejlesztők közötti kommunikációban. A Python nyelvben kétféle kommentelési módszer áll rendelkezésre: az egysoros és a többsoros kommentelés. Az egysoros kommentelés az adott utasítás elé kettőskeresztet tesz, míg a többsoros kommentet 3 aposztróf vagy 3 idézőjel közé írva adhatjuk meg. A kommenteket az értelmező programok figyelmen kívül hagyják, így azok nem befolyásolják a program futását.
Print és változók
A kód egyszerű “Hello World” üzenetet ír ki a képernyőre.
print("hello world")
A következő két sorban két változót hozunk létre és adunk nekik értéket, majd kiírjuk őket a képernyőre.
a = 15
b = 2.345
print(a)
print(b)
Az f-string segítségével formázott szöveget írunk ki a képernyőre, ahol a változó értékét 10 karakter szélességgel jelenítjük meg.
print(f'b= {b:10} db')
A .format() metódus segítségével formázott szöveget írunk ki a képernyőre, ahol az a és b változók értékeit használjuk fel.
print ("B={1} db{0}" .format(a, b))
Két karakterláncot fűzünk össze a “+” operátorral, majd kiírjuk az eredményt a képernyőre.
c="15"
d="34"
print(c + d)
# kimenet:"1534"
A c változó értékét átalakítjuk egész számmá az int() függvénnyel, majd hozzáadjuk a d változó értékét, amelyet szintén átalakítunk egész számmá. Az eredményt kiírjuk a képernyőre.
e = int(c)
print(e + int(d))
#kimenet: 39
d kerekítése 1 tizedes jegyre
print(round(d,1)) # kerekítés
A “-” karaktert tízszer írjuk ki a képernyőre.
print("-"*10)
Az f változó értékét átalakítjuk lebegőpontos számmá a float() függvénnyel, majd elosztjuk kettővel és kiírjuk az eredményt a képernyőre.
f="34.567"
print(float(f) / 2)
A chr() függvénnyel az ASCII kód táblából az 65-ös értéknek megfelelő karaktert állítjuk elő, majd kiírjuk a képernyőre.
g=chr(65)
print(g)
# kimenet:" A "
Az ord() függvénnyel az “B” karakter ASCII kódját állítjuk elő és kiírjuk a képernyőre.
print(ord("B"))
A következő három sorban három változónak adunk értéket, és mindegyiküket kiírjuk a képernyőre.
a=b=c=15
print(a)
print(b)
print(c)
A következő két sorban két változót hozunk létre és adunk nekik értéket, majd az összegüket, különbségüket, szorzatukat, osztásukat, egész osztásukat, maradékukat és hatványozásukat kiírjuk a képernyőre.
a=15
b=34
print(a+b) # összeg
print(a-b) # külömbség
print(a*b) # szorzat
print(b/a) # osztás
print(b//a) # egeszosztas
print(b % a) # maradék
print(b ** a ) # b edik hatványa
print(pow(2,3)) #Hatvány
print(a**2) # a másodikon
print((a+b)*2) # a+bnek a 2. hatványa
c = -23
d = 3.4567
print(abs(c))
print(round(d,1)) # kerekítés
print(pow(2,3)) #Hatvány
print(2 ** 3) #Hatvány
print(abs(c)) – Az abs(c) függvény abszolút értékét írja ki a képernyőre, amelynek eredménye pozitív szám lesz.
print(round(d,1)) – A round() függvénnyel kerekíti a d változó értékét egy tizedes pontosságra és azt kiírja a képernyőre.
print(pow(2,3)) – A pow() függvénnyel hatványozási műveletet végez, az eredményt pedig kiírja a képernyőre.
print(2 ** 3) – Az ** operátorral végzett hatványozási művelet eredményét írja ki a képernyőre.
Indexelés
Az indexelés a Pythonban lehetővé teszi, hogy hozzáférjünk egy adatsorozat egyes elemeihez. Például egy lista vagy egy karakterlánc esetében az indexelés segítségével kiválaszthatjuk az egyes elemeket. Az indexelés fontos alapvető koncepció a Pythonban, és számos feladat megoldásához használható.
Az első lépésben inicializálunk egy “van” nevű változót, amely egy logikai értéket tárol. A kezdetben False értékkel inicializált “van” változó azt fogja jelenteni, hogy nincs 29-cel osztható szám a listában.
van = True
A “for” ciklus végigmegy a lista elemein a “range(len(l))” segítségével. A “len(l)” függvény meghatározza a lista hosszát, amelyet a “range” függvénnyel együtt használunk a “for” ciklusban, hogy végigmenjünk a lista elemein. Az “i” változó minden iterációban megkapja a ciklus aktuális indexét.
for i in range(len(l)):
A “if” utasítás a lista jelenlegi elemének vizsgálatára szolgál. Ha a jelenlegi elem osztható 29-cel (azaz a maradék nélkül osztható), akkor a “van” változó értékét True-ra állítjuk, majd a ciklusból kilépünk a “break” utasítással. Ez azért fontos, hogy csak az első ilyen szám indexét kaphassuk meg.
if l[i] % 29 == 0:
van = True
break
Az “if van” utasítás a ciklus után fut le, és megvizsgálja, hogy van-e 29-cel osztható szám a listában. Ha van, akkor kiírja az első ilyen szám indexét a listában a “print(f’Az első 29-cel osztható szám indexe: {i}’)” utasítással, amely az “i” változó aktuális értékét fogja kiírni. Különben pedig kiírja a “Nincs 29-cel osztható szám a sorozatban.” szöveget a “print(‘Nincs 29-cel osztható szám a sorozatban.’)” utasítással.
És a teljes kód egyben így néz ki:
van = False
for i in range(len(l)):
if l[i] % 29 == 0:
van = True
break
if van:
print(f'Az első 29-cel osztható szám indexe: {i}')
else:
print('Nincs 29-cel osztható szám a sorozatban.')
Ezen kívül a Pythonban lehetőség van negatív indexelésre is, amely az adatsorozat végéről indul és a negatív számokat használja az elemek eléréséhez.
Például:
for i in range (len(lista)-1,-1,-1):
if int(lista[i]) % 8 == 0:
break
print(i)
Ez a Python kód egy for ciklust használ egy adott listán végigmenni a hátrafelé irányba. A ciklus az adott listának a hosszából indul, az utolsó indexről kezdve visszafelé halad, egészen az 0 indexig. Minden iterációban a listának az aktuális indexű eleme ellenőriztetik, hogy osztható-e 8-cal. Ha igen, akkor a ciklusból kilép a “break” kulcsszó használatával, és a ciklusváltozó (i) értékét az aktuális indexre állítja. Ha a ciklus véget ér anélkül, hogy találnánk 8-cal osztható elemet a listán, akkor az utolsó index (len(lista)-1) lesz az i értéke. A kód végén a “print(i)” parancs kiírja az i értékét, ami az utoljára talált 8-cal osztható elem indexe a listában.
A visszafelé indexelés használata általában olyan esetekben fordul elő, amikor egy adatsorozat vagy szöveg utolsó elemeire szeretnénk hivatkozni, vagy fordított sorrendben szeretnénk végigmenni az elemein. Például ha egy lista utolsó elemére szeretnénk hivatkozni, akkor a “-1” indexet használjuk, vagy ha végigmegyünk egy szövegen visszafelé, akkor a “range(len(szoveg)-1, -1, -1)” kifejezést használjuk a for ciklusban. A visszafelé indexelés használata tehát a programozás során gyakran hasznos lehet, különösen, ha az adatsorozatunk végétől szeretnénk kezdeni a feldolgozást.
Tételek
Összegzés
Hívjuk be a random, Python bővítményt
Megadjuk az “N” értékét (ez lesz a lista hossza)
Töltsük fel az “A” nevű listát (ez a kódrészlet egy N hosszúságú listát hoz létre, amelynek elemei 1 és 100 között véletlenszerűen generált egész számok, és a range() függvény segítségével hozza létre a listát.)
Ki írjuk az “A” nevű listát, zárójelek és egyébb jelek nélkül
import random
N = 20
A = [random.randint(1, 100) for _ in range(0,N)]
print(*A)
“N” hosszúságú “A” lista elemeinek összegét számolja ki egy while ciklus és egy számláló változó (i) segítségével. A ciklus minden iterációjában hozzáadja a következő A lista elemét az összeghez (szum), majd növeli a számláló változót (i). Végül kiírja az összeget egy f-string segítségével a print() függvénnyel.
i = 0
szum = 0
while i < N:
szum += A[i]
i += 1
print(f'A sorozat elemeinek összege {szum}')
“N” hosszúságú “A” lista elemeinek összegét számolja ki egy for ciklus segítségével. A ciklus minden iterációjában hozzáadja a következő A lista elemét az összeghez (szum), amelyet egy range() függvény segítségével állít be a 0 és N-1 közötti egész számok sorozataként. Végül kiírja az összeget egy f-string segítségével a print() függvénnyel.
szum = 0
for i in range(0,N):
szum += A[i]
print(f'\n2, A sorozat elemeinek összege {szum}')
“N” hosszúságú “A” lista elemeinek összegét számolja ki egy for ciklus segítségével. A ciklus minden iterációjában az aktuális lista elemet (e) adja hozzá az összeghez (szum). Végül kiírja az összeget egy f-string segítségével a print() függvénnyel.
szum = 0
for e in A:
szum += e
print(f'\ A sorozat elemeinek összege {szum}')
“N” hosszúságú “A” lista elemeinek összegét számolja ki a beépített sum() függvénnyel, amely összeadja a lista elemeit és visszatér az összeggel. Végül kiírja az összeget egy f-string segítségével a print() függvénnyel.
print(f'\n5, A sorozat elemeinek összege {sum(A)}')
Lineáris keresés
Hívjuk be a random, Python bővítményt
Megadjuk az “N” értékét (ez lesz a lista hossza)
Töltsük fel az “A” nevű listát (ez a kódrészlet egy N hosszúságú listát hoz létre, amelynek elemei 1 és 100 között véletlenszerűen generált egész számok, és a range() függvény segítségével hozza létre a listát.)
Ki írjuk az “A” nevű listát, zárójelek és egyébb jelek nélkül
import random
N = 20
A = [random.randint(1, 100) for _ in range(0,N)]
print(*A)
i = 0
Létrehozunk egy változót, i-t, amelynek kezdőértéke 0
van = False
Létrehozunk egy logikai változót, van-t, amelynek kezdőértéke False.
while i < N and not van:
Ez a ciklus addig fut, amíg az i kisebb, mint N és van hamis. Az and azt jelenti, hogy mindkét feltételnek igaznak kell lennie ahhoz, hogy a ciklus tovább fusson.
if A[i] % 3 == 0:
Az if utasítás azt vizsgálja, hogy az aktuális elem hárommal osztható-e. Ha igen, akkor az if blokk fut le.
van = True
Az if utasítás azt vizsgálja, hogy az aktuális elem hárommal osztható-e. Ha igen, akkor az if blokk fut le.
i += 1
Az i változó értékét 1-gyel növeljük.
if van:
Az if utasítás azt vizsgálja, hogy a van változó értéke True-e. Ha igen, akkor az if blokk fut le.
print(f'\n 3, Az első hárommal osztható szám {A[i-1]}')
A print() függvény segítségével kiírjuk az első hárommal osztható szám indexét és értékét. Az i-1 érték adja meg az indexet, mert az i változó a ciklus végén már 1-gyel nagyobb, mint az utolsó vizsgált index.
else:
Ha a van változó értéke False volt, akkor az else blokk fut le.
print(f'\n3, Nincs hárommal osztható szám a sorozatban')
A print() függvény segítségével kiírjuk, hogy a listában nincs hárommal osztható szám.
Teljes kód:
i = 0
van = False
while i < N and not van:
if A[i] % 3 == 0:
van = True
i += 1
if van:
print(f'\n 3, Az első hárommal osztható szám {A[i-1]}') # mert az i += 1 akkor is le fut
else:
print(f'\n3, Nincs hárommal osztható szám a sorozatban')
van = False
Létrehozunk egy logikai változót, van-t, amelynek kezdőértéke False.
for i in range(N):
Létrehozunk egy for ciklust, amely az A lista összes elemére végigmegy.
if A[i] % 3 == 0:
Az if utasítás azt vizsgálja, hogy az aktuális elem hárommal osztható-e. Ha igen, akkor az if blokk fut le.
van = True
Az if blokkban található utasítás beállítja a van változó értékét True-ra.
break
Az if blokkban található break utasítás miatt az i változó értéke nem fog tovább növekedni, amikor találunk egy hárommal osztható számot.
if van:
Az if utasítás azt vizsgálja, hogy a van változó értéke True-e. Ha igen, akkor az if blokk fut le.
if van:
Az if utasítás azt vizsgálja, hogy a van változó értéke True-e. Ha igen, akkor az if blokk fut le.
print(f'\n 4, Az első hárommal osztható szám {A[i]}')
A print() függvény segítségével kiírjuk az első hárommal osztható szám indexét és értékét. Az i változó értéke adja meg az indexet, amelyet az if blokkban találtunk meg.
else:
Ha a van változó értéke False volt, akkor az else blokk fut le.
print(f'\n4, Nincs hárommal osztható szám a sorozatban')
A print() függvény segítségével kiírjuk, hogy a listában nincs hárommal osztható szám.
Teljes kód:
van = False
for i in range(N):
if A[i] % 3 == 0: #10-nél a nincs lehetőséget kell ki írnika
van = True
break
if van:
print(f'\n 4, Az első hárommal osztható szám {A[i]}') # itt nem történik meg az inek a növelése, nem kell a -1
else:
print(f'\n4, Nincs hárommal osztható szám a sorozatban')
Összességében tehát a kód az első hárommal osztható szám keresésére szolgál egy adott listában két különböző módon. Az első módszer egy while ciklust használ, amely addig fut, amíg megtalálja az első hárommal osztható számot. A második módszer egy for ciklust használ, amely a lista összes elemére végigmegy, és a break utasítás segítségével megáll, amikor megtalálja az első hárommal osztható számot.
A lineáris keresést leggyakrabban akkor használják, amikor egy adott elem jelenlétét kell ellenőrizni egy rendezetlen listában vagy tömbben. A lineáris keresés hatékony megoldás lehet, ha a lista vagy tömb mérete nem túl nagy, és nem rendelkezünk előzetes információval az elem helyéről.
Például, ha egy adott számot vagy sztringet kell keresni egy nagy méretű adatsoron belül, és nem tudjuk, hogy pontosan hol van, akkor a lineáris keresés lehet a megfelelő megoldás. A lineáris keresést alkalmazzák gyakran az adatbázisok lekérdezési folyamataiban is, amikor egy adott rekordot kell megtalálni egy nagy adatbázisban.
Azonban, ha a lista vagy tömb mérete nagyon nagy, vagy ha az elemek rendezettek, akkor hatékonyabb megoldás lehet más keresési algoritmusok használata, mint például a bináris keresés, amely gyorsabb keresési sebességet biztosít a rendezett adatszerkezetekben.
Szorzat
Hívjuk be a random, Python bővítményt
Megadjuk az “N” értékét (ez lesz a lista hossza)
Töltsük fel az “A” nevű listát (ez a kódrészlet egy N hosszúságú listát hoz létre, amelynek elemei 1 és 100 között véletlenszerűen generált egész számok, és a range() függvény segítségével hozza létre a listát.)
Ki írjuk az “A” nevű listát, zárójelek és egyébb jelek nélkül
import random
N = 20
A = [random.randint(1, 100) for _ in range(0,N)]
print(*A)
“N” hosszúságú “A” lista elemeinek szorzatát számolja ki egy for ciklus segítségével. A ciklus minden iterációjában az aktuális lista elemet (e) szorozza az eddig megszámolt szorzattal (szum), majd eltárolja az eredményt a szum változóban. Végül kiírja a szorzatot egy f-string segítségével a print() függvénnyel.
A szorzat számítás során a szorzás eredményeit tároló változó, a szum kezdőértékének 1-nek kell lennie, mert ha 0-val kezdenénk, akkor az összes további szorzás 0-val egyenlő lenne, és az eredményünk is 0 lenne. Ha pedig 1-től indulunk, akkor az első szorzás eredménye az első elem értéke lesz, ami helyes eredményhez vezet.
szum = 1
for e in A:
szum *= e
print(f'\n1, A sorozat elemeinek szorzata {szum}')
A szorzat számítását gyakran használjuk matematikai és programozási problémák megoldására. A szorzat azokban a helyzetekben hasznos, amikor összefüggésekben kell gondolkodni, ahol a változók nem csak egymástól függenek, hanem szorzatban is szerepelnek.
Például, ha egy adott hosszúságú vektor elemeinek szorzatát kell kiszámolni, akkor a szorzatot használhatjuk. A szorzat számítása gyakori feladat programozási feladatokban is, például akkor, amikor az összes elemet valamilyen módon össze kell szorozni, vagy amikor az átlagot kell meghatározni a megadott adatokból. Ezenkívül a szorzat hasznos lehet a valószínűségszámításban is, például akkor, amikor több esemény bekövetkezésének valószínűségét kell kiszámítani.
Összességében a szorzat használata akkor javasolt, ha az adott probléma összefüggéseket tartalmaz, amelyekben a változók szorzata szerepel, és amelyekben a szorzat fontos információt hordoz.
Összefűzés
Hívjuk be a random, Python bővítményt
Megadjuk az “N” értékét (ez lesz a lista hossza)
Töltsük fel az “A” nevű listát (ez a kódrészlet egy N hosszúságú listát hoz létre, amelynek elemei 1 és 100 között véletlenszerűen generált egész számok, és a range() függvény segítségével hozza létre a listát.)
Ki írjuk az “A” nevű listát, zárójelek és egyébb jelek nélkül
import random
N = 20
A = [random.randint(1, 100) for _ in range(0,N)]
print(*A)
B lista elemeinek összefűzéséből álló karakterláncot hoz létre egy for ciklus segítségével. A ciklus minden iterációjában hozzáadja az aktuális lista elemet (e) a már meglévő szöveghez (szum), amely így sorban összefűzi a lista összes elemét. Végül kiírja az összefűzött karakterláncot egy f-string segítségével a print() függvénnyel.
B = ["a", "l", "m", "a", "f", "a",]
szum = ""
for e in B:
szum += e
print(f'\n1, B sorozat elemeinek összefűzése {szum}')
A program az “almafa” stringet adja vissza, mivel a for ciklusban végigiterál a B listán, és minden elemét hozzáadja a szum változóhoz, amelynek kezdeti értéke egy üres string. A string összefűzését az += operátorral végzi. Végül a program kiírja az összefűzött karakterláncot az f-string formátum használatával.
Az összefűzést, más néven konkatenációt, Pythonban számos helyen használhatjuk. Például, amikor karakterláncokat szeretnénk összefűzni, vagy amikor az elemeket egy listából vagy más iterálható objektumból össze kell fűzni. Ez hasznos lehet például szövegfájlok olvasásakor és írásakor, ahol a sorokat össze kell fűzni vagy elválasztani, vagy az adatbázisokban, amikor össze kell fűzni a rekordokat. Az összefűzés egy hatékony módszer lehet az adatok rendezésére vagy a kódban való formázásra, mivel lehetővé teszi az adatok egységes formátumra hozását.
Azért ” ” a szum kezdő értéke, mert a B lista elemei karakterek, és a karakterláncok összefűzéséhez a Python-ban egy üres karakterláncra van szükség, amelyhez a további karaktereket hozzá lehet adni. Az üres karakterlánc az, amely nem tartalmaz semmilyen karaktert, és a ” ” (szóköz) egy példa erre. Ha más kezdőértéket adnánk a szum változónak, például egy számot vagy egy logikai értéket, akkor a karakterláncok összefűzése nem lenne lehetséges.
Eldöntés
Hívjuk be a random, Python bővítményt
Megadjuk az “N” értékét (ez lesz a lista hossza)
Töltsük fel az “A” nevű listát (ez a kódrészlet egy N hosszúságú listát hoz létre, amelynek elemei 1 és 100 között véletlenszerűen generált egész számok, és a range() függvény segítségével hozza létre a listát.)
Ki írjuk az “A” nevű listát, zárójelek és egyébb jelek nélkül
import random
N = 20
A = [random.randint(1, 100) for _ in range(0,N)]
print(*A)
N hosszúságú A lista elemei között keres egy olyan elemet, amely osztható 3-mal. Ehhez egy while ciklust használ, amely minden iterációjában megnézi, hogy az aktuális lista elem (A[i]) osztható-e 3-mal. Ha igen, beállítja a van változót True értékre, amely jelzi, hogy talált 3-mal osztható elemet. Ha az összes lista elemet bejárta, vagy talált ilyen elemet, a ciklusból kilép. Végül kiírja, hogy van-e 3-mal osztható elem a listában, vagy sem, az eredménytől függően egy f-string segítségével a print() függvénnyel.
i = 0
van = False
while i < N and not van:
if A[i] % 3 == 0:
van = True
i += 1
print(f'{"Van" if van else "Nincs"} az A sorozatban 3mal osztható elem ')
Ebben az esetben egy while ciklust használ, amely minden iterációjában megnézi, hogy az aktuális lista elem (A[i]) osztható-e 3-mal. Ha igen, kilép a ciklusból a break utasítással. Ha nem talál ilyen elemet, végigmegy az összes lista elemen, majd kilép a ciklusból. Végül kiírja, hogy van-e 3-mal osztható elem a listában, vagy sem, az eredménytől függően egy f-string segítségével a print() függvénnyel.
while i < N:
if A[i] % 3 == 0:
break
i += 1
print(f'\n3, {"Van" if i < N else "Nincs"} az A sorozatban 3mal osztható elem ')
Az ilyen típusú eldöntések nagyon fontosak a programozásban, és szinte minden programban megtalálhatóak. Az eldöntések segítségével lehetőség van a program számára arra, hogy különböző utasításokat hajtson végre az adott feltétel függvényében. Ez lehetővé teszi a programok számára, hogy rugalmasan és dinamikusan működjenek, és alkalmazkodjanak a különböző helyzetekhez és környezetekhez. Az ilyen típusú eldöntéseknek számos alkalmazási területe van, például a keresési és rendezési algoritmusokban, a szűrőrendszerekben, a felhasználói felületekben és a szimulációkban.
Kiválasztás
Hívjuk be a random, Python bővítményt
Megadjuk az “N” értékét (ez lesz a lista hossza)
Töltsük fel az “A” nevű listát (ez a kódrészlet egy N hosszúságú listát hoz létre, amelynek elemei 1 és 100 között véletlenszerűen generált egész számok, és a range() függvény segítségével hozza létre a listát.)
Ki írjuk az “A” nevű listát, zárójelek és egyébb jelek nélkül
import random
N = 20
A = [random.randint(1, 100) for _ in range(0,N)]
print(*A)
i = 0
Létrehozunk egy változót, i-t, amelynek kezdőértéke 0
while A[i] % 2 != 0:
Ez a ciklus addig fog futni, amíg az aktuális indexű elem nem páros szám. Az A[i] megadja a lista i-edik elemét, a % 2 azt jelenti, hogy az adott szám osztható-e 2-vel maradék nélkül, a != 0 azt jelenti, hogy nem osztható maradék nélkül. Tehát a ciklus addig fut, amíg a lista következő eleme páratlan szám.
i += 1
Ha az aktuális elem páratlan szám, a változó értékét 1-gyel növeljük.
print(f'\n 1, Az első páros szám {A[i]} indexe {i}')
Miután találtunk egy páros számot, a print() függvény segítségével kiírjuk az első páros szám indexét és értékét.
A teljes kód így néz ki:
i = 0
while A[i] % 2 != 0:
i += 1
print(f'\n 1, Az első páros szám {A[i]} indexe {i}')
Létrehozunk egy for ciklust, amely az A lista összes elemére végigmegy.
if A[i] % 2 == 0:
A if utasítás azt vizsgálja, hogy az aktuális elem páros szám-e. Ha igen, akkor az if blokk fut le.
break
blokkban található break utasítás megállítja a for ciklust, amikor talál egy páros számot.
print(f'\n 2, Az első páros szám {A[i]} indexe {i}')
Miután találtunk egy páros számot, a print() függvény segítségével kiírjuk az első páros szám indexét és értékét.
A teljes kód így néz ki:
for i in range(len(A)):
if A[i] % 2 == 0:
break
print(f'\n 2, Az első páros szám {A[i]} indexe {i}')
A két megközelítés közötti különbség az, hogy az első megközelítés egy while ciklust használ, amely az első páros számot keresi, és csak akkor áll meg, amikor megtalálta. A második megközelítés egy for ciklust használ, amely az összes elemre végigmegy, és amikor megtalálja az első páros számot, azonnal megáll az if és a break utasítások segítségével.
for i in range(len(A)):
Adatszerkezetek
int
Mire használható az int?
Az egyik leggyakrabban használt adattípus az int, amely egész számokat képvisel.
Az int adattípus a programozási nyelvben használt egyik alapvető adattípus. Az egész számokat jelöli, azaz azokat a számokat, amelyeknek nincsen tizedes része, például 1, 2, 3, 4, stb.
Az int adattípus használata rendkívül egyszerű. Csak meg kell adnod az értéket, és a program az int adattípussal fogja értelmezni. Például, ha az értéke 5, akkor a program az int adattípusnak fogja értelmezni, és ezután az értéket az int adattípus szabályai szerint kezeli majd.
Fontos megjegyezni, hogy az int adattípus csak egész számokat fogad el. Ha valamilyen tizedes pontot vagy tizedest használsz az értékben, akkor az a program számára egy másik adattípus (pl. float) lesz.
Az int adattípus rendkívül fontos az alapvető matematikai műveletek végrehajtásához, például az összeadáshoz, kivonáshoz, szorzáshoz és osztáshoz. Az int adattípus használata lehetővé teszi, hogy a program egyszerűen és hatékonyan kezelje ezeket a műveleteket.
Példa
Az “int” típusú változók számtani műveletekkel kezelhetők, mint például az összeadás (+), kivonás (-), szorzás (*), osztás (/), egész osztás (//) és a maradék számítás (%).
a = 5
b = 2
print(a + b) # Output: 7
print(a - b) # Output: 3
print(a * b) # Output: 10
print(a / b) # Output: 2.5
print(a // b) # Output: 2
print(a % b) # Output: 1
Ha tizedes számmal próbálunk dolgozni az “int” típusú változóval, akkor a Python egyszerűen elhagyja a tizedes részt, és az egész számot használja.
a = 3.14
b = int(a)
print(b) # Output: 3
A fenti példában a “3.14” értéket egy lebegőpontos számként definiáltuk. Azután a “b” változóba helyeztük a “3.14” érték egész részét, amely az “int()” függvény használatával történt. Amikor az “int()” függvényt használjuk egy lebegőpontos számra, akkor a Python levágja a tizedes részt, és csak az egész részt használja.
Fontos megjegyezni, hogy az “int” típusú változók kizárólag egész számokat tudnak tárolni, és nem tudnak tizedes számokat tartalmazni. Ha tizedes számokkal szeretnénk dolgozni a Python-ban, akkor a “float” típusú változót kell használnunk.
Komplex feladat
fogyasztas = int(input('Az autó fogyasztása [l/100km]: '))
urtartalom = int(input('A benzintank űrtartalma [l]: '))
tav = int(input('A megtenni kívánt távolság [km]: '))
# Az autó által megtett távolság kiszámítása
km = urtartalom / fogyasztas * 100
# Az autó által megtett távolság kiíratása
print(f'Az autó {km} km-t tud megtenni, ha tele tankkal indul.')
# Ellenőrzés, hogy szükséges-e tankolni az út során
print(f'Az út során {"nem" if km < tav else ""} kell tankolnunk.')
- Bekérjük az autó fogyasztását (
fogyasztas), az üzemanyagtartály űrtartalmát (urtartalom) és a megtenni kívánt távolságot (tav) a felhasználótól. - Az
kmváltozóban kiszámítjuk, hogy az autó mennyi kilométert tud megtenni, ha tele tankkal indul. Ehhez az üzemanyagtartály űrtartalmát (urtartalom) elosztjuk az autó fogyasztásával (fogyasztas), majd megszorozzuk 100-zal, hogy az eredményt kilométerben kapjuk. - A
kmértékét kiíratjuk a képernyőre, hogy megtudjuk, hány kilométert tud megtenni az autó, ha tele tankkal indul. - Ellenőrizzük, hogy szükséges-e tankolni az út során. Ha az autó által megtett távolság (
km) kisebb, mint a megtenni kívánt távolság (tav), akkor kiírjuk, hogy nem kell tankolnunk az út során. Ellenkező esetben, ha az autó által megtett távolság nagyobb vagy egyenlő a megtenni kívánt távolsággal, akkor kiírjuk, hogy kell tankolnunk az út során.
Buktató, figyelmezetés
- A kód feltételezi, hogy a felhasználó helyesen adja meg az adatokat, és egész számokat ad meg.
- Meg kell győződni arról, hogy a felhasználó helyes értékeket ad meg a fogyasztás, üzemanyagtartály űrtartalma és távolság esetén.
- Az üzemanyagtartály űrtartalmát és a fogyasztást át kell váltani azonos mértékegységre (pl. mindkettő literre/100 km-re vagy mindkettő
float
Mire használható a float?
A “float” típusú változók a Python programozási nyelvben a lebegőpontos számokat tárolják. A lebegőpontos számok olyan számok, amelyeknek van egy egész része és egy tizedes része is. A tizedes rész a pont utáni rész, és a pont előtt lehet nulla vagy több jegy.
A “float” típusú változókat gyakran használják matematikai műveletekhez, amelyek tizedes pontosságot igényelnek. Az ilyen műveletek közé tartoznak például az adagolás, kivonás, szorzás és osztás.
Példa
Egyszerű példa a használatához
a = 3.14
b = 2.71
c = a + b
print(c) # Output: 5.85
Ebben a példában a “a” változóba egy tizedes pontossággal tárolt lebegőpontos számot helyeztünk el, majd ugyanezt tettük a “b” változóval is. A “c” változóba az “a” és “b” változók összegét helyeztük el, majd kiírattuk az “c” változó értékét, amely szintén egy tizedes pontossággal tárolt lebegőpontos szám.
A “float” típusú változók használata fontos, ha a programunkban olyan matematikai műveleteket hajtunk végre, amelyek tizedes pontosságot igényelnek.
complex
Mire használható az complex?
A “complex” típusú változók a Python programozási nyelvben a komplex számokat tárolják. A komplex számok egy valós és egy képzeletbeli részből állnak, amelyeket az alábbi módon írnak fel: a + bj, ahol a a valós rész, b pedig a képzeletbeli rész. A j az ún. imaginárius egység, amelyre teljesül, hogy j^2 = -1.
A “complex” típusú változókat általában matematikai műveletekhez használják, amelyekben komplex számok szerepelnek. Az ilyen műveletek közé tartoznak például az összeadás, kivonás, szorzás, osztás, konjugáció és az abszolút érték számítása.
1. Példa
Alábbi példában két komplex számot szorozunk össze, majd eredményként egy új “complex” típusú változóban tároljuk az eredményt:
a = 2 + 3j
b = 1 - 2j
c = a * b
print(c)
A fenti példában a “a” változóba egy komplex számot (2 + 3j), a “b” változóba pedig egy másik komplex számot (1 – 2j) helyeztünk el. Azután az “a” és “b” változókat összeszorzuk és az eredményt egy új “complex” típusú változóba (c) helyezzük. Az “c” változó értékét kiíratjuk a képernyőre, és az eredmény (8+1j) lesz.
A “complex” típusú változók használatakor fontos tudni, hogy a valós és a képzeletbeli rész is lebegőpontos számokat tartalmazhat. Emiatt azokat a matematikai műveleteket, amelyek komplex számokkal dolgoznak, lebegőpontos hibák is érinthetik.
2. Példa
Ebben a példában egy egyszerű komplex számot hozunk létre, majd kiíratjuk annak valós és képzeletbeli részét:
z = 2 + 3j
print("A komplex szám valós része:", z.real) # A komplex szám valós része: 2.0
print("A komplex szám képzeletbeli része:", z.imag) # A komplex szám képzeletbeli része: 3.0
Ebben az esetben a “z” változó egy egyszerű komplex számot tartalmaz (2 + 3j). Azután kiíratjuk a “z” változó valós és képzeletbeli részét a “real” és “imag” attribútumok segítségével. Az eredmény a következő lesz:
Összetett - Példa
z = 2 + 3j
w = 4 - 5j
# Összeadás
print(z + w) # eredmény: (6-2j)
# Kivonás
print(z - w) # eredmény: (-2+8j)
# Szorzás
print(z * w) # eredmény: (23+2j)
# Osztás
print(z / w) # eredmény: (-0.18421052631578946+0.7105263157894737j)
# Modulus (abszolút érték)
print(abs(z)) # eredmény: 3.605551275463989
# Argumentum (fázis) radiánban
print(cmath.phase(z)) # eredmény: 0.982793723247329
# Konjugált
print(z.conjugate()) # eredmény: (2-3j)
Ebben a példában két komplex számot hozunk létre, z és w. Majd különböző műveleteket hajtunk végre velük, például összeadjuk őket, kivonjuk őket, szorozzuk és osztjuk őket. A abs() függvény használatával a modulus (abszolút érték) határozható meg, és a cmath.phase() függvénnyel a fázis (argumentum) radiánban határozható meg. Végül a conjugate() függvény segítségével meghatározható egy adott komplex szám konjugáltja.
string
Mire használható a string?
A string adattípus egy olyan adattípus a Pythonban, amely szöveges adatok tárolására és manipulálására szolgál. A szöveg lehet bármilyen karakterből álló, beleértve a betűket, számokat és speciális karaktereket is. A string adattípus az egyik leggyakrabban használt adattípus a Python programozásban, mivel szöveges adatokat kell feldolgozni szinte minden alkalmazásban, legyen az adatbázis-kezelés, adatgyűjtés, webes alkalmazások vagy akár gépi tanulás.
A string adattípus Pythonban számos hasznos beépített módszert kínál, amelyek segítségével könnyedén manipulálhatóak a szövegek. Például a szöveg karaktereinek helyének és sorrendjének megváltoztatására, az összehasonlításra, a keresésre és helyettesítésre, valamint a szöveg darabokra bontására és egyesítésére.
A string adattípus karakterláncokat (stringeket) tárol, amelyeket az idézőjelek közé írunk. A Pythonban háromféle idézőjelet használhatunk: egyszeres idézőjelet (‘ ‘), dupla idézőjelet (” “) és háromszoros idézőjelet (”’ ”’ vagy “”” “””). Az egyszeres és a dupla idézőjelek között nincs különbség, de a háromszoros idézőjelek lehetővé teszik a többsoros stringek írását.
Példa
my_string = "Ez egy karakterlánc."
A karakterláncban található karakterek hozzáférhetők a Python indexelési szintaxisán keresztül, azaz egy adott karakter elérése az [] jelekkel történik. Például:
my_string = "Ez egy karakterlánc."
print(my_string[0]) # Output: "E"
A “str” adattípusnak számos hasznos beépített módszere van, amelyek lehetővé teszik a karakterláncok manipulálását, pl. összefűzés, karakterek cseréje, konvertálása stb.
Például, az alábbi kód megmutatja, hogyan fűzhetünk össze két karakterláncot a “+” operátorral:
str1 = "Hello"
str2 = "world"
result = str1 + " " + str2
print(result) # Output: "Hello world"
Összetett példa- Példa
# Egyszerű string deklaráció
name = "John Doe"
# String hosszának lekérdezése
print(len(name)) # Output: 8
# String karaktereinek kiírása
for char in name:
print(char)
# String manipulálása
new_name = name.replace("John", "Jane")
print(new_name) # Output: Jane Doe
# String darabokra bontása
text = "This is a sentence."
words = text.split(" ")
print(words) # Output: ['This', 'is', 'a', 'sentence.']
# String egyesítése
new_text = "-".join(words)
print(new_text) # Output: 'This-is-a-sentence.'
Ezen példákon keresztül láthatjuk, hogy a string adattípus hogyan használható a szöveges adatok tárolására és manipulálására. A string adattípus rendkívül rugalmas és erőteljes, és számos további módszer és funkció áll rendelkezésünkre, amelyek segítségével könnyedén dolgozhat.
bool
Mire használható a bool?
A “bool” adattípus (vagy logikai adattípus) a Python egyik alapvető adattípusa, amelyet arra használunk, hogy igaz vagy hamis értékeket tároljunk. Az “igaz” és “hamis” értékek jellemzően hasznosak olyan szituációkban, amikor a programnak el kell döntenie, hogy az adott körülmény teljesül-e vagy sem, és ennek függvényében megfelelő cselekvést kell végrehajtania.
A “bool” típus az “if” utasításokban, a ciklusokban, az összehasonlító operátorok használatával, a logikai operátorokkal és más olyan helyzetekben hasznos, ahol logikai értékre van szükségünk. Az összehasonlító operátorok, mint például a “<“, “<=”, “==”, “!=”, “>=”, “>”, “in”, “not in”, valamint a logikai operátorok, mint például az “and”, “or” és “not” segítségével értékelhetjük ki logikai kifejezéseket, amelyeknek a végeredménye a “bool” típus lesz.
Összehasonlítás - Példa
A következő kódrészlet a “bool” adattípus használatát mutatja be az összehasonlításra:
x = 5
y = 10
is_greater = x > y # is_greater értéke False lesz, mert x kisebb, mint y
print(is_greater) # Output: False
is_equal = x == y # is_equal értéke False lesz, mert x nem egyenlő y-val
print(is_equal) # Output: False
is_not_equal = x != y # is_not_equal értéke True lesz, mert x nem egyenlő y-val
print(is_not_equal) # Output: True
A “bool” adattípus hasznos minden olyan helyzetben, ahol logikai értékeket kell tárolni, például feltételes utasítások, ciklusok és függvények használatakor. A Pythonban a logikai értékek “True” és “False” mellett vannak olyan beépített értékek is, mint a “None” (semleges), amelyek szintén fontosak lehetnek a programozás során.
Egyszerű logikai kifejezések - Példa
a = 5
b = 10
c = a < b # True
d = a > b # False
e = a == b # False
f = a != b # True
Ebben a példában az a, b, c, d, e és f változók mindegyike bool típusú. Az a < b kifejezés igaz, mert az a változó értéke kisebb, mint a b változó értéke. Az a > b hamis, mert a értéke nem nagyobb, mint b értéke. Az a == b hamis, mert az a és b értéke nem azonosak, az a != b pedig igaz, mert a és b értéke nem azonos.
Felületvizsgálatok - Példa
age = 20
is_adult = age >= 18 # True
is_teenager = age >= 13 and age < 18 # False
is_child = age < 13 # False
Ebben a példában az age, is_adult, is_teenager és is_child változók mindegyike bool típusú. Az is_adult igaz, ha az age változó értéke nagyobb vagy egyenlő 18-cal, az is_teenager hamis, ha az age változó értéke nagyobb vagy egyenlő 13-cal és kisebb, mint 18, és az is_child hamis, ha az age változó értéke kisebb, mint 13.
Függvények visszatérési értéke - Példa
def is_even(number):
return number % 2 == 0
x = 4
y = 5
is_x_even = is_even(x) # True
is_y_even = is_even(y) # False
Ebben a példában az is_even függvény egy bool típusú értéket ad vissza: igaz, ha a number paraméter értéke páros, és hamis, ha páratlan. Az is_x_even változó igaz, mert a x értéke 4, ami páros szám, az is_y_even változó hamis, mert y értéke 5, ami páratlan szám.
list
Mire használható a list?
A lista (angolul: “list”) egy olyan adattípus, amely egy sorozatot tartalmazó objektumot jelöl. Az egyes elemek a listában indexek segítségével érhetők el, amelyek az első elemetől kezdve sorban növekednek egészen az utolsó elemig. A lista tetszőleges típusú elemeket tartalmazhat, beleértve más listákat, szótárakat, számokat, karakterláncokat és logikai értékeket is.
Példa
A lista Pythonban a szögletes zárójelek között definiálható. Az elemek vesszővel vannak elválasztva, és bármely érvényes Python kifejezést tartalmazhatnak. Például:
my_list = [1, 2, 3, "four", True]
A fenti példában a my_list nevű változó egy öt elemű listát tartalmaz, amely az egész számokat, karakterláncokat és egy logikai értéket tartalmazza.
A lista elemei elérhetők index segítségével, amelyek az első elemetől kezdődően egész számokkal vannak meghatározva. Például a my_list első eleméhez a következőképpen férhetünk hozzá:
first_element = my_list[0]
A lista elemek módosíthatók, és új elemeket is hozzáadhatunk a listához az append() metódus segítségével. Például:
my_list.append("new item")
Ez a kódrészlet hozzáad egy új elemet a listához, amelynek értéke “new item”.
A lista elemeket szintén eltávolíthatjuk a remove() metódus vagy a del kulcsszó használatával. Például:
my_list.remove("four")
del my_list[1]
Ezek a kódrészletek eltávolítják a listából a “four” elemet, majd a második elemet (a 2-t).
Összetett - Példa
Például az alábbi lista tartalmazza az aktuális kosarat, amely egy webshopban található:
kosar = ["Áfonya", "Kókuszos csokoládé", "Kenyér", "Tej", "Alma"]
A listában különböző típusú elemek is lehetnek, például számok vagy akár más listák is:
adatok = ["John Doe", 35, "john.doe@example.com", [101, 102, 103]]
A listák elemei numerikus indexszel érhetők el, amelyek az elemek sorrendjétől függenek. Az indexek nullától kezdődnek, és a lista hosszának egyel kevesebb, mint a lista elemek száma:
kosar = ["Áfonya", "Kókuszos csokoládé", "Kenyér", "Tej", "Alma"]
print(kosar[0]) # kimenet: "Áfonya"
print(kosar[2]) # kimenet: "Kenyér"
print(kosar[-1]) # kimenet: "Alma"
print(len(kosar)) # kimenet: 5
A listákhoz számos beépített metódus is tartozik, amelyek segítségével könnyen manipulálhatjuk őket. Például, ha hozzá akarunk adni egy új elemet a listához, akkor a append() metódust használhatjuk:
kosar = ["Áfonya", "Kókuszos csokoládé", "Kenyér", "Tej", "Alma"]
kosar.append("Sajt")
print(kosar) # kimenet: ["Áfonya", "Kókuszos csokoládé", "Kenyér", "Tej", "Alma", "Sajt"]
Ha pedig el akarjuk távolítani az utolsó elemet a listából, akkor a pop() metódust használhatjuk:
kosar = ["Áfonya", "Kókuszos csokoládé", "Kenyér", "Tej", "Alma"]
kosar.pop()
print(kosar) # kimenet: ["Áfonya", "Kókuszos csokoládé", "Kenyér", "Tej"]
A listák többféle módosítási műveletet is támogatnak, mint például elemek hozzáadása vagy eltávolítása, valamint a lista elemeinek átrendezése vagy másolása. A listák alkalmazása különösen hasznos, amikor egy programnak számos hasonló típusú objektumokat kell kezelnie, mint például adatsorokat, képeket vagy szövegeket.
Komplex feladat
def ibetuk(szoveg):
db = 0
for b in szoveg:
if b == 'i':
db += 1
return db
honapok = ['január', 'február', 'március', 'április', 'május', 'június', 'július', 'augusztus', 'szeptember', 'október', 'november', 'december']
max = honapok[0]
for e in honapok:
if ibetuk(max) < ibetuk(e):
max = e
print(f'A legtöbb \'i\' betűt tartalmazó hónap: {max}.')
A legtöbb 'i' betűt tartalmazó hónap: április.
- Definiálunk egy függvényt,
ibetuk, amely paraméterként kap egy szöveget (szoveg). Ez a függvény számolja meg, hogy hány ‘i’ betű van a szövegben. Ehhez inicializáljuk adbváltozót 0-val, majd végigmegyünk a szövegen karakterenként (for b in szoveg). Ha a karakter ‘i’, növeljük adbértékét eggyel. - Változóban (
honapok) tároljuk az összes hónap nevét egy listában. - Inicializálunk egy
maxváltozót, amelyet az első hónappal (honapok[0]) állítunk be kezdeti értékként. - Végigmegyünk minden hónapon (
for e in honapok) és összehasonlítjuk az ‘i’ betűk számát a jelenlegi legtöbb ‘i’-t tartalmazó hónappal (ibetuk(max) < ibetuk(e)). Ha az aktuális hónap több ‘i’-t tartalmaz, mint a jelenlegi legtöbb ‘i’-t tartalmazó hónap, akkor frissítjük amaxváltozót az aktuális hónapra. - Kiíratjuk a legtöbb ‘i’ betűt tartalmazó hónapot a képernyőre.
Buktató, figyelmezetés
- A kód feltételezi, hogy az ‘i’ betűket kisbetűként írják a hónapokban. Ha nagybetűvel vannak írva, az ‘i’ betűket nem fogja számolni.
- Az ‘i’ betűk számolásánál a kód nem különbözteti meg az ékezetes és ékezet nélküli ‘i’-ket. Tehát, ha a szövegben van ékezetes ‘í’ karakter, azt is számolja.
- Az ‘i’ betűk számolása case-sensitive módon történik, tehát kis- és nagybetű ‘i’-k külön-külön számolódnak.
- Az ‘i’ betűk számolása egyszerű karakterösszehasonlításon alapul. Ezt figyelembe kell venni, ha a szövegben más karakterek is lehetnek, és csak az ‘i’-ket szeretnénk számolni.
- Az ‘i’ betűk számolása során a kódban nincs figyelembe véve az ‘i’ betűk kontextusa, csak az ‘i’ karakterek előfordulásának száma számít.
tuple
Mire használható a tuple?
A tuple adattípus a Python egyik beépített adattípusa, amely egy sorrendben elrendezett, nem módosítható (immutable) objektumokból álló sorozatot (sequence) reprezentál. A tuple hasonló a list-hez, azonban a tuple elemei egyszer beállított értékeket tartalmaznak, amelyek nem módosíthatóak. Tehát a tuple elemeket egyszerűen csak ki lehet olvasni, de nem lehet módosítani.
A tuple azonban hasznos, ha olyan adatokat szeretnénk tárolni, amelyek nem változnak, például egy cím, egy telefonszám, vagy egy dátum. A tuple-kat zárójelek közé helyezzük, és az elemeket vesszővel választjuk el egymástól. A tuple elemek típusa lehet bármilyen Python objektum, így más tuple, lista vagy akár egy függvény is lehet az elem.
A tuple-kat szintaxisuk miatt könnyű definiálni és használni, mivel nem kell aggódniuk az esetleges módosítások miatt. Ha például az adott programban olyan adatokat kell tárolnunk, amelyeket a program élete során nem módosítunk, akkor a tuple használata megfelelő választás lehet.
Példa
Példa egy tuple létrehozására és kiíratására:
# egy tuple létrehozása
telefonszamok = ("+36 30 123 4567", "+36 20 987 6543", "+36 70 555 1212")
# kiíratjuk a tuple elemeit
for telefonszam in telefonszamok:
print(telefonszam)
Ebben a példában három telefonszámot tartalmazó tuple-t hoztunk létre, majd kiíratjuk az összes elemét a for ciklus segítségével. A tuple használata kényelmes, mivel nem kell aggódni a módosítások miatt. Ha megpróbálnánk hozzáadni vagy eltávolítani egy elemet a tuple-ből, akkor a Python hibát dobna.
Koordináták tárolása - Példa
coordinates = (10, 20, 30)
A tuple lehetővé teszi, hogy egyszerre tároljuk az x, y és z koordinátákat.
Személyes információk - Példa
person = ("John", "Doe", 35, "john.doe@example.com")
A tuple lehetővé teszi, hogy több értéket tároljunk egyszerre a személyről.
Számok listája - Példa
numbers = (1, 2, 3, 4, 5)
A tuple lehetővé teszi, hogy több értéket tároljunk egyszerre, mint például egy számok listája.
Konstansok definiálása - Példa
COLORS = ("red", "green", "blue")
A tuple lehetővé teszi, hogy több konstanst tároljunk egyszerre.
Heterogén adatok tárolása - Példa
mixed_data = ("John", 35, 1.75, True)
A tuple lehetővé teszi, hogy különböző típusú adatokat tároljunk egyszerre, akár egyetlen tuple-ben.
Szótár kulcs-érték párok tuple-ben történő tárolása - Példa
user_info = (("name", "John"), ("age", 35), ("email", "john.doe@example.com"))
A tuple lehetővé teszi, hogy kulcs-érték párokat tároljunk egyszerre, így egyszerűbben és rendezettebben tárolhatjuk a felhasználói információkat.
set
Mire használható a set?
A set adattípus egy olyan adatszerkezet, amely egyedi elemek gyűjteménye, amelyeket nem lehet rendezni. A set egy mutálható adatszerkezet, ami azt jelenti, hogy a hozzáadhatunk vagy eltávolíthatunk elemeket belőle.
A set adatstruktúra hasznos lehet, ha szeretnénk eltávolítani a duplikált elemeket egy gyűjteményből, vagy ha szeretnénk ellenőrizni, hogy egy elem szerepel-e egy adott gyűjteményben. A set-nek nincs indexe, így az elemek eléréséhez iterálnunk kell rajta.
A set létrehozásához kapcsos zárójeleket ({}) használunk, és vesszővel elválasztjuk az elemeket. A set támogatja a matematikai halmazok műveleteit is, mint például az uniót, metszetet, különbséget.
Példa
Például, ha az első halmazunk {1, 2, 3, 4, 5} és a második halmazunk {4, 5, 6, 7, 8}, akkor az uniójuk {1, 2, 3, 4, 5, 6, 7, 8}, a metszetük {4, 5}, a különbségük pedig {1, 2, 3} és {6, 7, 8}.
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
# Unió
union_set = set1 | set2
print(union_set) # Output: {1, 2, 3, 4, 5, 6, 7, 8}
# Metszet
intersection_set = set1 & set2
print(intersection_set) # Output: {4, 5}
# Különbség
difference_set = set1 - set2
print(difference_set) # Output: {1, 2, 3}
difference_set = set2 - set1
print(difference_set) # Output: {8, 6, 7}
A set adatszerkezet lehetővé teszi az elemek hozzáadását vagy eltávolítását is a add() és a remove() metódusok segítségével.
fruits = {"apple", "banana", "cherry"}
fruits.add("orange")
fruits.remove("banana")
print(fruits) # Output: {"apple", "cherry", "orange"}
Fontos megjegyezni, hogy a set-ben csak hashelhető objektumok szerepelhetnek, azaz azok, amelyekhez hozzárendelhető egy egyedi hash érték. Ezek például a számok, stringek és tuple-ök, de nem tartoznak ide a listák és a dictionary-k.
Összetett - Példa
# Hétvégi sportesemények résztvevői
foci_resztvevok = {"Anna", "Béla", "Cili", "Dénes", "Emma", "Feri", "Géza", "Hedi"}
kosar_resztvevok = {"Anna", "Cili", "Dénes", "Géza", "Hedi", "István", "Judit"}
# Közös résztvevők kinyerése
kozos_resztvevok = foci_resztvevok.intersection(kosar_resztvevok)
# Csak foci résztvevői
csak_foci_resztvevok = foci_resztvevok - kozos_resztvevok
# Csak kosár résztvevői
csak_kosar_resztvevok = kosar_resztvevok - kozos_resztvevok
print("Közös résztvevők:", kozos_resztvevok)
print("Csak foci résztvevők:", csak_foci_resztvevok)
print("Csak kosár résztvevők:", csak_kosar_resztvevok)
Ebben a példában a set adattípus segítségével tároljuk azoknak a sporteseményeknek a résztvevőit, amelyek hétvégén zajlanak. A két halmaz közös elemeit a intersection() metódussal, míg a két halmaz különbségeit az a - b művelettel számoljuk ki. Az eredményeket pedig a print() függvénnyel jelenítjük meg a képernyőn.
dict
Mire használható a dict?
A dictionary (szótár) adattípus a Python egyik legfontosabb adatszerkezete. A dictionary egy kulcs-érték párokból álló gyűjtemény, ahol az egyes kulcsokhoz különböző értékek tartoznak. A dictionaryket kapcsolati adatbázisokhoz hasonlítják, ahol a kulcsok egy adott rekordra, míg az értékek a rekord adataira utalnak.
A dictionary adatszerkezet létrehozásakor a kulcsokat és az értékeket kettősponttal elválasztva, a kulcs-érték párokat pedig vesszővel elválasztva adhatjuk meg, zárójelek között. A kulcsok tetszőleges hashelhető típusok lehetnek, például számok vagy karakterláncok.
A dictionary adatszerkezetben a kulcsok egyediek, azaz nem lehetnek többször előforduló kulcsok. Ha egy kulcsot felülírunk egy másik értékkel, az előző kulcshoz tartozó érték elvész. Az értékek bármilyen típusúak lehetnek, beleértve a listákat és más dictionaryket is.
Az értékekhez a kulcsok alapján könnyen hozzáférhetünk, csak a kulcsot kell megadni a dictionary négyzetes zárójelben történő indexelésekor. Ha egy olyan kulcsra hivatkozunk, amely nem szerepel a dictionary-ben, akkor KeyError kivétel keletkezik.
Dictionary használata - Példa
telefonszamok = {'John': '555-1234', 'Jane': '555-5678', 'Bob': '555-9012'}
print(telefonszamok['John']) # eredmény: '555-1234'
Ebben a példában a telefonszamok dictionary három kulcs-érték párt tartalmaz, ahol a kulcsok szöveges típusúak (John, Jane és Bob), az értékek pedig szintén szöveges típusúak (telefonszámok). A példában láthatjuk, hogy a dictionaryben tárolt adatokhoz a kulcsok alapján könnyedén hozzáférhetünk az indexelés segítségével.
Öszetett - Példa
# Adott egy szótár, amely a boltban kapható termékek adatait tartalmazza
inventory = {
"alma": {
"mennyiseg": 10,
"egysegar": 100,
"cikkszam": "A001"
},
"körte": {
"mennyiseg": 5,
"egysegar": 150,
"cikkszam": "A002"
},
"banán": {
"mennyiseg": 20,
"egysegar": 50,
"cikkszam": "A003"
}
}
# Ellenőrizzük, hogy van-e a boltban banán
if "banán" in inventory:
print("Van banán a boltban.")
else:
print("Nincs banán a boltban.")
# Módosítsuk a banán darabszámát 25-re
inventory["banán"]["mennyiseg"] = 25
# Ellenőrizzük, hogy módosult-e a banán darabszáma
print("A boltban most {} darab banán van.".format(inventory["banán"]["mennyiseg"]))
# Adjuk hozzá egy új termék adatait a szótárhoz
inventory["szőlő"] = {
"mennyiseg": 12,
"egysegar": 200,
"cikkszam": "A004"
}
# Ellenőrizzük, hogy hozzáadódott-e az új termék a szótárhoz
if "szőlő" in inventory:
print("Hozzáadva a szőlő a bolt kínálatához.")
else:
print("Hiba: nem sikerült hozzáadni a szőlőt a bolt kínálatához.")
Ez a példa egy boltban kapható termékek adatait tárolja egy dict adattípusban. Minden terméknek van egy neve, mennyisége, egységára és cikkszáma. A kód bemutatja, hogyan lehet hozzáadni és módosítani a szótárhoz tartozó adatokat, valamint hogyan lehet ellenőrizni, hogy a szótár tartalmazza-e adott termék adatait.
Elágazások
Az elágazások alapvetően a programozásban arra szolgálnak, hogy bizonyos feltételek alapján különböző utasításokat hajtsanak végre a programok. Az elágazások két fő típusa a “ha akkor” és a “ha akkor különben” elágazás.
Az “if” utasítás segítségével a “ha akkor” elágazás hajtható végre. Az “if” utasítás megvizsgálja egy adott feltétel igazságértékét. Ha a feltétel igaz, akkor az “if” ágban megadott utasítások hajtódnak végre, ha a feltétel hamis, akkor ezek az utasítások nem futnak le. Az “if” utasítás opcionálisul tartalmazhat “elif” ágakat is, amelyek egymás után következnek, és különböző feltételek teljesülése esetén különböző utasításokat hajtanak végre.
A “ha akkor különben” elágazás megvalósításához az “if” utasítás mellett a “else” utasításra is szükség van. Az “else” utasítás az “if” utasítás által megadott feltétel hamis esetén hajtódik végre. Az “if” utasítás és az “else” utasítás segítségével több ág is megadható, amelyek különböző feltételek teljesülése esetén hajtanak végre különböző utasításokat.
Az elágazások használata segít a programokban az esetek sokféleségének kezelésében, és lehetővé teszi, hogy a programok dinamikusan alkalmazkodjanak a változó környezeti feltételekhez. Az elágazások alkalmazása azonban néha bonyolult logikai szerkezeteket hozhat létre, amelyek nehezebbé tehetik a programok olvashatóságát és karbantarthatóságát. Ezért fontos, hogy az elágazásokat a programozás során célszerűen és ésszerűen alkalmazzuk.
Az elágazások alapvető vezérlési struktúrák a programozásban, amelyek lehetővé teszik, hogy a program a különböző feltételek függvényében különböző utakat kövessen. Az elágazások lehetővé teszik a programozónak, hogy különböző műveleteket hajtson végre különböző helyzetekben, ami rendkívül fontos a programok hatékony és rugalmas vezérlése szempontjából.
Az elágazásokat az “if”, “elif” és “else” kulcsszavak segítségével hozzuk létre a Pythonban. Az “if” kulcsszó egy feltételt vizsgál, és ha az igaz, akkor a blokkját hajtja végre, ellenkező esetben átugorja. Az “elif” kulcsszó hasonlóan működik, mint az “if”, azonban az előző feltétel hamis volt. Az “else” kulcsszó az összes korábbi feltétel hamis voltának esetére hajtódik végre.
Az elágazások használata különösen hasznos, amikor több feltétel teljesülése esetén ismerjük a műveleteket, amelyeket végrehajtani szeretnénk. Például, ha egy programban több kimeneti lehetőség van attól függően, hogy a felhasználó milyen adatot adott meg, akkor az “if” és “else” kulcsszavak használata lehetővé teszi a program számára, hogy meghatározza, melyik kimeneti lehetőséget kell használni.
Az elágazások segítségével a programozó számos dolgot megtehet, például adatok ellenőrzése, felhasználói bemenetek kezelése, hibajelzések kezelése és így tovább. Az elágazások alkalmazása a programozásban alapvető fontosságú, és mindenkinek, aki Pythonban programoz, alaposan meg kell értenie a használatukat.
Összefoglalva, az elágazások lehetővé teszik a programozónak, hogy a programot több különböző helyzetben különböző módon vezérelje, ami fontos a hatékony és rugalmas programozás szempontjából. Az “if”, “elif” és “else” kulcsszavak a Pythonban használatosak az elágazások létrehozásához, és az elágazások alkalmazása számos különböző feladat megoldására alkalmas.
Logikai
Logikai
Az alábbi kód a logikai elágazást mutatja be:
a = True
b = True
c = False
d = False
#not a - Megfordítja/tagadja az állítást (True->False False->True)
#a and b - Ha mind két állítás True, akkor True. Ha egy vagy a többi állítás False, akkor False.
#a or b - Ha egyik már True, akkor True. Ha az össze False, csak akkor False.
print(a and b)
print(a and d)
print(a or b)
print(a or d)
print(c or d)
print(not a)
True
False
True
True
False
False
Az if/else és a switch/case után az egyik leggyakoribb elágazás az, amikor két vagy több állítást logikailag össze kell kapcsolni és az eredményt ki kell értékelni. Ezt úgynevezett logikai operátorokkal tehetjük meg.
A logikai operátorok között szerepel a not, az and és az or. A not operátor megfordítja az állítás igazságtartalmát, azaz True értékre False-t, False értékre True-t ad vissza.
Az and operátor akkor ad vissza True értéket, ha mindkét állítás True, ellenkező esetben False értéket ad vissza.
Az or operátor akkor ad vissza True értéket, ha legalább az egyik állítás True, ha mindkét állítás False, akkor False értéket ad vissza.
Ezek az operátorok nagyon hasznosak, amikor például egy feltétel két vagy több állítás kombinációjából adódik. A logikai operátorok használatával összetett feltételeket lehet megfogalmazni, amelyeknek az igazságtartalma meghatározza a kódfuttatás irányát.
A példakódban látható a not, az and és az or operátorok működése különböző állításokkal. A kód eredménye True vagy False értékeket ad vissza az operátorok és az állítások eredményeként, amelyek alapján az elágazások vezérelhetők.
Szerkeszthető-e a háromszög?
a = int(input('Háromszög "a" oldala: '))
b = int(input('Háromszög "b" oldala: '))
c = int(input('Háromszög "c" oldala: '))
if a - b < c and b - c < a and c - a < b:
print("Szerkeszthető")
else:
print("Nem Szerkeszthető")
Háromszög "a" oldala: 10
Háromszög "b" oldala: 10
Háromszög "c" oldala: 30
Nem Szerkeszthető
Feltételes
Feltételes
Az alábbi kód a feltételes elágazást mutatja be:
kor = int(input("Hány éves vagy? "))
if kor < 18:
print("Fiatalkorú")
elif kor < 65:
print("Aktív korú")
else:
print("Nyugdíjas")
Hány éves vagy? 50
Aktív korú
Ez a program elkéri a felhasználó életkorát, majd ellenőrzi, hogy a kor melyik korcsoportba tartozik. Az if, elif és else utasítások segítségével három különböző esetet kezelünk.
Ha a kor kisebb mint 18, akkor a program kiírja, hogy “Fiatalkorú”. Ha a kor nagyobb vagy egyenlő mint 18, és kisebb mint 65, akkor az “Aktív korú” üzenetet jeleníti meg. Ha a kor nagyobb vagy egyenlő mint 65, akkor pedig a “Nyugdíjas” üzenetet írja ki a program.
Az input függvény segítségével az életkor beolvasására van lehetőség, amelyet az int függvény használatával egész számmá konvertálunk, hogy a program helyesen tudja kezelni a kor értékét.
Érdemjegy
e = int(input("Százalék: "))
if e <= 40:
print("Érdemjegy: 1")
elif e >= 41 and e <= 55:
print("Érdemjegy: 2")
elif e >= 56 and e <= 70:
print("Érdemjegy: 3")
elif e >= 71 and e <= 85:
print("Érdemjegy: 4")
else:
print("Érdemjegy: 5")
Százalék: 86
Érdemjegy: 5
- 40% alatt 1-es érdemjegy
- 41-55% között 2-es érdemjegy
- 56-70% között 3-as érdemjegy
- 71-85% között 4-es érdemjegy
- 86% felett 5-ös érdemjegy
Az input() függvény segítségével a felhasználó be tudja írni az adott százalék értéket, majd az if, elif és else kulcsszavak segítségével meghatározhatjuk a tartományokat és azokhoz tartozó érdemjegyeket. A program végén kiírja az érdemjegyet.
Számok összehasonlítása
a = int(input("Első szám: "))
b = int(input("Második szám: "))
if a > b:
print("Első szám nagyobb")
print("Második szám kisebb")
elif a < b:
print("Első szám kisebb")
print("Második szám nagyobb")
elif a == b:
print("A két szám egyenlő")
Első szám: 8238912
Második szám: 74952
Első szám nagyobb
Második szám kisebb
Ez a kód bekér két egész számot a felhasználótól az input() függvénnyel, majd összehasonlítja a két számot egy if-elif-else elágazással. Ha az első szám nagyobb, akkor kiírja, hogy az első szám nagyobb, ha a második szám nagyobb, akkor kiírja, hogy a második szám nagyobb, és ha a két szám egyenlő, akkor kiírja, hogy a két szám egyenlő. A kiírásokat a print() függvény végzi el.
Függvény
Függvény (def)
A “def” kulcsszó a Python nyelvben a függvények definiálására szolgál. A függvények olyan kódrészletek, amelyeket újra és újra használhatunk a programunkban, ezáltal csökkentve a kódképzési időt és javítva a kód olvashatóságát.
A függvények definiálásához használatos “def” kulcsszó után a függvény neve következik, amelyet zárójelekbe kell tennünk. Az zárójelekben szerepelnek a függvény bemenő paraméterei. Az utasításokat kettősponttal kell lezárni és indentálni (bekezdeni) kell őket a következő sorban.
Példa
Például, ha szeretnénk egy függvényt definiálni, amely két számot ad össze, akkor írhatunk egy ilyen függvénydefiníciót:
def osszeadas(szam1, szam2):
eredmeny = szam1 + szam2
return eredmeny
Ezután hívhatjuk a függvényt a következő módon:
eredmeny = osszeadas(2, 3)
print(eredmeny)
5
A fenti példában láthatjuk, hogy a “def” kulcsszó után a függvény neve következik, amelyet zárójelekbe helyeztünk. Az utasításokat kettősponttal zártuk le, és indentáltuk őket. A függvény visszatérési értékét a “return” kulcsszóval adtuk meg.
A függvény hívásakor az argumentumokat a zárójelekbe helyezzük, és a függvény nevét követően írjuk. A függvény visszatérési értékét a változóba mentjük, majd a “print” függvénnyel kinyomtatjuk az eredményt.
A függvényekkel egyszerűbbé tehetjük a programunkat, mert így elkerülhetjük a kódkészítés ismétlését. A függvényeket használhatjuk bármilyen programozási feladat megoldására. Nagyon fontos, hogy a függvény neve beszédes és érthető legyen, és a függvény egyszerre csak egy dolgot csináljon.
A “def” kulcsszó használatával új függvényeket hozhatunk létre a programunkban, amelyeknek különböző bemenő paramétereik és visszatérési értékeik lehetnek.
Példák lépésenként
def eljaras(): #Egy függvényt mindig definiálni kell
print("Nincs visszateréséri érték")
A def eljaras(): sorral kezdődő kód egy egyszerű eljárás definíciót mutat Pythonban, amelynek nincs visszatérési értéke, csak kinyomtat egy szöveget a konzolra.
eljaras() #így lehet behíni
Nincs visszateréséri érték
def fgv():
print("függvény törzse")
visszateresi_ertek = 10
return visszateresi_ertek
A fgv nevű függvény a print() függvénnyel kiírja a “függvény törzse” szöveget a konzolra, majd definiál egy visszateresi_ertek változót, amelynek értéke 10. Végül visszatér ezzel az értékkel. A függvény hívása esetén az így visszatérő értéket eltárolhatjuk egy változóban, vagy közvetlenül felhasználhatjuk a kódban.
print(fgv())
függvény törzse
10
def fgv2():
print("törzs")
v1 = 10
v2 = 20
return [v1, v2]
A fgv2 nevű függvény a print() függvénnyel kiírja a “törzs” szöveget a konzolra, majd két változót (v1 és v2) definiál, amelyeknek az értékei rendre 10 és 20. Végül visszatér egy listával, amelyben az előbb említett két változó szerepel.
print(fgv2())
törzs
[10, 20]
def fgv3(p):
print(f'paraméter: {p}')
return p*2
A fgv3 nevű függvény egy kötelezően megadandó paramétert (p) kap, majd kiírja annak értékét. Végül visszatér a paraméter kétszeresével. A függvény akkor használható, ha megadjuk neki a kötelező paramétert a hívás során.
fgv3(10)
paraméter: 10
20
def fgv4(p = 10):
print(f'paraméter: {p}')
return p*2
A fgv4 nevű függvény egy opcionális paramétert (p) kap, amelynek alapértéke 10. A függvény kiírja a paraméter értékét a konzolra, majd visszatér a paraméter kétszeresével. Ha a függvényt hívásakor nem adunk meg paramétert, akkor az alapérték (10) lesz használva.
print(fgv4())
print(fgv4(15)) #Paraméter felül lesz írva
paraméter: 10
20
paraméter: 15
30
def fgv6(p):
print(f'paraméter: {p}')
p[0] = p[0] + 1
A fgv6 nevű függvény egy listát kap paraméterként, majd kiírja annak értékét. Ezután megváltoztatja a lista első elemét, majd nem ad vissza semmilyen értéket. Mivel a függvény az eredeti lista első elemét változtatja meg, az eredeti lista értéke is megváltozik, amikor ezt a függvényt meghívják.
x=[0]
print(f'x értéke hívás előtt: {x}')
fgv6(x)
print(f'x értéke hívás után: {x}')
x értéke hívás előtt: [0]
paraméter: [0]
x értéke hívás után: [1]
Első eleme 0. Ezután kiírja az x értékét a konzolra. Az fgv6 függvényt az x listával hívják meg, amelynek eredményeként a függvény megváltoztatja az x lista első elemét. Ezután kiírja az x értékét a konzolra újra, és látható, hogy az értéke megváltozott a függvényhívás után, mert a függvény megváltoztatta az eredeti listát. A függvény nem ad vissza értéket, ezért az eredmény None lesz.
def fgv7(p1, p2):
print(f'p1 = {p1}')
print(f'p2 = {p2}')
return p1 * p2
A fgv7 nevű függvény két paramétert (p1 és p2) kap, majd kiírja a konzolra az értéküket, majd visszatér a két paraméter szorzatával.
e1 = fgv7(10, 20)
print(e1)
print(fgv7(20,4))
p1 = 10
p2 = 20
200
p1 = 20
p2 = 4
80
def fgv3(p):
print(f'paraméter: {p}')
return p*2
A függvény egy egész számot kap paraméterként, majd visszatérési értékként igazat ad vissza, ha a szám páratlan, hamisat ha a szám páros.
for i in range(1, 10):
if paratlan(i):
print(i, end =' ')
1 3 5 7 9
Szökőév
Ez a kód a felhasználó által megadott két évszám közötti szökőéveket listázza ki. A szokoev() függvény megállapítja, hogy egy év szökőév-e, míg az utána következő rész az adott évszámokra vonatkozóan hívja meg a szokoev() függvényt, majd kiírja a szökőéveket.
def szokoev(ev):
return ev % 400 == 0 or ev % 4 == 0 and ev % 100 !=0
a = int(input('Kérem a kezdőévet: '))
b = int(input('Kérem a másik évszámot: '))
if a>b:
a,b=b,a # a nagyobbra cseréli
sze = [e for e in range(a, b + 1) if szokoev(e)]
if len(sze) !=0:
print('Szökőévek: ', *sze, sep="; ")
else:
print('Nincs szökőév a megadott tartományban')
Kérem a kezdőévet: 1222
Kérem a másik évszámot: 2333
Szökőévek: ; 1224; 1228; 1232; 1236; 1240; 1244; 1248; 1252; 1256; 1260; 1264; 1268; 1272; 1276; 1280; 1284; 1288; 1292; 1296; 1304; 1308; 1312; 1316; 1320; 1324; 1328; 1332; 1336; 1340; 1344; 1348; 1352; 1356; 1360; 1364; 1368; 1372; 1376; 1380; 1384; 1388; 1392; 1396; 1404; 1408; 1412; 1416; 1420; 1424; 1428; 1432; 1436; 1440; 1444; 1448; 1452; 1456; 1460; 1464; 1468; 1472; 1476; 1480; 1484; 1488; 1492; 1496; 1504; 1508; 1512; 1516; 1520; 1524; 1528; 1532; 1536; 1540; 1544; 1548; 1552; 1556; 1560; 1564; 1568; 1572; 1576; 1580; 1584; 1588; 1592; 1596; 1600; 1604; 1608; 1612; 1616; 1620; 1624; 1628; 1632; 1636; 1640; 1644; 1648; 1652; 1656; 1660; 1664; 1668; 1672; 1676; 1680; 1684; 1688; 1692; 1696; 1704; 1708; 1712; 1716; 1720; 1724; 1728; 1732; 1736; 1740; 1744; 1748; 1752; 1756; 1760; 1764; 1768; 1772; 1776; 1780; 1784; 1788; 1792; 1796; 1804; 1808; 1812; 1816; 1820; 1824; 1828; 1832; 1836; 1840; 1844; 1848; 1852; 1856; 1860; 1864; 1868; 1872; 1876; 1880; 1884; 1888; 1892; 1896; 1904; 1908; 1912; 1916; 1920; 1924; 1928; 1932; 1936; 1940; 1944; 1948; 1952; 1956; 1960; 1964; 1968; 1972; 1976; 1980; 1984; 1988; 1992; 1996; 2000; 2004; 2008; 2012; 2016; 2020; 2024; 2028; 2032; 2036; 2040; 2044; 2048; 2052; 2056; 2060; 2064; 2068; 2072; 2076; 2080; 2084; 2088; 2092; 2096; 2104; 2108; 2112; 2116; 2120; 2124; 2128; 2132; 2136; 2140; 2144; 2148; 2152; 2156; 2160; 2164; 2168; 2172; 2176; 2180; 2184; 2188; 2192; 2196; 2204; 2208; 2212; 2216; 2220; 2224; 2228; 2232; 2236; 2240; 2244; 2248; 2252; 2256; 2260; 2264; 2268; 2272; 2276; 2280; 2284; 2288; 2292; 2296; 2304; 2308; 2312; 2316; 2320; 2324; 2328; 2332
Másképpen:
def szokoev(ev):
if (ev % 400 == 0):
return True
if (ev % 4 == 0 and ev % 100 != 0):
return True
return False
- Az első feltételvizsgálat (
ev % 400 == 0) azt ellenőrzi, hogy az év osztható-e 400-zal. Ha igen, akkor szökőévnek tekintjük, és a függvényTrueértékkel tér vissza. - Ha az első feltétel nem teljesül, a következő feltételvizsgálat következik (
ev % 4 == 0 and ev % 100 != 0). Ez ellenőrzi, hogy az év osztható-e 4-gyel és nem osztható 100-zal. Ha mindkét feltétel igaz, akkor szintén szökőévnek tekintjük az évet, és a függvényTrueértékkel tér vissza. - Ha egyik feltétel sem teljesül, akkor az év nem szökőév, és a függvény
Falseértékkel tér vissza.
def feladat():
ev1 = int(input('Kérem az egyik évszámot: '))
ev2 = int(input('Kérem a másik évszámot: '))
if (ev1 < ev2):
tol = ev1
ig = ev2
else:
tol = ev2
ig = ev1
- A következő két sorban bekérjük a felhasználótól az évszámokat,
ev1-et ésev2-t. - A
ifszerkezet eldönti, hogy melyik évszám a kisebb és melyik a nagyobb. A kisebb évszám kerül azev1változóba, a nagyobb pedig azev2változóba. Ez biztosítja, hogy helyesen definiáljuk a tartományt, amelyet később végig fogunk iterálni.
szokoevek = []
for ev in range(tol, ig + 1):
if szokoev(ev):
szokoevek.append(ev)
- Egy üres listát,
szokoevek-et hozunk létre, amelyben tárolni fogjuk a szökőéveket. - Egy
forciklussal végigiterálunk atolésigközötti értékeken (beleértve mindkét végpontot is). - Minden iterációban meghívjuk a
szokoevfüggvényt az adott évszámra, és ha az eredményTrue, hozzáadjuk az évszámot aszokoeveklistához.
if (len(szokoevek) == 0):
print('Nincs szökőév a megadott tartományban!')
else:
str = 'Szökőévek: '
for ev in szokoevek:
str += '{0}; '.format(ev)
print(str[:-2])
- A következő
if-elseszerkezetben ellenőrizzük, hogy van-e szökőév a megadott tartományban. - Ha a
szokoeveklista hossza 0, akkor kiírjuk, hogy nincs szökőév a megadott tartományban. - Ellenkező esetben elkészítjük a szökőévek listájának szöveges reprezentációját. Az
strváltozóban tároljuk a kezdeti szöveget, majd aforciklussal végigiterálunk aszokoeveklistán, és hozzáfűzzük az évszámot a szöveghez. - Végül kiírjuk a szöveget, figyelve arra, hogy az utolsó szökőév utáni pontosvesszőt és szóközt ne írjuk ki (
str[:-2]).
Teljes kód:
def szokoev(ev):
if (ev % 400 == 0):
return True
if (ev % 4 == 0 and ev % 100 != 0):
return True
return False
def feladat():
ev1 = int(input('Kérem az egyik évszámot: '))
ev2 = int(input('Kérem az másik évszámot: '))
if (ev1 < ev2):
tol = ev1
ig = ev2
else:
tol = ev2
ig = ev1
szokoevek = []
for ev in range(tol, ig + 1):
if szokoev(ev):
szokoevek.append(ev)
if (len(szokoevek) == 0):
print('Nincs szökőév a megadott tartományban!')
else:
str = 'Szökőévek: '
for ev in szokoevek:
str += '{0}; '.format(ev)
print(str[:-2])
Kulcsszavas paraméter
Kulcsszavas paraméter
A kulcsszavas paraméterek egy módszer, amellyel függvényhívásoknál nevekkel lehet hivatkozni a paraméterekre, így nem kell azokat az eredeti sorrendjükben felsorolni. Az ilyen paramétereket nevekkel definiálják a függvény definíciójában és hívásukkor a neveket és az azokhoz tartozó értékeket egyenlőségjellel összekötve adjuk meg. Ez segíthet az olvashatóságon és a hibák elkerülésén, különösen ha a függvénynek sok paramétere van vagy nem egyértelmű, milyen sorrendben kellene megadni azokat.
Példák
def fgv10(**kwargs):
for key, value in kwargs.items():
print("%s == %s" %(key, value))
Az fgv10 nevű függvény a kulcsszavas paramétereket használja, amelyek a függvényhívás során tetszőleges mennyiségű kulcs-érték párt tartalmaznak. Ezeket a paramétereket egy szótárba csomagolja, majd a for ciklus segítségével kiírja a kulcs-érték párokat a képernyőre.
fgv10(elso = 10, masodik = 20, harmadik = "alma")
elso == 10
masodik == 20
harmadik == alma
def fgv11(p1, *args, **kwargs):
print(f'p1 = {p1}')
for idx, val in enumerate(args):
print(f'{idx} - arg = {val}')
for key, val in kwargs.items():
print(f'{key} - {val}')
print("-"*10)
Az fgv11 egy függvény, amelynek van egy kötelező paramétere (p1), egy *args nevű tetszőleges számú pozícionális paramétere és egy **kwargs nevű tetszőleges számú kulcsszavas paramétere. A függvény kiírja a kötelező paramétert, az összes pozícionális paramétert (ha van ilyen) és az összes kulcsszavas paramétert (ha van ilyen).
fgv11(55)
fgv11(55, 44, 33)
fgv11(55, elso = 10, masodik = 'alma', harmadik = 30)
fgv11(55, 44, 33, elso = 10, masodik = 'alma', harmadik = 30)
p1 = 55
----------
p1 = 55
0 - arg = 44
1 - arg = 33
----------
p1 = 55
elso - 10
masodik - alma
harmadik - 30
----------
p1 = 55
0 - arg = 44
1 - arg = 33
elso - 10
masodik - alma
harmadik - 30
----------
Magánhangzó
Egy listán végigiterálva keresi a legtöbb magánhangzót tartalmazó napot. A napok listában hétfőtől péntekig vannak megadva a napok nevei. A maganhangzok függvény egy adott stringben megszámolja a magánhangzók számát, majd visszatér azzal a számmal. A program végigmegy a napok listán, és azonosítja a legtöbb magánhangzót tartalmazó napot, majd ezt kiírja a képernyőre.
napok = ["hétfő", "kedd", "szerda", "csütörtök", "péntek"]
def maganhangzok(nap):
m = 'aáeéiíoóöőuúüű'
db = 0
for n in nap:
if n in m:
db += 1
return db
maxi = 0
for i in range(len(napok)):
if maganhangzok(napok[i])>maganhangzok(napok[maxi]):
maxi = i
print(f'A legtöbb magánhangó a {napok[maxi]}-ben van.')
A legtöbb magánhangó a csütörtök-ben van.
Matematikai függvények és adatszerkezetek
Matematikai függvények és adatszerkezetek fontos szerepet játszanak az informatika világában, különösen a programozásban. Az adatszerkezetek lehetővé teszik, hogy hatékonyan tároljuk és kezeljük az adatokat, míg a matematikai függvények segítenek megoldani a matematikai problémákat és feladatokat.
Az adatszerkezetek között találhatók az egyszerűbb struktúrák, mint például az adattípusok (integer, float, string stb.), a tömbök, a listák és a szótárak. Ezek az adatszerkezetek lehetővé teszik az adatok hatékony tárolását és kezelését a programban, ami számos előnyt biztosít, például a gyorsabb adatelérés és az egyszerűbb adatmanipuláció.
Az adatszerkezetek mellett a matematikai függvények is kulcsfontosságúak a programozásban. A matematikai függvényeket gyakran használjuk matematikai problémák megoldására, de az informatikában számos más területen is felhasználhatóak, például a grafikus felhasználói felületek (GUI) létrehozásában vagy a kriptográfia területén.
A matematikai függvények közül az alapvetőbbek a trigonometrikus függvények (sin, cos, tan), a hatványozás és a gyökvonás. Emellett számos további matematikai függvény és művelet létezik, amelyek a programozásban hasznosak lehetnek, például az exponenciális függvények, a logaritmusok, a faktoriális, az összegzés és a maximum/minimum kiválasztása.
Az adatszerkezetek és matematikai függvények közötti kapcsolat is fontos szerepet játszik a programozásban. Az adatszerkezeteket gyakran használjuk a matematikai függvények paramétereinek tárolására és kezelésére. Például, ha számos számot szeretnénk összeadni, akkor tárolhatjuk ezeket egy tömbben vagy listában, majd használhatjuk az összegzés függvényét a matematikai összeadás végrehajtásához.
Végül fontos megemlíteni, hogy a matematikai függvények és adatszerkezetek használata mellett fontos, hogy a programozók megfelelően dokumentálják a kódjukat és érthetően nevezzenek el változókat és függvényeket. A dokumentáció segíti a kód megértését és karbantarthatóságát, valamint segít az esetleges hibák vagy problémák gyorsabb azonosításában és javításában.
Az adatszerkezetek és matematikai függvények használata rendkívül fontos a modern programozásban, különösen az adatok és matematikai problémák hatékony kezelése érdekében. Az adatszerkezetek lehetővé teszik az adatok gyors és hatékony tárolását és kezelését, míg a matematikai függvények segítenek az algoritmusok és matematikai problémák hatékonyabb megoldásában.
A programozók számára tehát elengedhetetlen a matematikai függvények és adatszerkezetek megértése és hatékony alkalmazása, hogy a programjaik hatékonyan és megbízhatóan működjenek. Az alapos dokumentáció és a jól megtervezett kód segít abban, hogy a programok könnyebben karbantarthatóak és skálázhatóak legyenek, amely fontos a hosszú távú siker érdekében.
Matematikai függvények
Teljes kód:
from math import pi, sin, cos, sqrt, log, ceil, floor, e
print(sin(pi/4))
print(cos(2*pi/3))
print(sqrt(81))
print(pi)
print(e)
print(log(e**2))
Magyarázat:
Ez a kódsor több matematikai függvényt importál a math modulból és ezeket használja kiiratásra.
Az import kulcsszóval beolvassuk a math modult, majd kiválasztjuk azokat a függvényeket, amelyeket használni szeretnénk. Ebben az esetben a pi, sin, cos, sqrt, log, ceil, floor és e függvényeket hívjuk meg. Ezek közül a pi és e a matematikai állandók, míg a többi függvény matematikai műveleteket végez.
Az első két sorban a sin() és cos() függvényeket használjuk fel, hogy kiszámoljuk a pi értékének tizedrészének szinuszát és koszinuszát. Az eredményeket a print() függvénnyel íratjuk ki a konzolra.
A harmadik sorban a sqrt() függvény segítségével kiszámoljuk az 81 négyzetgyökét.
A negyedik és az ötödik sorban egyszerűen csak kiíratjuk a pi és az e értékeit.
A hatodik sorban a log() függvényt használjuk, hogy kiszámoljuk a e négyzetének természetes logaritmusát, majd a print() függvénnyel íratjuk ki az eredményt a konzolra.
# importáljuk a math modulból azokat a függvényeket, amelyeket használni szeretnénk
from math import pi, sin, cos, sqrt, log, ceil, floor, e
# kiszámoljuk a pi/4 szinuszát
print(sin(pi/4))
# kiszámoljuk a 2*pi/3 koszinuszát
print(cos(2*pi/3))
# kiszámoljuk az 81 négyzetgyökét
print(sqrt(81))
# kiíratjuk a pi értékét
print(pi)
# kiíratjuk az e alapú exponenciális függvény értékét
print(e)
# kiszámoljuk az e^2 természetes logaritmusát
print(log(e**2))
Importálás másképpen
import math
print(math.sin(math.pi/4))
Ez a kód egy matematikai függvényt használ, a sin() függvényt, hogy a π/4 radián szöget számolja ki. Ehhez először a math modulból importálja a szükséges függvényeket, beleértve a sin() és a pi értékét.
Szám kerekítés
a = 23.456
print(ceil(a)) #felfele - 24
print(floor(a)) #lefele - 23
Ez a kód a Python math modulának a ceil() és floor() függvényeit használja. A kód egy tizedes pontossággal megadott float értéket, az “a” változó értékét használja.
A ceil() függvény a megadott számot azonnal követő legkisebb egész számot adja vissza, tehát felfelé kerekít. A kód eredménye 24, mivel az 23.456 értéket 24-re kerekíti.
A floor() függvény a megadott számot azonnal megelőző legnagyobb egész számot adja vissza, tehát lefelé kerekít. A kód eredménye 23, mivel az 23.456 értéket 23-ra kerekíti.
Ezek a függvények hasznosak lehetnek olyan esetekben, amikor pontosan meghatározott értékek kellenek, például számítások vagy adatmanipuláció során. A ceil() és a floor() függvényekkel ezeket az értékeket közelíthetjük az egész számokhoz.
Összetett adatszerkezetek
Részletesebb leírás az adatszerkezetekről
AdatszerkezetekhezTagolás
l = [1, 'alma', 7.5, True, 'körte', 6]
print(l)
print(*l)
print(*l, sep=' - ')
[1, 'alma', 7.5, True, 'körte', 6]
1 alma 7.5 True körte 6
1 - alma - 7.5 - True - körte - 6
Lista adatszerkezetet hoz létre, amelynek különböző típusú elemeket adunk hozzá, majd a listát kiírjuk a képernyőre.
A print(l) parancs kiírja a teljes listát a képernyőre, a benne lévő összes elemmel. Az eredmény a következő lenne: [1, ‘alma’, 7.5, True, ‘körte’, 6].
A print(*l) parancs használja a * operátort, amely szétszedi a lista elemeit, és azokat külön-külön adja át a print() függvénynek, ami aztán kiírja azokat a képernyőre. Az eredmény így a következő lenne: 1 alma 7.5 True körte 6. Megjegyzendő, hogy az első és utolsó elem között nincs szóköz, mivel az első elem és az első szóköz között nincs vessző.
A print(*l, sep=’ – ‘) parancs szintén használja a * operátort, hogy szétszedje a lista elemeit, majd azokat a ‘-‘ karakterrel elválasztva adja át a print() függvénynek. Az eredmény így a következő lenne: 1 – alma – 7.5 – True – körte – 6. A sep argumentum használatával beállítjuk, hogy milyen karaktert használjon elválasztónak az elemek között, amely alapértelmezetten a szóköz karakter.
l = [1, 'alma', 7.5, True, 'körte', 6] # egy lista létrehozása
print(l[1]) # a lista második elemét írja ki
print(l[-2]) # a lista utolsó előtti elemét írja ki
print(l[1:4]) # a lista második, harmadik és negyedik elemét írja ki
print(l[-3:-1]) # a lista utolsó előtti és utolsó elemét írja ki
print(l[:2]) # az első két elemet írja ki a listából
print(l[3:]) # a negyedik és az utána következő összes elemet írja ki a listából
print(l[1:5:2]) # a lista második, negyedik és hatodik elemét írja ki
print(len(l)) # a lista elemeinek a számát írja ki
print(type(l)) # a lista típusát írja ki
alma
körte
['alma', 7.5, True]
[True, 'körte']
[1, 'alma']
[True, 'körte', 6]
['alma', True]
6
<class 'list'>
l = [1, 'alma', 7.5, True, 'körte', 6] # egy lista létrehozása
l[4] = 'barack' #lista elemének értékének megváltoztatása
print(l)
l.append(123) #elem hozzáadás a listához
print(l)
l.extend(['A', 32]) #kibővíti a listát
print(l)
[1, 'alma', 7.5, True, 'barack', 6]
[1, 'alma', 7.5, True, 'barack', 6, 123]
[1, 'alma', 7.5, True, 'barack', 6, 123, 'A', 32]
l.insert(3, 99) #3.helyre beszúrja az adatot
print(l)
[1, 'alma', 7.5, 99, True, 'barack', 6, 123, 'A', 32]
l.remove(123) #eltávolítja a 123 adatot
print(l)
[1, 'alma', 7.5, 99, True, 'barack', 6, 'A', 32]
print(l.pop(1)) # kiírja majd eltávolítja az elemet
alma
Beépített metódusok
Az alábbi kód a list típusú változók néhány beépített metódusát mutatja be:
s = [56, 32, 865, 1, 67, 99, 43, 23, 6] # egy lista létrehozása
s.reverse() # megfordítja a lista sorrendjét
print(s) # kiírja a megfordított listát
s.sort() # rendezni kezdi a listát növekvő sorrendbe
print(s) # kiírja a rendezett listát
s.sort(reverse=True) # megfordítja a lista sorrendjét, ezzel csökkenő sorrendbe rendezve
print(s) # kiírja a megfordított és rendezett listát
del s[1] # eltávolítja a lista második elemét
print(s) # kiírja a lista módosított változatát
[6, 23, 43, 99, 67, 1, 865, 32, 56]
[1, 6, 23, 32, 43, 56, 67, 99, 865]
[865, 99, 67, 56, 43, 32, 23, 6, 1]
[865, 67, 56, 43, 32, 23, 6, 1]
A reverse() metódus megfordítja a lista sorrendjét, míg a sort() metódus alapértelmezetten növekvő sorrendbe rendez. Ha meg akarjuk fordítani a sorrendet, a sort(reverse=True) parancsot használhatjuk.
Az del kulcsszó eltávolítja a megadott indexű elemet a listából. Itt a s[1], azaz a lista második eleme kerül eltávolításra.
Tuple változók
Az alábbi kód a tuple típusú változók használatát mutatja be:
t = (1, 3, 54, 4, 8, 24) # egy tuple létrehozása
print(t) # kiírja a tuple elemeit
print(*t) # kiírja a tuple elemeit szóközzel elválasztva
print(type(t)) # kiírja a változó típusát
(1, 3, 54, 4, 8, 24)
1 3 54 4 8 24
<class 'tuple'>
A tuple típusú változók hasonlóak a list típusú változókhoz, azonban azok nem módosíthatóak. Az elemek sorrendjét és értékét nem lehet megváltoztatni. A tuple-t zárójelbe írjuk, míg a list-t szögletes zárójelekbe.
A print(*t) parancs a tuple elemeit szóközzel elválasztva írja ki. A type(t) paranccsal pedig kiírjuk a változó típusát, amely itt tuple.
Set változók - 1. Példa
Az alábbi kód a set típusú változók használatát mutatja be:
h = {10, 12, 32, 45, 'a'} # egy set létrehozása
print(h) # kiírja a set elemeit
be = int(input("Kérek egy számot: ")) # bekér egy számot
h.add(be) # hozzáadja a set-hez a bekért számot
print(h) # kiírja a set elemeit
print(len(h)) # kiírja a változó hosszát
print(type(h)) # kiírja a változó típusát
{32, 'a', 10, 12, 45}
Kérek egy számot: 23
{32, 'a', 10, 12, 45, 23}
6
<class 'set'>
A set típusú változók olyan kollekciók, amelyekben az elemek egyszer fordulnak elő, és nincs megadott sorrendjük. A set-ek közötti műveletek (metszet, unió, stb.) nagyon hatékonyak, és hasznosak lehetnek több adathalmaz összehasonlításához.
A print(len(h)) parancs kiírja a változó hosszát, vagyis a set-ben lévő elemek számát. A type(h) paranccsal pedig kiírjuk a változó típusát, amely itt set. A h.add(be) parancs pedig hozzáadja a bekért értéket a set-hez.
Set változók - 2. Példa
h1 = set('almafa')
h2 = set('jonatán')
print(*h1) # látszik hogy minden karakterből csak 1 lehet benne
print(*h2)
print(h1-h2) # csak az a. Ami a közös illetve a másik halmaz értéke nem látszik
print(h1 | h2) #két halamz uniója
print( h1 & h2) #két halmaz metszete
print(h1 ^ h2) # Minden benne van, kivéve ami mind a 2 halmazban
print('m' in h1) #Vizsgálja hogy benne van-e az m érték)
a l f m
j o a t n á
{'l', 'f', 'm'}
{'j', 'o', 'm', 'a', 'l', 'á', 't', 'n', 'f'}
{'a'}
{'o', 'l', 't', 'á', 'f', 'j', 'm', 'n'}
True
Az előző kódblokk egy set (halmaz) típusú változó létrehozásával, kezelésével foglalkozik. A set egy olyan adatszerkezet, amelyben az elemek egyedi (nem ismétlődő) és rendezetlen sorrendben szerepelnek. A set-et a kapcsos zárójelek között adjuk meg.
A kódblokk az “almafa” és “jonatán” stringekből halmazokat hoz létre a set() függvény segítségével. A * operátorral kiírjuk a halmazok elemeit.
Ezután kiírjuk a h1 halmaz és a h2 halmaz különbségét (h1-h2), amely csak az “a” elemet tartalmazza, mivel az a csak az első halmazban szerepel.
A | operátorral a h1 halmaz és a h2 halmaz unióját kapjuk meg, vagyis az összes elemet, amelyek bármelyik halmazban szerepelnek.
Az & operátorral a két halmaz metszetét kapjuk meg, vagyis azokat az elemeket, amelyek mindkét halmazban szerepelnek.
A ^ operátorral a szimmetrikus differenciát kapjuk meg, amely azokat az elemeket tartalmazza, amelyek az egyik halmazban, de nem a másikban, vagyis az összes olyan elemet, amely csak az egyik halmazban szerepel.
Végül a ‘m’ karakternek a h1 halmazban való előfordulását vizsgáljuk meg a ‘m’ in h1 kóddal, és a True eredményt kapjuk, mivel az “almafa” szóban van “m” karakter.
Szótár
d = {'Neve':'Ede', 'Kora':20, 'Menzás':True, 'Jegyek':[1, 3, 5, 4, 3, 2] }
print(d)
print(d['Neve'])
print(len(d))
print(type(d))
{'Neve': 'Ede', 'Kora': 20, 'Menzás': True, 'Jegyek': [1, 3, 5, 4, 3, 2]}
Ede
4
<class 'dict'>
Az adott kódrészlet egy szótár (dictionary) létrehozását mutatja be. A szótár egy kulcs-érték párokat tároló adatszerkezet, ahol a kulcsok egyediek és nem lehetnek megismétlődők. Az értékek bármilyen típusúak lehetnek.
A kódrészletben az ‘d’ nevű szótár négy kulcs-érték párt tartalmaz. Az első kulcs ‘Neve’, az értéke ‘Ede’, a második kulcs ‘Kora’, az értéke 20, a harmadik kulcs ‘Menzás’, az értéke True, és a negyedik kulcs ‘Jegyek’, az értéke pedig egy lista [1, 3, 5, 4, 3, 2].
Az utána következő sorokban az adott szótár kulcsainak és értékeinek lekérdezése történik. Az ‘Neve’ kulcshoz tartozó érték ‘Ede’, a szótár hossza (azaz a benne tárolt kulcs-érték párok száma) 4, és a szótár típusa a ‘dict’.
String - Szöveg
s = 'Az alma nem esik messze a Fájától'
print(s)
print(len(s)) #Hány karakterből áll
print(type(s))
print(s.startswith('Az')) #Megnézi hogy ezzel kezdődik-e
print(s.startswith('alma', 3, 10))
print(s.endswith('Fájától')) #Szerepel-e
print(s.count('al')) #Megszámolja mennyi ilyen van benne
print(s.index('al')) #Hanyadik karaktertől van
print(s.strip('A')) #Eltávolítja az "A" karaktert
sl = s.split(' ')
print(sl) # itt kiíratjuk a sl változó értékét
Az alma nem esik messze a Fájától
34
<class 'str'>
True
False
True
2
3
z alma nem esik messze a Fájától
['Az', 'alma', 'nem', 'esik', 'messze', 'a', 'Fájától']
Véletlen
Véletlen (random)
A random modul a Python egy beépített modulja, amelynek segítségével véletlenszerű számokat és adatokat lehet generálni. A modul funkciói között található például a randint() függvény, amely véletlenszerű egész számot generál a megadott tartományban, a random() függvény, amely 0 és 1 közötti véletlenszerű tizedestörtet generál, valamint a choice() függvény, amely véletlenszerűen kiválaszt egy elemet egy listából.
Példa
Például, ha az alábbi kódrészletet futtatjuk:
import random
print(random.randint(1, 10))
8
Ez generál egy véletlenszerű egész számot 1 és 10 között, majd kiírja a képernyőre.
Ha például szeretnénk egy véletlenszerű elemet választani egy listából, akkor használhatjuk a choice() függvényt. Például, ha az alábbi kódrészletet futtatjuk:
import random
my_list = ['alma', 'körte', 'barack', 'szilva']
print(random.choice(my_list))
8
Ez generál egy véletlenszerű egész számot 1 és 10 között, majd kiírja a képernyőre.
Ez véletlenszerűen kiválaszt egy elemet a my_list listából, majd kiírja a képernyőre. A kimenet minden egyes futtatáskor más lehet, attól függően, hogy melyik elem kerül véletlenszerűen kiválasztásra.
A random modul lehetőséget nyújt még többféle véletlenszerű adat generálására is, mint például véletlenszerű dátumok vagy időpontok generálása.
import random #random modul beimportálása
random.randint(0,100) #0-100 között
37
random.random() #valós véletlen
0.66720945930164
random.seed(20) #mindig ugyan azt a számot adja meg | rögzíti a számot
print(random.randint(0,1000))
927
random.seed(10) #fixálja
l = [random.randint(1,91) for _ in range(5)] # 5x ismétli
print(*l)
74 5 55 62 74
lista = [10, 100, 323, 221, 342, 567]
print(random.choice(lista)) #választ a listából 1 db-ot
10
nevek = ['Béla' , 'Mari' , 'Ödön' , 'Géza', 'Elek']
print(random.choice(nevek)) #választ a listából 1 nevet
Mari
szinek = ['piros' , 'zöld' , 'kék', 'sárga' , 'lila', 'barna', 'fekete', 'fehér']
print(random.choices(szinek, k=3)) #választ a listából 3 színt
['sárga', 'sárga', 'kék']
print(random.sample(szinek, k=3))
['kék', 'piros', 'lila']
Ciklusok
Ciklusok
A ciklusok a programozás egyik alapvető vezérlési struktúrái, amelyek segítségével lehetőségünk van arra, hogy bizonyos kód-szekvenciákat többször is végrehajtsunk.
A Python programozási nyelvben többféle ciklustípus is található. A leggyakrabban használt ciklustípusok a for és a while ciklusok.
A for ciklus lehetővé teszi, hogy egy adott lista, vagy más adatszerkezet elemein végigiteráljunk, és minden elemre végrehajtsuk a megadott utasításokat. A for ciklusban az iteráció számát a lista elemeinek száma határozza meg, így a ciklus addig fog futni, amíg az összes elemet be nem járta.
A while ciklus addig fut, amíg a megadott feltétel igaz. A while ciklus akkor hasznos, ha a ciklus lépéseinek száma nem ismert előre, és csak addig kell futtatni a ciklust, amíg egy bizonyos feltétel teljesül.
A ciklusokat használva gyakran meg kell állapítani, hogy milyen feltétel alapján kell véget vetni a ciklusnak. A ciklus belsejében megadott utasításoknak vagy utasítássorozatnak meg kell változtatniuk a feltételt, hogy a ciklus valamikor véget érjen, különben a ciklus végtelen ciklus lesz.
A ciklusok használata nagyon fontos a hatékony és jól strukturált programozás során. Azonban használatukat érdemes megfontolni, mivel egy végtelen ciklus könnyen megbéníthatja a programot. A ciklusokat csak akkor használjuk, ha feltétlenül szükséges, és minden esetben ellenőrizzük, hogy a ciklus feltétele valóban véget vet a ciklusnak.
A ciklusok alapvetően arra szolgálnak, hogy ismétlődő feladatokat hajtsunk végre anélkül, hogy kézzel kellene megismételni azokat. A Pythonban háromféle ciklus található: a for ciklus, a while ciklus és a do-while ciklust Pythonban nincs.
Példák
For
A for ciklus általában egy iterálható objektumon megy végig, például egy lista elemein, egy szöveg karakterein vagy egy számsorozaton. A for ciklus használatával könnyen végrehajthatunk egy sor műveletet minden elemen. Például:
for i in range(5):
print(i)
0
1
2
3
4
Ez a kód öt egész számot ír ki, sorban az 0-tól az 4-ig.
While
A while ciklus addig hajtja végre a kódot, amíg a megadott feltétel igaz. A while ciklus használatakor fontos biztosítani, hogy az igazságérték valamikor hamis legyen, különben a ciklus sosem fog véget érni, és végtelen hurokba kerül. Például:
i = 0
while i < 5:
print(i)
i += 1
0
1
2
3
4
Ez a kód öt egész számot ír ki, sorban az 0-tól az 4-ig.
While
While
A while ciklus a Python egyik alapvető ciklusa, amely addig hajtja végre a blokkot, amíg a megadott feltétel igaz. A feltétel minden ciklus elején ellenőrzésre kerül, és ha igaz, akkor a blokk végrehajtódik, majd újra ellenőrzésre kerül. Ha a feltétel hamisra értékelődik, akkor a ciklus végrehajtása leáll.
A while ciklus használható olyan esetekben, amikor nem ismerjük a ciklus előre meghatározott számát, vagy a ciklusban történő végrehajtás előfeltétele változó lehet.
Példa
Példaként, írjunk egy while ciklust, amely a számokat írja ki 1-től 10-ig. A ciklus addig ismétlődik, amíg az i változó értéke eléri a 10-et.
i = 1
while i <= 10:
print(i)
i += 1
1
2
3
4
5
6
7
8
9
10
A fenti kódrészletben az i változó értéke folyamatosan növekszik eggyel minden egyes cikluson belül, amíg el nem éri a 10-et. A ciklusmagban található print() függvény kiírja az aktuális i értékét, majd a ciklusmag után az i értéke növekszik eggyel. A ciklus futása tehát 10-szer ismétlődik, mivel a ciklusfeltétel igaz minden egyes futás után, amíg az i értéke el nem éri a 10-et.
A while ciklust nagyon sokféle módon lehet alkalmazni, attól függően, hogy milyen problémát kell megoldani. Fontos azonban, hogy vigyázzunk az olyan végtelen ciklusokkal, amelyek sosem állnak le, mert azok a program futását blokkolhatják. Egy végtelen ciklust akkor hozunk létre, ha a feltétel sosem válik hamisra.
Példa 2
while True:
a = int(input("Kérek egy számot: "))
if a % 2 ==1:
break
print('Ez páratlan')
Kérek egy számot: 23
Ez páratlan
A fenti kódrészletben az i változó értéke folyamatosan növekszik eggyel minden egyes cikluson belül, amíg el nem éri a 10-et. A ciklusmagban található print() függvény kiírja az aktuális i értékét, majd a ciklusmag után az i értéke növekszik eggyel. A ciklus futása tehát 10-szer ismétlődik, mivel a ciklusfeltétel igaz minden egyes futás után, amíg az i értéke el nem éri a 10-et.
A while ciklust nagyon sokféle módon lehet alkalmazni, attól függően, hogy milyen problémát kell megoldani. Fontos azonban, hogy vigyázzunk az olyan végtelen ciklusokkal, amelyek sosem állnak le, mert azok a program futását blokkolhatják. Egy végtelen ciklust akkor hozunk létre, ha a feltétel sosem válik hamisra.
For
For
A for ciklus Pythonban arra használható, hogy végigiteráljunk egy adott iterálható (iterable) objektumon, például egy listán vagy szövegen. A ciklus elején megadhatjuk az iterálás kezdőértékét, majd az objektum elemein végiglépve az iterálás végéig dolgozzuk fel az adatokat.
Példa
A következő példában egy for ciklust használunk, hogy végigiteráljunk egy lista elemein, és kiírjuk azokat:
numbers = [1, 2, 3, 4, 5]
for num in numbers:
print(num)
1
2
3
4
5
Ebben az esetben a numbers lista elemein megyünk végig a for ciklussal, és minden egyes elemet kiírunk a képernyőre. Az in kulcsszó azt jelzi, hogy az iterálást a numbers listán kell elvégezni, a num változó pedig a jelenlegi elemet jelöli a ciklusmagban.
2. Példa
A for ciklus segítségével könnyen tudunk dolgozni más adattípusokkal is, például szöveggel:
text = "Hello, world!"
for char in text:
print(char)
H
e
l
l
o
,
w
o
r
l
d
!
Ebben az esetben a for ciklus végigiterál a text változóban található karaktereken, és kiírja azokat a képernyőre.
3. Példa
A for ciklust használhatjuk az iterálható objektum elemeinek manipulálására is, például egy lista elemeinek összegzésére:
numbers = [1, 2, 3, 4, 5]
sum = 0
for num in numbers:
sum += num
print(sum)
15
Ebben az esetben a numbers lista elemein megyünk végig a for ciklussal, és minden egyes elemet hozzáadunk a sum változóhoz. A ciklus után a sum változó értékét kiírjuk a képernyőre, ami az összes elem összege lesz.
4. Példa
Ez a program egy “for” ciklust tartalmaz, amely végigiterál egy lista elemein, és minden egyes elemhez hozzárendel egy új változót. A lista itt “l”-nek van nevezve, és számokat tartalmaz. A cikluson belül minden egyes elemet kiírunk a képernyőre, miután megkettőztük a “print” függvény segítségével. Az “end=’ ‘” paraméter megakadályozza, hogy minden egyes szám új sorba kerüljön, és helyette egy szóközzel elválasztva jelenik meg.
l = [2, 5, 12, 23, 25, 20, 74, 56, 89]
for e in l:
print(e * 2, end = ' ')
4 10 24 46 50 40 148 112 178
Ez a program kiváló példa arra, hogyan lehet a for ciklust felhasználni a lista elemeinek feldolgozására. A “for” ciklus használata nagyon hatékony és könnyen érthető módszer arra, hogy minden egyes elemmel dolgozzunk a listán belül.
5. Példa
for idx, val in enumerate(l):
print(f'{idx} --> {val} ')
0 --> 2
1 --> 5
2 --> 12
3 --> 23
4 --> 25
5 --> 20
6 --> 74
7 --> 56
8 --> 89
A fenti programban a “for” kulcsszó segítségével végrehajtunk egy iterációt a lista elemein. Az “enumerate” függvény használatával lehetőség van a lista elemein való végighaladás mellett a lista indexeinek is a kiíratására. A “for” ciklus során minden egyes iterációban a “val” változó értéke az aktuális elemre állítódik be, a “idx” változó pedig az aktuális elem indexére.
A fenti példában a program egy listát tartalmaz, amelyben szerepelnek egész számok. A “for” ciklus segítségével a lista elemein végighaladunk, majd minden elemet kétzeresével kiírunk a képernyőre, az “end” paraméter segítségével az elemeket egy szóközzel elválasztva. A “enumerate” függvény használatával a lista elemeinek indexét is kiíratjuk, majd egy “->” jelet teszünk közéjük, végül a tényleges lista elemeket is kiíratjuk.
6. Példa
d = {'k':1, 'a':2, 'b':3, 'c':12}
for key in d:
print(f'{key} --> {d[key]}')
k --> 1
a --> 2
b --> 3
c --> 12
A fenti kódrészlet egy dictionary elemeit írja ki a kulcs-érték párok segítségével a for ciklus segítségével. A for key in d sorral bejárjuk a dictionary kulcsait, majd a print(f'{key} --> {d[key]}') sorban pedig kiírjuk a kulcs-érték párokat a megfelelő formátumban. A d[key] kifejezés segítségével kérjük le a kulcshoz tartozó értéket a dictionary-ból.
7. Példa
for i in range(10, 101, 10): # adott értéktől megy | Meddig megy | hányassával
print(i, end = ' ')
10 20 30 40 50 60 70 80 90 100
A kód egy for ciklust használ, amely 10-től 100-ig haladva 10-esével kiírja az értékeket a képernyőre.
8. Példa
for i in range(1, 101): # adott értéktől megy | Meddig megy | hányassával
if i % 7 == 0 and not i % 3 == 0:
print(i, end = ' ')
7 14 28 35 49 56 70 77 91 98
A for ciklus 1-től 100-ig iterál, és azokat az értékeket írja ki, amelyek oszthatóak 7-tel, de nem oszthatóak 3-mal.
Fájlkezelés
Alapok és hasznos tippek
A fájlkezelés az egyik alapvető funkciója a programozási nyelveknek. A Python programozási nyelvnek is számos fájlkezelési funkciója van, amelyek lehetővé teszik a fájlok olvasását, írását és módosítását. Ez a kategória bemutatja a Python fájlkezelési alapjait, és hasznos tippeket ad ahhoz, hogy hogyan lehet hatékonyan kezelni a fájlokat Pythonban. Továbbá, bemutatjuk a fájlkezelési funkciók néhány gyakorlati alkalmazását, hogy könnyen megértsük, hogyan lehet ezeket a funkciókat a való életben alkalmazni.
Fájl megnyitás módjai
A fájlkezelés a Pythonban lehetővé teszi, hogy különböző fájlműveleteket végezzünk, mint például fájl megnyitása, olvasása, írása vagy törlése. A legegyszerűbb módja a fájlkezelésnek a Pythonban az open() beépített függvény használata, amely egy fájl objektumot ad vissza12. Az open() függvénynek két paramétere van: a fájl neve és a megnyitás módja. A megnyitás módja lehet olvasás (‘r’), írás (‘w’), hozzáfűzés (‘a’) vagy mindkettő (‘r+’).
Az “r” mód a fájl megnyitásának alapértelmezett módja, és az olvasásra (read) utal. Ezzel a móddal megnyithatjuk a fájlt és elolvashatjuk annak tartalmát, de nem tudunk beleírni. Ha megpróbálunk írni egy “r” móddal megnyitott fájlba, akkor hibát kapunk. Például:
with open('jungle.txt', 'r') as f:
data = f.read()
print(data)
Ez a kód kiírja a ‘jungle.txt’ fájl tartalmát.
Vagy például, ha egy ‘jungle.txt’ nevű szövegfájlt szeretnénk létrehozni és beleírni a ‘lion’ szót, akkor a következő kódot használhatjuk:
with open('jungle.txt', 'w') as f:
f.write('lion')
A with kulcsszó segítségével automatikusan bezárjuk a fájlt a blokk végén, így nem kell aggódnunk az erőforrások szabadon hagyásáról.
A szöveg fájl így fog ki nézni:
lion
Ha egy már létező fájlhoz szeretnénk hozzáfűzni valamit, például a ‘tiger’ szót, akkor az ‘a’ módot használhatjuk:
with open('jungle.txt', 'a') as f:
f.write('tiger')
Az “a” a hozzáfűzés módját jelöli a fájl megnyitásakor. Ez azt jelenti, hogy ha egy már létező fájlhoz szeretnénk írni valamit, akkor az “a” móddal megnyitva nem felülírjuk a fájl tartalmát, hanem hozzáadjuk a végéhez. Így nem veszítjük el az eredeti adatokat. Az “a” mód csak írásra engedélyezett, olvasásra nem. Ha egy olyan fájlt próbálunk megnyitni “a” móddal, ami még nem létezik, akkor a Python automatikusan létrehozza azt.
Például, ha van egy ‘animals.txt’ nevű fájlunk, amiben ezek a sorok vannak:
cat
dog
És ezt a kódot futtatjuk:
with open('jungle.txt', 'a') as f:
f.write('tiger')
A fájl tartalma így fog kinézni:
cat
dog
tiger
Egyszerű feldolgozás
A fájlkezelés egy fontos része a programozásnak, amely lehetővé teszi számunkra, hogy adatokat olvassunk be és írjunk ki fájlokba. A Pythonban a fájlkezelés egyszerű és könnyen használható. A beépített open() függvény segítségével megnyithatjuk a fájlokat olvasásra, írásra vagy hozzáfűzésre. A fájl tartalmát soronként vagy egészben beolvashatjuk, és módosíthatjuk is. A példában látható kód bemutatja, hogyan olvashatunk be egy fájlt soronként és használhatjuk annak adatait.
Tegyük fel, hogy van egy fajl.txt nevű fájlunk, aminek a tartalma a következő:
első sor
második sor
harmadik sor
Ha futtatjuk ezt a kódot:
with open('fajl.txt', 'r') as f:
for sor in f:
print(sor.strip())
A kimenet a következő lesz:
első sor
második sor
harmadik sor
A kód soronként beolvassa a fájl tartalmát és kiírja a képernyőre. A strip() metódus eltávolítja az újsor karaktereket a sorok végéről.
Ez a kódrészlet egy fájlt nyit meg olvasásra a with open utasítással. A with utasítás biztosítja, hogy a fájl bezáródjon a blokk végén. A fajl.txt a fájl neve, az 'r' azt jelenti, hogy olvasásra nyitjuk meg a fájlt, az encoding='utf-8' pedig azt jelöli, hogy milyen karakterkódolást használunk.
Az első sorban lévő számot beolvassuk az int(f.readline()) utasítással és eltároljuk a szam változóban. Ezután a for sor in f.read().splitlines(): ciklusban végigmegyünk a listán és minden sort hozzáadunk a lista listához az Adatok(sor) utasítással. Ez azt jelenti, hogy minden sort átalakítunk az Adatok típusú objektummá és hozzáadjuk a lista listához.
Az Adatok egy osztály, amit a kódban definiáltunk. Az osztályok olyan sablonok, amelyek alapján objektumokat hozhatunk létre. Az Adatok osztályban van egy __init__ metódus, ami az osztály konstruktora. Ez a metódus fut le, amikor létrehozunk egy új Adatok objektumot az Adatok(sor) utasítással. Az __init__ metódusban beállítjuk az objektum adat attribútumát a sor értékére.
Például, ha a fájlban az első sorban az 'alma' szöveget olvassuk be, akkor létrehozunk egy új Adatok objektumot az Adatok('alma') utasítással és az objektum adat attribútuma 'alma' lesz.
Itt van egy példa fájl és kód:
fajl.txt:
3
alma
körte
barack
Ha futtatjuk ezt a kódot:
class Adatok:
def __init__(self, adat):
self.adat = adat
lista = []
with open('fajl.txt', 'r', encoding='utf-8') as f:
szam = int(f.readline())
for sor in f.read().splitlines():
lista.append(Adatok(sor))
for elem in lista:
print(elem.adat)
Ez a kód kiírja a következőt:
alma
körte
barack
És a szám változóban tároljuk el a 3-as számot a fájl első sorából.
Buktatók
Egyszerű hibák Könnyen vétett hibák Legjobb megoldások fájlfeldolgozás esetén.
Adat típusok helyes használata: A kódban vannak olyan attribútumok, amelyeket bizonyos típusra kell konvertálni, például az
idattribútumot egész számként (int) kell inicializálni, ateruletattribútumot lebegőpontos számként (float) kell inicializálni. Ha az adatok típusa nem megfelelő, akkor hibák és váratlan eredmények léphetnek fel.Karakterláncok kezelése: A
teruletértékben a tizedesvessző helyett a tizedespontot használjuk a lebegőpontos érték megfelelő kezeléséhez. Ehhez használjuk areplace(',', '.')metódust, amely a,karaktereket.karakterekre cseréli. Ez fontos, mivel a tizedesvesszőt nem ismeri fel a Python lebegőpontos számokként, és hibát okozhat.NULL értékek kezelése: Az adatokban lehetnek olyan helyek, ahol a
NULLszerepel az adott mezőben. Az ilyen értékeket helyesen kell kezelni, például üres stringgel ('') vagy 0-val inicializálni az attribútumokat.Fájlbeolvasás és formátum: A kód feltételezi, hogy az
alloviz.txtfájl megfelelő formátumban van, ahol a sorok pontosvesszővel vannak elválasztva. Ha a fájl formátuma nem megfelelő, akkor hibák léphetnek fel a fájl beolvasása és feldolgozása során.Fájlkezelés és hibakezelés: A fájlkezelő műveletek során figyelni kell a fájlok megfelelő kezelésére, például az
open()függvény hívásakor a megfelelő fájl elérési útvonalát kell megadni. Továbbá, a fájl olvasása során és a fájl bezárása előtt megfelelő hibakezelést kell alkalmazni, példáultry-exceptblokkot használni.Az adatok helyes kezelése: A kód nem ellenőrzi, hogy az adatok helyesek-e és megfelelnek-e a várt formátumnak. Ha az adatok hibásak vagy hiányosak a fájlban, akkor hibás eredmények vagy hibák léphetnek fel a feldolgozás során.
Példa feladat magyarázattal
Több adattípus
Tovább a példáhozÖsszetett feladat
Összetett feladat
magyarázat
def feladat():
epuletek = []
f = open('legmagasabb.txt', encoding='UTF-8')
f.readline()
sor = f.readline()
while (sor):
epuletek.append(Épület(sor))
sor = f.readline()
f.close()
- Első lépésben létrehozunk egy üres listát,
epuleteknéven, amelyben tárolni fogjuk az épületeket. - Megnyitjuk a
legmagasabb.txtnevű fájlt olvasásra, UTF-8 kódolással. - Beolvassuk az első sort a fájlból, majd további sorokat olvasunk be egy ciklusban.
- Minden beolvasott sort hozzáadunk az
epuleteklistához, azÉpületosztály segítségével létrehozva egy új épületet. - Amikor már nincs több sor, bezárjuk a fájlt.
print('Épületek száma: {0} db'.format(len(epuletek)))
- Kiírjuk a képernyőre az épületek számát, az
epuleteklista hosszát használva.
osszEmelet = 0
for e in epuletek:
osszEmelet += e.emelet
print('Emeletek összege: {0}'.format(osszEmelet))
- Egy
forciklussal végigiterálunk azepuleteklistán, és minden épület emelet számát hozzáadjuk azosszEmeletváltozóhoz. - Kiírjuk a képernyőre az emeletek összegét.
legmagasabbEpulet = epuletek[0]
for e in epuletek:
if (legmagasabbEpulet.magassag < e.magassag):
legmagasabbEpulet = e
print('\tNév: {0}'.format(legmagasabbEpulet.nev))
print('\tVáros: {0}'.format(legmagasabbEpulet.varos))
print('\tOrszág: {0}'.format(legmagasabbEpulet.orszag))
print('\tMagasság: {0}'.format(legmagasabbEpulet.magassag))
print('\tEmeletek száma: {0}'.format(legmagasabbEpulet.emelet))
print('\tÉpítés éve: {0}'.format(legmagasabbEpulet.epult))
- Az
epuleteklista első elemét (azaz az első épületet) alapértelmezetten a legmagasabb épületnek tekintjük. - Egy
forciklussal végigiterálunk azepuleteklistán, és minden épületet összehasonlítunk a jelenlegi legmagasabb épülettel. - Ha találunk egy olyan épületet, amely magasabb, mint a jelenlegi legmagasabb épület, akkor frissítjük a
legmagasabbEpuletváltozót. - Kiírjuk a képernyőre a legmagasabb épület adatait.
i = 0
while i < len(epuletek) and epuletek[i].orszag != 'Olaszország':
i += 1
if i < len(epuletek):
print('Van olasz épület az adatok között!')
else:
print('Nincs olasz épület az adatok között!')
- Inicializálunk egy
iváltozót, amelyet a ciklus indexelésére használunk. - Egy
whileciklusban végigmegyünk azepuleteklistán, és megvizsgáljuk, hogy az épület országa ‘Olaszország’-e. - Ha találunk egy olasz épületet, akkor befejezzük a ciklust, és kiírjuk, hogy van olasz épület az adatok között.
- Ha nem találunk olasz épületet, akkor kiírjuk, hogy nincs olasz épület az adatok között.
Teljes kód
def feladat():
epuletek = []
f = open('legmagasabb.txt', encoding='UTF-8')
f.readline()
sor = f.readline()
while (sor):
epuletek.append(Épület(sor))
sor = f.readline()
f.close()
print('Épületek száma: {0} db'.format(len(epuletek)))
osszEmelet = 0
for e in epuletek:
osszEmelet += e.emelet
print('Emeletek összege: {0}'.format(osszEmelet))
legmagasabbEpulet = epuletek[0]
for e in epuletek:
if (legmagasabbEpulet.magassag < e.magassag):
legmagasabbEpulet = e
print('A legmagasabb épület adatai')
print('\tNév: {0}'.format(legmagasabbEpulet.nev))
print('\tVáros: {0}'.format(legmagasabbEpulet.varos))
print('\tOrszág: {0}'.format(legmagasabbEpulet.orszag))
print('\tMagasság: {0}'.format(legmagasabbEpulet.magassag))
print('\tEmeletek száma: {0}'.format(legmagasabbEpulet.emelet))
print('\tÉpítés éve: {0}'.format(legmagasabbEpulet.epult))
i = 0
while i < len(epuletek) and epuletek[i].orszag != 'Olaszország':
i += 1
if i < len(epuletek):
print('Van olasz épület az adatok között!')
else:
print('Nincs olasz épület az adatok között!')
Példák
A Python programozási példákkal teli oldalunkon megtalálod a leggyakoribb programozási problémák megoldásait. Az oldal tematikus rendszerben mutatja be az egyes példákat, és részletesen leírja, hogy milyen célt szolgálnak. Fedezd fel a Python programozás széles világát és fejleszd tovább a készségeidet az oldalunkon található példákkal!
Páros szám vizsgálat
Páros szám vizsgálata
Az első sor a listát hozza létre, amely tartalmaz néhány számot.
l =[12, 11, 41, 75, 65 ,45, 66, 33,7, 49, 32, 73]
Az első lépésben inicializálunk egy “van” nevű változót, amely egy logikai értéket tárol. A kezdetben False értékkel inicializált “van” változó azt fogja jelenteni, hogy nincs páros szám a listában.
van = False
A “for” ciklus végigmegy a lista elemein a “range(len(l)-1)” segítségével. A “len(l)” függvény meghatározza a lista hosszát, amelyet a “range” függvénnyel együtt használunk a “for” ciklusban, hogy végigmenjünk a lista elemein. Az “i” változó minden iterációban megkapja a ciklus aktuális indexét.
for i in range(len(l)-1):
Az “if” utasítás a lista jelenlegi elemének vizsgálatára szolgál. Ha a jelenlegi elem páros (azaz a maradék nélkül osztható 2-vel), akkor a “van” változó értékét True-ra állítjuk, majd a ciklusból kilépünk a “break” utasítással. Ez azért fontos, hogy csak az első ilyen szám megtalálása után ismerjük fel, hogy van-e páros szám a listában.
if l[i] % 2 == 0:
van = True
break
Az “if van” utasítás a ciklus után fut le, és megvizsgálja, hogy van-e páros szám a listában. Ha van, akkor kiírja a “Van” szöveget a “print(f’Van’)” utasítással, különben pedig kiírja a “Nincs” szöveget a “print(‘Nincs’)” utasítással.
if van:
print(f'Van')
else:
print('Nincs')
Összességében ez a program arra szolgál, hogy megtalálja, van-e páros szám a listában, és ennek megfelelően ír ki egy üzenetet.
Teljes kód
ttt
l =[12, 11, 41, 75, 65 ,45, 66, 33,7, 49, 32, 73]
van = False
for i in range(len(l)-1):
if l[i] % 2 == 0:
van = True
break
if van:
print(f'Van')
else:
print('Nincs')
Két egymást követő szám páros-e?
A lenti kód megvizsgál egy adott listát, és megnézi, hogy a lista két egymás utáni száma páros-e. Ha talál ilyen párost, akkor kiírja a “Van” szöveget, különben pedig egy “Nincs” üzenetet ír ki.
Az első sor létrehozza a “l” nevű listát, amelyben számos szám van.
l =[12, 11, 41, 75, 65 ,45, 66, 33,7, 49, 32, 73]
Az első lépésben inicializálunk egy “van” nevű változót, amely egy logikai értéket tárol. A kezdetben False értékkel inicializált “van” változó azt jelenti, hogy nincs két egymás utáni páros szám a listában.
van = False
A “for” ciklus végigmegy a lista elemein a “range(len(l)-1)” segítségével. A “len(l)” függvény meghatározza a lista hosszát, amelyet a “range” függvénnyel együtt használunk a “for” ciklusban, hogy végigmenjünk a lista elemein. Az “i” változó minden iterációban megkapja a ciklus aktuális indexét.
for i in range(len(l)-1):
Az “if” utasítás az aktuális elem és a következő elem párosságának vizsgálatára szolgál. Ha mindkét elem páros, akkor a “van” változó értékét True-ra állítjuk, majd a ciklusból kilépünk a “break” utasítással. Ez azért fontos, hogy csak az első ilyen páros számok megtalálása után ismerjük fel, hogy van-e két egymás utáni páros szám a listában.
if l[i] % 2 == 0 and l[i+1] % 2 == 0:
van = True
break
Az “if van” utasítás a ciklus után fut le, és megvizsgálja, hogy van-e két egymás utáni páros szám a listában. Ha van, akkor kiírja a “Van” szöveget a “print(f’Van’)” utasítással, különben pedig kiírja a “Nincs” szöveget a “print(‘Nincs’)” utasítással.
if van:
print(f'Van')
else:
print('Nincs')
Összességében ez a program arra szolgál, hogy megtalálja, van-e a listában két egymás utáni páros szám, és ennek megfelelően ír ki egy üzenetet.
Teljes kód
l =[12, 11, 41, 75, 65 ,45, 66, 33,7, 49, 32, 73]
van = False
for i in range(len(l)-1):
if l[i] % 2 == 0 and l[i+1] % 2 == 0:
van = True
break
if van:
print(f'Van')
else:
print('Nincs')
Fogadásos feladat
1. Az “toto” osztály inicializálja az osztály példányait, amelyek az eredményeket tárolják.
class toto:
def __init__(self, sor):
ev, het, fordulo, t13p1, ny13p1, eredmenyek = sor.split(';')
self.ev = int(ev)
self.het = int(het)
self.fordulo = int(fordulo)
self.t13p1 = int(t13p1)
self.ny13p1 = int(ny13p1)
self.eredmenyek = eredmenyek
def nem_volt_dontetlen(self):
return self.eredmenyek.count('X') == 0
A fogadásos feladat ezeket az értékeket tartalmazza:
• Év: A fogadási forduló éve (1998-2020)
• Hét: A fogadási forduló hete (1-53)
• Forduló: Forduló sorszáma (1 vagy 2)
• T13p1: 13+1 találatos (telitalálatos) szelvények darabszáma
• Ny13p1: Egy darab 13+1 találatos szelvény után fizetett nyeremény
2. Az eredményeket tartalmazó fájlt megnyitja és beolvassa a sorokat.
fordulok = []
with open('toto.txt', 'r', encoding='utf-8') as f:
for sor in f.read().splitlines()[1:]: #kihagyja az első sort
fordulok.append(toto(sor))
4. Kiírja a fogadási fordulók számát.
print(f'2. feladat: Fogadási fordulók száma: {len(fordulok)}')
5. Megszámolja a telitalálatos szelvények számát.
telitalalatos = 0
for e in fordulok:
telitalalatos += e.t13p1
print(f'3. feladat: Telitalálatos szelvények száma: {telitalalatos}')
6. Ellenőrzi, hogy van-e olyan forduló, amelyben nem volt döntetlen eredmény, majd ezt a tényt kiírja.
volt = False
for e in fordulok:
if e.nem_volt_dontetlen():
volt = True
break
print(f'4. feladat: {"Volt" if volt else "Nem volt"} döntetlen mentes forduló')
Teljes kód:
class toto:
def __init__(self, sor):
ev, het, fordulo, t13p1, ny13p1, eredmenyek = sor.split(';')
self.ev = int(ev)
self.het = int(het)
self.fordulo = int(fordulo)
self.t13p1 = int(t13p1)
self.ny13p1 = int(ny13p1)
self.eredmenyek = eredmenyek
def nem_volt_dontetlen(self):
return self.eredmenyek.count('X') == 0
fordulok = []
with open('toto.txt', 'r', encoding='utf-8') as f:
for sor in f.read().splitlines()[1:]: #kihagyja az első sort
fordulok.append(toto(sor))
print(f'2. feladat: Fogadási fordulók száma: {len(fordulok)}')
telitalalatos = 0
for e in fordulok:
telitalalatos += e.t13p1
print(f'3. feladat: Telitalálatos szelvények száma: {telitalalatos}')
volt = False
for e in fordulok:
if e.nem_volt_dontetlen():
volt = True
break
print(f'4. feladat: {"Volt" if volt else "Nem volt"} döntetlen mentes forduló')
Feladat letöltése:
Prímszám vizsgálat
Itt van egy definíciós Python gyakorló feladat, amely egy függvényt definiál, amely eldönti, hogy egy adott szám prím-e:
def is_prime(num):
if num <= 1: # 1-nél kisebb szám nem lehet prím
return False
for i in range(2, int(num**0.5)+1):
if num % i == 0:
return False
return True
A függvény végigmegy az összes 2 és a szám gyökéig terjedő egész számon, és megnézi, hogy a szám osztható-e bármelyikkel ezek közül. Ha az, akkor a függvény False értéket ad vissza, különben True értékkel tér vissza.
A num**0.5 a szám négyzetgyöke, amely segít a hatékonyabb algoritmus megírásában. Mivel a prímszámok a páratlan számok kivételével mind két számjegyre való szorzattal állnak elő (pl. 7 = 1 * 7, 11 = 1 * 11, 13 = 1 * 13), így a tesztelő számokat csak a szám gyökéig kell vizsgálni.
Példa a függvény használatára:
print(is_prime(7)) # True
print(is_prime(10)) # False
print(is_prime(31)) # True
Hol használják a prím számokat:
A prím számoknak számos matematikai és alkalmazott matematikai alkalmazása van. Néhány példa:
Kriptográfia: A modern kriptográfiában a prím számok kiemelt szerepet játszanak. Például a RSA titkosítási módszer alapja a két nagy prím szám szorzata. A prím számok nagy számok, így nagyon nehéz megfejteni a titkosítást, ha az alapja prím számok szorzata.
Sita Eratosszthenész: Az antik görög matematikus, Eratosszthenész találta fel az ún. “sita” algoritmust, amely lehetővé teszi az összes prím szám megtalálását adott tartományban. Ez az algoritmus ma is használatos matematikai kutatásokban és alkalmazásokban.
Számelmélet: A számelmélet számos területén fontos szerepe van a prím számoknak. Például, az összetett számok faktorizálásához (azaz a szám felbonthatóságának vizsgálatához) gyakran szükséges prím számokat használni.
Algoritmusok: A prím számokat gyakran használják algoritmusok optimalizálásához és hatékonyságának javításához. Például, az útvonalválasztási protokollok a hálózatban (pl. Internet) gyakran használnak prím számokat a leggyorsabb és leghatékonyabb útvonalak kereséséhez.
Statisztika: A prím számok eloszlása is érdekes statisztikai tulajdonságokkal rendelkezik. Az Riemann-féle hipotézis állítása szerint a prímek eloszlása ismert matematikai eloszlásra vezethető vissza.
Összességében a prím számok matematikai és alkalmazott matematikai területeken széles körben használják.
Több adattípus
Fájlfeldolgozásos feladat
Első lépés
Az alloviz osztály definiálása és inicializálása.
class alloviz:
def __init__(self, sor):
id, nev, tipus, terulet, vizgyujto = sor.split(';')
self.id = int(id)
self.nev = nev
self.tipus = tipus if tipus!='NULL' else ''
self.terulet = float(terulet.replace(',', '.')) if terulet!='NULL' else 0
self.vizgyujto = int(vizgyujto) if vizgyujto!='NULL' else 0
- Az osztályban definiáljuk az
__init__nevű metódust, amely az objektum inicializálásáért felelős. - A metódus paraméterként kapja meg a
sorértéket, amely a feldolgozandó adatokat tartalmazza. - A
sorértéket pontosvesszővel elválasztott adatokra bontjuk asplit(';')metódus segítségével. - Az adatokat külön változóknak rendeljük, majd ezeket az objektum attribútumainak állítjuk be.
- Az
idattribútumot egész számként inicializáljuk azint(id)kifejezéssel. - A
teruletattribútumot lebegőpontos számként inicializáljuk afloat(terulet.replace(',', '.'))kifejezéssel, ahol a,karaktereket a.karakterre cseréljük. - A
vizgyujtoattribútumot egész számként inicializáljuk azint(vizgyujto)kifejezéssel. - Ha a
tipusvagyteruletértéke “NULL”, akkor azokat üres stringgel ('') vagy 0-val inicializáljuk.
Második lépés
Az adatok beolvasása és feldolgozása a fájlból.
l = []
with open ('alloviz.txt', 'r', encoding='utf-8') as f:
for sor in f.read().splitlines()[1:]:
l.append(alloviz(sor))
- Létrehozunk egy üres listát
lnéven, amely azallovizobjektumokat fogja tárolni. - Megnyitjuk a
alloviz.txtfájlt olvasásra, és azfnevű változóhoz rendeljük. - A fájl tartalmát beolvassuk, majd soronként feldolgozzuk.
- A sorokat a
splitlines()metódussal szétválasztjuk, majd a lista második elemtől (az első sort kihagyva) végigmegyünk aforciklussal. - Minden sorhoz létrehozunk egy
allovizobjektumot, amelyet a sorral példányosítunk, majd hozzáadjuk allistához.
Harmadik lépés
Az adatok elemzése és eredmények kiírása.
print('3.1 feladat:')
print(f'Az adatbázisban {len(l)} tó adatai szerepelnek.')
print('3.2 feladat:')
osszeg = 0
db = 0
for e in l:
if e.terulet != 0:
osszeg += e.terulet
db += 1
print(f'Az állóvizek területének átlaga {osszeg/db:.2f}')
- Kiírjuk a
llista elemeinek számát alen(l)kifejezéssel. - Ezután inicializálunk két változót:
osszegésdb0 értékkel. - Végigmegyünk a
llista elemein aforciklus segítségével.
Teljes kód
class alloviz:
def __init__(self, sor):
id, nev, tipus, terulet, vizgyujto = sor.split(';')
self.id = int(id)
self.nev = nev
self.tipus = tipus if tipus!='NULL' else ''
self.terulet = float(terulet.replace(',', '.')) if terulet!='NULL' else 0
self.vizgyujto = int(vizgyujto) if vizgyujto!='NULL' else 0
l = []
with open ('alloviz.txt', 'r', encoding='utf-8') as f:
for sor in f.read().splitlines()[1:]:
l.append(alloviz(sor))
print('3.1 feladat:')
print(f'Az adatbázisban {len(l)} tó adatai szerepelnek.')
print('3.2 feladat:')
osszeg = 0
db = 0
for e in l:
if e.terulet != 0:
osszeg += e.terulet
db += 1
print(f'Az állóvizek területének átlaga {osszeg/db:.2f}')
3.1 feladat:
Az adatbázisban 245 tó adatai szerepelnek.
3.2 feladat:
Az állóvizek területének átlaga 5.46
Matematikai függvény
A függvény teljes kódja a részletes magyarázattal:
def szamitas(szamok, definicio):
# Az if-elif-else szerkezet a definicio értékétől függően választja ki a megfelelő számítást
if definicio == "összeg":
# Ha definicio értéke "összeg", akkor az összegzést végezzük
eredmeny = sum(szamok)
elif definicio == "szorzat":
# Ha definicio értéke "szorzat", akkor a szorzást végezzük
eredmeny = 1
for szam in szamok:
eredmeny *= szam
elif definicio == "legnagyobb":
# Ha definicio értéke "legnagyobb", akkor a legnagyobb számot keressük
eredmeny = max(szamok)
elif definicio == "legkisebb":
# Ha definicio értéke "legkisebb", akkor a legkisebb számot keressük
eredmeny = min(szamok)
else:
# Ha definicio értéke sem egyezik a fenti értékekkel, akkor érvénytelen érték volt megadva
eredmeny = None
# Az eredmény visszaadása
return eredmeny
# Példa használat:
print(szamitas([1, 2, 3], "összeg")) # kimenet: 6
print(szamitas([4, 5, 6], "szorzat")) # kimenet: 120
print(szamitas([7, 8, 9], "legnagyobb")) # kimenet: 9
print(szamitas([10, 11, 12], "legkisebb")) # kimenet: 10
A szamitas függvény először ellenőrzi a definicio értékét, majd ennek alapján hajtja végre a megfelelő számítást a szamok listán. Az eredményt visszaadja a függvény. A példa használat során négy különböző számítást végezünk a szamitas függvény segítségével.
Egyszerűbb megoldása
def feladat1():
a = int(input('Kérem az első számot: '))
b = int(input('Kérem az második számot: '))
if a > b:
print('A nagyobb szám {0}, a kisebb {1}.'.format(a, b))
elif b > a:
print('A nagyobb szám {0}, a kisebb {1}.'.format(b, a))
else:
print('A két szám egyenlő.')
Adatbázis kezelés
SQLite
Az SQLite3 modul ereje: Betekintés a Python adatbázis-kezelés varázslatos világába
Az SQLite3 modul a Python varázspálcája az adatbázis-kezelés birodalmában. Ez a modul egy könnyű, fájl alapú adatbázis-motort ölel fel, amely nem igényel különálló szerverfolyamatot, így ideális beágyazott rendszerekhez és olyan alkalmazásokhoz, ahol a teljesítmény és a hordozhatóság kulcsfontosságú. De ne tévesszen meg a könnyű súlya – az SQLite3 modul lenyűgöző képességekkel bír, amelyek kinyitják az adatbázis-kezelés kapuit a Python programozók számára.
Fedezd fel az SQLite3 modul varázslatos eszköztárát:
- Adatbázisok varázslása: Egyszerű parancsokkal hozhatsz létre és nyithatsz meg adatbázisokat, kényelmesen kezelve az adatokat.
- Táblák, nézetek és indexek megalkotása: A táblák struktúrájának megtervezése gyerekjáték a modul varázslatos erejével. Nézeteket és indexeket is létrehozhatsz, hogy az adatok lekérdezése gyerekjáték legyen.
- Adatok varázslatos manipulációja: Az SQLite3 modul varázslatos parancsokkal könnyedén beszúrhatsz, frissíthetsz és törölhetsz adatokat az adatbázisban.
- Lekérdezések varázslása: A modul intuitív lekérdezési nyelvet biztosít, amellyel hatékonyan kinyerheted a kívánt információkat az adatbázisból.
- Tranzakciók varázslatos ereje: Biztonságosan kezelheted az adatokat tranzakciók használatával, biztosítva a konzisztenciát és a sértetlenséget.
Az SQLite3 modul varázslatai a következőket varázsolják elénk:
- Könnyű használat: A modul intuitív API-t kínál, amelyet még a kezdő Python programozók is könnyedén elsajátíthatnak.
- Gyorsaság: Az SQLite3 modul kiemelkedő teljesítményt nyújt, így ideális nagy adatmennyiségek kezelésére.
- Hordozhatóság: A modul platformfüggetlen, így bármilyen operációs rendszeren futtathatod a Python programjaidat.
- Megbízhatóság: Az SQLite3 modul stabil és megbízható, így biztos lehetsz benne, hogy az adataid biztonságban vannak.
Az SQLite3 modul varázslatos erejét a következő varázslatos területeken vetheted be:
- Webes alkalmazások: Dinamikus weboldalakat építhetsz adatbázis-vezérelt tartalommal.
- Asztali alkalmazások: Hatékony adatbázis-kezelést integrálhatsz az asztali programjaidba.
- Beágyazott rendszerek: Az SQLite3 modul ideális kis méretű eszközökbe, ahol a memóriahasználat kritikus fontosságú.
- Adattudásbázisok: Könnyedén tárolhatsz és lekérdezhetsz strukturált adatokat.
Az SQLite3 modul varázslatos képességei a következőket varázsolják elénk:
- Könnyű telepítés: A modul már beépítve van a Pythonba, így nem kell külön telepítened.
- Nyílt forráskód: Az SQLite3 modul nyílt forráskódú, így szabadon bővítheted és testreszabhatod a varázslatait.
- Aktív közösség: Nagy és aktív közösség áll mögött, amely varázslatos segítséget nyújthat a varázslás során.
Az SQLite3 modul varázslatos erejét elsajátítva a Python programozók kinyithatják az adatbázis-kezelés varázslatos kapuit, és lenyűgöző alkalmazásokat varázsolhatnak.
Fájl létrehozása
Hogyan hozzunk létre egy SQLite3 adatbázist Pythonban?
Képzeld, hogy van egy csomó adatod, amit el kell tárolnod. Persze, ott a sima szöveges fájl, de az egy nagy katyvasz. Kellene valami, ami strukturált, rendezett, és könnyen kereshető. Na, itt jön képbe az SQLite3 adatbázis!
Az SQLite3 egy szuperkönnyű adatbázismotor, amit beágyazhatsz a Python kódodba. Olyan, mint egy kis doboz, ahova elpakolhatod az adataidat.
Na de hogyan hozzunk létre egy ilyet?
Először is telepítened kell a Python 3-at és az SQLite3 modult. Ha ez megvan, akkor már nyithatod is a PyCharm-ot (vagy a kedvenc kódszerkesztődet).
Íme a varázskód:
import sqlite3
# Kapcsolódás az adatbázishoz
connection = sqlite3.connect("mydb.db")
# Kapcsolat bezárása
connection.close()
Mit is csinál ez a kód?
- Az
import sqlite3sor betölti az SQLite3 modult. - A
connection = sqlite3.connect("mydb.db")sor létrehoz egy “mydb.db” nevű adatbázist a munkamappában. - A
connection.close()sor bezárja a kapcsolatot az adatbázissal.
Ennyi! Már van is egy üres adatbázisod!
Gondolod bonyolult?
Egyáltalán nem! A kód pofonegyszerű, és hamarosan megtanulod, hogyan tölthetsz be adatokat, hozhatsz létre táblákat, és bonyolult lekérdezéseket is futtathatsz.
Tábla létrehozása
Ebben a leírásban végigvezetünk az SQLite3 adatbázis létrehozásának lépésein Pythonban, tömörebb, de informatív stílusban.
Lépések:
- Importálás:
import sqlite3
Betöltjük az SQLite3 modult a kódunkba.
- Kapcsolódás:
connection = sqlite3.connect("mydb.db")
Létrehozunk egy connection objektumot, ami a “mydb.db” nevű adatbázishoz kapcsolódik (a fájl a munkamappában jön létre).
- Tábla létrehozása:
cursor = connection.cursor()
cursor.execute("""
CREATE TABLE users (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT,
email TEXT
);
""")
- Létrehozunk egy
cursorobjektumot az SQL parancsok futtatásához. - A
cursor.execute()parancs segítségével futtatjuk aCREATE TABLESQL utasítást. - A
userstábla három oszlopot fog tartalmazni:id(azonosító),name(név) ésemail(email cím). - Az
idoszlop az elsődleges kulcs, automatikusan növekvő értékekkel.
- Változások mentése:
connection.commit()
Véglegesítjük az adatbázisban végrehajtott változtatásokat.
- Kapcsolat lezárása:
connection.close()
Bezárjuk a kapcsolatot az adatbázissal.
Ezzel a kóddal sikeresen létrehoztunk egy “mydb.db” nevű adatbázist és egy “users” nevű táblát benne.
Adatfelvitel
Az SQLite3 egy könnyű, fájl alapú adatbázismotor, amely ideális beágyazott rendszerekhez és kis méretű adatbázisokhoz. A Pythonban az sqlite3 modul segítségével egyszerűen hozhatunk létre, módosíthatunk és lekérdezhetünk SQLite3 adatbázisokat.
Ebben a leírásban bemutatjuk, hogyan tölthetsz fel adatokat egy SQLite3 adatbázisba Pythonban.
1. Egyszerű adatbevitel:
import sqlite3
connection = sqlite3.connect("mydb.db")
cursor = connection.cursor()
# Adatok beszúrása a "users" táblába
cursor.execute("""
INSERT INTO users (name, email)
VALUES (?, ?)
""", ("John Doe", "johndoe@example.com"))
connection.commit()
connection.close()
Magyarázat:
- A kód először betölti az SQLite3 modult és kapcsolódik a “mydb.db” adatbázishoz.
- Létrehoz egy
cursorobjektumot az SQL parancsok futtatásához. - Az
INSERT INTOSQL utasítással beszúrjuk az adatokat a “users” táblába. - A
?jelzők helyére aVALUESzáradékban megadott értékek kerülnek. - A
connection.commit()parancs véglegesíti a változtatásokat. - Végül bezárjuk a kapcsolatot az adatbázissal.
2. Több adat beszúrása
import sqlite3
connection = sqlite3.connect("mydb.db")
cursor = connection.cursor()
users = [
("Jane Doe", "janedoe@example.com"),
("Peter Smith", "petersmith@example.com"),
("Sarah Jones", "sarahjones@example.com"),
]
# Több adat beszúrása a "users" táblába
cursor.executemany("""
INSERT INTO users (name, email)
VALUES (?, ?)
""", users)
connection.commit()
connection.close()
Magyarázat:
- A kód először betölti az SQLite3 modult és kapcsolódik a “mydb.db” adatbázishoz.
- Létrehoz egy
cursorobjektumot az SQL parancsok futtatásához. - A
userslista tárolja a beillesztendő adatokat. - Az
executemany()metódus segítségével hatékonyan beszúrhatunk több adatot. - A
?jelzők helyére auserslista elemei kerülnek. - A
connection.commit()parancs véglegesíti a változtatásokat. - Végül bezárjuk a kapcsolatot az adatbázissal.
3. Adatbevitel paraméterekkel:
import sqlite3
def insert_user(name, email):
connection = sqlite3.connect("mydb.db")
cursor = connection.cursor()
cursor.execute("""
INSERT INTO users (name, email)
VALUES (?, ?)
""", (name, email))
connection.commit()
connection.close()
# Példa a használatra
insert_user("John Doe", "johndoe@example.com")
insert_user("Jane Doe", "janedoe@example.com")
Magyarázat:
- A kód definiál egy
insert_user()függvényt, ami paraméterként fogadja a nevet és az email címet. - A függvény belül kapcsolódik az adatbázishoz, beszúrja az adatokat, és bezárja a kapcsolatot.
- A kód példát mutat a függvény használatára két felhasználó beillesztésére.
Adatmódosítás
Ebben a leírásban bemutatjuk, hogyan módosíthatsz adatokat egy SQLite3 adatbázisban Pythonban, az UPDATE és DELETE parancsok használatával.
Példák:
1. Adat frissítése:
import sqlite3
connection = sqlite3.connect("mydb.db")
cursor = connection.cursor()
# Adat frissítése a "users" táblában
cursor.execute("""
UPDATE users
SET name = ?, email = ?
WHERE id = ?
""", ("John Doe", "johndoe@example.com", 1))
connection.commit()
connection.close()
Magyarázat:
- A kód először betölti az SQLite3 modult és kapcsolódik a “mydb.db” adatbázishoz.
- Létrehoz egy
cursorobjektumot az SQL parancsok futtatásához. - Az
UPDATESQL utasítással frissítjük az adatokat a “users” táblában. - A
WHEREzáradék határozza meg, hogy melyik rekordot kell frissíteni. - A
?jelzők helyére a megadott értékek kerülnek. - A
connection.commit()parancs véglegesíti a változtatásokat. - Végül bezárjuk a kapcsolatot az adatbázissal.
2. Adat törlése:
import sqlite3
connection = sqlite3.connect("mydb.db")
cursor = connection.cursor()
# Adat törlése a "users" táblából
cursor.execute("""
DELETE FROM users
WHERE id = ?
""", (1,))
connection.commit()
connection.close()
Magyarázat:
- A kód először betölti az SQLite3 modult és kapcsolódik a “mydb.db” adatbázishoz.
- Létrehoz egy
cursorobjektumot az SQL parancsok futtatásához. - A
DELETESQL utasítással törlünk adatot a “users” táblából. - A
WHEREzáradék határozza meg, hogy melyik rekordot kell törölni. - A
?jelző helyére a megadott érték kerül. - A
connection.commit()parancs véglegesíti a változtatásokat. - Végül bezárjuk a kapcsolatot az adatbázissal.
De az adatbázisban bármilyen módosítást végre lehet hajtani így SQL módosító lekérdezésekkel.
Lekérdezések
Ebben a leírásban bemutatjuk, hogyan hajthatsz végre adatlekérdezéseket egy SQLite3 adatbázisban Pythonban, az SELECT parancs használatával.
1. Egyszerű lekérdezés:
import sqlite3
connection = sqlite3.connect("mydb.db")
cursor = connection.cursor()
# Adatok lekérdezése a "users" táblából
cursor.execute("""
SELECT * FROM users
""")
# Lekérdezési eredmények feldolgozása
for row in cursor.fetchall():
print(row)
connection.close()
Magyarázat:
- A kód először betölti az SQLite3 modult és kapcsolódik a “mydb.db” adatbázishoz.
- Létrehoz egy
cursorobjektumot az SQL parancsok futtatásához. - Az
SELECT * FROM usersSQL utasítással lekérdezzük az összes adatot a “users” táblából. - A
cursor.fetchall()metódus lekéri az összes találatot. - A
forciklus bejárja a találatokat és kiírja őket. - Végül bezárjuk a kapcsolatot az adatbázissal.
2. Szűrt lekérdezés:
import sqlite3
connection = sqlite3.connect("mydb.db")
cursor = connection.cursor()
# Adatok lekérdezése a "users" táblából, ahol az email cím "example.com"-mal végződik
cursor.execute("""
SELECT * FROM users
WHERE email LIKE '%@example.com'
""")
# Lekérdezési eredmények feldolgozása
for row in cursor.fetchall():
print(row)
connection.close()
Magyarázat:
- A kód először betölti az SQLite3 modult és kapcsolódik a “mydb.db” adatbázishoz.
- Létrehoz egy
cursorobjektumot az SQL parancsok futtatásához. - Az
SELECT * FROM users WHERE email LIKE '%@example.com'SQL utasítással lekérdezzük azokat a “users” táblában lévő adatokat, ahol az email cím “example.com”-mal végződik. - A
LIKEoperátor joker karaktereket is használhat. - A
cursor.fetchall()metódus lekéri az összes találatot. - A
forciklus bejárja a találatokat és kiírja őket. - Végül bezárjuk a kapcsolatot az adatbázissal.
Összefoglalva:
Az SQLite3 egy hatékony eszköz az adatlekérdezésekhez Pythonban. A SELECT parancs és a különböző opciók használatával rugalmasan lekérdezheted az adataidat.
Menetrend feladat
Ez a Python fájl beolvassa egy “menetrend.txt” nevű szöveges fájlt, és az adatokat betölti egy “hajo.db” nevű SQLite3 adatbázisba. Ezután lekérdezi az adatbázist a “J1” azonosítóval rendelkező járatra vonatkozó információkért.
A fájl részei:
1. Osztály definíció:
import sqlite3 as sqlite
class menetrend:
def __init__(self, sor):
jarat, honnan, hova, indul, erkezik= sor.split('\t')
self.jarat=jarat
self.honnan=honnan
self.hova=hova
self.indul=indul
self.erkezik=erkezik
- Az
import sqlite3sor betölti az SQLite3 modult. - A
menetrendosztály definiál egy__init__metódust, amely feldolgoz egy bemenetisor-t, és az oszlopokat (jarat,honnan,hova,indul,erkezik) attribútumokként tárolja.
2. Adatok beolvasása:
lista=[]
with open('menetrend.txt', 'r', encoding='utf-8') as f:
for sor in f.read().splitlines()[1:]:
lista.append(menetrend(sor))
#a fájl sorai a így néznek ki
#elsősor:
#jarat honnan hova indul erkezik
#többi sor példa:
#B5 Balatonboglár Révfülöp 14:30 14:55
#E3 Balatonfüred Tihany 13:00 13:20
#F3 Fonyód Badacsony 10:00 10:30
#J1 Csopak Balatonfüred 11:20 11:45
#J1 Balatonfüred Tihany 11:45 12:05
- A
listaváltozó tárolja amenetrendobjektumokat. - A
withblokk beolvassa amenetrend.txtfájlt, és feldolgozza az egyes sorokat. - A
splitlines()metódus feldarabolja a fájl tartalmát sorokra. - A
menetrend(sor)konstruktor meghívódik a soronkénti feldolgozáshoz.
3. Adatbázis műveletek:
con = sqlite.connect('hajo.db')
cur = con.cursor();
cur.execute('DROP TABLE IF EXISTS menetrend')
con.commit()
cur.execute('''CREATE TABLE
menetrend(azon INTEGER PRIMARY KEY AUTOINCREMENT,
jarat TEXT, honnan TEXT, hova TEXT, indul TEXT, erkezik TEXT )''')
con.commit()
sql = 'INSERT INTO menetrend(jarat, honnan, hova, indul, erkezik) VALUES(?,?,?,?,?)'
for e in lista:
adat = (e.jarat, e.honnan, e.hova, e.indul, e.erkezik)
cur.execute(sql,adat)
con.commit()
- A
conváltozó tárolja az adatbázishoz való kapcsolódást. - A
curváltozó a lekérdezések futtatására szolgál. - A
DROP TABLE IF EXISTSparancs törli a “menetrend” táblát, ha létezik. - A
CREATE TABLEparancs létrehozza a “menetrend” táblát a megadott oszlopokkal. - Az
sqlváltozó tárolja az INSERT parancsot. - A
forciklus bejárja alistaelemeit, és beszúrja azokat az adatbázisba.
4. Lekérdezés:
cur.execute('SELECT * FROM menetrend WHERE jarat="J1"')
for s in cur.fetchall():
print(s)
- A
SELECT * FROM menetrend WHERE jarat="J1"parancs lekérdezi azokat a sorokat a “menetrend” táblából, ahol ajaratoszlop értéke “J1”. - A
fetchall()metódus lekéri az összes találatot. - A
forciklus bejárja a találatokat és kiírja őket.
A teljes kód:
import sqlite3 as sqlite
class menetrend:
def __init__(self, sor):
jarat, honnan, hova, indul, erkezik= sor.split('\t')
self.jarat=jarat
self.honnan=honnan
self.hova=hova
self.indul=indul
self.erkezik=erkezik
lista=[]
with open('menetrend.txt', 'r', encoding='utf-8') as f:
for sor in f.read().splitlines()[1:]:
lista.append(menetrend(sor))
con = sqlite.connect('hajo.db')
cur = con.cursor();
cur.execute('DROP TABLE IF EXISTS menetrend')
con.commit()
cur.execute('''CREATE TABLE
menetrend(azon INTEGER PRIMARY KEY AUTOINCREMENT,
jarat TEXT, honnan TEXT, hova TEXT, indul TEXT, erkezik TEXT )''')
con.commit()
sql = 'INSERT INTO menetrend(jarat, honnan, hova, indul, erkezik) VALUES(?,?,?,?,?)'
for e in lista:
adat = (e.jarat, e.honnan, e.hova, e.indul, e.erkezik)
cur.execute(sql,adat)
con.commit()
cur.execute('SELECT * FROM menetrend WHERE jarat="J1"')
for s in cur.fetchall():
print(s)
Összefoglalva:
Ez a Python fájl bemutatja, hogyan lehet beolvasni egy szöveges fájlt, betölteni az adatokat egy SQLite3 adatbázisba, és lekérdezni az adatbázist.