Seznamy (pokračování)

Protože v Jythonu jsou všechno objekty, asi vás nepřekvapí, že i seznam je objektem, a tudíž má své metody. Seznam nejdůležitějších metod je uveden níže.

Následující metody manipulují s obsahem seznamu a jejich návratová hodnota je None, což je ekvivalent pojmenovaného "Nic", obdobně jako v Javě je null.


append(prvek_seznamu)

Připojí prvek uvedený v argumentu metody za poslední prvek seznamu.

>>> seznam = [] #Prazdny seznam
>>>
>>> seznam
[]
>>> seznam.append('prvni') #Pripoji prvek ke konci seznamu
>>> seznam
['prvni']

Ke konci seznamu je možné připojit další prvek i následujícím postupem,

seznam[len(seznam):] = [hodnota]

Podobně je možné vložit i prvek před první prvek seznamu:

seznam[:0] = [hodnota]

 

extend(seznam)

Připojí k seznamu seznam, uvedený v argumentu.

>>> s1 = [1,2,3]
>>>
>>> s2 = ['a', 'b']
>>>
>>> s1.extend(s2)
>>>
>>> s1
[1, 2, 3, 'a', 'b']

 

remove(prvek_seznamu)

Odstraní ze seznamu první výskyt objektu , který byl uveden v argumentu metody. Pokud se zadaný objekt v seznamu nevyskytuje vyvolá se výjimka ValueError.

>>> s1 = ['a', 'b', 'c', 'a', 'd']
>>> s1
['a', 'b', 'c', 'a', 'd']
>>>
>>> s1.remove('a')
>>> s1
['b', 'c', 'a', 'd']

 

insert(index, prvek_seznamu)

Vloží do seznamu objekt tak, aby platilo seznam[index] == prvek_seznamu

>>> seznam = ['a', 'c']
>>>
>>> seznam.insert(1, 'b')
>>>
>>> seznam
['a', 'b', 'c']

 

Tuple: Konstantní seznamy

Tuple (n-tice) je objekt reprezentující konstantní seznam, tj. seznam obsahující fixovanou, indexovanou množinu objektových referencí. Objekty uvnitř tuple mohou být změněny, ale kolekce odkazů na tyto objekty - tuple, je neměnitelná. Tuple je použitelné, kdykoliv potřebujeme pracovat s konstantou.

Tuple vytvoříme tak, že uzavřeme jeho čárkou oddělené prvky do kulatých závorek:

(výraz, výraz, ...)

Prázdné tuple je reprezentováno prázdnými kulatými závorkami (). Chceme-li vytvořit tuple obsahující jeden prvek, je nutné za prvkem uvést i následující čárku:

>>> t = ('prvni') #toto neni tuple
>>> t
'prvni'
>>>
>>> t = ('prvni', ) #toto tuple je, carka uvnitr je nutna
>>> t
('prvni',)
>>>
>>> t = (1, 'ahoj', ['a', 'b'])
>>>
>>> t
(1, 'ahoj', ['a', 'b'])

Jelikož tuple je seznam, je možné k němu a jeho částem přistupovat stejně jako k seznamu:

>>> t
(1, 'ahoj', ['a', 'b'])
>>> t[0]
1
>>> t[0:2]
(1, 'ahoj')
>>> t[-1]
['a', 'b']
>>> t[:]
(1, 'ahoj', ['a', 'b'])
>>> 'ahoj' in t
1
>>>

Tuple je svou povahou konstatní objekt, tudíž nelze jeho obsah měnit:

>>> t[2] = 'abc'
Traceback (innermost last):
File "<console>", line 1, in ?
TypeError: can't assign to immutable object

Ale obsah objektů, které tuple obsahuje měnit lze:

>>> t
(1, 'ahoj', ['a', 'b'])
>>>
>>> t[2][0] = 'cau'
>>> t[2][1] = 'nazdar'
>>>
>>> t
(1, 'ahoj', ['cau', 'nazdar'])

Tuple neobsahuje žádné metody, které by umožnily s tuple manipulovat.

 

Asociativní pole

Asociativní pole, pro které se také často používá anglický termín „hash", je speciální typ pole, v němž jako index slouží tuple, řetězce nebo čísla. V praxi to znamená, že máte k dispozici šikovný a silný vyhledávací mechanismus. Místo názvu „index" se zpravidla používá pojem klíč.

Literatuře zabývající se Pythonem, nebo jeho java portací Jythonem, se místo pojmu hash používá pojem dictionary. My se budeme držet termínu asociativní pole.

Na asociativní pole se můžeme také dívat jako na proměnlivou (anglicky mutable), heterogenní kolekci objektů s náhodným přístupem. V asociativním poli není vůbec zaveden pojem uspořádání. Z úhlu pohledu programátora v Javě se asociativní pole v Jythonu podobají instancím třídy java.util.HashMap.

V praxi to funguje tak, že vytváříte neuspořádanou množinu dvojic klíč : hodnota, s požadavkem, že množina klíčů musí být unikátní, tj. žádný klíč se v konkrétním asociativním poli nesmí vyskytovat dvakrát. Množina dvojic klíč : hodnota je uzavřena do složených závorek:

>>> d = {1:'jedna', 2:'dve', 3:'tri'}
>>>
>>> dict = {'jedna': 'ichi', 'dva': 'ni', 'tri': 'san'}
>>>
>>> dalsiSeznam = {'first': [1, 2, 3, 4], 'second': 0xff}
>>>
>>> jesteJeden = {'I': d, 'II': dict }
>>>
>>> d
{3: 'tri', 2: 'dve', 1: 'jedna'}
>>> dict
{'jedna': 'ichi', 'dva': 'ni', 'tri': 'san'}
>>> dalsiSeznam
{'second': 255, 'first': [1, 2, 3, 4]}
>>> jesteJeden
{'I': {3: 'tri', 2: 'dve', 1: 'jedna'}, 'II': {'jedna': 'ichi', 'dva': 'ni', 'tr
i': 'san'}}

Všimněte si, že asociativní pole si neudržují svůj obsah v pořadí, v jakém byly prvky zadány.

Prázdné asociativní pole je reprezentováno prázdnými složenými závorkami {}.

Hlavní využití asociativních polí spočívá v ukládání hodnot s nějakým klíčem a následným manipulováním nebo vyhledáváním uložené hodnoty zadáním klíče. Dvojici klíč: hodnota je možné ze seznamu odstranit pomocí příkazu del. Pokud do asociativního pole uložíte hodnotu přiřazenou klíči, který již v seznamu existuje, je původní dvojice klíč : hodnota nahrazena dvojicí novou.

Zde je malý příklad využití asociativního pole:

>>> tel = {'jirka': 123456, 'stefan': 789232, 'kotelna': 111111}
>>> len(tel)
3
>>> tel['stefan']
789232
>>>
>>> tel
{'kotelna': 111111, 'jirka': 123456, 'stefan': 789232}
>>> tel['kotelna'] = 999999
>>>
>>> tel
{'kotelna': 999999, 'jirka': 123456, 'stefan': 789232}
>>>
>>> del tel['jirka']
>>> tel
{'kotelna': 999999, 'stefan': 789232}

Všechny prvky asociativního pole lze z pole odstranit pomocí metody clear():

>>> tel
{'kotelna': 999999, 'stefan': 789232}
>>> tel.clear()
>>> tel
{}