O que é um algoritmo e como o Python executa seu programa linha por linha

Um algoritmo é uma sequência finita de passos, sem ambiguidade, que leva de uma entrada a um resultado. O Python executa o seu programa como um leitor muito obediente seguiria uma receita: começa na primeira linha do arquivo, faz exatamente o que ela manda, desce para a segunda, depois para a terceira, uma instrução de cada vez, até o texto acabar ou alguma coisa dar errado.

Quase todo erro de quem está começando vem de esquecer uma das metades dessa frase. Ou o passo estava vago (quem escreveu sabia o que queria dizer, o computador não), ou a ordem estava trocada (a linha que usa um valor veio antes da linha que o cria). O texto a seguir mostra como enxergar as duas coisas num programa pequeno, com código que você abre e roda no PyPlaca. Os exemplos usam só o Serial, sem circuito nenhum. A ESP32 aparece apenas no final, para mostrar onde essa base vai ser usada.

O problema: o computador não adivinha

Imagine que um colega de turma recebe um bilhete: "calcula a média da turma para mim". Ele não precisa de mais nada. Sabe que as notas estão na planilha da professora, sabe que média é somar tudo e dividir pela quantidade de alunos, sabe que o resultado vai para a ata. Foram três lacunas e todas foram preenchidas sem esforço, porque pessoas completam o que falta.

O computador não completa nada. Se você escrever só "calcular a média", ele fica sem resposta para perguntas que ninguém fez. Média de quais números? Onde eles estão guardados? O que fazer com o resultado: guardar, mostrar, enviar? Cada pergunta sem resposta é um passo que faltou no algoritmo, e a máquina não pergunta de volta. Ela executa o que está escrito ou para com uma mensagem de erro.

Uma comparação que ajuda é o caminho explicado por telefone. Alguém que nunca esteve no seu bairro liga, perdido, e você diz "segue reto até o mercado e vira na rua da padaria". Para você está claro. Para quem ouve existem três mercados e duas padarias. Para a pessoa chegar, o caminho precisa vir em passos que só admitem uma leitura: "siga pela Rua das Flores por duas quadras, vire à direita na primeira rua depois do semáforo, a escola é o portão azul à esquerda". Isso é um algoritmo. A ordem também é parte da instrução, porque virar antes de andar as duas quadras leva a outro lugar.

O mesmo acontece no laboratório. Um cenário comum: a professora pede "faça um programa que calcule a média da turma" e dois alunos entregam respostas diferentes, as duas defensáveis. Um somou as notas dos 30 alunos e dividiu por 30. O outro calculou só a média dos aprovados, porque entendeu "turma" como quem passou. Nenhum dos dois errou em Python. O defeito estava no pedido, que deixava em aberto quais números entram na conta. Só depois que a turma combina de onde vêm os valores e o que deve aparecer no fim é que o código passa a ter uma resposta certa.

O que é, afinal, um algoritmo

Um algoritmo é a ideia de como resolver um problema, escrita em passos. Não depende de computador: a instrução do caminho acima é um, o modo de preparo de uma receita é outro, o jeito de calcular o troco na feira também. O que separa um algoritmo de uma lista de boas intenções são quatro características:

• Finito: chega ao fim. "Continue somando números para sempre" não é um algoritmo, é um problema.
• Preciso: cada passo tem um único significado. "Adicione um pouco de sal" não serve; "adicione 5 gramas" serve.
• Ordenado: a sequência faz parte da resposta. Trocar dois passos de lugar normalmente muda o resultado ou o impede de existir.
• Com saída: pode ter entrada (os números que serão somados) ou não ter, mas sempre produz algo que dá para observar, como um valor na tela ou um LED aceso.

Algoritmo e programa não são a mesma coisa. O algoritmo é a ideia, e o programa é essa ideia escrita numa linguagem que a máquina aceita. A mesma ideia pode virar um programa em Python, outro em C, um desenho na lousa ou um texto num caderno, e continua sendo a mesma ideia.

