Importation à partir de la bibliothèque intégrée lorsqu'un module avec le même nom existe

Situation: - Il y a un module dans mon project_folder appelé calendrier - Je voudrais utiliser la classe Calendar intégrée des bibliothèques Python - Lorsque j'utilise à partir de Calendar Import Calendar, il se plaint parce qu'il essaie de se charger à partir de mon module.

J'ai fait quelques recherches et je n'arrive pas à trouver une solution à mon problème.

• Comment accéder à un module de bibliothèque standard en Python quand il y a un module local avec le même nom?
• http://docs.python.org/whatsnew/2.5.html
• Comment éviter d'écrire tout le temps le nom du module lors de l'importation d'un module en python?

Des idées sans avoir à renommer mon module?

La solution acceptée contient une approche désormais obsolète.

La documentation importlib donne ici un bon exemple de la manière la plus appropriée de charger un module directement à partir d'un chemin de fichier pour python> = 3.5:

import importlib.util
import sys

# For illustrative purposes.
import tokenize
file_path = tokenize.__file__  # returns "/path/to/tokenize.py"
module_name = tokenize.__name__  # returns "tokenize"

spec = importlib.util.spec_from_file_location(module_name, file_path)
module = importlib.util.module_from_spec(spec)
sys.modules[module_name] = module
spec.loader.exec_module(module)

Ainsi, vous pouvez charger n'importe quel fichier .py à partir d'un chemin et définir le nom du module comme vous le souhaitez. Donc, ajustez simplement le module_namepour qu'il soit le nom personnalisé que vous souhaitez que le module ait lors de l'importation.

Pour charger un package au lieu d'un seul fichier, file_pathdevrait être le chemin vers la racine du package__init__.py

Il n'est pas nécessaire de changer le nom de votre module. Vous pouvez plutôt utiliser l’importation_absolue pour modifier le comportement d’importation. Par exemple, avec stem / socket.py, j'importe le module socket comme suit:

from __future__ import absolute_import
import socket

Cela ne fonctionne qu'avec Python 2.5 et supérieur; c'est un comportement d'activation qui est le comportement par défaut dans Python 3.0 et supérieur. Pylint se plaindra du code mais il est parfaitement valide.

En fait, résoudre ce problème est assez facile, mais l'implémentation sera toujours un peu fragile, car cela dépend des composants internes du mécanisme d'importation python et ils sont susceptibles de changer dans les versions futures.

(le code suivant montre comment charger les modules locaux et non locaux et comment ils peuvent coexister)

def import_non_local(name, custom_name=None):
    import imp, sys

    custom_name = custom_name or name

    f, pathname, desc = imp.find_module(name, sys.path[1:])
    module = imp.load_module(custom_name, f, pathname, desc)
    f.close()

    return module

# Import non-local module, use a custom name to differentiate it from local
# This name is only used internally for identifying the module. We decide
# the name in the local scope by assigning it to the variable calendar.
calendar = import_non_local('calendar','std_calendar')

# import local module normally, as calendar_local
import calendar as calendar_local

print calendar.Calendar
print calendar_local

La meilleure solution, si possible, est d'éviter de nommer vos modules avec le même nom que les noms de bibliothèque standard ou de module intégré.

La seule façon de résoudre ce problème est de détourner vous-même la machinerie d'importation interne. Ce n’est pas facile et risqué. Vous devez éviter à tout prix la balise en forme de graal car le péril est trop périlleux.

Renommez plutôt votre module.

Si vous voulez apprendre à détourner la machinerie d'importation interne, voici où vous iriez pour savoir comment procéder:

• La section Importing Modules de la documentation Python 2.7
• La section Importing Modules de la documentation Python 3.2
• PEP 302 - Nouveaux crochets d'importation

Il y a parfois de bonnes raisons de courir ce péril. La raison que vous donnez n'est pas parmi eux. Renommez votre module.

Si vous prenez le chemin périlleux, un problème que vous rencontrerez est que lorsque vous chargez un module, il se retrouve avec un `` nom officiel '' afin que Python puisse éviter d'avoir à analyser à nouveau le contenu de ce module. Un mappage du «nom officiel» d'un module à l'objet module lui-même peut être trouvé dans sys.modules.

Cela signifie que si vous êtes import calendarà un endroit, quel que soit le module importé, sera considéré comme le module avec le nom officiel calendaret toutes les autres tentatives vers import calendarn'importe où ailleurs, y compris dans un autre code faisant partie de la bibliothèque principale Python, obtiendront ce calendrier.

Il serait peut-être possible de concevoir un importateur client en utilisant le module imputil de Python 2.x qui obligeait les modules chargés à partir de certains chemins à rechercher les modules qu'ils importaient dans autre chose que le sys.modulespremier ou quelque chose du genre. Mais c'est une chose extrêmement épineuse à faire, et cela ne fonctionnera pas de toute façon dans Python 3.x.

Il y a une chose extrêmement laide et horrible que vous pouvez faire qui n'implique pas d'accrochage au mécanisme d'importation. C'est quelque chose que vous ne devriez probablement pas faire, mais cela fonctionnera probablement. Il transforme votre calendarmodule en un hybride du module de calendrier système et de votre module de calendrier. Merci à Boaz Yaniv pour le squelette de la fonction que j'utilise . Mettez ceci au début de votre calendar.pyfichier:

import sys

def copy_in_standard_module_symbols(name, local_module):
    import imp

    for i in range(0, 100):
        random_name = 'random_name_%d' % (i,)
        if random_name not in sys.modules:
            break
        else:
            random_name = None
    if random_name is None:
        raise RuntimeError("Couldn't manufacture an unused module name.")
    f, pathname, desc = imp.find_module(name, sys.path[1:])
    module = imp.load_module(random_name, f, pathname, desc)
    f.close()
    del sys.modules[random_name]
    for key in module.__dict__:
        if not hasattr(local_module, key):
            setattr(local_module, key, getattr(module, key))

copy_in_standard_module_symbols('calendar', sys.modules[copy_in_standard_module_symbols.__module__])

Je voudrais proposer ma version, qui est une combinaison de la solution de Boaz Yaniv et Omnifarious. Il importera la version système d'un module, avec deux différences principales par rapport aux réponses précédentes:

• Prend en charge la notation «point», par exemple. package.module
• Est un remplacement instantané de l'instruction d'importation sur les modules système, ce qui signifie qu'il vous suffit de remplacer cette ligne et s'il y a déjà des appels vers le module, ils fonctionneront tels quels

Mettez ceci quelque part accessible afin que vous puissiez l'appeler (j'ai le mien dans mon fichier __init__.py):

class SysModule(object):
    pass

def import_non_local(name, local_module=None, path=None, full_name=None, accessor=SysModule()):
    import imp, sys, os

    path = path or sys.path[1:]
    if isinstance(path, basestring):
        path = [path]

    if '.' in name:
        package_name = name.split('.')[0]
        f, pathname, desc = imp.find_module(package_name, path)
        if pathname not in __path__:
            __path__.insert(0, pathname)
        imp.load_module(package_name, f, pathname, desc)
        v = import_non_local('.'.join(name.split('.')[1:]), None, pathname, name, SysModule())
        setattr(accessor, package_name, v)
        if local_module:
            for key in accessor.__dict__.keys():
                setattr(local_module, key, getattr(accessor, key))
        return accessor
    try:
        f, pathname, desc = imp.find_module(name, path)
        if pathname not in __path__:
            __path__.insert(0, pathname)
        module = imp.load_module(name, f, pathname, desc)
        setattr(accessor, name, module)
        if local_module:
            for key in accessor.__dict__.keys():
                setattr(local_module, key, getattr(accessor, key))
            return module
        return accessor
    finally:
        try:
            if f:
                f.close()
        except:
            pass

Exemple

Je voulais importer mysql.connection, mais j'avais déjà un paquet local appelé mysql (les utilitaires officiels de mysql). Donc, pour obtenir le connecteur du package mysql du système, j'ai remplacé ceci:

import mysql.connector

Avec ça:

import sys
from mysql.utilities import import_non_local         # where I put the above function (mysql/utilities/__init__.py)
import_non_local('mysql.connector', sys.modules[__name__])

Résultat

# This unmodified line further down in the file now works just fine because mysql.connector has actually become part of the namespace
self.db_conn = mysql.connector.connect(**parameters)

Modifiez le chemin d'importation:

import sys
save_path = sys.path[:]
sys.path.remove('')
import calendar
sys.path = save_path