Parámetros por defecto y múltiples returns

Sábado 22 de octubre 10 pm

Podría estar jugando Warzone o Valorant, tampoco estoy presionado por aprender rápido; pero aquí estoy, tomando este maravilloso curso, porque me gusta, lo estoy disfrutando.

Si quiero retornar una lista en vez de la tupla

def find_volum(length = 1, width = 2, depth = 1)->list:
    return list((length * width * depth, width, 'hola'))
#tambien puedo usar su forma abreviada
    return [length * width * depth, width, 'hola']

Si quiero retornar un set(conjunto):

def find_volum(length : int, width: int = 2, depth: int = 1)->list:
    return {length * width * depth, width, 'hola'}

Ya sabes que puedes castear. Espero te ayude.

Gordos. Comparto peso ideal jejejeej

lunes 21 de noviembre
podria estar jugando una copa del mundo de fifa pero estoy aca haciendole huevos como todos ustedes compas

Hice un programita inspirado en la clase que te saca los volumenes de varias figuras.

import math
def area_polygon(sides, length):
  alpha = 360 / (2 * sides)
  betha = (alpha* math.pi)/180 #pasar los grados a radianes
  tan_betha = math.tan(betha)
  apotema = length / (2 * tan_betha)
  perimeter = sides * length
  area = perimeter * apotema / 2  
  return area
  
def volume_prism(sides, length, heith):
  area = area_polygon(sides, length)
  my_volume = area * heith
  return round(my_volume, 2)

def volume_sphere(radius):
  return radius ** 3
  
def volume_pyramid(sides, length, heith):
  volume_p = volume_prism(sides, length, heith)
  my_volume = volume_p / 3
  return round(my_volume, 2)
  
def volume_cube(length, depth, heigth):
  my_volume = length * depth * heigth
  return round(my_volume, 2)
  
  
menu_01 = '''
Welcome to the Volume Calculator
Choose an option:
1 - Cube
2 - Sphere
3 - Prism
4 - Pyramid
__'''

option_01 = input(menu_01)

if option_01 == '1': 
  figure = 'Cube'
  side = int(input('Side length: '))
  my_volume = volume_cube(side)

elif option_01 == '2':
  figure = 'Sphere'
  radius = int(input('Radius length: '))
  my_volume = volume_sphere(radius)

elif option_01 == '3':
  figure = 'Prism'
  sides = int(input('Number of sides of your base: '))
  length = float(input("Side's length: "))
  heith = float(input('Heith: '))
  my_volume = volume_prism(sides, length, heith)
elif option_01 == '4':
  figure = 'Pyramid'
  sides = int(input('Number of sides of your base: '))
  length = float(input("Side's length: "))
  heith = float(input('Heith: '))
  my_volume = volume_pyramid(sides, length, heith)
   
    
print(f'The volume of your {figure} is {my_volume}') 

Excelente curso, no sabia que se podian retornar varios valores de una funcion y poderlos almacenar de esta forma tan sencilla en varias variables! gracias profe!

Multiples Return

#------------------ Return -------------------

# funcion para calcular un volumen
def find_volumen(length, width, depth):
  return length * width * depth

result = find_volumen(2,3,6)
print(result)
--> 36

# funcion para calcular un volumen con valores por defecto
# si no ingresa algun valor, la funcion se ejecuta y toma los valores por asignados por defecto
def find_volumen2(length=1, width=1, depth=1):
  return length * width * depth

result = find_volumen2()
print(result)
--> 1

# asignar un valor especifico a algun parametro de la funcion
result = find_volumen2(width = 12)
print(result)
--> 12

# funcion que retorna multiples valores
# retorna una tupla
def find_volumen3(length=1, width=1, depth=1):
  return length * width * depth, width, 'hola'

result = find_volumen3(length = 2)
print(result)
--> (2, 1, 'hola')

#obtener solo un valor de la tupla devuelta
print(result[0])
--> 2

# asiganar cada valor de una tupla a una variable
result, width, texto = find_volumen3()
print(result)
print(width)
print(texto)
--> 1
		1
		hola

en ingles no porfavor, queda uno mas enredado, habemos un0os nuegvos en esto y eso se nos complica nos confunde mucho

