Subsections


5. Adatstruktúrák

Ez a fejezet az eddig tanultakból pár dolgot részletesebben is leír, és pár új dolgot is megmutat.


5.1 Még több dolog a listákról

A lista adattípusnak a már megismerteken kívül több eljárása (method) is van. Az összes eljárás ismertetése:

append( x)
Egy elemet hozzáad a lista végéhez; megegyezik az a[len(a):] = [x] utasítással.

extend( L)
A lista végéhez hozzáfűzi az L listát (mindegyik elemét egyenként); ugyanaz, mint az a[len(a):] = L.

insert( i, x)

Beszúr egy elemet az adott helyre. Az első argumentum az elem indexe, amely elé beszúrjuk, így a.insert(0, x) a lista elejére szúr be, és az a.insert(len(a), x) ugyanazt jelenti mint az a.append(x).

remove( x)

Eltávolítja a legelső olyan elemet a listából, amelynek értéke x. Hiba, ha nincs ilyen.

pop( [i])

Eltávolítja az adott helyen lévő elemet a listából, és visszaadja az értékét. Ha nem adtunk meg indexet, akkor az a.pop() az utolsó elemmel tér vissza. (Ekkor is eltávolítja az elemet.) (A függvény-argumentum megadásánál használt szögletes zárójel azt jelenti, hogy a paraméter megadása tetszőleges, és nem azt, hogy a [] jeleket be kell gépelni az adott helyen. Ezzel a jelöléssel gyakran találkozhatsz a Python Standard Library-ban (Szabványos Python könyvtárban))

index( x)

Visszatér az első olyan elem indexével, aminek az értéke x. Hiba, ha nincs ilyen.

count( x)
Visszaadja x előfordulásának a számát a listában.

sort( )
Rendezi a lista elemeit. A rendezett lista az eredeti listába kerül.

reverse( )
Megfordítja az elemek sorrendjét a listában - szintén az eredeti lista módosul.

Egy példa, amely tartalmazza a legtöbb eljárást:

>>> a = [66.25, 333, 333, 1, 1234.5]
>>> print a.count(333), a.count(66.25), a.count('x')
2 1 0
>>> a.insert(2, -1)
>>> a.append(333)
>>> a
[66.25, 333, -1, 333, 1, 1234.5, 333]
>>> a.index(333)
1
>>> a.remove(333)
>>> a
[66.25, -1, 333, 1, 1234.5, 333]
>>> a.reverse()
>>> a
[333, 1234.5, 1, 333, -1, 66.25]
>>> a.sort()
>>> a
[-1, 1, 66.25, 333, 333, 1234.5]


5.1.1 Lista használata veremként

A lista eljárásai megkönnyítik a lista veremként (stack) történő használatát ahol az utolsó lerakott elemet vesszük ki először (,,utoljára be, először ki'', LIFO). Ahhoz, hogy a verem tetejére egy elemet adjunk, használjuk az append() utasítást.

A lista legelső/legfelső elemének kivételéhez használjuk a pop() utasítást mindenféle index nélkül. Például:

>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]


5.1.2 A Listák használata sorként (queue)

A listát használhatjuk úgy is mint egy sort, ahol az első hozzáadott elemet vesszük ki először (``first-in, first-out'', FIFO). Ahhoz, hogy elemet hozzáadjunk a sor végéhez, használjuk az append() utasítást. A sor első elemét visszakaphatjuk a pop() utasítással, ha az argumentuma 0. Például:

>>> sor = ["Maca", "János", "Mihály"]
>>> sor.append("Teri")           # Teri megérkezett
>>> sor.append("Gergely")          # Gergely megérkezett
>>> sor.pop(0)
'Maca'
>>> sor.pop(0)
'János'
>>> sor
['Mihály', 'Teri', 'Gergely']


5.1.3 Eszközök a funkcionális programozáshoz

Három olyan beépített függvényünk van, amelyek nagyon hasznosak a listáknál - ezek a filter(), map(), és a reduce().

A "filter(függvény, sorozat)" egy - lehetőség szerint azonos típusú - sorozattal tér vissza, mely a sorozatnak azokat az elemeit tartalmazza, amelyekre függvény(elem) igaz. Például a következő módon szűrhetjük ki a 3-mal és 2-vel nem osztható számokat:

>>> def f(x): return x % 2 != 0 and x % 3 != 0
...
>>> filter(f, range(2, 25))
[5, 7, 11, 13, 17, 19, 23]

A "map(függvény, sorozat)" kiszámolja a függvény(elem) értéket a sorozat minden elemére és az eredmények listájával tér vissza. Például így számolhatjuk ki az első néhány köbszámot:

>>> def cube(x): return x*x*x
...
>>> map(cube, range(1, 11))
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]

Egynél több sorozatot is feldolgozhatunk; a függvénynek ekkor annyi argumentumának kell lennie, ahány sorozat van. Ekkor a függvényt az egymáshoz tartozó értékpárokkal hívja meg a Python (vagy None-t ad, ha valamelyik sorozat rövidebb a másiknál). Ha a függvény helyére None-t írunk, akkor a függvény a saját argumentumait adja vissza.

>>> seq = range(8)
>>> def add(x, y): return x+y
...
>>> map(add, seq, seq)
[0, 2, 4, 6, 8, 10, 12, 14]

A két esetet összevetve láthatjuk, hogy a "map(None, lista1, lista2)" elegáns módja annak, hogy két listát párok listájává alakítsunk. Például:

>>> sor = range(8)
>>> def negyzet(x): return x*x
...
>>> map(None, seq, map(negyzet, seq))
[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25), (6, 36), (7, 49)]

A "reduce(függv, sorozat)" egyetlen értékkel tér vissza, melyet úgy kapunk, hogy a bináris, kétváltozós függv függvényt meghívjuk a sorozat első két elemével, majd az eredménnyel és a következő elemmel, és így tovább. Például az 1-től 10-ig terjedő egész számokat így adhatjuk össze:

>>> def add(x,y): return x+y
...
>>> reduce(add, range(1, 11))
55

Ha csak egy érték van a sorozatban, akkor azt az értéket kapjuk; ha a sorozat üres, kivételdobás történik.

A harmadik argumentum használatával megadhatjuk a kezdőértéket. Ekkor úgy működik, mintha a sorozat legelején ez az érték állna. Ekkor tehát egy üres sorozat a kezdeti értéket adja vissza. Például:

>>> def sum(seq):
...     def add(x,y): return x+y
...     return reduce(add, seq, 0)
... 
>>> sum(range(1, 11))
55
>>> sum([])
0

Ne használd a példában definiált sum() függvényt: mivel számok összegzésére gyakran van igény, a beépített sum(sequence) függvényt használjuk erre, amely pontosan ugyanúgy működik, mint a fenti példában definiált függvény. New in version 2.3.

5.1.4 A listák magas szintű használata

Ha megértjük, hogyan működnek a listák, akkor rövid és átlátható programokat készíthetünk listafeldolgozásra a map(), filter() vagy lambda függvények használata és az ezt követő újrarendezés nélkül is. Az eredményként kapott listadefiníció gyakran világosabb, mintha a beépített eljárásokkal kaptuk volna. Minden magas fokú listakezelés így épül fel: a kifejezést egy for ág követi, ezt pedig nulla vagy több for vagy if ág. Az eredmény egy olyan lista, amely a for és if ágak alapján a kifejezés kiértékelésével keletkezik. Ha a kifejezés tuple típust eredményez, akkor zárójelbe kell tenni a kifejezést.

>>> freshfruit = ['  banana', '  loganberry ', 'passion fruit  ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']
>>> vec = [2, 4, 6]
>>> [3*x for x in vec]
[6, 12, 18]
>>> [3*x for x in vec if x > 3]
[12, 18]
>>> [3*x for x in vec if x < 2]
[]
>>> [{x: x**2} for x in vec]
[{2: 4}, {4: 16}, {6: 36}]
>>> [[x,x**2] for x in vec]
[[2, 4], [4, 16], [6, 36]]
>>> [x, x**2 for x in vec]	# hiba - a tuple típus zárójelet kíván
  File "<stdin>", line 1
    [x, x**2 for x in vec]
               ^
