2. Hodnoty, výrazy a příkazy

1. Hodnoty a typy objektů
2. Základní typy objektů
3. Booleovské hodnoty a výrazy
4. Změna typu
5. Jména a klíčová slova
6. Operátory a operandy
   1. Aritmetické operátory
   2. Operátory přiřazení
   3. Bitwise operátory
   4. Relační operátory
   5. Logické operátory
   6. Speciální operátory
   7. Hvězdičkové operátory
   8. Pořadí operací
   9. Podtržítka
7. Proměnné
1. Změna přiřazení
2. Aktualizace proměnné
3. Rozšířené přiřazení
8. Glosář
9. Cvičení

2.1 Hodnoty a typy objektů

Ústředním pojmem objektově orientovaného programovacího jazyka Python je objekt - coby instance programové struktury, zvané třída - viz Kap. 12.

Každý objekt (instance třídy) má jedinečnou hodnotu (value), typ (type) a identitu (ID). Typ je alternativní označení třídy, z níž byl objekt odvozen.

Hodnota je inherentní význam objektu, vyjadřující množství (např. číslo), vlastnost (např. barvu) či jedinečnost (např. textový řetězec), s nímž může být v rámci výpočtu manipulováno. Každá hodnota je nositelem nějakého typu.

Typ je název třídy, z níž byl objekt odvozen. Typ objektu vymezuje množinu podporovaných operací a rovněž definuje možné hodnoty objektu. Pokud si nejsme jisti, k jakému typu neboli třídě objekt patří, zjistíme to vestavěnou funkcí type(), jenž je součástí Pythonu:

>>> type("Hello, World!")    # Text v uvozovkách je objekt
<class 'str'>                  typu 'string' neboli řetězec
>>> type(17)                 # Celé číslo je rovněž objekt    
<class 'int'>                               typu 'integer'
>>> type(3.2)                # Desetinné číslo je objekt
<class 'float'>                             typu 'float'

Vězme tedy, že řetězce (strings) patří k typu str a celá čísla (integers) k typu int. Čísla s desetinnou čárkou (v Pythonu tečkou) patří k typu float. Přehled typů je uveden v následující části 2.2.

A což objekty jako "17" a "2.3"? Vypadají jako čísla, ale jsou v uvozovkách.

>>> type("17")
<class 'str'>
>>> type("2.3")
<class 'str'>

