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, 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, fomentando la reutilización y el mantenimiento del código. Al dominar estos conceptos, podrás 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 prompt de Python (>>>), lo que indica que ya estás en la consola interactiva de Python.
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)
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 sirven para encapsular código reutilizable y realizar tareas específicas. Son la pieza de construcción principal de los programas en Python.
Ahora, vamos a crear 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}")
Deberías ver la siguiente salida:
The area is: 15
Esta función calcula el área de un rectángulo dados su longitud y su anchura.
Las funciones también pueden tener valores de parámetros por defecto:
def power(base, exponent=2):
return base ** exponent
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 por defecto.
Las funciones pueden devolver múltiples valores utilizando tuplas:
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.
Comprendiendo 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 ámbito superior o contenedor:
La función interna puede acceder al parámetro x de la función externa.
Comprender el alcance de las funciones es fundamental 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 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 VM 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 del 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 del WebIDE y añade el siguiente contenido:
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, lo que hace que tu código sea más fácil de mantener y reutilizar.
Cuando importas un módulo, Python lo compila a bytecode y almacena el código compilado en un directorio llamado __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 tranquilidad, ya que Python gestiona 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 los módulos y cómo usar alias para 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 del WebIDE y añade el siguiente contenido:
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 del 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 usar 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 paso final, aprenderás a 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:
El archivo __init__.py es necesario para que Python trate al directorio como un paquete. Puede estar vacío o contener código de inicialización para el paquete.
Abre shapes.py en el editor del WebIDE y añade el siguiente contenido:
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 del 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 e 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 cómo definir y usar funciones, comprender el alcance de las funciones, crear y usar módulos, importar funciones específicas de los módulos y organizar módulos relacionados en paquetes.
Comenzaste creando funciones simples 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 mantenible y reutilizable.
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 al mismo tiempo 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 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 camino con Python, descubrirás que estas habilidades son esenciales para construir programas más complejos y colaborar en proyectos de mayor envergadura. Recuerda practicar estos conceptos con regularidad y explorar el vasto ecosistema de módulos y paquetes de Python disponibles para mejorar tus capacidades de programación.
