A煤n no tienes acceso a esta clase

Crea una cuenta y contin煤a viendo este curso

Funciones y abstracci贸n

15/31
Recursos

Aportes 966

Preguntas 45

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesi贸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 (鈥淗ola, 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_enumeracin(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 enumeracin (): #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')