PDS e Metodologias Ágeis
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.

PDS e Metodologias Ágeis
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:

SistemaPadrão/Dialeto G-codeUsado em
Ender-3Marlin/RepRap (G0, G1, G28, M104…)Impressoras 3D
FANUCISO G-code (muitos ciclos fixos, G71, G81, etc)CNC industrial (torno/fresa)
MitsubishiPróprio dialeto ISO compatível, similar ao FANUCCNC industrial
SiemensSinumerik (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.

PDS e Metodologias Ágeis
🔬💡 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 LEDTensão típica (V)
🔴 Vermelho2,0 V
🟢 Verde2,2 V
🔵 Azul3,0 V
⚪ Branco3,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.

CorNúmero
Preto0
Marrom1
Vermelho2
Laranja3
Amarelo4
Verde5
Azul6
Violeta7
Cinza8
Branco9
  • 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.
carreiras e competencias
🎭 Teatro das Competências: Empatia, Comunicação e Colaboração

1️⃣ Objetivo da Atividade

O Teatro das Competências tem como meta:

  • Desenvolver habilidades socioemocionais (empatia, comunicação assertiva, escuta ativa e colaboração).
  • Simular situações reais do mercado de trabalho em ambiente controlado e participativo.
  • Incentivar criatividade, improviso e trabalho em equipe.

2️⃣ Explicação Inicial para a Turma

Professor pode falar:

“Hoje vamos trabalhar situações comuns do ambiente profissional por meio de encenações rápidas. Vocês vão receber roteiros baseados em desafios reais, como conflitos entre colegas, atendimento a clientes insatisfeitos, brainstorming de ideias e entrevistas simuladas.

O objetivo não é apenas ‘atuar’, mas mostrar como resolver problemas usando empatia, comunicação clara e colaboração. No fim, vamos discutir juntos o que funcionou bem e o que poderia ser melhorado.”


3️⃣ Regras do Jogo

  1. Formação dos grupos: 3 a 4 integrantes por grupo.
  2. Distribuição dos roteiros: Cada grupo recebe um caso diferente.
  3. Tempo de preparação: 10 minutos para ler, discutir papéis e ensaiar.
  4. Apresentação: Cada grupo terá 3 a 5 minutos para encenar.
  5. Feedback: Após cada apresentação, a turma e o professor comentam os pontos positivos e sugerem melhorias.

4️⃣ Papéis e Roteiros Prontos

Cada grupo recebe um roteiro impresso com: situação, contexto, papéis e objetivos.


🎭 Roteiro 1: Conflito entre colegas de trabalho

  • Situação: Dois colaboradores discordam sobre a melhor forma de entregar um relatório urgente. O gerente intervém para mediar.
  • Papéis:
    • Colaborador 1: Quer entregar rápido, mesmo que simples.
    • Colaborador 2: Prefere perfeição, mesmo que atrase.
    • Gerente: Deve ouvir os dois lados e propor uma solução equilibrada.
  • Objetivo: Mostrar negociação, escuta ativa e busca de consenso.

🎭 Roteiro 2: Cliente insatisfeito

  • Situação: Um cliente está irritado com um serviço entregue errado. O atendente precisa resolver.
  • Papéis:
    • Cliente: Está nervoso e exige solução imediata.
    • Atendente: Deve ouvir com empatia e propor alternativas.
    • Supervisor: Apoia o atendente e valida a solução final.
  • Objetivo: Demonstrar comunicação calma e resolução eficaz de conflitos.

🎭 Roteiro 3: Brainstorming de inovação

  • Situação: Equipe precisa criar uma campanha publicitária inovadora em curto prazo.
  • Papéis:
    • Líder: Organiza a reunião e dá voz a todos.
    • Criativo: Traz ideias ousadas e diferentes.
    • Cético: Questiona custos e prazos das ideias.
    • Mediador: Tenta conciliar criatividade e viabilidade.
  • Objetivo: Mostrar colaboração e integração de ideias diferentes.

🎭 Roteiro 4: Entrevista de emprego em grupo

  • Situação: Entrevista dinâmica para vaga de trainee.
  • Papéis:
    • Entrevistador: Observa comportamento e interação entre candidatos.
    • Candidato colaborativo 1: Trabalha bem em equipe e ajuda os colegas.
    • Candidato colaborativo 2: Similar ao 1, mas traz ideias próprias.
    • Candidato competitivo: Quer brilhar sozinho e atrapalha o grupo.
  • Objetivo: Mostrar como postura e trabalho em equipe impactam em seleções reais.

5️⃣ Orientações para os Papéis

Cada participante deve receber uma ficha individual, contendo:

  • Nome do papel (ex.: Gerente, Cliente, Criativo).
  • Breve descrição de como atuar.
  • O que dizer ou fazer (pontos-chave):
    • Usar linguagem educada.
    • Demonstrar empatia (olhar nos olhos, ouvir sem interromper).
    • Sugerir soluções objetivas.

6️⃣ Encerramento e Discussão

Após todas as apresentações:

  • Perguntar:
    1. “Quais competências socioemocionais foram mais evidentes?”
    2. “O que ajudou a resolver os conflitos?”
    3. “Como isso se conecta a situações reais de trabalho?”
  • Professor dá feedback geral e reforça a importância de empatia, comunicação e colaboração para o sucesso profissional.
PDS e Metodologias Ágeis
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
PDS e Metodologias Ágeis
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.
carreiras e competencias
Empreendedorismo, Inovação e Tendências – 3 Bimestre
  • Plano de ação: Implementar, avaliar resultados e ajustar estratégias continuamente é essencial para o sucesso de um empreendimento.
  • Inovação: Fundamental para manter a competitividade, podendo ocorrer em produtos, processos e modelos de negócios. Exemplos como Nubank ilustram a importância de inovar e acompanhar tendências de mercado.
  • Startups: Empresas inovadoras, escaláveis e de rápido crescimento, com busca constante por soluções disruptivas. Investidores-anjos e incubadoras oferecem suporte financeiro e estratégico para o desenvolvimento dessas empresas.

Competências Socioemocionais

  • Produtividade e gestão do tempo: Uso da Matriz de Eisenhower para diferenciar tarefas urgentes e importantes, além de ferramentas como GTD, Kanban e Pomodoro para aumentar a eficiência.
  • Pitch pessoal: Apresentar sua história de forma clara e objetiva em 1 minuto, desenvolvendo comunicação e autoconfiança.
  • Teatro das competências: Simulações de situações do mercado de trabalho para exercitar empatia, colaboração e resolução de conflitos.

Principais Aprendizados

  1. Empreender exige planejamento, execução, avaliação contínua e inovação constante.
  2. A gestão do tempo e das prioridades impacta diretamente na produtividade e no alcance de metas.
  3. Competências socioemocionais (empatia, comunicação e colaboração) são cruciais para o mercado de trabalho moderno.
  4. Startups diferem de pequenas empresas por sua escalabilidade e foco em inovação, contando com investidores e incubadoras para crescer.

Competências Socioemocionais (Aulas 3 e 4)

  • Teatro das Competências (Parte 2): Simulações que reforçam habilidades como empatia, gestão de conflitos, proatividade e colaboração, essenciais para o mercado de trabalho.
  • Importância das soft skills: Desenvolver competências socioemocionais aumenta as chances de sucesso profissional e empregabilidade.

Finanças Pessoais e Familiares (Aulas 5, 6 e 7)

  • Planejamento financeiro familiar: Estratégias para administrar finanças em conjunto, com foco no envolvimento de todos os membros da família.
  • Método 50/15/35: Distribuir a renda em 50% para despesas essenciais, 15% para dívidas/prioridades e 35% para lazer e estilo de vida.
  • Perfis financeiros: Identificação de perfis (poupador, gastador, desligado) para criar estratégias personalizadas de controle financeiro.
  • Planilha financeira: Uso de planilhas para monitorar receitas, despesas e metas mensais, facilitando a visualização de gastos e ajustes.

Planejamento e Preparação Profissional (Aula 8)

  • Carta de apresentação: Documento que complementa o currículo, destacando experiências, habilidades e alinhamento com os valores da empresa.
  • Estrutura da carta: Saudação personalizada, introdução envolvente, corpo com conquistas relevantes, diferenciais e valores, encerramento confiante.
  • Boas práticas: Clareza, objetividade, personalização e revisão prévia para eliminar erros e transmitir profissionalismo.

Principais Aprendizados

  1. Competências socioemocionais e financeiras são pilares para o desenvolvimento pessoal e profissional.
  2. Planejamento financeiro em família, com métodos práticos e planilhas, reduz dívidas e melhora a qualidade de vida.
  3. Habilidades de comunicação escrita e apresentação são essenciais para processos seletivos e networking.
  4. O uso de ferramentas digitais como Excel, LinkedIn e Canva fortalece a organização e a apresentação profissional.

Apresentação Profissional (Vídeo e Carta)

  • Carta de apresentação: Ferramenta para destacar habilidades, experiências e alinhamento com a vaga. Deve ser breve, personalizada e objetiva.
  • Vídeo de apresentação: Complementa o currículo, mostrando comunicação verbal e não verbal. Requer roteiro estruturado: apresentação pessoal, formação, experiência, resultados e objetivos.
  • Prática integrada: Elaboração de carta e vídeo reforça a confiança, a clareza e o profissionalismo no processo seletivo.

Busca de Oportunidades de Trabalho

  • Estratégias de busca: Utilização de sites especializados (LinkedIn, Indeed, Catho, InfoJobs), redes de relacionamento, feiras de emprego, programas governamentais (Qualifica SP) e agências de recrutamento.
  • Gestão de candidaturas: Uso de planilhas ou ferramentas como Trello para acompanhar processos seletivos.
  • Prática de busca ativa: Pesquisa colaborativa e compartilhamento de vagas entre colegas para ampliar perspectivas.

Mentalidade de Crescimento

  • Lidando com rejeições: Não levar resultados negativos para o lado pessoal; entender como aprendizado.
  • Autorreflexão e resiliência: Identificar pontos fortes e áreas de melhoria, buscar feedback e manter atitude positiva.
  • Metodologia SMART: Estabelecer metas específicas, mensuráveis e alinhadas aos objetivos de carreira.

Principais Aprendizados

  1. Comunicação eficaz é essencial para destacar-se (carta e vídeo).
  2. Busca ativa e estruturada aumenta as chances de encontrar boas vagas.
  3. Resiliência e mentalidade de crescimento ajudam a transformar desafios em oportunidades.
  4. Ferramentas digitais (LinkedIn, Excel, Trello) são aliadas para organização e networking.

Planejamento Financeiro Pessoal (Método OKR)

  • Diferença entre objetivos e metas: Objetivos são gerais e de longo prazo; metas são específicas e detalhadas.
  • Método OKR: Define objetivos claros (O) com resultados-chave (KR) mensuráveis e monitorados periodicamente.
  • Ferramentas de apoio: Metas SMART, 5W2H e Trello para estruturar planos e monitoramento.
  • Aplicação prática: Cada estudante desenvolveu objetivos financeiros pessoais, com metas de curto e médio prazo, plano de ação e infográfico no Canva.
  • Análise do padrão de vida: Identificação de gastos essenciais, não essenciais e variáveis para ajustar hábitos e alinhar o planejamento financeiro.

Superando Desafios e Obstáculos no Empreendedorismo

  • Gestão por processos: Compreensão de processos de compras, produção e estoques para melhorar a eficiência e reduzir desperdícios.
  • Políticas de gestão: Implementação de políticas de RH, qualidade, segurança e tecnologia da informação para padronizar operações e melhorar resultados.
  • Exemplo prático: Estudo de caso da “Pizzaria Pereira” para ilustrar a aplicação de processos e políticas na gestão de pequenos negócios.
  • Habilidades empreendedoras: Desenvolvimento de proatividade, trabalho em equipe e capacidade de adaptação a desafios de gestão.

Principais Aprendizados

  1. O OKR e ferramentas de apoio permitem organizar metas e melhorar a disciplina financeira.
  2. Compreender o padrão de vida ajuda a alinhar gastos à realidade financeira e aos objetivos pessoais.
  3. Processos e políticas de gestão estruturam negócios e contribuem para o sucesso empreendedor.
  4. A prática de situações reais aproxima a teoria da aplicação prática, fortalecendo a mentalidade empreendedora e a resiliência.

Móbile de Valor (Complexidade, Qualidade, Preço e Tempo)

  • Ferramenta visual para equilibrar variáveis essenciais de um negócio:
    • Complexidade: nível de dificuldade para produzir o produto ou serviço.
    • Qualidade: padrão entregue ao cliente.
    • Preço: valor cobrado.
    • Tempo: prazo de entrega.
  • O equilíbrio dessas variáveis garante competitividade e sustentabilidade do negócio.

Pitch para Projetos e Negócios

  • Pitch Pessoal: breve apresentação de habilidades e objetivos profissionais.
  • Pitch de Negócio:
    • Estrutura concisa (30 segundos a 20 minutos) para atrair investidores ou clientes.
    • Tipos: Pitch de elevador, one-sentence, pitch deck, tweet pitch.
  • Organização do Pitch (9 passos):
    1. Punchline (frase de impacto)
    2. Problema (que será resolvido)
    3. Proposta de valor
    4. Mercado (potencial e tamanho)
    5. Solução
    6. Modelo de negócio
    7. Asking for (investimento desejado)
    8. Roadmap (plano de uso do capital)
    9. Time e contato

Comunicação pelas Mídias Sociais

  • Importância: Divulgação eficiente de produtos, serviços e negócios.
  • Passos principais:
    • Identificar o público-alvo e redes sociais utilizadas.
    • Criar conteúdo alinhado ao perfil do público.
    • Definir estratégias de publicação (frequência e formatos).
    • Analisar métricas (alcance, curtidas, engajamento).
  • Cuidados:
    • Não misturar perfis pessoais e profissionais.
    • Evitar erros gramaticais e polêmicas desnecessárias.

Principais Aprendizados

  1. O móbile de valor ajuda a equilibrar fatores críticos do negócio.
  2. O pitch bem estruturado é essencial para captar investimentos e apresentar ideias.
  3. Comunicação digital eficaz amplia o alcance e potencializa os resultados.
  4. Ferramentas digitais e redes sociais são indispensáveis no empreendedorismo moderno.
docker
Docker – Restrição de Recursos

Para rodar um container com restrição de recursos basta seguir a seguinte sintaxe:

docker container run -dt --nome [nome] --cpus [perc] -m [memoria] [imagem]
  • perc – é um valor de 0 a 1, sendo 1, 100% de recursos de um CPU , onde cada unidade é um núcleo de processador.
  • memoria é um valor absoluto onde vem acompanhado de k,m,g,t. Ex.: 100m (100 mega de memoria ram)

O processo de restrição de recursos pode ser feito em dois momentos. Ao rodar (run) ou depois (update).

docker container update --cpus [perc] [imagem]

Analise de recursos usados

Para analise dos recursos usados, use o comando stats.

docker container stats

Recursos do sistema

Para visualizar os recursos do equipamento

docker system info

Recursos do container

Para visualizar os recursos de um dado container, basta usar o seguinte comando.

docker container top [container_name]

Comando de Teste de Container

Apesar de não ser um comando do docker o stress é usado para testar estes parâmetros.

stress -c [cpu] -t [tempo]

Referências:

https://www.geeksforgeeks.org/linux-unix/linux-stress-command-with-examples

PDS e Metodologias Ágeis
Resultado do Projeto

A partir dessa conversa, o aluno consegue extrair:

Banco de Dados Simplificado

  • Tabela produtos
    • id (PK)
    • nome
    • preco
    • tamanho
    • foto
    • ativo (booleano)
  • Tabela adicionais
    • id (PK)
    • nome
    • preco
  • Tabela pedidos
    • id (PK)
    • nome_cliente
    • telefone_cliente
    • bairro
    • data_hora
  • Tabela itens_pedido
    • id (PK)
    • pedido_id (FK)
    • produto_id (FK)
    • tamanho
    • adicionais (lista simplificada, se quiser)

Casos de Uso

  • Cliente:
    • Visualizar produtos
    • Adicionar produtos ao carrinho
    • Escolher adicionais
    • Finalizar pedido
  • Dono da loja:
    • Cadastrar produto
    • Editar produto
    • Cadastrar adicionais
    • Desativar produto
    • Ver pedidos

Objetivo Final

🎯 Criar um site com:

  • Página inicial listando os produtos
  • Tela de escolha de adicionais
  • Carrinho de compras
  • Formulário simples (Nome, Telefone, Bairro)
  • Botão “Enviar pedido” integrando com WhatsApp
  • Painel administrativo bem simples

Vou seguir essa ordem para ficar fácil para seus alunos:

  1. 🎯 Casos de Uso
  2. 📦 Diagrama de Classes
  3. 🛢️ Tabelas (Banco de Dados)
  4. 🖥️ Programa em Python (bem simples, tipo console) para atender o cliente

Vou fazer tudo bem simples e didático para quem está começando! Vamos lá:


🎯 1. Casos de Uso

Ator 1: Cliente

  • Visualizar lista de produtos
  • Escolher produto e adicionais
  • Preencher nome, telefone e bairro
  • Confirmar pedido

Ator 2: Dono da loja

  • Cadastrar novo produto
  • Editar produto
  • Desativar produto
  • Cadastrar adicionais
  • Visualizar pedidos recebidos

📦 2. Diagrama de Classes (Simplificado)

+----------------+        +----------------+        +----------------+
|    Produto     |        |    Adicional    |        |     Pedido      |
+----------------+        +----------------+        +----------------+
| - id: int      |        | - id: int       |        | - id: int       |
| - nome: str    |        | - nome: str     |        | - nome_cliente  |
| - preco: float |        | - preco: float  |        | - telefone      |
| - tamanho: str |        +----------------+        | - bairro        |
| - ativo: bool  |                                 | - data_hora     |
+----------------+                                 +----------------+
          |                                               |
          |                                               |
          |                      +------------------------+
          |                      |
          |                 +-----------------+
          |                 |  ItensPedido     |
          |                 +-----------------+
          |                 | - id: int        |
          +---------------->| - pedido_id: int |
                            | - produto_id: int|
                            | - adicionais: str|
                            +-----------------+

🛢️ Tabelas no SQLite

Aqui está o script para criar o banco SQLite:

-- Criação das tabelas no SQLite

CREATE TABLE produtos (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    nome TEXT NOT NULL,
    preco REAL NOT NULL,
    tamanho TEXT NOT NULL,
    ativo INTEGER DEFAULT 1 -- 1 = ativo, 0 = inativo
);

CREATE TABLE adicionais (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    nome TEXT NOT NULL,
    preco REAL NOT NULL
);

CREATE TABLE pedidos (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    nome_cliente TEXT NOT NULL,
    telefone_cliente TEXT NOT NULL,
    bairro TEXT,
    data_hora TEXT DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE itens_pedido (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    pedido_id INTEGER,
    produto_id INTEGER,
    adicionais TEXT,
    FOREIGN KEY (pedido_id) REFERENCES pedidos(id),
    FOREIGN KEY (produto_id) REFERENCES produtos(id)
);

🐍 Código Python usando SQLite (bem fácil)

Aqui está o programa completo agora com banco SQLite:

import sqlite3
from datetime import datetime

# Conexão com o banco SQLite
conn = sqlite3.connect('acai.db')
cursor = conn.cursor()

# Cria tabelas se não existirem
cursor.execute('''
CREATE TABLE IF NOT EXISTS produtos (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    nome TEXT NOT NULL,
    preco REAL NOT NULL,
    tamanho TEXT NOT NULL,
    ativo INTEGER DEFAULT 1
)
''')

cursor.execute('''
CREATE TABLE IF NOT EXISTS adicionais (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    nome TEXT NOT NULL,
    preco REAL NOT NULL
)
''')

cursor.execute('''
CREATE TABLE IF NOT EXISTS pedidos (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    nome_cliente TEXT NOT NULL,
    telefone_cliente TEXT NOT NULL,
    bairro TEXT,
    data_hora TEXT DEFAULT CURRENT_TIMESTAMP
)
''')

cursor.execute('''
CREATE TABLE IF NOT EXISTS itens_pedido (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    pedido_id INTEGER,
    produto_id INTEGER,
    adicionais TEXT,
    FOREIGN KEY (pedido_id) REFERENCES pedidos(id),
    FOREIGN KEY (produto_id) REFERENCES produtos(id)
)
''')

conn.commit()

def cadastrar_produto():
    nome = input("Nome do produto: ")
    preco = float(input("Preço: "))
    tamanho = input("Tamanho (ex: 300ml, 500ml): ")
    cursor.execute("INSERT INTO produtos (nome, preco, tamanho) VALUES (?, ?, ?)", (nome, preco, tamanho))
    conn.commit()
    print("Produto cadastrado!\n")

def cadastrar_adicional():
    nome = input("Nome do adicional: ")
    preco = float(input("Preço do adicional: "))
    cursor.execute("INSERT INTO adicionais (nome, preco) VALUES (?, ?)", (nome, preco))
    conn.commit()
    print("Adicional cadastrado!\n")

def listar_produtos():
    cursor.execute("SELECT id, nome, preco, tamanho FROM produtos WHERE ativo = 1")
    produtos = cursor.fetchall()
    print("\nProdutos disponíveis:")
    for prod in produtos:
        print(f"{prod[0]}. {prod[1]} - {prod[3]} - R$ {prod[2]:.2f}")
    print()

def listar_adicionais():
    cursor.execute("SELECT id, nome, preco FROM adicionais")
    adicionais = cursor.fetchall()
    print("\nAdicionais disponíveis:")
    for ad in adicionais:
        print(f"{ad[0]}. {ad[1]} - R$ {ad[2]:.2f}")
    print()

def fazer_pedido():
    listar_produtos()
    produto_id = input("Escolha o número do produto: ")
    cursor.execute("SELECT nome, tamanho FROM produtos WHERE id = ? AND ativo = 1", (produto_id,))
    produto = cursor.fetchone()
    if not produto:
        print("Produto inválido!")
        return

    adicionais_selecionados = []
    while True:
        listar_adicionais()
        add = input("Escolha o número do adicional (ou ENTER para finalizar): ")
        if add == "":
            break
        cursor.execute("SELECT nome FROM adicionais WHERE id = ?", (add,))
        adicional = cursor.fetchone()
        if adicional:
            adicionais_selecionados.append(adicional[0])

    nome_cliente = input("Nome do cliente: ")
    telefone = input("Telefone do cliente: ")
    bairro = input("Bairro do cliente: ")

    cursor.execute("INSERT INTO pedidos (nome_cliente, telefone_cliente, bairro) VALUES (?, ?, ?)", 
                   (nome_cliente, telefone, bairro))
    pedido_id = cursor.lastrowid

    adicionais_texto = ', '.join(adicionais_selecionados)
    cursor.execute("INSERT INTO itens_pedido (pedido_id, produto_id, adicionais) VALUES (?, ?, ?)", 
                   (pedido_id, produto_id, adicionais_texto))
    
    conn.commit()
    print("Pedido registrado com sucesso!\n")

def listar_pedidos():
    cursor.execute('''
    SELECT pedidos.nome_cliente, pedidos.telefone_cliente, pedidos.bairro, pedidos.data_hora,
           produtos.nome, produtos.tamanho, itens_pedido.adicionais
    FROM pedidos
    JOIN itens_pedido ON pedidos.id = itens_pedido.pedido_id
    JOIN produtos ON produtos.id = itens_pedido.produto_id
    ''')
    pedidos = cursor.fetchall()
    print("\nPedidos recebidos:")
    for ped in pedidos:
        print(f"- {ped[0]} ({ped[1]}) pediu {ped[4]} {ped[5]} com {ped[6]} [{ped[3]}] - Bairro: {ped[2]}")
    print()

def menu_admin():
    while True:
        print("\n=== Menu Admin ===")
        print("1. Cadastrar Produto")
        print("2. Cadastrar Adicional")
        print("3. Listar Pedidos")
        print("4. Sair")
        op = input("Escolha: ")
        if op == "1":
            cadastrar_produto()
        elif op == "2":
            cadastrar_adicional()
        elif op == "3":
            listar_pedidos()
        elif op == "4":
            break
        else:
            print("Opção inválida.")

def menu_cliente():
    while True:
        print("\n=== Menu Cliente ===")
        print("1. Fazer Pedido")
        print("2. Sair")
        op = input("Escolha: ")
        if op == "1":
            fazer_pedido()
        elif op == "2":
            break
        else:
            print("Opção inválida.")

def main():
    while True:
        print("\n=== Sistema Açaí ===")
        print("1. Cliente")
        print("2. Admin")
        print("3. Sair")
        op = input("Escolha: ")
        if op == "1":
            menu_cliente()
        elif op == "2":
            menu_admin()
        elif op == "3":
            print("Até mais!")
            break
        else:
            print("Opção inválida.")

if __name__ == "__main__":
    main()

🧡 O que você tem agora:

  • Casos de uso ✅
  • Diagrama de classes ✅
  • Estrutura de tabelas SQL ✅
  • Programa Python inicial ✅

Vou montar agora um exemplo usando Streamlit, que é perfeito para criar interfaces web simples em Python — ideal pra mostrar pra turma!

💡 O que vamos fazer:

  • Listar produtos
  • Cliente escolher o produto
  • Selecionar adicionais
  • Preencher nome, telefone e bairro
  • Confirmar o pedido
  • Mostrar o pedido feito na tela (como simulação)

Tudo direto pelo navegador, usando o acai.db (SQLite)!


🖥️ Código Streamlit (arquivo app.py)

import streamlit as st
import sqlite3
from datetime import datetime

# Conexão com o banco SQLite
conn = sqlite3.connect('acai.db', check_same_thread=False)
cursor = conn.cursor()

# Funções auxiliares
def listar_produtos():
    cursor.execute("SELECT id, nome, preco, tamanho FROM produtos WHERE ativo = 1")
    return cursor.fetchall()

def listar_adicionais():
    cursor.execute("SELECT id, nome, preco FROM adicionais")
    return cursor.fetchall()

def registrar_pedido(nome_cliente, telefone, bairro, produto_id, adicionais_lista):
    cursor.execute("INSERT INTO pedidos (nome_cliente, telefone_cliente, bairro) VALUES (?, ?, ?)", 
                   (nome_cliente, telefone, bairro))
    pedido_id = cursor.lastrowid
    adicionais_texto = ', '.join(adicionais_lista)
    cursor.execute("INSERT INTO itens_pedido (pedido_id, produto_id, adicionais) VALUES (?, ?, ?)", 
                   (pedido_id, produto_id, adicionais_texto))
    conn.commit()

# Layout da página
st.title("🍧 Loja de Açaí")

st.header("Escolha seu Açaí")

produtos = listar_produtos()
produtos_dict = {f"{nome} - {tamanho} - R$ {preco:.2f}": id for id, nome, preco, tamanho in produtos}

produto_escolhido = st.selectbox("Selecione um produto", list(produtos_dict.keys()))

adicionais = listar_adicionais()
adicionais_selecionados = st.multiselect(
    "Escolha adicionais (opcional)",
    [f"{nome} - R$ {preco:.2f}" for id, nome, preco in adicionais]
)

st.header("Seus Dados")

nome_cliente = st.text_input("Nome completo")
telefone = st.text_input("Telefone")
bairro = st.text_input("Bairro")

if st.button("Confirmar Pedido"):
    if nome_cliente and telefone and produto_escolhido:
        # Captura IDs dos adicionais selecionados
        adicionais_nomes = [a.split(' - ')[0] for a in adicionais_selecionados]
        
        produto_id = produtos_dict[produto_escolhido]
        registrar_pedido(nome_cliente, telefone, bairro, produto_id, adicionais_nomes)

        st.success("Pedido enviado com sucesso!")
        st.balloons()
    else:
        st.error("Preencha seu nome, telefone e selecione um produto!")

st.divider()

st.subheader("📋 Últimos Pedidos")

cursor.execute('''
    SELECT pedidos.nome_cliente, produtos.nome, produtos.tamanho, itens_pedido.adicionais, pedidos.data_hora
    FROM pedidos
    JOIN itens_pedido ON pedidos.id = itens_pedido.pedido_id
    JOIN produtos ON produtos.id = itens_pedido.produto_id
    ORDER BY pedidos.data_hora DESC
    LIMIT 5
''')
ultimos_pedidos = cursor.fetchall()

for ped in ultimos_pedidos:
    st.write(f"**{ped[0]}** pediu **{ped[1]} {ped[2]}** com _{ped[3]}_ em {ped[4]}")


🚀 Como Rodar:

  1. Instalar o Streamlit:
bashCopiarEditarpip install streamlit
  1. Criar o arquivo app.py com o código acima.
  2. Rodar o aplicativo:
bashCopiarEditarstreamlit run app.py
  1. Vai abrir o navegador automaticamente!
    (Você verá a lojinha de Açaí funcionando 💜)

📋 O que esse exemplo ensina:

  • Conexão SQLite
  • Interface web amigável
  • Escolha de produtos e adicionais
  • Registro de pedidos
  • Feedback visual para o usuário
  • Listagem dos últimos pedidos feitos
PDS e Metodologias Ágeis
Levantamento de Requisitos

Este trabalho simula o dialogo entre um vendedor e um programador.

🟣 Entrevista 1 — Primeira Reunião (Levantamento Inicial)

CLIENTE:
Oi, tudo bem? Então… eu queria fazer um site pra minha loja de açaí, sabe? Um site bonito, que apareça as fotos dos potes bem cheios, com aquelas coberturas caindo assim…

Programador:
Oi, tudo ótimo! Ah, entendi, você quer um site que destaque bem as imagens dos seus produtos, certo?

CLIENTE:
Isso! E queria também que desse pra pessoa montar o açaí dela… tipo, ela escolhe o tamanho, os adicionais, põe leite condensado, paçoca… essas coisas.

Programador:
Entendi. Então seriam dois tipos de venda: produtos prontos (como um açaí tradicional 500ml) e o cliente montando o seu próprio açaí.

CLIENTE:
Exatamente! E sabe o que seria legal? Se tivesse música tocando no site!

Programador:
(risos) Música? Podemos pensar em colocar, mas talvez isso atrapalhe um pouco a navegação, sabe?
Você quer focar em vender ou fazer algo mais descontraído?

CLIENTE:
Ah, é… melhor vender né? Então esquece a música!

Programador:
Certo! Sobre os pedidos: como você quer receber? O cliente paga no site ou paga na hora?

CLIENTE:
Olha, ainda tô começando… queria que ele só mandasse o pedido. Daí eu confirmo no WhatsApp e combino o pagamento.

Programador:
Ok, pedido sem pagamento online. E você quer controlar o estoque também?

CLIENTE:
Estoque? Ah… seria bom saber quando tá acabando leite condensado, paçoca… Mas não precisa ser complicado, não. Se não der, deixa pra depois.

Programador:
Tudo bem, vou anotar como “controle simples de estoque” pra uma segunda fase.

CLIENTE:
Isso!


🟣 Entrevista 2 — Definindo o Básico (com mais detalhes)

Programador:
Oi, voltei! Organizei algumas ideias pra gente confirmar.

CLIENTE:
Ótimo! Vamos ver!

Programador:
Sobre os produtos: você quer cadastrar o nome do açaí, o preço, o tamanho (ex: 300ml, 500ml) e colocar uma foto. Correto?

CLIENTE:
Certo. Mas às vezes eu quero fazer promoções! Tipo, “Compre um de 500ml e ganhe uma granola grátis.”

Programador:
Entendi. Promoções podem ser configuradas também, mas talvez num segundo momento, combinado?

CLIENTE:
Tá bom! Primeiro vamos focar no básico.

Programador:
Sobre os adicionais: vamos ter uma listinha? Tipo: Banana, Paçoca, Leite condensado… cada um com um preço.

CLIENTE:
Sim! E às vezes eu queria dar adicionais grátis em dias especiais, tipo “sexta-feira da banana grátis”.

Programador:
Ok, posso deixar espaço para adicionar promoções depois. No momento, vamos focar no cliente escolher os adicionais e adicionar ao pedido.

CLIENTE:
Perfeito.

Programador:
Agora: o pedido.
O cliente seleciona o produto, escolhe os adicionais e informa o nome e telefone para contato, certo?

CLIENTE:
Isso! E o bairro também, né? Vai que eu começo a entregar…

Programador:
Boa ideia. Vamos incluir campo para Bairro também.

CLIENTE:
Ah, e se a pessoa quiser pedir dois açaís diferentes no mesmo pedido?

Programador:
Ótimo ponto. Então vamos deixar o carrinho com possibilidade de adicionar mais de um produto.


🟣 Entrevista 3 — Confirmando Tudo (com cliente viajando um pouco)

Programador:
Oi, tudo certo? Vim só pra validar antes de começar!

CLIENTE:
Opa! Tô animado!

Programador:
Então vamos lá:
No site, o cliente vai poder:

  • Ver a lista de produtos
  • Ver os adicionais
  • Escolher o produto e o tamanho
  • Escolher adicionais
  • Adicionar ao carrinho
  • Informar nome, telefone e bairro
  • Confirmar pedido
  • E o pedido vai pro seu WhatsApp.

CLIENTE:
Show! E se der, eu queria que o site piscasse alguma coisa, tipo uma estrela, quando a pessoa confirmasse o pedido!

Programador:
(risos) Vamos fazer uma mensagem de “Pedido enviado com sucesso”, pode ser?

CLIENTE:
Tá ótimo! Estrela piscando era bobagem minha, esquece!

Programador:
Beleza. Sobre o controle dos produtos: você vai conseguir acessar um painel pra:

  • Cadastrar novo açaí
  • Alterar preço
  • Cadastrar novos adicionais
  • Alterar fotos

CLIENTE:
Ahhh, legal! Quero também poder desativar um produto, tipo “acabou”, sem apagar tudo.

Programador:
Perfeito, vou colocar a opção de deixar um produto inativo.

CLIENTE:
E se eu mudar de ideia e quiser cobrar o pedido online?

Programador:
A gente consegue adicionar depois. Por enquanto vamos deixar como “pedido via WhatsApp” mesmo.

CLIENTE:
Combinado!

pt_BRPortuguese