Tvorba internetových aplikací

Jakub Klinkovský

:: České vysoké učení technické v Praze
:: Fakulta jaderná a fyzikálně inženýrská
:: Katedra softwarového inženýrství

Jazyk Python

Představení jazyka Python

Z předchozí přednášky:

Python je obecný, vysokoúrovňový, dynamický, interpretovaný programovací jazyk

Existuje několik implementací (interpreterů), např.
CPython, PyPy, IronPython, Jython, atd.
My budeme používat referenční implementaci CPython.

Prostředí jazyka Python

Ke stažení – aktuální verze 3.11 (případně stačí starší, např. školní počítače).

Poznámka: v systémech Linux a macOS je Python typicky předinstalovaný jako systémový balíček (ale nemusí být aktuální verze).

Prostředí jazyka Python obsahuje:

• interpreter – příkaz python (nebo python3) v terminálu (PowerShell nebo bash)
• správce balíčků pip (nebo pip3)
• defaultní sada modulů (balíčků) – standardní knihovna
• jednoduché IDE (Integrated Development and Learning Environment, IDLE)

Poznámka: některé moduly lze použít přímo z terminálu (např. venv pro správu virtuálních prostředí)

Použití interpreteru jazyka Python

1. Spuštění skriptu (programu) z terminálu:

   python skript.py
   

2. „Automatické“ spuštění skriptu (programu):
   1. Linux a macOS – nastavení spustitelného bitu:

      chmod +x skript.py
      ./skript.py
      

   2. Windows – „Otevřít pomocí“, vybrat Python
3. Interaktivní shell – příkaz python v terminálu nebo vybrat v grafickém menu
4. Spuštění modulu v terminálu: python -m MODULE --help
   Např. python -m pip --help (ekvivalentní příkazu pip --help)

Použití příkazu pip – instalace balíčku IPython

IPython poskytuje interaktivní shell pro Python s pokročilými funkcemi (např. tab-completion).

Instalace: použijeme příkaz pip install ipython
(případně python -m pip install ipython)

Spuštění: příkaz ipython v terminálu nebo vybrat v grafickém menu

Další podpříkazy pro správu balíčků:

• pip list – zobrazí nainstalované balíčky
• pip uninstall PACKAGE – odinstalování balíčku
• pip help – zobrazí nápovědu a další možnosti

Práce s IPythonem

Užitečné klávesové zkratky (úplný seznam):

• šipky nahoru/dolů – navigace v historii
• ctrl+e, ctrl+f, šipka doprava – přijme našeptaný text
• tab (pokud není na začátku řádku) – navigace v kontextovém našeptávači
• ctrl+o – vloží nový řádek za kurzor

Vývojová prostředí pro Python

• Stačí libovolný textový editor, např. Notepad++, gedit, Vim
  (Ne Notepad ani Wordpad!)
• IDE navržená přímo pro Python: PyCharm, Eric, Spyder, ...
• Obecná IDE s podporou pro Python: Visual Studio Code, Eclipse, ...

Důležitá nastavení pro textové editory:

• Odsazování pomocí 4 mezer, ne znak \t
• Automatické odsazování (např. za řádkem končícím znakem :)
• Unixové konce řádků (znak \n neboli LF)
• Kódování UTF-8

Syntaxe jazyka Python – proměnné

V shellu ipython:

In [1]: a = 42                  # nastaví hodnotu proměnné

In [2]: a                       # zobrazí hodnotu výrazu
Out[2]: 42

In [3]: a - 10                  # zobrazí hodnotu výrazu
Out[3]: 32

In [4]: a = "Hello, world!"     # předefinování proměnné (nezáleží na typu)

In [5]: a                       # zobrazí hodnotu výrazu
Out[5]: 'Hello, world!'

In [6]: len(a)                  # na stringy lze použít funkci len()
Out[6]: 13

Syntaxe jazyka Python – operátory

+       -       *       **      /       //      %      @
<<      >>      &       |       ^       ~       :=
<       >       <=      >=      ==      !=

Použití operátorů závisí na typu objektů, např.:

In [7]: a + 3
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[7], line 1
----> 1 a + 3

TypeError: can only concatenate str (not "int") to str

In [8]: a + str(3)
Out[8]: 'Hello, world!3'

Syntaxe jazyka Python – klíčová slova

• hodnoty: True, False, None
• řízení: if, else, elif, for, while, break, continue, pass, try, except, finally, raise, return, yield
• operátory: and, or, not, is, in
• strukturování: def, class, lambda, import, from
• ostatní: global, nonlocal, with, as, assert, del, async, await

Dále některá slova (match, case, _) jsou klíčová jen v určitém kontextu.

Dále identifikátory začínající _ nebo __ mají speciální význam.

Podmínky a cykly

In [9]: a = 4

In [10]: if 0 <= a < 10:           # ekvivalentně:  if 0 <= a and a < 10:
    ...:     print("a je v intervalu [0, 10)")
    ...: elif a < 0:
    ...:     print("a je záporné")
    ...: else:
    ...:     print("a je dvojciferné nebo větší")
    ...:
a je v intervalu [0, 10)

In [11]: for i in range(10):
    ...:     print(i, end=" ")
    ...:
0 1 2 3 4 5 6 7 8 9

Poznámka: Za řádkem ukončeným znakem : musí vždy následovat odsazený blok!

Funkce

In [12]: def ask(question):
    ...:     answer = input(question + " ")
    ...:     return int(answer)

In [13]: a = ask("Jaká je odpověď na základní otázku života, vesmíru a vůbec?")

Python umožňuje definovat defaultní hodnoty, poziční a keyword parametry.

Jakými způsoby lze zavolat tuto funkci?

In [12]: def f(a, /, b=2, *, c=3):
    ...:     print(a, b, c)

In [13]: f(a=0, b=1, c=2)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[65], line 1
----> 1 f(a=0, b=1, c=2)

TypeError: f() got some positional-only arguments passed as keyword arguments: 'a'

Vestavěné objekty

• print(), input() – funkce pro datový výstup a vstup
• str(), int(), float(), bool() – konverze datových typů
• list(), tuple(), dict(), set() – datové struktury
• dir() – funkce pro introspekci objektu (vrátí seznam jeho atributů a metod)
• další: viz dir(__builtins__)

Zpracování chyb

• Kontrola probíhá až při běhu programu (až na základní syntaktickou analýzu)
• Při každé operaci může vzniknout výjimka (např. SyntaxError, NameError, TypeError, nebo ValueError)

In [14]: try:
    ...:     a = ask("Jaká je odpověď na základní otázku života, vesmíru a vůbec?")
    ...: except ValueError as e:
    ...:     print("špatná odpověď")
    ...: finally:
    ...:     print("zadávání ukončeno")

Datové struktury: seznam, tuple, slovník, množina

In [15]: seznam = [0, 1, "a", "b", 1]         # seznam  ... list
In [16]: tpl = (0, 1, "a", "b", 1)            # tuple   ... immutable list
In [17]: mnozina = {0, 1, "a"}                # množina ... set
In [18]: slovnik = {"a": 0, "b": 1, "c": 10}  # slovník ... dictionary

In [19]: for i in seznam:                     # analogicky pro tuple a set
    ...:     print(i, end=" ")
0 1 a b 1

In [20]: for key, value in slovnik.items():   # další atributy: .keys() .values()
    ...:     print(key, value)
    ...:
a 0
b 1
c 10

Dostupné metody: viz dir(list), dir(tuple), dir(set), dir(dict)

Proměnlivost datových struktur

Pozor: proměnné pro datové struktury v Pythonu fungují jako „reference“:

In [1]: a = [0, 1]
In [2]: b = a
In [3]: b.append(2)

In [4]: a
Out[4]: [0, 1, 2]

In [5]: b
Out[5]: [0, 1, 2]

Indexování lineárních datových struktur

In [1]: s = "Hello"

• s[1:4] == "ell" – znaky v rozsahu indexů od 1 (včetně) po 4 (vyjma)
• s[1:] == "ello" – znaky v rozsahu indexů od 1 (včetně) až do konce
• s[:4] == "Hell" – znaky od začátku po index 4 (vyjma)
• s[:] == "Hello" – znaky od začátku až do konce (kopie řetězce)
• s[1:100] == "ello" – automatické useknutí koncového indexu

Poznámka: oba indexy mohou být záporné (viz obrázek)
Poznámka: stejným způsobem funguje indexování pro seznam a tuple

Textové řetězce

Tři způsoby zápisu:

1. Jednoduché uvozovky: 'a "b" c'
2. Dvojité uvozovky: "a 'b' c"
3. Trojité uvozovky: """string""", '''string''' (víceřádkový)

Vše vede na objekty typu str – vícebajtový textový řetězec kódovaný pomocí Unicode.

Modifikátory:

• r (raw): r"string\n" (znak \ nemá speciální význam)
• f (format): viz dále
• b (bytes): objekt typu bytes namísto str (např. b"ASCII-only text")

Poznámka: str.encode() → bytes, bytes.decode() → str

Formátování stringů

Způsoby formátování:

a = 10
s1 = "a = %d" % a
s2 = "a = {}".format(a)
s3 = f"a = {a}"
s4 = f"{a=}"
s5 = f"{a:0>5d}"

Viz f-string a format specification mini-language.

Čtení a zápis souborů

Funkce open(), která se používá jako context manager:

In [1]: with open("pokus.txt", "w") as f:
   ...:     print("Hello, world!", file=f)

In [2]: with open("pokus.txt", "r") as f:
    ..:     for line in f.readlines():
    ..:         print(line)
Hello, world!