Existe uma exceção aparente à regra do "finito" que aparece quando você chega às placas. Um programa de microcontrolador costuma ter um while True: que nunca termina, porque a placa existe para repetir a tarefa enquanto estiver ligada. Cada volta desse laço é finita e tem começo, meio e fim. O que não acaba é a repetição, e isso é uma escolha de quem projetou o programa. O artigo sobre programar sem travar mostra o que acontece dentro dessa repetição.

Três jeitos de escrever o mesmo algoritmo

Vamos usar um problema pequeno: calcular a média de duas notas, 7,5 e 8,5, e mostrar o resultado. A figura mostra a mesma solução escrita de três maneiras.

Cada forma serve a um momento diferente do trabalho.

Se você não consegue explicar o algoritmo em português, o código vai sair confuso, e nenhuma linguagem conserta isso. Por esse motivo vale escrever os passos numa folha antes de abrir o editor. O fluxograma ganha importância no próximo módulo da série, quando surgem as decisões: com if e else o programa deixa de ter um único caminho, e o desenho mostra as bifurcações melhor do que um parágrafo.

Agora o mesmo algoritmo em Python. Clique em Abrir no simulador, depois em Executar, e olhe a aba Serial.

nota1 = 7.5
nota2 = 8.5
soma = nota1 + nota2
media = soma / 2
print("Média:", media)

Linha por linha, o que cada uma faz:

• nota1 = 7.5 lê-se "guarde o valor 7.5 num nome chamado nota1". O nome fica à esquerda e o valor à direita. O sinal de = aqui é uma ordem, não uma pergunta sobre igualdade.
• soma = nota1 + nota2 calcula primeiro o lado direito, usando o que nota1 e nota2 guardam naquele momento, e só depois guarda o resultado em soma.
• print("Média:", media) manda texto para o Serial, o canal por onde o programa fala com quem o está rodando. Na placa real, o Serial chega ao computador pelo cabo USB. No PyPlaca, ele é a aba Serial. Num computador comum seria a janela do terminal.

