Wbudowane funkcje
*****************

Interpreter Pythona ma wbudowane wiele funkcji i typów, które zawsze
są dostępne. Spisane są tutaj w kolejności alfabetycznej.

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

abs(number, /)

   Zwraca wartość bezwzględną liczby. Argument może być liczbą
   całkowitą, zmiennoprzecinkową lub obiektem implementującym
   "__abs__()". Jeśli argument jest liczbą zespoloną, zwracany jest
   jej moduł.

aiter(async_iterable, /)

   Zwraca *asynchroniczny iterator* dla *asynchronicznego iterable'a*.
   Ekwiwalent wywołania "x.__aiter__()".

   Uwaga: W przeciwieństwie do "iter()", "aiter()" nie ma
   dwuargumentowego wariantu.

    Dodane w wersji 3.10.

all(iterable, /)

   Zwraca "True" jeśli wszystkie elementy *iterable*'a są prawdziwe
   (lub jeśli iterable jest pusty). Ekwiwalent kodu:

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

awaitable anext(async_iterator, /)
awaitable anext(async_iterator, default, /)

   W przypadku oczekiwania zwraca następny element z podanego
   *asynchronicznego iteratora* lub wartość *default*, jeżeli jest ona
   podana, a iterator został wyczerpany.

   Jest to asynchroniczny wariant wbudowanej funkcji "next()" i
   zachowuje się podobnie.

   Wywołuje on metodę "__anext__()" *async_iteratora*, zwracając
   *awaitable*. Oczekiwanie zwraca następną wartość iteratora. Jeśli
   podano wartość *default*, jest ona zwracana, jeśli iterator
   zostanie wyczerpany, w przeciwnym razie zostanie podniesiony
   wyjątek "StopAsyncIteration".

    Dodane w wersji 3.10.

any(iterable, /)

   Zwraca "True" jeśli jakikolwiek element *iterable*'a jest
   prawdziwy. Jeśli iterable jest pusty, zwraca "False". Ekwiwalent
   kodu:

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

ascii(object, /)

   Tak jak "repr()", zwraca ciąg znaków zawierający reprezentację
   obiektu, ale wypisuje znaki nie-ASCII w zwracanym przez "repr()"
   ciągu przy użyciu escape'ów "\x", "\u" lub "\U". Generuje ciąg
   znaków podobny do tego zwracanego przez "repr()" w Pythonie 2.

bin(integer, /)

   Konwertuje liczbę całkowitą do binarnego ciągu znaków z prefiksem
   „0b”. Wynik jest poprawnym wyrażeniem Pythona. Jeśli *integer* nie
   jest pythonowym obiektem "int", musi definiować metodę
   "__index__()", która zwraca liczbę całkowitą. Kilka przykładów:

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

   Jeśli prefiks „0b” nie jest pożądany, możesz użyć któregoś z
   poniższych sposobów.

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

   Zobacz też "format()" by uzyskać więcej informacji.

class bool(object=False, /)

   Zwraca wartość logiczną, tj. jedno z "True" lub "False". Wartość
   argumentu jest konwertowana przy użyciu standardowej procedury
   testowania truth testing procedure. Jeśli argument jest fałszywy
   lub pominięty, zwraca "False"; w przeciwnym razie, zwraca "True".
   Klasa "bool" jest podklasą klasy "int" (zobacz Numeric Types ---
   int, float, complex). Nie może być dalej podklasowana. Jej jedynymi
   instancjami są "False" i "True" (zobacz Boolean Type - bool).

   Zmienione w wersji 3.7: Parametr jest teraz tylko-pozycyjny.

breakpoint(*args, **kws)

   Ta funkcja powoduje przejście do debuggera w miejscu wywołania.  W
   szczególności wywołuje "sys.breakpointhook()", przekazując do niego
   bezpośrednio "args" i "kws". Domyślnie "sys.breakpointhook()"
   wywołuje funkcję "pdb.set_trace()" nie oczekującą argumentu. W tym
   przypadku jest to wyłącznie funkcja dla wygody, aby nie trzeba było
   jawnie importować "pdb" ani wpisywać tak dużo kodu, aby wejść do
   debuggera. Jednakże "sys.breakpointhook()" może być ustawiony na
   inną funkcję i "breakpoint()" automatycznie wywoła ją, pozwalając
   na przejście do wybranego debuggera. Jeśli "sys.breakpointhook()"
   nie jest dostępny, funkcja rzuci "RuntimeError".

   Domyślnie zachowanie funkcji "breakpoint()" można zmienić za pomocą
   zmiennej środowiskowej "PYTHONBREAKPOINT". Szczegółowe informacje
   można znaleźć w "sys.breakpointhook()".

   Należy pamiętać, że nie jest to gwarantowane, jeśli
   "sys.breakpointhook()" został wymieniony.

   Rzuca auditing event "builtins.breakpoint" z argumentem
   "breakpointhook".

    Dodane w wersji 3.7.

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

   Zwraca nową tablicę bajtów. Klasa "bytearray" jest mutowalną
   sekwencją liczb całkowitych w zakresie 0 <= x < 256. Ma większość
   metod mutowalnych sekwencji, opisanych w Mutable Sequence Types,
   jak również większość metod, które ma typ "bytes", patrz Bytes and
   Bytearray Operations.

   Opcjonalny parametr *source* może być użyty do inicjalizacji
   tablicy na kilka różnych sposobów:

   * Jeśli jest *stringiem*, musisz podać również parametr *encoding*
     (i opcjonalnie *errors*); "bytearray()" konwertuje string na
     bajty używając "str.encode()".

   * Jeśli jest *liczbą całkowitą*, tablica będzie miała taki rozmiar
     i będzie zainicjowana bajtami zerowymi.

   * Jeśli jest to obiekt spełniający interfejs bufora, bufor tylko-
     do-odczytu obiektu zostanie użyty do zainicjowania tablicy
     bajtów.

   * Jeśli jest *iterablem*, musi być iterablem składającym się z
     liczb całkowitych w zakresie "0 <= x < 256", które są użyte do
     zainicjowania tablicy.

   Bez argumentu tworzona jest tablica o rozmiarze 0.

   Zobacz też Binary Sequence Types --- bytes, bytearray, memoryview i
   Bytearray Objects.

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

   Zwraca nowy obiekt „bajtów”, który jest niemutowalną sekwencją
   liczb całkowitych z zakresu "0 <= x < 256". "bytes" jest
   niemutowalną wersją "bytearray" -- ma te same niemutujące metody i
   to samo zachowanie indeksowania i slice'owania.

   Argumenty konstruktora są interpretowane tak jak dla "bytearray()".

   Obiekty bytes mogą być również tworzone z literałami, patrz String
   and Bytes literals.

   Zobacz też Binary Sequence Types --- bytes, bytearray, memoryview,
   Bytes Objects i Bytes and Bytearray Operations.

callable(object, /)

   Zwraca "True" jeśli argument *object* jest wywoływalny, "False"
   jeśli nie. Jeśli zwraca "True", nadal możliwe jest, że wywołanie
   nie powiedzie się, ale jeśli zwraca "False", wywołanie *object*
   nigdy się nie powiedzie. Należy pamiętać, że klasy są wywoływalne
   (wywołanie klasy zwraca nową instancję); instancje są wywoływalne,
   jeśli ich klasa ma metodę "__call__()".

    Dodane w wersji 3.2: Ta funkcja była wpierw usunięta w Pythonie
   3.0 a następnie przywrócona w Pythonie 3.2.

chr(codepoint, /)

   Zwraca ciąg znaków reprezentujący znak dla podanego punktu kodowego
   Unicode. Na przykład "chr(97)" zwraca ciąg znaków "'a'", a
   "chr(8364)" zwraca ciąg "'€'". Jest odwrotnością "ord()".

   Poprawnym zakresem argumentu są wartości od 0 do 1 114 111
   (0x10FFFF w systemie szesnastkowym). Dla wartości poza tym zakresem
   zostanie rzucony "ValueError".

@classmethod

   Przekształca metodę w metodę klasową.

   Metoda klasowa otrzymuje klasę jako niejawny pierwszy argument,
   podobnie jak metoda instancji otrzymuje instancję. Aby zadeklarować
   metodę klasową, użyj tego idiomu:

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

   Forma "@classmethod" jest *dekoratorem* funkcji – szczegóły
   znajdziesz w Function definitions.

   Metoda klasowa może być wywoływana albo na klasie (na przykład
   "C.f()") albo na instancji (na przykład "C().f()"). Instancja jest
   ignorowana, brana jest pod uwagę tylko jej klasa. Jeśli metoda
   klasowa jest wywołana dla klasy dziedziczącej, obiekt klasy
   dziedziczącej jest przekazywany jako pierwszy argument.

   Metody klasowe różnią się od statycznych metod C++ lub Javy. Jeśli
   chcesz takie, sprawdź "staticmethod()" w tej sekcji. Więcej
   informacji o metodach klasowych znajdziesz w The standard type
   hierarchy.

   Zmienione w wersji 3.9: Metody klasowe mogą teraz opakowywać inne
   *deskryptory*, takie jak "property()".

   Zmienione w wersji 3.10: Metody klasowe dziedziczą teraz atrybuty
   metod ("__module__", "__name__", "__qualname__", "__doc__" i
   "__annotations__") i mają nowy atrybut "__wrapped__".

   Zdezaprobowane w wersji 3.11, usunięte w wersji 3.13: Metody klas
   nie mogą już opakowywać innych *deskryptorów* takich jak
   "property()".

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

   Kompiluje *source* do obiektu kodu lub obiektu AST. Obiekty kodu
   mogą wyć wykonywane przy użyciu "exec()" lub "eval()". *source*
   może być zwykłym ciągiem znaków, ciągiem bajtów lub obiektem AST. W
   dokumentacji modułu "ast" znajdziesz informacje o tym jak pracować
   z obiektami AST.

   Argument *filename* powinien dawać plik, z którego kod został
   przeczytany; przekaż jakąś rozpoznawalną wartość, jeśli nie został
   przeczytany z pliku (często używa się "'<string>'").

   Argument *mode* określa, jaki rodzaj kodu ma zostać skompilowany;
   może mieć wartość "'exec'" jeśli *source* składa się z sekwencji
   instrukcji, "'eval'" jeśli składa się z jednego wyrażenia lub
   "'single'" jeśli składa się z jednej interaktywnej instrukcji (w
   ostatnim przypadku, instrukcje wyrażeń, które ewaluują się do
   czegoś innego niż "None", zostaną wydrukowane na standardowe
   wyjście).

   Opcjonalne argumenty *flags* i *dont_inherit* kontrolują, które
   opcje kompilatora powinny być aktywowane i które przyszłe funkcje
   powinne być dozwolone. Jeśli żaden z nich nie jest obecny (lub oba
   są zerowe), kod jest kompilowany z tymi samymi flagami, które
   wpływają na kod wywołujący "compile()". Jeśli argument *flags* jest
   podany, a *dont_inherit* nie jest (lub wynosi zero), to opcje
   kompilatora i przyszłe instrukcje określone przez argument *flags*
   są używane w dodatku do tych, które i tak byłyby użyte. Jeśli
   *dont_inherit* jest niezerową liczbą całkowitą, to argument *flags*
   jest nim – flagi (przyszłe funkcje i opcje kompilatora) w
   otaczającym kodzie są ignorowane.

   Opcje kompilatora i przyszłe instrukcja są określone przez bity,
   które mogą być łączone bitowo w celu określenia wielu opcji. Pole
   bitowe wymagane do określenia danej przyszłej funkcji można znaleźć
   jako "compiler_flag" atrybut na instancji "_Feature" w module
   "__future__" . Flagi kompilatora można znaleźć w module "ast" , z
   prefiksem "PyCF_".

   Wartość argumentu *optimize* określa poziom optymalizacji
   kompilatora; wartość domyślna "-1" wybiera poziom optymalizacji
   interpretera podany przez opcje "-O".  Wyraźne poziomy to "0" (brak
   optymalizacji; "__debug__" to prawda), "1" (asercje są usuwane,
   "__debug__" to fałsz) lub "2" (docstrings są również usuwane).

   To funkcja rzuci "SyntaxError" jeśli skompilowane źródło jest
   nieprawidłowe.

   Jeśli chcesz przeanalizować kod Python do jego reprezentacji AST,
   zobacz "ast.parse()".

   Rzuci zdarzenie auditing "compile" z argumentem "source" i
   "filename". To zdarzenie może być również rzucone przez niejawną
   kompilację.

   Informacja:

     Podczas kompilacji napisem z kodem wielowierszowym w trybie
     "'single'" lub "'eval'", dane wejściowe muszą być zakończone co
     najmniej jedną znak nowej lini.  Ma to na celu ułatwienie
     wykrywania niekompletnych i kompletnych instrukcja w module
     "code" .

   Ostrzeżenie:

     Możliwe jest zawieszenie interpretera Python z wystarczająco
     dużym/złożonym napisem podczas kompilacji do obiektu AST z powodu
     ograniczeń głębokości stosu w kompilatorze AST Python.

   Zmienione w wersji 3.2: Zezwolono na używanie nowej linii w
   systemach Windows i Mac.  Ponadto wprowadzanie danych w trybie
   "'exec'" nie musi już kończyć się nową linią.  Dodano funkcję
   *optimize* parametr.

   Zmienione w wersji 3.5: Poprzednio, "TypeError" został rzucony gdy
   napotkano bajty null w *source*.

    Dodane w wersji 3.8: "ast.PyCF_ALLOW_TOP_LEVEL_AWAIT" można teraz
   przekazywać we flagach, aby włączyć obsługę najwyższego poziomu
   "await", "async for" i "async with".

class complex(number=0, /)
class complex(string, /)
class complex(real=0, imag=0)

   Konwertowanie pojedynczego napisu lub liczby na liczba zespolona
   lub tworzenie liczba zespolona z części rzeczywistej i urojonej.

   Przykłady:

      >>> 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 argument jest napisem, musi zawierać albo część rzeczywistą
   (w tym samym formacie co "float()"), albo część urojoną (w tym
   samym formacie, ale z przyrostkiem "'j'" lub "'J'" ), albo zarówno
   część rzeczywistą, jak i urojoną (znak części urojonej jest w tym
   przypadku obowiązkowy). Wartość napis może być opcjonalnie otoczona
   białymi znakami i okrągłymi nawiasami "'('" i "')'", które są
   ignorowane. napis nie może zawierać białych znaków między "'+'",
   "'-'", przyrostkiem "'j'" lub "'J'" a liczbą dziesiętną. Na
   przykład, "complex('1+2j')" jest w porządku, ale "complex('1 +
   2j')" rzuci "ValueError" . Dokładniej, dane wejściowe muszą być
   zgodne z regułą produkcji "complexvalue" w poniższej gramatyce, po
   usunięciu nawiasów oraz początkowych i końcowych znaków:

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

   Jeśli argument jest liczbą, konstruktor służy jako konwersja
   numeryczna, podobnie jak "int" i "float". Dla ogólnego obiektu
   Python "x" , "complex(x)" deleguje do "x.__complex__()". Jeśli
   "__complex__()" nie jest zdefiniowane, to spada z powrotem do
   "__float__()". Jeśli "__float__()" nie jest zdefiniowane, to spada
   z powrotem do "__index__()".

   Jeśli podano dwa argumenty lub argument nazwany, każdy argument
   może być dowolnego typu liczbowego (w tym złożonego). Jeśli oba
   argumenty są liczbami rzeczywistymi, zwraca liczba zespolona ze
   składnikiem rzeczywistym *real* i składnikiem urojonym *imag*.
   Jeśli oba argumenty są liczba zespolona, zwraca liczba zespolona ze
   składnikiem rzeczywistym "real.real-imag.imag" i składnikiem
   urojonym "real.imag+imag.real". Jeśli jedna z argumentow jest
   liczbą rzeczywistą, w powyższych wyrażeniach używany jest tylko jej
   składnik rzeczywisty.

   Jeśli wszystkie argumenty zostaną pominięte, zwraca "0j" .

   Typ Complex został opisany na stronie Numeric Types --- int, float,
   complex.

   Zmienione w wersji 3.6: Dozwolone jest grupowanie cyfr za pomocą
   podkreślników, tak jak w literałach kodu.

   Zmienione w wersji 3.8: Powraca do "__index__()", jeśli
   "__complex__()" i "__float__()" nie są zdefiniowane.

delattr(object, name, /)

   Jest to krewny "setattr()". Argumenty są obiektem i napisem. Napis
   musi być nazwą jednego z atrybut obiektu. Funkcja usuwa nazwany
   atrybut, pod warunkiem, że obiekt na to pozwala.  Na przykład,
   "delattr(x, 'foobar')" jest równoważne "del x.foobar". *name* nie
   musi być identyfikatorem Python (zobacz "setattr()").

class dict(**kwargs)
class dict(mapping, /, **kwargs)
class dict(iterable, /, **kwargs)

   Utwórz nowy słownik.  Obiekt "dict" jest klasą słownik.
   Dokumentacja dotycząca tej klasy znajduje się na stronach "dict" i
   Mapping Types --- dict.

   Inne kontenery można znaleźć w klasach wbudowanych "list" , "set" i
   "tuple", a także moduł "collections" .

dir()
dir(object, /)

   Bez argumentow, zwraca listę nazw w bieżącym zakresie lokalnym.  Z
   argumentów, próba zwraca listy prawidłowych atrybut dla tego
   obiektu.

   Jeśli obiekt posiada metodę o nazwie "__dir__()", metoda ta
   zostanie wywołana i musi zwracać listę atrybut. Pozwala to
   obiektom, które implementują niestandardowe "__getattr__()" lub
   "__getattribute__()" funkcje na dostosowanie sposobu, w jaki
   "dir()" zgłasza ich atrybuty.

   Jeśli obiekt nie udostępnia "__dir__()", funkcja stara się zebrać
   informacje z "__dict__" atrybut obiektu, jeśli jest zdefiniowany,
   oraz z jego obiektu typu.  Wynikowa lista niekoniecznie jest
   kompletna i może być niedokładna, jeśli obiekt ma niestandardowy
   "__getattr__()".

   Mechanizm domyślny "dir()" zachowuje się inaczej w przypadku
   różnych typów obiektów, ponieważ stara się uzyskać najbardziej
   istotne, a nie kompletne informacje:

   * Jeśli obiekt jest obiektem moduł, lista zawiera nazwy obiektów
     moduł atrybutow.

   * Jeśli obiekt jest obiektem typu lub klasy, lista zawiera nazwy
     jego atrybut i rekurencyjnie atrybut jego baz.

   * W przeciwnym razie lista zawiera nazwy atrybut' obiektow, nazwy
     atrybut jego klasy i rekurencyjnie atrybut klas bazowych jego
     klasy.

   Wynikowa lista jest posortowana alfabetycznie.  Na przykład:

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

   Informacja:

     Ponieważ "dir()" jest dostarczany głównie jako udogodnienie do
     użycia w interaktywnym wierszu polecenia, stara się dostarczyć
     interesujący zestaw nazw bardziej niż rygorystycznie lub
     konsekwentnie zdefiniowany zestaw nazw, a jego szczegółowy
     zachowanie może się zmieniać w różnych wydaniach.  Na przykład,
     atrybut metaklasy nie znajduje się na liście wyników, gdy
     argument jest klasą.

divmod(a, b, /)

   Weź dwie (niezłożone) liczby jako argumenty i zwraca parę liczb
   składającą się z ich ilorazu i reszty, gdy używasz liczba całkowita
   dzielenia.  W przypadku mieszanych typów operandów obowiązują
   reguły dla binarnych operatorów arytmetycznych.  Dla liczb
   całkowitych wynik jest taki sam jak "(a // b, a % b)". Dla liczb
   zmiennoprzecinkowych wynikiem jest "(q, a % b)", gdzie *q* jest
   zwykle "math.floor(a / b)", ale może być o 1 mniejsze.  W każdym
   przypadku "q * b + a % b" jest bardzo zbliżone do *a*, jeśli "a %
   b" jest niezerowe, to ma taki sam znak jak *b* i "0 <= abs(a % b) <
   abs(b)".

