Python Language
Importando modulos

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

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

import importlib
random = importlib.import_module("random")

collections_abc = importlib.import_module("collections.abc")

Para versiones anteriores de Python, use el módulo imp .

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:

1. Las importaciones deben ser en líneas separadas:

    from math import sqrt, ceil      # Not recommended
    from math import sqrt            # Recommended
    from math import ceil
   

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

3. 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 de module o no. Esto es doblemente cierto si tiene múltiples declaraciones from module import * -type.

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