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 archivo.

En este tutorial, aprenderá:

  • ¿Cuáles son los módulos en Python?
  • Módulo de importación de Python
  • ¿Cómo crear e importar un módulo en Python?
  • Importando una clase en Python
  • Usando desde para importar el módulo
  • Importando todo desde el módulo
  • Usando el módulo de importación
  • Usando la importación *
  • La función dir ()
  • Paquetes
  • PythonModuleSearchPath
  • Usando el alias del módulo en la importación
  • Importaciones absolutas y relativas en Python
  • Usando Importaciones Absolutas
  • Usando Importaciones Relativas

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

Un archivo se considera un módulo en Python. Para usar el módulo, debe importarlo usando 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.

Aquí está 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.pydisplay.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 cree otro archivo display.py.

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

import test

Durante la importación, no es necesario que menciones 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, necesita hacer uso de module_name.function_name.

Por ejemplo test.display_message ().

Import testprint(test.display_message())

Paso 6)

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

Welcome to Guru99 Tutorials!

Importando una clase en Python

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

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

myproj/Car.pydisplay.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_nameself.model = modelself.manu_year = manu_yeardef 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 Carcar_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())

Producción:

BMWCar brand is BMWCar model is Z5Car manufacture year is 2020Car brand is BMWCar 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 las 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.pydisplay.py

En test.py hay 2 funciones como se muestra:

Nombre de archivo: test.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 de archivo: display.py

from test import display_messageprint(display_message())

Producción:

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_messageprint(display_message1())

Producción:

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

Importando todo del módulo

Importar le permite importar el módulo completo usando la importación seguida 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.pydisplay.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

Usando solo el nombre del módulo de importación, para hacer referencia a las variables y funciones dentro del módulo, tiene que anteponer el nombre del módulo.

Ejemplo

Nombre de archivo: display.py

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

La prueba del nombre del módulo se utiliza para hacer referencia a la función y las variables dentro de la prueba del módulo.

Producción:

Welcome to Guru99 Tutorials!All about Python!Guru99Mumbai

Usando la importación *

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

Producción:

Welcome to Guru99 Tutorials!All about Python!Guru99Mumbai

La función dir ()

El dir () es una función incorporada en Python. 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, vamos a importar Car y asignar a dir () para ver la salida.

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

test prop/Car.pytest.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_nameself.model = modelself.manu_year = manu_yeardef 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: test.py

import Carclass_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. Intentemos 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 jsonjson_details = dir(json)print(json_details)

Producción:

['JSONDecodeError', 'JSONDecoder', 'JSONEncoder', '__all__', '__author__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__path__', '__spec__', '__version__', '_default_decoder', '_default_encoder', 'codecs', 'decoder', 'detect_encoding', 'dump', 'dumps', 'encoder', 'load', '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.pyfile. 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. Aquí están los detalles de module1.py, module2.py y module3.py

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

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

module3.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 da un nombre de alias como mod1. Del mismo modo, puede utilizar otros módulos module2.py y module3.py de mi paquete.

import mypackage.module1 as mod1print(mod1.mod1_func1())print(mod1.mod1_func2())print(mod1.mod1_func2())

Producción:

Welcome to Module1 function1NoneWelcome to Module1 function2NoneWelcome to Module1 function2None

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 de Python

Durante la ejecución, cuando python encuentra el 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, 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:

importsysprint(sys.path)

Producción:

['Python Latest\\task2', 'Users\\AppData\\Local\\Programs\\Python\\Python37\\python37.zip', 'Users\\AppData\\Local\\Programs\\Python\\Python37\\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.pydisplay.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 usará un alias para test.py en display.py

Import test as tprint(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 hacer referencia usando el alias t.

Producción:

Welcome to Guru99 Tutorials!All about Python!Guru99Mumbai

Importaciones absolutas y relativas en Python

Ahora sabe cómo importar un archivo como módulo dentro de otro archivo. Veamos ahora cómo administrar los archivos disponibles en 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 package1 y package2.

La carpeta package1 tiene dos módulos, module1.py y module2.py.

La carpeta package2 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.

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

from package1.module1 import myfunc1orfrom package1 import module1module1.myfunc1()

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

from package1.subpkg.module3 import myfunc3orfrom package1.subpkg import module3module3.myfunc3()

Ventajas y desventajas de utilizar importaciones absolutas

Estas son las ventajas de utilizar importaciones absolutas:

  • Es 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

A continuación, se muestran 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 el nombre de los módulos sea extenso.

Usar importaciones relativas

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

En la importación relativa, el módulo que se va a 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 from .

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 la estructura de carpetas mencionada anteriormente, tenemos los siguientes módulos con su función, a los que debemos hacer referencia.

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

from .module1 import myfunc1

Para trabajar con la función myfunc3, necesitará 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 le ayuda a hacer referencia 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 funcionalidad de importación está disponible en otros lenguajes como mecanografiado, JavaScript, java, ruby, etc.
  • Un módulo es 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 incorporados, 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 las 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.pyfile. 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 el 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, 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 va a importar es relativo a la ubicación actual que es la ubicación donde está presente la declaración de importación.

Articulos interesantes...