Cheatsheet Python para Iniciantes

Variáveis e Tipos

# Variáveis são como caixas para guardar coisas!

# Texto (strings) - usamos aspas
nome = "Maria"
comida_favorita = "pizza"

# Números inteiros
idade = 10
numero_irmaos = 2

# Números com decimais (float)
altura = 1.45
peso = 35.5

# Verdadeiro ou Falso (booleanos)
gosta_de_chocolate = True
gosta_de_brocolis = False

# Mostrar na tela
print(nome)  # Mostra: Maria
print("Eu tenho", idade, "anos")  # Mostra: Eu tenho 10 anos

Manipulação de Strings

# Strings são textos entre aspas

# Juntar textos (concatenação)
primeiro_nome = "Lucas"
sobrenome = "Silva"
nome_completo = primeiro_nome + " " + sobrenome
print(nome_completo)  # Lucas Silva

# Deixar tudo em MAIÚSCULAS
grito = "olá mundo".upper()
print(grito)  # OLÁ MUNDO

# Deixar tudo em minúsculas
sussurro = "CUIDADO!".lower()
print(sussurro)  # cuidado!

# Substituir partes do texto
frase = "Eu gosto de maçãs"
nova_frase = frase.replace("maçãs", "bananas")
print(nova_frase)  # Eu gosto de bananas

# Formato fácil (f-strings)
animal = "gato"
idade_animal = 3
print(f"Meu {animal} tem {idade_animal} anos")

Estruturas de Controle

# if, elif e else - tomar decisões!

idade = 12

if idade < 13:
    print("Você é criança!")
elif idade < 18:
    print("Você é adolescente!")
else:
    print("Você é adulto!")

# Comparações
tem_dinheiro = True
tem_fome = True

if tem_dinheiro and tem_fome:
    print("Vamos comprar um lanche!")

Funções Básicas

# Funções - como receitas de bolo!

# Função simples
def dizer_oi(nome):
    print(f"Oi, {nome}!")

# Usar a função
dizer_oi("Ana")  # Mostra: Oi, Ana!

# Função que retorna valor
def somar(a, b):
    return a + b

resultado = somar(5, 3)
print(resultado)  # Mostra: 8

Loops - For

# Loop for - repetir algo várias vezes!

# Contar de 1 até 5
for numero in range(1, 6):
    print(numero)

# Loop em uma lista
frutas = ["maçã", "banana", "laranja"]
for fruta in frutas:
    print(f"Eu gosto de {fruta}")

Loops - While

# Loop while - repetir enquanto algo for verdadeiro

contador = 1
while contador <= 5:
    print(contador)
    contador += 1

# Jogo de adivinhar
numero_secreto = 7
while True:
    palpite = int(input("Adivinhe o número (1-10): "))
    if palpite == numero_secreto:
        print("Parabéns! Você acertou!")
        break

Listas e Tuplas

# Listas - coleção de itens que pode mudar

notas = [7, 8.5, 9.5, 10]
amigos = ["João", "Maria", "Pedro"]

# Adicionar item no final
amigos.append("Ana")

# Remover item
amigos.remove("Pedro")

# Tuplas - coleção que não pode mudar
coordenadas = (10, 20)
cores_rgb = (255, 128, 0)

Dicionários

# Dicionários - pares de chave e valor

aluno = {
    "nome": "João",
    "idade": 12,
    "notas": [8, 9, 7.5]
}

# Acessar valores
print(aluno["nome"])  # João

# Adicionar novo par
aluno["cidade"] = "São Paulo"

# Remover par
del aluno["idade"]

Tratamento de Erros

# Try/Except - como uma rede de segurança!

# Divisão segura
try:
    numero = int(input("Digite um número: "))
    resultado = 10 / numero
    print(f"10 dividido por {numero} é {resultado}")
except ValueError:
    print("Ops! Digite um número válido!")
except ZeroDivisionError:
    print("Não podemos dividir por zero!")
finally:
    print("Fim do programa!")

JSON

# JSON - como guardar informações em formato de texto

import json

# Criar um dicionário de jogador
jogador = {
    "nome": "Mario",
    "vidas": 3,
    "itens": ["cogumelo", "estrela"],
    "ativo": True
}

# Salvar em arquivo JSON
with open('jogador.json', 'w') as arquivo:
    json.dump(jogador, arquivo)

# Ler do arquivo JSON
with open('jogador.json', 'r') as arquivo:
    dados = json.load(arquivo)
    print(dados["nome"])

Expressões Regulares

# Regex - encontrar padrões em texto

import re

# Procurar um padrão
texto = "Meu número é 123-456-789"
padrao = r"\d{3}-\d{3}-\d{3}"  # Procura números no formato xxx-xxx-xxx

# Encontrar o número
numero = re.search(padrao, texto)
print(numero.group())  # 123-456-789

# Encontrar emails em um texto
texto = "Contatos: ana@email.com e joao@email.com"
emails = re.findall(r"\w+@\w+\.\w+", texto)
print(emails)  # ['ana@email.com', 'joao@email.com']

Decoradores

# Decoradores - como embrulhos mágicos para funções!

def falar_alto(funcao):
    def wrapper():
        resultado = funcao()
        return resultado.upper()
    return wrapper

# Usar o decorador
@falar_alto
def dizer_oi():
    return "olá, mundo!"

print(dizer_oi())  # OLÁ, MUNDO!

Funções Lambda

# Funções Lambda - funções pequenas e rápidas!

# Função normal
def dobrar(x):
    return x * 2

# Mesma função como lambda
dobrar = lambda x: x * 2

# Usar com map para dobrar todos os números
numeros = [1, 2, 3, 4]
dobrados = list(map(lambda x: x * 2, numeros))
print(dobrados)  # [2, 4, 6, 8]

# Filtrar números pares
pares = list(filter(lambda x: x % 2 == 0, numeros))
print(pares)  # [2, 4]

Geradores

# Geradores - criam valores um por um

def contar_ate(n):
    i = 1
    while i <= n:
        yield i
        i += 1

# Usar o gerador
for numero in contar_ate(5):
    print(numero)

# Gerador de tabuada
def tabuada(n):
    for i in range(1, 11):
        yield f"{n} x {i} = {n * i}"

for linha in tabuada(7):
    print(linha)

Testes Automatizados

# Testes - verificar se o código funciona corretamente

import unittest

# Função que vamos testar
def somar(a, b):
    return a + b

# Classe de teste
class TesteSoma(unittest.TestCase):
    def test_soma_positivos(self):
        resultado = somar(2, 3)
        self.assertEqual(resultado, 5)
    
    def test_soma_negativos(self):
        resultado = somar(-1, -1)
        self.assertEqual(resultado, -2)

# Rodar os testes
if __name__ == '__main__':
    unittest.main()

Threading

# Threading - fazer várias coisas ao mesmo tempo!

import threading
import time

def fazer_tarefa(nome, tempo):
    print(f"Começando tarefa {nome}")
    time.sleep(tempo)  # Simula trabalho
    print(f"Terminando tarefa {nome}")

# Criar threads
t1 = threading.Thread(target=fazer_tarefa, args=("A", 2))
t2 = threading.Thread(target=fazer_tarefa, args=("B", 1))

# Iniciar threads
t1.start()
t2.start()

# Esperar threads terminarem
t1.join()
t2.join()

Web Scraping

# Web Scraping - pegar informações de sites

from bs4 import BeautifulSoup
import requests

# Pegar conteúdo de uma página web
url = "https://exemplo.com"
pagina = requests.get(url)

# Criar o objeto BeautifulSoup
soup = BeautifulSoup(pagina.content, 'html.parser')

# Encontrar elementos
titulos = soup.find_all('h1')
for titulo in titulos:
    print(titulo.text)

APIs e Requests

# APIs - conversar com outros programas na internet

import requests

# Fazer uma requisição GET
resposta = requests.get('https://api.exemplo.com/dados')

# Verificar se deu certo
if resposta.status_code == 200:
    dados = resposta.json()
    print(dados)

# Enviar dados (POST)
novo_item = {'nome': 'Teste', 'valor': 42}
resposta = requests.post('https://api.exemplo.com/criar', 
                            json=novo_item)

Flask

# Flask - criar sites e APIs

from flask import Flask, jsonify

# Criar aplicação
app = Flask('minha_api')

# Criar uma rota
@app.route('/')
def home():
    return "Bem-vindo à minha API!"

@app.route('/dados')
def get_dados():
    dados = {
        "nome": "Python",
        "tipo": "Linguagem"
    }
    return jsonify(dados)

# Rodar o servidor
if __name__ == '__main__':
    app.run(debug=True)

Banco de Dados SQLite

# SQLite - guardar dados em um banco

import sqlite3

# Conectar ao banco
conn = sqlite3.connect('dados.db')
cursor = conn.cursor()

