Noções Básicas de Python

10 exemplos para você começar com os fundamentos de Python - 7 básicos e 3 intermediários.

Pré-requisitos

• Python 3.14.0 instalado (python3 --version).
• Opcional: crie um ambiente isolado com uv venv ou python -m venv .venv antes de instalar pacotes.

Exemplos Básicos

1. Olá e o REPL

Execute Python interativamente ou como um script.

# hello.py
def main() -> None:
    name = "world"
    print(f"Hello, {name}!")
 
if __name__ == "__main__":
    main()

• python3 hello.py executa o script; python3 sozinho abre o REPL.
• if __name__ == "__main__" protege o código que deve ser executado apenas quando diretamente invocado.
• Use o REPL para sondar APIs antes de escrever um módulo completo.

2. Variáveis e Tipagem Dinâmica

Nomes se referem a objetos; tipos vivem nos objetos, não nos nomes.

count = 10          # int
count = "ten"       # agora str - legal em Python
items: list[int] = [1, 2, 3]  # dica de tipo opcional; a execução ainda é dinâmica

• Atribuição liga um nome a um objeto - não declara um tipo fixo.
• Dicas de tipo são para verificadores estáticos (mypy, pyright), não para imposição em tempo de execução.
• is testa a identidade do objeto; == testa a igualdade de valor.

Relacionado: Variáveis, Tipos e Tipagem Dinâmica - semântica de referência

3. Números e Booleanos

Inteiros têm precisão arbitrária; floats seguem IEEE 754.

big = 10**100
ratio = 1 / 3
truthy = bool("non-empty")  # True
falsy = bool("")            # False

• // é divisão inteira (floor division); / sempre retorna float em Python 3.
• Decimal e Fraction evitam surpresas com floats para dinheiro e razões.
• Números diferentes de zero e contêineres não vazios são "truthy" em condições if.

Relacionado: Números, Booleanos e Aritmética - armadilhas de Decimal e float

4. Strings e f-strings

Formate texto com expressões inline legíveis.

user = "Ada"
score = 98.5
msg = f"{user} scored {score:.1f}%"
escaped = r"C:\new\path"  # string raw - barras invertidas literais

• f-strings avaliam em tempo de execução e suportam especificadores de formato (:.2f, :,).
• str é texto Unicode; bytes é binário bruto - decodifique explicitamente com uma codificação.
• Strings com aspas triplas preservam novas linhas para docstrings e SQL.

Relacionado: Strings e f-strings - Unicode e bytes

5. Fluxo de Controle com if e for

Ramifique e itere com blocos baseados em indentação do Python.

values = [1, 2, 3, 4]
evens = []
for n in values:
    if n % 2 == 0:
        evens.append(n)
else:
    print("loop finished")  # executa quando o loop completa sem break

• Indentação (4 espaços típico) define o escopo do bloco - sem chaves.
• for itera sobre qualquer iterável, não apenas listas.
• else em um loop for executa apenas se o loop não usou break.

Relacionado: Fluxo de Controle - match/case e while

6. match / case (Correspondência Estrutural de Padrões)

Corresponda à forma, não apenas ao valor (Python 3.10+).

def describe(value: object) -> str:
    match value:
        case int(n) if n < 0:
            return "negative int"
        case int(n):
            return f"int {n}"
        case [first, *rest]:
            return f"list starting with {first}"
        case {"id": int(uid), "name": str(name)}:
            return f"user {uid}: {name}"
        case _:
            return "something else"

• Padrões podem desestruturar listas, dicionários e objetos.
• case _ é o fallback curinga.
• Prefira match ao ramificar com base na estrutura; use if/elif para booleanos simples.

Relacionado: Fluxo de Controle - guia completo de match

7. Compreensão de Lista

Construa listas declarativamente em uma única expressão.

squares = [n * n for n in range(10) if n % 2]
mapping = {name: len(name) for name in ["ada", "linus", "guido"]}
unique_lengths = {len(name) for name in ["ada", "linus"]}

• Compreensões são frequentemente mais rápidas e claras que loops append manuais.
• Compreensões de dicionário e conjunto usam sintaxe {chave: valor} e {item}, respectivamente.
• Use uma expressão geradora (x for x in items) quando precisar apenas de iteração preguiçosa.

Relacionado: Compreensões e Expressões Geradoras - quando preferir geradores

Exemplos Intermediários

8. Funções com Argumentos Flexíveis

Aceite parâmetros posicionais, de palavra-chave e variádicos.

def connect(host: str, port: int = 443, **options: object) -> dict:
    return {"host": host, "port": port, **options}
 
def total(*amounts: float, tax: float = 0.0) -> float:
    return sum(amounts) * (1 + tax)
 
connect("api.example.com", timeout=5, verify=True)
total(10.0, 20.0, tax=0.08)

• Parâmetros após * são apenas de palavra-chave (tax em total).
• **options coleta argumentos de palavra-chave extras em um dicionário.
• Argumentos mutáveis padrão (=[]) são um bug comum - use None e atribua dentro.

Relacionado: Funções, Args e Escopo - regras de escopo LEGB

9. Módulos e Imports

Organize o código em módulos e pacotes reutilizáveis.

# Em myapp/utils.py
def slugify(text: str) -> str:
    return text.lower().replace(" ", "-")
 
# Em myapp/main.py
from myapp.utils import slugify
 
print(slugify("Hello World"))

• Cada arquivo .py é um módulo; pastas com __init__.py (ou pacotes de namespace) formam pacotes.
• Prefira imports absolutos (from myapp.utils import ...) em código de aplicação.
• Execute como um módulo com python -m myapp.main para que os imports resolvam corretamente.

Relacionado: Módulos, Imports e Pacotes - evitando importações circulares

10. Arquivos com pathlib e Gerenciadores de Contexto

Leia e escreva arquivos com segurança com limpeza automática.

from pathlib import Path
 
config_path = Path("config.json")
config_path.write_text('{"debug": true}', encoding="utf-8")
data = config_path.read_text(encoding="utf-8")
 
with Path("log.txt").open("a", encoding="utf-8") as fh:
    fh.write("started\n")

• pathlib.Path envolve caminhos do SO com uma API consistente.
• Sempre passe encoding="utf-8" para arquivos de texto em todas as plataformas.
• with garante que os arquivos sejam fechados mesmo quando uma exceção ocorre.

Relacionado: Arquivos e I/O - I/O binário e codificações

Versões da Stack: Esta página foi escrita para Python 3.14.0 (estável 3.14, manutenção 3.13), FastAPI 0.115+, Django 5.2, Flask 3.1, Pydantic 2, PyTorch 2.6+, pandas 2.2+, Polars 1.x, ruff 0.9+ e uv 0.6+.