Jestliže ukončíte interpretr jazyka Python a spustíte ho znovu, veškeré funkce a proměnné, které jste si definovali, budou ztraceny. Chcete-li tedy psát delší programy, je lepší použít textový editor na připravení vstupu pro interpretr a tomu předat tento soubor jako vstup. Tento soubor se pak nazývá skript. Jak se váš program stává delší, možná ho budete chtít rozdělit na více souborů. Možná také budete chtít použít funkce, které jste již napsali, ve více programech bez kopírování jejich definic do každého programu.
Python proto umožňuje uložit definice do souborů a používat je v jednotlivých skriptech nebo v interaktivním interpretru. Tyto soubory jsou nazývány moduly; definice mohou být z jednotlivých modulů importovány do jiných modulů nebo také do hlavního modulu.
Modul je soubor obsahující definice a příkazy v jazyce Python. Jméno souboru je
stejné jako jméno modulu s příponou .py (modul classes je tudíž uložen v
souboru classes.py). Každý modul má možnost zjistit své jméno pomocí globální
proměnné __name__
(jako řetězec) . Například ve svém textovém editoru
vytvořte soubor pojmenovaný fibo.py s následujícím obsahem a uložte ho
do svého pracovního adresáře:
# Modul obsahující funkce pro výpočet Fibonacciho rozvoje def fib(n): # vytiskne Fibonacciho rozvoj do čísla n a, b = 0, 1 while b < n: print b, a, b = b, a+b def fib2(n): # vrátí Fibonacciho rozvoj do čísla n result = [] a, b = 0, 1 while b < n: result.append(b) a, b = b, a+b return result
Nyní spusťte interpretr jazyka Python a importujte modul za pomocí následujícího příkazu:
>>> import fibo
Příkaz import nezavede jména funkcí definovaná v modulu fibo
přímo do
aktuálního prostoru jmen - uloží sem pouze jméno modulu fibo
. Za pomoci
tohoto jména můžete používat funkce definované tímto modulem:
>>> fibo.fib(1000) 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 >>> fibo.fib2(100) [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89] >>> fibo.__name__ 'fibo'
Jestliže chcete použít tyto funkce častěji, můžete je uložit jako lokální proměnnou:
>>> fib = fibo.fib >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377
Moduly mohou mimo definic funkcí obsahovat i spustitelné příkazy. Tyto příkazy jsou vykonány při inicializaci modulu - jsou tedy spuštěny jen při prvním importování modulu.6.1
Každý modul má svůj vlastní prostor jmen, který je použit jako globální obor
jmen pro všechny funkce definované v modulu. Autor modulu tedy může používat
globální proměnné, aniž by se musel obávat střetu s globálními proměnnými
uživatele. Jinými slovy, jestliže víte, co děláte, můžete se odkazovat na
globální proměnné modulu stejným způsobem jako na funkce -
jmeno_modulu.promenna
.
Moduly mohou importovat jiné moduly. Je dobré umístit veškeré příkazy import na začátku modulu nebo skriptu (jazyk to ovšem nevyžaduje). Importované moduly jsou uloženy v globálním prostoru jmen importujícího modulu.
Existuje i varianta příkazu import, která zavede jména z nějakého modulu přímo do globálního prostoru jmen modulu, který si importování vyžádal. Například:
>>> from fibo import fib, fib2 >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377
Tento příkaz ale nevytvoří v lokálním prostoru jmen jméno modulu, ze kterého
byl import proveden (v tomto příkladě tedy jméno fibo
není definováno).
Existuje ještě jedna varianta, která zavede všechna jména, která modul definuje:
>>> from fibo import * >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377
Tento příkaz zavede všechna jména s výjimkou těch, která začínají znakem podtržítko ("_").
Je-li importován modul spam, iterpretr nejprve hledá soubor se jménem spam.py v pracovním adresáři a poté v seznamu adresářů specifikovaném proměnnou prostředí PYTHONPATH. Ta má stejnou syntaxi jako shellová proměnná PATH. Jestliže proměnná PYTHONPATH není nastavena nebo není-li v této cestě soubor nalezen, vyhledávání pokračuje v implicitní cestě (závislé na instalaci vašeho interpretru), na systémech Unixje tato cesta většinou .:/usr/local/lib/python.
V současných verzích interpretru jsou moduly vyhledávány v seznamu adresářů
určených proměnnou sys.path
, která je iniciována za použití jména
adresáře obsahujícího skript (nebo pracovního adresáře), proměnné
PYTHONPATH a cest závislých na instalaci interpretru. Programy jazyka
Python tedy mohou tuto proměnnou modifikovat. Poněvadž je adresář obsahující
skript první v této vyhledávací cestě, je důležité aby nějaký modul uložený
v pracovním adresáři neměl jméno stejné jako nějaký standardní modul - Python
by při pokusu o načtení modulu načetl tento soubor namísto standardního modulu.
Pro více informací nahlédněte do sekce 6.2,
"Standardní moduly."
Jako významné zrychlení spouštění krátkých programů, které používají množství standardních modulů zavádí Python soubory s příponou .pyc. Jestliže třeba v adresáři, kde se nachází soubor spam.py, existuje soubor se jménem spam.pyc, předpokládá se, že obsahuje již zkompilovanou verzi modulu spam. Čas modifikace té verze souboru spam.py použité k vytvoření souboru spam.pyc je zaznamenán ve spam.pyc. Jestliže se čas modifikace původního .py souboru a zkompilovaného .pyc liší, je soubor .pyc je ignorován a použije se původní .py.
O vytvoření souboru spam.pyc se nemusíte vůbec starat. Kdykoli je soubor spam.py bez problémů zkompilován, je učiněn pokus zapsat zkompilovanou verzi do souboru spam.pyc. Nepodaří-li se to, nejde o chybu. Pokud se soubor z nějakého důvodu nepodaří zapsat celý, pak je soubor spam.pyc při příštím importování vyhodnocen jako chybný a je ignorován. Obsah souboru spam.pyc je platformně nezávislý, takže moduly jazyka Python mohou být sdíleny počítači různých architektur.
Pár tipů pro experty:
SET_LINENO
. Veškerý bytecode je
optimalizovaný a .pyc
soubory jsou ignorovány.
Python je distribuován s knihovnou standardních modulů, popsaných v samostatném
dokumentu "Python Library Reference" (zkráceně "Library Reference"). Některé
moduly jsou nabízeny samotným interpretrem; umožňují přístup k operacím, které
nejsou součástí jádra interpretru, ale jsou mu velice blízká - buď kvůli
rychlosti nebo kvůli přístupu k voláním operačního systému. Tyto moduly jsou
závislé na konfiguračních volbách, které jsou zase závislé na platformně, kde
interpretr běží. Například, modul amoeba je přístupný pouze na
systémech, které nabízí Amoeba primitiva. Jeden modul vyžaduje zvláštní
pozornost: sys a obsahuje ho každý interpretr.
Proměnné sys.ps1
a sys.ps2
definují řetězce použité jako primární
a sekundární výzvy:
>>> import sys >>> sys.ps1 '>>> ' >>> sys.ps2 '... ' >>> sys.ps1 = 'C> ' C> print 'Ahoj!' Ahoj! C>
Tyto dvě proměnné jsou definovány pouze, je-li interpretr v interaktivním módu.
Proměnná sys.path
je seznam řetězců, které určují cesty pro vyhledávání
modulů. Je inicializován cestou převzatou z proměnné prostředí
PYTHONPATH nebo implicitní hodnoty, není-li PYTHONPATH
nastavena. Můžete jí změnit za použití standardních operací nad seznamy:
>>> import sys >>> sys.path.append('/ufs/guido/lib/python')
Interní funkce dir() se používá pro zjištění jmen, které daný modul definuje, a vrací seřazený seznam řetězců:
>>> import fibo, sys >>> dir(fibo) ['__name__', 'fib', 'fib2'] >>> dir(sys) ['__displayhook__', '__doc__', '__excepthook__', '__name__', '__stderr__', '__stdin__', '__stdout__', '_getframe', 'argv', 'builtin_module_names', 'byteorder', 'copyright', 'displayhook', 'exc_info', 'exc_type', 'excepthook', 'exec_prefix', 'executable', 'exit', 'getdefaultencoding', 'getdlopenflags', 'getrecursionlimit', 'getrefcount', 'hexversion', 'maxint', 'maxunicode', 'modules', 'path', 'platform', 'prefix', 'ps1', 'ps2', 'setcheckinterval', 'setdlopenflags', 'setprofile', 'setrecursionlimit', 'settrace', 'stderr', 'stdin', 'stdout', 'version', 'version_info', 'warnoptions']
Bez argumentů vrátí seznam jmen, které jsou definovány v aktuálním prostoru jmen:
>>> a = [1, 2, 3, 4, 5] >>> import fibo, sys >>> fib = fibo.fib >>> dir() ['__name__', 'a', 'fib', 'fibo', 'sys']
Tento seznam obsahuje všechny typy jmen: proměnné, moduly, funkce atd.
Funkce dir() neuvažuje jména interních funkcí a proměnných. Jestliže je chcete vidět, pak jsou definovány ve standardním modulu __builtin__ :
>>> import __builtin__ >>> dir(__builtin__) ['ArithmeticError', 'AssertionError', 'AttributeError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'FloatingPointError', 'IOError', 'ImportError', 'IndentationError', 'IndexError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'NameError', 'None', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'OverflowWarning', 'ReferenceError', 'RuntimeError', 'RuntimeWarning', 'StandardError', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TypeError', 'UnboundLocalError', 'UnicodeError', 'UserWarning', 'ValueError', 'Warning', 'ZeroDivisionError', '_', '__debug__', '__doc__', '__import__', '__name__', 'abs', 'apply', 'buffer', 'callable', 'chr', 'classmethod', 'cmp', 'coerce', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'eval', 'execfile', 'exit', 'file', 'filter', 'float', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'intern', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'long', 'map', 'max', 'min', 'object', 'oct', 'open', 'ord', 'pow', 'property', 'quit', 'range', 'raw_input', 'reduce', 'reload', 'repr', 'round', 'setattr', 'slice', 'staticmethod', 'str', 'super', 'tuple', 'type', 'unichr', 'unicode', 'vars', 'xrange', 'zip']
Balíčky umožňují strukturování Pythonových modulů za použití "tečkové notace". Například, modul se jménem A.B značí modul pojmenovaný "B" v balíčku "A". Stejně jako při použití modulů se autor oprošťuje od starostí s globální proměnnými jednotlivých modulů. Například autoři jednotlivých modulů rozsáhlých balíčků jako NumPy nebo Python Imaging Library se nemusí obávat střetu svých globálních proměnných s proměnnými jiného autora.
Představte si, že chcete navrhnout kolekci modulů ("balíček") pro jednotnou obsluhu zvukových souborů a zvukových dat. Existuje mnoho rozdílných zvukových formátů, takže potřebujete vytvořit a spravovat kolekci modulů pro konverze mezi těmito formáty. Také je mnoho různých operací, které budete chtít pravděpodobně se zvukovými daty provádět (například mixování, přidávání ozvěny, aplikování ekvalizéru apod.), postupně nejspíše vytvoříte množství modulů, které budou tuto činnost vykonávat. Zde je možná struktura vašeho balíčku (zobrazená jako hiearchický souborový systém):
Sound/ Hlavní balíček __init__.py Inicializace balíčku Formats/ Balíček pro konverzi souborových formátů __init__.py wavread.py wavwrite.py aiffread.py aiffwrite.py auread.py auwrite.py ... Effects/ Balíček pro zvukové efekty __init__.py echo.py surround.py reverse.py ... Filters/ Balíček filtrů __init__.py equalizer.py vocoder.py karaoke.py ...
Podle souborů __init__.py Python rozpoznává adresáře obsahující balíčky;
tato konvence byla zavedena, aby adresáře s obvyklým jménem (třeba
"string") nezakryly nějaký standardní modul, který je ve vyhledávací cestě
interpretru uveden později než aktuální adresář. V nejjednodušším případě je
__init__.py pouhý prázdný soubor, ale může také spustit inicializační
kód balíčku nebo nastavit proměnnou __all__
popisovanou později.
Uživatelé balíčku mohou importovat jednotlivé moduly tohoto balíčku, například:
import Sound.Effects.echo
Tento příkaz načte modul Sound.Effects.echo. Jeho proměnné a funkce ale musí být odkazovány plným jménem:
Sound.Effects.echo.echofilter(input, output, delay=0.7, atten=4)
Jinou možností je přímé importování modulu:
from Sound.Effects import echo
Tento příkaz také načte modul echo a učiní jej přístupným za použití jeho prefixu, takže může být použit třeba následovně:
echo.echofilter(input, output, delay=0.7, atten=4)
Další cestou je importování určité funkce nebo proměnné přímo:
from Sound.Effects.echo import echofilter
Tento příkaz opět načte modul echo a učiní jeho funkci echofilter() přístupnou přímo:
echofilter(input, output, delay=0.7, atten=4)
Jestliže používáte from balíček import jméno
, pak
jméno může být libovolný modul nebo balíček definovatný uvnitř balíčku
balíček. Stejně tak to ale může být i funkce, třída nebo proměnná.
Příkaz import
nejprve otestuje, nejedná-li se v prípadě jména
jméno o proměnnou definovanou uvnitř balíčku, není-li tomu tak,
předpokládá, že jde o modul a pokusí se ho načíst. Jestliže tento pokus selže,
dojde k výjimce ImportError.
Oproti tomu, při použití syntaxe import jméno1.jméno2.jméno3
musí být každá položka s výjimkou poslední balíček, poslední může být buď modul
nebo balíček, ale v nikdy ne třída, funkce jiná proměnná definovaná v modulu
(nebo balíčku).
Co se nyní stane, napíše-li uživatel from Sound.Effects import *
?
Mnohý uživatel by si mohl myslet, že interpretr projde souborový systém, najde
moduly patřící tomuto balíčku a importuje je. Bohužel tato operace nepracuje
dost dobře na platformách Mac a Windows, kde souborový systém neuchovává
informace o velikosti písmen jmen souborů! Na těchto platformách není žádná
záruka, že soubor ECHO.PY nebude importován jako modul echo,
Echo nebo ECHO. Omezení délky jmen soborů na 8+3 v systému
DOS přináší další problém s dlouhými jmény modulů.
Jediným řešením je poskytnutí explicitního výčtu modulů v balíčku. Příkaz
import používá následující konvenci: jestliže kód v souboru __init__.py
definuje seznam pojmenovaný __all__
, pak je tento seznam považován za
seznam jmen všech modulů, které mají být importovány při vykonání příkazu
from balíček import *
. Udržování tohoto seznamu aktuálním je na
autorovi balíčku. Autor balíčku se taktéž může rozhodnout ho nepodporovat,
jestliže považuje importování * za bezvýznamné. Například, soubor
Sounds/Effects/__init__.py by mohl obsahovat následující kód:
__all__ = ["echo", "surround", "reverse"]
Pak from Sound.Effects import *
zavede celkem tři moduly hlavního
balíčku Sound (echo, surround a reverse).
Jestliže proměnná __all__
není definována, příkaz
from Sound.Effects import *
neimportuje všechny moduly z balíčku
Sound.Effects, pouze spustí jeho inicializační kód (soubor
__init__.py) a pak importuje všechna jména, která tento kód definuje
(těmito jmény mohou být i explicitně zavedené moduly včetně všech modulů, které
byly načteny předchozími příkazy import). Proto zvažte použítí následujícího
kódu:
import Sound.Effects.echo import Sound.Effects.surround from Sound.Effects import *
V tomto příkladě poslední příkaz naimportuje moduly echo a surround do
aktuálního prostoru jmen, protože již byly načteny předchozími příkazy import.
(Takto interpretr postupuje nezávisle ne tom, zda je proměnná __all__
definována nebo ne.)
Používání from ... import * vede ke špatně čitelnému kódu. Jediným místem, kde
lze používání tohoto příkazu tolerovat je prostředí interaktivního
interpretru. Některé balíčky jsou dokonce navrženy tak, aby exportovaly jen
některá jména, kdežto jiné balíčky musí jejich uživatel importovat pouze jejich
plným jménem (čili příkaz import
).
Pamatujte, že na používání příkazu from balíček import modul
není nic špatného! Jde o velmi používaný postup, snad jen v případě, že
program potřebuje importovat více různých balíčků se stejným jménem musíte
použít jiný přístup.
import
nejprve podívá do
aktuálního balíčku a až poté prohledává standardní cestu. Proto modul surround
může jednoduše použít import echo
nebo
form echo import echofilter
. Jestliže importovaný modul není nalezen
v aktuálním balíčku, příkaz import
ho začne hledat podle pravidel, která
jsme si popsali dříve.
Je-li balíček strukturovaný na podřízené balíčky (třeba jako balíček
Sound v příkladu uvedeném výše), neexistuje žádná zkratka, jak se
odkazovat na moduly rodičovského balíčku - musí být použito plné jméno
balíčku. Například potřebuje-li modul Sound.Filters.vocoder
modul echo z balíčku Sound.Effects, musí použít příkaz
from Sound.Effects import echo
.