João tem 16 anos e está no 2º ano do ensino médio. Todo mês, ele recebe uma mesada de R$ 450,00 que usa para pagar algumas despesas do dia a dia.
Em abril, João anotou seus gastos:
Transporte escolar: ele gasta R$ 6,00 por dia com ônibus. Como o mês teve 20 dias de aula, foram R$ 120,00.
Internet em casa: contribui com R$ 70,00.
Alimentação na cantina: costuma gastar em média R$ 10,00 por dia na escola. Em 20 dias, gastou R$ 200,00.
Cinema e lazer: no mês, saiu duas vezes com os amigos, gastando R$ 60,00.
Material escolar: comprou um caderno novo e algumas canetas, gastando R$ 40,00.
João percebeu que o dinheiro quase não sobra no final do mês e começou a se preocupar, porque ele tem um objetivo: comprar um videogame que custa R$ 1.800,00. Ele gostaria de alcançar essa meta em 12 meses.
Agora João precisa organizar suas finanças para descobrir:
Quais são seus gastos fixos e quais são seus gastos variáveis.
Quanto ele recebeu e quanto gastou em abril.
Quanto sobrou ou faltou no mês.
Se for possível guardar R$ 150,00 por mês, em quanto tempo conseguirá comprar o videogame.
Como montar um plano de ação usando a técnica 5W2H para alcançar sua meta.
✍️ Atividades
How much (quanto custa):
Controle Financeiro
Classifique os gastos do João em fixos e variáveis.
Calcule a receita total, o total de gastos e quanto sobra ou falta.
Reconhecendo os Pontos
Qual foi o gasto mais alto de João?
Em quais despesas ele poderia economizar?
Se ele guardar R$ 150,00 por mês, em quanto tempo conseguirá comprar o videogame de R$ 1.800,00?
Plano de Ação (5W2H)
Monte o plano de ação para que João alcance seu objetivo.
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:
Importa o pandas.
Usa pd.read_csv() para ler o arquivo chamado listagem.csv.
Guarda os dados no DataFrame df.
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:
Lê o listagem.csv no DataFrame df.
Mostra o conteúdo completo.
Varre linha por linha do DataFrame.
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:
Lê o CSV no DataFrame.
Pede ao usuário a idade mínima e máxima.
Usa um filtro lógico para selecionar apenas quem está entre os dois valores.
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.
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.
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
O engenheiro desenha em CAD (3D).
O software CAM (fatiador, slicer, etc.) gera o G-code.
O G-code é enviado para a máquina CNC.
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:
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.
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:
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?
O Python cria um novo arquivo chamado cilindro.gcode na pasta onde o script está rodando.
Escreve dentro dele a linha: G21 ; usar milimetros
Fecha o arquivo automaticamente (porque usamos with).
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.
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.
Sem install, você pode copiar manualmente e carregar no boot:
sudo mkdir -p /lib/modules/$(uname -r)/extra
sudo cp ./ch34x.ko /lib/modules/$(uname -r)/extra/
sudo depmod -a
echo ch34x | sudo tee /etc/modules-load.d/ch34x.conf
Com DKMS (se suportado pelo repo), o módulo recompila após updates de kernel. Este projeto não traz dkms.conf oficial; dá para criar um, mas mantendo simples, o passo acima resolve.
Compatibilidade
Não é compatível com a placa Olimex ESP32-POE rev C.
Solução de Problemas
A) dmesg não mostra ttyUSB*, apenas:
usbserial: USB Serial support registered for ch34x
ch34x 3-2:1.0: ch34x converter detected
Possíveis causas e correções:
Dependências ausentes (compilação incompleta)
Refaça os passos 1 e 3, garantindo build-essential e linux-headers-$(uname -r) instalados.
Conflito de hardware (protoboard)
Se o Arduino está ligado a uma protoboard com jumpers, desconecte os fios (curto/conexão indevida pode impedir a enumeração correta). Conecte apenas via USB, teste novamente.
Cabeçalhos do kernel faltando
Instale linux-headers-$(uname -r) e recompile: sudo apt install -y linux-headers-$(uname -r) make clean && make
Secure Boot bloqueando o módulo
Assine o módulo (Seção 4) e recarregue: sudo make unload sudo kmodsign sha512 /var/lib/shim-signed/mok/MOK.priv /var/lib/shim-signed/mok/MOK.der ./ch34x.ko sudo make load
Kernel sem CONFIG_USB_SERIAL_CH341 (desativado/ausente)
Verifique a config do kernel: zcat /proc/config.gz | grep CH341 # ou grep CH341 /boot/config-$(uname -r)
Se estiver desabilitado, o módulo externo ch34x.ko deve suprir. Se ainda assim não carregar, revise mensagens do dmesg e confirme a versão do kernel/headers.
Permissões/Regra udev
Adicione seu usuário ao grupo dialout e reconecte: sudo usermod -aG dialout $USER sudo reboot
Depois do reboot, teste novamente ls -l /dev/ttyUSB*.
Nota o Fresco Logic FL200/FL2000DX VGA/DVI/HDMI Adapter não funciona com este procedimento.
É possível instalar um monitor adicional no linux, usando um adaptador USB/VGA conforme o da foto.
O DisplayLink permite utilizar monitores adicionais através de conexões USB em docks, adaptadores e monitores compatíveis. No Ubuntu, há duas formas de instalar o driver:
Repositório APT da Synaptics (recomendado, pois permite atualizações automáticas junto com o sistema).
Instalador Standalone (instalação manual).
O procedimento abaixo descreve como instalar em uma maquina linux ubuntu.
✅ Método 1: Instalação via Repositório APT da Synaptics (Recomendado)
Esse método facilita atualizações e integração com o sistema.
Passo 1 – Baixar o pacote do repositório
Faça o download do pacote synaptics-repository-keyring.deb no site oficial da Synaptics.
Este projeto propõe o desenvolvimento de um chatbot inteligente voltado para dúvidas sobre processos e procedimentos, utilizando exclusivamente um banco de dados relacional (MySQL) como fonte principal de consulta, sem uso de bancos vetoriais como ChromaDB. O sistema será capaz de pesquisar documentos, apresentar respostas, registrar feedback dos usuários e, em caso de respostas insuficientes, recorrer à API do ChatGPT como fallback.
2. Objetivos
Automatizar o atendimento a dúvidas sobre processos e procedimentos documentados.
Permitir atualização automática diária do conhecimento do chatbot com novos documentos.
Garantir precisão e cobertura das respostas, recorrendo ao ChatGPT em caso de dúvidas não solucionadas localmente.
Permitir avaliação do usuário e contínua evolução do sistema.
3. Arquitetura e Frameworks Utilizados
3.1 Principais Frameworks e Bibliotecas
Python 3.9+: Linguagem principal do sistema.
MySQL: Banco relacional para armazenar documentos, textos extraídos, logs, feedback e metadados.
mysql-connector-python ou SQLAlchemy: Conexão e manipulação do MySQL em Python.
pdfminer.six: Extração de texto de PDFs.
python-docx: Extração de texto de arquivos Word.
OpenAI (API): Integração com ChatGPT para fallback.
Unstructured (opcional): Para leitura flexível de múltiplos formatos.
Streamlit ou Flask (opcional): Interface web para interação com usuário e avaliação de respostas.
Agendador de tarefas (cron, Task Scheduler): Para automação da ingestão e atualização diária de documentos.
4. Metodologias Utilizadas
Busca textual clássica (SQL): As perguntas dos usuários são tratadas como consultas de texto, usando buscas por palavra-chave (LIKE, FULLTEXT).
Fallback Inteligente: Caso nenhuma resposta relevante seja localizada no MySQL, a pergunta é repassada ao ChatGPT via API.
Ciclo de Aprendizagem Contínua: Feedback do usuário para identificar perguntas mal respondidas e melhorar a base.
Automação de atualização diária: Script agendado para processar novos documentos e atualizar o banco de dados.
5. Etapas do Projeto
5.1 Planejamento e Levantamento de Requisitos
Definição dos tipos de documentos a serem processados (PDF, DOCX, TXT).
Estruturação das pastas: /docs_novos/ para documentos a indexar, /docs_indexados/ para documentos já processados.
Estruturação do banco MySQL: tabelas para documentos, logs, feedback, usuários.
5.2 Ambiente e Infraestrutura
Instalação do Python e bibliotecas necessárias.
Instalação e configuração do MySQL Server.
Criação do banco de dados e tabelas.
5.3 Processamento e Indexação de Documentos
Extração de texto de PDFs e Word usando pdfminer.six e python-docx.
Inserção dos textos extraídos na tabela de documentos do MySQL, com campos como: ID, nome do arquivo, texto, data, usuário, etc.
5.4 Desenvolvimento do Chatbot
Recebimento da pergunta do usuário via interface CLI, Web ou API.
Consulta ao MySQL utilizando SQL FULLTEXT SEARCH (ou LIKE) para encontrar o(s) documento(s) mais relevante(s).
Exibição da resposta ao usuário.
Caso a resposta seja vazia ou não satisfatória, consulta à API do ChatGPT.
Registro da interação e da avaliação do usuário.
5.5 Automatização da Atualização Diária
Script automatizado, agendado, para processar novos documentos diariamente:
Extração do texto.
Inserção no banco de dados.
Movimentação dos arquivos para pasta de processados.
5.6 Interface com o Usuário e Feedback
(Opcional) Interface web para consulta e avaliação das respostas.
Registro do feedback do usuário em tabela específica para análise futura.
5.7 Testes e Validação
Testes unitários dos scripts de processamento.
Testes de busca e precisão de respostas.
Testes de fallback e integração com ChatGPT.
5.8 Documentação e Treinamento
Documentação detalhada do sistema, scripts e uso.
Treinamento dos usuários e administradores do sistema.
6. Considerações Técnicas
6.1 Limitações da Busca no MySQL
Busca por palavra-chave: O MySQL não realiza buscas semânticas, ou seja, depende da correspondência exata ou parcial das palavras da pergunta com o texto dos documentos.
Alternativa: É possível usar o recurso FULLTEXT do MySQL para buscas em campos grandes (LONGTEXT), mas não substitui a busca vetorial.
Melhoria futura: Caso necessário, pode-se integrar futuramente um banco vetorial para busca semântica avançada.
7. Estrutura Sugerida de Tabelas MySQL
sqlCopiarEditarCREATE TABLE documentos (
id INT AUTO_INCREMENT PRIMARY KEY,
nome_arquivo VARCHAR(255),
texto LONGTEXT,
data_upload DATETIME,
usuario VARCHAR(100)
);
CREATE TABLE interacoes (
id INT AUTO_INCREMENT PRIMARY KEY,
id_documento INT,
pergunta TEXT,
resposta TEXT,
foi_fallback BOOLEAN,
data DATETIME,
FOREIGN KEY (id_documento) REFERENCES documentos(id)
);
CREATE TABLE feedback (
id INT AUTO_INCREMENT PRIMARY KEY,
id_interacao INT,
avaliacao ENUM('boa','ruim'),
comentario TEXT,
data DATETIME,
FOREIGN KEY (id_interacao) REFERENCES interacoes(id)
);
8. Resumo dos Frameworks e Bibliotecas
Framework/Biblioteca
Função
Python 3.9+
Linguagem principal
MySQL
Banco relacional, principal repositório
mysql-connector-python
Conexão Python-MySQL
pdfminer.six
Ler PDF
python-docx
Ler Word
OpenAI (API)
ChatGPT (fallback)
Unstructured
Ler múltiplos formatos (opcional)
Streamlit/Flask (opcional)
Interface web
9. Metodologias
Busca textual clássica (FULLTEXT/LIKE)
Fallback Inteligente
Aprendizagem Contínua (feedback)
Automação de ingestão de dados
10. Considerações Finais
O projeto propõe uma solução prática, fácil de gerenciar e com requisitos tecnológicos acessíveis, usando o MySQL como núcleo do sistema. Garante automatização da base de conhecimento, integração com IA de ponta (ChatGPT), avaliação do usuário e flexibilidade para futuras expansões.
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=ILEDVfonte−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:
Revisar física básica: tensão, corrente e resistência.
Aprender a Lei de Ohm: com exemplos simples e analogias.
Programar em Python: criar o cálculo automático do resistor.
Montar o circuito: usar LED, bateria e resistores em protoboard.
Testar valores diferentes: ver o LED acender, ficar fraco ou queimar.
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:
Consultar a tabela de cores para escolher o resistor adequado.
Conferir com o multímetro se o valor está correto.
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=ILEDVfonte−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.
class LancadorDeDados: def init(self, nro_lancamentos): self.nro_lancamentos = nro_lancamentos self.nro_ocorrencias = 6 # dado com 6 faces
def calculaPercentual(self): """Calcula o percentual usando a fórmula: (1/nro_ocorrencias)^nro_lancamentos.""" return (1 / self.nro_ocorrencias) ** self.nro_lancamentos * 100
def mostrar_percentual(self): """Mostra o resultado do cálculo.""" percentual = self.calculaPercentual() print(f"Lançamentos: {self.nro_lancamentos} → Percentual: {percentual:.4f}%")
==========================
Programa principal no Colab
==========================
for n in range(1, 6): # Calcula de 1 até 5 lançamentos consecutivos dado = LancadorDeDados(nro_lancamentos=n) dado.mostrar_percentual()
🎲 Probabilidade de Lançamentos Consecutivos de um Dado
Este programa calcula a probabilidade percentual de ocorrer uma sequência específica de resultados ao lançar um dado de 6 faces diversas vezes de forma consecutiva.
Ele utiliza a fórmula de probabilidade para eventos independentes:
Cada lançamento de um dado justo de 6 faces possui probabilidade igual de 1/6 para cada face.
Como os lançamentos são eventos independentes, a chance de obter o mesmo resultado consecutivamente é dada pela multiplicação das probabilidades.
Para transformar isso em percentual, multiplicamos o resultado por 100.
Exemplos:
1 lançamento:
P = (1 / 6) × 100 ≈ 16,67%
2 lançamentos consecutivos iguais:
P = (1 / 6)² × 100 ≈ 2,78%
3 lançamentos consecutivos iguais:
P = (1 / 6)³ × 100 ≈ 0,46%
🖥️ O que o programa faz
Define uma classe chamada LancadorDeDados.
Recebe como parâmetro o número de lançamentos consecutivos que será analisado.
Aplica a fórmula de probabilidade usando o número de faces do dado (6) e a quantidade de lançamentos informada.
Exibe o resultado em percentual.
📌 Saída esperada
O programa mostra o percentual de chance para cada quantidade de lançamentos consecutivos:
Testando o resultado
Neste programa testaremos se o resultado apresentado, condiz com a prática.
A idéia é lançar o dado muitas vezes e acompanhar as estatísticas de seu lançamento.
class LancadorDeDados:
def init(self):
self.resultados = [] # Lista para armazenar os lançamentos
def registrar_lancamento(self, valor):
"""Registra o valor digitado pelo usuário."""
if 1 <= valor <= 6:
self.resultados.append(valor)
else:
print("⚠️ Valor inválido! Digite apenas números de 1 a 6.")
def calculaPercentual(self, ocorrencias, total):
"""Calcula o percentual de ocorrência."""
return (ocorrencias / total) * 100 if total > 0 else 0
def mostrar_estatistica(self):
"""Exibe a estatística atualizada após cada lançamento."""
total = len(self.resultados)
print(f"\n📊 Estatística após {total} lançamentos:")
for face in range(1, 7):
ocorrencias = self.resultados.count(face)
percentual = self.calculaPercentual(ocorrencias, total)
print(f"Face {face}: {ocorrencias} ocorrências ({percentual:.2f}%)")
def mostrar_relatorio_final(self):
"""Exibe o relatório final consolidado."""
print("\n✅ Relatório Final:")
self.mostrar_estatistica()
==========================
Programa principal no Colab
==========================
dado = LancadorDeDados()
print("🎲 Digite os valores obtidos no lançamento do dado (1 a 6).")
print("Digite 0 para encerrar.\n")
while True:
valor = int(input("Digite o valor do dado (1 a 6) ou 0 para sair: "))
if valor == 0:
break
dado.registrar_lancamento(valor)
dado.mostrar_estatistica()
Relatório final consolidado
dado.mostrar_relatorio_final()
🎲 Programa de Estatística de Lançamentos de Dado
Este programa permite registrar manualmente os resultados de lançamentos de um dado e calcular a estatística de frequência e percentual de cada face (1 a 6) em tempo real. O programa segue um loop contínuo onde o usuário digita o valor obtido em cada lançamento, e ao digitar 0 o sistema encerra e apresenta o relatório final consolidado.
🧠 Conceito
A estatística apresentada pelo programa é baseada na frequência relativa de cada face, calculada como:
Percentual da Face = (Número de ocorrências da face / Total de lançamentos) × 100
Isso permite observar a distribuição das faces e como ela evolui à medida que mais lançamentos são registrados.
🖥️ Funcionalidades
O programa é estruturado com a classe LancadorDeDados.
Permite entradas manuais dos resultados dos lançamentos do dado.
A cada número digitado, a estatística de todas as faces (1 a 6) é atualizada e exibida.
O programa continua recebendo valores até que o usuário digite 0.
Ao encerrar, é exibido um relatório final consolidado.
🔑 Métodos da Classe
__init__(self)
Inicializa a lista self.resultados para armazenar os lançamentos.
registrar_lancamento(self, valor)
Registra o valor digitado pelo usuário (de 1 a 6).
Ignora e alerta se o valor for inválido.
calculaPercentual(self, ocorrencias, total)
Calcula o percentual de ocorrências de uma face específica em relação ao total de lançamentos.
mostrar_estatistica(self)
Mostra a estatística atualizada (ocorrências e percentuais) após cada lançamento digitado.
mostrar_relatorio_final(self)
Exibe o relatório final consolidado com os resultados e percentuais finais de todas as faces.
🎯 Tarefa: Aplicando Estatística com Lançamentos de Dado
Objetivo:
Utilizar o programa de estatística de lançamentos de dado para registrar resultados reais e comparar com os valores teóricos de probabilidade, entendendo como a frequência relativa se aproxima da probabilidade real à medida que aumentamos o número de lançamentos.
📝 Instruções:
Acesse e execute o programa no Google Colab que registra os lançamentos de um dado e calcula as estatísticas.
Simule lançamentos reais:
Use um dado físico (se disponível) ou um simulador online.
Digite no programa o resultado de cada lançamento.
Continue lançando até atingir diferentes tamanhos de amostra:
10 lançamentos
30 lançamentos
50 lançamentos
100 lançamentos
Observe como os percentuais calculados pelo programa se aproximam dos valores teóricos (aproximadamente 16,67% para cada face).
Finalize digitando “0” para encerrar e visualizar o relatório final consolidado.
🔎 Reflexão:
Compare os resultados obtidos para amostras pequenas (10 ou 30 lançamentos) com os resultados para amostras grandes (50 ou 100 lançamentos).
Responda:
Quanto maior o número de lançamentos, os percentuais ficaram mais próximos do valor esperado (16,67%)?
Por que isso acontece?
📌 Conclusão Esperada:
Os alunos devem perceber que:
Com poucos lançamentos, a distribuição é mais irregular e os percentuais variam bastante.
Com mais lançamentos (maior amostra), os percentuais tendem a se estabilizar e se aproximar dos valores teóricos de probabilidade.
Isso demonstra, na prática, a Lei dos Grandes Números, um princípio fundamental da estatística e probabilidade.
Portuguese 
English