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

1. Hodnoty a typy objektů
2. Typy datových objektů
3. Booleovské hodnoty a výrazy
4. Změna typu hodnoty
5. Proměnné
   1. Změna přiřazení
   2. Aktualizace proměnné
   3. Anotace typu proměnné
6. Jména a klíčová slova
7. Operátory a operandy
   1. Aritmetické operátory
   2. Bitwise operátory
   3. Operátory rozšířeného přiřazení
   4. Mroží operátor
   5. Relační operátory
   6. Logické operátory
   7. Speciální operátory
   8. Hvězdičkové operátory
   9. Pořadí operací
   10. Podtržítka
   11. Operace 'stack & queue'
8. Cvičení

2.1 Hodnoty a typy objektů

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

Celou plejádu možných objektů lze zhruba rozdělit do dvou skupin:

1. Na datové objekty, obsahující údaje (data), s nimiž lze pomocí jiných objektů pracovat - tyto objekty jsou blíže popsány v odstavci 2.2.
2. Na provozní objety, schopné s uvedenými datovými objekty manipulovat - příkladem těchto objektů budiž funkce, metody a třídy (viz).

Každý objekt má jedinečnou hodnotu (value), typ (type) a identitu (ID).

Hodnota je inherentní význam datového 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 (built-in) funkcí type():

>>> type("Hello, World!")    # Text v uvozovkách je objekt
<class 'str'>                  typu 'string' neboli řetězec
>>> type(17)                 # Celé číslo je objekt typu 'integer'    
<class 'int'>                              
>>> 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 bývají 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 (v binární formě) uložena.
Některé objekty mohou mít explicitně přiřazené jméno, obecně označované jako proměnná (variable). Typ proměnné je dán typem jí přiřazené hodnoty:

>>> num = 17; type(num), type(17)            # viz Poznámka-1           
(<class 'int'>, <class 'int'>)                
>>> id(num); id(17)        
(1835649200, 1835649200)                     # viz Poznámka-2

Poznámka-1:
V konzole interpreta (shellu) lze na jeden řádek vložit více příkazů, oddělených středníkem, případně čárkou.
Poznámka-2:
Výstup 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

Pro zvídavé

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

1. jako entita, daná pravidly jazyka Python
2. použitá možnost, daná deklarací objektu ve zdrojovém kódu (skriptu) nebo v příkazovém řádku; toto stadium má dvě variety - objekty předdefinované (built-in), které jsou součástí programového vybavení Pythonu a objekty deklarované uživatelem
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 Typy datových objektů

Datové typy Pythonu slouží k ukládání různých druhů dat a k manipulaci s nimi. Rozlišujeme datové objekty měnitelné (mutable) a neměnitelné (immutable).

Následující stručný přehled typů datových objektů jazyka Python je zároveň přehledem jejich možných literálů (přímých zápisů jejich hodnoty). V přehledu jsou nejprve uváděny názvy typů, posléze jejich literály.

Speciální typy

• bool - specielní typ s hodnotami True a False (1 a 0)
• NoneType - specielní typ s jedinou hodnotou None (absence hodnoty)
• ellipsis - specielní typ s jedinou hodnotou ... (tři tečky)

Numerické typy (numbers)

• int - integer neboli čísla celá; tato čísla se vyjadřují ve formátu:
  • decimálním (například 17); s bází 10
  • binárním (0b10001); s bází 2 (0b)
  • oktálním (0o21); s bází 8 (0o)
  • hexadecimálním (0x11); s bází 16 (0x)

  Poznámka:
  Při prezentaci v okně interpreta (Thonny, IDLE) se binární, oktální a hexadecimální formát automaticky převádí do formátu dekadického:

  >>> bin, oct, hex = 0b10001, 0o21, 0x11
  >>> print(bin, oct, hex)
  17 17 17
  

• float - racionální čísla s desetinnou tečkou:   12.58, 13.2
• Decimal - desetinná čísla s přesným výpočtem:   viz dále
• Fraction - zlomky ve tvaru čitatele a jmenovatele:   viz dále
• complex - komplexní čísla (reálná část + imaginární část):   3+2j

Sekvence

Sekvence je uspořádaná a indexovatelná (subscriptable - viz 3.2) množina hodnot, které nemění své pořadí:

