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]))
7 9.0 3 5
Každý řádek nahoře načítá modul jiným způsobem:
| Zápis | Co dostaneš | Jak voláš |
|---|---|---|
import math | celý modul pod jménem math | math.floor(7.9) |
from math import sqrt | jen jméno sqrt | sqrt(81) |
import statistics as stats | modul pod kratším jménem | stats.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))
(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.
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
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__")
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.
Modul obsahuje na nejvyšší úrovni print("ahoj"). Tři různé soubory téhož programu ho naimportují. Kolikrát se ahoj vypíše?
První import modul spustí a uloží. Další importy v témže běhu programu dostanou už hotový objekt.
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__")
__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.
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")
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)
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__")
Tohle je můj statistics.py, ne ten z Pythonu. Chyba: module 'statistics' has no attribute 'mean'
Ve složce s programem leží soubor random.py. Co udělá import random v tomto programu?
Python bere první shodu v sys.path. Výjimka platí jen pro moduly zabudované přímo do interpretu, například sys, a pro moduly, které už jsou načtené.
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.
projekt/
program.py
eshop/
__init__.py <- spustí se při importu balíčku
ceny.py
kosik.pyUvnitř 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__")
423.5 1210.0 eshop.kosik
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")
Co obsahuje __name__ v souboru, který byl naimportován příkazem import eshop.ceny?
Naimportovaný modul nese své plné tečkované jméno. "__main__" má jen soubor, který byl spuštěn jako hlavní program.
Pod kapotou · co přesně udělá import
- Podívá se do slovníku
sys.modules. Když tam modul je, vezme ho a hledání končí. - Projde hledače v
sys.meta_path: zabudované moduly, zmrazené moduly a nakonecPathFinder, který procházísys.path. Výsledkem jeModuleSpec(PEP 451). - Vytvoří prázdný objekt modulu, vloží ho do
sys.modulesa teprve potom spustí jeho kód. Když kód spadne, záznam zase odstraní. - 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__")
Č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__")
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á.