Funciones y Módulos de Python

Introducción

En este laboratorio, explorarás dos conceptos fundamentales en la programación de Python: funciones y módulos. Las funciones te permiten organizar tu código en bloques reutilizables, lo que hace que tus programas sean más modulares y fáciles de entender. Los módulos te permiten organizar funciones y variables relacionadas en archivos separados, lo que promueve la reutilización y el mantenimiento del código. Al dominar estos conceptos, podrás escribir código de Python más eficiente y organizado.

Skills Graph

Definición y Uso de Funciones

En este paso, aprenderás cómo definir y usar funciones en Python.

1. Abre el intérprete de Python escribiendo el siguiente comando en tu terminal:

   python

   Deberías ver el indicador de Python (>>>), lo que indica que ahora estás en la shell interactiva de Python.

2. Comencemos definiendo una función simple que salude a una persona. En el intérprete de Python, escribe lo siguiente:

   >>> def greet(name):
   ...     return f"Hello, {name}!"
   ...
   >>> result = greet("Alice")
   >>> print(result)
   Hello, Alice!

   1. Las funciones se definen utilizando la palabra clave def seguida del nombre de la función y los parámetros entre paréntesis. El cuerpo de la función está indentado.
   2. Esta función toma un parámetro name y devuelve una cadena de saludo. Luego llamamos a la función con el argumento "Alice" y mostramos el resultado.
   3. La declaración return se utiliza para devolver un valor desde la función. Si no hay una declaración return, la función devuelve None.
   4. Las funciones se pueden utilizar para encapsular código reutilizable y realizar tareas específicas. Son el bloque de construcción principal de los programas de Python.

3. Ahora, creemos una función que realice un cálculo:

   >>> def calculate_area(length, width):
   ...     return length * width
   ...
   >>> area = calculate_area(5, 3)
   >>> print(f"The area is: {area}")
   The area is: 15

   Esta función calcula el área de un rectángulo dado su largo y ancho.

4. Las funciones también pueden tener valores de parámetros predeterminados:

   >>> def power(base, exponent=2):
   ...     return base ** exponent
   ...
   >>> print(power(3))
   9
   >>> print(power(3, 3))
   27

   Aquí, si no se proporciona un exponente, la función utiliza 2 como valor predeterminado.

5. Las funciones pueden devolver múltiples valores utilizando tuplas:

   >>> def min_max(numbers):
   ...     return min(numbers), max(numbers)
   ...
   >>> minimum, maximum = min_max([1, 5, 3, 9, 2])
   >>> print(f"Minimum: {minimum}, Maximum: {maximum}")
   Minimum: 1, Maximum: 9

   Esta función devuelve tanto el valor mínimo como el máximo de una lista de números.

Recuerda, la indentación es crucial en Python. Los cuerpos de las funciones deben estar indentados de manera consistente.

Comprendiendo el Alcance de las Funciones

En este paso, aprenderás sobre el alcance de las funciones y cómo se comportan las variables dentro y fuera de las funciones.

1. En el intérprete de Python, exploremos las variables locales y globales:

   >>> x = 10  ## Variable global
   
   >>> def print_x():
   ...     print(f"Global x: {x}")
   ...
   >>> print_x()
   Global x: 10
   
   >>> def change_x():
   ...     x = 20  ## Variable local
   ...     print(f"Local x: {x}")
   ...
   >>> change_x()
   Local x: 20
   >>> print(f"Global x after change_x(): {x}")
   Global x after change_x(): 10

   Observa que la función change_x() crea una nueva variable local x, que no afecta a la variable global x.

2. Para modificar una variable global dentro de una función, utiliza la palabra clave global:

   >>> def modify_global_x():
   ...     global x
   ...     x = 30
   ...     print(f"Modified global x: {x}")
   ...
   >>> modify_global_x()
   Modified global x: 30
   >>> print(f"Global x after modify_global_x(): {x}")
   Global x after modify_global_x(): 30

   Ahora la variable global x ha sido modificada.

3. Las funciones también pueden acceder a variables de su alcance envolvente:

   >>> def outer_function(x):
   ...     def inner_function():
   ...         print(f"x from outer function: {x}")
   ...     inner_function()
   ...
   >>> outer_function(40)
   x from outer function: 40

   La función interna puede acceder al parámetro x de la función externa.