• string - řetězec, neměnitelná posloupnost alfanumerických znaků i mezer:   "100_krát nic"
• list - seznam, měnitelná posloupnost prvků stejného i různého typu:  ["m", 2, 5, False]
• tuple - entice, neměnitelná posloupnost prvků stejného i různého typu:   ("m", 2, 5, False); lze zapsat i bez závorek: "m", 2, 5, False
• range - rozsah, neměnitelná posloupnost celých čísel:   range(2, 5)

Následující binární sekvenční typy pracují se sekvencemi bitů (bytes - viz 7.1):

• bytes - neměnitelná sekvence bitů: b'R\xc5\xaf\xc5\xbee'
• bytearray - měnitelná sekvence bitů: bytearray(bytes)
• memoryview - neměnitelná sekvence, vytvořená funkcí memoryview(bytes)

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

U všech výše uvedených sekvenčních typů lze uplatnit tyto operace:
len(sekv), in sekv, seqv[i:j], min(sekv), max(sekv), sekv1+sekv2, sekv *number.

>>> tup = ("m", 2, 5, False) 
>>> úsek = tup[0:2]; úsek           # seqv[i:j] - viz 3.3
('m', 2)
>>> str = "obrázek"; max(str)
'á'   # 'á' má nejvyšší číselnou hodnotu v systému Unicode
>>> str * 3                         # sekv * integer 
'obrázekobrázekobrázek'

Kolekce

Uspořádaná i neuspořádaná množina měnitelných i nemětitelných prvků; uspořádaná (indexovatelná - subscriptable) množina nemění pořadí svých prvků:

• list (seznam) - měnitelná a uspořádaná množina prvků :   ["hello", 2.0, 5, [10, 20]]
• tuple (entice) - neměnitelná a uspořádaná množina prvků bez změny ID:   "a", 52, 3.8, (2, 8) --> ('a', 52, 3.8, (2, 8))
• set (sada) - měnitelná a neuspořádaná množina objektů (mění pořadí a redukuje opakující se prvky):   {3.6, "cat", True, 3.6} --> {"cat", True, 3.6}
• frozenset - neměnitelná množina prvků: frozenset({3.6, "cat", True})
• dict - slovník, měnitelná a uspořádaná množina pojmenovaných objektů:   {"size":12, "friend":"Karel"}

Kromě výše uvedených objektů typu kolekce existuje také modul collections:

from collections import ...
# namedtuple, deque, Counter, defaultdict, OrderedDict

Sekvence a kolekce jsou složené datové typy, sumárně označované jako kontejnery.
Specielním představitelem kontejneru je útvar, zvaný array, jenž je obdobou typu list, obsahující řadu hodnot stejného typu - viz Kap. 7.7.2.

Hodnoty specielních a numerických typů, jakož i typů tuple, range, string, bytes, frozenset, memoryview nelze dodatečně změnit; říkáme, že jsou neměnitelné (immutable).

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.

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, ... atd. Všechno v Pythonu je objekt a každý objekt je nějakého typu.

Počítání s čísly typu float

Datový typ float realizuje pro různá čísla různou přesnost:

>>> 0.126 * 2.3
  0.2898                     # přesný výstup         
>>> 0.1 + 0.1 + 0.1
  0.30000000000000004        # nepřesný výstup
 

S touto skutečností nutno počítat a přizpůsobit se jí:

1. použít funkci round(výsledek, počet_míst)

   >>> výsl = 7.3 / 1.5; výsl    # --> 4.866666666666666
   >>> print(round(výsl, 3))     # --> 4.867
   

2. Použít datový typ Decimal nebo Fraction - viz.

Počítání s čísly typu Decimal

Podporu pro rychlé a správné zaokrouhlování při počítání s desetinnými čísly poskytuje modul decimal.

Modul decimal ošetřuje výpočty s desetinnými čísly tak, že vrací výsledek s implicitně zadanou přesností:

>>> from decimal import Decimal

>>> a = Decimal('0.2')     # 1 desetinné místo 
>>> b = Decimal('0.12')    # 2 desetinná místa 
>>> print(a+b, a*b)
  0.32 0.024        # počet des. míst závisí na výsledku 

Počítání s čísly typu Fraction

Datový typ Fraction je součástí modulu fraction a umožňuje pracovat se zlomky. Zachovává přesnou hodnotu racionálního čísla, na rozdíl od čísel typu float (viz).

>>> from fractions import Fraction
>>> zlomek = Fraction(6, 8); zlomek
  Fraction(3, 4)   # zadaný výraz se zkrátil na 3/4
>>> z = Fraction(6,8) + Fraction(5,2); z
  Fraction(13, 4)  

2.3  Booleovské hodnoty, funkce 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.

>>> type(True); type(true)     # pouze True je OK!           
Traceback (most recent call last):
   NameError: name 'true' is not defined

Při porovnávání dvou objektů nutno rozlišovat mezi porovnáváním jejich hodnot nebo jejich identit; například dvě stokoruny mají stejné hodnoty ale nejsou to stejné objekty, majíce různá výrobní čísla.
V Pythonu je to obdobné, navíc lze porovnávat i typy objektů. Při porovnávání objektů používáme tuto zavedenou skladbu:

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

Při porovnávání objektů používáme převážně operátory == a is, nikoliv operátor přiřazení:

>>> a = [1, 2, 3]; b = a; c = a[:]  # operátory přiřazení 
>>> c == b; c == a;
 True True            # všechny objekty jsou stejné
>>> c is b; c is a
 False False          # pouze objekty 'a', 'b' jsou totožné
>>> print(id(a), id(b), id(c))
 2238680388544 2238680388544 2238674078912
>>> print(type(a), type(b), type(c), end=" ")
 <class 'list'> <class 'list'> <class 'list'>  

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 hodnoty

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

Funkce str(value) převádí jiné datové typy na objekt typu string (řetězec).

>>> str(32), str(32.12), str(3+2j)   # konverze na řetězce
 ('32', '32.12', '3+2j')             # tuple stringů

>>> str({3.6, "cat", True})          # konverze setu
 "{True, 3.6, 'cat'}"

Funkce float() přijímá literály numerického typu int a přemění jej na typ float, například:

>>> float(12), float(0b10001), float(False)
(12.0, 17.0, 0.0)

Funkce int(value, base) přijímá literály a proměnné typu number (mimo complex), bytes a str a přemění jej na typ integer, například:

>>> int>(32.12), int("57"), int(True)
(32, 57, 1)

Pro převod celého čísla do jiného číselného formátu 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 integer:

>>> hex(32), oct(32), bin(32)
('0x20', '0o40', '0b100000')    # zobrazení jako string, ale:
type(0x20), type(0o40), type(0b100000)
(<class 'int'>, <class 'int'>, <class 'int'>)

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

>>> ord(" "), ord("m"), ord("&")     # mezera je také znak
(32, 109, 38)

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

>>> chr(32), chr(109), chr(38)   
(' ', 'm', '&')

Pro převod sekvence (list, range, tuple, set, string, bytes) na sekvenci jiného typu slouží funkce list(), tuple(), set(), například:

>>> list("a5 True")                      # list z řetězce   
 ['a', '5', ' ', 'T', 'r', 'u', 'e']
>>> tuple("a5 True")                     # tuple z řetězce                     
 ('a', '5', '', 'T', 'r', 'u', 'e')
>>> set("abeceda")                       # set z řetězce
 {'c', 'a', 'b', 'd', 'e'} 

Pro převod entice, seznamu či setu na slovník slouží funkce dict() - viz kap. 9.5.

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

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

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

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

>>> 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  Proměnné

Proměnná (variable) je jméno přiřazeného objektu, uloženého 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, jen podtržítko.

# 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".

Hodnota na pravé straně je ke jménu na levé straně připojujena 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                      # objekt není definován!
NameError: 'ping' is not defined
>>> ping = 5; type(ping)
 <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, v definici třídy či funkce, případně v prostředí shellu IDLE nebo Thonny
2. poté je tato vazba zapsána do jmenného registru, příslušného místu deklarace

2.5.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.5.2  Hromadné přiřazení

Při hromadném přiřazení (multiple assignment) přiřadíme entici (tuple) jmen proměnných na levé straně výčtu (tuple, list) hodnot na pravé straně:

>>> x,y = 10,20      # počet jmen a hodnot musí být shodný
>>> y, x
 (20, 10)
 
# neboť: 
>>> a,b = "bum"; a,b   
 ValueError: too many values to unpack (expected 2)
>>> x, y, z = (10, 20)
 ValueError: not enough values to unpack (expected 3, got 2)

Mírně komplikovanější je tento způsob hromadného přiřazení:

>>> bod = 10, 20, 30            # <class 'tuple'> 
>>> x, y, z = bod; x,y,z
 (10, 20, 30)

Hromadné přiřazení se uplatní i ve smyčce for v iteráblu - viz 3.1:

2.5.3  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.6.3).

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

2.5.4  Anotace typu proměnné

Anotace proměnné je označení předpokládaného typu (type hint) přiřazované hodnoty při deklaraci proměnné. Protože je Python dynamicky typovaný jazyk, je tato informace pro jeho interpreta zcela nezávazná. Slouží téměř výhradně k lepšímu chápání smyslu čteného skriptu uživatelem. Pomáhá při ladění kódu například pomocí aplikace mypy.
Náznakem typu lze opatřit deklaraci proměnné, parametry a vratnou hodnotu funkce, jakož i metody třídy.

Používaná skladba náznaků (hints):

Náznak typu proměnné:       name: type
Totéž s přiřazením hodnoty: name: type = value 

Náznaky u parametrů funkce: def func_name(a: type, b: type):
u výstupní hodnoty funkce:  def func_name(a: type, b: type): -> type:

Totéž platí pro metody, t.j. funkce, definované uvnitř třídy,
včetně iniciační metody __init__. 

Jako příklad aplikace náznaků si uveďme definici funkce:

# F:/Codetest/HowTopy/ch-02/annot_meth.py

def multi(a: int, b: int, x) -> str:  # náznaky typů včetně výstupu
    return (a + b) * x

print(multi(2.5, 7, 3))	              # --> 28.5
print(multi('ha', 'ló ', 2))          # --> haló haló	

Interpret Pythonu náš předpis v pohodě ignoroval, protože ví, jak provádět součet a násobení a že tyto operace lze realizovat pro čísla i řetězce.
Pokud bychom tuto funkci realizovali pod dohledem aplikace mypy, dostalo by se nám v Terminálu těchto informací:

F:\Codetest\HowTopy\ch-02> mypy.exe annot_meth.py

annot_meth.py:5: error: Argument 1 to "multi"
 has incompatible type "str"; expected "int"  [arg-type]
annot_meth.py:5: error: Argument 2 to "multi"  has incompatible type "str"; 
expected "int"  [arg-type] 
annot_meth.py:6: error: Argument 1 to "multi"  has incompatible type "float"; expected "int"  [arg-type]
Found 3 errors in 1 file (checked 1 source file)

Předpoklad úspěšného provedení: Jsme "nacédovaní" do složky, obsahující zkoumaný skript a cestu k aplikaci mypy máme uloženou v proměnné PATH.




2.6 Jména a klíčová slova

Jména (identifiers) 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žívejme.

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")

Informaci o klíčovém slově získáme zadáním příkazu (například "raise"):

>>> help("raise")

Význam jednotlivých klíčových slov je (anglicky) uveden zde

Kromě výše uvedených klíčových slov existují 4 tak zvaná měkká klíčová slova (soft keywords): match, case, type a _ (podtržítko).




2.7 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 operace:

• unární (prefixové) - s jedním operátorem a jedním operandem:

  x,y = -3, 3
  +(x)    nebo   x. __pos__()          -->  -3
  -(x)    nebo   x. __neg__()          -->   3       
  ~  y    nebo   y. __invert__()       -->  -4
  Metoda __invert__() používá unární aritmetickou operaci
  bitwise NOT - # viz odstavec 2.6.2, pozn. 3. 
  

• binární (infixové) 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í se dvěma operátory a třemi operandy:

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

2.7.1   Aritmetické operátory

Aritmetickými operátory jsou znaky pro sčítání +, odčítání -, násobení *, umocňování **, prosté dělení / (vždy vrací typ float), celočíselné dělení // (vždy vrací typ int) a operátor modulo % (vrací pouze zbytek celočíselného dělení).
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 string, list, tuple, bytes a bytearray, nikoliv však pro range, dictionary, set a frozenset:

>>> "naše" + " prasátko"                      
 'naše prasátko'                               # string
>>> ["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
>>> -minute // 60.0                 # záporný podíl   
 -1.0

Záporný podíl je zaokrouhlován směrem minus nekonečno k nejbližšímu celému číslu:

>>> -45/60, -1<-0.75, -45//60.0   # 3 číselné výrazy v entici  
 (-0.75, True -1.0)

Operátor modulo 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 v aplikaci Thonny na pěkném příkladu převodu vteřin na hodiny, minuty a zbývající vteřiny. Následující text si překopírujte jako skript do textového editoru Thonny <bez názvu> a spusťte jeho provedení klikem na zelené ikoně:

# bez názvu

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) 

Výsledek pro zadaných 320 vteřin:

>>> %Run -c $EDITOR_CONTENT

Kolik vteřin celkem? 320                 # vstup uživatele
Celkem vteřin:  320
Hodin, minut, vteřin:  0 5 20

2.7.2   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):

18    

Operátor	Význam	Příklad
&	bitwise AND	1)   12 & 5    -->     4    (0b100)
|	bitwise OR	2)   12 | 5     -->   13   (0b1101)
~	bitwise NOT	3)    ~12       -->  -13   (-0b1101)
^	bitwise XOR	4)   12 ^ 5    -->     9   (0b1001)
<<	bitwise left shift	5)  12<< 2    -->   48  (0b110000)
>>	bitwise right shift	6) -12>> 2    -->     3  (0b11)

Poznámka:
Infixový operátor | s celočíselnými operandy provádí operaci bitwise OR.
Tentýž operátor s operandy typu set a dict provádí operaci union (sjednocení).
Uvnitř příkazu match-case (viz Kap. 9.11.3) přijímá opreátor | operandy typu string.

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.7.3   Operátory rozšířeného 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é, například pro x = 5 dostaneme:

Operátor	x=	Příklad	Výstup pro x = 5:
+=	5	x += 3	= 8
-=	5	x -= 3	= 2
*=	5	x *= 3	= 15
/=	5	x /= 3	= 1.6666666666666667
%=	5	x %= 3	= 2
//=	5	x //= 3	= 1
**=	5	x **= 3	= 125
&=	5	x &= 3	= 1
|=	5	x |= 3	= 7
^=	5	x ^= 3	= 6
>>=	5	x >>= 3	= 0
<<=	5	x <<= 3	= 40

2.7.4   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í pojmenovaného výrazu nebo pojmenovaný výraz. Pro zavedený operátor (:=) se ujalo označení mroží operátor (walrus opreator).
Tento operátor umožňuje provést okamžitě použitelné přiřazení uvnitř výrazu (expression) v závorkách.

(variable := expression)       # závorky jsou povinné

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

2.7.5   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í (statement) 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.

Je nutné rozlišovat mezi pojmem rovnost (equality ==) a totožnost (identity is):

>>> x,y = [1, 2, 3], [1, 2, 3]    # přiřazení hodnot k proměnnym
>>> id(x), id(y)
 (2536047102656, 2536006818688)
>>> x == y; x is y                # --> True, False - není totožné

2.7.6   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 zároveň 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.7.7   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         # přiřazení hodnoty k proměnné
>>> x2 = y2 = "hej"     # dtto
>>> 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!"               # string (řetězec)
>>> y = {1:"a", 2:"b"}            # dictionary (slovník)

>>> 'H' not in x                  # True
>>> 1 in y                        # True

2.7.8   Hvězdičkové operátory

S hvězdičkami se nám v Pythonu roztrhl pytel. K původním infixovým operátorům pro násobení (*) a umocňování (**) používáme ještě hvězdičky v postavení regulačních znaků v těchto situacích:

1. hvězdičky jako regulační znaky ve výčtu parametrů funkce; doplňkem k hvězdičce je lomítko ve výčtu parametrů - viz Kap. 4.2.5.
2. regulační znaky *args
pro zabalení (packing) i rozbalení (unpacking) prvků sekvence - viz Kap. 4.2.4.
3. 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.7.9 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.

