UC00618

Criar aplicações em Python

Fundamentos, OOP, bibliotecas, projectos

Curso profissional · 50h · Linguagem mais popular do mundo

Plano

  1. Por que Python
  2. Setup e sintaxe básica
  3. Estruturas de controlo
  4. Funções
  5. Estruturas de dados
  6. OOP — Programação Orientada a Objectos
  7. Bibliotecas essenciais
  8. Projecto final

Bloco 1 · Por que Python

Python — overview

  • Criado por Guido van Rossum (1991).
  • Filosofia: "There should be one obvious way to do it".
  • Sintaxe legível — quase pseudocódigo.
  • Multi-paradigma: imperativo, OOP, funcional.
  • Interpretado (não precisa compilar).
  • Dinamicamente tipado.
  • Standard library rica.
  • Comunidade massiva.

Usos

  • Web: Django, Flask, FastAPI.
  • Data Science: pandas, NumPy, scikit-learn.
  • Machine Learning: TensorFlow, PyTorch.
  • Automation / Scripting: tudo!
  • DevOps: Ansible, Fabric.
  • Education: linguagem #1 para ensino.
  • Scientific computing: SciPy.
  • Game dev: Pygame.

TIOBE Index 2026

Python é #1 linguagem mais popular do mundo há vários anos.

Vantagens carreira:

  • Vastíssimo mercado de trabalho.
  • Salários competitivos.
  • Crescimento contínuo (AI/ML).

Bloco 2 · Setup e sintaxe

Instalação

Windows / Mac / Linux:

  • Download: python.org/downloads.
  • Verificar: python --version (deve ser 3.10+).

Editor:

  • VSCode (recomendado, gratuito).
  • PyCharm (IDE poderosa).
  • Jupyter Notebook (data science).

Hello World

print("Olá, mundo!")

Correr:

python hello.py

Ou em REPL interactivo:

$ python
>>> print("Olá")
Olá
>>> 2 + 3
5

Variáveis e tipos

# Atribuição
nome = "Joana"          # str
idade = 25              # int
altura = 1.65           # float
estudante = True        # bool

# Type hints (Python 3.5+)
nome: str = "Joana"
idade: int = 25

# Multiple assignment
x, y, z = 1, 2, 3

# Constantes (convenção: maiúsculas)
PI = 3.14159

Operadores

# Aritméticos
+, -, *, /, //, %, **
# 7 / 2  → 3.5
# 7 // 2 → 3 (divisão inteira)
# 2 ** 3 → 8 (potência)

# Comparação
==, !=, <, >, <=, >=

# Lógicos
and, or, not

# Atribuição composta
x += 1   # x = x + 1
x *= 2   # x = x * 2

Strings

nome = "Python"

# Comprimento
len(nome)  # 6

# Indexing
nome[0]    # 'P'
nome[-1]   # 'n'

# Slicing
nome[0:3]  # 'Pyt'
nome[::2]  # 'Pto'

# F-strings (moderno, recomendado)
idade = 25
mensagem = f"{nome} tem {idade} anos"
# 'Python tem 25 anos'

# Métodos
"olá".upper()        # 'OLÁ'
"OLÁ".lower()        # 'olá'
"  abc  ".strip()    # 'abc'
"a,b,c".split(",")   # ['a', 'b', 'c']
",".join(['a','b'])  # 'a,b'

Bloco 3 · Estruturas de controlo

If / Elif / Else

idade = 18

if idade < 13:
    categoria = "criança"
elif idade < 18:
    categoria = "adolescente"
elif idade < 65:
    categoria = "adulto"
else:
    categoria = "sénior"

print(f"És {categoria}")

Indentação importante (4 espaços standard).

For

# Iterar lista
for fruta in ["maçã", "banana", "laranja"]:
    print(fruta)

# Range
for i in range(5):       # 0 a 4
    print(i)

for i in range(2, 10):   # 2 a 9
    print(i)

for i in range(0, 20, 2):  # 0, 2, 4...18
    print(i)

# Enumerate (índice + valor)
for i, fruta in enumerate(["maçã", "banana"]):
    print(f"{i}: {fruta}")

While

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

# Break / Continue
while True:
    resposta = input("Continuar? (s/n): ")
    if resposta == "n":
        break
    if resposta != "s":
        continue
    print("Continuando...")

Try / Except

try:
    numero = int(input("Número: "))
    resultado = 10 / numero
    print(resultado)
except ValueError:
    print("Não é número!")
except ZeroDivisionError:
    print("Não dividir por zero!")
except Exception as e:
    print(f"Erro: {e}")
finally:
    print("Sempre executa")

Bloco 4 · Funções

Definir funções

def saudar(nome):
    return f"Olá, {nome}!"

# Chamar
mensagem = saudar("Ana")
print(mensagem)  # Olá, Ana!

# Parâmetros default
def saudar(nome, saudacao="Olá"):
    return f"{saudacao}, {nome}!"

saudar("Ana")           # Olá, Ana!
saudar("Ana", "Hi")     # Hi, Ana!

# Type hints
def soma(a: int, b: int) -> int:
    return a + b

Argumentos variáveis

# *args (tupla)
def soma_todos(*numeros):
    return sum(numeros)

soma_todos(1, 2, 3, 4)  # 10

# **kwargs (dict)
def info(**dados):
    for chave, valor in dados.items():
        print(f"{chave}: {valor}")

info(nome="Ana", idade=25)
# nome: Ana
# idade: 25

Lambda

# Funções anónimas
quadrado = lambda x: x ** 2
quadrado(5)  # 25

# Com map / filter / sorted
numeros = [1, 2, 3, 4, 5]
quadrados = list(map(lambda x: x**2, numeros))
# [1, 4, 9, 16, 25]

pares = list(filter(lambda x: x % 2 == 0, numeros))
# [2, 4]

Bloco 5 · Estruturas de dados

Listas

frutas = ["maçã", "banana", "laranja"]

# Acesso
frutas[0]              # "maçã"
frutas[-1]             # "laranja"

# Adicionar
frutas.append("uva")
frutas.insert(0, "kiwi")

# Remover
frutas.remove("banana")
del frutas[0]
ultima = frutas.pop()

# Ordenar
frutas.sort()
frutas.sort(reverse=True)

# List comprehension
quadrados = [x**2 for x in range(10)]
pares = [x for x in range(20) if x % 2 == 0]

Tuplos

# Imutáveis
ponto = (3, 4)
x, y = ponto  # unpacking

# Útil para retornar múltiplos valores
def dividir(a, b):
    return a // b, a % b

q, r = dividir(17, 5)  # q=3, r=2

Dicionários

pessoa = {
    "nome": "Ana",
    "idade": 25,
    "cidade": "Lisboa"
}

# Acesso
pessoa["nome"]            # "Ana"
pessoa.get("email", "N/A")  # "N/A" se não existe

# Adicionar / modificar
pessoa["email"] = "ana@x.pt"
pessoa["idade"] = 26

# Iterar
for chave, valor in pessoa.items():
    print(f"{chave}: {valor}")

# Dict comprehension
quadrados = {x: x**2 for x in range(5)}
# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

Sets

# Conjuntos (sem duplicados, sem ordem)
numeros = {1, 2, 3, 2, 1}
print(numeros)  # {1, 2, 3}

# Operações
a = {1, 2, 3}
b = {2, 3, 4}
a | b  # união: {1, 2, 3, 4}
a & b  # intersecção: {2, 3}
a - b  # diferença: {1}

Bloco 6 · OOP

Classes

class Pessoa:
    # Construtor
    def __init__(self, nome, idade):
        self.nome = nome
        self.idade = idade
    
    # Método
    def saudar(self):
        return f"Olá, sou {self.nome}"
    
    # String representation
    def __repr__(self):
        return f"Pessoa({self.nome}, {self.idade})"

# Criar instâncias
ana = Pessoa("Ana", 25)
print(ana.saudar())  # Olá, sou Ana
print(ana)           # Pessoa(Ana, 25)

Herança

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

class Cao(Animal):
    def fala(self):
        return f"{self.nome}: Au au!"

class Gato(Animal):
    def fala(self):
        return f"{self.nome}: Miau!"

rex = Cao("Rex")
print(rex.fala())  # Rex: Au au!

Encapsulamento

class ContaBancaria:
    def __init__(self, titular, saldo=0):
        self.titular = titular
        self._saldo = saldo  # convenção: _privado
    
    def depositar(self, valor):
        if valor > 0:
            self._saldo += valor
    
    def levantar(self, valor):
        if 0 < valor <= self._saldo:
            self._saldo -= valor
            return True
        return False
    
    @property
    def saldo(self):
        return self._saldo

conta = ContaBancaria("Ana", 1000)
conta.depositar(500)
print(conta.saldo)  # 1500

Bloco 7 · Bibliotecas essenciais

Standard library

# Math
import math
math.sqrt(16)      # 4.0
math.pi            # 3.141592...

# Random
import random
random.randint(1, 100)
random.choice(["a", "b", "c"])
random.shuffle(lista)

# Datetime
from datetime import datetime, timedelta
agora = datetime.now()
amanha = agora + timedelta(days=1)

# OS / sys
import os
os.listdir(".")     # ficheiros na pasta
os.path.exists("file.txt")

# JSON
import json
data = json.loads('{"key": "value"}')
json_str = json.dumps(data)

Ficheiros

# Ler
with open("arquivo.txt", "r") as f:
    conteudo = f.read()
    # ou linha a linha
    for linha in f:
        print(linha)

# Escrever
with open("output.txt", "w") as f:
    f.write("Olá mundo\n")
    f.writelines(["linha 1\n", "linha 2\n"])

# CSV
import csv
with open("dados.csv") as f:
    reader = csv.DictReader(f)
    for linha in reader:
        print(linha["nome"])

pip + venv

# Criar ambiente virtual
python -m venv venv

# Activar
source venv/bin/activate    # Linux/Mac
venv\Scripts\activate       # Windows

# Instalar pacote
pip install requests
pip install pandas numpy

# Listar instalados
pip list

# Guardar dependências
pip freeze > requirements.txt

# Instalar de requirements
pip install -r requirements.txt

Bibliotecas populares

  • requests: HTTP fácil.
  • pandas: análise dados.
  • numpy: arrays numéricos.
  • matplotlib: gráficos.
  • flask / fastapi / django: web.
  • pytest: testes.
  • black: formatador.
  • selenium: automação browser.
  • beautifulsoup: web scraping.

Bloco 8 · Projecto

Tipos de projecto

  • Script: 1 ficheiro .py.
  • CLI tool: interface linha comando.
  • Web app: Flask/Django/FastAPI.
  • API REST: FastAPI.
  • Data analysis: pandas + matplotlib.
  • Bot: Discord/Telegram.
  • Game: Pygame.

Estrutura projecto

meu-projecto/
├── venv/              (não commit)
├── src/
│   ├── __init__.py
│   ├── main.py
│   └── utils.py
├── tests/
│   └── test_main.py
├── docs/
├── .gitignore
├── README.md
├── requirements.txt
└── setup.py           (se distribuir)

Boas práticas

✅ PEP 8 style guide (formatação).
✅ Type hints sempre.
✅ Docstrings em funções.
✅ Tests com pytest.
✅ Virtual environments.
✅ Black para formatar automaticamente.
✅ mypy para verificar tipos.
✅ pylint ou flake8 para lint.

UC00618 · resumo

  • Python = linguagem mais popular do mundo.
  • Sintaxe limpa: legível como pseudocódigo.
  • OOP + funcional + scripting.
  • Standard library rica.
  • Comunidade massiva com bibliotecas para tudo.
  • Web, data, AI, automation — cobre tudo.
  • PEP 8 + type hints + tests = código profissional.

NOTAS DO PROFESSOR 📖 O que define Python Importa que os formandos percebam que cada característica desta lista tem consequências práticas no dia-a-dia de quem programa. Ser interpretado e dinamicamente tipado acelera a escrita, mas obriga a testar mais. A legibilidade não é estética: reduz o custo de manter código que outros vão ler. 🗣️ Pontos a desenvolver oralmente • Contrastar interpretado vs compilado com um exemplo de ciclo editar-correr. • Explicar que "tipagem dinâmica" não significa "sem tipos" — daí os type hints mais à frente. • Dar um exemplo concreto de multi-paradigma: a mesma tarefa em estilo imperativo e funcional.

NOTAS DO PROFESSOR 📖 Versatilidade como argumento de empregabilidade Esta diversidade de áreas é o melhor argumento para investir em Python: a mesma linguagem abre portas em web, dados, automação e IA. Convém ligar cada domínio a um perfil de saída do curso para que os formandos visualizem onde se podem posicionar. 🗣️ Pontos a desenvolver oralmente • Pedir a cada formando que identifique a área que mais lhe interessa. • Sublinhar que a automação/scripting é o ganho imediato, mesmo sem ser programador a tempo inteiro. • Mostrar que dominar a base permite saltar entre estes domínios sem reaprender a linguagem.

NOTAS DO PROFESSOR 📖 Popularidade traduz-se em ecossistema A posição no TIOBE não é só uma curiosidade: popularidade significa mais bibliotecas, mais respostas no Stack Overflow e mais ofertas de emprego. Convém moderar o entusiasmo lembrando que o mercado valoriza quem sabe resolver problemas, não apenas quem conhece a sintaxe. 🗣️ Pontos a desenvolver oralmente • Explicar que rankings flutuam, mas a tendência de Python tem sido sólida. • Ligar o crescimento ao boom de IA/ML, que continua a puxar a procura. • Avisar que portefólio e projetos pesam mais num CV do que a linguagem em si.

NOTAS DO PROFESSOR 📖 Ambiente de trabalho consistente Garantir que todos têm o mesmo Python (3.10+) e o mesmo editor evita horas perdidas com problemas de configuração. Vale a pena fazer este passo em conjunto na sala, confirmando a versão antes de avançar para código. 🗣️ Pontos a desenvolver oralmente • Demonstrar como confirmar a versão e o que fazer se aparecer Python 2. • Justificar a escolha do VSCode pela curva de aprendizagem suave. • Referir o risco de ter várias versões instaladas e a confusão que isso gera.

NOTAS DO PROFESSOR 📖 Dois modos de executar código Convém distinguir bem o ficheiro `.py` (programa que se corre do início ao fim) do REPL interativo (laboratório para experimentar uma linha de cada vez). O REPL é a melhor ferramenta para tirar dúvidas rápidas sobre como uma expressão se comporta. 🗣️ Pontos a desenvolver oralmente • Demonstrar ao vivo o mesmo código nos dois modos. • Mostrar que no REPL não é preciso `print` para ver o valor de uma expressão. • Incentivar o uso do REPL para testar dúvidas antes de as escrever no ficheiro.

NOTAS DO PROFESSOR 📖 Nomes guardam tipos, não caixas Em Python a variável é uma etiqueta que aponta para um valor, e o tipo é inferido do valor atribuído. Os type hints não obrigam o interpretador a nada, mas documentam a intenção e ajudam o editor a detetar erros. A convenção de maiúsculas para constantes é cultural, já que a linguagem não impede a reatribuição. 🗣️ Pontos a desenvolver oralmente • Usar `type(x)` para mostrar o tipo inferido de cada variável. • Explicar que escrever PI em maiúsculas é um sinal para humanos, não uma proteção. • Demonstrar o unpacking múltiplo `x, y, z = 1, 2, 3` com um caso prático.

NOTAS DO PROFESSOR 📖 Cuidado com as divisões A distinção entre `/` (resultado float) e `//` (divisão inteira) é fonte clássica de bugs. Vale a pena demonstrar que `7 / 2` dá 3.5 enquanto `7 // 2` dá 3, e mostrar onde o operador módulo `%` é útil (verificar paridade, ciclos). 🗣️ Pontos a desenvolver oralmente • Exemplificar o uso de `%` para detetar números pares. • Mostrar a precedência: `**` antes de `*` e `/`, e estes antes de `+` e `-`. • Avisar que `and`/`or`/`not` são palavras, ao contrário de outras linguagens.

NOTAS DO PROFESSOR 📖 Strings são sequências imutáveis Tratar a string como uma sequência permite indexar, fatiar (slicing) e iterar, mas qualquer método que "altera" devolve na verdade uma nova string. As f-strings devem ser a forma padrão de compor texto com variáveis pela legibilidade. 🗣️ Pontos a desenvolver oralmente • Demonstrar que `nome.upper()` não muda a original — só devolve uma cópia. • Explicar o slicing com o exemplo do passo `[::2]` e índices negativos. • Contrastar f-strings com a concatenação com `+` para mostrar a diferença de clareza.

NOTAS DO PROFESSOR 📖 A indentação é sintaxe, não estética Ao contrário de outras linguagens, em Python a indentação define os blocos: não há chavetas. Misturar espaços e tabs ou alinhar mal provoca erros que confundem quem começa. O encadeamento `elif` avalia condições por ordem e pára na primeira verdadeira. 🗣️ Pontos a desenvolver oralmente • Mostrar um erro de IndentationError provocado de propósito. • Configurar o editor para inserir 4 espaços ao premir Tab. • Explicar a ordem de avaliação dos `elif` e porque a ordem das condições importa.

