Python Language
Importazione di moduli

Sintassi

• importa module_name
• import module_name.submodule_name
• da module_name import *
• da module_name import submodule_name [, class_name , function_name , ... ecc.]
• da module_name some_name importazione come NEW_NAME
• da module_name.submodule_name importazione class_name [, function_name, ... etc]

Osservazioni

Importare un modulo

Usa la dichiarazione di import :

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

import module importa un modulo e quindi ti permette di fare riferimento ai suoi oggetti - valori, funzioni e classi, per esempio - usando la sintassi module.name . Nell'esempio precedente, viene importato il modulo random , che contiene la funzione randint . Quindi importando random puoi chiamare randint con random.randint .

Puoi importare un modulo e assegnarlo a un nome diverso:

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

Se il file python main.py trova nella stessa cartella di custom.py . Puoi importarlo in questo modo:

import custom

È anche possibile importare una funzione da un modulo:

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

Per importare funzioni specifiche più in profondità in un modulo, l'operatore punto può essere utilizzato solo sul lato sinistro della parola chiave di import :

from urllib.request import urlopen

In Python, abbiamo due modi per chiamare la funzione dal livello superiore. Uno è import e un altro è from . Dovremmo usare l' import quando abbiamo la possibilità di una collisione di nomi. Supponiamo di avere file hello.py e file world.py aventi la stessa funzione chiamata function . Quindi la dichiarazione di import funzionerà correttamente.

from hello import function
from world import function

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

In generale l' import ti fornirà uno spazio dei nomi.

import hello
import world

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

Ma se siete abbastanza sicuri, in tutto il progetto non c'è alcun modo avere lo stesso nome di funzione è necessario utilizzare from dichiarazione

Più importazioni possono essere effettuate sulla stessa linea:

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

Le parole chiave e la sintassi mostrate sopra possono essere utilizzate anche in combinazioni:

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

Importazione di nomi specifici da un modulo

Invece di importare il modulo completo puoi importare solo i nomi specificati:

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

from random è necessario, perché l'interprete python deve sapere da quale risorsa deve importare una funzione o classe e import randint specifica la funzione o la classe stessa.

Un altro esempio qui sotto (simile a quello sopra):

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

Il seguente esempio genererà un errore, perché non abbiamo importato un modulo:

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

Uscite:

NameError: name 'random' is not defined

L'interprete python non capisce cosa intendi con random . Deve essere dichiarato aggiungendo l' import random all'esempio:

import random
random.randrange(1, 10)

Importare tutti i nomi da un modulo

from module_name import *

per esempio:

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

Ciò importerà tutti i nomi definiti nel modulo math nello spazio dei nomi globale, diversi dai nomi che iniziano con un carattere di sottolineatura (che indica che lo scrittore ritiene che sia solo per uso interno).

Avvertenza : se una funzione con lo stesso nome è già stata definita o importata, verrà sovrascritta . Quasi sempre importando solo nomi specifici from math import sqrt, ceil è il modo consigliato :

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

Le importazioni speciali sono consentite solo a livello di modulo. I tentativi di eseguirli nelle definizioni di classe o funzione producono un SyntaxError .

def f():
    from math import *

e

class A:
    from math import *

entrambi falliscono con:

SyntaxError: import * only allowed at module level

La variabile speciale __all__

I moduli possono avere una variabile speciale chiamata __all__ per limitare quali variabili vengono importate quando si utilizza from mymodule import * .

Dato il seguente modulo:

# mymodule.py

__all__ = ['imported_by_star']

imported_by_star = 42
not_imported_by_star = 21

Solo imported_by_star viene importata quando si utilizza 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

Tuttavia, not_imported_by_star può essere importato esplicitamente:

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

Importazione programmatica

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

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

Per le versioni precedenti di Python, usa il modulo 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()

NON usare __import__() per importare moduli in modo programmatico! Ci sono dettagli sottili che coinvolgono sys.modules , l'argomento fromlist , ecc. Che è facile ignorare quale importlib.import_module() gestisce per te.

Importa moduli da una posizione arbitraria del filesystem

Se si desidera importare un modulo che non esiste già come modulo integrato nella libreria standard Python né come pacchetto laterale, è possibile farlo aggiungendo il percorso alla directory in cui si trova il modulo su sys.path . Questo può essere utile laddove esistono più ambienti python su un host.

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

È importante aggiungere il percorso alla directory in cui è stato trovato mymodule , non il percorso del modulo stesso.

Regole PEP8 per le importazioni

Alcune linee guida di stile PEP8 raccomandate per le importazioni:

1. Le importazioni dovrebbero essere su linee separate:

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

2. Ordinare le importazioni come segue nella parte superiore del modulo:

   • Importazioni di librerie standard
   • Importazioni di terze parti correlate
   • Importazioni specifiche di applicazioni / librerie locali

3. Le importazioni con caratteri jolly devono essere evitate poiché causano confusione nei nomi nello spazio dei nomi corrente. Se si esegue l' from module import * , non è chiaro se un nome specifico nel codice proviene dal module o meno. Questo è doppiamente vero se si dispone di più istruzioni from module import * -type from module import * .

4. Evitare l'uso di importazioni relative; utilizzare invece le importazioni esplicite.

Importazione di sottomoduli

from module.submodule import function

Questa function importa da module.submodule .

__import __ () funzione

La funzione __import__() può essere utilizzata per importare moduli in cui il nome è noto solo in fase di esecuzione

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

# equivalent to import os

Questa funzione può anche essere utilizzata per specificare il percorso del file per un modulo

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

Reimportazione di un modulo

Quando si utilizza l'interprete interattivo, è possibile ricaricare un modulo. Questo può essere utile se stai modificando un modulo e vuoi importare la versione più recente, o se hai patch-patch un elemento di un modulo esistente e vuoi annullare le modifiche.

Nota che non puoi semplicemente import nuovo il modulo per annullare:

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

Questo perché l'interprete registra ogni modulo che importi. E quando provi a reimportare un modulo, l'interprete lo vede nel registro e non fa nulla. Quindi il modo più difficile per reimportare è utilizzare l' import dopo aver rimosso l'elemento corrispondente dal 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

Ma c'è di più un modo semplice e diretto.

Python 2

Usa la funzione di reload :

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

Python 3

La funzione di reload è stata spostata in importlib :

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