Python Language
Importation de modules

Syntaxe

• import nom_module
• import nom_module.submodule_name
• à partir de nom_module import *
• de submodule_name d'importation module_name [, class_name, nom_fonction, etc ...]
• from nom_module import some_name as new_name
• de nom_classe importation module_name.submodule_name [, nom_fonction, etc ...]

Remarques

Importer un module

Utilisez l'instruction import :

>>> import random
>>> print(random.randint(1, 10))
4

import module importation importera un module puis vous permettra de référencer ses objets - valeurs, fonctions et classes, par exemple - en utilisant la syntaxe module.name . Dans l'exemple ci-dessus, le module random est importé, qui contient la fonction randint . Donc, en important random randint random vous pouvez appeler randint avec random.randint .

Vous pouvez importer un module et lui attribuer un nom différent:

>>> import random as rn
>>> print(rn.randint(1, 10))
4

Si votre fichier python main.py est dans le même dossier que custom.py . Vous pouvez l'importer comme ceci:

import custom

Il est également possible d'importer une fonction depuis un module:

>>> from math import sin
>>> sin(1)
0.8414709848078965

Pour importer des fonctions spécifiques plus profondément dans un module, l'opérateur point peut être utilisé uniquement du côté gauche du mot clé import :

from urllib.request import urlopen

En python, nous avons deux façons d'appeler la fonction du niveau supérieur. L'un est import et l'autre from . Nous devrions utiliser l' import lorsque nous avons une possibilité de collision de noms. Supposons que nous hello.py fichiers hello.py et world.py ayant la même fonction nommée function . Ensuite, import déclaration d' import fonctionnera bien.

from hello import function
from world import function

function() #world's function will be invoked. Not hello's  

En général, l' import vous fournira un espace de noms.

import hello
import world

hello.function() # exclusively hello's function will be invoked 
world.function() # exclusively world's function will be invoked

Mais si vous êtes bien sûr, dans votre projet tout il n'y a aucun moyen ayant même nom de fonction , vous devez utiliser from déclaration

Plusieurs importations peuvent être effectuées sur la même ligne:

>>> # 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

Les mots-clés et la syntaxe présentés ci-dessus peuvent également être utilisés dans des combinaisons:

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

Importation de noms spécifiques à partir d'un module

Au lieu d'importer le module complet, vous ne pouvez importer que les noms spécifiés:

from random import randint # Syntax "from MODULENAME import NAME1[, NAME2[, ...]]"
print(randint(1, 10))      # Out: 5

from random est nécessaire, car l'interpréteur python doit savoir de quelle ressource il doit importer une fonction ou une classe et import randint spécifie la fonction ou la classe elle-même.

Un autre exemple ci-dessous (similaire à celui ci-dessus):

from math import pi
print(pi)                  # Out: 3.14159265359

L'exemple suivant génère une erreur, car nous n'avons pas importé de module:

random.randrange(1, 10)    # works only if "import random" has been run before

Les sorties:

NameError: name 'random' is not defined

L'interpréteur Python ne comprend pas ce que vous entendez par random . Il doit être déclaré en ajoutant l' import random à l'exemple:

import random
random.randrange(1, 10)

Importer tous les noms d'un module

from module_name import *

par exemple:

from math import *
sqrt(2)    # instead of math.sqrt(2)
ceil(2.7)  # instead of math.ceil(2.7)

Cela importera tous les noms définis dans le module math dans l'espace de noms global, à l'exception des noms commençant par un trait de soulignement (ce qui indique que le rédacteur estime qu'il est destiné à un usage interne uniquement).

Avertissement : Si une fonction du même nom a déjà été définie ou importée, elle sera écrasée . Importer presque toujours uniquement des noms spécifiques à from math import sqrt, ceil est la méthode recommandée :

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

Les importations étoilées ne sont autorisées qu'au niveau du module. Les tentatives de les exécuter dans des définitions de classe ou de fonction entraînent une SyntaxError .

def f():
    from math import *

et

class A:
    from math import *

les deux échouent avec:

SyntaxError: import * only allowed at module level

La variable spéciale __all__

Les modules peuvent avoir une variable spéciale nommée __all__ pour restreindre les variables importées lors de l'utilisation from mymodule import * .

Vu le module suivant:

# mymodule.py

__all__ = ['imported_by_star']

imported_by_star = 42
not_imported_by_star = 21

Seul imported_by_star est importé lors de l'utilisation 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

Cependant, not_imported_by_star peut être importé explicitement:

>>> from mymodule import not_imported_by_star
>>> not_imported_by_star
21

Importation programmatique

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

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

Pour les anciennes versions de Python, utilisez le module 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()

N'utilisez PAS __import__() pour importer des modules par programmation! Il y a des détails subtils concernant sys.modules , l'argument fromlist , etc., qui sont faciles à ignorer et que importlib.import_module() gère pour vous.

Importer des modules à partir d'un emplacement de système de fichiers arbitraire

Si vous souhaitez importer un module qui n'existe pas déjà en tant que module intégré dans la bibliothèque standard de Python ni en tant que package, vous pouvez le faire en ajoutant le chemin d'accès au répertoire dans lequel votre module est trouvé dans sys.path . Cela peut être utile lorsque plusieurs environnements Python existent sur un hôte.

import sys
sys.path.append("/path/to/directory/containing/your/module")
import mymodule

Il est important que vous ajoutiez le chemin d'accès au répertoire dans lequel mymodule est trouvé, pas le chemin du module lui-même.

Règles PEP8 pour les importations

Quelques recommandations de style PEP8 pour les importations:

1. Les importations doivent être sur des lignes séparées:

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

2. Ordre des importations comme suit en haut du module:

   • Importation de bibliothèque standard
   • Importations de tiers liées
   • Importations spécifiques aux applications / bibliothèques locales

3. Les importations de caractères génériques doivent être évitées car elles entraînent une confusion dans les noms de l'espace de noms actuel. Si vous effectuez une from module import * , il peut être difficile de savoir si un nom spécifique dans votre code provient du module ou non. Ceci est doublement vrai si vous avez plusieurs instructions de type from module import * .

4. Évitez d'utiliser des importations relatives; utiliser des importations explicites à la place.

Importer des sous-modules

from module.submodule import function

Cette function importation de module.submodule .

__import __ () fonction

La fonction __import__() peut être utilisée pour importer des modules dont le nom n'est connu qu'à l'exécution

if user_input == "os":
    os = __import__("os")

# equivalent to import os

Cette fonction peut également être utilisée pour spécifier le chemin du fichier vers un module

mod = __import__(r"C:/path/to/file/anywhere/on/computer/module.py")

Réimporter un module

Lors de l'utilisation de l'interpréteur interactif, vous souhaiterez peut-être recharger un module. Cela peut être utile si vous modifiez un module et que vous souhaitez importer la version la plus récente, ou si vous avez appliqué un patch sur un élément d'un module existant et que vous souhaitez annuler vos modifications.

Notez que vous ne pouvez pas import le module à nouveau pour annuler:

import math
math.pi = 3
print(math.pi)    # 3
import math
print(math.pi)    # 3

C'est parce que l'interpréteur enregistre chaque module que vous importez. Et lorsque vous essayez de réimporter un module, l'interprète le voit dans le registre et ne fait rien. Donc, le moyen difficile de réimporter est d'utiliser l' import après avoir supprimé l'élément correspondant du registre:

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

Mais il y a plus d'une manière simple et directe.

Python 2

Utilisez la fonction de reload :

import math
math.pi = 3
print(math.pi)    # 3
reload(math)
print(math.pi)    # 3.141592653589793

Python 3

La fonction de reload a été déplacée vers importlib :

import math
math.pi = 3
print(math.pi)    # 3
from importlib import reload
reload(math)
print(math.pi)    # 3.141592653589793