modulo python3
Nelle sezioni precedenti dello script è interprete Python per programmare noi, se si esce e si entra dal interprete Python, allora tutti i metodi e le variabili definite sarà scomparsa.
Python fornisce un modo per fare questo, queste definizioni memorizzati in un file per alcuni script o esempio interprete interattivo, questo file è chiamato un modulo.
Modulo è una definizione di tutti i file che contiene le funzioni e le variabili il cui .py suffisso del nome. I moduli possono essere introdotti in altri programmi di utilizzare questo modulo funzioni e altre funzioni. Questo è anche l'uso di pitone libreria standard.
Ecco un esempio di moduli della libreria standard di Python utilizzato.
#!/usr/bin/python3
# 文件名: using_sys.py
import sys
print('命令行参数如下:')
for i in sys.argv:
print(i)
print('\n\nPython 路径为：', sys.path, '\n')
Attuazione dei risultati sono i seguenti:
$ python using_sys.py 参数1 参数2 命令行参数如下: using_sys.py 参数1 参数2 Python 路径为： ['/root', '/usr/lib/python3.4', '/usr/lib/python3.4/plat-x86_64-linux-gnu', '/usr/lib/python3.4/lib-dynload', '/usr/local/lib/python3.4/dist-packages', '/usr/lib/python3/dist-packages']
- 1, import sys introdotte modulo sys.py libreria standard di Python, questo è l'introduzione di un approccio modulo.
- 2, sys.argv è una lista di opzioni della riga di comando sono inclusi.
- 3, sys.path comprende un interprete Python trovare automaticamente il percorso della lista dei moduli richiesti.
istruzione import
Vuoi usare file sorgente Python, semplicemente eseguire un'altra istruzione import nel file di origine, la sintassi è la seguente:
import module1[, module2[,... moduleN]
Quando l'interprete incontra l'istruzione import, se il modulo sarà importato nel percorso di ricerca corrente.
Il percorso di ricerca è un interprete sarà prima la ricerca di un elenco di tutte le directory. Come si desidera importare il supporto per i moduli, è necessario ordinare alla parte superiore dello script:
codice del file support.py è:
#!/usr/bin/python3
# Filename: support.py
def print_func( par ):
print ("Hello : ", par)
return
test.py introdotto modulo di supporto:
#!/usr/bin/python3
# Filename: test.py
# 导入模块
import support
# 现在可以调用模块里包含的函数了
support.print_func("w3big")
Esempi di uscita sopra:
$ python3 test.py Hello : w3big
Un modulo sarà importata solo una volta, non importa quante volte si esegue l'importazione. Ciò impedisce che il modulo di importazione viene eseguito più e più volte.
Quando usiamo l'istruzione import in cui, interprete Python è come trovare il file corrispondente esso?
Ciò comporta il percorso di ricerca di Python, il percorso di ricerca è composto da una serie di nomi di directory, interprete Python passa da queste directory per la ricerca di moduli introdotti.
Questo appare come una variabile di ambiente, infatti, può essere determinata definendo il percorso di ricerca ambiente modo variabile.
Percorso di ricerca è il compilatore Python o installazione determinato, installare nuova biblioteca dovrebbe essere modificato. Il percorso di ricerca è memorizzato nella variabile percorso modulo sys, fare un semplice esperimento di interprete interattivo, inserire il seguente codice:
>>> import sys >>> sys.path ['', '/usr/lib/python3.4', '/usr/lib/python3.4/plat-x86_64-linux-gnu', '/usr/lib/python3.4/lib-dynload', '/usr/local/lib/python3.4/dist-packages', '/usr/lib/python3/dist-packages'] >>>
sys.path è una lista di uscita, il primo dei quali è una stringa vuota '', rappresenta la directory corrente (se stampati da uno script, si può vedere più chiaramente quale directory), che eseguiamo interprete Python directory (se lo script è la directory in cui viene eseguito lo script).
Quindi, se come me esiste nella directory corrente con lo stesso nome del file da introdurre nel modulo, sarà introdotto il modulo per bloccare.
Comprendere il concetto di percorso di ricerca, è possibile modificare sys.path in uno script per introdurre alcuni non nel percorso di ricerca del modulo.
Ora, nella directory corrente o un interprete directory sys.path in cui creare un file fibo.py, come segue:
# 斐波那契(fibonacci)数列模块
def fib(n): # 定义到 n 的斐波那契数列
a, b = 0, 1
while b < n:
print(b, end=' ')
a, b = b, a+b
print()
def fib2(n): # 返回到 n 的斐波那契数列
result = []
a, b = 0, 1
while b < n:
result.append(b)
a, b = b, a+b
return result
Quindi immettere l'interprete Python, utilizzare il seguente comando per importare questo modulo:
>>> import fibo
Questo non è definito nella fibo direttamente nel nome della funzione è scritto nella tabella dei simboli, ma il nome del modulo fibo scritto lì.
È possibile utilizzare il nome del modulo di funzioni di accesso:
>>> fibo.fib(1000) 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 >>> fibo.fib2(100) [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89] >>> fibo.__name__ 'fibo'
Se si intende utilizzare una funzione spesso è possibile assegnarlo a un nome locale:
>>> fib = fibo.fib >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377
da ... istruzione import
Python consente di importare una dichiarazione da una parte specifica del namespace corrente dal modulo, la sintassi è la seguente:
from modname import name1[, name2[, ... nameN]]
Ad esempio, per importare il modulo di fibo della funzione fib, utilizzare la seguente istruzione:
>>> from fibo import fib, fib2 >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377
Questa affermazione non è l'intero modulo fibo nel namespace corrente, sarà Fibo unica funzione fib Lane, introdotto in.
Da ... import * dichiarazione
Tutti i contenuti di un modulo sono tutti nel namespace corrente sono possibili, è sufficiente utilizzare la seguente dichiarazione:
from modname import *
Questo fornisce un modo semplice per importare un modulo in tutti i progetti. Tuttavia, questa affermazione non dovrebbe essere troppo da usare.
modulo di profondità
Oltre al modulo metodo di definizione può anche includere codice eseguibile. Questi codici sono generalmente utilizzati per inizializzare il modulo. Questo codice è introdotto verrà eseguita solo la prima volta.
Ciascun modulo ha la sua tabella di simboli indipendenti, all'interno del modulo utilizzare per tutte le funzioni come una tabella di simboli globale.
Pertanto, l'autore del modulo può tranquillamente utilizzare queste variabili globali nel modulo senza preoccuparsi degli altri utenti di impegnarsi in un fiore delle variabili globali.
Da un altro aspetto, quando tu non sappia quello che stai facendo, è possibile anche accedere al modulo funzione nome_modulo.nome_elemento tale rappresentazione.
I moduli possono importare altri moduli. In un modulo (o dello script, o altrove) l'uso principale di importazione per importare un modulo, ovviamente, questo è solo una convenzione, e non obbligatoria. Il nome del modulo importato verrà inserito nella tabella dei simboli del funzionamento corrente del modulo.
Vi è anche un metodo di importazione, importazione può essere utilizzato direttamente all'interno del nome del modulo (funzione di variabili) nel vostro modulo operativo corrente. Ad esempio:
>>> from fibo import fib, fib2 >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377
Questo metodo non importerà il nome del modulo viene introdotto nella tabella dei caratteri corrente (quindi in questo caso all'interno, Fibo nome non è definito).
Questo è anche un modo per mettere un modulo di una volta tutti (funzione, variabile) i nomi vengono importati nel modulo di tabella di carattere corrente:
>>> from fibo import * >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377
Ciò importare tutti i nomi sono in, ma quelli di una singola sottolineatura (_) nome non è su questo caso. Nella maggior parte dei casi, i programmatori Python non usano questo metodo perché i nomi introdotti da altre fonti, è probabile che riguardano la definizione esistente.
attributo __name__
Quando un modulo viene introdotto un altro programma, il programma principale verrà eseguito. Se vogliamo essere introdotti nel modulo, il modulo non esegue un blocco di programma, possiamo usare l'attributo __name__ per fare questo blocco viene eseguito solo nel modulo runtime stesso.
#!/usr/bin/python3
# Filename: using_name.py
if __name__ == '__main__':
print('程序自身在运行')
else:
print('我来自另一模块')
Eseguire il seguente risultato:
$ python using_name.py
Programma stesso è in esecuzione
$ python >>> import using_name 我来自另一模块 >>>
Descrizione: Ogni modulo ha un attributo __name__, quando il suo valore è '__main__', esso indica che il modulo stesso è in esecuzione, altrimenti viene introdotta.
funzione Dir ()
内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回: </p> <pre> >>> import fibo, sys >>> dir(fibo) ['__name__', 'fib', 'fib2'] >>> dir(sys) ['__displayhook__', '__doc__', '__excepthook__', '__loader__', '__name__', '__package__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames', '_debugmallocstats', '_getframe', '_home', '_mercurial', '_xoptions', 'abiflags', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats', 'copyright', 'displayhook', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'getcheckinterval', 'getdefaultencoding', 'getdlopenflags', 'getfilesystemencoding', 'getobjects', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettotalrefcount', 'gettrace', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'ps1', 'setcheckinterval', 'setdlopenflags', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions']
Se non viene dato alcun argomento, allora la funzione dir () elencherà i nomi di tutti attualmente definiti:
>>> a = [1, 2, 3, 4, 5] >>> import fibo >>> fib = fibo.fib >>> dir() # 得到一个当前模块中定义的属性列表 ['__builtins__', '__name__', 'a', 'fib', 'fibo', 'sys'] >>> a = 5 # 建立一个新的变量 'a' >>> dir() ['__builtins__', '__doc__', '__name__', 'a', 'sys'] >>> >>> del a # 删除变量名a >>> >>> dir() ['__builtins__', '__doc__', '__name__', 'sys'] >>>
Modulo standard
si Python con alcuni della libreria standard di moduli nel documento Python Library Reference saranno introdotte (che si trova dietro il "Documento Reference Library").
Alcuni moduli sono costruiti direttamente nel parser, nelle lingue anche se non alcune funzioni built-in, ma era in grado di utilizzare un molto efficiente, anche a chiamate a livello di sistema non sono un problema.
Questi componenti possono essere configurati in forme diverse in base a diversi sistemi operativi, come ad esempio il modulo winreg sarà solo a disposizione del sistema di Windows.
Va notato che vi è una speciale SYS modulo, che è integrato in ogni parser Python. Variabili sys.ps1 e sys.ps2 definisce il prompt stringa corrispondente prompt primario e secondario:
>>> import sys
>>> sys.ps1
'>>> '
>>> sys.ps2
'... '
>>> sys.ps1 = 'C> '
C> print('Yuck!')
Yuck!
C>
pacchetto
Pacchetto è sotto forma di un modulo di gestione dello spazio dei nomi Python, usando "i nomi dei moduli tratteggiate."
Ad esempio, un nome del modulo è AB, poi ha detto che un pacchetto Un sotto-modulo B.
Se si utilizza il modulo, non dovete preoccuparvi di variabili globali tra interazione moduli diversi, come l'uso di nomi di moduli tratteggiate in questa forma, non ti preoccupare il modulo caso tra le diverse librerie con lo stesso nome.
In modo che diversi autori in grado di fornire moduli NumPy, o Python libreria grafica.
Supponiamo che si vuole progettare un modulo unificato di elaborazione voce e un file di dati (o lo chiamano un "pacchetto").
Esistenti varietà di diversi formati di file audio (fondamentalmente distinte, per estensione, per esempio: file wav ,:: File .aiff ,:: au,), quindi è necessario avere un insieme di crescente modulo per tra diversi formati.
E per i dati audio, ci sono molte operazioni differenti (come ad esempio la miscelazione, l'aggiunta di eco, aumentare la funzione di equalizzazione per creare effetto stereo artificiale), che hai bisogno anche di un insieme di come mai finire moduli per gestire queste operazioni.
Ecco una possibile struttura del pacchetto (in un file system gerarchico):
sound/ 顶层包
__init__.py 初始化 sound 包
formats/ 文件格式转换子包
__init__.py
wavread.py
wavwrite.py
aiffread.py
aiffwrite.py
auread.py
auwrite.py
...
effects/ 声音效果子包
__init__.py
echo.py
surround.py
reverse.py
...
filters/ filters 子包
__init__.py
equalizer.py
vocoder.py
karaoke.py
...
In Importa un pacchetto quando, Python sys.path directory in base al sottodirectory per trovare questo pacchetto contiene.
Solo directory contiene un file di nome __init__.py saranno considerati come un pacchetto, soprattutto per evitare alcuni degli abusi volgare del nome (ad esempio, chiamato stringa) incurante influenzano il percorso di ricerca di un modulo valido.
Nel caso più semplice, mettere un vuoto: file: __ init__.py esso. Naturalmente, questo file può contenere anche un po 'di codice di inizializzazione o è (sarà descritto più avanti) __all__ variabile.
Ogni volta che l'utente può importare solo un modulo specifico all'interno del pacchetto, come ad esempio:
import sound.effects.echo
Questo importerà sottomoduli: Sound.Effects.echo. Deve usare il nome completo di accesso:
sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)
Un altro metodo per introdurre i sotto-moduli sono:
from sound.effects import echo
Sarà anche importare sottomoduli: eco, e non ha bisogno di quei lunghi prefisso, in modo da poter utilizzare:
echo.echofilter(input, output, delay=0.7, atten=4)
Un altro cambiamento è direttamente introdotto in una funzione o variabile:
from sound.effects.echo import echofilter
Ancora una volta, questo metodo consente di importare sottomoduli: eco, e può usare la sua funzione di echofilter ():
echofilter (ingresso, uscita, ritardo = 0.7, atten = 4)
Si noti che quando si usa from package import elemento in questa forma quando l'elemento corrispondente può essere sia all'interno del sotto-modulo pacchetto (sub pacchetti), o altri nomi all'interno della definizione del pacchetto, come la funzione, classe o variabile.
La sintassi sarà prima importare il nome dell'elemento definito come un pacchetto, se non trovato, poi ha cercato di seguire un modulo da importare. Se non trovato, complimenti, una: exc: eccezione ImportError viene generata.
Al contrario, se si utilizza questo modulo come l'importazione elemento.sottoelemento.sottosottoelemento importare forma, tranne l'ultimo, deve essere un pacchetto, ma l'ultimo può essere un modulo o di un pacchetto, ma non può essere un nome di classe, funzione o variabile .
Importa da un pacchetto *
Immaginate se usiamo da Sound.Effects import * Che cosa accadrà?
Python entrerà nel sistema di file, trovare il pacchetto che tutti i sotto-moduli, uno per uno, tutti di loro di entrare in.
Ma, purtroppo, questo metodo funziona sulla piattaforma di Windows non è molto buona, perché Windows è un sistema di case-insensitive.
Su questa piattaforma, nessuno può garantire chiamato file di ECHO.py importato come modulo echo o Echo o ECHO.
(Ad esempio, Windows 95 è molto fastidioso per capitalizzare la prima lettera di ogni file viene visualizzato) e DOS 8 + 3 convenzione di denominazione sarà affrontare la questione di nomi di moduli lunghi non più intricata.
Per risolvere questo problema, l'unico problema del package per fornire un indice accurata del pacchetto.
Importa dichiarazione seguente regole: se il file di definizione del pacchetto chiamato __init__.py esiste __all__ elenco di variabili, utilizzando da tempo pacchetto import * di mettere tutti i nomi in questa lista come contenuto del pacchetto di importazione.
Come l'autore del pacchetto, non dimenticate dopo il pacchetto di aggiornamento per garantire __all__ ah anche aggiornato. Tu dici che non lo farò, non voglio utilizzare l'Importazione * questo uso, va bene, non è un problema, perché non si fa il capo. Ecco un esempio, in: file: suoni / effetti / __ init__.py contiene il seguente codice:
__all__ = ["echo", "surround", "reverse"]
Ciò significa che quando si utilizza questo utilizzo da Sound.Effects import *, si importare il pacchetto all'interno dei tre sotto-moduli.
Se __all__ davvero non è definito, quindi utilizzare questa sintassi da Sound.Effects import * tempo, non importa tutti i sottomoduli nei Sound.Effects pacchetto. Ha appena messo tutto il contenuto della confezione e dei suoi Sound.Effects definita all'interno di entrare in (definiti possono essere in esecuzione codice di inizializzazione __init__.py).
Ciò __init__.py che definisce tutti i nomi a venire in. E non distruggerà tutti i moduli esplicitamente specificato prima abbiamo introdotto questa frase. Guardate questa parte del codice:
import sound.effects.echo import sound.effects.surround from sound.effects import *
In questo esempio, prima dell'esecuzione da ... importazione, il pacchetto Sound.Effects l'eco e moduli surround sono importati nello spazio dei nomi corrente. (Naturalmente, anche se si definisce __all__ nessun problema)
Normalmente noi non sosteniamo l'uso di * questo metodo per importare il modulo, perché spesso questo metodo si tradurrà in ridotto la leggibilità. Ma questo è davvero una combinazione di tasti può risparmiare un sacco di fatica, e alcuni moduli sono progettati per diventare l'unica importazione attraverso un metodo particolare.
Ricordate, utilizzando dal pacchetto di importazione specific_submodule questo metodo non sarà mai sbagliato. In realtà, questo è il metodo consigliato. A meno che non si desidera importare sotto-moduli e sottomoduli possono avere altri pacchetti con lo stesso nome.
Se la struttura del pacchetto è un sub-package (come l'esempio per il pacchetto è suono), e si desidera importare il pacchetto fratelli (stesso pacchetto livello) si deve utilizzare importati percorso assoluto di importare. Ad esempio, se si desidera utilizzare i moduli del pacchetto Sound.Filters.vocoder modulo Sound.Effects eco, si deve scrivere da Sound.Effects import eco.
from . import echo from .. import formats from ..filters import equalizer
Implicite o esplicite le importazioni relative sono a partire dall'inizio del modulo corrente. Nome del modulo principale è sempre "__main__", modulo principale di una applicazione Python, si dovrebbe sempre usare un riferimenti percorso assoluto.
Pacchetto fornisce anche un __path__ proprietà aggiuntiva. Questa è una lista di directory, ognuno dei quali ha una directory contenente il pacchetto per questo servizio __init__.py, si deve essere eseguito prima di altri definiti in __init__.py oh. Questa variabile può essere modificata per l'influenza all'interno del modulo incluso nel pacchetto ed il pacchetto figlio.
Questa caratteristica non è comunemente utilizzato, tipicamente utilizzato per estendere il pacchetto all'interno del modulo.