""

lunes, 3 de febrero de 2025

Refuerzo funciones Libro Python para principiantes

Fuente: Libro "Python para principiantes". Practical books. Medellin, Colombia, 2023

14.2. Definición de funciones

En este punto del libro, esperamos que ya esté familiarizado con algunas funciones que provee
Python, tales como: print, input y len.

Una función es un bloque de código que está diseñado para hacer una tarea específica. Por ejemplo, la función input está diseñada para recoger datos que ingresa el usuario por teclado. La función print está diseñada para imprimir información por pantalla. Una función también puede verse como un “mini programa” que puede usarse dentro de un programa.

El propósito de usar funciones es dividir un programa grande en pequeñas partes. Y de esta manera hacer que el código sea más modular y reutilizable. En Python podemos definir nuestras propias funciones, para ello veamos la estructura de una función.
 

Estructura de una función
Una función posee una estructura como la presentada en la Figura 14-5.

 

 1. Se utiliza la palabra reservada de Python def (que indica que vamos a definir una
función).
2. Se define el nombre de la función. Se recomienda colocar un nombre alusivo a la acción
específica que realiza la función (recuerde no utilizar como nombre de la función,
nombres de palabras reservadas de Python).
3. Se agregan paréntesis “()” y dentro de los paréntesis se definen los parámetros que
recibe la función. Los parámetros son opcionales. En la siguiente sección se explicará
cómo se comportan las funciones con parámetros.
4. Se colocan dos puntos “:”.
5. Se define el cuerpo de la función. Allí se coloca la instrucción (o instrucciones) propias de
la función. Esa instrucción (o instrucciones) se deben colocar como bloques de código
indentados. Es decir, mover de izquierda a derecha (con respecto a def) mediante una tabulación.
6. Si la función tiene retorno, se debe colocar la palabra reservada de Python return,
seguida del valor a retornar. El retorno es opcional y se explicará en una sección posterior.
7. Finalmente, cuando se desee ejecutar el código de la función, esta se debe llamar o
“invocar”. Para invocar una función se debe colocar, por fuera del cuerpo de la función,
el nombre de la función, seguida de paréntesis y se deben enviar tantos argumentos
como parámetros tenga la función.

Definiendo nuestra primera función
Teniendo en cuenta la estructura anterior es hora de definir nuestra primera función.
Inicialmente, definiremos una función simple sin parámetros ni retorno. El siguiente código
muestra cómo definir una función llamada saludar, que se encarga de imprimir por pantalla un
texto de saludo.

• En la línea 1 definimos la función saludar que no recibe parámetros.
• En las líneas 2 y 3 definimos el cuerpo de la función. En este caso la función se encarga de
imprimir dos textos por pantalla.
• Luego, en la línea 5 invocamos la función, esto implica que se ejecutará el cuerpo de la
función y se imprimirán los dos textos por pantalla.
• Al terminar la ejecución de la función, se ejecuta la línea 6 y se imprime por pantalla el
texto "Fin programa".

Codificar y ejecutar

1. def saludar():
2. print("Bienvenido")
3. print("A mi programa")
4.
5. saludar()
6. print("Fin programa")



Flujo de ejecución
El flujo de ejecución de un programa que contiene la definición de una función propia es un poco
diferente a los flujos de ejecución que hemos visto en este libro. Por lo tanto, hagamos
seguimiento, paso a paso, de las líneas de código (del código anterior) que se ejecutan y en qué
orden lo hacen (ver Figura 14-7):
• Paso 1: Se ejecuta la línea 5. Allí invocamos la función saludar. Las líneas 1 a 3 son
omitidas por Python (dado que allí se encuentra el código de la función saludar). Esto
quiere decir que el código que define una función no se ejecuta por defecto.
• Paso 2: Luego de la invocación anterior, se ejecuta la línea 1.
• Pasos 3 y 4: Se ejecuta el cuerpo de la función saludar y se imprimen los dos textos allí
definidos.
• Paso 5: El cuerpo de la función termina, y ahora el programa retorna a su ejecución
principal (a la línea 6, línea posterior a la invocación de la función). Allí se imprime por
pantalla el texto "Fin programa".

