Praticando Python: trabalhando com projetos

Projetos em Python - Desenvolvendo projetos

Olá! Meu nome é Laís Urano, sou instrutora na Escola de Programação da Alura.

Audiodescrição: Laís Urano se descreve como uma mulher parda, com olhos e cabelos castanhos cacheados abaixo dos ombros. Ao fundo, parede lisa com iluminação gradiente do azul ao verde.

Quando precisamos desenvolver um projeto ou nos deparamos com um problema na programação, muitas vezes não sabemos exatamente por onde começar. Essa é a situação que enfrentamos agora.

Nosso problema é simples: realizar a soma de dois números digitados pelo usuário.

Identificando o problema

Primeiramente, precisamos identificar o problema geral, que é a soma de dois números fornecidos pelo usuário. Para resolver esse problema, vamos dividi-lo em subproblemas para seguir um passo a passo:

1. Pedir dois números ao usuário;
2. Somar esses números;
3. Mostrar o resultado para o usuário;
4. Após a execução bem-sucedida desse processo, testar e melhorar o código.

Criando o código

Sendo assim, podemos criar o código inicial. Para isso, criamos um arquivo onde adicionamos o primeiro esboço do código.

A primeira variável chamada numero1 recebe um valor do input() do usuário. Lembrando que o input() retorna uma string. Em seguida, convertemos essa string para float (número decimal). A segunda variável, numero2, segue o mesmo processo.

Depois, criamos a variável soma, que realiza a soma desses dois números, e utilizamos o print() para exibir o valor dessa soma.

numero1 = float(input())
numero2 = float(input())

soma = numero1 + numero2
print(soma)

Saída:

2
5
7.0

A saída que obtemos é simples: 2, 5 e 7.0. No entanto, o nosso código não é muito intuitivo. Não sabemos o que representam cada número da saída. Além disso, a soma não está encapsulada, ou seja, sempre que precisarmos somar valores, teremos que criar novamente a variável soma. Isso não é o ideal para o nosso projeto.

Melhorando o código

O primeiro passo para melhorar o código é encapsular a lógica de soma dentro de uma função e separar as responsabilidades em funções distintas.

Levando isso em conta, definimos a função def somar(), que recebe os parâmetros a e b, representando os dois valores, e retorna a soma a + b.

Além disso, no input() onde capturamos as variáveis numero1 e numero2, podemos informar ao usuário o que é preciso digitar. Por exemplo, "Digite o primeiro número" e "Digite o segundo número".

Por fim, o resultado será uma chamada para a função somar(), passando os dois valores das variáveis. Com isso, podemos repetir esse resultado quantas vezes quisermos. O print(), que vem logo após o resultado, exibirá a soma concatenada a uma frase explicativa.

def somar(a, b):
    return a + b

numero1 = float(input("Digite o primeiro número: "))
numero2 = float(input("Digite o segundo número: "))

resultado = somar(numero1, numero2)
print(f"A soma é: {resultado}")

Saída:

Digite o primeiro número: 2
Digite o segundo número: 5
A soma é: 7.0

Quando verificamos a saída desse código, ela se torna mais clara. Sabemos que digitamos um primeiro número (que é 2) e um segundo número (que é 5), recebemos a soma desses valores (que é 7.0).

Tratando possíveis erros

No entanto, precisamos tratar possíveis erros que o código possa ter, como quando o usuário digita algo inválido. Por exemplo, se alguém digitar uma letra em vez de um número, não conseguiremos converter esse valor para float, o que quebraria o código.

Para evitar isso, colocamos o código que criamos para numero1, numero2 resultado e print() dentro de um bloco try/except. O try tentará executar o código. Caso não consiga, devido a um valor inválido, o except exibirá uma mensagem de erro.

def somar(a, b):
    return a + b

try:
    numero1 = float(input("Digite o primeiro número: "))
    numero2 = float(input("Digite o segundo número: "))

    resultado = somar(numero1, numero2)
    print(f"A soma é: {resultado}")
except ValueError:
    print("Erro: Digite apenas números válidos!")

Saída:

Digite o primeiro número: abc
Erro: Digite apenas números válidos!

Para testar o código, podemos digitar abc como o primeiro número. Assim, receberemos automaticamente a mensagem de erro, informando que apenas números válidos devem ser digitados.

Dessa forma, o código não quebrará, apenas informará ao usuário que a execução não foi possível.

Testando manualmente

Além disso, podemos testar manualmente diversos cenários possíveis. Por exemplo, além de digitar um texto, o usuário pode simplesmente não inserir valor algum.

