Eliminação por Substituição em Código
Sobre a Matemática
Eliminar uma incógnita, entre várias equações simultâneas, é achar um sistema equivalente ao primeiro, que tenha uma equação e uma incógnita a menos. Os principais métodos de eliminação são os seguintes: 1º- por substituição, 2º- por comparação e 3º- por adição.
Eliminação por substituição – Para resolver um sistema de duas equações com duas incógnitas.
1º- Tira-se o valor de x da 1ª equação e leva-se este valor para a 2ª equação; vem uma equação de um só incógnita y, que se resolve:
2º- Leva-se o valor de y à equação que dá x e vem o valor de x.
Seja o sistema de 2 incógnitas: 5x – 7y = 2 (1) 3x + 4y = 34 (2)
Da equação 1, tira-se o valor de x: x = (2 + 7y) / 5 (3)
Leva-se este valor (3) de x para a equação (2) e tem-se: 3 * ((2 + 7y) / 5) + 4y = 34 (4)
Resolve-se esta equação com uma incógnita e tem-se: 3(2 + 7y) + 20y = 170, 6 + 21y + 20y = 170, 21y + 20y = 170 – 6, 41y = 164, y = 164 / 41 = 4 (5)
Levando-se para a igualdade (3) o valor de y, acha-se:
x = (2 + 7 * 4) / 5 = 30 / 5 = 6
Sobre o Código
Na linguagem de programação Python,
from – é a palavra-chave usada para importar partes específicas de um módulo ou biblioteca.
sympy – é a biblioteca voltada para matemática simbólica (álgebra, cálculo, equações, etc.).
import – é a palavra-chave usada para trazer bibliotecas externas ou módulos para dentro do programa.
symbols() – é a função da SymPy que cria variáveis simbólicas (como 𝑥,𝑦,𝑧) para manipulação algébrica.
Eq() – é a função da SymPy que define uma equação matemática, por exemplo Eq(x+y, 10).
solve() – é a função da SymPy que resolve equações ou sistemas de equações.
print() – é a função nativa que exibe informações na tela (saída padrão).
f"...{}" (f-string) – é a string formatada. Permite inserir variáveis ou expressões dentro de {} diretamente no texto.
def – é a palavra-chave usada para definir uma função.
return – é a palavra-chave usada dentro de funções para devolver um valor como resultado.
numpy – é a biblioteca voltada para cálculos numéricos e manipulação de matrizes e arrays multidimensionais.
as np – define um apelido (alias) para a biblioteca importada. Assim, em vez de escrever numpy, usamos np.
np.array([]) – é a função da NumPy que cria um array (estrutura semelhante a lista, mas otimizada para cálculos matemáticos).
np.linalg.solve() – é a função da NumPy que resolve sistemas lineares da forma 𝐴𝑥=𝑏.
# – é usado para criar comentários ao código, que são notas para se entender melhor o que o código faz.
Vamos ao código…
# Usando SymPy (biblioteca simbólica)
from sympy import symbols, Eq, solve
# Definindo as variáveis
x, y = symbols('x y')
# Equações do sistema
eq1 = Eq(5*x - 7*y, 2)
eq2 = Eq(3*x + 4*y, 34)
# Resolvendo o sistema
solucao = solve((eq1, eq2), (x, y))
print("Solução do sistema:")
print(f"x = {solucao[x]}, y = {solucao[y]}")| Código Python (.py) | O que faz |
| from sympy import symbols, Eq, solve | Importa funções da biblioteca SymPy: symbols (variáveis simbólicas), Eq (equações) e solve (resolver equações). |
| x, y = symbols(‘x y’) | Cria duas variáveis simbólicas chamadas x e y. |
| eq1 = Eq(5x – 7y, 2) | Define a primeira equação: 5𝑥−7𝑦=2. |
| eq2 = Eq(3*x + 4y, 34) | Define a segunda equação: 3𝑥+4𝑦=34. |
| solucao = solve((eq1, eq2), (x, y)) | Resolve o sistema formado por eq1 e eq2, retornando os valores de x e y. |
| print(“Solução do sistema:”) | Exibe um texto informativo no console. |
| print(f”x = {solucao[x]}, y = {solucao[y]}”) | Mostra os valores de x e y encontrados. |
Saída do código (valor de retorno)…
Solução do sistema:
x = 6, y = 4
# Usando substituição "manual" (sem utilização de bibliotecas Python)
# Equações: 5x - 7y = 2 e 3x + 4y = 34
# Passo 1: isolando x da primeira equação
def resolver_sistema():
# Isolando x
def x_em_funcao_de_y(y):
return (2 + 7*y) / 5
# Substituindo na segunda equação
y = 4 # calculado manualmente
x = x_em_funcao_de_y(y)
return x, y
x, y = resolver_sistema()
print(f"Solução: x = {x}, y = {y}")| Código Python (.py) | O que faz |
| def resolver_sistema(): | Define uma função chamada resolver_sistema. |
| def x_em_funcao_de_y(y): | Define uma função interna que calcula x em função de y. |
| return (2 + 7*y) / 5 | Fórmula isolada da primeira equação: 𝑥=2+7𝑦 / 5. |
| y = 4 # calculado manualmente | Define o valor de y (já resolvido previamente). |
| x = x_em_funcao_de_y(y) | Calcula x substituindo o valor de y. |
| return x, y | Retorna os valores de x e y. |
| x, y = resolver_sistema() | Chama a função e guarda os resultados em x e y. |
| print(f”Solução: x = {x}, y = {y}”) | Exibe a solução encontrada. |
Saída do código (valor de retorno)…
Solução: x = 6.0, y = 4
# Usando NumPy (método matricial)
import numpy as np
# Coeficientes do sistema
A = np.array([[5, -7],
[3, 4]])
# Termos independentes
b = np.array([2, 34])
# Resolvendo Ax = b
solucao = np.linalg.solve(A, b)
print("Solução do sistema:")
print(f"x = {solucao[0]}, y = {solucao[1]}")| Código Python (.py) | O que faz |
| import numpy as np | Importa a biblioteca NumPy e dá o apelido np. |
| A = np.array([[5, -7], [3, 4]]) | Cria a matriz dos coeficientes do sistema. |
| b = np.array([2, 34]) | Cria o vetor dos termos independentes: [2,34]. |
| solucao = np.linalg.solve(A, b) | Resolve o sistema linear 𝐴𝑥=𝑏 usando álgebra matricial. |
| print(“Solução do sistema:”) | Exibe um texto informativo. |
| print(f”x = {solucao[0]}, y = {solucao[1]}”) | Mostra os valores de x e y encontrados. |
Saída do código (valor de retorno)…
Solução do sistema:
x = 5.999999999999998, y = 3.999999999999999
Fonte:
– Editora Didática Paulista. Ensino Didático 2000: Ensino Fundamental e Ensino Médio. Sorocaba: Editora Didática Paulista, [s.d.].
– Códigos e comentários gerados por Microsoft Copilot com revisão nossa.
– https://docs.python.org/pt-br/3/ [Documentação Oficial do Python]