Calculadora de números complejos en Python

Más ejercicios resueltos

Si deseas revisar más ejercicios resueltos, haz click en el siguiente botón. 

El diseño de una calculadora de números complejos es un ejercicio básico que permite entender el funcionamiento de las condicionales anidadas y selectivas múltiples. En este artículo analizamos con bastante detalle este ejercicio poniendo énfasis en la lógica de programación y en la estructura selectiva anidada y múltiple empleando como herramienta PSeInt. Si deseas conocer con más detalle el enunciado del ejercicio calculadora de números complejos, haz click en el siguiente enlace.

El análisis de este ejercicio se encuentra sintetizado en el vídeo «Selectivas Anidadas en Python» en nuestro canal de YouTube. Te invitamos a que lo visites.

Lectura de datos

Para la lectura de datos en Python usaremos la función \texttt{input}. Usaremos la variable \texttt{operacion} para leer la operación aritmética. Para leer el primer número complejo usaremos las variables \texttt{par\_real1} y \texttt{par\_imag1}. De forma análoga, para leer el segundo número complejo usaremos las variables \texttt{par\_real2} y \texttt{par\_imag2}. En el caso de la lectura de los valores reales, usamos la función \texttt{float} para transformar la cadena de caracteres en un valor numérico. 

operacion=input("Ingrese operación (+,-,*,/):")
par_real1=float(input("Ingrese parte real del número 1: "))
par_imag1=float(input("Ingrese parte imaginaria del número 1: "))
par_real2=float(input("Ingrese parte real del número 2: "))
par_imag2=float(input("Ingrese parte imaginaria del número 2: ")) 

Control de flujo para las operaciones aritméticas

Para el control de flujo usaremos instrucciones selectivas anidadas. Usamos un \texttt{if} y anidamos varias condiciones a través de \texttt{elif}.

Para almacenar el resultado usaremos las variables \texttt{par\_real} y \texttt{par\_imag}. La idea es calcular el valor de estas variables en cada flujo alternativo de acuerdo a la regla de cada operación.

operacion=input("Ingrese operación (+,-,*,/):")
par_real1=float(input("Ingrese parte real del número 1: "))
par_imag1=float(input("Ingrese parte imaginaria del número 1: "))
par_real2=float(input("Ingrese parte real del número 2: "))
par_imag2=float(input("Ingrese parte imaginaria del número 2: "))

if operacion=='+':

elif operacion=='-':

elif operacion=='*':

elif operacion=='/':

print("El resultado es: {:.3f} + {:.3f}i".format(par_real, par_imag)) 

Calculando el resultado

El siguiente paso corresponde al cálculo de la operación propiamente dicha. Se realizarán 4 cálculos, uno en cada camino alternativo (\texttt{+}, \texttt{-}, \texttt{*}, \texttt{/}). Recuerde que el operador \texttt{**} permite elevar un número a cualquier potencia.

operacion=input("Ingrese operación (+,-,*,/):")
par_real1=float(input("Ingrese parte real del número 1: "))
par_imag1=float(input("Ingrese parte imaginaria del número 1: "))
par_real2=float(input("Ingrese parte real del número 2: "))
par_imag2=float(input("Ingrese parte imaginaria del número 2: "))

if operacion=='+':
    par_real = par_real1 + par_real2
    par_imag = par_imag1 + par_imag2
elif operacion=='-':
    par_real = par_real1 - par_real2
    par_imag = par_imag1 - par_imag2
elif operacion=='*':
    par_real = par_real1 * par_real2 - par_imag1 * par_imag2
    par_imag = par_real1 * par_imag2 + par_imag1 * par_real2
elif operacion=='/':
    denominador = par_real2**2 + par_imag2**2
    par_real = par_real1 * par_real2 + par_imag1 * par_imag2
    par_real /= denominador
    par_imag = par_imag1 * par_real2 - par_real1 * par_imag2
    par_imag /= denominador

print("El resultado es: {:.3f} + {:.3f}i".format(par_real, par_imag)) 

Validando la operación leída

Para validar la operación leída usaremos una bandera. Inicializamos la variable \texttt{operación\_valida}  con el valor de \texttt{True}. «Bajamos» la bandera cuando se detecta una operación no reconocida. Para esto usamos la cláusula \texttt{else} de la selectiva anidada. Antes de imprimir el resultado, verificamos si la bandera está «levantada», lo que significa que la operación es válida.

operacion=input("Ingrese operación (+,-,*,/):")
par_real1=float(input("Ingrese parte real del número 1: "))
par_imag1=float(input("Ingrese parte imaginaria del número 1: "))
par_real2=float(input("Ingrese parte real del número 2: "))
par_imag2=float(input("Ingrese parte imaginaria del número 2: "))

