Introducción
En este laboratorio, explorarás dos conceptos fundamentales en la programación con Python: las funciones y los módulos. Las funciones te permiten organizar tu código en bloques reutilizables, haciendo 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, serás capaz de escribir código Python más eficiente y organizado.
Definición y uso de funciones
En este paso, aprenderás cómo definir y utilizar funciones en Python.
Abre el intérprete de Python escribiendo el siguiente comando en tu terminal:
python
Deberías ver el símbolo de Python (>>>), lo que indica que ahora estás en el shell interactivo de Python.
Comencemos definiendo una función sencilla que salude a una persona. En el intérprete de Python, escribe primero la definición de la función:
def greet(name):
return f"Hello, {name}!"
Después de escribir la línea indentada return, presiona Enter en una línea en blanco una vez para finalizar la definición de la función. Luego, ejecuta la función en el mismo intérprete:
result = greet("Alice")
print(result)
Deberías ver la siguiente salida:
Hello, Alice!
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 debe estar indentado.
Esta función toma un parámetro name y devuelve una cadena de saludo. Luego, llamamos a la función con el argumento "Alice" e imprimimos el resultado.
La sentencia return se utiliza para devolver un valor desde la función. Si no hay una sentencia return, la función devuelve None.
Las funciones pueden utilizarse para encapsular código reutilizable y realizar tareas específicas. Son el bloque de construcción principal de los programas en Python.
Ahora, creemos una función que realice un cálculo. Define la función primero:
def calculate_area(length, width):
return length * width
Presiona Enter en una línea en blanco para finalizar la definición y luego llama a la función:
area = calculate_area(5, 3)
print(f"The area is: {area}")
Deberías ver la siguiente salida:
The area is: 15
Esta función calcula el área de un rectángulo a partir de su longitud y anchura.
Las funciones también pueden tener valores de parámetros predeterminados. Define la función primero:
def power(base, exponent=2):
return base ** exponent
Presiona Enter en una línea en blanco y luego prueba ambas llamadas:
print(power(3))
print(power(3, 3))
Deberías ver la siguiente salida:
9
27
Aquí, si no se proporciona un exponente, la función utiliza 2 como valor predeterminado.
Las funciones pueden devolver múltiples valores utilizando tuplas. Define la función primero:
def min_max(numbers):
return min(numbers), max(numbers)
Presiona Enter en una línea en blanco y luego llama a la función:
minimum, maximum = min_max([1, 5, 3, 9, 2])
print(f"Minimum: {minimum}, Maximum: {maximum}")
Deberías ver la siguiente salida:
Minimum: 1, Maximum: 9
Esta función devuelve tanto el valor mínimo como el máximo de una lista de números.
Recuerda que la indentación es crucial en Python. Los cuerpos de las funciones deben estar indentados de manera consistente.
Comprender el alcance de las funciones
En este paso, aprenderás sobre el alcance (scope) de las funciones y cómo se comportan las variables dentro y fuera de ellas.
En el intérprete de Python, exploremos las variables locales y globales:
x = 10 ## Global variable
def print_x():
print(f"Global x: {x}")
print_x()
def change_x():
x = 20 ## Local variable
print(f"Local x: {x}")
change_x()
print(f"Global x after change_x(): {x}")
Deberías ver la siguiente salida:
Global x: 10
Local x: 20
Global x after change_x(): 10
Observa que la función change_x() crea una nueva variable local x, la cual no afecta a la x global.
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()
print(f"Global x after modify_global_x(): {x}")
Deberías ver la siguiente salida:
Modified global x: 30
Global x after modify_global_x(): 30
Ahora la x global ha sido modificada.
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)
Deberías ver la siguiente salida:
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 libre de errores. Ayuda a prevenir efectos secundarios no deseados y hace que tus funciones sean más predecibles.
Crear y utilizar módulos
En este paso, aprenderás cómo crear y utilizar módulos de Python.
Sal del intérprete de Python escribiendo exit() o presionando Ctrl+D.
Abre el WebIDE en el entorno de la máquina virtual de LabEx.
Crea un nuevo archivo llamado math_operations.py en el directorio ~/project:
touch ~/project/math_operations.py
Abre el archivo recién creado en el editor WebIDE y añade 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.
Guarda el archivo (el guardado automático está habilitado en el WebIDE).
Ahora, crea otro archivo llamado use_math_module.py en el mismo directorio:
touch ~/project/use_math_module.py
Abre use_math_module.py en el editor WebIDE y añade 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 su constante.
Guarda el archivo y ejecútalo usando 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, haciendo que tu código sea más fácil de mantener y reutilizar.
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.
Importar funciones específicas de los módulos
En este paso, aprenderás cómo importar funciones específicas de los módulos y utilizar alias para hacer que tu código sea más conciso.
Crea un nuevo archivo llamado advanced_math.py en el directorio ~/project:
touch ~/project/advanced_math.py
Abre advanced_math.py en el editor WebIDE y añade 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 integrado math de Python para proporcionar operaciones matemáticas más avanzadas.
Ahora, crea un archivo llamado use_advanced_math.py en el mismo directorio:
touch ~/project/use_advanced_math.py
Abre use_advanced_math.py en el editor WebIDE y añade 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.
Guarda el archivo y ejecútalo usando 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.
Crear un paquete
En este paso final, aprenderás cómo crear un paquete, que es una forma de organizar módulos relacionados en una jerarquía de directorios.
Crea un nuevo directorio llamado geometry en el directorio ~/project:
mkdir ~/project/geometry
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.
Abre shapes.py en el editor WebIDE y añade 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
Ahora, crea un archivo llamado use_geometry_package.py en el directorio ~/project:
touch ~/project/use_geometry_package.py
Abre use_geometry_package.py en el editor WebIDE y añade 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)}")
Guarda el archivo y ejecútalo usando 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 y la importación de funcionalidades relacionadas en tus proyectos.
Resumen
En este laboratorio, has explorado dos conceptos fundamentales en la programación con Python: las funciones y los módulos. Has aprendido a definir y utilizar funciones, a comprender el alcance de las funciones, a crear y utilizar módulos, a importar funciones específicas de los módulos y a organizar módulos relacionados en paquetes.
Comenzaste creando funciones sencillas y avanzaste gradualmente hacia conceptos más complejos como el alcance de las funciones y las variables globales. Luego, aprendiste a crear módulos para organizar funciones y variables relacionadas en archivos separados, haciendo que tu código sea más fácil de mantener y reutilizar.
Exploraste diferentes formas de importar funciones desde 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, evitando conflictos de nombres entre diferentes módulos.
Finalmente, aprendiste a crear un paquete, que es una forma de organizar módulos relacionados en una jerarquía de directorios. Esto es particularmente ú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 con 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.
