Matemática · Python · Secundário

PyMath

Aprende Python resolvendo problemas reais de Matemática do 10.º, 11.º e 12.º anos. Do zero até à app completa.

10

Módulos

60+

Exercícios

10

Desafios

PyMath

Aprende Python
com Matemática

Curso progressivo alinhado com as Aprendizagens Essenciais de Matemática do 10.º, 11.º e 12.º anos.

10

Módulos

60+

Exercícios

10

Desafios

Criar perfil

O teu progresso fica guardado neste dispositivo. Gratuito, sem conta necessária.

Nome

Ano escolar

PyMath

0 XP —

Bem-vindo de volta, —

Continua de onde ficaste. Cada módulo desbloqueia o seguinte.

Progresso global

0%

Módulos do Curso

Conceitos Base

Fundamentos essenciais para começar a programar em Python.

O que é um Programa?

Programa = sequência de instruções

Um programa é uma lista de instruções que o computador executa em ordem. Em Python, cada linha é uma instrução — lê de cima para baixo.

linha 1 → executa linha 2 → executa

Variáveis

Variável = caixa com etiqueta

Uma variável guarda um valor na memória. O = é atribuição, não igualdade matemática.

x = 5 # cria "x" com valor 5 x = x + 1 # agora x = 6

Tipos de Dados

int

Números inteiros.

x = 42 | n = -7

float

Números reais com decimais.

pi = 3.14 | nota = 17.5

str

Texto entre aspas.

nome = "Ana"

bool

True ou False.

passou = True

list

Sequência ordenada.

notas = [14, 17, 12]

dict

Pares chave: valor.

d = {"nome": "Ana"}

Indentação

Obrigatória em Python! Usa 4 espaços ou Tab para definir blocos. Sem chavetas {} como noutras linguagens.

f-strings

Formatação moderna de texto

Coloca f antes das aspas e usa {variável} para inserir valores.

nome = "Ana" nota = 17.5 print(f"Aluna: {nome}, Nota: {nota:.1f}")

Comandos Essenciais

Estruturas de código fundamentais.

Input / Output

built-in

print()

print(val, end='\n', sep=' ')

Imprime valores no ecrã.

print(f"Área = {a:.2f}")

built-in

input()

input(prompt="")

Lê texto do utilizador. Devolve sempre str.

x = float(input("x = "))

Condicionais

keyword

if / elif / else

if cond: ... elif ...: ... else: ...

Executa blocos diferentes consoante condições.

if delta > 0: print("2 raízes")

Ciclos

keyword

for

for var in iterável:

Repete para cada elemento de uma sequência.

for i in range(1, 11): print(i)

keyword

while

while condição:

Repete enquanto a condição for True.

while n > 0: n -= 1

keyword

range()

range(stop) / range(a, b, passo)

Gera sequência de inteiros. Stop não incluído.

range(1,11) → 1..10

Funções

keyword

def

def nome(params):

Define uma função reutilizável.

def area(r): return 3.14*r**2

keyword

lambda

lambda params: expr

Função anónima de uma linha.

f = lambda x: 2*x + 1

Operadores

Todos os operadores Python com exemplos.

Aritméticos

+ Adição

3 + 4 → 7

- Subtração

10 - 3 → 7

* Multiplicação

4 * 5 → 20

/ Divisão (float)

7 / 2 → 3.5

// Divisão inteira

7 // 2 → 3

% Módulo (resto)

17 % 5 → 2

** Potência

2**10 → 1024

Comparação

== Igual

3 == 3 → True

!= Diferente

3 != 4 → True

< <= Menor

3 < 5 → True

> >= Maior

7 > 3 → True

Lógicos

and

True se ambas as condições forem True.

0 < x and x < 10

or

True se pelo menos uma for True.

x == 0 or x == 1

not

Inverte o valor booleano.

not True → False

Funções Built-in

Disponíveis sem importar nada.

built-in

abs(x)

Valor absoluto.

abs(-7) → 7

built-in

round(x, n)

Arredonda a n casas decimais.

round(3.14159, 2) → 3.14

built-in

max(iter)

Maior valor.

max([3,1,5]) → 5

built-in

min(iter)

Menor valor.

min([3,1,5]) → 1

built-in

sum(iter)

Soma todos os elementos.

sum([1,2,3,4]) → 10

built-in

len(obj)

Número de elementos.

len([1,2,3]) → 3

built-in

