Python Operadores de Atribuição (+=)

Um programa vive atualizando valores: o estoque diminui a cada venda, o total do caixa aumenta a cada cliente, o preço sobe com o reajuste. Para mudar o valor de uma variável a partir do valor que ela já tem, você escreve estoque = estoque - 3. É tão comum que o Python tem um atalho: estoque -= 3. Nesta aula você vai entender o = de verdade (ele não é o "igual" da Matemática), conhecer os atalhos +=, -=, *= e companhia, e descobrir por que o contador++ de outras linguagens não existe no Python.

Você vai aprender

O que o = faz: guardar, e não comparar.
Por que estoque = estoque - 3 faz sentido no Python (e não na Matemática).
Os atalhos: +=, -=, *=, /=, //=, %= e **=.
A acumular um total começando do zero.
Que o += também junta textos.
Que o Python não tem ++ nem --, e o perigo do ++contador.
Os erros reais: += numa variável que não existe, =+ trocado, + = separado.

Os programas desta aula rodaram no Python 3.14 da máquina da Ana (usuária ana, computador notebook), e podem ser repetidos no editor do guia.

A ideia: o quadro do estoque

Na parede da padaria há um quadro branco com o estoque do dia: "Pães: 20". Quando um cliente leva 3, a Ana não escreve uma conta no quadro; ela lê o número que está lá (20), faz a conta de cabeça (20 − 3 = 17), apaga o 20 e escreve 17 no lugar.

Uma variável é esse quadro, e o = é o gesto de apagar e escrever. Ler, calcular, guardar de volta: é isso que fazem todos os operadores desta aula.

1. O `=` guarda, não compara

Na Matemática, x = x - 3 é um absurdo: nenhum número é igual a ele mesmo menos 3. No Python, o = não quer dizer "é igual". Ele é uma ordem: "calcule o que está à direita e guarde na variável da esquerda". Por isso ele se chama operador de atribuição (atribuir = dar um valor a alguém).

estoque = 20
print("Antes:", estoque)
estoque = estoque - 3
print("Depois:", estoque)

$ python3 estoque_menos.py
Antes: 20
Depois: 17

O que acontece na linha 3, passo a passo:

O Python olha só o lado direito: estoque - 3.
Lê o valor atual de estoque: 20.
Faz a conta: 20 − 3 = 17.
Só agora olha o lado esquerdo e guarda o 17 em estoque. O 20 é "apagado".

A ordem é sempre essa: primeiro a direita, depois a esquerda. Para perguntar se dois valores são iguais existe outro sinal, o ==, com dois iguais (aula Comparações).

2. O atalho: `+=` e `-=`

Escrever o nome da variável duas vezes, estoque = estoque - 3, cansa e abre espaço para erro de digitação. O atalho junta o operador com o =:

Escrita longa	Atalho	Lê-se
`estoque = estoque - 3`	`estoque -= 3`	"tire 3 do estoque"
`total = total + 4.5`	`total += 4.5`	"some 4,5 ao total"

O caso mais comum de todos é o acumulador: uma variável que começa em zero e vai somando. O caixa da padaria, venda por venda:

total = 0
total += 4.5
print(total)
total += 12.0
print(total)
total += 0.75
print("Total do dia:", total)

$ python3 caixa.py
4.5
16.5
Total do dia: 17.25

total = 0: O caixa abre zerado. Esse começo é obrigatório: o += precisa ler o valor que já existe. Você vai ver o erro em Quando dá errado.
total += 4.5: Primeira venda: 0 + 4,5 = 4,5.
total += 12.0: Segunda venda: 4,5 + 12 = 16,5.
total += 0.75: Terceira venda: 16,5 + 0,75 = 17,25.

O += e o operador + não têm espaço entre os dois sinais: é += grudado. Em volta dele, um espaço de cada lado, como em qualquer operador.

Missão: o caixa começa zerado e teve três vendas: R$ 4,50, R$ 6,00 e R$ 3,00. Some as três ao total usando +=, uma linha para cada venda.

total = 0
print("Total:", total)

total = 0
total += 4.5
total += 6.0
total += 3.0
print("Total:", total)

3. Todos os atalhos

Cada operador aritmético (aula Operadores Aritméticos) tem o seu atalho. Neste programa, a mesma variável passa por todos eles, um depois do outro:

x = 10
x += 5
print("+=", x)
x -= 3
print("-=", x)
x *= 2
print("*=", x)
x /= 4
print("/=", x)
x //= 2
print("//=", x)
x %= 2
print("%=", x)
y = 3
y **= 4
print("**=", y)

