Playgrounds: Captura la excepción: ZeroDivisionError

Vamos aprendiendo

def my_divide(a, b):
  # Escribe tu solución 👇
  try:
    result = a / b
  except ZeroDivisionError as error:
    result = 'No se puede dividir por 0'
  return result
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

Estuve un buen rato luchando contra unos errores, pero cumplía con lo solicitado, solo que yo estaba usando " … " en lugar de ’ … ’

Espero que no les pase.

def my_divide(a, b):
   try:
      return a/b
   except ZeroDivisionError:
      return "No se puede dividir por 0"
  
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

Si fuera en español

- Esto para mi tiene más sentido porque se trata de entender la sintaxis y no memorizarla mecanicamente.

• en ingles:

 try:
      result = a / b
      return result
   except ZeroDivisionError as error:
      return 'No se puede dividir por 0'

• es español:

intenta:
	resultado = a / b
	entonces retorna resultado
excepto el error de división cero como error:
	entonces retorna 'No se puede dividir entre cero'

El ejercico esta en blanco alguin que lo repare

# Mi solución 👇
def my_divide(a, b):
   result = None
   try:
      result = a / b
   except ZeroDivisionError:
      result = "No se puede dividir por 0"
   return result
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

este es un código que lo que hacer es que pide una pareja de números para después dividirlos y en caso de que encuentre que el resultado es una división por cero saca un mensaje de error y pide volver a ingresar la pareja de números

print("""

Escoge una pareja de números, uno corresponderá a la letra “a” y otro a la letra “b”, para hacer la división de a/b""")

def my_divide(a,b):
try:
result = int(a) / int(b)
except ZeroDivisionError as error:
result = "es una división por cero, debes volver a ingresar los números"
return result

response = my_divide(input('entra a => '),input('entra b => '))
print("El resultado de esta división es " +str(response))

Dejo mi solución porque creo que la hice un poco diferente a los demás, para aportar otras opciones:

def my_divide(a, b):
   # Escribe tu solución 👇
   try:
      result = a / b
      return result
   except ZeroDivisionError:
      return 'No se puede dividir por 0'
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

Solución muy sencilla aprovechando la propiedad de que las funciones se detienen al hacer un return

def my_divide(a, b):
   if b == 0:
      return 'No se puede dividir por 0'
   result = a / b
   return result
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

No me permitio jugar en este playground, y es raro, lo probe en 3 navegadores, y los anteriores me habian funcionado

def my_divide(a, b):
   # Escribe tu solución 👇
  try:
    result = a / b
  except ZeroDivisionError as error:
    result = 'No se puede dividir por 0'
  return result
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

Mi solución:

def my_divide(a, b):
   # Escribe tu solución 👇
    try:
        result = a / b
        return result
    except:
        return 'No se puede dividir por 0'
        
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

Solucion:

def my_divide(a, b):
   # Escribe tu solución 👇
   try:
      result = a / b
   except ZeroDivisionError:
      result = 'No se puede dividir por 0'
   return result
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

Está sería mi solución

def my_divide(a, b):
   # Escribe tu solución 👇
   try:
       result = a / b
   except ZeroDivisionError as error:
       error = 'No se puede dividir por 0'
       result = error
       
   return result
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

Me encanta esta nueva sección. Muchas gracias. Acá dejo la respuesta a este reto

def my_divide(a, b):
  if a == 0 or b == 0:
    try:
      result = a / b
    except ZeroDivisionError as error:
      error = "No se puede dividir por 0"
      return error
  else:
    result = a / b
    return result

response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

def my_divide(a, b):
   try:
      if b==0:
         raise Exception('No se puede dividir por 0')
      result = a / b
      
   except Exception as e:
      result ="No se puede dividir por 0"
   return result
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

buen dia, campeon. buen reto.

def my_divide(a, b):
    try:
        if b == 0:
            raise ZeroDivisionError('No se puede dividir por 0')

        result = a / b
        return result

    except ZeroDivisionError as error:
        return str(error)

# Ejemplos de uso
response1 = my_divide(10, 2)

print(response1)  # Output: 5.0

response2 = my_divide(10, 0)
print(response2)  # Output: No se puede dividir por 0

En este ejercicio aprendi mucho con respecto al ejercicio en python. Espero seguir mejorando y aprendiendo sus secretos.

1. Define la función my_divide con dos parámetros, a y b, que representan los números a dividir:

   pythonCopy code
   def my_divide(a, b):
   
   

2. Dentro de la función, utiliza un bloque try para rodear la operación de división:

   pythonCopy code
   try:
   
   

3. En el bloque try, realiza la operación de división y asigna el resultado a una variable result:

   pythonCopy code
   result = a / b
   
   

4. Inmediatamente después del bloque try, agrega un bloque except para manejar la excepción ZeroDivisionError:

   pythonCopy code
   except ZeroDivisionError:
   
   

5. Dentro del bloque except, devuelve un mensaje de error indicando que no se puede dividir por cero:

   pythonCopy code
   return "No se puede dividir por 0"
   
   

6. Fuera del bloque try y except, la función continúa con su flujo normal.

7. Llama a la función my_divide con diferentes valores para a y b y almacena el resultado en la variable response:

   pythonCopy code
   response = my_divide(10, 2)
   
   

   pythonCopy code
   response = my_divide(10, 0)
   
   

8. Finalmente, imprime el resultado:

   pythonCopy code
   print(response)
   
   

Buenas compañeros, comparto mi solución a continuación:

def my_divide(a, b):
   # Escribe tu solución 👇
   try:
      result = a / b
   except ZeroDivisionError as error:
      result = 'No se puede dividir por 0'
   return result
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

Aqui como lo hice…

def my_divide(a, b):
   # Escribe tu solución 👇
   try:
      result = a / b
   
   except ZeroDivisionError:
      result = "No se puede dividir por 0"

   return result
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

😃

def my_divide(a, b):
   # Escribe tu solución 👇
   try:
      result = a / b
   except ZeroDivisionError:
      result = 'No se puede dividir por 0'

   return result

response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

no me funciona en la web, pero en vs code si:

def my_divide(a, b):
   # Escribe tu solución 👇
  try:
    result = a / b
    if result:
      return result
  except ZeroDivisionError as error:
      return str(error) + "- " + str(a) + " y " + str(b) + " no son divisibles por cero"
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

Aquí está mi solución:

def my_divide(a, b):
   try:
      # Escribe tu solución 👇
      result = a / b

      return result
   except ZeroDivisionError:
      return "No se puede dividir por 0"

    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

def my_divide(a, b):
    try:
        result = a / b
        return result
    except ZeroDivisionError as e:
        return "No se puede dividir por 0"

response = my_divide(10, 2)
print(response)  # Output: 5

response = my_divide(10, 0)

test_case_1

test_case_2

test_case_3

test_case_4

¡Felicidades, todas las pruebas pasaron!

Aqui mi solucion:
.
.
.
.
.
.
.
.

def my_divide(a, b):
   # Escribe tu solución 👇
   try:
      result = a / b
   except ZeroDivisionError as error:
      return 'No se puede dividir por 0'
   else:
      return result

response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

.
.
.
.
.
.
.

def my_divide(a, b):
   try:
      result = a / b
   except ZeroDivisionError as error:
     print('No se puede dividir por 0')
   return result

Mi solución, la cual no fue correcta ya que debía asignar a result la cadena de texto que no se puede dividir por 0 para tenerlo bien

def my_divide(a, b):
   # Escribe tu solución 👇
   try:
      result = a / b
   except ZeroDivisionError as error:
      return 'No se puede dividir por 0'
   return result

Les dejo mi respuesta si le srive a alguien 🏃‍♀️

def my_divide(a, b):
   # Escribe tu solución 👇
   try:
      result = a / b
   except ZeroDivisionError:
      result = 'No se puede dividir por 0'
   return result
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

# Para resolver este desafío,
# debes utilizar la función my_divide, 
# que recibe dos parámetros de entrada que representan los números a dividir.
def my_divide(a, b):
   # Escribe tu solución 👇
  
# Dentro de esta función, debes implementar la lógica necesaria para capturar la excepción ZeroDivisionError.
   try:
      result = a / b 
   except ZeroDivisionError as error:
      # También, debes retornar un mensaje que diga No se puede dividir por 0 cuando esta excepción ocurra.
      result = 'No se puede dividir por 0'
   return result
  
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

Me rompi la cabeza hasta que me di cuenta que la estaba reinventado la rueda con el execption ZeroDivisionError

def my_divide(a, b):
   # Escribe tu solución 👇
    try:
        print("Que es lo que esta pasando aqui")
        if (a==0) or (b == 0):
            raise ZeroDivisionError ("No se puede dividir por Cero")
    except ZeroDivisionError as error:
        print("Uppsss", error)
    else:
        result = a / b
        return result

def my_divide(a, b):
   # Escribe tu solución 👇
   try:
      result = a / b
      return result
   except ZeroDivisionError as error:
      return "No se puede dividir por 0"
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

Este si era reto para mi 😅 me demore por un error en return. Quería hacerlo con raise pero claro el mensaje no es limpio como con el try except.

Fino

def my_divide(a, b):
   # Escribe tu solución 👇
   try:
      result = a / b
   except ZeroDivisionError as error:
      result = "No se puede dividir por 0"
   return result
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