NOTAS DO PROFESSOR 📖 Iterar sobre coleções, não sobre índices O `for` de Python percorre diretamente os elementos de uma coleção, o que é mais legível do que gerir um contador. Quando se precisa do índice e do valor ao mesmo tempo, `enumerate` é a forma idiomática — evita o erro comum de aceder a `lista[i]` dentro do ciclo. 🗣️ Pontos a desenvolver oralmente • Comparar com o `for` baseado em índice de Java/C para realçar a diferença. • Detalhar os três argumentos de `range`: início, fim exclusivo e passo. • Mostrar que `enumerate` evita ter de criar e incrementar uma variável manualmente.

NOTAS DO PROFESSOR 📖 Quando usar while em vez de for O `while` serve para repetir enquanto uma condição se mantém verdadeira, sobretudo quando não se sabe à partida quantas iterações vão ocorrer (esperar input do utilizador, por exemplo). É preciso garantir que a condição muda dentro do ciclo, sob pena de loop infinito. 🗣️ Pontos a desenvolver oralmente • Distinguir `break` (sai do ciclo) de `continue` (salta para a próxima iteração). • Mostrar o padrão `while True` com `break` para menus interativos. • Alertar para o esquecimento do incremento como causa típica de ciclo infinito.

NOTAS DO PROFESSOR 📖 Tratar erros previsíveis com elegância O bloco try/except permite que o programa reaja a falhas em vez de rebentar. A boa prática é apanhar exceções específicas (ValueError, ZeroDivisionError) antes da genérica, para dar mensagens úteis. O `finally` corre sempre, ideal para libertar recursos. 🗣️ Pontos a desenvolver oralmente • Explicar porque apanhar `Exception` à cabeça esconde bugs. • Demonstrar a ordem de avaliação dos vários `except`. • Dar exemplos de erros recuperáveis (input inválido) vs erros de programação.

NOTAS DO PROFESSOR 📖 Funções como blocos reutilizáveis Encapsular lógica numa função evita repetição e torna o código testável e legível. Os parâmetros default permitem chamadas mais simples no caso comum, e os type hints na assinatura documentam o contrato da função. Convém reforçar a diferença entre definir e chamar. 🗣️ Pontos a desenvolver oralmente • Demonstrar o princípio DRY refatorando código repetido numa função. • Mostrar que parâmetros com default têm de vir depois dos obrigatórios. • Explicar a diferença entre `return` (devolve valor) e `print` (mostra no ecrã).

NOTAS DO PROFESSOR 📖 Funções que aceitam um número variável de argumentos `*args` recolhe argumentos posicionais num tuplo e `**kwargs` recolhe os nomeados num dicionário. É o mecanismo que permite escrever funções flexíveis como `print` ou wrappers. Convém clarificar que os asteriscos não fazem parte do nome, são operadores de empacotamento. 🗣️ Pontos a desenvolver oralmente • Mostrar que `*` e `**` também servem para desempacotar ao chamar uma função. • Dar um exemplo onde não se sabe quantos valores virão (somar uma lista variável). • Reforçar que os nomes `args` e `kwargs` são convenção, não obrigatórios.

NOTAS DO PROFESSOR 📖 Funções anónimas para uso pontual A lambda é uma função de uma só expressão, útil quando se precisa de passar comportamento como argumento a `map`, `filter` ou `sorted`. Convém moderar o entusiasmo: quando a lógica cresce, uma função nomeada com `def` é mais legível e testável. 🗣️ Pontos a desenvolver oralmente • Mostrar o mesmo resultado com lambda e com list comprehension, comparando legibilidade. • Demonstrar `sorted` com `key=lambda` para ordenar por um critério. • Avisar que lambdas longas são um cheiro de código a evitar.

NOTAS DO PROFESSOR 📖 A estrutura de dados mais usada A lista é mutável, ordenada e aceita duplicados — o cavalo de batalha do dia-a-dia. Vale a pena dar tempo às list comprehensions, que são uma marca idiomática de Python e substituem ciclos verbosos por uma linha clara. Atenção aos métodos que alteram a lista no lugar (sort, append) versus os que devolvem cópia. 🗣️ Pontos a desenvolver oralmente • Construir uma list comprehension a partir de um ciclo `for` equivalente, passo a passo. • Distinguir `append` (um elemento) de `extend` (vários). • Mostrar que `sort()` altera a lista e `sorted()` devolve uma nova.

NOTAS DO PROFESSOR 📖 Imutabilidade como garantia O tuplo é como uma lista que não pode mudar depois de criada, o que o torna ideal para dados que não devem ser alterados e para devolver vários valores de uma função. O unpacking é o que torna esse retorno múltiplo elegante. 🗣️ Pontos a desenvolver oralmente • Demonstrar o erro ao tentar atribuir a um índice de tuplo. • Mostrar o retorno de múltiplos valores como caso de uso mais comum. • Explicar quando preferir tuplo (dados fixos) vs lista (coleção que evolui).

NOTAS DO PROFESSOR 📖 Mapear chaves a valores O dicionário é a estrutura para associar pares chave→valor, com acesso muito rápido pela chave. Convém ensinar `.get()` com valor por omissão para evitar o erro KeyError quando a chave pode não existir. É a base de muito código real, incluindo dados vindos de JSON. 🗣️ Pontos a desenvolver oralmente • Contrastar `pessoa["x"]` (rebenta se não existe) com `pessoa.get("x", default)`. • Mostrar a iteração com `.items()` para percorrer chave e valor. • Ligar o dicionário ao formato JSON que aparecerá nas APIs.

NOTAS DO PROFESSOR 📖 Conjuntos para unicidade e teoria de conjuntos O set elimina duplicados automaticamente e suporta operações matemáticas (união, interseção, diferença). É a ferramenta certa para perguntas como "que elementos têm em comum?" ou "remover repetidos de uma lista". Não garante ordem nem aceita índices. 🗣️ Pontos a desenvolver oralmente • Mostrar o truque `set(lista)` para eliminar duplicados rapidamente. • Dar um exemplo prático de interseção (alunos inscritos em duas disciplinas). • Explicar porque não se pode aceder a `s[0]` num set.

NOTAS DO PROFESSOR 📖 Classes como moldes de objetos A classe define um molde; cada instância é um objeto concreto com os seus próprios dados. O `__init__` é o construtor e o `self` é a referência à instância atual — fonte de confusão inicial que vale a pena explicar com calma. O `__repr__` controla como o objeto se mostra ao imprimir. 🗣️ Pontos a desenvolver oralmente • Esclarecer que `self` é o primeiro parâmetro mas não se passa ao chamar. • Distinguir atributos de instância (cada objeto tem o seu) de métodos. • Mostrar o valor do `__repr__` ao depurar, imprimindo objetos no REPL.

NOTAS DO PROFESSOR 📖 Reutilizar comportamento e especializar A herança permite que uma subclasse aproveite a classe-mãe e redefina apenas o que muda. Este exemplo introduz polimorfismo: chamar `fala()` em diferentes animais dá resultados diferentes. O `NotImplementedError` força as subclasses a implementar o método. 🗣️ Pontos a desenvolver oralmente • Explicar que cada subclasse herda `__init__` da mãe e o atributo `nome`. • Demonstrar polimorfismo iterando uma lista de animais e chamando `fala()`. • Referir que herança em excesso complica — preferir composição quando faz sentido.

NOTAS DO PROFESSOR 📖 Proteger o estado interno do objeto O encapsulamento controla o acesso aos dados: aqui o saldo só muda através de métodos que validam (não se deposita valor negativo). A convenção do underscore `_saldo` sinaliza "privado", e o decorador `@property` expõe leitura sem permitir escrita direta. Python confia na disciplina, não impõe privacidade real. 🗣️ Pontos a desenvolver oralmente • Explicar que o underscore é uma convenção entre programadores, não uma barreira técnica. • Mostrar como `@property` permite ler `conta.saldo` como atributo mas controlado. • Discutir porque expor diretamente os atributos pode levar a estados inválidos.

NOTAS DO PROFESSOR 📖 Baterias incluídas A frase "batteries included" descreve a riqueza da standard library: muita coisa resolve-se sem instalar nada. Conhecer estes módulos (math, random, datetime, os, json) evita reinventar a roda. O par `json.loads`/`json.dumps` é especialmente útil para trocar dados com APIs. 🗣️ Pontos a desenvolver oralmente • Distinguir importar o módulo inteiro de `from x import y`. • Mostrar `json.loads` (texto→dict) vs `json.dumps` (dict→texto). • Incentivar a consultar a documentação oficial antes de procurar bibliotecas externas.

