Subsections

 
6. Moduly

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

 
6.1 Více o modulech

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 ("_").

 
6.1.1 Cesty pro vyhledávání modulů

 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."

6.1.2 "Kompilované" 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:

 
6.2 Standardní moduly

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')

 
6.3 Funkce dir()

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']

 
6.4 Balíčky

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).

 
6.4.1 Importování * z 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.

6.4.2 Odkazování se na moduly uvnitř balíčku

Jeden modul se kolikrát potřebuje odkazovat na nějaký jiný modul uvnitř téhož balíčku. Například ve výše uvedené stuktuře modulů chce modul surround používat modul echo. Proto se příkaz 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.



Footnotes

... modulu.6.1
Ve skutečnosti jsou definice funkcí také příkazy, které mohou být spouštěny. Jejich spuštění vytvoří jméno funkce v globálním prostoru jmen tohoto modulu.
See About this document... for information on suggesting changes.