Módulo de importación en Python con ejemplos

¿Qué son los módulos en Python?

Un módulo es un archivo con código python. El código puede tener la forma de variables, funciones o clases definidas. El nombre de 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 archivo.

En este tutorial, aprenderá:

¿Qué son los módulos en Python?
Módulo de importación de Python
¿Cómo crear e importar un módulo en Python?
Importación de una clase en Python
Uso del módulo de importación
Importando todo desde el módulo
Uso del módulo de importación
Usando importar *
La función dir( )
Paquetes
PythonModuleSearchPath
Usando el alias del módulo en la importación
Importaciones absolutas y relativas en Python
Uso de importaciones absolutas
Uso de importaciones relativas

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

Un archivo se considera como un módulo en python. Para usar el módulo, debe importarlo usando la importación palabra clave. La función o las variables presentes dentro del archivo se pueden usar en otro archivo importando el módulo. Esta funcionalidad está disponible en otros lenguajes, como mecanografiado, JavaScript, java, ruby, etc.

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

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

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

Siga los pasos dados 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) Cree un archivo y asígnele el nombre 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 moduletest.py, como se muestra a continuación:

import test

Durante la importación, no es necesario que mencione test.py sino solo el nombre del archivo.

Paso 5)

Luego puede llamar a la función display_message() desde test.py dentro de display.py, debe usar module_name.function_name.

Por ejemplo test.display_message().

Import test
print(test.display_message())

Paso 6)

Cuando ejecute display.py, obtendrá el siguiente resultado:

Welcome to Guru99 Tutorials!

Importar una clase en Python

Anteriormente, hemos visto un módulo simple con una función. Aquí creará una clase y referirá la clase dentro de otro archivo.

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

myproj/
	Car.py
	display.py

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

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)

En el archivo Car.py se encuentran los 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:mostrar.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

Entonces podemos acceder a todas las variables y funciones de Car.py usando el módulo Car.

Uso del módulo de importación

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

Cuando desee importar solo cosas específicas, puede utilizar la palabra clave "desde" 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 quieres la función display_message(). Se puede acceder directamente a la función o variable que está importando como se muestra a continuación:

Nombre del archivo:mostrar.py

from test import display_message
print(display_message())

Salida:

Welcome to Guru99 Tutorials!

Ahora, si usa la función display_message1(), arrojará un error de 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 importar seguido del nombre del módulo, es decir, el nombre del archivo o la biblioteca que se 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

Los siguientes son 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!"

Uso del módulo de importación

Usando solo el nombre del módulo de importación, para referirse a las variables y funciones dentro del módulo, tiene que prefijar con el nombre del módulo.

Ejemplo

Nombre de archivo:mostrar.py

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

La prueba del nombre del módulo se usa para referirse a la función y las variables dentro de la prueba del módulo.

Salida:

Welcome to Guru99 Tutorials!
All about Python!
Guru99
Mumbai

Uso de importar *

Veamos un ejemplo usando import * . Usando importar * , las funciones y variables son directamente accesibles, 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 dir()

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

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

Aquí hay un ejemplo funcional de dir() en un módulo. Tenemos una clase llamada Car.py, importemos Car y asignemos 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 puede intentar usar dir() en un módulo integrado disponible en Python. Probemos lo mismo en json módulo como se muestra en el siguiente ejemplo. Mostrará todas las propiedades y métodos disponibles en json módulo.

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 que un intérprete de Python lo trate como un paquete, su directorio debe tener el archivo init.py. El init.py hace que el directorio sea un paquete. Aquí está el diseño del paquete en el que vamos a trabajar.

El nombre del paquete es mi paquete . Para comenzar a trabajar con el paquete, cree un directorio llamado paquete/. Dentro del directorio, cree un archivo vacío llamado __init__.py. Cree 3 archivos más module1.py, module2.py y module3.py y defina las funciones como se muestra en la captura de pantalla. Estos son 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")

modulo2.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")

modulo3.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 paquete está listo para usar. Ahora llame al paquete dentro de cualquiera de sus archivos como se muestra a continuación :test.py:

Aquí, mypackage.module1 se importa y se le asigna un nombre de alias como mod1. Del mismo modo, puede usar otros módulos module2.py y module3.py de mi paquete.

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 demostrar el paquete con un módulo simple con funciones en su interior. Según su proyecto, también puede empaquetar con subpaquetes. Subcarpetas/ que tienen módulos con clases definidas.

Ruta de búsqueda del módulo de Python

Durante la ejecución, cuando python encuentra nombre del módulo de importación , el intérprete intenta localizar el módulo. Busca el módulo en la lista de módulos incorporados. Más adelante en todo, los directorios definidos dentro de sys.path.

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

En su directorio actual.
En la lista de módulos incorporados
Dentro de los directorios sys.path

Puede obtener los detalles de sys.path importando el módulo sys e imprimiendo sys.path. Le 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 mantener 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 dándole un nombre de alias. El alias se puede hacer usando la 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

El siguiente es 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 usará 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 que se utiliza para el módulo de prueba es t. Entonces, la función y las variables de test.py se pueden referir usando el alias t.

Salida:

Welcome to Guru99 Tutorials!
All about Python!
Guru99
Mumbai

Importaciones absolutas y relativas en Python

Ahora sabe 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 mi proyecto/. Tiene dos subcarpetas paquete1 y paquete2.

La carpeta paquete1 tiene dos módulos, módulo1.py y módulo2.py.

La carpeta paquete2 tiene una clase myclass.py, un subpaquete subpaquete 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.

Uso de importaciones absolutas

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

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

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

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

Para trabajar con la función myfunc3 necesitarás importar de la siguiente manera:

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

Ventajas y desventajas de usar importaciones absolutas

Estas son las ventajas de usar importaciones absolutas:

Se vuelve fácil rastrear los módulos para verificar el código.
Fácil de usar y muy directo.
Si el proyecto se mueve a una ruta diferente, las importaciones seguirán siendo las mismas.

Desventajas de usar importaciones absolutas

Estas son las desventajas de usar importaciones absolutas:

Desventajas:

La ruta de importación puede ser muy larga en caso de que los módulos estén anidados y si el nombre de los módulos es largo.

Uso de importaciones relativas

Teniendo en cuenta la misma estructura de carpetas que se menciona a continuación, veremos cómo importar la misma mediante importaciones relativas.

En la importación relativa, el módulo que se importará es relativo a la ubicación actual, que es la ubicación donde está presente la declaración de importación.

Sintaxis:

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

Habrá 2 puntos (..) antes del nombre del módulo si el módulo está en un nivel superior a la ubicación actual.

En referencia a la figura de estructura de carpetas mencionada anteriormente, tenemos los siguientes módulos con su función, a la que debemos referirnos.

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á importar de la siguiente manera:

from  .module1  import  myfunc1

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

from  .subpkg.module3  import  myfunc3

Ventajas de las importaciones relativas

Ventajas:

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

Desventajas:

Usando importaciones relativas, es difícil rastrear dónde reside el código

Resumen:

Importar en Python lo ayuda a referirse al código, es decir, .funciones/objetos que están escritos en otro archivo. También se usa para importar bibliotecas/paquetes de python que se instalan usando pip (administrador de paquetes de python), y luego debe usarlo en su código.
La función de importación está disponible en otros idiomas, como TypeScript, JavaScript, Java, Ruby, etc.
Un módulo en python es el código escrito dentro del archivo, por ejemplo (test.py). Dentro de su archivo, puede tener sus variables, funciones o su clase definida. El archivo completo se convierte en un módulo y se puede importar dentro de otro archivo para hacer referencia al código.
Con la funcionalidad del módulo, puede dividir su código en diferentes archivos en lugar de escribir todo dentro de un archivo. Más tarde, usando la importación, puede consultar el código dentro del archivo que necesita.
Python tiene sus módulos integrados, y también las bibliotecas/paquetes externos instalados mediante un administrador de paquetes de Python (pip), por ejemplo, pandas, NumPy, etc. se denominan módulos.
Puede importar solo una pequeña parte del módulo, es decir, solo las funciones requeridas y los nombres de variables del módulo en lugar de importar el código completo.
También puede convertir el nombre del módulo a una forma más corta dándole un nombre de alias. El alias se puede hacer usando la palabra clave.
Un paquete es un directorio con todos los módulos definidos en su interior. Para hacer que un intérprete de Python lo trate como un paquete, su directorio debe tener el archivo __init.py. El init.py hace que el directorio sea un paquete. Aquí está el diseño del paquete en el que vamos a trabajar.
Durante la ejecución, cuando python encuentra nombre del módulo de importación , el intérprete intenta localizar el módulo. Busca el módulo en la lista de módulos integrados. Más adelante en todo, los directorios definidos dentro de sys.path.
Para las importaciones absolutas, debe agregar la ruta completa de su módulo directamente desde la carpeta raíz del proyecto.
En la importación relativa, el módulo que se importará es relativo a la ubicación actual, que es la ubicación donde está presente la declaración de importación.

Multiproceso en Python con ejemplo:Aprenda GIL en Python Depurador de Python:mejore sin esfuerzo sus habilidades de depuración

python