Встроенные типы

В следующих разделах описываются стандартные типы, встроенные в интерпретатор.

Основными встроенными типами являются числа, последовательности, отображения, классы, экземпляры и исключения.

Некоторые классы коллекций являются мутабельными. Методы, которые добавляют, вычитают или переставляют местами свои члены и не возвращают конкретный элемент, никогда не возвращают сам экземпляр коллекции, а только None.

Некоторые операции поддерживаются несколькими типами объектов; в частности, практически все объекты можно сравнить на равенство, проверить на истинность значения и преобразовать в строку (с помощью функции repr() или немного отличающейся от нее функции str()). Последняя функция неявно используется при записи объекта функцией print().

Проверка истинности ценности

Любой объект можно проверить на истинность, использовать в качестве условия if или while, а также в качестве операнда для булевых операций, описанных ниже.

По умолчанию объект считается истинным, если в его классе не определен метод __bool__(), возвращающий False, или метод __len__(), возвращающий ноль при вызове объекта. [1] Вот большинство встроенных объектов, которые считаются ложными:

• константы, определенные как ложные: None и False.

• ноль любого числового типа: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)

• пустые последовательности и коллекции: '', (), [], {}, set(), range(0)

Операции и встроенные функции, имеющие булевский результат, всегда возвращают 0 или False для false и 1 или True для true, если не указано иное. (Важное исключение: булевы операции or и and всегда возвращают один из своих операндов).

Булевы операции — and, or, not

Это булевы операции, упорядоченные по возрастанию приоритета:

Операция	Результат	Примечания
x or y	если x истинно, то x, иначе y	(1)
x and y	если x ложно, то x, иначе y	(2)
not x	если x ложно, то True, иначе False.	(3)

Примечания:

1. Это оператор короткого замыкания, поэтому он оценивает второй аргумент только в том случае, если первый равен false.

2. Это оператор короткого замыкания, поэтому он оценивает второй аргумент только в том случае, если первый истинен.

3. Оператор not имеет более низкий приоритет, чем операторы, не являющиеся булевыми, поэтому not a == b интерпретируется как not (a == b), а a == not b является синтаксической ошибкой.

Сравнения

В Python существует восемь операций сравнения. Все они имеют одинаковый приоритет (который выше, чем у булевых операций). Сравнения можно объединять в цепочку произвольным образом; например, x < y <= z эквивалентно x < y and y <= z, за исключением того, что y оценивается только один раз (но в обоих случаях z не оценивается вообще, когда x < y оказывается ложным).

В этой таблице представлены операции сравнения:

Операция	Значение
<	строго меньше, чем
<=	меньше или равно
>	строго больше, чем
>=	больше или равно
==	равный
!=	не равный
is	идентичность объекта
is not	отрицаемая идентичность объекта

Объекты разных типов, за исключением различных числовых типов, никогда не сравниваются между собой. Оператор == определен всегда, но для некоторых типов объектов (например, объектов класса) эквивалентен is. Операторы <, <=, > и >= определены только там, где они имеют смысл; например, они вызывают исключение TypeError, если один из аргументов является комплексным числом.

Неидентичные экземпляры класса обычно сравниваются как неравные, если только в классе не определен метод __eq__().

Экземпляры класса не могут быть упорядочены относительно других экземпляров того же класса или других типов объектов, если в классе не определено достаточное количество методов __lt__(), __le__(), __gt__() и __ge__() (в общем случае достаточно __lt__() и __eq__(), если вы хотите использовать обычные значения операторов сравнения).

Поведение операторов is и is not нельзя настроить; кроме того, они могут быть применены к любым двум объектам и никогда не вызовут исключения.

Еще две операции с тем же синтаксическим приоритетом, in и not in, поддерживаются типами, которые являются iterable или реализуют метод __contains__().

Числовые типы — int, float, complex

Существует три различных числовых типа: integers, floating point numbers и complex numbers. Кроме того, булевы числа являются подтипом целых чисел. Целые числа имеют неограниченную точность. Числа с плавающей точкой обычно реализуются с помощью double в языке C; информацию о точности и внутреннем представлении чисел с плавающей точкой для машины, на которой выполняется ваша программа, можно найти в sys.float_info. Комплексные числа имеют действительную и мнимую части, каждая из которых является числом с плавающей точкой. Чтобы извлечь эти части из комплексного числа z, используйте z.real и z.imag. (В стандартную библиотеку входят дополнительные числовые типы fractions.Fraction для рациональных чисел и decimal.Decimal для чисел с плавающей точкой с задаваемой пользователем точностью).

