Funciones y abstracción

Aquí está mi código, recibo sugerencias de cómo mejorarlo

def enumeracion_exhaustiva (objetivo):
    respuesta = 0

    while respuesta**2 < objetivo:
        respuesta += 1

    if respuesta**2 == objetivo:
        print(f'La raiz de {objetivo} es {respuesta}')
    else:
        print(f'{objetivo} no tiene raiz cuadrada exacta')
    

def aproximacion (objetivo, epsilon):
    paso = epsilon**2
    respuesta = 0.0
    iteraciones = 0

    while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
        respuesta += paso
        iteraciones += 1

    if abs(respuesta**2 - objetivo) >= epsilon:
        print(f'No se encontro raiz cuadrada {objetivo}')
    else:
        print(f'La raiz cuadrada de {objetivo} es {respuesta}')

def busqueda_binaria (objetivo, epsilon):
    bajo = 0.0
    alto = max(1.0, objetivo)
    respuesta = (alto + bajo) / 2

    # absoluto = abs(respuesta**2 - objetivo)
    # print(f'absoluto: {absoluto}')

    while abs(respuesta**2 - objetivo) >= epsilon:
        print(f'bajo={bajo}, alto={alto}, respuesta={respuesta}')
        if respuesta**2 < objetivo:
            bajo = respuesta
        else:
            alto = respuesta
        respuesta = (alto + bajo) / 2   

        print(f'La raiz cuadrada de {objetivo} es {respuesta}')  

opcion = int(input(f'Elija el algoritmo de ordenamiento para buscar la raiz cuadrada de su numero \n 1. Enumeracion Exhaustiva \n 2. Aproximacion \n 3. Busqueda Binaria \n'))

if opcion == 1:
    print('1. Enumeracion Exhaustiva')
    numero = int(input('* Digite un numero: '))
    enumeracion_exhaustiva(numero)
elif opcion == 2:
    print('2. Aproximacion')
    numero = int(input('* Digite un numero: '))
    parametro_epsilon = float(input('* Digite un epsilon: '))
    aproximacion(numero,parametro_epsilon)
elif opcion == 3:
    print('3. Busqueda Binaria')
    numero = int(input('* Digite un numero: '))
    parametro_epsilon = float(input('* Digite un epsilon: '))
    busqueda_binaria(numero,parametro_epsilon)
else:
    print('Opcion no valida')

        ```

Esta es mi solucion:

def opciones():
  print(f'Opciones para hallar raiz cuadrada \n (1) Enumeracion exhaustiva \n (2) Aproximacion de soluciones \n (3) Busqueda binaria') 
  opcion = int(input('Elija una opcion: '))
  numero = int(input('Elija un numero: '))
  if opcion==1:
    Enumeracion(numero)
  elif opcion==2:
    Aproximacion(numero)
  elif opcion==3:
    BusquedaBinaria(numero)
  else:
    print('Elija 1, 2 o 3')

def Enumeracion(objetivo):
  respuesta = 0

  while respuesta**2 < objetivo:
      print(respuesta)
      respuesta += 1

  if respuesta**2 == objetivo:
      print(f'La raiz cuadrada de {objetivo} es {respuesta}')
  else:
      print(f'{objetivo} no tiene una raiz cuadrada exacta')

def Aproximacion(objetivo):
  epsilon = 0.001
  paso = epsilon**2 
  respuesta = 0.0

  while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
      #print(abs(respuesta**2 - objetivo), respuesta)
      respuesta += paso

  if abs(respuesta**2 - objetivo) >= epsilon:
      print(f'No se encontro la raiz cuadrada {objetivo}')
  else:
      print(f'La raiz cudrada de {objetivo} es {respuesta}')


def  BusquedaBinaria(objetivo):
  epsilon = 0.001
  bajo = 0.0
  alto = max(1.0, objetivo)
  respuesta = (alto + bajo) / 2

  while abs(respuesta**2 - objetivo) >= epsilon:
      print(f'bajo={bajo}, alto={alto}, respuesta={respuesta}')
      if respuesta**2 < objetivo:
          bajo = respuesta
      else:
          alto = respuesta

      respuesta = (alto + bajo) / 2
  print(f'La raiz cuadrada de {objetivo} es {respuesta}')

opciones()

El resultado se ve así:

Opciones para hallar raiz cuadrada 
 (1) Enumeracion exhaustiva 
 (2) Aproximacion de soluciones 
 (3) Busqueda binaria
Elija una opcion: 2
Elija un numero: 4
La raiz cudrada de 4 es 1.999749999925672

En programación, abstracción es realmente solo una forma de simplificar una idea o acción complicada. Veamos cuál es fácilmente la abstracción más común que todo programador sabe que son usos.
¿Qué es lo primero que aprendes como programador principiante? El Hello World… programa clásico donde imprime un texto en la consola. Pero, ¿alguna vez te has detenido y te has preguntado cómo funciona esto realmente bajo el capó?
El estándar Hello World en la mayoría de los idiomas generalmente se ve así:
print (“Hola, mundo”)
La mayoría de los programadores no saben cómo funciona esta única línea de código. Y tampoco tienen que hacerlo. Todo lo que necesita saber es qué entradas dar a la función print() para que funcione.

objetivo = int(input('Escoge un numero: '))
print('Porque metodo te gustaria encontrar la raiz cuadara?:')
print('1. Enumeracion exhaustiva.')
print('2. Aproximacion')
print('3. Busqueda Binaria')
opcion = int(input('Escribe el numero de la opcion que deseas: '))

def enumeracion_exhaustiva(objetivo):
  respuesta = 0

  while respuesta**2 < objetivo:
    respuesta += 1

  if respuesta**2 == objetivo:
    return print(f'La raiz cuadrada de {objetivo} es {respuesta}')
  else:
    return print(f'{objetivo} no tiene una raiz cuadrada exacta')

def aproximacion(objetivo):
  epsilon = 0.01
  paso = epsilon**2
  respuesta = 0.0

  while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
    respuesta += paso

  if abs(respuesta**2 - objetivo) >= epsilon:
    return print(f'No se encontro la raiz cuadrada de {objetivo}')
  else:
    return print(f'La raiz cuadrada de {objetivo} es {respuesta}')

def busqueda_binaria(objetivo):
  epsilon = 0.001
  bajo = 0.0
  alto = max(1.0, objetivo)
  respuesta = (alto + bajo) / 2

  while abs(respuesta**2 - objetivo) >= epsilon:
    if respuesta**2 < objetivo:
      bajo = respuesta
    else:
      alto = respuesta
    respuesta = (alto + bajo) / 2

  return print(f'La raiz cuadrada de {objetivo} es {respuesta}')

if opcion == 1:
  enumeracion_exhaustiva(objetivo)
elif opcion == 2:
  aproximacion(objetivo)
elif opcion == 3:
  busqueda_binaria(objetivo)
else:
  print('Opcion no valida.')```

Parte de la teoria:

.
Habilidades importantes de los ingenieros del Software
.

1.Abstracción: Significa que no necesitas entender la forma como opera algo internamente para poderlo utilizar.
2.Decomposición: Permite dividir el código en componentes que colaboran con un fin común (se puede pensar como mini programas dentro de un programa mayor).
.

Sintaxis de una función en python:

def <nombre>(<parámetros>):
    <cuerpo>
    return <expresion>

#Ejemplo:
def suma (a, b):
    total = a + b
    return total

suma(2, 3)

.

Argumentos de tipo Keyword y valores por defecto

def nombre_completo(nombre, apellido, inverso=False):
    if inverso:
        return f" {apellido} {nombre}"
    else:
        return f" {nombre} {apellido}"

nombre_completo("Harrinson", "Quintero")
nombre_completo("Harrinson", "Quintero", inverso=True)
nombre_completo(apellido="Harrinson", nombre="Quintero")

Importante destacar que los argumentos de una función que tengas valores por default van al final de los demás argumentos, de otra forma se produce un error.
SyntaxError: non-default argument follows default argument

def nombre_completo(inverso=False, nombre, apellido ):
    if inverso:
        return f'{apellido} {nombre}'
    else:
        return f'{nombre} {apellido}'

En mi caso particular, utilicé dos archivos, el primero reto.py, en el cual definí la lectura y el llamado de las variables, así como la importación de las funciones:

from funciones import (bbinaria, aproximacion)
import time
start_time = time.perf_counter()
objetivo  = int(input('Escoge un numero: '))
epsilon = 0.1
bajo = 0.0
alto = max(1.0, objetivo)
respuesta = (alto + bajo) / 2
seleccion = int(input('Ingresa una opción \n 1 para Busqueda binaria \n 2 para Aproximacion \n'))
paso = epsilon**2

if seleccion == 1:
    bbinaria(objetivo, respuesta, bajo, alto, epsilon)
else:
    aproximacion(objetivo, paso, bajo, alto, epsilon)

print (time.perf_counter() - start_time, "seconds")   

Adicionalmente, funciones.py (funciones en el archivo reto), donde definí los dos algoritmos usados:

#Algoritmo de Busqueda binaria
def bbinaria (objetivo, respuesta, bajo, alto, epsilon):
    while abs(respuesta**2 - objetivo) >= epsilon:
        print(f'bajo = {bajo}, alto={alto}, respuesta={respuesta}')
        if respuesta**2 < objetivo:
            bajo = respuesta
        else:
            alto = respuesta
        respuesta = (alto + bajo) / 2 
    print(f'la raiz cuadrada de {objetivo} es {respuesta}')

#Algoritmo de aproximación de soluciones
def aproximacion (objetivo, paso, bajo, alto, epsilon):
    respuesta = 0.0
    while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
        print(abs(respuesta**2 - objetivo), respuesta)
        respuesta += paso     
    if abs(respuesta **2 - objetivo) >= epsilon:
        print(f'No se encontro la raiz cuadrada de {objetivo}')
    else:
        print(f'La raiz cuadrada de {objetivo} es {respuesta}')

Aquí la solución con cada método para calcular la raíz cuadrada encapsulado y decompuesta en tres funciones que se mandan a llamar con una variable llamada method. 😄

def enumeracion(objetivo):
    respuesta = 0


    while respuesta**2 < objetivo: #Enumera todas las soluciones posibles
        print(respuesta)
        respuesta += 1


    if respuesta**2 == objetivo: #Evalúa las soluciones de acuerdo a las restricciones del problema
        return respuesta
    else:
        print(f'{objetivo} no tiene raíz cuadrada exacta') 


def aproximacion(objetivo):
    epsilon = 0.01
    paso = epsilon**2
    respuesta = 0.0


    while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
        print(abs(respuesta**2 - objetivo), respuesta)
        respuesta += paso


    if abs(respuesta**2 - objetivo) >= epsilon:
        print(f'No se encontro la raíz cuadrada de {objetivo}')
    else:
        return respuesta

    
def busq_binaria(objetivo):
    epsilon = 0.001
    bajo = 0.0
    alto = max(1.0, objetivo)
    respuesta = (alto + bajo) / 2

    while abs(respuesta**2 - objetivo) >= epsilon: 
        print(f'bajo = {bajo}, alto = {alto}, respuesta = {respuesta}')
        if respuesta**2 < objetivo:
            bajo = respuesta
        else:
            alto = respuesta

        respuesta = (alto + bajo) / 2
    
    return respuesta


method = input('''Escoge el método para calcular la raíz cuadrada
            [E]numeración exhaustiva 
            [A]proximación de soluciones
            [B]úsqueda binaria
            ''')


objetivo = int(input('Escoge un número entero: '))


if method == 'e' or method == 'E':
    result = enumeracion(objetivo)
    # print(f'La raíz cuadrada de {objetivo} es {result}')

elif method == 'a' or method == 'A':
    result = aproximacion(objetivo)
    # print(f'La raíz cuadrada de {objetivo} es {result}')

elif method == 'b' or method == 'B':
    result = busq_binaria(objetivo)
    # print(f'La raíz cuadrada de {objetivo} es {result}')

else:
    print('No escogiste un método')    

if result != None:
    print(f'La raíz cuadrada de {objetivo} es {result}')

también en python es común iniciar con una función principal que indique dónde inicia la ejecución del programa.

def main():
	#tu código comienza aquí


if __name__ == '__main__':
	main()

Abstracción: no necesitas saber cómo algo funciona internamente para poderlo utilizar.

Descomposición:
Dividir el código en componentes que colaboran con un fín en común.

Se que mi código no es el mejor pero es un trabajo honesto y corre bien jaja

❤

from datetime import datetime

def aproximacion():
    objetivo = int(input('Escoge un numero: '))
    epsilon = 0.01
    paso = epsilon ** 2
    respuesta = 0.0
    tiempoInicio = datetime.now()
    while abs(respuesta ** 2 - objetivo) >= epsilon and respuesta <= objetivo:
        respuesta += paso

    if abs(respuesta ** 2 - objetivo) >= epsilon:
        print(f'No se encontro la raiz cuadrada de {objetivo}')
    else:
        print(f'La raiz cuadrada de {objetivo} es {respuesta}')
        tiempoFinal = datetime.now()

    print(f'Comenzo a las {tiempoInicio} y termino a las {tiempoFinal}')
    Lista()

def enumeracionExhaustiva():
    objetivo = int(input('¿Escoge un entero: '))
    respuesta = 0

    while respuesta**2 < objetivo:
        respuesta += 1

    if respuesta**2 == objetivo:
        print(f'La raiz cuadrada de {objetivo} es {respuesta}')
    else:
        print(f'{objetivo} no tiene una raiz cuadrada exacta')
    
    Lista()

def busquedaBinaria():
    objetivo = int(input('Escoge un numero: '))
    # Precision
    epsilon = 0.001
    # limite inferior
    bajo = 0.0
    # limite superior
    alto = max(1.0, objetivo)

    respuesta = (alto + bajo) / 2

    # Derecha => alto
    # izquierda => bajo

    # MIsion disminuir a la mitad la busqueda

    while abs(respuesta ** 2 - objetivo) >= epsilon:
        print(f'bajo={bajo}, alto={alto}, respuesta={respuesta}')
        if respuesta ** 2 < objetivo:
            bajo = respuesta
        else:
            alto = respuesta
        # Divivir entre 2 el espacio de busqueda por ende solo la mitad
        respuesta  = (alto + bajo) / 2

    print(f'La raiz cuadrada de {objetivo} es {respuesta}')
    Lista()

def eleccion(opcion):
    if opcion == 1:
        aproximacion()
    elif opcion == 2:
        enumeracionExhaustiva()
    elif opcion == 3:
        busquedaBinaria()
    elif opcion == 4:
        print('Muchas gracias por usar nuestros sistemas!!')
    else:
        print('Solo puedes seleccionar los algoritmos de la lista, te devolveremos al inicio')
        Lista()

def Lista():
    print(""" 
            Cual algoritmo deseas usar para obtener la raiz cuadrada ?

            ====================Lista==================
            1- Aproximacion
            2- Enumeracion Exhaustiva
            3- Busqueda Binaria
            4- Salir
    """)
    opcion = int(input('Yo escogere: '))
    eleccion(opcion)

if __name__ == '__main__':
    Lista()```

Reto completado:

def enumeracion():
    objetivo = int(input("Escoge un entero: "))
    respuesta = 0
    while respuesta**2 < objetivo :
        print(respuesta)
        respuesta +=1
    if respuesta**2 == objetivo:
        print(f'La raiz cuadrada de {objetivo} es {respuesta}')
    else:
        print(f'{objetivo} no tiene raiz cuadrada exacta')
def aproximacion():
    objetivo = int(input('Escoge un numero: '))
    epsilon = 0.01
    paso = epsilon**2
    respuesta = 0.0
    while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
        print(abs(respuesta**2 - objetivo), respuesta)
        respuesta += paso
    if abs(respuesta**2 - objetivo) >= epsilon:
        print(f'No se encontro la raiz cuadrada {objetivo}')
    else:
        print(f'La raiz cudrada de {objetivo} es {respuesta}')
def busqueda_binaria():
    objetivo = int(input('Escoge un numero: '))
    epsilon = 0.001
    bajo = 0.0
    alto = max(1.0, objetivo)
    respuesta = (alto + bajo) / 2
    while abs(respuesta**2 - objetivo) >= epsilon:
        print(f'bajo={bajo}, alto={alto}, respuesta={respuesta}')
        if respuesta**2 < objetivo:
            bajo = respuesta
        else:
            alto = respuesta
            respuesta = (alto + bajo) / 2
    print(f'La raiz cuadrada de {objetivo} es {respuesta}')
menu = """
🙌Bienvenido Con este programa podras hacer busqueda de raices cuadradas con los siguientes 3 metodos🐱‍👓:

1 - Enumeracion
2 - Aproximacion
3 - Busqueda binaria

Eligue una opcion: """
opcion = int(input(menu))
if opcion == 1:
    print("Haz eleguido el metodo Enumeracion exhaustiva")
    enumeracion()
elif opcion == 2:
    print("Haz eleguido el numero aproximacion")
    aproximacion()
elif opcion == 3:
    print("Haz eleguido el metodo busqueda binaria")
    busqueda_binaria()
else:
    print("Elige una opcion correcta porfavor!")

Aquí está mi solución, tiene la estructura del curso de aprender Python creando un CRUD (Recomendado)

#Aproximación
def aproximacion (respuesta, objetivo, epsilon, paso):
    while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
        respuesta += paso

    if abs(respuesta**2 - objetivo) >= epsilon:
        print(f'Square root of {objetivo} not found')
    else:
        print(f'Square root of {objetivo} is {respuesta}')


#Búsqueda Binaria
def busqueda_bin (respuesta_bin, objetivo, epsilon, low, high):
    while abs (respuesta_bin**2 - objetivo) >= epsilon:
        #print(f'bajo={low}, alto={high}, respuesta={respuesta_bin}')
        if respuesta_bin**2 < objetivo:
            low = respuesta_bin
        else: 
            high = respuesta_bin

        respuesta_bin = (high + low) / 2
    

    print (f'Square root of {objetivo} is {respuesta_bin}')


#Enumeración Exhaustiva
def enumeracion (objetivo, respuesta_int):
    while respuesta_int**2 < objetivo:
        respuesta_int += 1
    if respuesta_int**2 == objetivo:
        print(f"Square root of {objetivo} is {respuesta_int}")

    else:
        print(f"{objetivo} has no exact square root")

#Bienvenida
def welcome ():
    print(" ")
    print ("WELCOME TO THE SQUARE ROOT CALCULATOR!")
    print("_"*50)
    print("Wich algoridim are you going to choose today?")
    print(" ")
    print("[A]proximation")
    print("[B]inary Search")
    print("[E]xhaustive ennumeration")
    print("_"*50)
    print(" ")


if __name__ == "__main__":
    #Da la bienvenida
    welcome ()

    #Comando para escoger el algoritmo
    command = input("Wich algorithm do you want to choose?: ")
    command = command.upper()    

    if command == "A":
        objetivo = int(input('Choose a number: '))
        paso = epsilon**2
        respuesta = 0.0
        epsilon = 0.01
        aproximacion = aproximacion (respuesta, objetivo,epsilon, paso)
        
    elif command == "B":
        objetivo = float(input('Choose a number: '))
        low = 0.0
        high = max(1.0, objetivo)
        epsilon = 0.01
        respuesta_bin = (high + low) / 2
        busqueda_bin(respuesta_bin, objetivo, epsilon, low, high)
        
    elif command == "E":
        objetivo = int(input('Choose a number: '))
        respuesta_int = 0
        enumeracion(objetivo, respuesta_int)

    else:
        print ("Invalid Command")```

def aprox_de_sol(objetivo):
   
    epsilon = 0.01
    paso = epsilon**2
    respuesta= 0.0

    while abs(respuesta**2 - objetivo) >= epsilon and objetivo >= respuesta:
        print(abs(respuesta**2 - objetivo), respuesta)
        respuesta += paso

    if abs(respuesta**2 - objetivo) >= epsilon:
        print(f'No se encontró la raíz cuadrada del objetivo')
    else:
        print(f'La raiz cuadrada de {objetivo} es {respuesta}')

def enum_exhaustiva(objetivo):
    answer = 0
    while answer**2 < objetivo:
        print(answer)
        answer += 1
    if answer**2 == objetivo:
        print(f'la raíz cuadrada del {objetivo} es {answer}')
    else:
        print(f'{objetivo} no tiene una raiz cuadrada exacta')