operacion_valida = True

if operacion=='+':
    par_real = par_real1 + par_real2
    par_imag = par_imag1 + par_imag2
elif operacion=='-':
    par_real = par_real1 - par_real2
    par_imag = par_imag1 - par_imag2
elif operacion=='*':
    par_real = par_real1 * par_real2 - par_imag1 * par_imag2
    par_imag = par_real1 * par_imag2 + par_imag1 * par_real2
elif operacion=='/':
    denominador = par_real2**2 + par_imag2**2
    if denominador == 0:
        division_por_cero = True
    else:
        par_real = par_real1 * par_real2 + par_imag1 * par_imag2
        par_real /= denominador
        par_imag = par_imag1 * par_real2 - par_real1 * par_imag2
        par_imag /= denominador
else:                
    operacion_valida = False
    print("La operación no es válida")

if operacion_valida:
    print("El resultado es: {:.3f} + {:.3f}i".format(par_real, par_imag)) 

Validando división entre cero

El último paso corresponde con la validación de la división entre cero. También usaremos una bandera para este caso. Estamos definiendo la variable \texttt{division\_por\_cero} la cual inicializamos con False. Cuando al operar una división, notemos que el segundo número es cero, «levantamos» esta bandera.

operacion=input("Ingrese operación (+,-,*,/):")
par_real1=float(input("Ingrese parte real del número 1: "))
par_imag1=float(input("Ingrese parte imaginaria del número 1: "))
par_real2=float(input("Ingrese parte real del número 2: "))
par_imag2=float(input("Ingrese parte imaginaria del número 2: "))

division_por_cero = False
operacion_valida = True

if operacion=='+':
    par_real = par_real1 + par_real2
    par_imag = par_imag1 + par_imag2
elif operacion=='-':
    par_real = par_real1 - par_real2
    par_imag = par_imag1 - par_imag2
elif operacion=='*':
    par_real = par_real1 * par_real2 - par_imag1 * par_imag2
    par_imag = par_real1 * par_imag2 + par_imag1 * par_real2
elif operacion=='/':
    denominador = par_real2**2 + par_imag2**2
    if denominador == 0:
        division_por_cero = True
    else:
        par_real = par_real1 * par_real2 + par_imag1 * par_imag2
        par_real /= denominador
        par_imag = par_imag1 * par_real2 - par_real1 * par_imag2
        par_imag /= denominador
else:                
    operacion_valida = False
    print("La operación no es válida")

if operacion_valida:
    if division_por_cero:
        print("No se puede dividir entre cero")
    else:
        print("El resultado es: {:.3f} + {:.3f}i".format(par_real, par_imag)) 

Python y los números complejos

Python maneja números complejos como tipo de dato nativo. Se puede usar la función \texttt{complex} para retornar un número complejo dada la parte real e imaginaria del mismo. El programa quedaría como se muestra a continuación.

operacion=input("Ingrese operación (+,-,*,/):")
par_real1=float(input("Ingrese parte real del número 1: "))
par_imag1=float(input("Ingrese parte imaginaria del número 1: "))
par_real2=float(input("Ingrese parte real del número 2: "))
par_imag2=float(input("Ingrese parte imaginaria del número 2: "))

division_por_cero = False
operacion_valida = True

n1=complex(par_real1, par_imag1)
n2=complex(par_real2, par_imag2)
if operacion=='+':
    n3=n1+n2
elif operacion=='-':
    n3=n1-n2
elif operacion=='*':
    n3=n1*n2
elif operacion=='/':
    denominador = par_real2**2 + par_imag2**2
    if denominador == 0:
        division_por_cero = True
    else:
        n3=n1/n2
else:                
    operacion_valida = False
    print("La operación no es válida")

if operacion_valida:
    if division_por_cero:
        print("No se puede dividir entre cero")
    else:
        print("El resultado es: {}".format(n3)) 

Conclusión

Hemos presentado en este artículo, una propuesta de solución al diseño de una calculadora de operaciones aritméticas de números complejos en Python. Se ha utilizado para el control de flujo estructuras selectivas anidadas. Podrá descargar la solución propuesta en el repositorio GitHub de iterando++ a través del siguiente enlace

Hemos preparado otros artículos adicionales en donde describimos al detalle la implementación de este problema PSeInt y en otros lenguajes de programación. Te invitamos a leer los siguientes artículos de iterando++

Si te interesa profundizar más en el desarrollo en Python, los dos mejores libros que se han escrito son Learning Python de Mark Lutz y Python Crash Course de Eric Matthes.

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *