Module python3
Dans les sections précédentes du script est l'interpréteur python pour nous programmer, si vous quittez et entrez par l'interpréteur Python, toutes les méthodes et les variables que vous définissez auront disparu.
Python fournit une façon de le faire, ces définitions stockées dans un fichier pour certains scripts ou instance d'interpréteur interactif, ce fichier est appelé un module.
Module est une définition de tous vos fichiers qui contient des fonctions et des variables dont le suffixe .py nom. Les modules peuvent être introduits dans d'autres programmes pour utiliser cette fonction de modules et d'autres fonctions. Ceci est également l'utilisation de python bibliothèque standard.
Voici un exemple de modules de la bibliothèque standard de python utilisé.
#!/usr/bin/python3
# 文件名: using_sys.py
import sys
print('命令行参数如下:')
for i in sys.argv:
print(i)
print('\n\nPython 路径为：', sys.path, '\n')
La mise en œuvre des résultats sont les suivants:
$ 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, sys d'importation introduites python module sys.py bibliothèque standard, ce qui est la mise en place d'une approche de module.
- 2, sys.argv est une liste des commutateurs de ligne de commande sont inclus.
- 3, sys.path comprend un interpréteur Python trouver automatiquement le chemin de la liste des modules requis.
instruction import
Voulez-vous utiliser le fichier source Python, il suffit de réaliser une autre instruction import dans le fichier source, la syntaxe est la suivante:
import module1[, module2[,... moduleN]
Lorsque l'interpréteur rencontre l'instruction import, si le module est importé dans le chemin de recherche en cours.
Le chemin de recherche est un interprète va d'abord rechercher une liste de tous les répertoires. Comme vous voulez importer le support de module, vous devez commander en haut du script:
Code de fichier support.py est:
#!/usr/bin/python3
# Filename: support.py
def print_func( par ):
print ("Hello : ", par)
return
test.py introduit module de support:
#!/usr/bin/python3
# Filename: test.py
# 导入模块
import support
# 现在可以调用模块里包含的函数了
support.print_func("w3big")
Des exemples de sortie ci-dessus:
$ python3 test.py Hello : w3big
Un module ne sera importé une fois, peu importe combien de fois vous exécutez l'importation. Cela empêche le module d'importation est exécuté maintes et maintes fois.
Lorsque nous utilisons l'instruction import quand, interpréteur Python est de savoir comment trouver le fichier correspondant il?
Cela implique le chemin de recherche Python, le chemin de recherche est composé d'une série de noms de répertoire, l'interpréteur Python va tourner à partir de ces répertoires pour rechercher des modules introduits.
Cela ressemble à une variable d'environnement, en fait, peut être déterminée en définissant l'environnement de chemin de recherche de manière variable.
Chemin de recherche est le compilateur ou une installation déterminée Python, installer la nouvelle bibliothèque doit également être modifié. Le chemin de recherche est stocké dans la variable du chemin de module sys, faire une expérience simple interpréteur interactif, entrez le code suivant:
>>> 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 est une liste de sortie, dont la première est une chaîne vide '', représente le répertoire courant (si elle est imprimée à partir d'un script, vous pouvez voir plus clairement quel répertoire), que nous exécutons l'interpréteur python répertoire (si le script est le répertoire où le script est exécuté).
Donc, si comme moi existe dans le répertoire courant avec le même nom que le fichier doit être introduit dans le module, le module sera mis en place pour bloquer.
Comprendre le concept de chemin de recherche, vous pouvez modifier sys.path dans un script d'introduire un certain pas dans le chemin de recherche du module.
Maintenant, dans le répertoire courant ou d'un interprète répertoire sys.path dans lequel créer un fichier fibo.py, comme suit:
# 斐波那契(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
Ensuite, entrez l'interpréteur Python, utilisez la commande suivante pour importer ce module:
>>> import fibo
Ce ne définit pas fibo directement dans le nom de la fonction est écrite dans la table des symboles, mais le nom du module fibo il écrit.
Vous pouvez utiliser le nom du module pour les fonctions d'accès:
>>> 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'
Si vous avez l'intention d'utiliser une fonction souvent, vous pouvez l'assigner à un nom local:
>>> fib = fibo.fib >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377
de ... déclaration d'importation
Python vous permet d'importer une déclaration d'une partie spécifique de l'espace de noms courant à partir du module, la syntaxe est la suivante:
from modname import name1[, name2[, ... nameN]]
Par exemple, pour importer le module fibo de la fonction fib, utilisez l'instruction suivante:
>>> from fibo import fib, fib2 >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377
Cette déclaration est pas l'ensemble du module de fibo dans l'espace de noms courant, il ne fera que FIBO fonction fib Lane introduit.
De ... import * déclaration
Tout le contenu d'un module sont tous dans l'espace de noms courant sont possibles, il suffit d'utiliser la déclaration suivante:
from modname import *
Cela fournit un moyen facile d'importer un module dans tous les projets. Toutefois, cette déclaration ne devrait pas être trop à utiliser.
Module de profondeur
En plus du module de définition de procédé peut également inclure le code exécutable. Ces codes sont généralement utilisés pour l'initialisation du module. Ce code est seulement la première fois est introduit sera exécuté.
Chaque module a sa propre table de symbole indépendant, à l'intérieur du module à utiliser pour toutes les fonctions comme une table de symbole globale.
Par conséquent, l'auteur du module peut utiliser en toute sécurité ces variables globales dans le module sans se soucier des autres utilisateurs de se livrer à une variable globale fleurs.
D'un autre aspect, quand vous savez vraiment ce que vous faites, vous pouvez également accéder au module de fonction par nommodule.nomelem telle représentation.
Les modules peuvent importer d'autres modules. Dans un module (ou un script, ou ailleurs) l'utilisation avant tout import pour importer un module, bien sûr, cela est juste une convention, et non obligatoire. Le nom du module importé sera placé dans la table des symboles de l'opération en cours du module.
Il y a aussi une méthode d'importation, l'importation peut être utilisé directement dans le nom du module (fonction de variables) dans votre module d'exploitation actuel. Par exemple:
>>> from fibo import fib, fib2 >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377
Cette méthode ne sera pas importer le nom du module est introduit dans le tableau de caractères courant (dans ce cas à l'intérieur, FIBO nom n'est pas défini).
Ceci est également un moyen de mettre un module unique tous (fonction, variables) noms sont importés dans le courant module de table de caractères:
>>> from fibo import * >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377
Cela importer tous les noms sont, mais ceux d'un seul trait de soulignement (_) nom ne figure pas sur cette affaire. Dans la plupart des cas, les programmeurs Python ne pas utiliser cette méthode parce que les noms introduits à partir d'autres sources, est susceptible de couvrir la définition actuelle.
__name__ attribut
Quand un module est d'abord introduit un autre programme, le programme principal sera exécuté. Si nous voulons être introduit dans le module, le module n'exécute un bloc de programme, nous pouvons utiliser __name__ attribut pour faire de ce bloc est exécuté seulement dans le module d'exécution lui-même.
#!/usr/bin/python3
# Filename: using_name.py
if __name__ == '__main__':
print('程序自身在运行')
else:
print('我来自另一模块')
Exécutez la sortie suivante:
$ python using_name.py
Programme lui-même est en marche
$ python >>> import using_name 我来自另一模块 >>>
Description: Chaque module a un attribut __name__, lorsque sa valeur est '__main__', il indique que le module lui - même est en cours d' exécution, sinon il est en cours d' introduction.
fonction 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']
Si aucun argument est donné, alors la fonction dir () liste les noms de tous actuellement définis:
>>> 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'] >>>
standard Module
Python lui-même avec une partie de la bibliothèque standard de modules dans le document Python Library Reference seront introduites à (qui est derrière la "bibliothèque de documents de référence»).
Certains modules sont construits directement dans l'analyseur, ces langues mais pas certaines fonctionnalités intégrées, mais il a pu utiliser un très efficace, même un appel au niveau du système ne pose aucun problème.
Ces composants peuvent être configurés sous différentes formes en fonction des différents systèmes d'exploitation, tels que le module winreg ne sera disponible pour le système Windows.
Il convient de noter qu'il existe un sys de module spécial, qui est intégré dans chaque analyseur Python. Variables sys.ps1 et sys.ps2 définit la chaîne correspondante invite invite primaire et secondaire:
>>> import sys
>>> sys.ps1
'>>> '
>>> sys.ps2
'... '
>>> sys.ps1 = 'C> '
C> print('Yuck!')
Yuck!
C>
paquet
Package est sous la forme d'un module de gestion de l'espace de noms Python, en utilisant "les noms de modules en pointillés."
Par exemple, un nom de module est AB, puis il a dit qu'un paquet Un sous-module B.
Si vous utilisez le module, vous n'avez pas à vous soucier de variables globales entre les différents modules d'interaction, comme l'utilisation de noms de modules en pointillés sous cette forme, ne vous inquiétez pas le module de cas entre les différentes bibliothèques du même nom.
Alors que les différents auteurs peuvent fournir le module NumPy ou bibliothèque graphique Python.
Supposons que vous souhaitez concevoir un module de traitement de la voix unifiée et un fichier de données (ou appellent un «paquet»).
variété existante de différents formats de fichiers audio (essentiellement distingués par extension, par exemple: .wav ,: fichier: .aiff ,: fichier: .au,), de sorte que vous devez disposer d'un ensemble de modules pour augmenter entre différents formats.
Et pour les données audio, il y a beaucoup d'opérations différentes (telles que le mélange, l'ajout d'écho, augmenter la fonction d'égaliseur pour créer un effet stéréo artificielle), que vous avez également besoin d'un ensemble de la façon dont jamais finir modules pour gérer ces opérations.
Voici une structure de package possible (dans un système de fichiers hiérarchique):
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
...
Dans l'importation d'un paquet quand, les répertoires Python de base sur le sous-répertoire pour trouver ce package contient.
Seul répertoire contient un fichier nommé __init__.py sera considéré comme un paquet, principalement pour éviter certains abus vulgaire du nom (par exemple, appelé string) négligente affecte le chemin de recherche à un module valide.
Dans le cas le plus simple, mettre un vide: file: __ init__.py il. Bien sûr, ce fichier peut également contenir un code d'initialisation ou est (sera décrit plus loin) __all__ variable.
Chaque fois que l'utilisateur peut importer uniquement un module spécifique à l'intérieur du paquet, tels que:
import sound.effects.echo
Cela importera sous-modules: Sound.Effects.echo. Il doit utiliser le nom complet d'accès:
sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)
Une autre méthode pour introduire des sous-modules sont:
from sound.effects import echo
Il sera également importer des sous-modules: écho, et il n'a pas besoin de ces longs préfixe, pour qu'il puisse utiliser:
echo.echofilter(input, output, delay=0.7, atten=4)
Un autre changement est introduit directement dans une fonction ou variable:
from sound.effects.echo import echofilter
Encore une fois, cette méthode va importer des sous-modules: écho, et peut utiliser sa fonction echofilter ():
echofilter (entrée, sortie, delay = 0,7, atten = 4)
Notez que lors de l'utilisation de l'emballage produit d'importation sous cette forme lorsque l'élément correspondant peut être soit à l'intérieur du sous-module de package (sous packages), ou d'autres noms à l'intérieur de la définition de package, comme fonction, classe ou variable.
La syntaxe sera d'abord importer le nom de l'élément défini comme un paquet, sinon trouvé, alors essayé de suivre un module à importer. Si non trouvé, félicitations, a: exc: ImportError exception est levée.
A l'inverse, si vous utilisez ce formulaire import element.souselement.soussouselement importer sous forme, sauf le dernier, il doit être un paquet, mais le dernier peut être un module ou d'un paquet, mais ne peut pas être un nom de classe, fonction ou variable .
Importer à partir d'un paquet *
Imaginez si nous utilisons de Sound.Effects import * Qu'est-ce qui va se passer?
Python va entrer dans le système de fichiers, trouver le paquet qui tous les sous-modules, un par un, tous d'entre eux entrent en.
Mais malheureusement, cette méthode fonctionne sur la plate-forme Windows est pas très bon, parce que Windows est un système insensible à la casse.
Sur cette plate-forme, personne ne peut se porter garant appelé fichier ECHO.py importé comme un écho de module ou Echo ou ECHO.
(Par exemple, Windows 95 est très ennuyeux de capitaliser la première lettre de chaque fichier est affiché) et DOS 8 + 3 convention de nommage traitera de la question des noms de modules longs ne plus embrouillé.
Pour résoudre ce problème, le seul problème le paquet auteur de fournir un indice précis de l'emballage.
déclaration d'importation des règles suivantes: Si le fichier de définition de package appelé __init__.py existe __all__ liste des variables, en utilisant du package import * temps de mettre tous les noms dans cette liste en tant que contenu package d'importation.
Comme l'auteur de l'emballage, ne pas oublier après que le paquet de mise à jour pour assurer __all__ ah également mis à jour. Vous dites que je ne vais pas le faire, je ne vais pas utiliser l'importation * cet usage, d'accord, pas de problème, pourquoi ne vous a pas fait le patron. Voici un exemple, dans: file: sons / effets / __ init__.py contient le code suivant:
__all__ = ["echo", "surround", "reverse"]
Cela signifie que lorsque vous utilisez cet usage de Sound.Effects import *, vous importez le paquet dans les trois sous-modules.
Si __all__ vraiment est pas défini, puis utilisez cette syntaxe de Sound.Effects import * temps, il n'importe pas de sous-modules dans les Sound.Effects du paquet. Il vient de mettre tout le contenu de l'emballage et son Sound.Effects défini à l'intérieur pour venir en (définie peut être en cours d'exécution du code d'initialisation __init__.py).
Cela __init__.py qui définit tous les noms à venir en. Et il ne va pas détruire tous les modules explicitement spécifié avant, nous avons introduit cette phrase. Regardez cette partie du code:
import sound.effects.echo import sound.effects.surround from sound.effects import *
Dans cet exemple, avant l'exécution de ... import, package Sound.Effects l'écho et les modules surround sont importés dans l'espace de noms courant. (Bien sûr, même si vous définissez __all__ pas de problème)
Normalement, nous ne préconisons pas l'utilisation de * cette méthode pour importer le module, car souvent cette méthode se traduira par une lisibilité réduite. Mais ce qui est vraiment une combinaison de touches permet d'économiser beaucoup d'efforts, et certains modules sont conçus pour devenir la seule importation par le biais d'une méthode particulière.
Rappelez-vous, à l'aide du package import specific_submodule cette méthode ne sera jamais tort. En fait, cette méthode est recommandée. Sauf si vous voulez importer des sous-modules et sous-modules peuvent avoir d'autres paquets du même nom.
Si la structure de l'emballage est un sous-ensemble (comme l'exemple pour le paquet est le son), et que vous voulez importer le package de frères (même package de niveau), vous devez utiliser un chemin absolu importé à importer. Par exemple, si vous souhaitez utiliser les modules de package sound.filters.vocoder le module echo, vous devez écrire à partir de Sound.Effects import écho.
from . import echo from .. import formats from ..filters import equalizer
Que les importations par rapport implicites ou explicites sont depuis le début du module courant. Nom du module principal est toujours "__main__", module principal d'une application Python, vous devez toujours utiliser une référence de chemin absolu.
Package fournit également une propriété __path__ supplémentaire. Ceci est une liste de répertoires, dont chacun a un répertoire contenant le package de ce service __init__.py, vous devez exécuter avant d'autres définis dans __init__.py oh. Cette variable peut être modifiée pour l'influence à l'intérieur du module inclus dans le package et le package enfant.
Cette fonctionnalité est pas couramment utilisé, généralement utilisé pour étendre le paquet à l'intérieur du module.