0 dní v řadě · 0 bodů

Datové struktury · 20 min

Indexy a řezy

Vystřihneš ze seznamu nebo textu libovolný kus, otočíš ho, vybereš každý druhý prvek a přepíšeš celý úsek jedním řádkem.

Hloubka
Úkoly
Lidsky řečeno

Vezmi krejčovský metr. Čísla na něm nejsou na políčkách, ale na ryskách mezi nimi. Když chceš kus látky, řekneš „od rysky 2 po rysku 5“ a střihneš. Dostaneš tři centimetry. Řezy v Pythonu fungují stejně, a jakmile si to představíš takhle, přestanou tě mást.

Rysky místo políček

Z minulé lekce znáš index: dny[0] je první prvek. Pro řezy si čísla představ na hranicích mezi prvky.

text
rysky:   0    1    2    3    4    5    6    7
         | po | út | st | čt | pá | so | ne |
odzadu: -7   -6   -5   -4   -3   -2   -1

Řez (anglicky slice) se píše seznam[od:do] a vrátí nový seznam s tím, co leží mezi dvěma ryskami. Prvek na pozici do už v něm není. Vynecháš-li začátek, jde se od kraje. Vynecháš-li konec, jde se až na konec.

dny = ["po", "út", "st", "čt", "pá", "so", "ne"]

print(dny[0:5])
print(dny[5:7])
print(dny[:2])
print(dny[5:])
print(dny[-2:])
print(dny[1:-1])
print(len(dny[1:4]))
Výstup
['po', 'út', 'st', 'čt', 'pá']
['so', 'ne']
['po', 'út']
['so', 'ne']
['so', 'ne']
['út', 'st', 'čt', 'pá', 'so']
3

Z toho plynou dvě praktické vlastnosti. Když obě rysky leží v seznamu a počítáš je zleva, je délka řezu do - od. A a[:k] + a[k:] dá vždy celý seznam, nic se neztratí ani nezdvojí, ať je k jakékoli.

Kvíz

Co vrátí [10, 20, 30, 40, 50][1:3]?

Řez odpouští

Jednotlivý index mimo rozsah skončí chybou. Řez přesah tiše ořízne, a když nic nezbude, vrátí prázdný seznam. Hodí se to, když chceš „nejvýš pět prvků“ a nevíš, kolik jich je.

Řezy nejsou jen pro seznamy. Stejně fungují u textů, n-tic i range.

dny = ["po", "út", "st"]

print(dny[:100])
print(dny[10:20])

datum = "2026-11-18"
print(datum[:4])
print(datum[5:7])
print(datum[-2:])

print(range(10)[2:5])
Výstup
['po', 'út', 'st']
[]
2026
11
18
range(2, 5)
Úkol

Žebříček

Seznam body je seřazený od nejlepšího. Bez ručního vypisování čísel vytvoř:

  • medaile: první tři výsledky,
  • posledni_dva: poslední dva výsledky,
  • stred: všechno mezi nimi.
body = [98, 91, 85, 70, 64, 52, 40]

# doplň
Výstup

Krok: každý druhý a pozpátku

Třetí číslo v řezu je krok: seznam[od:do:krok]. Krok 2 bere každý druhý prvek. Záporný krok jde pozpátku, takže od musí být vpravo od do.

cisla = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

print(cisla[::2])
print(cisla[1::2])
print(cisla[::-1])
print(cisla[7:2:-2])

print("kobyla"[::-1])
Výstup
[0, 2, 4, 6, 8]
[1, 3, 5, 7, 9]
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
[7, 5, 3]
alybok

[::-1] je běžný způsob, jak získat otočenou kopii. Metoda reverse() otočí seznam na místě a nic nevrací, stejně jako sort.

Úkol

Palindromy

Palindrom se čte stejně zepředu i zezadu. Do seznamu palindromy vyber ze slova ta, která jsou palindromem. Velikost písmen se nepočítá, ale do výsledku ulož slovo v původní podobě.

slova = ["Kajak", "Python", "Oko", "Radar", "most"]
palindromy = []

# doplň
Výstup

Řez je kopie

Přiřazení b = a seznam nekopíruje. Vznikne jen druhé jméno pro tentýž seznam. Řez naopak vyrobí nový seznam, a a[:] je proto nejkratší způsob, jak získat kopii celého.

original = [1, 2, 3]
druhe_jmeno = original
kopie = original[:]

original.append(4)

print(druhe_jmeno)
print(kopie)

cisla = [1, 2, 2, 3]
for c in cisla[:]:
    if c == 2:
        cisla.remove(c)
print(cisla)
Výstup
[1, 2, 3, 4]
[1, 2, 3]
[1, 3]

Druhá část řeší past z minulé lekce: cyklus běží přes kopii, takže mazání v originále mu pozici nerozhodí. Co přesně se při přiřazení děje, rozebírá lekce Reference, mutabilita a kopie.

zaznamy = ["a", "b", "c", "d"]
n = 0

print(zaznamy[-n:])
print(zaznamy[len(zaznamy) - n:])
Výstup
['a', 'b', 'c', 'd']
[]

Přepsání celého úseku

Řez může stát i na levé straně přiřazení. Úsek mezi ryskami se nahradí tím, co dáš vpravo, a délka se smí změnit. Prázdný úsek [2:2] znamená vložení, prázdný seznam vpravo smazání. Mazat umí i del.