Ejercicio:
Basado en el siguiente código, responda: (i) ¿Qué líneas y en qué orden se ejecutan? Y (ii) ¿Cuál
será la salida por pantalla?

Codificar y ejecutar

1. def saludar():
2.      print("Bienvenido")
3.     print("A mi programa")
4.
5. saludar()
6. saludar()

Curso virtual de Python UniAndes - Coursera / 3.1 Un programa para leer

 

3.1. Un programa para leer

Como dijimos en el primer capítulo, una habilidad importante que se debe desarrollar es la capacidad para leer código escrito por alguien más. En esta sección presentamos un nuevo ejemplo para que se ejercite y para que también observe varias de las características de Python que se van a estudiar en este nivel.

Al igual que en el nivel 1, el programa no tiene comentarios para que el ejercicio de lectura sea más exigente pero también más útil. Un programa tan largo como este normalmente tendría una buena cantidad de comentarios.


3.1.1. Lógica de la aplicación

El siguiente es el contenido completo del módulo logica_juego1.

>>import random

>>def mano_nueva()->dict:
>>    mano = {'carta1': carta_nueva(), 'carta2': carta_nueva(), 'tam': 2}
>>    return mano

>>def carta_nueva()->dict:
>>    palo = nombre_palo(random.randint(1,4))
>>    valor = random.randint(1,13)
>>    nombre_carta = "{} de {}".format(nombre_valor(valor), palo)
>>    carta = {"palo": palo, "valor": valor, "nombre" : nombre_carta}
>>    return carta

>>def agregar_carta(mano: dict)->dict:
>>    tam_actual = mano['tam']
>>    nueva_carta = carta_nueva()
>>    nueva_llave = 'carta{}'.format(tam_actual + 1)
>>    mano[nueva_llave] = nueva_carta
>>    mano['tam'] = tam_actual + 1
>>    return nueva_carta


>>def nombre_palo(num_palo: int)->str:
>>    nombre = "Picas"
>>    if num_palo == 2:
>>        nombre = "Corazones"
>>    elif num_palo == 3:
>>        nombre = "Tréboles"
>>    elif num_palo == 4:
>>        nombre = "Diamantes"
>>    return nombre


>>def nombre_valor(valor: int)->str:
>>    nombre = str(valor)
>>    if valor == 1:
>>        nombre = "AS"
>>    elif valor == 11:
>>        nombre = "J"
>>    elif valor == 12:
>>        nombre = "Q"
>>    elif valor == 13:
>>        nombre = "K"
>>    return nombre


>>def contar_puntos_mano(mano: dict)->int:
>>    puntos = contar_puntos_carta(mano, 1)
>>    puntos += contar_puntos_carta(mano, 2)
>>    puntos += contar_puntos_carta(mano, 3)
>>    puntos += contar_puntos_carta(mano, 4)
>>    puntos += contar_puntos_carta(mano, 5)
>>    return puntos


>>def contar_puntos_carta(mano: dict, numero_carta: int)->int:
>>    puntos = 0
>>    llave = "carta{}".format(numero_carta)
>>    if llave in mano:
>>        carta = mano[llave]
>>        valor = carta["valor"]
>>        if valor == 1:
>>            puntos = 11
>>        elif valor > 10:
>>            puntos = 10
>>        else:
>>            puntos = valor        
>>    return puntos


>>def casa_debe_continuar(mano_casa: dict)->bool:
>>    puntos_casa = contar_puntos_mano(mano_casa)
>>    return puntos_casa < 16 or puntos_casa > 21

 