Operátor	Název, použití
()	závorky
a**n,  a**(1/n)	umocnění, odmocnění
+x, -x,   ~x	unární +, - ,   bitwise NOT
*,  /,  //,  %	násobení, dělení, celočís. dělení, operátor modulo
+, -	aritmetický součin, podíl
<<, >>	bitwise left shift, bitw. right shift
&, ^, |	bitwise AND, XOR, OR - dle pořadí
<, <=, >, > =;  ==, !=	relace;  rovná se, nerovná se
+=, *=, /=, ...	složené přiřazení
not, and, or	logické operátory - dle pořadí
is, is not	operátory identity
in, not in	operátory příslušnosti
:=	'mroží' operátor

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 * 8**(1/3)
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.7.10 Podtržítka

Podtržítka mají různý význam v různých situacích.

1. Lze je použít jako oddělovač skupiny čísel:

   >>> mils = 1_200_000; mils    
    1200000
   

   Obdobně lze oddělovat části binárního, oktálního a hexadecimálního čísla: 0b_10001, 0o_21, 0x_11.

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

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

3. Vyjadřují anonymní hodnotu:

   >>> for _ in range(6):
          print(_*_, end=" ")    # 2x tatáž anonym. hodnota
   	           
    0 1 4 9 16 25
   

4. Podtržítko místo jména proměnné způsobí nepoužití odpovídající pozice ve výčtu přiřazovaných hodnot:

   # Ignorována jedna hodnota:
   >>> a, _, b = (1, 2, 3)
   >>> print(a,",", b)                    # --> 1 , 3
   
   # Ignorováno více hodnot:
   >>> c, *_, d = 1, 2, 3, 4, 5
   >>> print(c,",", d)                    # --> 1 , 5
   

5. 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
           pass
   SyntaxError: "invalid syntax"  
   
   >>> def pattern(name, class_):   # OK
           pass                              
   

6. Jednoduché podtržítko jako předpona jména vyjadřuje pouze upozornění, že deklarovaná třída, metoda, funkce nebo modul je zamýšlen pro interní použití uvnitř aktuálního modulu, třídy nebo paketu. Externímu použití však bráněno není:

   >>> class myClass:
           def __init__(self):
               self._bar = "Aleluja!"
   
   >>> myc = myClass(); myc._bar
   'Aleluja!'		
   

7. 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
   NameError: name 'obj' is not defined
   

   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!
   

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

2.7.11 Operace Stack & Queue




2.8  Cvičení

1. Co se stane, když dáte příkaz k tisku přiřazení?

   >>> print(n = 7)    # případně použijte jiný operátor
   

   A což toto?

   >>> print(7 + 5)
   

   Není-li tento výraz správný, opravte jej:

   >>> print(n:=7, n*3 "toto", 4-2, 5/2.0)
   



2. Následující číselné výrazy vypočítejte z hlavy a výsledky si následně ověřte v konzole. Zadané příklady byste z hlavy měli zvládnout!

   >>>  5 % 2
   >>>  9 % 5
   >>>  15 % 12
   >>>  12 % 15
   >>>  6 % 6
   >>>  0 % 7
   >>>  7 % 0
   



3. Přidejte závorky k výrazu 6 * 1 - 2 tak, aby se změnila jeho hodnota ze 4 na -6.


4. Za prompt v konzole Pythonu zapište houby + 4. To vyvolá chybu:

   >>> houby + 4
    NameError: name 'houby' is not defined
   

   S použitím mrožího operátoru přiřaďte jménu houby takovou hodnotu, aby houby + 4 bylo 10.


5. Dovedl byste zapsat následující vzorec pro výpočet výsledné hodnoty A počátečního vkladu P jako sled výrazů (nikoliv jako funkci) v programovém jazyce Python?
   
   kde:
   • P = počáteční vklad
   • r = úroková míra per annum jako desetinné číslo
   • n = počet hodnocených období za rok
   • t = počet roků
   Pro P=10000 Kč, n=12 měsíců, r=8%(0,08) a t=10 let by hodnota A měla být přibližně 22.196,4 Kč.
   Úlohu řešte v interaktivním i programovém režimu v aplikaci Thonny či IDLE. Skript vložte do souboru vynos.py ve složce kap-02.