python.edumach.cz

Python v kostce

🐍 O Pythonu

  1. Moderní, svobodný, volně šiřitelný

  2. Interpretovaný - šetří čas

  3. Snadno naučitelný, kompaktní programy

  4. Nejde v něm napsat “ošklivý” kód - žádné {} ani ; - seskupuje se odsazením řádku

    def rychlost(metry, sekundy):   # definice funkce
        v = metry/sekundy           # tělo fukce
        return v                    # návratová hodnota
    
    print(rychlost(120,30),"m/s")   # volání funkce rychlost() s argumenty
                                    # print() výpis návratové hodnoty a jednotky
    

    Živá ukázka: https://repl.it/@machac/vypocet-rychlosti

  5. Striktně objektový - vše v Pythonu je objekt:

    >>> a = "Python"
    >>> len(a)     # len() délka řetězce
    6
    >>> a.upper()  # metoda upper() převede znaky na velká písmena
    'PYTHON'
    >>> 
    
  6. Dynamicky typované proměnné - proměnná vzniká přiřazením:

    >>> c = 30
    >>> c
    30
    >>> c = "Python"
    >>> c
    'Python'
    >>> 
    
  7. Velikost proměnné je omezena pouze pamětí počítače:

    >>> b = 2**60000 # 2 umocněno na 60000
    >>> len(str(b))  # str() je přetypování čísla na string, len() = počet znaků
    18062            # počet znaků proměnné b
    >>> 
    
  8. Rozšiřitelný pomocí mnoha modulů

    >>> import math
    >>> math.cos(0)
    1.0
    >>> math.pi
    3.141592653589793
    
  9. Dva režimy: interaktivní (>>>) a psaní programů (soubor s příponou .py).

Jazyk Python je pojmenovaný podle pořadu společnosti BBC “Monty Python’s Flying Circus” a jeho název tedy nemá nic společného s hady. Guido van Rossum (tvůrce jazyka) je vášnivým fanouškem tohoto pořadu a při práci s Pythonem se doslova na každém rohu setkáte s proprietami majícími svůj původ v tomto pořadu.

🐍 Komentáře

Pro lepší pochopení programu, jak ostatními programátory, tak samotnými tvůrci, kteří se k programu vrátí po určité době, je vhodné jej opatřit vysvětlivkami a poznámkami, tzv. komentáři. Komentář je možné umístit na samostatný řádek nebo na konec řádku. Začíná symbolem # a končí koncem řádku. Vše, co je napsáno mezi těmito znaky, je Pythonem ignorováno.

Trojice uvozovek či apostrofů ("""...""" nebo '''...''') označuje víceřádkový komentář, případně dokumentační řetězec, pokud se vyskytuje na začátku funkce.

'''
toto je 
víceřádkový
komentář
'''

🐍 Proměnné a konstanty

V jazyce Python není nutné deklarovat typ proměnné, ani znak pro konec řádku. Proměnné vznikají automaticky při jejich prvním přiřazení. Řádek je ukončen svým koncem. Pokus o volání proměnné, které nikdy nebyla přiřazena žádná hodnota, vyvolá chybové hlášení.

Python používá dynamickou práci s typy, kdy lze proměnné opětovně přiřadit jiný objekt, a to i jiného datového typu. V interaktivním interpretu (Python IDLE) způsobí zápis proměnné vypsání její hodnoty. Proměnné v Pythonu jsou ve skutečnosti odkazy na objekty. Operátor = sváže proměnnou s objektem v paměti.

Syntaxe přiřazení (vytvoření odkazu na objekt):

proměnná = hodnota

V Pythonu existuje konstrukce pro přiřazení hodnot více proměnným v jednom řádku:

>>> a, b, c = 10, 23, "text"

Toho lze s výhodou využít např. pro výměnu obsahu dvou proměnných:

>>> a = 10
>>> b = 20
>>> a, b = b, a
>>> a
20
>>> b
10

TIP: V interaktivním režimu se na hodnotu předchozího výpočtu můžete odkazovat pomocí podtržítka _:

>>> 2 + 6
8
>>> _ * 2
16
>>> 3 + _
19
>>> a = _
>>> a
19
>>> 

Pravidla pro názvy proměnných:

Konvence pro názvy proměnných:

Stejná pravidla a konvence platí i pro názvy funkcí.

V Pythonu nelze deklarovat konstanty, typicky se deklarují jako běžné proměnné s velkými písmeny.

🐍 Datové typy

Pro manipulaci s objekty Python standardně nabízí funkce volané ve tvaru funkce(argumenty), metody volané stylem objekt.metoda(argumenty) a funkce modulů, jejichž syntaxe závisí na způsobu importu. Metoda je v podstatě funkce volaná pro určitý objekt.

Funkce type() zjistí datový typ argumentu:

>>> type(True)
<class 'bool'>
>>> type(6)
<class 'int'>
>>> type(1.2)
<class 'float'>
>>> type("Ahoj")
<class 'str'>

Čísla (int, float)

K nejpoužívanějším číselným typům na střední škole patří celá a reálná čísla:

Mezi celými čísly (integer) a čísly reálnými (floating point) se nerozlišuje deklarací datového typu, ale Python je od sebe poznává podle přítomnosti nebo nepřítomnosti desetinné tečky anebo exponentu uvozeného písmenem e či E.

>>> type(2e3)
<class 'float'>
>>> type(1.5)
<class 'float'>
>>> type(4)
<class 'int'>

Operace

Operátor Význam
+, - sčítání, odčítání
*, / násobení, dělení
** umocňování (lze i funkcí pow(x,y) xyx^y)
// celočíselné dělení, př. 5//2 vrátí 2
% zbytek po celočíselném dělení (modulo), př. 5%2 vrátí 1
divmod(x,y) vrátí podíl a zbytek po dělení čísla x číslem y jako n-tici dvou celých čísel
př. divmod(5,2) vrátí n-tici (2, 1)
+= přičtení k proměnné, např. a += 1 zvýší hodnotu proměnné a o 1.
a += b / 2 zvýší hodnotu proměnné a o polovinu hodnoty proměnné b

Obdobně fungují i operátory -= *= /= //= %=

Dále je možné využít interní funkce, které mohou operovat s čísly a funkce knihovny math, které je nutné před použitím importovat.

>>> from math import *
>>> pi
>>> 3.141592653589793
>>> 

Jestliže se v jednom výrazu objeví více operátorů, jsou operace vyhodnocovány pravidly používanými v matematice. Operátory na stejném řádku mají stejnou prioritu a vyhodnocují se zleva doprava kromě umocňování, které se vyhodnocuje zprava do leva. Prioritu je možné upravit pomocí závorek, které mají nejvyšší prioritu a tedy s nimi vyhodnocování začne. Použití závorek je vhodné i u složitějších výrazů, kde kromě požadovaného vyhodnocovaní napomáhá lepší čitelnosti.

Užitečné interní funkce:

Při převodu reálného čísla na celé pomocí funkce int() dojde k odříznutí desetinné části převáděného čísla.

Kromě výše uvedených numerických typů zvládá Python 3 i komplexních čísla pomocí funkce complex([real[, imag]]) a zlomky importem modulu fractions.

Bool

Typ bool nabývá dvou hodnot True (pravda) a False (nepravda). Pro zápis v Pythonu jsou důležitá počáteční velká písmena, true a false v něm booleovskými hodnotami nejsou. S True lze zacházet jako s číslem 1 a False 0. Booleovské (logické) operace jsou tři – and, or a not.

Relační operátory

Relační operátory při porovnávání výrazů vrací hodnoty True nebo False, jejich přehled je uveden v tabulce:

Operace Význam
<
>
menší než, větší než
<=
>=
menší nebo rovno než, větší nebo rovno než
==
!=
rovná se, nerovná se
is
is not
Operátory is a is not jsou testy pro identitu objektů, tedy výraz x is y je pravdivý pouze pokud x a y jsou jména pro totožný objekt.
in
not in
Operátory testu příslušnosti in a not in jsou podporovány pouze sekvenčními a množinovými typy a slovníkem, kde zjišťují obsah klíče. x in s se vyhodnotí na True pokud je x prvkem s, u řetězců pokud je x podřetězec s. Protože prázdný řetězec je podřetězec jakéhokoliv řetězce, bude "" in "cokoliv" vracet True.

V Pythonu nelze používat operátory <, >, <= a >= s různými datovými typy (vrátí výjimku TypeError).

Operátory is a is not jsou testy pro identitu objektů, tedy výraz x is y je pravdivý pouze pokud x a y jsou jména pro totožný objekt.

Operátory testu příslušnosti in a not in jsou podporovány pouze sekvenčními a množinovými typy a slovníkem, kde zjišťují obsah klíče. x in s se vyhodnotí na True pokud je x prvkem s, u řetězců pokud je x podřetězec s. Protože prázdný řetězec je podřetězec jakéhokoliv řetězce, bude "" in "cokoliv" vracet True.

Všechny logické operátory mají nižší prioritu než aritmetické operátory. Prioritu je možné upravit pomocí závorek, které i zlepšují čitelnost.

Řetězec (str)

Do řetězce (angl. string) můžeme uložit cokoliv, co můžeme kódovat jako text. V Pythonu 3 jsou všechny řetězce posloupnostmi znaků v Unicode. Řetězce definujeme uzavřením do apostrofů ('...') nebo do uvozovek ("..."). Je to jedno

V Pythonu není žádný typ pro znak (char), místo něj se používá řetězec s délkou jedna. Řetězce jsou neměnitelné posloupnosti (immutable sequences), není možné v nich měnit jednotlivé znaky.

Operátory:

Operátor Význam
'x' in st test příslušnosti (je 'x' obsaženo v st?)
st1 + st2 spojení řetězců
k*st k-opakování st (k je typu int)
st[i] kopie i-tého znaku (indexováno od 0)
st[i:(j+1)] kopie části řetězce od i-tého po j-tý znak (indexováno od 0)
for x in st procházení znak po znaku

Užitečné interní funkce a metody:

Jednotlivé znaky řetězce jsou zpřístupněny pomocí indexů. Číslování pořadí zepředu využívá kladná čísla a začíná 0, zezadu používá záporná čísla a začíná od –1.

+----+----+----+----+----+----+
| S  | t  | r  | i  | n  | g  |
+----+----+----+----+----+----+
| 0  | 1  | 2  | 3  | 4  | 5  |
+----+----+----+----+----+----+
| -6 | -5 | -4 | -3 | -2 | -1 |
+----+----+----+----+----+----+

K jednotlivým znakům přistupujeme pomocí indexové notace, tj. operátoru [pořadí znaku] psaného za řetězec. Výsledkem je kopie daného znaku. Úsek řetězce (angl. slice) získáme zadáním dvou indexů. Výsledkem bude nový řetězec obsahující znaky od prvního indexu po znak před druhým indexem. Pokud je první index nulový nebo druhý index poslední (zde 5), je možné je vynechat. Pomocí indexové notace a úseku nelze řetězce měnit. Řetězce je možné změnit pouze vytvořením nového řetězce, do kterého je možné přiřadit původní proměnné (pomocí indexování, výběru úseků, operátorů,…). Výběry prvků a částí mají vyšší prioritu než aritmetické a logické operátory.

Ukázka indexování a výběru úseků:

>>> s = 'String'
>>> s[0]
'S'
>>> s[1:3]
'tr'
>>> s[:2]     # řetězec od počátku po druhý znak
'St'
>>> s[2:]     # řetězec kromě prvních 2 znaků
'ring'

Escape sekvence

Python má speciální sekvence znaků, tzv. escape sekvence, které začínají zpětným lomítkem. Pokud jsou použity v řetězci je znak za zpětným lomítkem čten odlišným způsobem. Níže jsou uvedeny některé běžně používané escape sekvence v Pythonu:

Escape sekvence Představuje znak
\n nový řádek
\t tabulátor
\\ zpětné lomítko
\' apostrof
\" uvozovky
>>> print("C:\\Users\\Public\\Desktop\nCesta ke složce \"Veřejná plocha\"")
C:\Users\Public\Desktop
Cesta ke složce "Veřejná plocha"
>>>

Seznam [list]