def busq_bin(objetivo):

    epsilon = 0.001
    bajo= 0.0
    alto = max(1.0, objetivo)
    respuesta = (alto + bajo) / 2

    while abs(respuesta**2 - objetivo) >= epsilon:
        print(f'bajo={bajo}, alto={alto}, respuesta={respuesta}')
        if respuesta**2 < objetivo:
            bajo = respuesta
        else:
            alto = respuesta
    
        respuesta = (alto + bajo) / 2
    print(f'La raiz cuadrada del {objetivo} es {respuesta}')

option= int(input("Escoge el método para hallar la raíz cuadrada:\n 1.Enumeración exhaustiva. \n 2.Aproximación de soluciones. \n 3.Búsqueda Binaria \n"))
objetivo = int(input('Escoge un número: '))

if option == 1:
    enum_exhaustiva(objetivo)
elif option == 2:
    aprox_de_sol(objetivo)
elif option == 3:
    busq_bin(objetivo)
else:
    print("No es una opción válida")```

Mi aporte:

def BusquedaBinaria():
    objetivo = int(input('Escoge un numero: '))
    epsilon = 0.001
    bajo = 0.0
    alto = max(1.0, objetivo)
    respuesta = (alto + bajo) / 2

    while abs(respuesta**2 - objetivo) >= epsilon:
        print(f'bajo={bajo}, alto={alto}, respuesta{respuesta}')
        if respuesta**2 < objetivo:
            bajo = respuesta
        else:
            alto = respuesta

        respuesta = (alto + bajo) / 2

    print(f'La raiz cuadrada de {objetivo} es {respuesta}')


def Aproximacion():
    objetivo = int(input('Escoger un número: '))
    epsilon = 0.01
    paso = epsilon**2
    respuesta = 0.0

    while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
        print(abs(respuesta**2-objetivo), respuesta)

        respuesta += paso

    if abs(respuesta**2 - objetivo) >= epsilon:
        print(f'No se encontró raíz cuadrada de {objetivo}')
    else:
        print(f'La raíz cuadrada aproximada de {objetivo} es {respuesta}')



def EnumExahustiva():
    objetivo = int(input('Ecribe un numero entero: '))
    respuesta = 0

    while respuesta**2 < objetivo:
        respuesta += 1

    if respuesta**2 == objetivo:
        print(f'La raiz cuadrada de {objetivo} es {respuesta}')
    else:
        print(f'{objetivo} no tiene raiz cuadrada exacta')

def main():
    print('Escoge como buscar de la raiz cuadrada de un numero: ')
    print('''
        1. Por aproximacion
        2. Por Enumeracion exahustiva
        3. Por Busqueda biinaria
	4. Salir
            ''')
    command = int(input('Que metodo vas a usar: '))
    while True:
        if command == 1:
            Aproximacion()
            break
        elif command == 2:
            EnumExahustiva()
            break
        elif command == 3:
            BusquedaBinaria()
            break
        elif command == 4:
            False
        else:
            print('Opcion Invalida')
            break

if __name__ == "__main__":
    main()```

hola 😃 aqui les dejo mi codigo

def enumeracion_exhaustiva(objetivo):
    respuesta = 0
    while respuesta**2 < objetivo:
        respuesta += 1
    if respuesta**2 == objetivo:
        print(f'la raiz cuadrada de {objetivo} es {respuesta} ')
    else:
        print(f'{objetivo} no tiene una raiz cuadrada exacta')

def aproximacion(objetivo):
    epsilon = 0.01
    paso = epsilon**2 
    respuesta = 0.0
    while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
        respuesta += paso

    if abs(respuesta**2 - objetivo) >= epsilon:
        print(f'no se encontro la raiz cuadrada {objetivo}')
    else:
        print(f'la raiz cuadrada de {objetivo} es {respuesta}')

def busqueda_binaria(objetivo):
    epsilon = 0.1
    bajo = 0.0
    alto = max(1.0, objetivo)
    respuesta = (alto + bajo) / 2

    while abs(respuesta**2 - objetivo) >= epsilon:
        print(f'bajo = {bajo}, alto = {alto}, respuesta = {respuesta}')
        if respuesta**2 < objetivo:
            bajo = respuesta
        else:
            alto = respuesta

        respuesta = (alto + bajo) / 2

    print(f'la raiz cuadrada de {objetivo} es {respuesta}')

print('***bienvenido al programa de raices cuadradas***')
objetivo = (int(input('escribe el numero del que deseas saber su raiz cuadrada')))
print("""metodos que se pueden usar para sacar la raiz cuadrada:
      1.- enumeracion exhaustiva
      2.- aproximacion de soluciones
      3.- busqueda binaria""")
opcion = int(input('escoge una opcion: '))

if opcion == 1:
    print('se elijio enumeracion')
    enumeracion_exhaustiva(objetivo)
elif opcion == 2:
    print('se elijio aproximacion')
    aproximacion(objetivo)
elif opcion == 3: 
    print ('se elijio busqueda binaria')
    busqueda_binaria(objetivo)
else: 
    print('su opcion no esta en el menu, por favor elige un numero de 1 a 3')```

def seleccion_programa(info1):
    if info1 == 1:
        programa1()

    elif info1 == 2:
        programa2()

    elif info1 == 3:
        programa3()

    else:
            print('Seleaccione un numero del 1 al 3')

        

def programa1():
        print('Escogiste ENUMERACION EXAUSTIVA.')
        objetivo = int(input('Escoge un entero: '))
        respuesta = 0


        while respuesta**2 < objetivo:
            print(respuesta)
            respuesta += 1

        if respuesta**2 == objetivo:
            print(f'La raiz cuadrada de {objetivo} es {respuesta}')
        else:
            print(f'El {objetivo} no tiene una raiz cuadrada exacta')

def programa2():
        print('Elejiste Aproximacion DE SOLUCIONES!')
        
        objetivo = int(input('Escoge un numero'))
        epsilon = 0.01
        paso = epsilon**2
        respuesta = 0.0


        while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
            respuesta += paso

        if abs(respuesta**2 - objetivo) >= epsilon:
            print(f'No se encontro la raiz cuadrada de {objetivo}')

        else:
            print(f'La raiz cuadrada de {objetivo} es {respuesta}')

def programa3():
        print('Elejiste BUSQUEDA BINARIA')

        objetivo = int(input('Escoge un entero: '))

        epsilon = 0.01
        bajo = 0.0
        alto = max(1.0, objetivo)
        respuesta = (alto + bajo) / 2

        while abs(respuesta**2 - objetivo) >= epsilon:
            print(f'bajo={bajo}, alto={alto}, respuesta={respuesta}')
            if respuesta**2 < objetivo:
                bajo = respuesta
            else:
                alto = respuesta

            respuesta = (alto + bajo) / 2

        print(f'la raiz cuadrada de {objetivo} es {respuesta}')


def saludo():
    print('Hola bienvenido a tu programa para calcular la raiz cuadrada.')
    print(' ' * 50)
    print('¿Que programa desea utilizar?')
    print('\t|1 para utilizar "Enumeracion Exhaustiva"|')
    print('\t|2 para utilizar "Aproximacion De Soluciones"|')
    print('\t|3 para utilizar "Busqueda Binaria"|')

    info1 = int(input())

    return info1
    


if __name__ == "__main__":
    seleccion_programa(saludo())

]Reto realizado:

def busqueda_binaria(numero):
    epsilon = 0.000001
    bajo = 0.0
    alto = max(1.0, numero)
    respuesta = (alto + bajo) /2
    iteraciones = 0

    while abs(respuesta**2 - numero) >= epsilon:
        iteraciones += 1
        if respuesta**2 < numero:
            bajo = respuesta
        else:
            alto = respuesta
        respuesta = (alto + bajo) / 2
    print(f'la raiz cuadrada de {numero} es {respuesta} y se realizo en {iteraciones} iteracionesaa')


def aproximacion(numero):
    epsilon = 0.001
    paso = epsilon**2
    respuesta = 0.0
    iteraciones = 0

    while abs(respuesta**2 - numero) >= epsilon and respuesta <= numero:
        respuesta += paso
        iteraciones += 0
    if abs(respuesta**2 - numero) >= epsilon:
        print(f"No se encontro la raiz cuadrada de {numero}")
    else:
        print(f"La raiz cuadrada de {numero} es {respuesta} y se realizo en {iteraciones} iteraciones")
    

def enumeracion_exhaustiva(numero):
    respuesta = 0
    iteraciones = 0

    while respuesta**2 < numero:
        respuesta += 1
        iteraciones += 1
    if respuesta**2 == numero:
        print(f'La raiz de {numero} es {respuesta} y se realizo en {iteraciones} iteraciones')
    else:
        print(f'{numero} no tiene raiz cuadrada exacta')


def run():
    print(f'Bienvenido al programa de busqueda de la raiz cuadrada de un numero')
    numero = int(input('De que numero quieres saber la raiz cuadrada?  '))
    modo = int(input('Elige el modo por el cual quieras hallar la solución: \n 1 = Busqueda binaria \n 2 = aproximacion \n 3 = enumeracion exhaustiva \n'))
    if modo == 1:
        busqueda_binaria(numero)
    elif modo == 2:
        aproximacion(numero)
    elif modo == 3:
        enumeracion_exhaustiva(numero)
    else:
        ('No joda ponga un valor permitido')



if __name__ == '__main__':
    run()

menuOpciones = {
    1: 'Enumeracón exhaustiva',
    2: 'Aproximación de soluciones',
    3: 'Busqueda binaria',
    4: 'Salir'
}

def busquedaBinaria(objetivo, epsilon):
    print('Ejecutado busqueda binaria')    
    bajo = 0.0
    alto = max(1.0, objetivo)
    respuesta = (alto + bajo) / 2

    while abs(respuesta**2 - objetivo) >= epsilon:
        print(f'bajo={bajo}, alto={alto}, respuesta={respuesta}')
        if respuesta**2 < objetivo:
            bajo = respuesta
        else:
            alto = respuesta

        respuesta = (alto + bajo) / 2

    return respuesta

def aproximacionDeSoluciones(objetivo, epsilon):
    print('Ejecutando aproximación de soluciones')
    paso = epsilon**2 
    respuesta = 0.0

    while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
        print(abs(respuesta**2 - objetivo), respuesta)
        respuesta += paso

    if abs(respuesta**2 - objetivo) >= epsilon:
        print(f'No se encontro la raiz cuadrada {objetivo}')
        #lanzar una excepción controlada
    else:
        print(f'La raiz cudrada de {objetivo} es {respuesta}')

    return respuesta

def enumeracionExhaustiva(objetivo):
    print('Ejecutando enumeración exhaustiva')
    respuesta = 0

    while respuesta**2 < objetivo:
        print(respuesta)
        respuesta += 1

    if respuesta**2 == objetivo:
        print(f'La raiz cuadrada de {objetivo} es {respuesta}')
    else:        
        print(f'{objetivo} no tiene una raiz cuadrada exacta')
        #lanzar una excepción controlada

    return respuesta

def imprimirMenu():
    for key in menuOpciones.keys():
        print (key, '--', menuOpciones[key] )

while(True):
    imprimirMenu()
    opcion = int(input('Elige una opción: '))        
    #Validar opción seleccionada
    if opcion == 1:
        objetivo = int(input('Escoge un número: '))
        respuesta = enumeracionExhaustiva(objetivo)  
    elif opcion == 2:
        objetivo = int(input('Escoge un número: '))
        epsilon = 0.001
        respuesta = aproximacionDeSoluciones(objetivo,epsilon)
    elif opcion == 3:
        objetivo = int(input('Escoge un número: '))
        epsilon = 0.001
        respuesta = busquedaBinaria(objetivo,epsilon)
        print(f'La raiz cuadrada de {objetivo} es {respuesta}')     
    elif opcion == 4:
        print('Adiós')
        break
    else:
        print('No existe esa opción')

Hola, este es mi menú, me gustaría que me corrijan si estoy cumpliendo con alguna mala práctica, por que tengo dudas, ya que al crear una sola función, no sé si al cumplir con las buenas prácticas me vea en la necesidad de retornar un valor y no hacer el print devolviendo el resultado dentro de la función, toda crítica constructiva será bien recibida! 😄

def busqueda(opcion_elegida, objetivo_ingresado, epsilon_ingresado):
    if opcion_elegida == 1:
        respuesta = 0
        while respuesta ** 2 < objetivo_ingresado:
            print(respuesta)
            respuesta += 1

        if respuesta ** 2 == objetivo_ingresado:
            print(f'La raiz cuadrada de {objetivo_ingresado} es {respuesta}')
        else:
            print(f'El {objetivo_ingresado} no tiene una raiz cuadrada exacta')

    elif opcion_elegida == 2:
        paso = epsilon_ingresado ** 2
        respuesta = 0.0

        while abs(respuesta ** 2 - objetivo_ingresado) >= epsilon_ingresado and respuesta <= objetivo_ingresado:
            print(abs(respuesta ** 2 - objetivo_ingresado), respuesta)
            respuesta += paso

        if abs(respuesta ** 2 - objetivo_ingresado) >= epsilon_ingresado:
            print(f'No se encontró la raiz cuadrada del {objetivo_ingresado}')
        else:
            print(f'La raiz cuadrada de {objetivo_ingresado} es: {respuesta}')

    elif opcion_elegida == 3:
        bajo = 0.0
        alto = max(1.0, objetivo_ingresado)
        respuesta = (alto + bajo) / 2

        while abs(respuesta ** 2 - objetivo_ingresado) >= epsilon_ingresado:
            print(f'bajo={bajo}, alto={alto}, respuesta={respuesta}')
            if respuesta ** 2 < objetivo_ingresado:
                bajo = respuesta
            else:
                alto = respuesta

            respuesta = (alto + bajo) / 2

        print(f'La raiz cuadrada del objetivo es: {respuesta}')


def run():
    menu = """
    Bienvenidos al sistema de búsqueda, por favor, elige un tipo de búsqueda:

    1 - Enumeración exhaustiva
    2 - Aproximación
    3 - Binaria

    Elige una opción: 
    """
    opcion = int(input(menu))
    if opcion == 1:
        print(f'=== Enumeración exhaustiva ===')
        objetivo = int(input('Ingrese objetivo: '))
        busqueda(opcion_elegida=opcion,objetivo_ingresado=objetivo)
    elif opcion == 2:
        print(f'=== Aproximación ===')
        objetivo = int(input('Ingrese objetivo: '))
        epsilon = float(input('Ingrese exactitud: '))
        busqueda(opcion_elegida=opcion, objetivo_ingresado=objetivo, epsilon_ingresado=epsilon)
    elif opcion == 3:
        print(f'=== Búsqueda binaria ===')
        objetivo = int(input('Ingrese objetivo: '))
        epsilon = float(input('Ingrese exactitud: '))
        busqueda(opcion_elegida=opcion, objetivo_ingresado=objetivo, epsilon_ingresado=epsilon)
    else:
        print("Ingrese una opción correcta")


if __name__ == '__main__':
    run()

Por aca les dejo mi código

# Este programa calcula la raiz cuadrada de un numero entero con 3 algoritmos diferentes
print('Te damos la bienvenida a la calculadora de Raiz cuadrada.')
print('Este programa te permite calcular la raiz cuadrada usando 3 algoritmos diferentes')
print('Porfavor seleccione el algoritmo que desea usar')

def enumx (entero_enumx):
    respuesta_enum = 0
    while respuesta_enum**2 < entero_enumx:
        respuesta_enum += 1
    if respuesta_enum**2 == entero_enumx:
       return respuesta_enum
    else:
       return 0  
def aprox(entero_aprox):
    epsilon_aprox = 0.01
    paso_aprox = epsilon_aprox**2
    respuesta_aprox = 0.0
    while abs(respuesta_aprox**2 - entero_aprox)>= epsilon_aprox and  respuesta_aprox <= entero_aprox:
          respuesta_aprox += paso_aprox
    if abs(respuesta_aprox**2 - entero_aprox)>=epsilon_aprox:
          return 0
    else:
        return respuesta_aprox
def binarysearch (entero_bin):
    epsilon_bin = 0.01
    bajo_bin = 0.0
    alto_bin = max(1.0,entero_bin)
    respuesta_bin = (alto_bin + bajo_bin)/2
    pasos_bin = 0
    while abs(respuesta_bin**2 - entero_bin)>=epsilon_bin:
        pasos_bin +=1    
        if respuesta_bin**2 < objetivo_bin:
           bajo_bin = respuesta_bin
        else:
           alto_bin = respuesta_bin
        respuesta_bin = (alto_bin + bajo_bin) / 2
    return respuesta_bin

selector = int(input('Escriba (1) para Enumeracion Exhaustiva, (2) para Aproximacion o (3) para Busqueda Binaria: '))
if selector == 1:
    print('Bienvenido al algoritmo de Enumeracion Exhaustiva')
    objetivo_enumx= int(input('Por favor digite un numero entero: '))
    respuesta_enumx = enumx(objetivo_enumx)
    if respuesta_enumx != 0:
       print(f'La raiz cuadrada de {objetivo_enumx} es {respuesta_enumx}')
    else:
       print(f'El numero {objetivo_enumx} no tiene raiz cuadrada exacta')    
elif selector == 2:
    print('Bienvenido al algoritmo de aproximacion')
    objetivo_aprox = int(input('Porfavor digite un numero entero: '))
    respuesta_aprox= aprox(objetivo_aprox)
    if respuesta_aprox !=0:
        print(f'La raiz cuadrada de {objetivo_aprox} es {respuesta_aprox}')
    else:
        print(f'No se encontro la raiz cuadrada de {objetivo_aprox}')
elif selector == 3:
    print('Bienvenido al algoritmo de busqueda binaria')
    objetivo_bin = int(input('Por favor digite un numero entero: '))
    respuesta_bin = binarysearch (objetivo_bin)
    print(f'La raiz cuadrada de {objetivo_bin} es {respuesta_bin}')
else:
    print('Seleccione un algoritmo valido')

También se le puede el valor del 3er parámetro sin especificarlo, siempre que respete el orden.

import numpy as np

method1='[1] Busqueda exhautiva'; method2='[2] Busqueda binaria'; method3='[3] Bisección'
msg1='[0] No'; msg2='[1] Si'
response=True

def imprimir(number,solucion,iteraciones,tol,exp):
    if abs(solucion**exp -number)<=tol:
        print(f'\nLa raiz {exp}° de {number} es {solucion}')
        print(f'Se realizo el calculo en {iteraciones} iteraciones')
    else:
        print(f'\nno se encontro raiz {exp}° de {number}')
        print(f'La solucion aproximada fue {solucion} en {iteraciones} iteraciones.')


def busqueda_exhautiva(number,exponente,tol=0.01):
    paso=tol**exponente
    respuesta=0.0
    iteraciones=0

    while abs(respuesta**exponente -number) >=tol and respuesta <=number:
        respuesta+=paso
        iteraciones+=1
    
    imprimir(number,respuesta,iteraciones,tol,exponente)

def busqueda_binaria(number,exponente,tol=0.01):
    bajo=0.0; alto=max(1.0,number)
    respuesta=(alto+bajo)/2
    iteraciones=1

    while abs(respuesta**2 - number) >= tol:
        iteraciones+=1
        if respuesta**2<objetivo:
            bajo= respuesta
        else:
            alto=respuesta

        respuesta = (alto + bajo)/2
    
    imprimir(number,respuesta,iteraciones,tol,exponente)

def biseccion(number,exponente, tol=0.01):
    Funcion= lambda x: number-x**exponente      #funcion a solucionar (encontrar donde se hace 0)
    xlista=np.linspace(-1*number,number,50)     #hacemos un arreglo de valores en el eje x igualmente espaciado

    a=xlist[0] #primer extremo
    b=0        #segundo extremo

    for i in range(len(xlista)):
        fa=Funcion(xlista[i])    #funcion en a
        fb=Funcion(xlista[i+1])  #funcion en b
        prod=fa*fb
        if prod<0:
            a=xlista[i]     
            b=xlista[i+1]   
            break
    
    c=(a+b)/2              #extremo medio
    fc=Funcion(c)
    iteraciones=1

    while abs(fc)>tol:
        iteraciones+=1
        if (fc*fa)==0:
            print(c)
        elif (fc*fa) <0:
            b=c
        elif (fc*fa) >0:
            a=c
        
        c=(a+b)/2
        fc=Funcion(c)
    respuesta=c
    
    imprimir(number,respuesta,iteraciones,tol,exponente)



while response:
    print('\n'+'Escoge un algoritmo de aproximacion de raices:'+'\n')
    print(method1+'\n'+method2+'\n'+method3+'\n')
    method=int(input('Ingrese numero de metodo: '))

    objetivo=int(input('\nIngrese numero: '))
    radical= int(input('Ingrese radical: '))

    if method==1:
        busqueda_exhautiva(objetivo,radical)
    elif method==2:
        busqueda_binaria(objetivo,radical)
    elif method==3:
        biseccion(objetivo,radical)

    #cuerpo
    print('\n'+'¿Desea ingresar otra raiz?'+'\n')
    print(msg1+'\n'+msg2+'\n')
    response=bool(int(input('Ingrese opción: ')))

Mi solución al reto:
.

Comparto mi código. 😃

# DEFINICIÓN DE FUNCIONES(ALGORITMOS):
# //////////////////////////// 1 ENUMERACION EXHAUSTIVA  //////////////////////////////
def enumeracion_exhaustiva(objetivo,respuesta):
#respuesta = float(input('puedes sugerir una solución aproximada y reducir el tiempo de calculo: ')) # valor inicial de busqueda.
    while respuesta**2 < objetivo:
        respuesta += 1
        #print(f'respuesta = {respuesta}, error = {abs(respuesta**2 - objetivo)}')
    if respuesta**2 == objetivo:
        return respuesta #print(f'//  La raiz cuadrada de {objetivo} es {respuesta}')
    else:
        respuesta = -1
        return respuesta #print(f'{objetivo} no tiene raiz cuadrada exacta') 
# /////////////////////////// 2 APROXIMACION DE SOLUCIONES //////////////////////////////
def aprox_soluciones(objetivo, respuesta, epsilon):
    paso = epsilon**2 #es el salto o incremento que realiza al valor anterior.
        #
    while abs(respuesta**2-objetivo) >= epsilon:
        #print(respuesta, respuesta**2, objetivo)
        if respuesta**2 > objetivo:
                respuesta -= paso    # se debe decrementar para encontrar la solución
        elif respuesta**2 < objetivo:
                respuesta += paso    # se debe incrementar para encontrar la solución
        else:
            return respuesta #print(f'la respuesta es {respuesta}') # respuesta^2 = objetivo    
    if abs(respuesta**2 - objetivo) >= epsilon:
       respuesta = -1
       return respuesta #print('No se encontró solución')
    else:
       return respuesta #print(f'la raiz cuadrada de {objetivo} es {respuesta}')
     
# /////////////////////////// 3 BUSQUEDA BINARIA /////////////////////////////////////////
def busqueda_binaria(objetivo, epsilon):
    #print('Metodo busqueda binaria o de la Bisección')
    bajo = 0.0
    alto = max(1.0, objetivo)
    respuesta = (alto+bajo)/2
    while abs(respuesta**2 - objetivo) >= epsilon:
        #print(f'bajo={bajo}, alto={alto}, respuesta={respuesta}, error={respuesta**2 - objetivo}')
        if respuesta**2 < objetivo:
            bajo = respuesta
        else:
            alto = respuesta

        respuesta = (alto+bajo)/2
    return respuesta

# AQUI COMIENZA EL CODIGO:
print('////////////   Este programa calcula la raiz de un numero  //////////////')
print('//  Puedes elegir entre estos tres algoritmos de calculo: ')
print('//  Digite el numero correspondiente... ')
algoritmo = int(input('//  Enumeración exhaustiva (1), Aproximación de Soluciones (2) o Busqueda Binaria (3): '))
objetivo = int(input('// Escoge un entero y calcularé su Raíz: '))
import time
start_time = time.time()
if algoritmo == 1:
    respuesta = 0.0
    respuesta = enumeracion_exhaustiva(objetivo,respuesta)
if algoritmo == 2:
    epsilon = float(input('ingrese la precisión esperada epsilón: ')) # presición esperada.
    respuesta = float(input('puedes sugerir una solución aproximada y reducir el tiempo de calculo: ')) # valor inicial de busqueda.
    respuesta = aprox_soluciones(objetivo, respuesta, epsilon)
if algoritmo == 3:
    epsilon = float(input('ingrese la precisión esperada epsilón: ')) # presición esperada.
    respuesta = busqueda_binaria(objetivo, epsilon)
if respuesta == -1:
    print(f'{objetivo} no tiene raiz cuadrada exacta, o no tiene solución') 
else:
    print(f'//  La raiz cuadrada de {objetivo} es {respuesta}')
    print(f'//  Tiempo de ejecución del codigo fue:  {time.time() - start_time} segundos')
# Aqui finaliza el codigo principal.```

mi código del ejercicio 😄

def busqueda_binaria(objetivo, epsilon):
    epsilon = 0.01
    bajo = 0.0
    alto = max(1.0, objetivo)
    respuesta = (alto + bajo) / 2

    while abs(respuesta**2 - objetivo) >= epsilon:
        if respuesta**2 < objetivo:
            bajo = respuesta
        else:
            alto = respuesta
        respuesta = (alto + bajo) / 2

    return f'La raiz cuadrada de {objetivo} es {respuesta}'


def enumeracion_exhaustiva(objetivo):
    respuesta = 0

    while respuesta**2 < objetivo:
        respuesta += 1

    if respuesta**2 == objetivo:
        return f'La raíz cuadrada de {objetivo} es {respuesta}'
    else:
        return f'{objetivo} no tiene una raíz cuadrada exacta'


def aproximacion(objetivo, epsilon):
    epsilon = 0.01
    paso = epsilon**2
    respuesta = 0.0
    while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
        respuesta += paso

    if abs(respuesta**2 - objetivo) >= epsilon:
        return f'No se encontró la raiz cuadrada de {objetivo}'
    else:
        return f'La raíz cuadrada de {objetivo} es {respuesta}'


def run():
    objetivo = int(input('Escoge un número: '))

    metodo = int(input('''Escoge el método para encontrar la raiz cuadrada:
1. Busqueda binaria
2. Enumeración exhaustiva
3. Aproximación de soluciones

Ingrese 1, 2 o 3: '''))
    if metodo == 1:
        epsilon = abs(float(input('Escoge el margen de error aceptable (epsilon): ')))
        print(busqueda_binaria(objetivo, epsilon))
    elif metodo == 2:
        print(enumeracion_exhaustiva(objetivo))
    elif metodo == 3:
        epsilon = abs(float(input('Escoge el margen de error aceptable (epsilon): ')))
        print(aproximacion(objetivo, epsilon))
    else:
        print('Método inválido')


if __name__ == '__main__':
    run()

# Enumeración exhaustiva:

def enumeracion_exhaustiva(objetivo):
    resultado = 0
    
    while resultado**2 < objetivo:
        resultado += 1
    
    if resultado**2 == objetivo:
        return f"La raiz cuadrada de {objetivo} es: {resultado}"
    else: 
        return f"{objetivo} no tiene raiz cuadrada"
    
# Aproximación de soluciones:

def aproximacion_soluciones(objetivo, epsilon):
    epsilon = epsilon/100
    paso = epsilon**2
    respuesta = 0.0
    
    while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
        respuesta += paso
    
    if abs(respuesta**2 - objetivo) >= epsilon:
        return f"No se encontró la raiz de {objetivo}"
    else:
        return f"la raiz {objetivo} es: {respuesta}"   
    
# Busquedad binaria:

def busqueda_binaria(objetivo, epsilon):
    epsilon = epsilon/100
    alto = max(1, objetivo)
    bajo = 0.0
    respuesta = (alto + bajo)/2
    
    while abs(respuesta**2 - objetivo) >= epsilon:
        if respuesta**2 < objetivo:
            bajo = respuesta
        else:
            alto = respuesta
        
        respuesta = (bajo + alto)/2
        
    if abs(respuesta**2 - objetivo) >= epsilon:
        return f"No se encontró la raiz de {objetivo}"
    else:
        return f"la raiz {objetivo} es: {respuesta}" 
            
        
print("##### PROGRAMA PARA CALCULAR RAICES CON DIFERENTES ALGORITMOS #####\n")
objetivo = int(input("Número al que desea sacar la raiz cuadrada: "))
print("¿Con qué algoritmo desea buscar su raiz cuadrada?")
print("\t1 - Enumeración exhaustiva")
print("\t2 - Aproximación de soluciones")
print("\t3 - Busqueda binaria")

while True:
    opcion = int(input("Introduzca un número: "))
    if opcion> 0 and opcion < 4:    break
        

if opcion == 1:
    print(enumeracion_exhaustiva(objetivo))
    
elif opcion == 2:
    while True:
        epsilon = int(input("Introduzca el margen de error de 1 - 10 % : "))
        if epsilon> 0 and opcion < 10:  break
            
    print(aproximacion_soluciones(objetivo, epsilon))
    
else:
    while True:
        epsilon = int(input("Introduzca el margen de error de 1 - 10 % : "))
        if epsilon> 0 and opcion < 10:  break
    
    print(busqueda_binaria(objetivo, epsilon))    ```
Espero las correcciones y sugerencias

Funciones y abstracción

.
Abstracción: capacidad de separar los detalles complejos de una tarea o problema y enfocarse en los aspectos esenciales y relevantes para resolverlo. Esto implica crear una representación simplificada y conceptual del problema en cuestión, que permita entenderlo y solucionarlo de una manera más clara y estructurada. La abstracción se enfoca en el “¿qué hace?” más que en el “¿cómo lo hace?”.
.
Descomposición: es el proceso de descomponer un problema complejo en partes más pequeñas y manejables, con el objetivo de hacerlo más fácil de entender, resolver y mantener.
En programación, la descomposición se refiere al enfoque de dividir un programa en módulos o funciones más pequeñas que se encarguen de una tarea específica. Hacer esto, se puede mejorar la eficiencia, legibilidad y reutilización del código.
.
Definición de funciones en Python: se define utilizando la palabra clave def, seguida del nombre de la función y los parámetros entre paréntesis. Su sintaxis básica es:

def nombre_de_la_funcion(parametro1, parametro2, ...):
    # Cuerpo de la función
    # Aquí se especifica lo que hace la función
    return resultado

La palabra clave return se utiliza para devolver un resultado de la función. Puede haber uno o varios parámetros de entrada en una función, y la función puede devolver un valor o no devolver ninguno. Por ejemplo, la siguiente función suma dos números y devuelve el resultado:

def suma(a, b):
    resultado = a + b
    return resultado

Para llamar a una función, se utiliza el nombre de la función seguido de los parámetros entre paréntesis. Por ejemplo:

resultado = suma(3, 4)
print(resultado) # Retorna 7

Funciones

Se puede entender una función como un conjunto de líneas de código que realizan una tarea específica y pueden tomar “Argumentos” para diferentes “Parámetros” que modifiquen su funcionamiento y los datos de salida. Una función te permite implementar operaciones que son habitualmente utilizadas en un programa y, de esta manera, reducir la cantidad de código.

Las funciones en Python serán una parte del código de nuestro programa encargadas de cumplir algún objetivo específico definido por nosotros o por el lenguaje, recibiendo ciertos “datos de entrada” (Argumentos) en los llamados Parámetros para procesarlos y brindarnos “datos de salida” o de retorno.

Las funciones en Python son componentes importantes en la programación que cuentan con una estructura que consta de dos principios.

• Principio de reutilización: puedes reutilizar una función varias veces y en distintos programas.
• Principio de modularización: te permite segmentar programas complejos con módulos más simples para depurar y programar con mayor facilidad.

Dentro de las funciones en Python encontrarás integraciones de lenguaje creadas por el usuario para replicarlas en diferentes programas.

Funciones comunes en Python

En Python puedes crear funciones gracias a un lenguaje flexible y presente en cualquier tipo de aplicación. Tienes que tener presente que las funciones en Python tienen las siguientes características:

1. def: palabra clave.
2. Nombre de la función.
3. “()”: paréntesis que incluyen los parámetros de entrada (opcionales).
4. “:” : dos puntos.
5. Bloque de código.
6. Sentencia de retorno (opcional).

Estos son los 6 elementos que deben tener todas las funciones en Python. Son utilizadas en el mismo orden mencionado y te ayudan a mantener una estructura de programación óptima y eficiente.

Hola compañeros! acá les comparto mi código 😃

objective = int(input('Escoge un número entero para calcularle su raíz cuadrada: '))
choice_method = int(input('Escoge entre los siguintes métodos con el que quieres que se realice el calculo; \n1) Método por enumeración exhaustiva \n2) Método por aproximación \n3) Método por busqueda binaria \n'))
response = 0
epsilon = 0.0001

def enumeration(objective, response):
    while response ** 2 < objective:
        print(response)
        response += 1

    if response ** 2 == objective:
        print(f'La raiz cuadrada de {objective} es: {response}')
    else:
        print(f'El número {objective} no tiene raiz cuadrada exacta')

def aproximation(objective, epsilon):
    paso = epsilon ** 2
    response = 0.0

    while abs(response ** 2 - objective) >= epsilon and response <= objective:
        print(abs(response ** 2 - objective), response) 
        response += paso

    if abs(response ** 2 - objective) >= epsilon:
        print(f'No se encontro la raiz cuadrada {objective}')
    else:
        print(f'La raiz cuadrada de {objective} es {response}')


def binary_search(objective, epsilon):
    bajo = 0.0 
    alto = max(1.0, objective) 
    response = (alto + bajo) / 2 

    while abs(response ** 2 - objective) >= epsilon:
        print(f'bajo = {bajo}, alto = {alto}, respuesta = {response}')

        if response ** 2 < objective:    
            bajo = response
        else:
            alto = response

        response = (alto + bajo) / 2
    print(f'La raiz cuadrada de {objective} es {response}')



if choice_method == 1:
    enumeration(objective, response)
elif choice_method == 2:
    aproximation(objective, epsilon)
elif choice_method == 3:
    binary_search(objective, epsilon)
else:
    print("Escoge un método de calculo valido (1, 2 o 3)")

def enumeracion_ex (target):
    answer = 0

    while answer**2 < target:
        answer += 1
        print(answer**2, answer)

    if answer**2 == target:
        print(f"La raiz cuadrada de {target} es {answer}.")
    else:
        print(f"{target} no tiene raiz cuadrada exacta.")

def aproximacion(target):
    epsilon = 0.01
    step = epsilon**2
    answer = 0.0

    while abs(answer**2 - target) >= epsilon and answer <= target:
        print(abs(answer**2 - target), answer)
        answer += step

    if abs(answer**2 - target) >= epsilon:
        print(f"No se encontró la raíz cuadrada de {target}")
    else:
        print(f"La raíz cuadrada de {target} es {answer}")

def busq_binaria (target):
    epsilon = 0.01
    lowest = 0.0
    highest = max(1.0, target)
    answer = (highest + lowest) / 2

    while abs(answer**2 - target) >= epsilon:
        print(f"bajo = {lowest}, alto = {highest}, respuesta = {answer}")
        if answer**2 < target:
            lowest = answer 
        else: 
            highest = answer 

        answer = (highest + lowest) / 2

    print(f"La raíz cuadrada del {target} es {answer}")

target = int(input("Ingresa un número entero: "))
metodos = [1, 2, 3]
metodo = int(input("""Escoja un metodo por el que quiera solucionarlo
    1. Enumeración exhaustiva
    2. Aproximación
    3. Busqueda Binaria
    """))
while metodo not in metodos:
    metodo = int(input("""Escoja un metodo valido
        1. Enumeración exhaustiva
        2. Aproximación
        3. Busqueda Binaria
        """))

if metodo == 1:
    enumeracion_ex(target)
elif metodo == 2:
    aproximacion(target)
else:
    busq_binaria(target)

Buenas, aquí mi resolución del reto:

def run():
    def enumeracion_exaustiva():
        print('Escogiste el algoritmo de enumeracion exaustiva.')
        objetivo = int(input('Escoge un número entero: '))
        respuesta = 0


        while respuesta**2 < objetivo:
            respuesta += 1


        if respuesta**2 == objetivo:
            print(f'La raiz cuadrada de {objetivo} es {respuesta} .')
        else:
            print(f'{objetivo} no tiene una raiz cuadrada exacta.')


    def aproximacion_solucion():
        print('Escogiste el algoritmo de aproximacion a la solucion.')
        objetivo = int(input('Escoge un número entero: '))
        epsilon = 0.1
        paso = epsilon**2
        respuesta = 0.0


        while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
            respuesta += paso
    

        if abs(respuesta**2 - objetivo) >= epsilon:
            print(f'No se encontró la raiz cuadrada {objetivo}')
        else:
            print(f'La raiz cuadrada de {objetivo} es {respuesta}')


    def busqueda_binaria():
        print('Escogiste el algoritmo de búsqueda binaria.')
        objetivo = int(input('Escoge un número entero: '))
        epsilon = 0.001
        bajo = 0.0
        alto = max(1.0, objetivo)
        respuesta =  (alto + bajo) / 2


        while abs(respuesta**2 - objetivo) >= epsilon:
            if respuesta**2 < objetivo:
                bajo = respuesta
            else:
                alto = respuesta
        
            respuesta = (alto + bajo) / 2

        print(f'La raiz cuadrada de {objetivo} es {respuesta}')

    print('''Bienvenido a la calculadora de raices cuadradas. 
    - Ingresa 1 para resolver la raíz con el algoritmo de enumeración exhaustiva.
    - Ingresa 2 para resolver la raíz con el algoritmo de aproximación de solución.
    - Ingresa 3 para resolver la raíz con el algoritmo de busqueda binaria.''')
    
    
    opcion = int(input('Ingresa una opción: '))
    

    if opcion == 1:
        enumeracion_exaustiva()
    elif opcion == 2:
        aproximacion_solucion()
    elif opcion == 3:
        busqueda_binaria()
    else:
        print('El valor que ingresaste no corresponde a una opción.')


if __name__ == '__main__':
    run()

Aquí va mi código, repetí un if para seleccionar la opción 2 veces, una para imprimir un mensaje y el segundo para la selección de la opción a usar. Si alguien sabe como ahorrarme eso le agradecería me lo comente, mil gracias 😃

import os
import time


option_user = int(input('''
            SISTEMA PARA CALCULAR RAIZ CUADRADA
        
        Selecciona el algoritmo que desees utilizar:

        (1) Para Enumeración exhaustiva.
        (2) Para Aproximación de Soluciones.
        (3) Para Búsqueda Binaria.

    Ingresa una opción: '''))


if option_user == 1:
    print('''
    Seleccionaste la Enumeración exhaustiva.''')
elif option_user == 2:
    print('''
    Seleccionaste la Aproximación de Soluciones.''')
elif option_user == 3:
    print('''
    Seleccionaste la Búsqueda Binaria.''')
else:
        print('''
        Elige una opción correcta.''')

time.sleep(3)

os.system('clear') # Para limpiar la pantalla. Esto es para agregar un poco de movimiento a lo que se va mostrar en la pantalla.



objetivo = int(input('''
    Ahora, ingresa un número: '''))


time.sleep(1)
print('                  .')
time.sleep(1)
print('                  .')
time.sleep(1)
print('                  .')
time.sleep(1)


os.system('clear') # Para limpiar la pantalla. Esto es para agregar un poco de movimiento a lo que se va mostrar en la pantalla.


def enumeracion_exhaustiva(objetivo):
    respuesta = 0

    while respuesta**2 < objetivo:
        print(respuesta)
        respuesta += 1

    if respuesta**2 == objetivo:
        print(f'La raiz cuadrada de {objetivo} es {respuesta}')
    else:
        print(f'{objetivo} no tiene una raiz cuadrada exacta.')

def aproximacion(objetivo):

    epsilon = 0.01 # Aproximación a la respuesta, que tan cerca llegaremos a la respuesta
    paso =  epsilon**2 #Que tanto nos acercaremos en cada iteración a la respuesta
    respuesta = 0.0 #Tendrá el valor de la respuesta cuando lleguemos.

    while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
        print(abs(respuesta**2 - objetivo), respuesta)
        respuesta += paso

    if abs(respuesta**2 - objetivo) >= epsilon:
        print(f'No se encontró la raiz cuadrada {objetivo}')
    else:
        print(f'La raiz cuadrada de {objetivo} es {respuesta}')

def busqueda_binaria(objetivo):

    epsilon = 0.001
    bajo = 0.0
    alto = max(1.0,objetivo) #Nos regresa el valor más alto entre 2 valores. 1.0 o el objetivo. Si el objetivo es menor que 1.0, empezaremos con 1.0
    respuesta = (alto + bajo) / 2

    while abs(respuesta**2 - objetivo) >= epsilon:
        print(f'bajo={bajo}, alto={alto}, respuesta={respuesta}')
        if respuesta**2 < objetivo:
            bajo = respuesta
        else:
            alto = respuesta
        respuesta = (alto +bajo) / 2

    print(f'La raiz cuadrada de {objetivo} es {respuesta}')


if option_user == 1:
    enumeracion_exhaustiva(objetivo)
elif option_user == 2:
    aproximacion(objetivo)
else:
    busqueda_binaria(objetivo)

Hola comunidad, alguien me puede explicar que papel juega la variable inverso del segundo ejemplo.

Lo que entiendo es que si se ingresan los argumentos invertidos (primero el apellido y luego el nombre) la variable los invierte para que estén en orden.

Es así? me pueden ayuda?

Desde ya gracias…

Comparto mi codigo: Si alguien sabe como optimizarlo me gustaria saberlo.

### Definiendo las funciones:

def enumeracion (target):
    objetivo = target
    respuesta = 0

    while respuesta**2 < objetivo:
        respuesta +=1

    if respuesta**2 == objetivo:
        print(f'La raiz cuadrada de {objetivo} es {respuesta}')
    else:
        print(f'{objetivo} no tiene una raiz cuadrada exacta')

def aproximacion (target):
    objetivo = target
    epsilon = 0.01
    paso = epsilon**2
    respuesta = 0.0

    while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
        respuesta += paso

    if abs(respuesta**2 - objetivo) >= epsilon:
        print(f'No se encontro la raiz cuadrada de {objetivo}')
    else:
        print(f'La raiz cuadrada de {objetivo} es {respuesta}')


def busqueda_binaria(target):
    objetivo = target
    epsilon = 0.001
    bajo = 0.0
    alto = max(1.0, objetivo)
    respuesta = (alto + bajo) / 2

    while abs(respuesta**2 - objetivo) >= epsilon:
        if respuesta**2 < objetivo:
            bajo = respuesta
        else:
            alto = respuesta
        respuesta = (alto + bajo) / 2

    print(f'La raiz cuadrada de {objetivo} es {respuesta}')

### Interfaz de uso

print('Bienvenido al programa buscador de raiz cuadrada')
print('Seleccione su metodo de busqueda preferido')
print('1) Busqueda por enumeracion')
print('2) Busqueda por aproximacion')
print('3) Busqueda binaria')

metodo_de_busqueda = int(input('....: '))
    
if metodo_de_busqueda == 1:
    print('Usted selecciono el metodo de busqueda "1) Busqueda por enumeracion"')
    target1 = int(input("Escoge un numero: "))
    enumeracion(target1)
elif metodo_de_busqueda ==2:
    print('Usted selecciono el metodo de busqueda "2) Busqueda por aproximacion"')
    target1 = int(input("Escoge un numero: "))
    aproximacion(target1)
elif metodo_de_busqueda ==3:
    print('Usted selecciono el metodo de busqueda "3) Busqueda binaria"')
    target1 = int(input("Escoge un numero: "))
    busqueda_binaria(target1)
else:
    print('Por favor seleccione una opccion correcta')

print('Gracias por utilizar este programa')

Hola compañeros!
Les comparto el programa que hice, intenté seguir las buena practicas de escritura de código, cualquier aporte que deseen hacer es bienvenido.

<def run():
    operacion = int(input(""""
    Seleccione la opcion que desea:
    1.- Enumeracion.
    2.- Aproximacion
    3.- Busqueda Binaria
    """))
    
    if operacion > 0 and operacion < 4:
        objetivo = int(input("Seleccione un numero: "))
        if operacion == 1:
            enum(objetivo)
        elif operacion == 2:
            proxi(objetivo)
        else:
            bin(objetivo)
    else:
        print("El valor seleccionado no esta dentro de las opciones.")

def enum (objetivo):
    respuesta = 0

    while respuesta**2 < objetivo:
        print(respuesta)
        respuesta += 1

    if respuesta**2 == objetivo:
        print(f"La raiz cuadrada de {objetivo} es {respuesta}")
    else:
        print(f"{objetivo} no tiene una raiz cuadrada exacta")

def proxi (objetivo):
    epsilon = 0.0001
    paso = epsilon**2
    respuesta = 0.0 

    while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
        print(abs(respuesta**2-objetivo), respuesta)
        respuesta += paso

    if abs (respuesta**2 - objetivo) >= epsilon:
        print(f'No se encontro la raiz cuadrada del {objetivo}')
    else:
        print(f'la raiz cuadrada de {objetivo} es {respuesta}') 

def bin (objetivo):
    epsilon = 0.001
    bajo = 0.0
    alto = max(1.0, objetivo)
    respuesta = (alto + bajo)/2

    while abs(respuesta**2 - objetivo) >= epsilon:
        print(f'bajo={bajo}, alto={alto}, respuesta={respuesta}')
        if respuesta**2 < objetivo:
            bajo = respuesta
        else:
            alto = respuesta
    
        respuesta = (alto + bajo)/2

    print(f'La raiz cuadrada de {objetivo} es {respuesta}')

if __name__ == '__main__':
    run()> 

Saludos!

Así quedo mi código aplicando abstracción con el uso de funciones:

Reto

def enumeracion(objetivo):
    respuesta = 0
    while respuesta ** 2 < objetivo:
        respuesta += 1

    if respuesta ** 2 == objetivo:
        return print(f"la raiz cuadrada de {objetivo} es {respuesta}")
    else:
        return print(f"{objetivo} no tiene raiz cuadrada exacta")

def busqueda_binaria(objetivo):
    epsilon = 0.01
    bajo = 0.0
    alto = max(1.0, objetivo)
    respuesta = (alto + bajo) / 2

    while abs(respuesta ** 2 - objetivo) >= epsilon:
        if respuesta ** 2 < objetivo:
            bajo = respuesta
        
        else:
            alto = respuesta
        
        respuesta = (alto + bajo) / 2
    
    return print(f'La raíz cudrada del {objetivo} es: {respuesta}')


def aproximacion(objetivo):
    epsilon = 0.01 #Que tan cerca queremos llegar a la respuesta
    paso = epsilon ** 2 #Que tanto no estaremos acercando en cada iteración de la respuesta
    respuesta = 0.0

    while abs(respuesta ** 2 - objetivo) >= epsilon and respuesta <= objetivo:
        respuesta += paso

    if abs(respuesta ** 2 - objetivo) >= epsilon:
        return print(f'No se encontro la raiz cuadrada de {objetivo}')
    else:
        return print(f'La raiz cuadrada de {objetivo} es {respuesta}')


def run():
    menu = '''
    Escoja uno de los siguientes algoritmos para hallar la 
    raiz cuadrada de el numero que usted escoja.
    1. Enumeración exahustiva
    2. Busqueda binaria
    3. Aproximación de soluciones
    '''
    opcion = int(input(menu))
    objetivo = int(input("Ingrese un número: "))

    if opcion == 1:
        enumeracion(objetivo)
    elif opcion == 2:
        busqueda_binaria(objetivo)
    elif opcion == 3:
        aproximacion(objetivo)

    
if __name__ == '__main__':
    run()

Comparto mi solución al reto

def sqr_exhaustiva(objetivo):
    respuesta = 0

    while respuesta**2 < objetivo:
        respuesta += 1

    if respuesta**2 == objetivo:
        return f'La raíz cuadrada de {objetivo} es {respuesta}'
    else:
        return f'{objetivo} no tiene raíz cuadrada exacta'

def sqr_aproximacion(obj):
    epsilon = 0.001 
    paso = epsilon**2 
    respuesta = 0.0

    while abs(respuesta ** 2 - obj) >= epsilon and respuesta <= obj:
        respuesta += paso
        

    if abs(respuesta ** 2 - obj) >= epsilon:
        return f'No se encontro la raiz cuadrada de {obj}, por aproximación'
    else:
        return f'La raiz cuadrada de {obj} es {respuesta}'

def sqr_binaria(objetivo):
    epsilon = 0.01 # que tan cerca quiero estar de la solución 
    bajo = 0.0
    alto = max(1.0, objetivo)
    respuesta = (alto + bajo) / 2

    while abs(respuesta**2 - objetivo) >= epsilon:
        if respuesta**2 < objetivo:
            bajo = respuesta
        else:
            alto = respuesta
        
        respuesta = (alto + bajo) / 2

    return f'La raíz cuadrada de {objetivo} es {respuesta}'

def run():
    option = int(input('''Elige el tipo de busqueda que deseas hacer indicando el número
        1. Enumeración exhaustiva
        2. Aproximación
        3. Busqueda binaria\n'''))
    numero = int(input('Elige un número para hallar su raíz cuadrada: '))

    if option == 1:
        print(sqr_exhaustiva(numero))
    elif option == 2:
        print(sqr_aproximacion(numero))
    elif option == 3:
        print(sqr_binaria(numero))
    else:
        print('Elección equivocada')
        exit()

if __name__ == '__main__':
    run()

Muy bueno!

Esta es mi solución al desafío:
Le agregue un menú donde podes seleccionar entre los tres tipos de algoritmos 😀

def aproximacion():
    objetivo = int(input("Escoge un número: "))
    epsilon = 0.01
    paso = epsilon**2
    respuesta = 0.0

    while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
        respuesta += paso

    if abs(respuesta**2 - objetivo) >= epsilon:
        print("No se encontro la raiz cuadrada " + str(objetivo))   
    else:
        print("La raiz cuadrada de " + str(objetivo) + " es " + str(respuesta))  


def enumeracion():
    objetivo = int(input("Escoge un entero: "))
    respuesta = 0

    while respuesta**2 < objetivo:
        respuesta += 1

    if respuesta**2 == objetivo:
        print("La raiz cuadrada de " + str(objetivo) + " es " + str(respuesta)) 
    else:
        print(str(objetivo) + " no tiene una raiz cuadrada exacta") 


def busqueda_binaria():
    objetivo = int(input("Escoge un número: "))
    epsilon = 0.01
    bajo = 0.0
    alto = max(1.0, objetivo)
    respuesta = (alto + bajo) / 2

    while abs(respuesta**2 - objetivo) >= epsilon:
        if respuesta**2 < objetivo:
            bajo = respuesta
        else: 
            alto = respuesta

        respuesta = (alto + bajo) / 2


    print("La raiz cuadrada de " + str(objetivo) + " es " + str(respuesta))            


def run():
    menu = """
    Bienvenido!! 
    
    Elije el algoritmo que quieres utilizar
    para encontrar la raiz cuadrada de un numero

    1- Aproximación
    2- Enumeracion exhaustiva
    3- Busqueda binaria

    Elige una opcion: """
    opcion = input(menu)

    if opcion == "1":
        aproximacion()
    elif opcion == "2":
        enumeracion()
    elif opcion == "3":
        busqueda_binaria()
    else:
        print("Por favor elija una opcion existente")


if __name__ == "__main__":
    run()

Les comparto mi Solución al reto:

Aquí va mi código del reto, espero que si ven algo que esté mal o se pueda mejorar, me lo hagan saber.

def menu():
    print('--------------------Menu-------------------------------------------')
    print('Este programa permite usar diferentes métodos para calcular la raiz cuadrada de un número')
    print('Para este programa tenemos 3 algoritmos diferentes para calcular la raiz cuadrada de un número')
    print('Este es el menú: \nPresiona (1) para usar la enumeración exhaustiva \nPresiona (2) Para usar Aproximación de soluciones\nPresiona (3) Para usar búsqueda binaria')
    print('-------------------------------------------------------------------')
    
def enumeracionExahustiva(objetivo):
    respuesta=0
    while respuesta**2 < objetivo:
        respuesta+=1
    if respuesta**2 == objetivo:
        return (f'La raiz cuadrada de {objetivo} es {respuesta}')
    else:
        return (f'El {objetivo} no tiene una raiz cuadrada exacta')

def aproximacion(objetivo):
    epsilon= 0.01
    paso= epsilon**2
    respuesta= 0.0
    while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
        respuesta += paso
    if abs(respuesta**2-objetivo) >= epsilon:
        return(f'no se encontró la raiz cuadrada de {objetivo}')
    else:
        return(f'La raiz cuadrada de {objetivo} es {respuesta}')
        

def busquedaBinaria(objetivo):
    epsilon= 0.01
    limiteInferior= 0.0
    limiteSuperior= max(1.0, objetivo)
    respuesta=(limiteSuperior+limiteInferior) / 2
    while abs(respuesta**2 - objetivo) >= epsilon:
        if respuesta**2<objetivo:
            limiteInferior=respuesta
        else:
            limiteSuperior= respuesta
        respuesta= (limiteSuperior+limiteInferior)/2
    return(f'La raiz cuadrada de {objetivo} es igual a: {respuesta}')

def opcionErrada():
    return ('Ha digitado una opción errada')

def run():
    menu()
    opcion= input('Escoge una de las opciones del menú: ')
    objetivo = int(input('Escoge un número al que le quieras encontrar la raiz cuadrada: '))

    if opcion=='1':
        print(enumeracionExahustiva(objetivo))
    elif opcion=='2':
        print(aproximacion(objetivo))
    elif opcion=='3':
        print(busquedaBinaria(objetivo))
    else:
        print(opcionErrada())

if __name__=='__main__':#punto de entrada de un programa de python es una buena práctica en python
    run()

Mi aporte

def programas_numericos(opcion, objetivo):
    respuesta =0
    epsilon = 0.01
    paso = epsilon**2

    # Opcion 1: enumeracion
    if opcion == 1: 
        while respuesta**2 < objetivo:
            print(respuesta)
            respuesta += 1
        
        if respuesta**2 == objetivo:
            print(f'La raíz cuadrada de {objetivo} usando el método de enumeración es {respuesta}')
        else: 
            print('El número ingresado no tiene una raíz cuadrada exacta.')

    # Opcion 2: aproximación
    elif opcion == 2:
        while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
            print(abs(respuesta**2 - objetivo), respuesta)
            respuesta += paso

        if abs(respuesta**2 - objetivo) >= epsilon:
            print(f'No se encontró la raíz cuadrada de {objetivo}')
        else:
            print(f'La raíz cuadrada de {objetivo} usando el método de aproximación es {respuesta}')
    
    # Opción 3: Búsqueda binaria
    elif opcion == 3:
            bajo = 0.0
            alto = max(1.0, objetivo)
            respuesta = (alto + bajo)/2

            while abs(respuesta**2 - objetivo) >= epsilon:
                print(f'bajo = {bajo}, alto = {alto}, respuesta = {respuesta}')
                if respuesta**2 < objetivo:
                    bajo = respuesta 
                else:
                    alto = respuesta

                respuesta = (alto + bajo) /2
            
            print(f'La raíz cuadrada usando el método de búsqueda binaria de {objetivo} es {respuesta}')


def run():
    objetivo = int(input("""Bienvenido a la calculadora de raíces cuadradas
    Ingresa un número: """))

    opcion = int(input("""Por favor elige la método de cálculo:
    1. Enumeración (Funciona sólo con raíces exactas)
    2. Aproximación
    3. Búsqueda binaria: """))

    respuesta = programas_numericos(opcion, objetivo)

if __name__ == '__main__':
    run()

Mi código, se aceptan sugerencias

def Enumeracion_exhaustiva(square):
    resultado = 0
    while resultado**2 < square:
        resultado += 1
    if resultado**2 == square:
        return (f'La raiz cuadrada de {square} es {resultado}')
    else:
        return (f'{square} no tiene raiz cuadrada exacta')

def Aproximacion_de_soluciones(square):
    epsilon = float(input('Ingrese una aproximación: '))
    paso = epsilon**2
    resultado = 0.0
    while abs(resultado**2-square) >= epsilon and resultado < square:
        resultado += paso
    if abs(resultado**2 - square) >= epsilon:
        return (f'No se encontró la raíz cuadrada de {square}')
    else:
        return (f'La raiz cuadrada de {square} es {resultado}')

def Busqueda_binaria(square):
    epsilon = float(input('Ingrese una aproximación: '))
    bajo = 0.0
    alto = max(0.0, square)
    resultado = (alto+bajo)/2
    while abs(resultado**2 - square) >= epsilon:
        if resultado**2 < square:
            bajo = resultado
        else:
            alto = resultado
        resultado = (alto + bajo)/2
    return f'La raiz cuadrada de {square} es {resultado}'

objetivo = int(input('Ingresa un numero entero: '))
while objetivo < 0:
    objetivo = int(input('Ingresa un numero entero positivo: '))
if objetivo == 0:
    print(f'la raiz cuadrada de 0 es 0')
else:
    print('\n1 es Enumeracion exhaustiva\n2 es Aproximación de soluciones\n3 es Búsqueda binaria\n')
    metodo = int(input('Elije el numero del metodo con el que deseas hallar la raiz cuadrada: '))
    while metodo < 1 or metodo > 3:
        metodo = int(input('Elije 1, 2 o 3: '))
    print()
    if metodo == 1:
        print(Enumeracion_exhaustiva(objetivo))
    elif metodo == 2:
        print(Aproximacion_de_soluciones(objetivo))
    elif metodo == 3:
        print(Busqueda_binaria(objetivo))

Al momento de escribir el método y el número los coloco dentro de try para que escribas lo que escribas no te salga error.

def metodo1(num):
    resultado = 0
    while resultado**2 < num:
        resultado += 1
    if resultado**2 != num:
        print(f'La raíz cuadrada de {num} no es exacta.')
    else:
        print(f'La raíz cuadrada de {num} es {resultado}')
    print('Programa finalizado')

def metodo2(num2):
    epsilon = 0.01
    paso = epsilon**2
    respuesta = 0.0

    while abs(respuesta**2 - num2) >= epsilon and respuesta <= num2:
        print(respuesta**2 - num2, respuesta)
        respuesta += paso

    if abs(respuesta**2 - num2) >= epsilon:
        print(f'No se encontró la raíz cuadrada de {num2}')
    else:
        print(f'La raíz cuadrada de {num2} es {respuesta}')


def metodo3(num3):
    epsilon = 0.01
    bajo = 0.0
    alto = max(1.0, num3)
    respuesta = (alto + bajo) / 2

    while abs( respuesta**2 - num3) >= epsilon:
        print(f'Alto= {alto} bajo= {bajo} respuesta = {respuesta}')
        if respuesta**2 < num3:
            bajo = respuesta
        else:
            alto = respuesta

        respuesta = (alto + bajo) / 2

    print(f'La raíz cuadrada de {num3} es {respuesta}')

################################

print('Programa raiz cuadrada')

try:
    metodo = int(input('Escoja un metodo (1, 2, o 3): '))

    if metodo == 1:
        while 1 == 1:

            try:
                num = int(input('Escoge un numero: '))        
                metodo1(num)
                break
            except:
                print('Solo puede ser un numero entero')

    if metodo == 2:
        while 1 == 1:
            try:
                num2 = int(input('Escoge un numero: '))        
                metodo2(num2)
                break
            except:
                print('Solo puede ser un numero entero')

    if metodo == 3:
        while 1 == 1:
            try:
                num3 = int(input('Escoge un numero: '))
                metodo3(num3)
                break
            except:
                print('Solo puede ser un numero entero')

except:
    print('Elige una variable entre : 1, 2 o 3. \nLa variable 1 calcula lento y solo números naturales.') 
    print('La variable 2 también es lenta pero con decimales.\nLa 3 es la rápida y con decimales.')
    ```

en vez de declarar todas las funciones en un mismo archivo cree un archivo principal que importaba todas las demas funciones y adapte los otros programas que ya habiamos escrito para que se pudieran invocar como funciones del principal:

calculadora_de_raiz.py

import enumeracion
import busqueda_binaria
import aproximacion

option = int(input('Bienvenido a calculadora de raiz cuadrada por favor elige un algoritmo para calcular to objetivo: \n 0: enumeración \n 1: aproximación \n 2: busqueda binaria \n ingresa el número de la opción que quieres usar: '))
objetivo = int(input('A continuación ingresa el número que vas a calcular: '))

if option == 0:
    enumeracion.calcular(objetivo)
elif option == 1:
    aproximacion.calcular(objetivo)
elif option == 2:
    busqueda_binaria.calcular(objetivo)
else:
    print('no has ingresado una opción valida')

y como quedo uno de los otro archivos: aproximacion.py

def calcular(objetivo):
    epsilon = 0.01
    paso = epsilon ** 2
    respuesta = 0.0

    while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
        respuesta += paso

    if abs(respuesta**2 - objetivo) >= epsilon:
        print(f'No se encontro la raiz cuadrada {objetivo}')
    else:
        print(f'La raiz cuadrada de {objetivo} es {respuesta}')

def busquedaexhaustiva(objetivo,respuesta=0):
    while respuesta**2 < objetivo:
        respuesta+=1

    if respuesta**2>objetivo:
        return print(f'{objetivo} no tiene una raiz cuadrada entera')
    else:
        return print(f'La raiz cuadrada de {objetivo} es {respuesta}')


