|
|
|
|
|
|
|
Ústředním pojmem
Celou plejádu možných objektů lze zhruba rozdělit do dvou skupin:
Každý objekt má jedinečnou
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 funkcí
>>> type("Hello, World!") # Text v uvozovkách je objekt
<class 'str'> typu 'string' neboli řetězec
>>> type(17) # Celé číslo je objekt typu
<class 'int'> 'integer'
>>> type(3.2) # Desetinné číslo je objekt
<class 'float'> typu 'float'
Vězme tedy, že řetězce (strings) patří k typu
A což objekty jako
>>> 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ě:
Identita objektu je vyjádřena jeho
Některé objekty mohou mít explicitně přiřazené jméno, obecně označované jako
>>> num = 17; type(num), type(17)# num je jméno proměnné (<class 'int'>, <class 'int'>)# type(num) = type(17) >>> 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
Není na škodu si uvědomit, že objekt (základní entita Pythonu) má tři stadia existence:
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
Všechny vestavěné typy Pythonu jsou typy datové, s výjimkou typu
Nutno také uvést, že některé typy objektů (
Následující stručný přehled datových typů 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.
>>> bin, oct, hex = 0b10001, 0o21, 0x11 >>> print(bin, oct, hex) 17 17 17
Sekvence je uspořádaná a
Následující sekvenční typy pracují se sekvencemi bitů (viz 7.2):
Prvky všech sekvenčních typů jsou interně indexovány pořadovým číslem (
U všech výše uvedených sekvenčních typů lze uplatnit tyto operace:
Hodnoty specielních a numerických typů, jakož i typů
Hodnoty typů
Specielním představitelem kontejneru je útvar, zvaný
Poznámka 1:
Python nemá datový typ pro jeden znak, v jiných jazycích označovaný termínem
Kromě uvedeného výčtu datových typů disponuje Python řadou dalších typů jako
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
>>> from decimal import Decimal
>>> x = Decimal('0.1')
>>> y = Decimal('0.1')
>>> z = Decimal('0.1')
>>> s = x + y + z; s; print(s) # viz Poznámka 3
Decimal('0.3')
0.3
Poznámka 3:
Invokace výrazu za středníkem
Pythonovský typ pro uložení hodnoty
Jsou pouze dvě
>>>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
<levý operand> relační či specielní operátor <pravý operand>
>>> 5 == 5 True >>> 5 is not 5 False
Vestavěná funkce
>>> 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
Změna typu neboli
Funkce
>>> str(32), str(32.12), str(3+2j)# deklarace entice ('32', '32.12', '3+2j')# entice (tuple) stringů >>> str({3.6, "cat", True})# konverze setu "{True, 3.6, 'cat'}"
Funkce
>>> float(12), float(0b10001), float(False) (12.0, 17.0, 0.0)
Funkce
>>> int(32.12), int(0b100000), int(True) (32, 17, 1)
Pro převod celého čísla do jiného číselného formátu slouží funkce:
Funkce
Funkce
Funkce
Všechny formáty celého čísla, vytvořené funkcemi
>>> 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("m"), ord("&") # mezera je také znak
(32, 109, 38)
Převod přadového čísla systému Unicode na příslušný znak provádí funkce
>>> chr(32), chr(109), chr(38)
(' ', 'm', '&')
Pro převod sekvence (
>>> 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("a5 True") # set z řetězce
{'u', 'r', '', 'T', 'e', '5', 'a'}
Pro převod entice, slovníku či setu na slovník slouží funkce
>>> 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(3.2, 12) (3.2+12j)
Funkce
>>> ascii("žížala"), ascii("oves")
("'\\u017e\\xed\\u017eala'", "'oves'")
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.
Podtržítko '
Dáme-li proměnné nepřípustné jméno, obdržíme syntaktickou chybu:
>>> 76trombones = "big parade"SyntaxError: invalid syntax >>> more$ = 1000000SyntaxError: invalid syntax >>> class = "Computer Science 101"SyntaxError: invalid syntax
Ukazuje se, že
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")
Operátor je znak, zastupující funkci -
Z hlediska použitých operandů rozeznáváme
x,y = -3, 3 +(-3) nebo x. __pos()__() --> -3 -(-3) nebo x. __neg()__() --> 3 ~ 3 nebo y. __invert__() --> -4Metoda __invert__() používá unární aritmetickou operaci bitwise NOT - viz odstavec 2.6.3.
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.
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
Aritmetickými operátory jsou znaky pro sčítání
Pořadí důležitosti (precedence) je následující:
Operátor
>>> "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
>>> 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
Operátor
>>> 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 '
>>> 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
Lze jím také oddělit krajní číslice zprava od zadaného čísla. Například,
Použití operátoru modulo (
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)
Rozšířené (augmented) přiřazení je kombinace binární operace (
| Operátor | Příklad | Náhrada za |
|---|---|---|
| = | x = 5 | x = 5 |
| += | x += 3 | x = x + 3 |
| -= | x -= 3 | x = x - 3 |
| *= | x *= 3 | x = x * 3 |
| /= | x /= 3 | x = x / 3 |
| %= | x %= 3 | x = x % 3 |
| //= | x //= 3 | x = x // 3 |
| **= | x **= 3 | x = x ** 3 |
| &= | x &= 3 | x = x & 3 |
| |= | x |= 3 | x = x | 3 |
| ^= | x ^= 3 | x = x ^ 3 |
| >>= | x >>= 3 | x = x >> 3 |
| <<= | x <<= 3 | x = x << 3 |
Novějším (Python 3.8) způsobem přiřazení je přiřazení ve tvaru
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) 11Mrožík má rád kulaté závorky, bez závorek produkuje Syntax Error. S jinými než kulatými naloží takto: >>> {mrož := False}; [u := 5 + 3*2] {False} [11]
Bitwise operátory provádějí logické operace
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
| Operátor | Význam | Příklad |
|---|---|---|
| & | bitwise AND | 1) x & y -> 4 (0b100) |
| | | bitwise OR | 2) x | y -> 13 (0b1101) |
| ~ | bitwise NOT | 3) ~x -> -13 (-0b1101) |
| ^ | bitwise XOR | 4) x ^ y -> 9 (0b1001) |
| << | bitwise left shift | 5) x << 2 -> 48 ('0b110000') |
| >> | bitwise right shift | 6) x >> 2 -> 3 ('0b11') |
Operátor
Popisy operací:
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.
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 (
Je nutné rozlišovat mezi pojmem
>>> x, y = [1, 2, 3], [1, 2, 3] >>> x== y; xis y--> True, False
Logické (booleovské) operátory provádějí některé logické operace se zadanými operandy. Tyto operátory jsou tři:
Například, výrazy
Tvrzení
Konečně, operátor
Operátory
>>> x1 = y1 = 5 >>> x2 = y2 = "hej" >>> x1is not y1# False - operandy jsou identické >>> x2is y2# True - id(x1) == id(y1)
Operátory
>>> x = "Nazdárek!"# string >>> y = {1:"a", 2:"b"}# dictionary (slovník) >>> 'H'not in x# True >>> 1in y# True
S hvězdičkami se nám v Pythonu roztrhl pytel. K původním aritmetickým operátorům pro násobení (
Objeví-li se ve výrazu více než jeden operátor, závisí pořadí výpočtu na
| Operátor | Název, použití |
|---|---|
| () | závorky |
| a**n, a**(1/n) | umocnění, odmocnění |
| +x, -x, ~x | unární +, - , bitwise NOT |
| *, /, //, % | aritmetické operace |
| +, - | 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
>>> 7 * 3 // 2# (7 * 3) // 2 10
Opakované mocniny jsou vyhodnocovány zprava doleva (jsou
Některé operátory nemají asociativitu a řídí se jinými pravidly, například:
x < y < z--> x < y and y < z
Podtržítka mají různý význam v různých situacích.
Lze je použít jako oddělovač skupiny čísel:
>>> mils = 1.2 * 1000**2 >>> mils == 1_200_000 True
Obdobně lze oddělovat části binárního, oktálního a hexadecimálního čísla:
Zajímavé na formátu nedekadických čísel je mimo jiné také to, že při invokaci se vracejí v dekadické formě:
>>> bin, oct, hex = 0b_0010, 0o_64, 0x23ab (nerozděleno ) >>> print(bin,",", oct,",", hex) 2 , 52 , 9131# vrácen dekadický formát
>>> 2 + 3 5 >>> _ * 3 15
>>> for _ in range(6):
print(_*_, end=" ")
0 1 4 9 16 25
# 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(b,",", c)# --> 1 , 5
>>> def pattern(name, class):# class je klíčové slovo SyntaxError: "invalid syntax" >>> def pattern(name, class_):# OK pass
class myClass : def __init__(self): self._ bar = "Aleluja!"
>>> myc = myClass(); myc._bar 'Aleluja!'
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.__xAttributeError: '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!
Dvojitá podtržítka před i za názvem (double underscores -
Proměnná je uživatelské
# 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
>>> n = "hosana"# OK, objekt typu string >>> pi = 3.14159# OK, objekt typu float >>> x = pingNameError: '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:
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í.
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
Aktualizaci proměnné lze s výhodou provádět i pomocí operátorů
>>> y = 6 >>> y += 1; y 7
Anotace proměnných 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 uživatelem čteného skriptu. 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.
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 si uveďme definici funkce, potvrzující pravdivost druhé věty úvodního odstavce:
# F:/Codetest/HowTopy/ch-02 def multi(a: int, b: int, x) -> str: 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
F:\Codetest\HowTopy\ch-02> mypy 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)
Aplikaci mypy si do Pythonu nainstalujeme příkazem >
>>> print(n = 7)A což toto?
>>> print(7 + 5)Nebo toto?
>>> print(5.2, "toto", 4-2, 5/2.0)
>>> 5 % 2 >>> 9 % 5 >>> 15 % 12 >>> 12 % 15 >>> 6 % 6 >>> 0 % 7 >>> 7 % 0
JménuNameError: name 'houby' is not defined
Úlohu řešte v interaktivním i programovém režimu v aplikaci IDLE. Skript vložte do souboru
|
|
|
|
|
|
|