enumerate(iterable, start=0)

   Zwraca obiekt wyliczeniowy. *iterable* musi być sekwencją,
   *iteratorem* lub innym obiektem obsługującym iterację. Metoda
   "__next__()" iteratora zwróconego przez "enumerate()" zwraca
   dwukrotkę zawierającą licznik (od *start*, który domyślnie wynosi
   0) i wartości uzyskane z iteracji na argumencie *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')]

   Odpowiednik:

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

      * **globals** ("dict" | "None") -- Globalna przestrzeń nazw
        (domyślny: "None").

      * **locals** (*mapping* | "None") -- Lokalna przestrzeń nazw
        (domyślny: "None").

   Zwraca:
      Wynik obliczonej ekspresji.

   rzuca:
      Błędy składni są zgłaszane jako wyjątki.

   Ostrzeżenie:

     Ta funkcja wykonuje dowolny kod. Wywołanie go z danymi
     wejściowymi dostarczonymi przez użytkownika może prowadzić do luk
     w zabezpieczeniach.

   Argument *source* jest analizowany i ewaluowany jako wyrażenie
   Python (technicznie rzecz biorąc, lista warunków) przy użyciu
   mapowań *globals* i *locals* jako globalnej i lokalnej przestrzeni
   nazw.  Jeśli słownik *globals* jest obecny i nie zawiera wartości
   dla klucza "__builtins__", odwołanie do słownika wbudowanego modułu
   "builtins" jest wstawiane pod tym kluczem, zanim *source* zostanie
   przeanalizowane. W ten sposób można kontrolować, jakie built-iny są
   dostępne dla wykonywanego kodu, wstawiając własny słownik
   "__builtins__"  do *globals* przed przekazaniem go do "eval()".
   Jeśli mapowanie *locals* zostanie pominięte, domyślnie będzie to
   słownik *globals*.  Jeśli oba mapowania są pominięte, wyrażenie
   jest wykonywane z *globals* i *locals* w środowisku, w którym
   wywoływany jest "eval()". Uwaga, *eval()* będzie miał dostęp do
   *zagnieżdżonych zakresów* (non-locals) w otaczającym środowisku
   tylko wtedy, gdy są one już przywoływane w zakresie, który wywołuje
   "eval()" (np. poprzez instrukcję "nonlocal").

   Przykład:

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

   Ta funkcja może być również używana do wykonywania dowolnych
   obiektów kodu (takich jak te utworzone przez "compile()").  W tym
   przypadku należy przekazać obiekt kodu zamiast napisu. Jeśli obiekt
   kodu został skompilowany z "'exec'" jako *mode* argument, "eval()"
   wartością zwracana będzie "None".

   Wskazówki: dynamiczne wykonywanie instrukcji jest obsługiwane przez
   "exec()" funkcja .  Adresy "globals()" i "locals()" funkcje
   zwracaja określaaą odpowiednio bieżący globalny i lokalny adres
   słownika, który może być przydatny do przekazania do użycia przez
   adresy "eval()" lub "exec()".

   Jeśli podane źródło to napis, początkowe i końcowe spacje i
   tabulatory są usuwane.

   Zobacz "ast.literal_eval()" dla funkcj, którya może bezpiecznie
   ocenić napis z wyrażeniami zawierającymi tylko literały.

   Rzuci zdarzenie auditing event "exec" z obiektem kodu jako
   argument. Zdarzenia kompilacji kodu mogą być również rzucone.

   Zmienione w wersji 3.13: Funkcje *globals* i *locals* argumenty
   mogą być teraz przekazywane jako słowa kluczowe.

   Zmienione w wersji 3.13: Semantyka przestrzeni nazw domyślnych
   *locals* została dostosowana zgodnie z opisem dla wbudowanej
   "locals()"  .

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

   Ostrzeżenie:

     Ta funkcja wykonuje dowolny kod. Wywołanie go z danymi
     wejściowymi dostarczonymi przez użytkownika może prowadzić do luk
     w zabezpieczeniach.

   Ta funkcja obsługuje dynamiczne wykonywanie kodu Python. *source*
   musi być albo napis albo obiektem kodu.  Jeśli jest to napis, napis
   jest analizowany jako zestaw instrukcji Pythona, które sa następnie
   wykonywany (chyba że wystąpi błąd składni). [1] Jeśli jest to
   obiekt kodu, jest on po prostu wykonywany.  We wszystkich
   przypadkach wykonywany kod powinien być prawidłowy jako plik
   wejściowy (patrz sekcja File input w Podręczniku referencyjnym).
   Należy pamiętać, że wartości "nonlocal", "yield" i "return"
   instrukcije nie mogą być używane poza definicjami funkcji, nawet w
   kontekście kodu przekazywanego do "exec()" . Wartość zwracana to
   "None".

   We wszystkich przypadkach, jeśli części opcjonalne są pominięte,
   kod jest wykonywany w bieżącym zakresie.  Jeśli podano tylko
   *globals*, musi to być słownik (a nie podklasa z słownikem), który
   będzie używany zarówno dla zmiennych globalnych, jak i lokalnych.
   Jeśli podano *globals* i *locals*, są one używane odpowiednio dla
   zmiennych globalnych i lokalnych.  Jeśli podano *locals*, może to
   być dowolny obiekt mapowania.  Należy pamiętać, że na poziomie
   moduł, globals i locals są tym samym słownikem.

   Informacja:

     Gdy "exec" pobiera dwa oddzielne obiekty jako *globals* i
     *locals*, kod zostanie wykonany tak, jakby był osadzony w
     definicja klasy. Oznacza to, że funkcja i klasy zdefiniowane w
     wykonywanym kodzie nie będą mogły uzyskać dostępu do zmiennych
     przypisanych na najwyższym poziomie (ponieważ zmienne
     "najwyższego poziomu" są traktowane jako zmienne klasowe w
     definicja klasy).

   Jeśli *globals* słownik nie zawiera wartości dla klucza
   "__builtins__", odwołanie do słownika z wbudowanego modułu
   "builtins" jest wstawiane pod tym kluczem.  W ten sposób można
   kontrolować, które wbudowane są dostępne dla wykonywanego kodu,
   wstawiając własny "__builtins__" słownik do *globals* przed
   przekazaniem go do "exec()".

   Wyrażenie *closure* określa zamknięcie - krotka zmiennych
   komórkowych. Jest ważne tylko wtedy, gdy *obiekt* jest obiektem
   kodu zawierającym *wolne (zamknięcie) zmienne*. Długość krotka musi
   dokładnie odpowiadać długości "co_freevars" atrybutem obiektu kodu.

   Rzuci zdarzenie auditing event "exec" z obiektem kodu jako
   argument. Zdarzenia kompilacji kodu mogą być również rzucone.

   Informacja:

     Adresy wbudowane funkcji "globals()" i "locals()" zwraca to
     odpowiednio bieżąca globalna i lokalna przestrzeń nazw, które
     mogą być przydatne do przekazania jako drugi i trzeci argument do
     "exec()".

   Informacja:

     Elementy domyślne *locals* działają w sposób opisany dla funkcji
     "locals()" poniżej. Przekaż jawne *locals* słownik jeśli chcesz
     zobaczyć efekty kodu na *locals* po funkcji "exec()"  .

   Zmienione w wersji 3.11: Dodano parametr *zamknięcie*.

   Zmienione w wersji 3.13: Funkcje *globals* i *locals* argumenty
   mogą być teraz przekazywane jako słowa kluczowe.

   Zmienione w wersji 3.13: Semantyka przestrzeni nazw domyślnych
   *locals* została dostosowana zgodnie z opisem dla wbudowanej
   "locals()"  .

filter(function, iterable, /)

   Konstruuje iterator z tych elementów *iterable*, dla których
   *funkcja* jest prawdą.  *iterable* może być sekwencją, kontenerem
   obsługującym iterację lub iterator. Jeśli *funkcja* jest "None",
   zakłada się tożsamość funkcji, to znaczy wszystkie elementy
   *iterable*, które są fałszywe, są usuwane.

   Należy zauważyć, że "filter(function, iterable)" jest równoważne
   wyrażeniu generator "(item for item in iterable if function(item))"
   jeśli funkcja nie jest "None" i "(item for item in iterable if
   item)" jeśli funkcja jest "None".

   Zobacz "itertools.filterfalse()" dla komplementarnych funkci ktore
   zwracaja elementy *iterable* dla których *funkcja* jest fałszywe.

class float(number=0.0, /)
class float(string, /)

   Zwraca liczba zmiennoprzecinkowa zbudowana z liczby lub napisu.

   Przykłady:

      >>> 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 jest napisem, powinien zawierać liczbę dziesiętną,
   opcjonalnie poprzedzoną znakiem i opcjonalnie osadzoną w białych
   znakach.  Znak opcjonalny może być "'+'" lub "'-'"; znak "'+'" nie
   ma wpływu na otrzymaną wartość.  argument może być również napisem
   reprezentującym NaN (not-a-number) lub dodatnią lub ujemną
   nieskończoność. Dokładniej, dane wejściowe muszą być zgodne z
   regułą produkcji "floatvalue" w poniższej gramatyce, po usunięciu
   początkowych i końcowych białych znaków znak:

      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

   Wielkość liter nie ma znaczenia, więc na przykład "inf", "Inf",
   "INFINITY" i "iNfINity" są akceptowalnymi pisowniami dla dodatniej
   nieskończoności.

   W przeciwnym razie, jeśli argument jest liczba całkowita lub liczbą
   zmiennoprzecinkową, zwracana jest liczba zmiennoprzecinkowa o tej
   samej wartości (w zakresie precyzji zmiennoprzecinkowej Python).
   Rzuci jeśli argument jest poza zakresem liczby zmiennoprzecinkowej
   Python, zwrócona zostanie "OverflowError".

   W przypadku ogólnego obiektu Python "x" , "float(x)" deleguje do
   "x.__float__()". Jeśli "__float__()" nie jest zdefiniowana, to
   spada z powrotem do "__index__()".

   Jeśli nie podano argumentu, zwracane jest "0.0".

   Typ float został opisany na stronie Numeric Types --- int, float,
   complex.

   Zmienione w wersji 3.6: Dozwolone jest grupowanie cyfr za pomocą
   podkreślników, tak jak w literałach kodu.

   Zmienione w wersji 3.7: Parametr jest teraz tylko-pozycyjny.

   Zmienione w wersji 3.8: Powraca do "__index__()", jeśli
   "__float__()" nie jest zdefiniowane.

format(value, format_spec='', /)

   Konwertuje *value* na "formatted" reprezentację, kontrolowaną przez
   *format_spec*.  Interpretacja *format_spec* będzie zależeć od typu
   *value* argument; jednak istnieje standardowa składnia
   formatowania, która jest używana przez większość typów wbudowanych:
   Format Specification Mini-Language.

   Parametr domyślny *format_spec* jest pustym napisem, co zwykle daje
   taki sam efekt jak wywołanie "str(value)".

   Wywołanie "format(value, format_spec)" jest tłumaczone na
   "type(value).__format__(value, format_spec)", które omija instancję
   słownika podczas wyszukiwania metody "__format__()" wartości .
   Wyjątek "TypeError" jest rzucony, jeśli wyszukiwanie metody
   osiągnie "object" i *format_spec* jest niepusty, lub jeśli
   *format_spec* lub wartość zwracana nie są napisem.

   Zmienione w wersji 3.4: "object().__format__(format_spec)" rzuci
   "TypeError" jeśli *format_spec* nie jest pustym napisem.

class frozenset(iterable=(), /)

   Zwraca nowy obiekt "frozenset", opcjonalnie z elementami pobranymi
   z *iterable*. "frozenset" jest klasą wbudowaną.  Dokumentacja
   dotycząca tej klasy znajduje się na stronach "frozenset" i Set
   Types --- set, frozenset.

   Dla innych kontenerów zobacz klasy wbudowane "set" , "list",
   "tuple" i "dict", jak również moduł  "collections" .

getattr(object, name, /)
getattr(object, name, default, /)

   Zwraca wartość nazwanego atrybut obiektu *object*.  *name* musi być
   napisem. Jeśli napis jest nazwą jednego z atrybut obiektu, wynikiem
   jest wartość tego atrybutu.  Na przykład, "getattr(x, 'foobar')"
   jest równoważne "x.foobar". Jeśli nazwany atrybut nie istnieje,
   *default* jest zwracany, jeśli został podany, w przeciwnym razie
   "AttributeError" jest rzucony. *name* nie musi być identyfikatorem
   Pythona (Zobacz "setattr()").

   Informacja:

     Ponieważ manipulowanie nazwami prywatnymi odbywa się w czasie
     kompilacji, należy ręcznie zmanipulować nazwę prywatną atrybutu
     (atrybuty z dwoma wiodącymi podkreśleniami), aby pobrać ją za
     pomocą "getattr()".

globals()

   Zwraca słownik implementującą bieżącą przestrzeń nazw moduł. W
   przypadku kodu w funkcja, jest on ustawiany, gdy funkcja jest
   zdefiniowana i pozostaje taki sam niezależnie od tego, gdzie
   wywoływana jest funkcja.

hasattr(object, name, /)

   Argumenty to obiekt i napis. Wynikiem jest "True" jeśli napis jest
   nazwą jednego z obiektów atrybut, "False" jeśli nie. (Jest to
   zaimplementowane poprzez wywołanie "getattr(object, name)" i
   sprawdzenie, czy rzucone jest "AttributeError" ).

hash(object, /)

   Zwraca wartość skrótu obiektu (jeśli taki posiada).  Wartości
   skrótu są liczbami całkowitymi.  Są one używane do szybkiego
   porównywania kluczy słownika podczas wyszukiwania słownika.
   Wartości numeryczne, które są równe, mają tę samą wartość skrótu
   (nawet jeśli są różnych typów, jak w przypadku 1 i 1.0).

   Informacja:

     W przypadku obiektów z niestandardowymi metodami "__hash__()"
     należy pamiętać, że "hash()" obcina wartość zwracaną w oparciu o
     szerokość bitową maszyny hosta.

help()
help(request)

   Wywołuje system pomocy wbudowany.  (Ta funkcja jest przeznaczona do
   użytku interaktywnego.) Jeśli nie podano argumentu, interaktywny
   system pomocy uruchamia się na konsoli interpretera.  Jeśli
   argument jest napisem, to napis jest wyszukiwany jako nazwa modułu,
   funkcja, klasa, metoda, słowo kluczowe lub temat dokumentacji, a
   strona pomocy jest drukowana na konsoli.  Jeśli argument jest
   jakimkolwiek innym rodzajem obiektu, generowana jest strona pomocy
   dotycząca tego obiektu.

   Zauważ, że jeśli ukośnik (/) pojawia się na liście parametrów w
   funkcji podczas wywoływania "help()", oznacza to, że parametry
   przed ukośnikiem są tylko-pozycyjne. Aby uzyskać więcej informacji,
   zobacz wpis FAQ na temat parametrów tylko-pozycyjnych .

   Ta funkcja jest dodawana do przestrzeni nazw wbudowanych przez
   moduł "site" .

   Zmienione w wersji 3.4: Zmiany do "pydoc" i "inspect" oznaczają, że
   zgłoszone sygnatury dla callables są teraz bardziej kompleksowe i
   spójne.

