Python from Basics to Machine Learning: 100

Practical Scripts
Autor: K

13 de junho de 2025

Sumário
Introdução

Parte 1: Fundamentos do Python (1–30)

Variáveis, Tipos de Dados e Operações (1–10)

Funções e Módulos (11–20)

Estruturas de Dados e Manipulação de Arquivos (21–30)

Parte 2: Python Intermediário (31–60)

Orientação a Objetos (31–40)

Erros, Exceções e Testes (41–50)

Bibliotecas e Ferramentas Populares (51–60)

Parte 3: Introdução ao Machine Learning (61–100)

Conceitos Básicos e Scikit-learn (61–75)

Projetos Práticos (76–90)

Extras e Deploy (91–100)

Introdução
Bem-vindo ao Python from Basics to Machine Learning: 100 Practical Scripts! Este livro, escrito por K,
é para quem quer aprender Python do zero até criar modelos de machine learning. Cada script traz um
conceito explicado de forma simples, um exemplo prático e dicas para consolidar o aprendizado.
Vamos começar?

Script 1: Imprimir 'Olá, Mundo!'

A função print() exibe texto ou valores no console. É o ponto de partida para qualquer programador em
Python.
# Exibe uma mensagem no console
print("Olá, Mundo!")
Key Takeaways:
- Use print() para mostrar texto
- Texto deve estar entre aspas
- Experimente: mude a mensagem!

Script 2: Variáveis e Tipos de Dados

Variáveis armazenam dados, como números ou textos. Python detecta automaticamente o tipo de
dado (ex.: int, str).
# Cria variáveis
nome = "Ana" # String
idade = 25 # Inteiro
altura = 1.65 # Float

# Exibe valores e tipos

print(f"Nome: {nome}, Tipo: {type(nome)}")
print(f"Idade: {idade}, Tipo: {type(idade)}")
print(f"Altura: {altura}, Tipo: {type(altura)}")
Key Takeaways:
- Variáveis não precisam de declaração de tipo
- Use type() para verificar o tipo
- Experimente: crie uma variável booleana

Script 3: Operações Aritméticas

Python suporta operações como soma, subtração, multiplicação e divisão, usando operadores como +,
-, * e /.
# Operações aritméticas
a = 10
b = 3

soma = a + b
divisao = a / b
inteiro = a // b
resto = a % b
 print(f"Soma: {soma}")
print(f"Divisão: {divisao:.2f}")
print(f"Divisão inteira: {inteiro}")
print(f"Resto: {resto}")
Key Takeaways:
- Use // para divisão inteira e % para resto.
- Formate números com :.2f.
- Experimente: calcule a potência de a.

Script 4: Condicional if/else

As estruturas if, elif e else controlam o fluxo do programa com base em condições.
# Verifica idade
idade = 20

if idade >= 18:

print("Maior de idade")
elif idade >= 13:
print("Adolescente")
else:
print("Criança")
Key Takeaways:
- Use if para testar condições.
- elif verifica condições adicionais.
- Experimente: adicione outra condição.

Script 5: Laços com for

O laço for itera sobre sequências, como listas ou intervalos, executando um bloco de código
repetidamente.
# Itera sobre um intervalo
for i in range(5):
print(f"Contagem: {i}")

# Itera sobre uma lista

frutas = ["maçã", "banana", "laranja"]
for fruta in frutas:
print(f"Fruta: {fruta}")
Key Takeaways:
- Use range(n) para números de 0 a n-1.
- Itere diretamente sobre listas.
- Experimente: imprima apenas números pares.

Script 6: Laços com while

O laço while repete um bloco de código enquanto uma condição for verdadeira. Cuidado com loops
infinitos!
 # Conta até 5
contador = 1
while contador <= 5:
print(f"Contador: {contador}")
contador += 1
Key Takeaways:
- Incremente variáveis para evitar loops infinitos.
- Use break para sair do laço.
- Experimente: adicione uma condição de parada.

Script 7: Listas
Listas são coleções ordenadas e mutáveis de itens. Você pode adicionar, remover ou modificar
elementos.
# Cria uma lista
numeros = [1, 2, 3]

# Adiciona elemento
numeros.append(4)

# Remove elemento
numeros.remove(2)

# Acessa elemento
print(f"Primeiro: {numeros[0]}")
print(f"Lista: {numeros}")
Key Takeaways:
- Use append() para adicionar e remove() para remover.
- Acesse elementos com índices (ex.: [0]).
- Experimente: ordene a lista com sort().

Script 8: Dicionários
Dicionários armazenam pares chave-valor, permitindo acesso rápido a dados associados a chaves
únicas.
# Cria um dicionário
pessoa = {"nome": "João", "idade": 30}

# Acessa valor
print(f"Nome: {pessoa['nome']}")

# Adiciona chave-valor
pessoa["cidade"] = "São Paulo"

# Itera sobre chaves

for chave, valor in pessoa.items():
print(f"{chave}: {valor}")
Key Takeaways:
- Use items() para iterar sobre chaves e valores.
- Acesse valores com dicionario['chave'].
- Experimente: remova uma chave com pop().

Script 9: Tuplas
Tuplas são coleções ordenadas e imutáveis, úteis para dados que não devem mudar.
# Cria uma tupla
coordenadas = (10, 20)

# Acessa elementos
print(f"X: {coordenadas[0]}")

# Tuplas são imutáveis

try:
coordenadas[0] = 5
except TypeError:
print("Tuplas não podem ser modificadas!")
Key Takeaways:
- Tuplas usam parênteses ().
- São imutáveis, diferente de listas.
- Experimente: crie uma tupla com strings.

Script 10: Conjuntos

Conjuntos (set) armazenam elementos únicos, sem ordem, e suportam operações como união e
interseção.
# Cria conjuntos
a = {1, 2, 3}
b = {2, 3, 4}

# Operações
uniao = a | b
intersecao = a & b

print(f"União: {uniao}")
print(f"Interseção: {intersecao}")
Key Takeaways:
- Conjuntos eliminam duplicatas automaticamente.
- Use | para união e & para interseção.
- Experimente: adicione elementos com add().

Script 11: Definir Funções

Funções são blocos de código reutilizáveis que executam uma tarefa específica, definidas com def.
# Define uma função
def saudacao(nome):
return f"Olá, {nome}!"
 # Chama a função
print(saudacao("Ana"))
print(saudacao("João"))
Key Takeaways:
- Use def nome(): para criar funções.
- Retorne valores com return.
- Experimente: adicione um parâmetro opcional.

Script 12: Parâmetros Padrão

Parâmetros padrão permitem definir valores default para argumentos de funções, tornando-os
opcionais.
# Função com parâmetro padrão
def cumprimentar(nome, saudacao="Olá"):
return f"{saudacao}, {nome}!"

# Chama a função
print(cumprimentar("Ana"))
print(cumprimentar("João", "Oi"))
Key Takeaways:
- Defina parâmetros padrão com nome=valor.
- Parâmetros padrão são usados se não forem especificados.
- Experimente: crie uma função com dois parâmetros padrão.

Script 13: Funções com *args

*args permite que uma função aceite um número variável de argumentos posicionais, como uma tupla.
# Função com argumentos variáveis
def somar(*args):
return sum(args)

# Chama a função
print(somar(1, 2))
print(somar(1, 2, 3, 4))
Key Takeaways:
- Use *args para argumentos variáveis.
- args é uma tupla.
- Experimente: crie uma função que multiplica *args.

Script 14: Funções com **kwargs

**kwargs permite passar argumentos nomeados variáveis para uma função, como um dicionário.
# Função com argumentos nomeados
def descrever(**kwargs):
for chave, valor in kwargs.items():
print(f"{chave}: {valor}")
# Chama a função
 descrever(nome="Ana", idade=25)
