Module Python3
Dans les chapitres précédents, nous avons essentiellement utilisé l'interpréteur Python pour programmer. Si vous quittez l'interpréteur Python et y entrez à nouveau, toutes les méthodes et les variables que vous avez définies disparaîtront.
Pour résoudre ce problème, Python offre un moyen de stocker ces définitions dans un fichier pour qu'elles soient utilisées par des scripts ou des instances d'interpréteur interactif. Ce fichier est appelé un module.
Un module en Python est un fichier contenant des définitions et des instructions Python. Le nom du fichier est le nom du module plus le suffixe.py.
Un module peut contenir des fonctions, des classes, des variables et du code exécutable. Grâce aux modules, nous pouvons organiser le code en unités réutilisables pour faciliter la gestion et la maintenance.
Le rôle des modules
Réutilisation du code: Encapsuler les fonctionnalités communes dans des modules, qui peuvent être réutilisés dans plusieurs programmes.
Gestion des espaces de noms: Les modules peuvent éviter les conflits de noms ; les fonctions ou variables portant le même nom dans différents modules n'interfèrent pas entre elles.
Organisation du code: Diviser le code en différents modules selon leur fonction, ce qui rend la structure du programme plus claire.
Voici un exemple d'utilisation d'un module de la bibliothèque standard Python.
Exemple (Python 3.0+)
Le résultat de l'exécution est le suivant :
$ 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 importe le module sys.py de la bibliothèque standard Python ; c'est une façon d'importer un module.
- 2. sys.argv est une liste contenant les arguments de la ligne de commande.
- 3. sys.path contient une liste de chemins où l'interpréteur Python recherche automatiquement les modules requis.
instruction d'import
Pour utiliser un fichier source Python, il suffit d'exécuter une instruction import dans un autre fichier source. La syntaxe est la suivante :
import module1[, module2[,... moduleN]
Lorsque l'interpréteur rencontre une instruction import, le module sera importé s'il se trouve dans le chemin de recherche actuel.
Le chemin de recherche est une liste de tous les répertoires que l'interpréteur recherchera. Si vous souhaitez importer le module support, vous devez placer la commande en haut du script :
Code du fichier support.py
test.py importe le module support :
Code du fichier test.py
La sortie de l'exemple ci-dessus est :
$ python3 test.py Hello : Example
Télécharger le code
Un module n'est importé qu'une seule fois, quel que soit le nombre de fois que vous exécutezimport. Cela empêche le module importé d'être exécuté encore et encore.
Lorsque nous utilisons l'instruction import, comment l'interpréteur Python trouve-t-il le fichier correspondant ?
Cela implique le chemin de recherche de Python. Le chemin de recherche est constitué d'une série de noms de répertoires, et l'interpréteur Python recherche le module importé dans ces répertoires l'un après l'autre.
Chemin de recherche des modules
Lors de l'importation d'un module, Python recherche le module dans l'ordre suivant :
Le répertoire courant.
Variable d'environnement
PYTHONPATHRépertoire spécifié.Répertoire de la bibliothèque standard Python.
.pthRépertoire spécifié dans le fichier.
Le chemin de recherche est déterminé au moment de la compilation ou de l'installation de Python, et l'installation de nouvelles bibliothèques peut également le modifier. Le chemin de recherche est stocké dans la variable path du module sys. Faisons une expérience simple : dans l'interpréteur interactif, saisissez 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'] >>>
La sortie de sys.path est une liste, où le premier élément est une chaîne vide '', représentant le répertoire courant (si elle est affichée depuis un script, vous pouvez voir plus clairement de quel répertoire il s'agit), c'est-à-dire le répertoire où nous exécutons l'interpréteur Python (pour les scripts, il s'agit du répertoire où se trouve le script en cours d'exécution).
Par conséquent, si, comme dans mon cas, il y a un fichier portant le même nom que le module à importer dans le répertoire courant, il masquera le module à importer.
After understanding the concept of the search path, you can modifysys.pathpour importer certains modules qui ne figurent pas dans le chemin de recherche.
Maintenant, créez un fichier nommé fibo.py dans le répertoire courant de l'interpréteur ou dans un répertoire inclus dans sys.path. Le code est le suivant :
Exemple
Ensuite, entrez dans l'interpréteur Python et utilisez la commande suivante pour importer ce module :
>>> import fibo
Cela n'écrit pas les noms des fonctions définies directement dans fibo dans la table des symboles actuelle ; cela y écrit uniquement le nom du module fibo.
Vous pouvez utiliser le nom du module pour accéder aux fonctions :
Exemple
Si vous prévoyez d'utiliser fréquemment une fonction, vous pouvez l'affecter à un nom local :
>>> fib = fibo.fib >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377
instruction from ... import
L'instruction from de Python vous permet d'importer une partie spécifiée d'un module dans l'espace de noms courant. La syntaxe est la suivante :
from modname import name1[, name2[, ... nameN]]
Par exemple, pour importer la fonction fib depuis le module fibo, 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 n'importe pas tout le module fibo dans l'espace de noms courant ; elle importe uniquement la fonction fib depuis fibo.
Attribution d'alias aux modules
Utilisez le mot-cléaspour attribuer un alias à un module ou à une fonction :
import numpy as np # 将 numpy 模块别名设置为 np from math import sqrt as square_root # 将 sqrt 函数别名设置为 square_root
instruction from ... import *
Il est également possible d'importer tout le contenu d'un module dans l'espace de noms courant, utilisez simplement la déclaration suivante :
from modname import *
Cela fournit un moyen simple d'importer tous les éléments d'un module.
Non recommandé, car cela peut facilement provoquer des conflits de noms.
Plongée approfondie dans les modules
En plus des définitions de méthodes, un module peut également inclure du code exécutable. Ce code est généralement utilisé pour initialiser le module. Il n'est exécuté que lorsque le module est importé pour la première fois.
Chaque module possède sa propre table de symboles indépendante, qui est utilisée comme table de symboles globale pour toutes les fonctions du module.
Par conséquent, les auteurs de modules peuvent utiliser ces variables globales dans le module en toute sécurité, sans craindre de les confondre avec les variables globales d'autres utilisateurs.
En revanche, lorsque vous savez vraiment ce que vous faites, vous pouvez également accéder aux fonctions du module en utilisant une notation comme modname.itemname.
Les modules peuvent importer d'autres modules. Utilisez import en haut d'un module (ou d'un script, ou ailleurs) pour importer un module. Bien sûr, ce n'est qu'une convention, pas une obligation. Le nom du module importé sera placé dans la table de symboles du module en cours d'exploitation.
Il existe une autre façon d'importer : vous pouvez utiliser import pour importer directement des noms (fonctions, variables) d'un module dans le module en cours d'exploitation. 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 d'importation ne place pas le nom du module importé dans la table de symboles actuelle (donc dans cet exemple, le nom fibo n'est pas défini).
Il existe encore une autre méthode qui peut importer tous les noms (fonctions, variables) d'un module dans la table de symboles du module actuel en une seule fois :
>>> from fibo import * >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377
Cela importera tous les noms, mais les noms commençant par un seul underscore (_) ne sont pas inclus. Dans la plupart des cas, les programmeurs Python n'utilisent pas cette méthode, car les noms importés d'autres sources peuvent remplacer des définitions existantes.
Attribut __name__
Lorsqu'un module est importé pour la première fois par un autre programme, son programme principal s'exécute.
Si nous voulons qu'un certain bloc de code du module ne s'exécute pas lorsque le module est importé, nous pouvons utiliser l'attribut__name__pour que ce bloc ne s'exécute que lorsque le module lui-même est exécuté.
#!/usr/bin/python3
# Filename: using_name.py
if __name__ == '__main__':
print('程序自身在运行')
else:
print('我来自另一模块')
La sortie d'exécution est la suivante :
$ python using_name.py 程序自身在运行
$ python >>> import using_name 我来自另一模块 >>>
Explication : chaque module possède un attribut __name__.
Si le module est exécuté directement,
__name__sa valeur est__main__。Si le module est importé,
__name__sa valeur est le nom du module.
Remarque :__name__et__main__Il y a des doubles tirets bas en dessous,_ _c'est pour supprimer l'espace entre les deux.
Fonction dir()
La fonction intégrée dir() peut trouver tous les noms définis dans un module. Elle les renvoie sous forme de liste de chaînes de caractères :
>>> 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 n'est donné, la fonction dir() liste tous les noms 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'] >>>
Modules standard
Python lui-même est livré avec quelques bibliothèques de modules standard, qui seront présentées dans la référence de la bibliothèque Python (c'est-à-dire la « Library Reference » plus tard).
| Nom du module | Description |
|---|---|
math | Opérations mathématiques (telles que la racine carrée, les fonctions trigonométriques, etc.) |
os | Fonctions liées au système d'exploitation (telles que les opérations sur les fichiers et les répertoires) |
sys | Paramètres et fonctions liés au système |
random | Générer des nombres aléatoires |
datetime | Gérer les dates et les heures |
json | Traiter les données JSON |
re | Opérations sur les expressions régulières |
collections | Fournir des structures de données supplémentaires (telles que defaultdict, deque) |
itertools | Fournir des outils pour les itérateurs |
functools | Outils de fonctions d'ordre supérieur (tels que reduce, lru_cache) |
Certains modules sont intégrés directement à l'interpréteur. Bien qu'il ne s'agisse pas de fonctionnalités intégrées du langage, ils peuvent être utilisés très efficacement, même pour des appels au niveau système.
Ces composants sont configurés différemment selon le système d'exploitation. Par exemple, le module winreg n'est fourni que sur les systèmes Windows.
Notez qu'il existe un module spécial, sys, qui est intégré à chaque interpréteur Python. Les variables sys.ps1 et sys.ps2 définissent les chaînes correspondant aux invites principale et secondaire :
>>> import sys
>>> sys.ps1
'>>> '
>>> sys.ps2
'... '
>>> sys.ps1 = 'C> '
C> print('Example!')
Example!
C>
Paquet
Les paquets sont une façon de gérer les espaces de noms de modules Python, en utilisant des « noms de modules pointés ».
Par exemple, si le nom d'un module est A.B, alors il représente un sous-module B dans un paquet A.
Tout comme avec les modules, vous n'avez pas à vous soucier des variables globales qui s'affectent mutuellement entre différents modules ; l'utilisation de noms de modules pointés signifie aussi que vous n'avez pas à vous soucier des modules portant le même nom entre différentes bibliothèques.
De cette façon, différents auteurs peuvent fournir des modules NumPy, ou des bibliothèques graphiques Python.
Supposons que vous souhaitiez concevoir un ensemble de modules (ou un « paquet ») pour traiter uniformément des fichiers audio et des données.
Il existe de nombreux formats de fichiers audio différents (essentiellement distingués par leurs suffixes, par exemple : .wav, :file:.aiff, :file:.au,), vous avez donc besoin d'un ensemble toujours plus grand de modules pour convertir entre les différents formats.
Et pour ces données audio, il existe aussi de nombreuses opérations différentes (comme le mixage, l'ajout d'écho, l'ajout de fonctions d'égaliseur, la création d'effets stéréo artificiels), vous avez donc aussi besoin d'un ensemble sans fin de modules pour gérer ces opérations.
Voici une structure de paquet 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
...
Lors de l'importation d'un paquet, Python recherche dans les répertoires de sys.path pour trouver les sous-répertoires contenus dans le paquet.
Un répertoire n'est reconnu comme un paquet que s'il contient un fichier appelé __init__.py. Cela sert principalement à empêcher certains noms trop courants (comme string) d'affecter accidentellement des modules valides dans le chemin de recherche.
Dans le cas le plus simple, placez simplement un fichier :file:__init__.py vide. Bien sûr, ce fichier peut aussi contenir du code d'initialisation ou attribuer une valeur à la variable __all__ (présentée plus loin).
Les utilisateurs peuvent importer uniquement un module spécifique d'un paquet à la fois, par exemple :
import sound.effects.echo
Ceci importera le sous-module : sound.effects.echo. Il doit être accédé en utilisant son nom complet :
sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)
Il existe une autre façon d'importer un sous-module :
from sound.effects import echo
Ceci importera également le sous-module : echo, et cela ne nécessite pas ces longs préfixes, donc il peut être utilisé comme ceci :
echo.echofilter(input, output, delay=0.7, atten=4)
Une autre variante consiste à importer directement une fonction ou une variable :
from sound.effects.echo import echofilter
De même, cette méthode importera le sous-module : echo, et vous pouvez directement utiliser sa fonction echofilter() :
echofilter(input, output, delay=0.7, atten=4)
Notez que lorsque vous utilisezfrom package import itemsous cette forme, l'élément correspondant peut être soit un sous-module (sous-paquet) dans le paquet, soit d'autres noms définis dans le paquet, comme des fonctions, des classes ou des variables.
L'instruction import traite d'abord item comme un nom défini dans le paquet. S'il n'est pas trouvé, elle tente alors de l'importer en tant que module. S'il n'est toujours pas trouvé, elle lève une:exc:ImportErrorexception.
Inversement, si vous utilisez une forme commeimport item.subitem.subsubitemdans cette forme d'importation, tout sauf le dernier élément doit être un paquet, et le dernier élément peut être un module ou un paquet, mais il ne peut pas être le nom d'une classe, d'une fonction ou d'une variable.
Importation de * depuis un paquet
Si nous utilisonsfrom sound.effects import *, que va-t-il se passer ?
Python va entrer dans le système de fichiers, trouver tous les sous-modules du paquet et les importer tous un par un.
Mais cette méthode ne fonctionne pas très bien sur la plate-forme Windows, car Windows est un système insensible à la casse.
Sous Windows, nous ne pouvons pas déterminer si un fichier appelé ECHO.py est importé en tant que module nommé echo, Echo ou ECHO.
Pour résoudre ce problème, il nous suffit de fournir un index de paquet explicite.
L'instruction d'import suit cette règle : si le fichier de définition du paquet __init__.pycontient une variable de liste appelée__all__alors lors de l'utilisation defrom package import *tous les noms de cette liste sont importés comme contenu du paquet.
En tant qu'auteur du paquet, n'oubliez pas de vous assurer qu'après la mise à jour du paquet,__all__est également mis à jour.
L'exemple suivant contient le code suivant dans le fichier : sounds/effects/__init__.py:
__all__ = ["echo", "surround", "reverse"]
Cela signifie que lorsque vous utilisez from sound.effects import *, vous n'importerez que ces trois sous-modules du paquet.
Si__all__n'est vraiment pas défini, alors utiliserfrom sound.effects import *avec cette syntaxe n'importera aucun sous-module du paquet sound.effects. Cela importe uniquement le paquet sound.effects et tout le contenu qui y est défini (exécutant éventuellement le code d'initialisation défini dans __init__.py).
Cela importera tous les noms définis dans __init__.py. Et cela ne cassera aucun des modules explicitement spécifiés que nous avons importés avant cette instruction. Jetez un œil à cette partie du code :
import sound.effects.echo import sound.effects.surround from sound.effects import *
Dans cet exemple, avant d'exécuter from...import, les modules echo et surround du paquet sound.effects ont déjà été importés dans l'espace de noms courant. (Bien sûr, si __all__ est défini, il n'y a aucun problème.)
Habituellement, nous ne recommandons pas d'utiliser*cette méthode pour importer des modules, car elle réduit souvent la lisibilité du code. Cependant, elle peut effectivement économiser beaucoup de frappe, et certains modules sont conçus pour être importés uniquement via des méthodes spécifiques.
Rappelez-vous, utiliserfrom Package import specific_submodulecette méthode n'est jamais incorrecte. En fait, c'est aussi la méthode recommandée. À moins que le sous-module que vous souhaitez importer puisse avoir le même nom qu'un sous-module dans un autre paquet.
Si le paquet est un sous-paquet dans la structure (par exemple, dans ce cas pour le paquet sound), et que vous souhaitez importer un paquet frère (un paquet au même niveau), vous devez utiliser un chemin absolu pour l'importer. Par exemple, si le module sound.filters.vocoder veut utiliser le module echo du paquet sound.effects, vous devez écrire from sound.effects import echo.
from . import echo from .. import formats from ..filters import equalizer
Les imports relatifs implicites et explicites partent du module courant. Le nom du module principal est toujours "__main__". Le module principal d'une application Python doit toujours utiliser des références par chemin absolu.
Les paquets fournissent également un attribut supplémentaire __path__. Il s'agit d'une liste de répertoires, où chaque répertoire contenant possède un __init__.py qui sert ce paquet. Vous devez le définir avant que les autres fichiers __init__.py soient exécutés. Cette variable peut être modifiée pour affecter les modules et sous-paquets contenus dans le paquet.
Cette fonctionnalité n'est pas couramment utilisée ; elle sert généralement à étendre les modules d'un paquet.
Autres extensions