0 dní v řadě · 0 bodů

Soubory, chyby a knihovny · 20 min

Moduly a balíčky

Rozdělíš program do více souborů a pochopíš import, __name__, hledání modulů i past se souborem random.py.

Hloubka
Úkoly
Lidsky řečeno

Nikdo nenosí celou dílnu v kapsách. Nářadí leží v šuplících s popisky, a když potřebuješ kleště, otevřeš šuplík s kleštěmi. Modul je takový šuplík, balíček je skříňka se šuplíky a import znamená „přines mi to na stůl“.

Import: hotová práce zadarmo

Dokud má program sto řádků, stačí jeden soubor. U tří tisíc řádků hledáš funkci déle, než bys ji napsal znovu. A když ji zkopíruješ do druhého programu, máš najednou dvě verze téže chyby.

Modul je soubor s kódem Pythonu, který můžou používat jiné programy. Python s sebou nosí stovky hotových modulů, dohromady se jim říká standardní knihovna. Nic k nim nemusíš instalovat, stačí je načíst příkazem import.

import math
from math import sqrt, ceil
import statistics as stats

print(math.floor(7.9))
print(sqrt(81), ceil(2.1))
print(stats.mean([2, 4, 9]))
Výstup
7
9.0 3
5

Každý řádek nahoře načítá modul jiným způsobem:

ZápisCo dostanešJak voláš
import mathcelý modul pod jménem mathmath.floor(7.9)
from math import sqrtjen jméno sqrtsqrt(81)
import statistics as statsmodul pod kratším jménemstats.mean(...)

Výchozí volba je první řádek. Když o sto řádků níž uvidíš math.floor, hned víš, odkud se funkce vzala. Druhý zápis se hodí na pár často používaných jmen, třetí na dlouhé názvy nebo zavedené zkratky.

Existuje ještě čtvrtý zápis, from modul import *, který přetáhne všechno najednou. Vypadá pohodlně, dokud se dvě jména nepotkají.

from math import *
from cmath import *

print(sqrt(16))
Výstup
(4+0j)

Modul cmath počítá s komplexními čísly a má taky funkci sqrt. Druhý import tu první tiše přepsal, takže místo čísla 4.0 dostaneš (4+0j). Žádná chyba, žádné varování, jen divný výsledek o tři funkce dál.

Úkol

Kolik aut na výlet

Napiš funkci pocet_aut(lide, mista), která vrátí, kolik aut je potřeba, když se do jednoho vejde mista lidí. Pro 23 lidí a 5 míst to je 5 aut, nikdo nezůstává doma. Použij vhodnou funkci z modulu math.

# Sem patří import

def pocet_aut(lide, mista):
    return 0
Výstup

Vlastní modul je obyčejný soubor

Žádné zvláštní kouzlo v tom není. Soubor ceny.py je modul ceny. Když vedle něj leží program.py, může si ho načíst.

Na svém počítači bys oba soubory vytvořil v editoru a spustil python program.py. Tady každá ukázka běží ve vlastní prázdné složce, takže si soubory vyrobí sama přes pathlib a runpy.run_path zastoupí to spuštění. Zajímavé je to, co je uvnitř uvozovek.

from pathlib import Path
import importlib, runpy

Path("ceny.py").write_text("""
DPH = 0.21

def s_dph(cena):
    return round(cena * (1 + DPH), 2)

print("Načítám ceny.py")
""", encoding="utf-8")

Path("program.py").write_text("""
import ceny
import ceny

print(ceny.s_dph(100))
print(ceny.DPH)
""", encoding="utf-8")

importlib.invalidate_caches()  # ať si Python všimne nových souborů
runpy.run_path("program.py", run_name="__main__")
Výstup
Načítám ceny.py
121.0
0.21

Všimni si dvou věcí. Modul zpřístupnil svoji funkci i proměnnou. A věta Načítám ceny.py se vypsala jen jednou, přestože import je tam dvakrát. Python spustí kód modulu jen při prvním importu. Potom si hotový modul pamatuje a další importy dostanou tentýž objekt.

Kvíz

Modul obsahuje na nejvyšší úrovni print("ahoj"). Tři různé soubory téhož programu ho naimportují. Kolikrát se ahoj vypíše?

Modul, nebo program?

Z předchozího plyne nepříjemnost. Když si na konec modulu dáš zkušební výpis, spustí se každému, kdo modul naimportuje. Řešení stojí na proměnné __name__, kterou Python nastaví v každém souboru:

  • soubor spuštěný přímo má __name__ rovno "__main__",
  • naimportovaný soubor tam má své jméno, třeba "teplota".
