En este post de programación en Python con matemáticas te enseñaré cómo manejar fracciones o quebrados para hacer las operaciones de las mismas.

Veremos cómo hacer la suma, resta, producto, cociente (o multiplicación y división), inversa, potencia, simplificación y conversión entre mixta e impropia.

Básicamente te enseñaré cómo abstraer los quebrados en Python para que puedas operar con ellos y hacer todas sus operaciones. Desconozco si ya existe una librería que haga eso (o si el propio lenguaje lo hace), pero yo te enseñaré a hacerlo manualmente.

Las operaciones

Como te dije, vamos a operar con fracciones. Vamos a resolver:

• Suma
• Resta
• Multiplicación o producto
• Cociente o división
• Inversa de la fracción
• Potencia de una fracción

Además de convertir entre fracciones mixtas e impropias, así como simplificar quebrados. Supongo que en este punto ya sabes cómo hacer esas operaciones manualmente.

Clases ayudantes

Resolvamos esto con Programación orientada a objetos para hacer las cosas más fáciles. Una fracción tiene un numerador y un denominador. Para operar con otra, necesitamos recibir un objeto de la misma clase.

Para el caso de las fracciones mixtas las mismas tienen una parte entera y una fracción, misma que es de la clase Fraccion. Entonces vamos a tener dos clases: Fraccion y FraccionMixta.

Clase Fracción

Veamos primero el constructor que recibe el numerador y denominador. También definimos los métodos para convertirlo a cadena, y otro método que compara las fracciones:

def __init__(self, numerador, denominador):
    self.numerador = int(numerador)
    if denominador == 0:
        raise Exception("El denominador no puede ser 0")
    self.denominador = int(denominador)

def __str__(self):
    return str(self.numerador) + "/" + str(self.denominador)

def equivalente(self, otra: 'Fraccion') -> bool:
    return self.denominador == otra.denominador and self.numerador == otra.numerador

Como puedes ver, el denominador no puede ser 0, ya que de serlo se lanzará una excepción. A continuación vemos algunos ayudantes, pues para algunas cosas necesitaremos el Mínimo común múltiplo y el máximo común divisor:

"""
Ayudantes


"""

def maximo_comun_divisor(self, a, b):
    temporal = 0
    while b != 0:
        temporal = b
        b = a % b
        a = temporal
    return a

def minimo_comun_multiplo(self, a, b):
    return (a * b) / self.maximo_comun_divisor(a, b)

Finalmente veamos todos los métodos que se encargan de las operaciones. Aquí es en donde la magia sucede para poder resolver fracciones con Python:

"""
Operaciones
"""

def suma(self, otra: 'Fraccion') -> 'Fraccion':
    mcm = self.minimo_comun_multiplo(self.denominador, otra.denominador)
    diferencia_self = mcm/self.denominador
    diferencia_otra = mcm/otra.denominador
    numerador_resultado = (diferencia_self*self.numerador) + \
        (diferencia_otra*otra.numerador)
    return Fraccion(numerador_resultado, mcm)

def resta(self, otra: 'Fraccion') -> 'Fraccion':
    mcm = self.minimo_comun_multiplo(self.denominador, otra.denominador)
    diferencia_self = mcm/self.denominador
    diferencia_otra = mcm/otra.denominador
    numerador_resultado = (diferencia_self*self.numerador) - \
        (diferencia_otra*otra.numerador)
    return Fraccion(numerador_resultado, mcm)

def producto(self, otra: 'Fraccion') -> 'Fraccion':
    return Fraccion(self.numerador*otra.numerador, self.denominador*otra.denominador)

def cociente(self, otra: 'Fraccion') -> 'Fraccion':
    return Fraccion(self.numerador*otra.denominador, self.denominador*otra.numerador)

def inversa(self) -> 'Fraccion':
    return Fraccion(self.denominador, self.numerador)

def potencia(self, exponente) -> 'Fraccion':
    return Fraccion(self.numerador ** exponente, self.denominador ** exponente)

def simplifica(self) -> 'Fraccion':
    mcd = self.maximo_comun_divisor(self.numerador, self.denominador)
    return Fraccion(self.numerador / mcd, self.denominador / mcd)

def a_mixta(self) -> 'FraccionMixta':
    return FraccionMixta.desde_impropia(self)

Como mencioné antes, vamos a usar el mínimo común múltiplo para el caso de la resta y la suma. Además, el máximo común divisor se usa igualmente para simplificar el quebrado.

Existen otros métodos que convierten la fracción a mixta, pero eso tiene que ver con la siguiente clase. El código completo de la clase para manejar quebrados es:

