Rendezett sorozat (tuple)

Már megismerkedtünk a karakterláncokkal (sztringekkel) és listákkal, mint összetettebb adatszerkezetekkel. A rendezett sorozat vagy tuple megadása kerek zárójelek közt vesszőkkel elválasztva, vagy a tuple() függvénnyel adható meg:

In [1]:
t = (1, 5, 6, 2, 1)
print t[2]
type(t)

6
Out[1]:
tuple
In [2]:
l = [1, 2, 3]
t = tuple(l)
print t

(1, 2, 3)
In [3]:
for e in t:
    print e

1
2
3
In [4]:
t[1] = 4

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-4-141c76cb54a2> in <module>()
----> 1 t[1] = 4

TypeError: 'tuple' object does not support item assignment

Bizonyos helyzetekben a zárójel el is hagyható:

In [5]:
x = 2, 3, 4
print x

(2, 3, 4)
In [6]:
x, y = 2, 3
print x
print y

2
3

Változtatható és nem változtatható adatszerkezetek

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:

In [7]:
s = "lelet"
print s[2]
s = "lehet"

l
In [8]:
for e in s:
    print e,

l e h e t
In [9]:
s[2] = "l"

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-9-335b26526d8f> in <module>()
----> 1 s[2] = "l"

TypeError: 'str' object does not support item assignment

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 [10]:
d = {"kutya": 5}
type(d)
Out[10]:
dict

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

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

Szótárba új elemet úgy vehetünk fel, ha egy új kulcshoz hozzárendelünk egy értéket:

In [12]:
print d

{'macska': [1, 5], 'kutya': 5}

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

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

{(1, 5): 'macska', 5: 7, 'macska': [1, 5], 'kutya': 5}
{(1, 5): 'sajt', 5: 7, 'macska': [1, 5], 'kutya': 5}

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

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

(1, 5) sajt
5 7
macska [1, 5]
kutya 5

A szótárak elemeinek 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. Ezeket a hash-értékeket használja az elemek gyors eléréséhez. A részletek ismertetése nélkül néhány hash érték, ami lekérhető a hash() függvénnyel:

In [15]:
print hash((1, 5))
print hash(5), hash(0), hash(False), hash(True)
print hash("kutya")
print hash("kutyb")
print hash("kutya, macska, kutya, macska, akármi, valami")

3713081631939823281
5 0 0 1
7736109777944507559
7736109777944507556
105194640156580037

Gyűjteményes adattípusok bejárása, függvényei

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ó.

In [16]:
print "kutya "*3
print (1, 2, 3)*3
print [1, 2, 3]*3

kutya kutya kutya 
(1, 2, 3, 1, 2, 3, 1, 2, 3)
[1, 2, 3, 1, 2, 3, 1, 2, 3]
In [17]:
(1, 2) + (2, 4, 6)
Out[17]:
(1, 2, 2, 4, 6)
In [18]:
all((0, 1, 1, 1))
Out[18]:
False
In [19]:
any((0, 1, 1, 1))
Out[19]:
True
In [20]:
zip((1, 2, 3), (11, 12, 13))
Out[20]:
[(1, 11), (2, 12), (3, 13)]
In [21]:
sum((1, 2, 3))
Out[21]:
6

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

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

In [22]:
x = 6

def fv1():
    x = 0
    
print x

fv1()

print x

6
6

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 [23]:
x = 6

def fv1():
    print x

fv1()

6

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

In [24]:
x = 6

def fv1():
    global x
    x = 0

print x

fv1()

print x

6
0

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 [25]:
def fv1():
    w = 6
    print w
    
def fv2():
    print w
    
fv1()
fv2()

6

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-25-c0f1e3b0274f> in <module>()
      7 
      8 fv1()
----> 9 fv2()

<ipython-input-25-c0f1e3b0274f> in fv2()
      4 
      5 def fv2():
----> 6     print w
      7 
      8 fv1()

NameError: global name 'w' is not defined
  • a globális változók használatát kerüljük összetettebb programok esetén
  • ha mégis hasznos lenne, azt inkább csak konstansokra használjuk (szokás ezeket csupa nagy betűvel elnevezni), ilyenkor azonban a global kulcsszó használata szükségtelen (a Pythonban nincs konstans típus, mi gondoskodunk róla, hogy a változó konstans legyen)
In [ ]: