Búsqueda de sitios web

Importar módulo en Python con ejemplos

¿Cuáles 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 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 módulo de importación de Python?

Un archivo se considera un módulo en Python. Para utilizar el módulo, debe importarlo utilizando la palabra clave import. La función o 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 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) Cree un archivo y asígnele el nombre test.py

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

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

Paso 3) Ahora cree otro archivo display.py.

Paso 4) Dentro de display.py importe el archivo moduletest.py, como se muestra a continuación:

import test

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

Paso 5) Luego puede llamar a la función display_message() desde test.py dentro de display.py, debe utilizar 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 vimos un módulo simple con una función. Aquí se creará una clase y se referirá a 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 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

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

Usando desde para importar el módulo

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 que solo se importen cosas específicas, puede utilizar la palabra clave "de" 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: display.py

from test import display_message
print(display_message())

Salida:

Welcome to Guru99 Tutorials!

Ahora, si utiliza la función display_message1(), arrojará 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 usando import 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!"

Usando el módulo de importación

Usando solo el nombre del módulo de importación, para hacer referencia a las variables y funciones dentro del módulo, debe anteponerse con 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 la función y las variables dentro del módulo test.

Salida:

Welcome to Guru99 Tutorials!
All about Python!
Guru99
Mumbai

Usando importar *

Veamos un ejemplo usando import *. Usando import *, 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( )

El dir() es una función incorporada 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 proporcionará las variables y funciones que están presentes dentro del módulo.

Aquí hay un ejemplo práctico 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 puedes intentar usar dir() en un módulo integrado disponible en Python. Probemos lo mismo en el módulo json como se muestra en el siguiente ejemplo. Mostrará todas las propiedades y métodos disponibles en el módulo 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 que un intérprete de Python lo trate como un paquete, su directorio debe tener el archivo init.py. El init.py crea el directorio como 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. Aquí están 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 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. De manera similar, puedes 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/ tener módulos con clases definidas.

Ruta de búsqueda del módulo 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 integrados. Posteriormente, los directorios definidos dentro de 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 incorporados
  3. 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 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 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 usaremos 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, se puede hacer referencia a la función y las variables de test.py usando 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 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 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, debe agregar la ruta completa de su módulo directamente desde la carpeta raíz del proyecto.

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

Para trabajar con la funciónmyfunc1, 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 utilizar importaciones absolutas

Estas son las ventajas de utilizar importaciones absolutas:

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

Desventajas de utilizar importaciones absolutas

Estas son las desventajas de utilizar 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.

Usando importaciones relativas

Teniendo en cuenta la misma estructura de carpetas que se menciona a continuación, veremos cómo importarla utilizando 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 importaciones relativas, debe agregar un punto (.) antes del nombre del módulo al importar usando desde.

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

Refiriéndose a la figura de estructura de carpetas mencionada anteriormente, tenemos los siguientes módulos con su función, a los 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ónmyfunc1 necesitarás 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:

  • Al utilizar importaciones relativas, es difícil rastrear dónde reside el código.

Resumen

  • Importar en Python le ayuda a consultar el 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 usarlos en su código.
  • La funcionalidad 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 definidas sus variables, funciones o su clase. El archivo completo se convierte en un módulo y se puede importar dentro de otro archivo para consultar el código.
  • Con la funcionalidad del módulo, puede dividir su código en diferentes archivos en lugar de escribir todo dentro de un solo archivo. Más tarde, utilizando 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 usando 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 que un intérprete de Python lo trate como un paquete, su directorio debe tener el archivo __init.py. El init.py crea el directorio como 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. Posteriormente, los directorios definidos dentro de sys.path.
  • Para 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.

Artículos relacionados