Saída:

Digite o primeiro número: 5
Digite o primeiro número:
Erro: Digite apenas números válidos!

Se alguém digitar o primeiro número, mas apenas pressionar "Enter" no segundo campo, sem digitar valor algum, deve receber um erro, pois esse valor não pôde ser convertido, já que não existe.

Saída:

Digite o primeiro número: 2
Digite o segundo número: 5
A soma é: 7.0

Da mesma maneira, quando alteramos um código, é necessário testar novamente para verificar se o código está funcionando corretamente. Novamente, podemos digitar 2 e 5 para conferir se a soma será 7.0.

Explorando possíveis erros em projetos

No entanto, o ValueError não é o único erro que pode ocorrer. Existem diversos possíveis erros que podem surgir em um projeto, e precisamos estar cientes disso.

Por exemplo, o erro de entrada inválida, que ocorre quando não conseguimos converter um valor para o tipo indicado, como, por exemplo, uma string "abc" para float. Podemos tratar esse erro com um bloco de execução try/except.

Além disso, podemos receber um tipo inválido, caso esqueçamos de converter uma das variáveis de soma e tentemos somar um número com uma string. Isso não é possível, pois são incompatíveis. Resolvemos esse erro convertendo corretamente esses valores.

Também podemos enfrentar erros de índice fora da lista, uma chave inexistente em dicionários, erro de importação de módulo, módulo não encontrado, ou um atributo inexistente, caso não consigamos acessar esse atributo. Erros de sintaxe, como esquecer dois pontos ou parênteses, também podem ocorrer.

Existem inúmeros erros que podemos tratar ao trabalhar em um projeto. Precisamos apenas identificar quais são os mais importantes para o projeto específico em que estamos trabalhando.

Há diversos erros específicos no Python. Para conhecê-los com mais atenção, você pode consultar a documentação oficial do Python, especialmente quando nos deparamos com um erro desconhecido e não sabemos como tratá-lo no projeto.

Seguindo boas práticas

Além disso, é fundamental seguir boas práticas de programação. É essencial conhecer a PEP 8, que é um guia de estilo para escrever código em Python de forma legível, organizada e padronizada. Seguir essas regras facilita a organização, manutenção, colaboração e qualidade do código.

As boas práticas são importantes também para: a organização e estrutura do código, como a indentação correta; nomeação de variáveis, funções e classes, seguindo o padrão de PascalCase e snake_case no Python; e comentários de documentação claros e objetivos nos projetos.

Caso você queira se aprofundar nesse tema, há uma formação completa de boas práticas em Python que aborda toda a PEP 8 e vários assuntos adicionais, indicada para quem quer aprimorar suas práticas de programação, alinhadas com o mercado de trabalho.

Conclusão

É importante relembrar o passo a passo que seguimos: primeiro, definimos o problema geral. Em seguida, organizamos a execução em um passo a passo para a construção do projeto.

Depois, estruturamos o projeto. Nesse momento, poderíamos tanto colocar as funcionalidades em funções diferentes quanto separá-las em arquivos distintos, conforme a necessidade do projeto. Só assim começamos a escrever nosso código e, por fim, testamos e refinamos o projeto.

Agora que entendemos esse passo a passo e a lógica para construir um projeto, podemos aplicar esses conhecimentos em um projeto prático a seguir.

Projetos em Python - Praticando projetos

Agora que entendemos o passo a passo de desenvolver um projeto e construí-lo, recebemos um novo problema: criar um contador de palavras. O projeto deve receber uma frase do usuário e contar quantas vezes cada palavra aparece.

Identificando o problema

Assim, temos um problema geral, que é o contador de palavras. Precisamos dividi-lo em vários passos:

1. Entrada e o processamento de dados;
2. Criação da contagem das palavras;
3. Exibição dessa contagem;
4. Teste e refinamento do código.

Criando o código

Para começar, criamos um arquivo chamado contador.py onde desenvolveremos o código inicial.

A primeira ação é receber a frase através de uma variável frase, utilizando a função input() com a mensagem "Digite uma frase". Em seguida, queremos separar cada palavra pelo espaçamento, então criamos uma variável palavras e utilizamos frase.split() para separar cada palavra pelo espaço e criar uma lista de palavras.

Depois, imprimimos o tamanho dessa lista de palavras com a função len() e também as palavras em si, para verificar o que foi armazenado.

contador.py:

frase = input("Digite uma frase: ")
palavras = frase.split()
print(len(palavras))
print(palavras)