Buenas, compañeros. Dejo mi solución por acá, para que le sirva. 😃 ![](

def my_divide(a, b):
   # Escribe tu solución 👇

   try:
      result = a / b
   except ZeroDivisionError as error:
      result ="No se puede dividir por 0"
   return result
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

ME SALIERON CANAS, PERO APRENDI ALGO NUEVO

def my_divide(a, b):
   # Escribe tu solución 👇
   try:
      result = a / b
      return result
   except ZeroDivisionError as error:
      return 'No se puede dividir por 0'
    

def my_divide(a, b):
   # Escribe tu solución 👇
   try:
      result = a / b
   except ZeroDivisionError as error:
         result = "No se puede dividir por cero"
   return result
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

def my_divide(a, b):
   # Escribe tu solución 👇
   try:
      return a / b
   except ZeroDivisionError:
      return 'No se puede dividir por 0'
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

Aunque también lo hice con el Try, quise probar como me iba con un IF y también me funcionó

def my_divide(a, b):
  if b == 0:
    result = 'No se puede dividir por 0'
  else:
    result = a / b 
  return result
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

Usando try-error para que no se rompa aunque le ingreses letras o numeros decimales:

def division(a, b):
    try:
        dividendo = float(a)
        divisor = float(b)
        result = dividendo / divisor
        return result
    except ZeroDivisionError:
        print('Error: No se puede dividir por cero.')
        return division(input('inserte dividendo = > '), input('inserte divisor = > '))
    except ValueError:
        print('Debes ingresar valores numéricos.')
        return division(input('inserte dividendo = > '), input('inserte divisor = > '))
    
print(division(input('inserte dividendo = > '), input('inserte divisor = > ')))

def my_divide(a, b):
   # Escribe tu solución 👇
   try:
      result = a / b
   except ZeroDivisionError:
      result = 'No se puede dividir por 0'
   return result
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

y esta es la solución exacta para que el playgrounds nos lance los “confetti”.
def my_divide(a, b):

Escribe tu solución 👇

try:
result = a / b
except ZeroDivisionError as error:
return 'No se puede dividir por 0’
return result

response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

def my_divide(a, b):

Escribe tu solución 👇

try:
result = a / b
except ZeroDivisionError as error:
return error
return result

response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

def my_divide(a, b):

Escribe tu solución 👇

try:
result = a / b
return result
except ZeroDivisionError:
return ‘No se puede dividir por 0’

response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

Mi solución:

def my_divide(a, b):
   try:
      result = a / b
   except ZeroDivisionError:
      result = "No se puede dividir por 0"
   return result
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

def my_divide(a, b):
   try:
      result = a / b
   except ZeroDivisionError:
      result = "No se puede dividir por 0"
   return result
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

Voy aprendiendo

def my_divide(a, b):
   # Escribe tu solución 👇
   try:
      result = a / b
   except ZeroDivisionError as error:
      result = 'No se puede dividir por 0'
   return result
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0 

mi solucion es

def my_divide(a, b):
try:
result = a / b
except ZeroDivisionError as error:
result = "No se puede dividir por 0"
return result

response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

def my_divide(a, b):
   # Escribe tu solución 👇
   try:
     result = a / b
   except ZeroDivisionError as error:
     return "No se puede dividir por 0"
 
   return result
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

def my_divide(a, b):
try:
result = a / b
return result
except ZeroDivisionError as error:
result=(‘No se puede dividir por 0’)
return result

response = my_divide(10, 2)
print(response)

response = my_divide(10, 0)
print(response)

Utilicé un doble return, pero funciona 😃

def my_divide(a, b):
   try:
      result = a / b
      return result
   except ZeroDivisionError:
      return "No se puede dividir por 0"
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

Mi aporte:

<def my_divide(a, b):
   try:
      result = a/b
   except ZeroDivisionError as error:
         result = "No se puede dividir por 0"
   return result
  
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0> 

Les comparto mi propuesta de solución:

def my_divide(a, b):
   # Escribe tu solución 👇
  try:
    result = a / b
  except ZeroDivisionError:
    return "No se puede dividir por 0"
  return result
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

def my_divide(a, b):
   # Escribe tu solución 👇
   try:
      result = a / b
   except ZeroDivisionError as error:
      result = 'No se puede dividir por 0'
   return result
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

Realicé la prueba y este reto funciona. Así quedó:

def my_divide(a, b):
   # Escribe tu solución 👇
   try:
      result = a / b
   except ZeroDivisionError as error:
      result = "No se puede dividir por 0"
   return result

response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

   try:
      result = a / b
   except ZeroDivisionError:
      result = 'No se puede dividir por 0'
   finally:
      return result

mi aporte

<def my_divide(a, b):
   # Escribe tu solución 👇
   try:
      result = a / b
   except ZeroDivisionError as error:
      return "No se puede dividir por 0"
   return result
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0> 

def my_divide(a, b):
   # Escribe tu solución 👇
   try:
      result = a / b
      
   except ZeroDivisionError as error:
      result = 'No se puede dividir por cero'
   
   return result
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

Mi reto:

def my_divide(a, b):
   # Escribe tu solución 👇
   try:
      result = a / b
   except ZeroDivisionError as error:
      result = 'No se puede dividir por 0'
   return result
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

Se puede usar Exception ya que es una clase mas genérica, engloba los otros errores

 def my_divide(a, b): 
  try:
    return a/b
  except Exception as error:
    return 'No se puede dividir para 0'
            
    
response = my_divide(22, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

def my_divide(a, b):
try:
result = a / b
except ZeroDivisionError as error:
return “No se puede dividir por 0”

return result

response = my_divide(10, 2)
print(response) # 5.0

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

creo que lo cree distinto a varios, pero funciona bien:

def my_divide(a, b):
   # Escribe tu solución 👇
   try:
      result = a / b
      return result
   except ZeroDivisionError as error:
      return'No se puede dividir por 0'
   
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

Esta es la forma en la que yo lo resolví 😁

def my_divide(a, b):
   # Escribe tu solución 👇
   try :
      a / b
      result = a / b
      return result
   except ZeroDivisionError as error :
      return'No se puede dividir por 0'
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

def my_divide(a, b):
   # Escribe tu solución 👇
   try:
      result = a / b
      
   except ZeroDivisionError as error:
      return "No se puede dividir por 0"
    
   return result

Le agregué un while loop para volver a intentar la division en caso de error, saludos!

def run():
    i=1
    while i==1:
        division=lambda x,y: x/y
        x= float(input('Dividendo: '))
        y= float(input('Divisor: '))

        try:
            division(x,y)
            print(division(x,y))
            break
        except ZeroDivisionError:
            print('Imposible dividir entre cero')
            c=input(print('Desea intentarlo nuevamente y/n: '))
            if c=='n':
                break


if __name__=='__main__':
    run()

Codigo:

def my_divide(a, b):
   # Escribe tu solución 👇
   try:
      result = a/b
   except ZeroDivisionError:
      result = 'No se puede dividir por 0'
   return result
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0
 

def my_divide(a, b):
   try:
      return a / b
   except ZeroDivisionError as error:
      return "No se puede dividir por 0"
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

My code

def my_divide(a, b):
   try:
      result = a / b
      return result
   except ZeroDivisionError:
      return("No se puede dividir por 0")

Chicos, les comparto!

def my_divide(a, b):
   # Escribe tu solución 👇
   try:
      result = a / b
      return result
   
   except ZeroDivisionError:
      return ('No se puede dividir por 0')
         
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

Pueden obviar la creación de una variable retornando un valor en caso exitoso/fallido. Asi no usan espacio en memoria y se vuelve más legible su código.

def my_divide(a, b):
   # Escribe tu solución 👇
   try:
      return a / b
   except ZeroDivisionError:
      return 'No se puede dividir por 0'
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

Como lo solucione 😄

def my_divide(a, b):
   # Escribe tu solución 👇
   try:
      result = a / b
      return result
   except ZeroDivisionError as error:
      return('No se puede dividir por 0')  
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

def my_divide(a, b):

Escribe tu solución 👇

try:
result = a / b
return result
except ZeroDivisionError as error:
return ‘No se puede dividir por 0’

response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

Esta es mi solucion.

def my_divide(a, b):
   # Escribe tu solución 👇
   try:
      return a / b
   except ZeroDivisionError as error:
      return 'No se puede dividir por 0'
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

Esta es mi respuesta 😄

def my_divide(a, b):
   
   try:
      result = a / b
   except ZeroDivisionError as error:
      result = 'No se puede dividir por 0'
   
   return result
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

def my_divide(a, b):
   # Escribe tu solución 👇
   try:
      result = a / b
      return result
   except ZeroDivisionError as err:
      return "No se puede dividir por 0"
   
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

def my_divide(a, b):

Escribe tu solución 👇

try:

  resultado = a / b

except ZeroDivisionError as error:
resultado = 'No se puede dividir por 0’
return resultado

response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

les comparto la solución 😄

def my_divide(a, b):
   # Escribe tu solución 👇
   try:
      result = a / b
      return result
   except ZeroDivisionError as error: 
      return "No se puede dividir por 0"
    
response = my_divide(10, 2)
print(response) # 5

response = my_divide(10, 0)
print(response) # No se puede dividir por 0

def my_divide(a, b):
   try:
      result = a / b
   except ZeroDivisionError:
      result = "No se puede dividir por 0"
   return result