Comprender el alcance de las funciones es crucial para escribir código limpio y sin errores. Ayuda a prevenir efectos secundarios no deseados y hace que tus funciones sean más predecibles.

Creación y Uso de Módulos

En este paso, aprenderás cómo crear y usar módulos de Python.

1. Sal del intérprete de Python escribiendo exit() o presionando Ctrl+D.

2. Abre el WebIDE en el entorno de la máquina virtual (VM) de LabEx.

3. Crea un nuevo archivo llamado math_operations.py en el directorio ~/project:

   touch ~/project/math_operations.py

4. Abre el archivo recién creado en el editor del WebIDE y agrega el siguiente contenido:

   ## math_operations.py
   
   def add(a, b):
       return a + b
   
   def subtract(a, b):
       return a - b
   
   def multiply(a, b):
       return a * b
   
   def divide(a, b):
       if b!= 0:
           return a / b
       else:
           return "Error: Division by zero"
   
   PI = 3.14159

   Este módulo contiene cuatro operaciones matemáticas básicas y una constante PI.

5. Guarda el archivo (el auto - guardado está habilitado en el WebIDE).

6. Ahora, crea otro archivo llamado use_math_module.py en el mismo directorio:

   touch ~/project/use_math_module.py

7. Abre use_math_module.py en el editor del WebIDE y agrega el siguiente contenido:

   ## use_math_module.py
   
   import math_operations
   
   result_add = math_operations.add(5, 3)
   result_subtract = math_operations.subtract(10, 4)
   result_multiply = math_operations.multiply(2, 6)
   result_divide = math_operations.divide(15, 3)
   
   print(f"Addition: {result_add}")
   print(f"Subtraction: {result_subtract}")
   print(f"Multiplication: {result_multiply}")
   print(f"Division: {result_divide}")
   print(f"Value of PI: {math_operations.PI}")

   Este script importa el módulo math_operations y utiliza sus funciones y constante.

8. Guarda el archivo y ejecútalo utilizando el siguiente comando en la terminal:

   python ~/project/use_math_module.py

   Deberías ver una salida similar a esta:

   Addition: 8
   Subtraction: 6
   Multiplication: 12
   Division: 5.0
   Value of PI: 3.14159

Al crear módulos, puedes organizar funciones y variables relacionadas en archivos separados, lo que hace que tu código sea más mantenible y reutilizable.

Cuando importas un módulo, Python lo compila en bytecode y almacena el código compilado en un directorio __pycache__. Este directorio se crea en la misma ubicación que el archivo del módulo y contiene archivos de bytecode compilados (.pyc o .pyo).

Puedes ignorar este directorio con seguridad, ya que Python maneja automáticamente la compilación y el almacenamiento en caché de los módulos.

Importación de Funciones Específicas de Módulos

En este paso, aprenderás cómo importar funciones específicas de módulos y utilizar alias para hacer tu código más conciso.

1. Crea un nuevo archivo llamado advanced_math.py en el directorio ~/project:

   touch ~/project/advanced_math.py

2. Abre advanced_math.py en el editor del WebIDE y agrega el siguiente contenido:

   ## advanced_math.py
   
   import math
   
   def square_root(x):
       return math.sqrt(x)
   
   def power(base, exponent):
       return math.pow(base, exponent)
   
   def sin(angle):
       return math.sin(math.radians(angle))
   
   def cos(angle):
       return math.cos(math.radians(angle))

   Este módulo utiliza el módulo incorporado math de Python para proporcionar operaciones matemáticas más avanzadas.

3. Ahora, crea un archivo llamado use_advanced_math.py en el mismo directorio:

   touch ~/project/use_advanced_math.py

4. Abre use_advanced_math.py en el editor del WebIDE y agrega el siguiente contenido:

   ## use_advanced_math.py
   
   from advanced_math import square_root, power
   from advanced_math import sin as sine, cos as cosine
   
   x = 16
   y = 2
   angle = 30
   
   print(f"Square root of {x}: {square_root(x)}")
   print(f"{x} to the power of {y}: {power(x, y)}")
   print(f"Sine of {angle} degrees: {sine(angle)}")
   print(f"Cosine of {angle} degrees: {cosine(angle)}")

   Este script importa funciones específicas del módulo advanced_math y utiliza alias para sin y cos.