from pathlib import Path
import importlib, runpy

Path("teplota.py").write_text("""
def na_fahrenheit(c):
    return c * 9 / 5 + 32

print("__name__ v teplota.py:", __name__)

if __name__ == "__main__":
    print("20 °C je", na_fahrenheit(20), "°F")
""", encoding="utf-8")

Path("program.py").write_text("""
import teplota
print("__name__ v program.py:", __name__)
""", encoding="utf-8")

importlib.invalidate_caches()
runpy.run_path("program.py", run_name="__main__")
print("--- teď spouštím teplota.py přímo ---")
runpy.run_path("teplota.py", run_name="__main__")
Výstup
__name__ v teplota.py: teplota
__name__ v program.py: __main__
--- teď spouštím teplota.py přímo ---
__name__ v teplota.py: __main__
20 °C je 68.0 °F

Podmínka if __name__ == "__main__": tedy znamená „tohle proveď, jen když jsem hlavní program“. Soubor pak funguje oběma způsoby: jako nástroj pro ostatní i jako samostatný skript.

Úkol

Ať modul při importu mlčí

Modul prevody.py při každém importu vypíše zkušební řádek. Uprav text modulu tak, aby se Test: vypsal jen při přímém spuštění. Funkce musí zůstat dostupná i po importu.

from pathlib import Path

Path("prevody.py").write_text("""
def km_na_mile(km):
    return km * 0.621371

print("Test:", km_na_mile(10))
""", encoding="utf-8")
Výstup

Kde Python moduly hledá

Při import ceny projde Python seznam složek v sys.path, popořadě, a vezme první shodu. Na prvním místě bývá složka spuštěného programu, teprve za ní standardní knihovna a nakonec nainstalované balíčky.

import sys

for slozka in sys.path:
    print(slozka)
Výstup

Když nic nenajde, skončí chybou ModuleNotFoundError. Typické důvody jsou překlep v názvu, program spuštěný z jiné složky, nebo balíček, který ještě není nainstalovaný. Instalaci řeší lekce Virtuální prostředí a závislosti.

Pořadí složek má jeden zrádný důsledek. Tvůj soubor má přednost před standardní knihovnou.

from pathlib import Path
import importlib, runpy, sys

Path("statistics.py").write_text("""
print("Tohle je můj statistics.py, ne ten z Pythonu.")
""", encoding="utf-8")

Path("program.py").write_text("""
import statistics

try:
    print(statistics.mean([1, 2, 3]))
except AttributeError as chyba:
    print("Chyba:", chyba)
""", encoding="utf-8")

importlib.invalidate_caches()
sys.modules.pop("statistics", None)  # zapomeň případnou už načtenou verzi
runpy.run_path("program.py", run_name="__main__")
Výstup
Tohle je můj statistics.py, ne ten z Pythonu.
Chyba: module 'statistics' has no attribute 'mean'
Kvíz

Ve složce s programem leží soubor random.py. Co udělá import random v tomto programu?

Balíčky: moduly ve složkách

Když modulů přibývá, seskupíš je do složky. Složka se souborem __init__.py je balíček. Moduly uvnitř oslovíš tečkou, stejně jako funkci v modulu.

text
projekt/
    program.py
    eshop/
        __init__.py    <- spustí se při importu balíčku
        ceny.py
        kosik.py

Uvnitř balíčku se moduly odkazují na sousedy relativně: from .ceny import s_dph znamená „z modulu ceny ve stejné složce“. Soubor __init__.py může být prázdný, nebo vystaví to nejdůležitější, aby uživatel balíčku nemusel znát jeho vnitřní uspořádání.

from pathlib import Path
import importlib, runpy

Path("eshop").mkdir()
Path("eshop/__init__.py").write_text("""
from .kosik import celkem
""", encoding="utf-8")

Path("eshop/ceny.py").write_text("""
DPH = 0.21

def s_dph(cena):
    return round(cena * (1 + DPH), 2)
""", encoding="utf-8")

Path("eshop/kosik.py").write_text("""
from .ceny import s_dph

def celkem(polozky):
    return round(sum(s_dph(cena) for cena in polozky), 2)
""", encoding="utf-8")

