ProgramaciónPythonVLA9. Módulos

9. Módulos

Un módulo en Python es un archivo que contiene definiciones y declaraciones de Python. Estos archivos pueden contener funciones, clases y variables que pueden ser utilizadas en otros programas de Python. Los módulos en Python proporcionan una forma de organizar y reutilizar código de manera eficiente.

Cuando necesitas utilizar ciertas funcionalidades específicas en tu programa, puedes importar módulos relevantes para acceder a esas funcionalidades. Python tiene una gran biblioteca estándar que incluye una amplia variedad de módulos para realizar diversas tareas, como trabajar con archivos, realizar operaciones matemáticas, interactuar con el sistema operativo, entre otros.

Por ejemplo, el módulo os es un archivo que contiene código para interactuar con el sistema operativo. Cuando importas el módulo os en tu programa, puedes acceder a las funciones y atributos definidos en ese archivo para realizar operaciones relacionadas con el sistema operativo, como manipular archivos, obtener información sobre el sistema operativo, entre otros.

Algunos módulos os: Proporciona funciones para interactuar con el sistema operativo, como manipulación de archivos, operaciones de directorios y acceso a variables de entorno.

  • os.getcwd: Nos ayudará en saber la ruta exacta donde se encuentra actualmente el .py en ejecución.
import os

# Obtener la ruta actual del directorio de trabajo
ruta_actual = os.getcwd()
print("Ruta actual del directorio de trabajo: ", ruta_actual)
  • os.listdir: Nos ayudará en ver los archivos que se encuentran dentro de la carpeta del .py en ejecución.
# Listar archivos en el directorio actual
print("\\nArchivos en el directorio actual: ")
archivos_en_carpeta = os.listdir(ruta_actual)
for archivo in archivos_en_carpeta:
    print(archivo)
  • os.path.exists(): La función se utiliza para comprobar si un archivo o directorio existe en el sistema de archivos. Toma un argumento que es una ruta de archivo o directorio y devuelve True si existe en el sistema de archivos, o False si no existe.
archivo_existente = "archivo_existente.txt"
if os.path.exists(archivo_existente):
    print("\\nEl archivo '{}' existe".format(archivo_existente))
else:
    print("\\nEl archivo '{}' no existe".format(archivo_existente))

os.path: Proporciona funciones para manipular rutas de archivo y nombres de archivo de manera portable entre diferentes sistemas operativos. defaultdict, Counter, deque, entre otros.

  • Obtener el nombre del archivo: De esta manera buscamos un archivo y devuelve el nombre del archivo de una ruta dada.
import os

ruta = '/ruta/base/archivo.txt'
nombre_archivo = os.path.basename(ruta)
print(nombre_archivo)  # Salida: archivo.txt
  • Obtener el directorio de una ruta: De esta manera devuelve el directorio de una ruta dada.
import os

ruta = '/ruta/base/archivo.txt'
directorio = os.path.dirname(ruta)
print(directorio)  # Salida: /ruta/base
  • Obtener la extensión de un archivo: Devuelve la extensión del archivo de una ruta dada.
import os

ruta = '/ruta/base/archivo.txt'
extension = os.path.splitext(ruta)[1]
print(extension)  # Salida: .txt
  • Verificar si una ruta existe: Devuelve True si la ruta existe, de lo contrario devuelve False.
import os

ruta = '/ruta/base/archivo.txt'
existe = os.path.exists(ruta)
print(existe)  # Salida: True o False dependiendo de si la ruta existe

sys: Ofrece acceso a algunas variables y funciones específicas del intérprete de Python, como sys.argv para acceder a los argumentos de línea de comandos, y sys.exit() para salir del programa.

try:
    user = os.getlogin()
    print(f"El usuario actual es: {user}")
except Exception as e:
    print(f"Ocurrio un error al recuperar el usuario: {e}")

math: Contiene funciones matemáticas y constantes útiles, como funciones trigonométricas, funciones exponenciales y constantes matemáticas como pi y e.

import math

# Funciones trigonometricas
angulo = math.radians(45)
seno = math.sin(angulo)
coseno = math.cos(angulo)
tangente = math.tan(angulo)
print("\\nSeno del angulo: ", seno)
print("Coseno del angulo: ", coseno)
print("Tangente del angulo: ", tangente)

# Constantes matematicas
print("\\nValor de pi: ", math.pi)
print("Valor de e (numero de Euler): ", math.e)

# Operaciones aritmeticas
raiz_cuadrada = math.sqrt(16)
exponencial = math.exp(2)
logaritmo = math.log(10)
print("\\nRaiz cuadrada de 16: ", raiz_cuadrada)
print("e^2 (exponencial): ", exponencial)
print("Logaritmo natural de 10: ", logaritmo)

random: Proporciona funciones para generar números aleatorios y realizar operaciones relacionadas con la aleatoriedad, como seleccionar elementos aleatorios de una lista o generar números aleatorios dentro de un rango especificado.

  • random.randint(): Permite generar números aleatorios dentro de un rango específico.
import random
# Generar un numero aleatorio entre 1 y 100
numero_aleatorio = random.randint(1, 100)
print("Numero aleatorio entre 1 y 100: ", numero_aleatorio)
  • random.choice(): Permite generar una selección aleatoria dentro de una lista[ ].
import random
opciones = ['rojo', 'verde', 'azul', 'amarillo']
opcion_aleatoria = random.choice(opciones)
print("La opcion aleatoria es: ", opcion_aleatoria)
  • random.shuffle(): Permite mezclar de forma aleatoria los valores dentro de una lista[ ].
import random
lista = [1, 2, 3, 4, 5]
random.shuffle(lista)
print("Lista mezclada: ", lista)
  • random.sample(): Permite seleccionar la cantidad de elementos en K de forma aleatoria. Reduciendo la lista al valor de K.
import random
opciones = ['a', 'b', 'c', 'd', 'e']
elementos_aleatorios = random.sample(opciones, k = 3)
print("Elementos aleatorios unicos: ", elementos_aleatorios)

datetime: Permite trabajar con fechas y tiempos, incluyendo creación de objetos de fecha y tiempo, manipulación de fechas, formateo de fechas y cálculos de diferencia entre fechas.

  • datetime.datatime(): Toma la fecha y hora exacta del ordenador.
import datetime
fecha_actual = datetime.datetime.now()
print("Fecha y hora actual: ", fecha_actual)
  • datetime.now(): Se puede crear un objeto datetime llamado now, que representa la fecha y hora actuales E imprimimos cada parte de la fecha y hora actual, como el año, mes, día, hora, minuto y segundo.
from datetime import datetime
now = datetime.now()
print("Anio: ", now.year)
print("Mes: ", now.month)
print("Dia: ", now.day)
print("Hora: ", now.hour)
print("Minuto: ", now.minute)
print("Segundo: ", now.second)
  • datetime.now().strftime: Utilizamos el método strftime() para formatear el objeto datetime en una cadena con el formato deseado. En este caso, %Y-%m-%d %H:%M:%S representa el formato "Año-Mes-Día Hora:Minuto:Segundo".
from datetime import datetime
now = datetime.now()
formatted_date = now.strftime("%Y-%m-%d %H:%M:%S")
print("Fecha y hora formateadas: ", formatted_date)
  • datetime.datatime(): Tomamos 2 fechas y restamos first_date de second_date para obtener la diferencia entre ellas. Esto nos da un objeto timedelta, que representa la diferencia entre las dos fechas.
from datetime import datetime

first_date = datetime(2023, 12, 25)
second_date = datetime(2024, 3, 14)

difference = second_date - first_date
print("Diferencia de dias entre las fechas: ", difference.days)

re: Proporciona operaciones de expresiones regulares para realizar búsquedas y manipulaciones de patrones de texto.

  • re.findall: Búsqueda de coincidencias. De esta manera podemos encontrar patrones o coincidencias.
import re
# Buscar todas las coincidencias de un patron en una cadena
text = "La casa es roja y grande"
pattern = r"roja"
matches = re.findall(pattern, text)
print(matches)
  • re.sub: Sustitución de texto. Con re.sub, tomamos el texto, el patrón y por lo que lo queremos cambiar.