SyntaxError: invalid syntax
>>> [(x, x**2) for x in vec]
[(2, 4), (4, 16), (6, 36)]
>>> vec1 = [2, 4, 6]
>>> vec2 = [4, 3, -9]
>>> [x*y for x in vec1 for y in vec2]
[8, 6, -18, 16, 12, -36, 24, 18, -54]
>>> [x+y for x in vec1 for y in vec2]
[6, 5, -7, 8, 7, -5, 10, 9, -3]

A magasfokú listakezelés a map() eljárásnál sokkal rugalmasabb, és egynél több argumentummal rendelkező függvényekre, valamint beágyazott (nested) függvényekre is alkalmazható:

>>> [str(round(355/113.0, i)) for i in range(1,6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']


5.2 A del utasítás

Egy listaelem eltávolításának egyik módja, hogy az elem értéke helyett az indexét adjuk meg: ez a del utasítás. Ez arra is használható, hogy szeleteket töröljünk a listából (amit már megtettünk ezelőtt úgy, hogy a szeletnek az üres lista értékét adtuk). Például:

>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]

A del utasítást arra is használhatjuk, hogy az egész változót töröljük:

>>> del a

A továbbiakban hibát generál, ha az a névre hivatkozunk (kivéve, ha új értéket adunk neki). Más alkalmazásával is találkozunk később a del utasításnak.


5.3 Tuplék és sorozatok

Láttuk, hogy a listáknak és a karakterláncoknak rengeteg közös tulajdonsága van, például az indexelés és a szeletek használata. Ez két Mindkettő példa a sorozat../lib/typesseq.html-adattípusra. Mivel a Python egy folyamatos fejlődésben lévő nyelv, másfajta sorozat adattípusok is hozzáadhatóak. Egy másik beépített sorozat-adattípusa a tuple5.1.

A tuple objektumokat tartalmaz vesszőkkel elválasztva, például:

>>> t = 12345, 54321, 'hello!'
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')
>>> # A tuplékat egymásba ágyazhatjuk:
... u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))

Az objektumok különböző típusúak is lehetnek. A tuple nem megváltoztatható adattípus, viszont lehetnek megváltoztatható elemei. Példa:

>>> megtanulni = ['matek', 'angol'] # Ez egy megváltoztatható lista, [] jelölés!
>>> orarendem = ('tesi', 'nyelvtan', megtanulni) # ket string elem, es egy lista a tupléban -- () jelölés!

>>> orarendem[0] = 'rajz' # az első órát át akarom írni, nem lehet
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: object doesn't support item assignment

>>> orarendem[2][0]='versek' # viszont a tuple lista elemén belül -- ami megváltoztatható típus, szabadon írhatok!

Ahogy látható, a kimeneten a tuplék mindig zárójelezve vannak, így azok egymásba ágyazva is helyesen értelmezhetők; megadhatjuk zárójelekkel és anélkül is, néha azonban feltétlenül szükségesek a zárójelek (amikor az egy nagyobb kifejezés része).

A tuple típust sokféle dologra felhasználhatod. Például: (x, y) koordinátapár tárolása, dolgozók rekordjai egy adatbázisban...A tuplék a karakterláncokhoz hasonlóan megváltoztathatatlanok: nem adhatunk értéket egyetlen elemének (további hasonlóságok vannak a szeleteléssel és az összefűzéssel kapcsolatban is). Létrehozható olyan tuple, amely megváltoztatható elemeket - például tömböket - tartalmaz.

Egy különös probléma nulla vagy egy elemet tartalmazó tuple létrehozása: a nyelv szintaxisa lehetővé teszi ezt. Az üres zárojellel hozható létre a nulla elemű; az egy elemű pedig az érték után tett vesszővel (nem elég, ha az értéket zárójelbe tesszük). Csúnya, de hatékony. Például:

>>> ures = ()
>>> egyszeres = 'hello',    # <-- figyeljünk a vesszőre a végén
>>> len(ures)
0
>>> len(egyszeres)
1
>>> egyszeres
('hello',)

A t = 12345, 54321, 'hello!' értékadás egy példa a tuple változó feltöltésére5.2 és újbóli a 12345, 54321 és 'hello!' különböző objektumok értékei egy tupléba kerülnek. A fordított művelet is lehetséges, például:

>>> x, y, z = t