Preguntas: A partir de su lectura del programa, intente responder las siguientes preguntas. No se preocupe si no está seguro de algo, al final del nivel todas sus dudas deberían haber quedado aclaradas.

  • ¿Cuál cree que es el objetivo del programa?

  • ¿Cuál es el objetivo de cada bloque?

  • ¿Qué elementos de la sintaxis utilizada no conoce todavía?

    Lectura del programa por parte de PPI:

    El objetivo del programa parece ser la ejecución de un juego de cartas o naipes.

    Los objetivos de cada bloque son: retornar una mano nueva de cartas; retornar una carta; Identificar el nombre de un palo; identificar el valor y pinta de la carta; contar puntos de la mano; contar puntos de la carta; determinar si la casa debe continuar con el juego.

     

    3.1.2. Interfaz de la aplicación

    El siguiente es el contenido completo del módulo interfaz_juego1.

    >>import logica_juego1 as juego
    
    >>def mostrar_menu()->int:
    >>    print("\n¿Cómo quiere continuar?")
    >>    print("  1. Quiero otra carta")
    >>    print("  2. No quiero más cartas")
    >>    respuesta = input("Seleccione una opción: ")
    >>    if respuesta.isnumeric():
    >>        opcion = int(respuesta)
    >>        if opcion != 1 and opcion != 2:
    >>            print("Sólo podía seleccionar 1 o 2. Suponemos que no quiere más cartas")
    >>            opcion = 2            
    >>    else:
    >>        print("Sólo podía seleccionar 1 o 2. Suponemos que no quiere más cartas")
    >>        opcion = 2
    >>    return opcion
    
    
    >>def mostrar_primera_carta(mano: dict)->None:
    >>    plantilla = "La mano tiene {} cartas y está mostrando un {}"
    >>    print(plantilla.format(mano['tam'], mano['carta1']['nombre']))
    
    
    >>def mostrar_mano_abierta(mano: dict)->None:
    >>    num_cartas = mano['tam']
    >>    puntos_mano = juego.contar_puntos_mano(mano)
    >>    plantilla = "La mano tiene {} cartas y vale {} puntos"
    >>    print(plantilla.format(num_cartas, puntos_mano))
    >>    print("  La primera carta es: ", mano['carta1']['nombre'])
    >>    print("  La segunda carta es: ", mano['carta2']['nombre'])
    
    >>    if num_cartas >= 3:
    >>        print("  La tercera carta es: ", mano['carta3']['nombre'])
    
    >>    if num_cartas >= 4:
    >>        print("  La cuarta carta es: ", mano['carta4']['nombre'])
    
    >>    if num_cartas >= 5:
    >>        print("  La quinta carta es: ", mano['carta5']['nombre'])
    
    
    >>def mostrar_juego_actual(mano_jugador: dict, mano_casa: dict, abrir_casa: bool = False):
    >>    print("MANO JUGADOR")
    >>    mostrar_mano_abierta(mano_jugador)
    >>    print("MANO CASA")
    >>    if abrir_casa:
    >>        mostrar_mano_abierta(mano_casa)
    >>    else:
    >>        mostrar_primera_carta(mano_casa)
    
    
    >>def turno_jugador(mano_jugador: dict, mano_casa: dict)->bool:
    >>    continuar_juego = True
    >>    opcion = mostrar_menu()
    >>    if opcion == 2:
    >>        continuar_juego = False
    >>    else:
    >>        nueva = juego.agregar_carta(mano_jugador)
    >>        print("Tu nueva carta es: ", nueva['nombre'])
    >>        mostrar_juego_actual(mano_jugador, mano_casa)
    >>        puntos_mano = juego.contar_puntos_mano(mano_jugador)
    >>        if puntos_mano > 21:
    >>            print("\nTienes más de 21 puntos: ¡Perdiste!")
    >>            continuar_juego = False
    >>        elif puntos_mano == 21:
    >>            print("\nTienes exactamente 21 puntos: esperemos que la casa no tenga lo mismo.\n")
    >>            continuar_juego = False
    >>            
    >>    return continuar_juego
    
    
    >>def turno_casa(puntos_jugador: int, mano_casa: dict)->bool:
    >>    continuar_juego = True
    >>    puntos_casa = juego.contar_puntos_mano(mano_casa)
    >>    if puntos_casa > puntos_jugador:
    >>        print("La casa gana: {1} de la casa vs {0} del jugador".format(puntos_jugador, puntos_casa))
    >>        continuar_juego = False
    >>    else:
    >>        if juego.casa_debe_continuar(mano_casa):
    >>            nueva = juego.agregar_carta(mano_casa)
    >>            print("La casa saca otra carta ... {}".format(nueva['nombre']))
    >>            mostrar_mano_abierta(mano_casa)
                
    >>        puntos_casa = juego.contar_puntos_mano(mano_casa)
    >>        if puntos_casa > 21:
    >>            print("\nLa casa tiene más de 21: ¡el jugador gana!\n")
    >>            continuar_juego = False
    >>        elif puntos_casa == 21:
    >>            print("\nLa casa tiene 21: ¡la casa gana!\n")
    >>            continuar_juego = False
        
    >>    return continuar_juego
    
    
    >>def iniciar_aplicacion()->None:
    >>    mano_jugador = juego.mano_nueva()
    >>    mano_casa = juego.mano_nueva()
    >>    mostrar_juego_actual(mano_jugador, mano_casa)
    
    >>    continuar_juego = True
    
    >>    # tercera carta del jugador
    >>    if continuar_juego:
    >>        continuar_juego = turno_jugador(mano_jugador, mano_casa)
    
    >>    # cuarta carta del jugador
    >>    if continuar_juego:
    >>        continuar_juego = turno_jugador(mano_jugador, mano_casa)
    
    >>    # quinta carta del jugador
    >>    if continuar_juego:
    >>        continuar_juego = turno_jugador(mano_jugador, mano_casa)
    
    >>    puntos_jugador = juego.contar_puntos_mano(mano_jugador)
    >>    if puntos_jugador <= 21:
    >>        mostrar_juego_actual(mano_jugador, mano_casa, True)
    >>        print("\nEs el turno de la casa de jugar\n")
    >>        continuar_juego = True
            
    >>    # tercera carta de la casa
    >>    if continuar_juego:
    >>        continuar_juego = turno_casa(puntos_jugador, mano_casa)
    
    >>    # cuarta carta de la casa
    >>    if continuar_juego:
    >>        continuar_juego = turno_casa(puntos_jugador, mano_casa)
        
    >>    # quinta carta de la casa
    >>    if continuar_juego:
    >>        continuar_juego = turno_casa(puntos_jugador, mano_casa)
    
    >>    puntos_casa = juego.contar_puntos_mano(mano_casa)
    >>    if puntos_casa < puntos_jugador and puntos_jugador <= 21:
    >>        print("¡Ganaste!: tienes {} puntos vs {} puntos de la casa".format(puntos_jugador, puntos_casa))
    
    
    >>iniciar_aplicacion() 

    Preguntas: A partir de su lectura del programa, intente responder las siguientes preguntas. No se preocupe si no está seguro de algo, al final del nivel todas sus dudas deberían haber quedado aclaradas.

  • ¿Cuál cree que es el objetivo del programa?

  • ¿Qué información tendrá que suministrar el usuario que ejecute el programa?

  • ¿Cuál es el objetivo de cada bloque?

  • ¿Qué es lo que primero se ejecuta?


 

