Aula de Manipulação de dados em Python

Arquivos CSV

Um arquivo CSV (Comma-Separated Values) é um formato simples e muito usado para armazenar e trocar dados em forma de tabela. Nele, cada linha representa um registro e cada coluna é separada por vírgula (,), ponto e vírgula (;) ou outro delimitador.

✨ Principais características:

• É um arquivo de texto puro, fácil de abrir em qualquer editor ou programa.
• Pode ser lido e escrito por diversos sistemas e linguagens de programação.
• É amplamente usado para importar e exportar dados entre bancos de dados, planilhas (como Excel) e softwares.

📌 Exemplo de CSV:

nome,idade,cidade
Maria,25,São Paulo
João,30,Rio de Janeiro
Ana,22,Belo Horizonte

👉 Nesse exemplo:

• A primeira linha traz o cabeçalho (nomes das colunas).
• As linhas seguintes são os dados.

💡 Por ser simples e leve, o CSV é ideal quando precisamos de compatibilidade e portabilidade de dados, mas não traz recursos avançados como fórmulas ou formatação, presentes em arquivos de planilha.

Como criar um arquivo CSV

Entre no notepad++ e crie um novo arquivo.

Copie o seguinte conteúdo.

nome,idade,cidade
Maria,25,São Paulo
João,30,Rio de Janeiro
Ana,22,Belo Horizonte

Em seguida salve como listagem.csv

Pronto voce tem um arquivo csv válido.

Usando o Pandas

Pandas é uma biblioteca do Python muito usada para análise e manipulação de dados. Ele facilita o trabalho com tabelas, planilhas e arquivos CSV, oferecendo estruturas como DataFrame (que parece uma tabela do Excel dentro do Python).

📌 Explicação simplificada:

• O pandas permite ler arquivos CSV com apenas um comando.
• Depois de carregado, os dados ficam em um DataFrame, onde podemos visualizar, filtrar, ordenar e até realizar cálculos.
• É uma das bibliotecas mais usadas em ciência de dados e análise de dados.

---

Exemplo em Python usando o listagem.csv:

import pandas as pd

# Lê o arquivo CSV
df = pd.read_csv("listagem.csv")

# Exibe o conteúdo do arquivo
print(df)

✨ O código faz o seguinte:

1. Importa o pandas.
2. Usa pd.read_csv() para ler o arquivo chamado listagem.csv.
3. Guarda os dados no DataFrame df.
4. Imprime todo o conteúdo do arquivo.

💡 Assim, você consegue transformar seu CSV em uma tabela bem estruturada para manipulação dentro do Python.

Varrendo os registros de um CSV.

Depois de carregar o CSV no Pandas, você pode percorrer os registros linha a linha usando o método iterrows(). Assim, cada linha é lida como um índice e uma série de dados.

📌 Aqui está a continuação do programa:

import pandas as pd

# Lê o arquivo CSV
df = pd.read_csv("listagem.csv")

# Exibe todo o conteúdo do arquivo
print("Conteúdo completo do arquivo:\n")
print(df)

print("\nVarredura linha a linha:\n")
# Percorre cada linha do DataFrame
for index, row in df.iterrows():
    print(f"Linha {index}: {row.to_dict()}")

---

✨ O que esse código faz:

1. Lê o listagem.csv no DataFrame df.
2. Mostra o conteúdo completo.
3. Varre linha por linha do DataFrame.
4. Para cada linha, imprime um dicionário com os nomes das colunas e os valores.

📌 Exemplo de saída (supondo o CSV com nome,idade,cidade):

Linha 0: {'nome': 'Maria', 'idade': 25, 'cidade': 'São Paulo'}
Linha 1: {'nome': 'João', 'idade': 30, 'cidade': 'Rio de Janeiro'}
Linha 2: {'nome': 'Ana', 'idade': 22, 'cidade': 'Belo Horizonte'}

---

Quer que eu prepare uma versão onde, ao invés de imprimir o dicionário inteiro, já traga cada campo formatadinho, tipo:
👉 Maria - 25 anos - São Paulo?

Verificando informações com PANDAS

Podemos deixar o programa interativo: ele pergunta ao usuário uma faixa de idade (mínimo e máximo) e depois filtra as pessoas do listagem.csv que estão dentro desse intervalo.

Aqui está o código:

import pandas as pd

# Lê o arquivo CSV
df = pd.read_csv("listagem.csv")

# Pergunta ao usuário a faixa de idade
idade_min = int(input("Digite a idade mínima: "))
idade_max = int(input("Digite a idade máxima: "))

# Filtra os registros que estão na faixa
resultado = df[(df['idade'] >= idade_min) & (df['idade'] <= idade_max)]

# Mostra o resultado
print("\nPessoas dentro da faixa etária escolhida:\n")
if resultado.empty:
    print("Nenhuma pessoa encontrada nessa faixa de idade.")
else:
    for index, row in resultado.iterrows():
        print(f"{row['nome']} - {row['idade']} anos - {row['cidade']}")

✨ O que acontece aqui:

1. Lê o CSV no DataFrame.
2. Pede ao usuário a idade mínima e máxima.
3. Usa um filtro lógico para selecionar apenas quem está entre os dois valores.
4. Mostra o resultado de forma organizada.

📌 Exemplo de saída:

Digite a idade mínima: 20
Digite a idade máxima: 25

Pessoas dentro da faixa etária escolhida:

Maria - 25 anos - São Paulo
Ana - 22 anos - Belo Horizonte

Outras funcionalidades do pandas

O Pandas é super poderoso e tem muitas funcionalidades além de só ler e filtrar CSV. Vou te mostrar algumas das mais usadas com exemplos práticos:

---

📌 1. Mostrar só algumas linhas

print(df.head())   # primeiras 5 linhas
print(df.tail())   # últimas 5 linhas

---

📌 2. Ver informações rápidas do DataFrame

print(df.info())     # mostra colunas, tipos e nulos
print(df.describe()) # estatísticas (média, desvio, min, max, etc.)

---

📌 3. Selecionar colunas específicas

print(df['nome'])          # apenas a coluna "nome"
print(df[['nome', 'idade']])  # duas colunas

---

📌 4. Filtrar com condições

# Pessoas acima de 25 anos
print(df[df['idade'] > 25])

# Pessoas da cidade "São Paulo"
print(df[df['cidade'] == "São Paulo"])

---

📌 5. Ordenar registros

print(df.sort_values(by="idade"))              # do mais novo para o mais velho
print(df.sort_values(by="idade", ascending=False))  # do mais velho para o mais novo

---

📌 6. Agrupar dados

# Média de idade por cidade
print(df.groupby("cidade")["idade"].mean())

---

📌 7. Contar ocorrências

# Quantas pessoas por cidade
print(df["cidade"].value_counts())

---

📌 8. Criar ou modificar colunas

# Criar coluna com idade em meses
df["idade_meses"] = df["idade"] * 12
print(df)

---

📌 9. Exportar resultados

# Salvar em outro CSV
df.to_csv("resultado.csv", index=False)

---

