aulify · Sebenta

UC · Unidade de Competência · UC00606

Programação estruturada

Sebenta · Python como linguagem de base

50h · 4.5 pontos crédito Curso: T. Desenv. Software, T. Inform. Gestão ↗ Referencial oficial SNQ

Apresentação

UC00606 (50h · 4,5 pts) é a primeira UC de programação implementada. Continua o trabalho da UC00245 (Algoritmos), passando do pseudocódigo para Python. Aborda variáveis, controlo de fluxo, estruturas de dados básicas, funções e tratamento de erros.

Python foi escolhido por ser legível, gratuito, multiplataforma, e com vasta documentação. O conhecimento adquirido transfere-se facilmente para C, Java ou JavaScript.

Preparar o ambiente

Instalar Python

Windows: descarregar de python.org (versão 3.12+); marcar "Add Python to PATH" na instalação.

Ubuntu: já vem instalado (python3). Para versão mais recente: sudo apt install python3.12.

macOS: brew install python@3.12.

Editor recomendado

VSCode com a extensão Python da Microsoft. Vantagens: highlighting, autocomplete (Pylance), debugger gráfico, terminal integrado.

Outras opções: Thonny (didáctico, simples), PyCharm Community (mais pesado, mais funcionalidades), Sublime Text.

Primeiro programa

# ola.py
nome = input("Como te chamas? ")
print(f"Olá, {nome}!")

Executar:

python ola.py

Sintaxe básica

Variáveis e tipos

Python é dinamicamente tipado — não se declara o tipo, é inferido pelo valor.

idade = 17          # int
preco = 9.99        # float
nome = "Ana"        # str
maior = True        # bool
sem_valor = None    # NoneType

Para inspeccionar tipo: type(idade) retorna <class 'int'>.

Conversões

int("42")       # 42
float("3.14")   # 3.14
str(42)         # "42"
bool(0)         # False (qualquer 0 ou "" ou [] é False)
bool(1)         # True

Cuidado com int("3.14") — dá erro. Usar int(float("3.14")) se precisar.

Operadores

Aritméticos: +, -, *, / (real), // (inteira), % (resto), ** (potência).

Comparação: ==, !=, <, >, <=, >=. Retornam True/False.

Lógicos: and, or, not.

Atribuição composta: +=, -=, *=, /=, etc.

x = 5
x += 3      # x = 8
x *= 2      # x = 16

Controlo de fluxo

Condicionais

idade = int(input("Idade? "))

if idade >= 18:
    print("Maior")
elif idade >= 13:
    print("Adolescente")
else:
    print("Criança")

Em Python, indentação (4 espaços recomendado, regular) define blocos. Não há {}. Misturar tabs e espaços causa erros.

While

# Adivinhar número
import random
segredo = random.randint(1, 100)

while True:
    palpite = int(input("Palpite (1-100): "))
    if palpite == segredo:
        print("Acertaste!")
        break
    elif palpite < segredo:
        print("Maior")
    else:
        print("Menor")

break sai do loop; continue salta para a próxima iteração.

For

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

# Range — 1 a 5
for i in range(1, 6):
    print(i)

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

# Iterar lista
fruta = ["maçã", "pêra", "banana"]
for f in fruta:
    print(f)

# Iterar com índice
for i, f in enumerate(fruta):
    print(f"{i}: {f}")

Estruturas de dados

Listas

Sequência mutável ordenada de elementos.

numeros = [3, 1, 4, 1, 5, 9, 2, 6]

# Acesso
numeros[0]      # 3 (primeiro)
numeros[-1]     # 6 (último)
numeros[1:4]    # [1, 4, 1] (fatia, do índice 1 ao 3)

# Modificar
numeros.append(7)        # adiciona no fim
numeros.insert(0, 0)     # adiciona no índice 0
numeros.remove(1)        # remove primeira ocorrência de 1
del numeros[2]           # remove o do índice 2

# Operações
len(numeros)             # tamanho
sum(numeros)             # soma
max(numeros)             # máximo
min(numeros)
sorted(numeros)          # nova lista ordenada
numeros.sort()           # ordena in-place
numeros.reverse()        # inverte

List comprehensions

Forma compacta de criar listas:

# Quadrados de 0 a 9
quadrados = [x**2 for x in range(10)]
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# Pares até 20
pares = [x for x in range(20) if x % 2 == 0]