NOTAS DO PROFESSOR 📖 Trabalhar com ficheiros com segurança O `with open(...)` é a forma correta de abrir ficheiros porque garante o fecho automático mesmo se ocorrer um erro. Convém clarificar os modos (`r` leitura, `w` escrita que apaga, `a` append). O módulo csv poupa muito trabalho a tratar dados tabulares. 🗣️ Pontos a desenvolver oralmente • Avisar que o modo `w` apaga o conteúdo existente do ficheiro. • Explicar porque o `with` é preferível a abrir e fechar manualmente. • Mostrar `DictReader` para aceder às colunas por nome em vez de índice.

NOTAS DO PROFESSOR 📖 Isolar dependências por projeto O ambiente virtual evita o caos de instalar tudo globalmente: cada projeto tem as suas versões de bibliotecas. O `requirements.txt` torna o projeto reprodutível por outras pessoas. Este é um hábito profissional que distingue código amador de código partilhável. 🗣️ Pontos a desenvolver oralmente • Explicar o problema do conflito de versões que o venv resolve. • Demonstrar ativar/desativar o ambiente e confirmar pelo prompt. • Mostrar o ciclo: instalar, `pip freeze`, e reinstalar a partir do ficheiro.

NOTAS DO PROFESSOR 📖 O ecossistema é o superpoder A verdadeira força de Python está nas bibliotecas de terceiros que cobrem quase tudo. Saber escolher a biblioteca certa e ler a sua documentação é uma competência tão importante como escrever código. Convém ligar cada biblioteca à área de interesse de cada formando. 🗣️ Pontos a desenvolver oralmente • Mostrar onde procurar pacotes fiáveis (PyPI) e como avaliar a sua manutenção. • Dar um mini-exemplo com `requests` para tornar concreto. • Reforçar que instalar uma biblioteca não substitui perceber o que ela faz.

NOTAS DO PROFESSOR 📖 Escolher o âmbito certo para o projeto final Cada tipo de projeto tem um esforço e um valor de portefólio diferentes. Convém orientar os formandos a escolher algo ambicioso mas realizável no tempo disponível, alinhado com o perfil de saída que querem. Um script simples bem feito vale mais do que um projeto grande inacabado. 🗣️ Pontos a desenvolver oralmente • Ajudar cada formando a estimar a complexidade da sua ideia. • Sugerir começar pequeno e iterar, em vez de tentar tudo de uma vez. • Ligar a escolha de tipo de projeto à área de carreira pretendida.

NOTAS DO PROFESSOR 📖 Organização sinaliza profissionalismo Uma estrutura de pastas convencional torna o projeto navegável por qualquer programador. Separar código (`src`), testes (`tests`) e documentação, e ter `.gitignore`, README e `requirements.txt`, são sinais de maturidade que avaliadores e empregadores reconhecem de imediato. 🗣️ Pontos a desenvolver oralmente • Explicar porque a pasta `venv` nunca deve ir para o repositório. • Mostrar o papel do README como primeira impressão do projeto. • Reforçar que separar testes do código facilita a manutenção.

NOTAS DO PROFESSOR 📖 Código profissional segue convenções Estas práticas separam código que funciona de código que se mantém. O PEP 8 dá uma linguagem visual comum, as ferramentas (black, flake8, mypy) automatizam a verificação, e os testes dão confiança para mudar sem partir. Convém apresentá-las como hábitos a adotar desde já, não como burocracia futura. 🗣️ Pontos a desenvolver oralmente • Demonstrar o `black` a formatar um ficheiro desalinhado num clique. • Explicar a diferença entre formatador (black), linter (flake8) e type checker (mypy). • Reforçar que docstrings e type hints são documentação que vive no código.

NOTAS DO PROFESSOR 📖 Consolidar o percurso Este resumo fecha o arco: da sintaxe limpa às boas práticas profissionais. Vale a pena usá-lo para verificar a aprendizagem, pedindo aos formandos que liguem cada ponto a algo que praticaram. O reforço de que Python é uma base transversível para várias carreiras motiva os próximos passos. 🗣️ Pontos a desenvolver oralmente • Pedir a cada formando que nomeie o conceito que achou mais útil. • Sugerir caminhos de aprofundamento conforme o interesse (web, dados, IA). • Relembrar que a prática continuada é o que fixa estes conhecimentos.