descrever(cidade="São Paulo", profissao="Engenheira")
Key Takeaways:
- Use **kwargs para argumentos nomeados.
- kwargs é um dicionário.
- Experimente: combine args e *kwargs.

Script 15: Funções Lambda

Funções lambda são funções anônimas de uma linha, úteis para operações simples ou como
argumentos de outras funções.
# Função lambda para dobrar
dobrar = lambda x: x * 2
print(dobrar(5))

# Usar lambda com map

numeros = [1, 2, 3]
quadrados = list(map(lambda x: x ** 2, numeros))
print(quadrados)
Key Takeaways:
- Sintaxe: lambda argumentos: expressão.
- Ideal para funções curtas.
- Experimente: use lambda com filter().

Script 16: Módulo math

O módulo math fornece funções matemáticas, como raiz quadrada, seno e constante pi.
import math

# Usa funções do math

print(f"Raiz de 16: {math.sqrt(16)}")
print(f"Seno de 90°: {math.sin(math.radians(90)):.2f}")
print(f"Pi: {math.pi:.2f}")
Key Takeaways:
- Importe com import math.
- Use radians() para ângulos em radianos.
- Experimente: calcule o cosseno de 45°.

Script 17: Módulo random

O módulo random gera números aleatórios ou escolhe itens aleatoriamente de uma sequência.
import random

# Gera número aleatório

print(f"Número inteiro: {random.randint(1, 10)}")
print(f"Número float: {random.uniform(0, 1):.2f}")
# Escolhe item
 frutas = ["maçã", "banana", "laranja"]
print(f"Fruta aleatória: {random.choice(frutas)}")
Key Takeaways:
- Use randint(a, b) para inteiros.
- choice() seleciona um item.
- Experimente: embaralhe uma lista com shuffle().

Script 18: Criar Módulos

Módulos são arquivos Python que contêm funções ou classes, importados para reutilizar código.
# Arquivo: meu_modulo.py
def saudacao(nome):
return f"Olá, {nome}!"

# Arquivo principal
import meu_modulo

print(meu_modulo.saudacao("Ana"))
Key Takeaways:
- Crie módulos salvando funções em arquivos .py.
- Importe com import nome_modulo.
- Experimente: crie um módulo com duas funções.

Script 19: Importar Módulos Externos

Módulos externos, como requests, são instalados com pip e ampliam as funcionalidades do Python.
# Instale com: pip install requests
import requests

# Faz uma requisição

resposta = requests.get("https://api.github.com")
print(f"Status: {resposta.status_code}")
Key Takeaways:
- Use pip install para instalar pacotes.
- Importe como módulos nativos.
- Experimente: instale e use numpy.

Script 20: Organizar Código com Módulos

Organizar código em múltiplos módulos melhora a manutenção e legibilidade de projetos maiores.
# Arquivo: utilitarios.py
def calcular_media(numeros):
return sum(numeros) / len(numeros)

# Arquivo principal
from utilitarios import calcular_media
numeros = [10, 20, 30]
 print(f"Média: {calcular_media(numeros)}")
Key Takeaways:
- Divida código em módulos por funcionalidade.
- Use from modulo import função.
- Experimente: crie um módulo para cálculos matemáticos.

Script 21: Operações com Listas Aninhadas

Listas aninhadas são listas dentro de listas, úteis para representar matrizes ou dados hierárquicos.
# Cria uma lista aninhada (matriz 2x3)
matriz = [[1, 2, 3], [4, 5, 6]]

# Acessa elemento
print(matriz[0][1])

# Modifica elemento
matriz[1][2] = 7
print(matriz)

# Itera sobre a matriz

for linha in matriz:
for elemento in linha:
print(elemento, end=" ")
Key Takeaways:
- Use [i][j] para acessar elementos.
- Listas aninhadas são mutáveis.
- Experimente: crie uma matriz 3x3.

Script 22: Dicionários com Listas como Valores

Dicionários podem armazenar listas como valores, permitindo organizar dados complexos.
# Dicionário com listas
estoque = {
"frutas": ["maçã", "banana", "laranja"],
"vegetais": ["cenoura", "brócolis"]
}

# Acessa uma lista

print(estoque["frutas"])

# Adiciona item
estoque["frutas"].append("uva")
print(estoque)

# Itera
for categoria, itens in estoque.items():
print(f"{categoria}: {itens}")
Key Takeaways:
- Dicionários com listas agrupam dados.
- Acesse listas com dicionario[chave].
- Experimente: adicione uma nova categoria.

Script 23: Leitura e Escrita de Arquivos .txt

