Python Prático para Engenharias

Prof. Jéfer Benedett Dörr

Departamento de Engenharias e Exatas – UFPR/Palotina

Material prático para Engenharias, usando Google Colab, datasets reais e ferramentas modernas

🚀 Por que Python? Por que Google Colab?

Python é a linguagem mais popular para ciência de dados, automação, engenharia e pesquisa, devido à sua simplicidade, versatilidade e vasta comunidade. O Google Colab é uma plataforma gratuita que permite programar diretamente no navegador, com suporte a GPUs, integração com Google Drive e bibliotecas pré-instaladas.

• Simplicidade: Sintaxe clara, ideal para iniciantes e profissionais.
• Gratuito: Google Colab é 100% gratuito e roda na nuvem.
• Poderoso: Suporta bibliotecas como pandas, NumPy, Matplotlib, TensorFlow e Keras.
• Acessível: Sem instalação, disponível em colab.research.google.com.
• Colaboração: Compartilhe notebooks como documentos do Google Drive.

🟢 Primeiros Passos no Google Colab

Acesse o Google Colab e crie um novo notebook. Um notebook é composto por células de código ou texto. Execute o código abaixo para começar:

print("Olá, Engenharia! 🌱📊")
# Exemplo com variáveis
nome = "Engenheiro"
especie = "Iris"
print(f"Bem-vindo, {nome}! Vamos analisar dados da planta {especie}! 🚀")

Teste Você Mesmo! Altere a mensagem, adicione variáveis (ex.: nome da planta) e experimente emojis diferentes.

📊 Manipulando Dados Reais com pandas

A biblioteca pandas é ideal para trabalhar com tabelas, como planilhas Excel. Usaremos o Iris dataset do Kaggle, que contém medições de pétalas e sépalas de três espécies de flores (setosa, versicolor, virginica).[](https://archive.ics.uci.edu/)

import pandas as pd

# Carregar o Iris dataset
url = "https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv"
df = pd.read_csv(url)

# Exibir as primeiras 5 linhas
print(df.head())

# Resumo estatístico
print(df.describe())

# Contar espécies
print(df['species'].value_counts())

Teste Você Mesmo! Renomeie colunas com df.rename(columns={'sepal_length': 'comprimento_sepala'}) ou agrupe dados por espécie com df.groupby('species').mean().

Selecionando e Filtrando Dados

Filtre dados com base em condições, como pétalas maiores que 5 cm ou espécies específicas.

# Selecionar a coluna 'petal_length'
comprimento_petala = df['petal_length']

# Filtrar pétalas maiores que 5 cm
grandes = df[df['petal_length'] > 5]

# Filtrar apenas a espécie 'setosa'
setosa = df[df['species'] == 'setosa']

# Combinar condições (pétalas grandes e espécie 'virginica')
virginica_grandes = df[(df['petal_length'] > 5) & (df['species'] == 'virginica')]

print("Pétalas > 5 cm:\n", grandes.head())
print("\nApenas setosa:\n", setosa.head())
print("\nVirginica com pétalas grandes:\n", virginica_grandes.head())

Explicação: Use colchetes para acessar colunas (df['coluna']) e condições lógicas para filtrar. Combine condições com & (and), | (or) ou ~ (not).

Teste Você Mesmo! Filtre sépalas largas (> 3 cm) ou combine condições para outras espécies.

Transformando Dados

Crie novas colunas, substitua valores ou lide com dados ausentes.

# Criar coluna com razão entre comprimento e largura da pétala
df['petal_ratio'] = df['petal_length'] / df['petal_width']

# Substituir valores ausentes (se houver) por média
df['sepal_length'] = df['sepal_length'].fillna(df['sepal_length'].mean())

# Categorizar comprimento da pétala
df['petal_size'] = pd.cut(df['petal_length'], bins=[0, 3, 5, 7], labels=['Pequena', 'Média', 'Grande'])

print(df[['petal_length', 'petal_width', 'petal_ratio', 'petal_size']].head())

Teste Você Mesmo! Crie uma coluna com a razão entre sépala e pétala ou categorize outra variável.

🧮 Cálculos Avançados com NumPy

O NumPy é essencial para cálculos numéricos eficientes, como estatísticas, matrizes e normalização.

import numpy as np

# Criar array com comprimentos de pétalas
petalas = np.array(df['petal_length'])

# Cálculos estatísticos
media = np.mean(petalas)
desvio = np.std(petalas)
maximo = np.max(petalas)
minimo = np.min(petalas)

# Normalizar valores
petalas_normalizadas = (petalas - minimo) / (maximo - minimo)

# Operações com matrizes
matriz_sepalas = np.array(df[['sepal_length', 'sepal_width']])
media_por_coluna = np.mean(matriz_sepalas, axis=0)

print(f"Média: {media:.2f}, Desvio padrão: {desvio:.2f}")
print(f"Normalizadas: {petalas_normalizadas[:5]}")
print(f"Média por coluna (sépalas): {media_por_coluna}")

Teste Você Mesmo! Crie uma matriz com pétalas e calcule a mediana por coluna com np.median(matriz, axis=0).

📈 Visualização Gráfica com Matplotlib

A Matplotlib cria gráficos personalizados para análise de dados. Vamos visualizar o Iris dataset com diferentes tipos de gráficos.

import matplotlib.pyplot as plt
import pandas as pd

# Carregar dados
url = "https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv"
df = pd.read_csv(url)

# Gráfico de dispersão
plt.figure(figsize=(10, 6))
for especie in df['species'].unique():
    subset = df[df['species'] == especie]
    plt.scatter(subset['sepal_length'], subset['sepal_width'], label=especie, s=50)
plt.title("Sépalas por Espécie")
plt.xlabel("Comprimento da Sépala (cm)")
plt.ylabel("Largura da Sépala (cm)")
plt.legend()
plt.grid(True)
plt.savefig('sepalas_dispersao.png')
plt.show()

# Gráfico de barras
media_especies = df.groupby('species')['petal_length'].mean()
plt.figure(figsize=(8, 5))
plt.bar(media_especies.index, media_especies.values, color=['blue', 'green', 'orange'])
plt.title("Média do Comprimento da Pétala por Espécie")
plt.xlabel("Espécie")
plt.ylabel("Comprimento da Pétala (cm)")
plt.show()

# Gráfico de caixa (boxplot)
plt.figure(figsize=(8, 5))
plt.boxplot([df[df['species'] == especie]['petal_length'] for especie in df['species'].unique()],
            labels=df['species'].unique())
plt.title("Distribuição do Comprimento da Pétala por Espécie")
plt.ylabel("Comprimento da Pétala (cm)")
plt.show()

Teste Você Mesmo! Crie um gráfico de pizza com plt.pie para a contagem de espécies ou um histograma com plt.hist.

# Exemplo de arquivo materiais.csv:
# Material,Quantidade,Custo_unitario
# Concreto,12.5,350
# Aço,1.8,4500
# Tijolos,1500,1.1

import pandas as pd
import matplotlib.pyplot as plt

# 1. Carregar planilha
df = pd.read_csv('materiais.csv')

# 2. Calcular custo total de cada item
df['Custo_total'] = df['Quantidade'] * df['Custo_unitario']
custo_total_geral = df['Custo_total'].sum()
print(df)
print(f"Custo total da obra: R$ {custo_total_geral:.2f}")

# 3. Gráfico de pizza dos gastos
plt.figure(figsize=(6, 6))
plt.pie(df['Custo_total'], labels=df['Material'], autopct='R$%.2f', startangle=90)
plt.title('Distribuição dos Custos por Material')
plt.tight_layout()
plt.show()

🟠 Relatório de Aula

Python para relatórios.

    !pip install pandas numpy matplotlib reportlab

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from reportlab.lib.pagesizes import A4
from reportlab.pdfgen import canvas
from reportlab.lib.utils import ImageReader

# 1. Criar tabela de alunos e notas
np.random.seed(42)
alunos = ["Ana", "Bruno", "Clara", "Diego", "Elena", "Fernanda"]
notas = np.random.uniform(5, 10, (len(alunos), 4)).round(1)
df = pd.DataFrame(notas, columns=["Nota 1", "Nota 2", "Nota 3", "Nota 4"])
df.insert(0, "Aluno", alunos)
df["Média"] = df[["Nota 1", "Nota 2", "Nota 3", "Nota 4"]].mean(axis=1).round(2)
df["Status"] = np.where(df["Média"] >= 7, "Aprovado", "Reprovado")

print(df)

# 2. Gráfico das médias
plt.figure(figsize=(8, 5))
plt.bar(df["Aluno"], df["Média"], color='teal')
plt.axhline(7, color='red', linestyle='--', label="Média Mínima")
plt.title("Média dos Alunos")
plt.ylabel("Média Final")
plt.legend()
plt.tight_layout()
plt.savefig("grafico_medias.png")
plt.show()

# 3. Gerar relatório em PDF
pdf_name = "relatorio_alunos.pdf"
c = canvas.Canvas(pdf_name, pagesize=A4)
larg, alt = A4

# Título
c.setFont("Helvetica-Bold", 18)
c.drawString(50, alt - 50, "Relatório de Notas dos Alunos")

# Tabela
c.setFont("Helvetica", 12)
tabela_y = alt - 100
c.drawString(50, tabela_y, "Aluno    N1    N2    N3    N4    Média   Status")
for idx, row in df.iterrows():
    linha = f"{row['Aluno']:8} {row['Nota 1']:4.1f} {row['Nota 2']:4.1f} {row['Nota 3']:4.1f} {row['Nota 4']:4.1f}  {row['Média']:6.2f}  {row['Status']}"
    c.drawString(50, tabela_y - 20*(idx+1), linha)

# Gráfico no PDF
c.drawString(50, tabela_y - 20*(len(df)+2), "Gráfico das médias:")
grafico_y = tabela_y - 20*(len(df)+4)
img = ImageReader("grafico_medias.png")
c.drawImage(img, 50, grafico_y, width=400, height=200)

c.save()
print(f"Relatório salvo como {pdf_name}")

from google.colab import files
files.download('relatorio_alunos.pdf')
     

Relatório de Análise de Dados de Sensores

Neste exemplo, vamos mostrar como importar um arquivo CSV com dados de sensores, analisar e visualizar os dados, e exportar um relatório em PDF com resultados e gráficos.

Timestamp,Sensor1,Sensor2,Sensor3
2024-06-01 08:00,23.1,45.2,12.3
2024-06-01 08:01,23.3,44.9,12.5
2024-06-01 08:02,23.0,45.0,12.6
2024-06-01 08:03,22.8,44.8,12.5
2024-06-01 08:04,23.2,45.1,12.4

import pandas as pd
import matplotlib.pyplot as plt
from reportlab.lib.pagesizes import A4
from reportlab.pdfgen import canvas
from reportlab.lib.utils import ImageReader

# 1. Importar dados do CSV
df = pd.read_csv('sensores.csv', parse_dates=['Timestamp'])

# 2. Análise simples
estatisticas = df.describe()
print(estatisticas)

# 3. Gráfico temporal dos sensores
plt.figure(figsize=(8, 5))
for sensor in df.columns[1:]:
    plt.plot(df['Timestamp'], df[sensor], marker='o', label=sensor)
plt.title('Evolução Temporal dos Sensores')
plt.xlabel('Tempo')
plt.ylabel('Leitura')
plt.legend()
plt.grid(True)
plt.tight_layout()
plt.savefig('grafico_sensores.png')
plt.show()

# 4. Exportar relatório PDF
pdf_name = 'relatorio_sensores.pdf'
c = canvas.Canvas(pdf_name, pagesize=A4)
larg, alt = A4

c.setFont("Helvetica-Bold", 16)
c.drawString(50, alt-50, "Relatório de Análise de Sensores")

c.setFont("Helvetica", 12)
c.drawString(50, alt-80, "Resumo Estatístico:")
y0 = alt-100
for i, line in enumerate(estatisticas.to_string().split('\n')):
    c.drawString(50, y0 - 15*i, line)

# Gráfico no PDF
c.drawString(50, y0 - 120, "Gráfico de Evolução Temporal:")
img = ImageReader("grafico_sensores.png")
c.drawImage(img, 50, y0 - 350, width=400, height=200)

c.save()
print(f"Relatório salvo como {pdf_name}")

from google.colab import files
files.download('relatorio_sensores.pdf')

🟠 Relatório plus

Melhorado

    
    import pandas as pd
import matplotlib.pyplot as plt
from reportlab.lib.pagesizes import A4
from reportlab.lib import colors
from reportlab.pdfgen import canvas
from reportlab.lib.utils import ImageReader
from datetime import datetime

# 1. Importar dados do CSV
df = pd.read_csv('/content/sensores.csv', parse_dates=['Timestamp'])

# 2. Análise simples
estatisticas = df.describe().T  # .T = transposta para facilitar tabela

# 3. Gráfico temporal dos sensores
plt.figure(figsize=(8, 4))
for sensor in df.columns[1:]:
    plt.plot(df['Timestamp'], df[sensor], marker='o', label=sensor)
plt.title('Evolução Temporal dos Sensores')
plt.xlabel('Tempo')
plt.ylabel('Leitura')
plt.legend(frameon=True)
plt.grid(True, linestyle='--', alpha=0.7)
plt.tight_layout()
plt.savefig('grafico_sensores.png', dpi=150)
plt.close()

# 4. Gerar PDF 
pdf_name = 'relatorio_sensores.pdf'
c = canvas.Canvas(pdf_name, pagesize=A4)
larg, alt = A4

# Título centralizado
c.setFont("Helvetica-Bold", 20)
c.setFillColor(colors.HexColor("#1565c0"))
c.drawCentredString(larg/2, alt-60, "Relatório de Análise de Sensores")

# Linha separadora
c.setLineWidth(2)
c.setStrokeColor(colors.HexColor("#1976d2"))
c.line(50, alt-75, larg-50, alt-75)

# Estatísticas em caixa
caixa_top = alt-100
caixa_left = 40
caixa_width = larg-80
caixa_height = 120
c.setFillColor(colors.whitesmoke)
c.roundRect(caixa_left, caixa_top-caixa_height, caixa_width, caixa_height, 10, fill=True, stroke=0)
c.setStrokeColor(colors.HexColor("#1976d2"))
c.roundRect(caixa_left, caixa_top-caixa_height, caixa_width, caixa_height, 10, fill=False, stroke=1)

c.setFont("Helvetica-Bold", 12)
c.setFillColor(colors.HexColor("#0d47a1"))
c.drawString(caixa_left+10, caixa_top-25, "Resumo Estatístico dos Sensores")

# Cabeçalhos da tabela
c.setFont("Helvetica-Bold", 10)
colunas = ["Sensor", "Média", "Desvio", "Mínimo", "Máximo"]
for i, col in enumerate(colunas):
    c.drawString(caixa_left+15 + i*95, caixa_top-45, col)

# Valores estatísticos
c.setFont("Helvetica", 10)
for idx, (nome, linha) in enumerate(estatisticas.iterrows()):
    c.drawString(caixa_left+15, caixa_top-65-18*idx, str(nome))
    c.drawRightString(caixa_left+110, caixa_top-65-18*idx, f"{linha['mean']:.2f}")
    c.drawRightString(caixa_left+205, caixa_top-65-18*idx, f"{linha['std']:.2f}")
    c.drawRightString(caixa_left+300, caixa_top-65-18*idx, f"{linha['min']:.2f}")
    c.drawRightString(caixa_left+395, caixa_top-65-18*idx, f"{linha['max']:.2f}")

# Caixa do gráfico
graf_top = caixa_top-caixa_height-20
graf_height = 220
graf_left = 60
c.setStrokeColor(colors.HexColor("#1976d2"))
c.roundRect(graf_left, graf_top-graf_height, caixa_width-40, graf_height, 10, fill=0, stroke=1)

# Gráfico centralizado
img = ImageReader("grafico_sensores.png")
c.drawImage(img, graf_left+10, graf_top-graf_height+10, width=caixa_width-60, height=graf_height-20)

# Linha separadora final
c.setLineWidth(1)
c.setStrokeColor(colors.grey)
c.line(50, 90, larg-50, 90)

# Texto de rodapé
c.setFont("Helvetica-Oblique", 9)
c.setFillColor(colors.HexColor("#333"))
c.drawString(55, 75, f"Relatório gerado em {datetime.now().strftime('%d/%m/%Y %H:%M')} | por Seu Nome | Sensores Demo")

c.save()
print(f"Relatório salvo como {pdf_name}")

from google.colab import files
files.download('relatorio_sensores.pdf')
        

import numpy as np
import matplotlib.pyplot as plt

# Parâmetros
v0 = 30   # velocidade inicial (m/s)
theta = 45  # ângulo (graus)
g = 9.81  # gravidade (m/s²)

theta_rad = np.deg2rad(theta)
t_voo = 2 * v0 * np.sin(theta_rad) / g
alcance = v0**2 * np.sin(2*theta_rad) / g
t = np.linspace(0, t_voo, num=100)
x = v0 * np.cos(theta_rad) * t
y = v0 * np.sin(theta_rad) * t - 0.5 * g * t**2

plt.figure(figsize=(8, 5))
plt.plot(x, y, label=f"θ={theta}°, v₀={v0}m/s")
plt.title("Lançamento de Projétil")
plt.xlabel("Distância (m)")
plt.ylabel("Altura (m)")
plt.grid(True)
plt.legend()
plt.tight_layout()
plt.show()

print(f"Alcance máximo: {alcance:.2f} m")
print(f"Tempo de voo: {t_voo:.2f} s")

# Exemplo de arquivo experimento.csv:
# Tempo,Temperatura
# 0,22.1
# 1,22.8
# 2,23.4
# 3,24.0
# 4,24.7

import pandas as pd
import matplotlib.pyplot as plt
from scipy.stats import linregress

# 1. Ler arquivo CSV
df = pd.read_csv('experimento.csv')

# 2. Calcular estatísticas
media = df['Temperatura'].mean()
desvio = df['Temperatura'].std()
print(f"Média: {media:.2f}, Desvio padrão: {desvio:.2f}")

# 3. Regressão linear
reg = linregress(df['Tempo'], df['Temperatura'])
print(f"Inclinação: {reg.slope:.3f}, Intercepto: {reg.intercept:.2f}")

# 4. Gráfico com ajuste linear
plt.figure(figsize=(7, 4))
plt.plot(df['Tempo'], df['Temperatura'], 'o', label='Dados')
plt.plot(df['Tempo'], reg.intercept + reg.slope*df['Tempo'], 'r-', label='Ajuste Linear')
plt.xlabel('Tempo')
plt.ylabel('Temperatura')
plt.title('Análise de Experimento')
plt.legend()
plt.grid(True)
plt.tight_layout()
plt.show()

# Exemplo de arquivo safra.csv:
# Parcela,Área (ha),Produção (kg)
# 1,2.0,5400
# 2,1.8,4700
# 3,2.2,6000

import pandas as pd
import matplotlib.pyplot as plt

df = pd.read_csv('safra.csv')
df['Produtividade (kg/ha)'] = df['Produção (kg)'] / df['Área (ha)']

media = df['Produtividade (kg/ha)'].mean()
print(df)
print(f"Produtividade média: {media:.2f} kg/ha")

plt.figure(figsize=(8, 4))
plt.bar(df['Parcela'], df['Produtividade (kg/ha)'], color='green')
plt.axhline(media, color='red', linestyle='--', label='Média')
plt.xlabel('Parcela')
plt.ylabel('Produtividade (kg/ha)')
plt.title('Produtividade por Parcela')
plt.legend()
plt.tight_layout()
plt.show()

# Exemplo de arquivo solar.csv:
# Dia,Irradiacao (kWh/m2)
# 1,5.2
# 2,4.9
# 3,5.5
# ...
import pandas as pd
import matplotlib.pyplot as plt

# Parâmetros do sistema
potencia_pico = 3.0  # kWp
rendimento = 0.75    # eficiência do sistema

df = pd.read_csv('solar.csv')
df['Geracao_kWh'] = df['Irradiacao (kWh/m2)'] * potencia_pico * rendimento

print(f"Geração total no período: {df['Geracao_kWh'].sum():.2f} kWh")

plt.figure(figsize=(8, 4))
plt.plot(df['Dia'], df['Geracao_kWh'], marker='o')
plt.xlabel('Dia')
plt.ylabel('Geração (kWh)')
plt.title('Geração Solar Diária')
plt.grid(True)
plt.tight_layout()
plt.show()

# Exemplo de arquivo agua.csv:
# Timestamp,Temperatura,Oxigenio,pH
# 2024-06-01 08:00,24.1,6.9,7.5
# 2024-06-01 12:00,26.2,6.7,7.2
# 2024-06-01 16:00,27.5,6.5,6.8

import pandas as pd
import matplotlib.pyplot as plt

df = pd.read_csv('agua.csv', parse_dates=['Timestamp'])
print(df.describe())

# Alertar pH fora do ideal (ideal 6.5 a 8.5)
ph_ruim = df[(df['pH'] < 6.5) | (df['pH'] > 8.5)]
if not ph_ruim.empty:
    print("Atenção: pH fora do ideal nos horários:")
    print(ph_ruim[['Timestamp', 'pH']])

plt.figure(figsize=(8, 4))
plt.plot(df['Timestamp'], df['Temperatura'], label='Temperatura (°C)')
plt.plot(df['Timestamp'], df['Oxigenio'], label='Oxigênio (mg/L)')
plt.plot(df['Timestamp'], df['pH'], label='pH')
plt.xlabel('Tempo')
plt.title('Monitoramento dos Parâmetros da Água')
plt.legend()
plt.tight_layout()
plt.show()

!pip install opencv-python matplotlib

from google.colab import files
uploaded = files.upload()  # Faça upload de uma imagem (.jpg ou .png)

import cv2
import matplotlib.pyplot as plt
import numpy as np

# Obter nome do arquivo carregado
img_path = list(uploaded.keys())[0]

# Carregar imagem colorida e em tons de cinza
img_color = cv2.imread(img_path)
img_gray = cv2.cvtColor(img_color, cv2.COLOR_BGR2GRAY)

# Imagem preto e branco (binarização automática)
_, img_bin = cv2.threshold(img_gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)

# Bordas com Canny
img_edges = cv2.Canny(img_gray, 100, 200)

# Suavização (Blur)
img_blur = cv2.GaussianBlur(img_gray, (7,7), 0)

# Negativo
img_neg = 255 - img_gray

# Mostrar todas as imagens lado a lado
titulos = ['Original', 'Preto e Branco', 'Binarizada', 'Bordas (Canny)', 'Blur', 'Negativo']
imagens = [cv2.cvtColor(img_color, cv2.COLOR_BGR2RGB), img_gray, img_bin, img_edges, img_blur, img_neg]

plt.figure(figsize=(18,8))
for i in range(6):
    plt.subplot(2,3,i+1)
    if len(imagens[i].shape)==2:
        plt.imshow(imagens[i], cmap='gray')
    else:
        plt.imshow(imagens[i])
    plt.title(titulos[i])
    plt.axis('off')
plt.tight_layout()
plt.show()

    # Instale as libs se necessário
!pip install geopandas matplotlib

import geopandas as gpd
import matplotlib.pyplot as plt

# Baixar shapefile do Brasil (IBGE ou Natural Earth)
# Usando Natural Earth (mais leve e simples)
url = "https://raw.githubusercontent.com/codeforamerica/click_that_hood/master/public/data/brazil-states.geojson"
brasil = gpd.read_file(url)

# Dados de cidades/pontos
import pandas as pd
cidades = pd.DataFrame({
    "Cidade": ["Curitiba", "São Paulo", "Recife", "Manaus", "Brasília"],
    "Latitude": [-25.429, -23.550, -8.054, -3.119, -15.794],
    "Longitude": [-49.271, -46.633, -34.882, -60.021, -47.882]
})

# Converter para GeoDataFrame
gdf_pontos = gpd.GeoDataFrame(
    cidades, 
    geometry=gpd.points_from_xy(cidades["Longitude"], cidades["Latitude"]),
    crs="EPSG:4326"
)

# Plotar
fig, ax = plt.subplots(figsize=(8, 10))
brasil.plot(ax=ax, color="whitesmoke", edgecolor="gray")
gdf_pontos.plot(ax=ax, color="red", marker="o", markersize=60)

for idx, row in cidades.iterrows():
    ax.text(row["Longitude"]+0.5, row["Latitude"]+0.2, row["Cidade"], fontsize=10)

plt.title("Mapa do Brasil com Cidades Marcadas")
plt.axis('off')
plt.show()

  

    # Instale folium se precisar
!pip install folium

import folium

# Centro aproximado do Brasil
m = folium.Map(location=[-14.2, -51.9], zoom_start=4)

# Pontos
cidades = [
    {"nome": "Curitiba", "lat": -25.429, "lon": -49.271},
    {"nome": "São Paulo", "lat": -23.550, "lon": -46.633},
    {"nome": "Recife", "lat": -8.054, "lon": -34.882},
    {"nome": "Manaus", "lat": -3.119, "lon": -60.021},
    {"nome": "Brasília", "lat": -15.794, "lon": -47.882}
]

for c in cidades:
    folium.Marker([c["lat"], c["lon"]], popup=c["nome"]).add_to(m)

from IPython.display import display
display(m)
    
 

🟠 Visualização Interativa com Plotly

A Plotly cria gráficos interativos com zoom e hover. Ideal para apresentações dinâmicas.

import plotly.express as px
import pandas as pd

# Carregar dados
url = "https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv"
df = pd.read_csv(url)

# Gráfico de dispersão interativo
fig = px.scatter(df, x='sepal_length', y='sepal_width', color='species',
                 size='petal_length', title='Sépalas por Espécie',
                 labels={'sepal_length': 'Comprimento da Sépala (cm)', 'sepal_width': 'Largura da Sépala (cm)'})
fig.show()

# Gráfico de barras interativo
fig_bar = px.bar(df.groupby('species').mean().reset_index(), x='species', y='petal_length',
                 title='Média do Comprimento da Pétala por Espécie')
fig_bar.show()

Teste Você Mesmo! Use px.histogram para a distribuição de uma variável ou px.scatter_3d para um gráfico 3D.

import dash
from dash import dcc, html
import plotly.express as px
import pandas as pd

# Dados simulados (pode trocar por dados reais)
df = pd.DataFrame({
    "Tempo (s)": list(range(10)),
    "Temperatura (°C)": [22, 23, 24, 26, 25, 27, 28, 30, 29, 31]
})

app = dash.Dash(__name__)
app.layout = html.Div([
    html.H1("Monitoramento de Temperatura - Engenharia"),
    dcc.Graph(
        id='grafico-temp',
        figure=px.line(df, x="Tempo (s)", y="Temperatura (°C)", markers=True,
                       title="Evolução da Temperatura no Processo")
    ),
    html.P("Modifique os dados ou personalize os gráficos para o seu projeto!")
])

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

import streamlit as st
import pandas as pd
import matplotlib.pyplot as plt

# Dados simulados
df = pd.DataFrame({
    "Tempo (s)": list(range(20)),
    "Temperatura (°C)": [22, 23, 24, 26, 25, 27, 28, 30, 29, 31, 32, 34, 33, 35, 34, 33, 32, 30, 29, 28]
})

st.title("Dashboard de Temperatura - Engenharia")

# Filtro: selecione o intervalo de tempo
intervalo = st.slider("Selecione o intervalo de tempo (s):",
                      int(df["Tempo (s)"].min()), int(df["Tempo (s)"].max()),
                      (int(df["Tempo (s)"].min()), int(df["Tempo (s)"].max())))

df_filtrado = df[(df["Tempo (s)"] >= intervalo[0]) & (df["Tempo (s)"] <= intervalo[1])]

st.write(f"Exibindo dados de {intervalo[0]}s a {intervalo[1]}s")
st.dataframe(df_filtrado)

# Gráfico Matplotlib
fig, ax = plt.subplots()
ax.plot(df_filtrado["Tempo (s)"], df_filtrado["Temperatura (°C)"], marker='o', color='teal')
ax.set_title("Temperatura ao longo do tempo")
ax.set_xlabel("Tempo (s)")
ax.set_ylabel("Temperatura (°C)")
ax.grid(True)
st.pyplot(fig)

st.info("Dica: troque por dados reais usando st.file_uploader() ou pd.read_csv().")

🔬 Aplicações de Engenharia com Python

A seguir, exemplos reais de como Python e suas bibliotecas são usados na prática em diferentes áreas da Engenharia. Veja códigos, gráficos, dicas profissionais e tente adaptar para sua área!

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from scipy import signal

# Simular dados de vibração de máquina
fs = 1000  # Frequência de amostragem (Hz)
t = np.arange(0, 1, 1/fs)
f1, f2 = 50, 120  # Frequências características (Hz)
vibracao = 1.5*np.sin(2*np.pi*f1*t) + 0.8*np.sin(2*np.pi*f2*t) + 0.5*np.random.randn(len(t))

# Análise no domínio da frequência
frequencias, espectro = signal.welch(vibracao, fs, nperseg=1024)

# Plot
plt.figure(figsize=(12, 5))
plt.subplot(1, 2, 1)
plt.plot(t[:200], vibracao[:200])
plt.title('Sinal de Vibração (Domínio do Tempo)')
plt.xlabel('Tempo [s]')
plt.ylabel('Amplitude')

plt.subplot(1, 2, 2)
plt.semilogy(frequencias, espectro)
plt.title('Espectro de Frequência')
plt.xlabel('Frequência [Hz]')
plt.ylabel('Densidade Espectral')
plt.tight_layout()
plt.show()

# Simulação de transferência de calor
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation

L = 1.0  # Comprimento da barra
nx = 50  # Pontos discretos
alpha = 0.01  # Difusividade
dx = L / (nx - 1)
dt = 0.5 * dx**2 / alpha

T = np.zeros(nx)
T[nx//4:3*nx//4] = 100

A = (-2 * np.eye(nx) + np.eye(nx, k=1) + np.eye(nx, k=-1)) / dx**2
A[0, 0], A[-1, -1] = 0, 0

fig, ax = plt.subplots(figsize=(10, 5))
line, = ax.plot(np.linspace(0, L, nx), T)
ax.set_ylim(0, 110)
ax.set_xlabel('Posição na Barra (m)')
ax.set_ylabel('Temperatura (°C)')
ax.set_title('Evolução da Temperatura em uma Barra')

def update(frame):
    global T
    T += alpha * dt * (A @ T)
    line.set_ydata(T)
    return line,

ani = FuncAnimation(fig, update, frames=100, interval=50, blit=True)
plt.close()
from IPython.display import HTML
HTML(ani.to_jshtml())

import numpy as np
import matplotlib.pyplot as plt

L = 5.0  # m
E = 200e9  # Pa (aço)
I = 8.33e-6  # m^4
q = 10000  # N/m

x = np.linspace(0, L, 100)
deflection = q * x**2 / (24 * E * I) * (x**2 - 4*L*x + 6*L**2)

plt.figure(figsize=(10, 5))
plt.plot(x, deflection*1000, 'b-', linewidth=2)  # mm
plt.title('Deflexão de Viga Engastada sob Carga Uniforme')
plt.xlabel('Posição ao longo da viga (m)')
plt.ylabel('Deflexão (mm)')
plt.grid(True)
plt.show()

import numpy as np
import matplotlib.pyplot as plt
import scipy.signal as sig

R = 1e3  # 1kOhm
C = 1e-6  # 1uF
cutoff = 1/(2*np.pi*R*C)

w, h = sig.freqs([1], [R*C, 1])
plt.semilogx(w, 20*np.log10(abs(h)))
plt.axvline(cutoff, color='red', linestyle='--')
plt.title('Resposta em Frequência do Filtro RC')
plt.xlabel('Frequência [rad/s]')
plt.ylabel('Amplitude [dB]')
plt.grid(which='both', axis='both')
plt.show()

from scipy.optimize import minimize

def custo(x):
    comp, larg, alt = x
    return 2*(comp*larg) + 1*(2*comp*alt + 2*larg*alt)

constraints = {'type': 'eq', 'fun': lambda x: x[0]*x[1]*x[2] - 1000}
x0 = [10, 10, 10]
res = minimize(custo, x0, constraints=constraints, bounds=[(1,100)]*3)
print(f"Dimensões ótimas: {res.x} cm")
print(f"Custo mínimo: R${res.fun:.2f}")

!wget https://archive.ics.uci.edu/ml/machine-learning-databases/00601/ai4i2020.csv
import pandas as pd
import matplotlib.pyplot as plt

df_sensores = pd.read_csv('ai4i2020.csv')

plt.figure(figsize=(10, 6))
for tipo_falha in df_sensores['Machine failure'].unique():
    subset = df_sensores[df_sensores['Machine failure'] == tipo_falha]
    plt.scatter(subset['Air temperature [K]'], subset['Process temperature [K]'], 
                label=f"Falha {tipo_falha}", alpha=0.6)
plt.title('Temperaturas vs Falhas de Máquina')
plt.xlabel('Temperatura do Ar [K]')
plt.ylabel('Temperatura do Processo [K]')
plt.legend()
plt.grid(True)
plt.show()

🤖 Introdução ao Keras para Classificação

O Keras é uma biblioteca de deep learning para criar modelos de machine learning. Vamos construir um modelo para classificar espécies do Iris dataset.

      
      import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
from tensorflow import keras
from tensorflow.keras import layers, Input  # Adicionado Input

# Carregar dados
url = "https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv"
df = pd.read_csv(url)

# Preparar dados
X = df[['sepal_length', 'sepal_width', 'petal_length', 'petal_width']].values
y = df['species'].values

# Codificar rótulos
le = LabelEncoder()
y = le.fit_transform(y)

# Dividir em treino e teste
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Criar modelo - FORMA CORRIGIDA
model = keras.Sequential([
    Input(shape=(4,)),  # Camada de input explícita
    layers.Dense(16, activation='relu'),
    layers.Dense(8, activation='relu'),
    layers.Dense(3, activation='softmax')  # 3 classes
])

# Compilar modelo
model.compile(optimizer='adam', 
              loss='sparse_categorical_crossentropy', 
              metrics=['accuracy'])

# Treinar modelo
history = model.fit(X_train, y_train, 
                   epochs=50, 
                   batch_size=16, 
                   validation_split=0.2,  # Adicionado validação
                   verbose=1)  # Alterado para ver progresso

# Avaliar modelo
loss, accuracy = model.evaluate(X_test, y_test)
print(f"\nAcurácia no teste: {accuracy:.2f}")

model.summary()

# Prever uma amostra
amostra = np.array([[5.0, 3.4, 1.5, 0.2]])  # Exemplo de setosa
predicao = model.predict(amostra)
print(f"Espécie prevista: {le.inverse_transform([np.argmax(predicao)])[0]}")

# Prever exemplos característicos de cada espécie
exemplos = {
    'Setosa': np.array([[5.0, 3.4, 1.5, 0.2]]),       # Exemplo já fornecido
    'Versicolor': np.array([[6.0, 2.7, 4.5, 1.5]]),   # Características médias
    'Virginica': np.array([[7.0, 3.2, 6.5, 2.0]])     # Características maiores
}

for especie, dados in exemplos.items():
    predicao = model.predict(dados)
    classe_predita = le.inverse_transform([np.argmax(predicao)])[0]
    probabilidades = predicao[0]
    
    print(f"\nExemplo para {especie}:")
    print(f"Características: {dados[0]}")
    print(f"Espécie prevista: {classe_predita}")
    print(f"Probabilidades: [Setosa: {probabilidades[0]:.2%}, Versicolor: {probabilidades[1]:.2%}, Virginica: {probabilidades[2]:.2%}]")
      
    

Teste Você Mesmo! Experimente prever outras amostras ou adicione validação com validation_split=0.2 no model.fit.

📝 Atividades Práticas Avançadas

• Atividade 1: Análise Avançada com pandas

  Carregue o Iris dataset, crie uma coluna calculada (ex.: razão entre sépala e pétala) e agrupe por espécie para calcular estatísticas.

  Mostrar Exemplo

  import pandas as pd
  
  url = "https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv"
  df = pd.read_csv(url)
  
  # Criar coluna calculada
  df['sepal_petal_ratio'] = df['sepal_length'] / df['petal_length']
  
  # Agrupar por espécie
  print(df.groupby('species')['sepal_petal_ratio'].describe())

  Teste Você Mesmo! Crie uma coluna com a área da pétala (petal_length * petal_width) e filtre valores extremos.

• Atividade 2: Gráficos Combinados com Matplotlib

  Crie um gráfico combinando dispersão e linha para comparar sépalas e pétalas por espécie.

  Mostrar Exemplo

  import matplotlib.pyplot as plt
  import pandas as pd
  
  url = "https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv"
  df = pd.read_csv(url)
  
  plt.figure(figsize=(10, 6))
  for especie in df['species'].unique():
      subset = df[df['species'] == especie]
      plt.scatter(subset['sepal_length'], subset['petal_length'], label=especie, s=50)
      plt.plot(subset['sepal_length'], subset['petal_length'], '--')
  plt.title("Sépalas vs Pétalas por Espécie")
  plt.xlabel("Comprimento da Sépala (cm)")
  plt.ylabel("Comprimento da Pétala (cm)")
  plt.legend()
  plt.grid(True)
  plt.savefig('combinado_iris.png')
  plt.show()

  Teste Você Mesmo! Adicione anotações com plt.annotate para destacar valores máximos.

• Atividade 3: Classificação com Keras

  Modifique o modelo Keras para incluir validação e prever uma nova amostra do Iris dataset.

  Mostrar Exemplo

  import pandas as pd
  import numpy as np
  from sklearn.model_selection import train_test_split
  from sklearn.preprocessing import LabelEncoder
  from tensorflow import keras
  from tensorflow.keras import layers
  
  url = "https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv"
  df = pd.read_csv(url)
  
  X = df[['sepal_length', 'sepal_width', 'petal_length', 'petal_width']].values
  y = LabelEncoder().fit_transform(df['species'])
  X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
  
  model = keras.Sequential([
      layers.Dense(32, activation='relu', input_shape=(4,)),
      layers.Dense(16, activation='relu'),
      layers.Dense(3, activation='softmax')
  ])
  model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
  model.fit(X_train, y_train, epochs=100, batch_size=16, validation_split=0.2, verbose=0)
  
  loss, accuracy = model.evaluate(X_test, y_test)
  print(f"Acurácia no teste: {accuracy:.2f}")
  

  Teste Você Mesmo! Ajuste o número de neurônios ou adicione layers.Dropout(0.2) para evitar overfitting.

🔗 Recursos Adicionais

• Documentação oficial do pandas
• Documentação oficial do NumPy
• Documentação oficial do Matplotlib
• Documentação oficial do Plotly
• Documentação oficial do Dash
• Documentação oficial do Keras
• Datasets no Kaggle