$ python3 todos.py
+= 15
-= 12
*= 24
/= 6.0
//= 3.0
%= 1.0
**= 81

Atalho	É o mesmo que	No programa
`x += 5`	`x = x + 5`	10 + 5 = 15
`x -= 3`	`x = x - 3`	15 − 3 = 12
`x *= 2`	`x = x * 2`	12 × 2 = 24
`x /= 4`	`x = x / 4`	24 ÷ 4 = 6.0 (a divisão `/` sempre dá `float`)
`x //= 2`	`x = x // 2`	6.0 // 2 = 3.0 (continua `float`)
`x %= 2`	`x = x % 2`	o resto de 3.0 ÷ 2 = 1.0
`y **= 4`	`y = y ** 4`	3⁴ = 81

Repare que, depois do /=, o x virou float e nunca mais voltou a ser int: os atalhos seguem as mesmas regras dos operadores. Isso pega muita gente de surpresa:

paes = 12
paes /= 2
print(paes)
print(type(paes))

$ python3 metade.py
6.0
<class 'float'>

Para continuar com um inteiro, use paes //= 2.

O reajuste de preço com `*=`

Um aumento de 10% é multiplicar por 1,10. Com o atalho:

preco = 20.0
preco *= 1.10
print(preco)

$ python3 aumento.py
22.0

4. O `+=` com textos

Como o + junta textos, o += acrescenta um pedaço ao fim de um texto:

mensagem = "Bom dia"
mensagem += ", Ana"
mensagem += "!"
print(mensagem)

$ python3 texto_mais.py
Bom dia, Ana!

O *= também funciona com texto (repete), como o *. Mais sobre isso na aula Juntar e Repetir Textos.

5. O Python não tem `++`

Em C, Java e JavaScript, contador++ soma 1 a uma variável. O Python não tem esse operador, de propósito: contador += 1 já é curto e não deixa dúvida. Veja o que acontece quando alguém acostumado com outra linguagem tenta:

contador = 0
contador++
print(contador)

$ python3 mais_mais.py
  File "/home/ana/mais_mais.py", line 2
    contador++
              ^
SyntaxError: invalid syntax

Pelo menos, aqui, o Python reclama. Pior é com os sinais antes do nome:

contador = 0
++contador
print(contador)

$ python3 mais_mais2.py
0

Nenhum erro, e o contador continua zero. Para o Python, ++contador é +(+contador): o sinal de "mais" duas vezes, como em "mais mais 5", que continua sendo 5. A linha calcula um valor, não guarda em lugar nenhum, e segue em frente. O mesmo vale para --contador (menos com menos dá mais). Para somar 1, escreva contador += 1.

Formas diferentes de atualizar uma variável

Forma	Quando usar
`estoque -= 3`	O costume: curto e claro, sempre que a variável é atualizada a partir dela mesma
`estoque = estoque - 3`	Funciona igual. Útil enquanto você se acostuma, ou quando a conta é mais complicada que um operador só
`novo_estoque = estoque - 3`	Quando você quer manter o valor antigo (para comparar, mostrar o "antes"…)
`estoque += 3 * 10`	O lado direito pode ser uma conta inteira: ela é feita primeiro (3 × 10 = 30) e só então somada
`contador += 1`	Contar de um em um. No Python, nunca `contador++`

Mais dois jeitos de atribuir

O = tem outras formas que você vai encontrar: a = b = 0 guarda o mesmo valor em duas variáveis, e nome, idade = "Ana", 30 guarda dois valores de uma vez (aula Atribuição Múltipla). Existe ainda o :=, apelidado de "operador morsa" (o sinal lembra os olhos e as presas de uma morsa), que guarda um valor no meio de uma expressão; ele é mais avançado e só aparece em casos especiais.

Quando dá errado

+= numa variável que não existe: NameError

A Ana esqueceu de abrir o caixa com zero:

total += 4.5
print(total)

$ python3 sem_inicio.py
Traceback (most recent call last):
  File "/home/ana/sem_inicio.py", line 1, in <module>
    total += 4.5
    ^^^^^
NameError: name 'total' is not defined

line 1: O erro está na linha 1.
^^^^^: Os chapeuzinhos marcam o total.
NameError: name 'total' is not defined: "Erro de nome: o nome 'total' não está definido". O += é "leia o valor atual e some 4,5", mas não há valor atual para ler: a variável ainda não existe.

