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.

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}'

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")

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}')

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

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()

❤

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()```

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.

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:
.

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!")

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

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()

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

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())

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')```

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()```

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")```

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")```

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()```

Aca esta el 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 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 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 del objetivo ')
else:
    print(f'La raiz cuadrada de {objetivo} es {respuesta}')

def run():
menu = “”"
Hola Bienvenido, mediante este programa
podras calcular una raiz cuadrada con los sigueintes metodos:

1.Enumeracion Exaustiva
2.Busqueda Binaria
3.Aproximacion

Debes escoger una de estas opciones, para empezar.
"""
opcion = int(input(menu))

objetivo = int(input('Esgoge el numero al que se le va a calcular la raiz cuadrada: '))

if opcion == 1:
    enumeracion(objetivo)
elif opcion ==2:
    busqueda_binaria(objetivo)
elif opcion == 3:
    aproximacion(objetivo)
else:
    print('Elige una opcion correcta, segun el menu')

if name == ‘main’:
run()

Acá esta mi código:

"""Algoritmo - Enumeracion Exhaustiva"""
def enumeracion(objetivo):
    # objetivo = int(input("Escoge un entero: "))
    respuesta = 0
    # import time
    # tiempo_inicial = time.time()

    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 un raiz cuadrada exacta.")
    # print(f"El programa tardo en completar su funcion {time.time() - tiempo_inicial} segundos")

"""Aproximacion de soluciones"""
def aproximacion(objetivo):
    # 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 de {objetivo}")
    else:
        print(f"La raiz cuadrada de {objetivo} es {respuesta}")

"""Busqueda Binaria"""
def binaria(objetivo):
    # 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 de {objetivo} es {respuesta}")

menu = """
Programa que elige diferentes metodos para hallar la raiz cuadrada

1 - Metodo "Enumeración exhaustiva"
2 - Metodo "Aproximación de soluciones"
3 - Metodo "Busqueda binaria"

Elige una opción: """

opcion = int(input(menu))
objetivo = int(input("Ingresa un número para hallar su raiz cuadrada: "))

if opcion == 1:
    enumeracion(objetivo)
elif opcion == 2:
    aproximacion(objetivo)
elif opcion == 3:
    binaria(objetivo)
else:
    print("Elige una opcion correcta por favor")

El resultado se ve así:

Programa que elige diferentes metodos para hallar la raiz cuadrada

1 - Metodo "Enumeración exhaustiva"
2 - Metodo "Aproximación de soluciones"
3 - Metodo "Busqueda binaria"

Elige una opción: 3
Ingresa un número para hallar su raiz cuadrada: 16
La raiz cuadrada de 16 es 4.0

Lo hice de esta manera c:

Me gustaría recibir feedback para hacerlo mejor.

def enumeracion():
    objetivo = int(input('Escoge un número: '))
    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'El número {objetivo} no tiene una raíz cuadrada exacta.')


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(f'No se encontró la raíz cuadrada de {objetivo}')
        
    else:
        print(f'La raíz cuadrada de {objetivo} es {respuesta}')


def busqueda():
    objetivo = int(input('Escoge un número: '))
    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}')


def run():
    pass

if __name__ == '__main__':
    run()


menu = """
Bienvenido al buscador raices cuadradas: 

1 - Método de enumeración exhaustiva
2 - Método de aproximación de soluciones
3 - Método de búsqueda binaria (recomendado)

Elige una opción: """

opcion = int(input(menu))

if opcion == 1:
    enumeracion()
elif opcion == 2:
    aproximacion()
elif opcion == 3:
    busqueda()
else:
    print('Ingresa una opción correcta por favor')

Este es mi código:

def busquedabinaria(objetivo):
    objetivo = 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 la {respuesta}')


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}')




print("Programa para Busqueda de Raiz cuadrada de un número...")
print(
    """
    1. Busqueda binaria 
    2. Por Aproximación 
    3. Enumeración Exahustiva
    """
)
opcion = int(input('Introduce una opcion de como quieres obtener la raiz cuadrada: '))


if opcion == 1:
    objetivo = int(input("Intrdoduce un numero: "))
    busquedabinaria(objetivo)
elif opcion == 2:
    objetivo = int(input("Intrdoduce un numero: "))
    aproximacion(objetivo)
elif opcion == 3:
    objetivo = int(input("Intrdoduce un numero: "))
    enumeracion_exhaustiva(objetivo)
else: 
 print("Escoge una opcion correcta...")

def busquedaBinaaria(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 respuesta

def aproxSoluciones(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:
        return respuesta
    return

def enumeracionExhaustiva(objetivo):
    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')



while True:
    metodo = int(input(' Elige un metodo: '))
    if 1 <= metodo <= 3:
        break

if metodo == 1:
    print(enumeracionExhaustiva(objetivo))
elif metodo == 2:
    print(aproxSoluciones(objetivo))
elif metodo == 3:
    print(busquedaBinaaria(objetivo))

Aquí está el código de mi reto:

def enumeracion(objetivo):
    resultado = 0

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

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


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

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


def busqueda_binaria(objetivo, epsilon):
    bajo = 0.0
    alto = 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 elige_metodo():
    print(
        """ 
          Metodos para resolver la zaiz cuadrada:
          
          1 - Enumeración
          2 - Aproximación
          3 - Busqueda binaria
          
          """
    )
    metodo = input("Elige un metodo: ")

    if metodo == "1":
        numero = int(input("Dime el número a calcular: "))
        enumeracion(numero)
    elif metodo == "2":
        numero = int(input("Dime el número a calcular: "))
        rango = float(input("Dime el rango de precisión(0.01, 0.001,...: "))
        aproximacion(numero, rango)
    elif metodo == "3":
        numero = int(input("Dime el número a calcular: "))
        rango = float(input("Dime el rango de precisión(0.01, 0.001,...: "))
        busqueda_binaria(numero, rango)
    else:
        print("Elige una opción correcta")


def run():
    elige_metodo()


if __name__ == "__main__":
    run()

paera querer encapsularlo como deseo, me esta faltando algo para que las funciones me devuelvan dos valores globales, si alguno me puede ayudar a buscar la solucon, mas que agradecido, aunque segurmanete mas adelante del curso lo puedo resolver. pero me parecio la forma mas correcta de encapsular todo.

me faltaria devolver como variables globales a no_existe y resultado

def busqueda_binaria(objetivo):
    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:
        if respuesta**2 < objetivo:
            bajo = respuesta
        else:
            alto = respuesta
        respuesta = (alto + bajo) / 2
    return respuesta

def aproximacion(objetivo):
    objetivo = int(input('Escoje un numero: '))
    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:
            no_existe = False
        else:
            no_existe = True
    return respuesta, no_existe

def enumeracion_exhaustiva(objetivo):
    objetivo = int(input('Escoje un entero: '))
    respuesta = 0

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

    if respuesta**2 == objetivo:
        no_existe = False
    else:
        no_existe = True
    return respuesta, no_existe

print('Elije una de los siguiente algoritmos: ')
print('1 - Busqueda_binaria')
print('2 - Aproximacion')
print('3 - Enumeracion_exhaustiva')
seleccion = int(input('Elija una opcion del 1 - 3: '))
objetivo = int(input('Elije un numero para sacar su raiz cuadrada: '))

while seleccion != 1 and seleccion != 2 and seleccion != 3:
    if seleccion == 1:
        busqueda_binaria(objetivo)
    elif seleccion == 2:
        aproximacion(objetivo)
    elif seleccion == 3:
        enumeracion_exhaustiva(objetivo)
    else:
        print('No ingreso una opcion valida')

**_if no_existe == False:
    print(f'La raiz cuadrada es: {respuesta}')
else:
    print(f'La raiz cuadrada de {objetivo}, no existe')_**

el código quedaría mas o menos de la siguiente manera:

def  exaust_enum(target):
    ans = 0
    while ans**2 < target:
        ans +=1
    if  ans**2 == target:
        print(f'La raiz de {target} es {ans}')
    else:
        print(f'{target} no tiene raiz exacta')

def near_ans(target):
    epsilon = 0.01
    pas = epsilon**2
    ans = 0.0
    while abs(ans**2 - target) >= epsilon and ans <= target:
        ans += pas

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

def bin_search(target):
    epsilon = 0.01 
    down = 0.0
    up = max(1.0,target)
    ans = (up+down) / 2

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

def run():
    print('Este es un programa para calcular La raiz cuadrada de un numero')
    print('para lograr eso deberas escoger uno de los siguientes metodos')
    print('(E)numeracion exaustiva')
    print('(A)proximacion de soluciones')
    print('(B)usqueda binaria')
    loop = True
    while loop:
        metod = input('Selecciona el metodo que quieres utilizar: ')
        target = int(input('Cual es el numero entero al que le quieres calcular la raiz cuadrada: '))
        if metod.lower() == 'e':
            exaust_enum(target)
            loop = False
        elif metod.lower() == 'a':
            near_ans(target)
            loop = False
        elif metod.lower() == 'b':
            bin_search(target)
            loop = False

if __name__ == '__main__':
    run()

El reto es el siguiente:

def enumeracion_exhaustiva(objetivo):
    
    respuesta = 0

    while respuesta**2 < objetivo:
        respuesta +=1
    if respuesta**2 == objetivo:
        return respuesta
    else:
        return None


def aproximacion_de_soluciones(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:
        return None
    else:
        return 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 respuesta


def run():
    option = 0

    menu = """
    Bienvenido al programa de Algoritmos
    Selecciona el Algoritmo para calcular
    la raiz cuadrada de un número

    
    1 - Algoritmo de enumeración exhaustiva
    2 - Algoritmo de aproximación de soluciones
    3 - Algoritmo de búsqueda binaria


    Escoge una opción: """
    option = int(input(menu))
    objetivo = int(input('Escoge un número: '))
    respuesta = 0

    if option == 1:
        respuesta = enumeracion_exhaustiva(objetivo)
    elif option == 2:
        respuesta = aproximacion_de_soluciones(objetivo)
    elif option == 3:
        respuesta = busqueda_binaria(objetivo)

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


if __name__ == '__main__':
    run()

Definitivamente hay un gran salto entre la complejidad innecesaria del algoritmo Binary Search explicado con un caso tan matemático a esto, siento que los videos del Binary Search y los algoritmos de aproximación de soluciones y enumeración exhaustiva deberían de ser más sencillos y entendibles. Esa complejidad comparada con este video fue como un bajonazo.

Este es mi codig0x1

def menu():
    print('='*50)
    print('\t[*] Sacar raiz cuadrada [*]')
    print('''
1. aproximacion
2. enumeracion exhausiva
3. busqueda binaria
          ''')
    print('='*50)
   

def aproximacion(n):
    epsilon = 0.001
    paso = epsilon**2
    respuesta = 0.0

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

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

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

    return n


def enumeracion_exhaustiva(n):
    resul = 0

    while resul**2 < n:
        resul += 1
 
    if resul**2 == n:
        print(f'La raiz cuagrada de {n} es {resul}')

    else:
        print(f'{n} no tiene raiz cuadrada exacta')
    
    return n


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

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

        respuesta = (alto + bajo) / 2

    print(f'La raiz cadrada de {n} es {respuesta}')

    return n


def main():
    menu()
    opcion = int(input('Ingrese una opcion: '))
    if opcion == 1:
        n = int(input('Ingrese un numero: ')) 
        aproximacion(n)
    elif opcion == 2:
        n = int(input('Ingrese un numero: '))
        enumeracion_exhaustiva(n)
    elif opcion == 3:
        n = int(input('Ingrese un numero: '))
        busqueda_binaria(n)
    else:
        print("Ingrese un valor valido")
    


if __name__=='__main__':
    main()

Hola comunidad, mi solucion al reto:

import time


def exhaustiva(objetivo):
    print('Metodo seleccionado: Enumeracion Exhaustiva')
    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):
    print('Metodo seleccionado: Por Aproximacion')
    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 del {objetivo}')
    else:
        print(f'La raiz cuadrada de {objetivo} es {respuesta}')


def binaria(objetivo):
    print('Metodo seleccionado: Busqueda Binaria')
    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():
    opcion = int(input('''
Elija una Opcion de busqueda:

[1] - Enumeracion Exhaustiva
[2] - Por Aproximacion
[3] - Binaria

Opcion: '''))
    objetivo = int(input('\nEscoge un numero para buscar la raiz cuadrada: '))
    tiempo_inicial = time.time()

    if opcion == 1:
        exhaustiva(objetivo)
    elif opcion == 2:
        aproximacion(objetivo)
    elif opcion == 3:
        binaria(objetivo)
    else:
        print(f'La opcion {opcion} no existe. Programa finalizado!')

    print(f'El programa se ejecuto en {time.time() - tiempo_inicial} segundos')


if __name__ == '__main__':
    run()

Abstracción

La abstracción consiste en cumplir una función separando al usuario de la lógica que hay por detras.

Por ejemplo el Carro, un conductor no sabe como funciona un arbol de lebas o la combustión o el motor etc. Sin embargo puede conducirlo.

Dentro del código podemos crear funciones que cumplan propósitos específicos que podamos reutilizar dinámicamente sin tener que preocuparnos de como está escrito por detrás dicha función.

Por ejemplo las librerias

Mi código, cualquier comentario para mejorar es bienvenido!

Este es mi aporte con lo que he aprendido en los cursos de platzi

def run():
    def raiz_abarcativa():
        objetivo = (float(input('Escribe un número: ')))
        epsilon = 0.001
        resultado = 0 + epsilon

        if objetivo < 0:
            objetivo = objetivo * -1
        else:
            pass

        while abs(resultado**2 <= objetivo):
            resultado += 0.001
            print(resultado)
        if objetivo - resultado**2 <= epsilon:
                print(f'La raíz cuadrada de {objetivo} es {round(resultado, 2)} .')
        else:
                print('No hay resultado.')

        
    def raiz_binaria():
            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:
                if respuesta**2 < objetivo:
                    bajo = respuesta
                else:
                    alto = respuesta

                respuesta = (alto + bajo) / 2
                print(bajo, alto, respuesta)

            print(f'La respuesta es {respuesta}')
    

    def flotantes():
        objetivo = int(input('Escribe un entero: '))
        resultado = 0
        while abs(resultado**2 < objetivo):
            print(resultado)
            resultado += 1

        if objetivo == resultado**2:
            print(f'La raíz cuadrada de {objetivo} es {resultado}.')
        else:
            print('No tiene raíz.')

    def iteraciones():
        segundos = 0
        minutos = 0
        horas = 0

        while horas <= 1:
            while minutos <= 60:
                while segundos <= 60:
                    print(horas, minutos, segundos)
                    segundos += 1
                minutos += 1
                segundos = 0
            horas += 1
            minutos = 0

    
    def introduccion():
        nombre_1 = input('Escribe el nombre del primer usuario.')
        nombre_1 = nombre_1.capitalize()
        edad_1 = input('Escribe la edad del primer usuario.')
        nombre_2 = input('Escribe el nombre del segundo usuario.')
        nombre_2 = nombre_2.capitalize()
        edad_2 = input('Escribe la edad del segundo usuario.')

        if edad_1 > edad_2:
            print(nombre_1 + ' es mayor que '+ nombre_2 + '.')
        elif edad_1 < edad_2:
            print(nombre_2 + ' es mayor que '+ nombre_1 + '.')
        else:
            print('Tienen la misma edad.')


    def tipo_dato():
        float = 3.14
        int = 3
        booleano = True
        nada = None

        print(type(int))
        print(type(float))
        print(type(booleano))
        print(type(nada))

        words = ['cat', 'window', 'defenestrate']
        for a in words:
            print(a, len(a))
        print(a)


        print(f'{"hip " * 3} hurra')

        nombre = input('Escribe tu nombre: ')
        edad = input('Escribe tu edad: ')
        frase =f'Hola {nombre}, tenés {str(edad)}. La edad es sólo un número.'
        caracter = len(frase) 
        print(frase)
        print(f'El anterior mensaje tiene {str(caracter)} caracteres.')


    menu = int(input('''
    Selecciona el programa a ejecutar:

    1- Conocer raíz cuadrada de un numero.
    2- Contador de iteraciones.
    3- Comparar edades.
    4- Primer clase.
    '''))

    if menu == 1:
        sub_menu1 = int(input('''Selecciona: 
        1- Método abarcativo (intermedio en preciso)
        2- Método de búsqueda binaria (más preciso pero más lento)
        3- Método más rápido (menos preciso)'''))
        if sub_menu1 == 1:
            raiz_abarcativa()
        elif sub_menu1 == 2:
            raiz_binaria()
        elif sub_menu1 == 3:
            flotantes()
        else:
            print(f'Ingresa un opción correcta')
    elif menu == 2:
        iteraciones()
    elif menu == 3:
        introduccion()
    elif menu == 4:
        tipo_dato()
    else:
        print(f'Ingresa un opción correcta')


            



if __name__ == '__main__':
    run()

# FUNCIONES POR ALGORITMOS

# Enumeración Exhaustiva:

def enumeracion_exhaustiva():
    
    enum_objetivo   = int(input("Escoge un número: "))
    enum_respuesta  = 0

    while (enum_respuesta**2) < enum_objetivo:
        print(f'Probando con: {enum_respuesta}')
        enum_respuesta += 1
    if (enum_respuesta**2) == enum_objetivo:
        print(f'La raiz cuadrada de {enum_objetivo} es {enum_respuesta} mediante Enumeración Exhaustiva')
    else:
        print(f'{enum_objetivo} no tiene una raíz exacta')

# Aproximación de soluciones

def aproximacion_soluciones():

    aprox_objetivo  = int(input("Por favor, escoge un número: "))
    aprox_epsilon   = 0.01
    aprox_paso      = aprox_epsilon**2
    aprox_respuesta = 0.0

    while abs(aprox_respuesta**2 - aprox_objetivo) >= aprox_epsilon and aprox_respuesta <= aprox_objetivo:
        print(abs(aprox_respuesta**2 - aprox_objetivo), aprox_respuesta)
        aprox_respuesta += aprox_paso

    if abs(aprox_respuesta**2 - aprox_objetivo) >= aprox_epsilon:
        print(f'No se encontró la raíz cuadrada {aprox_objetivo} mediante aproximación de soluciones')
    else:
        print(f'La raiz cuadrada de {aprox_objetivo} es {aprox_respuesta} mediante aproximación de soluciones')

# Búsqueda Binaria

def busqueda_binaria():

    bbin_objetivo   = int(input("Escoge un número: "))
    bbin_epsilon    = 0.0001
    bbin_bajo       = 0.0
    bbin_alto       = max(1.0, bbin_objetivo)
    bbin_respuesta  = (bbin_alto + bbin_bajo) / 2
    
    while abs(bbin_respuesta**2 - bbin_objetivo) >= bbin_epsilon:
        print(f'bajo = {bbin_bajo} - alto {bbin_alto} - respuesta {bbin_respuesta}')
        if bbin_respuesta**2 < bbin_objetivo:
            bbin_bajo = bbin_respuesta
        else:
            bbin_alto = bbin_respuesta

        bbin_respuesta = (bbin_alto + bbin_bajo) / 2

    print(f'La raiz cuadrada de {bbin_objetivo} es {bbin_respuesta} mediante búsqueda binaria')


# SELECCIÓN DEL ALGORITMO POR PARTE DEL USUSARIO

seleccion_algoritmos = int(input("""
    
    ¡Bienvenido! ¿Cón cuál algoritmo deseas conocer la raíz cuadrada?

    1) Enumeración Exhaustiva
    2) Aproximación de Soluciones
    3) Búsqueda Binaria

    : """))

if seleccion_algoritmos == 1:
    enumeracion_exhaustiva()

elif seleccion_algoritmos == 2:
    aproximacion_soluciones()

elif seleccion_algoritmos == 3:
    busqueda_binaria()

else:
    print("Por favor, introduce un valor correcto.") 

Dejo mi solución al reto:

#solucion de raiz cuadrada con los tres algoritmos

print('------------------------------------------------------')
print('Bienvenido al programa de solución de raices cuadradas')
print('------------------------------------------------------\n')
print('Por favor, elige el método a utilizar (1, 2, 3):\n')
print('+++++++++++++++++++++++++++++++++++++++++++++++\n\n')

print('1 - Método de enumeración\n'
'2 - Método de aproximación\n'
'3 - Método Binario')

method = input()

print(f'El método elegido es {method}\n')



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 raíz cuadrada de {objetivo} es {respuesta}')
    else:
        print(f'El {objetivo} no tiene una raiz cuadrada exacta')

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

    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}')

def binaria():
    objetivo = int(input('Escoge un numero: '))
    epsilon = 0.001
    inf_lim = 0.0
    sup_lim = max(1.0, objetivo)
    respuesta = (sup_lim + inf_lim) / 2

    while abs(respuesta**2 - objetivo) >= epsilon:
        print(f'El limite inferior = {inf_lim}, el limite superior = {sup_lim}, respuesta= {respuesta}')
        if respuesta**2 < objetivo:
            inf_lim = respuesta
        else:
            sup_lim = respuesta

        respuesta = (sup_lim + inf_lim) / 2

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



if method == '1':
    enumeracion()
elif method == '2':
    aproximacion()
elif method == '3':
    binaria()
else:
    print('Opcion no valida')