2.1 O que você saberá se você ler todo este capítulo?
Você irá trabalhar em uma empresa ou em um mestrado/doutorado para resolver problemas usando Python, e não somente para apertar botões e comandos. Por isso, você precisará saber trabalhar com algoritmos (usando Python ou qualquer outra linguagem).
Algoritmo não é sinônimo de inteligência artificial, e você pode pensar em casos da vida real em forma de algoritmos.
Algoritmos podem conter dados.
Dados que não mudam são armazenados em constantes.
Dados que mudam são armazenados em variáveis.
Dados são manipulados com operadores (ex.: adição, subtração, divisão, comparação).
Dados podem ser números, textos ou variáveis lógicas (verdadeiro/falso), dentre outros.
Todo algoritmo é organizado da seguinte forma:
Entrada: são os pré-requisitos que um algoritmo tem para que possa funcionar, ou seja, os dados ou informações necessárias para realizar a tarefa.
Processamento: é a sequência de passos ou instruções que serão executados para processar a entrada e produzir uma saída.
Saída: é o resultado final que o algoritmo produz, que pode ser uma resposta, um valor ou uma ação.
Algoritmos servem para resolver problemas de um jeito estruturado e organizado seguindo uma sequência lógica: não importa o computador/pessoa que execute aquele algoritmo - devemos esperar o mesmo resultado.
Exemplo: não importa o modelo de celular, a cidade ou o restaurante - o aplicativo de delivery de comida deve funcionar da mesma forma para todas estas combinações possíveis.
O algoritmo precisa ser claro, conciso e eficiente na solução do problema proposto.
🎓 Vindo do Capítulo 1? Ótimo! Você já configurou seu ambiente e executou seu primeiro código. Agora é hora de entender COMO pensar em algoritmos antes de começar a programar de verdade. Este capítulo é sobre a lógica por trás do código. No Capítulo 3, você finalmente começará a programar em Python!
💡 Dica importante: Este capítulo tem bastante teoria, mas é essencial! Não pule seções. Cada conceito aqui será usado nos próximos capítulos.
Ah, antes de começar: veja o vídeo abaixo (ele possui legendas traduzidas para o português, se quiser). É um exemplo do que acontece quando você faz um algoritmo sem pensar direito na sua organização. No caso, Josh Darnit pediu para que os seus filhos fizessem um algoritmo (um passo-a-passo) para fazer um sanduíche de manteiga de amendoim e geleia. E ele seguiu as instruções ao pé da letra, como um computador seguirá ao pé da letra um algoritmo que você irá desenvolver no futuro.
Vídeo: Como fazer um sanduíche - algoritmo mal feito
💡 Dica: Este vídeo mostra exatamente por que algoritmos precisam ser bem pensados. Assista e você vai entender melhor o que vamos aprender neste capítulo!
2.2 Os algoritmos e a sua vida
Olha, se você está lendo isso, provavelmente já seguiu milhares de algoritmos na sua vida e nem percebeu!
Vamos supor que você quer preparar um bolo. Você sabe que para preparar um bolo, você precisa seguir uma receita passo a passo. Essa receita é um conjunto de instruções que você segue para chegar ao resultado desejado.
2.2.1 O que é um algoritmo, afinal?
Assim como na receita de bolo, um algoritmo é um conjunto de instruções que segue uma sequência lógica de passos para resolver um problema específico.
Mas não pense que algoritmo é só coisa de computador! Você usa algoritmos todos os dias:
Receita de bolo = algoritmo para fazer um bolo
Instruções do GPS = algoritmo para chegar em algum lugar
Regras de um jogo = algoritmo para jogar o jogo
Manual de montagem de móveis = algoritmo para montar o móvel
2.2.2 Como funcionam os algoritmos?
Os passos podem ser executados em ordem (ou seja: primeiro fazemos as instruções do passo 1, depois o passo 2, depois o passo 3 e assim sucessivamente) ou podem ter condições que definem qual passo deve ser executado em seguida.
Exemplo simples: “Se estiver chovendo, leve guarda-chuva. Se não estiver chovendo, pode sair sem guarda-chuva.” Aqui temos uma condição que decide qual passo seguir.
2.2.3 Exemplo 1: Fazendo um bolo
Vejamos por exemplo uma receita de bolo de chocolate. Perceba principalmente no exemplo abaixo a organização sequencial da receita e como ela é preparada em uma sequência lógica (afinal, não faria sentido lhe dar o modo de preparo sem passar primeiro os ingredientes, não é?).
Preaqueça o forno a 180°C. Unte uma forma redonda de 23 cm com manteiga ou óleo e enfarinhe.
Em uma tigela grande, misture o açúcar, a farinha de trigo, o cacau em pó, o bicarbonato de sódio, o fermento em pó e o sal.
Adicione os ovos, o leite, o óleo vegetal e a essência de baunilha. Bata em velocidade média por 2 minutos.
Adicione a água quente e misture até ficar homogêneo. A massa ficará bem líquida.
Se a massa estiver muito grossa, adicione mais água quente aos poucos, até que a massa atinja a consistência adequada.
Despeje a massa na forma untada.
Asse por 30 a 35 minutos ou até que um palito inserido no centro do bolo saia limpo.
Deixe esfriar completamente antes de servir.
2.2.3.3 Resultado esperado
Um bolo de chocolate.
Perceba que no passo 5 a condição “se” verifica se a massa está muito grossa. Se a massa estiver muito grossa, adicionamos mais água quente aos poucos até que a massa atinja a consistência adequada. Essa condição ajuda a garantir que o bolo não fique muito denso ou seco e que o resultado final seja o melhor possível.
Em outras palavras, esta condição não é obrigatória: poderíamos pular do passo 4 para o passo 6 se a massa estivesse na consistência adequada. Também poderíamos repetir várias e várias vezes o passo 5 até que ela finalmente estivesse do jeito que gostaríamos.
Perceba também que cada passo naquela receita de bolo é importante para garantir que o resultado seja o melhor possível. Por exemplo, a escolha dos ingredientes corretos e as medidas precisas são etapas cruciais para evitar erros na receita. Da mesma forma, a temperatura do forno e o tempo de cozimento são passos importantes para garantir que o bolo seja assado corretamente. Não importa o dia, local, a pessoa ou a marca do forno e da farinha de trigo: quem seguir os passos acima deverá ter o mesmo resultado. No caso, o bolo de chocolate.
2.2.4 Exemplo 2: Pedindo comida por aplicativo
Agora, vamos para outro exemplo de algoritmo: no caso, do pedido de comida em um aplicativo de delivery. Observe novamente a organização do algoritmo:
2.2.4.1 Pré-requisitos
Ter um smartphone ou tablet com acesso à internet.
Ter um aplicativo de delivery instalado e configurado com as informações do usuário, incluindo endereço de entrega e forma de pagamento.
2.2.4.2 Passo-a-passo
Abra o aplicativo de delivery.
Procure o restaurante desejado.
Escolha os itens desejados do menu.
Selecione as opções desejadas para cada item, como tamanho da porção, temperatura, ingredientes extras, etc.
Adicione os itens ao carrinho.
Verifique o carrinho para garantir que todos os itens estejam corretos e que as quantidades estejam de acordo com o desejado.
Se quiser adicionar mais itens ao pedido, repita os passos 3 a 6 até que todos os itens desejados estejam no carrinho.
Selecione a forma de pagamento desejada.
Insira o endereço de entrega correto ou confirme o endereço já cadastrado.
Se o endereço de entrega for diferente do endereço cadastrado, confirme o novo endereço de entrega.
Confirme o pedido.
2.2.4.3 Resultado esperado
O usuário recebe a comida no endereço indicado dentro do tempo estimado.
Veja mais uma vez que a organização é parecida com o exemplo do bolo: temos uma lista de pré-requisitos (que antes eram os ingredientes), a sequência de instruções e, finalmente, o resultado esperado. De novo: não importa o que você está pedindo, o modelo do celular ou a sua cidade: o funcionamento deve ser o mesmo e o resultado esperado também deve ser o mesmo, beleza?
Eu queria trazer estes exemplos para você para que ficasse claro que, ainda que sejam frequentemente associados à inteligência artificial e ao processamento de dados em computadores, os algoritmos podem ser encontrados em muitos outros contextos na vida real.
Se você está começando a estudar desenvolvimento de software, este seria um bom exercício: começar a pensar em outros exemplos no seu cotidiano que poderiam ser descritos em formato de algoritmos. Alguns exemplos de exercícios que você pode fazer em um pedaço de papel ou em um documento do Word seriam:
Limpar um cômodo da casa;
Atendimento de um cliente em uma loja;
Compra de um carro;
Organização de um churrasco de fim de semana;
Planejamento de uma viagem.
Por isso, veja que os algoritmos podem ser executados em outras plataformas que não são computadores. Por exemplo, os algoritmos são usados em jogos de tabuleiro como xadrez e damas, onde as jogadas dos jogadores seguem uma sequência de instruções definidas. Os algoritmos também podem ser usados em processos industriais, como a produção de alimentos ou de produtos químicos, para garantir que as etapas de produção sejam realizadas com precisão e eficiência.
Assim como na receita de bolo, um algoritmo é uma sequência de instruções que um computador segue para realizar uma tarefa específica. Os algoritmos são usados em uma ampla variedade de tarefas, desde buscas na internet até o processamento de imagens médicas e a previsão do tempo.
2.3 Os algoritmos e os computadores
Neste momento você já deve saber que algoritmos não são limitados somente a computadores. Agora, o próximo passo é ficar claro o que são computadores para podermos (finalmente) colocar a mão na massa. Primeiro: os computadores não se limitam somente aos notebooks e desktops que as pessoas usam para mandar e-mails, ler este conteúdo, jogar Counter-Strike ou ficar mexendo na internet. Também não são somente os celulares e tablets. Logo, computadores também incluem coisas como os elevadores, microondas e máquinas de lavar roupa.
Na verdade, a maioria dos dispositivos que usamos hoje em dia possui algum tipo de computador interno. Esses computadores são responsáveis por executar diversas tarefas que fazem com que esses dispositivos funcionem corretamente.
Por exemplo, pensemos em um elevador. Ele não é apenas uma caixa que se move para cima e para baixo, mas também inclui um sistema de controle que é executado por um computador interno. Esse computador é responsável por garantir que o elevador se mova corretamente, pare no andar correto e abra as portas de forma segura.
Da mesma forma, um microondas também inclui um computador interno que controla o tempo de cozimento e a intensidade das ondas de calor. Esse computador permite que o microondas aqueça sua comida de maneira uniforme e segura.
Por fim, até mesmo uma máquina de lavar roupa pode incluir um computador interno. Esse computador é responsável por controlar o ciclo de lavagem, a temperatura da água e a duração do ciclo. Isso garante que suas roupas sejam lavadas corretamente e sem danos.
O que eu queria trazer a você com estes pontos é que um algoritmo escrito para computador não incluem somente isso:
Algoritmos de busca em sites de busca como Google e Bing.
Algoritmos de recomendação em serviços de streaming de vídeo como Netflix e YouTube.
Algoritmos de filtragem de spam em serviços de e-mail como Gmail e Outlook.
Algoritmos de classificação de produtos em sites de comércio eletrônico como Amazon e Mercado Livre.
Algoritmos de previsão do clima em institutos de meteorologia.
Algoritmos de análise de dados em empresas de análise financeira.
Algoritmos de criptografia em sistemas de segurança de dados.
Algoritmos de compressão de dados em serviços de armazenamento em nuvem como Google Drive e Dropbox.
Algoritmos de reconhecimento de voz em assistentes pessoais como Siri e Alexa.
Algoritmos de reconhecimento facial em sistemas de segurança.
Algoritmos de diagnóstico em sistemas de saúde e medicina.
Algoritmos de recomendação em plataformas de música como Spotify e Apple Music.
Mas incluem também isso:
Algoritmos de controle de velocidade em esteiras de academia para manter o usuário na velocidade e ritmo adequados.
Algoritmos de controle de temperatura em microondas para garantir que a comida seja aquecida uniformemente.
Algoritmos de controle de força em motores de elevadores para garantir que ele suba e desça de forma segura e eficiente.
Algoritmos de processamento de dados em smartwatches para monitorar a atividade física, frequência cardíaca e sono do usuário.
Algoritmos de análise de imagem em sistemas médicos para detecção de doenças e anomalias em imagens de raio-X, ressonância magnética e tomografia.
2.3.1 O mesmo algoritmo em Python
Agora veja como o pseudocódigo acima fica quando transformado em Python de verdade:
💻 Execute a célula abaixo! Se você estiver usando Jupyter Notebook, clique na célula e aperte Shift + Enter. Se estiver usando PyCharm, copie o código para um arquivo .py e execute.
Code
# Início do algoritmo# Declaramos as variáveis (Python faz isso automaticamente)# Em Python, não precisamos declarar o tipo com antecedência# Solicita o primeiro número ao usuárioprint("Digite o primeiro número: ")num1 =int(input()) # input() lê o que o usuário digita; int() converte para inteiro# Solicita o segundo número ao usuário print("Digite o segundo número: ")num2 =int(input())# Calcula a somasoma = num1 + num2# Exibe o resultadoprint(f"O resultado da soma é: {soma}")# Fim do algoritmo
2.3.2 Comparando Pseudocódigo vs Python
Observe as semelhanças e diferenças:
Pseudocódigo
Python
Explicação
Inteiro: num1, num2, soma
(não necessário)
Python descobre o tipo automaticamente
Escreva("texto")
print("texto")
Função para mostrar mensagens
Leia(variavel)
variavel = input()
Função para ler entrada do usuário
soma = num1 + num2
soma = num1 + num2
Idêntico! A lógica é a mesma
Início / Fim
(não necessário)
Python usa indentação ao invés disso
🎯 Ponto importante: A LÓGICA é a mesma! Por isso aprender pseudocódigo é tão valioso - você está aprendendo a pensar como um programador, independente da linguagem.
⚠️ Nota: Não se preocupe se você não entendeu 100% do código Python. O objetivo aqui é você ver a conexão entre pseudocódigo e Python. No próximo capítulo, você aprenderá cada comando detalhadamente!
2.4 Pseudocódigo: O “rascunho” da programação
Agora que você sabe como pensar em algoritmos, vamos avançar mais um passo com o pseudocódigo.
2.4.1 O que é pseudocódigo?
Imagine que você quer construir uma casa. Você não vai começar construindo direto, né? Primeiro você faz um projeto, desenha a planta, pensa onde vai colocar cada coisa. O pseudocódigo é exatamente isso para programação: é o “projeto” do seu programa.
Pseudocódigo é uma forma de escrever algoritmos que:
✅ É fácil de entender (quase como português)
✅ Não precisa de sintaxe complicada de linguagem
✅ Foca na lógica, não na sintaxe
✅ Pode ser convertido para qualquer linguagem de programação
2.4.2 Por que usar pseudocódigo?
1. Planeja antes de programar - É como medir duas vezes antes de cortar uma vez. Você pensa na lógica antes de se preocupar com a sintaxe.
2. Identifica problemas cedo - É muito mais fácil corrigir um erro no pseudocódigo do que no código final.
3. Comunica ideias - Você pode mostrar seu pseudocódigo para outros programadores e eles vão entender rapidamente o que você quer fazer.
4. É linguagem universal - O mesmo pseudocódigo pode virar Python, Java, C++, ou qualquer outra linguagem.
2.4.3 Exemplo prático
Vamos ver um algoritmo para calcular a soma de dois números. Em pseudocódigo, seria assim:
InícioInteiro: num1, num2, somaEscreva("Digite o primeiro número: ")Leia(num1)Escreva("Digite o segundo número: ")Leia(num2)soma = num1 + num2Escreva("O resultado da soma é: ", soma)Fim
Todo algoritmo possui um início e fim. Isso era verdade com o exemplo do bolo (começamos tendo nada nas mãos e terminamos com um bolo), com o delivery (começamos com fome e acabamos com a comida entregue) e também é verdade aqui. No exemplo acima, o pseudocódigo começa com o passo Início na linha 1, que é uma convenção para indicar o início do algoritmo. Da mesma forma, o algoritmo termina com o passo Fim na linha 12, que indica o final do código.
Dentro deste bloco (ou seja: entre o Início e Fim) temos duas variáveis que foram declaradas logo de cara para armazenar os números: num1 e num2, ambas na linha 2. Estas variáveis poderiam ter qualquer outro nome como, por exemplo, numero1 e numero2; primeiro_numero e segundo_numero ou banana e abacaxi. Dito isso, é recomendável que você use nomes claros e descritivos para variáveis e funções, a fim de tornar o código mais fácil de ler e entender. Além disso, é importante usar uma indentação adequada (isto é: o espaçamento antes de iniciar cada uma das linhas) para separar os blocos de instruções e tornar o código mais legível.
Também definimos na linha 2 uma variável para armazenar o resultado da soma. Convenientemente, o nome desta variável é soma. Todas estas variáveis devem armazenar somente valores inteiros (isto é: sem casas decimais). isto também é definido pela linha 2.
O próximo passo (linhas 4 a 8) é solicitar ao usuário que digite os dois números, utilizando a função Escreva para exibir uma mensagem na tela (ou seja: fazer com que o computador escreva uma mensagem na tela para o usuário) e a função Leia para ler o que o usuário digitou com o teclado e armazenar isto nas variáveis correspondentes.
Depois disso, é feito o cálculo da soma na linha 10, utilizando a equação num1 + num2. O resultado é armazenado na variável soma.
Por fim, é exibido na tela o resultado da soma, utilizando novamente a função Escreva na linha 11, que exibe a mensagem “A soma dos dois números é:” seguida do valor da variável soma.
2.4.4 Onde usar/como trabalhar com pseudocódigos?
Os pseudocódigos são uma ferramenta útil para os desenvolvedores em diversos momentos, como na fase de planejamento e concepção de algoritmos e também para documentar um código já desenvolvido. Eles são uma espécie de “rascunho” que descreve, de forma abstrata e sem se preocupar com a sintaxe de uma linguagem de programação específica, as etapas e a lógica de um algoritmo.
Para você, serve para praticar. Isso ajuda demais na hora de começar a trabalhar com Python ou qualquer outra linguagem de programação para organizar as suas ideias. Você verá que funções como o Leia e Escreva possuirão nomes e formas de usar bem parecidas em Python.
Como exercício, tente escrever em um bloco de notas, folha de papel ou qualquer outro lugar algo que seja do seu dia-a-dia em um formato de algoritmo. Coloque início e fim pré-definidos e todos os passos de forma sequencial. Lembra do vídeo no início deste capítulo e da receita de bolo? Pois bem, o que acha de fazer algo parecido?
2.5 Conceitos Fundamentais que Você PRECISA Saber
⚠️ ATENÇÃO: Esta seção contém conceitos que você usará em TODOS os programas que fizer daqui para frente. Leia com calma e volte aqui sempre que tiver dúvidas!
Ok, estamos quaaase prontos para começar com o Python. Antes disso, valem reforçar alguns conceitos fundamentais:
2.5.1 Dados: A matéria-prima dos algoritmos
Dados são informações que são armazenadas e processadas por computadores. Um algoritmo irá processar dados para te dar algum resultado no final das contas.
Analogia culinária: Da mesma forma que um algoritmo para fazer o bolo de chocolate processa os ingredientes para te entregar um bolo, um algoritmo de delivery também irá processar o seu pedido (e os dados do seu cartão de crédito) para lhe entregar a comida.
No mundo digital: Um algoritmo de computadores irá processar números, textos e outros tipos de dados para lhe entregar algo no final das contas: isto pode ser uma transferência bancária, um sinal de alerta do microondas, uma mensagem de e-mail redirecionada à caixa de spam ou uma nova notificação no seu celular.
2.5.2 Por que tipos de dados são importantes?
Imagine que você está fazendo uma receita e precisa de “1 xícara de açúcar”. Se você colocar “1 xícara de sal”, o bolo vai ficar horrível, né? Com dados é a mesma coisa: você precisa saber que tipo de dado está trabalhando para usar os operadores corretos.
2.5.2.1 Tipos de dados
Em um algoritmo, existem vários tipos de dados que podem ser usados para armazenar informações e realizar cálculos. Desses, os mais básicos são:
Numéricos: armazenam valores numéricos, como inteiros e reais. Elas podem ser usadas em operações matemáticas, como adição, subtração, multiplicação e divisão. Exemplos de variáveis numéricas em um pseudocódigo são “idade”, “peso” e “preço”.
Números inteiros: usados para representar valores inteiros (sem casas decimais). Exemplos: -1000, -5, 0, 20, 49, 2023.
Números reais: usados para representar valores com casas decimais. Exemplos: 3.1415, 1.72, 77.4, 0.001, -2.54.
Lógicos/booleanos: representam valores lógicos, como verdadeiro (True) ou falso (False). Exemplo: uma variável chamada “possui_passaporte” poderia indicar se uma pessoa tem ou não tem passaporte.
Alfanuméricos: armazenam valores de texto, como nomes, endereços, palavras e frases. Elas podem ser usadas em operações de concatenação, que unem duas ou mais strings em uma única string. Exemplos de variáveis alfanuméricas em um pseudocódigo são “nome”, “sobrenome” e “endereço”. Strings são sequências de caracteres (letras, números, espaços em branco, etc.) que representam textos.
2.5.2.2 Constantes e variáveis
Além disso, estes tipos de dados podem ser tratados de formas diferentes pelos algoritmos. Assim, temos:
Constante: um valor que não pode ser alterado durante a execução do programa.
Variável: é um espaço na memória do computador que pode armazenar diferentes valores ao longo da execução do programa.
Por exemplo, em uma receita de bolo, a quantidade de açúcar que deve ser adicionada é uma constante, pois não varia de acordo com a situação ou contexto. É uma informação fixa e predefinida na receita. Por outro lado, a quantidade de farinha que deve ser adicionada pode variar de acordo com a quantidade de ovos que serão utilizados, ou de acordo com o tamanho da forma utilizada. É uma informação que pode mudar e, portanto, poderiam ser variáveis na receita.
Pensando em computadores, as constantes são utilizadas quando há um valor que é conhecido previamente e que deve permanecer inalterado durante a execução do algoritmo ou programa. Por exemplo, pode-se utilizar uma constante para representar o valor da velocidade da luz, que é uma grandeza conhecida e que não muda durante a execução do programa.
As variáveis, por outro lado, são usadas para armazenar valores que podem mudar durante a execução do programa. Por exemplo, em um programa de cálculo de notas de alunos, uma variável pode ser utilizada para armazenar a nota de cada aluno, e essa nota pode mudar à medida que o usuário insere novas informações no programa.
Em resumo, as constantes e as variáveis são importantes conceitos em algoritmos e programação, e são utilizadas para armazenar e manipular diferentes tipos de dados. As constantes são usadas para valores que não mudam durante a execução do programa, enquanto as variáveis são usadas para valores que podem mudar.
2.5.3 Operadores: As “ferramentas” para manipular dados
Lembra na receita do bolo onde tinha um passo escrito “misture o açúcar, a farinha de trigo, o cacau em pó, o bicarbonato de sódio, o fermento em pó e o sal”? E outro chamado “adicione os ovos, o leite, o óleo vegetal e a essência de baunilha”? Como isso funcionaria na prática?
Você deve imaginar alguém pegando os ingredientes e misturando todos eles na tigela. Misturar, neste caso, significa mexer todos eles até que você não saiba mais o que é leite, o que é ovo e o que seriam os outros ingredientes: é mexer até que tudo vire uma coisa só.
Em algoritmos de computador, não temos tigelas e nem ferramentas para manipular estes ingredientes. No lugar, temos operadores para manipular números, textos e booleanos. São eles:
2.5.3.1 1. Aritméticos (para fazer contas)
Realizam operações matemáticas:
Adição: + (2 + 3 = 5)
Subtração: - (10 - 4 = 6)
Multiplicação: * (3 * 4 = 12)
Divisão: / (15 / 3 = 5)
Módulo: % (resto da divisão: 10 % 3 = 1)
Exponenciação: ** (2 ** 3 = 8)
2.5.3.2 2. Relacionais (para comparar coisas)
Comparam dois valores e retornam verdadeiro ou falso:
Igualdade: == (5 == 5 → True)
Desigualdade: != (5 != 3 → True)
Maior que: > (10 > 5 → True)
Menor que: < (3 < 7 → True)
Maior ou igual: >= (5 >= 5 → True)
Menor ou igual: <= (4 <= 6 → True)
2.5.3.3 3. Lógicos (para combinar condições)
Combinam resultados booleanos:
E: and (True and False → False)
Ou: or (True or False → True)
Não: not (not True → False)
2.5.3.4 4. Atribuição (para guardar valores)
Atribuem valores a uma variável:
Igual: = (soma = num1 + num2)
No pseudocódigo da soma dos dois números observe que a linha 10 tinha o código soma = num1 + num2. Isto é lido como: “A variável somarecebe o resultado de num1 mais num2”.
💡 Dica: Pense nos operadores como ferramentas. Você não vai usar uma chave de fenda para martelar um prego, né? Com operadores é a mesma coisa: cada um tem sua função específica.
{#python:identation}
2.5.4 Indentação
💡 Muito importante em Python! Diferente de outras linguagens, Python usa indentação para organizar o código. Erros de indentação são muito comuns em iniciantes.
Você viu no exemplo do pseudocódigo alguns espaços à esquerda nas linhas 2 a 11? Aquilo são indentações. A indentação é uma técnica usada para organizar o código em um programa de computador. É como uma espécie de espaçamento (recuo) que ajuda a identificar quais linhas de código estão dentro de outras linhas. É como se fosse um “encaixe” do código, onde cada bloco está dentro do outro.
Pense que você tem um conjunto de instruções para seguir. Algumas dessas instruções precisam ser executadas dentro de outras instruções. Para que você não se perca na sequência, você pode separar essas instruções com espaços, deixando mais claro quais instruções pertencem a qual conjunto. Na programação, isso é chamado de indentação. Como uma comparação simplista, imagine uma estrutura de tópicos e subtópicos de uma apresentação no PowerPoint ou, ainda, uma biblioteca em que cada livro é classificado e organizado por categorias e subcategorias que estão umas dentro das outras.
Na prática, a indentação é feita com a adição de espaços ou tabulações (tecla Tab do teclado) no início de cada linha de código, criando um recuo que ajuda a identificar a hierarquia dos blocos de código. É uma prática importante porque torna o código mais legível e fácil de entender, e ajuda a evitar erros de sintaxe. Veremos mais sobre isso adiante.
TipQuer treinar seu raciocínio algorítmico?
Criei o batel.tech, um site gratuito com exercícios práticos de Python para complementar seus estudos. Lá você encontra:
✅ Exercícios progressivos sobre algoritmos e lógica de programação
✅ Feedback imediato para suas soluções
✅ Acompanhamento por IA para te ajudar quando travar
💬 Comunidade no Discord para trocar ideias
É um projeto pessoal meu (Prof. Wellington) para te dar mais insumos e ajudar na jornada Python! 🐍
2.5.5 Dicas para Resolver os Exercícios
Comece pelos mais fáceis: Não tente pular direto para o nível 5!
Leia o problema com calma: Entenda exatamente o que está sendo pedido
Quebre em partes menores: Divida problemas complexos em etapas
Use pseudocódigo: Sempre escreva o algoritmo antes de pensar em código
Teste mentalmente: Execute o algoritmo passo a passo na sua cabeça
Verifique casos extremos: O que acontece com valores muito grandes ou muito pequenos?
💡 Lembre-se: Algoritmos são sobre lógica, não sobre sintaxe. Foque em entender o problema e criar uma solução lógica antes de se preocupar com detalhes técnicos!
2.6 Exercícios Práticos
Agora é hora de praticar! Estes exercícios são organizados por nível de dificuldade, desde o básico até o avançado. Cada exercício tem gabarito completo com explicações detalhadas. Ah, e lembre-se: todos os exercícios abaixo não envolvem uma única linha de Python. A ideia é somente a de desenvolver um pouco o seu raciocínio lógico, beleza? Fique à vontade para consultar as respostas para entender um pouco mais sobre esta lógica: afinal, nada mais justo do que aprender com mais exemplos.
2.6.1 Nível 1: Muito Fácil (Aplicação direta de conceitos básicos)
2.6.1.1 Exercício 1.1: Identificando algoritmos do dia a dia
Objetivo: Reconhecer algoritmos em situações cotidianas
Instruções: Para cada situação abaixo, responda: É um algoritmo? Por quê?
Instruções para fazer um café
Lista de compras no supermercado
Regras de um jogo de futebol
Receita de bolo de chocolate
Manual de instruções de um micro-ondas
NoteGabarito
✅ Sim - Sequência de passos para chegar a um resultado específico
❌ Não - É apenas uma lista, não tem sequência de passos
✅ Sim - Regras que definem como o jogo deve funcionar
✅ Sim - Sequência de passos para fazer um bolo
✅ Sim - Instruções para usar o aparelho corretamente
Explicação: Algoritmo = sequência lógica de passos para resolver um problema específico. Lista de compras não resolve um problema, só lista itens.
2.6.1.2 Exercício 1.2: Tipos de dados básicos
Objetivo: Identificar tipos de dados em situações reais
Instruções: Para cada item abaixo, identifique o tipo de dado:
25 (idade de uma pessoa)
"Maria Silva" (nome completo)
1.75 (altura em metros)
True (pessoa tem CNH)
"12345-678" (CEP)
NoteGabarito
Numérico inteiro - Número sem casas decimais
Alfanumérico/String - Texto/sequência de caracteres
Numérico real - Número com casas decimais
Lógico/Booleano - Verdadeiro ou falso
Alfanumérico/String - Mesmo sendo números, CEP é texto (tem hífen)
Explicação:
Inteiro: números sem casas decimais (1, 2, 100, -5)
Real: números com casas decimais (1.5, 3.14, -2.7)
String: qualquer texto, mesmo que contenha números (CEP, telefone)
Booleano: apenas True ou False
2.6.1.3 Exercício 1.3: Constantes vs Variáveis
Objetivo: Diferenciar entre valores fixos e valores que mudam
Instruções: Classifique cada item como Constante ou Variável:
Velocidade da luz (299.792.458 m/s)
Saldo da conta bancária
Número de dias em uma semana
Idade de um usuário
Valor de PI (3.14159…)
NoteGabarito
Constante - Nunca muda, é uma constante física
Variável - Muda a cada transação
Constante - Sempre 7 dias
Variável - Aumenta todo ano
Constante - Valor matemático fixo
Explicação:
Constante: valor que nunca muda durante a execução
Objetivo: Criar um algoritmo básico em pseudocódigo
Instruções: Escreva o pseudocódigo para um algoritmo que:
Solicita ao usuário dois números
Calcula a multiplicação desses números
Exibe o resultado
NoteGabarito
Início
Inteiro: num1, num2, resultado
Escreva("Digite o primeiro número: ")
Leia(num1)
Escreva("Digite o segundo número: ")
Leia(num2)
resultado = num1 * num2
Escreva("O resultado da multiplicação é: ", resultado)
Fim
Explicação linha-a-linha:
Início e Fim: delimitam o algoritmo
Inteiro: num1, num2, resultado: declara variáveis do tipo inteiro
Escreva(): exibe mensagens na tela
Leia(): lê valores do usuário
resultado = num1 * num2: calcula e armazena o resultado
2.6.2.2 Exercício 2.2: Operadores relacionais
Objetivo: Aplicar operadores de comparação
Instruções: Para cada comparação, determine se o resultado é True ou False:
Instruções: Calcule o resultado de cada expressão lógica:
True and False
True or False
not True
(5 > 3) and (2 < 4)
(10 > 15) or (3 == 3)
NoteGabarito
True and False → False (E só é True se ambos forem True)
True or False → True (OU é True se pelo menos um for True)
not True → False (NOT inverte o valor)
(5 > 3) and (2 < 4) → True (True and True = True)
(10 > 15) or (3 == 3) → True (False or True = True)
Explicação:
and: E (ambos devem ser True)
or: OU (pelo menos um deve ser True)
not: NÃO (inverte o valor)
2.6.3 Nível 3: Médio (Requer raciocínio e combina múltiplos conceitos)
2.6.3.1 Exercício 3.1: Algoritmo completo em pseudocódigo
Objetivo: Criar um algoritmo mais complexo
Instruções: Escreva o pseudocódigo para um algoritmo que:
Solicita ao usuário o raio de um círculo
Calcula a área do círculo (área = PI × raio²)
Calcula o perímetro do círculo (perímetro = 2 × PI × raio)
Exibe ambos os resultados
NoteGabarito
Início
Real: raio, area, perimetro
Real: PI = 3.14159
Escreva("Digite o raio do círculo: ")
Leia(raio)
area = PI * raio * raio
perimetro = 2 * PI * raio
Escreva("A área do círculo é: ", area)
Escreva("O perímetro do círculo é: ", perimetro)
Fim
Explicação linha-a-linha:
Real: tipo de dado para números decimais
PI = 3.14159: constante com valor fixo
raio * raio: raio ao quadrado
2 * PI * raio: fórmula do perímetro
2.6.3.2 Exercício 3.2: Algoritmo com condições
Objetivo: Criar algoritmo que toma decisões
Instruções: Escreva o pseudocódigo para um algoritmo que:
Solicita a idade do usuário
Se a idade for maior ou igual a 18, exibe “Maior de idade”
Se a idade for menor que 18, exibe “Menor de idade”
NoteGabarito
Início
Inteiro: idade
Escreva("Digite sua idade: ")
Leia(idade)
Se (idade >= 18) então
Escreva("Maior de idade")
Senão
Escreva("Menor de idade")
FimSe
Fim
Explicação linha-a-linha:
Se (condição) então: estrutura condicional
idade >= 18: condição para maioridade
Senão: caso contrário
FimSe: fim da estrutura condicional
2.6.3.3 Exercício 3.3: Algoritmo com repetição
Objetivo: Criar algoritmo que repete ações
Instruções: Escreva o pseudocódigo para um algoritmo que:
Solicita um número ao usuário
Exibe a tabuada desse número (de 1 a 10)
Para cada multiplicação, mostra: “número × contador = resultado”
NoteGabarito
Início
Inteiro: numero, contador, resultado
Escreva("Digite um número: ")
Leia(numero)
Para contador de 1 até 10 faça
resultado = numero * contador
Escreva(numero, " × ", contador, " = ", resultado)
FimPara
Fim
Explicação linha-a-linha:
Para contador de 1 até 10 faça: loop de repetição
contador: variável que conta de 1 a 10
FimPara: fim do loop
2.6.4 Nível 4: Difícil (Integra conceitos e requer planejamento)
2.6.4.1 Exercício 4.1: Sistema de notas
Objetivo: Criar um sistema completo de cálculo de notas
Instruções: Escreva o pseudocódigo para um algoritmo que:
Solicita 3 notas do usuário
Calcula a média das notas
Se a média for maior ou igual a 7, exibe “Aprovado”
Se a média for menor que 7, exibe “Reprovado”
Exibe a média calculada
NoteGabarito
Início
Real: nota1, nota2, nota3, media
Escreva("Digite a primeira nota: ")
Leia(nota1)
Escreva("Digite a segunda nota: ")
Leia(nota2)
Escreva("Digite a terceira nota: ")
Leia(nota3)
media = (nota1 + nota2 + nota3) / 3
Se (media >= 7) então
Escreva("Aprovado! Média: ", media)
Senão
Escreva("Reprovado! Média: ", media)
FimSe
Fim
Explicação linha-a-linha:
Real: tipo para notas com casas decimais
(nota1 + nota2 + nota3) / 3: cálculo da média
Estrutura condicional para aprovação/reprovação
2.6.4.2 Exercício 4.2: Calculadora de IMC
Objetivo: Criar um sistema de cálculo de IMC com classificação
Instruções: Escreva o pseudocódigo para um algoritmo que:
Solicita peso (em kg) e altura (em metros)
Calcula o IMC (IMC = peso / altura²)
Classifica o IMC:
Se IMC < 18.5: “Abaixo do peso”
Se 18.5 ≤ IMC < 25: “Peso normal”
Se 25 ≤ IMC < 30: “Sobrepeso”
Se IMC ≥ 30: “Obesidade”
NoteGabarito
Início
Real: peso, altura, imc
Escreva("Digite seu peso (kg): ")
Leia(peso)
Escreva("Digite sua altura (m): ")
Leia(altura)
imc = peso / (altura * altura)
Se (imc < 18.5) então
Escreva("IMC: ", imc, " - Abaixo do peso")
Senão
Se (imc < 25) então
Escreva("IMC: ", imc, " - Peso normal")
Senão
Se (imc < 30) então
Escreva("IMC: ", imc, " - Sobrepeso")
Senão
Escreva("IMC: ", imc, " - Obesidade")
FimSe
FimSe
FimSe
Fim
Explicação linha-a-linha:
altura * altura: altura ao quadrado
Estruturas condicionais aninhadas para classificação
Cada condição verifica um intervalo de IMC
2.6.4.3 Exercício 4.3: Sistema de login
Objetivo: Criar um sistema básico de autenticação
Instruções: Escreva o pseudocódigo para um algoritmo que:
Define uma senha correta (ex: “123456”)
Solicita ao usuário que digite a senha
Se a senha estiver correta, exibe “Acesso liberado”
Se a senha estiver incorreta, exibe “Acesso negado”
Permite até 3 tentativas
NoteGabarito
Início
Texto: senha_correta, senha_digitada
Inteiro: tentativas
senha_correta = "123456"
tentativas = 0
Enquanto (tentativas < 3) faça
Escreva("Digite a senha: ")
Leia(senha_digitada)
Se (senha_digitada == senha_correta) então
Escreva("Acesso liberado!")
tentativas = 3 // Para sair do loop
Senão
tentativas = tentativas + 1
Se (tentativas < 3) então
Escreva("Senha incorreta. Tente novamente.")
Senão
Escreva("Acesso negado. Número máximo de tentativas atingido.")
FimSe
FimSe
FimEnquanto
Fim
Explicação linha-a-linha:
Texto: tipo para strings/senhas
Enquanto (condição) faça: loop condicional
tentativas = tentativas + 1: incrementa contador
Lógica para sair do loop quando senha correta
2.6.5 Nível 5: Muito Difícil (Desafio criativo e síntese avançada)
2.6.5.1 Exercício 5.1: Sistema de cadastro de alunos
Objetivo: Criar um sistema completo de gerenciamento de alunos
Instruções: Escreva o pseudocódigo para um algoritmo que:
Solicita dados do aluno (nome, idade, curso)
Solicita 4 notas do aluno
Calcula a média das notas
Determina o status (Aprovado/Reprovado)
Exibe um relatório completo com todos os dados
Calcula estatísticas da turma (média geral, quantos aprovados/reprovados)
NoteGabarito
Início
Texto: nome, curso
Inteiro: idade
Real: nota1, nota2, nota3, nota4, media
Texto: status
Inteiro: total_alunos, aprovados, reprovados
Real: media_geral, soma_medias
// Inicialização das variáveis de controle
total_alunos = 0
aprovados = 0
reprovados = 0
soma_medias = 0
Escreva("=== SISTEMA DE CADASTRO DE ALUNOS ===")
Escreva("Digite 'fim' no nome para encerrar")
Repita
Escreva("Nome do aluno: ")
Leia(nome)
Se (nome != "fim") então
Escreva("Idade: ")
Leia(idade)
Escreva("Curso: ")
Leia(curso)
Escreva("Nota 1: ")
Leia(nota1)
Escreva("Nota 2: ")
Leia(nota2)
Escreva("Nota 3: ")
Leia(nota3)
Escreva("Nota 4: ")
Leia(nota4)
// Cálculo da média
media = (nota1 + nota2 + nota3 + nota4) / 4
// Determinação do status
Se (media >= 7) então
status = "Aprovado"
aprovados = aprovados + 1
Senão
status = "Reprovado"
reprovados = reprovados + 1
FimSe
// Atualização das estatísticas
total_alunos = total_alunos + 1
soma_medias = soma_medias + media
// Exibição do relatório do aluno
Escreva("=== RELATÓRIO DO ALUNO ===")
Escreva("Nome: ", nome)
Escreva("Idade: ", idade)
Escreva("Curso: ", curso)
Escreva("Média: ", media)
Escreva("Status: ", status)
Escreva("==========================")
FimSe
Até (nome == "fim")
// Cálculo da média geral
Se (total_alunos > 0) então
media_geral = soma_medias / total_alunos
// Exibição das estatísticas da turma
Escreva("=== ESTATÍSTICAS DA TURMA ===")
Escreva("Total de alunos: ", total_alunos)
Escreva("Aprovados: ", aprovados)
Escreva("Reprovados: ", reprovados)
Escreva("Média geral: ", media_geral)
Escreva("=============================")
Senão
Escreva("Nenhum aluno foi cadastrado.")
FimSe
Fim
Explicação linha-a-linha:
Sistema completo com loop principal
Contadores para estatísticas
Validação para evitar divisão por zero
Relatório detalhado para cada aluno
Estatísticas finais da turma
2.6.5.2 Exercício 5.2: Sistema de banco simples
Objetivo: Criar um sistema bancário básico com múltiplas operações
Instruções: Escreva o pseudocódigo para um algoritmo que:
Inicia com saldo de R$ 1000
Oferece menu de opções: (1) Consultar saldo, (2) Sacar, (3) Depositar, (4) Sair
Para saque: verifica se há saldo suficiente
Mantém histórico das últimas 5 operações
Exibe saldo atualizado após cada operação
NoteGabarito
Início
Real: saldo, valor
Inteiro: opcao
Texto: historico[5]
Inteiro: contador_historico
// Inicialização
saldo = 1000.0
contador_historico = 0
Repita
Escreva("=== BANCO PYTHON ===")
Escreva("Saldo atual: R$ ", saldo)
Escreva("1 - Consultar saldo")
Escreva("2 - Sacar")
Escreva("3 - Depositar")
Escreva("4 - Sair")
Escreva("Escolha uma opção: ")
Leia(opcao)
Se (opcao == 1) então
Escreva("Saldo atual: R$ ", saldo)
historico[contador_historico] = "Consulta de saldo"
Senão
Se (opcao == 2) então
Escreva("Digite o valor para sacar: ")
Leia(valor)
Se (valor <= saldo) então
saldo = saldo - valor
Escreva("Saque realizado! Saldo atual: R$ ", saldo)
historico[contador_historico] = "Saque: R$ " + valor
Senão
Escreva("Saldo insuficiente!")
historico[contador_historico] = "Tentativa de saque negada: R$ " + valor
FimSe
Senão
Se (opcao == 3) então
Escreva("Digite o valor para depositar: ")
Leia(valor)
saldo = saldo + valor
Escreva("Depósito realizado! Saldo atual: R$ ", saldo)
historico[contador_historico] = "Depósito: R$ " + valor
Senão
Se (opcao == 4) então
Escreva("Obrigado por usar o Banco Python!")
Senão
Escreva("Opção inválida!")
FimSe
FimSe
FimSe
FimSe
// Atualização do histórico
Se (opcao != 4) então
contador_historico = contador_historico + 1
Se (contador_historico >= 5) então
contador_historico = 0 // Volta ao início do array
FimSe
FimSe
Até (opcao == 4)
// Exibição do histórico
Escreva("=== HISTÓRICO DE OPERAÇÕES ===")
Para i de 0 até 4 faça
Se (historico[i] != "") então
Escreva((i+1), ". ", historico[i])
FimSe
FimPara
Escreva("==============================")
Fim
Explicação linha-a-linha:
Sistema de menu com loop principal
Validação de saldo para saques
Array para histórico de operações
Controle de índice circular para histórico
Interface amigável com mensagens claras
2.7 Referências bibliográficas
ALALWAN, A. A. Mobile food ordering apps: An empirical study of the factors affecting customer e-satisfaction and continued intention to reuse. International Journal of Information Management, v. 50, p. 28-44, 2020.
BRYANT, R. E.; O.’HALLARON, D. R. Computer systems: a programmer’s perspective. Upper Saddle River: Prentice Hall, 2003.
CHOI, J-C. User familiarity and satisfaction with food delivery mobile apps. Sage Open, v. 10, n. 4, 2020.
CHOO, C. W. The knowing organization: How organizations use information to construct meaning, create knowledge and make decisions. International journal of information management, v. 16, n. 5, p. 329-340, 1996.
CORMEN, T. H. et al. Introduction to algorithms. 3rd ed. MIT Press, 2009.
DOWNEY, A. B. Think Python: How to Think Like a Computer Scientist (2ª ed.). O’Reilly Media, 2015.
FARRELL, J. Programming Logic and Design, Comprehensive. Cengage Learning, 2014.
FORBELLONE, A. L. V.; EBERSPÄCHER, H. F. Lógica de programação: a construção de algoritmos e estruturas de dados. 2005.
GRAHAM, R. L. et al. Concrete mathematics: a foundation for computer science. Computers in Physics, v. 3, n. 5, p. 106-107, 1989.
HARRIS, S.; ROSS, J. Beginning algorithms. John Wiley & Sons, 2005.
KELLEHER, J. D.; TIERNEY, B. Data science: An introduction. MIT Press, 2018.
KELTON, W. D. et al. Simulation with ARENA. 6th ed. McGraw-Hill, 2014.
KNUTH, D. E. The Art of Computer Programming, Volume 1: Fundamental Algorithms. 3rd ed. Addison-Wesley, 1997.
LOUDON, K. Mastering algorithms with C. O’Reilly Media, 1999.
PRESSMAN, R. S.; MAXIM, B. R.; MAXIM, J. R. Engenharia de software: uma abordagem profissional. McGraw-Hill, 2016.
PUGA, S.; RISSETTI, G. Lógica de programação e estruturas de dados, com aplicações em Java. Pearson Educación, 2008.
SANTOS, R. L. Lógica de programação e estruturas de dados: com aplicações em Java. Editora Novatec, 2015.
SEDGEWICK, R.; WAYNE, K. Algorithms. 4th ed. Addison-Wesley, 2011.
TANENBAUM, A. S.; WOODHULL, A. S. Operating Systems: Design and Implementation. 3rd ed. Pearson, 2015.
