Vestavěné funkce¶

Interpret Pythonu obsahuje řadu vestavěných funkcí a typů, které jsou vždy dostupné. Zde jsou uvedeny v abecedním pořadí.

Vestavěné funkce
A `abs()` `aiter()` `all()` `anext()` `any()` `ascii()` B `bin()` `bool()` `breakpoint()` `bytearray()` `bytes()` C `callable()` `chr()` `classmethod()` `compile()` `complex()` D `delattr()` `dict()` `dir()` `divmod()`	E `enumerate()` `eval()` `exec()` F `filter()` `float()` `format()` `frozenset()` G `getattr()` `globals()` H `hasattr()` `hash()` `help()` `hex()` I `id()` `input()` `int()` `isinstance()` `issubclass()` `iter()`	L `len()` `list()` `locals()` M `map()` `max()` `memoryview()` `min()` N `next()` O `object()` `oct()` `open()` `ord()` P `pow()` `print()` `property()`	R `range()` `repr()` `reversed()` `round()` S `set()` `setattr()` `slice()` `sorted()` `staticmethod()` `str()` `sum()` `super()` T `tuple()` `type()` V `vars()` Z `zip()` _ `__import__()`

abs(number, /)¶: Vrátí absolutní hodnotu čísla. Argumentem může být celé číslo, číslo s plovoucí řádovou čárkou nebo objekt implementující metodu __abs__(). Je-li argumentem komplexní číslo, vrátí se jeho velikost.

aiter(async_iterable, /)¶

Vrátí asynchronní iterátor pro asynchronní iterovatelný objekt. Odpovídá volání x.__aiter__().

Poznámka: Na rozdíl od iter() nemá aiter() variantu se dvěma argumenty.

Added in version 3.10.

all(iterable, /)¶

Vrátí True, pokud jsou všechny prvky iterovatelného objektu pravdivé (nebo pokud je iterovatelný objekt prázdný). Odpovídá zápisu:

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

awaitable anext(async_iterator, /)¶

awaitable anext(async_iterator, default, /)

Při vyhodnocení vrátí další položku zadaného asynchronního iterátoru, případně hodnotu default, pokud byla zadána a iterátor je vyčerpán.

Jde o asynchronní variantu vestavěné funkce next(), která se chová obdobně.

Funkce zavolá metodu __anext__() objektu async_iterator, která vrátí awaitable objekt. Jeho vyhodnocení poskytne další hodnotu iterátoru. Je-li zadána hodnota default, vrátí se při vyčerpání iterátoru; jinak se vyvolá výjimka StopAsyncIteration.

Added in version 3.10.

any(iterable, /)¶

Vrátí True, pokud je alespoň jeden prvek iterovatelného objektu pravdivý. Je-li iterovatelný objekt prázdný, vrátí False. Odpovídá zápisu:

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

ascii(object, /)¶: Podobně jako repr() vrátí řetězec obsahující tisknutelnou reprezentaci objektu, znaky mimo ASCII však v řetězci vráceném funkcí repr() escapuje pomocí sekvencí \x, \u nebo \U. Vytvoří tak řetězec podobný výsledku funkce repr() v Pythonu 2.

bin(integer, /)¶

Převede celé číslo na binární řetězec s prefixem „0b“. Výsledkem je platný výraz Pythonu. Není-li integer objektem třídy int, musí definovat metodu __index__(), která vrací celé číslo. Několik příkladů:

>>> bin(3)
'0b11'
>>> bin(-10)
'-0b1010'

Podle toho, zda chcete prefix „0b“ zahrnout, můžete použít některý z následujících způsobů.

>>> format(14, '#b'), format(14, 'b')
('0b1110', '1110')
>>> f'{14:#b}', f'{14:b}'
('0b1110', '1110')

Reprezentaci záporných hodnot pomocí dvojkového doplňku nabízí také enum.bin().

Další informace najdete také u funkce format().

class bool(object=False, /)¶: Vrátí booleovskou hodnotu, tedy True nebo False. Argument se převede pomocí standardního vyhodnocení pravdivosti. Je-li argument nepravdivý nebo vynechaný, vrátí False; jinak vrátí True. Třída bool je podtřídou int (viz Numeric Types — int, float, complex) a nelze ji dále odvozovat. Jejími jedinými instancemi jsou False a True (viz Boolean Type - bool).

Změněno ve verzi 3.7: Parametr je nyní pouze poziční.

breakpoint(*args, **kws)¶

Tato funkce v místě volání spustí debugger. Konkrétně zavolá sys.breakpointhook() a přímo mu předá args a kws. Ve výchozím nastavení volá sys.breakpointhook() funkci pdb.set_trace(), která neočekává žádné argumenty. V takovém případě jde čistě o usnadnění práce, díky němuž nemusíte explicitně importovat pdb ani psát tolik kódu pro vstup do debuggeru. sys.breakpointhook() však lze nastavit na jinou funkci a breakpoint() ji automaticky zavolá, takže můžete vstoupit do zvoleného debuggeru. Není-li sys.breakpointhook() dostupná, funkce vyvolá RuntimeError.

Výchozí chování funkce breakpoint() lze změnit proměnnou prostředí PYTHONBREAKPOINT. Podrobnosti o použití najdete u sys.breakpointhook().

Pokud byla sys.breakpointhook() nahrazena, není toto chování zaručeno.

Auditní událost

Vyvolá auditní událost builtins.breakpoint s argumenty breakpointhook.

Added in version 3.7.

class bytearray(source=b'')

class bytearray(source, encoding, errors='strict')

Vrátí nové pole bajtů. Třída bytearray je měnitelná sekvence celých čísel v rozsahu 0 <= x < 256. Poskytuje většinu obvyklých metod měnitelných sekvencí popsaných v Mutable Sequence Types a také většinu metod typu bytes, viz Bytes and Bytearray Operations.

Nepovinným parametrem source lze pole inicializovat několika způsoby:

Jde-li o řetězec, musíte zadat také parametr encoding (a volitelně errors); bytearray() poté řetězec převede na bajty pomocí str.encode().
Jde-li o celé číslo, pole bude mít zadanou velikost a inicializuje se nulovými bajty.
Jde-li o objekt vyhovující rozhraní bufferu, použije se k inicializaci pole bajtů buffer objektu určený pouze pro čtení.
Jde-li o iterovatelný objekt, musí poskytovat celá čísla v rozsahu 0 <= x < 256, která se použijí jako počáteční obsah pole.

Bez argumentu se vytvoří pole o velikosti 0.

Viz také Binary Sequence Types — bytes, bytearray, memoryview a Bytearray Objects.

class bytes(source=b'')

class bytes(source, encoding, errors='strict')

Vrátí nový objekt „bytes“, který je neměnnou sekvencí celých čísel v rozsahu 0 <= x < 256. bytes je neměnnou variantou bytearray — má stejné metody, které objekt nemění, a stejné chování při indexování a vytváření výřezů.

Argumenty konstruktoru se proto interpretují stejně jako u bytearray().

Objekty bytes lze vytvářet také pomocí literálů, viz String and Bytes literals.

Viz také Binary Sequence Types — bytes, bytearray, memoryview, Bytes Objects a Bytes and Bytearray Operations.

callable(object, /)¶: Vrátí True, pokud se argument object jeví jako volatelný, jinak False. Vrátí-li funkce True, může volání přesto selhat; vrátí-li však False, volání objektu object nikdy neuspěje. Třídy jsou volatelné (volání třídy vrátí novou instanci); instance jsou volatelné, pokud jejich třída obsahuje metodu __call__().

Added in version 3.2: Funkce byla nejprve v Pythonu 3.0 odstraněna a v Pythonu 3.2 znovu přidána.

chr(codepoint, /)¶

Vrátí řetězec představující znak se zadaným kódovým bodem Unicode. Například chr(97) vrátí řetězec 'a', zatímco chr(8364) vrátí řetězec '€'. Jde o inverzní funkci k ord().

Platný rozsah argumentu je od 0 do 1 114 111 (0x10FFFF v šestnáctkové soustavě). Hodnota mimo tento rozsah vyvolá ValueError.

@classmethod¶

Převede metodu na metodu třídy.

Metoda třídy přijímá třídu jako implicitní první argument, podobně jako instanční metoda přijímá instanci. Metodu třídy deklarujete tímto zápisem:

class C:
    @classmethod
    def f(cls, arg1, arg2): ...

Zápis @classmethod je dekorátor funkce — podrobnosti najdete v Function definitions.

Metodu třídy lze volat na třídě (například C.f()) i na instanci (například C().f()). Instance se kromě určení její třídy ignoruje. Je-li metoda třídy volána pro odvozenou třídu, předá se objekt odvozené třídy jako implicitní první argument.

Metody třídy se liší od statických metod v C++ nebo Javě. Pokud potřebujete statickou metodu, viz staticmethod() v této části. Další informace o metodách třídy najdete v The standard type hierarchy.

Změněno ve verzi 3.9: Metody třídy nyní mohou obalovat jiné deskriptory, například property().

Změněno ve verzi 3.10: Metody třídy nyní přebírají atributy metody (__module__, __name__, __qualname__, __doc__ a __annotations__) a mají nový atribut __wrapped__.

Zastaralé od verze 3.11, odstraněno ve verzi 3.13: Metody třídy již nemohou obalovat jiné deskriptory, například property().

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)¶

Zkompiluje source do objektu kódu nebo AST. Objekty kódu lze spustit pomocí exec() nebo eval(). source může být běžný řetězec, bajtový řetězec nebo objekt AST. Informace o práci s objekty AST najdete v dokumentaci modulu ast.

Argument filename by měl určovat soubor, ze kterého byl kód načten. Pokud nebyl načten ze souboru, předejte nějakou rozpoznatelnou hodnotu (běžně se používá '<string>').

Argument mode určuje druh kompilovaného kódu. Může mít hodnotu 'exec', pokud source tvoří posloupnost příkazů, 'eval', pokud jej tvoří jediný výraz, nebo 'single', pokud jej tvoří jediný interaktivní příkaz (v posledním případě se vypíší příkazy výrazů, jejichž výsledkem není None).

Nepovinné argumenty flags a dont_inherit určují, které volby kompilátoru se aktivují a které budoucí vlastnosti se povolí. Není-li zadán ani jeden z nich (nebo jsou oba nulové), kód se zkompiluje se stejnými příznaky, které působí na kód volající compile(). Je-li zadán argument flags a dont_inherit zadán není (nebo je nulový), použijí se volby kompilátoru a příkazy future určené argumentem flags navíc k těm, které by se použily tak jako tak. Je-li dont_inherit nenulové celé číslo, použije se výhradně argument flags — příznaky okolního kódu (budoucí vlastnosti a volby kompilátoru) se ignorují.

Volby kompilátoru a příkazy future se určují bity, které lze bitově spojovat operátorem OR a zadat tak více voleb. Bitové pole potřebné pro konkrétní budoucí vlastnost najdete v atributu compiler_flag instance _Feature v modulu __future__. Příznaky kompilátoru s prefixem PyCF_ najdete v modulu ast.

Argument optimize určuje úroveň optimalizace kompilátoru. Výchozí hodnota -1 vybere úroveň optimalizace interpretu danou volbami -O. Explicitní úrovně jsou 0 (bez optimalizace; __debug__ je pravdivé), 1 (příkazy assert se odstraní a __debug__ je nepravdivé) nebo 2 (odstraní se také dokumentační řetězce).

Pokud kompilovaný zdroj není platný, funkce vyvolá SyntaxError nebo ValueError.

Chcete-li kód Pythonu zpracovat do reprezentace AST, viz ast.parse().

Auditní událost

Vyvolá auditní událost compile s argumenty source a filename. Tuto událost může vyvolat také implicitní kompilace.

Poznámka

Při kompilaci řetězce s víceřádkovým kódem v režimu 'single' nebo 'eval' musí být vstup ukončen alespoň jedním znakem nového řádku. Usnadňuje to rozpoznávání neúplných a úplných příkazů v modulu code.

Varování

Při kompilaci dostatečně velkého nebo složitého řetězce do objektu AST může kvůli omezené hloubce zásobníku kompilátoru AST dojít k pádu interpretu Pythonu.

Změněno ve verzi 3.2: Bylo povoleno použití znaků konce řádku Windows a Mac. Vstup v režimu 'exec' již také nemusí končit novým řádkem. Byl přidán parametr optimize.

Změněno ve verzi 3.5: Při výskytu nulových bajtů ve source se dříve vyvolala TypeError.

Added in version 3.8: V příznacích lze nyní předat ast.PyCF_ALLOW_TOP_LEVEL_AWAIT a povolit tak podporu await, async for a async with na nejvyšší úrovni.

class complex(number=0, /)¶

class complex(string, /)

class complex(real=0, imag=0)

Převede jeden řetězec nebo číslo na komplexní číslo, případně vytvoří komplexní číslo z reálné a imaginární části.

Příklady:

>>> complex('+1.23')
(1.23+0j)
>>> complex('-4.5j')
-4.5j
>>> complex('-1.23+4.5j')
(-1.23+4.5j)
>>> complex('\t( -1.23+4.5J )\n')
(-1.23+4.5j)
>>> complex('-Infinity+NaNj')
(-inf+nanj)
>>> complex(1.23)
(1.23+0j)
>>> complex(imag=-4.5)
-4.5j
>>> complex(-1.23, 4.5)
(-1.23+4.5j)

Je-li argumentem řetězec, musí obsahovat buď reálnou část (ve stejném formátu jako u float()), nebo imaginární část (ve stejném formátu, avšak s příponou 'j' či 'J'), případně reálnou i imaginární část (v tomto případě je znaménko imaginární části povinné). Řetězec může být obklopen prázdnými znaky a kulatými závorkami '(' a ')', které se ignorují. Řetězec nesmí obsahovat prázdné znaky mezi '+', '-', příponou 'j' nebo 'J' a desetinným číslem. Například complex('1+2j') je platné, ale complex('1 + 2j') vyvolá ValueError. Přesněji řečeno musí vstup po odstranění závorek a úvodních i koncových prázdných znaků odpovídat syntaktickému pravidlu complexvalue v následující gramatice:

complexvalue ::= floatvalue |
                 floatvalue ("j" | "J") |
                 floatvalue sign absfloatvalue ("j" | "J")

Je-li argumentem číslo, slouží konstruktor k číselnému převodu podobně jako int a float. U obecného objektu Pythonu x deleguje complex(x) na x.__complex__(). Není-li definována __complex__(), použije se __float__(). Není-li definována ani __float__(), použije se __index__().

Jsou-li zadány dva argumenty nebo použity argumenty klíčových slov, může být každý argument libovolného číselného typu (včetně komplexního). Jsou-li oba argumenty reálná čísla, vrátí komplexní číslo s reálnou složkou real a imaginární složkou imag. Jsou-li oba argumenty komplexní čísla, vrátí komplexní číslo s reálnou složkou real.real-imag.imag a imaginární složkou real.imag+imag.real. Je-li jeden z argumentů reálné číslo, použije se ve výše uvedených výrazech pouze jeho reálná složka.

Viz také complex.from_number(), která přijímá pouze jeden číselný argument.

Jsou-li všechny argumenty vynechány, vrátí 0j.

Komplexní typ je popsán v Numeric Types — int, float, complex.

Změněno ve verzi 3.6: Je povoleno seskupování číslic pomocí podtržítek stejně jako v číselných literálech.

Změněno ve verzi 3.8: Na __index__() se přejde, nejsou-li definovány __complex__() ani __float__().

Zastaralé od verze 3.14: Předávání komplexního čísla jako argumentu real nebo imag je nyní zastaralé; mělo by se předávat pouze jako jediný poziční argument.

delattr(object, name, /)¶: Tato funkce je příbuzná s setattr(). Argumenty jsou objekt a řetězec. Řetězec musí být názvem jednoho z atributů objektu. Pokud to objekt dovoluje, funkce pojmenovaný atribut odstraní. Například delattr(x, 'foobar') odpovídá zápisu del x.foobar. name nemusí být identifikátorem Pythonu (viz setattr()).

class dict(**kwargs)

class dict(mapping, /, **kwargs)

class dict(iterable, /, **kwargs)

Vytvoří nový slovník. Objekt dict je třídou slovníku. Dokumentaci této třídy najdete u dict a v Mapping Types — dict.

Další kontejnery popisují vestavěné třídy list, set a tuple a také modul collections.

dir()¶

dir(object, /)

Bez argumentu vrátí seznam názvů v aktuálním lokálním oboru platnosti. S argumentem se pokusí vrátit seznam platných atributů daného objektu.

Má-li objekt metodu __dir__(), tato metoda se zavolá a musí vrátit seznam atributů. Objekty implementující vlastní funkci __getattr__() nebo __getattribute__() tak mohou přizpůsobit způsob, jakým dir() vypisuje jejich atributy.

Neposkytuje-li objekt __dir__(), pokusí se funkce co nejlépe shromáždit informace z atributu objektu __dict__, je-li definován, a z objektu jeho typu. Výsledný seznam nemusí být úplný a může být nepřesný, pokud má objekt vlastní __getattr__().

Výchozí mechanismus dir() se u různých typů objektů chová odlišně, protože se snaží poskytnout spíše nejrelevantnější než úplné informace:

Je-li objekt modulem, seznam obsahuje názvy atributů modulu.
Je-li objekt typem nebo třídou, seznam obsahuje názvy jeho atributů a rekurzivně také atributů jeho bází.
V ostatních případech seznam obsahuje názvy atributů objektu, názvy atributů jeho třídy a rekurzivně také atributů bázových tříd jeho třídy.

Výsledný seznam je seřazen abecedně. Například:

>>> import struct
>>> dir()   # show the names in the module namespace
['__builtins__', '__name__', 'struct']
>>> dir(struct)   # show the names in the struct module
['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
 '__initializing__', '__loader__', '__name__', '__package__',
 '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
 'unpack', 'unpack_from']
>>> class Shape:
...     def __dir__(self):
...         return ['area', 'perimeter', 'location']
...
>>> s = Shape()
>>> dir(s)
['area', 'location', 'perimeter']

Poznámka

Protože je dir() určena především pro pohodlné použití na interaktivní výzvě, snaží se spíše poskytnout zajímavou množinu názvů než přesně a konzistentně definovanou množinu. Její podrobné chování se proto může mezi vydáními měnit. Pokud je například argumentem třída, nejsou ve výsledném seznamu atributy metatřídy.

divmod(a, b, /)¶: Přijme dvě čísla (nikoli komplexní) a vrátí dvojici čísel tvořenou jejich podílem a zbytkem při celočíselném dělení. U smíšených typů operandů platí pravidla binárních aritmetických operátorů. Pro celá čísla je výsledek stejný jako (a // b, a % b). Pro čísla s plovoucí řádovou čárkou je výsledkem (q, a % b), kde q obvykle odpovídá math.floor(a / b), může však být o 1 menší. V každém případě je q * b + a % b velmi blízko a; je-li a % b nenulové, má stejné znaménko jako b a platí 0 <= abs(a % b) < abs(b).

enumerate(iterable, start=0)¶

Vrátí objekt enumerate. iterable musí být sekvence, iterátor nebo jiný objekt podporující iteraci. Metoda __next__() iterátoru vráceného funkcí enumerate() poskytuje n-tici obsahující pořadové číslo (od hodnoty start, jejíž výchozí hodnota je 0) a hodnotu získanou iterací přes iterable.

>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

Odpovídá zápisu:

def enumerate(iterable, start=0):
    n = start
    for elem in iterable:
        yield n, elem
        n += 1

eval(source, /, globals=None, locals=None)¶

Parametry:

source (str | code object) – Výraz Pythonu.
globals (dict | None) – Globální jmenný prostor (výchozí hodnota: None).
locals (mapping | None) – Lokální jmenný prostor (výchozí hodnota: None).

Vrací:

Výsledek vyhodnoceného výrazu.

Raises:

Syntaktické chyby se oznamují jako výjimky.

Varování

Tato funkce spouští libovolný kód. Její volání s nedůvěryhodným vstupem poskytnutým uživatelem vede k bezpečnostním zranitelnostem.

Argument source se zpracuje a vyhodnotí jako výraz Pythonu (technicky jako seznam podmínek), přičemž mapování globals a locals slouží jako globální a lokální jmenný prostor. Je-li zadán slovník globals a neobsahuje hodnotu pro klíč __builtins__, vloží se pod tento klíč před zpracováním source odkaz na slovník vestavěného modulu builtins. Přepsáním __builtins__ lze omezit nebo změnit dostupné názvy, nejde však o bezpečnostní mechanismus: spuštěný kód má stále přístup ke všem vestavěným objektům. Je-li mapování locals vynecháno, použije se jako výchozí slovník globals. Jsou-li obě mapování vynechána, zdroj se spustí s hodnotami globals a locals prostředí, ve kterém se volá eval(). Pozor, eval() bude mít přístup k vnořeným oborům platnosti (nelokálním názvům) okolního prostředí pouze tehdy, pokud se na ně již odkazuje obor platnosti volající eval() (například prostřednictvím příkazu nonlocal).

Příklad:

>>> x = 1
>>> eval('x+1')
2

Funkci lze použít také ke spuštění libovolných objektů kódu (například vytvořených funkcí compile()). V takovém případě předejte místo řetězce objekt kódu. Pokud byl objekt kódu zkompilován s argumentem mode nastaveným na 'exec', bude návratovou hodnotou eval() hodnota None.

Tip: Dynamické spouštění příkazů podporuje funkce exec(). Funkce globals() a locals() vracejí aktuální globální, respektive lokální slovník, které lze předávat pro použití funkcemi eval() nebo exec().

Je-li zadaný zdroj řetězcem, odstraní se z něj úvodní a koncové mezery a tabulátory.

Funkci pro vyhodnocování řetězců s výrazy obsahujícími pouze literály nabízí ast.literal_eval().

Auditní událost

Vyvolá auditní událost exec s objektem kódu jako argumentem. Mohou se vyvolat také události kompilace kódu.

Změněno ve verzi 3.13: Argumenty globals a locals lze nyní předávat jako klíčová slova.

Změněno ve verzi 3.13: Sémantika výchozího jmenného prostoru locals byla upravena podle popisu vestavěné funkce locals().

exec(source, /, globals=None, locals=None, *, closure=None)¶

Varování

Tato funkce spouští libovolný kód. Její volání s nedůvěryhodným vstupem poskytnutým uživatelem vede k bezpečnostním zranitelnostem.

Tato funkce podporuje dynamické spouštění kódu Pythonu. source musí být řetězec nebo objekt kódu. Jde-li o řetězec, zpracuje se jako blok příkazů Pythonu, který se následně spustí (pokud nedojde k syntaktické chybě). [1] Jde-li o objekt kódu, jednoduše se spustí. Spouštěný kód musí být ve všech případech platný jako vstup ze souboru (viz část File input v Referenční příručce). Pamatujte, že příkazy nonlocal, yield a return nelze použít mimo definice funkcí ani v kódu předaném funkci exec(). Návratovou hodnotou je None.

Jsou-li nepovinné části vynechány, spustí se kód ve všech případech v aktuálním oboru platnosti. Je-li zadáno pouze globals, musí jít o slovník (nikoli podtřídu slovníku), který se použije pro globální i lokální proměnné. Jsou-li zadány globals i locals, použijí se pro globální, respektive lokální proměnné. Zadané locals může být libovolný mapovací objekt. Pamatujte, že na úrovni modulu jsou globals a locals stejným slovníkem.

Poznámka

Obdrží-li exec dva samostatné objekty globals a locals, spustí se kód tak, jako by byl vložen do definice třídy. Funkce a třídy definované ve spuštěném kódu proto nebudou mít přístup k proměnným přiřazeným na nejvyšší úrovni (protože se s proměnnými „nejvyšší úrovně“ zachází jako s proměnnými třídy v její definici).

Neobsahuje-li slovník globals hodnotu pro klíč __builtins__, vloží se pod něj odkaz na slovník vestavěného modulu builtins. Přepsáním __builtins__ lze omezit nebo změnit dostupné názvy, nejde však o bezpečnostní mechanismus: spuštěný kód má stále přístup ke všem vestavěným objektům.

Argument closure určuje uzávěr — n-tici buněčných proměnných. Je platný pouze tehdy, když je object objektem kódu obsahujícím volné proměnné uzávěru. Délka n-tice musí přesně odpovídat délce atributu co_freevars objektu kódu.

Auditní událost

Vyvolá auditní událost exec s objektem kódu jako argumentem. Mohou se vyvolat také události kompilace kódu.

Poznámka

Vestavěné funkce globals() a locals() vracejí aktuální globální, respektive lokální jmenný prostor. Lze je proto předat jako druhý a třetí argument funkce exec().

Poznámka

Výchozí locals se chová podle popisu funkce locals() níže. Potřebujete-li po návratu funkce exec() pozorovat účinky kódu na locals, předejte explicitní slovník locals.

Změněno ve verzi 3.11: Byl přidán parametr closure.

Změněno ve verzi 3.13: Argumenty globals a locals lze nyní předávat jako klíčová slova.

Změněno ve verzi 3.13: Sémantika výchozího jmenného prostoru locals byla upravena podle popisu vestavěné funkce locals().

filter(function, iterable, /)¶

Vytvoří iterátor z těch prvků objektu iterable, pro něž je function pravdivá. iterable může být sekvence, kontejner podporující iteraci nebo iterátor. Je-li function rovna None, předpokládá se identická funkce, takže se odstraní všechny nepravdivé prvky objektu iterable.

filter(function, iterable) je ekvivalentní generátorovému výrazu (item for item in iterable if function(item)), není-li function rovna None, a výrazu (item for item in iterable if item), je-li function rovna None.

Doplňkovou funkci vracející prvky objektu iterable, pro něž je function nepravdivá, popisuje itertools.filterfalse().

class float(number=0.0, /)¶

class float(string, /)

Vrátí číslo s plovoucí řádovou čárkou vytvořené z čísla nebo řetězce.

Příklady:

>>> float('+1.23')
1.23
>>> float('   -12345\n')
-12345.0
>>> float('1e-003')
0.001
>>> float('+1E6')
1000000.0
>>> float('-Infinity')
-inf

Je-li argument řetězec, měl by obsahovat desetinné číslo, jemuž může předcházet znaménko a které může být obklopeno bílými znaky. Volitelné znaménko může být '+' nebo '-'; znaménko '+' nemá na výslednou hodnotu žádný vliv. Argument může být také řetězec představující NaN (není číslo) nebo kladné či záporné nekonečno. Přesněji řečeno musí vstup po odstranění počátečních a koncových bílých znaků odpovídat produkčnímu pravidlu floatvalue v následující gramatice:

sign          ::= "+" | "-"
infinity      ::= "Infinity" | "inf"
nan           ::= "nan"
digit         ::= <a Unicode decimal digit, i.e. characters in Unicode general category Nd>
digitpart     ::= digit (["_"] digit)*
number        ::= [digitpart] "." digitpart | digitpart ["."]
exponent      ::= ("e" | "E") [sign] digitpart
floatnumber   ::= number [exponent]
absfloatvalue ::= floatnumber | infinity | nan
floatvalue    ::= [sign] absfloatvalue

Na velikosti písmen nezáleží, takže například „inf“, „Inf“, „INFINITY“ a „iNfINity“ jsou všechno přípustné zápisy kladného nekonečna.

Je-li argument celé číslo nebo číslo s plovoucí řádovou čárkou, vrátí se číslo s plovoucí řádovou čárkou se stejnou hodnotou (v rámci přesnosti čísel s plovoucí řádovou čárkou v Pythonu). Leží-li argument mimo rozsah typu float v Pythonu, vyvolá se OverflowError.

U obecného objektu Pythonu x deleguje float(x) na x.__float__(). Není-li definována __float__(), použije se __index__().

Viz také float.from_number(), která přijímá pouze číselný argument.

Není-li zadán žádný argument, vrátí se 0.0.

Typ float popisuje oddíl Numeric Types — int, float, complex.

Změněno ve verzi 3.6: Je povoleno seskupovat číslice podtržítky stejně jako v literálech kódu.

Změněno ve verzi 3.7: Parametr je nyní pouze poziční.

Změněno ve verzi 3.8: Na __index__() se přejde, není-li definována __float__().

format(value, format_spec='', /)¶

Převede value na „formátovanou“ reprezentaci řízenou parametrem format_spec. Interpretace format_spec závisí na typu argumentu value; většina vestavěných typů však používá standardní syntaxi formátování: Format specification mini-language.

Výchozí format_spec je prázdný řetězec, který má obvykle stejný účinek jako volání str(value).

Volání format(value, format_spec) se převede na type(value).__format__(value, format_spec), čímž se při hledání metody __format__() hodnoty obejde slovník instance. Výjimka TypeError se vyvolá, pokud hledání metody dospěje k object a format_spec není prázdný, nebo pokud format_spec či návratová hodnota nejsou řetězce.

Změněno ve verzi 3.4: object().__format__(format_spec) vyvolá TypeError, pokud format_spec není prázdný řetězec.

class frozenset(iterable=(), /)

Vrátí nový objekt frozenset, volitelně s prvky převzatými z iterable. frozenset je vestavěná třída. Dokumentaci této třídy uvádějí frozenset a Set Types — set, frozenset.

Další kontejnery popisují vestavěné třídy set, list, tuple a dict i modul collections.

getattr(object, name, /)¶
getattr(object, name, default, /): Vrátí hodnotu pojmenovaného atributu objektu object. name musí být řetězec. Je-li řetězec názvem některého atributu objektu, výsledkem je hodnota tohoto atributu. Například getattr(x, 'foobar') je ekvivalentní výrazu x.foobar. Pokud pojmenovaný atribut neexistuje, vrátí se zadaná hodnota default, jinak se vyvolá AttributeError. name nemusí být identifikátor Pythonu (viz setattr()).

Poznámka

Protože k komolení soukromých názvů dochází při kompilaci, je nutné název soukromého atributu (atributu se dvěma počátečními podtržítky) pro získání pomocí getattr() zkomolit ručně.

globals()¶: Vrátí slovník implementující jmenný prostor aktuálního modulu. Pro kód uvnitř funkcí se tento prostor určí při definici funkce a zůstává stejný bez ohledu na to, odkud se funkce volá.

hasattr(object, name, /)¶: Argumenty jsou objekt a řetězec. Výsledkem je True, pokud je řetězec názvem některého atributu objektu, jinak False. (Implementace volá getattr(object, name) a zjišťuje, zda vyvolá AttributeError.)

hash(object, /)¶: Vrátí hodnotu otisku objektu (pokud ji má). Hodnoty otisku jsou celá čísla. Používají se k rychlému porovnávání klíčů při vyhledávání ve slovníku. Číselné hodnoty, které se porovnají jako shodné, mají stejnou hodnotu otisku (i když jsou různých typů, jako například 1 a 1.0).

Poznámka

U objektů s vlastní metodou __hash__() mějte na paměti, že hash() zkrátí návratovou hodnotu podle bitové šířky hostitelského počítače.

help()¶

help(request)

Spustí vestavěný systém nápovědy. (Tato funkce je určena k interaktivnímu použití.) Není-li zadán argument, spustí se interaktivní nápověda v konzoli interpretu. Je-li argument řetězec, vyhledá se jako název modulu, funkce, třídy, metody, klíčového slova nebo tématu dokumentace a v konzoli se vypíše stránka nápovědy. U argumentu jakéhokoli jiného druhu se vytvoří stránka nápovědy k danému objektu.

Objeví-li se při volání help() v seznamu parametrů funkce lomítko (/), znamená to, že parametry před lomítkem jsou pouze poziční. Další informace uvádí položka FAQ o pouze pozičních parametrech.

Tuto funkci přidává do vestavěného jmenného prostoru modul site.

Změněno ve verzi 3.4: Díky změnám modulů pydoc a inspect jsou nyní uváděné signatury volatelných objektů úplnější a konzistentnější.

hex(integer, /)¶

Převede celé číslo na řetězec s malými šestnáctkovými číslicemi a předponou „0x“. Není-li integer objektem int Pythonu, musí definovat metodu __index__(), která vrací celé číslo. Několik příkladů:

>>> hex(255)
'0xff'
>>> hex(-42)
'-0x2a'

Chcete-li převést celé číslo na řetězec s velkými nebo malými šestnáctkovými číslicemi, s předponou či bez ní, můžete použít některý z následujících způsobů:

>>> '%#x' % 255, '%x' % 255, '%X' % 255
('0xff', 'ff', 'FF')
>>> format(255, '#x'), format(255, 'x'), format(255, 'X')
('0xff', 'ff', 'FF')
>>> f'{255:#x}', f'{255:x}', f'{255:X}'
('0xff', 'ff', 'FF')

Další informace uvádí format().

Převod šestnáctkového řetězce na celé číslo se základem 16 popisuje také int().

Poznámka

Šestnáctkovou řetězcovou reprezentaci čísla float získáte metodou float.hex().

id(object, /)¶: Vrátí „identitu“ objektu. Jde o celé číslo, které je po dobu života objektu zaručeně jedinečné a neměnné. Dva objekty s nepřekrývající se dobou života mohou mít stejnou hodnotu id().

Implementační detail CPythonu

Jde o adresu objektu v paměti.

Auditní událost

Vyvolá auditní událost builtins.id s argumenty id.

input()¶

input(prompt, /)

Je-li přítomen argument prompt, vypíše se na standardní výstup bez koncového znaku nového řádku. Funkce poté načte řádek ze vstupu, převede jej na řetězec (s odstraněním koncového znaku nového řádku) a vrátí jej. Při načtení EOF se vyvolá EOFError. Příklad:

>>> s = input('--> ')
--> Monty Python's Flying Circus
>>> s
"Monty Python's Flying Circus"

Je-li načten modul readline, použije jej input() k poskytnutí propracovaných funkcí pro úpravu řádku a historii.

Auditní událost

Před čtením vstupu vyvolá auditní událost builtins.input s argumentem prompt.

Auditní událost

Po úspěšném načtení vstupu vyvolá auditní událost builtins.input/result s výsledkem.

class int(number=0, /)¶

class int(string, /, base=10)

Vrátí objekt celého čísla vytvořený z čísla nebo řetězce; nejsou-li zadány žádné argumenty, vrátí 0.

Příklady:

>>> int(123.45)
123
>>> int('123')
123
>>> int('   -12_345\n')
-12345
>>> int('FACE', 16)
64206
>>> int('0xface', 0)
64206
>>> int('01110011', base=2)
115

Definuje-li argument metodu __int__(), vrátí int(x) hodnotu x.__int__(). Definuje-li argument __index__(), vrátí x.__index__(). U čísel s plovoucí řádovou čárkou se hodnota ořízne směrem k nule.

Není-li argument číslo nebo je-li zadán base, musí jít o řetězec či instanci bytes nebo bytearray, která představuje celé číslo v číselné soustavě se základem base. Řetězci může volitelně předcházet + nebo - (bez mezery mezi nimi), může mít počáteční nuly, být obklopen bílými znaky a obsahovat mezi číslicemi jednotlivá podtržítka.

Řetězec celého čísla o základu n obsahuje číslice, z nichž každá představuje hodnotu od 0 do n-1. Hodnoty 0–9 lze zapsat libovolnou desetinnou číslicí Unicode. Hodnoty 10–35 lze zapsat písmeny a až z (nebo A až Z). Výchozí hodnota base je 10. Povolené základy jsou 0 a 2–36. Řetězce se základem 2, 8 a 16 mohou mít předponu 0b/0B, 0o/0O nebo 0x/0X stejně jako celočíselné literály v kódu. Při základu 0 se řetězec interpretuje obdobně jako celočíselný literál v kódu: skutečný základ 2, 8, 10 nebo 16 určuje předpona. Základ 0 také nepovoluje počáteční nuly: int('010', 0) není platné, zatímco int('010') a int('010', 8) ano.

Celočíselný typ popisuje oddíl Numeric Types — int, float, complex.

Změněno ve verzi 3.4: Není-li base instancí int a má-li objekt base metodu base.__index__, zavolá se tato metoda pro získání celého čísla představujícího základ. Předchozí verze používaly base.__int__ namísto base.__index__.

Změněno ve verzi 3.6: Je povoleno seskupovat číslice podtržítky stejně jako v literálech kódu.

Změněno ve verzi 3.7: První parametr je nyní pouze poziční.

Změněno ve verzi 3.8: Na __index__() se přejde, není-li definována __int__().

Změněno ve verzi 3.11: Řetězcové vstupy a řetězcové reprezentace typu int lze omezit, což pomáhá předcházet útokům typu odepření služby. Při překročení limitu se vyvolá ValueError, ať už k němu dojde během převodu řetězce na int, nebo by limit překročil převod int na řetězec. Viz dokumentace omezení délky řetězcového převodu celých čísel.

Změněno ve verzi 3.14: int() již nedeleguje na metodu __trunc__().

isinstance(object, classinfo, /)¶: Vrátí True, je-li argument object instancí argumentu classinfo nebo jeho (přímé, nepřímé či virtuální) podtřídy. Není-li object objektem daného typu, funkce vždy vrátí False. Je-li classinfo n-ticí objektů typů (případně rekurzivně dalších takových n-tic) nebo sjednocením typů více typů, vrátí True, pokud je object instancí kteréhokoli z nich. Není-li classinfo typem ani n-ticí typů a takových n-tic, vyvolá se výjimka TypeError. U neplatného typu se TypeError nemusí vyvolat, uspěje-li dřívější test.

Změněno ve verzi 3.10: classinfo může být sjednocením typů.

issubclass(class, classinfo, /)¶: Vrátí True, je-li class (přímou, nepřímou či virtuální) podtřídou classinfo. Třída se považuje za podtřídu sebe sama. classinfo může být n-tice objektů tříd (případně rekurzivně dalších takových n-tic) nebo sjednocení typů; v takovém případě vrátí True, je-li class podtřídou kterékoli položky v classinfo. Ve všech ostatních případech se vyvolá výjimka TypeError.

Změněno ve verzi 3.10: classinfo může být sjednocením typů.

iter(iterable, /)¶

iter(callable, sentinel, /)

Vrátí objekt iterátoru. První argument se interpretuje velmi odlišně podle přítomnosti druhého argumentu. Bez druhého argumentu musí jediný argument být kolekce podporující protokol iterovatelného objektu (metodu __iter__()) nebo protokol sekvence (metodu __getitem__() s celočíselnými argumenty začínajícími hodnotou 0). Nepodporuje-li ani jeden z těchto protokolů, vyvolá se TypeError. Je-li zadán druhý argument sentinel, musí být první argument volatelný objekt. Takto vytvořený iterátor při každém volání své metody __next__() zavolá callable bez argumentů; rovná-li se vrácená hodnota hodnotě sentinel, vyvolá se StopIteration, jinak se hodnota vrátí.

Viz také Iterator Types.

Jedním z užitečných použití druhé podoby iter() je vytvoření čtečky bloků. Například čtení bloků pevné šířky z binárního databázového souboru až do dosažení konce souboru:

from functools import partial
with open('mydata.db', 'rb') as f:
    for block in iter(partial(f.read, 64), b''):
        process_block(block)

len(object, /)¶: Vrátí délku (počet položek) objektu. Argumentem může být sekvence (například řetězec, bytes, n-tice, seznam nebo range) či kolekce (například slovník, množina nebo neměnná množina).

Implementační detail CPythonu

len vyvolá OverflowError u délek větších než sys.maxsize, například range(2 ** 100).

class list(iterable=(), /): list ve skutečnosti není funkce, ale typ měnitelné sekvence, jak popisují oddíly Lists a Sequence Types — list, tuple, range.

locals()¶

Vrátí mapovací objekt představující aktuální místní tabulku symbolů, v níž jsou klíči názvy proměnných a hodnotami jejich právě navázané reference.

V oboru platnosti modulu i při použití exec() nebo eval() s jediným jmenným prostorem vrací tato funkce stejný jmenný prostor jako globals().

V oboru platnosti třídy vrací jmenný prostor, který bude předán konstruktoru metatřídy.

Při použití exec() nebo eval() s oddělenými místními a globálními argumenty vrací místní jmenný prostor předaný volání funkce.

Ve všech výše uvedených případech vrátí každé volání locals() v daném rámci vykonávání tentýž mapovací objekt. Změny provedené prostřednictvím mapovacího objektu vráceného z locals() se projeví jako přiřazené, znovu přiřazené nebo odstraněné místní proměnné a přiřazení, opětovné přiřazení či odstranění místních proměnných okamžitě ovlivní obsah vráceného mapování.

V optimalizovaném oboru platnosti (včetně funkcí, generátorů a korutin) naproti tomu každé volání locals() vrací nový slovník s aktuálními vazbami místních proměnných funkce a všech nelokálních referencí buněk. Změny vazeb názvů provedené prostřednictvím vráceného slovníku se v tomto případě nezapisují zpět do odpovídajících místních proměnných ani nelokálních referencí buněk. Jejich přiřazení, opětovné přiřazení či odstranění zároveň neovlivní obsah dříve vrácených slovníků.

Volání locals() v rámci komprehenze ve funkci, generátoru nebo korutině odpovídá volání v obklopujícím oboru platnosti, zahrne však inicializované iterační proměnné komprehenze. V ostatních oborech se chová, jako kdyby komprehenze běžela jako vnořená funkce.

Volání locals() v rámci generátorového výrazu odpovídá volání ve vnořené generátorové funkci.

Změněno ve verzi 3.12: Chování locals() v komprehenzi bylo upraveno podle PEP 709.

Změněno ve verzi 3.13: V rámci PEP 667 je nyní definována sémantika změn mapovacích objektů vrácených touto funkcí. Chování v optimalizovaných oborech platnosti nyní odpovídá výše uvedenému popisu. V ostatních oborech zůstává kromě svého zpřesnění oproti předchozím verzím nezměněné.

map(function, iterable, /, *iterables, strict=False)¶: Vrátí iterátor, který použije function na každou položku objektu iterable a poskytuje výsledky. Jsou-li předány další argumenty iterables, musí function přijímat odpovídající počet argumentů a používá se souběžně na položky všech iterovatelných objektů. U více iterovatelných objektů se iterátor zastaví po vyčerpání nejkratšího z nich. Je-li strict rovno True a některý iterovatelný objekt se vyčerpá dříve než ostatní, vyvolá se ValueError. Pro případy, kdy jsou vstupy funkce již uspořádány do n-tic argumentů, viz itertools.starmap().

Změněno ve verzi 3.14: Přidán parametr strict.

max(iterable, /, *, key=None)¶

max(iterable, /, *, default, key=None)

max(arg1, arg2, /, *args, key=None)

Vrátí největší položku iterovatelného objektu nebo největší ze dvou či více argumentů.

Je-li zadán jeden poziční argument, měl by být iterovatelným objektem. Vrátí se jeho největší položka. Jsou-li zadány dva nebo více pozičních argumentů, vrátí se největší z nich.

K dispozici jsou dva volitelné argumenty pouze klíčových slov. Argument key určuje jednoargumentovou řadicí funkci podobnou té, kterou používá list.sort(). Argument default určuje objekt vrácený v případě, že je zadaný iterovatelný objekt prázdný. Je-li prázdný a default není zadán, vyvolá se ValueError.

Je-li maximálních položek více, funkce vrátí první nalezenou. To odpovídá ostatním nástrojům zachovávajícím stabilitu řazení, například sorted(iterable, key=keyfunc, reverse=True)[0] a heapq.nlargest(1, iterable, key=keyfunc).

Změněno ve verzi 3.4: Přidán parametr pouze klíčového slova default.

Změněno ve verzi 3.8: key může být None.

class memoryview(object): Vrátí objekt „pohledu do paměti“ vytvořený ze zadaného argumentu. Další informace uvádí Memory Views.

min(iterable, /, *, key=None)¶

min(iterable, /, *, default, key=None)

min(arg1, arg2, /, *args, key=None)

Vrátí nejmenší položku iterovatelného objektu nebo nejmenší ze dvou či více argumentů.

Je-li zadán jeden poziční argument, měl by být iterovatelným objektem. Vrátí se jeho nejmenší položka. Jsou-li zadány dva nebo více pozičních argumentů, vrátí se nejmenší z nich.

K dispozici jsou dva volitelné argumenty pouze klíčových slov. Argument key určuje jednoargumentovou řadicí funkci podobnou té, kterou používá list.sort(). Argument default určuje objekt vrácený v případě, že je zadaný iterovatelný objekt prázdný. Je-li prázdný a default není zadán, vyvolá se ValueError.

Je-li minimálních položek více, funkce vrátí první nalezenou. To odpovídá ostatním nástrojům zachovávajícím stabilitu řazení, například sorted(iterable, key=keyfunc)[0] a heapq.nsmallest(1, iterable, key=keyfunc).

Změněno ve verzi 3.4: Přidán parametr pouze klíčového slova default.

Změněno ve verzi 3.8: key může být None.

next(iterator, /)¶
next(iterator, default, /): Získá další položku z iterátoru voláním jeho metody __next__(). Je-li zadána hodnota default, vrátí se při vyčerpání iterátoru; jinak se vyvolá StopIteration.

class object¶: Toto je konečná základní třída všech ostatních tříd. Obsahuje metody společné všem instancím tříd Pythonu. Konstruktor při zavolání vrátí nový objekt bez dalších vlastností. Nepřijímá žádné argumenty.

Poznámka

Instance object nemají atribut __dict__, takže instanci object nelze přiřazovat libovolné atributy.

oct(integer, /)¶

Převede celé číslo na osmičkový řetězec s předponou „0o“. Výsledkem je platný výraz Pythonu. Není-li integer objektem int Pythonu, musí definovat metodu __index__(), která vrací celé číslo. Například:

>>> oct(8)
'0o10'
>>> oct(-56)
'-0o70'

Chcete-li celé číslo převést na osmičkový řetězec s předponou „0o“ nebo bez ní, můžete použít některý z následujících způsobů.

>>> '%#o' % 10, '%o' % 10
('0o12', '12')
>>> format(10, '#o'), format(10, 'o')
('0o12', '12')
>>> f'{10:#o}', f'{10:o}'
('0o12', '12')

Další informace uvádí format().

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)¶

Otevře file a vrátí odpovídající souborový objekt. Nelze-li soubor otevřít, vyvolá se OSError. Další příklady použití této funkce uvádí Čtení a zápis souborů.

file je objekt podobný cestě udávající cestu (absolutní nebo relativní vůči aktuálnímu pracovnímu adresáři) k otevíranému souboru nebo celočíselný deskriptor souboru, který se má obalit. (Je-li zadán deskriptor souboru, při zavření vráceného I/O objektu se také zavře, pokud closefd není nastaveno na False.)

mode je volitelný řetězec určující režim otevření souboru. Výchozí hodnota 'r' znamená otevření pro čtení v textovém režimu. Další běžné hodnoty jsou 'w' pro zápis (existující soubor se nejprve zkrátí), 'x' pro výhradní vytvoření a 'a' pro připojování (na některých unixových systémech to znamená, že se všechny zápisy připojují na konec souboru bez ohledu na aktuální pozici). Není-li v textovém režimu zadáno encoding, použité kódování závisí na platformě: aktuální kódování národního prostředí se získá voláním locale.getencoding(). (Pro čtení a zápis nezpracovaných bajtů použijte binární režim a encoding nezadávejte.) Dostupné režimy jsou:

Znak	Význam
`'r'`	otevření pro čtení (výchozí)
`'w'`	otevření pro zápis s předchozím zkrácením souboru
`'x'`	otevření pro výhradní vytvoření; selže, pokud soubor již existuje
`'a'`	otevření pro zápis s připojováním na konec existujícího souboru
`'b'`	binární režim
`'t'`	textový režim (výchozí)
`'+'`	otevření pro aktualizaci (čtení i zápis)

Výchozí režim je 'r' (otevření pro čtení textu, synonymum 'rt'). Režimy 'w+' a 'w+b' soubor otevřou a zkrátí. Režimy 'r+' a 'r+b' jej otevřou bez zkrácení.

Jak uvádí Overview, Python rozlišuje binární a textový vstup a výstup. Soubory otevřené v binárním režimu (argument mode obsahuje 'b') vracejí obsah jako objekty bytes bez dekódování. V textovém režimu (výchozím, nebo když mode obsahuje 't') se obsah souboru vrací jako str; bajty se nejprve dekódují kódováním závislým na platformě nebo zadaným encoding.

Poznámka

Python není závislý na pojetí textových souborů v podkladovém operačním systému. Veškeré zpracování provádí sám Python, a je proto nezávislé na platformě.

buffering je volitelné celé číslo nastavující zásady bufferování. Hodnota 0 bufferování vypne (povoleno pouze v binárním režimu), 1 zvolí řádkové bufferování (použitelné pouze při zápisu v textovém režimu) a celé číslo > 1 udává velikost bufferu pevných bloků v bajtech. Takto zadaná velikost bufferu platí pro bufferovaný binární vstup a výstup, avšak TextIOWrapper (tedy soubory otevřené s mode='r+') používá další bufferování. Pro jeho vypnutí v TextIOWrapper zvažte příznak write_through metody io.TextIOWrapper.reconfigure(). Není-li argument buffering zadán, výchozí zásady fungují následovně:

Binární soubory se bufferují v blocích pevné velikosti; je-li dostupná velikost bloku zařízení, činí velikost bufferu max(min(blocksize, 8 MiB), DEFAULT_BUFFER_SIZE). Na většině systémů bude buffer obvykle velký 128 kilobajtů.
„Interaktivní“ textové soubory (soubory, pro něž isatty() vrací True) používají řádkové bufferování. Ostatní textové soubory používají výše popsané zásady pro binární soubory.

encoding je název kódování použitého k dekódování nebo zakódování souboru. Má se používat pouze v textovém režimu. Výchozí kódování závisí na platformě (vrací je locale.getencoding()), lze však použít libovolné textové kódování podporované Pythonem. Seznam podporovaných kódování uvádí modul codecs.

errors je volitelný řetězec určující způsob zpracování chyb kódování a dekódování; nelze jej použít v binárním režimu. K dispozici je řada standardních obslužných rutin chyb (uvedených v Error Handlers), platný je však také každý název obsluhy registrovaný pomocí codecs.register_error(). Mezi standardní názvy patří:

'strict' vyvolá při chybě kódování výjimku ValueError. Výchozí hodnota None má stejný účinek.
'ignore' chyby ignoruje. Ignorování chyb kódování může vést ke ztrátě dat.
'replace' vloží na místo chybných dat náhradní značku (například '?').
'surrogateescape' představuje chybné bajty nízkými náhradními jednotkami kódu v rozsahu U+DC80 až U+DCFF. Při použití obsluhy surrogateescape během zápisu se tyto jednotky převedou zpět na stejné bajty. To je užitečné při zpracování souborů v neznámém kódování.
'xmlcharrefreplace' je podporováno pouze při zápisu do souboru. Znaky, které kódování nepodporuje, se nahradí odpovídající znakovou referencí XML &#nnn;.
'backslashreplace' nahrazuje chybná data escape sekvencemi Pythonu se zpětným lomítkem.
'namereplace' (také podporováno pouze při zápisu) nahrazuje nepodporované znaky escape sekvencemi \N{...}.

newline určuje způsob zpracování znaků nového řádku z proudu. Může mít hodnotu None, '', '\n', '\r' nebo '\r\n'. Funguje následovně:

Je-li při čtení z proudu newline rovno None, zapne se režim univerzálních nových řádků. Vstupní řádky mohou končit '\n', '\r' nebo '\r\n' a před vrácením volajícímu se převedou na '\n'. Je-li hodnota '', režim univerzálních nových řádků je zapnutý, ale zakončení řádků se vracejí bez převodu. U ostatních platných hodnot ukončuje vstupní řádek pouze zadaný řetězec a zakončení se vrací bez převodu.
Je-li při zápisu do proudu newline rovno None, všechny zapisované znaky '\n' se převedou na výchozí systémový oddělovač řádků os.linesep. Je-li newline rovno '' nebo '\n', žádný převod neprobíhá. U ostatních platných hodnot se zapisované znaky '\n' převedou na zadaný řetězec.

Je-li closefd rovno False a byl zadán deskriptor souboru namísto názvu, zůstane podkladový deskriptor při zavření souboru otevřený. Je-li zadán název souboru, musí být closefd rovno True (výchozí hodnota), jinak se vyvolá chyba.

Vlastní otevírací funkci lze použít předáním volatelného objektu jako opener. Podkladový deskriptor souborového objektu se pak získá voláním opener s argumenty (file, flags). opener musí vrátit otevřený deskriptor souboru (předání os.open jako opener poskytuje podobnou funkčnost jako předání None).

Nově vytvořený soubor je neděditelný.

Následující příklad používá parametr dir_fd funkce os.open() k otevření souboru relativně vůči danému adresáři:

>>> import os
>>> dir_fd = os.open('somedir', os.O_RDONLY)
>>> def opener(path, flags):
...     return os.open(path, flags, dir_fd=dir_fd)
...
>>> with open('spamspam.txt', 'w', opener=opener) as f:
...     print('This will be written to somedir/spamspam.txt', file=f)
...
>>> os.close(dir_fd)  # don't leak a file descriptor

Typ souborového objektu vráceného funkcí open() závisí na režimu. Při otevření souboru v textovém režimu ('w', 'r', 'wt', 'rt' atd.) vrací open() podtřídu io.TextIOBase (konkrétně io.TextIOWrapper). Při otevření v bufferovaném binárním režimu je vrácená třída podtřídou io.BufferedIOBase. Konkrétní třída se liší: v binárním režimu čtení se vrací io.BufferedReader, v binárním režimu zápisu a připojování io.BufferedWriter a v režimu čtení i zápisu io.BufferedRandom. Je-li bufferování vypnuto, vrací se nezpracovaný proud, podtřída io.RawIOBase, konkrétně io.FileIO.

Viz také moduly pro práci se soubory, například fileinput, io (kde je deklarována open()), os, os.path, tempfile a shutil.

Auditní událost

Vyvolá auditní událost open s argumenty path,mode,flags.

Argumenty mode a flags mohou být oproti původnímu volání změněné nebo odvozené.

Změněno ve verzi 3.3:

Přidán parametr opener.
Přidán režim 'x'.
Dříve vyvolávaná IOError je nyní aliasem OSError.
Pokud soubor otevíraný v režimu výhradního vytvoření ('x') již existuje, vyvolá se nyní FileExistsError.

Změněno ve verzi 3.4:

Soubor je nyní neděditelný.

Změněno ve verzi 3.5:

Pokud je systémové volání přerušeno a obsluha signálu nevyvolá výjimku, funkce nyní systémové volání zopakuje namísto vyvolání výjimky InterruptedError (zdůvodnění viz PEP 475).
Přidána obsluha chyb 'namereplace'.

Změněno ve verzi 3.6:

Přidána podpora objektů implementujících os.PathLike.
V systému Windows může otevření bufferu konzole vrátit jinou podtřídu io.RawIOBase než io.FileIO.

Změněno ve verzi 3.11: Režim 'U' byl odstraněn.

ord(character, /)¶

Vrátí pořadovou hodnotu znaku.

Je-li argument řetězec o jednom znaku, vrátí bod kódu Unicode tohoto znaku. Například ord('a') vrátí celé číslo 97 a ord('€') (znak eura) vrátí 8364. Jde o inverzní funkci k chr().

Je-li argument objekt bytes nebo bytearray délky 1, vrátí hodnotu jeho jediného bajtu. Například ord(b'a') vrátí celé číslo 97.

pow(base, exp, mod=None)¶

Vrátí base umocněné na exp; je-li přítomno mod, vrátí base umocněné na exp modulo mod (vypočítané efektivněji než pow(base, exp) % mod). Dvouargumentová podoba pow(base, exp) odpovídá použití operátoru mocnění: base**exp.

Jsou-li argumenty vestavěné číselné typy se smíšenými typy operandů, použijí se pravidla převodu pro binární aritmetické operátory. U operandů int má výsledek stejný typ jako operandy (po převodu), není-li druhý argument záporný; v takovém případě se všechny argumenty převedou na float a vrátí se výsledek typu float. Například pow(10, 2) vrátí 100, ale pow(10, -2) vrátí 0.01. U záporného základu typu int nebo float a neceločíselného exponentu se vrátí komplexní výsledek. Například pow(-9, 0.5) vrátí hodnotu blízkou 3j. Naproti tomu u záporného základu typu int nebo float s celočíselným exponentem se vrátí výsledek typu float. Například pow(-9, 2.0) vrátí 81.0.

Jsou-li operandy base a exp typu int a je přítomno mod, musí mít mod rovněž celočíselný typ a být nenulové. Je-li mod přítomno a exp je záporné, musí být base a mod nesoudělné. V takovém případě se vrátí pow(inv_base, -exp, mod), kde inv_base je inverze base modulo mod.

Příklad výpočtu inverze čísla 38 modulo 97:

>>> pow(38, -1, mod=97)
23
>>> 23 * 38 % 97 == 1
True

Změněno ve verzi 3.8: U operandů int nyní tříargumentová podoba pow dovoluje záporný druhý argument, což umožňuje výpočet modulárních inverzí.

Změněno ve verzi 3.8: Povoleny argumenty klíčových slov. Dříve byly podporovány pouze poziční argumenty.

print(*objects, sep=' ', end='\n', file=None, flush=False)¶

Vypíše objects do textového proudu file, oddělené hodnotou sep a následované hodnotou end. Jsou-li sep, end, file a flush uvedeny, musí být zadány jako argumenty klíčových slov.

Všechny argumenty, které nejsou klíčovými slovy, se převedou na řetězce jako pomocí str() a zapíší do proudu oddělené hodnotou sep a následované end. sep i end musí být řetězce; mohou být také None, což znamená použití výchozích hodnot. Nejsou-li zadány žádné objects, print() zapíše pouze end.

Argument file musí být objekt s metodou write(string); není-li uveden nebo je-li roven None, použije se sys.stdout. Protože se vypisované argumenty převádějí na textové řetězce, nelze print() použít se souborovými objekty v binárním režimu. Pro ně použijte file.write(...).

Bufferování výstupu obvykle určuje file. Je-li však flush pravdivé, vynutí se vyprázdnění proudu.

Změněno ve verzi 3.3: Přidán argument klíčového slova flush.

class property(fget=None, fset=None, fdel=None, doc=None)¶

Vrátí atribut vlastnosti.

fget je funkce pro získání hodnoty atributu. fset je funkce pro nastavení hodnoty atributu. fdel je funkce pro odstranění hodnoty atributu. doc vytváří dokumentační řetězec atributu.

Typickým použitím je definice spravovaného atributu x:

class C:
    def __init__(self):
        self._x = None

    def getx(self):
        return self._x

    def setx(self, value):
        self._x = value

    def delx(self):
        del self._x

    x = property(getx, setx, delx, "I'm the 'x' property.")

Je-li c instancí C, c.x zavolá getter, c.x = value zavolá setter a del c.x deleter.

Je-li zadáno doc, stane se dokumentačním řetězcem atributu vlastnosti. Jinak vlastnost zkopíruje dokumentační řetězec fget (pokud existuje). Díky tomu lze snadno vytvářet vlastnosti pouze pro čtení použitím property() jako dekorátoru:

class Parrot:
    def __init__(self):
        self._voltage = 100000

    @property
    def voltage(self):
        """Get the current voltage."""
        return self._voltage

Dekorátor @property změní metodu voltage() na „getter“ atributu stejného názvu určeného pouze pro čtení a nastaví dokumentační řetězec voltage na „Get the current voltage.“

@getter¶

@setter¶

@deleter¶

Objekt vlastnosti má metody getter, setter a deleter, které lze použít jako dekorátory. Vytvoří kopii vlastnosti a nastaví odpovídající přístupovou funkci na dekorovanou funkci. Nejlépe to ukáže příklad:

class C:
    def __init__(self):
        self._x = None

    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @x.deleter
    def x(self):
        del self._x

Tento kód je přesně ekvivalentní prvnímu příkladu. Doplňkovým funkcím je nutné dát stejný název jako původní vlastnosti (v tomto případě x).

Vrácený objekt vlastnosti má také atributy fget, fset a fdel odpovídající argumentům konstruktoru.

Změněno ve verzi 3.5: Dokumentační řetězce objektů vlastností jsou nyní zapisovatelné.

__name__¶: Atribut uchovávající název vlastnosti. Název vlastnosti lze změnit za běhu.

Added in version 3.13.

class range(stop, /)
class range(start, stop, step=1, /): range ve skutečnosti není funkce, ale typ neměnné sekvence, jak popisují oddíly Ranges a Sequence Types — list, tuple, range.

repr(object, /)¶

Vrátí řetězec obsahující tisknutelnou reprezentaci objektu. U mnoha typů se funkce pokouší vrátit řetězec, který po předání funkci eval() vytvoří objekt se stejnou hodnotou. Jinak je reprezentací řetězec uzavřený v ostrých závorkách, který obsahuje název typu objektu a další informace, často včetně názvu a adresy objektu. Třída může návratovou hodnotu této funkce pro své instance řídit definicí metody __repr__(). Není-li dostupná sys.displayhook(), vyvolá tato funkce RuntimeError.

Tato třída má vlastní reprezentaci, kterou lze vyhodnotit:

class Person:
   def __init__(self, name, age):
      self.name = name
      self.age = age

   def __repr__(self):
      return f"Person('{self.name}', {self.age})"

reversed(object, /)¶: Vrátí obrácený iterátor. Argument musí být objekt s metodou __reversed__() nebo musí podporovat protokol sekvence (metodu __len__() a metodu __getitem__() s celočíselnými argumenty začínajícími hodnotou 0).

round(number, ndigits=None)¶

Vrátí number zaokrouhlené na přesnost ndigits číslic za desetinnou tečkou. Je-li ndigits vynecháno nebo rovno None, vrátí celé číslo nejbližší vstupu.

U vestavěných typů podporujících round() se hodnoty zaokrouhlují na nejbližší násobek 10 na minus ndigits. Jsou-li dva násobky stejně blízké, zaokrouhlí se k sudé možnosti (například round(0.5) i round(-0.5) jsou 0 a round(1.5) je 2). Pro ndigits je platné libovolné celé číslo (kladné, nulové i záporné). Je-li ndigits vynecháno nebo rovno None, návratovou hodnotou je celé číslo. Jinak má návratová hodnota stejný typ jako number.

U obecného objektu Pythonu number deleguje round na number.__round__.

Poznámka

Chování round() pro čísla float může být překvapivé: například round(2.675, 2) poskytne 2.67 namísto očekávaných 2.68. Nejde o chybu, ale o důsledek skutečnosti, že většinu desetinných zlomků nelze jako float vyjádřit přesně. Další informace uvádí Aritmetika s plovoucí řádovou čárkou: problémy a omezení.

class set(iterable=(), /)

Vrátí nový objekt set, volitelně s prvky převzatými z iterable. set je vestavěná třída. Dokumentaci této třídy uvádějí set a Set Types — set, frozenset.

Další kontejnery popisují vestavěné třídy frozenset, list, tuple a dict i modul collections.

setattr(object, name, value, /)¶

Jde o protějšek funkce getattr(). Argumenty jsou objekt, řetězec a libovolná hodnota. Řetězec může pojmenovávat existující nebo nový atribut. Pokud to objekt dovoluje, funkce přiřadí atributu hodnotu. Například setattr(x, 'foobar', 123) je ekvivalentní výrazu x.foobar = 123.

name nemusí být identifikátor Pythonu podle Names (identifiers and keywords), pokud si objekt toto omezení sám nevynutí, například ve vlastní metodě __getattribute__() nebo pomocí __slots__. Atribut, jehož název není identifikátor, nebude přístupný tečkovou notací, lze k němu však přistoupit například prostřednictvím getattr().

Poznámka

Protože k komolení soukromých názvů dochází při kompilaci, je nutné název soukromého atributu (atributu se dvěma počátečními podtržítky) pro nastavení pomocí setattr() zkomolit ručně.

class slice(stop, /)¶

class slice(start, stop, step=None, /)

Vrátí objekt výřezu představující množinu indexů určenou výrazem range(start, stop, step). Výchozí hodnotou argumentů start a step je None.

Objekty výřezu vznikají také při použití syntaxe výřezů. Například: a[start:stop:step] nebo a[start:stop, i].

Alternativní variantu poskytuje itertools.islice(); vrací iterátor.

start¶
stop¶
step¶: Tyto atributy pouze pro čtení jsou nastaveny na hodnoty argumentů (nebo jejich výchozí hodnoty). Nemají žádnou další výslovnou funkci, používá je však NumPy a další balíčky třetích stran.

Změněno ve verzi 3.12: Objekty výřezu jsou nyní hashovatelné (pokud jsou hashovatelné start, stop a step).

sorted(iterable, /, *, key=None, reverse=False)¶

Vrátí nový seřazený seznam z položek objektu iterable.

Má dva volitelné argumenty, které musí být zadány jako argumenty klíčových slov.

key určuje funkci jednoho argumentu, která z každého prvku objektu iterable získá porovnávací klíč (například key=str.lower). Výchozí hodnota je None (prvky se porovnávají přímo).

reverse je booleovská hodnota. Je-li nastavena na True, prvky seznamu se seřadí, jako kdyby každé porovnání proběhlo obráceně.

Pro převod funkce cmp starého stylu na funkci key použijte functools.cmp_to_key().

Vestavěná funkce sorted() je zaručeně stabilní. Řazení je stabilní, pokud nemění vzájemné pořadí prvků, které se porovnají jako shodné. To je užitečné při víceprůchodovém řazení (například nejprve podle oddělení a poté podle platové třídy).

Algoritmus řazení používá mezi položkami pouze porovnání <. Přestože pro řazení stačí definovat metodu __lt__(), PEP 8 doporučuje implementovat všech šest rozšířených porovnání. Pomůže to předejít chybám při použití stejných dat s jinými nástroji pro řazení, například max(), které spoléhají na jinou podkladovou metodu. Implementace všech šesti porovnání také omezuje nejasnosti při porovnávání smíšených typů, jež může zavolat odraženou metodu __gt__().

Příklady a stručný návod k řazení uvádí Sorting Techniques.

@staticmethod¶

Převede metodu na statickou metodu.

Statická metoda nedostává implicitní první argument. Pro její deklaraci použijte následující idiom:

class C:
    @staticmethod
    def f(arg1, arg2, argN): ...

Podoba @staticmethod je dekorátor funkce; podrobnosti uvádí Function definitions.

Statickou metodu lze volat na třídě (například C.f()) i na instanci (například C().f()). Také deskriptor statické metody je volatelný, takže jej lze použít v definici třídy (například f()).

Statické metody v Pythonu se podobají metodám v Javě nebo C++. Variantou užitečnou pro tvorbu alternativních konstruktorů tříd je classmethod().

Stejně jako všechny dekorátory lze také staticmethod zavolat jako běžnou funkci a dále pracovat s jejím výsledkem. To je potřeba v případech, kdy potřebujete z těla třídy referenci na funkci a chcete zabránit automatickému převodu na metodu instance. Tehdy použijte tento idiom:

def regular_function():
    ...

class C:
    method = staticmethod(regular_function)

Další informace o statických metodách uvádí The standard type hierarchy.

Změněno ve verzi 3.10: Statické metody nyní přebírají atributy metody (__module__, __name__, __qualname__, __doc__ a __annotations__), mají nový atribut __wrapped__ a lze je volat jako běžné funkce.

class str(*, encoding='utf-8', errors='strict')

class str(object)

class str(object, encoding, errors='strict')

class str(object, *, errors)

Vrátí verzi objektu object typu str. Podrobnosti uvádí str().

str je vestavěná řetězcová třída. Obecné informace o řetězcích uvádí Text Sequence Type — str.

sum(iterable, /, start=0)¶

Sečte zleva doprava hodnotu start a položky objektu iterable a vrátí součet. Položky iterable jsou obvykle čísla a počáteční hodnota nesmí být řetězec.

Pro některé případy použití existují vhodné alternativy k sum(). Upřednostňovaným rychlým způsobem spojení sekvence řetězců je volání ''.join(sequence). Pro sčítání hodnot s plovoucí řádovou čárkou s rozšířenou přesností viz math.fsum(). Pro spojení řady iterovatelných objektů zvažte itertools.chain().

Změněno ve verzi 3.8: Parametr start lze zadat jako argument klíčového slova.

Změněno ve verzi 3.12: Sčítání hodnot float přešlo na algoritmus, který na většině sestavení poskytuje vyšší přesnost a lepší komutativitu.

Změněno ve verzi 3.14: Přidána specializace pro sčítání komplexních čísel používající stejný algoritmus jako sčítání hodnot float.

class super¶

class super(type, object_or_type=None, /)

Vrátí proxy objekt, který deleguje volání metod na rodičovskou nebo sourozeneckou třídu typu type. To je užitečné pro přístup ke zděděným metodám, které byly ve třídě překryty.

object_or_type určuje prohledávané pořadí rozlišení metod. Hledání začíná třídou bezprostředně následující za type.

Je-li například __mro__ objektu object_or_type D -> B -> C -> A -> object a hodnota type je B, prohledává super() pořadí C -> A -> object.

Atribut __mro__ třídy odpovídající object_or_type obsahuje pořadí hledání metod používané funkcemi getattr() i super(). Atribut je dynamický a může se změnit při každé aktualizaci hierarchie dědičnosti.

Je-li druhý argument vynechán, vrácený objekt super je nevázaný. Je-li druhý argument objekt, musí být isinstance(obj, type) pravdivé. Je-li druhý argument typ, musí být pravdivé issubclass(type2, type) (to je užitečné pro metody tříd).

Při přímém volání uvnitř běžné metody třídy lze oba argumenty vynechat („bezargumentové super()“). type pak bude obklopující třída a obj první argument bezprostředně obklopující funkce (obvykle self). To znamená, že bezargumentové super() nebude fungovat očekávaným způsobem uvnitř vnořených funkcí, včetně generátorových výrazů, které vnořené funkce vytvářejí implicitně.

super má dvě typická použití. V hierarchii tříd s jednoduchou dědičností lze pomocí super odkazovat na rodičovské třídy bez jejich výslovného pojmenování, což usnadňuje údržbu kódu. Toto použití se blíží použití super v jiných programovacích jazycích.

Druhým použitím je podpora kooperativní vícenásobné dědičnosti v dynamickém běhovém prostředí. Toto použití je specifické pro Python a nevyskytuje se ve staticky kompilovaných jazycích ani v jazycích podporujících pouze jednoduchou dědičnost. Umožňuje implementovat „diamantové diagramy“, v nichž stejnou metodu implementuje více základních tříd. Správný návrh vyžaduje, aby takové implementace měly vždy stejnou signaturu volání (protože pořadí volání se určuje za běhu, přizpůsobuje se změnám hierarchie tříd a může zahrnovat sourozenecké třídy, které před spuštěním nejsou známé).

V obou případech vypadá typické volání nadtřídy takto:

class C(B):
    def method(self, arg):
        super().method(arg)    # This does the same thing as:
                               # super(C, self).method(arg)

super() funguje kromě vyhledávání metod také pro vyhledávání atributů. Jedním z možných použití je volání deskriptorů v rodičovské nebo sourozenecké třídě.

super() je implementována jako součást procesu vazby pro výslovné vyhledávání atributů tečkovou notací, například super().__getitem__(name). Implementuje vlastní metodu __getattribute__(), která prohledává třídy v předvídatelném pořadí podporujícím kooperativní vícenásobnou dědičnost. Proto není super() definována pro implicitní vyhledávání pomocí příkazů nebo operátorů, například super()[name].

Kromě bezargumentové podoby také není super() omezena na použití uvnitř metod. Dvouargumentová podoba určuje argumenty přesně a vytvoří odpovídající reference. Bezargumentová podoba funguje pouze uvnitř definice třídy, protože překladač doplní údaje potřebné ke správnému získání právě definované třídy a u běžných metod také k přístupu k aktuální instanci.

Praktická doporučení k návrhu kooperativních tříd pomocí super() uvádí průvodce použitím super().

Změněno ve verzi 3.14: Objekty super lze nyní serializovat modulem pickle a kopírovat.

class tuple(iterable=(), /): tuple ve skutečnosti není funkce, ale typ neměnné sekvence, jak popisují oddíly Tuples a Sequence Types — list, tuple, range.

class type(object, /)¶

class type(name, bases, dict, /, **kwargs)

S jedním argumentem vrátí typ objektu object. Návratovou hodnotou je objekt typu, obvykle stejný jako objekt vrácený atributem object.__class__.

Pro testování typu objektu se doporučuje vestavěná funkce isinstance(), protože bere v úvahu podtřídy.

Se třemi argumenty vrátí nový objekt typu. Jde v podstatě o dynamickou podobu příkazu class. Řetězec name je názvem třídy a stane se atributem __name__. N-tice bases obsahuje základní třídy a stane se atributem __bases__; je-li prázdná, přidá se object, konečný základ všech tříd. Slovník dict obsahuje definice atributů a metod pro tělo třídy; předtím, než se stane atributem __dict__, může být zkopírován nebo obalen. Následující dva příkazy vytvoří shodné objekty type:

>>> class X:
...     a = 1
...
>>> X = type('X', (), dict(a=1))

Viz také:

Argumenty klíčových slov předané tříargumentové podobě se předají odpovídajícímu mechanismu metatřídy (obvykle __init_subclass__()) stejně jako klíčová slova v definici třídy (kromě metaclass).

Viz také Customizing class creation.

Změněno ve verzi 3.6: Podtřídy type, které nepřekrývají type.__new__, již nemohou používat jednoargumentovou podobu k získání typu objektu.

vars()¶

vars(object, /)

Vrátí atribut __dict__ modulu, třídy, instance nebo jiného objektu s atributem __dict__.

Objekty jako moduly a instance mají měnitelný atribut __dict__; jiné objekty však mohou zápis do atributu __dict__ omezovat (například třídy používají types.MappingProxyType, aby zabránily přímým změnám slovníku).

Bez argumentu se vars() chová jako locals().

Výjimka TypeError se vyvolá, je-li zadán objekt, který nemá atribut __dict__ (například pokud jeho třída definuje atribut __slots__).

Změněno ve verzi 3.13: Výsledek volání této funkce bez argumentu byl upraven podle popisu vestavěné funkce locals().

zip(*iterables, strict=False)¶

Prochází souběžně několik iterovatelných objektů a vytváří n-tice s jednou položkou z každého z nich.

Příklad:

>>> for item in zip([1, 2, 3], ['sugar', 'spice', 'everything nice']):
...     print(item)
...
(1, 'sugar')
(2, 'spice')
(3, 'everything nice')

Formálněji: zip() vrací iterátor n-tic, kde i-tá n-tice obsahuje i-tý prvek z každého iterovatelného argumentu.

Jiný pohled na zip() je, že mění řádky na sloupce a sloupce na řádky. Podobá se to transpozici matice.

zip() je líná: prvky se nezpracují, dokud se přes iterovatelný objekt nezačne iterovat, například cyklem for nebo obalením do list.

Je třeba vzít v úvahu, že iterovatelné objekty předané funkci zip() mohou mít různou délku, někdy záměrně a někdy kvůli chybě v kódu, který je připravil. Python nabízí tři způsoby řešení:

Ve výchozím nastavení se zip() zastaví po vyčerpání nejkratšího iterovatelného objektu. Zbývající položky delších objektů ignoruje a zkrátí výsledek na délku nejkratšího:
```
>>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum']))
[(0, 'fee'), (1, 'fi'), (2, 'fo')]
```
zip() se často používá tam, kde se předpokládá stejná délka iterovatelných objektů. V takovém případě se doporučuje volba strict=True. Její výstup je stejný jako u běžné zip():
```
>>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True))
[('a', 1), ('b', 2), ('c', 3)]
```
Na rozdíl od výchozího chování vyvolá ValueError, pokud se jeden iterovatelný objekt vyčerpá dříve než ostatní:
```
>>> for item in zip(range(3), ['fee', 'fi', 'fo', 'fum'], strict=True):
...     print(item)
...
(0, 'fee')
(1, 'fi')
(2, 'fo')
Traceback (most recent call last):
  ...
ValueError: zip() argument 2 is longer than argument 1
```
Bez argumentu strict=True se každá chyba vedoucí k různým délkám iterovatelných objektů potlačí a může se projevit jako obtížně odhalitelná chyba v jiné části programu.
Kratší iterovatelné objekty lze doplnit konstantní hodnotou, aby měly všechny stejnou délku. Provádí to itertools.zip_longest().

Mezní případy: S jediným iterovatelným argumentem vrací zip() iterátor jednoprvkových n-tic. Bez argumentů vrací prázdný iterátor.

Tipy a triky:

Je zaručeno vyhodnocování iterovatelných objektů zleva doprava. To umožňuje idiom pro seskupení datové řady do skupin délky n pomocí zip(*[iter(s)]*n, strict=True). Tentýž iterátor se zopakuje n-krát, takže každá výstupní n-tice obsahuje výsledky n volání iterátoru. Vstup se tím rozdělí na bloky délky n.

zip() lze spolu s operátorem * použít k rozbalení seznamu:

>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> list(zip(x, y))
[(1, 4), (2, 5), (3, 6)]
>>> x2, y2 = zip(*zip(x, y))
>>> x == list(x2) and y == list(y2)
True

Změněno ve verzi 3.10: Přidán argument strict.

__import__(name, globals=None, locals=None, fromlist=(), level=0)¶

Poznámka

Jde o pokročilou funkci, která na rozdíl od importlib.import_module() není při běžném programování v Pythonu potřeba.

Tuto funkci volá příkaz import. Lze ji nahradit (importováním modulu builtins a přiřazením do builtins.__import__), a změnit tak sémantiku příkazu import. Tento postup se však důrazně nedoporučuje, protože stejných cílů lze obvykle snáze dosáhnout importními háčky (viz PEP 302), aniž by vznikly problémy s kódem předpokládajícím výchozí implementaci importu. Také přímé použití __import__() se nedoporučuje; přednost má importlib.import_module().

Funkce importuje modul name a případně pomocí zadaných globals a locals určí, jak název interpretovat v kontextu balíčku. fromlist udává názvy objektů nebo podmodulů, které se mají importovat z modulu určeného parametrem name. Standardní implementace argument locals vůbec nepoužívá a globals používá pouze k určení kontextu balíčku příkazu import.

level určuje použití absolutních nebo relativních importů. 0 (výchozí hodnota) znamená provádět pouze absolutní importy. Kladné hodnoty level udávají počet rodičovských adresářů, které se mají prohledat relativně vůči adresáři modulu volajícího __import__() (podrobnosti viz PEP 328).

Má-li proměnná name podobu package.module, obvykle se vrátí balíček nejvyšší úrovně (název po první tečku), a nikoli modul pojmenovaný name. Je-li však zadán neprázdný argument fromlist, vrátí se modul pojmenovaný name.

Například příkaz import spam vytvoří bajtkód podobný následujícímu kódu:

spam = __import__('spam', globals(), locals(), [], 0)

Příkaz import spam.ham vede k tomuto volání:

spam = __import__('spam.ham', globals(), locals(), [], 0)

Všimněte si, že __import__() zde vrací modul nejvyšší úrovně, protože právě tento objekt příkaz import naváže na název.

Naproti tomu příkaz from spam.ham import eggs, sausage as saus vede k:

_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)
eggs = _temp.eggs
saus = _temp.sausage

Z __import__() se zde vrátí modul spam.ham. Z tohoto objektu se získají importované názvy a přiřadí se příslušným názvům.

Chcete-li jednoduše importovat modul (případně uvnitř balíčku) podle názvu, použijte importlib.import_module().

Změněno ve verzi 3.3: Záporné hodnoty level již nejsou podporovány (výchozí hodnota se tím také mění na 0).

Změněno ve verzi 3.9: Při použití voleb příkazového řádku -E nebo -I se nyní ignoruje proměnná prostředí PYTHONCASEOK.

Poznámky pod čarou

Vestavěné funkce¶

Tutorial Pythonu

Navigace

Related Topics