This is called, appropriately enough, sequence unpacking. Sequence unpacking requires that the list of variables on the left have the same number of elements as the length of the sequence. Note that multiple assignment is really just a combination of tuple packing and sequence unpacking!

Ezt hívják, elég helyesen, sorozat szétbontásnak. A sorozat szétbontásához az szükséges, hogy a bal oldalon annyi elem szerepeljen, ahány elem van a tupléban. Jegyezzük meg, hogy a többszörös értékadás csak egy változata a tuple lehetséges feltöltésének!

Van egy kis asszimetria itt: a különböző objektumokkal való feltöltés mindig tuplét eredményez, ugyanakkor a szétbontás minden sorozatra működik.


5.4 A halmazok (Set)

A Python a set adattípust (sets) is alaptípusként definiálja. a set: elemek rendezetlen halmaza, amelyben minden elem csak egyszer fordulhat elő. Alapvető használata: megadott elem meglétének ellenőrzése, elemek kettőzésének kiszűrése. A set objektumok támogatják az olyan matematikai műveleteket, mint az egyesítés (union), közös metszet (intersection), különbség (difference), és a szimmetrikus eltérés (symmetric difference).

Íme egy rövid bemutató:

>>> kosar = ['alma', 'narancs', 'alma', 'korte', 'narancs', 'banan']
>>> gyumolcsok = set(kosar)            # set létrehozása egyedi elemekkel
>>> gyumolcsok
set(['narancs', 'korte', 'alma', 'banan'])
>>> 'narancs' in gyumolcsok            # gyors ellenőrzés: benne van-e
True
>>> 'kakukkfu' in gyumolcsok
False

>>> # Példa: set műveletek két szó egyedi betűin
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  # 'a'-nak egyedi elemei
set(['a', 'r', 'b', 'c', 'd'])
>>> a - b                              # 'a'-ban megvan, b-ből hiányzik
set(['r', 'd', 'b'])
>>> a | b                              # vagy 'a'-ban, vagy 'b'-ben megvan
set(['a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'])
>>> a & b                              # 'a'-ban és 'b'-ben is megvan
set(['a', 'c'])
>>> a ^ b                              # vagy 'a'-ban, vagy 'b'-ben megvan, de 
				       # egyszerre mindkettőben nem 
set(['r', 'd', 'b', 'm', 'z', 'l'])


5.5 Szótárak

Egy másik hasznos adattípus a Pythonban a szótár. A szótárakat más nyelvekben ,,asszociatív tömböknek'' nevezik. Szemben a sorozatokkal - amelyek számokkal vannak indexelve - a tömböket kulcsokkal indexeljük, amely mindenféle megváltoztathatatlan típus lehet; karakterláncok és számok mindig lehetnek kulcsok. Tuplék is használhatók kulcsnak, ha csak számokat, karakterláncokat vagy tuplékat tartalmaznak; ha egy tuple megváltoztatható objektumot tartalmaz - közvetlenül vagy közvetve, akkor nem lehet kulcs.

Listát nem lehet kulcsként használni, mert annak értékei az append(), extend() eljárásokkal, valamint a szeletelő vagy indexelt értékadásokkal (helyben) módosíthatók.

Gondoljunk úgy a szótárra, mint kulcs: érték párok rendezetlen halmazára, azzal a megkötéssel, hogy a szótárban a kulcsoknak egyedieknek kell lenniük. Egy kapcsos zárójelpárral egy üres szótárat hozhatunk létre: {}. Ha a zárójelbe vesszőkkel elválasztott kulcs:érték párokból álló listát helyezünk, akkor ez belekerül a szótárba; egy szótár tartalma is ilyen módon jelenik meg a kimeneten.

A legfontosabb műveletek egy szótáron: eltárolni egy értéket egy kulccsal együtt, visszakapni egy értéket megadva a kulcsát. Lehet törölni is egy kulcs:érték párt a del-lel. Ha olyan kulccsal tárolsz egy új értéket, amilyen kulcsot már használtál, a kulcs az új értékre fog vonatkozni, a régi érték elveszik. Hiba, ha egy nemlétező kulcsra hivatkozol.