# Criar uma tabela
cursor.execute('''
CREATE TABLE IF NOT EXISTS usuarios (
    id INTEGER PRIMARY KEY,
    nome TEXT,
    idade INTEGER
)''')

# Inserir dados
cursor.execute('INSERT INTO usuarios (nome, idade) VALUES (?, ?)',
                 ('Ana', 25))

# Salvar mudanças
conn.commit()

# Buscar dados
cursor.execute('SELECT * FROM usuarios')
usuarios = cursor.fetchall()

# Fechar conexão
conn.close()

Comandos Git

# Git - controle de versão do código

# Iniciar um repositório
$ git init

# Ver status das mudanças
$ git status

# Adicionar arquivos
$ git add arquivo.py
$ git add .  # adiciona todos os arquivos

# Criar um commit
$ git commit -m "Primeira versão do código"

# Ver histórico
$ git log

# Criar e mudar de branch
$ git branch nova-funcionalidade
$ git checkout nova-funcionalidade

Machine Learning

# Machine Learning - ensinar o computador a aprender!

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression

# Carregar dados
dados = pd.read_csv('dados.csv')

# Preparar dados
X = dados[['tamanho', 'quartos']]
y = dados['preco']

# Dividir em treino e teste
X_treino, X_teste, y_treino, y_teste = train_test_split(X, y)

# Treinar modelo
modelo = LinearRegression()
modelo.fit(X_treino, y_treino)

# Fazer previsões
previsoes = modelo.predict(X_teste)

Context Managers

# Context Managers - gerenciar recursos com segurança

class MinhaConexao:
    def __enter__(self):
        print("Abrindo conexão...")
        return self
    
    def __exit__(self, type, value, traceback):
        print("Fechando conexão...")

# Usar o context manager
with MinhaConexao() as conn:
    print("Fazendo algo com a conexão")

# Context manager para arquivo
with open('arquivo.txt', 'w') as f:
    f.write("Olá, mundo!")

Subprocess

# Subprocess - executar comandos do sistema

import subprocess

# Executar um comando simples
resultado = subprocess.run(['ls', '-l'], 
                              capture_output=True, 
                              text=True)

print(resultado.stdout)

# Executar comando com pipe
processo = subprocess.Popen(['echo', 'Olá!'],
                              stdout=subprocess.PIPE,
                              text=True)

saida, erro = processo.communicate()

Itertools

# Itertools - ferramentas para trabalhar com iterações

from itertools import count, cycle, repeat, combinations

# Contador infinito
for i in count(1):
    if i > 5:
        break
    print(i)

# Ciclo de elementos
cores = cycle(['vermelho', 'verde', 'azul'])
for _ in range(6):
    print(next(cores))

# Combinações
letras = ['A', 'B', 'C']
for combo in combinations(letras, 2):
    print(combo)

Herança

# Herança - classes que herdam características de outras

class Animal:
    def __init__(self, nome):
        self.nome = nome
    
    def fazer_som(self):
        print("Som genérico de animal")

class Gato(Animal):
    def fazer_som(self):
        print("Miau!")

class Cachorro(Animal):
    def fazer_som(self):
        print("Au au!")

# Criar animais
meu_gato = Gato("Frajola")
meu_cachorro = Cachorro("Rex")

meu_gato.fazer_som()  # Miau!
meu_cachorro.fazer_som()  # Au au!

Métodos Especiais

# Métodos especiais - dão superpoderes às classes!

class Carta:
    def __init__(self, valor, naipe):
        self.valor = valor
        self.naipe = naipe
    
    def __str__(self):
        return f"{self.valor} de {self.naipe}"
    
    def __lt__(self, outra):
        valores = {'J': 11, 'Q': 12, 'K': 13, 'A': 14}
        v1 = valores.get(self.valor, int(self.valor))
        v2 = valores.get(outra.valor, int(outra.valor))
        return v1 < v2

# Usar a classe
carta1 = Carta('A', '♠')
carta2 = Carta('7', '♥')

print(carta1)  # A de ♠
print(carta2 < carta1)  # True

Decoradores Avançados

# Decoradores com parâmetros

def repetir(vezes):
    def decorador(func):
        def wrapper(*args, **kwargs):
            for _ in range(vezes):
                resultado = func(*args, **kwargs)
            return resultado
        return wrapper
    return decorador

# Usar o decorador
@repetir(3)
def saudacao(nome):
    print(f"Olá, {nome}!")

saudacao("Maria")  # Imprime 3 vezes

