Python - Moduli

Un modulo ti consente di organizzare logicamente il tuo codice Python. Il raggruppamento del codice correlato in un modulo semplifica la comprensione e l'utilizzo del codice. Un modulo è un oggetto Python con attributi con nomi arbitrari che puoi associare e fare riferimento.

Semplicemente, un modulo è un file costituito da codice Python. Un modulo può definire funzioni, classi e variabili. Un modulo può anche includere codice eseguibile.

Esempio

Il codice Python per un modulo denominato aname normalmente risiede in un file denominato aname.py . Ecco un esempio di un semplice modulo, support.py

def print_func( par ):
   print "Hello : ", par
   return

L' istruzione import

È possibile utilizzare qualsiasi file sorgente Python come modulo eseguendo un'istruzione import in un altro file sorgente Python. L' importazione ha la seguente sintassi:

import module1[, module2[,... moduleN]

Quando l'interprete incontra un'istruzione import, importa il modulo se il modulo è presente nel percorso di ricerca. Un percorso di ricerca è un elenco di directory che l'interprete cerca prima di importare un modulo. Ad esempio, per importare il modulo support.py, è necessario inserire il seguente comando all'inizio dello script:

#!/usr/bin/python

# Import module support
import support

# Now you can call defined function that module as follows
support.print_func("Zara")

Quando il codice sopra viene eseguito, produce il seguente risultato:

Hello : Zara

Un modulo viene caricato una sola volta, indipendentemente dal numero di volte in cui viene importato. Ciò impedisce l'esecuzione del modulo più e più volte se si verificano più importazioni.

L' istruzione from ... import

L' istruzione from di Python consente di importare attributi specifici da un modulo nello spazio dei nomi corrente. L' importazione da ... ha la seguente sintassi:

from modname import name1[, name2[, ... nameN]]

Ad esempio, per importare la funzione fibonacci dal modulo fib, utilizzare la seguente dichiarazione:

from fib import fibonacci

Questa istruzione non importa l'intero modulo fib nello spazio dei nomi corrente; introduce semplicemente l'elemento fibonacci dal modulo fib nella tabella dei simboli globale del modulo di importazione.

L' istruzione from ... import *

È anche possibile importare tutti i nomi da un modulo nello spazio dei nomi corrente utilizzando la seguente istruzione di importazione:

from modname import *

Ciò fornisce un modo semplice per importare tutti gli elementi da un modulo nello spazio dei nomi corrente; tuttavia, questa istruzione dovrebbe essere usata con parsimonia.

Individuazione dei moduli

Quando importi un modulo, l'interprete Python cerca il modulo nelle seguenti sequenze:

La directory corrente.
Se il modulo non viene trovato, Python cerca quindi ogni directory nella variabile di shell PYTHONPATH.
Se tutto il resto fallisce, Python controlla il percorso predefinito. Su UNIX, questo percorso predefinito è normalmente / usr / local / lib / python /.

Il percorso di ricerca del modulo è memorizzato nel modulo di sistema sys come sys.pathvariabile. La variabile sys.path contiene la directory corrente, PYTHONPATH e il valore predefinito dipendente dall'installazione.

La variabile PYTHONPATH

PYTHONPATH è una variabile di ambiente, costituita da un elenco di directory. La sintassi di PYTHONPATH è la stessa della variabile di shell PATH.

Ecco un tipico PYTHONPATH da un sistema Windows:

set PYTHONPATH = c:\python20\lib;

Ed ecco un tipico PYTHONPATH da un sistema UNIX -

set PYTHONPATH = /usr/local/lib/python

Spazi dei nomi e ambito

Le variabili sono nomi (identificatori) associati agli oggetti. Uno spazio dei nomi è un dizionario di nomi di variabili (chiavi) e dei loro oggetti (valori) corrispondenti.

Un'istruzione Python può accedere alle variabili in uno spazio dei nomi locale e nello spazio dei nomi globale . Se una variabile locale e una globale hanno lo stesso nome, la variabile locale ombreggia la variabile globale.

Ogni funzione ha il proprio spazio dei nomi locale. I metodi di classe seguono la stessa regola di scoping delle funzioni ordinarie.

Python fa ipotesi plausibili sul fatto che le variabili siano locali o globali. Si presuppone che qualsiasi variabile a cui è stato assegnato un valore in una funzione sia locale.

Pertanto, per assegnare un valore a una variabile globale all'interno di una funzione, è necessario prima utilizzare l'istruzione globale.

L'istruzione global VarName dice a Python che VarName è una variabile globale. Python smette di cercare la variabile nello spazio dei nomi locale.

Ad esempio, definiamo una variabile Money nello spazio dei nomi globale. All'interno della funzione Money , assegniamo a Money un valore, quindi Python assume Money come variabile locale. Tuttavia, abbiamo avuto accesso al valore della variabile locale Money prima di impostarla, quindi il risultato è UnboundLocalError. Rimuovere il commento dall'istruzione globale risolve il problema.

#!/usr/bin/python

Money = 2000
def AddMoney():
   # Uncomment the following line to fix the code:
   # global Money
   Money = Money + 1

print Money
AddMoney()
print Money

La funzione dir ()

La funzione built-in dir () restituisce un elenco ordinato di stringhe contenenti i nomi definiti da un modulo.

L'elenco contiene i nomi di tutti i moduli, variabili e funzioni definiti in un modulo. Di seguito è riportato un semplice esempio:

#!/usr/bin/python

# Import built-in module math
import math

content = dir(math)
print content

Quando il codice sopra viene eseguito, produce il seguente risultato:

['__doc__', '__file__', '__name__', 'acos', 'asin', 'atan', 
'atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e', 'exp', 
'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log',
'log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 
'sqrt', 'tan', 'tanh']

Qui, la variabile stringa speciale __name__ è il nome del modulo e __file__ è il nome del file da cui è stato caricato il modulo.

Le funzioni globals () e locals ()

Le funzioni globals () e locals () possono essere utilizzate per restituire i nomi negli spazi dei nomi globale e locale a seconda della posizione da cui vengono chiamati.

Se locals () viene chiamato dall'interno di una funzione, restituirà tutti i nomi a cui è possibile accedere localmente da quella funzione.

Se globals () viene chiamato dall'interno di una funzione, restituirà tutti i nomi a cui è possibile accedere globalmente da quella funzione.

Il tipo di ritorno di entrambe queste funzioni è dizionario. Pertanto, i nomi possono essere estratti utilizzando la funzione keys ().

Il reload () Funzione

Quando il modulo viene importato in uno script, il codice nella parte di primo livello di un modulo viene eseguito solo una volta.

Pertanto, se si desidera rieseguire il codice di primo livello in un modulo, è possibile utilizzare la funzione reload () . La funzione reload () importa di nuovo un modulo importato in precedenza. La sintassi della funzione reload () è questa:

reload(module_name)

Qui, module_name è il nome del modulo che si desidera ricaricare e non la stringa contenente il nome del modulo. Ad esempio, per ricaricare il modulo hello , procedi come segue:

reload(hello)

Pacchetti in Python

Un pacchetto è una struttura di directory di file gerarchica che definisce un unico ambiente applicativo Python che consiste di moduli e sottopacchetti e sottopacchetti e così via.

Considera un file Pots.py disponibile nella directory del telefono . Questo file ha la seguente riga di codice sorgente:

#!/usr/bin/python

def Pots():
   print "I'm Pots Phone"

In modo simile, abbiamo altri due file con funzioni diverse con lo stesso nome di cui sopra -

File Phone / Isdn.py con funzione Isdn ()
File Phone / G3.py con funzione G3 ()

Ora, crea un altro file __init__.py nella directory del telefono -

Phone/__init__.py

Per rendere disponibili tutte le tue funzioni quando hai importato il telefono, devi inserire istruzioni di importazione esplicite in __init__.py come segue:

from Pots import Pots
from Isdn import Isdn
from G3 import G3

Dopo aver aggiunto queste righe a __init__.py, tutte queste classi saranno disponibili quando importi il pacchetto Telefono.

#!/usr/bin/python

# Now import your Phone Package.
import Phone

Phone.Pots()
Phone.Isdn()
Phone.G3()

Quando il codice sopra viene eseguito, produce il seguente risultato:

I'm Pots Phone
I'm 3G Phone
I'm ISDN Phone

Nell'esempio sopra, abbiamo preso esempio di una singola funzione in ogni file, ma puoi mantenere più funzioni nei tuoi file. Puoi anche definire diverse classi Python in quei file e quindi puoi creare i tuoi pacchetti da quelle classi.