Curso Virtual de Python UniAndes - Coursera / Nivel 2 "Tomando desiciones 3.0 Introduccion.

../_images/nivel2.png 

3. Introducción

Machines take me by surprise with great frequency.

—Alan Turing

En este nivel se presentan los conceptos necesarios para que un programa no siempre se ejecute de la misma manera, sino que pueda tomar decisiones dependiendo de las condiciones en que se ejecute y de los datos que proporcione el usuario. En este nivel también se introduce una estructura de datos (diccionarios) que permite manejar información más compleja que la que permiten los tipos simples presentados hasta acá.

Los conceptos principales que se estudian en este nivel son los siguientes:

  • Valores de verdad (booleanos)

  • Instrucciones condicionales

  • Diccionarios

  • Paso de parámetros por valor y por referencia

  • Módulos adicionales

 

Curso Virtual Python UniAndes - Coursera / 2.12 Ejercicios adicionales

 

2.12. Ejercicios adicionales


2.12.1. Conceptos básicos

  1. Defina y dé un ejemplo para cada uno de los siguientes conceptos que se estudiaron en este capítulo:

    • Tipo de datos

    • Variable

    • Expresión

    • Operador

    • Función

    • Parámetro

  2. ¿Qué tipo de dato utilizaría para representar cada uno de los siguientes elementos?

    • El nombre de una persona

    • El número de identificación de una persona

    • La edad de una persona

    • El cilindraje del motor de un carro

    • La capacidad en litros del baúl de un carro

    • El año de fabricación de un carro

    • La marca de un carro

Solución de PPI al item 2.12.1:

Tipos de datos: numéricos (int, float); boleanos (True, false); Cadenas de texto (str). Listas (list); tuplas(tupla); diccionario (dic)  ejemplo:

>>numero = 5

>>print(type(numero))

>>> class int

Variable: es un objeto de python que tiene un nombre y un valor almacenado. A su vez el valor almacenado tiene un tipo de dato y ocupa un espacio de memoria en el computador. ejemplo: 

>>numero =5

2.  

Para representar el nombre de una persona se utiliza un String

El numero de identificación de una persona es un tipo int.

la edad de una persona es tipo int.

El cilindraje de motor de un carro puede ser tipo float.

La capacidad en listros del baul de un caro tambien tipo float.

El año de fabricacion de un carro es int.

La marca de un carro es String


2.12.2. Lectura de programas

¿Qué imprimen los siguientes programas? Intente predecir qué van a imprimir los siguientes programas y después copie el código al intérprete de Python y verifique sus respuestas.

>># Bloque de codigo 1
>>v1 = 5
>>v2 = 1 + v2
>>v3 = v1 + v2
>>v4 = v3 / (4 + 1)
>>print("v4:", v4)
>># Bloque de codigo 2
>>v1 = 5
>>v2 = v1 ** 2
>>v2 = v1 + v2
>>print("v2:", v2)
>># Bloque de codigo 3
>>v1 = '5'
>>v2 = v1 * 3
>>print("v2:", v2)
>># Bloque de codigo 4
>>v1 = '5'
>>v2 = v1 * 3
>>v3 = v1 + v2
>>print("v3:", v3)
>># Bloque de codigo 5
v1 = '5'
>>v2 = v1 * 3
>>v3 = v1 + v2 + 9
>>print("v3:", v3)
>># Bloque de codigo 6
v1 = 124
>>v2 = v1 // 3
>>v3 = v1 % 3
>>print("124/3:", v2, v3)

Solución de PPI al item 2.12.2 :

El primer bloque de código debe generar un error porque v2 no esta definida. ademas v4 depende de v3 y v3 a su vez depende de v2. 
--------------------------------------------------
NameError        Traceback (most recent call last)
<ipython-input-1-1cb42efe49df> in <cell line: 0>()
      1 v1 = 5
----> 2 v2 = 1 + v2
      3 v3 = v1 + v2
      4 v4 = v3 / (4 + 1)
      5 print("v4:", v4)

NameError: name 'v2' is not defined
El segundo bloque de código arroja el siguiente resultado: v2: 30
El tercer bloque de código tiene una particularidad y es que  a la vble v1 se le asigna el str '5'; v2 : '555'
El cuarto bloque de código arroja v3:'5555'
El quinto bloque de código arroja un error ya que v3= '5555' +9 la suma de entre un Str y un int no es posible
-------------------------------------------------
TypeError        Traceback (most recent call last)
<ipython-input-5-65de4ed229b8> in <cell line: 0>()
      2 v1 = '5'
      3 v2 = v1 * 3
----> 4 v3 = v1 + v2 + 9
      5 print("v3:", v3)

TypeError: can only concatenate str (not "int") to str

El sexto bloque de codigo arroja como respuesta: 124/3: 41 1

2.12.3. Búsqueda de errores

Revise con atención los siguientes enunciados y el programa que intenta resolverlos. Explique cuál es el problema del programa y corrí jalo.

Ayuda: Si no encuentra los problemas leyendo el código, copie los programas a su IDE y ejecútelos para intentar diagnosticar los problemas. Para esto tendrá que identificar valores de los parámetros que le sean útiles y posiblemente hacer los cálculos a mano para ver qué podría estar mal.

2.12.3.1. Tiempo de descarga