"""

  ____          _____               _ _           _       
 |  _ \        |  __ \             (_) |         | |      
 | |_) |_   _  | |__) |_ _ _ __ _____| |__  _   _| |_ ___ 
 |  _ <| | | | |  ___/ _` | '__|_  / | '_ \| | | | __/ _ \
 | |_) | |_| | | |  | (_| | |   / /| | |_) | |_| | ||  __/
 |____/ \__, | |_|   \__,_|_|  /___|_|_.__/ \__, |\__\___|
         __/ |                               __/ |        
        |___/                               |___/         
    
____________________________________
/ Si necesitas ayuda, contáctame en \
\ https://parzibyte.me               /
 ------------------------------------
        \   ^__^
         \  (oo)\_______
            (__)\       )\/\
                ||----w |
                ||     ||
Creado por Parzibyte (https://parzibyte.me).
------------------------------------------------------------------------------------------------
            | IMPORTANTE |
Si vas a borrar este encabezado, considera:
Seguirme: https://parzibyte.me/blog/sigueme/
Y compartir mi blog con tus amigos
También tengo canal de YouTube: https://www.youtube.com/channel/UCroP4BTWjfM0CkGB6AFUoBg?sub_confirmation=1
Twitter: https://twitter.com/parzibyte
Facebook: https://facebook.com/parzibyte.fanpage
Instagram: https://instagram.com/parzibyte
Hacer una donación vía PayPal: https://paypal.me/LuisCabreraBenito
------------------------------------------------------------------------------------------------
"""
class Fraccion():
    def __init__(self, numerador, denominador):
        self.numerador = int(numerador)
        if denominador == 0:
            raise Exception("El denominador no puede ser 0")
        self.denominador = int(denominador)

    def __str__(self):
        return str(self.numerador) + "/" + str(self.denominador)

    def equivalente(self, otra: 'Fraccion') -> bool:
        return self.denominador == otra.denominador and self.numerador == otra.numerador

    """
    Ayudantes
    
    
    """

    def maximo_comun_divisor(self, a, b):
        temporal = 0
        while b != 0:
            temporal = b
            b = a % b
            a = temporal
        return a

    def minimo_comun_multiplo(self, a, b):
        return (a * b) / self.maximo_comun_divisor(a, b)

    """
    Operaciones
    """

    def suma(self, otra: 'Fraccion') -> 'Fraccion':
        mcm = self.minimo_comun_multiplo(self.denominador, otra.denominador)
        diferencia_self = mcm/self.denominador
        diferencia_otra = mcm/otra.denominador
        numerador_resultado = (diferencia_self*self.numerador) + \
            (diferencia_otra*otra.numerador)
        return Fraccion(numerador_resultado, mcm)

    def resta(self, otra: 'Fraccion') -> 'Fraccion':
        mcm = self.minimo_comun_multiplo(self.denominador, otra.denominador)
        diferencia_self = mcm/self.denominador
        diferencia_otra = mcm/otra.denominador
        numerador_resultado = (diferencia_self*self.numerador) - \
            (diferencia_otra*otra.numerador)
        return Fraccion(numerador_resultado, mcm)

    def producto(self, otra: 'Fraccion') -> 'Fraccion':
        return Fraccion(self.numerador*otra.numerador, self.denominador*otra.denominador)

    def cociente(self, otra: 'Fraccion') -> 'Fraccion':
        return Fraccion(self.numerador*otra.denominador, self.denominador*otra.numerador)

    def inversa(self) -> 'Fraccion':
        return Fraccion(self.denominador, self.numerador)

    def potencia(self, exponente) -> 'Fraccion':
        return Fraccion(self.numerador ** exponente, self.denominador ** exponente)

    def simplifica(self) -> 'Fraccion':
        mcd = self.maximo_comun_divisor(self.numerador, self.denominador)
        return Fraccion(self.numerador / mcd, self.denominador / mcd)

    def a_mixta(self) -> 'FraccionMixta':
        return FraccionMixta.desde_impropia(self)

Más adelante veremos cómo usarla.

La fracción mixta

Una fracción mixta tiene una parte entera y una fracción. En este caso las operaciones que tiene son la de convertir la mixta a impropia, y convertir una impropia a una mixta.

También cuenta con el constructor y el método para convertir la fracción a cadena.

class FraccionMixta():
    def __init__(self, entero: int, fraccion: 'Fraccion'):
        self.entero = entero
        self.fraccion = fraccion

    def a_impropia(self):
        numerador = self.fraccion.numerador
        if(self.entero != 0):
            numerador = numerador + (self.fraccion.denominador*self.entero)
        return Fraccion(numerador, self.fraccion.denominador)

    def desde_impropia(fraccion: 'Fraccion'):
        entero = 0
        if fraccion.numerador >= fraccion.denominador:
            entero = fraccion.numerador//fraccion.denominador
            residuo = fraccion.numerador % fraccion.denominador
            if residuo > 0:
                fraccion = Fraccion(residuo, fraccion.denominador)
            else:
                fraccion = None
        return FraccionMixta(entero, fraccion)

    def __str__(self):
        resultado = ""
        if self.entero:
            resultado += str(self.entero)
            if self.fraccion != None:
                resultado += " + "
        if self.fraccion:
            resultado += str(self.fraccion)
        return resultado