sorted(iter)

Devolve lista ordenada.

sorted([3,1,2]) → [1,2,3]

built-in

int(x) / float(x) / str(x)

Converte entre tipos.

int("42") → 42

built-in

enumerate(iter)

Itera com índice e valor.

for i,v in enumerate(lst)

built-in

zip(a, b)

Combina dois iteráveis.

for a,b in zip(x,y)

Métodos de Listas

lista

.append(val)

Adiciona no fim.

lst.append(7)

lista

.sort()

Ordena no lugar.

lst.sort(reverse=True)

lista

.pop(idx)

Remove e devolve elemento.

lst.pop() / lst.pop(2)

lista

[expr for x in iter]

List comprehension.

[x**2 for x in range(5)]

Módulo math

import math

const

math.pi

3.141592653589793

const

math.e

2.718281828459045

math

math.sqrt(x)

Raiz quadrada.

math.sqrt(144) → 12.0

math

math.factorial(n)

n!

math.factorial(6) → 720

math

math.gcd(a, b)

Máximo Divisor Comum.

math.gcd(48,18) → 6

math

math.floor(x) / ceil(x)

Arredonda baixo / cima.

math.floor(3.9) → 3

math

math.sin/cos/tan(x)

Funções trig (radianos).

math.sin(math.pi/2) → 1.0

math

math.radians(x)

Graus → Radianos.

math.radians(180) → π

math

math.log(x, base)

Logaritmo. Sem base: ln.

math.log(100,10) → 2.0

math

math.exp(x)

eˣ

math.exp(1) → 2.718...

Glossário

Termos de programação em português.

OUTPUT

— Clica em Executar para ver o resultado —

Tab indentação Ctrl+Z desfazer 💡 Python real via Pyodide · Para projectos avançados: Google Colab ou Replit

🎯 Desafios Rápidos

📝 Notas

🕓 Histórico

Nenhuma execução ainda.

Nenhum comando encontrado.

— —

O que é o Python?

Python é uma linguagem de programação criada em 1991, muito usada em matemática, ciência de dados e inteligência artificial. É famosa por ser simples de ler e escrever — quase como inglês.

Porquê Python para Matemática? As AE de Matemática A destacam o Pensamento Computacional como competência essencial. Python permite modelar fenómenos reais, testar conjecturas e visualizar dados.

Variáveis e Tipos de Dados

Uma variável guarda um valor na memória. O tipo é inferido automaticamente:

populacao_lisboa = 545000    # int — inteiro
taxa_juro = 0.025            # float — decimal (2.5%)
nome_escola = "Escola Sec." # str — texto
aprovado = True              # bool — verdadeiro/falso

Operadores Aritméticos

17 // 5   # 3  — divisão inteira
17 % 5    # 2  — resto (módulo)
2 ** 10   # 1024  — potência

f-strings

raio = 5
area = 3.14159 * raio ** 2
print(f"Raio: {raio} cm")
print(f"Área: {area:.2f} cm²")

Literacia Financeira — AE 10.º

As AE incluem modelos financeiros. Python calcula juros simples e compostos em segundos:

capital, taxa, anos = 1000, 0.03, 5
# Juro simples: J = C × r × t
print(f"Juro simples: {capital*taxa*anos:.2f}€")
# Juro composto: M = C × (1+r)^t
print(f"Montante composto: {capital*(1+taxa)**anos:.2f}€")

Funções Quadráticas e Equações do 2.º Grau

As funções quadráticas são tema central do 10.º ano. Python permite calcular zeros, vértice e discriminante de forma imediata.

Ligação às AE: As AE do 10.º incluem funções quadráticas — zeros, vértice, monotonia. O discriminante Δ = b² − 4ac determina o número de soluções reais.

A Fórmula Resolvente

import math
a, b, c = 1, -5, 6   # x² - 5x + 6 = 0
delta = b**2 - 4*a*c
if delta > 0:
    x1 = (-b + math.sqrt(delta)) / (2*a)
    x2 = (-b - math.sqrt(delta)) / (2*a)
    print(f"x₁={x1:.2f}, x₂={x2:.2f}")  # 3, 2
elif delta == 0:
    print(f"Raiz dupla: {-b/(2*a):.2f}")
else:
    print("Sem raízes reais (Δ < 0)")

O Vértice da Parábola

a, b, c = 1, -4, 3
xv = -b / (2*a)
yv = a*xv**2 + b*xv + c
print(f"Vértice V({xv}, {yv})")
print(f"{'Mínimo' if a>0 else 'Máximo'}: y = {yv}")

Modelação com Funções Quadráticas — AE 10.º

# Rectângulo: lados (x+2) e (x-1), área = 24 m²
# (x+2)(x-1) = 24  →  x² + x - 26 = 0
import math
a, b, c = 1, 1, -26
x = (-b + math.sqrt(b**2 - 4*a*c)) / (2*a)
print(f"Lados: {x+2:.2f} m e {x-1:.2f} m")
print(f"Área: {(x+2)*(x-1):.1f} m²")

Estruturas Condicionais

As condicionais permitem que o programa tome decisões. Em Matemática: "se Δ > 0, há duas soluções; senão..."

Ligação às AE: O 10.º inclui Geometria — classificação de triângulos. As condicionais são a ferramenta natural para implementar classificações matemáticas.

if / elif / else

angulo = 90
if angulo < 90:
    print("Ângulo agudo")
elif angulo == 90:
    print("Ângulo recto")
elif angulo < 180:
    print("Ângulo obtuso")
else:
    print("Ângulo nulo ou giro")

Operadores Lógicos

x = 8
if x > 0 and x % 2 == 0:
    print(f"{x} é positivo e par")
if 0 <= x <= 10:       # intervalo [0,10]
    print("x pertence a [0, 10]")

Classificação de Triângulos — AE 10.º Geometria

a, b, c = 3, 4, 5
# Desigualdade triangular
if a+b>c and a+c>b and b+c>a:
    if a==b==c: tipo = "equilátero"
    elif a==b or b==c or a==c: tipo = "isósceles"
    else: tipo = "escaleno"
    lados = sorted([a, b, c])
    c2 = lados[2]**2
    ab2 = lados[0]**2 + lados[1]**2
    if c2 == ab2: ang = "rectângulo"
    elif c2 < ab2: ang = "acutângulo"
    else: ang = "obtusângulo"
    print(f"Triângulo {tipo} e {ang}")
else:
    print("Triângulo inválido")

Listas e Estatística Descritiva

As listas são a estrutura ideal para guardar amostras e calcular medidas estatísticas — tema central do 10.º ano.

Ligação às AE: O 10.º inclui Estatística Descritiva: média, mediana, moda, variância e desvio padrão. As AE recomendam o uso de tecnologia para explorar dados reais.

Operações com Listas

notas = [12, 15, 10, 18, 14, 16, 9, 17, 13, 11]
print(f"Total: {len(notas)} alunos")
print(f"Máx: {max(notas)}, Mín: {min(notas)}")
notas.append(15)    # adicionar
notas.sort()        # ordenar

Medidas de Localização

notas = [12, 15, 10, 18, 14, 16, 9, 17, 13, 11]
media = sum(notas) / len(notas)
ordenadas = sorted(notas)
n = len(ordenadas)
mediana = (ordenadas[n//2-1]+ordenadas[n//2])/2 if n%2==0 else ordenadas[n//2]
moda = max(set(notas), key=notas.count)
print(f"Média: {media:.1f}, Mediana: {mediana}, Moda: {moda}")

List Comprehension

notas = [12, 15, 10, 18, 14, 16, 9, 17, 13, 11]
media = sum(notas)/len(notas)
acima = [n for n in notas if n > media]
print(f"Acima da média ({media:.1f}): {acima}")
quadrados = [x**2 for x in range(1, 11)]
print(quadrados)

Ciclos e Sucessões

Os ciclos automatizam cálculos repetitivos. São a ferramenta natural para explorar sucessões — tema central do 11.º ano.

Ligação às AE: O 11.º inclui Matemática Discreta: sucessões numéricas, progressões aritméticas (PA) e geométricas (PG), princípio de indução matemática.

Progressão Aritmética

a1, r = 3, 4   # primeiro termo e razão
# Fórmula geral: aₙ = a₁ + (n-1)×r
termos = [a1 + (n-1)*r for n in range(1, 11)]
print(f"PA: {termos}")
# Soma: Sₙ = n/2 × (a₁ + aₙ)
soma = 10 * (a1 + termos[-1]) / 2
print(f"S₁₀ = {soma}")

Progressão Geométrica

a1, q = 1, 2   # primeiro termo e razão
# Fórmula geral: aₙ = a₁ × q^(n-1)
termos = [a1 * q**(n-1) for n in range(1, 11)]
print(f"PG: {termos}")
# Soma: Sₙ = a₁(qⁿ-1)/(q-1)
soma = a1 * (q**10 - 1) / (q - 1)
print(f"S₁₀ = {soma:.0f}")

while — Critério de Convergência

# Primeiro n tal que aₙ > 1000 (PG com a₁=1, q=2)
n, termo = 1, 1
while termo <= 1000:
    n += 1
    termo = 2**(n-1)
print(f"a{n} = {termo} > 1000")

Funções Python e Funções Matemáticas

Em Python, uma função encapsula lógica reutilizável. Em Matemática, associa cada elemento do domínio a um único do contradomínio. A ligação é directa e poderosa.

Ligação às AE: O 11.º aprofunda Funções: taxa de variação, derivada, monotonia. Python permite calcular derivadas numericamente e explorar propriedades de funções reais.

Definir e Chamar Funções

def f(x):
    return x**2 - 4*x + 3
# Tabela de valores
for x in range(-1, 6):
    print(f"f({x}) = {f(x)}")

Taxa Média de Variação e Derivada Numérica

def f(x): return x**2

# TMV entre a e b: (f(b)-f(a))/(b-a)
def tmv(f, a, b): return (f(b) - f(a)) / (b - a)

# Derivada numérica: limite da TMV quando h→0
def derivada(f, x, h=0.0001):
    return (f(x+h) - f(x)) / h

print(f"TMV[1,3] = {tmv(f,1,3)}")      # 4.0
print(f"f'(3) ≈ {derivada(f,3):.4f}") # ≈ 6.0

Recursividade

def factorial(n):
    if n <= 1: return 1
    return n * factorial(n-1)

def fibonacci(n):
    if n <= 1: return n
    return fibonacci(n-1) + fibonacci(n-2)

print([factorial(n) for n in range(8)])
print([fibonacci(n) for n in range(10)])

Dicionários e Geometria Analítica

Os dicionários guardam dados como pares chave-valor — ideais para pontos e vectores da Geometria Analítica do 11.º ano.

Ligação às AE: O 11.º inclui Geometria Analítica: pontos, vectores, distâncias, produto escalar e equações de rectas.

Pontos e Distâncias

import math
A = {'x': 1, 'y': 2}
B = {'x': 4, 'y': 6}
def distancia(P, Q):
    return math.sqrt((Q['x']-P['x'])**2 + (Q['y']-P['y'])**2)
print(f"|AB| = {distancia(A,B):.2f}")  # 5.00

Vectores e Produto Escalar

import math
u = {'x': 3, 'y': 4}
v = {'x': 1, 'y': -2}

def modulo(v): return math.sqrt(v['x']**2 + v['y']**2)
def prod_esc(u,v): return u['x']*v['x'] + u['y']*v['y']
def angulo(u,v):
    cos_t = prod_esc(u,v) / (modulo(u)*modulo(v))
    return math.degrees(math.acos(max(-1,min(1,cos_t))))

print(f"|u|={modulo(u):.1f}")
print(f"u·v={prod_esc(u,v)}")
print(f"θ={angulo(u,v):.1f}°")

Iterar sobre Dicionários

ponto = {'x': 3, 'y': 4, 'z': 0}
for chave, valor in ponto.items():
    print(f"  {chave}: {valor}")
# Verificar se chave existe
if 'z' in ponto:
    print("Ponto 3D")

Estatística com Python

O 11.º ano aprofunda a Estatística. Python permite calcular variância, desvio padrão e correlação sem ferramentas externas.

Ligação às AE: O 11.º inclui medidas de dispersão e estatística bivariada. As AE recomendam explicitamente o uso de tecnologia — Python é a escolha ideal.

Variância e Desvio Padrão

dados = [12, 15, 10, 18, 14, 16, 9, 17, 13, 11]
media = sum(dados) / len(dados)
# σ² = Σ(xᵢ - x̄)² / n
variancia = sum((x-media)**2 for x in dados) / len(dados)
desvio = variancia ** 0.5
print(f"Média: {media:.1f}")
print(f"Variância: {variancia:.2f}")
print(f"Desvio padrão: {desvio:.2f}")

Quartis e Amplitude Interquartil

def quartil(dados, q):
    ord_d = sorted(dados)
    n = len(ord_d)
    pos = q * (n-1) / 4
    i = int(pos)
    f = pos - i
    return ord_d[i] + f*(ord_d[min(i+1,n-1)]-ord_d[i])

dados = [4,7,8,9,10,12,14,17,18,20]
Q1, Q2, Q3 = quartil(dados,1), quartil(dados,2), quartil(dados,3)
print(f"Q1={Q1}, Q2={Q2}, Q3={Q3}, AIQ={Q3-Q1}")

Correlação de Pearson

# Horas de estudo vs nota no teste
x = [1, 2, 3, 4, 5]
y = [50, 60, 70, 80, 90]
n = len(x)
mx, my = sum(x)/n, sum(y)/n
num = sum((x[i]-mx)*(y[i]-my) for i in range(n))
den = (sum((xi-mx)**2 for xi in x)*sum((yi-my)**2 for yi in y))**0.5
print(f"r = {num/den:.4f}")  # 1.0 = correlação perfeita

Módulo math — Trigonometria e Funções Transcendentes

O módulo math implementa as funções do 11.º e 12.º anos: trigonometria, logaritmos e exponenciais.

Ligação às AE: O 11.º inclui Trigonometria (lei dos senos e cossenos). O 12.º inclui funções exponenciais e logarítmicas. Atenção: Python usa radianos!

Funções Trigonométricas

import math
# Converter graus → radianos
print(f"sin(30°) = {math.sin(math.radians(30)):.4f}")  # 0.5000
print(f"cos(60°) = {math.cos(math.radians(60)):.4f}")  # 0.5000
print(f"tan(45°) = {math.tan(math.pi/4):.4f}")         # 1.0000

Lei dos Cossenos — AE 11.º

c² = a² + b² − 2ab·cos(C) — generaliza o Teorema de Pitágoras:

import math
a, b, C_graus = 5, 7, 60
C = math.radians(C_graus)
c = math.sqrt(a**2 + b**2 - 2*a*b*math.cos(C))
A = math.degrees(math.asin(a*math.sin(C)/c))
B = 180 - C_graus - A
print(f"c = {c:.3f}")
print(f"A≈{A:.1f}°, B≈{B:.1f}°, C={C_graus}°")

Logaritmos e Escalas

import math
# pH = -log₁₀([H⁺]) — escala logarítmica
pH = -math.log10(1e-7)
print(f"pH da água pura: {pH:.0f}")  # 7

# Crescimento exponencial: P(t) = P₀ × e^(rt)
P0, r, t = 1000, 0.05, 10
print(f"P({t} anos) = {P0*math.exp(r*t):.0f}")

NumPy, Probabilidades e Visualização

NumPy e Matplotlib são as bibliotecas essenciais para o 12.º ano — probabilidades, matrizes, integrais e visualização de funções.

Ligação às AE: O 12.º inclui Probabilidades, e três temas alternativos: Matrizes, Integrais/Primitivas ou Inferência Estatística. NumPy cobre todos eles.

Arrays NumPy

import numpy as np
notas = np.array([12,15,10,18,14,16,9,17,13,11])
print(f"Média: {np.mean(notas):.1f}")
print(f"Desvio padrão: {np.std(notas):.2f}")
print(f"Mediana: {np.median(notas)}")
x = np.linspace(0, 2*np.pi, 1000)  # 1000 pontos
y = np.sin(x)

Probabilidades — Simulação Monte Carlo

import numpy as np
np.random.seed(42)
dado1 = np.random.randint(1, 7, 10000)
dado2 = np.random.randint(1, 7, 10000)
soma = dado1 + dado2
freq_7 = np.sum(soma == 7) / 10000
print(f"P(soma=7) simulada: {freq_7:.4f}")
print(f"P(soma=7) teórica: {6/36:.4f}")

Matrizes e Sistemas de Equações — AE 12.º

import numpy as np
# 2x + y = 5   e   x + 3y = 10
A = np.array([[2,1],[1,3]])
b = np.array([5, 10])
sol = np.linalg.solve(A, b)
print(f"x={sol[0]:.1f}, y={sol[1]:.1f}")  # x=1.0, y=3.0
print(f"det(A) = {np.linalg.det(A):.1f}")

Integração Numérica — AE 12.º

import numpy as np
x = np.linspace(0, 1, 10000)
integral = np.trapz(x**2, x)
print(f"integral x² em [0,1] ≈ {integral:.6f}")
print(f"Valor exacto: {1/3:.6f}")