2.3. Operações matemáticas

O Python funciona como uma calculadora de raiz. Esta página abrange os operadores que 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 ao nível do hardware.

2.3.1. Aritmética

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

  • + – adição

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

  • * – multiplicação

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

  • // – divisão inteira. Devolve o quociente inteiro arredondado para 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 com tipos mistos promove automaticamente inteiros para floats:

>>> 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 tiver dúvidas – não têm custo em tempo de execução.

2.3.2. Comparação

Os operadores de comparação devolvem 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 precisamente porque o Python recusa-se a confundir silenciosamente os dois.

2.3.3. Lógica booleana

Três operadores combinam booleanos:

  • and – True apenas 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 devolvem um dos seus operandos em vez de um True ou False literal, o que permite escrever valores predefinidos de forma compacta:

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

2.3.4. Operadores bit a bit

Para trabalho com hardware – compactar campos de registo, mascarar bits, analisar cabeçalhos de protocolo – recorrerá aos operadores bit a bit. 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 para um)

  • << – deslocamento à esquerda

  • >> – deslocamento à direita

As formas literais hexadecimal e binária são convenientes ao ler e escrever estes 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 verdade/falsidade); & / | operam sobre bits. Não os confunda. 0b1100 and 0b1010 avalia como 0b1010 porque ambos os operandos são verdadeiros – não é o que normalmente se quer ao manipular bits.

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

Um conjunto de funções incorporadas cobre operações numéricas comuns que os operadores por si só não cobrem:

  • round() – inteiro mais próximo, ou o número mais próximo com ndigits casas decimais quando é fornecido um segundo argumento. Devolve um int para round(x), um float para round(x, n). Os empates (0.5, 1.5, …) arredondam para o número par mais próximo, não sempre para cima.

  • divmod() – devolve (quotient, remainder) numa só 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 enorme valor intermédio, o que é a única forma 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 em diferentes bases (bin, oct, hex) são abordadas em Métodos de string e formatação.

2.3.6. O módulo math

As funções matemáticas comuns residem no módulo math. Importe-o uma vez e chame as suas funções através de 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 habituais (sqrt, exp, log, sin, cos, tan, atan2, floor, ceil, pi, e, …). Para números aleatórios, consulte o módulo random; para manipulação de bits em vírgula fixa, os operadores acima são geralmente suficientes.

2.3.7. Números complexos

Para trabalho numérico que requer componentes imaginárias, 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 compilações MicroPython, mas raramente são necessários para trabalho com câmara; mencionamo-los principalmente para que não sejam uma surpresa se migrar código que os utilize.