5. Guarda el archivo y ejecútalo utilizando el siguiente comando en la terminal:

   python ~/project/use_advanced_math.py

   Deberías ver una salida similar a esta:

   Square root of 16: 4.0
   16 to the power of 2: 256.0
   Sine of 30 degrees: 0.49999999999999994
   Cosine of 30 degrees: 0.8660254037844387

Al importar funciones específicas y utilizar alias, puedes hacer que tu código sea más legible y evitar conflictos de nombres entre diferentes módulos.

Creación de un Paquete

En este último paso, aprenderás cómo crear un paquete, que es una forma de organizar módulos relacionados en una jerarquía de directorios.

1. Crea un nuevo directorio llamado geometry en el directorio ~/project:

   mkdir ~/project/geometry

2. Dentro del directorio geometry, crea dos archivos: __init__.py y shapes.py:

   touch ~/project/geometry/__init__.py
   touch ~/project/geometry/shapes.py

   El archivo __init__.py es necesario para que Python trate el directorio como un paquete. Puede estar vacío o contener código de inicialización para el paquete.

3. Abre shapes.py en el editor del WebIDE y agrega el siguiente contenido:

   ## geometry/shapes.py
   
   import math
   
   def circle_area(radius):
       return math.pi * radius ** 2
   
   def rectangle_area(length, width):
       return length * width
   
   def triangle_area(base, height):
       return 0.5 * base * height

4. Ahora, crea un archivo llamado use_geometry_package.py en el directorio ~/project:

   touch ~/project/use_geometry_package.py

5. Abre use_geometry_package.py en el editor del WebIDE y agrega el siguiente contenido:

   ## use_geometry_package.py
   
   from geometry.shapes import circle_area, rectangle_area, triangle_area
   
   radius = 5
   length = 4
   width = 6
   base = 3
   height = 8
   
   print(f"Area of circle with radius {radius}: {circle_area(radius):.2f}")
   print(f"Area of rectangle with length {length} and width {width}: {rectangle_area(length, width)}")
   print(f"Area of triangle with base {base} and height {height}: {triangle_area(base, height)}")

6. Guarda el archivo y ejecútalo utilizando el siguiente comando en la terminal:

   python ~/project/use_geometry_package.py

   Deberías ver una salida similar a esta:

   Area of circle with radius 5: 78.54
   Area of rectangle with length 4 and width 6: 24
   Area of triangle with base 3 and height 8: 12.0

Al crear un paquete, has organizado módulos relacionados en una jerarquía de directorios, lo que facilita la gestión e importación de funcionalidades relacionadas en tus proyectos.

Resumen

En este laboratorio, has explorado dos conceptos fundamentales en la programación de Python: funciones y módulos. Has aprendido cómo definir y usar funciones, comprender el alcance de las funciones, crear y usar módulos, importar funciones específicas de módulos y organizar módulos relacionados en paquetes.

Comenzaste creando funciones simples y gradualmente avanzaste hacia conceptos más complejos como el alcance de las funciones y las variables globales. Luego aprendiste cómo crear módulos para organizar funciones y variables relacionadas en archivos separados, lo que hace que tu código sea más mantenible y reutilizable.

Exploraste diferentes formas de importar funciones de módulos, incluyendo la importación de funciones específicas y el uso de alias. Este conocimiento te permite escribir código más conciso y legible mientras evitas conflictos de nombres entre diferentes módulos.

Finalmente, aprendiste cómo crear un paquete, que es una forma de organizar módulos relacionados en una jerarquía de directorios. Esto es especialmente útil para proyectos más grandes donde necesitas gestionar múltiples módulos relacionados.

Estos conceptos de funciones y módulos son cruciales para escribir código Python bien organizado, eficiente y reutilizable. A medida que continúes tu viaje en Python, encontrarás que estas habilidades son esenciales para construir programas más complejos y colaborar en proyectos más grandes. Recuerda practicar estos conceptos regularmente y explorar el vasto ecosistema de módulos y paquetes de Python disponibles para mejorar tus capacidades de programación.