O resultado aparece como Média: 8.0 e não como Média: 8. A barra / do Python sempre devolve um número decimal, mesmo quando a conta fecha redonda: 10 / 2 mostra 5.0. A divisão que devolve só a parte inteira existe, e é outra barra (//), que fica para o artigo sobre operadores.

Como o Python lê o seu arquivo

Quando você aperta Executar, acontecem duas fases, nessa ordem.

Na primeira, o Python lê o arquivo inteiro e confere se cada linha está escrita de um jeito que ele entende: parênteses fechados, aspas no lugar certo, palavras da linguagem escritas corretamente. Ainda não está executando nada, só verificando a gramática. Se alguma linha falha nessa conferência, o programa não começa. Nenhuma das linhas anteriores roda, mesmo as que estavam perfeitas.

A segunda fase só começa se a primeira passou. Aí o Python executa as instruções de cima para baixo, uma depois da outra. Cada vez que uma linha cria uma variável, o nome e o valor entram na memória e ficam lá para as próximas linhas usarem. Um detalhe que explica muita coisa: o Python não olha para a frente. Quando está na linha 3, ele não sabe o que a linha 7 vai criar. Só conhece o que já foi executado acima.

preco = 3.5
quantidade = 4
total = preco * quantidade
print("Total:", total)

A próxima figura acompanha esse programa de quatro linhas. À esquerda está o código; à direita, o que a memória e o Serial guardam depois de cada linha.

Depois da linha 1, só preco existe. Depois da linha 2, existem preco e quantidade. Só na linha 3 o Python tem tudo de que precisa para calcular preco * quantidade, e só na linha 4 alguma coisa aparece no Serial. Se você inverter a ordem e puser o cálculo antes das duas primeiras linhas, o Python chega à conta sem ter nada guardado e reclama. Isso aparece mais adiante, na parte sobre erros.

Guardar de novo no mesmo nome

Um nome de variável pode receber um valor novo quantas vezes você quiser. O valor antigo some, e o nome passa a apontar para o novo.

pontos = 10
print(pontos)
pontos = pontos + 5
print(pontos)
pontos = pontos * 2
print(pontos)

A linha pontos = pontos + 5 assusta quem vem da matemática, onde nenhum número é igual a ele mesmo mais cinco. Em Python não existe contradição, porque o = não afirma igualdade, ele manda guardar. O computador resolve primeiro a conta da direita (10 mais 5, que dá 15) e depois guarda o 15 no nome que está à esquerda. Na linha seguinte, pontos vale 15, e a multiplicação por 2 produz 30. Esse padrão de pegar o valor atual, calcular e guardar de volta é o mais comum de toda a programação: contadores, somas acumuladas e placares de jogo funcionam assim.

O que o Python ignora

Nem tudo no arquivo é ordem. O Python descarta tudo o que vem depois de um # até o fim da linha, e também as linhas em branco.

# isto é um comentário: o Python ignora
x = 2   # também ignora daqui até o fim da linha

y = 3

print(x + y)

Comentários servem para você, não para a máquina. O bom comentário explica por que uma linha existe, não repete o que ela faz.

Já os espaços no começo da linha não são ignorados. Em Python, o recuo (a indentação) faz parte da sintaxe, e uma linha comum não pode começar mais para dentro do que a anterior sem motivo. Escrever print("a") e, na linha de baixo, print("b") com quatro espaços à frente produz IndentationError: unexpected indent, um erro da primeira fase, que impede o programa inteiro de começar. O recuo ganha um papel central quando chegarmos às decisões e aos laços, e nesse ponto ele deixa de ser um incômodo e passa a ser o jeito de dizer quais linhas pertencem a quê.

Dois erros que se comportam de jeitos opostos

Quem aprende costuma tratar toda mensagem vermelha como a mesma coisa. Na prática há duas famílias, e saber em qual você caiu economiza muito tempo.

O erro de sintaxe (SyntaxError) vem da primeira fase. Como o Python confere o arquivo inteiro antes de rodar, nada chega a executar. No painel da esquerda da figura, a linha 1 é um print("antes") perfeito, mas ele não aparece, porque a linha 2 estava malformada. Quem vê o Serial mostrando só o erro costuma achar que o programa "nem começou", e é exatamente isso que aconteceu.

O erro em execução vem da segunda fase. O arquivo estava gramaticalmente correto, o Python começou, foi executando linha por linha e caiu numa instrução que não consegue cumprir, como dividir por zero ou usar um nome que não existe. O que já foi executado antes continua valendo e já saiu no Serial. O que vem depois nunca roda.

Como ler a mensagem

O PyPlaca mostra os erros no mesmo formato do MicroPython. Este programa tem a conta antes das variáveis:

total = preco * quantidade
preco = 3.5
quantidade = 4
print("Total:", total)

E a mensagem no Serial é esta:

Traceback (most recent call last):
  File "main.py", line 1, in <module>
NameError: name 'preco' isn't defined

A leitura mais produtiva começa pela última linha, que traz o tipo do erro e a explicação: NameError, o nome preco não está definido. A linha de cima diz onde: main.py, linha 1. O trecho in <module> quer dizer que o erro está no nível principal do arquivo e não dentro de uma função (as funções vêm no módulo 4). Com essas duas informações, você já sabe o que procurar: na linha 1 existe um nome que ainda não foi criado.

As mensagens do MicroPython são um pouco diferentes das do Python do computador. O MicroPython escreve name 'preco' isn't defined, e o Python de um computador comum, name 'preco' is not defined. Na divisão por zero, o MicroPython diz divide by zero e o Python do computador, division by zero. Nos erros de sintaxe, as versões recentes do Python do computador chegam a sugerir o que faltou ("Perhaps you forgot a comma?"), e o MicroPython diz apenas invalid syntax. A causa é a mesma nos dois casos, só muda o texto.

Teste de mesa: seguir o programa com o dedo

Existe uma técnica antiga para descobrir o que um programa faz sem rodá-lo: o teste de mesa. Você desenha uma tabela com uma coluna para cada variável e uma linha para cada passo, e vai preenchendo à mão, executando o programa como se fosse o Python. Para o programa dos pontos, fica assim:

Parece trabalhoso para um programa tão curto, e é. O valor aparece quando o programa não faz o que você esperava. Em vez de olhar o código e tentar "sentir" o que está errado, você compara o que a tabela diz que deveria acontecer com o que o Serial realmente mostrou, e a primeira linha em que os dois divergem é onde está o defeito.

O PyPlaca faz essa tabela por você. Use o botão Passo (atalho F10) para executar uma linha de cada vez e abra a aba Variáveis. O programa para antes de rodar a linha marcada no editor, e a tabela mostra o valor de cada variável naquele instante, em ordem alfabética. Se passar do ponto, o botão de voltar um passo (Ctrl+Shift+F10) desfaz a última linha, e o que já saiu no Serial continua lá, como num terminal de verdade. É a figura da memória, só que acontecendo na tela com o seu programa.

Erros comuns do começo

Vírgula no lugar do ponto

No Brasil escrevemos 7,5. Em Python, o separador decimal é o ponto, e a vírgula tem outro significado: separar valores. O problema é que nota1 = 7,5 é válido. O Python não reclama na linha 1, porque entende que você quer guardar dois valores juntos, 7 e 5, numa coleção chamada tupla.

nota1 = 7,5
nota2 = 8,5
soma = nota1 + nota2
media = soma / 2
print(media)

Esse programa roda as três primeiras linhas sem nenhum aviso. O erro só aparece na linha 4:

Traceback (most recent call last):
  File "main.py", line 4, in <module>
TypeError: unsupported types for __truediv__: 'tuple', 'int'

Se você pusesse print(nota1) logo depois da linha 1, veria (7, 5) no Serial, e a pista estaria clara. Aqui há uma lição que vale para muitos defeitos: a linha que o Python aponta é onde ele percebeu o problema, e não necessariamente onde você o criou. Quando o erro parece não fazer sentido naquela linha, volte e confira de onde vieram os valores que ela usa.

A cena costuma ser esta no laboratório: o aluno escreve 7,5 porque é assim que anota a nota no caderno, roda o programa e recebe um erro na linha 4 que fala de tuple. Ele relê a linha 4, reescreve a conta, troca o operador, e nada muda, porque o defeito nunca esteve ali. O que desfaz o nó é o teste de mesa. Ao preencher na tabela o valor de nota1 depois da linha 1, aparece (7, 5) onde era esperado 7.5, e a dúvida acaba.

Calcular e não mostrar

Este programa roda do começo ao fim sem nenhum erro e não mostra nada:

preco = 3.5
quantidade = 4
total = preco * quantidade

A conta foi feita, o resultado está na memória, e ninguém pediu para mostrá-lo. Falta o print. Por isso "o programa não faz nada" nem sempre quer dizer que ele está quebrado: às vezes ele só não foi mandado mostrar o resultado.

Letra maiúscula e minúscula

Para o Python, total e Total são nomes diferentes, e print e Print também. Este programa:

total = 10
print(Total)

termina em NameError: name 'Total' isn't defined, porque a única variável criada foi total com t minúsculo. Quando o erro disser que um nome não está definido e o nome parecer certo, confira as letras maiúsculas.

Texto sem aspas

Escrever print(Maria) em vez de print("Maria") também produz um NameError. Sem aspas, o Python acha que Maria é o nome de uma variável e vai procurá-la na memória. As aspas dizem "isto é um texto, não é um nome". Já as aspas abertas e não fechadas, como em print("Olá), são um erro de sintaxe da primeira fase, e o programa inteiro deixa de rodar.

Exercício: o troco da compra

Você compra 4 itens de R$ 3,50 cada e paga com uma nota de R$ 20. Escreva o algoritmo que mostra o valor da conta e o troco. Tente primeiro em português, num papel, e só depois escreva o Python.

Uma resposta possível, em português:

1. Guardar o preço de cada item: 3,50.
2. Guardar a quantidade de itens: 4.
3. Calcular a conta: preço vezes quantidade.
4. Guardar o valor pago: 20.
5. Calcular o troco: valor pago menos a conta.
6. Mostrar a conta e o troco.

Em Python, cada passo vira uma linha, na mesma ordem:

preco_item = 3.5
quantidade = 4
conta = preco_item * quantidade
pago = 20
troco = pago - conta
print("Conta:", conta)
print("Troco:", troco)

O teste de mesa deste programa mostra uma variável nova a cada passo, e o troco só pode ser calculado depois que conta e pago existem:

As linhas 6 e 7 só mostram esses valores no Serial: Conta: 14.0 e Troco: 6.0. Para praticar, mude o preço, a quantidade e o valor pago e escreva no papel o que espera ver antes de rodar. Depois inverta as linhas 4 e 5 e tente prever a mensagem de erro, o nome e a linha, antes de executar.

Numa turma, esse problema costuma render duas soluções. Uma escreve a conta direto, conta = 3.5 * 4, e funciona. A outra guarda preço e quantidade em variáveis antes de calcular, como no código acima. As duas mostram Troco: 6.0 hoje. A diferença aparece quando o enunciado muda para 5 itens de R$ 4,20: na primeira, é preciso caçar os números dentro das contas, e na segunda basta mexer nas duas primeiras linhas. Vale comparar as duas lado a lado antes de decidir qual é a melhor.

Perguntas frequentes

Preciso saber desenhar fluxograma para programar?

Não. O fluxograma é uma ferramenta de raciocínio, e muita gente prefere escrever os passos em português ou fazer uma tabela. Ele compensa mais quando o problema tem muitos caminhos, e você vai notar isso a partir das decisões.

O Python lê o arquivo inteiro antes de executar?

Lê, mas só para conferir a escrita. A execução de verdade acontece depois, linha por linha. É por isso que um erro de sintaxe na última linha impede que a primeira seja executada, enquanto um erro de execução na última linha deixa tudo o que veio antes rodar.

O Python da ESP32 roda igual ao do computador?

O núcleo da linguagem é o mesmo, e tudo o que este artigo mostrou funciona igual. As diferenças aparecem nos detalhes: o texto de algumas mensagens de erro, como visto acima, e os números decimais, que na placa usam 32 bits de precisão. Por causa disso, 10 / 3 mostra 3.3333332 na placa e no simulador, enquanto o Python do computador mostra mais casas. Há ainda módulos da biblioteca padrão que, na placa, trazem menos funções do que no computador. Cada artigo da série avisa quando uma dessas diferenças importa.

Para continuar

O caminho natural é praticar na trilha Lógica com Python, com 60 desafios de lógica em Python. Três deles encaixam direto com o que foi visto aqui: Olá Mundo, com uma única linha de print; Soma de dois, para treinar o cálculo e a saída; e Média de notas, que é o algoritmo da primeira figura com valores diferentes. Ao resolver, faça o teste de mesa no papel antes de enviar a resposta e use o botão Passo se o resultado não bater.

O próximo assunto da série é entrada e saída, ou seja, como fazer o programa perguntar um valor com input() e responder com print(). Se você quer ver a mesma ideia de executar linha por linha movendo um pino de verdade, o artigo Primeiros passos com MicroPython na ESP32 faz um LED piscar com o mesmo main.py, e a ficha da ESP32 DevKit V1 mostra a placa em que esse código vai rodar. As trilhas de hardware começam em Primeiros passos.