В следующих разделах описываются стандартные типы, встроенные в интерпретатор.
Основные встроенные типы - это числа, последовательности, сопоставления, классы, экземпляры и исключения.
Некоторые классы коллекций изменяемы. Методы, которые добавляют, вычитают или переупорядочивают свои элементы на месте и не возвращают конкретный элемент, никогда не возвращают сам экземпляр коллекции, но None.
Некоторые операции поддерживаются несколькими типами объектов; в частности, практически все объекты можно сравнивать на равенство, проверять на истинность и преобразовывать в строку (с repr() функцией или немного другой str() функцией). Последняя функция неявно используется, когда объект записывается print() функцией.
Проверка истинности
Любой объект может быть проверен на значение истинности, для использования в if или while, или в качестве операнда булевых операций ниже.
По умолчанию объект считается истинным, если его не определяет: либо __bool__() метод, который возвращает False, либо __len__() метод, который возвращает ноль при вызове с объектом. Вот большинство встроенных объектов, считающихся ложными:
- константы, определенные как ложные: 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
Объяснение:
- Это оператор короткого замыкания, поэтому он оценивает второй аргумент, только если первый неверен.
- Это оператор короткого замыкания, поэтому он оценивает второй аргумент, только если первый верен.
- not имеет более низкий приоритет, чем небулевы операторы, поэтому not a == b интерпретируется как, not (a == b) и a == not b является синтаксической ошибкой.
Сравнения
В Python есть восемь операций сравнения. Все они имеют одинаковый приоритет (который выше, чем у логических операций). Сравнения можно связывать произвольно; например, x < y <= z эквивалентно x < y and y <= z, за исключением того, что y оценивается только один раз (но в обоих случаях z вообще не оценивается, когда x < y оказывается ложным).
В этой таблице приведены операции сравнения:
Объекты разных типов, кроме разных числовых, никогда не сравниваются равными. == Оператор всегда определяется, но для некоторых типов объектов (например, класс объекты) используют is вместо ==. <, <=, >и >= операторы определены только там, где они имеют смысл; например, они вызывают TypeError исключение, когда один из аргументов - комплексное число.
Неидентичные экземпляры класса обычно сравниваются как неравные, если класс не определяет __eq__() метод.
Экземпляры класса не может быть заказаны по отношению к другим экземплярам того же класса или другим типам объектов, если класс не определяет методы
Экземпляры класса не может быть заказаны по отношению к другим экземплярам того же класса или другим типам объектов, если класс достаточно не определяет методы: __lt__(), __le__(), __gt__() и __ge__() (в общем, __lt__() и __eq__() достаточно, если вы хотите, обычные значения операторы сравнения).
Поведение операторов is и is not не может быть изменено; также они могут применяться к любым двум объектам и никогда не вызывать исключения.
Числовые типы - int, float, complex
Существует три различных числовых типа: целые числа, числа с плавающей запятой и комплексные числа . Кроме того, логические значения - это подтип целых чисел. Целые числа имеют неограниченную точность. Числа с плавающей запятой обычно реализуют double в C; информация о точности и внутреннем представлении чисел с плавающей запятой для машины, на которой выполняется ваша программа, доступна в sys.float_info.
Комплексные числа имеют действительную и мнимую части, каждое из которых является числом с плавающей запятой. Чтобы извлечь эти части из комплексного числа z , используйте z.real и z.imag. (Стандартная библиотека включает дополнительные числовые типы fractions.Fraction для рациональных чисел и decimal.Decimal для чисел с плавающей запятой с определяемой пользователем точностью.)
Числа создаются числовыми литералами или в результате встроенных функций и операторов. Целочисленные литералы без украшений (включая шестнадцатеричные, восьмеричные и двоичные числа) дают целые числа. Числовые литералы, содержащие десятичную точку или знак экспоненты, дают числа с плавающей запятой. Добавление 'j'или 'J'к числовому литералу дает мнимое число (комплексное число с нулевой действительной частью), которое вы можете добавить к целому числу или с плавающей запятой, чтобы получить комплексное число с действительной и мнимой частями.
Конструкторы int(), float() и complex() могут использоваться для создания чисел определенного типа.
Все числовые типы (кроме сложных) поддерживают следующие операции:
Все numbers.Real типы ( int и float) также включают следующие операции:
Побитовые операции с целыми типами
Побитовые операции имеют смысл только для целых чисел. Результат поразрядных операций вычисляется так, как если бы они выполнялись с дополнением до двух с бесконечным числом битов знака.
Приоритеты двоичных побитовых операций ниже, чем у числовых операций, и выше, чем у сравнений; унарная операция ~ имеет тот же приоритет, что и другие унарные числовые операции ( + и -).
В этой таблице перечислены побитовые операции, отсортированные по возрастанию приоритета:
Объяснение:
- Отрицательное количество сдвигов недопустимо и приводит ValueError к увеличению a.
- Сдвиг влево на n бит эквивалентен умножению на .pow(2, n)
- Сдвиг вправо на n бит эквивалентен делению пола на .pow(2, n)
- Выполнение этих вычислений по крайней мере с одним дополнительным битом расширения знака в конечном представлении дополнения до двух (рабочая разрядность или более) достаточно, чтобы получить тот же результат, как если бы было бесконечное число битов знака. 1 + max(x.bit_length(), y.bit_length())
Дополнительные методы для целочисленных типов
Тип int реализует абстрактный базовый класс . Кроме того, он предоставляет еще несколько методов: numbers.Integral
int.bit_length()
Возвращает количество битов, необходимых для представления целого числа в двоичном формате, исключая знак и ведущие нули:
>>> n = -37
>>> bin(n)
'-0b100101'
>>> n.bit_length()
6
Эквивалентен:
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
int.to_bytes(length, byteorder, *, 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'
Целое число представлено байтами длины . OverflowError Возбуждаются , если число не представимо с заданным числом байт.
Byteorder аргумент определяет порядок байтов, используемый для представления целого числа. Если byteorder есть "big", старший байт находится в начале массива байтов. Если byteorder есть "little", старший байт находится в конце массива байтов. Чтобы запросить собственный порядок байтов хост-системы, используйте sys.byteorder в качестве значения порядка байтов.
Signed аргумент определяет, можно ли использовать отрицательное число
int.as_integer_ratio()
Верните пару целых чисел, отношение которых в точности равно исходному целому числу и с положительным знаменателем. Целочисленное отношение целых чисел (целых чисел) всегда является целым числом как числителем и как знаменателем.
Дополнительные методы с плавающей запятой
Тип float реализует абстрактный базовый класс. float также имеет следующие дополнительные методы .numbers.Real
float.as_integer_ratio()
Возвращает пару целых чисел, отношение которых точно равно исходному веществу с плавающей запятой, и с положительным знаменателем. Вызывает OverflowError на бесконечности и ValueError на NaN.
float.is_integer()
Возвращает True, если экземпляр с плавающей запятой конечен с целым значением и False противном случае:
>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
Два метода поддерживают преобразование в шестнадцатеричные строки и обратно. Поскольку числа с плавающей запятой в Python хранятся внутри как двоичные числа, преобразование числа с плавающей запятой в десятичную строку или из нее обычно связано с небольшой ошибкой округления. Напротив, шестнадцатеричные строки позволяют точное представление и спецификацию чисел с плавающей запятой. Это может быть полезно при отладке и числовой работе.
float.hex()
Возвращет представление числа с плавающей запятой в виде шестнадцатеричной строки. Для конечных чисел с плавающей запятой это представление всегда будет включать 0x начальную, конечную pи экспоненту.
classmethod float.fromhex( s )
Метод класса для возврата числа с плавающей запятой, представленного шестнадцатеричной строкой s . Строка s может иметь начальные и конечные пробелы.
Обратите внимание, что float.hex() это метод экземпляра, а float.fromhex() метод класса.
Шестнадцатеричная строка имеет вид:
[sign] ['0x'] integer ['.' fraction] ['p' exponent]
где необязательный параметр sign может быть либо + или -, и fraction являются строками шестнадцатеричных цифр, а exponent являются десятичным целым числом с необязательным начальным знаком. Регистр не имеет значения, и в целой или дробной части должна быть хотя бы одна шестнадцатеричная цифра.
Обратите внимание, что показатель степени записывается в десятичном виде, а не в шестнадцатеричном, и что он дает степень 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. Для простоты реализации и эффективности в различных числовых типов (включая int, float, decimal.Decimal и fractions.Fractio) хэш в Python для числовых типов на основе одной математической функции, который определен для любого рационального числа, и следовательно относится ко всем экземплярам и и всех конечных экземпляров из int and fractions.Fraction.
Детали реализации CPython в настоящее время - простое число P = 2**31 - 1 используется на машинах с 32-битными длинными C и P = 2**61 - 1 на машинах с 64-битными C
Вот подробные правила:
- Если 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 и sys.hash_info.nan используются как хеш-значения для положительной бесконечности, отрицательной бесконечности или nans (соответственно). (Все хэшируемые nans имеют одинаковое хеш-значение.)
- Для комплексного числа z хеш-значения действительной и мнимой частей объединяются путем вычисления hash(z.real) + sys.hash_info.imag * hash(z.imag), уменьшенного по модулю 2 ** sys.hash_info.width, поэтому он находится в диапазоне (-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 sys.hash_info.nan
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)) - (hash_value & M)
if hash_value == -1:
hash_value = -2
return hash_value0
Заключение
Ждите следующую часть(или нет)
Пост создан для тг-канала @coolcoders