def aproximaciondesoluciones (objetivo):
    epsilon = 0.01
    paso = epsilon**2
    resultado = 0.0

    while abs(resultado**2 - objetivo) > epsilon and resultado**2 < objetivo:
        resultado+= paso

    if abs(resultado**2 - objetivo) <= epsilon:
        return print(f'La raiz cuadra de {objetivo} es {resultado}')
    else:
        return print(f'No existe la raiz cuadra de {objetivo}')


def busquedabinaria (objetivo):
    epsilon = 0.001
    bajo = 0.0
    alto = max(1.0, objetivo)
    resultado = (alto+bajo)/2

    while abs(resultado**2 - objetivo) > epsilon and resultado < objetivo:
        if resultado**2 > objetivo:
            alto=resultado
        else:
            bajo = resultado
        resultado = (alto+bajo)/2

    if abs(resultado**2 - objetivo) <= epsilon:
        return print(f'La raiz cuadra de {objetivo} es {resultado}')
    else:
        return print(f'No existe la raiz cuadra de {objetivo}')


print('a: busqueda exhaustiva')
print('b: aproximación de soluciones')
print('c: busqueda binaria')
objetivo = int(input('Escoje un numero: '))
metodo = input('Escoje un metodo: ')

if metodo=='a':
    busquedaexhaustiva(objetivo)
elif metodo=='b':
    aproximaciondesoluciones(objetivo)
elif metodo=='c':
    busquedabinaria(objetivo)
else: 
    print('Ese metodo no existe')

Aqui mi reto

# ENUMERACION EXHAUSTIVA
def enumeracion_exhaustiva( objetivo ):
  respuesta = 0
  while respuesta**2 < objetivo:
      respuesta += 1
  if respuesta**2 == objetivo:
      print(f'La razi cuadrada de {objetivo} es {respuesta}')
  else:
      print(f'{objetivo} no tiene una raiz cuadrada exacta')

# APROXIMACION DE SOLUCIONES
def aproximacion( objetivo ):
  epsilon = 0.01
  paso = epsilon**2
  respuesta = 0.0

  while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
    respuesta += paso

  if abs(respuesta**2 - objetivo) >= epsilon:
    print(f'No se encontro la raiz cuadrada de {objetivo}')
  else:
    print(f'La raiz cuadrada de {objetivo} es {respuesta}')

# BUSQUEDA BINARIA
def busqueda_binaria( objetivo ):
  epsilon = 0.01
  bajo = 0.0
  alto = max(1.0, objetivo)
  respuesta = (alto + bajo) / 2

  while abs(respuesta**2 - objetivo) >= epsilon:
    if respuesta**2 < objetivo:
      bajo = respuesta
    else:
      alto = respuesta
    respuesta = ( alto + bajo ) / 2
  print(f'La raiz cuadrada de {objetivo} es {respuesta}')

#PROGRAMA PRINCIPAL
opcion = int(input('BIENVENIDO AL PROGRAMA DE CALCULO DE RAIZ CUADRADA...\n Selecciona una forma de calculo:\n 1 .- Calcular por Enumeración Exhaustiva\n 2 .- Calcular por Aproximación\n 3 .- Calcular por Busqueda Binaria... '))
if opcion >= 1 and opcion <= 3:
  numero = int( input('Teclea un número para calcular la raiz cuadrada... ') )
  print(f'Calculando raiz para {numero}, espere un momento...')
  if opcion == 1:
    enumeracion_exhaustiva(numero)
  elif opcion == 2:
    aproximacion(numero)
  elif opcion == 3:
    busqueda_binaria(numero)
else:
  print(f'La opción {opcion} es inválida!')

Mi solucion al reto:

def raizCuadrada(option, numero):
    if option == 1:
        objetivo = numero
        respuesta = 0
        while respuesta**2 < objetivo:
            respuesta += 1
        if respuesta**2 == objetivo:
            print(f'La raíz cuadrada de {objetivo} es {respuesta}.')
        else:
            print(f'{objetivo} no tiene raíz cuadrada exacta.')
    elif option == 2:
        objetivo = numero
        epsilon = 0.01
        paso = epsilon**2
        respuesta = 0.0
        while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
            print(abs(respuesta**2 - objetivo), respuesta)
            respuesta += paso
        if abs(respuesta**2 - objetivo >= epsilon):
            print(f'No se encontro la raíz cuadrada {objetivo}')
        else:
            print(f'La raíz cuadrada de {objetivo} es {respuesta}')
    elif option == 3:
        objetivo = numero
        epsilon = 0.001
        bajo = 0.0
        alto = max(1.0, objetivo)
        respuesta = (alto + bajo) / 2
        while abs(respuesta**2 - objetivo) >= epsilon:
            print(f'bajo = {bajo}, alto = {alto}, respuesta = {respuesta}')
            if respuesta**2 < objetivo:
                bajo = respuesta
            else:
                alto = respuesta
            respuesta = (alto + bajo) / 2
        print(f'La raíz cuadrada de {objetivo} es {respuesta}')
    else:
        print('Opcion no válida')

numero = int(input('Escoga un numero: '))
option = int(input('1) Solo saber si tiene raiz cuadrada exacta\n2) Saber paso por paso su raiz cuadrada\n3) Aplicar el algoritmo de busqueda binaria para encontrar la raiz cuadrada\n'))
raizCuadrada(option, numero)

Mi aporte al reto 😃

def enumeracion_exhaustiva(objetivo):
    respuesta=0

    while respuesta**2 < objetivo:
        respuesta += 1
    
    if respuesta**2 == objetivo:
        print(f'La raiz cuadrada de {objetivo} es {respuesta}')
    else:
        print(f'{objetivo} no tien raiz cuadrada exacta')

def aprox_soluciones(objetivo):
    epsilon = 0.01
    paso = epsilon**2
    respuesta = 0.0

    while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
        respuesta += paso

    if abs(respuesta**2-objetivo) >= epsilon:
        print(f'No se encontro la raiz cuadrada de {objetivo}')
    else:
        print(f'La raiz cuadrada de {objetivo} es {respuesta}')

def busqueda_binaria(objetivo):
    epsilon = 0.01
    bajo = 0.0
    alto = max(1.0, objetivo)
    respuesta = (alto + bajo)/2

    while abs(respuesta**2 - objetivo) >= epsilon:
        if respuesta**2 < objetivo:
            bajo = respuesta
        else:
            alto = respuesta 

        respuesta = (alto+bajo) / 2

    print (f'La raiz cuadrada de {objetivo} es {respuesta}')

def run():
    print('CALCULAR RAIZ CUADRADA')
    objetivo=int(input('Escoge un número: '))
    print('ALGORITMOS: 1. Enumeración exaustiva, 2. Aproximación de soluciones, 3. Búsqueda binaria')
    algoritmo=int(input('Seleccione el algoritmo que desea utilizar:'))
    
    if algoritmo==1:
        enumeracion_exhaustiva(objetivo)
    elif algoritmo==2:
        aprox_soluciones(objetivo)
    elif algoritmo==3:
        busqueda_binaria(objetivo)
    else:
        print('Selección Incorrrecta! Empezamos de nuevo...')
        run()
       

if __name__=='__main__':
    run()```

Hola, aquí mi respuesta al reto:

# DEFINICION DE LAS FUNCIONES.

#-------------------- enumeracion exhaustiva -----------------------------

def enumeracionExhaustiva(objetivo):

    resultado = 0

    while resultado**2 < objetivo :
        resultado += 1

    if resultado**2 == objetivo:
        return f'{objetivo} tiene raiz cuadrada exacta, y es {resultado}'

    else:
        return f'{objetivo} no tiene raiz cuadrada exacta'

#-------------------- aproximacion de soluciones -----------------------------

def aproximacionDeSoluciones(objetivo):

    epsilon = 0.01
    paso = epsilon**2
    respuesta = 0.0
    i = 0 # contador de iteraciones

    while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
        respuesta += paso
        i +=1
        #print(f'{abs(respuesta**2 - objetivo)} {respuesta}')

    if abs(respuesta**2 - objetivo) >= epsilon:

        return f'No se encontro la raiz cuadrada {objetivo}, con {i} iteraciones'

    else:
        return f'La raiz cuadrada del {objetivo} es aprox. {respuesta}, con {i} iteraciones'


#-------------------- busqueda binaria -----------------------------

def busquedaBinaria(objetivo):

    epsilon = 0.01
    bajo =0.0
    alto = max(1.0,objetivo)
    respuesta= (alto + bajo)/2
    i =0 # contador

    while abs(respuesta**2 - objetivo) >= epsilon:
	
	    i +=1
	    #print(f' bajo = {bajo}, alto = {alto},   respuesta = {respuesta}')
	
	    if respuesta**2 < objetivo :
		    bajo = respuesta
	    else:
		    alto = respuesta
		
	    respuesta = (alto + bajo)/2
	
    return f' La raiz cuadrada de {objetivo} es {respuesta}, con {i} iteraciones'

#----------------------------PROGRAMA PRINCIPAL----------------------------------------

# Opcion 1 : Calcula la raiz cuadrada con el metodo "enumeracion exhaustiva"
# Opcion 2 : Calcula la raiz cuadrada con el metodo "aproximacion de soluciones"
# Opcion 3 : Calcula la raiz cuadrada con el metodo "busqueda binaria"

print(f'1 - Calcula la raiz cuadrada con el metodo enumeracion exhaustiva')
print(f'2 - Calcula la raiz cuadrada con el metodo aproximacion de soluciones')
print(f'3 - Calcula la raiz cuadrada con el metodo busqueda binaria')

opcion = int(input('Ingresa la opcion: '))

if opcion == 1:
    a = int(input('Raiz cuadrada de: '))
    print(f'----------------------------------')
    print(enumeracionExhaustiva(a))
    print(f'----------------------------------')

elif opcion == 2:

    a = int(input('Raiz cuadrada de: '))
    print(f'----------------------------------')
    print(aproximacionDeSoluciones(a))
    print(f'----------------------------------')

elif opcion == 3:

    a = int(input('Raiz cuadrada de: '))
    print(f'----------------------------------')
    print(busquedaBinaria(a))
    print(f'----------------------------------')

else:
    print(f'No es una opcion valida')

Mi solución al reto

Lo primero que hice fue encapsular los algoritmos de las clases anteriores y en el archivo principal importe esos algorimos y llame las funciones de acuerdo a la selecion del usuario

import approximation
import search_binary
import enumation

def inicio():
    print('''
            BIENVENIDO USUARIO

            Que operacion desea usar
            1) Busqueda Binaria
            2) Aproximacion
            3) Enumeracion
    ''')
    option = int(input(': '))

    if option==1:
        search_binary.busqueda_binaria()
    elif option == 2:
        approximation.aproximacion()
    elif option == 3:
        enumation.enumeracion()
    else:
        print('Opcion incorrecta')
        inicio()



if __name__ == '__main__':
    inicio()```

¡Reto resuelto!

def enumeracion_exh():
    objetivo = int(input('Escribe un numero: '))
    respuesta = 0

    while respuesta**2 < objetivo:
        print(respuesta)
        respuesta += 1

    if respuesta**2 == objetivo:
        print(f'La raiz cuadrada de  {objetivo} es {respuesta}')
    else:
        print(f'{objetivo} No tiene raiz cuadrada Exacta')

def aproximacion():
    objetivo = int(input('Escribe un numero: '))
    epsilon = 0.01 #que tan preciso queremos ser 
    paso = epsilon**2 #que tanto nos acercamos en cada iteración
    respuesta = 0.0 #variable que almacenara la respuesta

    while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
        print(abs(respuesta**2 - objetivo), respuesta)
        respuesta += paso

    if abs(respuesta**2 - objetivo) >= epsilon:
        print(f'no se encontro la raiz cuadrada {objetivo}')    
    else:
        print(f'La raiz cuadrada de {objetivo} es {respuesta}')

def busqueda_binaria():
    objetivo = int(input('escoge un numero: '))
    epsilon = 0.01
    bajo = 0.0
    alto = max(1.0, objetivo)
    respuesta = (alto + bajo) / 2

    while abs(respuesta**2 - objetivo ) >= epsilon:
        print(f'bajo={bajo}, alto={alto}, respuesta={respuesta}, respuesta1={respuesta**2 - objetivo}')
        if respuesta**2 < objetivo:
            bajo = respuesta
        else:
            alto = respuesta
        respuesta = (alto + bajo ) / 2

    print(f'La raíz cuadrada de {objetivo} es {respuesta}')

print('¡Bienvenido!')
print('¡Calcule la raíz cuadrada de un numero con base a estos algoritmos!\n')
print('1 Enumeracion exhaustiva \n' 
      '2 Aproximación de valores \n'
      '3 Busqueda binaria\n')
num = int(input('Seleccione una opción: '))

if num == 1:
    print('Bienvenido al algoritmo de Enumeración exhaustiva \n')
    enumeracion_exh()
elif num == 2:
    print('Bienvenido al algoritmo de aproximación de valores \n')
    aproximacion()
elif num == 3:
    print('Bienvenido al algoritmo de busqueda binaria \n')
    busqueda_binaria()
else:
    print("No selecciono ninguna de las opciones, vuelva a intentarlo")

Reto

from enumeracion import enumeracion
from aproximacion import aproximacion
from busqueda_bynaria import busqueda_bynaria

print('Selecciona una opcion: \n 1 Ennumeracion \n 2 Aproximacion \n 3 Busqueda Bynaria')
selection = int(input('Que algoritmo deseas usar?: '))
objetivo = int(input('Cual es el valor buscado?: '))

if selection == 1:
    enumeracion(objetivo)
elif selection == 2:
    aproximacion(objetivo)
elif selection == 3:
    busqueda_bynaria(objetivo)
else:
    print('Esa opcion no es valida')```

Mi respuesta (no guarde los primeros dos códigos):

print('''
        Escoje un modo de operacion
        1) Busqueda binaria
        2) Aproximacion

        ''')
option = int(input(': '))

def busqueda_binaria():
    objetivo = int(input('Escoge un numero: '))
    epsilon = 0.001
    bajo = 0.0
    alto = max(1.0, objetivo)
    respuesta = (alto + bajo) / 2

    while abs(respuesta**2 - objetivo) >= epsilon:
        print(f'bajo={bajo}, alto={alto}, respuesta={respuesta}')
        if respuesta**2 < objetivo:
            bajo = respuesta
        else:
            alto = respuesta

        respuesta = (alto + bajo) / 2

    print(f'La raiz cuadrada de {objetivo} es {respuesta}')


def aproximacion():
    objetivo = int(input('Escoje un numero: '))
    epsilon = 0.01
    paso = epsilon**2
    respuesta = 0.0

    while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
        print(respuesta)
        respuesta += paso

    if abs(respuesta**2 - objetivo) >= epsilon:
        print(f'No se encontro la raiz cuadrada del objetivo')
    else:
        print(f'La raiz cuadrada del {objetivo} es {respuesta}')

if option == 1:
    print('Busqueda binaria')
    busqueda_binaria()
elif option == 2:
    print('Aproximacion')
    aproximacion()
else:
    print("Intenta de nuevo")```

#abstraccion = saber para que funciona, y su comportamiento más no su funcionamiento en específico
#Decomposición = dividir el código en componentes, modularidad
import math

def suma (a,b):
    total = a+b
    return total

def raiz_por_enumeración(numero):
    respuesta = 0
    while respuesta**2 < numero:
        respuesta += 1
    return respuesta

def raiz_por_aproximacion(numero):
    respuesta = 0
    epsilon = 0.01
    paso = epsilon**2

    while abs(respuesta**2 - numero) >= epsilon and respuesta <= numero:
        respuesta += paso
    
    return respuesta

def raiz_por_busqueda_binaria(numero):
    epsilon = 0.00001 
    bajo = 0.0
    alto = max(1.0, numero)
    respuesta = (alto + bajo) / 2

    while abs(respuesta**2 - numero) >= epsilon:
        if respuesta**2 < numero:
            bajo = respuesta
        else:
            alto = respuesta
        
        respuesta = (alto + bajo)/2
    return respuesta

def raiz_cuadrada(metodo, numero):
    if metodo == 'E':
        respuesta = raiz_por_enumeración(numero)
    elif metodo == 'A':
        respuesta = raiz_por_aproximacion(numero)
    elif metodo == 'B':
        respuesta = raiz_por_busqueda_binaria(numero)

    printer(respuesta, numero)
    
def printer(respuesta, numero):
    if round(respuesta**2) == numero:
        print(f'la raiz cuadrada de {numero} es  {respuesta}')
    else:
        print(f'{numero} no tiene raiz cuadrada exacta, por favor elija aproximación o busqueda binaria')

numero = int(input('Elije un número: '))
metodo = str.upper(input('Elije el método (E)numeración, (A)proximación, (B)usqueda Binaria: '))
raiz_cuadrada(metodo, numero)

Reto cumplido:

#  Enumeración exhaustiva
def enumerado(objetivo):
	respuesta = 0
	while respuesta**2 < objetivo:
	    respuesta += 1

	if respuesta**2 == objetivo:
	    print(f'La raiz cuadrada de {objetivo} es {respuesta}')
	else:
	    print(f'{objetivo} no tiene una raiz cuadrada exacta')

#  Aproximación de soluciones
def aproximacion(objetivo):
	epsilon = 0.01
	paso = epsilon**2 
	respuesta = 0.0

	while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
	    respuesta += paso

	if abs(respuesta**2 - objetivo) >= epsilon:
	    print(f'No se encontro la raiz cuadrada {objetivo}')
	else:
	    print(f'La raiz cudrada de {objetivo} es {respuesta}')

#  Búsqueda binaria
def busqueda_binaria(objetivo):
	epsilon = 0.0000000000001
	bajo = 0.0
	alto = max(1.0, objetivo)
	respuesta = (alto + bajo) / 2

	while abs(respuesta**2 - objetivo) >= epsilon:
	    if respuesta**2 < objetivo:
	        bajo = respuesta
	    else:
	        alto = respuesta

	    respuesta = (alto + bajo) / 2

	print(f'La raiz cuadrada de {objetivo} es {respuesta}')


# Interfaz
print("""
		Bienvenido

		Para encontrar la raíz cuadrada escoge uno de los siguientes algoritmos:

		1) Enumeración exhaustiva
		2) Aproximación de soluciones
		3) Búsqueda binaria
		""")

# Seleccion de algoritmo
algoritmo = int(input('¿Cual algoritmo quieres utilizar? (1, 2 o 3): '))

if algoritmo == 1:
	print("Usted ha escogido Enumeración exhaustiva")
	enumerado(int(input("Escoge un entero: ")))
elif algoritmo == 2:
	print("Usted ha escogido Aproximación de soluciones")
	aproximacion(int(input("Escoge un entero: ")))
elif algoritmo == 3:
	print("Usted ha escogido Búsqueda binaria")
	busqueda_binaria(int(input("Escoge un entero: ")))
else:
	print("Opción incorrecta, reinicie el programa")

Hola a todos, así lo hice yo. Agradezco si me ayudan con comentarios!

import tkinter as tk
from InputFunciones import *
parentWindow = tk.Tk()
parentWindow.title("Compilación de Curso")
parentWindow.geometry("380x80")


valorDefault = tk.StringVar(parentWindow)

choices = { 'Raiz Cuadrada Entera','Edades','Raiz cuadrada con enumeracion Exhaustiva','Raiz cuadrada con busqueda binaria'}
valorDefault.set('Selecciona por favor') 

popupMenu = tk.OptionMenu(parentWindow, valorDefault, *choices)
tk.Label(parentWindow, text="Escoge uno de los 4 modulos del curso").grid(row = 0, column = 1,padx=95)
popupMenu.grid(row = 1, column =1)

botonSalir= tk.Button(parentWindow, text="salir", command=parentWindow.destroy).grid(row=2,column=1)


def change_dropdown(*args):
        parentWindow.destroy()
        tipoDeFuncion(str(valorDefault.get()))

valorDefault.trace('w', change_dropdown)

parentWindow.mainloop()

Queda así

print("1. Enumeracion | 2. Aproximacion | 3. Busqueda Binaria")
opciones = int(input('Escoge una de las siguientes opciones: '))
objetivo = int(input('Escriba un numero para resolver su raiz cuadrada: '))

if opciones == 1:
    respuesta = 0

    while respuesta**2 < objetivo:
        print(respuesta)
        respuesta += 1

    if respuesta**2 == objetivo:
       print(f'La raiz cuadrada {objetivo} es {respuesta}')
    else:
        print(f'{objetivo} no tiene raiz cuadrada')
elif opciones == 2:
    epsilon = 0.001
    paso = epsilon**2
    respuesta = 0.0
    # abs() devuelve el valor absoluto
    while abs(respuesta**2 - obejetivo) >= epsilon and respuesta <= obejetivo:
        print(abs(respuesta**2-obejetivo), respuesta)
        respuesta += paso
    if abs(respuesta**2 - obejetivo) >= epsilon:
        print(f'No se encontro la raiz cuadrada {obejetivo}')
    else:
        print(f'la raiz cuadrada de {obejetivo} es {respuesta}')
elif opciones == 3:
    epsilon = 0.01
    bajo = 0.0
    alto = max(1.0, objetivo)
    respuesta = (alto + bajo) / 2
    while abs(respuesta**2 - objetivo) >= epsilon:
        print(f'bajo={bajo}, alto={alto}, respuesta={respuesta}')
    if respuesta**2 < objetivo:
        bajo = respuesta
    else:
        alto = respuesta
        respuesta = (alto + bajo) / 2
    print(f'La raiz cuadrada de {objetivo} ws {respuesta}')

def enumeracion(objetivo):
    respuesta = 0
    while respuesta ** 2 < objetivo:
        respuesta += 1

    if respuesta ** 2 == objetivo:
        impresion = f'La raiz cuadrada de {objetivo} es {respuesta}'
    else:
        impresion = f'{objetivo} no tiene una raiz cuadrada exacta'
    
    return impresion

def aproximacion(objetivo):
    epsilon = 0.01
    paso = epsilon ** 2
    respuesta = 0.0

    while abs(respuesta ** 2 - objetivo) >= epsilon and respuesta <= objetivo:
        respuesta += paso

    if abs(respuesta ** 2 - objetivo) >= epsilon:
        impresion = f'No se encontro la raiz cuadrada de {objetivo}'
        
    else:
        impresion = f'La raiz cuadrada de {objetivo} es {respuesta}'

    return impresion

def busqueda_binaria(objetivo):
    epsilon = 0.00001
    bajo = 0.0
    alto = max(1.0, objetivo)
    respuesta = (alto + bajo) / 2

    while abs(respuesta ** 2 - objetivo) >= epsilon:
        
        if respuesta ** 2 < objetivo:
            bajo = respuesta
        else:
            alto = respuesta

        respuesta = (alto + bajo) / 2
    
    impresion = f'La raíz cuadrada de {objetivo} es {respuesta}'

    return impresion


print('Programa para calcular raiz cuadrada')
print('\n')

objetivo = int(input('Ingrese un número: '))

print('Metodos')
print('\n')
print('1. Enumeración exahustiva')
print('2. Aproximación de soluciones')
print('3. Busqueda binaria')

print('\n')
menu = int(input('Ingrese un número acorde al metodo elegido: '))

if menu == 1:
   print('\n')
   print(f'Enumerción exahustiva: {enumeracion(objetivo)}')
elif menu == 2:
    print('\n')
    print(f'Aproximación de soluciones: {aproximacion(objetivo)}')
elif menu == 3:
    print('\n')
    print(f'Busqueda binaria: {busqueda_binaria(objetivo)}')
else:
    print('\n')
    print('Has ingresado un valor que no corresponde con el menu')

def enumeración (): #Función de enumeración
    objetivo = int(input("Escoge un número entero: "))
    respuesta = 0

    while respuesta**2 < objetivo:
     respuesta += 1

    if respuesta**2 == objetivo:
        print(f"La raiz cuadrada de {objetivo} es {respuesta}")
    else:
        print(f"La raiz cuadrada del {objetivo} no es exacta ")
def aproximacion(): # Función de aproximación
    objetivo = int(input("Escoge un número: "))
    epsilon = 0.01  
    paso = epsilon ** 2
    respuesta = 0.0

    while abs(respuesta ** 2 - objetivo) >= epsilon and respuesta <= objetivo:
        print(abs(respuesta ** 2 - objetivo), respuesta)
        respuesta += paso
    if abs(respuesta ** 2 - objetivo) >= epsilon:
        print(f"No se encontro la raiz cuadrada del {objetivo}")
    else:
        print(f"La raiz cuadrada del {objetivo} es {respuesta}")
def busqueda_binaria ():
    objetivo = int(input("Escoge un número: "))  
    epsilon = 0.01  # recordar más exacto más decimales
    bajo = 0.0  # limite inferior
    alto = max(1.0, objetivo)
    respuesta = (alto + bajo) / 2

    while abs(respuesta ** 2 - objetivo) >= epsilon:
        print(f" bajo={bajo}, alto={alto}, respuesta={respuesta}")
        if respuesta ** 2 < objetivo:
            bajo = respuesta
        else:
            alto = respuesta
        respuesta = (alto + bajo) / 2

    print(f"la raiz cuadrada de {objetivo} es {respuesta}") 
def menu ():
    print("Elige el rpoceddimiento que quieres utilizar")
    print()
    print("Los modelos son los siguientes:")
    print("1º Enumeración")
    print("2º Aproximación")
    print("3º Busqueda binaria")

    metodo = int(input("Introduce el nº correspondiente: "))
    if metodo == 1:
        enumeración()
    elif metodo == 2:
        aproximacion()
    elif metodo == 3:
        busqueda_binaria()
    elif not 1 or 2 or 3:
        print("No has elegido un numero dentro de los parametros")
    else:
        print("Continúa")


menu() 

def exhaustiva(valor):
    resultado=0
    while resultado**2 < valor:
        resultado+=1
    if resultado**2==valor:
        print(f'La raiz cuadrada de {valor} es {resultado}')
    else:
        print(f'{valor} no tiene raiz cuadrada exacta')

def aproximacion(valor):
    epsilon = 0.01
    paso = epsilon**2
    resultado = 0    
    while abs(resultado**2 - valor) >= epsilon and resultado <= valor:
        resultado += paso
    if abs(resultado**2 - valor) >= epsilon:
        print(f'Para {valor} no se encontro raiz cuadrada exacta')
    else:
        print(f'La raiz cuadrada de {valor} es {resultado}')

def binaria(valor):
    epsilon=0.01
    bajo=0.0
    alto=max(1.0,valor)
    resultado=(alto + bajo)/2
    while abs(resultado**2 - valor) >= epsilon:
        if resultado**2 > valor:
            alto=resultado
        else:
            bajo=resultado
        resultado=(alto + bajo)/2
    print(f'La raiz cuadrada de {valor} es {resultado}')
    

numero=int(input('Por favor ingresa el numero \n'))
print(f'Tu numero es {numero} \n')
print('Ahora elige uno de los siguientes metodos para hallar la raiz cuadrada: \n')
print('1) Enumeración exhaustiva \n')
print('2) Aproximacion \n')
print('3) Busqueda binaria \n')
algoritmo=int(input('Ingresa el numero del metodo deseado \n'))

if algoritmo == 1:
    exhaustiva(numero)
elif algoritmo == 2:
    aproximacion(numero)
elif algoritmo == 3:
    binaria(numero)    
else:
    print('Opcion no valida')

print('Adios')

def exaustiva():
    objetivo = int(input('Escoge un entero: '))
    respuesta = 0

    while respuesta**2 < objetivo:
        respuesta +=1

    if respuesta**2 == objetivo:
        print(f'La raiz cuadrada de {objetivo} es {respuesta}')
    else:
        print(f'{objetivo} no tiene raiz cuadrada exacta')


def binaria():
    objetivo = int(input('Escoge un numero: '))
    epsilon = 0.01
    bajo = 0.0
    alto = max(1.0, objetivo)
    respuesta = (alto + bajo) / 2

    while abs(respuesta**2 - objetivo) >= epsilon:
        print(f'bajo= {bajo}, alto= {alto}, respuesta={respuesta} ')
        if respuesta**2 < objetivo:
            bajo = respuesta
        else:
            alto = respuesta
    
        respuesta = (alto + bajo) / 2

    print(f'La raiz cuadrada del {objetivo} es {respuesta}')    



def aproximacion():

    objetivo = int(input('Elige un número: '))
    epsilon = 0.01
    paso = epsilon**2
    respuesta = 0.0

    while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
        print(abs(respuesta**2 - objetivo), respuesta)
        respuesta += paso

    if abs(respuesta**2 - objetivo) >= epsilon:
        print(f'No se encontró la raíz cuadrada de {objetivo}')
    else:
        print(f'La raíz cuadrada de {objetivo} es {respuesta}')

def menu ():
    print ('Que mètodo quieres usar para hallar tu raiz cuadrada?')
    print ('1) Enumeración exaustiva' )
    print ('2) Busqueda binaria' )
    print ('3) Aproximación de soluciones')
    metodo = int(input('Elige una opción: '))

    if metodo == 1:
        exaustiva()
    elif metodo == 2:
        binaria()
    elif metodo == 3:
        aproximacion()
    else:
        print('Escoge otro no te pases')
    menu()
if __name__ == '__main__':
    menu()

[4:20] Definición de funciones: siempre comienzan con el keyword def que significa definición, seguido del nombre que le pondremos a la función y los parametros entre parentesis seguido de dos puntos.

objetivo = int(input('Escoge un entero: \n'))
tipoCalculo = int(input('Elige el método de calculo de raís, INGRESA EL NUMERO CORREPONDIENTE \n 1 Para Enumeracion \n 2 Para Búsqueda Binaria \n 3 Para Aproximación \n Luego pulsa ENTER:\n'))


def enumeracion(objetivo):
    respuesta = 0
    while respuesta**2 < objetivo:
        respuesta += 1
    if respuesta**2 == objetivo:
        return print(f'La raiz cuadrada de {objetivo} es {respuesta}\n')
    else:
        return print(f'{objetivo} no tiene raiz cuadrada exacta\n')

def busquedaBinaria(objetivo):
    epsilon = 0.001
    bajo = 0.0
    alto = max(1.0,objetivo)
    respuesta = ((alto +bajo) / 2)

    while abs(respuesta**2 - objetivo) >= epsilon:
        if respuesta**2 < objetivo:
            bajo = respuesta
        else:
            alto = respuesta
        respuesta = (alto + bajo) / 2

    return print(f'La rais cuadrada de {objetivo} es {respuesta}\n')

def aproximacion(objetivo):
    epsilon = 0.01
    paso = epsilon**2

    respuesta = 0.0

    while abs(respuesta**2 - objetivo) > epsilon and respuesta <=objetivo:
        respuesta += paso

    if abs(respuesta**2 - objetivo) >= epsilon:
        return print(f'No se encontro la raiz cuadrada del {objetivo} \n')
    else:
        return print(f'La raiz cuadrada del {objetivo} es {respuesta}\n')

print(' ')
print(' ')

while tipoCalculo <= 5:
    # print(tipoCalculo)
    if tipoCalculo == 1:
        print('Esta es la opcion Enumeracion \n')
        enumeracion(objetivo)
        tipoCalculo = 0
        print(' ')
    elif tipoCalculo == 2:
        print('Esta es la opcion de Búsqueda Binaria\n')
        busquedaBinaria(objetivo)
        tipoCalculo = 0
        print(' ')
    elif tipoCalculo == 3:
        print('Esta es la opcion de Aproximacion\n')
        aproximacion(objetivo)
        tipoCalculo = 0
        print(' ')
    elif tipoCalculo == 4:
        print('Salir\n')
        break
    elif tipoCalculo == 5:
        objetivo = int(input('Escoge un nuevo entero: \n'))
        tipoCalculo = 0
        print(' ')
    elif tipoCalculo ==0:
        print('Escoge otra opcion 1, 2 , 3 o pulsa 4 para SALIR')
        tipoCalculo = int(input('Elige el método de calculo de raís, INGRESA EL NUMERO CORREPONDIENTE \n 1 Para Enumeracion \n 2 Para Búsqueda Binaria \n 3 Para Aproximación \n 4 Para SALIR \n 5 Para elegir otro numero \n Luego pulsa ENTER:\n'))
        print(' ')
    else:
        print('Opcion invalida marque por favor 1, 2, 3, 4 o 5')
        print(' ')


print('Gracias por usar este pequeño programa')

Reto:

def enumeracion_exhaustiva(objetivo):
    respuesta = 0

    while respuesta**2 < objetivo:
        respuesta += 1

    if respuesta**2 == objetivo:
        print(f'La raiz de {objetivo} es {respuesta}')
    else:
        print(f'{objetivo} no tiene raiz cuadrada exacta')
    

def aproximacion(objetivo, epsilon):
    paso = epsilon**2
    respuesta = 0.0
    iteraciones = 0

    while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
        respuesta += paso
        iteraciones += 1

    if abs(respuesta**2 - objetivo) >= epsilon:
        print(f'No se encontro raiz cuadrada {objetivo}')
    else:
        print(f'La raiz cuadrada de {objetivo} es {respuesta}')

def busqueda_binaria(objetivo, epsilon):
    bajo = 0.0
    alto = max(1.0, objetivo)
    respuesta = (alto + bajo) / 2

    while abs(respuesta**2 - objetivo) <= epsilon:
        print(f'bajo={bajo}, alto={alto}, respuesta={respuesta}')
        if respuesta**2 < objetivo:
            bajo = respuesta
        else:
            alto = respuesta
        respuesta = (alto + bajo) / 2   

        print(f'La raiz cuadrada de {objetivo} es {respuesta}')  

opcion = int(input(f'Elija el algoritmo de ordenamiento para buscar la raiz cuadrada de su numero \n 1. Enumeracion Exhaustiva \n 2. Aproximacion \n 3. Busqueda Binaria \n'))

if opcion == 1:
    print('1. Enumeracion Exhaustiva')
    numero = int(input('- Digite un numero: '))
    enumeracion_exhaustiva(numero)
elif opcion == 2:
    print('2. Aproximacion')
    numero = int(input('- Digite un numero: '))
    parametro_epsilon = float(input('* Digite un epsilon: '))
    aproximacion(numero,parametro_epsilon)
elif opcion == 3:
    print('3. Busqueda Binaria')
    numero = int(input('- Digite un numero: '))
    parametro_epsilon = float(input('* Digite un epsilon: '))
    busqueda_binaria(numero,parametro_epsilon)
else:
    print('Opcion no valida')```

Al fin me sirvió, no quería ver los demás ejercicios antes de intentarlo yo.

tipo = input('ingrese el nombre del algoritmo que desea ejecutar(enumeracion/aproximacion/binaria): ')
obj = float(input('Ingrese el numero: '))
rta = 0.0
epsilon = 0.01
paso = epsilon**2
bajo = 0.0
alto = max(1.0, obj)
rta_binaria = (alto + bajo) / 2

def enumeracion (obj, rta):
        while rta**2 < obj:
            rta += 1
        if rta**2 == obj:
            print(f'La raíz cuadrada de {int(obj)} es {int(rta)}')
        else:
            print(f'{obj} no tiene una raíz cuadrada exacta')

def aproximacion (obj, rta, epsilon, paso):
    while abs(rta**2 - obj) >= epsilon and rta <= obj:
        rta += paso
    if abs(rta**2 - obj) >= epsilon:
        print(f'No se encontró la raíz cuadrada de {obj}')
    else:
        print(f'La raíz cuadrada de {obj} es {rta}')

def binaria (obj, rta_binaria, epsilon, bajo, alto):
    while abs(rta_binaria**2 - obj) >= epsilon:
        if rta_binaria**2 < obj:
            bajo = rta_binaria
        else:
            alto = rta_binaria
        rta_binaria = (alto + bajo) / 2
    print(f'La raíz cuadrada de {obj} es {rta_binaria}')

if tipo == 'enumeracion':
    enumeracion(obj, rta)
elif tipo == 'aproximacion':
    aproximacion(obj, rta, epsilon, paso)
elif tipo == 'binaria':
    binaria(obj, rta_binaria, epsilon, bajo, alto)
else:
    print('Elige un algoritmo válido.') ```

Definición de funciones

Llamado de funciones

Ejecución

def raizCuadradaExacta():
    objetivo=int(input('Ingresa un enetero: '))
    respuesta=0
    while respuesta**2<objetivo:
        respuesta+=1
    if respuesta**2==objetivo:
        print(f'La raíz cuadrada de objetivo es {respuesta}')
    else:
        print('El objetivo no tiene una raíz cuadrada exacta')

def raizCuadradaAproximada():
    objetivo=int(input('Ingresa un número: '))
    epsilon=0.01
    paso=epsilon**2
    respuesta=0.0
    num=0
    while abs(respuesta**2-objetivo)>=epsilon and respuesta<=objetivo:
        print(respuesta**2-objetivo, respuesta)
        respuesta+=paso
        num+=1
    if abs(respuesta**2-objetivo)>=epsilon:
        print(f'No se encontro la raíz cuadrada del objetivo')
    else:
        print(f'La raíz cuadrada de {objetivo} es {respuesta}')

def raizCuadradaBusquedaBinaria():
    objetivo=int(input('Ingresa un número: '))
    epsilon=0.01
    bajo=0.0
    alto=max(1.0,objetivo)
    respuesta=(alto+bajo)/2
    while abs(respuesta**2-objetivo)>=epsilon:
        print(f'bajo: {bajo}, alto: {alto}, respuesta: {respuesta}')
        if respuesta**2<objetivo:
            bajo=respuesta
        else:
            alto=respuesta
        respuesta=(alto+bajo)/2
    print(f'La raíz cuadrada de {objetivo} es {respuesta}')

opc=0
while opc!=4:
    print('1.- Calcular la raíz cuadrada exacta de un número')
    print('2.- Calcular la raíz cuadrada aproximada de un número')
    print('3.- Calcular la raíz cuadrada a través de buqueda binaria')
    print('4.- Salir')
    opc=int(input('Ingresa una opción del menú: '))
    if opc==1:
        raizCuadradaExacta()
    elif opc==2:
        raizCuadradaAproximada()
    elif opc==3:
        raizCuadradaBusquedaBinaria()
    else:
        break

def enumeracion():
    
    objetivo = int(input(' \n Digita el numero que deseas hallarle la raiz: '))
    respuesta = 0

    while respuesta**2 < objetivo:
        respuesta += 1

    if respuesta**2 == objetivo:
        print(f'\n La raiz cuadrada de {objetivo} es {respuesta} \n')
    else:
        print(f'\n {objetivo} no tine raiz cuadrada exacta \n')


def aproximacion():

    objetivo = int(input(' \n Digita el numero que deseas hallarle la raiz: '))
    epsilon = 0.01
    paso = epsilon**2
    respuesta = 0.0

    while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
        respuesta += paso

    if abs(respuesta**2 - objetivo) >= epsilon:
        print(f'\n No se encontro la raiz cuadrada de {objetivo} \n ')
    else:
        print(f'\n La raiz cuadrada de {objetivo} es {respuesta} \n ')


def bus_bin():

    objetivo = int(input(' \n Digita el numero que deseas hallarle la raiz: '))
    epsilon = 0.01
    bajo = 0.0
    alto = max(1.0, objetivo)
    respuesta = (alto + bajo) / 2

    while abs(respuesta**2 - objetivo) >= epsilon:
        if respuesta**2 < objetivo:
            bajo = respuesta
        else:
            alto = respuesta

        respuesta = (alto + bajo) / 2

    print(f'\n La raiz cuadrada de {objetivo} es {respuesta} \n ')

while True:
    opcion = int(input('\n Que algoritmo deseas utilizar? \n \n 1. Enumeracion. \n 2. Aproximacion. \n 3. Busqueda Binaria. \n 4. Salir. \n \n Opcion: '))
    
    if opcion == 1:
        enumeracion()

    elif opcion == 2:
        aproximacion()

    elif opcion == 3:
        bus_bin()

    elif opcion == 4:
        print('\n Espero haberte ayudado!')
        break

    else:
        print('\n Escoge un opcion valida. \n')```

def enumeracion(objetivo):
    respuesta = 0

    while respuesta**2 < objetivo:
        respuesta += 1
    if respuesta**2 == objetivo:
        return respuesta
    else:
        print(f'{objetivo} no tiene una raíz cuadrada exacta')

def aproximacion(objetivo):
    epsilon = 0.01
    paso = epsilon**2 
    respuesta = 0.0

    while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo :
        respuesta += paso

    if abs(respuesta**2 - objetivo) >= epsilon:
        print(f'No se encontró la raíz cuandrada de {objetivo}')
    else:
        return respuesta

def busqueda_binaria(objetivo):
    epsilon = 0.0001
    bajo = 0.0
    alto = max(1.0, objetivo)
    respuesta = (alto + bajo) / 2

    while abs(respuesta**2 - objetivo) >= epsilon:
        if respuesta**2 < objetivo:
            bajo = respuesta
        else:
            alto = respuesta
        
        respuesta = (alto + bajo) / 2

    return respuesta

def resultado(objetivo, respuesta):
    print(f'La raiz cuadrada de {objetivo} es {respuesta}')

objetivo = int(input('salutaciones excelso usuario, por favor digite un número entero: '))
selector = input('¿qué método para hayar la raíz cuadrada desea usar, seleto usuario?\n a. Por enumeración exaustiva\n b. Por aproximación\n c. Por busqueda binaria\n')

if selector == 'a' or selector == 'Por enumeración' or selector == 'a. Por enumeración':
    enumeracion(objetivo)
    respuesta = enumeracion(objetivo)
elif selector == 'b' or selector == 'Por aproximación' or selector == 'a. Por aproximación':
    aproximacion(objetivo)
    respuesta = aproximacion(objetivo)
elif selector == 'c' or selector == 'Por busqueda binaria' or selector == 'a. Por busqueda binaria':
    busqueda_binaria(objetivo)
    respuesta = busqueda_binaria(objetivo)
else:
    print('¡Oh! me parece que no ha seleccionado una opción valida, excelso usuario')

resultado(objetivo, respuesta)

Cualquier observacion es bien recibida 😃

def aproximacion():

    objetivo = int(input('Escoge un numero: '))
    epsilon = 0.01
    paso = epsilon**2
    respuesta = 0.0

    while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
        respuesta += paso

    if abs(respuesta**2 - objetivo) >= epsilon:
        print(f'No se encontro la raiz cuadrada de {objetivo}.')
    else:
        print(f'La raiz cuadrada de {objetivo} es {respuesta}.')

def busqueda_binaria():

    objetivo = int(input('Escoge un numero: '))
    epsilon = 0.01
    bajo = 0.0
    alto = max(1.0, objetivo)
    respuesta = (alto + bajo) / 2

    while abs(respuesta**2 - objetivo) >= epsilon:

        if respuesta**2 < objetivo:
            bajo = respuesta        
        else:
            alto = respuesta
        
        respuesta = (alto + bajo) / 2
    
    print(f'La raiz cuadrada de {objetivo} es {round(respuesta, 1)}.')

def busqueda_exhaustiva():
    objetivo = int(input('Escoge un numero: '))
    respuesta = 0

    while respuesta**2 < objetivo:

        respuesta += 1
    
    if respuesta**2 == objetivo:
        print(f'La raiz cuadrada de {objetivo} es {respuesta}.')

    else:
        print(f'{objetivo} no tiene raiz cuadrada.')

if __name__ == '__main__':

    while True:
        seleccion = int(input(""" 
         Escoge un algoritmo para hayar una raiz cuadrada:
         [1] - Busqueda exhaustiva.
         [2] - Aproximacion.
         [3] - Busqueda binaria. 
         respuesta: """))

        if seleccion == 1:
            busqueda_exhaustiva()
        elif seleccion == 2:
            aproximacion()
        elif seleccion == 3:
            busqueda_binaria()
        else:
            print('Comando no valido.')

# Autor: Enrique Avendaño Ardila
# Fecha: 28/06/2020
# Descripción:
#       Respuesta reto tema Funciones y Abstracción
#       Curso de Introducción al Pensamiento Computacional con Python
#       Instruido por: David Aroesti
#       https://platzi.com/clases/python-cs/

import datetime
import os

def main(_objetivo_):
    limpiarPantalla()
    _metodo_ = entrarEntero(f'''Calcular la raíz cuadrada de {_objetivo_}\n
    Métodos Disponibles
        [1] Enumeración Exhaustiva.
        [2] Aproximación de soluciones.
        [3] Busqueda binaria.
    Seleccionar método para el cálculo: ''')
    limpiarPantalla()

    if _metodo_ == 1:
        exhaustiva(_objetivo_)
    elif _metodo_ == 2:
        aproximacion(_objetivo_)
    elif _metodo_ == 3:
        binaria(_objetivo_)
    else:
        print(f'No se ha definido método con valor {_metodo_}. Reintente nuevamente')
        _metodo_ = input(f'')
        main(_objetivo_)

def exhaustiva(_objetivo_):
    _respuesta_ = 0
    _iteraciones_ = 0
    _hora_inicial_ = datetime.datetime.now()

    while _respuesta_**2 < _objetivo_:
        _respuesta_ += 1
        _iteraciones_ +=1
    _hora_final_ = datetime.datetime.now()
    _tiempo_total_ = _hora_final_ - _hora_inicial_
 
    if _respuesta_**2 == _objetivo_:
        print(f'{_respuesta_} es la raiz cuadrada de {_objetivo_}. Se cálculo en {_iteraciones_} iteraciones, con duración {_tiempo_total_.total_seconds()} segundo(s)')
    else:
        print(f'El número {_objetivo_} no tiene raiz cuadrada exacta. Se cálculo en {_iteraciones_} iteraciones, con duración {_tiempo_total_.total_seconds()} segundo(s)')
    _objetivo_ = input(f'... presione cualquier tecla para continuar ...')

def aproximacion(_objetivo_):
    _epsilon_ = 0.01
    _paso_ = _epsilon_ **2 
    _respuesta_ = 0.0
    _iteraciones_ = 0
    _hora_inicial_ = datetime.datetime.now()
    while abs(_respuesta_**2 - _objetivo_) >= _epsilon_  and _respuesta_ <= _objetivo_:
        # print(abs(_respuesta_ **2 - _objetivo_), _respuesta_) #No habilitado
        _respuesta_ += _paso_ 
        _iteraciones_ += 1
    _hora_final_ = datetime.datetime.now()
    _tiempo_total_ = _hora_final_ - _hora_inicial_

    if abs(_respuesta_**2 - _objetivo_) >= _epsilon_ :
        print(f'No se encontró la ráiz cuadrada de {_objetivo_}. Se cálculo en {_iteraciones_} iteraciones, con duración {_tiempo_total_.total_seconds()} segundo(s)')
    else:
        print(f'{round(_respuesta_,2)} es la raíz cuadrada de {_objetivo_} con una epsilón de {_epsilon_}. Se cálculo en {_iteraciones_} iteraciones, con duración {_tiempo_total_.total_seconds()} segundo(s)')
    _objetivo_ = input(f'... presione cualquier tecla para continuar ...')

def binaria(_objetivo_):
    _epsilon_  = 0.001
    _bajo_ = 0.0
    _alto_ = max(1.0, _objetivo_)
    _respuesta_ = (_alto_ + _bajo_) / 2
    _iteraciones_ = 0
    _hora_inicial_ = datetime.datetime.now()
    while abs(_respuesta_**2 - _objetivo_) >= _epsilon_ :
        print(abs(_respuesta_ **2 - _objetivo_), _respuesta_)
        if _respuesta_**2 < _objetivo_:
            _bajo_ = _respuesta_
        else:
            _alto_ = _respuesta_
        _respuesta_ = (_alto_ + _bajo_) / 2
        _iteraciones_ += 1
    _hora_final_ = datetime.datetime.now()
    _tiempo_total_ = _hora_final_ - _hora_inicial_
    print(f'{round(_respuesta_,2)} es la raíz cuadrada de {_objetivo_} con una epsilón de {_epsilon_}. Se cálculo en {_iteraciones_} iteraciones, con duración {_tiempo_total_.total_seconds()} segundo(s)')
    _objetivo_ = input(f'... presione cualquier tecla para continuar ...')

def limpiarPantalla(): #Definimos la función estableciendo el nombre que queramos
    if os.name == "posix":
        os.system ("clear")
    elif os.name == "ce" or os.name == "nt" or os.name == "dos":
        os.system ("cls")

def entrarEntero(message):
    while True:
        try:
            _entradaUsuario_ = int(input(message))       
        except ValueError:
            limpiarPantalla()
            print("!Se requiere un número entero!\nPresione cualquier tecla para intentar nuevamente...")
            _entradaUsuario_ = input(f'')
            limpiarPantalla()
            continue
        else:
            return _entradaUsuario_

if __name__ == "__main__":
    _objetivo_ = 1
    while _objetivo_ != 0:
        limpiarPantalla()
        _objetivo_ = 0
        _objetivo_ = entrarEntero('N° al cual desea calcular raiz cuadrada: (cero "0" para Salir) ')
        if _objetivo_ != 0:
            main(_objetivo_)

Saludos!
Esta tarea me tomó mucho tiempo, creo que me toca sentarme un ratico para entender bien el código, agradezco todas las recomendaciones.

numero = int(input('De cual numero deseas hallar la raiz cuadrada? '))
metodos = {'a' : 'Enumeracion Exhaustiva', 'b' : 'Aproximacion de Soluciones' , 'c' : 'Busqueda Binaria'}
metodo = input('Selecciona el metodo de calculo, a: Enumeracion Exhaustiva; b: Aproximacion de Soluciones; c; Busqueda Binaria:  ')
respuesta = 0

epsilon = 0.01
paso = epsilon**2
respuesta_epsilon = 0.0
bajo = 0.0
alto = max(1.0, numero)
respuesta_binaria = (alto - bajo) / 2

if metodo == 'a':

	while respuesta **2 < numero:
		respuesta += 1

	if respuesta **2 == numero:
		print(f'La raiz cuadrada de {numero} calculada por el metodo de {metodos[metodo]} es {respuesta}')
	
	else:
		print(f'El {numero} no tiene una raiz cuadrada exacta')


elif metodo == 'b':

	while abs(respuesta_epsilon**2 - numero) >= epsilon and respuesta_epsilon <= numero:
		respuesta_epsilon += paso
				
	if abs(respuesta_epsilon**2 - numero) >= epsilon:
		print(f'No se encontro la raiz cuadrada de {numero} calculada por el metodo de {metodos[metodo]}')

	else:
		print(f'La raiz cuadrada de {numero} calculada por el metodo de {metodos[metodo]} es {respuesta_epsilon}')


else:
	
	while abs(respuesta_binaria**2 - numero) >= epsilon:
		if respuesta_binaria**2 < numero:
			bajo = respuesta_binaria
		else:
			alto = respuesta_binaria
			
		respuesta_binaria = (alto + bajo) / 2

	print(f'La raiz cuadrada de {numero} calculada por el metodo de {metodos[metodo]} es {respuesta_binaria}')

Aquí le dejo mi código, cualquier comentario que tenga me gustaría saber, criticas constructivas.

def ejecutar():
    while True:
        opcion = int(input('Opcion:1)-Enumeracion Exhaustiva,(2)-Aproximacion, (3)-Binario, coloque una opcion del 1 al 3 y (4) para SALIR: '))
        if opcion == 1:
            enumeraExhaustiva()
        elif opcion == 2:
            aproximacion()
        elif opcion == 3:
            busqBinaria()
        elif opcion == 4:
            break
        else:
            print('Coloque una opcion del 1 al 3 el numero que coloco es Incorrecto o si desea salir el 4')


def enumeraExhaustiva():
    objetivo = int(input('Coloque un numero Entero: '))
    respuesta = 0
    while respuesta**2 < objetivo:
        respuesta += 1
    if respuesta**2 == objetivo:
        print(f'La raiz cuadrada de {objetivo} es {respuesta}')
    else:
        print(f'{objetivo} no tiene una raiz cuadrada exacta')

def aproximacion():
    objetivo = int(input('Coloque un numero Entero: '))
    epsilon = 0.01
    paso = epsilon**2
    respuesta = 0.0
    while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
        print(abs(respuesta**2 - objetivo), respuesta)
        respuesta += paso
    if abs(respuesta**2 - objetivo) >= epsilon:
        print(f'No se encontro la raiz cuadrada {objetivo}')
    else:
        print(f'La raiz cudrada de {objetivo} es {respuesta}')

def busqBinaria():
    objetivo = int(input('Coloque un numero Entero: '))
    epsilon = 0.01
    bajo = 0.0
    alto = max(1.0, objetivo)
    respuesta = (alto + bajo) / 2
    while abs(respuesta**2 - objetivo) >= epsilon:
        print(f'bajo={bajo}, alto={alto}, respuesta={respuesta}')
        if respuesta**2 < objetivo:
            bajo = respuesta
        else:
            alto = respuesta
        respuesta = (alto + bajo) / 2
    print(f'La raiz cuadrada de {objetivo} es {respuesta}')

if __name__ == '__main__':
    ejecutar()````

Aquí esta mi código, el cual te dice el tiempo que demora en cada una de las opciones:

import time


def opciones():
    opcion = int(input("""
Escoge el método para encontrar la raiz cuadrada de un número:

1. Enumeración (lento pero seguro)
2. Aproximación (lento pero preciso)
3. Busqueda Binaria (Eficiente y rápido)

Escoja una opción:  """))
    numero = int(input("Escoja un número: "))
    if opcion == 1:
        enumeracion(numero)
    elif opcion == 2:
        aproximacion(numero)
    elif opcion == 3:
        busqueda_binaria(numero)
    else:
        print("Escoja entre un número de 1, 2 o 3")

def enumeracion(objetivo):

    respuesta = 0

    tiempo_inicial = time.time()


    while respuesta**2 < objetivo:
        respuesta += 1

    if respuesta**2 == objetivo:
        print(f"La raiz cuadrada de {objetivo} es {respuesta}")
    else:
        print(f"{objetivo} no tiene raiz cuadrada exacta")

    print(f"El programa demoró {time.time() - tiempo_inicial} segundos")



def aproximacion(objetivo):
    epsilon = 0.01
    paso = epsilon**2
    respuesta = 0.0

    tiempo_inicial = time.time()

    while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
        respuesta += paso
    
    if abs(respuesta**2 - objetivo) >= epsilon:
        print(f"No se encontró la raiz cuadrada de {objetivo}")
    else:
        print(f"La raiz cuadrada de {objetivo} es {respuesta}")
    print(f"El programa demoró {time.time() - tiempo_inicial} segundos")


def busqueda_binaria(objetivo):
    epsilon = 0.0001
    bajo = 0.0
    alto = max(1.0, objetivo)
    respuesta = (alto+bajo)/2

    tiempo_inicial = time.time()

    while abs(respuesta**2 - objetivo) >= epsilon:
        if respuesta**2 < objetivo:
            bajo = respuesta	
        else:
         alto = respuesta

        respuesta = (alto+bajo) / 2

    print(f"La raiz cuadrada de {objetivo} es {respuesta}")
    print(f"El programa demoró {time.time() - tiempo_inicial} segundos")

opciones()```

las respuestas se ven de esta manera:

Escoge el método para encontrar la raíz cuadrada de un número:

1. Enumeración (lento pero seguro)
2. Aproximación (lento pero preciso)
3. Búsqueda Binaria (Eficiente y rápido)

Escoja una opción: 3
Escoja un número: 158
La raíz cuadrada de 158 es 12.56980848312378
El programa demoró 0.0 segundos```

Les dejo mi resolución, escucho sugerencias:

def aprox(objetivo, epsilon):
    paso = epsilon**2
    respuesta = 0.0

    while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
        respuesta += paso
    if abs(respuesta**2 - objetivo) >= epsilon:
        print(f'No se encontró la raiz cuadrada de {objetivo}')
    else:
        print(f'La raíz cuadrada de {objetivo} es {respuesta}')


def binaria(objetivo, epsilon):
    bajo = 0.0
    alto = max(1.0, objetivo)
    respuesta = (alto + bajo) / 2

    while abs(respuesta**2 - objetivo) >= epsilon:
        if respuesta**2 < objetivo: 
            bajo = respuesta
        else:
            alto = respuesta
        respuesta = (alto + bajo) / 2

    print(f'La raíz cuadrada de {objetivo} es {respuesta}')


def enumeracion(objetivo):
    respuesta = 0

    while respuesta**2 < objetivo:
        respuesta += 1
    if respuesta**2 == objetivo:
        print(f'La raíz cuadrada de {objetivo} es {respuesta}')
    else:
        print(f'{objetivo} no tiene una raíz cuadrada exacta')


def run():
    print("""BIENVENIDOS
    ELIJA UN MODELO PARA CALCULAR LA RAIZ CUADRADA DE UN NÚMERO (márgen de error: 0.01):
    1 - APROXIMACIÓN
    2 - BÚSQUEDA BINARIA
    3 - ENUMERACIÓN EXHAUSTIVA""")
    
    objetivo = int(input('Escoge un número entero: '))
    epsilon = 0.01
    modelo = int(input('Escoge un modelo: '))
    if modelo == 1:
        aprox(objetivo, epsilon)
    elif modelo == 2:
        binaria(objetivo, epsilon)
    elif modelo == 3:
        enumeracion(objetivo)
    else:
        print('No es una opción válida')
    
    
if __name__ == "__main__":
    run()```

Dejo mi reto 🤓,

def enumeracion(objetivo):
    respuesta = 0

    while respuesta**2 < objetivo:
        print(respuesta)
        respuesta += 1

    if respuesta**2 == objetivo:
        print(f'La raiz cuadrada de {objetivo} es {respuesta}')
    else:
        print(f'{objetivo} no tiene una raiz cuadrada exacta')

def aproxima(objetivo):
    epsilon = 0.01
    paso = epsilon**2 
    respuesta = 0.0

    while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
        print(abs(respuesta**2 - objetivo), respuesta)
        respuesta += paso

    if abs(respuesta**2 - objetivo) >= epsilon:
        print(f'No se encontro la raiz cuadrada {objetivo}')
    else:
        print(f'La raiz cudrada de {objetivo} es {respuesta}')
    
def binaria(objetivo):
    epsilon = 0.01
    bajo = 0.0
    alto = max(1.0, objetivo)
    respuesta = (alto + bajo) / 2

    while abs(respuesta**2 - objetivo) >= epsilon:
        print(f'bajo={bajo}, alto={alto}, respuesta={respuesta}')
        if respuesta**2 < objetivo:
            bajo = respuesta
        else:
            alto = respuesta

        respuesta = (alto + bajo) / 2

    print(f'La raiz cuadrada de {objetivo} es {respuesta}')

def run():
    margen('🟥')
    objetivo = int(input('Escoge un numero: '))
    margen('🟥')
    eleccion = int(input('Escoge un sistema para resolver la raiz cuadrada: 1 - Enumeración Exhaustiva | 2 - Aproximación | 3 - Búsqueda Binaria : '))
    
    if eleccion == 1:
        enumeracion(objetivo)
    elif eleccion == 2:
        aproxima(objetivo)
    elif eleccion == 3:
        binaria(objetivo)
    else:
        print(f'Escoge un número entero, {objetivo} no cumple con las indicaciones')

def margen(emoji): #Para no repetir tanto el margen
    print('')
    print('*' * 10, emoji, '*' * 10)
    print('')

margen('🏁')
print(f'Este programa es para calcular la raiz cuadra con diferentes métodos')
margen('🏁')
run()

Esta es mi solución al reto de encapsular los algoritmos pasados para calcular raíces.

def enumerac_exaustiva (objetivo):
    respuesta=0
    while respuesta**2 < objetivo:
        respuesta += 1
    if respuesta**2 == objetivo:
        print(f'La raiz cuadrada de {objetivo} es {respuesta}')
    else:
        print(f'{objetivo} no tiene raiz cuadrada exacta')

def aproxima_solu (objetivo):
    epsilon =0.01
    paso = epsilon**2
    respuesta =0.0
    while abs(respuesta**2-objetivo) >= epsilon and respuesta <= objetivo:
        respuesta += paso
    if abs(respuesta**2-objetivo) >=epsilon:
        print(f'no se encontro raiz cuadrada de {objetivo}')
    else:
        print(f'la raiz cuadrada de {objetivo} es {respuesta}')

def busqueda_binaria (objetivo):
    epsilon=0.01
    bajo=0.0
    alto=max(1.0,objetivo)
    respuesta=(alto+bajo)/2
    while abs(respuesta**2 - objetivo) >=epsilon:
        if respuesta**2 < objetivo:
            bajo=respuesta
        else:
            alto=respuesta
        respuesta=(alto+bajo)/2
    print (f'la raiz cuadrada de {objetivo} es {respuesta}')        


for i in range(1,5):
    print('CALCULADORA DE RAIZ CUADRADA:\n')
    print('Metodos:\n a:enumeracion exahustiva\n b:aproximacion de solucion\n c:busqueda binaria')
    metodo=input('\nEscoge el metodo para calcular la raiz cuadrada: ')
    metodo=metodo.lower()
    tupla=('a','b','c')
    if not metodo in tupla:
        print('Opcion no valida\n')
        continue
    number=int(input('Introduce un numero entero: '))
    
    if metodo =='a':     
        enumerac_exaustiva (number)
    elif metodo == 'b':
        aproxima_solu (number)
    else:
        busqueda_binaria(number)
    print('\n')