Числа создаются с помощью числовых литералов или в результате работы встроенных функций и операторов. Целые литералы без украшений (включая шестнадцатеричные, восьмеричные и двоичные числа) дают целые числа. Числовые литералы, содержащие десятичную точку или знак экспоненты, дают числа с плавающей запятой. Добавление 'j' или 'J' к числовому литералу дает мнимое число (комплексное число с нулевой действительной частью), которое можно добавить к целому числу или числу с плавающей запятой, чтобы получить комплексное число с действительной и мнимой частями.

Python полностью поддерживает смешанную арифметику: когда двоичный арифметический оператор имеет операнды разных числовых типов, операнд с более «узким» типом расширяется до другого, где целое число узче плавающей точки, которая узче комплексного. Сравнение между числами разных типов ведет себя так, как будто сравниваются точные значения этих чисел. [2]

Конструкторы int(), float() и complex() можно использовать для получения чисел определенного типа.

Все числовые типы (кроме комплексного) поддерживают следующие операции (приоритеты операций см. в Старшинство операторов):

Операция	Результат	Примечания	Полная документация
x + y	сумма x и y
x - y	разность x и y
x * y	произведение x и y
x / y	коэффициент от x и y
x // y	колличество x и y с полом	(1)(2)
x % y	остаток от x / y	(2)
-x	x отрицается
+x	x без изменений
abs(x)	абсолютное значение или величина x		abs()
int(x)	x преобразуется в целое число	(3)(6)	int()
float(x)	x преобразуется в плавающую точку	(4)(6)	float()
complex(re, im)	комплексное число с действительной частью re, мнимой частью im. По умолчанию im равно нулю.	(6)	complex()
c.conjugate()	сопряжение комплексного числа c
divmod(x, y)	пара (x // y, x % y)	(2)	divmod()
pow(x, y)	x к мощности y	(5)	pow()
x ** y	x к мощности y	(5)

Примечания:

1. Также называется целочисленным делением. Для операндов типа int результат имеет тип int. Для операндов типа float результат имеет тип float. В общем случае результатом является целое число, хотя тип результата не обязательно int. Результат всегда округляется в сторону минус бесконечности: 1//2 - это 0, (-1)//2 - это -1, 1//(-2) - это -1, а (-1)//(-2) - это 0.

2. Не для комплексных чисел. Вместо этого преобразуйте в плавающие числа, используя abs(), если это необходимо.

3. При преобразовании из float в int происходит усечение, отбрасывается дробная часть. Альтернативные варианты преобразования см. в функциях math.floor() и math.ceil().

4. float также принимает строки «nan» и «inf» с необязательным префиксом «+» или «-» для обозначения «не числа» (NaN) и положительной или отрицательной бесконечности.

5. Python определяет pow(0, 0) и 0 ** 0 как 1, как это принято в языках программирования.

6. В числовые литералы принимаются цифры от 0 до 9 или любой эквивалент Unicode (кодовые точки со свойством Nd).

   Полный список точек кода со свойством Nd см. в разделе the Unicode Standard.

Все типы numbers.Real (int и float) также включают следующие операции:

Операция	Результат
math.trunc(x)	x усечено до Integral
round(x[, n])	x округляется до n цифр, округляя половину до четных. Если значение n опущено, по умолчанию оно равно 0.
math.floor(x)	наибольший Integral <= x
math.ceil(x)	наименьший Integral >= x

Дополнительные числовые операции описаны в модулях math и cmath.

Побитовые операции над целочисленными типами

Побитовые операции имеют смысл только для целых чисел. Результат побитовых операций вычисляется так, как если бы они выполнялись в двоичном дополнении с бесконечным числом знаковых битов.

Приоритеты двоичных побитовых операций ниже, чем числовых операций, и выше, чем сравнения; унарная операция ~ имеет тот же приоритет, что и другие унарные числовые операции (+ и -).

В этой таблице перечислены побитовые операции, отсортированные по возрастанию приоритета:

Операция	Результат	Примечания
x | y	побитовое or из x и y	(4)
x ^ y	побитовое exclusive or из x и y	(4)
x & y	побитовое and из x и y	(4)
x << n	x сдвинуто влево на n бит	(1)(2)
x >> n	x сдвинуто вправо на n бит	(1)(3)
~x	инвертированные биты x

Примечания:

1. Отрицательные значения сдвига недопустимы и приводят к появлению ValueError.

2. Сдвиг влево на n бит эквивалентен умножению на pow(2, n).

3. Сдвиг вправо на n бит эквивалентен полу делению на pow(2, n).

4. Выполнение этих вычислений хотя бы с одним дополнительным битом расширения знака в конечном представлении двойки (ширина рабочего бита 1 + max(x.bit_length(), y.bit_length()) или больше) достаточно для получения того же результата, что и при наличии бесконечного числа битов знака.

Дополнительные методы для целочисленных типов

Тип int реализует numbers.Integral abstract base class. Кроме того, он предоставляет еще несколько методов:

int.bit_length()

Возвращает количество битов, необходимых для представления целого числа в двоичном виде, без учета знака и ведущих нулей:

>>> n = -37
>>> bin(n)
'-0b100101'
>>> n.bit_length()
6

Точнее, если x ненулевое, то x.bit_length() - единственное положительное целое число k такое, что 2**(k-1) <= abs(x) < 2**k. Эквивалентно, если abs(x) достаточно мало, чтобы иметь правильно округленный логарифм, то k = 1 + int(log(abs(x), 2)). Если x равен нулю, то x.bit_length() возвращает 0.

Эквивалент:

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6

Added in version 3.1.

int.bit_count()

Возвращает количество единиц в двоичном представлении абсолютного значения целого числа. Это значение также известно как счетчик населения. Пример:

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3

Эквивалент:

def bit_count(self):
    return bin(self).count("1")

Added in version 3.10.

int.to_bytes(length=1, byteorder='big', *, signed=False)

Возвращает массив байтов, представляющих целое число.

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'

Целое число представляется с помощью байтов length и по умолчанию равно 1. Если целое число не может быть представлено с помощью заданного количества байт, выдается сообщение OverflowError.

Аргумент byteorder определяет порядок байтов, используемый для представления целого числа, и по умолчанию принимает значение "big". Если byteorder равен "big", то старший байт находится в начале массива байтов. Если byteorder равен "little", то старший байт находится в конце массива байтов.

Аргумент signed определяет, будет ли для представления целого числа использоваться дополнение двойки. Если значение signed равно False и задано отрицательное целое число, то будет выдано сообщение OverflowError. По умолчанию значение signed равно False.

Значения по умолчанию можно использовать для удобного преобразования целого числа в однобайтовый объект:

>>> (65).to_bytes()
b'A'

Однако при использовании аргументов по умолчанию не пытайтесь преобразовать значение, превышающее 255, иначе вы получите ошибку OverflowError.

Эквивалент:

def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)

Added in version 3.2.

Изменено в версии 3.11: Добавлены значения аргументов по умолчанию для length и byteorder.

classmethod int.from_bytes(bytes, byteorder='big', *, signed=False)

Возвращает целое число, представленное заданным массивом байтов.

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680

Аргумент bytes должен быть либо bytes-like object, либо итерируемым числом, производящим байты.

Аргумент byteorder определяет порядок байтов, используемый для представления целого числа, и по умолчанию принимает значение "big". Если byteorder равен "big", то старший байт находится в начале массива байтов. Если byteorder равен "little", то старший байт находится в конце массива байтов. Чтобы запросить собственный порядок байтов хост-системы, используйте sys.byteorder в качестве значения порядка байтов.

Аргумент signed указывает, используется ли для представления целого числа дополнение двумя знаками.

Эквивалент:

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n

Added in version 3.2.

Изменено в версии 3.11: Добавлено значение аргумента по умолчанию для byteorder.

int.as_integer_ratio()

Возвращает пару целых чисел, отношение которых равно исходному целому числу и имеет положительный знаменатель. Отношение целых чисел (целых чисел) всегда равно целому числу в числителе и 1 в знаменателе.

Added in version 3.8.

int.is_integer()

Возвращает True. Существует для совместимости с типом утки float.is_integer().

Added in version 3.12.

Дополнительные методы на поплавке

Тип float реализует методы numbers.Real abstract base class. float также имеет следующие дополнительные методы.

float.as_integer_ratio()

Возвращает пару целых чисел, отношение которых в точности равно исходному float. Отношение выражается в наименьших членах и имеет положительный знаменатель. Вызывает OverflowError при бесконечности и ValueError при NaN.

float.is_integer()

Возвращает True, если экземпляр float конечен с интегральным значением, и False в противном случае:

>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False

Два метода поддерживают преобразование в шестнадцатеричные строки и из них. Поскольку плавающие числа в Python хранятся как двоичные числа, преобразование плавающего числа в строку или из строки в десятичную систему счисления обычно сопровождается небольшой ошибкой округления. В отличие от этого, шестнадцатеричные строки позволяют точно представлять и указывать числа с плавающей точкой. Это может быть полезно при отладке и в численной работе.

float.hex()

Возвращает представление числа с плавающей точкой в виде шестнадцатеричной строки. Для конечных чисел с плавающей точкой это представление всегда будет включать ведущую 0x и последующую p и экспоненту.

classmethod float.fromhex(s)

Метод класса, возвращающий float, представленный шестнадцатеричной строкой s. Строка s может содержать ведущие и последующие пробельные символы.

Обратите внимание, что float.hex() - это метод экземпляра, а float.fromhex() - метод класса.

Шестнадцатеричная строка имеет вид:

[sign] ['0x'] integer ['.' fraction] ['p' exponent]

где необязательный sign может быть либо +, либо -, integer и fraction - строки шестнадцатеричных цифр, а exponent - десятичное целое число с необязательным ведущим знаком. Регистр не имеет значения, и в целой или дробной части должна быть хотя бы одна шестнадцатеричная цифра. Этот синтаксис похож на синтаксис, указанный в разделе 6.4.4.2 стандарта C99, а также на синтаксис, используемый в Java 1.5 и далее. В частности, вывод float.hex() можно использовать как шестнадцатеричный литерал с плавающей точкой в коде на C или Java, а шестнадцатеричные строки, создаваемые символом формата %a в C или Double.toHexString в Java, принимаются float.fromhex().

Обратите внимание, что экспонента записывается в десятичной, а не в шестнадцатеричной системе счисления, и что она дает силу 2, на которую нужно умножить коэффициент. Например, шестнадцатеричная строка 0x3.a7p10 представляет число с плавающей точкой (3 + 10./16 + 7./16**2) * 2.0**10, или 3740.0:

>>> float.fromhex('0x3.a7p10')
3740.0

Применение обратного преобразования к 3740.0 дает другую шестнадцатеричную строку, представляющую то же число:

>>> float.hex(3740.0)
'0x1.d380000000000p+11'

Хеширование числовых типов

Для чисел x и y, возможно, разных типов, требуется, чтобы hash(x) == hash(y) всякий раз равнялся x == y (подробнее см. документацию по методу __hash__()). Для простоты реализации и эффективности работы с различными числовыми типами (включая int, float, decimal.Decimal и fractions.Fraction) хэш Python для числовых типов основан на одной математической функции, которая определена для любого рационального числа, а значит, применима ко всем экземплярам int и fractions.Fraction, а также ко всем конечным экземплярам float и decimal.Decimal. По сути, эта функция задается сокращением по модулю P для фиксированного простого P. Значение P доступно в Python как атрибут modulus в sys.hash_info.

Детали реализации CPython: В настоящее время используется прайм P = 2**31 - 1 на машинах с 32-битным C longs и P = 2**61 - 1 на машинах с 64-битным C longs.

Вот подробные правила:

• Если x = m / n - неотрицательное рациональное число, а n не делится на P, определите hash(x) как m * invmod(n, P) % P, где invmod(n, P) - обратное n по модулю P.

• Если x = m / n - неотрицательное рациональное число, а n делится на P (но не делится на m), то n не имеет обратной величины по модулю P и правило выше не применимо; в этом случае определите hash(x) как постоянную величину sys.hash_info.inf.

• Если x = m / n - отрицательное рациональное число, определите hash(x) как -hash(-x). Если полученный хэш равен -1, замените его на -2.

• Определенные значения sys.hash_info.inf и -sys.hash_info.inf используются как хэш-значения для положительной бесконечности или отрицательной бесконечности (соответственно).

• Для числа complex z хэш-значения действительной и мнимой частей объединяются путем вычисления hash(z.real) + sys.hash_info.imag * hash(z.imag), уменьшенного по модулю 2**sys.hash_info.width так, чтобы оно лежало в range(-2**(sys.hash_info.width - 1), 2**(sys.hash_info.width - 1)). И снова, если результат равен -1, он заменяется на -2.

Чтобы пояснить вышеизложенные правила, приведем пример кода Python, эквивалентного встроенному хэшу, для вычисления хэша рационального числа float или complex:

import sys, math

def hash_fraction(m, n):
    """Compute the hash of a rational number m / n.

    Assumes m and n are integers, with n positive.
    Equivalent to hash(fractions.Fraction(m, n)).

    """
    P = sys.hash_info.modulus
    # Remove common factors of P.  (Unnecessary if m and n already coprime.)
    while m % P == n % P == 0:
        m, n = m // P, n // P

    if n % P == 0:
        hash_value = sys.hash_info.inf
    else:
        # Fermat's Little Theorem: pow(n, P-1, P) is 1, so
        # pow(n, P-2, P) gives the inverse of n modulo P.
        hash_value = (abs(m) % P) * pow(n, P - 2, P) % P
    if m < 0:
        hash_value = -hash_value
    if hash_value == -1:
        hash_value = -2
    return hash_value

def hash_float(x):
    """Compute the hash of a float x."""

    if math.isnan(x):
        return object.__hash__(x)
    elif math.isinf(x):
        return sys.hash_info.inf if x > 0 else -sys.hash_info.inf
    else:
        return hash_fraction(*x.as_integer_ratio())

def hash_complex(z):
    """Compute the hash of a complex number z."""

    hash_value = hash_float(z.real) + sys.hash_info.imag * hash_float(z.imag)
    # do a signed reduction modulo 2**sys.hash_info.width
    M = 2**(sys.hash_info.width - 1)
    hash_value = (hash_value & (M - 1)) -