import re
# Reemplazar todas las ocurrencias de un patron en una cadena
text = "La casa es roja y grande"
pattern = r"roja"
new_text = re.sub(pattern, "azul", text)
print(new_text)
  • re.split: División de texto. Con re.split tomamos una cadena de string, el patrón y de esta forma se separan por partes
import re
# Dividir una cadena en funcion de un patron
text = "apple, banana, cherry"
pattern = r", "
parts = re.split(pattern, text)
print(parts)
  • re.match: Validación de formato. De esta manera podemos verificar si un formato está correcto.
import re
# Verificar si una cadena sigue un patron especifico
pattern = r"\\d{3}-\\d{3}-\\d{4}"
text = "123-456-7890"
if re.match(pattern, text):
    print("Formato de numero de telefono valido")
else:
    print("Formato de numero de telefono invalido")
  • re.search: Extracción de información. De esta manera podemos extraer la información de un string
import re
# Extraer informacion de una cadena que sigue un patron
text = "Nombre: Juan, Edad: 30, Correo: juan@example.com"
pattern = r"Nombre: (\\w+), Edad: (\\d+), Correo: (\\S+)"
match = re.search(pattern, text)
if match:
    name = match.group(1)
    age = match.group(2)
    email = match.group(3)
    print("Nombre: ", name)
    print("Edad: ", age)
    print("Correo: ", email)

json: Permite la codificación y decodificación de datos JSON (JavaScript Object Notation), lo que facilita el intercambio de datos entre aplicaciones en forma de texto estructurado.

Cargar datos JSON desde una cadena o un archivo: En este ejemplo, utilizamos json.loads() para cargar datos JSON desde una cadena y convertirlos en un diccionario de Python.

Luego utilizamos json.load() para cargar datos JSON desde un archivo y almacenarlos en una variable.

import json
import os
# Cargar datos JSON desde una cadena
json_string = '{"nombre": "Juan", "edad": 30, "cuidad": "Nueva York"}'
data = json.loads(json_string)
print(data)
# Verificar si el archivo 'datos.json' existe
if not os.path.exists("datos.json"):
    # Si no existe, crear el archivo con datos de ejemplo
    with open("datos.json", "w") as file:
        json.dump(data, file)
# Cargar datos desde el archivo 'datos.json'
with open("datos.json", "r") as file:
    data = json.load(file)
print(data)

json.dumps : Utilizamos json.dumps() para convertir un diccionario de Python en una cadena JSON.  Luego, convertimos una lista de Python en una cadena JSON.

import json

# Convertir un diccionario Python a JSON
data = {"nombre": "Juan", "edad": 30, "ciudad": "Nueva York"}
json_data = json.dumps(data)
print(json_data)

# Convertir una lista Python a JSON
data = ["manzana", "banana", "cereza"]
json_data = json.dumps(data)
print(json_data)

Manipular datos JSON: Este es un ejemplo de cómo podemos manipular datos con json.

import json

# Acceder a valores especificos en datos JSON
data = {"nombre": "Juan", "edad": 30, "ciudad": "Nueva York"}
print(data["nombre"])

# Modificar datos JSON
data["edad"] = 31
print(data)

# Agregar nuevos datos JSON
data["profesion"] = "Ingeniero"
print(data)

# Eliminar datos JSON
del data["ciudad"]
print(data)

Guardar datos JSON en un archivo: Aquí, utilizamos json.dump() para escribir datos JSON en un archivo. Esto guarda el contenido de data en el archivo "datos.json" en formato JSON.

import json

data = {"nombre": "Juan", "edad": 30, "ciudad": "Nueva York"}

# Guardar datos JSON en un archivo
with open("datos.json", "w") as file:
    json.dump(data, file)

csv: Ofrece funciones para trabajar con archivos CSV (Comma-Separated Values), lo que facilita la lectura y escritura de datos en formato CSV.