her realizado varios cursos incluso avanzados, pero hay que ver como se aperenden cosas nuevas, excelente clase!

Realmente hoy me siento más pythonista que NUNCA:

def find_volum(lenght, width, deph):
  return lenght * width * deph, width, '<== This is width'

result = find_volum(5,5,5)
print(result)

result, width, text = find_volum(5,5,5)
print(result)
print(width)
print(text)

Disfrutando de este maravilloso curso tengo 32 años no quiero para de aprender tengo alta habilidades de gamer toda una vida pero era ignorante sobre la programación ahora quiero implementarla en mi vida como prioridad dejando un lado los juego con ganas de ser programador backend

El momento en el que asigna a 3 variables (separados por coma) el resultado de find_volume(), se llamada desempaquetado. En otros lenguajes de programación como en Javascript es similar al destructuring.

El desempaquetado es útil cuando tienes un return mucho más largo y no quieres crear n-variables. Aunque no sería recomendable realizar muchos returns a partir de una función para restar complejidad (zen de Python). Si partimos desde la base que un return múltiple devuelve una tupla. Entonces el asunto es como se desempaqueta una tupla.
.
Aqui algunos ejemplos:
Se tiene la tupla de longitud 7.

x = (1,2,3,4,5,6,7)
a,b,c,d,e,f,g = x
print(a) # Devuelve 1
print(b) # Devuelve 2

Es improductivo asignar 1 a 1 y si no colocas la totalidad exacta arroja error.
En este caso puedes usar la asignación con *. Ejemplo:

x = (1,2,3,4,5,6,7)
a,b,*c = x
print(a) # Devuelve 1
print(b) # Devuelve 2
print(c) # Devuelve [3,4,5,6,7]

El uso del asterisco hace que todos los elementos restantes se asignen a una lista.
Ahora, también gracias a esta sintaxis se pueden traer los últimos valores. Ejemplo:

x = (1,2,3,4,5,6,7)
a,*b,c,d = x
print(a) # Devuelve 1
print(b) # Devuelve [2,3,4,5]
print(c) # Devuelve 6
print(d) # Devuelve 7

Lunes 6 de Marzo, podría estar siendo productivo en el trabajo, pero aquí estoy, tomando este maravilloso curso, porque me gusta, lo estoy disfrutando.

Increible, esto permitirá desarrollar cosas increibles

domingo 12 de febrero, 7:50 am estoy tomando mi curso en mi nueva Dell y justamente estaria juagano pero me importa mucho aprender para continuar con otro curso y considero que es una buena hora.

def find_volume(lenght=1, width=1, depth=1):
  return lenght * width * depth, width, 'hi'

result, width, text = find_volume(width=10)

print(result)
print(width)
print(text)

Estoy muy agredecida contigo, eres un maravilloso profesor, de lo mejor en platzi!

Contigo da gusto aprender

De verdad con esta clase aprendí mucho!

HOLAAA!! Aqui les dejo mi codigo espero ayude

'''
Multiples return
'''
def jumpline():
  print('-' * 25)

# Funcion para encontrar el volumen
def find_volume(length, width, depth):
  return length * width * depth

# Si intento ejecutar la funcion sin asignarle parametros nme va dar error
#result = find_volume()
#print(result) # TypeError

result = find_volume(10, 20, 3)
print(result) # 600
jumpline()

# Puedo asignar un valor por defecto en caso que no me den cierto argumento
def find_volume(length = 3, width = 15, depth = 2):
  return length * width * depth

result = find_volume()
print(result) # 90 Resultado de la multiplicacion de los valores por defecto
jumpline()

# Quiero solo asignar un valor, por ejemplo width
def find_volume(length = 3, width = 15, depth = 2):
  return length * width * depth

result = find_volume(width = 10)
print(result) # 60
jumpline()

# Tambien puedo retornar mas de una funcion
def find_volume(length = 3, width = 15, depth = 2):
  return length * width * depth, 'Volume', width

result = find_volume(width = 30)
print(result) # (180, 'Volume: ', 30) Me devuelve una tupla