hex(integer, /)

   Konwertuje liczbę całkowitą na zapis szesnastkowy małymi literami
   poprzedzony "0x". Jeśli *integer* nie jest pythonowym obiektem
   "int" , musi definiować metodę "__index__()", która zwraca liczbę
   całkowitą. Kilka przykładów:

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

   Jeśli chcesz przekonwertować liczbe całkowita na wielką lub małą
   liczbę szesnastkową napis z prefiksem lub bez, możesz użyć jednego
   z poniższych sposobów:

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

   Zobacz też "format()" by uzyskać więcej informacji.

   Zobacz także "int()", aby przekonwertować szesnastkowy napis na
   liczba całkowita przy użyciu podstawy 16.

   Informacja:

     Aby uzyskać napis szesnastkowej reprezentacj dla
     zmiennoprzecinkowej, należy użyć metody "float.hex()".

id(object, /)

   Zwraca "tożsamość" obiektu.  Jest to liczba całkowita, która jest
   gwarantowana jako unikalny i stały dla tego obiektu przez cały
   okres jego życia. Dwa obiekty o nienakładających się okresach życia
   mogą mieć tę samą wartość "id()".

   Jest to adres obiektu w pamięci.

   Rzuci  auditing event "builtins.id" bez argumentu "id" .

input()
input(prompt, /)

   Jeśli *prompt* argument jest obecny, jest on zapisywany na
   standardowe wyjście bez końcowej nowej linii.  Następnie funkcja
   odczytuje linię z wejścia, konwertuje ją na napis (usuwając końcową
   nową linię) i zwraca.  Po odczytaniu EOF, "EOFError" jest rzucone.
   Przykład:

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

   Jeśli załadowano moduł "readline" , to "input()" użyje go do
   zapewnienia rozbudowanych funkcji edycji wierszy i historii.

   Rzuca auditing event "builtins.input" z argumentem "prompt" przed
   odczytaniem wpisu

   Rzuca zdarzenie auditing "builtins.input/result" z wynikiem po
   pomyślnym odczytaniu danych wejściowych.

class int(number=0, /)
class int(string, /, base=10)

   Zwraca obiekt liczba całkowita zbudowana z liczby lub napisu, lub
   zwraca "0" jeśli nie podano argumentu.

   Przykłady:

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

   Jeśli argument definiuje "__int__()", "int(x)" zwraca "x.__int__()"
   .  Jeśli argument definiuje "__index__()", to zwraca
   "x.__index__()" .  Jeśli argument definiuje "__trunc__()", to
   zwraca "x.__trunc__()" . W przypadku liczb zmiennoprzecinkowych
   jest ona obcinana w kierunku zera.

   Jeśli argument nie jest liczbą lub jeśli podano *base*, musi to być
   instancja napisu, "bytes" lub "bytearray" reprezentująca liczba
   całkowita w radix *base*.  Opcjonalnie, napis może być poprzedzony
   przez "+" lub "-" (bez spacji pomiędzy nimi), mieć początkowe zera,
   być otoczone białymi znakami i mieć pojedyncze podkreślenia
   pomiędzy cyframi.

   Baza-n liczba całkowita napis zawiera cyfry, z których każda
   reprezentuje wartość od 0 do n-1. Wartości 0--9 mogą być
   reprezentowane przez dowolną cyfrę dziesiętną Unicode. Wartości
   10-35 mogą być reprezentowane przez "a" do "z" (lub "A" do "Z").
   Domyślna baza jest 10. Dozwolone wartości bazowe to 0 i 2--36.
   Podstawy 2, -8 i -16 napis mogą być opcjonalnie poprzedzone
   przedrostkiem "0b"/"0B", "0o"/"0O", lub "0x"/"0X", tak jak w
   przypadku literałów liczba całkowita w kodzie.  Dla podstawy 0,
   napis jest interpretowane w podobny sposób jak liczba całkowita w
   kodzie, w którym rzeczywista podstawa wynosi 2, 8, 10 lub 16,
   zgodnie z przedrostkiem. Podstawa 0 również nie zezwala na zera
   wiodące: "int('010', 0)" nie jest legalne, podczas gdy "int('010')"
   i "int('010', 8)" są.

   Typ liczba całkowita (integer) został opisany w Numeric Types ---
   int, float, complex.

   Zmienione w wersji 3.4: Jeśli *base* nie jest instancją "int" i
   obiekt *base* posiada metodę "base.__index__", metoda ta jest
   wywoływana w celu uzyskania liczba całkowitych dla bazy.
   Poprzednie wersje używały "base.__int__" zamiast "base.__index__".

   Zmienione w wersji 3.6: Dozwolone jest grupowanie cyfr za pomocą
   podkreślników, tak jak w literałach kodu.

   Zmienione w wersji 3.7: Pierwszy parametr jest teraz tylko
   pozycyjny.

   Zmienione w wersji 3.8: Powraca do "__index__()", jeśli "__int__()"
   nie jest zdefiniowane.

   Zmienione w wersji 3.11: Delegacja do "__trunc__()" jest
   zdezaprobowana.

   Zmienione w wersji 3.11: "int" napis wejścia i reprezentacje napisa
   mogą być ograniczone, aby pomóc uniknąć ataków typu "odmowa
   usługi". "ValueError" jest rzucone, gdy limit zostanie przekroczony
   podczas konwersji napisa na "int" lub gdy konwersja "int" na napis
   przekroczy limit. Zobacz dokumentację liczba całkowita napis
   ograniczenia długości konwersji.

isinstance(object, classinfo, /)

   Zwraca "True" jeśli argument *object* jest instancją argumentu
   *classinfo*, lub jego (bezpośrednią, pośrednią lub *wirtualną*)
   podklasą.  Jeśli *object* nie jest obiektem danego typu, funkcja
   zawsze zwraca "False". Jeśli *classinfo* jest krotką obiektów typu
   (lub rekurencyjnie, innych takich krotek) lub Union Type wielu
   typów, zwraca "True" jeśli *obiekt* jest instancją któregokolwiek z
   typów. Jeśli *classinfo* nie jest typem lub krotką typów i takich
   krotek, rzucany jest wyjątek "TypeError". "TypeError" może nie być
   rzucony dla nieprawidłowego typu, jeśli wcześniejsze sprawdzenie
   powiedzie się.

   Zmienione w wersji 3.10: *classinfo* może być Union Type.

issubclass(class, classinfo, /)

   Zwraca "True" jeśli *class* jest podklasą (bezpośrednią, pośrednią
   lub *wirtualną*) *classinfo*.  Klasa jest uważana za podklasę samej
   siebie. *classinfo* może być krotką obiektów klasy (lub
   rekurencyjnie, innych takich krotek) lub Union Type, w którym to
   przypadku zwraca "True" jeśli *class* jest podklasą dowolnego wpisu
   w *classinfo*.  W każdym innym przypadku rzucany jest wyjątek
   "TypeError".

   Zmienione w wersji 3.10: *classinfo* może być Union Type.

iter(iterable, /)
iter(callable, sentinel, /)

   Zwraca obiekt *iteratora*.  Pierwszy argument jest interpretowany
   bardzo różnie w zależności od obecności drugiego argumentu. Bez
   drugiego argumentu, jedyny argument musi być obiektem kolekcji,
   która obsługuje protokół *iterable* (metoda "__iter__()" ), lub
   musi obsługiwać protokół sekwencji (metoda "__getitem__()" z
   argumentami liczb całkowitych zaczynających się od "0"). Jeśli nie
   obsługuje żadnego z tych protokołów, zostanie rzucony "TypeError".
   Jeśli podano drugi argument, *sentinel*, to pierwszy argument musi
   być obiektem wywoływalnym. Utworzony w tym przypadku iterator
   będzie wywoływał *callable* bez argumentu dla każdego wywołania
   jego metody "__next__()"; jeśli zwrócona wartość jest równa
   *sentinel*, zostanie rzucone "StopIteration", w przeciwnym razie
   zostanie zwrócona wartość.

   Zobacz także Iterator Types.

   Jednym z przydatnych aplikacji drugiej formy "iter()" jest
   zbudowanie blok czytnika. Na przykład, odczytywanie stałej
   szerokości bloku z binarnego pliku bazy danych aż do osiągnięcia
   końca pliku:

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

len(object, /)

   Zwraca długość (liczba elementów) obiektu.  Obiekt argument może
   być sekwencją (taką jak napis, bajty, krotka, lista lub zakres) lub
   kolekcją (taką jak słownik, zbiór lub zbiór zamrożony).

   "len" rzuca "OverflowError" dla długości większych niż
   "sys.maxsize", takich jak "range(2 ** 100)".

class list(iterable=(), /)

   Zamiast być funkcją, "list" jest w rzeczywistości typem mutowalnej
   (zmiennej) sekwencji, jak udokumentowano w Listy i Sequence Types
   --- list, tuple, range.

locals()

   Zwraca obiekt mapowania reprezentujący bieżącą lokalną tablicę
   symboli, z nazwami zmiennych jako kluczami i ich aktualnie
   powiązanymi referencjami jako wartościami.

   W zakresie moduł, a także podczas korzystania z "exec()" lub
   "eval()" z pojedynczą przestrzenią nazw, ta funkcja zwraca ta sama
   przestrzeń nazw co "globals()".

   W zakresie klasy, zwraca przestrzeń nazw, która zostanie przekazana
   do konstruktora metaklasy.

   W przypadku korzystania z "exec()" lub "eval()" z oddzielnymi
   lokalnymi i globalnymi argumentami, zwraca lokalną przestrzeń nazw
   przekazaną do wywołania funkcji.

   We wszystkich powyższych przypadkach każde wywołanie "locals()" w
   danej ramce wykonania spowoduje zwracanie *tego samego* obiektu
   mapowania. Zmiany dokonane za pośrednictwem obiektu mapowania
   zwróconego z "locals()" będą widoczne jako przypisane, ponownie
   przypisane lub usunięte zmienne lokalne, a przypisanie, ponowne
   przypisanie lub usunięcie zmiennych lokalnych natychmiast wpłynie
   na zawartość zwróconego obiektu mapowania.

   W *optimized scope* (włączając w to funkcja, generatory i
   coroutines), każde wywołanie "locals()" zamiast zwracania świeżego
   słownika zawierający aktualne wiązania zmiennych lokalnych funkcji
   i wszelkie nielokalne odwołania do komórek. W tym przypadku zmiany
   powiązań nazw dokonane za pośrednictwem zwróconego dict *nie* są
   zapisywane z powrotem do odpowiednich zmiennych lokalnych lub
   nielokalnych odwołań do komórek, a przypisywanie, ponowne
   przypisywanie lub usuwanie zmiennych lokalnych i nielokalnych
   odwołań do komórek *nie* wpływa na zawartość wcześniej zwróconego
   słownika.

   Wywołanie "locals()" jako części rozumienia w funkcji, generator
   lub coroutine jest równoważne wywołaniu go w zakresie zawierającym,
   z wyjątkiem tego, że zainicjowane zmienne iteracyjne rozumienia
   zostaną uwzględnione. W innych zakresach zachowuje się tak, jakby
   rozumienie działało jako zagnieżdżone funkcja.

   Wywołanie "locals()" jako części wyrażenia generator jest
   równoważne wywołaniu go w zagnieżdżonym generatorze funkcji .

   Zmienione w wersji 3.12: Zachowanie  "locals()" w zrozumieniu
   została zaktualizowana zgodnie z opisem w **PEP 709**.

   Zmienione w wersji 3.13: Jako część **PEP 667**, semantyka
   mutowania obiektów mapowania zwróconych z tej funkcji jest teraz
   zdefiniowana. Zachowanie w *zoptymalizowanych zakresach* jest teraz
   opisane powyżej. Poza zdefiniowaniem, zachowanie w innych zakresach
   pozostaje niezmienione w stosunku do poprzednich wersji.