A szótár objektum keys() eljárása a kulcsok listáját adja vissza véletlenszerű sorrendben (ha rendezni akarod, használd a sort() eljárást a kulcsok listájára). Ha ellenőrizni szeretnéd, vajon egy kulcs benne van-e a szótárban, használd a szótárak has_key() eljárását.

Íme egy kis példa a szótár használatára:

>>> tel = {'János': 4098, 'Simon': 4139}
>>> tel['Géza'] = 4127
>>> tel
{'Simon': 4139, 'Géza': 4127, 'János': 4098}
>>> tel['János']
4098
>>> del tel['Simon']
>>> tel['Pisti'] = 4127
>>> tel
{'Géza': 4127, 'Pisti': 4127, 'János': 4098}
>>> tel.keys()
['Géza', 'Pisti', 'János']
>>> tel.has_key('Géza')
True

A dict() konstruktor közvetlenül tuplékban tárolt kulcs-érték párok listájából is létre tudja hozni a szótárat. Ha a párok valamilyen mintát követnek, akkor lista-műveletekkel rövidebb módon is megadhatjuk a kulcs-érték listát.

>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'jack': 4098, 'guido': 4127}
>>> dict([(x, x**2) for x in (2, 4, 6)])     # use a list comprehension
{2: 4, 4: 16, 6: 36}

Later in the tutorial, we will learn about Generator Expressions which are even better suited for the task of supplying key-values pairs to the dict() constructor.

Az oktató egy későbbi részben tanulni fogunk a 'Generátor kifejezésekről' (Generator Expressions), melyek még alkalmasabbak a kulcs-érték párok beillesztésére, mint a dict() konstruktor.


5.6 Ciklustechnikák

Ha végig szeretnénk menni egy szótár elemein, akkor az iteritems() eljáással lépésenként egyidőben megkapjuk a kulcsot, és a hozzá tartozó értéket.

>>> lovagok = {'Gallahad': 'a tiszta', 'Robin': 'a bátor'}
>>> for k, v in lovagok.iteritems():
...     print k, v
...
Gallahad a tiszta
Robin a bátor

Ha sorozaton megyünk végig, akkor az pozíciót jelző index értékét és a hozzá tartozó értéket egyszerre kaphatjuk meg az enumerate() eljárással.

Példa:5.3

 
>>> for i, v in enumerate(['tic', 'tac', 'toe']):
...     print i, v
...
0 tic
1 tac
2 toe

Két vagy több sorozat egyszerre történő feldolgozásához a sorozatokat a zip() függvénnyel kell párba állítani.

>>> kerdesek = ['neved', 'csoda, amit keresel', 'kedvenc szined']
>>> answers = ['Lancelot', 'A szent Gral', 'Kek']
>>> for q, a in zip(kerdesek, valaszok):
...     print 'Mi a %s?  %s.' % (q, a)
...	
Mi a neved?  It is lancelot. Lancelot.
Mi a csoda, amit keresel?  A szent Gral.
Mi a kedvenc szined?  Kek.

Egy sorozaton visszafelé haladáshoz először add meg a sorozatot, majd utána hívd meg a reversed() függvényt.

>>> for i in reversed(xrange(1,10,2)):
...     print i
...
9
7
5
3
1

Rendezett sorrendben való listázáshoz használd a sorted() függvényt, amely új, rendezett listát ad vissza, változatlanul hagyva a régi listát.

>>> kosar = ['alma', 'narancs', 'alma', 'korte', 'narancs', 'banan']
>>> for f in sorted(set(basket)):
...     print f
... 	
alma
banan
korte
narancs


5.7 Még több dolog a feltételekről

A while és az if utasításokban eddig használt feltételek egyéb műveleteket is tartalmazhatnak az összehasonlítás mellett.

Az in és not in relációk ellenőrzik, hogy az érték előfordul-e egy sorozatban. Az is és is not relációk összehasonlítják, hogy két dolog valóban azonos-e; ez csak olyan változékony dolgoknál fontos, amilyenek például a listák. Minden összehasonlító relációnak azonos precedenciája van, mely magasabb mint a számokkal végzett műveleteké.

Relációkat láncolhatunk is, például: az a < b == c megvizsgálja, hogy az a kisebb-e mint b, és ezen felül b egyenlő-e c-vel.