Jsou to řetězce. Řetězce mohou být v Pythonu uzavřeny v jednoduchých ('), dvojitých (") nebo i trojitých uvozovkách. Uvnitř dvojitých uvozovek mohou být uvozovky jednoduché a obráceně: 'Pravil "Ne!" '.

Identita objektu je vyjádřena jeho identifikačním číslem (ID), které je adresou paměťového místa, ve kterém je aktuálně hodnota uložena.
Některé objekty mohou mít explicitně přiřazené jméno, obecně označované jako proměnná:

>>> num = 17; type(num), type(17)   # num je jméno proměnné           
(<class 'int'>, <class 'int'>)   
>>> id(num), id(17)        
(1835649200, 1835649200)            # zde id(num) == id(17)

Komentář na posledním řádku nutno brát s jistou rezervou, neboť ne vždy id(name) == id(value). Vždy však platí, že identita existujícího objektu je v rámci jedné seance neměnná.

Vznik objektu

Není na škodu si uvědomit, že objekt (základní entita Pythonu) má tři stadia existence:

1. jako použitelná možnost, daná pravidly jazyka Python
2. použitá možnost, daná deklarací objektu ve zdrojovém kódu (skriptu); toto stadium má dvě variety - objekty předdefinované (built-in), které jsou součástí programového vybavení Pythonu a objekty deklarované uživatelem ve skriptu
3. realizovaná možnost, daná provedením zdrojového kódu interpretem

Nový objekt vzniká zpracováním programového textu interpretem Pythonu, přičemž je ověřováno, zda takový objekt již je či není v paměti počítače uložen.
Přiřazování identifikačních čísel k objektům je ve výlučné kompetenci Interpreta a do jisté míry se řídí řadou známých pravidel.

Opuštěná hodnota zůstává v paměti i po změně přiřazení. Z paměti zmizí až po ukončení aktuální seance Pythonu působením procedury garbage collection.

2.2 Základní typy objektů

Velice frekventovaným termínem při popisování struktury programovacího jazyka je slovo literál. Literál (literal - doslovný) je přímý zápis určité hodnoty.

Následující stručný přehled datových typů jazyka Python je zároveň přehledem jeho literálů. V přehledu jsou nejprve uváděny názvy typů, posléze příklady jejich literálů (modře):

• NoneType - specielní typ s jedinou hodnotou None (absence hodnoty)
• ellipsis - specielní typ s jedinou hodnotou ... (tři tečky)

• int - integers neboli čísla celá (neomezené velikosti); tato čísla se vyjadřují ve formátu
  • decimálním (například 0, 5, -10 )
  • binárním (0b10001)
  • oktálním (0o21)
  • hexadecimálním (0x11)
  • bool - specielní typ s hodnotami True a False (1 a 0).
• float - racionální čísla s desetinnou tečkou:   12.58, 13.2
• complex - komplexní čísla (reálná část + imaginární část):   3+2j

Sekvence je uspořádaná množina indexovaných hodnot, které nemění své pořadí:

• list - seznam, měnitelná sekvence prvků stejného i různého typu:  ["m", 2, 5, False] - literál
• tuple - entice, neměnitelná sekvence prvků stejného i různého typu:   ("m", 2, 5, False) - literál
• range - neměnitelná posloupnost celých čísel:   range(2, 5)
• string - řetězec, neměnitelná sekvence znaků Unicode:   "Růže" - literál

Následující sekvenční typy pracují se sekvencemi bitů:

• bytes - neměnitelná sekvence bajtů: b'R\xc5\xaf\xc5\xbee' - literál
• bytearray - měnitelná verze předchozího typu
• memoryview - sekvence, vytvořená funkci memoryview(obj)

Prvky všech sekvenčních typů jsou interně indexovány pořadovým číslem (indexem), počínajícím nulou (viz 3.1). To umožňuje přímý přístup k elementu sekvence.

• set - množina, měnitelná kolekce jedinečných objektů:   {3.6, "cat", True} - literál
• frozenset - neměnitelná množina: frozenset({3.6, "cat", True}) - literál
• dict - slovník, měnitelná sekvence párových objektů, které rovněž nemění své pořadí:   {"size":12, "friend":"Karel"} - literál

Objekty typu set a frozenset mění své pořadí a nejsou tedy (na rozdíl od sekvencí) "subscriptable".
Naproti tomu slovník nemění své pořadí ale místo indexů používá klíče svých párových elementů.

Sekvence a kolekce jsou složené datové typy, sumárně označované jako kontejnery. Mají tu společnou vlastnost, že jsou iterovatelné, jsou to tedy iterábly (viz Kap 3.2). Liší se od sebe tím, že elementy kolekce (kromě typu dict) mění při manipulaci pořadí, kdežto sekvence nikoli.

Všechny názvy typů kromě None jsou zároveň i názvy vestavěných funkcí.

Hodnoty typů list, set, dict, bytearray lze po jejich vytvoření dodatečně změnit; říkáme, že jsou měnitelné (mutable) - změna hodnoty nevyvolá změnu ID.

Hodnoty typů int, float, complex, bool, str, bytes, tuple, frozenset, range dodatečně změnit nelze; říkáme, že jsou neměnitelné (immutable).

Poznámka 1:

Python nemá datový typ pro jeden znak, v jiných jazycích označovaný termínem char . Nahrazuje jej řetězcem s jedním prvkem - např   "a".

Kromě uvedeného výčtu datových typů disponuje Python řadou dalších typů jako module, function, method, class, array, atd, které jsou deklarované v příslušných modulech - viz Data Types

Poznámka 2:
Počítání s desetinnými čísly typu float není úplně přesné:

>>> f = 0.1 + 0.1 + 0.1 ; f             # viz Poznámka 3
0.30000000000000004

Existuje modul decimal, který (kromě jiného) ošetřuje výpočty s desetinnými čísly tak, že jsou rychlejší a přesnější.

>>> from decimal import Decimal

>>> x = Decimal('0.1')
>>> y = Decimal('0.1')
>>> z = Decimal('0.1')

>>> s = x + y + z; print(s)             # viz Poznámka 3
 0.3

Poznámka 3:
Invokace výrazu za středníkem chodí pouze v interaktivním režimu konzoly. Nechodí při spuštění skriptu ze souboru ~.py.

2.3   Booleovské hodnoty a výrazy

Pythonovský typ pro uložení hodnoty True nebo False zvaný bool je pojmenován po britském matematikovi George Booleovi, jenž vytvořil tak zvanou booleovu algebru, která je základem moderní počítačové aritmetiky.

Jsou pouze dvě booleovské hodnoty: True a False. Velká počáteční písmena jsou důležitá, neboť true a false booleovskými hodnotami nejsou.

>>>type(True) 
<class 'bool'>
>>>type(true)
Traceback (most recent call last):
>>File "<stdin>", line 1, in <module>
NameError: name 'true' is not defined

Booleovský výraz (prostěji podmínka) je výraz, který vede k boooleovské hodnotě. Tento výraz má tuto zavedenou skladbu:

<levý operand> relační či specielní operátor <pravý operand>

>>> 5 == 5
True
>>> 5 is not 5
False

Vestavěná funkce bool vrací booleovskou hodnotu čísel a řetězců. U číselných typů generují nulové hodnoty výstup False, nenulové hodnoty výstup True. Prázdné řetězce dávají False, neprázdné řetězce dávají True:

>>> bool(1)
True
>>> bool(0)
False
>>> bool("No !")           # neprázdný řetězec
True
>>> bool("")               # prázdný řetězec
False
>>> bool(3.14159)          # nenulová hodnota
True
>>> bool(0.0)              # nulová hodnota
False

2.4 Změna typu

Změna typu neboli konverze typu se provádí pomocí řady vestavěných funkcí.

Funkce str přijímá int, float či binary a přemění jej na string.

>>> str(32), str(32.12), str(0b100000)
('32', '32.12', '32')

Funkce float přijímá int, string či binary a přemění jej na float.

>>> float(32), float('32'), float(0b100000)
(32.0, 32.0, 32.0)

Funkce int přijímá string, float či binary a přemění jej na integer.

>>> int("32"), int(32.12), int(0b100000)
(32, 32, 32)

Funkce int(string, base) přijímá číslo ve formátu řetězce a základ jeho číselného systému (base) a vrací celé číslo se základem 10.

>>> int('0b100000',2), int('0o40',8), int('0x20',16)
(32, 32, 32)

Pro převod celého čísla do jiného číselného systému slouží funkce:

Funkce hex(integer) přijímá celé číslo a přemění jej na číslo se základem 16.

Funkce oct(integer) přijímá celé číslo a přemění jej na číslo se základem 8.

Funkce bin(integer) přijímá celé číslo a přemění jej na číslo se základem 2.

Všechny formáty celého čísla, vytvořené funkcemi hex, oct, bin,   jsou typu string:

>>> hex(32), oct(32), bin(32)
('0x20', '0o40', '0b100000')
type('0x20'), type('0o40'), type('0b100000')
(<class 'str'>, <class 'str'>, <class 'str'>)

Všechny formáty celého čísla, zapsané přímo jako literál nebo jako přiřazená hodnota k proměnné, jsou typu integer:

>>> 0x20, 0o40, 0b100000                   # literály
(32, 32, 32)
>>> hx = 0x20; oc = 0o40; bn = 0b100000    # proměnné
>>> hx, oc, bn
(32, 32, 32)

Převod znaku na pořadové číslo systému Unicode provádí funkce ord('znak')

>>> ord(" "), ord("m"), ord("ž")       # mezera je také znak
(32, 109, 382)

Převod přadového čísla systému Unicode na příslušný znak provádí funkce chr('unicode')

>>> chr(32), chr(109), chr(382)    
(' ', 'm', 'ž')

Pro převod řetězce na kontejnery typu list, tuple, set slouží funkce list(string), tuple(string), set(string). Podobně lze použít převody tuple(list), tuple(set), set(tuple), set(list).

>>> list("a5 True")
['a', '5', '', 'T', 'r', 'u', 'e']
>>> tuple("a5 True")                     
('a', '5', '', 'T', 'r', 'u', 'e')
>>> set("a5 True")
{'u', 'r', '', 'T', 'e', '5', 'a'}

Pro převod entice, slovníku či setu na slovník slouží funkce dict() - viz kap. 11.1, třetí ukázka.

>>> tup = (("a", 5), ("b", True))
>>> dit = dict(tup); dit               # dict from tuple
{'a': 5, 'b': True}

>>> lup = [("a", 5), ("b", True)]
>>> lip = dict(lup); lip               # dict from list
{'a': 5, 'b': True}

>>> sup = {("a", 5), ("b", True)}
>>> sip = dict(sup); sip               # dict from set
{'a': 5, 'b': True}

Pro převod reálných čísel na číslo komplexní slouží funkce complex(real, imag).

>>> complex(3.2, 12)
(3.2+12j)

Funkce ascii(string) přijímá řetězec a vrací jej doplněný zpětnými lomítky u znaků, které nejsou obsaženy v kódování ASCii.

>>> ascii("žížala"), ascii("oves")
("'\\u017e\\xed\\u017eala'", "'oves'")

2.5 Jména a klíčová slova

Jména proměnných, jakož i funkcí a tříd, mohou být libovolně dlouhá. Mohou obsahovat jak písmena tak číslice, ale musejí začínat písmenem a nesmějí obsahovat mezeru. I když je přípustné použít velká písmena, z konvenčních důvodů to neděláme. Pokud tak učiníme, musíme si uvědomit, že velikost písmena hraje roli. Bruce a bruce jsou různá jména.

Podtržítko (_) se ve jménu smí použít (naopak pomlčka (-) se používat nemá). Často se používá u jmen s více slovy, jako je moje_jmeno nebo price_of_tea_in_china. Podtržítko na počátku názvu mívá speciální význam, takže jej zatím raději takto nepoužívejte.

Dáme-li proměnné nepřípustné jméno, obdržíme syntaktickou chybu:

>>> 76trombones = "big parade"
SyntaxError: invalid syntax
>>> more$ = 1000000
SyntaxError: invalid syntax
>>> class = "Computer Science 101"
SyntaxError: invalid syntax

76trombones není legální, protože nezačíná písmenem, more$ není legální, protože obsahuje nedovolený znak, označení dolaru. Co je ale špatného na class?

Ukazuje se, že class je jedno z klíčových slov Pythonu. Klíčová slova jsou vyhrazená slova a nemohou být použita jako jména proměnných.

Python má aktuálně třicet dva plus tři klíčová slova:

and     as        assert  async    await     break    
class   continue  def     del      elif      else     
except  finally   for     from     global    if
import  in        is      lambda   nonlocal  not
or      pass      raise   return   try       while   
with    yield     True    False    None

Aktuálně platný seznam klíčových slov získáme zadáním příkazu:

>>> help("keywords")

2.6 Operátory a operandy

Operátor je znak, zastupující funkci - prefixovou (stojící před operandem), infixovou (stojící mezi operandy) a postfixovou (stojící za operandem či funkcí - v Pythonu se nepoužívá).

Z hlediska použitých operandů rozeznáváme

• unární operace s jedním operátorem a jedním operandem:

  x,y = -3, 3
  +(-3)    nebo   x. __pos()__()        -->  -3
  -(-3)    nebo   x. __neg()__()        -->   3       
   ~ 3     nebo   y. __invert__()       -->  -4
  Metoda __invert__() používá unární aritmetickou operaci
  bitwise NOT - viz odstavec 2.6.3. 
  

• binární operace s jedním operátorem a dvěma operandy:

  Python používá různé druhy operátorů: aritmetické, 
  bitwise, relační, logické, a speciální operátory.
  Jejich popis je uveden v další části textu.
  

• ternární operace se dvěma operátory a třemi 'operandy':

  a,b = 10,20          # operandem bývá i podmínka  
  
  a if a<b else b                   -->   10
  a<b and a or b                    -->   10
  (a,b) [a<b]                       -->   20
  (lambda: a, lambda: b) [a<b]()    -->   20
  {True: a, False: b} [a<b]         -->   20
  

2.6.1   Aritmetické operátory

Aritmetickými operátory jsou znaky pro sčítání +, odčítání -, násobení *, umocňování **, dělení /, celočíselné dělení //, a operátor modulo % (dělení s celočíselným zbytkem).
Pořadí důležitosti (precedence) je následující: Závorky | Umocňování a odmocňování | Násobení a dělení | Sčítání a odčítání.

Operátor + lze kromě numerických hodnot použít také pro operandy typu str, list, tuple, bytes a bytearray, nikoliv však pro range, dict, set a frozenset:

>>> "naše" + " prasátko"                      # string
'naše prasátko'
>>> ["naše"]+["prasátko"]   
['naše', 'prasátko']                          # list
("naše",)+("prasátko",)
('naše', 'prasátko')                          # tuple
>>> b"our" + b" little pig"            
b'our little pig'                             # bytes
>>> bytearray(" naše", "utf-8") + bytearray(" prasátko", "utf-8")
bytearray(b' na\xc5\xa1e pras\xc3\xa1tko')    # bytearray 

Výše uvedené operandy lze rovněž násobit celým číslem. Objeví-li se na místě operandu proměnná, je kompilátorem zaměměna za svou hodnotu před tím, než se operace provede:

>>> hele, mese = "hele", "mese "
>>> (hele + mese)*3      # záporné číslo vrátí prázdný řetězec
'helemese helemese helemese '

Popsané součty operandů (kromě čísel) provádí Python při kompilaci v rámci zjednodušení (redukce) výrazů. U řetězců se tato procedura označuje jako zřetězení (concatenation).

Operátor celočíselného dělení // (floor division) zaokrouhluje kladný podíl směrem dolů. Pracuje i s desetinnými čísly.

>>> minute = 59 
>>> minute // 60  
0
>>> -minute // -60.0
0.0

Záporný podíl je zaokrouhlován směrem k minus nekonečno.

>>> -minute // 60.0  
-1.0

Operátor modulo pracuje s celými čísly (číselnými výrazy) a poskytuje zbytek při dělení prvního operandu druhým. V Pythonu jej označujeme znakem pro procento (%). V pořadí operací má stejnou preferenci jako násobení.

>>> 7 % 3.0     
1.0

Ukazuje se, že modulo operátor je překvapivě užitečný. Na příklad, můžeme zjistit, zda jedno číslo je dělitelné druhým: je-li x % y == 0, pak x je dělitelné číslem y.

Lze jím také oddělit krajní číslice zprava od zadaného čísla. Například, x % 10 vyčlení nejkrajnější číslici čísla x zprava (při základu 10). Podobně x % 100 vyčlení dvě poslední číslice.

Použití operátoru modulo (%) si ukážeme na pěkném příkladu převodu vteřin na hodiny, minuty a zbývající vteřiny:

secs_celk = int(input("Kolik vteřin celkem?"))
hodiny = secs_celk // 3600
secs_navic = secs_celk % 3600
minuty = secs_navic // 60
sekundy = secs_navic % 60

print("Celkem vteřin: ", secs_celk)
print("Hodin, minut, vteřin: ", hodiny, minuty, sekundy) 

2.6.2   Operátory přiřazení

2.6.3   Bitwise operátory

Bitwise operátory provádějí logické operace AND, OR, NOT, operaci XOR, jakož i operace levého a pravého posunu na binárních řetězcích, což jsou sekvence nul a jedniček.

Tyto operátory nejprve převedou celá čísla svých operandů do binárního formátu stejné délky, na tomto formátu provedou bit za bitem (bitwise) předepsanou operaci a výsledek posléze převedou zpět na celé číslo.
Příklady v následující tabulce jsou vyčísleny pro x,y = 12, 5 (0b1100, 0b0101):

Popisy operací:

1. Vrací 1, jsou-li oba odpovídající bity = 1, jinak vrací 0.
2. Vrací 1, je-li alespoň jeden z odpovídajících bitů = 1, jinak vrací 0.
3. Vrací doplněk (komplement) čísla x k číslu 1: ~x = -(x+1)
4. Vrací 1, je-li jeden z bitů = 1 a druhý = 0; jinak vrací 0.
5. K binárnímu tvaru levé hodnoty přidá zprava nuly v počtu pravého čísla.
6. Od binárního tvaru levé hodnoty odebere zprava numera v počtu pravého čísla.

Užitečné vztahy:

bin(~12)        --> '-0b1101'   # ~12 = -(10+1) = -13
bin(a^b)        --> ' 0b1001'
int('110000',2) --> 48          # dclr-tto int('0b110000',2)

Binární systém vyžaduje více paměťového prostoru než decimální systém ale je méně komplikovaný pro uplatnění v hardwaru počítače.

2.6.4   Relační operátory

Relační operátory vyjadřují tvrzení o kvantitativním vztahu mezi dvěma hodnotami. Jsou to tyto operátory:

    x == y                # x je rovno y
    x != y                # x není rovno y
    x >  y                # x je větší než y
    x <  y                # x je menší než y
    x >= y                # x je větší nebo rovno y
    x <= y                # x je menší nebo rovno y

Jednotlivé tvrzení může být buď pravdivé nebo nepravdivé.

>>> 5 < 3
>>> False
>>> 5/3 < 10
>>> True

Rovnítko (=) není operátorem, nýbrž znakem pro přiřazení hodnoty ke jménu. Tato veledůležitá vázací operace (binding) umožňuje pracovat s objekty prostřednictvím jejich jmen.

2.6.5   Logické operátory

Logické (booleovské) operátory provádějí některé logické operace se zadanými operandy. Tyto operátory jsou tři: and , or a not. Jak vidíme, jsou to zároveň klíčová slova. Význam těchto operátorů je podobný jejich významu v češtině (a, nebo, ne). Například, výrazy x > 0 and x < 10 jsou pravdivé podle pravidel formální logiky pouze tehdy, jsou-li pravdivá obě tvrzení, to jest, je-li x větší než 0 a menší než 10.

Tvrzení n%2 == 0 or n%3 == 0 je pravdivé, je-li alespoň jedna z podmínek pravdivá, to jest, je-li číslo dělitelné dvěma nebo třemi.

Konečně, operátor not neguje následující booleovský výraz, takže not(x > y) je pravda, je-li x > y nepravda; to jest je-li x menší nebo rovno y.

2.6.6   Speciální operátory

Operátory totožnosti (identity) - is a is not ověřují, zda dva objekty mají stejné ID i stejnou hodnotu:

>>> x1 = y1 = 5
>>> x2 = y2 = "hej" 
>>> x1 is not y1          # False  - operandy jsou identické
>>> x2 is y2              # True   - id(x1) == id(y1)

Operátory příslušnosti (membership) in a not in ověřují, zda je zkoumaná proměnná přítomna v zadané sekvenci (string, list, tuple, set a dictionary):

>>> x = "Nazdárek!"
>>> y = {1:"a", 2:"b"}
>>> 'H' not in x           # True
>>> 1 in y                 # True

Operátor přiřazení s výrazem (mroží operátor) :=

Novějším (Python 3.8) způsobem přiřazení je přiřazení ve tvaru (var := val), označované jako přiřazení s výrazem. Pro zavedený operátor (:=) se ujalo označení mroží operátor.

Prostý příkaz přiřazení (mrož = False) nevrací hodnotu:
Přiřazení s výrazem vrací hodnotu: 
>>> (mrož := False)                         
False
>>> (u := 5 + 3*2)                     
11
Mrožík má rád závorky, bez závorky produkuje Syntax Error.

Mroží operátor umožňuje zkrácené pojmenování vyhodnoceného výrazu (viz poslední ukázka v Kap. 6.12.
Nutno však upozornit na to, že v následné ukázce se nejedná o mroží operátor, nýbrž o formátování výstupu, popsané v Kap. 6.13.

>>> x = 3; f"{x:=8}"
'       3'              # řetězec o délce 8 (včetně čísla 3)

2.6.7   Hvězdičkové operátory

S hvězdičkami se nám v Pythonu roztrhl pytel. K původním aritmetickým operátorům pro násobení (*) a umocňování (**) máme aktuálně ještě:

1. hvězdičky jako regulační znaky ve výčtu parametrů funkce; samotná hvězdička přikazuje aby všechny následující parametry přijímaly pouze párové argumenty funkce; doplňkem k hvězdičce ve výčtu parametrů je lomítko ve výčtu parametrů, které nařizuje aby všechny předcházející parametry přijímaly pouze poziční argumenty funkce -viz Kap. 4.2.2
2. hvězdičky jako dekorátory variadických parametrů či argumentů *args pro sekvence a **kwargs pro slovníky - viz Kap.4.2.3 a 4.2.4

2.6.8 Pořadí operací

Objeví-li se ve výrazu více než jeden operátor, závisí pořadí výpočtu na pravidlech o pořadí operací. Python (až na výjimky) respektuje stejná pravidla, jaká se používají v matematice.

Téměř všechny operátory se stejnou prioritou jsou vyhodnocovány zleva doprava (jsou asociativní zleva).

>>> 7 * 3 // 2          # (7 * 3) // 2
10

Opakované mocniny jsou vyhodnocovány zprava doleva (jsou asociativní zprava).

>>> 2**3**2             # 2**(3**2)  
512
>>> 7*8**(1/3)          # 7*3?¯8
14.0

Některé operátory nemají asociativitu a řídí se jinými pravidly, například:

x < y < z     -->  x < y and y < z

2.6.9 Podtržítka

Podtržítka mají různý význam v různých situacích. Ukázka 4 až 6 souvisí s třídami (viz kap. 12).

1. V konzole interpreta představují poslední uloženou hodnotu výrazu:

   >>> 2 + 3
   5
   >>> _ * 3
   15
   

2. Vyjadřují anonymní hodnotu:

   >>> for _ in range(6):
           print(_*_, end=" ")
   0 1 4 9 16 25
   

3. Jednoduché podtržítko jako přípona slouží k rozlišení aktuálně deklarovaného jména od stejnojmenného klíčového slova:

   >>> def pattern(name, class):    # class je klíčové slovo
   SyntaxError: "invalid syntax"  
   
   >>> def pattern(name, class_):   # OK
           pass                              
   

4. Jednoduché podtržítko jako předpona vyjadřuje pouze upozornění, že atribut třídy by se z nějakých důvodů neměl používat. Externímu použití bráněno není:

   class myClass:
       def __init__(self):
           self._bar = "Aleluja!"
   

   >>> myc = myClass(); myc._bar
   'Aleluja!'
   

5. Dvojité podtržítko před jménem atributu třídy je signál pro kompilátor aby v interním seznamu __dir__ připojil název třídy k názvu atributu (viz dir(obj)), čímž zamlží jeho existenci. Popsaný proces se označuje jako komolení názvu (name mangling):

   class myClass:
      def __init__(self):
         self.__x = 20         # privátní název atributu
      def __myFunc(self):      # privátní název atributu
         print("Hello, World!")     
    
   obj=myClass()                     # instance třídy
   

   Názvy s předsazenými dvojitými podtržítky jsou externě nepřístupné:

   >>> obj.__x
   AttributeError: 'myClass' object has no attribute '__x'
   

   Zkomolené (mangled) názvy atributů __x, __myFunc() mají tvar :   _myClass__x, _myClass__myFunc(). Pouze v této formě jsou externě přístupné:

   >>> obj._myClass__x; obj._myClass__myFunc()
   20
   Hello, World!
   

6. Dvojitá podtržítka před i za názvem (double underscores - dunders) metody označují speciální metodu třídy - viz kapitola 12.8.

2.7 Proměnné

Proměnná je uživatelské jméno, které odkazuje na přiřazený objekt, uložený pod identifikačním číslem (ID) v paměti počítače. Typ proměnné je dán typem přiřazeného objektu. Jméno bez přiřazeného objektu není akceptováno (ani mu není přiřazeno ID). Jména proměnných jsou case-sensitive, pomlčka uvnitř slova není povolena.

# Příklady názvů proměnných:
>>> a, a_a, A, aA,       

Podle zavedené konvence jsou jména, počínající velkým písmenen, vyhražena pro názvy tříd. Není doporučován ani formát "aA".

Objekt na pravé straně ke jménu na levé straně připojuje příkaz přiřazení, vyjádřený operátorem přiřazení (=). Vše, co umístíme na pravou stranu operátoru přiřazení, musí Python znát nebo umět vytvořit:

>>> n = "hosana"           # OK, objekt typu string
>>> pi = 3.14159           # OK, objekt typu float
>>> x = ping; ping = 5       
NameError: 'ping' is not defined
>>> ping = 5; x = ping; type(x)
<class ´int´>              # OK, objekt typu integer

Před vlastním přiřazením se vyhodnotí případný výraz na pravé straně.

>>> a = 5 + 3; a
8

Vazba jména na objekt se vyskytuje ve dvou místech:

1. nejprve tam, kde je tato vazba deklarována, to jest v souboru (modulu) či v definici třídy nebo funkce
2. poté je tato vazba zapsána do slovníku (jmenného registru) oblasti, příslušné místu deklarace

2.7.1   Změna přiřazení

Stejnému jménu lze postupně přiřazovat různé hodnoty (objekty):

>>> bruce = 5
>>> bruce
5
>>> bruce = 7; bruce
7

Nové přiřazení ruší přiřazení předchozí.

2.7.2   Aktualizace proměnné

Nejběžnější formou změny přiřazení je aktualizace, kdy nová hodnota proměnné závisí na její předchozí hodnotě, například:

x = 6; id(x)                              # inicializace 
2161740743056
x = x + 1; x; id(x)                       # aktualizace
7
2161740743088

Aktualizace proměnné přičtením hodnoty 1 se nazývá increment, aktualizace odečtením hodnoty 1 se nazývá decrement. Aktualizovaná proměnná musí mít předem přiřazenou počáteční hodnotu (viz inicializace).

Aktualizaci proměnné lze s výhodou provádět i pomocí operátorů rozšířeného přiřazení  +=  -=  *=  /=  //=  %=   (viz 2.7.3).

>>> y = 6
>>> y += 1; y    
7

2.7.3   Rozšířené přiřazení

Rozšířené (augmented) přiřazení je kombinace binární operace (+, -, *, /, %, **, //) a příkazu přiřazení (=) v jednom výraze. Toto přiřazení provede změnu hodnoty existující proměnné:

Podobně lze provést rozšířené přiřazení s bitwise operátory &, |, ^, >>  a  <<=.

2.10 Glosář

>>> n = n + 1
NameError: name 'n' is not defined

2.11 Cvičení