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.