Importazione dalla libreria incorporata quando esiste un modulo con lo stesso nome

Situazione: - C'è un modulo nella mia cartella project_folder chiamato calendar - Vorrei usare la classe Calendar incorporata dalle librerie Python - Quando uso dall'importazione del calendario Calendar si lamenta perché sta cercando di caricare dal mio modulo.

Ho effettuato alcune ricerche e non riesco a trovare una soluzione al mio problema.

• Come accedere a un modulo della libreria standard in Python quando è presente un modulo locale con lo stesso nome?
• http://docs.python.org/whatsnew/2.5.html
• Come evitare di scrivere il nome del modulo tutto il tempo durante l'importazione di un modulo in Python?

Qualche idea senza dover rinominare il mio modulo?

La soluzione accettata contiene un approccio ormai deprecato.

La documentazione importlib qui fornisce un buon esempio del modo più appropriato per caricare un modulo direttamente da un percorso di file per 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)

Quindi, puoi caricare qualsiasi file .py da un percorso e impostare il nome del modulo come desideri. Quindi regola solo il module_namenome personalizzato che desideri che il modulo abbia durante l'importazione.

Per caricare un pacchetto invece di un singolo file, file_pathdovrebbe essere il percorso alla radice del pacchetto__init__.py

Non è necessario modificare il nome del modulo. Piuttosto, puoi usare absolute_import per modificare il comportamento di importazione. Ad esempio con stem / socket.py importo il modulo socket come segue:

from __future__ import absolute_import
import socket

Funziona solo con Python 2.5 e versioni successive; sta abilitando il comportamento che è l'impostazione predefinita in Python 3.0 e versioni successive. Pylint si lamenterà del codice ma è perfettamente valido.

In realtà, risolverlo è piuttosto semplice, ma l'implementazione sarà sempre un po 'fragile, perché dipende dagli interni del meccanismo di importazione di Python e sono soggetti a modifiche nelle versioni future.

(il codice seguente mostra come caricare moduli sia locali che non locali e come possono coesistere)

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 soluzione migliore, se possibile, è evitare di nominare i moduli con lo stesso nome della libreria standard o dei nomi dei moduli incorporati.

L'unico modo per risolvere questo problema è dirottare da soli i macchinari di importazione interni. Questo non è facile e pieno di pericoli. Dovresti evitare a tutti i costi il ​​faro a forma di graal perché il pericolo è troppo pericoloso.

Rinomina invece il tuo modulo.

Se vuoi imparare come dirottare il meccanismo di importazione interno, ecco dove dovresti andare per scoprire come farlo:

• La sezione Importing Modules della documentazione di Python 2.7
• La sezione Importing Modules della documentazione di Python 3.2
• PEP 302 - Nuovi ganci di importazione

A volte ci sono buone ragioni per entrare in questo pericolo. La ragione che dai non è tra queste. Rinomina il tuo modulo.

Se prendi il percorso pericoloso, un problema che incontrerai è che quando carichi un modulo finisce con un "nome ufficiale" in modo che Python possa evitare di dover analizzare il contenuto di quel modulo mai più. Una mappatura del 'nome ufficiale' di un modulo all'oggetto del modulo stesso può essere trovata in sys.modules.

Ciò significa che se ti trovi import calendarin un posto, qualsiasi modulo importato verrà considerato come il modulo con il nome ufficiale calendare tutti gli altri tentativi in import calendarqualsiasi altro luogo, incluso in altro codice che fa parte della libreria Python principale, otterranno quel calendario.

Potrebbe essere possibile progettare un importatore di clienti usando il modulo imputil in Python 2.x che ha fatto sì che i moduli caricati da determinati percorsi cercassero i moduli che stavano importando in qualcosa di diverso dal sys.modulesprimo o qualcosa del genere. Ma è una cosa estremamente complicata da fare, e comunque non funzionerà in Python 3.x.

C'è una cosa estremamente brutta e orribile che puoi fare che non implica l'aggancio del meccanismo di importazione. Questo è qualcosa che probabilmente non dovresti fare, ma probabilmente funzionerà. Trasforma il tuo calendarmodulo in un ibrido tra il modulo calendario del sistema e il modulo calendario. Grazie a Boaz Yaniv per lo scheletro della funzione che utilizzo . Metti questo all'inizio del tuo calendar.pyfile:

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__])

Vorrei offrire la mia versione, che è una combinazione della soluzione di Boaz Yaniv e di Omnifarious. Importerà la versione di sistema di un modulo, con due differenze principali rispetto alle risposte precedenti:

• Supporta la notazione "punto", ad es. package.module
• È un sostituto immediato per l'istruzione import sui moduli di sistema, il che significa che devi solo sostituire quella riga e se ci sono già chiamate fatte al modulo funzioneranno così com'è

Mettilo da qualche parte accessibile in modo da poterlo chiamare (ho il mio nel mio file __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

Esempio

Volevo importare mysql.connection, ma avevo già un pacchetto locale chiamato mysql (le utility mysql ufficiali). Quindi, per ottenere il connettore dal pacchetto mysql di sistema, ho sostituito questo:

import mysql.connector

Con questo:

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__])

Risultato

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

Modifica il percorso di importazione:

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