Importar módulo en Python con ejemplos

Las secciones siguientes explican los módulos, los paquetes, los diferentes estilos de importación y cómo funcionan las importaciones absolutas y relativas en Python.

¿Cuáles son los módulos en Python?

Un módulo es un archivo con Python Código. El código puede estar en forma de variables, funciones o una clase definida. El nombre del archivo se convierte en el nombre del módulo.

Por ejemplo, si su nombre de archivo es guru99.py, el nombre del módulo será guru99. Con la funcionalidad del módulo, puede dividir su código en diferentes archivos en lugar de escribir todo dentro de un solo archivo.

¿Qué es el Python módulo de importación?

Un archivo se considera un módulo en PythonPara usar el módulo, debe importarlo usando el importar palabra clave. Las funciones o variables presentes en el archivo se pueden usar en otro archivo importando el módulo. Esta funcionalidad está disponible en otros lenguajes como TypeScript, JavaTexto, Java, rubí, etc

Cómo crear e importar un módulo en Python?

Ahora crearemos un módulo y lo importaremos a otro archivo.

Este es el flujo para crear e importar el módulo como se muestra en la captura de pantalla:

Siga los pasos indicados para crear un módulo en Python.

La estructura de carpetas utilizada para probar el código es la siguiente:

modtest/
	test.py
	display.py	

Paso 1) Crea un archivo y nómbralo test.py.

Paso 2) Dentro de test.py crea una función llamada display_message()

Def display_message():
    return "Welcome to Guru99 Tutorials!"

Paso 3) Ahora crea otro archivo display.py.

Paso 4) Dentro de display.py, importa el archivo test.py del módulo, como se muestra a continuación:

import test

Al importar, no es necesario mencionar el archivo test.py, sino solo el nombre del archivo.

Paso 5) Luego puedes llamar a la función display_message() desde test.py dentro de display.py. Necesitas usar module_name.function_name.

Por ejemplo test.display_message().

Import test
print(test.display_message())

Paso 6) Cuando ejecute display.py, obtendrá lo siguiente Salida:

Welcome to Guru99 Tutorials!

Importar una clase en Python

Anteriormente, vimos un módulo simple con una función. Aquí crearemos una clase y haremos referencia a ella dentro de otro archivo.

La estructura de carpetas para probar el código es la siguiente:

myproj/
	Car.py
	display.py

Crea un archivo llamado Car.py con el siguiente código:

Nombre del archivo: Car.py

class Car:
	brand_name = "BMW"
	model = "Z4"
	manu_year = "2020"

	def __init__(self, brand_name, model, manu_year):
		self.brand_name = brand_name
		self.model = model
		self.manu_year = manu_year

	def car_details(self):
		print("Car brand is ", self.brand_name)
		print("Car model is ", self.model)
		print("Car manufacture year is ", self.manu_year)
			
			
	def get_Car_brand(self):
		print("Car brand is ", self.brand_name)

	def get_Car_model(self):
		print("Car model is ", self.model) 

En el archivo Car.py, hay atributos brand_name, model y manu_year. Las funciones definidas dentro de la clase son car_details(), get_Car_brand(), get_Car_model().

Usemos ahora el archivo Car.py como módulo en otro archivo llamado display.py.

Nombre de archivo: display.py

import Car
car_det = Car.Car("BMW","Z5", 2020)
print(car_det.brand_name)
print(car_det.car_details())
print(car_det.get_Car_brand())
print(car_det.get_Car_model())

Salida:

BMW
Car brand is  BMW
Car model is  Z5
Car manufacture year is  2020
Car brand is  BMW
Car model is  Z5

Así, podemos acceder a todas las variables y funciones de Car.py utilizando el módulo Car.

Usando desde para importar el módulo

Puedes importar solo una pequeña parte del módulo, es decir, solo las funciones y los nombres de variables necesarios, en lugar de importar el código completo.

Cuando desee importar solo elementos específicos, puede utilizar la palabra clave "from" para importar lo que desee.

