Битовый тип данных в python

Built-in Types

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

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

Некоторые классы коллекций изменяемы. Методы, которые добавляют, вычитают или переставляют элементы на месте и не возвращают конкретный элемент, никогда не возвращают сам экземпляр коллекции, а 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 всегда возвращают один из своих операндов.)

Логические операции — and , or , not

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

если x ложно, то True , иначе False

1. Это оператор короткого замыкания,поэтому он оценивает второй аргумент только в том случае,если первый является ложным.
2. Это оператор короткого замыкания,поэтому он оценивает второй аргумент только в том случае,если первый из них верен.
3. not имеет более низкий приоритет, чем небулевы операторы, поэтому not a == b интерпретируется как not (a == b) , а a == not b является синтаксической ошибкой.

Comparisons

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

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

идентичность объекта отрицания

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

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

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

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

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

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

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

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

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

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

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

Источник

Побитовые операторы Python: руководство

Несмотря на то, что Python не считается подходящим языком для низкоуровневого программирования, инструменты для этого у него всё же есть. Один из таких инструментов — побитовые (или битовые) операторы.

Побитовые операторы в Python предназначены для изменения строк с двоичным кодом, что может понадобиться для работы с криптографическими алгоритмами, драйверами различных устройств или, например, с сетевой инфраструктурой. Также они могут пригодиться для изменения графики низкого уровня и для любых других задач, где требуется выполнять различные действия с двоичным кодом.

Результатом действия побитовых операторов в Python является изменение объекта на уровне битов путем нескольких типов логических операций с двоичным кодом. Эти операции мы и рассмотрим в данной статье.

Побитовый вывод натуральных чисел

Поскольку мы будем работать с двоичным кодом, причем преимущественно с целыми числами, давайте сначала научимся выводить эти числа в нужном нам виде. Это делается очень просто:

Вот мы и получили бинарное представление числа 5. Впрочем, совсем ли бинарное? На самом деле 5 здесь — это последние три цифры ( 101 ), а код 0b используется в Python для вывода чисел в бинарном виде (есть и — 0b для отрицательных значений). Теперь мы можем вывести любое число в двоичном коде, а вот так будет выглядеть ноль и первая десятка:

>>> bin(0)
0b0
>>> bin(1)
0b1
>>> bin(2)
0b10
>>> bin(3)
0b11
>>> bin(4)
0b100
>>> bin(5)
0b101
>>> bin(6)
0b110
>>> bin(7)
0b111
>>> bin(8)
0b1000
>>> bin(9)
0b1001
>>> bin(10)
0b1010

Из этого ряда понятен принцип битового представления чисел: единицы последовательно заменяют нули, а когда все значения достигают 1, добавляется новый разряд. Досчитаем до 15:

>>> bin(11)
0b1011
>>> bin(12)
0b1100
>>> bin(13)
0b1101
>>> bin(14)
0b1110
>>> bin(15)
0b1111

Четвертый разряд исчерпан (заполнен единицами), поэтому далее в дело вступает пятый, и числа 16 и 17 будут записаны уже так:

>>> bin(16)
0b10000
>>> bin(17)
0b10001

Таким образом, двоичный код организован строго по законам математики: три разряда битов будет у чисел от 4 до 7, четвертый добавляется для чисел от 8 до 15, пять разрядов будет у чисел с 16 до 31, шесть — с 32 до 63, семь — с 64 до 127 и т. д. То есть новый разряд добавляется при очередном умножении на два. Это полезно знать при сравнении операндов с разной разрядностью: в этом случае у операнда с меньшим числом разрядов можно добавить соответствующее число нулей сразу после 0b .

Типы основных битовых операторов Python

Теперь мы готовы оперировать битами, используя логику следующих инструментов:

& (AND, И)

Логика работы: при сравнении двух бит (в одном и том же разряде) & выдает 1 (то есть бит будет скопирован), если бит есть в обоих сравниваемых операндах, и 0, если это условие не выполняется (то есть бит отсутствует хотя бы в одном из операндов). Схематически работу & можно представить так:

Это самое жесткое условие, когда бит возвращается (выдается 1) только в случае, если он был в обоих операндах. Теперь примеры:

Добавляем тройке третий разряд для удобства представления и видим, что только средние биты присутствуют у обоих значений (по 1 в каждом числе), поэтому возвращается такое число: 0b010, а это 2.

24 = 0b011000
62 = 0b111110
24 = 0b011000

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

>>> 555 & 878
554

555 = 0b1000101011
878 = 0b1101101110
554 = 0b1000101010

А теперь примеры посложнее, попрактикуемся с числами с разным количеством разрядов:

>>> 80 & 755
80

80 = 0b0001010000
755 = 0b1011110011
80 = 0b0001010000

>>> 446 & 19
18

446 = 0b110111110
19 = 0b000010011
18 = 0b000010010

>>> 101 & 883
97

101 = 0b0001100101
883 = 0b1101110011
97 = 0b0001100001

| (OR, ИЛИ)

Логика работы: при сравнении двух бит | выдает 1 (бит будет скопирован), если бит есть хотя бы в одном из сравниваемых операндах, и 0, если он отсутствует в обоих. Схематически работу | можно представить так:

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

>>> 9 | 5
13

9 = 0b1001
5 = 0b0101
13 = 0b1101

Бит не копируется только во втором разряде (справа), поскольку там нули у обоих операндов, в результате возвращается 13.

>>> 87 | 59
127

87 = 0b1010111
59 = 0b0111011
127 = 0b1111111

>>> 846 | 657
991

846 = 0b1101001110
657 = 0b1010010001
991 = 0b1111011111

И задачи посложнее, с уже знакомыми цифрами, но совершенно иными результатами:

>>> 80 | 755
755

80 = 0b0001010000
755 = 0b1011110011
755 = 0b1011110011

>>> 446 | 19
447

446 = 0b110111110
19 = 0b000010011
447 = 0b110111111

>>> 101 | 883
887

101 = 0b0001100101
883 = 0b1101110011
887 = 0b1101110111

^ (XOR, исключающее ИЛИ)

Логика работы: при сравнении двух бит ^ выдает 1 (бит будет скопирован), если сравниваемые операнды различаются, и 0, если они одинаковы. Схематически работу ^ можно представить так:

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

>>> 5 ^ 2
7

5 = 0b0101
2 = 0b0010
7 = 0b0111

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

>>> 90 ^ 92
6

90 = 0b1011010
92 = 0b1011100
6 = 0b0000110

>>> 352 ^ 686
974

352 = 0b0101100000
686 = 0b1010101110
974 = 0b1111001110

Несколько примеров с операндами с разным количеством разрядов:

>>> 80 | 755
675

80 = 0b0001010000
755 = 0b1011110011
675 = 0b1010100011

>>> 446 | 19
429

446 = 0b110111110
19 = 0b000010011
429 = 0b110101101

>>> 101 | 883
790

101 = 0b0001100101
883 = 0b1101110011
790 = 0b1100010110

~ (NOT, НЕ)

~ не сравнивает значения, а переворачивает биты в целочисленных значениях. При этом учтите, что положительные числа будут преобразованы в отрицательные со сдвигом на единицу, и наоборот. Работает это так:

>>> ~0
-1
>>> ~30
-31
>>> ~-30
29
>>> ~80
-81
>>> ~-80
79
>>> ~255
-256
>>> ~-255
254

Побитовые сдвиги влево и вправо

Сдвинули 1 на 1 бит и получили 2, потому что:

то есть, единица переместилась на одну позицию влево. А если переместить на две?

Нетрудно догадаться, что даст сдвиг единицы на 3 позиции:

Вот еще пара примеров с раскладкой по битам:

>>> 10 20

10 = 0b01010
20 = 0b10100

>>> 10 40

10 = 0b001010
40 = 0b101000

Правый сдвиг обозначается символами >> , и точно так же слева пишется изменяемое число, а справа от оператора указывается количество бит, на которое выполняется сдвиг. Это обратная операция, поэтому:

>>> 2 >> 1
1
>>> 4 >> 2
1
>>> 8 >> 3
1
>>> 40 >> 1
20
>>> 40 >> 2
10

Практическое применение в программировании

• Одна из областей IT, где активно используются битовые операции (в особенности сдвиги) — криптография. Сдвиговые операции позволяют изменять значения данных так, что без наличия ключей, хранящих первоначальные значения, дешифрование становится невозможным.
• Следующая область применения битовых операций: сетевые технологии, где действия над битами необходимы для проверки соответствия адресов и подсетей.
• А практика побитовых операций & и | поможет вам лучше понять принцип работы операторов and и or в Python и то, как работают любые другие программы, где используется Булева логика, основанная на значениях True (1) и False (0).

Источник