print(result[0]) # 180
jumpline()

# Puedo de una vez asignar una variable a cada elemento de la tupla
result, text, width = find_volume(width = 30)
print(result, text, width) # 180 Volume 30
print(result) # 180
print(text) # Volume
print(width) # 30

Excelente los parámetros por defectos

#Asignar valores por defecto
def find_volume(length = 1, width = 1, depth = 1):
return length * width * depth, width, 'hola’
result, width, text = find_volume(width = 10)
print(result)
print(width)
print(text)

def find_volume(length = 1, width = 1, depth = 1):
  return length * width * depth,width,'hola'

result, width, text = find_volume(width=10)

print(result)
print(width)
print(text)

No estoy 100% seguro, pero creo que en geometria se usan las palabras height, length y width.

Conreturn podemos invocar para que se llamen varios datos al mismo tiempo y utilizando una sola funcion, para ello citaremos el siguiente ejemplo:

Vamos hallar el area de un cuadrado el cual tendrá sus valores de Alto, Ancho, Profundidad y que imprima un texto que diga: “El Valor del volumen es de:” y al final compare el resultado con el esperado.

Ejemplo

def fund_volumen(length=1, width=1, depth=1):
  return 'El valor del Volumen es de: ', length * width * depth, length

text, result, length = fund_volumen(length=10)

print(text)
print(result)
print(length)

_Producción:_
El valor del Volumen es de: 
10
10

Material de apoyo

CALCULADORA BASICA 😃

def inicio():
    usuario = input(str("Ingresa tu nombre: "));
    print(f"Bienvenido {usuario} Elige una opcion: ")
    print(f"1.Sumar  2.Restar 3.Multiplicar 4.Division 5.Ponenca");
    opciones = int(input("Elige una opción: "));
    if opciones == 1:
        suma(5,5);
    elif opciones == 2:
        resta(5,5);
    elif opciones == 3:
        multiplicacion(5,5);
    elif opciones == 4: 
        division(5,5);
    elif opciones == 5: 
         ponencia(5,5);
    else:
        print("Dato errorneo");

def suma(a,b):
    print(a + b);

def resta(a,b):
     print(a - b);

def multiplicacion(a,b):
     print(a * b);

def division(a,b):
     print(a / b);

def ponencia(a,b):
     print(a ** b);
     
inicio();

En las funciones se puede incluir un asterisco (*) indica que no se permiten argumentos posicionales después de él.

def pow(*,number, base ):
	""" elevar un número a una potencia base """
	return number**base

eg1 = pow(number=2, base=3)
# No es valida la llamada por posición 
eg2= pow(10,4)

no retorna únicamente el parámetro width, en tu caso lo hace porque 1101= 10

def volumen (altura , ancho , profundidad):
return altura * ancho * profundidad
resultado_volumen = volumen(5,5,5)
print(resultado_volumen)

def volumen2 (altura1=1 , ancho1=1 , profundidad1=1):
return altura1 * ancho1 * profundidad1, ancho1, "hola"
resultado_volumen2, altura1 , text = volumen2(altura1=10)
print(resultado_volumen2)
print(altura1)
print(text)

def volumen (altura , ancho , profundidad):
return altura * ancho * profundidad
resultado_volumen = volumen(5,5,5)
print(resultado_volumen)

En español, las palabras “lengt”, “width” y “depth” se traducen como:

“lengt”: longitud
"width": anchura o ancho
"depth": profundidad o altura

Estos términos son comúnmente utilizados para describir las dimensiones o medidas de objetos en tres dimensiones, como cajas, cubos, o cualquier otro tipo de forma tridimensional. Por ejemplo, si tienes un cubo, la longitud, anchura y profundidad serían las tres dimensiones que caracterizan su tamaño.

En palabras tecnicas, los valores por defecto en el mundo de python se les conoce como Argumentos nominales.
Estos argumentos nominales no solo toman valores especificos sino tambien genericos, es decir:

def person(name = str, edad = int, altura = float) -> list:
    return f"hola mi nombre es {name} y tengo {edad} años y mido {altura}"

resultado = person("Jose",23,21.2)
print(resultado)

