# Вбудовані функції

Інтерпретатор Python має низку функцій і типів, які вбудовані в нього та завжди доступні. Вони перераховані тут в алфавітному порядку.

Вбудовані функції
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()` М `map()` `max()` `memoryview()` `min()` Н `anext()` 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(x)

  Return the absolute value of a number. The argument may be an integer, a floating-point number, or an object implementing `__abs__()`. If the argument is a complex number, its magnitude is returned.

aiter(async_iterable)

  Повертає асинхронний ітератор для asynchronous iterable. Еквівалент виклику `x.__aiter__()`.

  Примітка. На відміну від `iter()`, `aiter()` не має 2х-аргументного варіанту.

  Added in version 3.10.

all(iterable)

  Повертає `True`, якщо всі елементи iterable є істинними (або якщо iterable порожній). Дорівнює:

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

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

  Коли очікується, повертає наступний елемент із заданого asynchronous iterator або default, якщо задано, а ітератор вичерпано.

  Це асинхронний варіант вбудованої функції `next()`, і він поводиться аналогічно.

  Це викликає метод `__anext__()` async_iterator, повертаючи awaitable. Очікування цього повертає наступне значення ітератора. Якщо вказано default, воно повертається, якщо ітератор вичерпано, інакше `StopAsyncIteration` викликається.

  Added in version 3.10.

any(iterable)

  Повертає `True`, якщо будь-який елемент iterable є істинним. Якщо iterable порожній, поверніть `False`. Дорівнює:

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

ascii(object)

  Як `repr()` повертає рядок, що містить представлення об’єкта для друку, але екранує символи, відмінні від ASCII, у рядку, який повертає `repr()`, використовуючи `\x`, `\u` або `\U` екранує. Це генерує рядок, подібний до того, який повертає `repr()` у Python 2.

bin(x)

  Convert an integer number to a binary string prefixed with «0b». The result is a valid Python expression. If x is not a Python `int` object, it has to define an `__index__()` method that returns an integer. Some examples:

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

  Якщо префікс «0b» потрібний чи ні, ви можете скористатися одним із наведених нижче способів.

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

  Дивіться також `format()` для отримання додаткової інформації.

class bool(object=False, /)

  Return a Boolean value, i.e. one of `True` or `False`. The argument is converted using the standard truth testing procedure. If the argument is false or omitted, this returns `False`; otherwise, it returns `True`. The `bool` class is a subclass of `int` (see Числові типи — int, float, complex). It cannot be subclassed further. Its only instances are `False` and `True` (see Boolean Type - bool).

  Змінено в версії 3.7: The parameter is now positional-only.

breakpoint(*args, **kws)

  This function drops you into the debugger at the call site. Specifically, it calls `sys.breakpointhook()`, passing `args` and `kws` straight through. By default, `sys.breakpointhook()` calls `pdb.set_trace()` expecting no arguments. In this case, it is purely a convenience function so you don’t have to explicitly import `pdb` or type as much code to enter the debugger. However, `sys.breakpointhook()` can be set to some other function and `breakpoint()` will automatically call that, allowing you to drop into the debugger of choice. If `sys.breakpointhook()` is not accessible, this function will raise `RuntimeError`.

  By default, the behavior of `breakpoint()` can be changed with the `PYTHONBREAKPOINT` environment variable. See `sys.breakpointhook()` for usage details.

  Note that this is not guaranteed if `sys.breakpointhook()` has been replaced.

  Викликає подію аудиту `builtins.breakpoint` з аргументом `breakpointhook`.

  Added in version 3.7.

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

  Повертає новий масив байтів. Клас `bytearray` — це змінна послідовність цілих чисел у діапазоні 0 <= x < 256. Він містить більшість звичайних методів змінних послідовностей, описаних у Змінні типи послідовностей, а також більшість методи, які має тип `bytes`, див. Операції з байтами та масивом байтів.

  Додатковий параметр source можна використовувати для ініціалізації масиву кількома різними способами:

  - Якщо це рядок, ви також повинні надати параметри encoding (і, необов’язково, errors); Потім `bytearray()` перетворює рядок на байти за допомогою `str.encode()`.

  - Якщо це ціле число, масив матиме такий розмір і буде ініціалізовано нульовими байтами.

  - Якщо це об’єкт, що відповідає інтерфейсу буфера, для ініціалізації масиву байтів буде використано буфер лише для читання об’єкта.

  - Якщо це iterable, це має бути iterable цілих чисел у діапазоні `0 <= x < 256`, які використовуються як початковий вміст масиву.

  Без аргументу створюється масив розміром 0.

  Дивіться також Типи бінарних послідовностей — bytes, bytearray, memoryview і Об’єкти байтового масиву.

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

  Повертає новий об’єкт «bytes», який є незмінною послідовністю цілих чисел у діапазоні «0 <= x < 256». `bytes` є незмінною версією `bytearray` – вона має ті самі методи без мутації та таку саму поведінку індексування та зрізання.

  Відповідно, аргументи конструктора інтерпретуються як для `bytearray()`.

  Об’єкти Bytes також можна створювати за допомогою літералів, див. Рядкові та байтові літерали.

  Дивіться також Типи бінарних послідовностей — bytes, bytearray, memoryview, Об’єкти Bytes і Операції з байтами та масивом байтів.

callable(object)

  Return `True` if the object argument appears callable, `False` if not. If this returns `True`, it is still possible that a call fails, but if it is `False`, calling object will never succeed. Note that classes are callable (calling a class returns a new instance); instances are callable if their class has a `__call__()` method.

  Added in version 3.2: Цю функцію спочатку було видалено в Python 3.0, а потім повернуто в Python 3.2.

chr(i)

  Повертає рядок, що представляє символ, кодовою точкою Unicode якого є ціле число i. Наприклад, `chr(97)` повертає рядок `'a''`, а `chr(8364)` повертає рядок `'€'`. Це зворотне до `ord()`.

  Допустимий діапазон для аргументу – від 0 до 1 114 111 (0x10FFFF за основою 16). `ValueError` буде викликано, якщо i знаходиться за межами цього діапазону.

