Introducción
Bienvenidos al laboratorio sobre las funciones integradas (built-in functions) de Python. El intérprete de Python proporciona un conjunto rico de funciones y tipos que están siempre disponibles, sin necesidad de realizar ninguna importación. Estas funciones son los bloques de construcción fundamentales para realizar tareas comunes, desde la manipulación de datos hasta las operaciones de entrada/salida (input/output).
En este laboratorio, obtendrán experiencia práctica con algunas de las funciones integradas más esenciales, categorizadas en grupos lógicos. Al finalizar este laboratorio, dominarán el uso de estas funciones para escribir código Python más eficiente y legible.
Conversión e Inspección de Tipos de Datos
En este paso, aprenderá a convertir entre diferentes tipos de datos e inspeccionar objetos usando funciones como int(), str(), list(), dict(), type() e isinstance(). Estas son fundamentales para manejar datos en Python.
Nota: Si no está familiarizado con el uso de WebIDE (similar a VS Code), por favor, aprenda primero en este laboratorio.
Primero, abra el archivo step1_conversion.py desde el explorador de archivos a la izquierda. Escribiremos nuestro código en este archivo.
Agregue el siguiente código a step1_conversion.py. Este código demuestra cómo convertir una cadena (string) a un entero (integer), una tupla a una lista (list) y una lista de pares a un diccionario (dictionary). También muestra cómo verificar el tipo de un objeto.
## step1_conversion.py
## int(): Devuelve un objeto entero (integer) a partir de un número o cadena.
num_str = "123"
num_int = int(num_str)
print(f"Cadena '{num_str}' como entero: {num_int}")
## str(): Devuelve una versión en cadena (string) de un objeto.
int_val = 456
str_val = str(int_val)
print(f"Entero {int_val} como cadena: '{str_val}'")
## list(): Crea una nueva lista a partir de un iterable.
my_tuple = ('a', 'b', 'c')
my_list = list(my_tuple)
print(f"Tupla {my_tuple} como lista: {my_list}")
## dict(): Crea un nuevo diccionario.
my_pairs = [('x', 1), ('y', 2)]
my_dict = dict(my_pairs)
print(f"Lista de pares {my_pairs} como diccionario: {my_dict}")
## type(): Devuelve el tipo de un objeto.
print(f"Tipo de num_int: {type(num_int)}")
## isinstance(): Devuelve True si el objeto es una instancia de una clase.
is_list = isinstance(my_list, list)
print(f"¿Es my_list una instancia de list? {is_list}")
Ahora, guarde el archivo y ejecútelo desde la terminal.
python3 step1_conversion.py
Debería ver la siguiente salida, que confirma que las conversiones e inspecciones de tipos de datos fueron exitosas.
String '123' as integer: 123
Integer 456 as string: '456'
Tuple ('a', 'b', 'c') as list: ['a', 'b', 'c']
List of pairs [('x', 1), ('y', 2)] as dict: {'x': 1, 'y': 2}
Type of num_int: <class 'int'>
Is my_list an instance of list? True
Operaciones Matemáticas y Numéricas
En este paso, realizarán cálculos matemáticos comunes utilizando funciones integradas. Cubriremos abs(), sum(), min(), max(), round() y pow().
Abran el archivo step2_math.py desde el explorador de archivos.
Añadan el siguiente código a step2_math.py. Este script demuestra cómo aplicar varias funciones matemáticas a números y listas de números.
## step2_math.py
numbers = [5, -10, 15, -2, 8]
## abs(): Devuelve el valor absoluto de un número.
print(f"Valor absoluto de -10: {abs(-10)}")
## sum(): Suma los elementos de un iterable.
print(f"Suma de los números {numbers}: {sum(numbers)}")
## min(): Devuelve el elemento más pequeño en un iterable.
print(f"Mínimo de los números: {min(numbers)}")
## max(): Devuelve el elemento más grande en un iterable.
print(f"Máximo de los números: {max(numbers)}")
## round(): Devuelve un número redondeado a una precisión dada.
pi_approx = 3.14159
print(f"Redondeando {pi_approx} a 2 decimales: {round(pi_approx, 2)}")
## pow(): Devuelve la base elevada a la potencia del exponente.
print(f"2 elevado a la potencia de 3: {pow(2, 3)}")
Guarden el archivo y ejecútenlo en la terminal.
python3 step2_math.py
La salida debería mostrar los resultados de cada operación matemática.
Absolute value of -10: 10
Sum of numbers [5, -10, 15, -2, 8]: 16
Minimum of numbers: -10
Maximum of numbers: 15
Rounding 3.14159 to 2 decimal places: 3.14
2 to the power of 3: 8
Trabajando con Secuencias e Iterables
En este paso, aprenderán a manipular y procesar secuencias como listas y tuplas. Cubriremos len(), sorted(), reversed(), enumerate(), map(), filter() y zip(). Muchas de estas funciones devuelven iteradores, que son objetos eficientes y que ahorran memoria.
Abran el archivo step3_sequences.py.
Añadan el siguiente código a step3_sequences.py. Este script demostrará cómo obtener la longitud de una lista, ordenarla, invertirla y realizar transformaciones más complejas usando map, filter y zip.
## step3_sequences.py
my_list = [3, 1, 4, 1, 5, 9]
print(f"Lista original: {my_list}")
## len(): Devuelve la longitud (el número de elementos) de un objeto.
print(f"Longitud de la lista: {len(my_list)}")
## sorted(): Devuelve una nueva lista ordenada a partir de los elementos en el iterable.
print(f"Lista ordenada: {sorted(my_list)}")
## reversed(): Devuelve un iterador inverso. Lo convertimos a lista para imprimir.
print(f"Lista invertida: {list(reversed(my_list))}")
## enumerate(): Devuelve un objeto enumerate (iterador de pares índice, valor).
print(f"Lista enumerada: {list(enumerate(my_list))}")
## map(): Devuelve un iterador que aplica una función a cada elemento del iterable.
squared_numbers = map(lambda x: x*x, my_list)
print(f"Números al cuadrado (map): {list(squared_numbers)}")
## filter(): Construye un iterador a partir de los elementos del iterable para los cuales una función devuelve verdadero.
even_numbers = filter(lambda x: x % 2 == 0, my_list)
print(f"Números pares (filter): {list(even_numbers)}")
## zip(): Itera sobre varios iterables en paralelo.
list_a = ['a', 'b', 'c']
list_b = [1, 2, 3]
zipped = zip(list_a, list_b)
print(f"Listas combinadas (zipped): {list(zipped)}")
Guarden el archivo y ejecútenlo.
python3 step3_sequences.py
Verán la salida de varias operaciones de secuencia. Noten cómo funciones como reversed, map, filter y zip devuelven iteradores, los cuales convertimos a listas usando list() para mostrar su contenido.
Original list: [3, 1, 4, 1, 5, 9]
Length of the list: 6
Sorted list: [1, 1, 3, 4, 5, 9]
Reversed list: [9, 5, 1, 4, 1, 3]
Enumerated list: [(0, 3), (1, 1), (2, 4), (3, 1), (4, 5), (5, 9)]
Squared numbers (map): [9, 1, 16, 1, 25, 81]
Even numbers (filter): [4]
Zipped lists: [('a', 1), ('b', 2), ('c', 3)]
Entrada/Salida y Representación de Objetos
En este paso, manejarán operaciones básicas de entrada/salida (Input/Output, I/O) y controlarán cómo se representan los objetos como cadenas de texto (strings). Nos centraremos en print(), open(), repr() y format(). También mencionaremos brevemente input().
Abran el archivo step4_io.py.
La función input() lee una línea de la consola, la convierte a una cadena de texto y la devuelve. Por ejemplo: name = input("Enter your name: "). No la usaremos en nuestro script para evitar pausar la ejecución, pero es una función crucial de conocer.
Ahora, añadan el siguiente código a step4_io.py. Este script escribirá en un archivo, leerá desde él y demostrará diferentes formas de representar y formatear objetos como cadenas de texto.
## step4_io.py
import datetime
## open(): Abre un archivo y devuelve un objeto de archivo correspondiente.
## Usamos una declaración 'with' para asegurar que el archivo se cierre automáticamente.
file_path = "/home/labex/project/my_file.txt"
with open(file_path, "w") as f:
f.write("Hello, LabEx!\n")
f.write("This is a test file.")
print(f"Escritura exitosa en {file_path}")
## Lectura desde el archivo
with open(file_path, "r") as f:
content = f.read()
print("--- Contenido del Archivo ---")
print(content)
print("--------------------")
## repr(): Devuelve una cadena que contiene una representación imprimible e inequívoca de un objeto.
now = datetime.datetime(2023, 10, 27, 10, 30, 0)
print(f"str(now): {str(now)}")
print(f"repr(now): {repr(now)}")
## format(): Convierte un valor a una representación "formateada".
formatted_string = format(123.4567, ".2f")
print(f"Número formateado (123.4567 a .2f): {formatted_string}")
Guarden el archivo y ejecútenlo desde la terminal.
python3 step4_io.py
El script creará y escribirá en my_file.txt, lo leerá de nuevo e imprimirá el contenido. También muestra la diferencia entre str() y repr() para un objeto datetime y demuestra el formateo de números.
Successfully wrote to /home/labex/project/my_file.txt
--- File Content ---
Hello, LabEx!
This is a test file.
--------------------
str(now): 2023-10-27 10:30:00
repr(now): datetime.datetime(2023, 10, 27, 10, 30)
Formatted number (123.4567 to .2f): 123.46
Introspección de Objetos y Metaprogramación
En este paso final, explorarán funciones avanzadas para interactuar con atributos y espacios de nombres (namespaces) de objetos. Esto a menudo se denomina introspección o reflexión. Usaremos getattr(), hasattr(), setattr(), dir(), globals() y locals().
Abran el archivo step5_introspection.py.
Definiremos una clase simple y luego usaremos funciones de introspección para inspeccionar y modificar dinámicamente sus instancias. Añadan el siguiente código a step5_introspection.py.
## step5_introspection.py
class Person:
species = "Homo sapiens"
def __init__(self, name, age):
self.name = name
self.age = age
p = Person("Alice", 30)
## hasattr(): Devuelve True si el objeto tiene el atributo nombrado.
print(f"¿Tiene la persona el atributo 'name'? {hasattr(p, 'name')}")
print(f"¿Tiene la persona el atributo 'height'? {hasattr(p, 'height')}")
## setattr(): Es el equivalente de getattr(). Establece un atributo en un objeto.
print("Estableciendo el atributo 'height' a 175...")
setattr(p, 'height', 175)
print(f"¿Tiene la persona el atributo 'height' ahora? {hasattr(p, 'height')}")
## getattr(): Devuelve el valor del atributo nombrado de un objeto.
print(f"Nombre de la persona: {getattr(p, 'name')}")
print(f"Altura de la persona: {getattr(p, 'height')}")
## dir(): Devuelve la lista de nombres en el ámbito local actual o los atributos de un objeto.
## Comprobamos si 'height' está ahora en la lista de atributos.
print(f"¿Está 'height' en dir(p)? {'height' in dir(p)}")
## globals(): Devuelve un diccionario de la tabla de símbolos global actual.
## Comprobaremos si nuestra clase 'Person' está en globals.
print(f"¿Está 'Person' en globals? {'Person' in globals().keys()}")
## locals(): Devuelve un diccionario de la tabla de símbolos local actual.
def a_func():
x = 10
print(f"¿Está 'x' en locals()? {'x' in locals().keys()}")
a_func()
Guarden el archivo y ejecútenlo.
python3 step5_introspection.py
La salida demuestra cómo pueden verificar, establecer y obtener dinámicamente atributos de un objeto usando sus nombres como cadenas de texto. También muestra cómo inspeccionar los atributos de un objeto y las variables disponibles en los ámbitos global y local.
Does person have 'name' attribute? True
Does person have 'height' attribute? False
Setting attribute 'height' to 175...
Does person have 'height' attribute now? True
Person's name: Alice
Person's height: 175
Is 'height' in dir(p)? True
Is 'Person' in globals? True
Is 'x' in locals()? True
Resumen
¡Felicidades por completar el laboratorio! Han adquirido experiencia práctica con una amplia gama de funciones integradas (built-in functions) esenciales de Python.
En este laboratorio, han aprendido a:
- Convertir entre tipos de datos e inspeccionar objetos (
int,str,type,isinstance). - Realizar operaciones matemáticas comunes (
abs,sum,min,max,round). - Manipular y procesar secuencias e iterables (
len,sorted,map,filter,zip). - Manejar operaciones básicas de Entrada/Salida de archivos (I/O) y representación de objetos como cadenas (
open,repr,format). - Inspeccionar y modificar dinámicamente objetos y espacios de nombres (
hasattr,getattr,setattr,dir).
Estas funciones son fundamentales para la programación diaria en Python. Dominarlas mejorará significativamente la eficiencia y legibilidad de su código. Continúen explorando otras funciones integradas y practiquen su uso en sus propios proyectos.
