Python Language
Importando modulos
Buscar..
Sintaxis
- importar nombre_módulo
- import module_name.submodule_name
- desde nombre_módulo import *
- from module_name import submodule_name [, class_name , function_name , ... etc]
- desde nombre_módulo importar nombre_algunos como nuevo_nombre
- from module_name.submodule_name import class_name [, function_name , ... etc]
Observaciones
Importar un módulo hará que Python evalúe todo el código de nivel superior en este módulo para que aprenda todas las funciones, clases y variables que contiene el módulo. Cuando desee que un módulo suyo se importe en otro lugar, tenga cuidado con su código de nivel superior y if __name__ == '__main__':
en if __name__ == '__main__':
si no desea que se ejecute cuando se importe el módulo.
Importando un modulo
Utilice la declaración de import
:
>>> import random
>>> print(random.randint(1, 10))
4
import module
importará un módulo y luego le permitirá hacer referencia a sus objetos (valores, funciones y clases, por ejemplo) utilizando la sintaxis module.name
. En el ejemplo anterior, se importa el módulo random
, que contiene la función randint
. Entonces, al importar random
, puede llamar a randint
con random.randint
.
Puedes importar un módulo y asignarlo a un nombre diferente:
>>> import random as rn
>>> print(rn.randint(1, 10))
4
Si su archivo python main.py
está en la misma carpeta que custom.py
. Puedes importarlo así:
import custom
También es posible importar una función desde un módulo:
>>> from math import sin
>>> sin(1)
0.8414709848078965
Para importar funciones específicas más profundamente en un módulo, el operador de punto se puede usar solo en el lado izquierdo de la palabra clave de import
:
from urllib.request import urlopen
En Python, tenemos dos formas de llamar a la función desde el nivel superior. Uno es import
y otro es from
. Debemos utilizar la import
cuando tenemos la posibilidad de colisión de nombres. Supongamos que tenemos el archivo hello.py
y los archivos world.py
que tienen la misma función llamada function
. Entonces la declaración de import
funcionará bien.
from hello import function
from world import function
function() #world's function will be invoked. Not hello's
En general la import
le proporcionará un espacio de nombres.
import hello
import world
hello.function() # exclusively hello's function will be invoked
world.function() # exclusively world's function will be invoked
Pero si está lo suficientemente seguro, en todo su proyecto no hay forma de tener el mismo nombre de función que debe usar from
declaración
Múltiples importaciones se pueden hacer en la misma línea:
>>> # Multiple modules
>>> import time, sockets, random
>>> # Multiple functions
>>> from math import sin, cos, tan
>>> # Multiple constants
>>> from math import pi, e
>>> print(pi)
3.141592653589793
>>> print(cos(45))
0.5253219888177297
>>> print(time.time())
1482807222.7240417
Las palabras clave y la sintaxis que se muestran arriba también se pueden usar en combinaciones:
>>> from urllib.request import urlopen as geturl, pathname2url as path2url, getproxies
>>> from math import factorial as fact, gamma, atan as arctan
>>> import random.randint, time, sys
>>> print(time.time())
1482807222.7240417
>>> print(arctan(60))
1.554131203080956
>>> filepath = "/dogs/jumping poodle (december).png"
>>> print(path2url(filepath))
/dogs/jumping%20poodle%20%28december%29.png
Importando nombres específicos desde un módulo
En lugar de importar el módulo completo, solo puede importar nombres específicos:
from random import randint # Syntax "from MODULENAME import NAME1[, NAME2[, ...]]"
print(randint(1, 10)) # Out: 5
se necesita de forma from random
, porque el intérprete de python debe saber de qué recurso debe importar una función o clase y import randint
especifica la función o la clase en sí.
Otro ejemplo a continuación (similar al anterior):
from math import pi
print(pi) # Out: 3.14159265359
El siguiente ejemplo generará un error, porque no hemos importado un módulo:
random.randrange(1, 10) # works only if "import random" has been run before
Salidas:
NameError: name 'random' is not defined
El intérprete de python no entiende lo que quieres decir con random
. Debe declararse agregando import random
al ejemplo:
import random
random.randrange(1, 10)
Importando todos los nombres de un módulo
from module_name import *
por ejemplo:
from math import *
sqrt(2) # instead of math.sqrt(2)
ceil(2.7) # instead of math.ceil(2.7)
Esto importará todos los nombres definidos en el módulo math
en el espacio de nombres global, excepto los nombres que comienzan con un guión bajo (lo que indica que el escritor siente que es solo para uso interno).
Advertencia : si una función con el mismo nombre ya se definió o importó, se sobrescribirá . Casi siempre importando solo nombres específicos from math import sqrt, ceil
es la forma recomendada :
def sqrt(num):
print("I don't know what's the square root of {}.".format(num))
sqrt(4)
# Output: I don't know what's the square root of 4.
from math import *
sqrt(4)
# Output: 2.0
Las importaciones destacadas solo se permiten a nivel de módulo. Los intentos de realizarlas en definiciones de clase o función dan como resultado un SyntaxError
.
def f():
from math import *
y
class A:
from math import *
ambos fallan con:
SyntaxError: import * only allowed at module level
La variable especial __all__
Los módulos pueden tener una variable especial llamada __all__
para restringir qué variables se importan cuando se usan from mymodule import *
.
Dado el siguiente módulo:
# mymodule.py
__all__ = ['imported_by_star']
imported_by_star = 42
not_imported_by_star = 21
Sólo imported_by_star
ha sido importada cuando se utiliza from mymodule import *
:
>>> from mymodule import *
>>> imported_by_star
42
>>> not_imported_by_star
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'not_imported_by_star' is not defined
Sin embargo, not_imported_by_star
se puede importar explícitamente:
>>> from mymodule import not_imported_by_star
>>> not_imported_by_star
21
Importación programática
Para importar un módulo a través de una llamada de función, use el módulo importlib
(incluido en Python a partir de la versión 2.7):
import importlib
random = importlib.import_module("random")
La función importlib.import_module()
también importará el submódulo de un paquete directamente:
collections_abc = importlib.import_module("collections.abc")
Para versiones anteriores de Python, use el módulo imp
.
Utilice las funciones imp.find_module
y imp.load_module
para realizar una importación programática.
Tomado de la documentación de la biblioteca estándar
import imp, sys
def import_module(name):
fp, pathname, description = imp.find_module(name)
try:
return imp.load_module(name, fp, pathname, description)
finally:
if fp:
fp.close()
NO use __import__()
para importar módulos mediante programación. Hay detalles sutiles relacionados con sys.modules
, el argumento fromlist
, etc. que son fáciles de pasar por alto, que importlib.import_module()
maneja por ti.
Importar módulos desde una ubicación de sistema de archivos arbitraria.
Si desea importar un módulo que ya no existe como un módulo integrado en la Biblioteca estándar de Python ni como un paquete adicional, puede hacerlo agregando la ruta al directorio donde se encuentra su módulo a sys.path
Esto puede ser útil cuando existen varios entornos de Python en un host.
import sys
sys.path.append("/path/to/directory/containing/your/module")
import mymodule
Es importante que agregue la ruta al directorio en el que se encuentra mymodule
, no la ruta al módulo en sí.
Reglas PEP8 para Importaciones
Algunas pautas de estilo PEP8 recomendadas para importaciones:
Las importaciones deben ser en líneas separadas:
from math import sqrt, ceil # Not recommended from math import sqrt # Recommended from math import ceil
Ordene las importaciones de la siguiente manera en la parte superior del módulo:
- Importaciones de la biblioteca estándar
- Importaciones de terceros relacionados
- Importaciones específicas de aplicaciones / bibliotecas locales
Se deben evitar las importaciones de comodines ya que genera confusión en los nombres en el espacio de nombres actual. Si lo hace
from module import *
, puede no estar claro si un nombre específico en su código proviene demodule
o no. Esto es doblemente cierto si tiene múltiples declaracionesfrom module import *
-type.Evite el uso de importaciones relativas; usa importaciones explícitas en su lugar.
Importando submódulos
from module.submodule import function
Esto importa la function
desde module.submodule
.
__importar __ () función
La función __import__()
se puede usar para importar módulos donde el nombre solo se conoce en tiempo de ejecución
if user_input == "os":
os = __import__("os")
# equivalent to import os
Esta función también se puede utilizar para especificar la ruta del archivo a un módulo
mod = __import__(r"C:/path/to/file/anywhere/on/computer/module.py")
Reimportando un módulo
Cuando utilice el intérprete interactivo, es posible que desee volver a cargar un módulo. Esto puede ser útil si está editando un módulo y desea importar la versión más reciente, o si ha modificado un elemento de un módulo existente y desea revertir sus cambios.
Tenga en cuenta que no puede volver a import
el módulo para revertir:
import math
math.pi = 3
print(math.pi) # 3
import math
print(math.pi) # 3
Esto se debe a que el intérprete registra todos los módulos que importa. Y cuando intenta reimportar un módulo, el intérprete lo ve en el registro y no hace nada. Por lo tanto, la manera más difícil de reimportar es usar la import
después de eliminar el elemento correspondiente del registro:
print(math.pi) # 3
import sys
if 'math' in sys.modules: # Is the ``math`` module in the register?
del sys.modules['math'] # If so, remove it.
import math
print(math.pi) # 3.141592653589793
Pero hay más de una manera directa y sencilla.
Python 2
Utilice la función de reload
:
import math
math.pi = 3
print(math.pi) # 3
reload(math)
print(math.pi) # 3.141592653589793
Python 3
La función de reload
ha movido a importlib
:
import math
math.pi = 3
print(math.pi) # 3
from importlib import reload
reload(math)
print(math.pi) # 3.141592653589793