Vlastnosti datových typů

V této kapitole je popsáno, jak se pracuje se základními typy Pythonu. Je to megadlouhá kapitola, tak se na to připravte.

None

Tento typ se používá v případě, že nechcete mít v proměnné žádnou hodnotu. V jazyce C odpovídá tomuto typu hodnota NULL. None má tu výhodu, že se rovná jen sám sobě (nerovná se ani nule!). Hodnotu None vrací funkce, které nic nevrací. Nepleťte si None a 'None' - to druhé je typ string!

Využít se dá při psaní funkce, která v případě, že parametry funkce neumožní správný výpočet (například dělení nulou) vrátí hodnotu None, jinak číselný výsledek (který může být právě nula). Jednoduchou kontrolou, zda je vrácená hodnota rovna None zjistíte, zda se výpočet povedl.

>>> None == None
True
>>> None == 0
False

Celé, celé dlouhé, racionální a komplexní číslo

Pro tyto typy existují standardní operátory + (plus), - (mínus), * (krát), / (děleno), // (celočíselné dělení), % (zbytek po celočíselném dělení), () (závorky), a ještě operátor ** (mocnina). Na jejich používání není nic zvláštního.

>>> 3 % 2
1
>>> 3.0**(4/2)
9.0
>>> x = 3.0**4/2
>>> print(x)
40.5
Všimněte si priorit operátorů (co má přednost, mocina nebo dělení? Násobení, nebo sčítání?). Vyzkoušejte si priority operátorů v interaktivním režimu Pythonu.
V Pythonu 2.7 a starším by výraz 3 % 2 vrátil 1L, kde L znamená typ long. Ale jak už jsem psal v minulé kapitole, od verze 3.0 už long neexistuje.

Bitové operátory

Dále jsou v Pythonu binární operátory >>, << (bitové posuvy), ~ (vlnovka = binární komplement), | (bitové or), & (bitové and), ^ (stříška = bitové xor). Tyto operátory pracují jen s celými čísly.

>>> x = 0
>>> ~x # (vlnovka = binární doplněk/komplement)
-1
>>> x = 1
>>> x << 1
2
>>> x = 1
>>> x << 2
4
Pokud chcete podrobnější informace o práci s bity, můžete se podívat na číselné soustavy popisované v tutoriálu o jazyku C.

Seznamy

Seznam (anglicky list) je uspořádané zobrazení (tj. máte zaručeno, že v jakém pořadí do něj něco uložíte, v takovém to tam zůstane), které může obsahovat jakékoliv jiné datové typy.

Uvozuje se hranatými závorkami a k jednotlivým položkám se přistupuje pomocí indexů, obdobně jako u řetězců.

V jiných programovacích jazycích má list nejblíže k poli (array), do kterého se může ukládat libovolný typ (znáte z PHP).
>>> x= [3, "ahoj", None]
>>>print(x[1])
ahoj
>>> print(x[1:])
['ahoj', None]
>>> print(x[:-1])
[3, 'ahoj']

Hlavní výhodou seznamu, oproti n-ticím (viz níže) je, že jej můžete měnit příkazem del, přiřazením, nebo pomocí vlastních metod.

Seznam lze násobit podobně jako řetězce nebo n-tice (viz níže).

  1. >>> x= 3*x
  2. >>> print(x)
  3. [3, 'ahoj', None, 3, 'ahoj', None, 3, 'ahoj', None]
  4. >>> del x[3:6] # smaže prostřední trojici
  5. >>> print(x)
  6. [3, 'ahoj', None, 3, 'ahoj', None]
  7. >>> x[3:] = ['1 hodnota misto tri'] # smaže vše za třetí položkou až do konce a vloží novou hodnotu
  8. >>> print(x)
  9. [3, 'ahoj', None, '1 hodnota misto tri']
Se seznamy, n-ticemi a řetězci lze používat tzv. slice. To je způsob, jakým lze přistupovat k větší části seznamu (n-tice, řetězce), než k jedné položce pomocí indexu, jak je běžné v jiných programovacích jazycích.
Protože nejsou seznamy neměnné, můžete použít slice i na jejich modifikaci (viz v příkladu řádky 4 a 7).

Metody

Seznam má metody, což jsou funkce implementované uvnitř seznamu, které pracují s objekty uloženými v seznamu. (Vlastně všechny objekty v Pythonu mají nějaké metody).
Volají se přes tzv. tečkovou notaci. Tj. napíše se jméno proměnné typu seznam, tečka a jméno metody s případnými parametry v závorkách.
Všimněte si, že u metod je nutné psát na konci závorky (), i když jim nepředáváte žádný argument.

Některé metody seznamu:

  • append(x) k seznamu připojí objekt x.
  • count(x) vrací počet položek v seznamu odpovídající x.
  • index(x) vrací nejmenší index odpovídající položce x, nebo vyvolá výjimku (výjimky probereme později).
  • insert(i, x) do seznamu na index i vloží objekt x (totéž co seznam[i:i] = x).
  • reverse() obrátí položky v seznamu.
  • pop(i) odebere i-tý prvek ze seznamu a vrátí jej jako svou návratovou hodnotu. Pokud i neuvedete, vrátí poslední prvek ze seznamu.
  • sort() tato metoda seznam setřídí.
>>> # Následující příklad funguje jen Pythonu verze 2.7 a starším
>>> # Python od verze 3.0 neumožňuje porovnávat různé datové typy
>>> # Proto funkce sort vyhodí v Pythonu 3.0 výjimku TypeError
>>> x=3*[3, 'ahoj', None]
>>> x.sort()
>>> print(x)
[None, None, None, 3, 3, 3, 'ahoj', 'ahoj', 'ahoj']
>>> # Následující příklad funguje v Pythonu 3.0, protože seznam x
>>> # obsahuje jen hodnoty stejného typu (jen čísla)
>>> x = [3, 5, 1, 44, -7, 0]
>>> x.sort()
>>> x
[-7, 0, 1, 3, 5, 44]
Všechny metody seznamu zjistíte příkazem dir([]).

N-tice

N-tice (anglicky tuple) je podobná seznamu. N-tice je však neměnitelná (immutable).

Uvozuje se kulatými závorkami. Chcete-li deklarovat n-tici s jedním prvkem, musíte uvést za prvek čárku, jinak by takový výraz byl vyhodnocen jako objekt v závorce a ne n-tice s jedním objektem!

>>> x = ()
>>> type(x)
<class 'tuple'>
>>> x = (1)
>>> type(x)
<class 'int'>
>>> x = (1,)
>>> type(x)
<class 'tuple'>

Pokud použijete několik výrazů oddělených od sebe čárkou, jsou automaticky vyhodnoceny Pythonem jako n-tice a podle toho se chovají (závorky kolem n-tice už nejsou potřeba).

>>> x = 1, 2, "ahoj", None, 3, 4
>>> print(x[2])
ahoj
>>> print(a,c) # tisknu dvě proměnné
a 3
>>> print ((a,c)) # tisknu n-tici proměnných
('a', 3)

N-tice lze násobit podobně jako řetězce, nebo seznamy, ale nejde z nich nic mazat, nebo je měnit.

>>> x = 1, 2, "ahoj", None, 3, 4
>>> x = 2*x
>>> x
(1, 2, 'ahoj', None, 3, 4, 1, 2, 'ahoj', None, 3, 4)
>>> x[1:3]
(2, 'ahoj')
>>> x[0] = 'takt o nevyjde'
Traceback (most recent call last):
  File "<pyshell#158>", line 1, in <module>
    x[0] = 'takt o nevyjde'
TypeError: 'tuple' object does not support item assignment

Asi si říkáte, proč má Python seznamy a n-tice, když jsou téměř to samé. Zakopaný pse je právě v té neměnnosti n-tice. Ta je vyžadována například pro klíče slovníků (viz dále). Takže n-tici můžete použít jako klíč slovníku, ale seznam ne.

K převodu mezi seznamem a n-ticí můžete využít funkce list() a tuple().

>>> list((1,2,3))
[1, 2, 3]
>>> tuple([1,2,3])
(1, 2, 3)

Slovníky

Slovník (anglicky dict), někdy též nazývaný asociativní pole, je datová struktura, která se může indexovat jakýmikoliv hodnotamy libovolných neměnitelných typů (takže ne seznamem, ale n-ticí ano).

Slovník je uvozen špičatými závorkami {} a jednotlivé položky se deklarují ve tvaru index : hodnota. K jednotlivým hodnotám se přistupuje přes indexy. Klíče a hodnoty nelze zaměňovat.

>>> x={}
>>> x={"klic": "hodnota", "none": None}
>>> print(x["klic"])
hodnota
>>> print(x["hodnota"])
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
KeyError: hodnota
>>> x["novy_klic"] = "nova_hodnota"
>>> print(x)
{'klic': 'hodnota', 'novy_klic': 'nova_hodnota', 'none': None}
>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'jack': 4098, 'guido': 4127}
>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'jack': 4098, 'guido': 4127}

Všimněte si, že hodnoty ve slovníku nejsou uspořádány podle toho, jak byli do slovníku vloženy. Slovník není uspořádaná množina, na pořadí hodnot ve slovníku se nemůžete nikdy spolehnout.

Klíče slovníku musí být neměnné objekty, takže např. seznam nemůže být kličem, ale n-tice ano.

>>> slovnik = {[0,1,2]:'hodnota'}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>> slovnik = {(0,1,2):'hodnota'}
>>> slovnik[(1,0,2)] ='druha hodnota'
>>> slovnik
{(0, 1, 2): 'hodnota', (1, 0, 2): 'druha hodnota'}

Metody

Některé metody slovníku:

  • keys() vrátí všechny klíče ze slovníku
  • values() vrátí všechny hodnoty ze slovníku
  • has_key(x) vrací True, pokud je x klíčem ve slovníku, jinak False.
V Pythonu verze 3.0 byla odstraněna metoda has_key. Místo ní můžete použít operátor in.
>>> x = {"jedna" : "one", "dva" : "two", "tři" : "three"}
>>> for i in x.keys():
        print(i,end=" ")

       
jedna tři dva
>>> "two" in x # operátor in hledá klíče, ne hodnoty
False
>>> "dva" in x
True

Chcete-li odstranit z asociativního pole nějaký záznam, použijte příkaz del takto:

>>> del x["dva"]
>>> x
{'jedna': 'one', 'tři': 'three'}

Set

Set je neuspořádaná množina unikátních hodnot. Set má také definované některé matematické operace s množinami

>>> ovoce = {'jablko','hruska'}
>>> ovoce.add('meloun')
>>> ovoce
set(['hruska', 'jablko', 'meloun'])
>>> ovoce.add('jablko')          # jablko uz v setu je, proto se znova neprida
>>> ovoce
set(['hruska', 'jablko', 'meloun'])
>>> zelenina = set(['mrkev','celer','redkvicka','celer','celer'])
>>> zelenina
set(['mrkev', 'celer', 'redkvicka'])
>>> ovoceazelenina = ovoce | zelenina
>>> ovoceazelenina
set(['hruska', 'jablko', 'mrkev', 'meloun', 'redkvicka', 'celer'])
>>> ovoceazelenina - ovoce
set(['mrkev', 'celer', 'redkvicka'])
>>> ovoceazelenina & ovoce
set(['hruska', 'jablko', 'meloun'])
>>> ovoce ^ {'jablko','pomeranc'}
set(['hruska', 'meloun', 'pomeranc'])

Řetězce