Esta es mi solucion al reto, es un codigo que encapsula los algoritmos antes visto en funciones como se pide y ademas tiene un bucle while que permite aplicar los tres algorimos para encontrar la solucion y poder comparar los resultados.

def busquedaBinaaria(objetivo):
    '''En esta funcion se encapsula el algoritmo de busqueda binaria que definimos en clases anteriores'''
    epsilon = 0.01
    bajo = 0.0
    alto = max(1.0, objetivo)
    respuesta = ( alto + bajo ) / 2

    while abs(respuesta ** 2 - objetivo) >= epsilon:
        if respuesta ** 2 < objetivo:
            bajo = respuesta
        else:
            alto = respuesta
        respuesta = ( alto + bajo ) / 2
    return respuesta

def aproxSoluciones(objetivo):
    '''En esta funcion se encapsula el algoritmo de aproximacion de soluciones que definimos en clases anteriores'''
    epsilon = 0.01
    paso = epsilon ** 2
    respuesta = 0.0

    while abs(respuesta ** 2 - objetivo) >= epsilon and respuesta <= objetivo:
        respuesta += paso

    if abs(respuesta ** 2 - objetivo) >= epsilon:
        print(f'no se encontro la raiz cuadrada de {objetivo}') 
    else:
        return respuesta
    return

def enumeracionExhaustiva(objetivo):
    '''En esta funcion se encapsula el algoritmo de enumeracion exaustiva que definimos en clases anteriores'''
    respuesta = 0

    while respuesta ** 2 < objetivo:
        respuesta += 1 
    if respuesta ** 2 == objetivo:
        return respuesta
    else:
        print(f' {objetivo} no tiene raiz cuadrada exacta')
    return

# print(enumeracionExhaustiva(4))

# print(aproxSoluciones(17))



# print(busquedaBinaaria(19.5))

objetivo = int(input('Elige un numero: '))

print('1 = enumeracion exhaustiva\n2 = aproximacion de resultado\n3 = busqueda binaria\n0 = para salir del programa')



while True:
    metodo = int(input('\n Elige un metodo: '))
    if 1 <= metodo <= 3:
        if metodo == 1:
            print(enumeracionExhaustiva(objetivo))
        elif metodo == 2:
            print(aproxSoluciones(objetivo))
        elif metodo == 3:
            print(busquedaBinaaria(objetivo))
    else:
        break

Comparto mi solución al ejercicio propuesto

def metodos():
    metodo = True
    print("*" * 80)
    print("Bienvenido a un programa para obtener raices cuadradas por metodos numericos")
    print("*" * 80)
    while metodo == True:
        opcion = int(input('''
        Por favor, digite el numero del metodo que desea utilizar
          - 1. Para aproximacion por metodo exhaustivo
          - 2. Para aproximacion por metodo de aproximacion de soluciones
          - 3. Para aproximacion por metodo por busqueda binaria
        '''))
        if opcion == 1:
            objetivo = int(input('Escoge un numero al cual determinarle la raiz cuadrada: '))
            exhaustiva(objetivo)
            metodo = False
        elif opcion == 2:
            objetivo = int(input('Escoge un numero al cual determinarle la raiz cuadrada: '))
            aproximacion(objetivo)
            metodo = False
        elif opcion == 3:
            objetivo = int(input('Escoge un numero al cual determinarle la raiz cuadrada: '))
            binaria(objetivo)
            metodo = False
        else:
            print("Por favor, seleccione un digito valido")


def exhaustiva(objetivo):
    respuesta = 0
    while respuesta**2 < objetivo:
        respuesta += 1
    if respuesta**2 == objetivo:
        print(f'La raiz cuadrada de {objetivo} es {respuesta}')
    else:
        print(f'{objetivo} no tiene una raiz cuadrada exacta')
    
def aproximacion(objetivo):
    epsilon = 0.001
    paso = epsilon**2 
    respuesta = 0.0
    while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
        respuesta += paso
    if abs(respuesta**2 - objetivo) >= epsilon:
        print(f'No se encontro la raiz cuadrada {objetivo}')
    else:
        print(f'La raiz cudrada de {objetivo} es {respuesta}')

def binaria(objetivo):
    epsilon = 0.001
    bajo = 0.0
    alto = max(1.0, objetivo)
    respuesta = (alto + bajo) / 2
    while abs(respuesta**2 - objetivo) >= epsilon:
        if respuesta**2 < objetivo:
            bajo = respuesta
        else:
            alto = respuesta
        respuesta = (alto + bajo) / 2
    print(f'La raiz cuadrada de {objetivo} es {respuesta}')
    
metodos()

Este es mi aporte al codigo

import time

print(f'{"-"*10} funciones {"-"*10} \n',
      '1. Escoge un numero. \n',
      '2. Escoge el algoritmo de solucion. \n',
      '--> 1. Enumeracion exhaustiva\n',
      '--> 2. aproximacion de soluciones\n',
      '--> 3. busqueda binaria\n'
      )

objetivo = int(input('ingrese un numero: '))
seleccion_algoritmo = int(input('seleccione un algoritmo: '))


def funcion_enumeracion_exhaustiva(objetivo):
    respuesta = 0
    while respuesta**2 < objetivo:
        respuesta+=1
    
    if respuesta**2 == objetivo:
        return print(f'la raiz de {objetivo} es {respuesta}')
    else:
        return print(f'{objetivo} no tiene raices exactas')

def funcion_aproximacion_soluciones(objetivo, epsion):
    paso = epsion**2
    respuesta = 0.0
    contador = 0
    tiempo_inicio = time.time()
    
    while abs(respuesta**2 - objetivo)>= epsion and respuesta <= objetivo:
        respuesta += paso
        contador +=1
    
    if abs(respuesta**2 - objetivo) >= epsion:
        return print(f'no hay raiz cuadrada del {objetivo}')
    else:
        return print(f'Raiz cuadrada del {objetivo} es {respuesta}\n', f'pasos {contador}\n', 'tiempo de ejecucion es %s segundos' %(time.time() - tiempo_inicio))

def funcion_busqueda_binaria(objetivo, epsilon):
    bajo = 0.0
    alto = max(1.0, objetivo)
    respuesta = (alto + bajo)/2
    contador = 0

    while abs(respuesta**2 - objetivo) >= epsilon:
        print(f'bajo={bajo}, alto={alto}, respuesta={respuesta}')
        if respuesta**2 < objetivo:
            bajo = respuesta
        else:
            alto = respuesta
        
        respuesta = (alto +  bajo) / 2
        contador += 1
        
    return print(f'la raiz cuadrada de {objetivo} es {respuesta} y el programa hizo {contador} pasos')
    

    
if seleccion_algoritmo == 1:
    funcion_enumeracion_exhaustiva(objetivo)
elif seleccion_algoritmo == 2:
    exactitud= int(input('ingrese porcentaje de exactitud: '))
    print(f'{exactitud} %')
    epsilon = exactitud/100
    funcion_aproximacion_soluciones(objetivo, epsion=epsilon)
    
elif seleccion_algoritmo == 3:
    exactitud= int(input('ingrese porcentaje de exactitud: '))
    print(f'{exactitud} %')
    epsilon = exactitud/100
    funcion_busqueda_binaria(objetivo, epsilon)
else:
    print('seleccion no valida')

Aquí mi código, es la primera vez que lo hago solo, ahora si voy viendo el progreso

def raiz_cuadrada(metodo):
    if metodo == 1:
        numero = int(input('Elegiste el método de enumeración, escoge un entero: '))
        respuesta = 0

        while respuesta ** 2 < numero:
            print(respuesta)  # ayuda para saber que hace el algoritmo
            respuesta += 1

        if respuesta ** 2 == numero:
            print(f'La raíz cuadrada de {numero} es {respuesta}')
        else:
            print(f'El {numero} no tiene una raíz cuadrada exacta')
    elif metodo == 2:
        numero = int(input('Elegiste el método de aproximación, escoge un número: '))
        epsilon = 0.01
        paso = epsilon ** 2
        respuesta = 0.0

        while abs(respuesta ** 2 - numero) >= epsilon and respuesta <= numero:
            print(abs(respuesta ** 2 - numero), respuesta)
            respuesta += paso

        if abs(respuesta ** 2 - numero) >= epsilon:
            print('No se encontró la raíz cuadrada del objetivo')
        else:
            print(f'La raíz cuandrada de {numero} es {respuesta}')
    elif metodo == 3:
        numero = int(input('Elegiste el método de búsqueda binaria, escoge un número: '))
        epsilon = 0.001
        bajo = 0.0
        alto = max(1.0, numero)
        respuesta = (alto + bajo) / 2

        while abs(respuesta ** 2 - numero) >= epsilon:
            print(f'alto = {alto}, bajo = {bajo}, respuesta = {respuesta}')
            if respuesta ** 2 < numero:
                bajo = respuesta
            else:
                alto = respuesta

            respuesta = (alto + bajo) / 2

        print(f'La raíz cuadrada de {numero} es {respuesta}')
    else:
        print('Opción inválida')

raiz_cuadrada(int(input('''Si quieres saber la raíz cuadrada de un número:
Elige 1 para el método de enumeración, 
Elige 2 para el método de aproximación o 
Elige 3 para el método de búsqueda binaria 
''')))

Esta fue mi solución al reto.

numeroIng = int(input('Por favor ingrese un numero para calcular su raíz cuadrada: '))

opcion_Raiz = int(input('Por favor ingrese el numero de una de las siguientes opciones para calcular la raíz: \n 1. Raíz cuadrada exacta. \n 2. Raíz cuadrada aproximación. \n 3. Raíz cuadrada binaria. \n\n Opción: '))

def calcula_Raiz_Numero(numero, opcion):
    epsilon = 0.01
    val_aumenta = epsilon**2
    num_Min = 0.0
    num_Max = max(1.0, numero)
    
    if opcion == 3:
        respuesta = (num_Max + num_Min) / 2
    else:
        respuesta = 0.0
    
    if opcion == 1:
        while respuesta**2 < numero:
            respuesta += 1

        if respuesta**2 == numero:
            print(f'Opción {opcion}. La raiz cuadrada de {numero} es {respuesta}')
            return f'Opción {opcion}. La raiz cuadrada de {numero} es {respuesta}'
        else:
            print(f'Opción {opcion}. El numero {numero} no tiene raíz cuadrada exacta')
            return f'Opción {opcion}. El numero {numero} no tiene raíz cuadrada exacta'
            
    elif opcion == 2:
        while abs(respuesta**2 - numero) >= epsilon and respuesta <= numero:
            #print(abs(respuesta**2 - numeroIng), respuesta)
            respuesta += val_aumenta

        if abs(respuesta**2 - numero) >= epsilon:
            print(f'Opción {opcion}. No tiene raiz cuadrada el numero {numero}')
            return f'Opción {opcion}. No tiene raiz cuadrada el numero {numero}'
        else:
            print(f'Opción {opcion}. La raiz cuadrada del numero {numeroIng} es {respuesta}')
            return f'Opción {opcion}. La raiz cuadrada del numero {numeroIng} es {respuesta}'
    else:        
        while abs(respuesta**2 - numero) >= epsilon:
            #print(f'Numero minimo = {num_Min}, Numero maximo = {num_Max}, Respuesta = {respuesta}')    

            if respuesta**2 < numero:
                num_Min = respuesta
            else:
                num_Max = respuesta
            
            respuesta = (num_Max + num_Min) / 2
            
        print(f'Opción {opcion}. La raiz cuadrada de {numeroIng} es {respuesta}')
        return f'Opción {opcion}. La raiz cuadrada de {numeroIng} es {respuesta}'

if opcion_Raiz >= 1 and opcion_Raiz <= 3:
    calcula_Raiz_Numero(numeroIng, opcion_Raiz)
else:
    print('La opción no es válida. \nPor favor inténtelo de nuevo.')

Este es mi reto

def exact_root(target):
    response = 0

    while response**2 < target:
        print(response)
        response +=1
    if response**2 == target:
        print(f'la raiz cuadrada exacta de {target} es {response}\n')
    else:
        print(f'{target} no tiene raiz cuadrada exacta\n')
        

def bynary_algorithm(target,epsilon):
    min=0.0
    maxi=max(0.0,target)
    responce=(min + maxi)/2

    while responce**2 - target >= epsilon:
        print(f'bajo={min},alto={maxi},respuesta={responce}')
        if abs(responce**2 < target):
            min=responce
        else:
            maxi=responce
        responce=(min + maxi)/2
    print(f'la raiz cuadrada de {target} por medio del metodo binario es {responce}')

def approach_algoritm(target,epsilon,step):
    responce=0.0
    
    while abs(responce**2-target)>= epsilon and responce <= target:
        print(abs(responce**2-target),responce)
        responce+=step
    if abs(responce**2-target) >= epsilon:
        print(f'no se encuentra la raiz exacta de {target}\n')
    else:
        print(f'la raiz cuadrada aproximada de {target} es {responce}\n')


def run():
    target=int(input('ingrese un numero: \n'))
    ep=int(input('ingrese la cantidad de digitos de presicion: \n'))
    epsilon=1*(10**-ep)
    step=epsilon**2
    print('''
        1:'raiz exacta',
        2:'raiz por aproximacion aritmetica',
        3:'raiz por aproximacion binaria',
        ''')
    option_user=int(input('ingrese la operacion que desea realizar: \n'))
    if option_user == 1:
            exact_root(target)
    elif option_user == 2:
            bynary_algorithm(target,epsilon)
    elif option_user == 3:
            approach_algoritm(target,epsilon,step)
    else:
        print('la opcion ingresada es erronea,vuelva ejecutar\n')

run() 

Mi aporte

def enumeracion(objetivo):
    respuesta = 0

    while respuesta**2 < objetivo:
        print(respuesta)
        respuesta += 1

    if respuesta**2 == objetivo:
        return print(f'La raiz cuadrada de {objetivo} es {respuesta}')
    else:
        return print(f'{objetivo} no tiene una raiz cuadrada exacta')
    
    
def aproximacion(objetivo):
    epsilon = 0.01
    paso = epsilon**2 
    respuesta = 0.0

    while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
        print(abs(respuesta**2 - objetivo), respuesta)
        respuesta += paso

    if abs(respuesta**2 - objetivo) >= epsilon:
        return print(f'No se encontro la raiz cuadrada {objetivo}')
    else:
        return print(f'La raiz cudrada de {objetivo} es {respuesta}')

    

def busqueda_binaria(objetivo):
    epsilon = 0.01
    bajo = 0.0
    alto = max(1.0, objetivo)
    respuesta = (alto + bajo) / 2

    while abs(respuesta**2 - objetivo) >= epsilon:
        print(f'bajo={bajo}, alto={alto}, respuesta={respuesta}')
        if respuesta**2 < objetivo:
            bajo = respuesta
            
        else:
            alto = respuesta

        respuesta = (alto + bajo) / 2

    return print(f'La raiz cuadrada de {objetivo} es {respuesta}')




menu= 0
bandera = True
while bandera == True :
    objetivo = int(input('Escoge un numero: '))
    print(f'Por que metodo te gustaria encontrar la raiz cuadrada de tu numero {objetivo}')
    print('1) Enumeracion')
    print('2) Aproximacion')
    print('3) Busqueda Binaria')
    menu= int(input('Ingrese una opcion: '))

    if menu == 1:
        enumeracion(objetivo)
    elif menu == 2:
        aproximacion(objetivo)
    elif menu == 3:
        busqueda_binaria(objetivo)
    else:
        print("Opcion invalida")


    print("¿Desea repetir usando otro metodo?")
    print("1) Si     ó     2) No")
    repetir= int(input("Introduzca su opcion -> "))

    if repetir == 1:
        bandera = True

    elif repetir == 2:
        print("Adios")
        bandera = False

    else:
        print("Opcion Invalida, Adios.")
        bandera = False

Comparto mi aporte este es el resultado que me ha dado Code Interpreter de ChatGPT, una solución elegante… le he pedido que lo explicará paso a paso para comprender mejor el motivo de hacerlo así y tiene su lógica.

def enumeracion_exhaustiva(objetivo):
    respuesta = 0
    while respuesta**2 < objetivo:
        print(respuesta)
        respuesta += 1
    if respuesta**2 == objetivo:
        print(f"La raíz cuadrada de {objetivo} es {respuesta}")
    else:
        print(f"{objetivo} no tiene una raiz cuadrada exacta")


def aproximacion(objetivo):
    epsilon = 0.01
    paso = epsilon**2
    respuesta = 0.0 
    while abs(respuesta**2 - objetivo ) >= epsilon and respuesta <= objetivo:
        respuesta += paso 
    if abs(respuesta**2 - objetivo) >= epsilon:
        print(f"No se encontró la raiz cuadrada {objetivo}")
    else:
        print(f"La raiz cuadrada de {objetivo} es {respuesta}")


def busqueda_binaria(objetivo):
    epsilon = 0.001 
    bajo = 0.0
    alto = max(1.0, objetivo)
    respuesta = (alto + bajo) / 2
    while abs(respuesta**2 - objetivo) >= epsilon:
        print(f"bajo={bajo}, alto={alto}, respuesta={respuesta}")
        if respuesta**2 < objetivo:
            bajo = respuesta
        else: 
            alto = respuesta
        respuesta = (alto + bajo) / 2
    print(f"La raiz cuadrada de {objetivo} es {respuesta}")


def main():
    objetivo = int(input("Escoge un numero: "))
    print("Escoge un método para calcular la raíz cuadrada:")
    print("1. Enumeración exhaustiva")
    print("2. Aproximación")
    print("3. Búsqueda binaria")
    metodo = int(input("Tu elección: "))
    if metodo == 1:
        enumeracion_exhaustiva(objetivo)
    elif metodo == 2:
        aproximacion(objetivo)
    elif metodo == 3:
        busqueda_binaria(objetivo)
    else:
        print("Método no reconocido")

if __name__ == "__main__":
    main()

Estimados, comparto la solución a la cual he llegado; se acepta feedback:

#Encapsular los tres algoritmos anteriores en distintas funciones y preguntar al usuario cual algoritmo desea utilizar.

def enumeracion(objetivo):
    respuesta = 0;

    while respuesta**2 < objetivo:
        respuesta += 1;

    if respuesta**2 == objetivo:
        print(f'La raiz cuadrada de {objetivo} es {respuesta}');
    else:
        print(f'{objetivo} no tiene raiz cuadrada exacta.');

def aproximacion(objetivo):
    epsilon = 0.01;
    paso = epsilon**2;
    respuesta = 0.0;

    while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo:
        respuesta += paso;

    if abs(respuesta**2 - objetivo) >= epsilon:
        print(f"No se encontro la raiz cuadrada de {objetivo}");
    else:
        print(f"La raiz cuadrada de {objetivo} es {respuesta}");

def busqueda_binaria(objetivo):
    epsilon = 0.01;
    bajo = 0.0;
    alto = max(1.0, objetivo);
    respuesta = (alto + bajo) / 2;

    while abs(respuesta**2 - objetivo) >= epsilon:
        print(f'bajo = {bajo}, alto = {alto}, repsuesta = {respuesta}');
        if respuesta**2 < objetivo:
            bajo = respuesta;
        else:
            alto = respuesta;

        respuesta = (alto + bajo) / 2;

    print(f'La raiz cuadrada de {objetivo} es {respuesta}');

inicio = int(input("\nIngresa el número: \n1) para seleccionar el algoritmo por enumeración \n2) para el algoritmo por aproximación \n3) para utilizar el algoritmo por busqueda binaria. \nIngresa el número aquí -> "));

if inicio == 1:
    objetivo = int(input("Ingresa un entero: "));
    enumeracion(objetivo);
elif inicio == 2:
    objetivo = int(input("Ingresa un número entero: "));
    aproximacion(objetivo);
elif inicio == 3:
    objetivo = int(input("Ingresa un número: "));
    busqueda_binaria(objetivo);
else:
    print("Ingresa un número válido.");

Challenge completed

Run>

Type the number you want to know the square root: 16
Choose a option:
1-Exhaustive enumeration method
2-Aproximations of solutions method
3-Binary search(default)

3

low: 0.0, high: 16, result= 8.0
Square root 16 is 4.0
Execution time: 0.00014543533325195312

La palabra “decomponer” no existe en español, realmente es una mala traducción de “decompose” en inglés. Su traducción es descomposición.

Abstracción: un enfoque mental selectivo que extrae o separa un cierto aspecto de la realidad de todos los demás.