Guia completo de Python para desenvolvimento moderno e científico
📖 Definição
Python é uma linguagem de programação de alto nível, interpretada e multi-paradigma. Conhecida por sua sintaxe clara e legibilidade, é amplamente usada em desenvolvimento web, ciência de dados, automação e inteligência artificial.
💪 Por que aprender?
• Sintaxe limpa e legível
• Multi-paradigma (OO, funcional, procedural)
• Ecossistema rico de bibliotecas
• Ideal para iniciantes
• Comunidade ativa e suporte corporativo
🚀 O que você pode fazer?
• Desenvolvimento web (Django, Flask)
• Ciência de dados e Machine Learning
• Automação e scripts
• Desenvolvimento de APIs
• Análise e visualização de dados
Django, Flask, FastAPI
Pandas, NumPy, Matplotlib
TensorFlow, PyTorch, Scikit
Async, Type Hints, 3.12+
🐍 Variáveis e Tipos
Use quando: Declarando variáveis, trabalhando com dados ou convertendo tipos
📋Declaração de Variáveis
nome = "João"# String
idade = 25# Inteiro
altura = 1.75# Float
ativo = True# Booleano
dados = None# Nulo
📋Tipos Primitivos
type("texto")# <class 'str'>
type(42)# <class 'int'>
type(3.14)# <class 'float'>
type(True)# <class 'bool'>
type(None)# <class 'NoneType'>
type([1, 2, 3])# <class 'list'>
type((1, 2, 3))# <class 'tuple'>
type({1, 2, 3})# <class 'set'>
type({"a": 1})# <class 'dict'>
📋Conversão de Tipos
str(123)# Para string
int("42")# Para inteiro
float("3.14")# Para float
bool(1)# Para boolean
list("abc")# Para lista
tuple([1, 2])# Para tupla
set([1, 2, 3])# Para conjunto
dict([("a", 1)])# Para dicionário
📋 Estruturas de Dados
Use quando: Trabalhando com coleções de dados, estruturas, armazenamento
📋Listas (Arrays)
lista = [1, 2, 3, 4, 5]# Criar lista
lista = list(range(10))# Lista com range
lista[0]# Acessar elemento
lista[-1]# Último elemento
lista[1:4]# Fatia [1:4)
lista[:3]# Primeiros 3
lista[2:]# Do 2 até o fim
lista[::2]# Passo 2
📋Métodos de Listas
lista.append(6)# Adicionar no fim
lista.insert(0, 0)# Inserir na posição
lista.remove(3)# Remover elemento
lista.pop()# Remover último
lista.extend([7, 8])# Estender lista
lista.sort()# Ordenar
lista.reverse()# Inverter
lista.count(3)# Contar ocorrências
lista.index(3)# Índice do elemento
📋Tuplas
tupla = (1, 2, 3)# Criar tupla
tupla = tuple([1, 2, 3])# Converter lista
a, b, c = tupla# Desempacotar
tupla[0]# Acessar elemento
len(tupla)# Tamanho
📋Dicionários
pessoa = {"nome": "João", "idade": 25}# Criar dicionário
pessoa = dict(nome="João", idade=25)# Com construtor
pessoa["nome"]# Acessar por chave
pessoa.get("nome")# Acessar seguro
pessoa["idade"] = 26# Modificar valor
pessoa["cidade"] = "São Paulo"# Adicionar chave
del pessoa["idade"]# Remover chave
pessoa.keys()# Lista de chaves
pessoa.values()# Lista de valores
pessoa.items()# Lista de pares
🔀 Estruturas de Controle
Use quando: Controlando fluxo do programa, repetições, decisões
📋If/Else
if idade >= 18:
print("Maior de idade")
else:
print("Menor de idade")# Condicional simples
if nota >= 7:
print("Aprovado")
elif nota >= 5:
print("Recuperação")
else:
print("Reprovado")# Múltiplas condições
if 18 <= idade <= 65:
print("Em idade trabalhativa")# Condição composta
📋Loops For
for i in range(5):
print(i)# Loop com range
for i in range(1, 10, 2):
print(i)# Range com passo
for item in lista:
print(item)# Iterar lista
for indice, valor in enumerate(lista):
print(indice, valor)# Com índice
for chave, valor in dicionario.items():
print(chave, valor)# Iterar dicionário
📋Loops While
contador = 0
while contador < 5:
print(contador)
contador += 1# Loop condicional
while True:
resposta = input("Digite 'sair' para parar: ")
if resposta == "sair":
break# Loop infinito com break
while True:
try:
resultado = 10 / 0
except ZeroDivisionError:
print("Erro de divisão")
break# Loop com tratamento de erro
📋Break e Continue
for i in range(10):
if i == 5:
continue
print(i)# Pular iteração
for i in range(10):
if i == 7:
break
print(i)# Interromper loop
⚡ Funções
Use quando: Reutilizando código, organização lógica, modularização
📋Definição Básica
def saudar(nome):
return f"Olá, {nome}!"# Função simples
def calcular_area(base, altura):
return (base * altura) / 2# Com parâmetros
def saudar(nome="Visitante"):
return f"Olá, {nome}!"# Parâmetro padrão
def processar(*args):
for arg in args:
print(arg)# Argumentos variáveis
def configurar(**kwargs):
for chave, valor in kwargs.items():
print(f"{chave}: {valor}")# Argumentos nomeados
📋Funções Lambda
soma = lambda a, b: a + b# Função anônima
quadrado = lambda x: x ** 2# Expressão lambda
lista.sort(key=lambda x: x[1])# Chave de ordenação
numeros = list(map(lambda x: x**2, range(10)))# Map com lambda
pares = list(filter(lambda x: x%2==0, range(10)))# Filter com lambda
📋Decoradores
def timer(func):
def wrapper(*args, **kwargs):
import time
inicio = time.time()
resultado = func(*args, **kwargs)
fim = time.time()
print(f"Tempo: {fim - inicio:.2f}s")
return resultado
return wrapper# Decorador de timer
@timer
def calcular_soma(n):
return sum(range(n))# Usando decorador
def log_chamada(func):
def wrapper(*args, **kwargs):
print(f"Chamando {func.__name__}")
return func(*args, **kwargs)
return wrapper# Decorador de log
📋Funções Built-in
print("Hello, World!")# Imprimir
len([1, 2, 3])# Tamanho
sum([1, 2, 3, 4])# Soma
max([1, 5, 3])# Máximo
min([1, 5, 3])# Mínimo
abs(-5)# Valor absoluto
round(3.14159, 2)# Arredondar
type(42)# Tipo do dado
isinstance(42, int)# Verificar tipo
🏗️ Programação Orientada a Objetos
Use quando: Modelando entidades complexas, reutilização código, organização
📋Classes Básicas
class Pessoa:
def __init__(self, nome, idade):
self.nome = nome
self.idade = idade
def saudar(self):
return f"Olá, sou {self.nome}"# Classe simples
class Animal:
def __init__(self, nome):
self.nome = nome
def falar(self):
raise NotImplementedError("Subclasses devem implementar")# Classe abstrata
class Contador:
def __init__(self):
self.valor = 0
def incrementar(self):
self.valor += 1
def __str__(self):
return f"Contador: {self.valor}"# Com métodos
📋Herança
class Animal:
def __init__(self, nome):
self.nome = nome
def falar(self):
pass
class Cachorro(Animal):
def falar(self):
return "Au au!"# Herança simples
class Veiculo:
def __init__(self, marca):
self.marca = marca
class Carro(Veiculo):
def __init__(self, marca, modelo):
super().__init__(marca)
self.modelo = modelo# Chamando super()
class A:
def metodo(self):
return "A"
class B(A):
def metodo(self):
return super().metodo() + "B"# Usando super()
📋Métodos Especiais
class Pessoa:
def __init__(self, nome):
self.nome = nome
def __str__(self):
return f"Pessoa: {self.nome}"
def __repr__(self):
return f"Pessoa('{self.nome}')"# __str__ e __repr__
class Lista:
def __init__(self, itens):
self.itens = itens
def __len__(self):
return len(self.itens)
def __getitem__(self, indice):
return self.itens[indice]# __len__ e __getitem__
class Conta:
def __init__(self, saldo):
self.saldo = saldo
def __add__(self, valor):
return Conta(self.saldo + valor)# Sobrecarga de operador
📋Propriedades
class Pessoa:
def __init__(self, nome):
self._nome = nome
@property
def nome(self):
return self._nome
@nome.setter
def nome(self, valor):
self._nome = valor.title()# Property getter/setter
class Retangulo:
def __init__(self, largura, altura):
self._largura = largura
self._altura = altura
@property
def area(self):
return self._largura * self._altura# Property calculada
📦 Módulos e Pacotes
Use quando: Organizando código, reutilização, gerenciando dependências
📋Importação
import math# Importar módulo
import numpy as np# Com alias
from math import sqrt, pi# Importar específicos
from datetime import datetime, date# Múltiplos
import requests
import json
from bs4 import BeautifulSoup# Múltiplos módulos
📋Módulos Built-in
import math
math.sqrt(16)# Funções matemáticas
import random
random.randint(1, 100)# Números aleatórios
import datetime
datetime.now()# Data e hora
import os
os.listdir(".")# Sistema operacional
import sys
sys.path# Sistema e caminhos
import json
json.loads('{"a": 1}')# JSON
import re
re.findall(r"\d+", "abc123")# Expressões regulares
📋Criando Módulos
# meu_modulo.py
def saudar(nome):
return f"Olá, {nome}!"
def calcular_area(base, altura):
return (base * altura) / 2# Arquivo de módulo
# main.py
import meu_modulo
print(meu_modulo.saudar("João"))
print(meu_modulo.calcular_area(10, 5))# Usando módulo
# __init__.py
from .funcoes import saudar, calcular_area
from .classes import Pessoa# Pacote com __init__
📋Pip (Gerenciador de Pacotes)
pip install numpy# Instalar pacote
pip install requests==2.25.1# Versão específica
pip install -r requirements.txt# Do arquivo
pip list# Listar instalados
pip show numpy# Informações do pacote
pip uninstall numpy# Desinstalar
pip freeze > requirements.txt# Gerar requirements
⚠️ Tratamento de Erros
Use quando: Tratando erros, recursos, validações, robustez
📋Try/Except
try:
resultado = 10 / 0
except ZeroDivisionError:
print("Erro: Divisão por zero")
except Exception as e:
print(f"Erro genérico: {e}")# Captura específica e genérica
try:
numero = int(input("Digite um número: "))
resultado = 100 / numero
except ValueError:
print("Erro: Digite um número válido")
except ZeroDivisionError:
print("Erro: Não pode dividir por zero")# Múltiplas exceções
try:
with open("arquivo.txt", "r") as f:
conteudo = f.read()
except FileNotFoundError:
print("Arquivo não encontrado")
except PermissionError:
print("Sem permissão")# Com arquivos
📋Finally
try:
arquivo = open("dados.txt", "r")
conteudo = arquivo.read()
except FileNotFoundError:
print("Arquivo não encontrado")
finally:
if "arquivo" in locals():
arquivo.close()# Sempre executa
try:
conexao = conectar_banco()
dados = conexao.consultar()
except Exception as e:
registrar_erro(e)
raise
finally:
if "conexao" in locals():
conexao.close()# Limpeza de recursos
📋Raise Personalizadas
class ErroCustomizado(Exception):
def __init__(self, mensagem):
self.mensagem = mensagem
super().__init__(self.mensagem)# Criar exceção
def validar_idade(idade):
if idade < 0:
raise ValueError("Idade não pode ser negativa")
if idade > 150:
raise ValueError("Idade muito alta")
return idade# Validar com raise
try:
validar_idade(-5)
except ValueError as e:
print(f"Erro de validação: {e}")# Capturar exceção
📋With Statement
with open("arquivo.txt", "r") as f:
conteudo = f.read()
# Arquivo fechado automaticamente# Gerenciamento automático
import sqlite3
with sqlite3.connect("banco.db") as conn:
cursor = conn.cursor()
# Conexão fechada automaticamente# Com banco de dados
from contextlib import contextmanager
@contextmanager
def temporizador():
import time
inicio = time.time()
yield
fim = time.time()
print(f"Tempo: {fim - inicio:.2f}s")
with temporizador():
# Código a ser medido# Context manager personalizado
📁 Manipulação de Arquivos
Use quando: Processando arquivos, persistência de dados, I/O
📋Leitura de Arquivos
with open("arquivo.txt", "r") as f:
conteudo = f.read()# Ler tudo
with open("arquivo.txt", "r") as f:
linhas = f.readlines()# Ler linhas
with open("arquivo.txt", "r") as f:
for linha in f:
print(linha.strip())# Ler linha por linha
with open("dados.json", "r") as f:
dados = json.load(f)# Ler JSON
import csv
with open("dados.csv", "r") as f:
leitor = csv.reader(f)
for linha in leitor:
print(linha)# Ler CSV
📋Escrita de Arquivos
with open("saida.txt", "w") as f:
f.write("Hello, World!")# Escrever texto
with open("linhas.txt", "w") as f:
f.writelines(["Linha 1\n", "Linha 2\n"])# Escrever múltiplas linhas
with open("dados.json", "w") as f:
json.dump({"nome": "João", "idade": 25}, f)# Escrever JSON
import csv
dados = [["Nome", "Idade"], ["João", 25], ["Maria", 30]]
with open("dados.csv", "w", newline="") as f:
escritor = csv.writer(f)
escritor.writerows(dados)# Escrever CSV
📋Manipulação de Diretórios
import os
os.listdir(".")# Listar arquivos
import os
os.makedirs("novo_diretorio", exist_ok=True)# Criar diretório
import os
os.path.exists("arquivo.txt")# Verificar existência
import os
os.path.getsize("arquivo.txt")# Tamanho do arquivo
import os
os.remove("arquivo.txt")# Remover arquivo
import shutil
shutil.copy("origem.txt", "destino.txt")# Copiar arquivo
import shutil
shutil.move("antigo.txt", "novo.txt")# Mover/renomear
📋Pathlib (Moderno)
from pathlib import Path
arquivo = Path("dados.txt")
conteudo = arquivo.read_text()# Ler com pathlib
from pathlib import Path
arquivo = Path("saida.txt")
arquivo.write_text("Hello!")# Escrever com pathlib
from pathlib import Path
caminho = Path("/home/usuario/documentos")
arquivo = caminho / "relatorio.txt"# Construir caminho
from pathlib import Path
pasta = Path(".")
arquivos_py = pasta.glob("*.py")# Listar com padrão
🎯 List Comprehensions
Use quando: Processamento de dados, transformações, filtragem
📋Básicas
[x**2 for x in range(10)]# Quadrados de 0-9
[x for x in range(20) if x % 2 == 0]# Números pares
[x.upper() for x in ["a", "b", "c"]]# Transformar strings
[(x, x**2) for x in range(5)]# Tuplas
📋Aninhadas
[[x*y for y in range(3)] for x in range(3)]# Matriz 3x3
[[x, y] for x in range(3) for y in range(3) if x + y == 3]# Com condição
palavras = ["python", "java", "javascript"]
[[letra.upper() for letra in palavra] for palavra in palavras]# Processar strings
📋Com Funções
import math
[math.sqrt(x) for x in range(1, 26) if x % 5 == 0]# Com função
def eh_primo(n):
return n > 1 and all(n % i != 0 for i in range(2, int(n**0.5) + 1))
[ x for x in range(2, 50) if eh_primo(x) ]# Números primos
⚡ Geradores e Iteradores
Use quando: Processamento de grandes volumes, memória eficiente
📋Geradores
def contar_ate(n):
for i in range(n):
yield i
for num in contar_ate(5):
print(num)# Gerador simples
def fibonacci():
a, b = 0, 1
while True:
yield a
a, b = b, a + b# Sequência infinita
quadrados = (x**2 for x in range(10))# Generator expression
📋Iteradores
class Contador:
def __init__(self, limite):
self.limite = limite
self.atual = 0
def __iter__(self):
return self
def __next__(self):
if self.atual >= self.limite:
raise StopIteration
valor = self.atual
self.atual += 1
return valor# Implementar iterador
for i in Contador(5):
print(i)# Usar iterador
📋Itertools
import itertools
list(itertools.combinations([1, 2, 3], 2))# Combinações
import itertools
list(itertools.permutations([1, 2, 3], 2))# Permutações
import itertools
list(itertools.product([1, 2], ["a", "b"]))# Produto cartesiano
import itertools
list(itertools.cycle([1, 2, 3]))[:6]# Ciclo infinito
🎨 Decoradores Avançados
Use quando: Metaprogramação, padrões de projeto, extensibilidade
📋Decoradores com Parâmetros
def repetir(vezes):
def decorador(func):
def wrapper(*args, **kwargs):
resultado = None
for _ in range(vezes):
resultado = func(*args, **kwargs)
return resultado
return wrapper
return decorador
@repetir(3)
def saudar():
print("Olá!")# Com parâmetros
📋Decoradores de Classe
def adicionar_metodo(classe):
def novo_metodo(self):
return "Método adicionado"
classe.novo_metodo = novo_metodo
return classe
@adicionar_metodo
class MinhaClasse:
pass# Modificar classe
📋Property Avançada
class Pessoa:
def __init__(self):
self._idade = 0
@property
def idade(self):
return self._idade
@idade.setter
def idade(self, valor):
if valor < 0:
raise ValueError("Idade não pode ser negativa")
self._idade = valor# Com validação
📋Singleton
def singleton(classe):
instancias = {}
def obter_instancia(*args, **kwargs):
if classe not in instancias:
instancias[classe] = classe(*args, **kwargs)
return instancias[classe]
return obter_instancia
@singleton
class BancoDeDados:
def __init__(self):
self.conexao = None# Padrão Singleton
🔢 Programação Funcional
Use quando: Processamento de dados, pipelines, código imutável
📋Funções de Ordem Superior
def aplicar_operacao(lista, operacao):
return [operacao(x) for x in lista]
dobrar = lambda x: x * 2
resultado = aplicar_operacao([1, 2, 3], dobrar)# Função como parâmetro
def criar_multiplicador(fator):
return lambda x: x * fator
dobrar = criar_multiplicador(2)
triplicar = criar_multiplicador(3)# Closure
📋Map, Filter, Reduce
numeros = [1, 2, 3, 4, 5]
quadrados = list(map(lambda x: x**2, numeros))# Map
numeros = [1, 2, 3, 4, 5, 6]
pares = list(filter(lambda x: x % 2 == 0, numeros))# Filter
from functools import reduce
numeros = [1, 2, 3, 4, 5]
soma = reduce(lambda x, y: x + y, numeros)# Reduce
📋Funções Parciais
from functools import partial
def potencia(base, expoente):
return base ** expoente
dobro = partial(potencia, 2)
cubo = partial(potencia, 3)# Função parcial
📋Composição de Funções
def compor(f, g):
return lambda x: f(g(x))
dobrar = lambda x: x * 2
incrementar = lambda x: x + 1
dobrar_e_incrementar = compor(incrementar, dobrar)# Composição
🧪 Testes Unitários
Use quando: Desenvolvimento orientado a testes, qualidade de código
📋unittest
import unittest
class TestCalculadora(unittest.TestCase):
def test_soma(self):
self.assertEqual(2 + 2, 4)
def test_divisao_por_zero(self):
with self.assertRaises(ZeroDivisionError):
resultado = 10 / 0
if __name__ == "__main__":
unittest.main()# Teste básico
📋pytest
def test_soma():
assert 2 + 2 == 4
def test_lista_vazia():
assert len([]) == 0
def test_erro_divisao():
with pytest.raises(ZeroDivisionError):
resultado = 10 / 0# Testes com pytest
📋Mock
from unittest.mock import Mock, patch
def test_api_request():
with patch("requests.get") as mock_get:
mock_response = Mock()
mock_response.json.return_value = {"status": "ok"}
mock_get.return_value = mock_response
resultado = fazer_requisicao_api()
assert resultado["status"] == "ok"# Mock de API
📋Fixtures
@pytest.fixture
def cliente_db():
# Configuração do banco de teste
conexao = conectar_banco_teste()
yield conexao
# Limpeza após o teste
conexao.close()
def test_inserir_usuario(cliente_db):
usuario = {"nome": "João", "email": "joao@email.com"}
resultado = cliente_db.inserir(usuario)
assert resultado["sucesso"] == True# Fixture pytest
⚡ Performance e Otimização
Use quando: Aplicações críticas, processamento intenso, otimização
📋Profiling
import cProfile
import time
def funcao_lenta():
time.sleep(1)
return "Pronto"
cProfile.run("funcao_lenta()")# Profile básico
import timeit
tempo = timeit.timeit(
"sum(range(1000))",
number=1000
)
print(f"Tempo médio: {tempo/1000:.6f}s")# Medir tempo
📋Otimizações
# Lento
resultado = []
for i in range(10000):
resultado.append(i * 2)
# Rápido
resultado = [i * 2 for i in range(10000)]# List comprehension
# Lento
if chave in dicionario:
valor = dicionario[chave]
else:
valor = valor_padrao
# Rápido
valor = dicionario.get(chave, valor_padrao)# get() vs in
📋Memória
import sys
lista = list(range(1000))
print(f"Tamanho: {sys.getsizeof(lista)} bytes")# Medir memória
import gc
# Forçar coleta de lixo
gc.collect()
print(f"Objetos coletados: {gc.garbage}")# Garbage collector
📋Numba e Cython
from numba import jit
@jit
def soma_rapida(n):
total = 0
for i in range(n):
total += i
return total# Numba JIT
🤝 Contribuindo
Encontrou um erro? Quer melhorar um cheatsheet? Tem uma sugestão? Adoraríamos suas contribuições! Abra uma issue ou submeta um PR.
Gostou do projeto? Apoie o desenvolvimento com um café e ajude a manter tudo open source ☕