Python oferece operadores aritméticos comuns como soma (+), subtração (-), multiplicação (*), divisão real (/), divisão inteira (//), módulo (%) e exponenciação (**).

Estruturas condicionais podem ser escritas de forma compacta:

menor = a if a < b else b

O comando assert interrommpe a execução caso a expressão avalie como falsa, sendo útil para depuração.

Laços de repetição incluem while e for, este último frequnetemente combinado com range(inicio, parada, passo):

for elemento in range(1, 10, 2):
    print(elemento)

Trabalhando com Listas

Listas são estruturas mutáveis que armazenam múltiplos elementos:

nomes = ["Ana", "Bruno", "Carla"]
nomes.append("Diego")
nomes.extend(["Eva", "Felipe"])
nomes.insert(0, "Primeiro")

Para remover elementos, utilize remove(), pop() ou del:

nomes.remove("Diego")
removido = nomes.pop()
del nomes[0]

Fatiamento permite extrair porções da lista:

subconjunto = nomes[1:3]  # índice 1 até 2

Métodos auxiliares: count() conta ocorrências, index() retorna o índice, reverse() inverte, sort() ordena.

Tuplas, Strings e Sequências

Tuplas são imutáveis e definidas por vírgulas:

coordenadas = (10, 20)
ponto = 5, 10

Strings possuem diversos métodos integrados como capitalize(), casefold(), center(), count(), find(), join(), strip(), entre outros.

Formatação de strings:

"{0} adora {1}".format("Eu", "Python")
"{valor:.2f} GB".format(valor=23.5)

Operações comuns a sequências: max(), min(), sorted(), reversed(), enumerate(), zip().

Funções

Definição básica:

def somar(a, b):
    return a + b

Parâmetros variáveis:

def processar(*argumentos):
    print(f"Total: {len(argumentos)}")

Funções anônimas com lambda:

operacao = lambda x, y: x * y

filter() filtra elementos, map() aplica transformações:

numeros = [1, 2, 3, 4, 5]
pares = list(filter(lambda n: n % 2 == 0, numeros))
dobrados = list(map(lambda n: n * 2, numeros))

Recursão:

def fatorial(numero):
    if numero <= 1:
        return 1
    return numero * fatorial(numero - 1)

Variáveis Globais, Escopo e Closure

def modificar_global():
    global contador
    contador = 10

contador = 1
modificar_global()

Funções aninhadas e uso de nonlocal:

def externa():
    valor = 5
    def interna():
        nonlocal valor
        valor *= valor
        return valor
    return interna()

Dicionários e Conjuntos

dicionario = {"chave": "valor"}
criado = dict.fromkeys(["a", "b", "c"], "padrao")

Conjuntos contêm apenas elementos únicos. frozenset cria conjuntos imutáveis:

unicos = {1, 2, 3, 3}
congelado = frozenset([4, 5, 6])

Manipulação de Arquivos

arquivo = open("dados.txt", "r", encoding="utf-8")
conteudo = arquivo.read()
arquivo.close()

Modos: 'r' leitura, 'w' escrita, 'a' anexar, 'b' binário.

Uso recomendado com with:

with open("dados.txt", "w") as manipulador:
    manipulador.write("Conteúdo de exemplo")

Módulo OS

import os

os.getcwd()
os.chdir("/novo/caminho")
os.listdir()
os.makedirs("pasta/subpasta")
os.remove("arquivo.txt")
os.rename("velho.txt", "novo.txt")

O submódulo os.path oferece utilidades como join(), split(), exists(), isfile(), getsize().

Serialização com Pickle

import pickle

dados = {"nome": "Teste", "valores": [1, 2, 3]}

with open("cache.pkl", "wb") as destino:
    pickle.dump(dados, destino)

with open("cache.pkl", "rb") as origem:
    restaurado = pickle.load(origem)

Tratamento de Exceções

try:
    resultado = 10 / 0
except ZeroDivisionError as erro:
    print(f"Erro capturado: {erro}")
finally:
    print("Sempre executado")

É possível lançar exceções manualmente com raise.

Classes e Orientação a Objetos

class Animal:
    def __init__(self, nome):
        self.nome = nome

    def emitir_som(self):
        print(f"{self.nome} fez um som")

class Cachorro(Animal):
    def __init__(self, nome, raca):
        super().__init__(nome)
        self.raca = raca

    def emitir_som(self):
        print(f"{self.nome} latiu")

Atributos iniciados com duplo underscore tornam-se privados por convenção.

BIFs Relevantes para Classes

• issubclass(): verifica herança entre classes
• isinstance(): verifica o tipo de um objeto
• hasattr(), getattr(), setattr(), delattr(): manipulação dinâmica de atributos
• property(): define propriedades gerenciadas

Métodos Mágicos

Construção e Destruição

class Exemplo:
    def __new__(cls, *argumentos):
        instancia = super().__new__(cls)
        return instancia

    def __init__(self):
        print("Objeto criado")

    def __del__(self):
        print("Objeto destruído")

Operadores Aritméticos

class NumeroPersonalizado:
    def __init__(self, valor):
        self.valor = valor

    def __add__(self, outro):
        return NumeroPersonalizado(self.valor + outro.valor)

    def __mul__(self, outro):
        return NumeroPersonalizado(self.valor * outro.valor)

    def __str__(self):
        return f"Valor: {self.valor}"

Acesso a Atributos

class Configuracao:
    def __getattr__(self, nome):
        print(f"Atributo '{nome}' não existe")

    def __setattr__(self, nome, valor):
        print(f"Definindo {nome} = {valor}")
        super().__setattr__(nome, valor)

    def __delattr__(self, nome):
        print(f"Removendo {nome}")
        super().__delattr__(nome)

Propriedades com property()

class Retangulo:
    def __init__(self):
        self._largura = 0

    def obter_largura(self):
        return self._largura

    def definir_largura(self, valor):
        self._largura = valor

    def deletar_largura(self):
        del self._largura

    largura = property(obter_largura, definir_largura, deletar_largura)

Descrição (Descriptors)

class Validador:
    def __get__(self, instancia, proprietario):
        return instancia._valor

    def __set__(self, instancia, valor):
        if valor < 0:
            raise ValueError("Valor negativo não permitido")
        instancia._valor = valor

    def __delete__(self, instancia):
        del instancia._valor

Sequências Personalizadas

Método	Finalidade
__len__	Comportamento de len()
__getitem__	Acesso por índice obj[chave]
__setitem__	Atribuição obj[chave] = valor
__delitem__	Remoção del obj[chave]
__iter__	Retorna iterador
__contains__	Operador in

class ListaRastreadora:
    def __init__(self, *elementos):
        self._dados = list(elementos)
        self._acessos = {}

    def __len__(self):
        return len(self._dados)

    def __getitem__(self, indice):
        self._acessos[indice] = self._acessos.get(indice, 0) + 1
        return self._dados[indice]

Iteradores e Geradores

Iteradores implementam __iter__ e __next__:

class Fibonacci:
    def __init__(self, limite=100):
        self._limite = limite
        self._anterior = 0
        self._atual = 1

    def __iter__(self):
        return self

    def __next__(self):
        if self._atual > self._limite:
            raise StopIteration
        resultado = self._atual
        self._anterior, self._atual = self._atual, self._anterior + self._atual
        return resultado

Geradores utilizam yield:

def contador():
    yield "primeiro"
    yield "segundo"

gerador = contador()
print(next(gerador))
print(next(gerador))

Compreensões de lista, dicionário, conjunto e geradores:

pares = [n for n in range(50) if n % 2 == 0]
mapa = {k: k**2 for k in range(10)}
unicos = {x for x in [1, 1, 2, 3, 3]}
lazy = (n for n in range(100))

Módulos e Importação

import modulo_exemplo
from modulo_exemplo import funcao_especifica
import modulo_exemplo as alias

Verificação de execução direta:

if __name__ == "__main__":
    executar_principal()

Caminhos de busca de módulos:

import sys
print(sys.path)

Web Scraping com urllib

import urllib.request
import urllib.parse

resposta = urllib.request.urlopen("https://www.exemplo.com")
html = resposta.read().decode("utf-8")

# Configurando proxy
proxy = urllib.request.ProxyHandler({"http": "127.0.0.1:8080"})
abridor = urllib.request.build_opener(proxy)
urllib.request.install_opener(abridor)

Interface Gráfica com Tkinter

import tkinter as tk

class Aplicacao:
    def __init__(self, janela):
        self.frame = tk.Frame(janela)
        self.frame.pack(padx=20, pady=20)

        self.botao = tk.Button(
            self.frame,
            text="Clique aqui",
            command=self.responder
        )
        self.botao.pack()

    def responder(self):
        print("Botão acionado")

raiz = tk.Tk()
app = Aplicacao(raiz)
raiz.mainloop()

Desevnolvimento de Jogos com Pygame

import pygame
import sys

pygame.init()
dimensoes = largura, altura = 800, 600
velocidade = [3, 2]
cor_fundo = (240, 240, 240)

tela = pygame.display.set_mode(dimensoes)
pygame.display.set_caption("Minha Aplicação Pygame")

sprite = pygame.image.load("sprite.png")
posicao = sprite.get_rect()

while True:
    for evento in pygame.event.get():
        if evento.type == pygame.QUIT:
            sys.exit()

    posicao = posicao.move(velocidade)

    if posicao.left < 0 or posicao.right > largura:
        velocidade[0] = -velocidade[0]
        sprite = pygame.transform.flip(sprite, True, False)

    if posicao.top < 0 or posicao.bottom > altura:
        velocidade[1] = -velocidade[1]

    tela.fill(cor_fundo)
    tela.blit(sprite, posicao)
    pygame.display.flip()
    pygame.time.delay(20)

Tipos de Dados Básicos

Python possui inteiros (int), booleanos (bool), decimais (float) e strings (str). Conversões entre tipos:

numero = int("42")
texto = str(100)
decimal = float("3.14")

Verificação de tipos:

type(variavel)
isinstance(valor, int)

Métodos de string para validação: isalnum(), isalpha(), isdigit(), islower(), isupper(), isspace().

Primeiro Programa e BIFs

palpite = int(input("Digite um número entre 1 e 10: "))
if palpite == 7:
    print("Acertou!")
else:
    print("Errou! Era 7.")
print("Fim do jogo")

BIFs (Built-in Functions) podem ser listadas com dir(__builtins__) e examinadas com help().