Lectura de un archivo csv: Este código abre un archivo CSV llamado "datos.csv" en modo lectura y utiliza csv.reader para leer cada fila del archivo. Cada fila se imprime como una lista de elementos.

import csv

# Abrir un archivo CSV en modo lectura
with open("datos.csv", newline='') as csvfile:
    reader = csv.reader(csvfile)
    for row in reader:
        print(row)

Escritura en un archivo csv: En este ejemplo, definimos una lista de listas data, donde cada lista representa una fila del archivo CSV. Luego, abrimos un archivo CSV en modo escritura y utilizamos csv.writer para escribir los datos en el archivo.

import csv

# Datos que queremos escribir en el archivo CSV
data = [
    ["Nombre", "Edad", "Cuidad"],
    ["Juan", 30, "Nueva York"],
    ["Maria", 25, "Madrid"],
]

# Abrir una archivo CSV en modo escritura
with open("datos.csv", "w", newline='') as csvfile:
    writer = csv.writer(csvfile)
    writer.writerows(data)

Lectura de un archivo CSV con encabezados: Aquí, abrimos un archivo CSV que tiene la primera fila como encabezados. Utilizamos csv.DictReader para leer el archivo y cada fila se devuelve como un diccionario, donde las claves son los encabezados y los valores son los elementos de esa fila.

import csv

# Abrir un archivo CSV con encabezados
with open('datos.csv', newline='') as csvfile:
    reader = csv.DictReader(csvfile)
    for row in reader:
        print(row['Nombre'], row['Edad'], row['Cuidad'])

Escritura en un archivo CSV con encabezados: En este caso, definimos una lista de diccionarios data, donde cada diccionario representa una fila del archivo CSV. Utilizamos csv.DictWriter para escribir en el archivo, especificando los nombres de los campos con fieldnames, escribiendo primero los encabezados con writeheader(), y luego escribiendo las filas con writerow().

import csv

# Datos que queremos escribir en el archivo CSV
data = [
    {'Nombre': 'Juan', 'Edad': 30, 'Cuidad': 'Nueva York'},
    {'Nombre': 'Maria', 'Edad': 25, 'Cuidad': 'Madrid'}
]

# Abrir una archivo CSV en modo escritura
with open("datos.csv", "w", newline='') as csvfile:
    fieldnames = ['Nombre', 'Edad', 'Cuidad']
    writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
    writer.writeheader()
    for row in data:
        writer.writerow(row)

collections: Contiene clases y funciones útiles para trabajar con estructuras de datos especiales como diccionarios, listas y tuplas, como defaultdict, counter, entre otros.

  • collections (counter): Este ejemplo cuenta la frecuencia de cada elemento en la lista y crea un diccionario con la clave como elemento y el valor como su frecuencia.
from collections import Counter

# Crear un contador de elementos en una lista
lista = ['a', 'b', 'c', 'a', 'b', 'a']
contador = Counter(lista)
print(contador)
  • collections (DefaultDict): En este caso, defaultdict se inicializa con int como su tipo predeterminado, lo que hace que el valor predeterminado para claves inexistentes sea 0.
from collections import defaultdict

# Crear un diccionario predeterminado con un valor predeterminado para claves no existentes
d = defaultdict(int)
d['a'] = 1
print(d['a'])
print(d['b'])
  • collections(OrderedDict): OrderedDict mantiene el orden de inserción de las claves, lo que puede ser útil cuando necesitas iterar sobre un diccionario en un orden específico.
from collections import OrderedDict

# Crear un diccionario ordenado
d = OrderedDict()
d['b'] = 2
d['a'] = 1
d['c'] = 3
print(d)
  • collections: most_common() devuelve una lista de los elementos más comunes junto con sus recuentos en orden descendente.
from collections import OrderedDict
d = {}
d['a'] = 1
d['b'] = 2
d['c'] = 3
d['d'] = 4
print(d)
del d['c']
d['c'] = 4
print(d)

od = OrderedDict()
od['a'] = 1
od['b'] = 2
od['c'] = 3
od['d'] = 4
print(od)
del d['c']
d['c'] = 4
print(od)
Built with LogoFlowershow