And operation in python example

Побитовые операторы 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).

Источник

Python Logical AND Operator

To perform logical AND operation in Python, use and keyword.

In this tutorial, we shall learn how and operator works with different permutations of operand values, with the help of well detailed example programs.

Syntax of and Operator

The syntax of python and operator is:

result = operand1 and operand2

and operator returns a boolean value: True or False.

Truth Table

The following table provides the return value for different combinations of operand values.

Operand1	Operand2	Return Value
True	True	True
True	False	False
False	True	False
False	False	False

Examples

1. Python and operator with boolean values

In the following example, we take different sets of boolean values into two variables and perform logical and operation between them.

Python Program

#True and True a = True b = True c = a and b print(a,'and',b,'is:',c) #True and False a = True b = False c = a and b print(a,'and',b,'is:',c) #False and True a = False b = True c = a and b print(a,'and',b,'is:',c) #False and False a = False b = False c = a and b print(a,'and',b,'is:',c)

True and True is: True True and False is: False False and True is: False False and False is: False

2. AND Operator with non-boolean operands

When using and operator in boolean expressions, you can also use non-zero numbers instead of True and 0 instead of False.

In the following example, we shall explore the aspect of providing integer values as operands to and operator.

Python Program

#True and True a = 5 b = 3 c = a and b print(a,'and',b,'is:',c) #True and False a = 8 b = 0 c = a and b print(a,'and',b,'is:',c) #False and True a = 0 b = -8 c = a and b print(a,'and',b,'is:',c) #False and False a = 0 b = 0 c = a and b print(a,'and',b,'is:',c)

5 and 3 is: 3 8 and 0 is: 0 0 and -8 is: 0 0 and 0 is: 0

Summary

In this tutorial of Python Examples, we learned how to use and keyword to perform Logical AND Operation in Python.

Источник

Python Оператор AND

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

В Python есть два типа операторов AND:

Логический оператор И

Логический оператор И работает с логическими значениями и приводит к истинному или ложному результату в зависимости от условия. Оператор and возвращает True, если оба операнда имеют значение True, в противном случае он возвращает False.

num1 = int(input('Enter first number:\n')) num2 = int(input('Enter second number:\n')) if num1 > num2 and num1 < 10: print('True') elif num1 < 0 and num2 < 0: print('Both the numbers are negative.') else: print('False')

Введите первое число: 9 Введите второе число: 5 Верно

Перегрузка логического оператора

Логические операторы Python работают с логическими значениями. По умолчанию логическое значение объекта — True. Если объект — None или False, то значение — False. Мы можем предоставить реализацию __bool __() для изменения логических значений объекта по умолчанию.

class Data: def __init__(self, i): self.id = i def __bool__(self): return self.id % 2 == 0 d1 = Data(6) d2 = Data(4) print(bool(Data(3)) and bool(Data(4))) # False

Приведенный выше фрагмент кода напечатает False, потому что логическое значение Data (3) — False.

Если мы удалим реализацию функции __bool __(), оба значения объектов данных будут True и будут напечатаны True.

Побитовый оператор И

Побитовые операторы работают с битами. Он возвращает 1, когда оба бита операндов равны 1, иначе он возвращает 0 (ноль).

ab = 0110 0100 = 0100 = 4 (десятичный)

Побитовая перегрузка оператора

Существуют различные определенные методы перегрузки побитовых операторов в Python.

Побитовый оператор	Syntax
&	__and __ (self, other)
|	__или __ (self, other)
^	__xor __ (self, other)
~	__invert __ (self)
	__lshift __ (self, other)
>>	__rshift __ (self, other)

class Operate(): def __init__(self, x): self.x = x def __and__(self, res): print("Bitwise AND operator overloading Example") if isinstance(res, Operate): return self.x res.x else: raise ValueError("Must belong to Operate Class") if __name__ == "__main__": a = Operate(6) b = Operate(4) print(ab)

Bitwise AND operator overloading Example 4

Порядок оценки

Выполнение операндов через операторы происходит left to right .

def evaluate(n): print("Function called for operand:", n) return True if n > 0 else False x = evaluate y = evaluate z = evaluate if x(-1) or y(5) and z(10): print("One of the numbers is positive.")

Функция, вызываемая для операнда: 5 Функция, вызываемая для операнда: 10 Одно из чисел положительное.

Источник