Hay unos tipos de argumentos interesantes, que son los posiconales (*args,*kwargs), que seguramente verás en en lo avanzado.

Interesante el ejemplo de poder retornar distintas estructuras de datos en función de las necesidades del programador.

Los parámetros por defecto son valores predefinidos que se asignan a los parámetros de una función en caso de que no se proporcione un valor explícito al llamar a esa función. Esto permite que la función sea más flexible, ya que los parámetros por defecto evitan que sea necesario proporcionar todos los argumentos en cada llamada.

Aquí tienes un ejemplo de cómo definir una función con parámetros por defecto en Python:

def saludar(nombre, saludo="Hola"):
    mensaje = f"{saludo}, {nombre}!"
    return mensaje

# Llamada a la función sin especificar el saludo
print(saludar("Juan"))  # Salida: Hola, Juan!

# Llamada a la función especificando un saludo diferente
print(saludar("Ana", "¡Buenos días!"))  # Salida: ¡Buenos días!, Ana!

En el ejemplo anterior, la función saludar() tiene un parámetro saludo con un valor por defecto de “Hola”. Si no se proporciona un valor para saludo al llamar a la función, se utilizará el valor por defecto. Sin embargo, si se proporciona un valor para saludo, ese valor se utilizará en lugar del valor por defecto.

Respecto a los múltiples retornos, en Python es posible que una función devuelva más de un valor. Esto se puede lograr mediante el uso de una tupla o una lista para almacenar los valores y luego devolver esa estructura de datos.

Aquí tienes un ejemplo de una función que devuelve múltiples valores utilizando una tupla:

def obtener_coordenadas():
    x = 10
    y = 20
    z = 30
    return x, y, z

# Llamada a la función y desempaquetado de los valores devueltos
coordenada_x, coordenada_y, coordenada_z = obtener_coordenadas()

print(coordenada_x)  # Salida: 10
print(coordenada_y)  # Salida: 20
print(coordenada_z)  # Salida: 30

En este ejemplo, la función obtener_coordenadas() devuelve tres valores: x, y y z. Al llamar a la función y asignar el resultado a tres variables separadas, los valores se desempaquetan automáticamente en esas variables.

Ten en cuenta que también podrías devolver una lista en lugar de una tupla si prefieres utilizar ese tipo de estructura de datos. El enfoque exacto depende de tus necesidades y preferencias.

En el curso anterior lei la documentación y esto último se le llama unpacking, que es “sacar” variables o datos de un iterable.

def find_volume(length=1, width=1, depth=2): 
    return length * width * depth, width, 'hola
result, width, text = find_volume(width=10) # podemos separar por "," para asignar los resultados, en el mismo orden que la function return obtendremos las variables, se le llama unpacking

Utilizando parámetros por defecto para calcular el ingreso total por la venta de computadoras.

def ingreso(precio=1500, cantidad=20):
  return precio * cantidad

result = ingreso(cantidad=100)
print('El ingreso total es => ', result, 'USD')

🚀 “No cabe duda que cada vez es mas interesante con lo que se puede hacer con python 💻.”

Desempaquetado

Lo que hace el profe en el minuto 5:28 de poner las variables: (result, width, text) es lo que se conoce como desempaquetado, que asigna a las variables, los parametros. Es importante que hayan tantas variables como parametros, ni mas ni menos, de lo contrario mostrará un error.

Para tenerlo mas claro veamos este ejemplo:

vehiculo = ["Bus", "Moto", "Carro"]
x, y, z = vehiculos
print(x)  #Imprimirá Bus
print(y) #Imprimirá Moto
print(z) #Imprimirá Carro

Como vemos, si usted tiene una colección de valores en una tupla, lista, etc. Python le permite extraer los valores en variables. Esto se llama desempacar.

He venido trabajando en el juego del curso anterior de crear el juego de piedra, papel o tijera y estos son los resultados hasta ahora. Pueden probarlo y comentarme como lo ven 😊

import random

options = ('piedra', 'papel', 'tijera')
rounds = 1
user_win = 0
computer_win = 0