Entonces la sintaxis es

from  module import your function_name , variables,... etc.

La estructura de carpetas utilizada para probar el código es la siguiente:

modtest/
	test.py
	display.py	

En test.py hay 2 funciones como se muestra:

Nombre de archivo: prueba.py

defdisplay_message():
	return "Welcome to Guru99 Tutorials!"
	
def display_message1():
	return "All about Python!"

Ahora necesitas la función display_message(). Puedes acceder directamente a la función o variable que estás importando, como se muestra a continuación:

Nombre del archivo: display.py

from test import display_message
print(display_message())

Salida:

Welcome to Guru99 Tutorials!

Ahora bien, si por casualidad utiliza la función display_message1(), se producirá un error que indica que la función no está definida, como se muestra a continuación:

from test import display_message
print(display_message1())

Salida:

Traceback (most recent call last):
File "display.py", line 3, in <module>
print(display_message1())
Name Error: name 'display_message1' is not defined

Importando todo desde el módulo

Importar le permite importar el módulo completo utilizando import seguido del nombre del módulo, es decir, el nombre del archivo o la biblioteca que se va a utilizar.

Sintaxis:

Import module

O usando

from module import *

La estructura de carpetas utilizada para probar el código es la siguiente:

modtest/
	test.py
	display.py	

A continuación se muestran los detalles del código dentro de test.py

my_name = "Guru99"
my_address = "Mumbai"

defdisplay_message():
	return "Welcome to Guru99 Tutorials!"
	
	
def display_message1():
	return "All about Python!"

Usando el módulo de importación

Para utilizar únicamente el nombre del módulo de importación, y hacer referencia a las variables y funciones dentro del módulo, debe anteponerles el nombre del módulo.

Ejemplo

Nombre de archivo: display.py

Import test
print(test.display_message())
print(test.display_message1())
print(test.my_name)
print(test.my_address)

El nombre del módulo "test" se utiliza para referirse a las funciones y variables dentro del módulo "test".

Salida:

Welcome to Guru99 Tutorials!
All about Python!
Guru99
Mumbai

Usando importar *

Veamos un ejemplo usando importar *. Utilizando importar *, se puede acceder directamente a las funciones y variables, como se muestra en el siguiente ejemplo:

from test import *

print(display_message())
print(display_message1())
print(my_name)
print(my_address)

Salida:

Welcome to Guru99 Tutorials!
All about Python!
Guru99
Mumbai

La función directorio( )

La función dir() es una función integrada en Python. El método dir() devuelve todas las propiedades y métodos, incluidas las propiedades integradas del objeto dado.

Así que cuando se usa dir() en el módulo, te dará las variables y funciones que están presentes dentro del módulo.

Aquí tienes un ejemplo práctico de dir() en un módulo. Tenemos una clase llamada Car.py; importemos Car y asignémosla a dir() para ver el resultado.

La estructura de carpetas para probar el código será la siguiente:

test prop/
	Car.py
	test.py	

Nombre de archivo: Car.py

class Car:
	brand_name = "BMW"
	model = "Z4"
	manu_year = "2020"

	def __init__(self, brand_name, model, manu_year):
		self.brand_name = brand_name
		self.model = model
		self.manu_year = manu_year

	def car_details(self):
		print("Car brand is ", self.brand_name)
		print("Car model is ", self.model)
		print("Car manufacture year is ", self.manu_year)
			
			
	def get_Car_brand(self):
		print("Car brand is ", self.brand_name)

	def get_Car_model(self):
		print("Car model is ", self.model) 

Nombre de archivo: prueba.py

import Car

class_contents = dir(Car)
print(class_contents)

La salida nos da el nombre de la clase y todas las funciones definidas en Car.py.

También puedes intentar usar dir() en un módulo integrado disponible en PythonIntentemos lo mismo en el json módulo como se muestra en el ejemplo a continuación. Mostrará todas las propiedades y métodos disponibles en el json .

