M = [[1, 2], [3, 4]]
Tömb egy elemét így érhetjük el:
M[0][1]
M = [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[0, 9], [0, 0]]] # 3x2x2-es tömb
M[2][0][1]
Írjunk olyan függvényt, mely kiír egy 2D tömböt táblázatszerűen ilyesmi formában:
1 2
3 4def tomb_kiir(M):
for i in range(len(M)):
for j in range(len(M[i])):
print(M[i][j], end='\t') # TAB karakter
print()
tomb_kiir([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
tomb_kiir([[1, 2, 3, 3.5], [4, 5, 6, 6.5], [7, 8, 9, 9.5]])
Törzsvásárlói kedvezményt szeretnénk adni a vásárlóinknak. Adott a nevük (egyedi, string) és az eddigi vásárlásaik végösszege (egyenként). Minden ügyfélhez egy lista tartozik, melynek első eleme a személy neve, a második egy lista a vásárlások összegéről, például:
["Anett", [54, 23, 12, 56, 12, 71]]
A kedvezményt a következő módon adnánk:
Összes vásárlás > 200: 10%
Összes vásárlás > 500: 15%
Összes vásárlás > 1000: 20%
Írjuk meg a függvényt, mely megkapja a vásárlók listáját (elemei, mint a fenti "Anett" lista) és visszaad egy listát melyben 2 elemű listák vannak, az első elem a vásárló neve, a második a kedvezménye. Pl:
["Anett", 10]
Hogyan fogjunk neki? Bontsuk részfeladatokra!
Kétféle képpen lehet haladni (design):
# top-down
def kedvezmeny(vasarlok):
kedvezmenyek = []
for vasarlo in vasarlok:
kedvezmenyek.append(kedvezmeny_szamol(vasarlo))
return kedvezmenyek
def kedvezmeny_szamol(vasarlo):
nev = vasarlo[0]
osszeg = 0
for vasarlas in vasarlo[1]:
osszeg += vasarlas
return [nev, osszegbol_kedvezmeny(osszeg)]
def osszegbol_kedvezmeny(osszeg):
if osszeg > 1000:
return 20
if osszeg > 500:
return 15
if osszeg > 200:
return 10
return 0
kedvezmeny([["Anett", [54, 23, 12, 56, 12, 71]],
["Hagrid", [111, 545, 343, 56, 12, 66]],
["Béla", [11, 3, 12, 1, 12, 55]],
["Not_a_wizard", [54, 222, 65, 56, 43, 71]]])
Már megismerkedtünk a karakterláncokkal (sztringekkel) és listákkal, mint összetettebb adatszerkezetekkel. A szám-n-es vagy tuple megadása kerek zárójelek közt vesszőkkel elválasztva, vagy a tuple() függvénnyel adható meg:
t = (1, 5, 6, 2, 1)
print(t[2])
type(t)
l = [1, 2, 3]
t = tuple(l)
print(t)
for e in t:
print(e, end=" ")
t[1] = 4
Bizonyos helyzetekben a zárójel el is hagyható:
x = 2, 3, 4
print(x)
x, y = 2, 3
print(x)
print(y)
1-hosszú tuple nem összetévesztendő a sima zárójellel, ennek érdekében az utolsó (és egyben első) elem után vesszőt rakunk.
print(type((1)))
print(type((1,)))
A tuple-k úgy működnek, mint a listák egy kivétellel. A listák elemei változtathatók (mutable), a tuple elemei nem változtathatók (immutable). Egy tuple elemei csak úgy változtathatók meg, ha újra létrehozzuk, hasonlóan a string-ekhez:
s = ("l", "e", "l", "e", "t")
print(s[2])
s = ("l", "e", "h", "e", "t")
for e in s:
print(e, end=' ')
s[2] = "l"
A szótárakat képzelhetjük úgy, mint kulcs-érték párok tárolóit. Egy szótár kulcsa bármilyen megváltoztathatatlan adatszerkezet lehet, akár egyszerű, mint egy egész vagy valós szám, akár egy tuple, vagy egy string.
Létrehozhatjuk kapcsos zárójellel { } vagy a dict() függvénnyel.
d = {"kutya": 5}
type(d)
Értékként bármilyen adattípus szerepelhet, nem kell megváltoztathatatlannak lennie:
d = {}
d["macska"] = [1, 5]
d
Szótárba új elemet úgy vehetünk fel, ha egy új kulcshoz hozzárendelünk egy értéket:
d["cica"] = 1
d
Egy szótáron belül többféle típusú kulcs is lehet:
d = dict()
d[5] = 7
d[(1, 5)] = "macska"
print(d)
d["macska"] = [1, 5]
d[(1, 5)] = "sajt"
print(d)
A szótár kulcsai bejárhatók egy for ciklussal:
for kulcs in d:
print(kulcs, d[kulcs])
Az előbbi vásárló adatbázis így nézne ki szótárral:
vasarlok = {"Anett": [54, 23, 12, 56, 12, 71],
"Hagrid": [111, 545, 601],
"Béla": [11, 3, 12, 1, 12, 55],
"Not_a_wizard": [54, 222, 165, 56]}
print(vasarlok)
print()
print(vasarlok["Béla"])
Feladat: Írjunk olyan programot, mely minden vásárlónra eltárolja a kedvezményét is.
# szótárral
def kedvezmeny(vasarlok):
for vasarlo in vasarlok:
vasarlok[vasarlo] = {"v": vasarlok[vasarlo]}
vasarlok[vasarlo]["k"] = kedvezmeny_szamol(vasarlok[vasarlo]["v"])
print(vasarlo, vasarlok[vasarlo]["k"])
def kedvezmeny_szamol(v):
osszeg = 0
for vasarlas in v:
osszeg += vasarlas
return osszegbol_kedvezmeny(osszeg)
def osszegbol_kedvezmeny(osszeg):
if osszeg > 1000:
return 20
if osszeg > 500:
return 15
if osszeg > 200:
return 10
return 0
kedvezmeny(vasarlok)
vasarlok.keys()
vasarlok.values()
for i in vasarlok.values():
print(i)
sorted(vasarlok)
Minek alapján sort-ol, ha a kulcsok különféle típusúak lehetnek?
Több beépített python függvény és algoritmus is (mint például a dict) használja a hash() függvényt. Ezeket a hash-értékeket használja az elemek gyors eléréséhez. Hogy a szótárban a kulcs hash-elhető legyen, nem változhat, ezért a kulcs nem lehet mutable objektum, például lista!
A számítástechnika és a kriptográfia más területein is fontos (mind alkalmazásban, mind elméletben) Haladó adatszerkezetek és algoritmuselemzési technikák, Friedl Katalin.
Mit csinál egy hash:
Ezen felül extra elvárások lehetnek (kriptográfiai hash):
Néhány hash érték, ami lekérhető a hash() függvénnyel:
print(hash((1, 5)))
print(hash(5), hash(0), hash(False), hash(True))
print(hash((5,)))
print(hash("kutya"))
print(hash("kutyb"))
print(hash("mutya"))
print(hash("kutya, macska, kutya, macska, akármi, valami"))
dict)Bejárható (iterable) az olyan adattípus, mely egyesével vissza tudja adni az összes értékét. Bejárásra a for ciklus használható (ezt már előbb láttuk).
Több hasznos beépített függvény van ami egyes bejárható objektumokra alkalmazható.
# ismétlés
print("kutya "*3)
print((1, 2, 3)*3)
print([1, 2, 3]*3)
# konkatenálás
(1, 2) + (2, 4, 6)
# mind igaz-e (logikai többváltozós "és")
print(all((False, True, True, True)))
print(all((0, 1, 1, 1)))
# bármelyik igaz-e (logikai többváltozós "vagy")
any((0, 1, 1, 1))
# "transzponlás"
zip([1, 2, 3], [11, 12, 13], ["a", "b", "c"])
list(_)
tomb_kiir(_)
A "transzponálás" hagyományos for ciklussal:
M = [1, 2, 3], [11, 12, 13], ["a", "b", "c"]
for i in range(3): # oszlop index
for row in M: # sor
print(row[i], end=' ')
print()
# összeg (számokra van, sztringekre ez nem)
sum((1, 2, 3))