Seznam (list) je posloupnost (tj. s definovaným pořadím prvků), která může obsahovat prvky různých datových typů (čísla, řetězce, jiné seznamy, atd.). Na rozdíl od řetězců jsou seznamy měnitelné, tedy je možné prvky přidávat, odebírat, měnit za jiné, a pod. Indexování, výběr prvku a částí seznamu je obdobné jako u řetězců, navíc je možné jejich použití pro změnu seznamu. Seznam vznikne zápisem čárkami oddělených hodnot do hranatých závorek.

Operátory:
(seznam je název proměnné)

Užitečné interní funkce a metody:
(seznam je název proměnné)

Při odstranění prvku seznamu jsou posunuty všechny následující položky tak, aby vzniklá mezera byla zaplněna.

N-tice (tuple)

N-tice (tuple) jsou podobné seznamům, ale nemohou být modifikovány, chovají se jako neměnitelné seznamy (immutable sequences). Neposkytují žádné metody, které by je dovolovaly měnit - append(), extend(), insert(), remove(), pop()…

N-tice je definována pomocí čárek:

>>> t = 1,6,8,9,36,5
>>> t
(1, 6, 8, 9, 36, 5)

Kulaté závorky je nutné použít při zápisu prázdné n-tice, tedy (), v ostatních případech jsou pomocné.

>>> n = ()
>>> n
()

Čárku je nutné napsat i v jednoprvkové n-tici, závorky je možné vynechat. Bez čárky vznikne pouze číslo:

>>> x=(3)  # Bez čárky vznikne pouze číslo
>>> x
3
>>> u=(3,) # Čárku je nutné napsat i v jednoprvkové n-tici
>>> u
(3,)
>>> v=4,   # závorky je možné vynechat
>>> v
(4,)

Můžeme používat funkce (len(), max(), min(), sum()) a operátory (+ a in), které nemění originál.

>>> t = 1,2,3
>>> u = 4,5,6
>>> t+u
(1, 2, 3, 4, 5, 6)
>>> 5 in u
True
>>> 5 in t
False

Převod n-tice <-> seznam

tuple()

Převede seznam (list) na n-tici (tuple) … “zmrazí” seznam:

>>> s = [5,8,6,2,4,10]
>>> s
[5, 8, 6, 2, 4, 10]
>>> tuple(s)
(5, 8, 6, 2, 4, 10)
>>> 

list()

Převede n-tici (tuple) na seznam (list) … “rozpustí” n-tici:

>>> n = (5, 8, 6, 2, 4, 10)
>>> n
(5, 8, 6, 2, 4, 10)
>>> seznam(n)
>>> list(n)
[5, 8, 6, 2, 4, 10]
>>> 

🐍 Vstup a výstup

Pro vstup dat z klávesnice slouží vestavěná funkce input(), kde nepovinným argumentem je řetězec, který se vypisuje jako výzva:

>>> vstup = input('Zadej cislo:')
Zadej cislo:

Funkce čeká, až uživatel zadá odpověď, kterou ukončí stiskem klávesy Enter. Vložené údaje jsou uloženy jako řetězce. Pokud je požadována číselná hodnota musí se konvertovat:

>>> vstup_cislo = int(input('Zadej cislo:'))

Příkaz print() vypíše data uživateli, přičemž v argumentu jsou zobrazované hodnoty, kterých může být více. Po přidání dalšího argumentu ve tvaru end='' bude následující výpis pokračovat na stejném řádku. Pokud end není zadán, je nastaven na \n.

Příklad výpisu na jednom řádku:

for i in range(1,10):
    print(i, end='')

123456789

🐍 Větvení (if…else)

Podmíněné větvení umožňuje Python prostřednictvím příkazu if. Začíná částí if („jestliže“), následuje žádná nebo více klauzulí elif („jestliže ne, tak zkus jestli“) a na závěr můžeme zařadit volitelnou klauzuli else („jestliže ne, tak“).

V Pythonu neexistují příkazy typu case a switch.

Běžná syntaxe:

if logický_výraz:  # dvojtečka na konci
    příkaz         # odsazeno o 4 mezery od okraje řádku  

S druhou větví:

if logický_výraz:
    příkaz
else:
    příkaz

Obecná syntaxe:

if logický_výraz1:
    příkazy1
elif logický_výraz2:
    příkazy2
elif logický_výrazN:
    příkazyN
else:
    další_příkazy

Pokud je logický_výraz1 pravdivý, provedou se příkazy1 a if se ukončí. Jinak se postupně prochází jednotlivé logické výrazy částí elif, dokud není některá z nich splněna a provedeny její příkazy. Pokud není splněna žádná z nich, provedou se další_příkazy části else.

Zkrácený příkaz if ... else na jediný podmíněný výraz:

příkaz1 if logický_výraz else příkaz2

V případě, že se logický_výraz vyhodnotí na True, bude výsledkem příkaz1, v opačném případě příkaz2.

Pokud v určité části podmíněného větvení nechceme provést žádnou akci, můžeme použít příkaz pass (“nedělej nic”).

🐍 Cykly (for, while)

for

Cyklus for v Pythonu prochází posloupnosti, pracuje tedy nad řetězci, seznamy, n-ticemi nebo dalšími iterovatelnými objekty.

Obecná syntaxe:

for proměnná in posloupnost:
    # příkazy_for
else:
    # příkazy_else

Část příkazy_for se postupně provede pro každý prvek posloupnosti uvedené za in, poté bude provedena případná část else. Nepovinná část else se v praxi, obdobně jako u cyklu while, často nevyužívá.

Posloupnost může být například seznam hodnot:

for i in 1,2,3,4,5:
	print("Pracujeme v Pythonu") 

Také lze vytvářet různé seznamy pro hodnoty proměnné cyklu, lze dokonce měnit jejich datové typy – v seznamu mohou být celá čísla, reálná čísla i řetězce:

for i in 3.14,"pes ",2+3,"{}":
	print(i*5)

Vypíše:

15.700000000000001
pes pes pes pes pes 
25
{}{}{}{}{}

Pokud je seznamem hodnot proměnné cyklu řetězec, tento se rozloží na jednotlivé znaky a příkazy v těle cyklu se vykonají pro jednotlivé znaky:

a=1
for i in 'Python':
	print(i*a)
	a=a+1

Vypíše:

P
yy
ttt
hhhh
ooooo
nnnnnn

range()

Pro generování seznamu hodnot proměnné cyklu for lze využít funkci range() v jedné ze tří verzí:

range(stop);
range(start, stop);
range(start, stop, step)

Parametr start určuje první prvek generované posloupnosti (pokud chybí, je první prvek 0). Parametr stop určuje poslední prvek, který se už v posloupnosti nebude vyskytovat. Parametr step udává hodnotu, o kterou další prvek vyšší/nižší (pokud chybí, je krok 1).

for i in range(5):
    print(i)

Vypíše 5 od 0 do n-1:

0
1
2
3
4

Generování seznamů a n-tic

Posloupnosti typu range je možné převést na seznam či n-tici pomocí funkce list() a tuple(). Tímto způsobem je i možné vytvářet seznamy a n-tice:

>>> list(range(4))        # generování seznamu (list)
[0, 1, 2, 3]
>>> tuple(range(2,10,3))  # generování n-tice (tuple)
(2, 5, 8)

Načtení hodnot ze seznamu

for i in ['jaro', 'léto', 'podzim', 'zima']:
    print(i) 

Nebo pomocí proměnné:

a = ['jaro', 'léto', 'podzim', 'zima']
for i in a:
    print(i) 

while

While je cyklus, který se neustále (cyklicky) vrací na začátek, dokud je splněna podmínka (logický výraz).

while logický_výraz:
    # příkazy

Pokud dojde k nekonečnému cyklu je možné jej v interpretu přerušit stiskem Ctrl+C nebo restartovat shell stiskem Ctrl+F6.

Obecná syntaxe:

while logický_výraz:
    příkazy_while
else:
    příkazy_else

Cyklus while spouští vnořený blok příkazy_while, dokud je logický_výraz na začátku vyhodnocen jako True. Pokud je logický_výraz hned napoprvé nepravdivý, tak se příkazy_while nespustí ani jednou. Pokud je logický_výraz vyhodnocen na False, cyklus se ukončí a provede se část else, je-li uvedena.