Path("program.py").write_text("""
import eshop
from eshop.ceny import s_dph

print(eshop.celkem([100, 250]))
print(s_dph(1000))
print(eshop.kosik.__name__)
""", encoding="utf-8")

importlib.invalidate_caches()
runpy.run_path("program.py", run_name="__main__")
Výstup
423.5
1210.0
eshop.kosik
Úkol

Vystav funkci z balíčku

Balíček texty má modul cisteni s funkcí normalizuj. Doplň text souboru __init__.py tak, aby šlo psát rovnou texty.normalizuj(...).

from pathlib import Path

Path("texty").mkdir(exist_ok=True)
Path("texty/cisteni.py").write_text("""
def normalizuj(text):
    return text.strip().lower()
""", encoding="utf-8")

Path("texty/__init__.py").write_text("""
""", encoding="utf-8")
Výstup
Kvíz

Co obsahuje __name__ v souboru, který byl naimportován příkazem import eshop.ceny?

Pod kapotou · co přesně udělá import
  1. Podívá se do slovníku sys.modules. Když tam modul je, vezme ho a hledání končí.
  2. Projde hledače v sys.meta_path: zabudované moduly, zmrazené moduly a nakonec PathFinder, který prochází sys.path. Výsledkem je ModuleSpec (PEP 451).
  3. Vytvoří prázdný objekt modulu, vloží ho do sys.modules a teprve potom spustí jeho kód. Když kód spadne, záznam zase odstraní.
  4. Přiřadí jméno v tvém jmenném prostoru.

Bytecode se ukládá do __pycache__/ceny.cpython-312.pyc a ve výchozím stavu se platnost ověřuje podle času změny a velikosti zdroje. Pro reprodukovatelné buildy existují pyc soubory založené na hashi (PEP 552). Skript spuštěný přímo se do pyc neukládá. PathFinder si kešuje obsah složek, proto po vytvoření souboru za běhu patří importlib.invalidate_caches().

Bod 3 vysvětluje kruhové importy. Druhý modul dostane ze sys.modules napůl hotový první modul a jméno, které v něm ještě nevzniklo, nenajde.

from pathlib import Path
import importlib, runpy

Path("objednavky.py").write_text("""
from zakaznici import jmeno_zakaznika

def cislo_objednavky():
    return 42
""", encoding="utf-8")

Path("zakaznici.py").write_text("""
from objednavky import cislo_objednavky

def jmeno_zakaznika():
    return "Eva"
""", encoding="utf-8")

Path("program.py").write_text("import objednavky\n", encoding="utf-8")
importlib.invalidate_caches()
runpy.run_path("program.py", run_name="__main__")
Výstup

Čisté řešení je přesunout společný kód do třetího modulu. Záplaty jsou import zakaznici s přístupem k atributu až při volání, nebo import uvnitř funkce. Pokud je cyklus jen kvůli typovým anotacím, patří import pod if typing.TYPE_CHECKING:.

Další užitečné věci: python -X importtime program.py ukáže, co zdržuje start. python -P nebo PYTHONSAFEPATH=1 (od 3.11) nepřidá složku skriptu do sys.path, což odstraní celou třídu problémů se zastíněním. Složka bez __init__.py je namespace balíček (PEP 420), který se může skládat z více míst na disku. Jako náhradu za zapomenutý __init__.py ho neber, nástroje na hledání balíčků a testů s ním často zacházejí jinak. Modulová funkce __getattr__ (PEP 562) umožňuje líné načítání drahých závislostí.

Pod kapotou · from import kopíruje vazbu, ne proměnnou

from modul import X vytvoří nové jméno ukazující na objekt, který byl v modul.X v tu chvíli. Pozdější přiřazení do modul.X ho nezmění.

from pathlib import Path
import importlib, runpy

Path("nastaveni.py").write_text("DPH = 0.21\n", encoding="utf-8")
Path("program.py").write_text("""
import nastaveni
from nastaveni import DPH

nastaveni.DPH = 0.12

print("nastaveni.DPH:", nastaveni.DPH)
print("DPH:", DPH)
""", encoding="utf-8")

importlib.invalidate_caches()
runpy.run_path("program.py", run_name="__main__")
Výstup
nastaveni.DPH: 0.12
DPH: 0.21

Přesně kvůli tomu se v testech záměna objektu dělá tam, kde se jméno používá, a ne tam, kde bylo definováno. Totéž kousne importlib.reload: znovu spustí kód v tomtéž objektu modulu, ale jména získaná přes from a instance starých tříd zůstanou stará.