# Messages
victory_menssage = 'Has ganado'
defeat_message = 'Has perdido'
tie_message = 'Empate'
invalid_option_message = 'Opción no valida :('
user_win_message = 'El ganador es el usuario'
computer_win_message = 'El ganador es la computadora'

# show the message
def show_message(message):
  print(message)

def user_win_the_round():
  show_message(victory_menssage)
  print(f"{user_option} gana contra {computer_option}")

def computer_win_the_round():
  show_message(defeat_message)
  print(f"{user_option} pierde contra {computer_option}")

def results_of_round():
  print('Resultados:')
  print(f"Usuario => {user_win}")
  print(f"Computadora => {computer_win}")
  print("-" * 50)

while True:
  print('*' * 10)
  print('ROUND', rounds)
  print('*' * 10)
  
  # Select a option
  user_option = input('Piedra, papel o tijera => ').lower()
  computer_option = random.choice(options)

  # User option is in the options 
  if not user_option in options:
    show_message(invalid_option_message)
    continue
    
  elif user_option in options:
    print("Usuario = ", user_option)
    print("Computadora = ", computer_option)

    # Rules of Game
    if user_option == computer_option:
      show_message(tie_message)
      
    elif user_option == "piedra":
      if computer_option == "papel":
        computer_win_the_round()
        computer_win += 1

      elif computer_option == "tijera":
        user_win_the_round()
        user_win += 1
    
    elif user_option == "papel":
      if computer_option == "piedra":
        user_win_the_round()
        user_win += 1

      elif computer_option == "tijera":
        computer_win_the_round()  
        computer_win += 1
        
    elif user_option == "tijera":
      if computer_option == "piedra":
        computer_win_the_round()
        computer_win += 1

      elif computer_option == "papel":
        user_win_the_round()
        user_win += 1

  rounds += 1 
  results_of_round()

  if user_win == 3:
    show_message(user_win_message)
    break
  elif computer_win == 3:
    show_message(computer_win_message)
    break

Trataré de explicar la última parte con lo que entendí:

Primero, la funcion find_volume “retorna” tres valores.

def find_volume(length=1, width=1, depth=1):
  return length * width * depth, width, 'hola'

Estos son:

1. lengthwidthdepth
2. width
3. ‘hola’

Segundo, se guardan dichos valores en tres variables y se modifica el valor de width a 10

result, width, text = find_volume(width=10)

Las variables son:

1. result que guarda lengthwidthdepth
2. width que guarda width
3. text que guarda ‘hola’

Por último, se imprimen las tres variables:

print(result)
print(width)
print(text)

Podemos implementar una simple lógica para imprimir si estamos calculando el volumen con los valores por default o con valores nuevos para la función. También añadí un parámetro que podamos indicar la unidad de medida.

# Return & args
def find_volume(length=1, width=2, depth=3, measurement_unit=str):
    measurement_unit = measurement_unit
    if length == 1 and width == 2 and depth == 3:
        v = length * width * depth
        print(f"Haciendo uso de mi función 'find_volume', volumen por default: {v} {measurement_unit}")
        return v

    else:
        v = length * width * depth
        print(f"Haciendo uso de mi función 'find_volume', el volumen calculado es: {v} {measurement_unit}")
        return v


volume = find_volume(measurement_unit="mts")
volume_2 = find_volume(3, 5, 7, measurement_unit="mts")

Les comparto mi interpretación de esta clase utilizando strings para que la impresión en consola sea mucho más clara:

def find_volume(lenght=1, width=1, depth=1):
    return f'lenght = {lenght}, width = {width}, depth = {depth}', f'volume = {lenght * width * depth}'

result = find_volume(10, 20, 35)
print(result)

En este caso, como se ingresaron algunos valores a la función, el resultado en consola es el siguiente:

(‘lenght = 10, width = 20, depth = 35’, ‘volume = 7000’)

Las funciones con parámetros por defecto permiten que una función tenga argumentos opcionales que, si no se proporcionan, se utilizarán valores predeterminados. Esto significa que el usuario puede proporcionar valores para los argumentos opcionales, pero si no lo hace, se utilizarán los valores predeterminados. Aquí hay un ejemplo:

def calcular_edad(nombre, año_nacimiento, año_actual=2023):
    edad = año_actual - año_nacimiento
    return f"{nombre} tiene {edad} años."

# Llamada a la función con todos los argumentos
print(calcular_edad("Juan", 1990, 2023))

# Llamada a la función con argumento opcional
print(calcular_edad("Pedro", 1985))

Wow excelente clase, retornar múltiples valores en una función puede optimizar muchísimo nuestras soluciones y ayudarnos a tener un código más limpio.

Les comparto el código de la clase comentado 💚

# Parámetros por defecto y múltiples returns

# Definiendo valores por defecto para cada parametro de la funcion
def find_volume(length=1, width=1, depth=1):
  # Puedo retornar multiples valores separados por coma
  return length * width * depth, width, "Hola"

# Llamar la funcion enviando alguno de sus argumentos
result = find_volume(width=10)

# Llamar la funcion enviando todos sus argumentos
result = find_volume(10, 20, 30)

# Al retornar multiples valores, estos se almacenan en una tupla ()
# Imprimir la tupla completa
print(result)

# Pruedo almacenar cada valor de la tupla en una variable independiente
result, width, string = find_volume(10, 20, 30)
print(result)
print(width)
print(string)

Que buena clase

def find_volume(length=1, width=1, depth=1):
  return length * width * depth, width, 'hola'

result = find_volume(10, 20, 3)

print(result)

result = find_volume()
print(result[2])

result = find_volume(width=10)
print(result[1])

result = find_volume(width=7, length=5)
print(result[0])

result, width, text = find_volume(width=7, length=5)
print(result, width, text)

#Parametros por defecto y retornos multiples

#Sin parametros por defecto
def fin_volume(length,width,depth):
    return length*width*depth

resultado=fin_volume(10,20,30)
print(resultado)    

#Con parametros por defecto para todos
def find_volume(length=1,width=1,depth=1):
    return length*width*depth

resultado1=find_volume()
resultado2=find_volume(width=10)
print(resultado1)    
print(resultado2)

#Multiples returns, lo devuelve como tupla
def find_volumen(length=1,width=1,depth=1):
    return length*width*depth,width,"hola"
resultado3=find_volumen(width=10)
print(resultado3)
print(resultado3[0]) #Porque es una tupla

#Alternativa a multiples returns
def find_volumen(length=1,width=1,depth=1):
    return length*width*depth,width,"hola"
resultado4,ancho,texto=find_volumen(width=10)
print(resultado4)
print(texto)
print(ancho)

por eso me encanta ver los cursos, aunque sean iniciales, porque siempre hay algo nuevo que aprender, nunca habia visto lo de retorno multiple

el resulto con tuplas:

metodo 02, retorna una tupla

def find_volume(length=1, width=1, depth=1):
return length * width * depth, width, ‘hola’

result = find_volume(width=10)

print("resultado ",result [0], "width ", result [1], " text ", result [2])

#obtener el volumen

largo = int (input("Ingrese el largo: "))
ancho = int (input("Ingrese el ancho "))
profundidad = int (input ("Ingrese profundidad: "))

def volumen (largo, ancho, profundidad):
vol = (largoanchoprofundidad)
#retorno multiples variables, no solo el volumen
return vol, “Este es el resultado”, 10

resultado_volumen = volumen(largo, ancho, profundidad)
print (f"El volumen de los valores ingresados es: {resultado_volumen}")

""" returns """
def find_volume(length=-1, width=-1, depth=-1):
  res = length * width * depth
  return res, "El volumen es:", depth

volume, texto, var = find_volume(2, 3, 4)
print(texto, volume)

prueba, texto, x = find_volume()
print(prueba)

#Función para hallar la hipotenusa de un triángulo
import math
catetoA = int(input("Ingrese el valor del cateto A: "))
catetoB = int(input("Ingrese el valor del cateto B: "))
def hipotenusa(catetoA, catetoB):
  return round(math.sqrt(catetoA **2 + catetoB **2),2)

respuesta = hipotenusa(catetoA, catetoB)
print(f"Si cateto A = {catetoA} y cateto B = {catetoB}. La hipotenusa del triángulo es {respuesta}")