Python Precedência dos Operadores

Quanto é 2 + 3 * 4? Se você fizer a conta da esquerda para a direita, dá 20. O Python responde 14. Ele não errou: ele segue a mesma regra que você aprendeu na escola, a multiplicação vem antes da soma. Essa regra de "quem vai primeiro" se chama precedência (do latim, "ir na frente"). Nesta aula você vai ver a ordem completa, do ** até o or, e o que fazer quando quiser outra ordem: parênteses.

Você vai aprender

Por que 2 + 3 * 4 dá 14, e como os parênteses mudam a conta.
A potência **, que vem antes de tudo, até do sinal de menos: -2 ** 2 dá -4.
O que acontece quando dois operadores têm a mesma força: da esquerda para a direita (com uma exceção).
Onde entram as comparações (>, ==, in, is) e o not, o and e o or.
O erro mais comum de todos: a média calculada sem parênteses. E o TypeError real de um texto somado com uma conta.
A tabela completa, do mais forte para o mais fraco.

A ideia: a ordem das tarefas

A Ana vai fazer um bolo. A receita diz: "misture a farinha com os ovos, leve ao forno". Ninguém leva a farinha ao forno antes de misturar: há uma ordem. Numa conta é igual. Quando a expressão tem vários operadores, o Python não sai fazendo na ordem em que eles aparecem; ele segue uma lista de prioridades, a mesma da matemática da escola:

Primeiro, o que está entre parênteses.
Depois, a potência (**).
Depois, multiplicação e divisão (*, /, //, %).
Por último, soma e subtração (+, -).

Os operadores que você conheceu na aula Operadores Aritméticos estão todos nessa lista. As comparações e o and/or entram depois deles, como você vai ver na seção 5.

1. Multiplicação antes da soma

$ python3
Python 3.14.4 (main, Aug 20 2026, 10:41:58) [GCC 15.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> 2 + 3 * 4
14
>>> (2 + 3) * 4
20
>>> exit()

2 + 3 * 4: O * tem mais força que o +. O Python faz primeiro 3 * 4, que dá 12, e depois 2 + 12: 14.
(2 + 3) * 4: Os parênteses dizem "isto primeiro". O Python faz 2 + 3, que dá 5, e depois 5 * 4: 20.

Um jeito de ver o que o Python enxerga é imaginar os parênteses que ele "põe sozinho": 2 + 3 * 4 é lido como 2 + (3 * 4).

Um exemplo da vida da Ana: uma blusa de 50 reais com 10% de desconto.

preco = 50
desconto = 10

preco_final = preco - preco * desconto / 100
print("Preço final:", preco_final)

$ python3 desconto.py
Preço final: 45.0

O Python fez preco * desconto (500), depois / 100 (5.0) e só no fim preco - 5.0: 45.0. Aqui a ordem natural era exatamente a que a Ana queria, e nenhum parêntese foi preciso. (O resultado tem .0 porque a divisão / sempre dá um float, como você viu em Números.)

2. A potência vem antes de tudo

A potência, **, é o operador de conta mais forte. Ela vem antes da multiplicação:

$ python3
Python 3.14.4 (main, Aug 20 2026, 10:41:58) [GCC 15.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> 2 * 3 ** 2
18
>>> (2 * 3) ** 2
36
>>> -2 ** 2
-4
>>> (-2) ** 2
4
>>> exit()

2 * 3 ** 2: primeiro 3 ** 2 (9), depois 2 * 9: 18.
(2 * 3) ** 2: primeiro 2 * 3 (6), depois 6 ** 2: 36.
-2 ** 2 dá -4, e não 4! O sinal de menos na frente de um número é um operador também, e ele é mais fraco que a potência. O Python lê -(2 ** 2): eleva 2 ao quadrado (4) e depois troca o sinal.
Para elevar o menos dois ao quadrado, ponha parênteses: (-2) ** 2 dá 4.

É assim na matemática também

Na escola, −2² também vale −4: o expoente fica "grudado" no 2, e não no sinal. O Python segue a mesma convenção. Na dúvida, parênteses.

3. Mesma força: da esquerda para a direita

E quando dois operadores têm a mesma força, como - e -, ou / e *? Aí o Python vai da esquerda para a direita, como você lê:

$ python3
Python 3.14.4 (main, Aug 20 2026, 10:41:58) [GCC 15.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> 10 - 4 - 3
3
>>> 10 - (4 - 3)
9
>>> 100 / 10 * 2
20.0
>>> 100 / (10 * 2)
5.0
>>> 17 // 5 * 2
6
>>> exit()

10 - 4 - 3 é (10 - 4) - 3: 6 menos 3, 3. Com os parênteses no outro lugar, 10 - (4 - 3) é 10 menos 1: 9.
100 / 10 * 2 é (100 / 10) * 2: 10.0 vezes 2, 20.0. Muita gente espera 5, achando que a multiplicação vem antes. Não vem: * e / têm a mesma força, e vale a ordem da leitura.
17 // 5 * 2: a divisão inteira // também tem a força do *. 17 // 5 dá 3, vezes 2: 6.

A exceção: a potência vai da direita para a esquerda

$ python3
Python 3.14.4 (main, Aug 20 2026, 10:41:58) [GCC 15.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> 2 ** 3 ** 2
512
>>> (2 ** 3) ** 2
64
>>> exit()

2 ** 3 ** 2 é lido como 2 ** (3 ** 2): primeiro 3 ** 2 (9), depois 2 ** 9: 512. É a única exceção da tabela, e também segue a matemática (numa "torre" de expoentes, a conta começa por cima). Se você quer o outro jeito, (2 ** 3) ** 2 dá 8 ao quadrado: 64.

Missão: a Ana tirou 7 e 9 nas provas. A média deveria ser 8, mas o programa mostra 11.5. Ponha parênteses no lugar certo.

nota1 = 7
nota2 = 9
media = nota1 + nota2 / 2
print("Média:", media)

nota1 = 7
nota2 = 9
media = (nota1 + nota2) / 2
print("Média:", media)

Por que 11.5? Sem parênteses, o Python fez primeiro nota2 / 2 (4.5) e depois 7 + 4.5. A seção Quando dá errado volta a esse erro, que é o mais comum desta aula.

4. Contas antes das comparações

As comparações (>, <, ==, !=, e também in e is, da aula is e in) são mais fracas que todas as contas. Então o Python primeiro calcula os dois lados e só depois compara:

$ python3
Python 3.14.4 (main, Aug 20 2026, 10:41:58) [GCC 15.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> 2 + 3 > 4
True
>>> x = 5
>>> 1 < x < 10
True
>>> exit()

2 + 3 > 4 é (2 + 3) > 4, isto é, 5 > 4: True. É o que você esperaria, e por isso quase nunca se põe parênteses em volta das contas de uma comparação.

Todas as comparações têm a mesma força entre si, e o Python faz uma coisa especial quando elas aparecem em fila: 1 < x < 10 quer dizer "1 < x e x < 10", como na matemática. É a comparação encadeada, que a aula Comparações apresenta. Ela é ótima para faixas de valores, mas tem uma armadilha, que está em Quando dá errado.

5. `not`, depois `and`, depois `or`

Os operadores lógicos da aula and, or e not são os mais fracos de todos, e também têm uma ordem entre eles: not primeiro, depois and, por último or. (Um jeito de lembrar: o and é como uma multiplicação, e o or, como uma soma.)

$ python3
Python 3.14.4 (main, Aug 20 2026, 10:41:58) [GCC 15.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> True or False and False
True
>>> (True or False) and False
False
>>> not True == False
True
>>> not 5 > 3 and 2 > 1
False
>>> exit()

True or False and False: o and vai primeiro. False and False dá False; depois, True or False: True.
Com parênteses, (True or False) and False é True and False: False. Os mesmos valores, outra resposta.
not True == False: o not é mais fraco que o ==! O Python lê not (True == False), isto é, not False: True.
not 5 > 3 and 2 > 1 é (not (5 > 3)) and (2 > 1): False and True, False.

Agora um caso de verdade. No cinema do bairro, a meia-entrada vale para crianças (menos de 12 anos) e idosos (60 ou mais), mas sempre com a carteirinha. O sobrinho da Ana tem 8 anos e esqueceu a carteirinha:

idade = 8
tem_carteirinha = False

print(idade < 12 or idade >= 60 and tem_carteirinha)
print((idade < 12 or idade >= 60) and tem_carteirinha)

$ python3 meia.py
True
False

A primeira linha deu True, e o menino entraria pagando meia sem carteirinha. Como o and vai antes do or, o Python leu idade < 12 or (idade >= 60 and tem_carteirinha): a carteirinha ficou exigida só dos idosos. A segunda linha, com parênteses em volta do "criança ou idoso", diz o que a regra diz: False.

Misturou and com or? Use parênteses

Mesmo quando a ordem natural já é a que você quer, os parênteses deixam claro para quem lê (inclusive você, daqui a um mês). Numa linha com and e or juntos, eles são quase obrigatórios.

A tabela completa

Do mais forte (feito primeiro) para o mais fraco (feito por último). Os que estão na mesma linha têm a mesma força e vão da esquerda para a direita (menos a potência):

Força	Operadores	Nome	Exemplo
1 (mais forte)	`( )`	Parênteses	`(2 + 3) * 4` → 20
2	`**`	Potência (da direita para a esquerda)	`2 3 2` → 512
3	`-x`, `+x`	Sinal na frente de um valor	`-2 ** 2` → -4
4	`*`, `/`, `//`, `%`	Multiplicação e divisões	`100 / 10 * 2` → 20.0
5	`+`, `-`	Soma e subtração	`2 + 3 * 4` → 14
6	`==`, `!=`, `<`, `<=`, `>`, `>=`, `in`, `not in`, `is`, `is not`	Comparações	`2 + 3 > 4` → True
7	`not`	"Não"	`not True == False` → True
8	`and`	"E"
9 (mais fraco)	`or`	"Ou"	`True or False and False` → True

A tabela oficial do Python tem mais alguns operadores, que você ainda não conhece (os que trabalham com os bits de um número, como & e |, o if/else numa linha e o lambda). A tabela inteira está na página Operadores da Referência.

Formas diferentes de escrever a mesma conta

A Ana quer converter 25 graus Celsius para Fahrenheit: multiplica por 9, divide por 5, soma 32. Três jeitos de escrever:

celsius = 25
fahrenheit = celsius * 9 / 5 + 32
print(fahrenheit)
print(((celsius * 9) / 5) + 32)
print(celsius * (9 / 5) + 32)

$ python3 temp.py
77.0
77.0
77.0

Forma	Quando usar
`celsius * 9 / 5 + 32`	Quando a ordem natural é óbvia (só `*`, `/` e `+`, como na escola). Limpa e correta
`((celsius * 9) / 5) + 32`	Evite: parênteses demais, que não mudam nada, cansam quem lê
`celsius * (9 / 5) + 32`	Boa quando o parêntese mostra uma ideia (aqui, "o fator 9/5")
`(nota1 + nota2) / 2`	Obrigatório: sem ele, a conta muda
`(a or b) and c`	Sempre que misturar `and` com `or`

A regra prática: parênteses quando mudam a conta, ou quando ajudam a ler. Ninguém precisa decorar a tabela inteira; precisa saber os casos comuns e, na dúvida, pôr parênteses.

Quando dá errado

A média sem parênteses: nenhuma mensagem, resposta errada

nota1 = 7
nota2 = 9
media = nota1 + nota2 / 2
print("Média:", media)

$ python3 media.py
Média: 11.5

O pior tipo de erro: o programa roda, não reclama de nada, e a resposta está errada. A média de 7 e 9 não pode ser 11.5 (a média nunca passa da maior nota). O Python fez o que está escrito: nota1 + (nota2 / 2), isto é, 7 + 4.5. Como consertar: media = (nota1 + nota2) / 2.

$ python3 media-certa.py
Média: 8.0

Desconfie sempre de um resultado que "não faz sentido", e confira a conta com números fáceis, de cabeça.

Um texto somado com uma conta: TypeError

quantidade = 2
preco = 3
print("Total: " + quantidade * preco)

$ python3 total.py
Traceback (most recent call last):
  File "/home/ana/total.py", line 3, in <module>
    print("Total: " + quantidade * preco)
          ~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~
TypeError: can only concatenate str (not "int") to str

File "/home/ana/total.py", line 3: O erro está na linha 3 do arquivo total.py.
~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~: As marcas embaixo da linha. O ^ aponta o operador que falhou: o +. Os ~ sublinham os dois lados dele: à esquerda, "Total: "; à direita, quantidade * preco inteiro. É a precedência aparecendo na mensagem: a multiplicação já tinha sido feita (deu 6), e o + recebeu o texto e o número 6.
TypeError:: "Erro de tipo".
can only concatenate str (not "int") to str: "Só dá para concatenar (juntar) um str (texto) com outro str, e não com um int (número inteiro)." O + entre textos junta; entre números, soma; entre um texto e um número, o Python não sabe o que você quer.

Como consertar: transforme o resultado em texto com str(), ou deixe o print separar as partes com vírgula:

quantidade = 2
preco = 3
print("Total: " + str(quantidade * preco))
print("Total:", quantidade * preco)

$ python3 total-certo.py
Total: 6
Total: 6

Juntar textos com + é o assunto da aula Juntar e Repetir Textos; o jeito mais prático de misturar texto e números, as f-strings, tem aula própria.

== True no fim de uma comparação

A Ana quer saber se o primo dela, de 15 anos, tem mais de 12. Ela escreveu == True no fim, "para garantir":

idade = 15
print(idade > 12 == True)
print((idade > 12) == True)
print(idade > 12)

$ python3 encadeada.py
False
True
True

A primeira linha deu False, sem erro nenhum. O > e o == têm a mesma força, e comparações em fila viram uma comparação encadeada: idade > 12 == True quer dizer idade > 12 and 12 == True. E 12 não é igual a True. Como consertar: não escreva == True. A comparação idade > 12 já é True ou False sozinha (terceira linha).

Uma conta do lado esquerdo do =

$ python3
Python 3.14.4 (main, Aug 20 2026, 10:41:58) [GCC 15.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> x = 5
>>> 2 + 3 = x
  File "<python-input-1>", line 1
    2 + 3 = x
    ^^^^^
SyntaxError: cannot assign to expression here. Maybe you meant '==' instead of '='?
>>> exit()

O = não é um operador de conta: ele guarda o valor da direita no nome da esquerda (aula Variáveis), e por isso fica fora da tabela de precedência, por último de tudo. cannot assign to expression here quer dizer "não dá para guardar um valor numa expressão (2 + 3)". O Python ainda pergunta: "talvez você quisesse == em vez de =?". Como consertar: para guardar, o nome vem à esquerda (x = 2 + 3); para comparar, 2 + 3 == x.

Missão: a Ana e dois amigos pediram 2 lanches de 12 reais, com 3 reais de entrega, e vão dividir a conta por 3. Cada um deveria pagar 9 reais, mas o programa diz 25. Conserte a conta com parênteses.

lanches = 2
preco_lanche = 12
entrega = 3
pessoas = 3

cada_um = lanches * preco_lanche + entrega / pessoas
print("Cada um paga:", cada_um)

lanches = 2
preco_lanche = 12
entrega = 3
pessoas = 3

cada_um = (lanches * preco_lanche + entrega) / pessoas
print("Cada um paga:", cada_um)

Referência rápida

Regra	Exemplo	O Python lê como	Resultado
`*` antes de `+`	`2 + 3 * 4`	`2 + (3 * 4)`	`14`
`*` antes de ``	`2 * 3 ** 2`	`2 * (3 ** 2)`	`18`
`**` antes do sinal	`-2 ** 2`	`-(2 ** 2)`	`-4`
Mesma força: esquerda → direita	`100 / 10 * 2`	`(100 / 10) * 2`	`20.0`
`**`: direita → esquerda	`2 3 2`	`2 (3 2)`	`512`
Contas antes de comparações	`2 + 3 > 4`	`(2 + 3) > 4`	`True`
Comparações em fila	`1 < x < 10`	`1 < x and x < 10`	`True` (com `x = 5`)
`and` antes de `or`	`True or False and False`	`True or (False and False)`	`True`
`not` depois das comparações	`not True == False`	`not (True == False)`	`True`

Exercícios

1. Faça de cabeça

Quanto o Python mostra para print(10 + 2 * 5)?

2. Agora com parênteses

E para print((10 + 2) * 5)?

3. Da esquerda para a direita

Quanto vale 20 - 10 - 5?

4. Quanto vale 2 ** 2 * 3?

64 81 12 7

5. Quanto vale not False and False?

True, porque o not vale para tudo o que vem depois False: o not vai primeiro (not False é True), depois True and False Dá erro None

6. Qual conta dá a média certa de a, b e c?

(a + b + c) / 3 a + b + c / 3 a + (b + c) / 3 a + b + (c / 3)

7. Quanto vale 3 + 4 * 2 > 10?

False, porque (3 + 4) * 2 é 14 Dá TypeError 11 True, porque 3 + 8 é 11, que é maior que 10

Missão final: o preço da potência

Missão: a Ana quer a área de um quadrado de lado 4 + 2 (o lado é a soma de duas tábuas). A área é o lado ao quadrado, então deveria dar 36. O programa diz 8. Conserte.

tabua1 = 4
tabua2 = 2
area = tabua1 + tabua2 ** 2
print("Área:", area)

tabua1 = 4
tabua2 = 2
area = (tabua1 + tabua2) ** 2
print("Área:", area)

Resumo

Precedência é a ordem em que o Python faz as operações de uma expressão: parênteses, **, sinal, * / // %, + -, comparações, not, and, or.
Operadores de mesma força vão da esquerda para a direita (100 / 10 * 2 dá 20.0); a exceção é a potência, que vai da direita para a esquerda (2 ** 3 ** 2 dá 512).
-2 ** 2 dá -4: a potência vem antes do sinal. Para o quadrado de −2, (-2) ** 2.
O erro mais comum é a média sem parênteses: nota1 + nota2 / 2. Ele não dá mensagem nenhuma; só a resposta errada.
Misturou and e or? Parênteses. E nunca termine uma comparação com == True.
Na dúvida, parênteses: eles nunca atrapalham a conta, e ajudam quem lê.