map(function, iterable, *iterables)

   Zwraca iterator , który stosuje *funkcje* do każdego elementu
   *iterable*, dając wyniki.  Jeśli przekazane zostaną dodatkowe
   *iterable* argumenty, *funkcja* musi przyjąć taką liczbę argumentow
   i jest stosowana do elementów ze wszystkich iterable równolegle.  W
   przypadku wielu iterables, iterator zatrzymuje się, gdy najkrótszy
   iterable zostanie wyczerpany.  Dla przypadków, w których wejścia
   funkcji są już ułożone w argumentach krotka , zobacz
   "itertools.starmap()" .

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

   Zwraca największy element w iterable lub największy z dwóch lub
   więcej argumentow.

   Jeśli podano jeden pozycjny argument, powinien to być *iterable*.
   Zwracany jest największy element w iterable.  Jeśli podano dwa lub
   więcej pozycyjne argumenty, zwracany jest największy z pozycyjnych
   argumentow.

   Istnieją dwa opcjonalne tylko ze słowem kluczowym argument.
   *Kluczowy* argument określa jedno-argumentowy uporządkowanie
   funkcji jak to używane dla "list.sort()". *Domyślny* argument
   określa obiekt do zwracania, jeśli podany iterable jest pusty.
   Jeśli iterable jest pusty i *domyślny* nie jest podany,
   "ValueError" jest rzucony.

   Jeśli wiele elementów jest maksymalnych, funkcja zwraca pierwszy
   napotkany element.  Jest to zgodne z innymi narzędziami
   zachowującymi stabilność sortowania, takimi jak "sorted(iterable,
   key=keyfunc, reverse=True)[0]" i "heapq.nlargest(1, iterable,
   key=keyfunc)".

   Zmienione w wersji 3.4: Dodano *default* tylko słowo kluczowe
   parametr.

   Zmienione w wersji 3.8: *Kluczem* może być "None".

class memoryview(object)

   Zwraca obiekt "memory view" utworzony z podanego argumentu.  Więcej
   informacji można znaleźć na stronie Memory Views.

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

   Zwraca najmniejszy element w iterable lub najmniejszy z dwóch lub
   więcej argumentow.

   Jeśli podano jeden pozycjny argument, powinien to być *iterable*.
   Zwracany jest najmniejszy element w iterable.  Jeśli podano dwa lub
   więcej pozycyjne argumenty, zwracany jest najmniejszy z pozycyjnych
   argumentow.

   Istnieją dwa opcjonalne tylko ze słowem kluczowym argument.
   *Kluczowy* argument określa jedno-argumentowy uporządkowanie
   funkcji jak to używane dla "list.sort()". *Domyślny* argument
   określa obiekt do zwracania, jeśli podany iterable jest pusty.
   Jeśli iterable jest pusty i *domyślny* nie jest podany,
   "ValueError" jest rzucony.

   Jeśli wiele elementów jest minimalnych, funkcja zwraca pierwszy
   napotkany.  Jest to zgodne z innymi narzędziami zachowującymi
   stabilność sortowania, takimi jak "sorted(iterable,
   key=keyfunc)[0]" i "heapq.nsmallest(1, iterable, key=keyfunc)".

   Zmienione w wersji 3.4: Dodano *default* tylko słowo kluczowe
   parametr.

   Zmienione w wersji 3.8: *Kluczem* może być "None".

next(iterator, /)
next(iterator, default, /)

   Pobiera następny element z *iterator* poprzez wywołanie jego metody
   "__next__()".  Jeśli *domyślny* jest podany, jest zwracany, jeśli
   iterator jest wyczerpany, w przeciwnym razie "StopIteration" jest
   rzucony.

class object

   Jest to ostateczna klasa bazowa wszystkich innych klas. Posiada
   metody, które są wspólne dla wszystkich instancji klas Pythona.
   Kiedy konstruktor jest wywoływany, zwraca nowy obiekt bez funkcji.
   Klasa konstruktor nie akceptuje żadnych argumentow.

   Informacja:

     "object" instancje *nie* mają "__dict__" atrybut , więc nie można
     przypisać dowolnego atrybuta do instancji "object".

oct(integer, /)

   Konwertuje liczbę całkowitą na ósemkowy ciąg znaków z prefiksem
   "0o".  Wynikiem jest poprawne wyrażenie Python. Jeśli *integer* nie
   jest pythonowym obiektem "int", musi definiować metodę
   "__index__()", która zwraca liczbę całkowitą. Na przykład:

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

   Jeśli chcesz przekonwertować liczbę całkowita na ósemkowy napis z
   przedrostkiem "0o" lub bez, możesz użyć jednego z poniższych
   sposobów.

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

   Zobacz też "format()" by uzyskać więcej informacji.

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

   Otwiera *file* i zwraca odpowiedni *obiekt pliku*.  Jeśli pliku nie
   da się otworzyć, rzucany jest "OSError". Więcej przykładów użycia
   tej funkcji można znaleźć w Odczytywanie i zapisywanie plików.

   *file* jest *obiektem path-like* podającym nazwę ścieżki
   (bezwzględną lub względną do bieżącego katalogu roboczego) pliku,
   który ma zostać otwarty, lub liczbą całkowitą deskryptora pliku,
   który ma zostać opakowany.  (Jeśli podano deskryptor pliku, jest on
   zamykany, gdy zwrócony obiekt I/O jest zamykany, chyba że *closefd*
   jest ustawione na "False".)

   *mode* to opcjonalny napis , który określa tryb, w którym plik jest
   otwierany.  Domyślnie jest to "'r'", co oznacza otwarcie do odczytu
   w trybie tekstowym. Inne popularne wartości to "'w'" dla zapisu
   (obcinanie pliku, jeśli już istnieje), "'x'" dla wyłącznego
   tworzenia i "'a'" dla dołączania (co w *niektórych* systemach Unix
   oznacza, że *wszystkie* zapisy są dołączane do końca pliku
   niezależnie od bieżącej pozycji wyszukiwania).  W trybie tekstowym,
   jeśli nie podano *encoding*, używane kodowanie jest zależne od
   platformy: "locale.getencoding()" jest wywoływane w celu uzyskania
   bieżącego kodowania locale. (Do odczytu i zapisu nieprzetworzonych
   bajtów należy użyć trybu binarnego i pozostawić *encoding*
   nieokreślone).  Dostępne tryby to:

   +-----------+-----------------------------------------------------------------+
   | Znak      | Znaczenie                                                       |
   |===========|=================================================================|
   | "'r'"     | otwarte do czytania (domyślny)                                  |
   +-----------+-----------------------------------------------------------------+
   | "'w'"     | otworzyć do zapisu, najpierw obcinając plik                     |
   +-----------+-----------------------------------------------------------------+
   | "'x'"     | otwarcie do wyłącznego utworzenia, niepowodzenie, jeśli plik    |
   |           | już istnieje                                                    |
   +-----------+-----------------------------------------------------------------+
   | "'a'"     | otwarte do zapisu, dołączenie do końca pliku, jeśli istnieje    |
   +-----------+-----------------------------------------------------------------+
   | "'b'"     | tryb binarny                                                    |
   +-----------+-----------------------------------------------------------------+
   | "'t'"     | tryb tekstowy (domyślny)                                        |
   +-----------+-----------------------------------------------------------------+
   | "'+'"     | otwarte na aktualizację (odczyt i zapis)                        |
   +-----------+-----------------------------------------------------------------+

   Tryb domyślny to "'r'" (otwarty do odczytu tekstu, synonim "'rt'").
   Tryby "'w+'" i "'w+b'" otwierają i obcinają plik.  Tryby "'r+'" i
   "'r+b'" otwierają plik bez obcinania.

   Jak wspomniano w Skorowidz, Python rozróżnia binarne i tekstowe
   I/O.  Pliki otwierane w trybie binarnym (w tym "'b'" w *mode*
   argument) zwracają zawartość jako obiekty "bytes" bez żadnego
   dekodowania.  W trybie tekstowym ( domyślny, lub gdy "'t'" jest
   zawarte w *mode* argument), zawartość pliku jest zwracana jako
   "str", bajty zostały najpierw zdekodowane przy użyciu kodowania
   zależnego od platformy lub przy użyciu określonego *kodowania*,
   jeśli zostało podane.

   Informacja:

     Python nie zależy od pojęcia plików tekstowych w systemie
     operacyjnym; całe przetwarzanie jest wykonywane przez Pythoan i
     dlatego jest niezależne od platformy.

   *buffering* to opcjonalna liczba całkowita używana do ustawiania
   polityki buforowania.  Przekaż 0, aby wyłączyć buforowanie
   (dozwolone tylko w trybie binarnym), 1, aby wybrać buforowanie
   liniowe (używane tylko podczas pisania w trybie tekstowym) i liczba
   całkowita > 1, aby wskazać rozmiar w bajtach bufora o stałym
   rozmiarze. Należy zauważyć, że określenie rozmiaru bufora w ten
   sposób dotyczy binarnie buforowanego wejścia/wyjścia, ale
   "TextIOWrapper" (tj. pliki otwierane za pomocą "mode='r+'") będą
   miały inne buforowanie. Aby wyłączyć buforowanie w "TextIOWrapper",
   należy rozważyć użycie flagi "write_through" dla
   "io.TextIOWrapper.reconfigure()". Gdy nie podano *buforowania*
   argument, polityka buforowania domyślny działa w następujący
   sposób:

   * Pliki binarne są buforowane w kawałkach o stałym rozmiarze;
     rozmiar bufora jest wybierany przy użyciu heurystyki próbującej
     określić "rozmiar urządzenia bazowego" i powracając do
     "io.DEFAULT_BUFFER_SIZE".  W wielu systemach bufor ma długość
     4096 lub 8192 bajtów.

   * "Interaktywne" pliki tekstowe (pliki, dla których "isatty()"
     zwraca "True" ) używają buforowania linii.  Inne pliki tekstowe
     używają zasad opisanych powyżej dla plików binarnych.

   *encoding* to nazwa kodowania używanego do dekodowania lub
   kodowania pliku. Powinno być używane tylko w trybie tekstowym.
   Kodowanie domyślne jest zależne od platformy (cokolwiek
   "locale.getencoding()" zwraca ), ale można użyć dowolnego
   *kodowanie tekstu* obsługiwanego przez Python. Lista obsługiwanych
   kodowań znajduje się na stronie "codecs" modułu .

   *errors* to opcjonalny napis, który określa sposób obsługi błędów
   kodowania i dekodowania - nie może być używany w trybie binarnym.
   Dostępnych jest wiele standardowych programów obsługi błędów
   (wymienionych w Error Handlers), choć każda nazwa obsługi błędów
   zarejestrowana w "codecs.register_error()" jest również ważna.
   Standardowe nazwy obejmują:

   * "'strict'" do rzucenja wyjątek "ValueError", jeśli wystąpi błąd
     kodowania.  Wartość domyślna z "None" ma ten sam efekt.

   * "'ignore'" ignoruje błędy.  Należy pamiętać, że ignorowanie
     błędów kodowania może prowadzić do utraty danych.

   * "'replace'" powoduje wstawienie znacznika zastępczego (takiego
     jak "'?'") tam, gdzie występują zniekształcone dane.

   * "'surrogateescape'" będzie reprezentować wszelkie nieprawidłowe
     bajty jako niskie jednostki kodu zastępczego w zakresie od U+DC80
     do U+DCFF. Te jednostki kodu zastępczego zostaną następnie
     przekształcone z powrotem w te same bajty, gdy podczas zapisu
     danych zostanie użyta obsługa błędów "surrogateescape".  Jest to
     przydatne do przetwarzania plików w nieznanym kodowaniu.

   * "'xmlcharrefreplace'" jest obsługiwany tylko podczas zapisu do
     pliku. Znak nieobsługiwany przez kodowanie jest zastępowany
     odpowiednim odniesieniem XML znak "&#*nnn*;" .

   * "'backslashreplace'" zastępuje zniekształcone dane przez
     sekwencje specjalne Python'z ukośnikiem wstecznym.

   * "'namereplace'" (również obsługiwane tylko podczas zapisu)
     zastępuje nieobsługiwane znak sekwencjami ucieczki "\N{...}".

   *newline* określa sposób analizowania nowej linii znak ze
   strumienia. Może to być "None", "''", "'\n'", "'\r'" i "'\r\n'".
   Działa to w następujący sposób:

   * Podczas odczytu danych wejściowych ze strumienia, jeśli *newline*
     to "None", włączony jest uniwersalny tryb nowych linii.  Linie na
     wejściu mogą kończyć się na "'\n'", "'\r'", lub "'\r\n'", które
     są tłumaczone na "'\n'" przed zwróceniem do wywołującego.  Jeśli
     jest to "''", włączony jest uniwersalny tryb nowych linii, ale
     zakończenia linii są zwracane do wywołującego bez tłumaczenia.
     Jeśli ma dowolną z pozostałych legalnych wartości, linie
     wejściowe są kończone tylko przez podany napis, a zakończenie
     linii jest zwracane bez tłumaczenia.

   * Podczas zapisywania danych wyjściowych do strumienia, jeśli
     *newline* ma wartość "None", wszelkie zapisane "'\n'" znaki są
     tłumaczone na systemowy domyślny separator linii, "os.linesep".
     Jeśli *newline* ma wartość "''" lub "'\n'", tłumaczenie nie jest
     wykonywane.  Jeśli *newline* jest dowolną z pozostałych legalnych
     wartości, wszelkie zapisane "'\n'" znaki są tłumaczone na podany
     napis.

   Jeśli *closefd* ma wartość "False" i podano deskryptor pliku, a nie
   nazwę pliku, to bazowy deskryptor pliku pozostanie otwarty po
   zamknięciu pliku.  Jeśli podano nazwę pliku, *closefd* musi mieć
   wartość "True" ( domyślny); w przeciwnym razie wystąpi błąd.

   Niestandardowy otwieracz może być użyty poprzez przekazanie
   wywołania jako *opener*. Podstawowy deskryptor pliku dla obiektu
   pliku jest następnie uzyskiwany przez wywołanie *opener* z (*file*,
   *flags*). *opener* musi zwracać otwarty deskryptor pliku
   (przekazanie "os.open" jako *opener* skutkuje funkcjonalnością
   podobną do przekazania "None").

   Nowo utworzony plik jest non-inheritable.

   Poniższy przykład używa dir_fd  parametr z "os.open()" funkcji do
   otwarcia pliku względem danego katalogu:

      >>> 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('To zostanie zapisane  w somedir/spamspam.txt', file=f)
      ...
      >>> os.close(dir_fd)  # nie ujawniaj deskryptora pliku

   Typ *file object* zwracany przez "open()" zależy od trybu.  Gdy
   "open()" jest używany do otwarcia pliku w trybie tekstowym ("'w'",
   "'r'", "'wt'", "'rt'", itd.), to zwracana jest podklasa klasy
   "io.TextIOBase" (w szczególności "io.TextIOWrapper").  W przypadku
   użycia do otwarcia pliku w trybie binarnym z buforowaniem, zwracana
   klasą jest podklasa z "io.BufferedIOBase". Dokładna klasa różni
   się: w trybie odczytu binarnego, jest to zwracane z
   "io.BufferedReader"; w trybach zapisu binarnego i dołączania
   binarnego, jest to zwracane z "io.BufferedWriter", a w trybie
   odczytu/zapisu, jest to zwracane z "io.BufferedRandom". Gdy
   buforowanie jest wyłączone, zwracany jest nieprzetworzony strumień,
   podklasa z "io.RawIOBase", "io.FileIO".

   Zobacz także moduły obsługę plików, takich jak "fileinput", "io"
   (gdzie zadeklarowano "open()" ), "os", "os.path", "tempfile" i
   "shutil".

   Rzuca auditing event "open" z argumentami "path" , "mode", "flags".

   Adresy "mode" i "flags" argumenty mogły zostać zmodyfikowane lub
   wywnioskowane z oryginalnego połączenia.

   Zmienione w wersji 3.3:

   * Dodano *opener* parametr.

   * Dodano tryb "'x'".

   * "IOError" kiedyś był rzucony, teraz jest alias z "OSError".

   * "FileExistsError" jest teraz rzucane, jeśli plik otwarty w trybie
     wyłącznego tworzenia ("'x'") już istnieje.

   Zmienione w wersji 3.4:

   * Plik nie jest teraz dziedziczony.

   Zmienione w wersji 3.5:

   * Jeśli wywołanie systemowe zostanie przerwane, a program obsługi
     sygnału nie rzuci wyjątku, funkcji ponawia teraz wywołanie
     systemowe zamiast rzucenja wyjątku "InterruptedError" (zobacz
     **PEP 475** dla uzasadnienia).

   * Dodano obsługę błędów "'namereplace'".

   Zmienione w wersji 3.6:

   * Dodano obsługę akceptowania obiektów implementujących
     "os.PathLike".

   * W systemie Windows, otwarcie bufora konsoli może zwracać podklasa
     z "io.RawIOBase" innego niż "io.FileIO".

   Zmienione w wersji 3.11: Tryb "'U'" został usunięty.