Como consertar: dê um valor inicial antes do primeiro +=: total = 0.

=+ no lugar de +=: não dá erro, mas não soma

total = 10
total =+ 5
print(total)

$ python3 invertido.py
5

Esperava 15, veio 5, e sem nenhum aviso. Com os sinais trocados, o Python leu total = +5: "guarde o número mais cinco". O 10 foi apagado. É um erro silencioso, difícil de achar. Como consertar: o sinal da conta vem antes do igual: +=, -=. (Uma dica para lembrar: é a mesma ordem da fala, "mais igual".)

Espaço no meio: + =

total = 10
total + = 5

$ python3 espaco.py
  File "/home/ana/espaco.py", line 2
    total + = 5
            ^
SyntaxError: invalid syntax

Os dois sinais formam um operador só e precisam ficar grudados. Separados, o Python vê um + sem nada à direita e, logo depois, um = perdido; o chapeuzinho aponta o =. Como consertar: total += 5.

Somar um número a um texto: TypeError

mensagem = "Pedido número "
mensagem += 7
print(mensagem)

$ python3 texto_num.py
Traceback (most recent call last):
  File "/home/ana/texto_num.py", line 2, in <module>
    mensagem += 7
TypeError: can only concatenate str (not "int") to str

A mesma mensagem do "texto" + 7: só dá para juntar texto com texto. Como consertar: mensagem += str(7) (aula Conversão de Tipos).

Referência rápida

Operador	Exemplo	É o mesmo que
`=`	`x = 5`	Guarda 5 em `x`
`+=`	`x += 5`	`x = x + 5`
`-=`	`x -= 5`	`x = x - 5`
`*=`	`x *= 5`	`x = x * 5`
`/=`	`x /= 5`	`x = x / 5` (vira `float`)
`//=`	`x //= 5`	`x = x // 5`
`%=`	`x %= 5`	`x = x % 5`
`**=`	`x **= 5`	`x = x ** 5`

Sintoma	Causa provável
`NameError: name 'total' is not defined` num `+=`	Faltou o valor inicial (`total = 0`)
O valor foi trocado em vez de somado, sem erro	`=+` no lugar de `+=`
`SyntaxError: invalid syntax` em `x++` ou `x + = 1`	Não existe `++`; e o `+=` vai grudado
O contador não sai do zero, sem erro	`++contador` não faz nada: use `contador += 1`
Um inteiro virou `6.0`	Usou `/=`; para inteiro, `//=`

Exercícios

1. Qual o valor final?

Escreva o valor de n depois de cada linha (cada linha continua da anterior, começando com n = 4):

n += 6 → n *= 3 → n -= 5 → n //= 2 →

2. Somar um

Complete a forma Python de somar 1 ao contador:

contador 1

3. O que estoque = estoque - 3 faz?

Pergunta se o estoque é igual a ele mesmo menos 3 Calcula o estoque atual menos 3 e guarda o resultado em estoque Dá erro, porque a variável aparece dos dois lados Cria uma variável nova chamada estoque - 3

4. Depois de pontos = 10 e pontos =+ 2, quanto vale pontos?

12 8 2 Dá SyntaxError

5. Depois de x = 9 e x /= 3, o que print(x) mostra?

3 27 0 3.0

Missão final: o estoque do dia

Missão: a padaria abriu com 50 pães. Pela manhã, vendeu 12 (use -=). À tarde, chegaram 3 caixas de 10 pães (use += com a conta 3 * 10). Atualize o estoque antes do print.

estoque = 50
print("Estoque:", estoque)

estoque = 50
estoque -= 12
estoque += 3 * 10
print("Estoque:", estoque)

Resumo

O = guarda: calcula o lado direito e põe o resultado na variável da esquerda. Para comparar, é ==.
estoque = estoque - 3 lê o valor atual, faz a conta e guarda o novo valor no lugar.
Os atalhos juntam o operador com o igual: +=, -=, *=, /=, //=, %=, **=. x += 5 é o mesmo que x = x + 5.
Um acumulador precisa começar com um valor: total = 0, senão o += dá NameError.
/= transforma o valor em float, como o /.
+= também acrescenta texto ao fim de um texto.
Não existe ++: contador++ dá SyntaxError, e ++contador não faz nada, sem avisar. Use contador += 1.
Cuidado com =+ (troca o valor em vez de somar) e com + = separado (SyntaxError).