2.3. Operações matemáticas

O Python funciona como uma calculadora desde o início. Esta página aborda os operadores que você usará com mais frequência: aritmética com números, comparações que produzem booleanos, operadores lógicos que combinam condições e operadores bit a bit para trabalho em nível de hardware.

2.3.1. Aritmética

Os operadores aritméticos padrão sobre valores int e float:

  • + – adição

  • - – subtração (ou negação, como prefixo: -x)

  • * – multiplicação

  • / – divisão. Retorna sempre um float, mesmo quando ambos os operandos são inteiros.

  • // – divisão inteira (floor division). Retorna o quociente inteiro arredondado em direção a menos infinito.

  • % – módulo (resto).

  • ** – exponenciação (2 ** 10 é 1024).

>>> 7 / 2
3.5
>>> 7 // 2
3
>>> -7 // 2
-4
>>> 7 % 2
1
>>> 2 ** 16
65536

A aritmética de tipos mistos promove inteiros para floats automaticamente:

>>> 3 + 0.5
3.5

A atribuição aumentada combina o operador com = para uma atualização compacta no local:

counter = 0
counter += 1                # equivalent to counter = counter + 1
counter *= 2                # works for *= /= //= %= **= too

A precedência dos operadores segue a ordem convencional: ** primeiro, depois - unário, depois *, /, // e %, depois + e -. Use parênteses quando estiver em dúvida – eles não custam nada em tempo de execução.

2.3.2. Comparação

Os operadores de comparação retornam um bool (True ou False):

  • == e != – igual / diferente.

  • <, <=, >, >= – ordenação.

>>> 3 == 3
True
>>> 3 == 3.0
True
>>> 3 < 5 <= 5
True

O último exemplo é uma comparação encadeada e é exatamente equivalente a 3 < 5 and 5 <= 5.

Aviso

= atribui; == compara. A expressão if x = 5: é um erro de sintaxe justamente porque o Python se recusa a confundir os dois silenciosamente.

2.3.3. Lógica booleana

Três operadores combinam booleanos:

  • and – True somente quando ambos os lados são verdadeiros.

  • or – True quando qualquer um dos lados é verdadeiro.

  • not – inverte um único booleano.

and e or fazem curto-circuito: param de avaliar assim que o resultado é conhecido. False and slow_check() nunca chama slow_check.

and e or também retornam um de seus operandos em vez de um literal True ou False, o que permite escrever valores padrão de forma compacta:

name = user_name or "anonymous"   # "" / 0 / None are falsy

2.3.4. Operadores bit a bit

Para trabalho com hardware – empacotar campos de registradores, mascarar bits, analisar cabeçalhos de protocolos – você recorrerá aos operadores bit a bit. Eles atuam sobre a representação binária de um int:

  • & – AND bit a bit

  • | – OR bit a bit

  • ^ – XOR bit a bit

  • ~ – NOT bit a bit (complemento de um)

  • << – deslocamento à esquerda

  • >> – deslocamento à direita

As formas literais hexadecimais e binárias são convenientes ao ler e escrever esses valores:

>>> 0b1100 & 0b1010
8                              # 0b1000
>>> 0b1100 | 0b1010
14                             # 0b1110
>>> 0xFF ^ 0x0F
240                            # 0xF0
>>> 1 << 8
256
>>> (0xABCD >> 8) & 0xFF
171                            # extract the high byte

Existem formas aumentadas para cada um: |=, &=, ^=, <<=, >>=.

Nota

and / or operam sobre booleanos (ou sobre a veracidade); & / | operam sobre bits. Não os confunda. 0b1100 and 0b1010 resulta em 0b1010 porque ambos os operandos são verdadeiros – não é o que você normalmente quer ao manipular bits.

2.3.5. Funções embutidas úteis para números

Um punhado de funções embutidas cobre operações numéricas comuns que apenas os operadores não cobrem:

  • round() – inteiro mais próximo, ou as ndigits casas decimais mais próximas quando um segundo argumento é fornecido. Retorna um int para round(x) e um float para round(x, n). Empates (0.5, 1.5, …) são arredondados para o número par mais próximo, e não sempre para cima.

  • divmod() – retorna (quotient, remainder) em uma única chamada. Útil para dividir uma quantidade em unidades (segundos em minutos e segundos, bytes em páginas e deslocamentos).

  • pow() – o mesmo que ** na forma de dois argumentos. A forma de três argumentos pow(base, exp, mod) calcula (base ** exp) % mod sem nunca materializar o valor intermediário gigante, que é a única maneira prática de fazer exponenciação modular para expoentes grandes.

>>> round(3.7)
4
>>> round(3.14159, 2)
3.14
>>> round(0.5)               # ties go to even, not always up
0
>>> round(1.5)
2

>>> divmod(125, 60)          # 125 seconds = 2 min, 5 sec
(2, 5)
>>> minutes, seconds = divmod(125, 60)

>>> pow(3, 4)                # same as 3 ** 4
81
>>> pow(3, 100, 7)           # (3 ** 100) mod 7, efficient
4

As conversões de inteiro para string entre bases (bin, oct, hex) são abordadas em Métodos de string e formatação.

2.3.6. O módulo math

Funções matemáticas comuns residem no módulo math. Importe-o uma vez e chame suas funções por um nome com ponto:

import math

print(math.sqrt(2))              # 1.4142135
print(math.sin(math.pi / 2))     # 1.0
print(math.floor(3.7))           # 3
print(math.log(100, 10))         # 2.0

O módulo math do MicroPython cobre os suspeitos de sempre (sqrt, exp, log, sin, cos, tan, atan2, floor, ceil, pi, e, …). Para números aleatórios, veja o módulo random; para manipulação de bits em ponto fixo, os operadores acima geralmente são suficientes.

2.3.7. Números complexos

Para trabalho numérico que precisa de componentes imaginários, o Python tem um tipo complex com literais com sufixo j (1 + 2j). O módulo cmath espelha o math para entradas complexas. Ambos estão presentes na maioria das builds do MicroPython, mas raramente são necessários para trabalho com câmera; mencionamo-os principalmente para que não sejam uma surpresa caso você porte código que os utilize.