Saída:

Digite uma frase: olá mundo mundo!!
3
['olá', 'mundo', 'mundo!!']

Para testar, digitamos a frase "Olá, mundo, mundo!!". Na saída, imprimimos o número 3, pois foram reconhecidas 3 palavras nessa frase. Logo depois, imprimimos as 3 palavras armazenadas na lista.

No entanto, nosso código apresenta duas funcionalidades principais. A primeira é a entrada e saída de dados, onde recebemos a mensagem e a passamos para o usuário. A segunda é o processo interno do contador. Podemos, então, dividir essas funcionalidades.

Melhorando o código

Primeiro, devemos criar uma função para o contador e inseri-la no arquivo contador.py.

A função contar_palavras() receberá apenas a frase como parâmetro. Nela, faremos o mesmo processo anterior. Criaremos uma variável palavras que recebe frase.split(). Depois, imprimiremos essas palavras para verificar o que foi recebido e fazer um return para enviar o tamanho dessas palavras.

contador.py:

def contar_palavras(frase):
    palavras = frase.split()
    print(palavras)
    return len(palavras)

Agora, a lógica de receber essa frase e passá-la para o usuário estará em um arquivo chamado main.py, que será criado no mesmo diretório de contador.py.

No main.py, importamos a função contar_palavras do contador. Em seguida, criamos uma variável frase para receber o input() do usuário e a variável quantidade que executará a função contar_palavras(), passando a frase.

Por fim, fazemos um print() para exibir um texto concatenado com a quantidade de palavras.

main.py:

from contador import contar_palavras

frase = input("Digite uma frase: ")
quantidade = contar_palavras(frase)
print(f"A frase tem {quantidade} palavras.")

Saída:

Digite uma frase: livros são livros.
['livros', 'são', 'livros.']
A frase tem 3 palavras.

Para testar, digitamos a frase "livros são livros.". Na saída, recebemos a informação de que foram armazenadas as palavras "livros", "são" e "livros.", totalizando três palavras.

Contudo, existe um problema nesse projeto. As palavras "livros" e "livros." estão sendo consideradas palavras diferentes, e a pontuação na frase está sendo considerada uma palavra válida, o que não é adequado.

Explorando possíveis entradas do usuário

Por isso, precisamos identificar as possíveis entradas do usuário e as problemáticas associadas a elas.

Por exemplo, uma entrada vazia, onde o usuário pressiona "Enter" sem digitar nada, não pode ser considerada válida, pois o código pode falhar. Também não deveríamos considerar entradas com apenas espaços ou pontuações.

Do mesmo modo, é importante tratar caracteres especiais, acentos, pontuações dentro do texto e vários espaços entre palavras, pois podem gerar listas incorretas com a função split().

Além disso, palavras repetidas, independentemente de conter letras maiúsculas ou minúsculas, devem ser consideradas como uma única palavra no cálculo do tamanho da frase.

De acordo com a regra de negócio estabelecida nesse projeto, números na frase serão considerados palavras válidas, mas isso pode ser ajustado conforme o contexto. Também devemos nos atentar para entradas que contenham apenas números ou uma mistura de letras e números.

Tratando o código

Para começar a tratar essas questões no projeto, podemos remover as pontuações e converter todas as palavras para letras minúsculas, garantindo que sejam consideradas iguais - independente da capitalização.

Dentro do arquivo contador.py, podemos criar uma função chamada limpar_texto(), que receberá o texto como parâmetro. A primeira ação será utilizar a função lower() para transformar todo o texto em letras minúsculas.

Em seguida, criaremos uma variável chamada caracteres, na qual listaremos todos os caracteres que não queremos considerar.

Depois, passaremos por um bloco de repetição para cada caractere dentro dessa string de caracteres, utilizando a função replace() para substituir o caractere por nada, ou seja, apagando-o do texto.

Assim, retornaremos o texto limpo e tratado, o qual será utilizado na função contar_palavras().

contador.py:

def limpar_texto(texto):
    texto = texto.lower()
    caracteres = ".,!?:;\"'()[]{}"
    for char in caracteres:
        texto = texto.replace(char, "")
    return texto

Na função contar_palavras(), chamaremos a função limpar_texto() para obter a frase limpa. Em seguida, dividiremos as palavras dessa frase limpa através do split(). Por último, retornaremos a quantidade de palavras.

def contar_palavras(frase):
    frase = limpar_texto(frase)
    palavras = frase.split()
    return len(palavras)

Só que ainda precisamos verificar a frequência dessas palavras e evitar palavras inválidas.