Python usa open() para ler e escrever arquivos de texto. O gerenciador with fecha automaticamente.
# Escreve em um arquivo
with open('exemplo.txt', 'w') as arquivo:
arquivo.write("Linha 1: Olá, mundo!
")
arquivo.write("Linha 2: Python é incrível.")

# Lê o arquivo
with open('exemplo.txt', 'r') as arquivo:
conteudo = arquivo.read()
print(conteudo)
Key Takeaways:
- Use with open(nome, modo).
- Modos: 'w' (escrever), 'r' (ler).
- Experimente: adicione mais linhas.

Script 24: Leitura e Escrita de Arquivos .csv

Arquivos CSV armazenam dados tabulares. O módulo csv facilita leitura e escrita.
import csv

# Escreve CSV
with open('dados.csv', 'w', newline='') as arquivo:
escritor = csv.writer(arquivo)
escritor.writerow(['Nome', 'Idade'])
escritor.writerow(['Ana', 25])
escritor.writerow(['João', 30])

# Lê CSV
with open('dados.csv', 'r') as arquivo:
leitor = csv.reader(arquivo)
for linha in leitor:
print(linha)
Key Takeaways:
- Use csv.writer e csv.reader.
- newline='' evita linhas em branco.
- Experimente: adicione mais linhas.

Script 25: Contagem de Palavras em um Arquivo

Contar palavras em um arquivo de texto é útil para análise de dados. Use split() para dividir o texto.
# Escreve texto
 with open('texto.txt', 'w') as arquivo:
arquivo.write("Python é incrível. Python é fácil de aprender.")

# Conta palavras
with open('texto.txt', 'r') as arquivo:
texto = arquivo.read()
palavras = texto.split()
contagem = len(palavras)
print(f"Número de palavras: {contagem}")
Key Takeaways:
- split() divide por espaços.
- Use len() para contar.
- Experimente: conte palavras únicas com set().

Script 26: Análise de Logs com Listas

Logs registram eventos. Analise logs filtrando linhas específicas, como erros, usando listas.
# Escreve log
with open('log.txt', 'w') as arquivo:
arquivo.write("INFO: Sistema iniciado
ERROR: Falha de conexão
INFO: Conexão restaurada")

# Analisa log
erros = []
with open('log.txt', 'r') as arquivo:
for linha in arquivo:
if "ERROR" in linha:
erros.append(linha.strip())
print(f"Erros encontrados: {erros}")
Key Takeaways:
- Use strip() para remover quebras de linha.
- Filtre com condições (ex.: 'ERROR' in linha).
- Experimente: conte linhas com 'INFO'.

Script 27: Trabalhar com Datas (datetime)

O módulo datetime manipula datas e horas, permitindo cálculos e formatação.
from datetime import datetime, timedelta

# Data atual
agora = datetime.now()
print(f"Data atual: {agora.strftime('%d/%m/%Y %H:%M')}")

# Calcula data futura

futuro = agora + timedelta(days=7)
print(f"Daqui a 7 dias: {futuro.strftime('%d/%m/%Y')}")
Key Takeaways:
- datetime.now() retorna data/hora atual.
- timedelta adiciona períodos.
- Experimente: calcule diferença entre datas.

Script 28: Manipulação de Arquivos JSON

JSON é um formato leve para dados estruturados. O módulo json converte dicionários em JSON e
vice-versa.
import json

# Cria dicionário
dados = {"nome": "Ana", "idade": 25, "cidade": "São Paulo"}

# Escreve JSON
with open('dados.json', 'w') as arquivo:
json.dump(dados, arquivo)

# Lê JSON
with open('dados.json', 'r') as arquivo:
dados_lidos = json.load(arquivo)
print(dados_lidos)
Key Takeaways:
- json.dump() escreve; json.load() lê.
- JSON é compatível com dicionários.
- Experimente: adicione mais dados.

Script 29: Serialização com pickle

O módulo pickle serializa objetos Python em arquivos binários, salvando estados complexos.
import pickle

# Cria lista
dados = [1, 2, 3, "teste"]

# Salva com pickle

with open('dados.pkl', 'wb') as arquivo:
pickle.dump(dados, arquivo)

# Carrega
with open('dados.pkl', 'rb') as arquivo:
dados_carregados = pickle.load(arquivo)
print(dados_carregados)
Key Takeaways:
- pickle.dump() salva; pickle.load() carrega.
- Use modos 'wb' e 'rb'.
- Experimente: salve um dicionário.
Script 30: Manipulação de Arquivos com with
O gerenciador with simplifica a manipulação de arquivos, fechando-os automaticamente.
# Escreve e lê com with
try:
with open('teste.txt', 'w') as arquivo:
arquivo.write("Teste com with")
with open('teste.txt', 'r') as arquivo:
conteudo = arquivo.read()
print(conteudo)
except FileNotFoundError:
print("Arquivo não encontrado!")
Key Takeaways:
- with fecha arquivos automaticamente.
- Combine com try/except.
- Experimente: use readlines().

Script 31: Criar uma Classe Simples

Classes definem objetos com atributos e métodos, base da programação orientada a objetos (OOP).
# Define uma classe
class Retangulo:
def _init_(self, largura, altura):
self.largura = largura
self.altura = altura

def area(self):
return self.largura * self.altura

# Cria objeto
ret = Retangulo(5, 3)
print(f"Área: {ret.area()}")
Key Takeaways:
- Use class Nome: e _init_.
- Métodos usam self.
- Experimente: adicione método para perímetro.

Script 32: Métodos de Instância e Atributos

Métodos de instância operam em objetos e acessam seus atributos, definidos em _init_.
# Classe com atributos
class Carro:
def _init_(self, marca, velocidade=0):
self.marca = marca
self.velocidade = velocidade

def acelerar(self, incremento):

self.velocidade += incremento
return f"{self.marca} a {self.velocidade} km/h"
 # Usa objeto
carro = Carro("Fiat")
print(carro.acelerar(50))
Key Takeaways:
- Métodos usam self para atributos.
- Atributos são definidos em _init_.
- Experimente: adicione método para frear.

Script 33: Herança

Herança permite que uma classe filha herde atributos e métodos de uma classe pai.
# Classe pai
class Veiculo:
def _init_(self, marca):
self.marca = marca

def mover(self):
return f"{self.marca} está se movendo."

# Classe filha
class Carro(Veiculo):
def buzinar(self):
return "Bi-bi!"

# Usa classe filha

carro = Carro("Toyota")
print(carro.mover())
print(carro.buzinar())
Key Takeaways:
- Herança: class Filha(Pai):.
- Classe filha herda métodos do pai.
- Experimente: crie uma classe Moto.

Script 34: Sobrescrita de Métodos

Classes filhas podem sobrescrever métodos do pai para alterar comportamento.
# Classe pai
class Animal:
def som(self):
return "Som genérico"

# Classe filha
class Cachorro(Animal):
def som(self):
return "Au au!"

# Usa classe
cachorro = Cachorro()
print(cachorro.som())
Key Takeaways:
- Sobrescreva com mesmo nome e parâmetros.
- Altera comportamento do método pai.
- Experimente: sobrescreva outro método.

Script 35: Métodos Estáticos

Métodos estáticos pertencem à classe, não a instâncias, usando @staticmethod.
# Classe com método estático
class Calculadora:
@staticmethod
def soma(a, b):
return a + b

# Usa sem objeto

print(Calculadora.soma(5, 3))
Key Takeaways:
- Use @staticmethod sem self.
- Métodos estáticos são como funções normais.
- Experimente: crie método para subtração.

Script 36: Métodos de Classe

Métodos de classe operam na classe, usando @classmethod e cls.
# Classe com método de classe
class Empresa:
nome = "TechCorp"

@classmethod
def info(cls):
return f"Empresa: {cls.nome}"

# Usa método
print(Empresa.info())
Key Takeaways:
- Use @classmethod e cls.
- Acessa atributos da classe.
- Experimente: modifique nome.

Script 37: Encapsulamento (Atributos Privados)

Encapsulamento protege atributos com (protegido) ou _ (privado).
# Classe com atributo privado
class Conta:
def _init_(self, saldo):
self.__saldo = saldo

def depositar(self, valor):

 self.__saldo += valor
return self.__saldo

def get_saldo(self):
return self.__saldo

# Usa classe
conta = Conta(100)
print(conta.depositar(50))
print(conta.get_saldo())
Key Takeaways:
- Use __nome para privados.
- Acesse via métodos (getters/setters).
- Experimente: acesse __saldo diretamente.

Script 38: Propriedades com @property

@property transforma métodos em atributos, com acesso simplificado.
# Classe com propriedade
class Circulo:
def _init_(self, raio):
self._raio = raio

@property
def area(self):
return 3.14 * self._raio ** 2

# Usa propriedade
circulo = Circulo(5)
print(circulo.area)
Key Takeaways:
- @property simula atributos.
- Use _nome para protegidos.
- Experimente: crie propriedade para diâmetro.

Script 39: Polimorfismo

Polimorfismo permite que classes diferentes implementem métodos com o mesmo nome.
# Classes com polimorfismo
class Gato:
def som(self):
return "Miau!"

class Cachorro:
def som(self):
return "Au au!"

# Usa polimorfismo
animais = [Gato(), Cachorro()]
 for animal in animais:
print(animal.som())
Key Takeaways:
- Polimorfismo usa métodos com mesmo nome.
- Flexível em loops.
- Experimente: adicione classe Pássaro.

Script 40: Sistema Bancário Simples

Combina classes, métodos e encapsulamento para criar um sistema bancário.
# Sistema bancário
class ContaBancaria:
def _init_(self, titular, saldo=0):
self.titular = titular
self.__saldo = saldo

def depositar(self, valor):

self.__saldo += valor
return f"Saldo: {self.__saldo}"

def sacar(self, valor):

if valor <= self.__saldo:
self.__saldo -= valor
return f"Saldo: {self.__saldo}"
return "Saldo insuficiente"

# Usa classe
conta = ContaBancaria("Ana")
print(conta.depositar(100))
print(conta.sacar(50))
Key Takeaways:
- Combine encapsulamento e métodos.
- Valide operações como saque.
- Experimente: adicione transferência.

Script 41: Tratamento de Exceções com try/except

O bloco try/except captura erros para evitar que o programa pare.
# Tratamento de divisão por zero
try:
numero = int(input("Digite um número: "))
resultado = 10 / numero
print(f"Resultado: {resultado}")
except ZeroDivisionError:
print("Erro: Divisão por zero!")
except ValueError:
print("Erro: Entrada inválida!")
Key Takeaways:
- Use try: e except: para erros.
- Especifique tipos de erro.
- Experimente: adicione outro except.

Script 42: Uso de else e finally em Exceções

else executa sem erros; finally executa sempre.
# Exemplo com else e finally
try:
numero = int(input("Digite um número: "))
resultado = 100 / numero
except ZeroDivisionError:
print("Erro: Divisão por zero!")
else:
print(f"Sucesso! Resultado: {resultado}")
finally:
print("Operação concluída.")
Key Takeaways:
- else: sem exceções.
- finally: sempre executa.
- Experimente: use finally em arquivo.

Script 43: Levantar Exceções com raise

raise gera exceções manualmente para validar condições.
# Valida idade
def definir_idade(idade):
if idade < 0:
raise ValueError("Idade não pode ser negativa!")
if idade > 150:
raise ValueError("Idade inválida!")
return f"Idade definida: {idade}"

# Testa função
try:
print(definir_idade(-5))
except ValueError as erro:
print(f"Erro: {erro}")
Key Takeaways:
- Use raise para erros personalizados.
- Combine com try/except.
- Experimente: valide um e-mail.

Script 44: Criar Exceções Personalizadas

Crie exceções personalizadas herdando de Exception.
# Exceção personalizada
class SaldoInsuficienteError(Exception):
 pass

# Classe de conta
class Conta:
def _init_(self, saldo):
self.saldo = saldo

def sacar(self, valor):

if valor > self.saldo:
raise SaldoInsuficienteError("Saldo insuficiente!")
self.saldo -= valor
return self.saldo

# Testa
conta = Conta(100)
try:
print(conta.sacar(150))
except SaldoInsuficienteError as erro:
print(f"Erro: {erro}")
Key Takeaways:
- Crie com class NomeErro(Exception):.
- Use raise para lançar.
- Experimente: crie exceção para entrada inválida.

Script 45: Introdução ao Módulo unittest

unittest cria testes automatizados para verificar código.
import unittest

# Função a testar
def soma(a, b):
return a + b

# Classe de teste
class TestSoma(unittest.TestCase):
def test_soma_positivos(self):
self.assertEqual(soma(2, 3), 5)

def test_soma_negativos(self):
self.assertEqual(soma(-1, -1), -2)

# Executa testes
if _name_ == '_main_':
unittest.main(argv=[''], exit=False)
Key Takeaways:
- Use unittest.TestCase.
- Métodos começam com test_.
- Experimente: teste números decimais.
Script 46: Testar Funções com unittest
Teste funções com casos válidos, inválidos e extremos usando unittest.
import unittest

# Função a testar
def dividir(a, b):
if b == 0:
raise ValueError("Divisão por zero!")
return a / b

# Classe de teste
class TestDividir(unittest.TestCase):
def test_divisao_normal(self):
self.assertEqual(dividir(10, 2), 5.0)

def test_divisao_por_zero(self):
with self.assertRaises(ValueError):
dividir(10, 0)

# Executa testes
if _name_ == '_main_':
unittest.main(argv=[''], exit=False)
Key Takeaways:
- Use assertRaises() para exceções.
- Teste casos normais e de erro.
- Experimente: teste números negativos.

Script 47: Testar Classes com unittest

Teste métodos e atributos de classes com unittest.
import unittest

# Classe a testar
class Conta:
def _init_(self, saldo):
self.saldo = saldo

def depositar(self, valor):

self.saldo += valor
return self.saldo

# Classe de teste
class TestConta(unittest.TestCase):
def setUp(self):
self.conta = Conta(100)

def test_depositar(self):
self.assertEqual(self.conta.depositar(50), 150)

def test_saldo_inicial(self):
 self.assertEqual(self.conta.saldo, 100)

# Executa testes
if _name_ == '_main_':
unittest.main(argv=[''], exit=False)
Key Takeaways:
- Use setUp() para configurar.
- Teste métodos e atributos.
- Experimente: teste método de saque.

Script 48: Cobertura de Código com coverage

coverage mede a porcentagem de código testada.
# calculadora.py
def soma(a, b):
return a + b

def subtrair(a, b):

return a - b

# test_calculadora.py
import unittest
from calculadora import soma

class TestCalculadora(unittest.TestCase):
def test_soma(self):
self.assertEqual(soma(2, 2), 4)

if _name_ == '_main_':
unittest.main(argv=[''], exit=False)

# Terminal:
# pip install coverage
# coverage run -m unittest test_calculadora.py
# coverage report
Key Takeaways:
- Instale com pip install coverage.
- Use coverage run e report.
- Experimente: teste subtrair.

Script 49: Debugging com pdb

pdb permite depurar código com breakpoints.
import pdb

# Função com erro

def calcular_media(numeros):
pdb.set_trace()
total = sum(numeros)
 media = total / len(numeros)
return media

# Testa
numeros = [10, 20, 30]
print(calcular_media(numeros))
Key Takeaways:
- Use pdb.set_trace() para pausar.
- Comandos: n, p, c, q.
- Experimente: depure uma função com erro.

Script 50: Logging em Python

logging registra eventos, como erros, em vez de print().
import logging

# Configura logging
logging.basicConfig(level=logging.INFO, filename='app.log', format='%(asctime)s - %(leve

# Usa logging
logging.info("Programa iniciado.")
try:
resultado = 10 / 0
except ZeroDivisionError:
logging.error("Divisão por zero!")
logging.info("Programa finalizado.")
Key Takeaways:
- Use logging.info(), logging.error().
- Configure com filename e format.
- Experimente: adicione logging a uma função.

Script 51: Introdução ao NumPy

NumPy é uma biblioteca para cálculos numéricos, ideal para arrays e operações matemáticas
eficientes.
import numpy as np

# Cria array
array = np.array([1, 2, 3, 4])

# Operações
print(f"Soma: {np.sum(array)}")
print(f"Média: {np.mean(array):.2f}")
print(f"Array ao quadrado: {array ** 2}")
Key Takeaways:
- Instale com pip install numpy
- Use np.array() para criar arrays
- Experimente: crie um array 2D
Script 52: Manipulação de Arrays com NumPy
NumPy permite redimensionar, fatiar e combinar arrays de forma eficiente.
import numpy as np

# Cria array 2D
matriz = np.array([[1, 2], [3, 4]])

# Fatiamento
print(f"Primeira linha: {matriz[0, :]}")

# Redimensiona
matriz_1d = matriz.reshape(4)
print(f"1D: {matriz_1d}")

# Concatena
array2 = np.array([[5, 6]])
matriz_concat = np.vstack((matriz, array2))
print(matriz_concat)
Key Takeaways:
- Use reshape() para mudar forma
- vstack() empilha verticalmente
- Experimente: use hstack()

Script 53: Introdução ao pandas

pandas é uma biblioteca para manipulação de dados tabulares, como DataFrames.
import pandas as pd

# Cria DataFrame
dados = {'Nome': ['Ana', 'João'], 'Idade': [25, 30]}
df = pd.DataFrame(dados)

# Exibe
print(df)

# Filtra
print(df[df['Idade'] > 25])
Key Takeaways:
- Instale com pip install pandas.
- DataFrames são como tabelas.
- Experimente: adicione uma coluna.

Script 54: Manipulação de DataFrames

DataFrames do pandas permitem filtrar, agrupar e combinar dados.
import pandas as pd
 # Cria DataFrame
df = pd.DataFrame({
'Nome': ['Ana', 'João', 'Maria'],
'Idade': [25, 30, 22],
'Cidade': ['SP', 'RJ', 'SP']
})

# Agrupa
grupo = df.groupby('Cidade')['Idade'].mean()
print(grupo)

# Adiciona coluna
df['Maioridade'] = df['Idade'] >= 18
print(df)
Key Takeaways:
- groupby() agrega dados.
- Adicione colunas com df['nova'].
- Experimente: filtre por cidade.

Script 55: Visualização com Matplotlib

Matplotlib cria gráficos, como linhas, dispersão e histogramas.
import matplotlib.pyplot as plt

# Dados
x = [1, 2, 3, 4]
y = [10, 20, 25, 30]

# Cria gráfico
plt.plot(x, y, marker='o')
plt.title("Gráfico Simples")
plt.xlabel("X")
plt.ylabel("Y")
plt.show()
Key Takeaways:
- Instale com pip install matplotlib.
- Use plt.plot() e plt.show().
- Experimente: crie um histograma.

Script 56: Gráficos com seaborn

seaborn é uma biblioteca de visualização baseada em Matplotlib, com gráficos mais estilizados.
import seaborn as sns
import pandas as pd

# Dados
dados = pd.DataFrame({
'Categoria': ['A', 'A', 'B', 'B'],
'Valor': [10, 20, 15, 25]
 })

# Gráfico
sns.barplot(x='Categoria', y='Valor', data=dados)
plt.title("Gráfico de Barras")
plt.show()
Key Takeaways:
- Instale com pip install seaborn.
- Integra com pandas.
- Experimente: crie um boxplot.

Script 57: Requisições HTTP com requests

A biblioteca requests faz requisições HTTP, como GET e POST.
import requests

# Requisição GET
resposta = requests.get('https://api.github.com')
print(f"Status: {resposta.status_code}")
print(f"JSON: {resposta.json()['current_user_url']}")
Key Takeaways:
- Instale com pip install requests.
- Use json() para respostas.
- Experimente: faça uma requisição POST.

Script 58: Web Scraping com BeautifulSoup

BeautifulSoup extrai dados de páginas HTML, útil para web scraping.
from bs4 import BeautifulSoup
import requests

# Requisição
url = 'https://example.com'
resposta = requests.get(url)
soup = BeautifulSoup(resposta.text, 'html.parser')

# Extrai título
titulo = soup.find('h1').text
print(f"Título: {titulo}")
Key Takeaways:
- Instale com pip install beautifulsoup4.
- Use find() ou find_all().
- Experimente: extraia links.

Script 59: Manipulação de Imagens com Pillow

Pillow é uma biblioteca para abrir, editar e salvar imagens.
 from PIL import Image

# Abre imagem
imagem = Image.open('exemplo.jpg')

# Redimensiona
imagem_redim = imagem.resize((100, 100))

# Salva
imagem_redim.save('exemplo_redim.jpg')
print("Imagem redimensionada salva!")
Key Takeaways:
- Instale com pip install Pillow.
- Use resize() e save().
- Experimente: aplique filtro.

Script 60: Automação com pyautogui

pyautogui automatiza cliques, teclas e movimentos do mouse.
import pyautogui
import time

# Configura pausa
pyautogui.PAUSE = 1

# Move mouse e clica

pyautogui.moveTo(100, 100)
pyautogui.click()

# Digita
pyautogui.write("Olá, mundo!")
pyautogui.press('enter')
Key Takeaways:
- Instale com pip install pyautogui.
- Use PAUSE para controle.
- Experimente: abra um aplicativo.

Script 61: O que é Machine Learning? (Comentado no Script)

Machine Learning (ML) é uma área da IA onde modelos aprendem padrões para prever ou decidir.
# Este script explica ML sem código executável

print("Este é um script introdutório sobre Machine Learning.")

Key Takeaways:
- ML usa dados para aprender.
- Tipos: supervisionado, não supervisionado.
- Experimente: pesquise um dataset.
Script 62: Introdução ao scikit-learn
scikit-learn é uma biblioteca para machine learning, com ferramentas para classificação, regressão e
mais.
from sklearn.linear_model import LinearRegression
import numpy as np

# Dados
X = np.array([[1], [2], [3], [4]])
y = np.array([2, 4, 6, 8])

# Treina modelo
modelo = LinearRegression()
modelo.fit(X, y)

# Prevê
print(f"Previsão para x=5: {modelo.predict([[5]])[0]:.2f}")
Key Takeaways:
- Instale com pip install scikit-learn.
- Use fit() e predict().
- Experimente: adicione mais dados.

Script 63: Regressão Linear com scikit-learn

Regressão linear prevê valores numéricos, ajustando uma reta aos dados.
from sklearn.linear_model import LinearRegression
from sklearn.datasets import make_regression

# Gera dados
X, y = make_regression(n_samples=100, n_features=1, noise=10, random_state=42)

# Treina modelo
modelo = LinearRegression()
modelo.fit(X, y)

# Prevê
print(f"Coeficiente: {modelo.coef_[0]:.2f}")
print(f"Intercepto: {modelo.intercept_:.2f}")
Key Takeaways:
- coef_ e intercept_ definem a reta.
- Use datasets sintéticos para testes.
- Experimente: visualize com Matplotlib.

Script 64: Classificação com Regressão Logística

Regressão logística classifica dados em categorias (ex.: sim/não).
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification
# Gera dados
 X, y = make_classification(n_samples=100, n_features=2, n_classes=2, random_state=42)

# Treina modelo
modelo = LogisticRegression()
modelo.fit(X, y)

# Avalia
print(f"Acurácia: {modelo.score(X, y):.2f}")
Key Takeaways:
- Use para classificação binária.
- score() retorna acurácia.
- Experimente: divida em treino/teste.

Script 65: Divisão de Dados em Treino e Teste

train_test_split divide dados em conjuntos de treino e teste para avaliar modelos.
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
import numpy as np

# Dados
X = np.array([[1], [2], [3], [4], [5]])
y = np.array([2, 4, 6, 8, 10])

# Divide
X_treino, X_teste, y_treino, y_teste = train_test_split(X, y, test_size=0.2, random_stat

# Treina
modelo = LinearRegression()
modelo.fit(X_treino, y_treino)
print(f"Acurácia (R²): {modelo.score(X_teste, y_teste):.2f}")
Key Takeaways:
- Use test_size para proporção.
- random_state garante reprodutibilidade.
- Experimente: mude test_size.

Script 66: Métricas de Avaliação para Classificação

Métricas como acurácia, precisão, recall e F1-score avaliam modelos de classificação.
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score

# Carrega dados (binário)

iris = load_iris()
X = iris.data[iris.target != 2][:, :2]
y = iris.target[iris.target != 2]
# Treina modelo
 X_treino, X_teste, y_treino, y_teste = train_test_split(X, y, test_size=0.2, random_stat
modelo = LogisticRegression()
modelo.fit(X_treino, y_treino)
y_pred = modelo.predict(X_teste)

# Calcula métricas
print(f"Acurácia: {accuracy_score(y_teste, y_pred):.2f}")
print(f"Precisão: {precision_score(y_teste, y_pred):.2f}")
print(f"Recall: {recall_score(y_teste, y_pred):.2f}")
print(f"F1-score: {f1_score(y_teste, y_pred):.2f}")
Key Takeaways:
- Acurácia mede acertos gerais.
- Use sklearn.metrics.
- Experimente: teste outro modelo.

Script 67: Matriz de Confusão

A matriz de confusão mostra previsões corretas e incorretas em classificação.
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix
import seaborn as sns
import matplotlib.pyplot as plt

# Carrega dados (binário)

iris = load_iris()
X = iris.data[iris.target != 2][:, :2]
y = iris.target[iris.target != 2]

# Treina modelo
X_treino, X_teste, y_treino, y_teste = train_test_split(X, y, test_size=0.2, random_stat
modelo = LogisticRegression()
modelo.fit(X_treino, y_treino)
y_pred = modelo.predict(X_teste)

# Cria matriz
cm = confusion_matrix(y_teste, y_pred)
sns.heatmap(cm, annot=True, fmt="d", cmap="Blues")
plt.xlabel("Predito")
plt.ylabel("Real")
plt.title("Matriz de Confusão")
plt.show()
Key Takeaways:
- Matriz exibe TP, FP, TN, FN.
- Use seaborn.heatmap().
- Experimente: matriz com três classes.

Script 68: K-Nearest Neighbors (KNN)

KNN classifica com base nos k vizinhos mais próximos, usando distância.
from sklearn.neighbors import KNeighborsClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

# Carrega dados
iris = load_iris()
X, y = iris.data, iris.target

# Treina modelo
X_treino, X_teste, y_treino, y_teste = train_test_split(X, y, test_size=0.2, random_stat
modelo = KNeighborsClassifier(n_neighbors=3)
modelo.fit(X_treino, y_treino)
print(f"Acurácia: {modelo.score(X_teste, y_teste):.2f}")
Key Takeaways:
- n_neighbors define k.
- Sensível à escala; normalize.
- Experimente: varie n_neighbors.

Script 69: Árvores de Decisão

Árvores de decisão dividem dados com base em condições, criando modelos interpretáveis.
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

# Carrega dados
iris = load_iris()
X, y = iris.data, iris.target

# Treina modelo
X_treino, X_teste, y_treino, y_teste = train_test_split(X, y, test_size=0.2, random_stat
modelo = DecisionTreeClassifier(max_depth=3, random_state=42)
modelo.fit(X_treino, y_treino)
print(f"Acurácia: {modelo.score(X_teste, y_teste):.2f}")
Key Takeaways:
- max_depth limita complexidade.
- Fácil de interpretar.
- Experimente: visualize com plot_tree().

Script 70: Random Forest

Random Forest combina árvores de decisão para melhorar precisão.
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

# Carrega dados
iris = load_iris()
 X, y = iris.data, iris.target

# Treina modelo
X_treino, X_teste, y_treino, y_teste = train_test_split(X, y, test_size=0.2, random_stat
modelo = RandomForestClassifier(n_estimators=100, random_state=42)
modelo.fit(X_treino, y_treino)
print(f"Acurácia: {modelo.score(X_teste, y_teste):.2f}")
Key Takeaways:
- n_estimators define árvores.
- Reduz sobreajuste.
- Experimente: ajuste max_depth.

Script 71: Validação Cruzada

Validação cruzada (k-fold) avalia modelos dividindo dados em k partes.
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
from sklearn.model_selection import cross_val_score

# Carrega dados
iris = load_iris()
X, y = iris.data, iris.target

# Realiza validação
modelo = LogisticRegression(max_iter=200)
scores = cross_val_score(modelo, X, y, cv=5)
print(f"Acurácia média: {scores.mean():.2f} (±{scores.std():.2f})")
Key Takeaways:
- Use cross_val_score().
- Avalia estabilidade.
- Experimente: teste com KNN.

Script 72: Busca de Hiperparâmetros com GridSearchCV

GridSearchCV testa combinações de hiperparâmetros.
from sklearn.model_selection import GridSearchCV
from sklearn.neighbors import KNeighborsClassifier
from sklearn.datasets import load_iris

# Carrega dados
iris = load_iris()
X, y = iris.data, iris.target

# Define grade
parametros = {'n_neighbors': [3, 5, 7], 'weights': ['uniform', 'distance']}
modelo = KNeighborsClassifier()
grid = GridSearchCV(modelo, parametros, cv=5)
grid.fit(X, y)
print(f"Melhores parâmetros: {grid.best_params_}")
 print(f"Acurácia: {grid.best_score_:.2f}")
Key Takeaways:
- Otimiza hiperparâmetros.
- Use dicionário para parâmetros.
- Experimente: teste Random Forest.

Script 73: Normalização com StandardScaler

StandardScaler ajusta dados para média 0 e variância 1.
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

# Carrega dados
iris = load_iris()
X, y = iris.data, iris.target

# Normaliza
scaler = StandardScaler()
X_norm = scaler.fit_transform(X)

# Treina modelo
X_treino, X_teste, y_treino, y_teste = train_test_split(X_norm, y, test_size=0.2, random
modelo = KNeighborsClassifier(n_neighbors=3)
modelo.fit(X_treino, y_treino)
print(f"Acurácia: {modelo.score(X_teste, y_teste):.2f}")
Key Takeaways:
- Normaliza com StandardScaler.
- Use fit_transform() e transform().
- Experimente: compare sem normalização.

Script 74: Visualização de Dados com Pairplot

pairplot do seaborn visualiza relações entre features.
import seaborn as sns
import pandas as pd
from sklearn.datasets import load_iris

# Carrega dados
iris = load_iris()
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['target'] = iris.target

# Cria pairplot
sns.pairplot(df, hue='target', diag_kind='hist')
plt.show()
Key Takeaways:
- pairplot mostra dispersão.
- Use hue para classes.
- Experimente: use outro dataset.

Script 75: Salvar e Carregar Modelos com joblib

joblib salva modelos treinados para reutilização.
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
import joblib

# Carrega e treina
iris = load_iris()
X, y = iris.data, iris.target
modelo = LogisticRegression(max_iter=200)
modelo.fit(X, y)

# Salva
joblib.dump(modelo, 'modelo_iris.pkl')

# Carrega
modelo_carregado = joblib.load('modelo_iris.pkl')
print(f"Acurácia: {modelo_carregado.score(X, y):.2f}")
Key Takeaways:
- Use joblib.dump() e load().
- Economiza tempo.
- Experimente: salve Random Forest.

Script 76: Prever Preços de Casas com Regressão

Use regressão linear para prever preços de casas.
from sklearn.datasets import load_boston
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
import numpy as np

# Carrega dataset
boston = load_boston()
X = boston.data[:, 5:6] # Usa número de quartos
y = boston.target

# Divide e treina
X_treino, X_teste, y_treino, y_teste = train_test_split(X, y, test_size=0.2, random_stat
modelo = LinearRegression()
modelo.fit(X_treino, y_treino)

# Avalia
y_pred = modelo.predict(X_teste)
rmse = np.sqrt(mean_squared_error(y_teste, y_pred))
 print(f"RMSE: {rmse:.2f}")

# Prevê
quartos = np.array([[6]])
preco = modelo.predict(quartos)
print(f"Preço previsto: ${preco[0]:.2f}k")
Key Takeaways:
- Datasets do scikit-learn ajudam.
- Regressão prevê números.
- Experimente: use mais features.

Script 77: Classificação de Íris

Classificar flores do dataset iris com Random Forest.
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix
import seaborn as sns
import matplotlib.pyplot as plt

# Carrega dados
iris = load_iris()
X, y = iris.data, iris.target

# Treina modelo
X_treino, X_teste, y_treino, y_teste = train_test_split(X, y, test_size=0.2, random_stat
modelo = RandomForestClassifier(random_state=42)
modelo.fit(X_treino, y_treino)

# Avalia
y_pred = modelo.predict(X_teste)
cm = confusion_matrix(y_teste, y_pred)
sns.heatmap(cm, annot=True, fmt="d", cmap="Blues")
plt.show()
print(f"Acurácia: {modelo.score(X_teste, y_teste):.2f}")
Key Takeaways:
- Random Forest é robusto.
- Matriz revela erros.
- Experimente: teste com KNN.

Script 78: Detecção de Spam com Naive Bayes

Naive Bayes classifica textos, como e-mails spam.
from sklearn.naive_bayes import MultinomialNB
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.model_selection import train_test_split

# Dados fictícios
 emails = ["Oferta imperdível!", "Reunião amanhã", "Ganhe dinheiro rápido!", "Relatório s
labels = [1, 0, 1, 0] # 1: spam, 0: não spam

# Vetoriza texto
vectorizer = CountVectorizer()
X = vectorizer.fit_transform(emails)

# Treina modelo
X_treino, X_teste, y_treino, y_teste = train_test_split(X, labels, test_size=0.2, random
modelo = MultinomialNB()
modelo.fit(X_treino, y_treino)
print(f"Acurácia: {modelo.score(X_teste, y_teste):.2f}")
Key Takeaways:
- Naive Bayes é eficaz para texto.
- CountVectorizer vetoriza.
- Experimente: adicione e-mails.

Script 79: Análise de Sentimentos com Texto

Classificar textos como positivos ou negativos.
from sklearn.linear_model import LogisticRegression
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.model_selection import train_test_split

# Dados fictícios
textos = ["Adorei o filme!", "Que filme horrível!", "Muito bom!", "Não gostei."]
sentimentos = [1, 0, 1, 0] # 1: positivo, 0: negativo

# Vetoriza
vectorizer = TfidfVectorizer()
X = vectorizer.fit_transform(textos)

# Treina modelo
X_treino, X_teste, y_treino, y_teste = train_test_split(X, sentimentos, test_size=0.2, r
modelo = LogisticRegression()
modelo.fit(X_treino, y_treino)
print(f"Acurácia: {modelo.score(X_teste, y_teste):.2f}")
Key Takeaways:
- TfidfVectorizer pesa palavras.
- Logistic Regression para binário.
- Experimente: teste novos textos.

Script 80: Previsão de Vendas

Prever vendas com regressão linear.
from sklearn.linear_model import LinearRegression
import numpy as np
import matplotlib.pyplot as plt
# Dados fictícios
 X = np.array([[1], [2], [3], [4], [5]])
y = np.array([100, 120, 140, 160, 180])

# Treina modelo
modelo = LinearRegression()
modelo.fit(X, y)

# Prevê
mes_futuro = np.array([[6]])
venda = modelo.predict(mes_futuro)
print(f"Venda prevista para mês 6: {venda[0]:.2f}")

# Visualiza
plt.scatter(X, y, color="blue")
plt.plot(X, modelo.predict(X), color="red")
plt.show()
Key Takeaways:
- Modela tendências.
- Visualize com Matplotlib.
- Experimente: adicione meses.

Script 81: Previsão de Sobrevivência no Titanic

Prever sobrevivência no Titanic com Random Forest.
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder

# Dados fictícios
dados = pd.DataFrame({
'idade': [22, 38, 26, 35],
'sexo': ['homem', 'mulher', 'mulher', 'homem'],
'classe': [3, 1, 3, 1],
'sobreviveu': [0, 1, 1, 0]
})

# Prepara dados
le = LabelEncoder()
dados['sexo'] = le.fit_transform(dados['sexo'])
X = dados[['idade', 'sexo', 'classe']]
y = dados['sobreviveu']

# Treina modelo
X_treino, X_teste, y_treino, y_teste = train_test_split(X, y, test_size=0.2, random_stat
modelo = RandomForestClassifier(random_state=42)
modelo.fit(X_treino, y_treino)
print(f"Acurácia: {modelo.score(X_teste, y_teste):.2f}")
Key Takeaways:
- LabelEncoder para categóricas.
- Random Forest para dados mistos.
- Experimente: use dataset real.

Script 82: Reconhecimento de Dígitos com MNIST

Classificar dígitos manuscritos com KNN.
from sklearn.datasets import load_digits
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt

# Carrega dados
digits = load_digits()
X, y = digits.data, digits.target

# Visualiza
plt.imshow(digits.images[0], cmap='gray')
plt.title(f"Dígito: {y[0]}")
plt.show()

# Treina modelo
X_treino, X_teste, y_treino, y_teste = train_test_split(X, y, test_size=0.2, random_stat
modelo = KNeighborsClassifier(n_neighbors=3)
modelo.fit(X_treino, y_treino)
print(f"Acurácia: {modelo.score(X_teste, y_teste):.2f}")
Key Takeaways:
- MNIST é clássico.
- KNN para imagens simples.
- Experimente: teste Logistic Regression.

Script 83: Sistema de Recomendação Simples

Recomendações baseadas em similaridade de cosseno.
from sklearn.metrics.pairwise import cosine_similarity
import pandas as pd
import numpy as np

# Dados fictícios
dados = pd.DataFrame({
'Filme A': [5, 4, 0, 1],
'Filme B': [0, 5, 4, 2],
'Filme C': [2, 0, 5, 3]
}, index=['User1', 'User2', 'User3', 'User4'])

# Calcula similaridade
similaridade = cosine_similarity(dados.fillna(0))
print("Matriz de similaridade:
", similaridade)
# Recomenda para User1
 user1_sim = similaridade[0]
melhor_match = np.argmax(user1_sim[1:]) + 1
print(f"Usuário mais similar a User1: User{melhor_match + 1}")
Key Takeaways:
- Similaridade de cosseno mede afinidade.
- fillna(0) trata ausências.
- Experimente: adicione filmes.

Script 84: Detecção de Fraude com Árvore de Decisão

Detectar fraudes com árvores de decisão.
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
import pandas as pd

# Dados fictícios
dados = pd.DataFrame({
'valor': [100, 5000, 50, 2000],
'hora': [12, 2, 15, 3],
'fraude': [0, 1, 0, 1]
})

# Treina modelo
X = dados[['valor', 'hora']]
y = dados['fraude']
X_treino, X_teste, y_treino, y_teste = train_test_split(X, y, test_size=0.2, random_stat
modelo = DecisionTreeClassifier(random_state=42)
modelo.fit(X_treino, y_treino)
print(f"Acurácia: {modelo.score(X_teste, y_teste):.2f}")
Key Takeaways:
- Árvores são interpretáveis.
- Dados reais precisam de balanceamento.
- Experimente: adicione transações.

Script 85: Classificação de Notas de Filmes

Classificar críticas de filmes como positivas ou negativas.
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split

# Dados fictícios
criticas = ["Ótimo filme!", "Péssimo roteiro.", "Adorei a história!", "Muito chato."]
rotulos = [1, 0, 1, 0] # 1: positivo, 0: negativo

# Vetoriza
vectorizer = TfidfVectorizer()
X = vectorizer.fit_transform(criticas)
# Treina modelo
 X_treino, X_teste, y_treino, y_teste = train_test_split(X, rotulos, test_size=0.2, rando
modelo = LogisticRegression()
modelo.fit(X_treino, y_treino)
print(f"Acurácia: {modelo.score(X_teste, y_teste):.2f}")
Key Takeaways:
- TfidfVectorizer para texto.
- Logistic Regression para binário.
- Experimente: novas críticas.

Script 86: Reconhecimento de Voz Simples

speech_recognition converte áudio em texto.
import speech_recognition as sr

# Inicializa
reconhecedor = sr.Recognizer()

# Captura áudio
with sr.Microphone() as fonte:
print("Fale algo...")
audio = reconhecedor.listen(fonte)
try:
texto = reconhecedor.recognize_google(audio, language='pt-BR')
print(f"Você disse: {texto}")
except sr.UnknownValueError:
print("Não entendi.")
except sr.RequestError:
print("Erro na conexão.")
Key Takeaways:
- Instale com pip install SpeechRecognition.
- Requer microfone e conexão.
- Experimente: salve áudio em WAV.

Script 87: Classificação de Imagens com scikit-learn

Classificar imagens simples com SVM.
from sklearn.svm import SVC
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split

# Carrega dados
digits = load_digits()
X, y = digits.data, digits.target

# Treina modelo
X_treino, X_teste, y_treino, y_teste = train_test_split(X, y, test_size=0.2, random_stat
modelo = SVC(kernel='linear')
modelo.fit(X_treino, y_treino)
print(f"Acurácia: {modelo.score(X_teste, y_teste):.2f}")
Key Takeaways:
- SVM para imagens pequenas.
- Dados achatados em vetores.
- Experimente: use kernel RBF.

Script 88: Clustering com K-Means

K-Means agrupa dados não rotulados em clusters.
from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs
import matplotlib.pyplot as plt

# Gera dados
X, _ = make_blobs(n_samples=300, centers=3, random_state=42)

# Aplica K-Means
modelo = KMeans(n_clusters=3, random_state=42)
modelo.fit(X)
labels = modelo.labels_

# Visualiza
plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis')
plt.title("Clusters com K-Means")
plt.show()
Key Takeaways:
- n_clusters define grupos.
- Use dados sintéticos.
- Experimente: varie clusters.

Script 89: Redução de Dimensionalidade com PCA

PCA reduz dimensões, mantendo variância.
from sklearn.decomposition import PCA
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt

# Carrega dados
iris = load_iris()
X, y = iris.data, iris.target

# Aplica PCA
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X)

# Visualiza
plt.scatter(X_pca[:, 0], X_pca[:, 1], c=y, cmap='viridis')
plt.title("Iris com PCA")
plt.xlabel("Componente 1")
plt.ylabel("Componente 2")
plt.show()
Key Takeaways:
- PCA para visualização.
- n_components define dimensões.
- Experimente: outro dataset.

Script 90: Introdução ao AutoML com scikit-learn

TPOT automatiza seleção de modelos e hiperparâmetros.
from tpot import TPOTClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

# Carrega dados
iris = load_iris()
X, y = iris.data, iris.target

# Divide dados
X_treino, X_teste, y_treino, y_teste = train_test_split(X, y, test_size=0.2, random_stat

# Aplica TPOT
tpot = TPOTClassifier(generations=5, population_size=20, verbosity=2, random_state=42)
tpot.fit(X_treino, y_treino)
print(f"Acurácia: {tpot.score(X_teste, y_teste):.2f}")
Key Takeaways:
- Instale com pip install tpot.
- Testa pipelines.
- Experimente: ajuste generations.

Script 91: Explicabilidade com SHAP

SHAP explica previsões, mostrando a contribuição de features.
import shap
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_iris

# Carrega dados
iris = load_iris()
X, y = iris.data, iris.target
modelo = RandomForestClassifier(random_state=42)
modelo.fit(X, y)

# Explica
explainer = shap.TreeExplainer(modelo)
shap_values = explainer.shap_values(X)
shap.summary_plot(shap_values, X, feature_names=iris.feature_names)
Key Takeaways:
- Instale com pip install shap.
- Visualiza importância.
- Experimente: outro modelo.
Script 92: Visualização de Árvores de Decisão
Visualizar árvores ajuda a entender decisões.
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt
from sklearn.tree import plot_tree

# Carrega dados
iris = load_iris()
X, y = iris.data, iris.target
modelo = DecisionTreeClassifier(max_depth=3, random_state=42)
modelo.fit(X, y)

# Visualiza
plt.figure(figsize=(12, 8))
plot_tree(modelo, feature_names=iris.feature_names, class_names=iris.target_names, fille
plt.show()
Key Takeaways:
- plot_tree exibe estrutura.
- max_depth simplifica.
- Experimente: aumente profundidade.

Script 93: Salvar Modelos com pickle

pickle salva modelos em arquivos binários.
import pickle
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris

# Treina modelo
iris = load_iris()
X, y = iris.data, iris.target
modelo = LogisticRegression(max_iter=200)
modelo.fit(X, y)

# Salva
with open('modelo_iris.pkl', 'wb') as arquivo:
pickle.dump(modelo, arquivo)

# Carrega
with open('modelo_iris.pkl', 'rb') as arquivo:
modelo_carregado = pickle.load(arquivo)
print(f"Acurácia: {modelo_carregado.score(X, y):.2f}")
Key Takeaways:
- pickle.dump() e load().
- Mantém estado treinado.
- Experimente: salve Random Forest.
Script 94: API com Flask para Modelos
Flask cria APIs para servir modelos via HTTP.
from flask import Flask, request, jsonify
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
import numpy as np

app = Flask(_name_)

# Treina modelo
iris = load_iris()
modelo = LogisticRegression(max_iter=200)
modelo.fit(iris.data, iris.target)

@app.route('/prever', methods=['POST'])
def prever():
dados = request.json['features']
predicao = modelo.predict([dados])[0]
return jsonify({'predicao': int(predicao)})

if _name_ == '_main_':
app.run(debug=True)
Key Takeaways:
- Instale com pip install flask.
- Use @app.route.
- Experimente: teste com requests.

Script 95: Interface Gráfica com tkinter

tkinter cria interfaces gráficas simples.
import tkinter as tk
from tkinter import messagebox

# Cria janela
janela = tk.Tk()
janela.title("Calculadora Simples")
janela.geometry("200x150")

# Função
def calcular():
try:
num = float(entrada.get())
resultado = num * 2
messagebox.showinfo("Resultado", f"O dobro é {resultado}")
except ValueError:
messagebox.showerror("Erro", "Digite um número!")

# Widgets
 tk.Label(janela, text="Digite um número:").pack(pady=10)
entrada = tk.Entry(janela)
entrada.pack()
tk.Button(janela, text="Calcular", command=calcular).pack(pady=10)

janela.mainloop()
Key Takeaways:
- tkinter nativo do Python.
- Use Label, Entry, Button.
- Experimente: adicione operação.

Script 96: Deploy Local de Modelos

Deploy local com Flask para testar APIs.
from flask import Flask, request, jsonify
import joblib

app = Flask(_name_)

# Carrega modelo
modelo = joblib.load('modelo_iris.pkl')

@app.route('/prever', methods=['POST'])
def prever():
dados = request.json['features']
predicao = modelo.predict([dados])[0]
return jsonify({'predicao': int(predicao)})

if _name_ == '_main_':
app.run(host='0.0.0.0', port=5000)
Key Takeaways:
- Use joblib para carregar.
- Teste com app.run().
- Experimente: use Postman.

Script 97: Pipeline com scikit-learn

Pipelines combinam pré-processamento e modelagem.
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

# Carrega dados
iris = load_iris()
X, y = iris.data, iris.target

# Cria pipeline
 pipeline = Pipeline([
('scaler', StandardScaler()),
('modelo', LogisticRegression(max_iter=200))
])

# Treina
X_treino, X_teste, y_treino, y_teste = train_test_split(X, y, test_size=0.2, random_stat
pipeline.fit(X_treino, y_treino)
print(f"Acurácia: {pipeline.score(X_teste, y_teste):.2f}")
Key Takeaways:
- Pipelines garantem consistência.
- Combine com Pipeline().
- Experimente: adicione PCA.

Script 98: Relatório de Classificação

classification_report fornece métricas detalhadas.
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report

# Carrega dados
iris = load_iris()
X, y = iris.data, iris.target

# Treina modelo
X_treino, X_teste, y_treino, y_teste = train_test_split(X, y, test_size=0.2, random_stat
modelo = RandomForestClassifier(random_state=42)
modelo.fit(X_treino, y_treino)
y_pred = modelo.predict(X_teste)

# Relatório
print(classification_report(y_teste, y_pred, target_names=iris.target_names))
Key Takeaways:
- Detalha métricas por classe.
- Avalia desbalanceamento.
- Experimente: outro modelo.

Script 99: Lidar com Dados Desbalanceados

SMOTE gera amostras sintéticas para balancear dados.
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from imblearn.over_sampling import SMOTE
import pandas as pd

# Dados fictícios
dados = pd.DataFrame({
 'valor': [100, 200, 5000, 6000],
'fraude': [0, 0, 1, 1]
})
X = dados[['valor']]
y = dados['fraude']

# Aplica SMOTE
smote = SMOTE(random_state=42)
X_balanceado, y_balanceado = smote.fit_resample(X, y)

# Treina modelo
X_treino, X_teste, y_treino, y_teste = train_test_split(X_balanceado, y_balanceado, test
modelo = RandomForestClassifier(random_state=42)
modelo.fit(X_treino, y_treino)
print(f"Acurácia: {modelo.score(X_teste, y_teste):.2f}")
Key Takeaways:
- Instale com pip install imbalanced-learn.
- SMOTE balanceia classes.
- Experimente: compare sem SMOTE.

Script 100: Publicar Código no GitHub

GitHub permite compartilhar e versionar código com git.
Key Takeaways:
- Use git para versionar.
- Crie README.md.
- Experimente: publique este script.