# Maiúsculas
nomes = ["ana", "joão", "pedro"]
maiusc = [n.upper() for n in nomes]

Strings

Cadeia imutável de caracteres.

nome = "Ana Silva"

nome[0]              # 'A'
nome[-1]             # 'a'
nome.upper()         # "ANA SILVA"
nome.lower()         # "ana silva"
nome.split()         # ["Ana", "Silva"]
nome.replace("Silva", "Costa")   # "Ana Costa"
len(nome)            # 9
"Silva" in nome      # True

f-strings (Python 3.6+):

idade = 17
print(f"Tenho {idade} anos.")
print(f"Daqui a 10 anos: {idade + 10}")
print(f"Pi = {3.14159:.2f}")    # 2 casas decimais

Dicionários

Pares chave-valor.

aluno = {
    "nome": "Ana",
    "idade": 17,
    "notas": [15, 16, 14]
}

aluno["nome"]                    # "Ana"
aluno["email"] = "a@ex.pt"       # adicionar
del aluno["idade"]               # remover

# Iterar
for chave in aluno:
    print(chave)

for chave, valor in aluno.items():
    print(f"{chave}: {valor}")

# Verificar
"nome" in aluno         # True
aluno.get("email")      # "a@ex.pt"
aluno.get("morada", "Lisboa")  # "Lisboa" (default)

Tuples

Imutáveis. Úteis para retornar múltiplos valores.

coord = (3, 4)
x, y = coord            # unpacking

def stats(nums):
    return min(nums), max(nums), sum(nums) / len(nums)

mn, mx, avg = stats([1, 5, 3, 9, 2])

Sets

Colecção não-ordenada sem duplicados.

visitas = {"Ana", "João", "Ana", "Pedro"}
# {"Ana", "João", "Pedro"}

visitas.add("Maria")
visitas.remove("Ana")

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

Funções

Definição

def quadrado(x):
    return x * x

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

print(quadrado(5))      # 25
print(soma(3, 4))       # 7

Argumentos por defeito

def saudacao(nome, lingua="pt"):
    if lingua == "pt":
        return f"Olá, {nome}!"
    elif lingua == "en":
        return f"Hello, {nome}!"
    return f"Hi, {nome}"

saudacao("Ana")             # "Olá, Ana!"
saudacao("Ana", "en")       # "Hello, Ana!"

Argumentos nomeados

def carta(destinatario, assunto, urgente=False):
    print(f"Para: {destinatario}")
    print(f"Assunto: {assunto}")
    if urgente:
        print("URGENTE")

# Ambos válidos:
carta("Ana", "Convite")
carta(assunto="Convite", destinatario="Ana", urgente=True)

args e *kwargs

def soma(*nums):
    total = 0
    for n in nums:
        total += n
    return total

soma(1, 2, 3)          # 6
soma(1, 2, 3, 4, 5)    # 15

def info(**dados):
    for k, v in dados.items():
        print(f"{k}: {v}")

info(nome="Ana", idade=17)

Funções como blocos · decomposição

Em vez de um programa monolítico, decompor em funções com responsabilidade única:

def ler_numeros():
    """Lê números separados por espaço."""
    linha = input("Números: ")
    return [int(x) for x in linha.split()]

def calcular_media(nums):
    """Devolve média ou 0 se lista vazia."""
    return sum(nums) / len(nums) if nums else 0

def calcular_mediana(nums):
    """Devolve mediana."""
    s = sorted(nums)
    n = len(s)
    if n == 0:
        return 0
    return s[n // 2] if n % 2 == 1 else (s[n//2-1] + s[n//2]) / 2

def imprimir_resultado(media, mediana):
    print(f"Média:   {media:.2f}")
    print(f"Mediana: {mediana:.2f}")

def main():
    nums = ler_numeros()
    imprimir_resultado(calcular_media(nums), calcular_mediana(nums))

if __name__ == "__main__":
    main()

A construção if __name__ == "__main__" permite que o ficheiro seja importado como módulo sem executar main().

Tratamento de erros

Try / except

try:
    idade = int(input("Idade? "))
    print(f"Em 10 anos terás {idade + 10}")
except ValueError:
    print("Idade tem de ser número.")
except KeyboardInterrupt:
    print("\nCancelado pelo utilizador.")
finally:
    print("Programa terminado.")

Excepções comuns

Excepção	Causa
`ValueError`	Conversão inválida (`int("abc")`)
`TypeError`	Operação em tipos errados (`"a" + 5`)
`ZeroDivisionError`	Divisão por zero
`IndexError`	Índice fora da lista
`KeyError`	Chave inexistente em dict
`FileNotFoundError`	Ficheiro não existe
`KeyboardInterrupt`	Utilizador pressionou Ctrl+C

Levantar excepções

def raiz(x):
    if x < 0:
        raise ValueError("Não há raiz real de número negativo")
    return x ** 0.5

try:
    print(raiz(-4))
except ValueError as e:
    print(f"Erro: {e}")

Input/output

Input

nome = input("Nome: ")          # str
idade = int(input("Idade: "))   # int
preco = float(input("Preço: ")) # float

input() devolve sempre string. Converter conforme necessidade.

Print formatado

nome = "Ana"
saldo = 1234.5678

# f-string (preferido)
print(f"{nome}: {saldo:.2f}€")

# .format()
print("{}: {:.2f}€".format(nome, saldo))

# % (legado)
print("%s: %.2f€" % (nome, saldo))

Ficheiros

# Escrever
with open("dados.txt", "w", encoding="utf-8") as f:
    f.write("Olá\n")
    f.write("Mundo\n")

# Ler linha a linha
with open("dados.txt", encoding="utf-8") as f:
    for linha in f:
        print(linha.strip())   # strip remove \n

# Ler tudo
with open("dados.txt", encoding="utf-8") as f:
    texto = f.read()

# Acrescentar
with open("dados.txt", "a", encoding="utf-8") as f:
    f.write("Mais uma\n")

Modos: "r" leitura (default), "w" escrita (apaga), "a" append, "r+" leitura+escrita.

with garante fecho automático mesmo se houver excepção. Sempre usar.

Módulos

Importar

import math
print(math.pi)              # 3.14159...
print(math.sqrt(16))        # 4.0

from random import randint
print(randint(1, 100))      # número aleatório

import datetime as dt
agora = dt.datetime.now()

Criar módulo próprio

# utils.py
def saudacao(nome):
    return f"Olá, {nome}!"

def saudacao_formal(nome):
    return f"Bom dia, Senhor/a {nome}."

# main.py
import utils

print(utils.saudacao("Ana"))
print(utils.saudacao_formal("Costa"))

Boas práticas

Nomenclatura (PEP 8)

Variáveis e funções: snake_case. nome_completo, calcular_imposto.
Constantes: MAIÚSCULAS. IVA = 0.23.
Classes: PascalCase. class Aluno:.
Nomes claros: idade em vez de i; total_compras em vez de t.

Comentários

# Comentário de uma linha

"""
Comentário
em várias linhas (ou docstring).
"""

def soma(a, b):
    """Devolve a soma de a e b."""
    return a + b

Docstrings explicam o porquê, não o como (que o código já diz).

Estilo

Indentação consistente: 4 espaços.
Linhas até 80-100 caracteres.
Espaços à volta de operadores: x = 5, não x=5.
Linha em branco entre funções.

Debug

print() para inspeccionar valores.
VSCode debugger para parar em breakpoints.
assert condição, "mensagem" para verificações de sanidade.

Apêndices

A · Cheatsheet

# Tipos
int, float, str, bool, list, dict, tuple, set, None

# Conversão
int(x), float(x), str(x), bool(x)

# Controlo
if/elif/else, while, for, break, continue

# Coleções
[], {}, (), set()

# Funções
def nome(a, b=def): return ...

# Excepções
try/except/else/finally, raise

# I/O
input(), print(), open()

# Módulos
import x, from x import y, import x as y

B · Glossário

Indentação. Espaços/tabs no início de linha que definem blocos em Python. Iterável. Objecto sobre o qual se pode fazer for (lista, string, dict, etc.). Mutável vs imutável. Listas mutáveis; strings, tuples, ints imutáveis. PEP 8. Guia de estilo oficial Python. REPL. Read-Eval-Print Loop — prompt interactivo do Python.

C · Recursos

docs.python.org · documentação oficial.
Real Python · realpython.com — tutoriais.
Automate the Boring Stuff · automatetheboringstuff.com — livro gratuito.
Exercism · exercism.org — exercícios com mentor.