ord(character, /)

   Zwraca wartość porządkową znaku.

   Jeśli argument jest jedno-znakowym ciągiem znaków, zwraca punkt
   kodowy Unicode tego znaku. Na przykład, "ord('a')" zwraca liczbę
   całkowitą "97" i "ord('€')" (znak euro) zwraca "8364" . Jest to
   odwrotność "chr()".

   Jeśli argument jest obiektem "bytes" lub "bytearray" o długości 1,
   zwraca jego wartość pojedynczego bajtu. Na przykład "ord(b'a')"
   zwraca liczbę całkowitą "97".

pow(base, exp, mod=None)

   Zwraca *base* do potęgi *exp*; jeśli *mod* jest obecny, zwraca
   *base* do potęgi *exp*, modulo *mod* (obliczane bardziej efektywnie
   niż "pow(base, exp) % mod"). Forma dwóchargumentow "pow(base, exp)"
   jest równoważna użyciu operatora potęgi: "base**exp".

   Gdy argumenty są wbudowanymi typami numerycznymi z mieszanymi
   typami operandów, obowiązują zasady koercji dla binarnych
   operatorów arytmetycznych.  Dla operandów "int" wynik ma ten sam
   typ co operandy (po koercji), chyba że drugi argument jest ujemny;
   w takim przypadku wszystkie argument są konwertowane na float i
   dostarczany jest wynik float.  Na przykład, "pow(10, 2)" zwracać
   "100" , ale "pow(10, -2)" zwracać "0.01" .  W przypadku ujemnej
   podstawy typu "int" lub "float" i wykładnika niecałkowitego
   dostarczany jest wynik złożony.  Na przykład, "pow(-9, 0.5)" zwraca
   wartość zbliżona do "3j". Natomiast dla ujemnej podstawy typu "int"
   lub "float" z wykładnikiem całkowitym, dostarczany jest wynik
   zmiennoprzecinkowy. Na przykład "pow(-9, 2.0)" zwraca "81.0" .

   Dla operandów "int" *base* i *exp*, jeśli *mod* jest obecny, *mod*
   musi być również typu liczba całkowita i *mod* musi być niezerowy.
   Jeśli *mod* jest obecny, a *exp* jest ujemny, *base* musi być
   względnie pierwsze do *mod*. W takim przypadku zwracana jest
   wartość "pow(inv_base, -exp, mod)", gdzie *inv_base* jest
   odwrotnością *base* modulo *mod*.

   Oto przykład obliczania odwrotności dla "38" modulo "97":

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

   Zmienione w wersji 3.8: W przypadku operandów "int", trzy-argumenty
   formy "pow" pozwala teraz, aby drugi argument był ujemny,
   umożliwiając obliczanie odwrotności modularnych.

   Zmienione w wersji 3.8: Zezwalaj na argument nazwany.  Wcześniej
   obsługiwane były tylko pozycyjne argument.

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

   Wypisuje *obiekty* do strumienia tekstowego *file*, oddzielone
   *sep* i zakończone *end*.  *sep*, *end*, *file* i *flush*, jeśli
   występują, muszą być podane jako argument nazwany.

   Wszystkie non-argumenty nazwane są konwertowane na napis tak jak
   "str()" i zapisywane do strumienia, oddzielone *sep* i *end*.
   Zarówno *sep* jak i *end* muszą być napisem; mogą być również
   "None", co oznacza użycie wartości domyślne.  Jeśli nie podano
   *objects*, "print()" po prostu zapisze *end*.

   *Plik* argument musi być obiektem z metodą "write(string)"; jeśli
   nie jest obecny lub "None", zostanie użyty "sys.stdout".  Ponieważ
   drukowane argument są konwertowane na tekst napis, "print()" nie
   może być używany z obiektami plików w trybie binarnym.  Zamiast
   tego należy uży "file.write(...)".

   Buforowanie wyjścia jest zwykle określane przez *file*. Jednakże,
   jeśli *flush* jest prawdą, strumień jest przymusowo opróżniany.

   Zmienione w wersji 3.3: Dodano *flush* argument nazwany.

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

   Zwraca atrybut właściwośći.

   *fget* to funkcja do pobierania wartości atrybut.  *fset* to
   funkcja do ustawiania wartości atrybut. *fdel* to funkcja do
   usuwania wartości atrybut.  Z kolei *doc* tworzy docstring dla
   atrybut.

   Typowym zastosowaniem jest zdefiniowanie zarządzanego atrybutu "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* jest instancją *C*, "c.x" wywoła getter, "c.x = value"
   wywoła setter, a "del c.x" deleter.

   Jeśli zostanie podana, *doc* będzie docstringiem właściwości
   atrybut. W przeciwnym razie właściwość skopiuje docstring *fget*
   (jeśli istnieje).  Umożliwia to łatwe tworzenie właściwości tylko
   do odczytu przy użyciu "property()" jako *dekorator*:

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

          @property
          def voltage(self):
              """Uzyska aktualne napięcie.""
              return self._voltage

   "@property" dekorator zamienia metodę "voltage()" w "getter" dla
   tylko do odczytu atrybut o tej samej nazwie i ustawia docstring dla
   *voltage* na "Get the current voltage".

   @getter

   @setter

   @deleter

      Obiekt właściwości ma metody "getter", "setter" i "deleter"
      używane jako dekorator, które tworzą kopię właściwości z
      odpowiednim akcesorem funkcji ustawionym na dekorowany funkcja.
      Najlepiej wyjaśnić to na przykładzie:

         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

      Ten kod jest dokładnie taki sam jak w pierwszym przykładzie.
      Pamiętaj, aby nadać dodatkowym funkcjom takie same nazwy jak
      oryginalnej właściwości (w tym przypadku "x").

      Zwrócony obiekt właściwości ma również atrybutow "fget" , "fset"
      i "fdel" odpowiadające konstruktor argumentu.

   Zmienione w wersji 3.5: Dokumentacja obiektów właściwości sa teraz
   zapisywalne.

   __name__

      Atrybut przechowująca nazwę właściwości. Nazwa właściwości może
      zostać zmieniona w czasie wykonywania.

       Dodane w wersji 3.13.

class range(stop, /)
class range(start, stop, step=1, /)

   Zamiast być funkcja, "range" jest w rzeczywistości niezmiennym
   typem sekwencji, jak udokumentowano w Ranges i Sequence Types ---
   list, tuple, range.

repr(object, /)

   Zwraca napis zawierający nadającą się do druku reprezentację
   obiektu.  W przypadku wielu typów, ta funkcja podejmuje próbę
   zwracanja napisu, która dałaby obiekt o tej samej wartości po
   przekazaniu do "eval()"; w przeciwnym razie reprezentacja jest
   napisem ujęta w nawiasy kątowe, które zawierają nazwę typu obiektu
   wraz z dodatkowymi informacjami, często zawierającymi nazwę i adres
   obiektu.  Klasa może kontrolować co funkcja zwraca dla swoich
   instancji, definiując metodę "__repr__()". Jeśli
   "sys.displayhook()" nie jest dostępna, ta funkcja będzie rzucona
   "RuntimeError" .

   Ta klasa ma niestandardową reprezentację, którą można ocenić:

      class Osoba:
         def __init__(self, imie, wiek):
            self.imie = imie
            self.wiek = wiek

         def __repr__(self):
            zwracać f "Person('{self.imie}', {self.wiek})".

reversed(object, /)

   Zwraca odwrócony *iterator*. Argument musi być obiektem, który ma
   metodę "__reversed__()" lub obsługuje protokół sekwencji (metoda
   "__len__()" i metoda "__getitem__()" z całkowitymi argumentami
   począwszy od "0").

round(number, ndigits=None)

   Zwraca *liczba* zaokrąglona do *cyfr* po przecinku dziesiętnym.
   Jeśli *ndigits* zostanie pominięte lub będzie "None", to zwraca
   najbliższa liczbe całkowita wartości wejściowej.

   Dla typów wbudowanych wspierających "round()", wartości są
   zaokrąglane do najbliższej wielokrotności 10 do potęgi minus
   *ndigits*; jeśli dwie wielokrotności są równie bliskie,
   zaokrąglanie jest wykonywane w kierunku parzystego wyboru (więc, na
   przykład, zarówno "round(0.5)" jak i "round(-0.5)" są "0", a
   "round(1.5)" jest "2").  Każda wartość liczby całkowitej jest ważna
   dla *cyfr* (dodatnich, zerowych lub ujemnych).  zwracana wartość
   jest liczba całkowita jeśli *ndigits* jest pominięte lub "None". W
   przeciwnym razie zwracana wartość ma ten sam typ co *number*.

   Dla ogólnego obiektu Python "number" , "round" deleguje do
   "number.__round__".

   Informacja:

     Zachowanie "round()" dla zmiennoprzecinkowych może być
     zaskakujący: na przykład, "round(2.675, 2)" daje "2.67" zamiast
     oczekiwanego "2.68". Nie jest to błąd: wynika to z faktu, że
     większość ułamków dziesiętnych nie może być reprezentowana
     dokładnie jako liczba zmiennoprzecinkowa.  Więcej informacji
     można znaleźć na stronie Arytmetyka liczb zmiennoprzecinkowych:
     problemy i ograniczenia.

class set(iterable=(), /)

   Zwraca nowy obiekt "set", opcjonalnie z elementami pobranymi z
   *iterable*. "set" jest klasą wbudowana.  Dokumentacja dotycząca tej
   klasy znajduje się na stronach "set" i Set Types --- set,
   frozenset.

   Dla innych kontenerów zobacz klasy wbudowane "frozenset" , "list",
   "tuple" i "dict", jak również "collections" moduł .

setattr(object, name, value, /)

   Jest to odpowiednik "getattr()". Argumenty to obiekt, napis i
   dowolna wartość.  Napis może nazywać istniejący atrybut lub nowy
   atrybut.  Funkcja przypisuje wartość do atrybut, pod warunkiem, że
   obiekt na to pozwala.  Na przykład, "setattr(x, 'foobar', 123)"
   jest równoważne "x.foobar = 123".

   *name* nie musi być identyfikatorem Pythona zdefiniowanym w
   Identifiers and keywords, chyba że obiekt zdecyduje się to wymusić,
   na przykład w niestandardowym "__getattribute__()" lub poprzez
   "__slots__". Obiekt atrybut, którego nazwa nie jest
   identyfikatorem, nie będzie dostępny przy użyciu notacji kropkowej,
   ale będzie dostępny za pośrednictwem "getattr()" itd.

   Informacja:

     Ponieważ mangling nazwy prywatnej ma miejsce w czasie kompilacji,
     należy ręcznie zmienić nazwę prywatnego atrybutu (atrybut z dwoma
     wiodącymi podkreśleniami), aby ustawić ją z "setattr()".

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

   Zwraca obiekt *slice* reprezentujący zbiór indeksów określonych
   przez "range(start, stop, step)".  *start* i *step* argumenty
   domyślne do "None".

   Obiekty slice mają dane tylko do odczytu atrybut "start" , "stop" i
   "step", które jedynie zwracać wartości argument (lub ich domyślny).
   Nie mają one żadnej innej wyraźnej funkcjonalności; są jednak
   używane przez NumPy i inne pakiety innych firm.

   start

   stop

   step

   Obiekty Slice są również generowane, gdy używana jest rozszerzona
   składnia indeksowania.  Na przykład: "a[start:stop:step]" lub
   "a[start:stop, i]". Zobacz "itertools.islice()" dla alternatywy,
   która zwraca *iterator*.

   Zmienione w wersji 3.12: Obiekty Slice są teraz *hashable* (pod
   warunkiem, że "start", "stop" i "step" są hashable).

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

   Zwraca nową posortowaną listę z elementów w *iterable*.

   Posiada dwa opcjonalne argumenty, które muszą być określone jako
   argument nazwany.

   *key* określa funkcje jednego argumentu, który jest używany do
   wyodrębnienia klucza porównania z każdego elementu w *iterable* (na
   przykład "key=str.lower").  Wartość domyślna to "None"
   (bezpośrednie porównanie elementów).

   *reverse* jest wartością logiczną.  Jeśli jest ustawiona na "True",
   elementy listy są sortowane tak, jakby każde porównanie było
   odwrócone.

   Użyj "functools.cmp_to_key()" do konwersji starego stylu *cmp*
   funkcja na *key* funkcja.

   Wbudowana "sorted()" funkcja ma gwarancję stabilności. Sortowanie
   jest stabilne, jeśli gwarantuje, że nie zmieni względnej kolejności
   elementów, które porównują równe --- jest to pomocne przy
   sortowaniu w wielu przejściach (na przykład sortowanie według
   działu, a następnie według kategorii wynagrodzenia).

   Algorytm sortowania używa tylko porównań "<" między elementami.
   Podczas gdy zdefiniowanie metoda "__lt__()" wystarczy do
   sortowania, **PEP 8** zaleca zaimplementowanie wszystkich sześciu
   bogatych porównań. Pomoże to uniknąć błędów podczas korzystania z
   tych samych danych z innymi narzędziami porządkującymi, takimi jak
   "max()", które opierają się na innej metodzie bazowej.
   Zaimplementowanie wszystkich sześciu porównań pomaga również
   uniknąć nieporozumień w przypadku porównań typów mieszanych, które
   mogą wywoływać metodę "__gt__()".

   Przykłady sortowania i krótki samouczek sortowania można znaleźć na
   stronie Sorting Techniques.

@staticmethod

   Przekształcenie metody w metodę statyczną.

   Metoda statyczna nie otrzymuje niejawnego pierwszego argumentu. Aby
   zadeklarować metodę statyczną, użyj tego idiomu:

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

   Forma "@staticmethod" to *dekorator* funkcji -- zobacz Function
   definitions po szczegóły.

   Metoda statyczna może być wywołana na klasie (np. "C.f()") lub na
   instancji (np. "C().f()"). Co więcej, metoda statyczna *descriptor*
   jest również wywoływalna, więc może być użyta w definicja klasy
   (np. "f()").

   Metody statyczne w Python są podobne do tych, które można znaleźć w
   Java lub C++. Zobacz także "classmethod()", aby zapoznać się z
   wariantem, który jest przydatny do tworzenia alternatywnych
   konstruktorów klas.

   Podobnie jak wszystkie dekoratory, możliwe jest również wywołanie
   "staticmethod" jako zwykłoł funkcje i zrobienie czegoś z jego
   wynikiem.  Jest to potrzebne w niektórych przypadkach, gdy
   potrzebujesz odniesienia do funkcji z ciałej klasy i chcesz uniknąć
   automatycznej transformacji do metody instancji.  W takich
   przypadkach należy użyć tego idiomu:

      def standardowa_funkcja():
          ...

      class C:
          methoda = staticmethod(standardowa_funkcja)

   Więcej informacji na temat metod statycznych można znaleźć na
   stronie The standard type hierarchy.

   Zmienione w wersji 3.10: Metody statyczne dziedziczą teraz metodę
   atrybut ("__module__", "__name__", "__qualname__", "__doc__" i
   "__annotations__"), mają nową "__wrapped__" atrybut i są teraz
   wywoływane jako zwykła funkcja.

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

   Zwraca "str" wersja of *object*.  Szczegółowe informacje można
   znaleźć na stronie "str()".

   "str" jest wbudowanem napisem *class*.  Aby uzyskać ogólne
   informacje na temat napisow, zobacz Text Sequence Type --- str.

sum(iterable, /, start=0)

   Sumuje *start* i elementy *iterable* od lewej do prawej i zwraca
   sumę.  Elementy *iterable* są zwykle liczbami, a wartością
   początkową nie może być napisem.

   W niektórych przypadkach istnieją dobra alternatywa dla "sum()".
   Preferowanym, szybkim sposobem na łączyć sekwencji napisów jest
   wywołanie "''.join(sequence)".  Aby dodać wartości
   zmiennoprzecinkowe z rozszerzoną precyzją, zobacz "math.fsum()".
   Aby łączyć serię iterable, należy rozważyć użycie
   "itertools.chain()".

   Zmienione w wersji 3.8: Parametr  *start* można określić jako
   argument nazwany.

   Zmienione w wersji 3.12: Sumowanie zmiennoprzecinkowe zostało
   przełączone na algorytm, który zapewnia większą dokładność i lepszą
   przemienność w większości kompilacji.

class super
class super(type, object_or_type=None, /)

   Zwraca obiekt proxy, który deleguje wywołania metod do klasy
   nadrzędnej lub rodzeństwa *type*.  Jest to przydatne do uzyskiwania
   dostępu do odziedziczonych metod, które zostały przesłonięte w
   klasie.

   *object_or_type* określa *method resolution order* do przeszukania.
   Wyszukiwanie rozpoczyna się od klasy zaraz po *type*.

   Na przykład, jeśli "__mro__" z *object_or_type* jest "D -> B -> C
   -> A -> object" i wartość *type* jest "B", to "super()" wyszukuje
   "C -> A -> object".

   "__mro__" atrybut klasy odpowiadającej *object_or_type* wymienia
   kolejność wyszukiwania metod używaną zarówno przez "getattr()" jak
   i "super()".  Adres atrybut jest dynamiczny i może ulec zmianie
   przy każdej aktualizacji hierarchii dziedziczenia.

   Jeśli drugi argument zostanie pominięty, zwrócony superobiekt jest
   niezwiązany.  Jeśli drugi argument jest obiektem, "isinstance(obj,
   type)" musi być prawda.  Jeśli drugi argument jest typem,
   "issubclass(type2, type)" musi być prawda (jest to przydatne dla
   metod klasowych).

   W przypadku wywołania bezpośrednio w zwykłej metodzie klasy, obie
   argument mogą zostać pominięte ("zero-argument "super()" "). W
   takim przypadku *type* będzie klasą otaczającą, a *obj* będzie
   pierwszym argumentem bezpośrednio otaczającego funkcje (zazwyczaj
   "self"). (Oznacza to, że zero-argument "super()" nie będzie działać
   zgodnie z oczekiwaniami wewnątrz zagnieżdżonych funkci, w tym
   wyrażeń generator, które domyślnie tworzą zagnieżdżone funkcje).

   Istnieją dwa typowe przypadki użycia *super*.  W hierarchii klas z
   pojedynczym dziedziczeniem, *super* może być używany do odwoływania
   się do klas nadrzędnych bez ich jawnego nazywania, dzięki czemu kod
   jest łatwiejszy w utrzymaniu.  To zastosowanie jest bardzo podobne
   do użycia *super* w innych językach programowania.

   Drugim przypadkiem użycia jest obsługa kooperatywnego dziedziczenia
   wielokrotnego w dynamicznym środowisku wykonawczym.  Ten przypadek
   użycia jest unikalny dla Python i nie występuje w statycznie
   kompilowanych językach lub językach, które obsługują tylko
   pojedyncze dziedziczenie.  Umożliwia to implementację "diagramów
   diamentowych", w których wiele klas bazowych implementuje tę samą
   metodę.  Dobry projekt nakazuje, aby takie implementacje miały tę
   samą sygnaturę wywołania w każdym przypadku (ponieważ kolejność
   wywołań jest określana w czasie wykonywania, ponieważ kolejność ta
   dostosowuje się do zmian w hierarchii klas i ponieważ kolejność ta
   może obejmować klasy rodzeństwa, które są nieznane przed
   uruchomieniem).

   W obu przypadkach typowe wywołanie superklasy wygląda następująco:

      class C(B):
          def methoda(self, arg):
              super().methoda(arg) # To robi to samo co:
                                     # super(C, self).methoda(arg)

   Oprócz wyszukiwania metod, "super()" działa również dla
   wyszukiwania atrybut.  Jednym z możliwych przypadków użycia jest
   wywołanie *descriptors* w klasie nadrzędnej lub podrzędnej.

   Należy zauważyć, że "super()" jest zaimplementowany jako część
   wiązania przetwarzanie/proces dla jawnego wyszukiwania kropkowego
   atrybut, takiego jak "super().__getitem__(name)". Czyni to poprzez
   implementację własnej metody "__getattribute__()" do wyszukiwania
   klas w przewidywalnej kolejności, która obsługuje wielokrotne
   dziedziczenie oparte na współpracy. Odpowiednio, "super()" jest
   niezdefiniowany dla niejawnych wyszukiwań przy użyciu instrukcja
   lub operatorów takich jak "super()[name]".

   Należy również pamiętać, że poza formą zero argument, "super()" nie
   jest ograniczona do użycia wewnątrz metod.  Dwie formy argumentów
   dokładnie określają argumenty i tworzą odpowiednie odniesienia.
   Forma zero argumentów działa tylko wewnątrz definicja klasy,
   ponieważ kompilator wypełnia niezbędne szczegóły, aby poprawnie
   pobrać definiowaną klasę, a także uzyskać dostęp do bieżącej
   instancji dla zwykłych metod.

   Praktyczne sugestie dotyczące projektowania klas współpracujących
   przy użyciu "super()" można znaleźć w poradniku korzystania z
   super().

class tuple(iterable=(), /)

   Zamiast być funkcja, "tuple" jest w rzeczywistości niezmiennym
   typem sekwencji, jak udokumentowano w Tuples i Sequence Types ---
   list, tuple, range.

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

   Z jednym argumentem, zwraca typ *obiektu*.  Typ zwracanej wartość
   jest obiektem typu i generalnie jest to ten sam obiekt, który
   został zwrócony przez "object.__class__".

   Funckja wbudowana  "isinstance()" jest zalecana do testowania typu
   obiektu, ponieważ uwzględnia podklasa.

   Z trzema argumentamy, zwracać nowy typ obiektu.  Jest to zasadniczo
   dynamiczna forma "class" instrukcja . *name* napis jest nazwą klasy
   i staje się "__name__" atrybut . *bases* krotka zawiera klasy
   bazowe i staje się "__bases__" atrybut ; jeśli jest pusta, dodawana
   jest "object", ostateczna baza wszystkich klas.  The *dict* słownik
   zawiera atrybut i definicje metod dla ciało klasy; może być
   kopiowany lub zawijany zanim stanie się "__dict__" atrybut .
   Następujące dwa instrukcja tworzą identyczne "type" obiekty:

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

   Zobacz także:

   * Dokumentacja atrybutow i metod na klasach.

   * Type Objects

   Argument nazwane dostarczone do trzech formularzy argumenty są
   przekazywane do odpowiedniego mechanizmu metaklas (zwykle
   "__init_subclass__()") w taki sam sposób, jak słowa kluczowe w
   definicja klasy (poza *metaclass*).

   Zobacz także Customizing class creation.

   Zmienione w wersji 3.6: Podklasy z "type", które nie nadpisują
   "type.__new__" nie mogą już używać formy jednego-argumentu do
   uzyskania typu obiektu.

vars()
vars(object, /)

   Zwraca atrybut  "__dict__" dla moduł, klas, instancji lub dowolnego
   innego obiektu z "__dict__" atrybut .

   Obiekty takie jak moduł i instancje mają możliwość aktualizacji
   "__dict__" atrybut; jednak inne obiekty mogą mieć ograniczenia
   zapisu na ich "__dict__" atrybut (na przykład klasy używają
   "types.MappingProxyType", aby zapobiec bezpośrednim aktualizacjom
   słownika).

   Bez argumenta, "vars()" działa jak "locals()".

   Wyjątek "TypeError" jest rzucony, jeśli obiekt jest określony, ale
   nie ma "__dict__" atrybut (na przykład, jeśli jego klasa definiuje
   "__slots__" atrybut ).

   Zmienione w wersji 3.13: Wynik wywołania tej funkcji bez argumentow
   został zaktualizowany zgodnie z opisem dla wbudowanej   "locals()"
   .

zip(*iterables, strict=False)

   Iteruje równolegle po kilku iterables, tworząc krotke z elementem z
   każdej z nich.

   Przykład:

      >>> for item in zip([1, 2, 3], ['cukier', 'przyprawa', 'wszystko fajnie']):
      ... print(item)
      ...
      (1, 'cukier')
      (2, "przyprawa")
      (3, "wszystko fajnie")

   Bardziej formalnie: "zip()" zwraca i iterator z krotka, gdzie
   *i*-ty krotka zawiera *i*-ty element z każdego z argument iterable
   .

   Innym sposobem myślenia o "zip()" jest to, że zamienia wiersze w
   kolumny, a kolumny w wiersze.  Jest to podobne do przekształcania
   macierzy.

   "zip()" jest leniwy: Elementy nie będą przetwarzane, dopóki
   iterable nie zostanie poddany iteracji, np. przez pętlę "for" lub
   przez zawinięcie w "list".

   Jedną rzeczą, którą należy wziąć pod uwagę, jest to, że iterable
   przekazywane do "zip()" mogą mieć różne długości; czasami z
   założenia, a czasami z powodu błędu w kodzie, który przygotował te
   iterable. Python oferuje trzy różne podejścia do radzenia sobie z
   tym problemem:

   * Przez domyślny, "zip()" zatrzymuje się, gdy najkrótszy iterable
     jest wyczerpany. Zignoruje pozostałe elementy w dłuższym
     iterable, obcinając wynik do długości najkrótszego iterable:

        >>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum']))
        [(0, 'fee'), (1, 'fi'), (2, 'fo')]

   * "zip()" jest często używana w przypadkach, gdy zakłada się, że
     iterable są równej długości.  W takich przypadkach zaleca się
     użycie opcji "strict=True". Jej wynik jest taki sam jak zwykłego
     "zip()":

        >>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True))
        [('a', 1), ('b', 2), ('c', 3)]

     W przeciwieństwie do domyślnego zachowania , rzuci  "ValueError",
     jeśli jeden iterable zostanie wyczerpany przed innymi:

     >>> 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 "strict=True" argumentu, każdy błąd, który skutkuje iterable
     o różnych długościach zostanie wyciszony, prawdopodobnie
     objawiając się jako trudny do znalezienia błąd w innej części
     programu.

   * Krótsze iterable mogą być uzupełnione stałą wartością, aby
     wszystkie iterable miały taką samą długość.  Odbywa się to
     poprzez "itertools.zip_longest()".

   Przypadki brzegowe: Z pojedynczym iterable argument, "zip()" zwraca
   iterator z 1-krotka.  Bez argumentu, to zwraca pusty iterator.

   Wskazówki i porady:

   * Kolejność oceny od lewej do prawej strony iterable jest
     gwarantowana. Umożliwia to idiom grupowania serii danych w grupy
     o długości n przy użyciu "zip(*[iter(s)]*n, strict=True)".
     Powtarza to *tę samą* iterator "n" razy, tak że każde wyjście
     krotka ma wynik wywołań "n" do iteratora. Powoduje to podzielenie
     danych wejściowych na fragmenty o długości n.

   * "zip()" w połączeniu z operatorem "*" może być użyty do
     rozpakowania listy:

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

   Zmienione w wersji 3.10: Dodano argument "strict" .

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

   Informacja:

     Jest to zaawansowana funkcja, która nie jest potrzebna w
     codziennym programowaniu Pythona, w przeciwieństwie do
     "importlib.import_module()".

   Ten funkcja jest wywoływany przez "import" instrukcja .  Można go
   zastąpić (importując "builtins" moduł i przypisując do
   "builtins.__import__") w celu zmiany semantyki "import" instrukcja
   , ale jest to **bardżo** odradzane, ponieważ zwykle prostsze jest
   użycie haków importu (zobacz **PEP 302**), aby osiągnąć te same
   cele i nie powoduje problemów z kodem, który zakłada, że
   implementacja importu domyślny jest w użyciu.  Bezpośrednie użycie
   "__import__()" jest również odradzane na korzyść
   "importlib.import_module()".

   Funkcja importuje moduł *name*, potencjalnie używając podanych
   *globals* i *locals* do określenia, jak interpretować nazwę w
   kontekście pakietu. *fromlist* podaje nazwy obiektów lub
   submodułów, które powinny zostać zaimportowane z moduł podanego
   przez *name*.  Standardowa implementacja nie używa *locals*
   argumentu w ogóle i używa *globals* tylko do określenia kontekstu
   pakietu "import" instrukcja .

   *level* określa, czy ma być używany import bezwzględny czy
   względny. "0" (domyślnie) oznacza tylko import bezwzględny.
   Dodatnie wartości dla *level* wskazują liczbę katalogów nadrzędnych
   do przeszukania względem katalogu moduł wywołującego "__import__()"
   (zobacz **PEP 328** dla szczegółów).

   Gdy zmienna *name* ma postać "package.module", zwykle zwracany jest
   pakiet najwyższego poziomu (nazwa do pierwszej kropki), *nie* moduł
   nazwany przez *name*.  Jednakże, gdy podana jest niepusta
   *fromlist* argument, zwracany jest moduł nazwany przez *name*.

   Na przykład, instrukcja "import spam" skutkuje kodem bajtowym
   przypominającym następujący kod:

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

   Instrukcja "import spam.ham" skutkuje następującym połączeniem:

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

   Zauważ, że "__import__()" zwraca toplevel moduł tutaj, ponieważ
   jest to obiekt, który jest powiązany z nazwą przez "import"
   instrukcje .

   Z drugiej strony, instrukcja "from spam.ham import eggs, sausage as
   saus" skutkuje

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

   Tutaj obiekt "spam.ham" jest zwracany z "__import__()".  Z tego
   obiektu pobierane są nazwy do zaimportowania i przypisywane do
   odpowiednich nazw.

   Jeśli chcesz po prostu zaimportować moduł (potencjalnie w ramach
   pakietu) według nazwy, użyj "importlib.import_module()".

   Zmienione w wersji 3.3: Ujemne wartości dla *level* nie są już
   obsługiwane (co również zmienia wartość domyślny na 0).

   Zmienione w wersji 3.9: Gdy używane są opcje wiersza poleceń "-E"
   lub "-I", opcja zmienna środowiskowa "PYTHONCASEOK" jest teraz
   ignorowana.

-[ Przypisy ]-

[1] Zwróć uwagę, że parser akceptuje tylko Unixowy styl końca linii.
    Jeśli wczytujesz kod z pliku, wykorzystaj konwersję linii aby
    przekonwertować style końca linii Winows albo Mac.