Řetězce se zapisují pomocí jednoduchých nebo dvojitých uvozovek. Oboje je ekvivalentní. Pokud je řetězec uvozen dvojitými uvozovkami, pak je jednoduchá uvozovka chápána jako obyčejný znak a naopak (uvnitř řetězce se nemusí před uvozovkou používat zpětné lomítko \' resp. \").

>>> type("hello 'world'")
<class 'str'>
>>> type('hello "world"')
<class 'str'>
>>> print("hello \"world\"")
hello "world"

Řetězec může být uvozen i 3 uvozovkami (dvojitými nebo jednoduchými). potom se za konec řetězce pokládá jen sekvence 3. uvozovek (apostrfů) a můžete řetězec psát i na několik řádek.

>>> x = """veta plna "uvozovek" a 'uvozovek'''"""
>>> print(x)
veta plna "uvozovek" a 'uvozovek'''
>>> x = '''Věta napsaná
           na několika řádcích. Všiměte si, že na mezerách
na začátku řádek záleží!'
''
>>> print(x)
Věta napsaná
           na několika řádcích. Všiměte si, že na mezerách
na začátku řádek záleží!
V Pythonu byste hledaly typ pro znak (char) marně. Namísto toho se používá řetězec s jedním znakem (řetězec délky 1).

V řetězcích je možné používat speciální znaky podobně jako v jazyce C. Například \n znamená další řádek, \\ se píše místo zpětného lomítka, \' je uvozovka, \" je dvojitá uvozovka, \t tabulátor atd.

>>> print('pozor na uvozovky\t\'!\'\n\n\n')
pozor na uvozovky       '
!'



>>>

Pokud nechcete aby se speciální znaky interprtovali, napište na začátek řetězce znak r (bez mezery).

>>> print(r'pozor na uvozovky\t\'!\'\n\n\n')
pozor na uvozovky\t\'
!\'\n\n\n

Řetězce lze sčítat a násobit. Pokud zasebe napíšete dva řetězcové literály, pak se spojí v jeden. Ale musí to být fakt řetězcové literály, pokud takhle zapíšete např. literál a funkci, která vrací řetězec, nebo proměnnou tak to nefunguje.

>>> x = 'abc'
>>> x = x + " " + x
>>> print(x)
abc abc
>>> 5 * "X"
'XXXXX'
>>> print("hello" " " "world")
hello world
>>> print("hello " x)
  File "<stdin>", line 1
    print("hello " x)
                   ^
SyntaxError: invalid syntax

Slice

Slice (česky řez, nebo taky kus, plátek …) je způsob, jak se dá označit část řetězce, seznamu nebo n-tice.

K jednotlivým položkám se dá přistupovat pomocí operátoru [] (hranaté závorky), do kterých se píše index položky, kterou chcete získat.
První znak má index 0, druhý 1 atd. Poslední znak se dá indexovat číslem -1, předposlední -2 atd.

Slice také používá hranaté závorky, ale uvnitř není index, ale dvojtečkou oddělená dvojice indexů, která označuje začátek a konec rozsahu, který chceme získat.

Indexu před i za dvojtečkou se může ve slice vynechat, pak výběr začne od začátku, resp. pokračuje do konce. V extrémním případě, kdy se vynechají oba indexy, vybere se všechno.

>>> x = '12345'
>>> x[0]
'1'
>>> x[4]
'5'
>>> x[-1]
'5'
>>> x[0:2]
'12'
>>> x[2:]
'345'
>>> x[2:-2]
'3'
>>> x[1:-2]
23
>>> x[:]
'12345'
Slice

U slovníků, které jsou „mutable“, se dají slice využít k modifikaci vybrané části slovníku.

>>> x = [1, 2, 3, 4, 5]
>>> x[1:3] = '1 až 3' # v tomto případě se bere text jako n-tice znaků
>>> x
[1, '1', ' ', 'a', 'ž', ' ', '3', 4, 5]
>>> del x[1:7]
>>> x
[1, 4, 5]
>>> x[2] = "Hello World"
>>> x
[1, 4, 'Hello World']
>>> x[1:1] = "Hello World", # díky čárce na konci je "Hello World" položka n-tice
>>> x
[1, 'Hello World', 4, 'Hello World']

Formátování

Python verze 3 zavedl nový způsob pro formátování řetězců. Starý způsob lze stále použít, ale je deprecated a v budoucích verzích (nejspíš ale za dlouho) bude odstraněn. Proto byste měli používat spíše ten nový způsob.

Po staru

S řetězci lze použít přetížený operátor % (který se normálně používá na zjištění zbytku po dělení).

K formátování se používají sekvence začínající taky procenterm, téměř stejně jako v jazyce C. Do těchto sekvencí se dosazují hodnoty pomocí n-tice.

>>> x = 'cislo %f a retezec %s' % (4, '4')
>>> print(x)
cislo 4.0000 a retezec 4
>>> x = 'cislo %i a retezec "%s"' % (4, x)
>>> print(x)
cislo 4 a retezec "cislo 4.0000 a retezec 4"

Za výraz %i nebo %d se dosazuje celé číslo, za %s řetězec, za %f racionální číslo (číslo s desetinnou čárkou) atd.

Na dalším příkladě je vidět, jak můžete pomoci % sekvence ovlivnit délku výstupu.

>>> 'retezec %20s retezec' % 'a'
'retezec                    a retezec'
>>> 'retezec %-20s retezec' % 'a'
'retezec a                    retezec'
>>> 'retezec %2d retezec' % 4
'retezec  4 retezec'
>>> 'retezec %05d retezec' % 4 #délka 5 znaků, doplněno nulami
'retezec 00004 retezec'
>>> 'retezec %-10.2f retezec' % 4 # délka 10 znaků, 2 desetinná místa
'retezec 4.00       retezec'

Poslední vymožeností operátoru % je v použití slovníku. Za % lze uvést do kulatých závorek jméno klíče a tím zajistit přiřazení správné hodnoty ze slovníku.

>>> slovnik = {'text':'abcdefg', 'cislo':123, 'cislo2':456}
>>> 'tady je text "%(text)s" a tady cislo %(cislo2)i' % slovnik
'tady je text "abcdefg" a tady cislo 456'

Po novu

Od verze 3.0 přibila řetězcům metoda format().
Ta nahradí v řetězci {} svými argumenty.
Do složených závorek je možné napsat index argumentu, kterým se mají závorky nahradit.

>>> print("{ }!".format("Hello",'world'));
Hello world!
>>> print("{1} {0} {1}!".format("baby","go"));
go baby go!

Pokud předáte argumenty metodě format() pojmenované, může te se na jména odkazovat místo indexů. Oba způsoby se dají míchat

>>> print("{prikaz} {0} {prikaz}!".format("baby",prikaz="go"));
go baby go!

Za index nebo jméno argumentu můžete napsat dvojtečku a formátování výstupu, obdobně jako jsem popisoval jak se to dělá po staru.
Všiměte si, že místo mínus se k zarovnání do leva používá závorka <.

>>> print("{vlevo:<10.1f} => {0:10.0f}".format(3/4,vlevo=3/4));
0.8        =>          1

A jako poslední ukázku si dovolím použít příklad z oficiálního tutoriálu, který ukazuje, jak můžete využít slovníky pro předání argumentů metodě format().

>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '
...       'Dcab: {0[Dcab]:d}'.format(table))
Jack: 4098; Sjoerd: 4127; Dcab: 8637678
>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print('Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: {Dcab:d}}'.format(**table))
Jack: 4098; Sjoerd: 4127; Dcab: 8637678
Význam předávání argumentu funkci s dvěma hvězdičkama na začátku (**table) je vysvětleno v kapitole Vytváření funkcí – Rozbalování argumentů.

Podrobný popis formátování najdete v dokumentaci. Dočtete se tam například, že typ s, nebo neuvedení typu formátu se bere jako řetězec, c jako znak (takže celé číslo se zkonvertuje na odpovídající unicode znak), d je celé číslo, f je číslo s desetinnou čárkou. A mnohé další drobnosti.

Metody

Některé metody řetězce:

  • strip(), lstrip(), rstrip() odstraní bílé znaky ze začátku a (nebo) konce řetězce
  • endswith() vrátí True, pokud řetězec končí řetezcem předaným jako argument
  • find() hledá podřetězec v řetězci, vrací jeho index, nebo -1, když jej nenajde
>>> " adfasdf ".rstrip()
' adfasdf'
>>> " adfasdf ".lstrip()
'adfasdf '
>>> " adfasdf ".strip()
'adfasdf'
>>> "soubor.txt".endswith(".txt")
True
>>> "soubor.txt".find(".txt")
6

Všechny metody si můžete, jako vždy, vytisknout příkazem dir("").

Komentář Hlášení chyby
Vytvořeno: 11.9.2005
Naposledy upraveno: 30.8.2015
Tato stánka používá ke svému běhu cookies, díky kterým je možné monitorovat, co tu provádíte (ne že bych to bez cookies nezvládl). Také vás tu bude špehovat google analytics. Jestli si myslíte, že je to problém, vypněte si cookies ve vašem prohlížeči, nebo odejděte a už se nevracejte :-). Prohlížením tohoto webu souhlasíte s používáním cookies. Dozvědět se více..