@classmethod

  Перетворення методу в метод класу.

  Метод класу отримує клас як неявний перший аргумент, так само як метод екземпляра отримує екземпляр. Щоб оголосити метод класу, використовуйте цю ідіому:

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

  Форма `@classmethod` є функцією decorator – подробиці див. Визначення функцій.

  Метод класу можна викликати або в класі (наприклад, `C.f()`), або в екземплярі (такому як `C().f()`). Примірник ігнорується, за винятком його класу. Якщо метод класу викликається для похідного класу, об’єкт похідного класу передається як неявний перший аргумент.

  Методи класу відрізняються від статичних методів C++ або Java. Якщо ви хочете їх, перегляньте `staticmethod()` у цьому розділі. Для отримання додаткової інформації про методи класу див. Стандартна ієрархія типів.

  Змінено в версії 3.9: Методи класу тепер можуть обгортати інші дескриптори, такі як `property()`.

  Змінено в версії 3.10: Class methods now inherit the method attributes (`__module__`, `__name__`, `__qualname__`, `__doc__` and `__annotations__`) and have a new `__wrapped__` attribute.

  Deprecated since version 3.11, removed in version 3.13: Class methods can no longer wrap other descriptors such as `property()`.

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

  Скомпілюйте джерело в код або об’єкт AST. Об’єкти коду можуть бути виконані за допомогою `exec()` або `eval()`. джерело може бути звичайним рядком, рядком байтів або об’єктом AST. Зверніться до документації модуля `ast`, щоб дізнатися, як працювати з об’єктами AST.

  Аргумент ім’я_файлу повинен давати файл, з якого було прочитано код; передати певне розпізнаване значення, якщо воно не було прочитано з файлу (зазвичай використовується `' <string>'`).

  Аргумент mode визначає тип коду, який потрібно скомпілювати; це може бути `'exec'`, якщо source складається з послідовності операторів, `'eval'`, якщо воно складається з одного виразу, або `'single'`, якщо воно складається з одного інтерактивний оператор (в останньому випадку оператори-вирази, які мають значення, відмінне від `None`, будуть надруковані).

  Необов’язкові аргументи flags і dont_inherit визначають, які параметри компілятора мають бути активовані та які майбутні функції мають бути дозволені. Якщо жоден не присутній (або обидва дорівнюють нулю), код компілюється з тими самими прапорцями, які впливають на код, який викликає `compile()`. Якщо надано аргумент flags, а dont_inherit — ні (або дорівнює нулю), то параметри компілятора та майбутні оператори, визначені аргументом flags, використовуються на додаток до тих, які були б використані в будь-якому випадку. Якщо dont_inherit є ненульовим цілим числом, то це аргумент flags — прапори (майбутні функції та параметри компілятора) у навколишньому коді ігноруються.

  Параметри компілятора та майбутні оператори визначаються бітами, які можна об’єднати порозрядним АБО, щоб визначити кілька параметрів. Бітове поле, необхідне для вказівки певної майбутньої функції, можна знайти як атрибут `compiler_flag` екземпляра `_Feature` у модулі `__future__`. Прапори компілятора можна знайти в `ast` модулі з префіксом `PyCF_`.

  Аргумент optimize визначає рівень оптимізації компілятора; значення за замовчуванням `-1` вибирає рівень оптимізації інтерпретатора, як задано параметрами `-O`. Явні рівні: `0` (немає оптимізації; `__debug__` є істинним), `1` (затвердження видалено, `__debug__` є хибним) або `2` (рядки документа також видалено ).

  Ця функція викликає `SyntaxError`, якщо скомпільоване джерело недійсне, і `ValueError`, якщо джерело містить нульові байти.

  Якщо ви хочете розібрати код Python у його представлення AST, перегляньте `ast.parse()`.

  Викликає подію аудиту `компіляція` з аргументами `джерело` та `назва файлу`. Ця подія також може бути викликана неявною компіляцією.

  Примітка

  Під час компіляції рядка з багаторядковим кодом у режимі `'single'` або `'eval'` вхідні дані мають завершуватися принаймні одним символом нового рядка. Це робиться для полегшення виявлення неповних і повних операторів у модулі `code`.

  Попередження

  Можливий збій інтерпретатора Python із досить великим/складним рядком під час компіляції в об’єкт AST через обмеження глибини стеку в компіляторі AST Python.

  Змінено в версії 3.2: Дозволено використання нових рядків у Windows і Mac. Крім того, введення в режимі `'exec''` більше не повинно закінчуватися символом нового рядка. Додано параметр optimize.

  Змінено в версії 3.5: Раніше `TypeError` виникало, коли в source зустрічалися нульові байти.

  Added in version 3.8: `ast.PyCF_ALLOW_TOP_LEVEL_AWAIT` тепер можна передавати у прапорах, щоб увімкнути підтримку верхнього рівня `await`, `async for` і `async with`.

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

  Convert a single string or number to a complex number, or create a complex number from real and imaginary parts.

  приклади:

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

  If the argument is a string, it must contain either a real part (in the same format as for `float()`) or an imaginary part (in the same format but with a `'j'` or `'J'` suffix), or both real and imaginary parts (the sign of the imaginary part is mandatory in this case). The string can optionally be surrounded by whitespaces and the round parentheses `'('` and `')'`, which are ignored. The string must not contain whitespace between `'+'`, `'-'`, the `'j'` or `'J'` suffix, and the decimal number. For example, `complex('1+2j')` is fine, but `complex('1 + 2j')` raises `ValueError`. More precisely, the input must conform to the `complexvalue` production rule in the following grammar, after parentheses and leading and trailing whitespace characters are removed:

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

  If the argument is a number, the constructor serves as a numeric conversion like `int` and `float`. For a general Python object `x`, `complex(x)` delegates to `x.__complex__()`. If `__complex__()` is not defined then it falls back to `__float__()`. If `__float__()` is not defined then it falls back to `__index__()`.

  If two arguments are provided or keyword arguments are used, each argument may be any numeric type (including complex). If both arguments are real numbers, return a complex number with the real component real and the imaginary component imag. If both arguments are complex numbers, return a complex number with the real component `real.real-imag.imag` and the imaginary component `real.imag+imag.real`. If one of arguments is a real number, only its real component is used in the above expressions.

  See also `complex.from_number()` which only accepts a single numeric argument.

  If all arguments are omitted, returns `0j`.

  Складний тип описано в Числові типи — int, float, complex.

  Змінено в версії 3.6: Допускається групування цифр із підкресленням, як у кодових літералах.

  Змінено в версії 3.8: Falls back to `__index__()` if `__complex__()` and `__float__()` are not defined.

  Застаріло починаючи з версії 3.14: Passing a complex number as the real or imag argument is now deprecated; it should only be passed as a single positional argument.

delattr(object, name)

  This is a relative of `setattr()`. The arguments are an object and a string. The string must be the name of one of the object’s attributes. The function deletes the named attribute, provided the object allows it. For example, `delattr(x, 'foobar')` is equivalent to `del x.foobar`. name need not be a Python identifier (see `setattr()`).

class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)

  Створіть новий словник. Об’єкт `dict` є класом словника. Перегляньте `dict` і Типи зіставлення — dict для документації про цей клас.

  Для інших контейнерів перегляньте вбудовані класи `list`, `set` і `tuple`, а також модуль `collections`.

dir()
dir(object)

  Без аргументів повертає список імен у поточній локальній області. За допомогою аргументу спробуйте повернути список дійсних атрибутів для цього об’єкта.

  If the object has a method named `__dir__()`, this method will be called and must return the list of attributes. This allows objects that implement a custom `__getattr__()` or `__getattribute__()` function to customize the way `dir()` reports their attributes.

  If the object does not provide `__dir__()`, the function tries its best to gather information from the object’s `__dict__` attribute, if defined, and from its type object. The resulting list is not necessarily complete and may be inaccurate when the object has a custom `__getattr__()`.

  Механізм за замовчуванням `dir()` поводиться по-різному з різними типами об’єктів, оскільки він намагається створити найбільш релевантну, а не повну інформацію:

  - Якщо об’єкт є об’єктом модуля, список містить назви атрибутів модуля.

  - Якщо об’єкт є об’єктом типу або класу, список містить імена його атрибутів і рекурсивно атрибутів його баз.

  - В іншому випадку список містить назви атрибутів об’єкта, назви атрибутів його класу та рекурсивно атрибутів базових класів його класу.

  Отриманий список відсортовано за алфавітом. Наприклад:

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

  Примітка

  Оскільки `dir()` надається насамперед для зручності використання в інтерактивному запиті, він намагається надати цікавий набір імен більше, ніж намагається надати чітко або послідовно визначений набір імен, і його детальна поведінка може змінитися через випуски. Наприклад, атрибути метакласу відсутні в списку результатів, якщо аргументом є клас.

divmod(a, b)

  Take two (non-complex) numbers as arguments and return a pair of numbers consisting of their quotient and remainder when using integer division. With mixed operand types, the rules for binary arithmetic operators apply. For integers, the result is the same as `(a // b, a % b)`. For floating-point numbers the result is `(q, a % b)`, where q is usually `math.floor(a / b)` but may be 1 less than that. In any case `q * b + a % b` is very close to a, if `a % b` is non-zero it has the same sign as b, and `0 <= abs(a % b) < abs(b)`.

enumerate(iterable, start=0)

  Повертає об’єкт перерахування. iterable має бути послідовністю, iterator або іншим об’єктом, який підтримує ітерацію. Метод `__next__()` ітератора, який повертає `enumerate()`, повертає кортеж, що містить лічильник (від start, який за замовчуванням дорівнює 0) і значення, отримані в результаті ітерації над 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')]

  Дорівнює:

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

eval(source, /, globals=None, locals=None)
  Параметри:

    - source (`str` | code object) – A Python expression.

    - globals (`dict` | `None`) – The global namespace (default: `None`).

    - locals (mapping | `None`) – The local namespace (default: `None`).

  Повертає:

    The result of the evaluated expression.

  Raises:

    Syntax errors are reported as exceptions.

  The expression argument is parsed and evaluated as a Python expression (technically speaking, a condition list) using the globals and locals mappings as global and local namespace. If the globals dictionary is present and does not contain a value for the key `__builtins__`, a reference to the dictionary of the built-in module `builtins` is inserted under that key before expression is parsed. That way you can control what builtins are available to the executed code by inserting your own `__builtins__` dictionary into globals before passing it to `eval()`. If the locals mapping is omitted it defaults to the globals dictionary. If both mappings are omitted, the expression is executed with the globals and locals in the environment where `eval()` is called. Note, eval() will only have access to the nested scopes (non-locals) in the enclosing environment if they are already referenced in the scope that is calling `eval()` (e.g. via a `nonlocal` statement).

  приклад:

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

  Ця функція також може бути використана для виконання довільних об’єктів коду (наприклад, створених `compile()`). У цьому випадку передавайте об’єкт коду замість рядка. Якщо об’єкт коду було скомпільовано з `'exec'` як аргументом mode, значення, що повертається `eval()`, буде `None`.

  Підказки: динамічне виконання операторів підтримується функцією `exec()`. Функції `globals()` і `locals()` повертають поточний глобальний і локальний словники відповідно, які можуть бути корисними передати для використання `eval()` або `exec()`.

  Якщо дане джерело є рядком, то пробіли та табуляції на початку та в кінці видаляються.

  Перегляньте `ast.literal_eval()` для функції, яка може безпечно обчислювати рядки з виразами, що містять лише літерали.

  Викликає подію аудиту `exec` з об’єктом коду як аргументом. Також можуть виникати події компіляції коду.

  Змінено в версії 3.13: The globals and locals arguments can now be passed as keywords.

  Змінено в версії 3.13: The semantics of the default locals namespace have been adjusted as described for the `locals()` builtin.

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

  This function supports dynamic execution of Python code. source must be either a string or a code object. If it is a string, the string is parsed as a suite of Python statements which is then executed (unless a syntax error occurs). [1] If it is a code object, it is simply executed. In all cases, the code that’s executed is expected to be valid as file input (see the section Введення файлу in the Reference Manual). Be aware that the `nonlocal`, `yield`, and `return` statements may not be used outside of function definitions even within the context of code passed to the `exec()` function. The return value is `None`.

  In all cases, if the optional parts are omitted, the code is executed in the current scope. If only globals is provided, it must be a dictionary (and not a subclass of dictionary), which will be used for both the global and the local variables. If globals and locals are given, they are used for the global and local variables, respectively. If provided, locals can be any mapping object. Remember that at the module level, globals and locals are the same dictionary.

  Примітка

  When `exec` gets two separate objects as globals and locals, the code will be executed as if it were embedded in a class definition. This means functions and classes defined in the executed code will not be able to access variables assigned at the top level (as the «top level» variables are treated as class variables in a class definition).

  Якщо словник globals не містить значення для ключа `__builtins__`, під цим ключем вставляється посилання на словник вбудованого модуля `builtins`. Таким чином ви можете контролювати, які вбудовані елементи доступні для виконуваного коду, вставивши свій власний словник `__builtins__` у globals перед передачею його в `exec()`.

  The closure argument specifies a closure–a tuple of cellvars. It’s only valid when the object is a code object containing free (closure) variables. The length of the tuple must exactly match the length of the code object’s `co_freevars` attribute.

  Викликає подію аудиту `exec` з об’єктом коду як аргументом. Також можуть виникати події компіляції коду.

  Примітка

  The built-in functions `globals()` and `locals()` return the current global and local namespace, respectively, which may be useful to pass around for use as the second and third argument to `exec()`.

  Примітка

  The default locals act as described for function `locals()` below. Pass an explicit locals dictionary if you need to see effects of the code on locals after function `exec()` returns.

  Змінено в версії 3.11: Added the closure parameter.

  Змінено в версії 3.13: The globals and locals arguments can now be passed as keywords.

  Змінено в версії 3.13: The semantics of the default locals namespace have been adjusted as described for the `locals()` builtin.

filter(function, iterable)

  Construct an iterator from those elements of iterable for which function is true. iterable may be either a sequence, a container which supports iteration, or an iterator. If function is `None`, the identity function is assumed, that is, all elements of iterable that are false are removed.

  Зауважте, що `filter(function, iterable)` еквівалентний виразу генератора `(item for item в iterable if function(item))`, якщо функція не є `None` і `(item for item в iterable if item)` якщо функція `None`.

  See `itertools.filterfalse()` for the complementary function that returns elements of iterable for which function is false.

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

  Return a floating-point number constructed from a number or a string.

  приклади:

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

  If the argument is a string, it should contain a decimal number, optionally preceded by a sign, and optionally embedded in whitespace. The optional sign may be `'+'` or `'-'`; a `'+'` sign has no effect on the value produced. The argument may also be a string representing a NaN (not-a-number), or positive or negative infinity. More precisely, the input must conform to the `floatvalue` production rule in the following grammar, after leading and trailing whitespace characters are removed:

      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

  Case is not significant, so, for example, «inf», «Inf», «INFINITY», and «iNfINity» are all acceptable spellings for positive infinity.

  Otherwise, if the argument is an integer or a floating-point number, a floating-point number with the same value (within Python’s floating-point precision) is returned. If the argument is outside the range of a Python float, an `OverflowError` will be raised.

  For a general Python object `x`, `float(x)` delegates to `x.__float__()`. If `__float__()` is not defined then it falls back to `__index__()`.

  See also `float.from_number()` which only accepts a numeric argument.

  Якщо аргумент не вказано, повертається `0.0`.

  Тип float описано в Числові типи — int, float, complex.

  Змінено в версії 3.6: Допускається групування цифр із підкресленням, як у кодових літералах.

  Змінено в версії 3.7: The parameter is now positional-only.

  Змінено в версії 3.8: Falls back to `__index__()` if `__float__()` is not defined.

format(value, format_spec='')

  Перетворення значення на «форматований» представлення, як керується format_spec. Інтерпретація format_spec залежатиме від типу аргументу value; проте існує стандартний синтаксис форматування, який використовується більшістю вбудованих типів: Міні-мова специфікації формату.

  За замовчуванням format_spec є порожнім рядком, який зазвичай дає той самий ефект, що й виклик `str(value)`.

  A call to `format(value, format_spec)` is translated to `type(value).__format__(value, format_spec)` which bypasses the instance dictionary when searching for the value’s `__format__()` method. A `TypeError` exception is raised if the method search reaches `object` and the format_spec is non-empty, or if either the format_spec or the return value are not strings.

  Змінено в версії 3.4: `object().__format__(format_spec)` викликає `TypeError`, якщо format_spec не є порожнім рядком.

class frozenset(iterable=set())

  Повертає новий об’єкт `frozenset`, необов’язково з елементами, взятими з iterable. `frozenset` є вбудованим класом. Перегляньте `frozenset` і Типи наборів — set, frozenset для документації про цей клас.

  Для інших контейнерів перегляньте вбудовані класи `set`, `list`, `tuple` і `dict`, а також модуль `collections`.

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

  Return the value of the named attribute of object. name must be a string. If the string is the name of one of the object’s attributes, the result is the value of that attribute. For example, `getattr(x, 'foobar')` is equivalent to `x.foobar`. If the named attribute does not exist, default is returned if provided, otherwise `AttributeError` is raised. name need not be a Python identifier (see `setattr()`).

  Примітка

  Оскільки викривлення приватного імені відбувається під час компіляції, потрібно вручну спотворити ім’я приватного атрибута (атрибути з двома символами підкреслення на початку), щоб отримати його за допомогою `getattr()`.

globals()

  Повертає словник, що реалізує поточний простір імен модуля. Для коду всередині функцій це значення встановлюється під час визначення функції та залишається незмінним незалежно від місця виклику функції.

hasattr(object, name)

  Аргументами є об’єкт і рядок. Результатом є `True`, якщо рядок є назвою одного з атрибутів об’єкта, `False`, якщо ні. (Це реалізується шляхом виклику `getattr(object, name)` і перевірки, чи викликає це `AttributeError` чи ні.)

hash(object)

  Повертає хеш-значення об’єкта (якщо воно є). Хеш-значення є цілими числами. Вони використовуються для швидкого порівняння ключів словника під час пошуку в словнику. Числові значення, які порівнюються, мають однакове хеш-значення (навіть якщо вони мають різні типи, як у випадку 1 і 1.0).

  Примітка

  For objects with custom `__hash__()` methods, note that `hash()` truncates the return value based on the bit width of the host machine.

help()
help(request)

  Виклик вбудованої довідкової системи. (Ця функція призначена для інтерактивного використання.) Якщо аргумент не задано, інтерактивна довідкова система запускається на консолі інтерпретатора. Якщо аргументом є рядок, то цей рядок шукається як ім’я модуля, функції, класу, методу, ключового слова чи розділу документації, а на консолі друкується довідкова сторінка. Якщо аргументом є об’єкт будь-якого іншого типу, для цього об’єкта буде створено сторінку довідки.

  Зауважте, що якщо скісна риска (/) з’являється у списку параметрів функції під час виклику `help()`, це означає, що параметри перед скісною рискою є лише позиційними. Для отримання додаткової інформації див. запис у поширених питаннях щодо позиційних параметрів.

  Ця функція додається до вбудованого простору імен модулем `site`.

  Змінено в версії 3.4: Зміни в `pydoc` і `inspect` означають, що звітні підписи для викликів тепер більш повні та узгоджені.

hex(x)

  Convert an integer number to a lowercase hexadecimal string prefixed with «0x». If x is not a Python `int` object, it has to define an `__index__()` method that returns an integer. Some examples:

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

  Якщо ви хочете перетворити ціле число у верхній або нижній шістнадцятковий рядок із префіксом або без нього, ви можете скористатися одним із наведених нижче способів:

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

  Дивіться також `format()` для отримання додаткової інформації.

  Дивіться також `int()` для перетворення шістнадцяткового рядка в ціле число за основою 16.

  Примітка

  Щоб отримати шістнадцяткове представлення рядка для float, використовуйте метод `float.hex()`.

id(object)

  Повернути «ідентичність» об’єкта. Це ціле число, яке гарантовано буде унікальним і постійним для цього об’єкта протягом усього його існування. Два об’єкти з що існують у різні проміжки часу можуть мати однакові значення `id()`.

  Деталі реалізації CPython: This is the address of the object in memory.

  Викликає подію аудиту `builtins.id` з аргументом `id`.

input()
input(prompt)

  Якщо присутній аргумент prompt, він записується в стандартний вивід без символу нового рядка. Потім функція зчитує рядок із вхідних даних, перетворює його на рядок (вилучаючи кінцевий новий рядок) і повертає його. Під час читання EOF виникає `EOFError`. Приклад:

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

  Якщо модуль `readline` було завантажено, то `input()` використовуватиме його для забезпечення складних функцій редагування рядка та історії.

  Викликає подію аудиту `builtins.input` з аргументом `prompt` перед читанням введення

  Викликає подію аудиту `builtins.input/result` з результатом після успішного читання введення.

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

  Return an integer object constructed from a number or a string, or return `0` if no arguments are given.

  приклади:

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

  If the argument defines `__int__()`, `int(x)` returns `x.__int__()`. If the argument defines `__index__()`, it returns `x.__index__()`. For floating-point numbers, this truncates towards zero.

  If the argument is not a number or if base is given, then it must be a string, `bytes`, or `bytearray` instance representing an integer in radix base. Optionally, the string can be preceded by `+` or `-` (with no space in between), have leading zeros, be surrounded by whitespace, and have single underscores interspersed between digits.

  A base-n integer string contains digits, each representing a value from 0 to n-1. The values 0–9 can be represented by any Unicode decimal digit. The values 10–35 can be represented by `a` to `z` (or `A` to `Z`). The default base is 10. The allowed bases are 0 and 2–36. Base-2, -8, and -16 strings can be optionally prefixed with `0b`/`0B`, `0o`/`0O`, or `0x`/`0X`, as with integer literals in code. For base 0, the string is interpreted in a similar way to an integer literal in code, in that the actual base is 2, 8, 10, or 16 as determined by the prefix. Base 0 also disallows leading zeros: `int('010', 0)` is not legal, while `int('010')` and `int('010', 8)` are.

  Цілочисельний тип описано в Числові типи — int, float, complex.

  Змінено в версії 3.4: Якщо base не є екземпляром `int` і об’єкт base має метод `base.__index__`, цей метод викликається для отримання цілого числа для бази. У попередніх версіях використовувався `base.__int__` замість `base.__index__`.

  Змінено в версії 3.6: Допускається групування цифр із підкресленням, як у кодових літералах.

  Змінено в версії 3.7: The first parameter is now positional-only.

  Змінено в версії 3.8: Falls back to `__index__()` if `__int__()` is not defined.

  Змінено в версії 3.11: `int` string inputs and string representations can be limited to help avoid denial of service attacks. A `ValueError` is raised when the limit is exceeded while converting a string to an `int` or when converting an `int` into a string would exceed the limit. See the integer string conversion length limitation documentation.

  Змінено в версії 3.14: `int()` no longer delegates to the `__trunc__()` method.

isinstance(object, classinfo)

  Return `True` if the object argument is an instance of the classinfo argument, or of a (direct, indirect, or virtual) subclass thereof. If object is not an object of the given type, the function always returns `False`. If classinfo is a tuple of type objects (or recursively, other such tuples) or a Тип союзу of multiple types, return `True` if object is an instance of any of the types. If classinfo is not a type or tuple of types and such tuples, a `TypeError` exception is raised. `TypeError` may not be raised for an invalid type if an earlier check succeeds.

  Змінено в версії 3.10: classinfo може бути Тип союзу.

issubclass(class, classinfo)

  Повертає `True`, якщо class є підкласом (прямим, непрямим або віртуальним) classinfo. Клас вважається підкласом самого себе. classinfo може бути кортежем об’єктів класу (або рекурсивно іншими подібними кортежами) або Тип союзу, у цьому випадку повертає `True`, якщо class є підкласом будь-якого запису в інформація про клас. У будь-якому іншому випадку виникає виняток `TypeError`.

  Змінено в версії 3.10: classinfo може бути Тип союзу.

iter(object)
iter(object, sentinel)

  Return an iterator object. The first argument is interpreted very differently depending on the presence of the second argument. Without a second argument, object must be a collection object which supports the iterable protocol (the `__iter__()` method), or it must support the sequence protocol (the `__getitem__()` method with integer arguments starting at `0`). If it does not support either of those protocols, `TypeError` is raised. If the second argument, sentinel, is given, then object must be a callable object. The iterator created in this case will call object with no arguments for each call to its `__next__()` method; if the value returned is equal to sentinel, `StopIteration` will be raised, otherwise the value will be returned.

  Дивіться також Типи ітераторів.

  Одним із корисних застосувань другої форми `iter()` є створення програми для читання блоків. Наприклад, читання блоків фіксованої ширини з бінарного файлу бази даних до досягнення кінця файлу:

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

len(s)

  Повертає довжину (кількість елементів) об’єкта. Аргументом може бути послідовність (наприклад, рядок, байти, кортеж, список або діапазон) або колекція (наприклад, словник, набір або заморожений набір).

  Деталі реалізації CPython: `len` викликає `OverflowError` для довжин, більших за `sys.maxsize`, наприклад `range(2 ** 100)`.

class list
class list(iterable)

  Замість того, щоб бути функцією, `list` насправді є змінним типом послідовності, як описано в списки і Типи послідовностей — list, tuple, range.

locals()

  > Return a mapping object representing the current local symbol table, with variable names as the keys, and their currently bound references as the values.

  > At module scope, as well as when using `exec()` or `eval()` with a single namespace, this function returns the same namespace as `globals()`.

  > At class scope, it returns the namespace that will be passed to the metaclass constructor.

  > When using `exec()` or `eval()` with separate local and global arguments, it returns the local namespace passed in to the function call.

  > In all of the above cases, each call to `locals()` in a given frame of execution will return the same mapping object. Changes made through the mapping object returned from `locals()` will be visible as assigned, reassigned, or deleted local variables, and assigning, reassigning, or deleting local variables will immediately affect the contents of the returned mapping object.

  > In an optimized scope (including functions, generators, and coroutines), each call to `locals()` instead returns a fresh dictionary containing the current bindings of the function’s local variables and any nonlocal cell references. In this case, name binding changes made via the returned dict are not written back to the corresponding local variables or nonlocal cell references, and assigning, reassigning, or deleting local variables and nonlocal cell references does not affect the contents of previously returned dictionaries.

  > Calling `locals()` as part of a comprehension in a function, generator, or coroutine is equivalent to calling it in the containing scope, except that the comprehension’s initialised iteration variables will be included. In other scopes, it behaves as if the comprehension were running as a nested function.

  > Calling `locals()` as part of a generator expression is equivalent to calling it in a nested generator function.

  Змінено в версії 3.12: The behaviour of `locals()` in a comprehension has been updated as described in PEP 709.

  Змінено в версії 3.13: As part of PEP 667, the semantics of mutating the mapping objects returned from this function are now defined. The behavior in optimized scopes is now as described above. Aside from being defined, the behaviour in other scopes remains unchanged from previous versions.

map(function, iterable, *iterables)

  Return an iterator that applies function to every item of iterable, yielding the results. If additional iterables arguments are passed, function must take that many arguments and is applied to the items from all iterables in parallel. With multiple iterables, the iterator stops when the shortest iterable is exhausted. For cases where the function inputs are already arranged into argument tuples, see `itertools.starmap()`.

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

  Повертає найбільший елемент у ітерації або найбільший з двох чи більше аргументів.

  Якщо надається один позиційний аргумент, це має бути iterable. Повертається найбільший елемент ітерації. Якщо надано два або більше позиційних аргументів, повертається найбільший із позиційних аргументів.

  Є два необов’язкові аргументи лише для ключових слів. Аргумент key визначає функцію впорядкування з одним аргументом, подібну до тієї, яка використовується для `list.sort()`. Аргумент default визначає об’єкт, який повертається, якщо наданий ітераційний елемент порожній. Якщо iterable порожній і default не вказано, виникає `ValueError`.

  Якщо кілька елементів є максимальними, функція повертає перший знайдений. Це узгоджується з іншими інструментами збереження стабільності сортування, такими як `sorted(iterable, key=keyfunc, reverse=True)[0]` і `heapq.nlargest(1, iterable, key=keyfunc)`.

  Змінено в версії 3.4: Added the default keyword-only parameter.

  Змінено в версії 3.8: Ключ може бути `None`.

class memoryview(object)

  Повертає об’єкт «перегляд пам’яті», створений із заданого аргументу. Перегляньте Перегляди пам’яті для отримання додаткової інформації.

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

  Повертає найменший елемент у ітерації або найменший з двох чи більше аргументів.

  Якщо надається один позиційний аргумент, це має бути iterable. Повертається найменший елемент ітерації. Якщо надано два або більше позиційних аргументів, повертається найменший із позиційних аргументів.

  Є два необов’язкові аргументи лише для ключових слів. Аргумент key визначає функцію впорядкування з одним аргументом, подібну до тієї, яка використовується для `list.sort()`. Аргумент default визначає об’єкт, який повертається, якщо наданий ітераційний елемент порожній. Якщо iterable порожній і default не вказано, виникає `ValueError`.

  Якщо декілька елементів є мінімальними, функція повертає перший знайдений. Це узгоджується з іншими інструментами збереження стабільності сортування, такими як `sorted(iterable, key=keyfunc)[0]` і `heapq.nsmallest(1, iterable, key=keyfunc)`.

  Змінено в версії 3.4: Added the default keyword-only parameter.

  Змінено в версії 3.8: Ключ може бути `None`.

next(iterator)
next(iterator, default)

  Отримайте наступний елемент із iterator, викликавши його метод `__next__()`. Якщо задано default, воно повертається, якщо ітератор вичерпано, інакше `StopIteration` викликається.

class object

  Повернути новий безособливий об’єкт. `object` є основою для всіх класів. Він має методи, які є спільними для всіх екземплярів класів Python. Ця функція не приймає жодних аргументів.

  Примітка

  `object` instances do not have `__dict__` attributes, so you can’t assign arbitrary attributes to an instance of `object`.

oct(x)

  Convert an integer number to an octal string prefixed with «0o». The result is a valid Python expression. If x is not a Python `int` object, it has to define an `__index__()` method that returns an integer. For example:

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

  Якщо ви хочете перетворити ціле число на вісімковий рядок із префіксом «0o» чи ні, ви можете скористатися одним із наведених нижче способів.

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

  Дивіться також `format()` для отримання додаткової інформації.

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

  Відкрийте файл і поверніть відповідний file object. Якщо файл неможливо відкрити, виникає `OSError`. Перегляньте Читання та запис файлів для отримання додаткових прикладів використання цієї функції.

  file — це path-like object, що надає шлях (абсолютний або відносний до поточного робочого каталогу) до файлу, який потрібно відкрити, або цілочисельний файловий дескриптор файлу, який потрібно обернути. (Якщо задано дескриптор файлу, він закривається, коли повертається об’єкт вводу/виводу, якщо closefd не має значення `False`.)

  mode is an optional string that specifies the mode in which the file is opened. It defaults to `'r'` which means open for reading in text mode. Other common values are `'w'` for writing (truncating the file if it already exists), `'x'` for exclusive creation, and `'a'` for appending (which on some Unix systems, means that all writes append to the end of the file regardless of the current seek position). In text mode, if encoding is not specified the encoding used is platform-dependent: `locale.getencoding()` is called to get the current locale encoding. (For reading and writing raw bytes use binary mode and leave encoding unspecified.) The available modes are:

  характер | Значення
  --- | ---
  `'r''` | відкритий для читання (за замовчуванням)
  `'w'` | відкрити для запису, спочатку скоротивши файл
  `'x''` | відкрити для ексклюзивного створення, якщо файл уже існує
  `'a'` | відкрито для запису, додаючи в кінець файлу, якщо він існує
  `'b''` | двійковий режим
  `'t''` | текстовий режим (за замовчуванням)
  `'+'` | відкритий для оновлення (читання та запис)

  Типовим режимом є `'r'` (відкритий для читання тексту, синонім `'rt'`). Режими `'w+'` і `'w+b'` відкривають і скорочують файл. Режими `'r+'` і `'r+b'` відкривають файл без скорочення.

  Як згадувалося в Огляд, Python розрізняє двійковий і текстовий ввід-вивід. Файли, відкриті в двійковому режимі (включаючи `'b'` в аргументі mode) повертають вміст як об’єкти `bytes` без будь-якого декодування. У текстовому режимі (за замовчуванням або коли `'t'` включено в аргумент mode) вміст файлу повертається як `str`, байти, які спочатку були декодовані за допомогою платформи -залежне кодування або використання зазначеного кодування, якщо воно вказано.

  Примітка

  Python не залежить від поняття текстових файлів базової операційної системи; вся обробка виконується самим Python, і тому вона не залежить від платформи.

  buffering is an optional integer used to set the buffering policy. Pass 0 to switch buffering off (only allowed in binary mode), 1 to select line buffering (only usable when writing in text mode), and an integer > 1 to indicate the size in bytes of a fixed-size chunk buffer. Note that specifying a buffer size this way applies for binary buffered I/O, but `TextIOWrapper` (i.e., files opened with `mode='r+'`) would have another buffering. To disable buffering in `TextIOWrapper`, consider using the `write_through` flag for `io.TextIOWrapper.reconfigure()`. When no buffering argument is given, the default buffering policy works as follows:

  - Binary files are buffered in fixed-size chunks; the size of the buffer is chosen using a heuristic trying to determine the underlying device’s «block size» and falling back on `io.DEFAULT_BUFFER_SIZE`. On many systems, the buffer will typically be 4096 or 8192 bytes long.

  - «Інтерактивні» текстові файли (файли, для яких `isatty()` повертає `True`) використовують буферизацію рядка. Інші текстові файли використовують політику, описану вище для двійкових файлів.

  encoding is the name of the encoding used to decode or encode the file. This should only be used in text mode. The default encoding is platform dependent (whatever `locale.getencoding()` returns), but any text encoding supported by Python can be used. See the `codecs` module for the list of supported encodings.

  errors — це необов’язковий рядок, який визначає, як мають оброблятися помилки кодування та декодування — це не можна використовувати в двійковому режимі. Доступні різноманітні стандартні обробники помилок (перераховані в Обробники помилок), хоча будь-яка назва обробки помилок, зареєстрована в `codecs.register_error()`, також дійсна. Стандартні назви включають:

  - `'strict'`, щоб викликати виключення `ValueError`, якщо є помилка кодування. Значення за замовчуванням «Немає» має той самий ефект.

  - `'ignore''` ігнорує помилки. Зауважте, що ігнорування помилок кодування може призвести до втрати даних.

  - `'replace'` вставляє маркер заміни (наприклад, `'?'`), де є неправильно сформовані дані.

  - `'surrogateescape'` представлятиме будь-які неправильні байти як одиниці нижнього сурогатного коду в діапазоні від U+DC80 до U+DCFF. Ці одиниці сурогатного коду потім будуть перетворені назад у ті самі байти, коли під час запису даних використовується обробник помилок `surrogateescape`. Це корисно для обробки файлів у невідомому кодуванні.

  - `'xmlcharrefreplace'` is only supported when writing to a file. Characters not supported by the encoding are replaced with the appropriate XML character reference `&#nnn;`.

  - `'backslashreplace'` замінює некоректні дані керуючими послідовностями Python зі зворотною похилою рискою.

  - `'namereplace'` (також підтримується лише під час запису) замінює непідтримувані символи `\N{...}` керуючими послідовностями.

  newline determines how to parse newline characters from the stream. It can be `None`, `''`, `'\n'`, `'\r'`, and `'\r\n'`. It works as follows:

  - Під час читання вхідних даних із потоку, якщо новий рядок має значення `None`, увімкнено універсальний режим нових рядків. Рядки у вхідних даних можуть закінчуватися на `'\n'`, `'\r'` або `'\r\n'`, і вони перекладаються на `'\n'` перед поверненням до абонента. Якщо це `''`, універсальний режим нових рядків увімкнено, але закінчення рядків повертаються абоненту без перекладу. Якщо він має будь-яке з інших дозволених значень, рядки введення завершуються лише заданим рядком, а закінчення рядка повертається до викликаючого без перекладу.

  - Під час запису вихідних даних у потік, якщо новий рядок має значення `None`, будь-які записані символи `'\n'` переводяться в системний роздільник рядків за умовчанням, `os.linesep`. Якщо новий рядок є `''` або `'\n'`, переклад не відбувається. Якщо новий рядок є будь-яким іншим допустимим значенням, будь-які написані символи `'\n'` переводяться в заданий рядок.

  Якщо closefd має значення `False` і вказано дескриптор файлу, а не ім’я файлу, базовий дескриптор файлу залишатиметься відкритим, коли файл буде закрито. Якщо вказано ім’я файлу closefd має бути `True` (за замовчуванням); інакше виникне помилка.

  Спеціальний відкривач можна використовувати, передавши виклик як opener. Базовий файловий дескриптор для об’єкта файлу потім отримується шляхом виклику opener за допомогою (file, flags). opener має повертати дескриптор відкритого файлу (передача `os.open` як opener призводить до функціональності, подібної до передачі `None`).

  Щойно створений файл не успадковується.

  У наступному прикладі використовується параметр dir_fd функції `os.open()` для відкриття файлу відносно заданого каталогу:

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

  Тип об’єкта file object, який повертає функція `open()`, залежить від режиму. Коли `open()` використовується для відкриття файлу в текстовому режимі (`'w'`, `'r'`, `'wt'`, `'rt'`, тощо), він повертає підклас `io.TextIOBase` (зокрема `io.TextIOWrapper`). Коли файл використовується для відкриття файлу в бінарному режимі з буферизацією, повертається клас є підкласом `io.BufferedIOBase`. Точний клас різниться: у бінарному режимі читання він повертає `io.BufferedReader`; у двійкових режимах запису та додавання повертає `io.BufferedWriter`, а в режимі читання/запису повертає `io.BufferedRandom`. Коли буферизацію вимкнено, повертається необроблений потік, підклас `io.RawIOBase`, `io.FileIO`.

  Перегляньте також модулі обробки файлів, такі як `fileinput`, `io` (де оголошено `open()`), `os`, `os.path`, `tempfile` і `shutil`.

  Викликає подію аудиту `open` з аргументами `path`, `mode`, `flags`.

  Аргументи `mode` і `flags` могли бути змінені або виведені з початкового виклику.

  Змінено в версії 3.3:

  - Додано параметр opener.

  - Додано режим `'x`.

  - `IOError` раніше викликався, тепер це псевдонім `OSError`.

  - `FileExistsError` тепер викликається, якщо файл, відкритий у монопольному режимі створення (`'x'`), уже існує.

  Змінено в версії 3.4:

  - Тепер файл не успадковується.

  Змінено в версії 3.5:

  - Якщо системний виклик перервано, а обробник сигналу не викликає виключення, функція тепер повторює системний виклик замість того, щоб викликати виняток `InterruptedError` (перегляньте PEP 475 для обґрунтування).

  - Додано обробник помилок `'namereplace'`.

  Змінено в версії 3.6:

  - Додано підтримку прийняття об’єктів, що реалізують `os.PathLike`.

  - У Windows відкриття буфера консолі може повернути підклас `io.RawIOBase`, відмінний від `io.FileIO`.

  Змінено в версії 3.11: The `'U'` mode has been removed.

ord(c)

  Дано рядок, що представляє один символ Unicode, повертає ціле число, що представляє код Unicode цього символу. Наприклад, `ord('a')` повертає ціле число `97`, `ord('€')` (знак євро) повертає `8364`. Це зворотне до `chr()`.

pow(base, exp, mod=None)

  Повернути base до потужності exp; якщо присутній mod, повертає base до ступеня exp, за модулем mod (обчислюється ефективніше, ніж `pow(base, exp) % mod`). Форма з двома аргументами `pow(base, exp)` еквівалентна використанню оператора ступеня: `base**exp`.

  The arguments must have numeric types. With mixed operand types, the coercion rules for binary arithmetic operators apply. For `int` operands, the result has the same type as the operands (after coercion) unless the second argument is negative; in that case, all arguments are converted to float and a float result is delivered. For example, `pow(10, 2)` returns `100`, but `pow(10, -2)` returns `0.01`. For a negative base of type `int` or `float` and a non-integral exponent, a complex result is delivered. For example, `pow(-9, 0.5)` returns a value close to `3j`. Whereas, for a negative base of type `int` or `float` with an integral exponent, a float result is delivered. For example, `pow(-9, 2.0)` returns `81.0`.

  Для `int` операндів base і exp, якщо присутній mod, mod також має бути цілого типу, а mod має бути ненульовим. Якщо mod присутній і exp від’ємний, base має бути відносно простим до mod. У цьому випадку повертається `pow(inv_base, -exp, mod)`, де inv_base є оберненим до base за модулем mod.

  Ось приклад обчислення оберненого числа для `38` за модулем `97`:

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

  Змінено в версії 3.8: Для операндів `int` форма з трьома аргументами `pow` тепер дозволяє другому аргументу бути від’ємним, що дозволяє обчислювати модульні обернені.

  Змінено в версії 3.8: Дозволити аргументи ключових слів. Раніше підтримувалися лише позиційні аргументи.

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

  Вивести об’єкти в файл текстового потоку, розділивши sep і супроводжуючи end. sep, end, file і flush, якщо вони присутні, потрібно надати як аргументи ключового слова.

  Усі аргументи, не пов’язані з ключовими словами, перетворюються на рядки, як це робить `str()`, і записуються в потік, розділені символом sep і після нього end. І sep, і end повинні бути рядками; вони також можуть бути `None`, що означає використання стандартних значень. Якщо об’єктів не надано, `print()` просто напише end.

  Аргумент file має бути об’єктом із методом `write(string)`; якщо його немає або `None`, буде використано `sys.stdout`. Оскільки надруковані аргументи перетворюються на текстові рядки, `print()` не можна використовувати з об’єктами файлу двійкового режиму. Для цього замість цього використовуйте `file.write(...)`.

  Output buffering is usually determined by file. However, if flush is true, the stream is forcibly flushed.

  Змінено в версії 3.3: Додано аргумент ключового слова flush.

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

  Повертає атрибут властивості.

  fget — це функція для отримання значення атрибута. fset — це функція для встановлення значення атрибута. fdel — це функція для видалення значення атрибута. А doc створює рядок документації для атрибута.

  Типовим використанням є визначення керованого атрибута `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.")

  Якщо c є екземпляром C, `c.x` викличе засіб отримання, `c.x = value` викличе установник, а `del c.x` засіб видалення.

  Якщо вказано, doc буде рядком документації атрибута властивості. В іншому випадку властивість скопіює рядок документа fget (якщо він існує). Це дає змогу легко створювати властивості лише для читання, використовуючи `property()` як decorator:

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

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

  The `@property` decorator turns the `voltage()` method into a «getter» for a read-only attribute with the same name, and it sets the docstring for voltage to «Get the current voltage.»

  @getter
  @setter
  @deleter

    A property object has `getter`, `setter`, and `deleter` methods usable as decorators that create a copy of the property with the corresponding accessor function set to the decorated function. This is best explained with an example:

        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

    Цей код точно еквівалентний першому прикладу. Обов’язково дайте додатковим функціям те саме ім’я, що й початкова властивість (у цьому випадку `x`).

    Повернений об’єкт властивості також має атрибути `fget`, `fset` і `fdel`, що відповідають аргументам конструктора.

  Змінено в версії 3.5: Рядки документації об’єктів властивості тепер доступні для запису.

  __name__

    Attribute holding the name of the property. The name of the property can be changed at runtime.

    Added in version 3.13.

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

  Замість того, щоб бути функцією, `range` насправді є незмінним типом послідовності, як описано в діапазони і Типи послідовностей — list, tuple, range.

repr(object)

  Return a string containing a printable representation of an object. For many types, this function makes an attempt to return a string that would yield an object with the same value when passed to `eval()`; otherwise, the representation is a string enclosed in angle brackets that contains the name of the type of the object together with additional information often including the name and address of the object. A class can control what this function returns for its instances by defining a `__repr__()` method. If `sys.displayhook()` is not accessible, this function will raise `RuntimeError`.

  This class has a custom representation that can be evaluated:

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

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

reversed(seq)

  Return a reverse iterator. seq must be an object which has a `__reversed__()` method or supports the sequence protocol (the `__len__()` method and the `__getitem__()` method with integer arguments starting at `0`).

round(number, ndigits=None)

  Повертає число, округлене до nцифр з точністю після коми. Якщо ndigits опущено або має значення `None`, він повертає найближче ціле число до вхідних даних.

  Для вбудованих типів, які підтримують `round()`, значення округлюються до найближчого кратного 10 у степені мінус ndigits; якщо два кратні однаково близькі, округлення виконується в бік парного вибору (тому, наприклад, як``round(0.5)``, так і `round(-0.5)` є `0`, а `round(1.5)` є `2`). Будь-яке ціле значення є дійсним для nцифр (додатне, нульове або від’ємне). Повернене значення є цілим числом, якщо ndigits пропущено або `None`. В іншому випадку значення, що повертається, має той самий тип, що й число.

  Для загального об’єкта Python `number` `round` делегує `number.__round__`.

  Примітка

  Поведінка `round()` для числа з плаваючою точкою може бути несподіваною: наприклад, `round(2.675, 2)` дає `2.67` замість очікуваного `2.68`. Це не помилка: це результат того факту, що більшість десяткових дробів не можна представити точно як число з плаваючою точкою. Перегляньте Floating-Point Arithmetic: Issues and Limitations для отримання додаткової інформації.

class set
class set(iterable)

  Повертає новий об’єкт `set`, необов’язково з елементами, взятими з iterable. `набір` є вбудованим класом. Перегляньте `set` і Типи наборів — set, frozenset для документації про цей клас.

  Для інших контейнерів перегляньте вбудовані класи `frozenset`, `list`, `tuple` і `dict`, а також модуль `collections`.

setattr(object, name, value)

  Це відповідник `getattr()`. Аргументами є об’єкт, рядок і довільне значення. Рядок може називати існуючий атрибут або новий атрибут. Функція присвоює значення атрибуту, якщо це дозволяє об’єкт. Наприклад, `setattr(x, 'foobar', 123)` еквівалентно `x.foobar = 123`.

  name need not be a Python identifier as defined in Ідентифікатори та ключові слова unless the object chooses to enforce that, for example in a custom `__getattribute__()` or via `__slots__`. An attribute whose name is not an identifier will not be accessible using the dot notation, but is accessible through `getattr()` etc..

  Примітка

  Оскільки викривлення приватного імені відбувається під час компіляції, потрібно вручну спотворити ім’я приватного атрибута (атрибути з двома символами підкреслення на початку), щоб встановити його за допомогою `setattr()`.

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

  Return a slice object representing the set of indices specified by `range(start, stop, step)`. The start and step arguments default to `None`.

  start
  stop
  step

    Slice objects have read-only data attributes `start`, `stop`, and `step` which merely return the argument values (or their default). They have no other explicit functionality; however, they are used by NumPy and other third-party packages.

  Slice objects are also generated when extended indexing syntax is used. For example: `a[start:stop:step]` or `a[start:stop, i]`. See `itertools.islice()` for an alternate version that returns an iterator.

  Змінено в версії 3.12: Slice objects are now hashable (provided `start`, `stop`, and `step` are hashable).

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

  Повертає новий відсортований список з елементів у iterable.

  Має два необов’язкові аргументи, які необхідно вказати як аргументи ключового слова.

  key визначає функцію одного аргументу, яка використовується для отримання ключа порівняння з кожного елемента в iterable (наприклад, `key=str.lower`). Значення за замовчуванням – `None` (пряме порівняння елементів).

  reverse — це логічне значення. Якщо встановлено значення `True`, елементи списку сортуються так, ніби кожне порівняння було зворотним.

  Використовуйте `functools.cmp_to_key()`, щоб перетворити функцію cmp старого стилю на функцію key.

  Вбудована функція `sorted()` гарантовано буде стабільною. Сортування є стабільним, якщо воно гарантує відсутність зміни відносного порядку порівнюваних рівних елементів — це корисно для сортування за кілька проходів (наприклад, сортування за відділом, а потім за ступенем заробітної плати).

  Алгоритм сортування використовує лише `<` comparisons between items. While defining an `__lt__()` method will suffice for sorting, PEP 8 recommends that all six rich comparisons. Це допоможе уникнути помилок під час використання тих самих даних з іншими інструментами впорядкування, такими як `max()`, які покладаються на інший базовий метод. Реалізація всіх шести порівнянь також допомагає уникнути плутанини для порівнянь змішаного типу, які можуть викликати відображений метод `__gt__()`.

  Приклади сортування та короткий посібник із сортування див. Sorting Techniques.

@staticmethod

  Перетворення методу в статичний метод.

  Статичний метод не отримує неявний перший аргумент. Щоб оголосити статичний метод, використовуйте цю ідіому:

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

  Форма `@staticmethod` є функцією decorator – подробиці див. Визначення функцій.

  A static method can be called either on the class (such as `C.f()`) or on an instance (such as `C().f()`). Moreover, the static method descriptor is also callable, so it can be used in the class definition (such as `f()`).

  Статичні методи в Python подібні до методів Java або C++. Також перегляньте `classmethod()` варіант, який корисний для створення альтернативних конструкторів класів.

  Як і в усіх декораторах, також можна викликати `staticmethod` як звичайну функцію та щось робити з його результатом. Це необхідно в деяких випадках, коли вам потрібно посилання на функцію з тіла класу, і ви хочете уникнути автоматичного перетворення в метод екземпляра. Для цих випадків використовуйте цю ідіому:

      def regular_function():
          ...

      class C:
          method = staticmethod(regular_function)

  Для отримання додаткової інформації про статичні методи див. Стандартна ієрархія типів.

  Змінено в версії 3.10: Static methods now inherit the method attributes (`__module__`, `__name__`, `__qualname__`, `__doc__` and `__annotations__`), have a new `__wrapped__` attribute, and are now callable as regular functions.

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

  Повертає `str` версію object. Дивіться `str()` для деталей.

  `str` — це вбудований рядок class. Щоб отримати загальну інформацію про рядки, перегляньте Тип текстової послідовності — str.

sum(iterable, /, start=0)

  Сумує start і елементи iterable зліва направо та повертає підсумок. Елементи iterable зазвичай є числами, а початкове значення не може бути рядком.

  For some use cases, there are good alternatives to `sum()`. The preferred, fast way to concatenate a sequence of strings is by calling `''.join(sequence)`. To add floating-point values with extended precision, see `math.fsum()`. To concatenate a series of iterables, consider using `itertools.chain()`.

  Змінено в версії 3.8: Параметр start можна вказати як аргумент ключового слова.

  Змінено в версії 3.12: Summation of floats switched to an algorithm that gives higher accuracy and better commutativity on most builds.

  Змінено в версії 3.14: Added specialization for summation of complexes, using same algorithm as for summation of floats.

class super
class super(type, object_or_type=None)

  Повертає проксі-об’єкт, який делегує виклики методу батьківському або рідному класу типу. Це корисно для доступу до успадкованих методів, які були перевизначені в класі.

  The object_or_type determines the method resolution order to be searched. The search starts from the class right after the type.

  For example, if `__mro__` of object_or_type is `D -> B -> C -> A -> object` and the value of type is `B`, then `super()` searches `C -> A -> object`.

  The `__mro__` attribute of the class corresponding to object_or_type lists the method resolution search order used by both `getattr()` and `super()`. The attribute is dynamic and can change whenever the inheritance hierarchy is updated.

  Якщо другий аргумент опущено, повернутий супероб’єкт не зв’язаний. Якщо другий аргумент є об’єктом, `isinstance(obj, type)` має бути істинним. Якщо другий аргумент є типом, `issubclass(type2, type)` має бути істинним (це корисно для методів класу).

  When called directly within an ordinary method of a class, both arguments may be omitted («zero-argument `super()`»). In this case, type will be the enclosing class, and obj will be the first argument of the immediately enclosing function (typically `self`). (This means that zero-argument `super()` will not work as expected within nested functions, including generator expressions, which implicitly create nested functions.)

  Є два типових випадки використання super. В ієрархії класів з єдиним успадкуванням super можна використовувати для посилання на батьківські класи, не вказуючи їх явно, що робить код більш придатним для обслуговування. Це використання дуже схоже на використання super в інших мовах програмування.

  Другий варіант використання — це підтримка кооперативного множинного успадкування в динамічному середовищі виконання. Цей варіант використання унікальний для Python і не зустрічається в статично скомпільованих мовах або мовах, які підтримують лише одне успадкування. Це дає змогу реалізувати «діамантові діаграми», де кілька базових класів реалізують один і той же метод. Хороший дизайн вимагає, щоб такі реалізації мали однакову сигнатуру виклику в кожному випадку (оскільки порядок викликів визначається під час виконання, оскільки цей порядок адаптується до змін в ієрархії класів, і оскільки цей порядок може включати однотипні класи, які невідомі до виконання ).

  Для обох випадків типовий виклик суперкласу виглядає так:

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

  Окрім пошуку методів, `super()` також працює для пошуку атрибутів. Одним із можливих варіантів використання цього є виклик дескрипторів у батьківському або рідному класі.

  Note that `super()` is implemented as part of the binding process for explicit dotted attribute lookups such as `super().__getitem__(name)`. It does so by implementing its own `__getattribute__()` method for searching classes in a predictable order that supports cooperative multiple inheritance. Accordingly, `super()` is undefined for implicit lookups using statements or operators such as `super()[name]`.

  Також зауважте, що, окрім форми нульового аргументу, `super()` не обмежується використанням внутрішніх методів. Форма з двома аргументами точно визначає аргументи та робить відповідні посилання. Форма нульового аргументу працює лише всередині визначення класу, оскільки компілятор заповнює необхідні деталі для правильного отримання визначеного класу, а також для доступу до поточного екземпляра для звичайних методів.

  Щоб отримати практичні поради щодо створення кооперативних класів за допомогою `super()`, перегляньте посібник із використання super().

class tuple
class tuple(iterable)

  Замість того, щоб бути функцією, `tuple` насправді є незмінним типом послідовності, як описано в Кортежі і Типи послідовностей — list, tuple, range.

class type(object)
class type(name, bases, dict, **kwds)

  With one argument, return the type of an object. The return value is a type object and generally the same object as returned by `object.__class__`.

  Для перевірки типу об’єкта рекомендується використовувати вбудовану функцію `isinstance()`, оскільки вона враховує підкласи.

  With three arguments, return a new type object. This is essentially a dynamic form of the `class` statement. The name string is the class name and becomes the `__name__` attribute. The bases tuple contains the base classes and becomes the `__bases__` attribute; if empty, `object`, the ultimate base of all classes, is added. The dict dictionary contains attribute and method definitions for the class body; it may be copied or wrapped before becoming the `__dict__` attribute. The following two statements create identical `type` objects:

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

  See also:

  - Documentation on attributes and methods on classes.

  - Об’єкти типу

  Аргументи ключових слів, надані у формі з трьома аргументами, передаються у відповідний механізм метакласу (зазвичай `__init_subclass__()`) так само, як ключові слова у визначенні класу (крім metaclass).

  Дивіться також Налаштування створення класу.

  Змінено в версії 3.6: Subclasses of `type` which don’t override `type.__new__` may no longer use the one-argument form to get the type of an object.

vars()
vars(object)

  Return the `__dict__` attribute for a module, class, instance, or any other object with a `__dict__` attribute.

  Objects such as modules and instances have an updateable `__dict__` attribute; however, other objects may have write restrictions on their `__dict__` attributes (for example, classes use a `types.MappingProxyType` to prevent direct dictionary updates).

  Without an argument, `vars()` acts like `locals()`.

  Виняток `TypeError` виникає, якщо об’єкт указано, але він не має атрибута `__dict__` (наприклад, якщо його клас визначає `__slots__` атрибут).

  Змінено в версії 3.13: The result of calling this function without an argument has been updated as described for the `locals()` builtin.

zip(*iterables, strict=False)

  Виконайте ітерацію кількох ітерацій паралельно, створюючи кортежі з елементом з кожного.

  Приклад:

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

  Більш формально: `zip()` повертає ітератор кортежів, де i-й кортеж містить i-й елемент з кожного з ітерованих аргументів.

  Інший спосіб уявлення про `zip()` полягає в тому, що він перетворює рядки на стовпці, а стовпці — на рядки. Це схоже на транспонування матриці.

  `zip()` ледачий: елементи не будуть оброблені, доки не буде виконано ітерацію, напр. за допомогою циклу `for` або загортання в `list`.

  Варто взяти до уваги те, що ітератори, передані `zip()`, можуть мати різну довжину; іноді задумом, а іноді через помилку в коді, який підготував ці ітерації. Python пропонує три різні підходи до вирішення цієї проблеми:

  - За замовчуванням `zip()` зупиняється, коли вичерпується найкоротша ітерація. Він ігноруватиме решта елементів у довших ітераціях, відрізаючи результат до довжини найкоротшої ітерації:

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

  - `zip()` часто використовується у випадках, коли передбачається, що ітератори мають однакову довжину. У таких випадках рекомендується використовувати параметр `strict=True`. Його вихід такий самий, як і звичайний `zip()`:

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

    Unlike the default behavior, it raises a `ValueError` if one iterable is exhausted before the others:

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

    Без аргументу `strict=True` будь-яка помилка, яка призводить до ітерацій різної довжини, буде замовчена, можливо, проявляючись як помилка, яку важко знайти в іншій частині програми.

  - Коротші ітератори можна доповнити постійним значенням, щоб усі ітератори мали однакову довжину. Це робить `itertools.zip_longest()`.

  Граничні випадки: з одним ітерованим аргументом `zip()` повертає ітератор 1-кортежів. Без аргументів він повертає порожній ітератор.

  Поради та підказки:

  - Порядок оцінки ітерацій зліва направо гарантується. Це робить можливою ідіому для кластеризації рядів даних у групи довжини n за допомогою `zip(*[iter(s)]*n, strict=True)`. Це повторює той самий ітератор `n` разів, щоб кожен вихідний кортеж мав результат `n` викликів ітератора. Це призводить до поділу вхідних даних на фрагменти довжиною n.

  - `zip()` у поєднанні з оператором `*` можна використовувати для розпакування списку:

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

  Змінено в версії 3.10: Додано аргумент `строгий`.

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

  Примітка

  Це розширена функція, яка не потрібна в повсякденному програмуванні на Python, на відміну від `importlib.import_module()`.

  Ця функція викликається оператором `import`. Його можна замінити (імпортувавши модуль `builtins` і призначивши `builtins.__import__`), щоб змінити семантику оператора `import`, але це настійно не рекомендується, оскільки зазвичай простіше використовувати перехоплювачі імпорту (див. PEP 302) для досягнення тих самих цілей і не викликає проблем із кодом, який припускає, що використовується реалізація імпорту за замовчуванням. Пряме використання `__import__()` також не рекомендується на користь `importlib.import_module()`.

  Функція імпортує name модуля, потенційно використовуючи задані globals і locals, щоб визначити, як інтерпретувати назву в контексті пакета. Список fromlist надає імена об’єктів або підмодулів, які слід імпортувати з модуля, заданого name. Стандартна реалізація взагалі не використовує свій аргумент locals і використовує його globals лише для визначення контексту пакета оператора `import`.

  рівень визначає, чи використовувати абсолютний чи відносний імпорт. `0` (за замовчуванням) означає виконання лише абсолютного імпорту. Позитивні значення для level вказують на кількість батьківських каталогів для пошуку відносно каталогу модуля, який викликає `__import__()` (див. PEP 328 для деталей).

  Якщо змінна name має форму `package.module`, зазвичай повертається пакет верхнього рівня (ім’я до першої крапки), а не модуль, названий name. Однак, якщо вказано непорожній аргумент fromlist, повертається модуль, названий name.

  Наприклад, оператор `import spam` призводить до байт-коду, схожого на такий код:

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

  Інструкція `import spam.ham` призводить до цього виклику:

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

  Зверніть увагу, як `__import__()` повертає тут модуль верхнього рівня, оскільки це об’єкт, який прив’язаний до імені оператором `import`.

  З іншого боку, заява `from spam.ham import eggs, sausage as saus` призводить до:

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

  Тут модуль `spam.ham` повертається з `__import__()`. З цього об’єкта витягуються імена для імпорту та призначаються їх відповідні імена.

  Якщо ви просто хочете імпортувати модуль (можливо, у пакеті) за назвою, використовуйте `importlib.import_module()`.

  Змінено в версії 3.3: Від’ємні значення для рівня більше не підтримуються (що також змінює значення за замовчуванням на 0).

  Змінено в версії 3.9: Коли використовуються параметри командного рядка `-E` або `-I`, змінна середовища `PYTHONCASEOK` ігнорується.

Примітки

[1]

Зауважте, що синтаксичний аналізатор приймає символ кінця рядка лише в стилі Unix. Якщо ви читаєте код з файлу, обов’язково використовуйте режим перетворення нового рядка для перетворення символів нового рядка з Windows або Mac.