Regra de Três em Código
Sobre a Matemática
É a que ensina a resolver problemas por meio de proporções. Chama-se de três, pois os elementos conhecidos são ordinariamente três.
É direta se as grandezas que entram no problema são diretamente proporcionais, e inversa se o são inversamente.
Divide-se em simples e composta, conforma a resolução exija uma ou várias proporções.
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 para matemática simbólica (álgebra, equações, cálculo).
import – é a palavra-chave usada para trazer módulos ou funções externas para o código.
symbols() – é a função da SymPy que cria variáveis simbólicas (representam incógnitas em equações).
Eq() – é a função da SymPy que define uma equação matemática (lado esquerdo = lado direito).
solve() – é a função da SymPy que resolve equações e retorna os valores das incógnitas.
def – é a palavra-chave usada para definir uma função.
Docstring – é o texto entre aspas triplas """ ... """ dentro de funções, usado para documentar o que a função faz.
if: – é a estrutura condicional: executa um bloco de código se a condição for verdadeira.
elif: (“Else if”) – executa outro bloco se a condição anterior for falsa e esta for verdadeira.
else: – executa um bloco de código caso nenhuma condição anterior seja satisfeita.
*= – é um operador de atribuição composto. Ele multiplica o valor atual de uma variável por outro valor e, em seguida, atualiza a própria variável com o resultado.
raise – é usado para lançar (gerar) uma exceção/erro no programa.
ValueError() – é o tipo de exceção, indica que um valor passado é inválido.
return – é a palavra-chave que encerra a função e devolve um valor para quem a chamou.
for..in..: – é a estrutura de repetição que percorre elementos de uma sequência (lista, string, etc.).
zip() – é a função que combina duas ou mais listas em pares (tuplas), permitindo iterar sobre elas simultaneamente.
print() – é a função que exibe informações na saída padrão (geralmente no console).
# – é 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…
from sympy import symbols, Eq, solve
def regra_de_tres_simples(a, b, c, tipo="direta"):
"""
Resolve regra de três simples.
a está para b assim como c está para x.
tipo: 'direta' ou 'inversa'
"""
x = symbols('x')
if tipo == "direta":
eq = Eq(a/b, c/x)
elif tipo == "inversa":
eq = Eq(a/b, x/c)
else:
raise ValueError("Tipo deve ser 'direta' ou 'inversa'")
resultado = solve(eq, x)
return resultado[0]| Código Python (.py) | O que faz |
| from sympy import symbols, Eq, solve | Importa funções da biblioteca SymPy: symbols cria variáveis simbólicas, Eq define equações, e solve resolve essas equações. |
| def regra_de_tres_simples(a, b, c, tipo=”direta”): | Define uma função chamada regra_de_tres_simples que recebe três valores conhecidos (a, b, c) e o tipo de proporção (direta ou inversa). |
| “”” … “”” | Comentário explicativo (docstring) descrevendo o que a função faz. |
| x = symbols(‘x’) | Cria a variável simbólica x, que será a incógnita da equação. |
| if tipo == “direta”: | Verifica se o tipo escolhido é direta. |
| eq = Eq(a/b, c/x) | Monta a equação da regra de três direta: 𝑎/𝑏=𝑐/𝑥. |
| elif tipo == “inversa”: | Caso contrário, verifica se o tipo é inversa. |
| eq = Eq(a/b, x/c) | Monta a equação da regra de três inversa: 𝑎/𝑏=𝑥/𝑐. |
| else: | Se o tipo não for válido, cai aqui. |
| raise ValueError(“Tipo deve ser ‘direta’ ou ‘inversa'”) | Lança um erro informando que o tipo deve ser apenas “direta” ou “inversa”. |
| resultado = solve(eq, x) | Resolve a equação para encontrar o valor de x. |
| return resultado[0] | Retorna o valor encontrado para x. |
def regra_de_tres_composta(valores_a, valores_b, tipo="direta"):
"""
Resolve regra de três composta.
valores_a: lista de grandezas conhecidas (lado A)
valores_b: lista de grandezas correspondentes (lado B)
tipo: 'direta' ou 'inversa'
"""
x = symbols('x')
proporcao = 1
for a, b in zip(valores_a, valores_b):
if tipo == "direta":
proporcao *= a/b
elif tipo == "inversa":
proporcao *= b/a
else:
raise ValueError("Tipo deve ser 'direta' ou 'inversa'")
eq = Eq(proporcao, x)
resultado = solve(eq, x)
return resultado[0]| Código Python (.py) | O que faz |
| def regra_de_tres_composta(valores_a, valores_b, tipo=”direta”): | Define a função para regra de três composta, recebendo listas de valores (valores_a e valores_b). |
| x = symbols(‘x’) | Cria a incógnita x. |
| proporcao = 1 | Inicializa a variável proporcao com 1 (será usada para multiplicar as razões). |
| for a, b in zip(valores_a, valores_b): | Faz um loop percorrendo pares de valores das listas valores_a e valores_b. |
| if tipo == “direta”: | Verifica se é uma proporção direta. |
| proporcao *= a/b | Multiplica a proporção acumulada por 𝑎/𝑏. |
| elif tipo == “inversa”: | Caso seja inversa. |
| proporcao *= b/a | Multiplica a proporção acumulada por 𝑏/𝑎. |
| else: | Se o tipo não for válido. |
| raise ValueError(“Tipo deve ser ‘direta’ ou ‘inversa'”) | Lança erro avisando que o tipo é inválido. |
| eq = Eq(proporcao, x) | Cria a equação final da regra de três composta. |
| resultado = solve(eq, x) | Resolve a equação para encontrar x. |
| return resultado[0] | Retorna o valor encontrado. |
# Exemplos de uso:
print("Simples Direta: 2 está para 4 assim como 6 está para x")
print(regra_de_tres_simples(2, 4, 6, tipo="direta"))
print("Simples Inversa: 5 está para 10 assim como 8 está para x")
print(regra_de_tres_simples(5, 10, 8, tipo="inversa"))
print("Composta Direta: [2, 3] está para [4, 6] assim como x")
print(regra_de_tres_composta([2, 3], [4, 6], tipo="direta"))| Código Python (.py) | O que faz |
| print(“Simples Direta: 2 está para 4 assim como 6 está para x”) | Imprime uma explicação do exemplo de regra de três direta. |
| print(regra_de_tres_simples(2, 4, 6, tipo=”direta”)) | Chama a função e imprime o resultado da regra de três direta. |
| print(“Simples Inversa: 5 está para 10 assim como 8 está para x”) | Imprime explicação do exemplo de regra de três inversa. |
| print(regra_de_tres_simples(5, 10, 8, tipo=”inversa”)) | Chama a função e imprime o resultado da regra de três inversa. |
| print(“Composta Direta: [2, 3] está para [4, 6] assim como x”) | Imprime explicação do exemplo de regra de três composta. |
| print(regra_de_tres_composta([2, 3], [4, 6], tipo=”direta”)) | Chama a função e imprime o resultado da regra de três composta. |
Saída do código (valor de retorno)…
Simples Direta: 2 está para 4 assim como 6 está para x
12.0000000000000
Simples Inversa: 5 está para 10 assim como 8 está para x
4.00000000000000
Composta Direta: [2, 3] está para [4, 6] assim como x
0.250000000000000
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]