✨ Ou seja, o Pandas serve não só para ler arquivos CSV, mas também para explorar, analisar e transformar dados de forma rápida e prática.

Buscar dados e analise dos dados.

Existem locais que se pode buscar dados abertos, em geral. O governo fornece diversas bases de dados para que seja utilizada por alunos e profissionais a fim de analise de dados.

https://arquivos.receitafederal.gov.br/dados/cnpj/dados_abertos_cnpj/2025-08

Se olharmos estes dados podemos verificar o cnae de diversos produtos.

0111301″;”Cultivo de arroz”
“0111302”;”Cultivo de milho”
“0111303”;”Cultivo de trigo”
“0111399”;”Cultivo de outros cereais não especificados anteriormente”
“0112101”;”Cultivo de algodão herbáceo”
“0112102”;”Cultivo de juta”
“0112199”;”Cultivo de outras fibras de lavoura temporária não especificadas anteriormente”
“0113000”;”Cultivo de cana-de-açúcar”
“0114800”;”Cultivo de fumo”
“0115600”;”Cultivo de soja”
“0116401”;”Cultivo de amendoim”
“0116402”;”Cultivo de girassol”
“0116403”;”Cultivo de mamona”
“0116499”;”Cultivo de outras oleaginosas de lavoura temporária não especificadas anteriormente”
“0119901”;”Cultivo de abacaxi”
“0119902”;”Cultivo de alho”
“0119903”;”Cultivo de batata-inglesa”
“0119904”;”Cultivo de cebola”
“0119905”;”Cultivo de feijão”

O CNAE significa Classificação Nacional de Atividades Econômicas.

📌 Ele é um padrão oficial no Brasil criado pelo IBGE e utilizado pela Receita Federal, juntas comerciais, prefeituras e outros órgãos para identificar e categorizar a atividade econômica de empresas e profissionais.

✨ Principais pontos:

• Cada atividade econômica tem um código numérico único (exemplo: comércio de roupas, consultoria em TI, fabricação de móveis etc.).
• É usado em cadastros fiscais (como o CNPJ) e em registros de empresas.
• Serve para padronizar estatísticas e informações econômicas em nível nacional.
• Impacta diretamente em tributos e enquadramento fiscal (pois a atividade define impostos e obrigações).

---

📌 Exemplo de código CNAE:

• 62.01-5/01 → Desenvolvimento de programas de computador sob encomenda.
• 47.54-7/01 → Comércio varejista de móveis.

---

Ou seja, o CNAE funciona como um RG da atividade da empresa, identificando exatamente o que ela faz.

Tarefa.

Buscar atividades relacionadas que contem a palavra açaí.

Desenvolva um programa que pega a lista de CNAI e dado uma palavra busca todos os que tiverem aquela palavra.

Trabalho de Programação em Python

Objetivo do trabalho:

O objetivo deste trabalho é criar um arquivo para impressão 3D.

Visão sobre o projeto e informações sobre o ambiente

🟦 O que é CNC?

✨ CNC significa Controle Numérico Computadorizado (Computer Numerical Control).

• É a automação de máquinas (fresadoras, tornos, impressoras 3D, cortadoras a laser, etc.).
• No lugar de um operador manual girando manivelas, o computador controla os motores.
• O programa informa onde a ferramenta deve ir, a velocidade e o que fazer.

➡️ Resultado: peças produzidas com mais precisão, repetibilidade e velocidade.

Exemplos de máquinas CNC:

• Fresadora CNC (corta metal ou madeira).
• Torno CNC (peças cilíndricas).
• Impressora 3D (constrói objetos em camadas).
• Router CNC (corte em madeira e acrílico).
• Laser CNC (gravação/corte de chapas).

---

🟦 O que é G-code?

✨ O G-code é a linguagem usada pelas máquinas CNC.

Cada linha é uma instrução que a máquina entende.

É formado por códigos de duas letras (como G1, M104) seguidos de números (coordenadas, temperaturas, velocidades).

🟦 Como nasce uma peça CNC

1. O engenheiro desenha em CAD (3D).
2. O software CAM (fatiador, slicer, etc.) gera o G-code.
3. O G-code é enviado para a máquina CNC.
4. A máquina executa linha a linha e cria a peça.

---

🟦 Por que é importante aprender?

• O CNC está presente em indústria, medicina, aeronáutica, prototipagem e design.
• Entender G-code é como entender a “gramática” das máquinas.
• Mesmo que existam softwares automáticos, saber G-code permite:
  • Ajustar peças.
  • Corrigir erros.
  • Criar trajetórias personalizadas.

Qual o GCode da Ender-3

O padrão de G-code da Ender-3 é o Marlin/RepRap flavor, não FANUC, Mitsubishi ou Siemens. Eles são todos “G-code”, mas os dialetos são diferentes.

🔹 Diferença principal:

• A Ender-3 segue o padrão Marlin/RepRap (open-source) → voltado para impressoras 3D, bem simplificado.
• Já os CNC industriais (FANUC, Mitsubishi, Siemens) usam dialetos diferentes de ISO G-code, com foco em fresadoras, tornos e centros de usinagem, que possuem muitos recursos que uma impressora 3D não precisa (offsets, ciclos fixos, compensações de ferramenta, etc).

📌 Comparativo resumido:

Sistema	Padrão/Dialeto G-code	Usado em
Ender-3	Marlin/RepRap (G0, G1, G28, M104…)	Impressoras 3D
FANUC	ISO G-code (muitos ciclos fixos, G71, G81, etc)	CNC industrial (torno/fresa)
Mitsubishi	Próprio dialeto ISO compatível, similar ao FANUC	CNC industrial
Siemens	Sinumerik (ISO G-code, mas com macros próprios e ciclos especiais)	CNC industrial

Comandos GCode básico.

🟦 Configuração inicial

• G21 → Define as unidades em milímetros (a Ender-3 trabalha sempre em mm).
• G90 → Define o modo absoluto de posicionamento (as coordenadas X/Y/Z são relativas ao 0,0 da mesa).
• M82 → Define a extrusão em modo absoluto (valores de E sempre crescem).
• G28 → Faz o homing de todos os eixos (leva X, Y e Z até os switches de fim de curso).

---

🟦 Aquecimento (opcional)

• M104 S200 → Seta a temperatura do bico em 200 °C, mas não espera aquecer.
• M140 S60 → Seta a temperatura da mesa em 60 °C, mas também não espera.
• M109 S200 → Define o bico em 200 °C e espera até atingir antes de continuar.
• M190 S60 → Define a mesa em 60 °C e espera até atingir.

(Esses eu deixei comentados, caso queira imprimir de fato, não só movimentar.)

---

🟦 Movimentação inicial

• G1 Z0.20 F1200 → Move o bico para a altura de 0.20 mm acima da mesa, na velocidade de 1200 mm/min.
• G1 X110 Y110 F6000 → Leva o bico até o centro da mesa (coordenada X110 Y110), rápido.
• G1 X130 Y110 F3000 → Move até a posição inicial do círculo (20 mm à direita do centro).

---

🟦 Configuração de extrusão

• M83 → Define a extrusão como relativa (cada valor de E representa apenas o incremento de filamento).
• G92 E0 → Zera o contador de extrusão (dizendo ao firmware que estamos em E=0).
• G1 F1200 → Define a velocidade padrão (feedrate) de 1200 mm/min para os próximos movimentos.

---

🟦 Desenhando o círculo

• G2 → Faz um movimento circular horário (clockwise).
• X... Y... → Define o ponto final do arco.
• I... J... → Define o centro do arco em relação ao ponto inicial.
• E... → Quantidade de filamento extrudido durante o arco.

No código:

1. G2 X90 Y110 I-20 J0 E2.10 → Desenha meia-volta (da direita pro lado esquerdo do círculo), extrudindo 2.1 mm de filamento.
2. G2 X130 Y110 I20 J0 E2.10 → Fecha a volta (do lado esquerdo de volta à direita), extrudindo mais 2.1 mm.

---

🟦 Finalização

• G1 Z5 F3000 → Levanta o bico 5 mm para não arranhar a peça.
• M84 → Desliga os motores (desenergiza os steppers).

Exemplo de Código na Ender-3

; ===== Círculo Ender-3 (Marlin/RepRap) =====
; Raio: 20 mm | Centro: X110 Y110 | Camada: 0.20 mm | Largura: 0.40 mm
; Filamento: 1.75 mm | Extrusão total aprox: 4.20 mm

G21                 ; mm
G90                 ; coordenadas absolutas
M82                 ; extrusão absoluta por padrão
G28                 ; home X Y Z

; (opcional) aquecer
; M104 S200         ; bico 200°C
; M140 S60          ; mesa 60°C
; M109 S200         ; aguarda bico
; M190 S60          ; aguarda mesa

G1 Z0.20 F1200      ; altura de primeira camada (ajuste se quiser)
G1 X110 Y110 F6000  ; vai ao centro da mesa
G1 X130 Y110 F3000  ; vai ao ponto inicial do círculo (raio 20 mm à direita)

M83                 ; extrusão relativa
G92 E0              ; zera extrusor
G1 F1200            ; feed para impressão

; Círculo completo em duas meias-voltas (G2 = horário)
; Meia-volta 1: de (130,110) até (90,110) com centro em (110,110) => I=-20 J=0
G2 X90  Y110 I-20 J0 E2.10

; Meia-volta 2: de (90,110) até (130,110) com centro em (110,110) => I=+20 J=0
G2 X130 Y110 I20  J0 E2.10

; fim
G1 Z5 F3000         ; levanta
M84                 ; desativa motores
; ============================================

Visualizando o arquivo

O usuário pode verificar o arquivo, copiando o mesmo para o site:

https://ncviewer.com

Click em Novo arquivo, e copie o fonte

Neste exemplo criamos apenas uma camada. Onde incluímos e verificamos o desenho.

Agora iremos mostrar como fica o gcode com multiplas camadas.

; ===== Ender-3 | Cilindro oco (raio 10mm, altura 5mm, camada 0.20mm) =====
; Centro: X110 Y110 | Bico: 0.4 | Parede ≈ 0.8 mm (2 voltas por camada)
; Material sugerido: PLA (200/60). Ajuste se necessário.

G21                 ; mm
G90                 ; posicoes absolutas em X/Y/Z
M82                 ; extrusao absoluta por padrao
G28                 ; homing

; --- Aquecimento (descomente para imprimir de verdade) ---
; M104 S200          ; bico 200°C (nao espera)
; M140 S60           ; mesa 60°C (nao espera)
; M109 S200          ; bico 200°C (espera)
; M190 S60           ; mesa 60°C (espera)

G0 Z0.20 F1200      ; primeira camada
G0 X110 Y110 F6000  ; vai ao centro da mesa
G0 X120 Y110 F6000  ; ponto inicial do circulo (raio 10 mm para a direita)

M83                 ; extrusao relativa (E incrementa por trecho)
G92 E0              ; zera extrusor
G1 F1200            ; feed de impressao (~20 mm/s)

; Observacao: cada meia-volta extrude ~1.05 mm (estimado p/ bico 0.4, camada 0.2)

; ---------------------- Camada 1 (Z=0.20) ----------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z0.40 F1200

; ---------------------- Camada 2 (Z=0.40) ----------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z0.60 F1200

; ---------------------- Camada 3 (Z=0.60) ----------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z0.80 F1200

; ---------------------- Camada 4 (Z=0.80) ----------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z1.00 F1200

; ---------------------- Camada 5 (Z=1.00) ----------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z1.20 F1200

; ---------------------- Camada 6 (Z=1.20) ----------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z1.40 F1200

; ---------------------- Camada 7 (Z=1.40) ----------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z1.60 F1200

; ---------------------- Camada 8 (Z=1.60) ----------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z1.80 F1200

; ---------------------- Camada 9 (Z=1.80) ----------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z2.00 F1200

; ---------------------- Camada 10 (Z=2.00) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z2.20 F1200

; ---------------------- Camada 11 (Z=2.20) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z2.40 F1200

; ---------------------- Camada 12 (Z=2.40) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z2.60 F1200

; ---------------------- Camada 13 (Z=2.60) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z2.80 F1200

; ---------------------- Camada 14 (Z=2.80) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z3.00 F1200

; ---------------------- Camada 15 (Z=3.00) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z3.20 F1200

; ---------------------- Camada 16 (Z=3.20) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z3.40 F1200

; ---------------------- Camada 17 (Z=3.40) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z3.60 F1200

; ---------------------- Camada 18 (Z=3.60) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z3.80 F1200

; ---------------------- Camada 19 (Z=3.80) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z4.00 F1200

; ---------------------- Camada 20 (Z=4.00) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z4.20 F1200

; ---------------------- Camada 21 (Z=4.20) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z4.40 F1200

; ---------------------- Camada 22 (Z=4.40) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z4.60 F1200

; ---------------------- Camada 23 (Z=4.60) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z4.80 F1200

; ---------------------- Camada 24 (Z=4.80) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z5.00 F1200

; ---------------------- Camada 25 (Z=5.00) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05

; --- Finalizacao ---
G1 Z10 F3000        ; afasta o bico
; M104 S0           ; desligar bico (descomente se aqueceu)
; M140 S0           ; desligar mesa (descomente se aqueceu)
M84                 ; motores off
; =================================================================

O arquivo pode ser baixado aqui.

Como fica o arquivo pronto.

Base do Python

📘 Como criar e gravar um arquivo com Python

Em Python, para criar um arquivo de texto usamos a função open().

• O primeiro parâmetro é o nome do arquivo (ex.: "cilindro.gcode").
• O segundo parâmetro é o modo de abertura:
  • "w" → escrever (se já existir, sobrescreve).
  • "a" → acrescentar no final (append).
  • "r" → apenas leitura.

Depois usamos o método .write() para gravar conteúdo no arquivo.
No final, usamos .close() (ou o with que fecha automaticamente).

# Criar e gravar um arquivo de texto em Python

# Abre (ou cria) o arquivo chamado "cilindro.gcode" no modo escrita ("w")
with open("cilindro.gcode", "w", encoding="utf-8") as arquivo:
    # Grava apenas uma linha de texto no arquivo
    arquivo.write("G21 ; usar milimetros\n")

print("Arquivo 'cilindro.gcode' criado com sucesso!")

🔹 O que acontece aqui?

1. O Python cria um novo arquivo chamado cilindro.gcode na pasta onde o script está rodando.
2. Escreve dentro dele a linha: G21 ; usar milimetros
3. Fecha o arquivo automaticamente (porque usamos with).
4. Agora esse arquivo pode ser aberto em qualquer editor de texto.

Criando o programa em python com 10 camadas.

# -*- coding: utf-8 -*-
# Gera G-code para um cilindro (tubo) com 10 camadas – Ender-3 / Marlin
# Saída: cilindro_10camadas.gcode

import math

# ===== Parâmetros =====
RAIO_MM       = 10.0         # raio do cilindro (mm)
CAMADAS       = 10           # quantidade de camadas solicitada
ALTURA_CAM_MM = 0.20         # espessura da camada (mm) → 10 camadas = 2,0 mm
CENTRO_X      = 110.0        # centro aproximado da Ender-3
CENTRO_Y      = 110.0
LARG_LINHA    = 0.40         # ~bico 0.4
VEL_IMPR      = 1200         # mm/min (~20 mm/s)
VEL_VIAGEM    = 6000         # mm/min
SEGMENTOS     = 120          # segmentos para aproximar o círculo

# Extrusão (E relativo) – modelo simples
FILAMENTO_D   = 1.75
AREA_FILA     = math.pi * (FILAMENTO_D/2.0)**2  # mm²

def e_para_trecho(compr_mm: float) -> float:
    """Converte o comprimento do trecho em mm do filamento a extrudar (E)."""
    volume = LARG_LINHA * ALTURA_CAM_MM * compr_mm   # mm³
    return volume / AREA_FILA                        # mm de filamento

def anel_g1(z: float, raio: float, nseg: int) -> list[str]:
    """Retorna linhas G-code (G1) aproximando um círculo com 'nseg' segmentos."""
    linhas = []
    # vai ao ponto inicial (ângulo 0) sem extrudar
    x0 = CENTRO_X + raio
    y0 = CENTRO_Y
    linhas.append(f"G0 X{x0:.3f} Y{y0:.3f} Z{z:.3f} F{VEL_VIAGEM}")

    ang_step = 2 * math.pi / nseg
    x_prev, y_prev = x0, y0
    for i in range(1, nseg + 1):
        ang = i * ang_step
        x = CENTRO_X + raio * math.cos(ang)
        y = CENTRO_Y + raio * math.sin(ang)
        L = math.hypot(x - x_prev, y - y_prev)
        e = e_para_trecho(L)
        linhas.append(f"G1 X{x:.3f} Y{y:.3f} E{e:.5f} F{VEL_IMPR}")
        x_prev, y_prev = x, y

    return linhas

# ===== Montagem do G-code =====
g = []
g.append("; ===== Ender-3 | Cilindro (tubo) – 10 camadas =====")
g.append(f"; Raio={RAIO_MM} mm | Camadas={CAMADAS} | h={ALTURA_CAM_MM} mm | centro=({CENTRO_X},{CENTRO_Y})")
g.append("G21            ; mm")
g.append("G90            ; posicoes absolutas")
g.append("M82            ; extrusao absoluta (padrão)")
g.append("G28            ; homing")
# Aquecimento opcional – descomente se for imprimir de verdade
#g.append("M104 S200      ; bico 200C (nao espera)")
#g.append("M140 S60       ; mesa 60C (nao espera)")
#g.append("M109 S200      ; bico 200C (espera)")
#g.append("M190 S60       ; mesa 60C (espera)")

g.append("G0 Z0.20 F1200 ; primeira camada")
g.append(f"G0 X{CENTRO_X:.3f} Y{CENTRO_Y:.3f} F{VEL_VIAGEM}")
g.append(f"G0 X{CENTRO_X+RAIO_MM:.3f} Y{CENTRO_Y:.3f} F{VEL_VIAGEM}")
g.append("M83            ; extrusao relativa")
g.append("G92 E0         ; zera extrusor")
z = ALTURA_CAM_MM

for camada in range(1, CAMADAS + 1):
    g.append(f"; --- Camada {camada}/{CAMADAS} (Z={z:.2f}) ---")
    g.extend(anel_g1(z, RAIO_MM, SEGMENTOS))
    if camada < CAMADAS:
        z += ALTURA_CAM_MM
        g.append(f"G0 Z{z:.3f} F{VEL_VIAGEM}")

# Finalização
g.append("G0 Z10 F3000   ; afasta a peça")
#g.append("M104 S0        ; desliga bico (se aqueceu)")
#g.append("M140 S0        ; desliga mesa (se aqueceu)")
g.append("M84            ; motores off")
g.append("; ================================================")

with open("cilindro_10camadas.gcode", "w", encoding="utf-8") as f:
    f.write("\n".join(g))

print("OK: arquivo gerado 'cilindro_10camadas.gcode'")

🔹 Conclusão

✅ Pontos positivos do que foi apresentado

• Você aprendeu que o G-code é apenas um arquivo texto, criado em qualquer editor ou até gerado automaticamente com Python.
• Vimos como montar um cilindro simples na Ender-3: cada camada é um círculo (ou anel) e, ao empilhar, formamos a peça 3D.
• O exercício mostrou que é possível entender a lógica por trás dos slicers (Cura, PrusaSlicer), ou seja, como os softwares de fatiamento transformam o modelo 3D em comandos de máquina.
• A integração com Python abriu espaço para automatizar a criação de trajetórias, o que pode ser aplicado tanto no ensino quanto em projetos reais.

---

🔧 O que pode ser melhorado no código

• Hoje usamos uma aproximação simples da extrusão. Podemos melhorar:
  • Calibrando melhor a relação entre comprimento da linha e extrusão (considerando fluxo real da impressora).
  • Adicionando duas ou mais paredes e infill (preenchimento interno) para criar cilindros sólidos.
  • Gerando movimentos de skirt/brim (bordas externas) para melhorar a aderência na mesa.
  • Inserindo parâmetros configuráveis como temperaturas, velocidades, e altura de camada em variáveis globais.
• Outra evolução seria criar uma função para gerar qualquer geometria básica (quadrados, triângulos, espirais) — ótimo como exercício de programação para alunos.

---

🏭 Como as empresas usam essa técnica em projetos avançados

• Na indústria 4.0, G-code é usado em usinagem CNC (torno, fresadora, router) para fabricar peças metálicas e plásticas com altíssima precisão.
• Em empresas de impressão 3D, o código é gerado automaticamente por slicers avançados, mas muitos engenheiros ainda ajustam o G-code manualmente para:
  • Criar estruturas de suporte inteligentes.
  • Controlar velocidades diferentes por região da peça.
  • Inserir pausas programadas (para troca de cor, inserir peças metálicas, sensores, etc).
• Em projetos mais complexos, o G-code pode ser integrado com simulações digitais (digital twins), verificando antes se a trajetória da ferramenta será eficiente, segura e otimizada.
• Grandes empresas usam até G-code adaptativo: a máquina lê sensores em tempo real (vibração, temperatura, pressão) e ajusta o código dinamicamente, algo que está evoluindo em direção à manufatura inteligente e autônoma.

---

👉 Ou seja, o que fizemos aqui — gerar um cilindro simples em Python — é uma porta de entrada para entender como máquinas e softwares conversam.
O conceito de criar e manipular arquivos de texto está presente em praticamente toda a computação:

• Impressão 3D e CNC → geração de arquivos G-code.
• Programação → arquivos usados por compiladores (código-fonte em C, Java, Python).
• Escritório → planilhas eletrônicas (CSV, XLSX), processadores de texto (DOCX, ODT, RTF) e apresentações (PPTX) são, na essência, arquivos de texto ou estruturados.
• Web → arquivos HTML, CSS e JSON, que formam sites e APIs.
• Banco de dados → exportação de informações em CSV, SQL scripts.
• Ciência de dados → geração automática de relatórios, datasets em TXT/CSV para análise.
• Automação → scripts Python criam logs de sistemas, arquivos de configuração e até relatórios prontos em PDF.

Assim, usar Python para construir e manipular arquivos não se limita ao G-code: abre uma gama enorme de aplicações, como:

• Criar relatórios automáticos de uma pesquisa.
• Gerar gráficos e salvar em arquivos para apresentação.
• Simular experimentos e salvar resultados em planilhas.
• Desenvolver conversores (por exemplo, transformar dados em XML, JSON ou YAML).
• Automatizar tarefas repetitivas em empresas, economizando tempo e reduzindo erros.

Esse mesmo raciocínio — simples, mas poderoso — é o que sustenta desde projetos escolares até sistemas industriais complexos, permitindo que a programação conecte ideias a resultados práticos no mundo real.

Este blog foi gerado com auxilio do CHATGPT 5.

Será utilizado em treinamento no curso técnico da Escola Estadual Diva Tarlá, em Ribeirão Preto.

🔬💡 Projeto/Prática: Como um Sistema Computacional Pode Resolver Problemas de Eletrônica – O Cálculo da Resistência de um LED Usando Python

🔋💡 História: A Lâmpada Misteriosa de Lucas

Lucas tem 16 anos, é curioso e adora desmontar coisas. Um dia, enquanto mexia numa caixa de sucata do avô, encontrou uma pequena lâmpada de LED vermelha e uma bateria de 9V.

— “Será que consigo acender isso?”, pensou, empolgado.

Ele conectou o LED direto na bateria. Por um instante, ele brilhou forte… e depois queimou!

— “Mas por que isso aconteceu? Não era só ligar e pronto?”

Frustrado, Lucas correu até sua irmã Ana, que estava estudando para a prova de física. Ela olhou para ele e sorriu:

— Ana: “Lucas, você acabou de aprender na prática o que eu estudei hoje: Lei de Ohm e eletricidade básica.”

---

🔌 Capítulo 1 – A Descoberta da Eletricidade

Ana pegou um papel e começou a desenhar:

— Ana: “Lembra que a gente aprendeu que a eletricidade é o movimento dos elétrons?
Na escola, estudamos tensão (voltagem), que é como a pressão da água num cano, e corrente, que é como o fluxo dessa água. E tem também a resistência, que é como se fosse um aperto no cano que controla o fluxo.”

Lucas, curioso, respondeu:
— Lucas: “Ah, então quando liguei o LED direto na bateria, era como jogar um jato de água sem controle?”

— Ana: “Exatamente! O LED não aguenta toda essa ‘pressão’. É por isso que ele queimou.”

---

📐 Capítulo 2 – A Lei de Ohm

Ana escreveu a fórmula da Lei de Ohm no caderno: V=R⋅IV = R \cdot IV=R⋅I

— Ana: “Olha só: se reorganizarmos, podemos calcular a resistência necessária:” R=Vfonte−VLEDILEDR = \frac{V_\text{fonte} – V_\text{LED}}{I_\text{LED}}R=ILED​Vfonte​−VLED​​

Lucas ficou intrigado.
— Lucas: “Então preciso de um resistor para proteger o LED?”

— Ana: “Sim! Isso é exatamente o que aprendemos em física: controlar a corrente usando resistência.”

Ela explicou que cada cor de LED tem uma queda de tensão típica. Pegou uma tabela na internet:

Cor do LED	Tensão típica (V)
🔴 Vermelho	2,0 V
🟢 Verde	2,2 V
🔵 Azul	3,0 V
⚪ Branco	3,2 V

---

💻 Capítulo 3 – O Computador como Ferramenta

Lucas, empolgado, disse:
— Lucas: “Mas calcular isso toda hora é chato. Vou programar isso!”

Ele abriu o notebook e escreveu em Python:

def calcular_resistencia(v_fonte, v_led, i_led_mA):
    """
    Calcula a resistência ideal para um LED usando a Lei de Ohm.
    v_fonte: tensão da fonte (Volts)
    v_led: tensão típica do LED (Volts)
    i_led_mA: corrente do LED (miliamperes)
    """
    i_led = i_led_mA / 1000  # converte mA para A
    return (v_fonte - v_led) / i_led

print("=== Sistema Computacional: Cálculo de Resistor para LED ===")
v_fonte = float(input("Digite a tensão da fonte (V): "))
v_led = float(input("Digite a tensão do LED (V): "))
i_led_mA = float(input("Digite a corrente do LED (mA): "))

resistor = calcular_resistencia(v_fonte, v_led, i_led_mA)
print(f"\n🔧 Resistor recomendado: {resistor:.2f} Ω")
print("Use o valor comercial mais próximo.")

Ele digitou os valores:

• Fonte: 9V
• LED vermelho: 2V
• Corrente: 20mA

O computador respondeu:

Resistor recomendado: 350.00 Ω

Lucas ficou maravilhado:
— Lucas: “Então com um resistor de 350Ω, meu LED vai funcionar sem queimar?”

— Ana: “Sim! E olha como você aplicou física e programação juntas. Isso é exatamente o que estamos aprendendo no segundo grau: usar conceitos teóricos para resolver problemas práticos.”

---

🔬 Capítulo 4 – A Experiência Prática

No dia seguinte, Lucas levou o circuito para a escola. Na aula de física, a professora pediu que os alunos montassem o mesmo experimento em protoboards.

Eles testaram resistores diferentes:

• Com 330Ω: LED brilhante, seguro.
• Com 1kΩ: LED fraco, mas protegido.
• Sem resistor: queimou na hora.

A turma riu quando viram o LED queimando sem resistor, e todos compreenderam de forma prática o motivo da existência dos resistores.

---

🎓 Conclusão da História

Ao final da aula, a professora disse:

“O que Lucas fez foi criar um sistema computacional para resolver um problema real de eletrônica. Ele aplicou conceitos de física (Lei de Ohm), eletrônica (uso de resistores) e programação (Python) de forma integrada.”

Lucas sorriu. Agora, sempre que via um LED acender — seja na TV, no celular ou até no semáforo — ele lembrava que havia ciência e cálculo por trás daquele simples pontinho de luz.

---

🧩 Plano Prático para Aplicação

Inspirado na história de Lucas, você fará o mesmo em sala de aula:

1. Revisar física básica: tensão, corrente e resistência.
2. Aprender a Lei de Ohm: com exemplos simples e analogias.
3. Programar em Python: criar o cálculo automático do resistor.
4. Montar o circuito: usar LED, bateria e resistores em protoboard.
5. Testar valores diferentes: ver o LED acender, ficar fraco ou queimar.
6. Discutir resultados: refletir sobre como ciência e tecnologia se complementam.

Vamos a prática

🔧 Multímetro

O multímetro é uma ferramenta essencial para medir e testar circuitos elétricos. Ele será usado no projeto para:

• Medir a tensão da fonte (V): verificar se a bateria ou fonte realmente fornece 9V (ou o valor configurado).
• Medir a resistência do resistor (Ω): confirmar se o resistor utilizado tem o valor correto, conforme a tabela de cores.
• Verificar continuidade: testar se as ligações na protoboard estão corretas e sem falhas.

📌 Aplicação no projeto: Antes de ligar o LED, os alunos vão usar o multímetro para conferir a voltagem da fonte e o valor do resistor escolhido. Isso evita erros e garante segurança.

---

🔌 Protoboard

A protoboard será o espaço para montar e testar o circuito do LED sem necessidade de solda.

• Permite inserir a bateria, resistor e LED facilmente.
• Possui trilhas internas conectadas que facilitam a montagem e modificação rápida do circuito.
• Ideal para experimentação, como trocar resistores e observar o efeito no brilho do LED.

📌 Aplicação no projeto: Os alunos irão montar o circuito calculado (Fonte → Resistor → LED) na protoboard e testar os diferentes valores de resistência.

---

🎨 Tabela de Cores dos Resistores

Os resistores têm faixas coloridas que indicam seu valor em Ohms. Essa tabela será usada para identificar e confirmar os resistores corretos para o projeto.

Cor	Número
Preto	0
Marrom	1
Vermelho	2
Laranja	3
Amarelo	4
Verde	5
Azul	6
Violeta	7
Cinza	8
Branco	9

• Duas primeiras cores: dígitos do valor.
• Terceira cor: multiplicador.
• Quarta cor: tolerância (ex.: dourado = ±5%).

📌 Aplicação no projeto: Após calcular o valor com Python, os alunos vão:

1. Consultar a tabela de cores para escolher o resistor adequado.
2. Conferir com o multímetro se o valor está correto.
3. Montar na protoboard e observar o LED funcionando.

---

🔬 Fluxo Prático no Projeto

1️⃣ Calcular no Python o valor do resistor.
2️⃣ Identificar o resistor pela tabela de cores.
3️⃣ Medir no multímetro para confirmar o valor.
4️⃣ Montar o circuito na protoboard com a fonte, resistor e LED.
5️⃣ Ligar e observar: testar brilho e segurança do LED.
6️⃣ Experimentar resistores de valores diferentes e anotar os resultados.

---

🧪 Apresentação da Prática: Cálculo e Montagem de Circuito com LED e Resistor

🎯 Objetivo da Prática

• Compreender na prática a relação entre tensão, corrente e resistência usando a Lei de Ohm.
• Utilizar Python para calcular o resistor ideal para um LED.
• Aprender a identificar resistores pela tabela de cores e confirmar seu valor com um multímetro.
• Montar um circuito real em uma protoboard e testar seu funcionamento.

---

🗂 Etapas da Apresentação

🔹 1. Introdução Teórica (15 min)

Objetivo: Relembrar conceitos fundamentais e contextualizar o experimento.

• Início lúdico: Mostrar imagens de LEDs em objetos do dia a dia (TVs, semáforos, celulares).
• Explicar rapidamente os conceitos de tensão (voltagem), corrente elétrica e resistência, usando a analogia da água em um cano:
  • Tensão = pressão da água.
  • Corrente = fluxo da água.
  • Resistência = estreitamento no cano que limita o fluxo.
• Introduzir a Lei de Ohm e sua fórmula: V=R⋅I⇒R=Vfonte−VLEDILEDV = R \cdot I \quad \Rightarrow \quad R = \frac{V_\text{fonte} – V_\text{LED}}{I_\text{LED}}V=R⋅I⇒R=ILED​Vfonte​−VLED​​
• Mostrar a tabela de tensões dos LEDs (diferentes cores, diferentes tensões).

---

🔹 2. Demonstração de Ferramentas (15 min)

Objetivo: Familiarizar os alunos com os instrumentos e componentes.

• Protoboard: Mostrar como é a distribuição interna de trilhas (linhas horizontais e verticais).
• Multímetro:
  • Demonstrar como medir tensão da fonte (modo Volts DC).
  • Demonstrar como medir resistência de resistores (modo Ohms).
• Tabela de cores de resistores:
  • Explicar como identificar resistores com base nas faixas coloridas.
  • Exemplo prático: um resistor vermelho-violeta-marrom-dourado é 270Ω ±5%.

---

🔹 3. Programação do Cálculo (20 min)

Objetivo: Aplicar programação para automatizar o cálculo do resistor.

• Apresentar o código Python para cálculo do resistor.
• No computador ou Google Colab, pedir para os alunos executarem:
  • Fonte: 9V
  • LED: Vermelho (2V)
  • Corrente: 20mA
• O programa retorna: 350Ω.
• Discutir sobre o resistor comercial mais próximo (330Ω).

---

🔹 4. Identificação e Teste do Resistor (15 min)

Objetivo: Relacionar cálculo teórico com identificação prática.

• Cada grupo escolhe um resistor conforme o cálculo.
• Usar a tabela de cores para identificar o valor correspondente.
• Confirmar com o multímetro se o valor bate com o esperado.

---

🔹 5. Montagem na Protoboard (20 min)

Objetivo: Aplicar física e programação para criar o circuito.

• Montar o circuito:
  • Fonte (bateria de 9V ou fonte de bancada).
  • Resistor calculado.
  • LED conectado na posição correta (anodo e catodo).
• Conferir as conexões com o multímetro (continuidade).
• Ligar o circuito e observar o LED acendendo.

---

🔹 6. Testes Experimentais (20 min)

Objetivo: Observar efeitos práticos de diferentes resistências.

• Trocar o resistor por valores diferentes:
  • Menor valor: LED mais brilhante (risco de queimar).
  • Maior valor: LED mais fraco, mas protegido.
  • Sem resistor: LED queimando (feito com um LED de demonstração pelo professor).
• Discutir o efeito de cada mudança e como a resistência controla a corrente.

---

🔹 7. Encerramento e Discussão (15 min)

Objetivo: Consolidar os conceitos.

• Revisar:
  • Como a Lei de Ohm foi aplicada.
  • Como o Python ajudou no cálculo automático.
  • O uso do multímetro para validar componentes.
  • A importância da protoboard para testes seguros.
• Relacionar com situações do cotidiano (fontes de energia, carregadores de celular, luzes LED em carros).
• Convidar os alunos a criar novos cálculos e testar LEDs de diferentes cores.

---

🧩 Materiais Necessários

• Protoboard.
• LEDs de diferentes cores.
• Resistores variados.
• Fonte de alimentação (bateria 9V ou fonte regulada).
• Multímetros digitais (um por grupo).
• Computador ou celular com Python (Google Colab).
• Tabela de cores de resistores impressa.

---

🔬 Resultados Esperados

• Compreensão clara de como calcular e testar resistores.
• Capacidade de usar ferramentas práticas como multímetro e protoboard.
• Entender a integração entre física teórica e aplicação prática.
• Visualizar como programação ajuda a resolver problemas reais de eletrônica.

Exercícios comentados

1️⃣ Exercício: Gerenciamento de Mudanças em Requisitos

Enunciado

Uma clínica médica está implementando um sistema de prontuário eletrônico. Durante o desenvolvimento, um novo requisito surge: permitir que os pacientes consultem seus exames online.

Tarefas:

1. Elaborar um plano de gerenciamento de mudanças.
2. Criar um fluxo UML para análise/aprovação da mudança.
3. Explicar como métodos ágeis poderiam ajudar.

---

Resolução

Plano de Gerenciamento de Mudanças:

• Identificação da Mudança: Inclusão do módulo de consulta de exames online.
• Justificativa: Aumentar a autonomia dos pacientes e reduzir demanda no atendimento.
• Avaliação de Impacto:
  • Custo: Necessidade de servidor seguro e integração com o laboratório.
  • Prazo: Estimativa de +3 sprints no Scrum.
  • Segurança: Implementação de autenticação multifator.
  • Usabilidade: Interface simplificada para acesso via celular.
• Prioridade: Alta (impacto direto no valor para o cliente).
• Controle de Versão: Atualização do documento de requisitos (IEEE 830).

Fluxo UML (atividade simplificada):

[Solicitação de Mudança] → [Análise de Impacto] → [Aprovação do Comitê] → 
[Planejamento no Backlog] → [Implementação e Testes] → [Deploy e Feedback]

Métodos Ágeis:

• Scrum permite ajustes rápidos via backlog.
• Cada sprint incorpora incrementos pequenos (entrega contínua).
• Feedback dos usuários nas revisões ajuda a validar rapidamente.

---

2️⃣ Exercício: Herança e Encapsulamento

Enunciado

Crie uma classe Pessoa com atributos comuns (nome, idade e CPF), e duas subclasses: Aluno e Professor, que herdam atributos e adicionam informações específicas.

---

Resolução em Python

class Pessoa:
    def __init__(self, nome, idade, cpf):
        self._nome = nome
        self._idade = idade
        self._cpf = cpf

    def get_nome(self):
        return self._nome

    def set_nome(self, nome):
        self._nome = nome

    def get_idade(self):
        return self._idade

    def set_idade(self, idade):
        self._idade = idade

    def get_cpf(self):
        return self._cpf

    def set_cpf(self, cpf):
        self._cpf = cpf


class Aluno(Pessoa):
    def __init__(self, nome, idade, cpf, serie):
        super().__init__(nome, idade, cpf)
        self.serie = serie

    def exibir_informacoes(self):
        return f"Aluno: {self.get_nome()}, Idade: {self.get_idade()}, Série: {self.serie}"


class Professor(Pessoa):
    def __init__(self, nome, idade, cpf, disciplina):
        super().__init__(nome, idade, cpf)
        self.disciplina = disciplina

    def exibir_informacoes(self):
        return f"Professor: {self.get_nome()}, Idade: {self.get_idade()}, Disciplina: {self.disciplina}"


# Teste
aluno1 = Aluno("Carlos", 15, "123.456.789-00", "9º Ano")
prof1 = Professor("Ana", 35, "987.654.321-00", "Matemática")

print(aluno1.exibir_informacoes())
print(prof1.exibir_informacoes())

Saída esperada:

yamlCopiarEditarAluno: Carlos, Idade: 15, Série: 9º Ano
Professor: Ana, Idade: 35, Disciplina: Matemática

---

3️⃣ Exercício: Polimorfismo em um Sistema de Entregas

Enunciado

Implemente classes de transporte (Moto, Caminhao, Drone) que calculam o tempo de entrega de forma distinta, utilizando polimorfismo.

---

Resolução em Python

from abc import ABC, abstractmethod

class Transporte(ABC):
    @abstractmethod
    def calcular_tempo(self, distancia):
        pass


class Moto(Transporte):
    def calcular_tempo(self, distancia):
        velocidade = 60  # km/h
        return distancia / velocidade


class Caminhao(Transporte):
    def calcular_tempo(self, distancia):
        velocidade = 40  # km/h
        return distancia / velocidade


class Drone(Transporte):
    def calcular_tempo(self, distancia):
        velocidade = 80  # km/h
        return distancia / velocidade


# Teste com polimorfismo
transportes = [Moto(), Caminhao(), Drone()]
distancia = 120  # km

for t in transportes:
    print(f"{t.__class__.__name__}: Tempo estimado = {t.calcular_tempo(distancia):.2f} horas")

Saída esperada:

Moto: Tempo estimado = 2.00 horas
Caminhao: Tempo estimado = 3.00 horas
Drone: Tempo estimado = 1.50 horas

Programação – 3 Bimestre

Validação e Verificação de Requisitos

• Verificação de requisitos: Processo que assegura clareza, completude, consistência, rastreabilidade e testabilidade antes do desenvolvimento.
  • Técnicas: revisões por pares, análise de gap, checklists, matriz de rastreabilidade e critérios de aceitação.
  • Ferramentas: IBM Rational DOORS, JIRA e Enterprise Architect.
• Validação de requisitos: Garante que o sistema atenda às necessidades dos stakeholders, evitando mal-entendidos e retrabalho.
  • Ferramentas: planilhas de validação, reuniões com clientes, critérios claros de aceitação e feedback contínuo.
  • Exemplo: uso em sistemas de e-commerce, finanças pessoais e reservas de voos.

---

Pilares da Programação Orientada a Objetos (POO) – Encapsulamento

• Conceito: Protege atributos e métodos de uma classe, permitindo acesso controlado através de getters e setters.
• Benefícios:
  • Segurança: impede alterações indevidas nos dados.
  • Manutenibilidade: facilita ajustes e ampliações no código.
  • Modularidade: separa responsabilidades, tornando o sistema mais organizado.
• Exemplos práticos em Python:
  • Controle de curtidas em e-commerce.
  • Sistema de gestão de carros com atributos encapsulados.
  • Sistema de biblioteca com implementação de métodos de acesso.

---

Principais Aprendizados

1. Requisitos bem validados e verificados reduzem falhas e retrabalho no desenvolvimento.
2. POO com encapsulamento reforça boas práticas de segurança e organização no código.
3. Ferramentas de apoio (planilhas, checklists, IDEs) otimizam processos técnicos e colaborativos.
4. Exemplos reais facilitam a compreensão e aplicação dos conceitos de engenharia de software.

Encapsulamento em Projetos Práticos (POO)

• Reforço do encapsulamento: Controle de atributos e métodos com segurança e acesso controlado, melhorando integridade e confiabilidade do código.
• Exemplo prático: Sistema de controle de estoque de carros, com classes Carro e Estoque, aplicação de getters e setters, e métodos como adicionar_carro.
• Benefícios: Segurança, manutenção facilitada, modularidade e prevenção de bugs.
• Questões éticas: Proteção de dados, segurança cibernética e transparência no uso de informações.

---

Testes Não Funcionais

• Desenvolvimento e execução: Identificação de requisitos não funcionais (desempenho, segurança, usabilidade, confiabilidade), definição de critérios e uso de ferramentas apropriadas.
• Ferramentas e práticas:
  • Pentest: Exploração de vulnerabilidades usando Kali Linux e ferramentas como SQLMap e PortSwigger.
  • Burp Suite: Interceptação e modificação de requisições HTTP para identificar falhas de controle de acesso.
• Testes de desempenho e segurança: Avaliação de escalabilidade, estabilidade, vulnerabilidades e usabilidade.
• OWASP Top 10: Referência essencial para práticas de segurança web.

---

Diagramas UML – Diagrama de Estados

• Definição: Representa mudanças de estados de um objeto ou sistema em resposta a eventos.
• Elementos principais:
  • Estados (inicial, intermediários e final).
  • Transições acionadas por eventos.
  • Ações associadas às mudanças de estado.
• Exemplos práticos:
  • Controle de acesso eletrônico (porta: fechada, abrindo, aberta, fechando, trancada).
  • Processo de matrícula em instituições educacionais.
• Benefícios: Visualização do comportamento do sistema, identificação de falhas e melhor comunicação entre stakeholders.

Diagramas UML – Atividades

• Definição: Ferramenta visual que modela o fluxo de atividades, ações e decisões em sistemas e processos.
• Aplicações:
  • Modelagem de processos de negócios (reservas de passagens aéreas).
  • Desenvolvimento de software (fluxos de tela, módulos específicos).
  • Engenharia de sistemas complexos (controle de tráfego aéreo).
• Benefícios:
  • Facilita comunicação entre stakeholders.
  • Identifica gargalos e otimiza processos.
  • Documenta sistemas e facilita manutenção.
• Ferramentas: Lucidchart, Draw.io, Microsoft Visio.

---

Herança em POO

• Conceito: Permite que classes herdem atributos e métodos de outras, criando hierarquias reutilizáveis.
• Exemplo prático:
  • ContaBancaria (superclasse): métodos comuns (depositar, sacar, consultar_saldo).
  • ContaCorrente, ContaPoupanca e ContaInvestimento (subclasses) com funcionalidades específicas.
• Reutilização de código:
  • Implementação de cálculos de tarifas com métodos estáticos e classes utilitárias.
  • Inclusão de novas funcionalidades (ex: conta universitária gratuita) sem duplicação de código.
• Método de transferência: Transferência entre contas com verificação de saldo.
• Aspectos éticos:
  • Privacidade dos dados, segurança de transações e transparência nas práticas bancárias.

---

Principais Aprendizados

1. Diagramas de atividades ajudam na visualização, comunicação e melhoria de sistemas.
2. Herança simplifica manutenção e amplia escalabilidade, evitando duplicação de código.
3. Práticas éticas e segurança devem ser consideradas na implementação de sistemas financeiros.
4. Ferramentas de modelagem e POO combinadas fornecem base sólida para projetos de software.

Gerenciamento de Mudanças em Requisitos

• Definição: Processo contínuo que ocorre durante todo o ciclo de vida do projeto, envolvendo identificação, análise, documentação, priorização e controle de requisitos.
• Importância:
  • Permite adaptação às mudanças de mercado e necessidades do cliente.
  • Minimiza riscos e falhas decorrentes de requisitos mal gerenciados.
• Boas práticas:
  • Documentação clara e enxuta.
  • Avaliação de impacto (prazo, custo e qualidade).
  • Controle rigoroso de versões e rastreabilidade.
• Exemplos práticos: Aplicação em sistemas de saúde (SUS), lojas e softwares corporativos, com foco em segurança e ética (proteção de dados).

---

Herança em Projetos Práticos (POO)

• Exemplo aplicado: Sistema de gestão de loja de eletrônicos.
  • Classe base: ProdutoEletronico (atributos e métodos comuns).
  • Subclasses: Smartphone, Laptop, Televisor, cada uma com características próprias.
• Benefícios da herança:
  • Reutilização de código.
  • Estrutura hierárquica clara e extensível.
  • Facilidade de manutenção e escalabilidade.
• Prática de implementação:
  • Testes práticos para validar métodos.
  • Flexibilidade para novos tipos de produtos.

---

Principais Aprendizados

1. Gerenciamento eficaz de requisitos é essencial para evitar falhas e alinhar o projeto às expectativas do cliente.
2. Documentação ágil e enxuta facilita comunicação e evita burocracia excessiva.
3. Herança em POO permite criar sistemas organizados, reutilizáveis e preparados para expansão.
4. Aspectos éticos e segurança devem ser considerados tanto no gerenciamento de mudanças quanto na implementação de software.

Herança em Projetos Práticos

• Exemplo aplicado: Sistema de gerenciamento escolar com classes Pessoa, Funcionario e Aluno, mostrando a criação de estruturas hierárquicas e reutilização de código.
• Conceitos aplicados:
  • Encapsulamento de atributos e métodos.
  • Uso de composição (objetos como atributos de outras classes).
  • Estrutura hierárquica clara e extensível para novos tipos de entidades.

---

Polimorfismo (POO)

• Definição: Permite que objetos de diferentes classes respondam de forma distinta a uma mesma interface, aumentando flexibilidade e reutilização.
• Tipos abordados:
  • Sobreposição (override): Subclasses redefinem métodos herdados da classe pai.
  • Exemplo prático: Sistema de entregas com veículos (carro, caminhão, bicicleta), cada um com cálculo específico de tempo de entrega.
• Aplicações adicionais:
  • Loja virtual com diferentes tipos de produtos (livros, eletrônicos e alimentos).
  • Sistema de rastreamento de encomendas com classes Encomenda, Pacote, Carta e RemessaGrande, utilizando herança e sobreposição para especializações.

---

Benefícios Chave

1. Reutilização de código: Com herança e polimorfismo, métodos comuns são centralizados e especializados conforme necessário.
2. Flexibilidade e extensibilidade: Fácil adição de novos tipos de classes sem alterar estruturas existentes.
3. Modelagem próxima ao mundo real: Representação clara de entidades e suas relações hierárquicas.
4. Manutenção simplificada: Alterações localizadas reduzem riscos de falhas globais no sistema.