Import json
json_details = dir(json)
print(json_details)

Salida:

['JSONDecodeError', 'JSONDecoder', 'JSONEncoder', '__all__', '__author__', '__bu
iltins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__pac
kage__', '__path__', '__spec__', '__version__', '_default_decoder', '_default_en
coder', 'codecs', 'decoder', 'detect_encoding', 'dump', 'dumps', 'encoder', 'loa
d', 'loads', 'scanner']

Paquetes

Un paquete es un directorio con todos los módulos definidos en su interior. para hacer un Python El intérprete lo trata como un paquete; su directorio debe contener el archivo __init__.py. Este archivo convierte el directorio en un paquete. A continuación, se muestra la estructura del paquete con el que vamos a trabajar.

El nombre del paquete es mi paquetePara empezar a trabajar con el paquete, crea un directorio llamado mypackage/. Dentro de este directorio, crea un archivo vacío llamado __init__.py. Crea tres archivos más: module1.py, module2.py y module3.py, y define las funciones como se muestra en la captura de pantalla. Aquí tienes los detalles de module1.py, module2.py y module3.py.

módulo1.py

def mod1_func1():
print("Welcome to Module1 function1")

def mod1_func2():
print("Welcome to Module1 function2")

def mod1_func3():
print("Welcome to Module1 function3")

módulo2.py

def mod2_func1():
print("Welcome to Module2 function1")

def mod2_func2():
print("Welcome to Module2 function2")

def mod2_func3():
print("Welcome to Module2 function3")

módulo3.py

def mod3_func1():
print("Welcome to Module3 function1")

def mod3_func2():
print("Welcome to Module3 function2")

def mod3_func3():
print("Welcome to Module3 function3")

El PARA DOS Está listo para usarse. Ahora llama al paquete dentro de cualquiera de tus archivos como se muestra a continuación en test.py:

Aquí, mypackage.module1 se importa y se le asigna un nombre de alias como modo1. De manera similar, puede utilizar los otros módulos module2.py y module3.py de mypackage.

import mypackage.module1 as mod1

print(mod1.mod1_func1())
print(mod1.mod1_func2())
print(mod1.mod1_func2())

Salida:

Welcome to Module1 function1
None
Welcome to Module1 function2
None
Welcome to Module1 function2
None

Acabamos de mostrar el paquete con un módulo sencillo que contiene funciones. Según su proyecto, también puede crear paquetes con subpaquetes, es decir, subcarpetas con módulos que contienen clases definidas.

Python Ruta de búsqueda del módulo

Durante la ejecución, cuando Python viene a través de importar nombre del móduloEl intérprete intenta localizar el módulo. Busca el módulo en la lista de módulos integrados y, a continuación, en todos los directorios definidos en sys.path.

En resumen, el intérprete realiza la siguiente búsqueda para localizar el módulo:

1. En su directorio actual.
2. En la lista de módulos integrados.
3. Dentro de los directorios sys.path.

Puedes obtener los detalles de sys.path importando el módulo sys e imprimiendo sys.path. Esto te dará la lista de directorios como se muestra a continuación:

importsys
print(sys.path)

Salida:

['Python Latest\\task2', 'Users\\AppData\\Local\\Programs\\Python\
\Python37\\python37.zip', 'Users\\AppData\\Local\\Programs\\Python\\P
ython37\\DLLs']

También puede modificar la ruta y conservar los directorios según sus requisitos.

Usando el alias del módulo en la importación

También puede convertir el nombre del módulo a una forma más corta asignándole un alias. El alias se puede crear utilizando el as palabra clave.

Sintaxis:

import filename as alias name

La estructura de carpetas para probar el código será la siguiente:

Mod test/
	test.py
	display.py	

A continuación se muestra el código dentro de test.py

my_name = "Guru99"
my_address = "Mumbai"

def display_message():
	return "Welcome to Guru99 Tutorials!"	
	
def display_message1():
	return "All about Python!"

Ahora utilizaremos un alias para test.py en display.py.

Import test as t

print(t.display_message())
print(t.display_message1())
print(t.my_name)
print(t.my_address)

El alias utilizado para el módulo de prueba es t. Por lo tanto, se puede hacer referencia a las funciones y variables de test.py utilizando el alias t.

Salida:

Welcome to Guru99 Tutorials!
All about Python!
Guru99
Mumbai

Importaciones absolutas y relativas en Python

Ahora sabes cómo importar un archivo como un módulo dentro de otro archivo. Veamos ahora cómo administrar los archivos disponibles en las carpetas. Los archivos de las carpetas se pueden importar mediante importaciones absolutas o relativas.

Considere que tiene la estructura de carpetas de su proyecto, como se muestra a continuación:

La carpeta raíz es myproject/. Tiene dos subcarpetas: package1 y package2.

La carpeta package1 contiene dos módulos: module1.py y module2.py.

La carpeta paquete2 tiene una clase myclass.py, un subpaquete subpkg con module3.py y el último module4.py.

• En module1.py, hay una función llamada myfunc1.
• En module2.py, hay una función llamada myfunc2.
• En module3.py, hay una función llamada myfunc3.
• En module4.py, hay una función llamada myfunc4.

Usando importaciones absolutas

Para importaciones absolutas, debes agregar la ruta completa de tu módulo directamente desde la carpeta raíz del proyecto.

Veamos ahora cómo utilizar las importaciones absolutas para referirnos a las funciones presentes en cada uno de los módulos.

Para trabajar con la función myfunc1, deberá importarla de la siguiente manera:

from package1.module1  import  myfunc1
or
from package1 import module1
module1.myfunc1()  

Para trabajar con la función myfunc3, deberá importarla de la siguiente manera:

from package1.subpkg.module3  import  myfunc3
or
from package1.subpkg import module3
module3.myfunc3()  

Ventajas y desventajas de utilizar importaciones absolutas

Estas son las ventajas de utilizar importaciones absolutas:

• Se vuelve fácil tracDevolvemos los módulos para la comprobación del código.
• Fácil de usar y muy sencillo.
• Si el proyecto se traslada a una ruta diferente, las importaciones seguirán siendo las mismas.

Desventajas de utilizar importaciones absolutas

Estas son las desventajas de usar importaciones absolutas:

• La ruta de importación puede volverse muy larga si los módulos están anidados y los nombres de los módulos son extensos.

Usar importaciones relativas

Teniendo en cuenta la misma estructura de carpetas mencionada anteriormente, veremos cómo importarla utilizando importaciones relativas.

En una importación relativa, el módulo que se va a importar es relativo a la ubicación actual, es decir, la ubicación donde se encuentra la instrucción de importación.

Sintaxis

En importaciones relativas, debe agregar un punto (.) antes del nombre del módulo al importar usando desde.

Habrá dos puntos (..) antes del nombre del módulo si el módulo está un nivel por encima de la ubicación actual.

Haciendo referencia a la figura de la estructura de carpetas mencionada anteriormente, tenemos los siguientes módulos con sus funciones, a los que debemos consultar.

• En module1.py, hay una función llamada myfunc1.
• En module2.py, hay una función llamada myfunc2.
• En module3.py, hay una función llamada myfunc3.
• En module4.py, hay una función llamada myfunc4.

Para trabajar con la función myfunc1, deberá importarla de la siguiente manera:

from  .module1  import  myfunc1

Para trabajar con la función myfunc3, deberá importarla de la siguiente manera:

from  .subpkg.module3  import  myfunc3

Ventajas de las importaciones relativas

• Es fácil trabajar con importaciones relativas.
• Desde la ubicación actual, las importaciones se pueden acortar en comparación con las importaciones absolutas.

Desventajas de las importaciones relativas

• Utilizando importaciones relativas, es difícil tracy de vuelta donde reside el código.

Preguntas Frecuentes