30 dicas de exercícios de Python para iniciantes

21. Manipulação de Datas

Manipulação de datas é uma habilidade essencial para desenvolver aplicações que lidam com tempo e datas, como sistemas de agendamento e controle de versão. Compreender como usar o módulo datetime para manipular datas permite realizar cálculos precisos e formatar datas conforme necessário. Este exercício de Python ajuda os iniciantes a praticar a manipulação de datas, uma habilidade importante para muitas aplicações.

Exercício: Use o módulo datetime para calcular a diferença em dias entre duas datas fornecidas pelo usuário.

from datetime import datetime

data1 = input("Digite a primeira data (dd/mm/yyyy): ")
data2 = input("Digite a segunda data (dd/mm/yyyy): ")

formato = "%d/%m/%Y"
d1 = datetime.strptime(data1, formato)
d2 = datetime.strptime(data2, formato)

diferenca = abs((d2 - d1).days)
print("Diferença em dias:", diferenca)

Explicação: O módulo datetime é usado para converter strings de datas em objetos datetime. A diferença em dias entre as duas datas é calculada e exibida.

22. Testes Unitários

Testes unitários são uma prática essencial para garantir a qualidade e a confiabilidade do código. Eles permitem verificar se as funções individuais funcionam corretamente e facilitam a manutenção do código. Este exercício de Python ensina os iniciantes a escrever e executar testes unitários, uma habilidade importante para desenvolver software robusto e confiável.

Exercício: Crie uma função que calcule o fatorial de um número e escreva testes unitários para essa função.

main.py:

def fatorial(n):
if n == 0:
return 1
else:
return n * fatorial(n - 1)

test_main.py:

import unittest
from main import fatorial

class TestFatorial(unittest.TestCase):
def test_fatorial_0(self):
self.assertEqual(fatorial(0), 1)

def test_fatorial_5(self):
self.assertEqual(fatorial(5), 120)

def test_fatorial_10(self):
self.assertEqual(fatorial(10), 3628800)

if __name__ == '__main__':
unittest.main()

Explicação: Criamos uma função fatorial que calcula o fatorial de um número de forma recursiva. Em seguida, escrevemos testes unitários para verificar se a função retorna os resultados esperados.

23. Conexão com Banco de Dados

Interagir com bancos de dados é uma habilidade crucial para desenvolver aplicações que manipulam grandes volumes de dados. Compreender como usar o módulo sqlite3 para criar e manipular bancos de dados permite armazenar e recuperar dados de maneira eficiente. Este exercício de Python ensina os iniciantes a trabalhar com bancos de dados SQLite, uma habilidade importante para muitas aplicações de software.

Exercício: Use o módulo sqlite3 para criar um banco de dados, adicionar uma tabela e inserir alguns registros.

import sqlite3

# Conectando ao banco de dados (ou criando um novo)
conexao = sqlite3.connect('meu_banco.db')
cursor = conexao.cursor()

# Criando uma tabela
cursor.execute('''CREATE TABLE IF NOT EXISTS pessoas
(id INTEGER PRIMARY KEY, nome TEXT, idade INTEGER)''')

# Inserindo alguns registros
cursor.execute("INSERT INTO pessoas (nome, idade) VALUES ('Alice', 30)")
cursor.execute("INSERT INTO pessoas (nome, idade) VALUES ('Bob', 25)")

# Confirmando as alterações
conexao.commit()

# Consultando os registros
cursor.execute("SELECT * FROM pessoas")
for row in cursor.fetchall():
print(row)

# Fechando a conexão
conexao.close()

Explicação: Este programa cria uma conexão com um banco de dados SQLite, cria uma tabela se não existir, insere alguns registros e consulta os dados. A conexão é fechada após a execução das operações.

24. Web Scraping

Web Scraping é uma técnica poderosa para coletar dados de sites de forma automatizada. Compreender como usar bibliotecas como requests e BeautifulSoup permite acessar e processar dados da web de maneira eficiente. Este exercício de Python ensina os iniciantes a realizar web scraping, uma habilidade valiosa para muitas aplicações de análise de dados e monitoramento.

Exercício: Use a biblioteca BeautifulSoup para extrair os títulos de artigos de um blog.

import requests
from bs4 import BeautifulSoup

url = "https://example.com/blog"
resposta = requests.get(url)
soup = BeautifulSoup(resposta.content, "html.parser")

for titulo in soup.find_all("h2", class_="post-title"):
print(titulo.get_text())

Explicação: Utilizamos a biblioteca requests para obter o conteúdo de uma página web e BeautifulSoup para analisar o HTML. A função find_all é usada para extrair os títulos dos artigos, que são então impressos.

25. Criação de Gráficos

Visualização de dados é uma parte essencial da análise de dados. Compreender como usar bibliotecas como matplotlib para criar gráficos permite representar dados de maneira visual e comunicar resultados de forma eficaz. Este exercício de Python ensina os iniciantes a criar gráficos de barras, uma habilidade importante para muitas aplicações de análise de dados.

Exercício: Use a biblioteca matplotlib para criar um gráfico de barras mostrando a quantidade de frutas.

import matplotlib.pyplot as plt

frutas = ["Maçãs", "Bananas", "Laranjas", "Uvas"]
quantidades = [10, 15, 7, 12]

plt.bar(frutas, quantidades)
plt.xlabel('Frutas')
plt.ylabel('Quantidades')
plt.title('Quantidades de Frutas')
plt.show()

Explicação: A biblioteca matplotlib é usada para criar um gráfico de barras. As listas frutas e quantidades contêm os dados a serem plotados. O gráfico é configurado e exibido usando plt.show.

26. Análise de Dados

Análise de dados é uma habilidade crucial em muitas áreas, desde ciência de dados até negócios. Compreender como usar bibliotecas como pandas para manipular e analisar dados permite extrair insights valiosos de grandes conjuntos de dados. Este exercício de Python ensina os iniciantes a usar pandas para leitura e análise de dados, uma habilidade importante para muitas aplicações de análise de dados.

Exercício: Use a biblioteca pandas para ler um arquivo CSV e exibir estatísticas básicas.

import pandas as pd

dados = pd.read_csv("dados.csv")
print(dados.describe())

Explicação: Utilizamos a biblioteca pandas para ler um arquivo CSV contendo dados e describe para exibir estatísticas básicas, como média, desvio padrão e quartis.

27. Processamento de Imagens

Processamento de imagens é uma habilidade importante para aplicações que lidam com imagens, como reconhecimento de padrões e análise visual. Compreender como usar bibliotecas como PIL permite manipular e processar imagens de maneira eficiente. Este exercício de Python ensina os iniciantes a realizar operações básicas de processamento de imagens, uma habilidade valiosa para muitas aplicações de análise e processamento de imagens.

Exercício: Use a biblioteca PIL para abrir uma imagem, converter para escala de cinza e salvar a imagem convertida.

from PIL import Image

imagem = Image.open("imagem.jpg")
imagem_cinza = imagem.convert("L")
imagem_cinza.save("imagem_cinza.jpg")

Explicação: A biblioteca PIL (Pillow) é usada para abrir uma imagem, convertê-la para escala de cinza usando o método convert e salvar a nova imagem.

28. Desenvolvimento Web

Desenvolvimento web é uma habilidade essencial para criar aplicações web dinâmicas e interativas. Compreender como usar frameworks como Flask e Django permite desenvolver e implementar aplicações web de maneira eficiente. Este exercício de Python ensina os iniciantes a criar uma aplicação web básica, uma habilidade importante para muitos desenvolvedores.

Exercício: Crie uma aplicação web simples com Flask que exiba "Olá, Mundo!" em uma página.

from flask import Flask

app = Flask(__name__)

@app.route("/")
def ola_mundo():
return "Olá, Mundo!"

if __name__ == '__main__':
app.run(debug=True)

Explicação: Utilizamos o framework Flask para criar uma aplicação web básica. Definimos uma rota (/) que retorna a mensagem "Olá, Mundo!". A aplicação é executada com app.run.

29. Automação com Python

Automação de tarefas é uma habilidade valiosa que permite economizar tempo e aumentar a eficiência. Compreender como usar Python para automatizar tarefas repetitivas permite criar scripts que realizam essas tarefas de maneira rápida e confiável. Este exercício de Python ensina os iniciantes a automatizar a verificação de URLs, uma aplicação prática e útil da automação.

Exercício: Crie um script que leia uma lista de URLs de um arquivo e verifique se cada URL está acessível.

import requests

def verificar_urls(arquivo):
with open(arquivo, 'r') as f:
urls = f.readlines()

for url in urls:
try:
resposta = requests.get(url.strip())
if resposta.status_code == 200:
print(f"{url.strip()} está acessível")
else:
print(f"{url.strip()} retornou status {resposta.status_code}")
except requests.ConnectionError:
print(f"{url.strip()} não está acessível")

arquivo = 'urls.txt'
verificar_urls(arquivo)

Explicação: O script lê URLs de um arquivo e usa a biblioteca requests para verificar se cada URL está acessível, tratando possíveis erros de conexão.

30. Machine Learning com Scikit-Learn

Machine learning é uma habilidade avançada que permite criar modelos preditivos a partir de dados. Compreender como usar bibliotecas como scikit-learn para treinar e avaliar modelos de machine learning permite desenvolver aplicações inteligentes e baseadas em dados. Este exercício de Python ensina os iniciantes a treinar um modelo de regressão linear, uma habilidade fundamental para muitos projetos de machine learning.

Exercício: Use scikit-learn para treinar um modelo de regressão linear simples.

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
import numpy as np

# Dados de exemplo
X = np.array([[1], [2], [3], [4], [5]])
y = np.array([1, 3, 2, 5, 4])

# Dividindo os dados em treino e teste
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

# Treinando o modelo
modelo = LinearRegression()
modelo.fit(X_train, y_train)

# Fazendo previsões
y_pred = modelo.predict(X_test)
print("Valores previstos:", y_pred)
print("Valores reais:", y_test)

Explicação: Utilizamos scikit-learn para dividir os dados em conjuntos de treinamento e teste, treinar um modelo de regressão linear e fazer previsões.

Conclusão

Aprender Python pode ser uma jornada empolgante e recompensadora. Os exercícios de Python apresentados abordam conceitos fundamentais da linguagem, desde a sintaxe básica até tópicos mais avançados, como programação orientada a objetos e uso de bibliotecas externas. Praticar esses exercícios ajudará a consolidar o conhecimento e preparar o iniciante para desafios mais complexos. Lembre-se de que a prática constante e a curiosidade são chaves para se tornar proficiente em Python. Boa sorte em sua jornada de aprendizado!

Para continuar aprendendo e tirar dúvidas ao longo do processo, é fundamental fazer parte de uma comunidade ativa. No Fórum da Casa do Desenvolvedor, você pode se conectar com mais de 18 mil desenvolvedores. Esta comunidade vibrante oferece um espaço para compartilhar conhecimentos, resolver problemas e aprender com especialistas na área. Aproveite essa oportunidade para crescer e se desenvolver como programador Python, contando com o suporte de uma rede ampla e engajada de profissionais.