Lo único que hacemos es hacer las operaciones matemáticas pero usando el lenguaje de programación Python. Verás que es muy fácil operar con las fracciones.

Modo de uso

Ya vimos las clases, ahora veamos cómo usarlas. Primero debemos importar las clases o tenerlas en el mismo archivo en donde las vamos a usar. Yo he optado por separarlas e importarlas por separado:

from fraccion import Fraccion, FraccionMixta

Ya después podemos crear una instancia e invocar a sus métodos. Por ejemplo, para sumar 2 quebrados en Python:

f = Fraccion(5, 6)
f2 = Fraccion(7, 24)
print(f"{f} + {f2} = {f.suma(f2)}")

Poniendo todo junto

Para terminar el post te demostraré todos los métodos que podemos usar así como los resultados. Verás que son correctos, y que podemos usarlos según nuestras necesidades.

Por ejemplo, podrías primero sumar una fracción y después simplificarla, o convertirla a mixta. Eres libre de combinar todos los métodos.

"""

  ____          _____               _ _           _       
 |  _ \        |  __ \             (_) |         | |      
 | |_) |_   _  | |__) |_ _ _ __ _____| |__  _   _| |_ ___ 
 |  _ <| | | | |  ___/ _` | '__|_  / | '_ \| | | | __/ _ \
 | |_) | |_| | | |  | (_| | |   / /| | |_) | |_| | ||  __/
 |____/ \__, | |_|   \__,_|_|  /___|_|_.__/ \__, |\__\___|
         __/ |                               __/ |        
        |___/                               |___/         
    
____________________________________
/ Si necesitas ayuda, contáctame en \
\ https://parzibyte.me               /
 ------------------------------------
        \   ^__^
         \  (oo)\_______
            (__)\       )\/\
                ||----w |
                ||     ||
Creado por Parzibyte (https://parzibyte.me).
------------------------------------------------------------------------------------------------
            | IMPORTANTE |
Si vas a borrar este encabezado, considera:
Seguirme: https://parzibyte.me/blog/sigueme/
Y compartir mi blog con tus amigos
También tengo canal de YouTube: https://www.youtube.com/channel/UCroP4BTWjfM0CkGB6AFUoBg?sub_confirmation=1
Twitter: https://twitter.com/parzibyte
Facebook: https://facebook.com/parzibyte.fanpage
Instagram: https://instagram.com/parzibyte
Hacer una donación vía PayPal: https://paypal.me/LuisCabreraBenito
------------------------------------------------------------------------------------------------
"""
from fraccion import Fraccion, FraccionMixta

f = Fraccion(5, 6)
f2 = Fraccion(7, 24)
print(f"{f} + {f2} = {f.suma(f2)}")
print(f"{f} - {f2} = {f.resta(f2)}")
print(f"{f} * {f2} = {f.producto(f2)}")
print(f"{f} / {f2} = {f.cociente(f2)}")
print(f"Inversa de {f} = {f.inversa()}")
exponente = 3
print(f"Potencia de {f} con exponente {exponente} = {f.potencia(exponente)}")
fraccion_para_simplificar = Fraccion(80, 120)
print(
    f"Simplificar {fraccion_para_simplificar} = {fraccion_para_simplificar.simplifica()}")
f3 = Fraccion(1, 5)
f4 = Fraccion(1, 3)
f5 = Fraccion(1, 5)
print(f"{f3} es igual a {f4}? {f3.equivalente(f4)}")
print(f"{f3} es igual a {f5}? {f3.equivalente(f5)}")
print(f"{f4} es igual a {f5}? {f4.equivalente(f5)}")

fracciones = [

    Fraccion(7, 3),
    Fraccion(2, 3),
    Fraccion(5, 5),
    Fraccion(10, 5),
    Fraccion(1, 5),
    Fraccion(7, 5),
    Fraccion(71, 5),
]

for fraccion in fracciones:
    print(f"{fraccion} a mixta = {fraccion.a_mixta()}")

fracciones = [
    FraccionMixta(1, Fraccion(3, 5)),
    FraccionMixta(0, Fraccion(3, 5)),
    FraccionMixta(2, Fraccion(3, 5)),
    FraccionMixta(1, Fraccion(2, 5)),
    FraccionMixta(14, Fraccion(1, 5)),
    FraccionMixta(0, Fraccion(1, 1)),
]

for fraccion in fracciones:
    print(f"{fraccion} a impropia = {fraccion.a_impropia()}")

Te dejo el código completo en GitHub. Recuerda que igualmente puedes aprender más sobre Python en mi blog.

Por cierto, puedes ver la explicación en YouTube: