5 - Operações, Operandos e Operadores

Os Operadores de Atribuição são utilizados para o apontamento dos objetos de valores em variáveis.

Exemplos com operadores de atribuição:

Atribuição simples:

x = 5
print(x)

5

Atribuição de adição:

x = 5
x += 3
print(x)

8

Atribuição de subtração:

x = 5
x -= 3
print(x)

2

Atribuição de multiplicação:

x = 5
x *= 3
print(x)

15

Atribuição de divisão:

x = 5
x /= 3
print(x)

1.6666666666666667

Atribuição de parte inteira da divisão:

x = 5
x //= 3
print(x)

1

Atribuição de resto (módulo):

x = 5
x %= 3
print(x)

2

Atribuição de exponenciação:

x = 5
x **= 3
print(x)

125

Atribuição de and:

x = 5
x &= 3
print(x)

1

Atribuição de or:

x = 5
x |= 3
print(x)

7

Atribuição de xor:

x = 5
x ^= 3
print(x)

6

Atribuição de deslocamento para a direita:

Primeiro declaramos a função lambda nomeada msg que recebe um argumento x e retorna uma string contendo a representação binária de x.

msg = lambda x: f"{bin(x)[2:].zfill(8)} é a representação binária de {x}"

x = 224
print(msg(x))
x >>= 3
print(msg(x))

11100000 é a representação binária de 224
00011100 é a representação binária de 28

No exemplo a representação binária de x é alterada de '11111111' para '00011111', deslocando 3 bits para a direita e preenchendo com zeros a esquerda.

Atribuição de deslocamento para a esquerda:

x = 7
print(msg(x))
x <<= 3
print(msg(x))

00000111 é a representação binária de 7
00111000 é a representação binária de 56

No exemplo a representação binária de x é alterada de '00000101' para '00101000', deslocando 3 bits para a esquerda e preenchendo com zeros a direita.

Os operadores aritméticos são usados ​​com valores numéricos para realizar operações matemáticas comuns.

Exemplos:

print(f"Adição: 10 + 5 = {10 + 5}")
print(f"Subtração: 10 - 5 = {10 - 5}")
print(f"Multiplicação: 10 * 5 = {10 * 5}")
print(f"Divisão: 10 / 3 = {10 / 3}")
print(f"Módulo: 10 % 3 = {10 % 3}")
print(f"Exponenciação: 10 ** 5 = {10 ** 5}")
print(f"Inteiro da Divisão: 10 // 3 = {10 // 3}")

Adição: 10 + 5 = 15
Subtração: 10 - 5 = 5
Multiplicação: 10 * 5 = 50
Divisão: 10 / 3 = 3.3333333333333335
Módulo: 10 % 3 = 1
Exponenciação: 10 ** 5 = 100000
Inteiro da Divisão: 10 // 3 = 3

Os operadores de comparação são usados para comparar dois valores.

Exemplos:

x = 5
y = 10
print(f"x = {x}, y = {y}")
print(f"igual: x == y = {x == y}")
print(f"diferente: x != y = {x != y}")
print(f"maior: x > y = {x > y}")
print(f"menor: x < y = {x < y}")
print(f"maior ou igual: x >= y = {x >= y}")
print(f"menor ou igual: x <= y = {x <= y}")

x = 5, y = 10
igual: x == y = False
diferente: x != y = True
maior: x > y = False
menor: x < y = True
maior ou igual: x >= y = False
menor ou igual: x <= y = True

Os operadores lógicos são usados para combinar instruções condicionais.

Exemplos com os operadores lógicos usando as variáveis x e y.

x = 5
y = 10

Abaixo x é maior que 4 (verdadeiro) e y não é menor que 10: verdadeiro E falso = falso (True and False = False).

print(x > 4 and x < 10)

True

Abaixo x é maior que 4 (verdadeiro) e y não é menor que 10 (falso): verdadeiro OU falso = verdadeiro (True or False = True).

print(x > 4 or y < 10)

True

Abaixo a negação do resultado de x < 7 < y.

print(not(x < 7 < y))

False

Os operadores de identidade são usados para comparar os objetos, não se forem iguais, mas se forem realmente o mesmo objeto, com a mesma localização de memória.

Exemplos:

x = 5
y = 10
print(f"x = {x}, y = {y}")
print(f"x is y = {x is y}")
print(f"x is not y = {x is not y}")
y = x
print(f"y = x")
print(f"x is y = {x is y}")
print(f"x is not y = {x is not y}")

x = 5, y = 10
x is y = False
x is not y = True
y = x
x is y = True
x is not y = False

Os operadores de associação são usados para testar se um objeto é apresentada em uma sequência.

Exemplos:

x = 5
y = [0,5,10,15,20]
print(f"x = {x}, y = {y}")
print(f"x in y = {x in y}")
print(f"x not in y = {x not in y}")

x = 5, y = [0, 5, 10, 15, 20]
x in y = True
x not in y = False

Operadores bit a bit são usados para comparar números inteiros (binários).

Exemplos com os operadores bit a bit usando as variáveis x e y.

x = 170
y = 3
binario = lambda x: bin(x).split('b')[1].zfill(8)
xb = binario(x)
yb = binario(y)
print(f"{xb}={x}")
print(f"{yb}={y}")

10101010=170
00000011=3

Abaixo o operador & (AND BITWISE) do valor de x com o valor de y.

print(f"{xb} &")
print(f"{yb}")
print("--------")
print(f"{binario(x & y)} = {x & y}")

10101010 &
00000011
--------
00000010 = 2

Abaixo o operador | (OR BITWISE) do valor de x com o valor de y.

print(f"{xb} |")
print(f"{yb}")
print("--------")
print(f"{binario(x | y)} = {x | y}")

10101010 |
00000011
--------
10101011 = 171

Abaixo o operador ^ (XOR BITWISE) do valor de x com o valor de y.

print(f"{xb} ^")
print(f"{yb}")
print("--------")
print(f"{binario(x ^ y)} = {x ^ y}")

10101010 ^
00000011
--------
10101001 = 169

Abaixo o operador ~ (NOT BITWISE) do valor de x.

print(f"~{xb}")
print("--------")
print(f" {binario(~x)} = {~x}")

~10101010
--------
 10101011 = -171

Abaixo o operador << (LEFT SHIFT BITWISE) do valor de x com o valor de 3.

print(f"{xb} <<")
print(f"{yb}")
print("-----------")
print(f"{binario(x << y)} = {x << y}")

10101010 <<
00000011
-----------
10101010000 = 1360

Abaixo o operador >> (RIGHT SHIFT BITWISE) do valor de x com o valor de 3.

print(f"{xb} >>")
print(f"{yb}")
print("--------")
print(f"{binario(x >> y)} = {x >> y}")

10101010 >>
00000011
--------
00010101 = 21