Enunciado: Escriba una función que reciba la velocidad del Internet de un usuario (en Mbps, es decir, Megabits por segundo), y el tamaño de un archivo a descargar (en GB, es decir, Gigabytes), y retorne el tiempo en minutos estimado (redondee al entero más cercano), para realizar la descarga de dicho archivo sobre esa red. Para esto, tenga en cuenta que el tiempo lo puede calcular como t = tamaño archivo/velocidad descarga. El tamaño y velocidad deben estar en unidades homogéneas (por ejemplo, MB y MB/s, o GB y GB/s) para que se puedan operar). Nota: Recuerde que un MB (Megabyte) equivale a 8 Mb (Megabits), y que un GB equivale a 1000 MB.

>>def calcular_tiempo_descarga(velocidad: int, tamanio_archivo: int)->int:
>>    """ Tiempo de descarga
>>    Parámetros:
>>      velocidad (int): Velocidad de descarga de la red, en Mbps
>>      tamanio_archivo (int): Tamaño del archivo a descargar, en GB
>>    Retorno:
>>      int: Tiempo estimado en minutos que toma la descarga del archivo
>>    """
>>    gb_megas = tamanio_archivo * 1000
>>    v = velocidad * 8
>>    tiempo = gb_megas / v
>>    return round(tiempo)

2.12.3.2. IVA y propina

Enunciado: Escriba una función que reciba el costo en pesos de una cuenta de restaurante, y luego calcule el impuesto IVA asociado y la propina para el mesero. La tasa del IVA corresponde al 19%, y la propina en el restaurante es del 10% del valor de la factura (sin impuestos). Debe retornar una cadena que muestre el IVA, propina y total de la siguiente manera: “X,Y,Z”, donde X es el IVA, Y la propina y Z el total. No olvide aproximar los números al entero más cercano.

>>def calcular_iva_propina_total_factura (costo_factura: int) -> str:
>>    """ IVA y propina
>>    Parámetros:
>>      costo_factura (int): Costo de la factura del restaurante, sin impuestos ni propina
>>    Retorno:
>>      str: Cadena con el iva, propina y total de la factura, separados por coma
>>    """
>>    IVA = round (costo_factura*19/100)
>>    propina = round (costo_factura*10/100) 
>>    total = round (costo_factura + propina + IVA)
>>    return str(IVA) + "," + str(propina) + "," + str(total)

2.12.3.3. Saludo prolongado

Enunciado: Escriba una función que reciba un nombre y un entero, y retorne la cadena ‘Hola’ seguida del nombre recibido por parámetro, pero con la letra ‘o’ repetida tantas veces como indique el entero recibido, así como la letra ‘a’ la mitad de las veces que la ‘o’ (si la mitad no es exacta, se debe tomar la parte entera). Por ejemplo, si se reciben como parámetros ‘Egan’ y 5, la cadena a retornar será ‘Hooooolaa Egan’.

>>def saludar_repetidas_veces(nombre: str, veces: int)->str:
>>    """ Saludo prolongado
>>    Parámetros:
>>      nombre (str): Nombre a incluir en el saludo
>>      veces (int): Cantidad de veces a repetir las letras
>>    Retorno:
>>      str: Cadena con el saludo con letras repetidas
>>    """
>>    o_varias_veces = "o" * veces
>>    a_varias_veces = "a" * (veces//2)
>>    return "h" + o_varias_veces + "l" + a_varias_veces +" "+ nombre

2.12.4. Solución de problemas

  1. Enunciado: El volumen de un cilindro se puede calcular multiplicando el área de su base circular por su altura. Cree una función que reciba el radio de la base y la altura del cilindro, y calcule su volumen. Retorne el resultado redondeado a un solo decimal.

  2. Enunciado: Cree una función que pueda calcular el índice de masa corporal (BMI) de una persona a partir de su peso en libras y su altura en pulgadas. La fórmula para calcular el BMI es la siguiente:

, pero para que la fórmula funcione debe estar en kilogramos y
  1. en metros. Recuerde que 1 libra corresponde a 0.454 kg, y que 1 pulgada corresponde a 0.0254 metros. El valor de retorno debe estar redondeado a dos decimales.

     

     

Entradas recientes

Que dice Gemini Notebook sobre POO en Python?

PPI:   Me gustaría que al comienzo me explicaras POO sin tener en cuenta la ingenieria de confiabilidad y quisiera resolver los ejercicios e...

Entradas Populares