Introducci贸n

1

El Zen de Python

Conjuntos

2

Sets

3

Modificando conjuntos

4

Operaciones con conjuntos

5

Playgrounds: Elimina elementos duplicados usando conjuntos

Comprehensions

6

List Comprehension

7

Dictionary Comprehension

8

Dictionary Comprehension: condition

9

Playgrounds: Crea una lista usando List Comprehension

10

Lists vs. Tuples vs. Sets

Funciones

11

Funciones

12

Funciones: return

13

Par谩metros por defecto y m煤ltiples returns

14

El scope

15

Refactor game

16

Playgrounds: Tienda de Tecnolog铆a

17

Funciones an贸nimas: lambda

18

Higher order function: una funci贸n dentro de otra funci贸n

19

Map

20

Map con diccionarios

21

Reto: map con inmutabilidad

22

Playgrounds: Multiplica todos los elementos por dos

23

Filter

24

Playgrounds: Retorna solo palabras de 4 letras y m谩s

25

Reduce

M贸dulos

26

M贸dulos

27

Mis propios m贸dulos

28

M贸dulos como scripts: __name__ y __main__

29

Paquetes

30

Playgrounds: Calcular la suma de todas las compras

Manipulaci贸n de archivos y errores

31

Iterables

32

Errores en Python

33

Manejo de excepciones

34

Playgrounds: Captura la excepci贸n: ZeroDivisionError

35

Leer un archivo de texto

36

Escribir en un archivo

37

Leer un CSV

38

Playgrounds: Lee un CSV para calcular el total de gastos

Gr谩ficas en Python

39

Creando una gr谩fica

40

Reto: graficando la poblaci贸n de un pa铆s

41

Reto: graficando la poblaci贸n mundial

Pr贸ximos pasos

42

隆Conoce otros proyectos de este curso!

43

Reconoce tu proceso y certif铆cate

44

Toma el Curso de PIP y Entornos Virtuales con Python

No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Playgrounds: Captura la excepci贸n: ZeroDivisionError

34/44

Aportes 98

Preguntas 3

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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 鈥渁鈥 y otro a la letra 鈥渂鈥, 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
```js def my_divide(a, b): try: result = a / b except ZeroDivisionError: return 'No se puede dividir por 0' return result ```A mi parecer no hace falta guardar el error con el comando `as` ni usar la var *result* para guardar un string. *(solo en este caso)*
![](https://static.platzi.com/media/user_upload/msedge_sLUobVLrXS-82d85ceb-0f01-456b-ad91-f928f98b20ca.jpg)
```python 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 ```

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

```js 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 ```

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

```python 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 ```
````python sdef 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 ````

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

```python 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 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
  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 鈥渃onfetti鈥.
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 鈥楴o 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=(鈥楴o 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 鈥淣o 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 鈥楴o 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
undefined