|
|
|
|
|
|
|
Jediné dva stavy, které umí počítač ve svém elektronickém obvodu rozlišit, je přítomnost či nepřítomnost elektrického náboje. Těmto stavům se přisuzuje význam hodnoty 0 nebo 1 a tato duální hodnota se nazývá jeden bit. Seskupením osmi bitů vytvoříme bajt (byte), jímž lze vytvořit 256 (= 28) kombinací nul a jedniček neboli binárních čísel 00000000 (= 0) až 11111111 (= 256).
Při komunikaci s počítačem jsou všechný tisknutelné i netisknutelné (řídící) znaky vyjádřeny kódovými čísly, neboli kódovými body (code points).
Souvztažnost čísel se znaky je vyjádřena různými kódovanými sadami znaků. Kódování ASCII obsahuje 128 kódových bodů, které pokrývají znaky, symboly, číslice a velká i malá písmena anglické abecedy (například číslice 1 má kódový bod 49).
Zbývající paměťový prostor (128 čísel) jednoho bajtu je (byl) využíván různými dalšími sadami znaků pro potřebu dalších jazyků, případně pro "rozšířenou" verzí ASCII - Latin-1. Pro češtinu je použitelný systém ISO-8859-2 (Latin2) a Windows -1250 (cp1250).
Společným rysem těchto seznamů je to, že to jsou zároveň sady znaků (character sets) i kódovací schemata (character encodings), neboť všechny jejich znaky lze vyjádřit jedním bajtem.
S příchodem Internetu začala mnohost kódovacích sad nevyhovovat. Na počátku 90. let minulého století byl do používání uveden systém Unicode, jenž definuje číselnou řadu 0 až 1.114.111 (0 až 0x10FFFF v hexadecimálním vyjádření). Jednotlivé číslo této řady se nazývá Unicode Code Point (UCP). Obsazená část této řady obsahuje aktuálně přes 137.000 znaků pro téměř všechna písma, symboly a znaky, používané na zemi (zjednodušeně řečeno). Prvních 128 znaků sady Unicode je shodných se znaky kódování ASCII.
Python implicitně používá kódování UTF-8. Všechny akcentované znaky češtiny zabírají 2 bajty. Kódová čísla se zapisují v hexadecimálním formátu.
Ústředním pojmem programovacího jazyka Python je objekt - coby instance programové struktury, zvané třída - viz Kap. 12.
Každý objekt hodnotu (value), typ (type) a identitu (ID).
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.
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 typu
<class 'str'> '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.3.
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ě:
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# num je jméno pro přiřazený objekt, >>> type(num); type(17) <class 'int'> <class 'int'># typ jména je dán typem přiřazené hodnoty >>> 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
Existence objektu je podmíněna jeho přítomností v paměti počítače, kde je uložen pod určitou adresou - identifikačním číslem (ID).
Při spuštění Pythonu se do operační paměti načte tato řada (sdílených) objektů, připravených k okamžitému použití:
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.
>>> ping = 250; id(ping); id(250)# 250 < 1835652928 1835652928256!!# id(ping) == id(250) >>> ping = 200; id(ping); id(200) 1835652128 1835652128# id(ping) == id(200) >>> id(250) 1835652928# objekt '250' stále existuje jako použitelný 'sirotek'
Opuštěná hodnota zde 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.
Zcela jiné výstupy dostaneme, přiřadíme-li hodnoty > 256:
>>> rum = 270 >>> id(rum); id(270) 38420176 38420208# id(rum) != id(270) >>> rum = 300 id(rum); id(300); id(270) 38420224 38420240# id(rum) != id(300) 38420176# id(270) == id(rum_1) ??
Proč a jak interpret udělil celkem čtyři ID pojďme nezkoumat.
Řetězce, které mají méně než 20 znaků ASCII, případně obsahují číslice či podtržítko, jsou takzvaně "internovány", to jest zachází se nimi podobně jako se "sdílenými" objekty.
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í stuč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):
None (not a number)... (tři tečky) True a False17)0b10001)0o21)0x11)12.58, 13.2 3+2j
["m", 2, 5, False] - ("m", 2, 5, False) - range(2, 5) (viz 4.8) "Růže" - b'R\xc5\xaf\xc5\xbee' (viz 7.2) - memoryview(obj) (viz 7.2)Prvky všech sekvenčních typů jsou interně indexovány pořadovým číslem, počínajícím nulou. To umožňuje přímý přístup k elementu sekvence - viz např. kap. 6.1, 8.2 a 10.1.
{"size":12, "friend":"Karel"} - {3.6, "cat", True} - Sekvence a kolekce jsou složené datové typy, také označované jako kontejnery, jejichž společnou vlastností je to, že vlastní magickou metodu
Všechny názvy typů kromě NoneType 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). Pokud ke stejné proměnné přiřadíme upravenou stávající (neměnitelnou) hodnotu, provádíme změnu přiřazení, neboli přiřazujeme objekt s jiným ID.
Poznámka:
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
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
Změna typu neboli konverze typu se provádí pomocí řady vestavěných funkcí.
Funkce str(integer OR float) přijímá celé číslo či float a přemění jej na string.
>>> str(32), str(3.2)
('32', '3.2')
Funkce float(integer OR string) přijímá celé číslo či string a přemění jej na float.
>>> float(32), float("32"), float("3.2")
(32.0, 32.0, 3.2)
Funkce int(string OR float) přijímá string či float a přemění jej na integer.
>>> int("32") string pouze s celým číslem
32
>>> int(3.2), int(3.5), int(3.6) odtrhne desetinnou část čísla
(3, 3, 3)
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(hex(32))
<class 'str'>
Všechny formáty celého čísla, zapsané přímo nebo jako přiřazená hodnota, jsou typu integer:
>>> hx = 0x20; oc = 0o40; bn = 0b100000 >>> hx, oc, bn; type(hx), type(0x20) (32, 32, 32)# literály hex, oct, bin převedeny na dekadický formát (<class 'int'>, <class 'int'>)
Převod znaku na pořadové číslo systému Unicode provádí funkce ord('znak')
>>> ord(" "), ord("m"), ord("ž")
(32, 109, 382)
Převod přadového čísla Unicode na příslušný znak provádí funkce chr('integer')
>>> chr(32), chr(109), chr(382)
(' ', 'm', 'ž')
Pro převod řetězce na sekvence list, tuple, set slouží funkce list(string), tuple(string), set(string).
>>> list("a5True")
['a', '5', 'T', 'r', 'u', 'e']
>>> tuple("a5 True")
('a', '5', 'T', 'r', 'u', 'e')
>>> set("a5True")
{'u', 'r', 'T', 'e', '5', 'a'}
Pro převod entice, slovníku či setu s vnořenými enticemi či slovníky (obsahující dvojice key:value) na slovník - slouží funkce dict(tuple OR list OR set).
>>> tup1 = (("a", 5), ("b", True))
>>> tup2 = (["a", 5], ["b", True])
>>> dict(tup1), dict(tup2)
({'a': 5, 'b': True}, {'a': 5, 'b': True})
>>> lup1 = [("a", 5), ("b", True)]
>>> lup2 = [["a", 5], ["b", True]]
>>> dict(lup1), dict(lup2)
({'a': 5, 'b': True}, {'a': 5, 'b': True})
>>> sup1 = {("a", 5), ("b", True)}
>>> sup2 = {["a", 5], ["b", True]} TypeError: unhashable type: 'list'
>>> dict(sup1)
{'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'")
Jména proměnných 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 breakclass continue def del elif elseexcept finally for from global ifimport in is lambda nonlocal notor pass raise return try whilewith yield True False None
Skutečně platný seznam klíčových slov získáme zadáním příkazů:
>>> import keyword >>> keyword.kwlist
Proměnná je uživatelské jméno, odkazující na přiřazený objekt, uložený pod identifikačním číslem (ID) v paměti počítače. Typ proměnné (jména) je dán typem přiřazené hodnoty. Jméno bez přiřazeného objektu není akceptováno (ani mu není přiřazeno ID).
Objekt ke jménu připojuje příkaz přiřazení, realizovaný 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"# no problem >>> pi = 3.14159# no problem >>> x = pingNameError: name 'ping' is not defined >>> ping = 5 >>> x = ping# no problem
Hromadné přiřazení
Jedním příkazem lze přiřadit různé objekty různým proměnným (prvky n, pi, message zde tvoří entici). Podrobněji je hromadné přiřazení popsáno v kapitole 10.4:
>>> n, pi, message = 17, 3.14, "Prší"# id(n)!=id(pi)!=id(message)
Hromadným přiřazením nejsou dále uvedené příkazy. Zde se jedná o deklaraci, že a, b, c jsou jména, odkazující na stejný objekt 3, případně 300.
>>> a = b = c = 3# id(a)==id(b)==id(c) >>> a = b = c = 300==id(3)# id(a)==id(b)==id(c) !=id(300)
U menšího čísla je ID proměnné totožné s ID přiřazeného čísla. U čísla 300 tomu tak není proto, že 300 > 257 -
Název proměnné lze použít ve funkci print():
>>> print(message) Prší >>> print(n) 17 >>> print(pi) 3.14
Funkce print() vrací řetězec bez apostrofů. V konzole (nikoliv ve skriptu) se obejdeme i bez funkce print:
>>> message = "Jak je?" >>> message 'Jak je?'
Změna přiřazení
Stejnému jménu lze postupně přiřazovat různé hodnoty (objekty):
>>> bruce = 5
>>> bruce
5
>>> bruce = 7
>>> print(bruce)
7
Nové přiřazení ruší přiřazení předchozí.
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# inicializace # --> 6 x = x + 1# aktualizace # --> 7 # id(6) != id(7)
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í dalších operátorů přiřazení (viz 2.8.6) += -= *= /= //= %=
>>> x = 6 >>> x +=1 >>> x 7 >>>
Operátor je znak, zastupující infixovou funkci, stojící mezi dvěma operandy, neboli parametry funkce. Python používá různé druhy operátorů: aritmetické, relační, logické, přiřazovací a bitwise 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).
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, tuple ['naše', 'prasátko'] ('naše', 'prasátko') >>> b"our" + b" little pig"bytes can only contain ASCII literal characters b'our little pig' >>> bytearray(" naše", "utf-8") + bytearray(" prasátko", "utf-8") bytearray(b' na\xc5\xa1e pras\xc3\xa1tko')
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)*3Popsané 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 konkatenace (concatenation).# záporné číslo vrátí prázdný řetězec 'helemese helemese helemese '
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 % 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)
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.
Logické (booleovské) 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.
Bitwise operátory pracují s operandy jako by to byly řetězce binárních číslic a to bit za bitem. Příklady v následující tabulce jsou vyčísleny pro x = 10 (binárně 0000 1010) a y = 4 (0000 0100):
| Operátor | Význam | Příklad |
|---|---|---|
| & | bitwise AND | x & y = 0 (0000 0000) |
| | | bitwise OR | x | y = 14 (0000 1110) |
| ~ | bitwise NOT | ~x = -11 (1111 0101) |
| ^ | bitwise XOR | x ^ y = 14 (0000 1110) |
| >> | bitwise right shift | x >> 2 = 2 (0000 0010) |
| << | bitwise left shift | x << 2 = 40 (0010 1000) |
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é:
| Operátor | Příklad | Nahrazuje |
|---|---|---|
| += | x += 5 | x = x + 5 |
| -= | x -= 5 | x = x - 5 |
| *= | x *= 5 | x = x * 5 |
| /= | x /= 5 | x = x / 5 |
| % | x %= 5 | x = x % 5 |
| // | x // 5 | x = x // 5 |
| **= | x **= 5 | x = x ** 5 |
Podobně lze provést rozšířené přiřazení s operátory &, |, ^, >> a <<=.
Nejnovějším typem (Python 3.6) rozšířeného přiřazení je tak zvaný mroží operátor (:=), vytvářející pojmenované přiřazení:
Průběh se standardním přiřazením: >>> mrož = False; mrož FalsePrůběh s pojmenovaným přiřazením: >>> print(mrož := True) TrueMrožík má rád závorky: >>> (u := 5 + 3*2)# bez závorky produkuje Syntax Error 11
Mroží operátor umožňuje zkrácené pojmenování vyhodnoceného výrazu.
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" >>> x1is noty1 # False - operandy jsou identické >>> x2isy2 # 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
Všechny uvedené operátory jsou také klíčovými slovy.
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 respektuje stejná pravidla, jaká se používají v matematice.
>>> 2**3**2 # 2**(3**2)
512
Příkaz je instrukce, kterou může interpret provést. Samotný příkaz však neprodukuje žádný výstup. Dosud jsme poznali pouze příkaz přířazení = a příkaz import. V krátké době se seznámíme s dalšími příkazy, jako je while, for, if. Zadaný příkaz interpret Pythonu mlčky provede.
Výraz je kombinace hodnot, proměnných, operátorů a případně i volání funkcí. Zapíšeme-li výraz na příkazový řádek, interpret jej vyhodnotí a zobrazí výsledek.
>>> 1 + 1
2
>>> len("hello")
5
V ukázce vidíme vestavěnou funkci len, která vrací délku zadané hodnoty, v tomto případě délku řetězce. Po print a type je to třetí ukázka vestavěné funkce.
Vyhodnocení výrazu generuje hodnotu a proto se výrazy mohou vyskytovat jen na pravé straně příkazu přiřazení :
>>> 17 17 >>> y = 3.14 >>> y 3.14
Podtržítka mají různý význam v různých situacích. Situace 5 až 7 souvisí s třídami - viz kap. 12.
>>> 2 + 3 5 >>> _ * 3 15
>>> x, _, y = (1, 2, 3) >>> x,y (1, 3)
>>> for _ in range(6): ... print(_*_, end=" ") 0 1 4 9 16 25
>>> def pattern(name, class):
SyntaxError: "invalid syntax"
>>> def pattern(name, class_):
pass # OK
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.__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!
Dvojitá podtržítka před i za názvem (double underscores - dunders) metody označují speciální metodu třídy - viz kapitola 12.5.
>>> n = n + 1 NameError: name 'n' is not defined
>>> 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
NameError: name 'houby' is not definedJménu houby přiřaďte takovou hodnotu, aby houby + 4 bylo 10.
Úlohu řešte v interaktivním i programovém režimu v aplikaci IDLE. Skript vložte do souboru vynos.py ve složce kap-02.
|
|
|
|
|
|
|