Változtatható, nem változtatható adatszerkezetek

Már megismerkedtünk a stringekkel és listákkal, mint összetettebb adatszerkezetek. Most lássunk egy újat, a tuple-t:

In [ ]:
t = (1, 5, 6, 2, 1)
print t[2]
In [ ]:
for e in t:
    print e
In [ ]:
t[1] = 4

Amint látjátok teljesen úgy mûködnek, mint a listák, azzal az egy kivétellel, hogy nem változtathatók az elemei. Ha létrehoztunk valahogy egy tuple-t, akkor már csak úgy változtathatjuk meg az elemeit, ha újra létrehozzuk, hasonlóan, mint a stringek:

In [ ]:
s = "kutya"
print s[2]
s = "macska"
In [ ]:
for e in s:
    print e
In [ ]:
s[2] = "n"

Szótárak

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:

In [ ]:
d = {"kutya": 5}

Értékként bármilyen adattípus szerepelhet, nem kell megváltoztathatatlannak lennie:

In [ ]:
d["macska"] = [1, 5]

Amint látjátok szótárba új elemet egyszerûen úgy vehetünk fel, ha egy új kulcshoz hozzárendelünk egy értéket:

In [ ]:
print d

Egy szótáron belül több féle kulcs is lehet:

In [ ]:
d[5] = 7
d[(1, 5)] = "macska"
print d
d[(1, 5)] = "sajt"
print d

A szótár kulcsai bejárhatók egy for ciklussal:

In [ ]:
for kulcs in d:
    print kulcs, d[kulcs]

A szótárak elemein nincs rendezés, így az elemek sorrendje véletlenszerûnek tûnhet. A háttérben a szótárak tárolási mechanizmusa áll.

A szótárak úgynevezett hash függvényt alkalmaznak, hogy a kulcsokat leképezzék egy véges halmazra (pl egész számok egy intervallumon). Ezeket a leképezett értékeket használja utána, hogy gyorsan elérhesse az elemeket. Ebbe mélyebben nem megyünk bele, de érdekességként a hash értékeket lekérhetjük a hash függvénnyel:

In [ ]:
print hash((1, 5))
print hash(5)
print hash("macska")
print hash("macskb")
print hash("kutya")

Lokális és globális változók

Tekintsük az alábbi kódot, mit ír ki eredményül?

In [ ]:
x = 6

def fv1():
    x = 0
    
print x

fv1()

print x

A fv1-ben használt x változó nem ugyanaz, mint a kód legelején használt. Amikor egy függvényen belül vagyunk, akkor minden külsõ változót csak értékként tudunk elérni, de megváltoztatni csak úgy nem tudunk, helyette ilyenkor egy lokális változót hozunk létre ugyanazzal a névvel, mely csak ebben a függvényben él.

In [ ]:
x = 6

def fv1():
    print x

fv1()

Megmondhatjuk a függvénynek, hogy mi a külsõ globális változót szeretnénk használni a global kulcsszóval:

In [ ]:
x = 6

def fv1():
    global x
    x = 0

print x

fv1()

print x

Tehát a változók, melyeket a függvényekben hozunk létre csak lokálisak és kívül, vagy más függvényekben nem fognak látszani:

In [ ]:
def fv1():
    y = 6
    
def fv2():
    print y
    
fv1()
fv2()

Gyakorlás

In [ ]: