No tienes acceso a esta clase

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

Adquiere por un a帽o todos los cursos, escuelas y certificados por un precio especial.

Antes: $249

Currency
$219/a帽o

Paga en 4 cuotas sin intereses

Paga en 4 cuotas sin intereses
Comprar ahora

Termina en:

0D
16H
50M
46S

Funciones y abstracci贸n

15/31
Recursos

Aportes 1089

Preguntas 50

Ordenar por:

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

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.

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

def enumeracion_exhaustiva(objetivo):
  respuesta = 0

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

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

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

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

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

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

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

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

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

Parte de la teoria:

.
Habilidades importantes de los ingenieros del Software
.

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

Sintaxis de una funci贸n en python:

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

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

suma(2, 3)

.

Argumentos de tipo Keyword y valores por defecto

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

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

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

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

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

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

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

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

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

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

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

Aqu铆 la soluci贸n con cada m茅todo para calcular la ra铆z cuadrada encapsulado y decompuesta en tres funciones que se mandan a llamar con una variable llamada method. 馃槃

def enumeracion(objetivo):
    respuesta = 0


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


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


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


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


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

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

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

        respuesta = (alto + bajo) / 2
    
    return respuesta


method = input('''Escoge el m茅todo para calcular la ra铆z cuadrada
            [E]numeraci贸n exhaustiva 
            [A]proximaci贸n de soluciones
            [B]煤squeda binaria
            ''')


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


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

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

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

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

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




tambi茅n en python es com煤n iniciar con una funci贸n principal que indique d贸nde inicia la ejecuci贸n del programa.

def main():
	#tu c贸digo comienza aqu铆


if __name__ == '__main__':
	main()

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

Descomposici贸n:
Dividir el c贸digo en componentes que colaboran con un f铆n en com煤n.

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

from datetime import datetime

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

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

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

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

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

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

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

    respuesta = (alto + bajo) / 2

    # Derecha => alto
    # izquierda => bajo

    # MIsion disminuir a la mitad la busqueda

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

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

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

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

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

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

Reto completado:

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

1 - Enumeracion
2 - Aproximacion
3 - Busqueda binaria

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

Aqu铆 est谩 mi soluci贸n, tiene la estructura del curso de aprender Python creando un CRUD (Recomendado)

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

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


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

        respuesta_bin = (high + low) / 2
    

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


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

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

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


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

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

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

    else:
        print ("Invalid Command")```
def aprox_de_sol(objetivo):
   
    epsilon = 0.01
    paso = epsilon**2
    respuesta= 0.0

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

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

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

def busq_bin(objetivo):

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

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

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

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

Mi aporte:

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

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

        respuesta = (alto + bajo) / 2

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


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

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

        respuesta += paso

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



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

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

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

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

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

hola 馃槂 aqui les dejo mi codigo

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

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

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

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

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

        respuesta = (alto + bajo) / 2

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

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

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

    elif info1 == 2:
        programa2()

    elif info1 == 3:
        programa3()

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

        

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


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

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

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


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

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

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

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

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

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

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

            respuesta = (alto + bajo) / 2

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


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

    info1 = int(input())

    return info1
    


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

]Reto realizado:

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

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


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

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

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

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


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



if __name__ == '__main__':
    run()
menuOpciones = {
    1: 'Enumerac贸n exhaustiva',
    2: 'Aproximaci贸n de soluciones',
    3: 'Busqueda binaria',
    4: 'Salir'
}

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

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

        respuesta = (alto + bajo) / 2

    return respuesta

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

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

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

    return respuesta

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

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

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

    return respuesta

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

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

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

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

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

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

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

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

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

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

            respuesta = (alto + bajo) / 2

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


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

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

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


if __name__ == '__main__':
    run()

Por aca les dejo mi c贸digo

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

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

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

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

import numpy as np

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

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


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

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

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

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

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

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

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

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

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



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

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

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

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

Mi soluci贸n al reto:
.

Comparto mi c贸digo. 馃槂

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

        respuesta = (alto+bajo)/2
    return respuesta

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

mi c贸digo del ejercicio 馃槃

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

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

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


def enumeracion_exhaustiva(objetivo):
    respuesta = 0

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

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


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

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


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

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

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


if __name__ == '__main__':
    run()
# Enumeraci贸n exhaustiva:

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

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

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

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

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

Funciones y abstracci贸n


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

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

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

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

Para llamar a una funci贸n, se utiliza el nombre de la funci贸n seguido de los par谩metros entre par茅ntesis. Por ejemplo:

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

Funciones

Se puede entender una funci贸n como un conjunto de l铆neas de c贸digo que realizan una tarea espec铆fica y pueden tomar 鈥淎rgumentos鈥 para diferentes 鈥淧ar谩metros鈥 que modifiquen su funcionamiento y los datos de salida. Una funci贸n te permite implementar operaciones que son habitualmente utilizadas en un programa y, de esta manera, reducir la cantidad de c贸digo.

Las funciones en Python ser谩n una parte del c贸digo de nuestro programa encargadas de cumplir alg煤n objetivo espec铆fico definido por nosotros o por el lenguaje, recibiendo ciertos 鈥渄atos de entrada鈥 (Argumentos) en los llamados Par谩metros para procesarlos y brindarnos 鈥渄atos de salida鈥 o de retorno.

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

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

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

Funciones comunes en Python

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

  1. def: palabra clave.
  2. Nombre de la funci贸n.
  3. 鈥()鈥: par茅ntesis que incluyen los par谩metros de entrada (opcionales).
  4. 鈥:鈥 : dos puntos.
  5. Bloque de c贸digo.
  6. Sentencia de retorno (opcional).

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

Hola compa帽eros! ac谩 les comparto mi c贸digo 馃槂

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

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

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

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

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

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


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

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

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

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



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

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

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

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

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

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

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

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

        answer = (highest + lowest) / 2

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

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

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

Buenas, aqu铆 mi resoluci贸n del reto:

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


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


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


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


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

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


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


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

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

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

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


if __name__ == '__main__':
    run()

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


import os
import time


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

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

    Ingresa una opci贸n: '''))


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

time.sleep(3)

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



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


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


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


def enumeracion_exhaustiva(objetivo):
    respuesta = 0

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

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

def aproximacion(objetivo):

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

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

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

def busqueda_binaria(objetivo):

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

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

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


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

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

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

Es as铆? me pueden ayuda?

Desde ya gracias鈥

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

### Definiendo las funciones:

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

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

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

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

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

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


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

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

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

### Interfaz de uso

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

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

print('Gracias por utilizar este programa')

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

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

def enum (objetivo):
    respuesta = 0

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

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

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

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

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

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

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

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

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

Saludos!

As铆 quedo mi c贸digo aplicando abstracci贸n con el uso de funciones:

Reto

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

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

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

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


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

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

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


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

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

    
if __name__ == '__main__':
    run()

Comparto mi soluci贸n al reto

def sqr_exhaustiva(objetivo):
    respuesta = 0

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

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

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

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

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

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

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

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

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

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

if __name__ == '__main__':
    run()

Muy bueno!

Esta es mi soluci贸n al desaf铆o:
Le agregue un men煤 donde podes seleccionar entre los tres tipos de algoritmos 馃榾

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

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

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


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

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

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


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

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

        respuesta = (alto + bajo) / 2


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


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

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

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

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


if __name__ == "__main__":
    run()

Les comparto mi Soluci贸n al reto:

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

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

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

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

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

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

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

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


Mi aporte

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

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

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

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

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

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


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

    opcion = int(input("""Por favor elige la m茅todo de c谩lculo:
    1. Enumeraci贸n (Funciona s贸lo con ra铆ces exactas)
    2. Aproximaci贸n
    3. B煤squeda binaria: """))

    respuesta = programas_numericos(opcion, objetivo)

if __name__ == '__main__':
    run()

Mi c贸digo, se aceptan sugerencias

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

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

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

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

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

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

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

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

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


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

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

        respuesta = (alto + bajo) / 2

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

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

print('Programa raiz cuadrada')

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

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

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

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

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

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

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

calculadora_de_raiz.py

import enumeracion
import busqueda_binaria
import aproximacion

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

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

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

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

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

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

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

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


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

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

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


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

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

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


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

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

Aqui mi reto

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

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

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

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

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

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

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

Mi solucion al reto:

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

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

Mi aporte al reto 馃槂

def enumeracion_exhaustiva(objetivo):
    respuesta=0

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

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

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

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

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

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

        respuesta = (alto+bajo) / 2

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

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

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

Hola, aqu铆 mi respuesta al reto:

# DEFINICION DE LAS FUNCIONES.

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

def enumeracionExhaustiva(objetivo):

    resultado = 0

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

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

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

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

def aproximacionDeSoluciones(objetivo):

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

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

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

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

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


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

def busquedaBinaria(objetivo):

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

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

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

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

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

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

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

elif opcion == 2:

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

elif opcion == 3:

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

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

Mi soluci贸n al reto

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

import approximation
import search_binary
import enumation

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

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

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



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

隆Reto resuelto!

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

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

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

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

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

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

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

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

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

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

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

Reto

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

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

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

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

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

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

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

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

        respuesta = (alto + bajo) / 2

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


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

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

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

if option == 1:
    print('Busqueda binaria')
    busqueda_binaria()
elif option == 2:
    print('Aproximacion')
    aproximacion()
else:
    print("Intenta de nuevo")```
#abstraccion = saber para que funciona, y su comportamiento m谩s no su funcionamiento en espec铆fico
#Decomposici贸n = dividir el c贸digo en componentes, modularidad
import math

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

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

Dejo mi reto 馃,

def enumeracion(objetivo):
    respuesta = 0

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

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

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

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

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

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

        respuesta = (alto + bajo) / 2

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

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

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

margen('馃弫')
print(f'Este programa es para calcular la raiz cuadra con diferentes m茅todos')
margen('馃弫')
run()

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

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

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

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


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

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


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

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

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

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

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

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

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

# print(enumeracionExhaustiva(4))

# print(aproxSoluciones(17))



# print(busquedaBinaaria(19.5))

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

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



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

Comparto mi soluci贸n al ejercicio propuesto

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


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

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

Este es mi aporte al codigo

import time

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

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


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

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

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

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

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

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

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

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

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

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

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

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

            respuesta = (alto + bajo) / 2

        print(f'La ra铆z cuadrada de {numero} es {respuesta}')
    else:
        print('Opci贸n inv谩lida')

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

Esta fue mi soluci贸n al reto.

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

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

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

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

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

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

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

Este es mi reto

def exact_root(target):
    response = 0

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

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

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

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


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

run() 

Mi aporte

def enumeracion(objetivo):
    respuesta = 0

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

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

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

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

    

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

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

        respuesta = (alto + bajo) / 2

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




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

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


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

    if repetir == 1:
        bandera = True

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

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




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

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


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


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


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

if __name__ == "__main__":
    main()

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

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

def enumeracion(objetivo):
    respuesta = 0;

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

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

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

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

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

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

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

        respuesta = (alto + bajo) / 2;

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

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

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

Challenge completed

Run>

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

3

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

La palabra 鈥渄ecomponer鈥 no existe en espa帽ol, realmente es una mala traducci贸n de 鈥渄ecompose鈥 en ingl茅s. Su traducci贸n es descomposici贸n.

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