Python 3.14: t-řetězce, barvičky, lepší nápověda a odcházející GIL

Obsah

1. Python 3.14 – evoluce, nikoli revoluce

2. Krátké ohlédnutí do minulosti: Python 1, 2 a 3

3. Novinky představené v Pythonu 3.14

4. Praktická část

5. Instalace Pythonu 3.14 s využitím nástrojů pdm nebo uv

6. Překlad Pythonu 3.14 ze zdrojových kódů

7. Barevné zvýraznění REPLu interpretru jazyka Python

8. Barevné zvýraznění nápovědy modulu argparse

9. Barevné zvýraznění výstupu generovaného standardním modulem unittest

10. Vylepšená nápověda při nesprávném zápisu klíčového slova nebo identifikátoru

11. Vylepšení syntaxe a sémantiky jazyka Python

12. Zjednodušení zápisu zachycení většího množství výjimek v jediném bloku except

13. Kdy je možné zapsat typy výjimek bez kulatých závorek?

14. Detekce explicitního výskoku z bloku finally

15. Motivace a ukázky kódu

16. Podpora pro t-řetězce

17. Ukázky rozdílů mezi f-řetězci a t-řetězci

18. Obsah navazujícího článku

19. Repositář s demonstračními příklady

20. Odkazy na Internetu

1. Python 3.14 – evoluce, nikoli revoluce

Jak již bylo napsáno v perexu dnešního článku, byl minulý týden oficiálně vydán Python 3.14. Python je živým a neustále se vyvíjejícím programovacím jazykem, takže asi nebude příliš překvapující, že i ve verzi 3.14 nalezneme relativně velké množství změn, které jsou přímo viditelné (změna syntaxe a sémantiky Pythonu, obarvení syntaxe v interpretru atd.).

Více změn a vylepšení se však nachází „pod kapotou“, tj. v implementaci vlastního interpretru Pythonu (s i bez GILu), automatického správce paměti (garbage collector), či například vylepšeného rozhraní umožňujícího připojení debuggerů k interpretru. V dnešním článku i v článku navazujícím si tyto změny a vylepšení postupně popíšeme a samozřejmě si většinu z nich i ukážeme na demonstračních příkladech.

2. Krátké ohlédnutí do minulosti: Python 1, 2 a 3

Ještě před popisem novinek představených v Pythonu 3.14 se krátce zmiňme o vývoji tohoto dnes pravděpodobně nejpopulárnějších programovacího jazyka. První stabilní verze programovacího jazyka Python byla vydána již pradávno, konkrétně v roce 1994 a verze 1.x byly postupně vydávány až do roku 2001 (!), v němž vyšla poslední jedničková verze 1.6.1, která celou řadu Python 1 oficiálně uzavřela. V Pythonu 1 ještě pochopitelně nenalezneme všechny vlastnosti, které známe ze stále ještě částečně rozšířeného Pythonu 2 nebo Pythonu 3 (který dnes Python 2 postupně nahrazuje, i když je zajímavé, že ho ještě zcela nenahradil).

Například řetězce byly v Pythonu 1 ještě čistě osmibitové (ASCII), zatímco už v Pythonu 2 bylo možné použít Unicode řetězce. Dále v Pythonu 1 nebyla podporována takzvaná generátorová notace a od ní odvozené konstrukce pro inicializaci seznamů, množin a slovníků. Taktéž ale neexistovaly ani operátory spojené s operací přiřazení, tedy například operátor +=, |= apod. Tyto varianty operátorů byly přidány až do Pythonu 2; inspirací byly v této oblasti pochopitelně především céčkové programovací jazyky. A konečně, v Pythonu 1 neměly řetězce žádné metody, například string.startswith atd. – i tato funkcionalita byla přidána až v Pythonu 2.

V následující tabulce jsou vypsány všechny oficiálně vydané verze Pythonu 1:

Oficiální vydání Pythonu 2.0 datujeme na 16. říjen 2000. Python 2 byl velmi úspěšným projektem, který do značné míry zajistil Pythonu místo na samotném vrcholu popularity programovacích jazyků. Ovšem již v roce 2008 vyšel Python 3.0 (založený na PEP 3000, což bylo někdy spojováno do označení „Python 3000“), který je s verzí 2 částečně nekompatibilní.

Právě popularita a velké rozšíření Pythonu 2 a jeho balíčků na jedné straně a nekompatibilita Pythonu 3 na straně druhé zapříčinila více než desetileté schizma světa Pythonu, které je teprve postupně napravováno s tím, jak se stále více balíčků a aplikací portuje na Python 3 (a v některých oblastech ani zdaleka není ukončeno, nicméně všechny nejdůležitější knihovny jsou již nabízeny buď výhradně pro Python 3 nebo jak pro Python 2, tak i pro Python 3).

Opět si pochopitelně vypíšeme data vydání různých verzí Pythonu 2 (bez „setinkových“ vydání):

Žádná z těchto verzí Pythonu již není oficiálně podporována a doporučuje se, aby všechny nové projekty vznikaly již pro Python 3. Python 3.0, tedy první verze Pythonu řady 3, byla vydána v prosinci 2008. Za zmínku stojí „překryv“ v současném vydávání Pythonu 2.x a 3.x:

3. Novinky představené v Pythonu 3.14

Jak jsme si již naznačili v úvodní kapitole, některé ze změn provedené v Pythonu verze 3.14 se týkají samotného jazyka, i když oproti „malým revolucím“ z minulosti (async+await, generické datové typy, skupiny výjimek atd.) se ve verzi 3.14 jedná spíše o kosmetická vylepšení. Vylepšila se však uživatelská přítulnost, protože REPL Pythonu nově podporuje zvýraznění syntaxe, obarvena je i nápověda generovaná standardním modulem argparse nebo výsledky jednotkových testů.

Nejvýznamnější změny jsou ty nejméně viditelné, protože jsou schované „pod kapotou“. Týká se to vylepšení interpretru bez GILu, možnosti běhu většího množství interpretrů, vylepšení automatického správce paměti či podpoře pro připojení debuggeru k již běžícímu interpretru:

4. Praktická část

Ve druhé části dnešního článku si některé výše zmíněné novinky představené v Pythonu 3.14 ukážeme prakticky. Nejdříve si řekneme, jakým způsobem je vlastně možné Python 3.14 nainstalovat v případě, že nejsou k dispozici oficiální balíčky pro vaši distribuci Linuxu (a to většinou v době psaní článku – 10. října – ještě nejsou). Dále si ukážeme vylepšení spočívající v obarvení různých typů výstupů, vylepšená chybová hlášení při nalezení klíčových slov a identifikátorů, u nichž došlo k přepisu (chybějící znak atd.).

Posléze se budeme věnovat těm novinkám, které byly představeny a popsány v PEP-758 (zjednodušení zápisu zachycení většího množství výjimek), PEP-765 (detekce výskoku z bloku finally) a PEP-750 (t-řetězce). Vylepšení a zrychlení samotného interpretru (alternativní provádění bajtkódu, vylepšení noGILu atd.) však budou vzhledem k velkému rozsahu změn popsána až v navazujícím článku.

5. Instalace Pythonu 3.14 s využitím nástrojů pdm nebo uv

Python 3.14 je možné nainstalovat několika způsoby. Nejjednodušší je situace v případě, že je tato verze Pythonu dostupná přímo v balíčcích vámi používané distribuce Linuxu. V takovém (ideálním) případě postačuje použít apt, dnf atd. a popř. si upravit alternatives.

Pokud Python 3.14 dostupný není, můžeme se ho pokusit nainstalovat s využitím nástrojů pdm nebo uv, které Python zvolené verze (nebo verzí) dokážou pro uživatele doinstalovat, a to bez nutnosti mít k dispozici administrátorská práva. Ukažme si celý postup při použití balíčku uv.

Zjištění, které verze Pythonu jsou již nainstalovány:

$ uv python list
 
cpython-3.13.3-linux-x86_64-gnu     /usr/bin/python3.13
cpython-3.12.10-linux-x86_64-gnu    /usr/bin/python3.12
cpython-3.12.10-linux-x86_64-gnu    /usr/bin/python3 -> python3.12
cpython-3.12.10-linux-x86_64-gnu    /usr/bin/python -> ./python3
cpython-3.11.12-linux-x86_64-gnu    /usr/bin/python3.11

Instalace Pythonu 3.14:

$ uv python install 3.14
 
Installed Python 3.14.0rc2 in 3.74s
 + cpython-3.14.0rc2-linux-x86_64-gnu (python3.14)

Ve skutečnosti se nemusí nainstalovat oficiální verze 3.14, ale typicky se nainstaluje verze starší!

Kontrola, zda došlo k instalaci a jakou verzi Pythonu jsme vlastně nainstalovali:

$ whereis python3.14
 
python3.14: /home/ptisnovs/.local/bin/python3.14
 
 
 
$ uv run python3.14 --version
 
Python 3.14.0rc2
 
 
 
$ uv run python3.14
 
Python 3.14.0rc2 (main, Aug 18 2025, 19:19:22) [Clang 20.1.4 ] on linux
Type "help", "copyright", "credits" or "license" for more information.

V adresáři /home/${USER}/.local/bin/pyt­hon3.14 by měly být uloženy následující soubory:

$ ls -lah
total 30M
drwxr-xr-x. 1 ptisnovs ptisnovs  192 Oct 10 13:04 .
drwxr-xr-x. 1 ptisnovs ptisnovs   36 Oct 10 13:04 ..
lrwxrwxrwx. 1 ptisnovs ptisnovs    8 Oct 10 13:04 idle3 -> idle3.14
-rwxr-xr-x. 1 ptisnovs ptisnovs  156 Oct 10 13:04 idle3.14
-rwxr-xr-x. 1 ptisnovs ptisnovs  286 Oct 10 13:04 pip
-rwxr-xr-x. 1 ptisnovs ptisnovs  286 Oct 10 13:04 pip3
-rwxr-xr-x. 1 ptisnovs ptisnovs  286 Oct 10 13:04 pip3.14
lrwxrwxrwx. 1 ptisnovs ptisnovs    9 Oct 10 13:04 pydoc3 -> pydoc3.14
-rwxr-xr-x. 1 ptisnovs ptisnovs  141 Oct 10 13:04 pydoc3.14
lrwxrwxrwx. 1 ptisnovs ptisnovs   10 Oct 10 13:04 python -> python3.14
lrwxrwxrwx. 1 ptisnovs ptisnovs   10 Oct 10 13:04 python3 -> python3.14
-rwxr-xr-x. 1 ptisnovs ptisnovs  30M Oct 10 13:04 python3.14
-rwxr-xr-x. 1 ptisnovs ptisnovs 3.2K Oct 10 13:04 python3.14-config
lrwxrwxrwx. 1 ptisnovs ptisnovs   17 Oct 10 13:04 python3-config -> python3.14-config

6. Překlad Pythonu 3.14 ze zdrojových kódů

Pokud si chcete vyzkoušet stabilní a oficiálně vydaný Python 3.14, postačuje si ze stránek www.python.org/downloads/ stáhnout archiv (zkomprimovaný tarball), ten rozbalit a použít klasickou kombinaci příkazů (je nutné mít nainstalován překladač céčka, včetně jeho sady nástrojů, a navíc i nástroj make):

$ cd Python-3.14.0
$ ./configure
$ make

Průběh překladu (jen krátká ukázka):

...
...
...
gcc  -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O3 -Wall    -std=c11 -Wextra -Wno-unused-parameter -Wno-missing-field-initializers -Wstrict-prototypes -Werror=implicit-function-declaration -fvisibility=hidden  -I./Include/internal -I./Include/internal/mimalloc  -I. -I./Include    -fPIC -c ./Modules/_testcapi/config.c -o Modules/_testcapi/config.o
gcc  -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O3 -Wall    -std=c11 -Wextra -Wno-unused-parameter -Wno-missing-field-initializers -Wstrict-prototypes -Werror=implicit-function-declaration -fvisibility=hidden  -I./Include/internal -I./Include/internal/mimalloc  -I. -I./Include    -fPIC -c ./Modules/_testcapi/import.c -o Modules/_testcapi/import.o
gcc  -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O3 -Wall    -std=c11 -Wextra -Wno-unused-parameter -Wno-missing-field-initializers -Wstrict-prototypes -Werror=implicit-function-declaration -fvisibility=hidden  -I./Include/internal -I./Include/internal/mimalloc  -I. -I./Include    -fPIC -c ./Modules/_testcapi/frame.c -o Modules/_testcapi/frame.o
gcc  -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O3 -Wall    -std=c11 -Wextra -Wno-unused-parameter -Wno-missing-field-initializers -Wstrict-prototypes -Werror=implicit-function-declaration -fvisibility=hidden  -I./Include/internal -I./Include/internal/mimalloc  -I. -I./Include    -fPIC -c ./Modules/_testcapi/type.c -o Modules/_testcapi/type.o
 
sed -e "s,/usr/bin/env python3,/usr/local/bin/python3.14," < ./Tools/scripts/idle3 > build/scripts-3.14/idle3.14
sed -e "s,/usr/bin/env python3,/usr/local/bin/python3.14," < ./Tools/scripts/pydoc3 > build/scripts-3.14/pydoc3.14
sed -e "s,@EXENAME@,/usr/local/bin/python3.14," < ./Misc/python-config.in >python-config.py
LC_ALL=C sed -e 's,\$(\([A-Za-z0-9_]*\)),\$\{\1\},g' < Misc/python-config.sh >python-config
The following modules are *disabled* in configure script:
_sqlite3
 
The necessary bits to build these optional modules were not found:
_dbm                  _gdbm                 _tkinter
_uuid                 readline
To find the necessary bits, look in configure.ac and config.log.
 
Checked 114 modules (36 built-in, 71 shared, 1 n/a on linux-x86_64, 1 disabled, 5 missing, 0 failed on import)
./python -E ./Tools/build/generate-build-details.py `cat pybuilddir.txt`/build-details.json

Výsledkem je spustitelný soubor python, který je již pěkný bumbrlíček (Python 1 se vešel na disketu):

$ ls -lah python 
 
-rwxr-xr-x. 1 ptisnovs ptisnovs 33M Oct 10 13:26 python

Po překladu je možné Python nainstalovat příkazem:

$ sudo make install

popř. je možné pouze symlinkovat výsledný spustitelný soubor python do ~/bin/ atd. (podle nastavení cest).

Kontrola verze Pythonu (zde konkrétně příkaz spouštím z adresáře, ve kterém byl proveden překlad):

$ ./python --version
 
Python 3.14.0

Spuštění interpretru Pythonu:

$ ./python
 
Python 3.14.0 (main, Oct 10 2025, 13:26:39) [GCC 14.2.1 20240912 (Red Hat 14.2.1-3)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

7. Barevné zvýraznění REPLu interpretru jazyka Python

Nejdříve se podívejme na změny a vylepšení, které jsou patrné na první pohled. Už při prvním spuštění interaktivní smyčky (REPL – Read Eval Print Loop) interpretru Pythonu zjistíme, že je nyní celé prostředí „barevnější“ a začíná tak do jisté míry připomínat populární IPython. Pro tuto novou vlastnost platí více než jinde, že jeden obrázek vydá za stovky slov, takže si pouze ukažme, jak vlastně nyní vypadá typické „sezení“ s REPLem (interaktivním prostředím) Pythonu:

Obrázek 1: Barevné zvýraznění REPLu Pythonu 3.14

Autor: tisnik, podle licence: Rights Managed

Podpora pro obarvený výstup byla přidána již v Pythonu 3.13, nyní se však provádí i obarvení syntaxe.

Z vývoje, který můžeme v posledních letech sledovat, to vypadá, že terminálové aplikace zažívají vzestup. Možná za to může velmi dobrá podpora pro barevný výstup v moderních emulátorech terminálu, podpora Unicode znaků a taktéž existence nástrojů typu tmux.

8. Barevné zvýraznění nápovědy modulu argparse

Došlo i k vylepšení standardního modulu argparse, který se používá pro definici přepínačů na příkazovém řádku i pro zpracování zadaného příkazového řádku. Tento modul podporuje i přepínače -h a –help, které zobrazí automaticky generovanou nápovědu (argparse zná všechny přepínače i jejich popis). Tato nápověda je nově zobrazena s obarveným textem, stejně jako krátká nápověda Usage zobrazená tehdy, pokud uživatel zadá neplatný přepínač.

Tato změna se dotkne všech aplikací, které se spouští z příkazového řádku a které modul argparse používají. Ukažme si to na jednoduchém příkladu, ve kterém je definováno několik přepínačů s jejich popisem, datovým typem i výchozí hodnotou:

from argparse import ArgumentParser
 
 
def main():
    parser = ArgumentParser()
    parser.add_argument(
        "-v",
        "--verbose",
        dest="verbose",
        help="make it verbose",
        action="store_true",
        default=None,
    )
    parser.add_argument(
        "-n",
        "--no-colors",
        dest="nocolors",
        help="disable color output",
        action="store_true",
        default=None,
    )
    parser.add_argument(
        "-d",
        "--directory",
        dest="directory",
        help="directory with JSON files to check",
        action="store",
        default=".",
    )
    parser.add_argument(
        "--timeout",
        type=int,
        default=30,
        help="Request timeout in seconds (default: 30).",
    )
 
    args = parser.parse_args()
 
    print(args)
 
 
if __name__ == "__main__":
    main()

Porovnejme si zobrazení nápovědy v Pythonu 3.13 a Pythonu 3.14:

Obrázek 2: Nápověda s přepínači aplikace, zobrazeno Pythonem 3.13.

Autor: tisnik, podle licence: Rights Managed

Při použití interpretru Pythonu 3.14 se bude skript chovat odlišně:

Obrázek 3: Nápověda s přepínači aplikace, zobrazeno Pythonem 3.14.

Autor: tisnik, podle licence: Rights Managed

9. Barevné zvýraznění výstupu generovaného standardním modulem unittest

Barevně jsou zvýrazněny i výsledky jednotkových testů, ovšem za předpokladu, že se pro jejich definici použije standardní modul unittest (změna interpretru Pythonu pochopitelně nemá podobný vliv na moduly třetích stran, například na modul pytest). Opět se podívejme na jednoduchý příklad. Tentokrát se bude jednat o výpočet množiny prvočísel až do zadaného limitu. Algoritmus výpočtu vypadá následovně (a je nyní jedno, že může být optimalizován):

"""Výpočet seznamu prvočísel až do zadaného limitu."""
 
# originální kód lze nalézt na adrese:
# http://www.rosettacode.org/wiki/Sieve_of_Eratosthenes#Odds-only_version_of_the_array_sieve_above
 
 
def primes2(limit):
    """Výpočet seznamu prvočísel až do zadaného limitu."""
    # okrajový případ
    if limit < 2:
        return []
 
    # druhý případ - 2 je speciálním prvočíslem
    if limit < 3:
        return [2]
 
    lmtbf = (limit - 3) // 2
 
    # naplnění tabulky, která se bude prosívat
    buf = [True] * (lmtbf + 1)
 
    # vlastní prosívání
    for i in range((int(limit ** 0.5) - 3) // 2 + 1):
        if buf[i]:
            p = i + i + 3
            s = p * (i + 1) + i
            buf[s::p] = [False] * ((lmtbf - s) // p + 1)
 
    # vytvoření seznamu prvočísel
    return [2] + [i + i + 3 for i, v in enumerate(buf) if v]

Jednotkové testy vytvořené s využitím standardního modulu unittest vypadají následovně. Jeden z testů je napsán takovým způsobem, aby nahlásil chybu:

"""Implementace jednotkových testů."""
 
import unittest
 
from primes import primes2
 
 
class TestStringMethods(unittest.TestCase):
    def test_primes_10(self):
        """Otestování výpočtu seznamu prvočísel až do limitu 10."""
        # získat seznam prvočísel až do limitu 10
        p = primes2(10)
        # testy lze dále rozšiřovat
        assert 2 in p
        assert 10 not in p
 
    def test_primes_100000(self):
        """Otestování výpočtu seznamu prvočísel až do limitu 100000."""
        # získat seznam prvočísel až do limitu 100000
        p = primes2(100000)
        # testy lze dále rozšiřovat
        assert 2 in p
        assert 10 not in p
        # hodnoty získány ze seznamu:
        # https://primes.utm.edu/lists/small/10000.txt
        assert 99989 in p
        assert 99991 in p
 
    def test_primes_0(self):
        """Otestování výpočtu seznamu prvočísel do limitu 0."""
        p = primes2(0)
        # otestujeme, zda je sekvence prázdná (není zcela přesné)
        assert not p
 
    def test_primes_should_fail(self):
        """Otestování výpočtu seznamu prvočísel do limitu 2."""
        p = primes2(2)
        assert p == [1, 2, 3]
 
    def test_primes_2(self):
        """Otestování výpočtu seznamu prvočísel do limitu 2."""
        p = primes2(2)
        # otestujeme, zda sekvence obsahuje pouze hodnotu 2
        assert 2 in p
        assert p == [2]
 
 
if __name__ == "__main__":
    unittest.main()

Při spuštění testů starší verzí interpretru Pythonu se zobrazí tyto výsledky:

Obrázek 4: Výsledky jednotkových testů vypsané Pythonem 3.13.

Autor: tisnik, podle licence: Rights Managed

Naopak Python 3.14 zobrazí výsledky barevně odlišené:

Obrázek 5: Výsledky jednotkových testů vypsané Pythonem 3.14.

Autor: tisnik, podle licence: Rights Managed

10. Vylepšená nápověda při nesprávném zápisu klíčového slova nebo identifikátoru

Vylepšila se i nápověda zobrazená interpretrem programovacího jazyka Python při nalezení nesprávného zápisu klíčového slova nebo identifikátoru. Nyní se interpret snaží najít podobné (korektní) slovo, což je funkce, s níž se můžeme setkat stále častěji (BASH atd.), protože se rozhraní příkazového řádku neustále přibližuje lidským požadavkům.

Příklad nesprávného zápisu jména standardní funkce a reakce interpretru:

Obrázek 6: Chybové hlášení a nápověda s navrhnovanou opravou.

Autor: tisnik, podle licence: Rights Managed

Ukažme si některé další příklady nesprávného zápisu a reakce interpretru:

clss Address(BaseModel):
    street: str
    house_number: int
    city: str

Detekce nekorektně zapsaného klíčového slova class:

  File "/home/ptisnovs/src/most-popular-python-libs/python3.14/syntax_error_1.py", line 1
    clss Address(BaseModel):
    ^^^^
SyntaxError: invalid syntax. Did you mean 'class'?

Druhý příklad:

for i in ranger(10):
    print(i)

Detekce nesprávně zapsané standardní funkce range:

Traceback (most recent call last):
  File "/home/ptisnovs/src/most-popular-python-libs/python3.14/syntax_error_2.py", line 1, in
    for i in ranger(10):
             ^^^^^^
NameError: name 'ranger' is not defined. Did you mean: 'range'?

Třetí příklad:

for i in range(10):
    println(i)

Detekce nesprávně zapsané standardní funkce print:

Traceback (most recent call last):
  File "/home/ptisnovs/src/most-popular-python-libs/python3.14/syntax_error_3.py", line 2, in
    println(i)
    ^^^^^^^
NameError: name 'println' is not defined. Did you mean: 'print'?

Čtvrtý příklad:

def test_fn():
    for x in range(10):
        try:
            y = 1 / x
            print(f"{x:2}  {y:4.2f}")
        except ZeroDivisionError:
            print(f"{x:2}  divide by zero")
        finale:
            pass
 
 
test_fn()

Detekce nesprávně zapsaného klíčového slova finally:

  File "/home/ptisnovs/src/most-popular-python-libs/python3.14/syntax_error_4.py", line 8
    finale:
    ^^^^^^
SyntaxError: invalid syntax. Did you mean 'finally'?

Pátý příklad:

i = 0
whale i < 10:
    i += 1
    print(i)

Detekce nesprávně zapsaného klíčového slova while:

  File "/home/ptisnovs/src/most-popular-python-libs/python3.14/syntax_error_5.py", line 2
    whale i < 10:
    ^^^^^
SyntaxError: invalid syntax. Did you mean 'while'?

11. Vylepšení syntaxe a sémantiky jazyka Python

Všechny nové vlastnosti Pythonu 3.14, s nimiž jsme se až doposud v tomto článku setkali, se vlastně týkaly vylepšení rozhraní mezi vývojářem na straně jedné a interpretrem na straně druhé. Ovšem do Pythonu 3.14 byly přidány nové více či méně užitečné vlastnosti i do samotného jazyka Python, tj. do jeho syntaxe a sémantiky.

Tyto nové vlastnosti sice nejsou tak revoluční, jako tomu bylo v některých předchozích verzích Pythonu (přidání typových informací, konstrukce pro pattern matching, podpora pro asynchronní programování atd.), ovšem i tak stojí za zmínku i za ukázky.

12. Zjednodušení zápisu zachycení většího množství výjimek v jediném bloku except

První, i když relativně malé vylepšení jazyka Python, spočívá v tom, že pokud se v nějakém bloku except zachytává větší množství výjimek (resp. přesněji řečeno výjimek několika typů), není nutné typy těchto výjimek umístit do kulatých závorek. Toto vylepšení, které je popsáno v PEP 758 – Allow except and except* expressions without parentheses, je plně dopředně kompatibilní s předchozími verzemi programovacího jazyka Python, protože je stále možné (a někdy i nutné – viz dále) výjimky do kulatých závorek zapisovat (ovšem zdrojové kódy využívající tento zápis pochopitelně nebudou přijaty staršími překladači ani interpretry).

Připomeňme si, jak je možné v jediném bloku except zachytit více výjimek:

try:
    with open("pep-758-motivation.py", "r") as fin:
        content = fin.read()
    with open("bar", "w") as fout:
        fout.write(content)
except (FileNotFoundError, PermissionError, IsADirectoryError, IOError):
    print("File handling exception")

popř. můžeme uložit objekt nesoucí informaci o výjimce do lokální proměnné nazývané idiomaticky e s využitím konstrukce as e:

try:
    with open("pep-758-motivation.py", "r") as fin:
        content = fin.read()
    with open("bar", "w") as fout:
        fout.write(content)
except (FileNotFoundError, PermissionError, IsADirectoryError, IOError) as e:
    print(type(e))

13. Kdy je možné zapsat typy výjimek bez kulatých závorek?

První z demonstračních příkladů, které byly uvedeny v předchozí kapitole, je nyní možné zapsat zkráceným způsobem, tj. typy výjimek nemusí být vloženy do kulatých závorek:

try:
    with open("pep-758-motivation.py", "r") as fin:
        content = fin.read()
    with open("bar", "w") as fout:
        fout.write(content)
except FileNotFoundError, PermissionError, IsADirectoryError, IOError:
    print("File handling exception")

Důležité je ovšem vědět, že tento nový způsob zápisu se nemůže použít v případě, kdy je použita konstrukce except … as …. Pokud se o toto zjednodušení pokusíme, bude interpret programovacího jazyka Python 3.14 hlásit chyby syntaxe (a nutno dodat, že tato konstrukce se pravděpodobně používá mnohem častěji, než pouhé zachycení výjimek):

try:
    with open("pep-758-motivation.py", "r") as fin:
        content = fin.read()
    with open("bar", "w") as fout:
        fout.write(content)
except FileNotFoundError, PermissionError, IsADirectoryError, IOError as e:
    print(type(e))

Informace o syntaktické chybě nalezené překladačem bude vypadat takto:

  File "/home/ptisnovs/src/most-popular-python-libs/python3.14/pep-758-usage-as.py", line 6
    except FileNotFoundError, PermissionError, IsADirectoryError, IOError as e:
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
SyntaxError: multiple exception types must be parenthesized when using 'as'

14. Detekce explicitního výskoku z bloku finally

Interpretry a překladače všech starších verzí programovacího jazyka Python umožňovaly, aby se v bloku finally (ten se provede nezávisle na tom, zda je vyhozena a následně zachycena výjimka či nikoli) používaly jazykové konstrukce umožňující výskok (opuštění) bloků try-except-finally. Mezi takové konstrukce patří return, break, ale i continue. Jak si uvedeme v navazující kapitole, byla tato kombinace finally+return atd. sice po syntaktické stránce korektní, ovšem typicky se jedná o logickou chybu v návrhu programu. Z tohoto důvodu Python 3.14 v takových případech detekuje a hlásí varování o nekorektní syntaxi (tj. logická chyba byla ponížena na pouhé varování, ovšem je to lepší, než původní ignorování této situace).

15. Motivace a ukázky kódu

Podívejme se nyní na nové chování interpretru Pythonu. Začneme příkladem, ve kterém se vyskakuje z bloku finally příkazem return, což konkrétně v tomto případě vlastně nijak nevadí:

def test_fn():
    try:
        with open("pep-758-motivation.py", "r") as fin:
            content = fin.read()
        with open("bar", "w") as fout:
            fout.write(content)
    except (FileNotFoundError, PermissionError, IsADirectoryError, IOError) as e:
        print(type(e))
    finally:
        return
 
 
test_fn()

Reakce interpretru:

/home/ptisnovs/src/most-popular-python-libs/python3.14/pep-765-motivation-1.py:10:
SyntaxWarning: 'return' in a 'finally' block
  return
<class 'FileNotFoundError'>

Korektní příklad výpočtu tabulky převrácených hodnot. Nyní je blok finally prázdný resp. přesněji řečeno neobsahuje příkaz pro výskok:

def test_fn():
    for x in range(10):
        try:
            y = 1 / x
            print(f"{x:2}  {y:4.2f}")
        except ZeroDivisionError:
            print(f"{x:2}  divide by zero")
        finally:
            pass
 
 
test_fn()

Výsledky:

 0  divide by zero
 1  1.00
 2  0.50
 3  0.33
 4  0.25
 5  0.20
 6  0.17
 7  0.14
 8  0.12
 9  0.11

Předchozí příklad, ovšem s explicitním výskokem:

def test_fn():
    for x in range(10):
        try:
            y = 1 / x
            print(f"{x:2}  {y:4.2f}")
        except ZeroDivisionError:
            print(f"{x:2}  divide by zero")
        finally:
            return
 
 
test_fn()

Zobrazí se varování interpretru a současně se vypočte a zobrazí jediná hodnota – poté je výpočet ukončen příkazem return:

/home/ptisnovs/src/most-popular-python-libs/python3.14/pep-765-motivation-3.py:9:
SyntaxWarning: 'return' in a 'finally' block
  return
 0  divide by zero

Podobný příklad, ale upravený do takové podoby, že se namísto return použije continue:

def test_fn():
    for x in range(10):
        try:
            y = 1 / x
            print(f"{x:2}  {y:4.2f}")
        except ZeroDivisionError:
            print(f"{x:2}  divide by zero")
        finally:
            continue
 
 
test_fn()

Opět se zobrazí varování (jedenkrát) a poté proběhne výpočet:

/home/ptisnovs/src/most-popular-python-libs/python3.14/pep-765-motivation-4.py:9:
SyntaxWarning: 'continue' in a 'finally' block
  continue
 0  divide by zero
 1  1.00
 2  0.50
 3  0.33
 4  0.25
 5  0.20
 6  0.17
 7  0.14
 8  0.12
 9  0.11

16. Podpora pro t-řetězce

Do programovacího jazyka Python byla v rámci nových vlastností verze 3.6 (tedy hodně dávno) přidána podpora pro takzvané formátovací řetězce neboli zkráceně f-řetězce (f-strings). Tato nová jazyková konstrukce zjednodušuje formátování dat, která se mají vytisknout na standardní výstup, zobrazit na HTML stránce, zobrazit v grafickém uživatelském rozhraní nějakého projektu s GUI atd. Tyto operace typicky znamenají že se musí nějakým způsobem zkombinovat statický textový obsah s hodnotami proměnných, atributy objektů atd.

Formátovací řetězce se zapisují podobně jako běžné řetězce, tj. jsou zapsané do apostrofů nebo uvozovek, popř. do trojitých apostrofů nebo uvozovek (víceřádkové řetězce). Ovšem oproti běžným řetězcům začínají formátovací řetězce prefixem f zapsaným před samotným řetězcovým literálem (konstantou) a právě z tohoto důvodu se v původní anglické dokumentaci o programovacím jazyce Python tyto řetězce nazývají f-strings.

Podívejme se nyní na jeden z nejjednodušších způsobů využití formátovacích řetězců, ve kterém se provádí takzvaná interpolace. V následujícím skriptu napsaném v Pythonu nejdříve nadeklarujeme tři proměnné a posléze vypíšeme hodnoty všech třech proměnných, a to podle šablony (template), která vypadá následovně:

f"{a}+{b}={c}"

Znaky a, b a c (které představují názvy proměnných) jsou v šabloně zapsány mezi složené závorky a z tohoto důvodu jsou při konstrukci výsledného řetězce tyto znaky nahrazeny za hodnotu proměnných se stejným jménem. Pokud budou tyto proměnné nastaveny na hodnoty:

a=1
b=2
c=a+b

tak se po spuštění tohoto skriptu na terminálu zobrazí následující text:

1+2=3

Do Pythonu 3.14 byly přidány takzvané t-řetězce, které se zapisují podobně jako f-řetězce, ovšem mají prefix t. Výsledkem interpolace ovšem v tomto případě nebude běžný řetězec, ale instance třídy Template, která kromě dalších atributů obsahuje seznam všech požadovaných interpolací. Tyto t-řetězce je tedy možné využít v komplikovanějších šablonovacích systémech, preprocesorech, nástrojích pro transformaci dat atd. Jedná se o velmi zajímavou technologii, které bude věnován samostatný článek.

17. Ukázky rozdílů mezi f-řetězci a t-řetězci

Podívejme se, jaké jsou rozdíly mezi dnes již zcela standardními f-řetězci a novými t-řetězci. Následující příklad ukazuje, jakým způsobem je možné naformátovat text výrazu i s jeho výsledkem s využitím f-řetězce:

a = 1
b = 2
 
s = f"{a}+{b}={a+b}"
print(s)
print(type(s))

Po spuštění by se měla vypsat naformátovaná zpráva i typ výsledné hodnoty (řetězce):

1+2=3
<class 'str'>

Otestujme si, co se stane, pokud namísto f-řetězce zapíšeme t-řetězec:

a = 1
b = 2
 
s = t"{a}+{b}={a+b}"
print(s)
print(type(s))

Výsledek bude zcela odlišný, protože namísto běžného řetězce získáme hodnotu typu Template, resp. instanci této třídy. A ta bude obsahovat informace o jednotlivých provedených interpolacích:

Template(strings=('', '+', '=', ''), interpolations=(Interpolation(1, 'a', None, ''), Interpolation(2, 'b', None, ''), Interpolation(3, 'a+b', None, '')))
<class 'string.templatelib.Template'>

V f-řetězcích může být umístěno i volání funkcí, metod atd. Opět si to otestujme:

x = "hello world!"
 
s = f"Důležitá zpráva pro vás: '{x.capitalize()}'"
print(s)
print(type(s))

Výsledkem je opět běžný řetězec:

Důležitá zpráva pro vás: 'Hello world!'
<class 'str'>

Podobný příklad, ovšem s t-řetězcem:

x = "hello world!"
 
s = t"Důležitá zpráva pro vás: '{x.capitalize()}'"
print(s)
print(type(s))

Povšimněte si, že objekt typu Template obsahuje i informaci o tom, že jedna z interpolací volá metodu capitalize:

Template(strings=("Důležitá zpráva pro vás: '", "'"), interpolations=(Interpolation('Hello world!', 'x.capitalize()', None, ''),))
<class 'string.templatelib.Template'>

18. Obsah navazujícího článku

Python 3.14 ve skutečnosti přináší ještě více změn. Ty se týkají například vylepšení běhu interpretru se zakázaným GILem (Global Interpreter Lock), možnosti připojení debuggeru k již běžícímu Pythonovskému procesu, vylepšení automatického správce paměti (Garbage Collector) a dokonce i nového režimu interpretace bajtkódu Pythonu, což by mělo zvýšit jeho rychlost.

Těmito technologiemi se budeme zabývat v samostatném článku, protože některé z nich vyžadují relativně dlouhý technický popis. Nicméně všechny zmíněné technologie (až na možnost připojení debuggeru k běžícímu procesu) vedou k měřitelnému zrychlení interpretru Pythonu.

19. Repositář s demonstračními příklady

Demonstrační příklady vytvořené pro Python verze 3.14 a popsané v dnešním článku najdete v repositáři https://github.com/tisnik/most-popular-python-libs/. Následují odkazy na jednotlivé příklady:

20. Odkazy na Internetu

1. Python 3.14.0
   https://test.python.org/dow­nloads/release/python-3140/
2. PEP 765 – Disallow return/break/continue that exit a finally block
   https://peps.python.org/pep-0765/
3. PEP 758 – Allow except and except* expressions without parentheses
   https://peps.python.org/pep-0758/
4. What’s new in Python 3.14 (official)
   https://docs.python.org/3/what­snew/3.14.html
5. What’s New In Python 3.13 (official)
   https://docs.python.org/3/what­snew/3.13.html
6. What’s New In Python 3.12 (official)
   https://docs.python.org/3/what­snew/3.12.html
7. What’s New In Python 3.11 (official)
   https://docs.python.org/3/what­snew/3.11.html
8. What’s New In Python 3.12
   https://dev.to/mahiuddindev/python-312–4n43
9. PEP 698 – Override Decorator for Static Typing
   https://peps.python.org/pep-0698/
10. PEP 484 – Type Hints
    https://www.python.org/dev/peps/pep-0484/
11. What’s New In Python 3.5
    https://docs.python.org/3­.5/whatsnew/3.5.html
12. 26.1. typing — Support for type hints
    https://docs.python.org/3­.5/library/typing.html#mo­dule-typing
13. Type Hints – Guido van Rossum – PyCon 2015 (youtube)
    https://www.youtube.com/wat­ch?v=2wDvzy6Hgxg
14. Python 3.5 is on its way
    https://lwn.net/Articles/650904/
15. Type hints
    https://lwn.net/Articles/640359/
16. Stránka projektu PDM
    https://pdm.fming.dev/latest/
17. PDF na GitHubu
    https://github.com/pdm-project/pdm
18. PEP 582 – Python local packages directory
    https://peps.python.org/pep-0582/
19. PDM na PyPi
    https://pypi.org/project/pdm/
20. Which Python package manager should you use?
    https://towardsdatascience.com/which-python-package-manager-should-you-use-d0fd0789a250
21. How to Use PDM to Manage Python Dependencies without a Virtual Environment
    https://www.youtube.com/wat­ch?v=qOIWNSTYfcc
22. What are the best Python package managers?
    https://www.slant.co/topics/2666/~best-python-package-managers
23. PEP 621 – Storing project metadata in pyproject.toml
    https://peps.python.org/pep-0621/
24. Pick a Python Lockfile and Improve Security
    https://blog.phylum.io/pick-a-python-lockfile-and-improve-security/
25. PyPA specifications
    https://packaging.python.or­g/en/latest/specification­s/
26. Creation of virtual environments
    https://docs.python.org/3/li­brary/venv.html
27. How to Use virtualenv in Python
    https://learnpython.com/blog/how-to-use-virtualenv-python/
28. Python Virtual Environments: A Primer
    https://realpython.com/python-virtual-environments-a-primer/
29. virtualenv Cheatsheet
    https://aaronlelevier.git­hub.io/virtualenv-cheatsheet/
30. Installing Python Modules
    https://docs.python.org/3/in­stalling/index.html
31. Python: The Documentary | An origin story
    https://www.youtube.com/wat­ch?v=GfH4QL4VqJ0
32. History of Python
    https://en.wikipedia.org/wi­ki/History_of_Python
33. History of Python
    https://www.geeksforgeeks­.org/python/history-of-python/
34. IPython: jedno z nejpropracovanějších interaktivních prostředí pro práci s Pythonem
    https://www.root.cz/clanky/ipython-jedno-z-nejpropracova-nejsich-interaktivnich-prostredi-pro-praci-s-pythonem/
35. Další kulaté výročí v IT: dvacet let existence Pythonu 2
    https://www.root.cz/clanky/dalsi-kulate-vyroci-v-it-dvacet-let-existence-pythonu-2/