A relációkat összefűzhetjük and és or logikai műveletekkel is, és a reláció erdményét (vagy bármely logikai műveletét) ellentettjére változtathatjuk a not művelettel. Ezeknek mindnek kisebb precedenciájuk van, mint a relációknak, és közülük a not rendelkezik a legmagasabbal és az or a legkisebbel. Tehát az A and not B or C ugyanazt jelenti, mint az (A and (not B)) or C. Természetesen a zárójeleket használhatjuk a kívánt feltétel eléréséhez.

Az and és or logikai műveletek úgynevezett shortcat (lusta/rövid kiértékelésű) műveletek: Az argumentumaik balról jobbra fejtődnek ki, és a kifejtés rögtön megáll, mihelyt a végeredmény egyértelmű. Például: ha A és C mindkettő igaz de B hamis, akkor a A és B és C kifejezés során a C értékét a Python már nem vizsgálja. Általában a shortcut műveletek visszatérési értéke - ha általános értékeket és nem logikai értéket használunk - az utolsónak kifejtett argumantummal egyezik.

Lehetséges, hogy egy reláció vagy más logikai kifejezés értékét egy változóba rakjuk. Például:

>>> string1, string2, string3 = '', 'Trondheim', 'Hammer Dance'
>>> non_null = string1 or string2 or string3
>>> non_null
'Trondheim'

Jegyezzük meg, hogy a Pythonban - szemben a C-vel - nem lehet értékadás egy kifejezés belsejében. Lehet, hogy a C programozók morognak emiatt, de így kikerülhető egy gyakori probléma, amelyet a C programokban gyakran elkövetnek: = jelet írnak ott, ahol == kellene.


5.8 Sorozatok és más típusok összehasonlítása

Sorozat objektumokat összehasonlíthatunk másik azonos típusú objektummal. Az összehasonlítás a lexikografikai rendezést használja: először az első elemeket hasonlítja össze, ha ezek különböznek, ez meghatározza az összehasonlítás eredményét; ha egyenlőek, akkor a második elemeket hasonlítja össze, és így tovább, amíg az egyik sorozatnak vége nem lesz. Ha a két összehasonlítandó elem azonos típusú sorozat, akkor az összehasonítás rekurzívan történik. Ha a két sorozat minden eleme azonos, akkor tekinthetőek a sorozatok egyenlőeknek. Ha sz egyik sorozat a másiknak kezdő rész-sorozata, akkor a rövidebb sorozat a kisebb. A karakterláncok lexikografikai elemzésére az egyes karakterek ASCII rendezését alkalmazzuk. Néhány példa azonos típusú sorozatok összehasonlítására:

(1, 2, 3)              < (1, 2, 4)
[1, 2, 3]              < [1, 2, 4]
'ABC' < 'C' < 'Pascal' < 'Python'
(1, 2, 3, 4)           < (1, 2, 4)
(1, 2)                 < (1, 2, -1)
(1, 2, 3)             == (1.0, 2.0, 3.0)
(1, 2, ('aa', 'ab'))   < (1, 2, ('abc', 'a'), 4)

Jegyezzük meg, hogy különböző típusú objektumok összehasonlítása is szabályos. A kimenet jól meghatározott, de önkényes: a típusok a típusneveik szerint rendeződnek. Így egy lista mindig kisebb, mint egy karakterlánc, egy karakterlánc mindig kisebb, mint egy tuple, stb. 5.4Vegyes számtípusok a számértékeik szerint rendeződnek, így például 0 egyenlő 0.0-val.



Footnotes

... tuple5.1
A lista és a tuple hasonló a PHP tömb típusához - a lista egy írható tömb, a tuple egy csak olvasható tömbnek felel meg első közelítésre.
... feltöltésére5.2
Ha a változó már tartalmazott objektumokat, az összes eleme törlődik, és az új - feltöltésnél megadott elemeket tartalmazza csak
...Példa:5.3
A tic-tac-toe az amőba játék angol nyelvterületen elterjedt neve.
... stb.5.4
A különböző típusú objektumok összehasonlítási szabályai nem megbízhatóak - a Python későbbi verzióiban változhatnak.
See About this document... for information on suggesting changes.