Geradores Avançados

# Geradores com pipeline

def numeros():
    n = 0
    while True:
        yield n
        n += 1

def pares(sequencia):
    for num in sequencia:
        if num % 2 == 0:
            yield num

def multiplica_por(sequencia, n):
    for num in sequencia:
        yield num * n

# Usar os geradores em pipeline
nums = numeros()  # Gera números infinitos
nums_pares = pares(nums)  # Filtra só os pares
nums_dobro = multiplica_por(nums_pares, 2)  # Dobra cada número

# Pegar os primeiros 5 resultados
for _, num in zip(range(5), nums_dobro):
    print(num)

FastAPI

# FastAPI - criar APIs rápidas e modernas

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    nome: str
    preco: float

# Rota GET simples
@app.get("/")
def ler_raiz():
    return {"mensagem": "Olá Mundo!"}

# Rota POST com validação
@app.post("/items/")
def criar_item(item: Item):
    return item

Pandas

# Pandas - trabalhar com dados em tabelas

import pandas as pd

# Criar um DataFrame
dados = {
    'nome': ['Ana', 'João', 'Maria'],
    'idade': [25, 30, 28],
    'cidade': ['SP', 'RJ', 'MG']
}
df = pd.DataFrame(dados)

# Filtrar dados
jovens = df[df['idade'] < 30]

# Agrupar e calcular média
media_idade = df.groupby('cidade')['idade'].mean()

Numpy

# Numpy - trabalhar com arrays e matemática

import numpy as np

# Criar arrays
arr1 = np.array([1, 2, 3, 4, 5])
arr2 = np.zeros(5)
arr3 = np.random.rand(5)

# Operações com arrays
soma = arr1 + 10  # Soma 10 a cada elemento
media = np.mean(arr1)  # Calcula média
max_val = np.max(arr1)  # Encontra maior valor

Asyncio

# Asyncio - programação assíncrona

import asyncio

async def fazer_cafe():
    print("Começando a fazer café...")
    await asyncio.sleep(2)  # Simula espera
    return "Café pronto!"

async def fazer_torrada():
    print("Fazendo torrada...")
    await asyncio.sleep(1)
    return "Torrada pronta!"

async def cafe_da_manha():
    cafe, torrada = await asyncio.gather(
        fazer_cafe(),
        fazer_torrada()
    )
    print(cafe, torrada)

# Rodar o programa assíncrono
asyncio.run(cafe_da_manha())

Sockets

# Sockets - comunicação entre computadores

import socket

# Criar um servidor
servidor = socket.socket()
servidor.bind(('localhost', 12345))
servidor.listen(5)

while True:
    cliente, endereco = servidor.accept()
    dados = cliente.recv(1024)
    print(f"Recebido: {dados.decode()}")
    cliente.send("Mensagem recebida!".encode())
    cliente.close()

Input e Output

# Como receber dados do usuário

# Pedir um texto
nome = input("Qual é seu nome? ")
print(f"Olá, {nome}!")

# Pedir um número
idade = int(input("Quantos anos você tem? "))
print(f"Daqui a 5 anos você terá {idade + 5} anos")

Tratamento de Erros Básico

# Como lidar com erros simples

try:
    numero = int(input("Digite um número: "))
    resultado = 10 / numero
except ValueError:
    print("Isso não é um número!")
except ZeroDivisionError:
    print("Não posso dividir por zero!")

Arquivos Simples

# Trabalhar com arquivos de texto

# Escrever em um arquivo
with open('notas.txt', 'w') as arquivo:
    arquivo.write("Primeira linha\n")
    arquivo.write("Segunda linha\n")

# Ler de um arquivo
with open('notas.txt', 'r') as arquivo:
    conteudo = arquivo.read()
    print(conteudo)

Cheatsheet em Python

Variáveis e Tipos

Manipulação de Strings

Estruturas de Controle

Funções Básicas

Loops - For

Loops - While

Listas e Tuplas

Dicionários

Tratamento de Erros

JSON

Expressões Regulares

Decoradores

Funções Lambda

Geradores

Testes Automatizados

Threading

Web Scraping

APIs e Requests

Flask

Banco de Dados SQLite

Comandos Git

Machine Learning

Context Managers

Subprocess

Itertools

Herança

Métodos Especiais

Decoradores Avançados

Geradores Avançados

FastAPI

Pandas

Numpy

Asyncio

Sockets

Input e Output

Tratamento de Erros Básico

Arquivos Simples