Break, continue a pass u cyklů

Příkaz break ukončuje cyklus, tedy přepne tok programu na příkaz následující za nejvnitřnějším cyklem, v němž se nachází.

Příkaz continue ukončuje aktuální iteraci nejbližšího vnějšího cyklu (cyklus pokračuje následující iterací).

Příkaz pass nedělá vůbec nic.

Část else se u cyklů provede jen pokud nebyl cyklus ukončen přes break.

Výše uvedené příkazy patří na střední škole spíše mezi rozšiřující učivo.

🐍 Funkce

Funkce je blok příkazů, které můžeme volat opakovaně a kterému můžeme předávat argumenty a někdy mají i návratovou hodnotu.

Obecně funkcím, které nic nevrací (jen něco udělají) se občas říká procedury. V Pythonu není hranice mezi “normální” funkcí a procedurou příliš ostrá, ale přesto se hodí tento koncept znát. Příklad: print("Python") je terminologicky procedura (nic nevrací), kdežto len("Python") je terminologicky funkce, protože vrátí 6 (počet znaků řetězce).

Obecná syntaxe uživatelské funkce:

def název_funkce (argumenty):
    příkazy
    return návratová_hodnota

Syntaxe argumentu s výchozí hodnotou:

def název_funkce (argument = výchozí_hodnota):

Funkce jsou definovány příkazem def. Argumenty jsou volitelné, pokud je jich více oddělují se čárkou. Argumenty mohou mít i výchozí hodnotu, pak se stávají nepovinnými.

Příkaz return ukončuje běh funkce a uvozuje výraz, který je vracen jako návratová hodnota. Pokud return není uveden, nebo nemá žádný argument, vrátí funkce hodnotu None.

Rekurze

Rekurzivní funkce jsou takové funkce, které opakovaně volají samy sebe pouze s jinými argumenty. Každá přímo rekurzivní funkce by měla obsahovat základní případ, pro který je definován výsledek a rekurzivní případ. Základní případ zastavuje rekurzi. Rekurzivní funkce mohou být náročné na zdroje, nicméně některé algoritmy lze pomocí nich vyjádřit nejpřirozeněji.

Příklad rekurze pro přesun kotoučů hry Hanojské věže:

def presun(n, odkud, kam, kudy):
    global i
    if n==1:        
        i = i + 1
        print(i, "...", odkud , "->", kam)
    else:
        presun(n-1, odkud, kudy, kam)
        presun(1, odkud, kam, kudy)
        presun(n-1, kudy, kam, odkud)

i = 0
kotoucu = int(input("Kolik kotoučů: "))
print("Bude potřeba", 2**kotoucu-1, "tahů.")
presun(kotoucu, "levý", "pravý", "prostřední")

Příklad:

Kolik kotoučů: 4
Bude potřeba 15 tahů.
1 ... levý -> prostřední
2 ... levý -> pravý
3 ... prostřední -> pravý
4 ... levý -> prostřední
5 ... pravý -> levý
6 ... pravý -> prostřední
7 ... levý -> prostřední
8 ... levý -> pravý
9 ... prostřední -> pravý
10 ... prostřední -> levý
11 ... pravý -> levý
12 ... prostřední -> pravý
13 ... levý -> prostřední
14 ... levý -> pravý
15 ... prostřední -> pravý
>>> 

🐍 Ošetření výjimek

Pokud dojde při běhu programu k chybě nebo výjimce, Python se obvykle zastaví a vygeneruje chybovou zprávu. Tyto výjimky lze zpracovat pomocí try příkazu:

try:
	# vykoná, pokud je vše v pořádku
except:
	# Vykoná, pokud nastne chyba

Například:

a = 5
b = 0

try:
    c = a/b
except:
    print("Nulou nepodělíš!")

🐍 Moduly

Modul je samostatný soubor definující skupinu funkcí Pythonu nebo jiných objektů pro opakované použití.

Objekty modulu lze importovat více způsoby:

import jmenomodulu

vyhledá modul jmenomodulu, zanalyzuje jeho obsah a zpřístupní jej. Při použití objektů modulu je třeba uvést i jméno modulu. Např:

>>> import math
>>> math.cos(0)
1.0
>>> math.pi
3.141592653589793

Tento způsob je i bezpečnější, protože nehrozí chyby způsobené kolizí jmen.

from jmenomodulu import jmeno1, jmeno2, ...

zpřístupní objekty jmeno1, jmeno2, … bez nutnosti uvádět jméno modulu.

from jmenomodulu import *

naimportuje všechny objekty daného modulu bez nutnosti uvádět jméno modulu při jejich použití. Hvězdička (*) zastupuje jména všech objektů definovaných v modulu. Pokud je v našem kódu či v jiném importovaném modulu objekt stejného jména, dojde k chybě způsobené kolizí jmen.

>>> from math import *
>>> pi
3.141592653589793
>>> cos(0)
1.0

Funkce dir(jmenomodulu) zobrazí seznam všech jmen definovaných modulem v argumentu.

>>> from math import *
>>> dir(math)
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc']
>>>

Funkce help(objekt) zavolá v interaktivním režimu nápovědu pro objekt v argumentu.

Modul math

Vestavěný modul math poskytuje matematické funkce a konstanty, jako je například odmocňování, goniometrické funkce a konstanta π\pi. V tabulce jsou uvedeny konstanty a funkce, které se vyskytují ve středoškolské matematice.

Import modulu (varianta 1) bezpečné proti možným kolizím se jmény proměnných:

import math          # zápis funkce:  math.pi, math.e, math.sin()

Import modulu (varianta 2): možné kolize se jmény proměnných e nebo pi

from math import *   # zápis funkce:  pi, e, sin()
Funkce a konstanty (výběr) Popis
math.sin() vrátí sinus úhlu zadaného v radiánech
math.cos() vrátí kosinus úhlu zadaného v radiánech
math.tan() vrátí tangens úhlu zadaného v radiánech
math.asin() vrátí velikost úhlu z hodnoty sinu (v radiánech)
math.acos() vrátí velikost úhlu z hodnoty kosinu (v radiánech)
math.atan() vrátí velikost úhlu z hodnoty tangens (v radiánech)
math.radians(s) převede číslo s ze stupňů na radiány
math.degrees(r) převede číslo r z radiánů na stupně
math.pi konstanta π\pi = 3.141592653589793
math.e konstanta ee = 2.718281828459045
math.ceil(x) vrátí x\lceil x \rceil, tj. nejmenší celé číslo (int) větší nebo stejné jako x,
př. ceil(5.4) == 6
math.floor(x) vrátí x\lfloor x \rfloor, tj. největší celé číslo (int) menší nebo stejné jako x,
př. floor(5.4) == 5
math.trunc(x) vrátí celou část x jako číslo typu int (stejné jako int(x))
math.pow(x, y) vrátí xyx^y
math.sqrt(x) vrátí x\sqrt{x}
math.exp(x) vrátí exe^x
math.log(x, b) vrátí logb(x)\log_b(x) (bb je volitelné, výchozí hodnota je ee)
math.log10(x) vrátí log10(x)\log_{10}(x)
math.factorial(x) vrátí x!x!
math.hypot(x,y) vrátí odmocninu z x2+y2\sqrt{x^2 + y^2}, př. math.hypot(3,4) == 5
math.copysign(x,y) vrátí číslo x se znaménkem čísla y

Modul datetime

Vestavěný modul datetime umožňuje vytvářet datum a čas a pracovat s nimi. Práce s datem a časem je složité téma, proto jsou uvedeny jen základní funkce a způsoby vytvoření dat.

Import modulu:

import datetime

Některé funkce a metody modulu datetime:

Modul random

Vestavěný modul random je určen pro různé způsoby generování náhodných čísel.

Import modulu:

import random

Některé funkce a metody modulu random:

🐢 Modul turtle

Populární způsob vysvětlení základů programování je pomocí “želví grafiky”, která byla součástí programovacího jazyka Logo, jenž vyvinuli Wally Feurzig a Seymour Papert v roce 1966. Lze nalézt samostatně, je však i standardní součástí Pythonu. Pomocí příkazů, je možné vykreslovat různé tvary a obrázky. Následuje výčet funkcí, které mohou být vhodné při řešení jednodušších příkladů na SŠ:

Import modulu (nejjednodušší na psaní programů):

from turtle import *

Vytvoření a změna želvy:

Pohyb želvy:

Ve výchozí pozici je želva uprostřed okna (pozice 0,00,0) a je otočena vpravo.

Práce s oknem:

from turtle import *

def stromek(delka):    
    forward(delka)
    if delka > 5:
        left(45)
        stromek(0.6 * delka) #rekurzivní volání funkce s jiným parametrem
        right(90)
        stromek(0.6 * delka) #rekurzivní volání funkce s jiným parametrem
        left(45)
    back(delka)   

shape("turtle") # tvar zelvy
speed(2)        # rychlost zelvy
home()          # jdi domu
left(90)        # otoc se 90st vlevo

stromek(45)     # vykresli stromek s délkou 45 px

Modul tkinter

tkinter je modul (knihovna) pro programovací jazyk Python, která umožňuje v Pythonu vytvářet okna. Prostě grafická okna jak je je znáte z Windows či linuxové KDE/GNOME. Modul se dodává společně s instalací Pythonu a je tak dostupný všude, kde je Python. Funguje stejně na na Linuxu i Windows, takže váš program funguje bez jakýchkoliv změn tam i tam. Grafické rozhraní je poskytováno přes mnoho modulů. Nejdůležitější je samotný modul tkinter. Před použitím je nutné jej naimportovat:

import tkinter

Příklad pro vykreslení třístupňové pyramidy:

import tkinter
canvas = tkinter.Canvas() # vytvoř okno a pojmenuj ho canvas
canvas.pack()

canvas.create_rectangle(100, 200, 100 + 150, 200 + 50)
canvas.create_rectangle(100 + 25, 150, 100 + 150 - 25, 150 + 50)
canvas.create_rectangle(100 + 50, 100, 100 + 150 - 50, 100 + 50)

Modul matplotlib

Modul kreslí všemožné grafy viz https://matplotlib.org/

import matplotlib.pyplot as plt #import modulu pyplot z modulu matplotlib (jmeno plt) 
num = (7,22,11,34,17,52,26,13,40,20,10,5,16,8,4,2,1) #n-tice nebo seznam
plt.plot(num)
plt.show()

graf

🐍 Práce se soubory

Pro čtení a zápis textových souborů se musí nejprve otevřít pomocí funkce open() a po ukončení práce opět zavřít použitím close().

Syntaxe funkce open:

s = open('jmeno_souboru', 'mod')

Je třeba dát pozor, abyste pracovali v adresáři do kterého máte právo čtení a zápisu. Ve Windows bude třeba zadat i cestu, kde je nutné použít escape sekvenci pro zápis zpětného lomítka, např.:

s = open('C:\\Users\\10XPrijmeniJ\\Documents\\Python\\cviceni\\text.txt', 'w')

Ve Windows je také nutné respektovat, že se uživatelské složky jmenují jinak, než je u nich napsané:

Viditelný název Skutečný název
Dokumenty Documents
Plocha Desktop
Obrázky Pictures
Stažené soubory Downloads

Soubor je možné otevřít v několika režimech, které jsou nepovinné. Pokud není zadán, je nastaven na r. Pokud soubor neexistuje, bude v režimu w a a automaticky vytvořen. V režimu w je existující soubor přepsán.

Metody pro čtení a zápis:

Pokud se při čtení dostaneme na konec souboru, je všemi těmito metodami vracen prázdný řetězec.

Příkaz with

Pro práci se soubory nabízí Python speciální příkaz with, který po skončení soubor uzavře a to i v případě pokud kód vyvolá výjimku.

Syntaxe příkazu with:

with open('jmeno_souboru', 'mod') as promenna:
    prikazy

Moduly os a glob

Další možnosti získávání informací a manipulací se soubory a navíc i adresáři umožňuje modul os, což je zkratka pro operační systém. Pro práci s adresáři (například získání obsahu určitého adresáře) lze využít také modul glob. Oba moduly jsou součástí standardní pythonovské knihovny.

Tímto stručným výčtem možnosti Pythonu zdaleka nekončí.