p = ["a", "b", "c", "d", "e", "f", "g"]

p[1:3] = ["X"]
print(p)

p[2:2] = ["nové", "další"]
print(p)

p[-2:] = []
print(p)

del p[::2]
print(p)
Výstup
['a', 'X', 'd', 'e', 'f', 'g']
['a', 'X', 'nové', 'další', 'd', 'e', 'f', 'g']
['a', 'X', 'nové', 'další', 'd', 'e']
['X', 'další', 'e']

Když je v řezu krok, musí počet nových prvků přesně sedět, protože Python neví, kam by přebytek dal.

c = [0, 1, 2, 3, 4, 5]

c[::2] = [9, 9, 9]
print(c)

c[::2] = [7, 7]
Výstup
[9, 1, 9, 3, 9, 5]

Texty a n-tice měnit nejdou, takže řez u nich funguje jen pro čtení.

Kvíz

Co je v a po a = [1, 2, 3, 4] a a[1:3] = []?

Okna a dávky

Dva vzory z praxe, oba stojí na řezu s proměnnými. Klouzavé okno se posouvá po datech a vyhlazuje je. Tady je průměr prodejů za tři dny:

prodeje = [12, 15, 11, 18, 20, 17, 25]
okno = 3

for i in range(len(prodeje) - okno + 1):
    kus = prodeje[i:i + okno]
    print(kus, round(sum(kus) / okno, 1))
Výstup
[12, 15, 11] 12.7
[15, 11, 18] 14.7
[11, 18, 20] 16.3
[18, 20, 17] 18.3
[20, 17, 25] 20.7

Dávky dělí data na stejně velké kusy, třeba když služba přijme najednou nejvýš sto záznamů. Pomůže krok v range a to, že řez přesah odpustí. Vyzkoušej si to sám.

Úkol

Rozděl na dávky

Rozděl polozky na kusy o velikosti velikost a ulož je do seznamu davky. Poslední dávka může být kratší. Pro zadaná data vyjde [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10]].

polozky = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
velikost = 4
davky = []

# doplň
Výstup

Čísla v řezech se dají pojmenovat. Funkce slice vyrobí řez jako hodnotu, což se hodí u textů s pevnou šířkou sloupců. Místo záhadného radek[11:16] čteš radek[UROVEN].

DATUM = slice(0, 10)
UROVEN = slice(11, 16)
ZPRAVA = slice(18, None)

log = [
    "2026-11-18 ERROR  disk je plný",
    "2026-11-19 INFO   zálohování hotovo",
]

for radek in log:
    print(radek[DATUM], radek[UROVEN].strip(), radek[ZPRAVA], sep=" / ")
Výstup
2026-11-18 / ERROR / disk je plný
2026-11-19 / INFO / zálohování hotovo
Pod kapotou · slice objekt, indices a cena kopie

a[1:5] je volání a.__getitem__(slice(1, 5, None)). Hranaté závorky přijmou i čárky a ..., jazyk jen předá objekt a význam určí typ. Na tom stojí vícerozměrné indexování v NumPy.

class Ukaz:
    def __getitem__(self, klic):
        return klic

u = Ukaz()
print(u[1:5])
print(u[::2])
print(u[1:2, ::3])
print(u[...])

print(slice(-3, None).indices(10))
print(slice(None, None, -1).indices(5))
print(list(range(*slice(None, None, -1).indices(5))))
print([0, 1, 2, 3, 4][4:-1:-1])
Výstup
slice(1, 5, None)
slice(None, None, 2)
(slice(1, 2, None), slice(None, None, 3))
Ellipsis
(7, 10, 1)
(4, -1, -1)
[4, 3, 2, 1, 0]
[]

indices(n) převede řez na konkrétní (start, stop, step) pro délku n a je určený pro range. Výsledek (4, -1, -1) ale nesmíš vrátit zpět do řezu: a[4:-1:-1] je prázdné, protože -1 tam znamená poslední prvek. Pro „až na začátek“ existuje v řezu jen None.

Další věci, které se v praxi vymstí:

  • Řez seznamu kopíruje k ukazatelů a zvyšuje čítače referencí, stojí tedy O(k) času i paměti. Smyčka while a: a = a[1:] je kvadratická. Pro čtení bez kopie máš index, reversed(a) nebo itertools.islice, ten ale prochází od začátku.
  • Kopie je mělká: vnořené seznamy zůstávají sdílené.
  • a[:] = nova mění existující objekt, takže změnu uvidí všichni, kdo na něj drží odkaz. a = nova jen přesune jméno.
  • V NumPy je řez pohled, ne kopie. Zápis do něj změní původní pole. U bytes se bez kopírování obejdeš přes memoryview.
  • s[::-1] otáčí kódové body, ne viditelné znaky. U "é" nebo emoji složených ze sekvencí se text rozpadne.
  • Od Pythonu 3.12 jsou objekty slice hashovatelné, pokud jsou hashovatelné jejich složky, takže mohou být klíčem slovníku.

Vyzkoušej si: Řezy živě

Posuvníky nastavují start, stop a krok. Vybrané prvky se podbarví a pod nimi vidíš zápis a výsledek.