Por isso, ainda na função contar_palavras(), depois de limpar a frase, podemos verificar se há algo válido nessa variável. Se não houver nada válido, retornaremos um dicionário vazio, pois não existem palavras válidas nesse momento. Caso contrário, separaremos as palavras com frase.split(), transformando-as em uma lista novamente.

A contagem será feita em um dicionário, onde a chave será a palavra e o valor será a quantidade de ocorrências na frase. Para adicionar essas palavras no dicionário vazio, vamos utilizar um bloco de repetição for onde passaremos por cada palavra dentro de palavras.

Se a palavra já existir no dicionário, somaremos 1 à contagem. Caso contrário, criaremos uma nova chave com a palavra e iniciaremos a contagem em 1, ou seja, teremos a primeira ocorrência da palavra. Finalmente, retornaremos o dicionário de contagem.

def contar_palavras(frase):
    frase = limpar_texto(frase)
    if not frase.strip():
        return {}
    
    palavras = frase.split()
    contagem = {}
    
    for palavra in palavras:
        contagem[palavra] = contagem.get(palavra, 0) + 1
    
    return contagem

Agora, temos duas possibilidades de retorno: um dicionário vazio ou um dicionário com todas as palavras e suas frequências.

Feito isso, podemos aprimorar o código no arquivo main.py, verificando se a entrada está vazia e apresentando a contagem da frequência de palavras de forma clara para o usuário.

No momento em que armazenamos a frase, podemos remover todos os espaços vazios através do método strip().

Em seguida, fazemos uma verificação com o if. Se a frase estiver vazia, imprimos uma mensagem indicando que nenhuma frase foi digitada. Caso contrário, passamos a frase para a função contar_palavras() e armazenamos isso na variável resultado.

Com isso, podemos fazer outro if. Dessa vez, queremos verificar se há um resultado, ou seja, se recebemos um dicionário que não está vazio, imprimimos cada palavra e sua quantidade. Para isso, fazemos um for em resultado.items() que retorna o par chave e valor do dicionário. Caso contrário, indicamos que nenhuma palavra válida foi encontrada.

main.py:

from contador import contar_palavras

frase = input("Digite uma frase: ").strip()
if not frase:
    print("Erro: Nenhuma frase foi digitada.")
else:
    resultado = contar_palavras(frase)
    if resultado:
        print("Contagem de Palavras:")
        for palavra, quantidade in resultado.items():
            print(f"{palavra}: {quantidade}")
    else:
        print("Nenhuma palavra válida foi encontrada.")

Com isso, o main trata as condições de nenhuma frase digitada e nenhuma palavra válida encontrada.

Testando diferentes situações

Agora, podemos verificar exemplos de resposta.

No primeiro exemplo, digitamos a palavra "OLÁ, mUndo!" com uma mistura de letras maiúsculas e minúsculas, além de vírgula e exclamação. Ainda assim, o programa considera apenas 2 palavras válidas, como esperado.

Saída:

Digite uma frase: OLÁ, mUndo!
Contagem de palavras:
olá: 1
mundo: 1

Também podemos digitar "python(] é incrível incrível.", com pontuação e palavras repetidas. Na contagem, foram identificadas apenas uma ocorrência das palavras "python" e "é", mas duas ocorrências da palavra "incrível".

Saída:

Digite uma frase: python(] é incrível incrível.
Contagem de palavras:
python: 1
é: 1
incrível: 2

Além disso, podemos escrever palavras que contém letras e números, como a pergunta "Python3 é melhor que o Python2 em 2025?". Nossa regra de negócio ainda considera esses ocorrências como palavras válidas.

Saída:

Digite uma frase: Python3 é melhor que Python2 em 2025?
Contagem de palavras:
python3: 1
é: 1
melhor: 1
que: 1
python2: 1
em: 1
2025: 1

Próximos passos

Agora que concluímos este projeto, é hora de praticar. Utilize as atividades deste curso para aprimorar seus conhecimentos. Caso tenha dúvidas ou queira discutir o conteúdo, utilize o fórum e o Discord da Alura. Compartilhe o resumo dos seus novos conhecimentos em suas redes sociais, utilizando a hashtag #aprendizadoalura. Até a próxima!

Sobre o curso Praticando Python: trabalhando com projetos

O curso Praticando Python: trabalhando com projetos possui 18 minutos de vídeos, em um total de 15 atividades. Gostou? Conheça nossos outros cursos de em Programação, ou leia nossos artigos de Programação.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Projetos em Python