Python
Tutorial Python: Importar módulos y paquetes
Aprende a importar módulos y paquetes en Python con técnicas, alias, importaciones relativas y absolutas para un código modular y mantenible.
Aprende Python y certifícateSintaxis de importación
La importación de módulos es una de las características fundamentales de Python que permite reutilizar código organizado en diferentes archivos. Cuando desarrollamos aplicaciones complejas, resulta imprescindible dividir nuestro código en unidades lógicas más pequeñas y manejables.
Python ofrece una sintaxis clara y flexible para importar código de otros módulos y paquetes. Veamos cómo funciona este mecanismo de importación.
Estructura básica de importación
La forma más sencilla de importar un módulo completo es mediante la palabra clave import
seguida del nombre del módulo:
import math
Esta instrucción hace que todas las funciones, clases y variables definidas en el módulo math
estén disponibles en nuestro programa, pero debemos acceder a ellas utilizando la notación de punto:
# Accedemos a la constante pi del módulo math
radio = 5
area = math.pi * radio**2
print(f"El área del círculo es: {area}")
Podemos importar múltiples módulos en una sola línea, separándolos por comas:
import os, sys, random
Sin embargo, la guía de estilo oficial de Python (PEP 8) recomienda importar cada módulo en una línea separada para mejorar la legibilidad:
import os
import sys
import random
Importación con rutas de módulos
Cuando trabajamos con módulos organizados en paquetes o subpaquetes, podemos importarlos especificando la ruta completa:
import urllib.request
import xml.etree.ElementTree
Esto nos permite acceder a módulos específicos dentro de paquetes más grandes, manteniendo una estructura organizada.
Importación con nombres personalizados
A veces, los nombres de los módulos pueden ser largos o pueden entrar en conflicto con otros nombres en nuestro código. Python permite asignar un alias al módulo importado utilizando la palabra clave as
:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
# Ahora podemos usar los alias
data = np.array([1, 2, 3, 4, 5])
print(np.mean(data)) # En lugar de numpy.mean(data)
Esta técnica es especialmente útil para módulos con nombres largos o para seguir convenciones comunes en la comunidad de Python (como usar np
para NumPy).
Importación selectiva
Si solo necesitamos algunas funciones o clases específicas de un módulo, podemos importarlas directamente sin importar todo el módulo:
from datetime import datetime, timedelta
# Podemos usar las funciones directamente sin el prefijo del módulo
ahora = datetime.now()
mañana = ahora + timedelta(days=1)
print(f"Ahora: {ahora}")
print(f"Mañana a esta hora: {mañana}")
También podemos importar todo el contenido de un módulo directamente en nuestro espacio de nombres:
from math import *
# Podemos usar las funciones directamente
print(sin(pi/2)) # 1.0
print(sqrt(16)) # 4.0
Sin embargo, esta práctica no es recomendada en código de producción, ya que puede causar conflictos de nombres y hace que sea difícil rastrear el origen de las funciones utilizadas.
Importación condicional
En ocasiones, necesitamos importar módulos solo bajo ciertas condiciones. Python permite realizar importaciones dentro de bloques condicionales:
if sys.platform.startswith('win'):
import winreg
else:
import pwd
Esta técnica es útil para manejar dependencias específicas de plataforma o para importar módulos opcionales.
Importación con manejo de excepciones
Podemos manejar posibles errores durante la importación utilizando bloques try-except:
try:
import numpy as np
NUMPY_AVAILABLE = True
except ImportError:
NUMPY_AVAILABLE = False
print("NumPy no está instalado. Algunas funcionalidades estarán limitadas.")
# Más adelante en el código
if NUMPY_AVAILABLE:
# Usar funcionalidades de NumPy
data = np.array([1, 2, 3])
else:
# Implementación alternativa sin NumPy
data = [1, 2, 3]
Esta práctica es especialmente útil cuando nuestro código puede funcionar con o sin ciertas dependencias opcionales.
Importación de módulos dinámicos
Python también permite importar módulos de forma dinámica utilizando la función importlib.import_module()
:
import importlib
# Importar un módulo basado en una variable
module_name = "math" if need_math else "random"
module = importlib.import_module(module_name)
# Usar el módulo importado dinámicamente
if module_name == "math":
print(module.sqrt(16))
else:
print(module.randint(1, 10))
Esta técnica es avanzada pero útil cuando necesitamos decidir qué módulos importar en tiempo de ejecución.
Buenas prácticas de importación
Para mantener un código limpio y mantenible, es recomendable seguir estas prácticas:
- Colocar todas las importaciones al principio del archivo, después de los docstrings pero antes de las variables globales y el código.
- Organizar las importaciones en grupos separados por líneas en blanco:
- Módulos de la biblioteca estándar
- Módulos de terceros
- Módulos locales de la aplicación
# Biblioteca estándar
import os
import sys
from datetime import datetime
# Bibliotecas de terceros
import numpy as np
import pandas as pd
# Módulos locales
from .utils import helper
from .models import User
- Evitar importaciones circulares donde dos módulos se importan mutuamente, ya que pueden causar problemas difíciles de depurar.
- Preferir importaciones explícitas (
from module import specific_function
) sobre importaciones genéricas (from module import *
).
La sintaxis de importación de Python es flexible y potente, permitiéndonos organizar nuestro código de manera modular y reutilizable. Dominar estas técnicas es fundamental para desarrollar aplicaciones Python bien estructuradas y mantenibles.
Import, from import
La importación de módulos en Python se puede realizar de diferentes maneras, cada una con sus propias ventajas y casos de uso específicos. Las dos formas principales son mediante las declaraciones import
y from import
, que ofrecen distintos niveles de control sobre cómo accedemos a los componentes de un módulo.
Declaración import
La declaración import
es la forma más directa de incorporar un módulo completo a nuestro programa:
import random
Cuando usamos esta sintaxis, el espacio de nombres del módulo se mantiene separado del espacio de nombres actual. Esto significa que debemos acceder a los elementos del módulo utilizando la notación de punto:
# Generamos un número aleatorio entre 1 y 10
numero = random.randint(1, 10)
print(f"Número aleatorio: {numero}")
# Elegimos un elemento aleatorio de una lista
colores = ["rojo", "verde", "azul", "amarillo"]
color_elegido = random.choice(colores)
print(f"Color elegido: {color_elegido}")
Esta forma de importación tiene la ventaja de hacer explícito el origen de cada función o clase que utilizamos, lo que mejora la legibilidad y evita conflictos de nombres.
Declaración from import
La declaración from import
nos permite importar elementos específicos de un módulo directamente a nuestro espacio de nombres actual:
from random import randint, choice, shuffle
Con esta sintaxis, podemos usar las funciones importadas directamente, sin necesidad de especificar el módulo:
# Generamos un número aleatorio entre 1 y 10
numero = randint(1, 10)
print(f"Número aleatorio: {numero}")
# Elegimos un elemento aleatorio de una lista
colores = ["rojo", "verde", "azul", "amarillo"]
color_elegido = choice(colores)
print(f"Color elegido: {color_elegido}")
# Mezclamos los elementos de la lista
shuffle(colores)
print(f"Lista mezclada: {colores}")
Esta forma de importación hace que el código sea más conciso, pero puede generar confusión sobre el origen de las funciones si se importan muchos elementos de diferentes módulos.
Importación de todos los elementos
Python también permite importar todos los elementos de un módulo usando el asterisco:
from random import *
Aunque esta sintaxis puede parecer conveniente, generalmente se considera una mala práctica en código de producción por varias razones:
- Hace difícil determinar de dónde proviene cada función o clase
- Puede causar conflictos de nombres inesperados
- Dificulta el análisis estático del código por herramientas automáticas
# Ejemplo de posible conflicto
from math import *
from numpy import * # Sobrescribe algunas funciones de math
# ¿De qué módulo viene esta función sin?
resultado = sin(0.5) # ¿Es math.sin o numpy.sin?
Importación con renombrado
Tanto con import
como con from import
, podemos renombrar los elementos importados usando la palabra clave as
:
# Renombrando un módulo completo
import numpy as np
# Renombrando elementos específicos
from datetime import datetime as dt, timedelta as td
Esto es especialmente útil para:
- Abreviar nombres largos
- Evitar conflictos con nombres existentes
- Seguir convenciones comunes en la comunidad
# Uso de módulo renombrado
datos = np.array([1, 2, 3, 4, 5])
media = np.mean(datos)
print(f"Media: {media}")
# Uso de elementos renombrados
ahora = dt.now()
mañana = ahora + td(days=1)
print(f"Fecha actual: {ahora.strftime('%d/%m/%Y')}")
print(f"Mañana: {mañana.strftime('%d/%m/%Y')}")
Importación de subcomponentes
Para módulos organizados jerárquicamente, podemos importar subcomponentes específicos:
# Importación de un submódulo completo
import urllib.request
# Importación de elementos específicos de un submódulo
from urllib.request import urlopen, Request
Esto nos permite acceder a funcionalidades específicas dentro de paquetes más grandes:
# Usando el submódulo completo
respuesta = urllib.request.urlopen("https://python.org")
contenido = respuesta.read()
# Usando elementos específicos importados
req = Request("https://python.org", headers={"User-Agent": "Mozilla/5.0"})
respuesta = urlopen(req)
Importación de elementos con nombres complejos
Cuando necesitamos importar elementos con nombres que incluyen caracteres especiales o que coinciden con palabras clave de Python, podemos usar la importación con renombrado:
# Importación de una clase con nombre que coincide con una palabra clave
from mymodule import class_ as MyClass
# Importación de un elemento con nombre que incluye caracteres especiales
from othermodule import special$function as special_function
Comparación entre import y from import
Ambas formas de importación tienen sus ventajas y desventajas:
Característica | import module |
from module import element |
---|---|---|
Espacio de nombres | Mantiene separado | Integra en el espacio actual |
Claridad de origen | Alta (siempre explícito) | Baja (origen no visible) |
Concisión de código | Menor (requiere prefijo) | Mayor (uso directo) |
Riesgo de conflictos | Bajo | Más alto |
Control de importación | Todo el módulo | Selectivo |
Ejemplos prácticos
Veamos algunos ejemplos prácticos que muestran cuándo usar cada enfoque:
Ejemplo 1: Trabajando con fechas
# Enfoque con import
import datetime
fecha_actual = datetime.datetime.now()
una_semana = datetime.timedelta(days=7)
proxima_semana = fecha_actual + una_semana
# Enfoque con from import
from datetime import datetime, timedelta
fecha_actual = datetime.now()
una_semana = timedelta(days=7)
proxima_semana = fecha_actual + una_semana
El segundo enfoque es más conciso, pero el primero deja más claro el origen de cada elemento.
Ejemplo 2: Procesamiento de datos
# Enfoque con import (más explícito)
import pandas as pd
import numpy as np
df = pd.read_csv("datos.csv")
media = np.mean(df["valores"])
desviacion = np.std(df["valores"])
# Enfoque con from import (más conciso pero menos explícito)
from pandas import read_csv
from numpy import mean, std
df = read_csv("datos.csv")
media = mean(df["valores"])
desviacion = std(df["valores"])
En este caso, el primer enfoque es más común en la comunidad de ciencia de datos, ya que hace más evidente qué biblioteca proporciona cada función.
Ejemplo 3: Operaciones con archivos y sistema
# Combinación de enfoques según necesidad
import os
from pathlib import Path
from shutil import copy2, rmtree
# Verificar si un directorio existe
if not os.path.exists("backup"):
os.mkdir("backup")
# Crear una ruta de archivo
ruta_archivo = Path("documentos") / "informe.txt"
# Copiar y eliminar archivos
copy2(ruta_archivo, "backup/")
if os.path.exists("temp"):
rmtree("temp")
Este ejemplo muestra cómo podemos combinar ambos enfoques según nuestras necesidades específicas.
La elección entre import
y from import
depende del contexto específico, la claridad deseada y las convenciones del proyecto. En general, es recomendable ser consistente y priorizar la legibilidad y el mantenimiento a largo plazo del código.
Importaciones relativas y absolutas
Cuando trabajamos con proyectos Python de cierta complejidad, organizamos nuestro código en múltiples archivos distribuidos en diferentes directorios. En este contexto, entender la diferencia entre importaciones absolutas y relativas se vuelve fundamental para mantener un código organizado y evitar problemas de dependencias.
Importaciones absolutas
Las importaciones absolutas especifican la ruta completa desde la raíz del paquete hasta el módulo que queremos importar. Este tipo de importación es el comportamiento predeterminado en Python y el más recomendado para la mayoría de los casos.
# Importación absoluta
import package.subpackage.module
from package.subpackage.module import function
Las importaciones absolutas tienen varias ventajas:
- Son explícitas y claras sobre la ubicación exacta del módulo
- Funcionan independientemente de dónde se encuentre el archivo que realiza la importación
- Son más fáciles de entender para quienes no están familiarizados con el proyecto
Veamos un ejemplo de estructura de proyecto:
mi_proyecto/
├── __init__.py
├── main.py
├── utils/
│ ├── __init__.py
│ ├── helpers.py
│ └── formatters.py
└── models/
├── __init__.py
├── user.py
└── product.py
Si queremos importar funciones entre estos módulos usando importaciones absolutas:
# En main.py
from mi_proyecto.utils.helpers import validate_input
from mi_proyecto.models.user import User
# En models/product.py
from mi_proyecto.utils.formatters import format_price
from mi_proyecto.models.user import User
Estas importaciones funcionarán correctamente siempre que el directorio mi_proyecto
esté en el sys.path
de Python, lo cual ocurre automáticamente cuando ejecutamos el script desde el directorio padre o cuando el paquete está instalado.
Importaciones relativas
Las importaciones relativas especifican la ubicación de un módulo en relación con el módulo actual. Se utilizan puntos (.
) para indicar la relación entre módulos:
- Un punto (
.
) representa el paquete actual - Dos puntos (
..
) representan el paquete padre - Tres puntos (
...
) representan el paquete abuelo, y así sucesivamente
# Importaciones relativas
from . import module # Módulo en el mismo paquete
from .subpackage import module # Submódulo en el mismo paquete
from .. import module # Módulo en el paquete padre
from ..sibling import module # Módulo hermano en el paquete padre
Siguiendo con nuestro ejemplo anterior, podríamos usar importaciones relativas así:
# En models/product.py
from ..utils.formatters import format_price # Subir un nivel y entrar en utils
from . import user # Módulo en el mismo paquete
from .user import User # Clase específica del módulo hermano
Las importaciones relativas son especialmente útiles cuando:
- Reorganizamos la estructura de directorios del proyecto
- Queremos hacer el código más portable
- Trabajamos con paquetes que podrían cambiar de nombre
Restricciones de las importaciones relativas
Es importante entender algunas limitaciones de las importaciones relativas:
- Solo funcionan dentro de paquetes: No se pueden usar en scripts independientes que se ejecutan directamente.
# Esto fallará si ejecutamos el script directamente
from .utils import helper # ModuleNotFoundError
- Requieren que el módulo tenga un nombre: El módulo debe ser parte de un paquete y ejecutarse como tal.
# Esto fallará con importaciones relativas
python models/user.py
# Esto funcionará
python -m mi_proyecto.models.user
- No pueden ir más allá de la raíz del paquete: No podemos usar
...
para salir completamente del paquete.
Ejemplo práctico: Aplicación web
Veamos un ejemplo más completo de una aplicación web con diferentes módulos:
webapp/
├── __init__.py
├── app.py
├── config/
│ ├── __init__.py
│ ├── settings.py
│ └── constants.py
├── models/
│ ├── __init__.py
│ ├── user.py
│ └── post.py
└── utils/
├── __init__.py
├── db.py
└── validators.py
Usando importaciones absolutas:
# En app.py
from webapp.config.settings import DEBUG, SECRET_KEY
from webapp.models.user import User
from webapp.utils.db import connect_db
# En models/post.py
from webapp.models.user import User
from webapp.utils.validators import validate_content
from webapp.config.constants import MAX_POST_LENGTH
Usando importaciones relativas:
# En app.py (archivo en la raíz del paquete)
from .config.settings import DEBUG, SECRET_KEY
from .models.user import User
from .utils.db import connect_db
# En models/post.py
from . import user
from .user import User
from ..utils.validators import validate_content
from ..config.constants import MAX_POST_LENGTH
Cuándo usar cada tipo de importación
La elección entre importaciones absolutas y relativas depende del contexto y las necesidades específicas:
Importaciones absolutas | Importaciones relativas |
---|---|
Proyectos grandes con muchos colaboradores | Paquetes que podrían cambiar de nombre |
Código que necesita ser explícito | Refactorizaciones frecuentes de estructura |
Módulos que se ejecutan como scripts | Módulos que solo se importan como parte de un paquete |
Preferidas por PEP 8 (guía de estilo oficial) | Útiles para evitar repetición en rutas largas |
Mejores prácticas
Para mantener un código limpio y evitar problemas, considera estas recomendaciones:
- Sé consistente: Elige un enfoque y úsalo de manera uniforme en todo el proyecto
- Prefiere importaciones absolutas para proyectos grandes y colaborativos
- Usa importaciones relativas solo cuando ofrezcan una ventaja clara
- Evita mezclar ambos estilos en el mismo módulo sin una buena razón
- Documenta la estructura del proyecto para facilitar la navegación
# Ejemplo de buena práctica: agrupación lógica de importaciones
# Primero importaciones de biblioteca estándar
import os
import sys
from datetime import datetime
# Después importaciones absolutas de terceros
import requests
import pandas as pd
# Finalmente importaciones del proyecto (absolutas o relativas consistentemente)
from mi_proyecto.utils.helpers import format_date
from .models import User, Post
Solución de problemas comunes
Algunos errores frecuentes relacionados con importaciones y cómo solucionarlos:
- ModuleNotFoundError: Ocurre cuando Python no puede encontrar el módulo.
# Error: ModuleNotFoundError: No module named 'mi_proyecto'
from mi_proyecto.utils import helpers
# Solución: Asegúrate de que el directorio raíz esté en sys.path
import sys
sys.path.append('/ruta/al/directorio/padre')
# O ejecuta desde el directorio correcto
- ImportError con importaciones relativas: Ocurre al usar importaciones relativas en scripts ejecutados directamente.
# Error: ImportError: attempted relative import with no known parent package
from ..utils import helpers
# Solución: Ejecuta como módulo, no como script
# En lugar de: python models/user.py
# Usa: python -m mi_proyecto.models.user
- Importaciones circulares: Ocurren cuando dos módulos se importan mutuamente.
# En a.py
from b import function_b # Importa b, que a su vez importa a
# En b.py
from a import function_a # Importa a, que a su vez importa b
# Solución: Reestructura el código o mueve la importación dentro de la función
def function_b():
from a import function_a # Importación local
return function_a()
Las importaciones relativas y absolutas son herramientas poderosas que, cuando se utilizan correctamente, nos ayudan a mantener un código modular, organizado y fácil de mantener. La elección entre una u otra dependerá de las necesidades específicas de cada proyecto, pero entender ambas es esencial para cualquier desarrollador Python.
Alias de importación
Los alias de importación constituyen una característica fundamental en Python que permite renombrar módulos o elementos específicos durante su importación. Esta técnica resulta particularmente útil cuando trabajamos con nombres de módulos largos, complejos o potencialmente conflictivos.
La sintaxis para crear un alias es sencilla y se implementa mediante la palabra clave as
:
import módulo as alias
from módulo import elemento as alias_elemento
Ventajas de utilizar alias
El uso de alias en las importaciones ofrece múltiples beneficios:
- Mejora la legibilidad del código al simplificar nombres extensos
- Evita conflictos de nombres entre diferentes módulos
- Facilita la migración entre bibliotecas similares
- Reduce la cantidad de código al trabajar con nombres más cortos
- Sigue convenciones establecidas en la comunidad Python
Alias para módulos completos
Una de las aplicaciones más comunes de los alias es simplificar nombres de módulos largos:
import matplotlib.pyplot as plt
import tensorflow as tf
import pandas as pd
# Uso de los alias
plt.figure(figsize=(10, 6))
df = pd.DataFrame({'valores': [1, 2, 3, 4, 5]})
modelo = tf.keras.Sequential()
Este enfoque no solo hace que el código sea más conciso, sino que también sigue las convenciones estándar de la comunidad científica y de análisis de datos en Python.
Alias para elementos específicos
También podemos crear alias para elementos individuales importados con from import
:
from datetime import datetime as dt
from collections import defaultdict as dd
from functools import partial as p
# Uso de los alias
ahora = dt.now()
contador = dd(int)
duplicar = p(lambda x, y: x * y, 2)
Esta técnica es especialmente útil cuando:
- El nombre original es demasiado largo o poco descriptivo
- Necesitamos distinguir entre elementos con nombres similares
- Queremos adaptar la terminología al contexto específico de nuestra aplicación
Resolución de conflictos de nombres
Los alias son una herramienta excelente para resolver conflictos de nombres entre diferentes módulos:
# Dos módulos diferentes con una función 'parse'
from html_parser import parse as parse_html
from json_parser import parse as parse_json
# Ahora podemos usar ambas funciones sin ambigüedad
contenido_html = parse_html("<p>Ejemplo</p>")
contenido_json = parse_json('{"clave": "valor"}')
Sin los alias, tendríamos que importar los módulos completos o arriesgarnos a que una importación sobrescriba a la otra.
Alias para facilitar la migración de código
Los alias pueden facilitar la transición entre diferentes bibliotecas o versiones:
# Versión antigua del código
try:
import antiguo_modulo as modulo
except ImportError:
import nuevo_modulo as modulo
# El resto del código usa 'modulo' independientemente de cuál se importó
resultado = modulo.procesar_datos(entrada)
Esta técnica permite mantener la compatibilidad con diferentes entornos o facilitar la migración gradual a nuevas bibliotecas.
Alias en importaciones anidadas
Los alias también funcionan con importaciones de submódulos:
import xml.etree.ElementTree as ET
from multiprocessing.dummy import Pool as ThreadPool
# Uso de los alias
root = ET.fromstring("<root><item>1</item></root>")
pool = ThreadPool(4)
Esto es particularmente útil para acceder a componentes profundamente anidados en paquetes grandes.
Convenciones comunes de alias
Existen algunas convenciones ampliamente adoptadas para alias de módulos populares:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import tensorflow as tf
import scipy as sp
import statsmodels.api as sm
Seguir estas convenciones hace que el código sea más reconocible para otros desarrolladores familiarizados con el ecosistema Python.
Alias descriptivos según el contexto
A veces, es útil crear alias que reflejen mejor el propósito específico del módulo en nuestro contexto:
import requests as http_client
import json as json_parser
import logging as logger
# El código comunica mejor la intención
response = http_client.get('https://api.ejemplo.com/datos')
datos = json_parser.loads(response.text)
logger.info("Datos recibidos correctamente")
Estos alias pueden hacer que el código sea más autodocumentado y expresivo.
Alias para clases y funciones específicas
Podemos crear alias para elementos específicos que hacen el código más claro:
from pathlib import Path as FilePath
from datetime import datetime as DateTime
from collections import namedtuple as StructType
# Uso con nombres más descriptivos
ruta = FilePath("/var/log/app.log")
ahora = DateTime.now()
Punto = StructType('Punto', ['x', 'y', 'z'])
Ejemplo práctico: Análisis de datos
Veamos un ejemplo más completo que muestra cómo los alias mejoran la legibilidad en un flujo de trabajo de análisis de datos:
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split as split_data
from sklearn.linear_model import LinearRegression as LinReg
from sklearn.metrics import mean_squared_error as mse
# Cargar y preparar datos
datos = pd.read_csv("datos.csv")
X = datos[['caracteristica1', 'caracteristica2']]
y = datos['objetivo']
# Dividir datos
X_train, X_test, y_train, y_test = split_data(X, y, test_size=0.3, random_state=42)
# Entrenar modelo
modelo = LinReg()
modelo.fit(X_train, y_train)
# Evaluar modelo
predicciones = modelo.predict(X_test)
error = np.sqrt(mse(y_test, predicciones))
print(f"Error cuadrático medio: {error:.4f}")
# Visualizar resultados
plt.figure(figsize=(10, 6))
plt.scatter(y_test, predicciones, alpha=0.7)
plt.plot([y.min(), y.max()], [y.min(), y.max()], 'r--')
plt.xlabel('Valores reales')
plt.ylabel('Predicciones')
plt.title('Comparación entre valores reales y predicciones')
plt.tight_layout()
plt.show()
Los alias hacen que este código sea más conciso y fácil de seguir, especialmente para quienes están familiarizados con las convenciones de la comunidad de ciencia de datos.
Consideraciones y buenas prácticas
Al utilizar alias de importación, es recomendable seguir estas pautas:
- Sé consistente con los alias en todo el proyecto
- Sigue las convenciones establecidas para bibliotecas populares
- Documenta los alias no convencionales en el código
- Evita alias confusos que puedan llevar a malentendidos
- No abuses de los alias; úsalos cuando realmente aporten valor
# Ejemplo de documentación de alias no convencionales
import tensorflow as tf # Biblioteca de aprendizaje profundo
import torch as pt # PyTorch para modelos alternativos
import pandas as pd # Manipulación de datos tabulares
import dask.dataframe as ddf # Para conjuntos de datos distribuidos
# Explicación al inicio del archivo sobre la convención de alias utilizada
Los alias de importación, cuando se utilizan adecuadamente, pueden mejorar significativamente la legibilidad y mantenibilidad del código Python, especialmente en proyectos complejos que utilizan múltiples bibliotecas externas.
Otros ejercicios de programación de Python
Evalúa tus conocimientos de esta lección Importar módulos y paquetes con nuestros retos de programación de tipo Test, Puzzle, Código y Proyecto con VSCode, guiados por IA.
Módulo math
Reto herencia
Excepciones
Introducción a Python
Reto variables
Funciones Python
Reto funciones
Módulo datetime
Reto acumulación
Reto estructuras condicionales
Polimorfismo
Módulo os
Reto métodos dunder
Diccionarios
Reto clases y objetos
Reto operadores
Operadores
Estructuras de control
Funciones lambda
Reto diccionarios
Reto función lambda
Encapsulación
Reto coleciones
Reto funciones auxiliares
Crear módulos y paquetes
Módulo datetime
Excepciones
Operadores
Diccionarios
Reto map, filter
Reto tuplas
Proyecto gestor de tareas CRUD
Tuplas
Variables
Tipos de datos
Conjuntos
Reto mixins
Módulo csv
Módulo json
Herencia
Análisis de datos de ventas con Pandas
Reto fechas y tiempo
Reto estructuras de iteración
Funciones
Reto comprehensions
Variables
Reto serialización
Módulo csv
Reto polimorfismo
Polimorfismo
Clases y objetos
Reto encapsulación
Estructuras de control
Importar módulos y paquetes
Módulo math
Funciones lambda
Reto excepciones
Listas
Reto archivos
Encapsulación
Reto conjuntos
Clases y objetos
Instalación de Python y creación de proyecto
Reto listas
Tipos de datos
Crear módulos y paquetes
Tuplas
Herencia
Reto acceso a sistema
Proyecto sintaxis calculadora
Importar módulos y paquetes
Clases y objetos
Módulo os
Listas
Conjuntos
Reto tipos de datos
Reto matemáticas
Módulo json
Todas las lecciones de Python
Accede a todas las lecciones de Python y aprende con ejemplos prácticos de código y ejercicios de programación con IDE web sin instalar nada.
Introducción A Python
Introducción
Instalación Y Creación De Proyecto
Introducción
Tema 2: Tipos De Datos, Variables Y Operadores
Introducción
Instalación De Python
Introducción
Tipos De Datos
Sintaxis
Variables
Sintaxis
Operadores
Sintaxis
Estructuras De Control
Sintaxis
Funciones
Sintaxis
Estructuras Control Iterativo
Sintaxis
Estructuras Control Condicional
Sintaxis
Testing Con Pytest
Sintaxis
Listas
Estructuras De Datos
Tuplas
Estructuras De Datos
Diccionarios
Estructuras De Datos
Conjuntos
Estructuras De Datos
Comprehensions
Estructuras De Datos
Clases Y Objetos
Programación Orientada A Objetos
Excepciones
Programación Orientada A Objetos
Encapsulación
Programación Orientada A Objetos
Herencia
Programación Orientada A Objetos
Polimorfismo
Programación Orientada A Objetos
Mixins Y Herencia Múltiple
Programación Orientada A Objetos
Métodos Especiales (Dunder Methods)
Programación Orientada A Objetos
Composición De Clases
Programación Orientada A Objetos
Funciones Lambda
Programación Funcional
Aplicación Parcial
Programación Funcional
Entrada Y Salida, Manejo De Archivos
Programación Funcional
Decoradores
Programación Funcional
Generadores
Programación Funcional
Paradigma Funcional
Programación Funcional
Composición De Funciones
Programación Funcional
Funciones Orden Superior Map Y Filter
Programación Funcional
Funciones Auxiliares
Programación Funcional
Reducción Y Acumulación
Programación Funcional
Archivos Comprimidos
Entrada Y Salida Io
Entrada Y Salida Avanzada
Entrada Y Salida Io
Archivos Temporales
Entrada Y Salida Io
Contexto With
Entrada Y Salida Io
Módulo Csv
Biblioteca Estándar
Módulo Json
Biblioteca Estándar
Módulo Datetime
Biblioteca Estándar
Módulo Math
Biblioteca Estándar
Módulo Os
Biblioteca Estándar
Módulo Re
Biblioteca Estándar
Módulo Random
Biblioteca Estándar
Módulo Time
Biblioteca Estándar
Módulo Collections
Biblioteca Estándar
Módulo Sys
Biblioteca Estándar
Módulo Statistics
Biblioteca Estándar
Módulo Pickle
Biblioteca Estándar
Módulo Pathlib
Biblioteca Estándar
Importar Módulos Y Paquetes
Paquetes Y Módulos
Crear Módulos Y Paquetes
Paquetes Y Módulos
Entornos Virtuales (Virtualenv, Venv)
Entorno Y Dependencias
Gestión De Dependencias (Pip, Requirements.txt)
Entorno Y Dependencias
Python-dotenv Y Variables De Entorno
Entorno Y Dependencias
Acceso A Datos Con Mysql, Pymongo Y Pandas
Acceso A Bases De Datos
Acceso A Mongodb Con Pymongo
Acceso A Bases De Datos
Acceso A Mysql Con Mysql Connector
Acceso A Bases De Datos
Novedades Python 3.13
Características Modernas
Operador Walrus
Características Modernas
Pattern Matching
Características Modernas
Instalación Beautiful Soup
Web Scraping
Sintaxis General De Beautiful Soup
Web Scraping
Tipos De Selectores
Web Scraping
Web Scraping De Html
Web Scraping
Web Scraping Para Ciencia De Datos
Web Scraping
Autenticación Y Acceso A Recursos Protegidos
Web Scraping
Combinación De Selenium Con Beautiful Soup
Web Scraping
En esta lección
Objetivos de aprendizaje de esta lección
- Comprender la sintaxis básica para importar módulos y paquetes en Python.
- Diferenciar entre las declaraciones
import
yfrom import
y sus usos adecuados. - Conocer la diferencia entre importaciones absolutas y relativas y cuándo utilizarlas.
- Aprender a utilizar alias en importaciones para mejorar la legibilidad y evitar conflictos.
- Aplicar buenas prácticas para organizar y manejar importaciones en proyectos Python.