Module Python3
Dans les chapitres précédents, nous avons utilisé l'interpréteur Python pour programmer nos scripts. Si vous quittez puis entrez dans l'interpréteur Python, toutes les méthodes et variables que vous avez définies disparaîtront.
À cette fin, Python fournit un moyen de stocker ces définitions dans un fichier destiné à être utilisé par certains scripts ou instances d'interpréteur interactif. Ce fichier est appelé module.
Un module est un fichier qui contient toutes les fonctions et variables que vous définissez, et son suffixe est .py. Les modules peuvent être importés par d'autres programmes pour utiliser des fonctions et d'autres fonctions du module. Cela se fait également à l'aide de la bibliothèque standard Python.
Ce qui suit est un exemple utilisant des modules de la bibliothèque standard Python.
#!/usr/bin/python3
# 文件名: using_sys.py
import sys
print('命令行参数如下:')
for i in sys.argv:
print(i)
print('\n\nPython 路径为：', sys.path, '\n')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 introduit le module sys.py dans la bibliothèque standard python ; certain module.
2. sys.argv est une liste contenant des paramètres de ligne de commande.
3. sys.path contient une liste de chemins où l'interpréteur Python trouve automatiquement les modules requis.
instruction d'importation
Si vous souhaitez utiliser un fichier source Python, exécutez simplement l'instruction d'importation dans un autre fichier source. La syntaxe est la suivante :
import module1[, module2[,... moduleN]
Lorsque l'interpréteur rencontre une instruction d'importation, 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 dans lesquels l'interprète recherchera en premier. Si vous souhaitez importer le module de support, vous devez mettre la commande en haut du script :
support.py Le code du fichier est :
#!/usr/bin/python3
# Filename: support.py
def print_func( par ):
print ("Hello : ", par)
returntest.py Présentez le module de support :
#!/usr/bin/python3
# Filename: test.py
# 导入模块
import support
# 现在可以调用模块里包含的函数了
support.print_func("php")Le résultat de sortie de l'exemple ci-dessus :
$ python3 test.py Hello : php
Un module ne sera importé qu'une seule fois, quel que soit le nombre de fois que vous exécutez l'importation. Cela empêche les modules importés d'être exécutés encore et encore.
Quand on utilise 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 composé d'une série de noms de répertoires. L'interpréteur Python recherche tour à tour les modules importés de ces répertoires.
Cela ressemble beaucoup à des variables d'environnement. En fait, le chemin de recherche peut également être déterminé en définissant des variables d'environnement.
Le chemin de recherche est déterminé lors de la compilation ou de l'installation de Python, et il doit également être modifié lors de l'installation de nouvelles bibliothèques. Le chemin de recherche est stocké dans la variable path du module sys. Pour faire une expérience simple, dans l'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 La sortie est une liste où se trouve le premier élément. vide La chaîne '' représente le répertoire courant (s'il est imprimé à partir d'un script, vous pouvez voir plus clairement de quel répertoire il s'agit), c'est-à-dire le répertoire où l'on exécute l'interpréteur python (pour les scripts, c'est le répertoire où le le script en cours d'exécution est localisé).
Donc si comme moi il y a un fichier du même nom que le module à importer dans le répertoire courant, le module à importer sera bloqué.
Après avoir compris le concept de chemin de recherche, vous pouvez modifier sys.path dans le script pour introduire certains modules qui ne sont pas dans le chemin de recherche.
Maintenant, créez un fichier fibo.py dans le répertoire courant de l'interpréteur ou un répertoire dans sys.path Le code est le suivant :
# 斐波那契(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
Entrez ensuite dans l'interpréteur Python et utilisez la commande suivante pour importer ce module :
>>> import fibo
Cela n'écrit pas le nom de la fonction directement défini dans fibo dans la table des symboles actuelle, mais ajoute uniquement le module fibo. le nom y est écrit.
Les fonctions sont accessibles en utilisant le nom du module :
>>> 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 prévoyez d'utiliser fréquemment une fonction, vous pouvez lui attribuer un nom local :
>>> fib = fibo.fib >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377
from...import instruction
L'instruction from de Python vous permet d'importer une partie spécifiée du module dans l'espace de noms actuel :
from modname import name1[, name2[, ... nameN]]
Par exemple, pour importer. la fonction fibo du module fib, utilisez l'instruction suivante :
from fibo import fib
Cette déclaration n'importera pas l'intégralité du module fib dans l'espace de noms actuel, elle introduira uniquement un seul fibonacci dans fib dans la table des symboles globale du module qui exécute cette déclaration.
Instruction From…import*
Il est également possible d'importer tout le contenu d'un module dans l'espace de noms courant, utilisez simplement l'instruction suivante :
from modname import *
Cela fournit un moyen simple d'importer tous les projets dans un module. Il ne faut cependant pas abuser de cette affirmation.
Modules approfondis
En plus des définitions de méthodes, les modules peuvent également inclure du code exécutable. Ces codes sont généralement utilisés pour initialiser ce module. Ce code ne sera exécuté que lors de sa première importation.
Chaque module possède sa propre table de symboles indépendante, qui est utilisée comme table de symboles globale pour toutes les fonctions à l'intérieur du module.
Ainsi, l'auteur du module peut utiliser en toute sécurité ces variables globales à l'intérieur du module sans se soucier de jouer avec les variables globales des autres utilisateurs.
D'un autre côté, si vous savez vraiment ce que vous faites, vous pouvez également accéder aux fonctions du module via une notation telle que modname.itemname. Les modules
peuvent importer d'autres modules. Utiliser import au début d'un module (ou d'un script, ou ailleurs) pour importer un module n'est bien sûr qu'une convention, pas une exigence. Le nom du module importé sera placé dans la table des symboles du module actuellement opérationnel.
Il existe également une méthode d'importation. Vous pouvez utiliser import pour importer directement les noms (des fonctions et des variables) du module dans le module d'opération 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 d'import ne mettra pas le nom du module importé dans la table de caractères courante (donc dans cet exemple, le nom fibo n'est pas défini).
Il existe une autre façon d'importer tous les noms (fonctions, variables) du module dans la table de caractères 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 importés, sauf les noms commençant par un seul trait de soulignement (_). Dans la plupart des cas, les programmeurs Python n'utilisent pas cette méthode, car l'introduction de noms provenant d'autres sources risque d'écraser les définitions existantes.
Attribut __name__
Lorsqu'un module est introduit pour la première fois par un autre programme, son programme principal s'exécutera. Si nous voulons qu'un certain bloc de programme dans le module ne soit pas exécuté lorsque le module est importé, nous pouvons utiliser l'attribut __name__ pour que le bloc de programme 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('我来自另一模块')Le résultat en cours d'exécution est le suivant :
$ python using_name.py
Le programme lui-même est en cours d'exécution
$ python >>> import using_name 我来自另一模块 >>>
Explication : Chaque module a un attribut __name__ Lorsque sa valeur est '__main__', cela indique que le module lui-même est en cours d'exécution. est importé.
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 paramètre n'est donné, la fonction dir() listera 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'] >>>
Standard modules
Python lui-même est livré avec certaines bibliothèques de modules standard, qui seront introduites dans le document de référence de la bibliothèque Python (c'est-à-dire le "Document de référence de la bibliothèque" plus tard).
Certains modules sont intégrés directement dans l'analyseur. Bien qu'il ne s'agisse pas de fonctions intégrées dans certains langages, ils peuvent être utilisés très efficacement, et même les appels au niveau système ne posent aucun problème.
Ces composants seront configurés de différentes manières selon les différents systèmes d'exploitation. Par exemple, le module winreg ne sera fourni que pour les systèmes Windows.
Il convient de noter qu'il existe un module spécial sys qui est intégré à chaque analyseur Python. Les variables sys.ps1 et sys.ps2 définissent les chaînes correspondant à l'invite principale et à l'invite secondaire :
>>> import sys
>>> sys.ps1
'>>> '
>>> sys.ps2
'... '
>>> sys.ps1 = 'C> '
C> print('Yuck!')
Yuck!
C>Package
Package est un moyen de gérer l'espace de noms du module Python Form, en prenant le "nom du module point".
Par exemple, le nom d'un module est A.B, alors il représente un sous-module B dans le package A.
Tout comme lorsque vous utilisez des modules, vous n'avez pas à vous soucier de l'influence mutuelle des variables globales entre les différents modules. En utilisant le format de nom de module point, vous n'avez pas à vous soucier de la duplication des noms de module. entre différentes bibliothèques.
De cette manière, différents auteurs peuvent fournir des modules NumPy ou des bibliothèques graphiques Python.
Supposons que vous souhaitiez concevoir un module (ou l'appeler un « package ») qui gère les fichiers audio et les données de manière unifiée.
Il existe de nombreux formats de fichiers audio différents (essentiellement distingués par des noms de suffixes, tels que : .wav, :file:.aiff, :file:.au,), vous devez donc avoir un ensemble de constantes ajoutées module de conversion entre différents formats.
Et il existe de nombreuses opérations différentes pour ces données audio (telles que le mixage, l'ajout d'écho, l'ajout de fonctions d'égalisation, la création d'effets stéréo artificiels), vous avez donc besoin d'un ensemble de modules que vous ne pourrez jamais finir d'écrire. 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 ...
Lors de l'importation d'un package, Python se basera sur le répertoire dans sys.path Rechercher les sous-répertoires contenus dans ce package . Le répertoire
ne sera reconnu comme un package que s'il contient un fichier appelé __init__.py Ceci est principalement pour éviter que certains noms clichés (comme la chaîne) n'affectent accidentellement les modules valides dans le chemin de recherche.
Dans le cas le plus simple, mettez simplement un :file:__init__.py vide. Bien entendu, ce fichier peut également contenir du code d'initialisation ou attribuer des valeurs à la variable __all__ (à présenter ultérieurement).
Les utilisateurs ne peuvent importer que des modules spécifiques dans un package à la fois, par exemple :
import sound.effects.echo
Cela importera le sous-module : mod:song.effects.echo. Il doit utiliser son nom complet pour accéder :
sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)
Il existe également un moyen d'importer des sous-modules :
from sound.effects import echo
Cela importera également le sous-module : mod:echo, et il n'a pas besoin de ces longs préfixes, il peut donc ê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 :mod:echo, et vous pourrez directement utiliser sa fonction :func:echofilter :
echofilter(input, output, delay=0.7, atten = 4)
Notez que lors de l'utilisation d'un élément d'importation à partir d'un package, l'élément correspondant peut être un sous-module (sous-package) dans le package, ou d'autres noms définis dans le package, tels que des fonctions, des classes ou des variables.
La syntaxe d'importation traitera d'abord l'élément comme le nom d'une définition de package. S'il n'est pas trouvé, elle essaiera de l'importer en tant que module. S'il n'a pas encore été trouvé, félicitations, une exception :exc:ImportError a été levée.
Au contraire, si vous utilisez le formulaire d'import tel que import item.subitem.subsubitem, à l'exception du dernier élément, tous doivent être des packages, et le dernier élément peut être un module ou un package, mais il ne peut pas être une classe, le nom de la fonction ou de la variable.
Importer * depuis un package
Imaginez ce qui se passerait si nous utilisions from sound.effects import * ?
Python entrera dans le système de fichiers, trouvera tous les sous-modules de ce package et les importera un par un.
Mais malheureusement, cette méthode ne fonctionne pas très bien sur la plateforme Windows, car Windows est un système insensible à la casse.
Sur ce type de plateforme, personne n'ose garantir qu'un fichier appelé ECHO.py soit importé en tant que module :mod:echo ou :mod:Echo ou encore :mod:ECHO.
(Par exemple, Windows 95 met en majuscule la première lettre de chaque fichier) et la règle de dénomination 8+3 du DOS rend le problème encore plus compliqué lorsqu'il s'agit de noms de modules longs.
Afin de résoudre ce problème, nous pouvons uniquement demander à l'auteur du package de fournir un index précis du package.
L'instruction d'importation suit les règles suivantes : Si le fichier de définition du package __init__.py a une variable de liste appelée __all__, alors lors de l'utilisation de from package import *, tous les noms de cette liste seront importés en tant que contenu du package.
En tant qu'auteur du package, n'oubliez pas de vous assurer que __all__ est également mis à jour après la mise à jour du package. Vous avez dit que je ne ferai pas ça, que je n'utiliserai pas import*, d'accord, pas de problème, qui fait de vous le patron. Voici un exemple, file:sounds/effects/__init__.py contient le code suivant :
__all__ = ["echo", "surround", "reverse"]
Cela signifie que lorsque vous utilisez from sound.effects import * this Lors de l'utilisation cela, vous importerez uniquement ces trois sous-modules dans le package.
Si __all__ est vrai mais n'est pas défini, alors l'utilisation de la syntaxe de sound.effects import * n'importera *pas* aucun sous-module dans le package : mod:sound.effects. Il importe simplement le package :mod:sound.effects et tout ce qui y est défini (éventuellement en exécutant le code d'initialisation défini dans :file:__init__.py).
Cela importera tous les noms définis dans :file:__init__.py. Et cela ne détruira pas tous les modules explicitement spécifiés que nous avons importés avant cette phrase. 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 de package:mod:sound.effects sont importés dans l'espace de noms actuel. (Bien sûr, ce ne serait pas un problème si __all__ était défini)
Habituellement, nous ne préconisons pas d'utiliser * cette méthode pour importer des modules, car cette méthode conduit souvent à une lisibilité réduite du code. Cependant, cela permet d'économiser beaucoup de frappes au clavier et certains modules sont conçus pour être importés uniquement via des méthodes spécifiques.
N'oubliez pas que vous ne pouvez jamais vous tromper en utilisant from Package import Specific_submodule. En fait, c’est l’approche recommandée. Sauf si le sous-module que vous souhaitez importer peut avoir le même nom qu'un sous-module d'un autre package.
Si le package est un sous-package dans la structure (comme dans cet exemple pour le package : mod:sound), et que vous souhaitez importer un package frère (un package de même niveau), vous devez utiliser le chemin absolu d’importation pour importer. Par exemple, si le module :mod:sound.filters.vocoder souhaite utiliser le module :mod:echo du package :mod:sound.effects, vous écrivez depuis sound.effects import echo.
from . import echo from .. import formats from ..filters import equalizer
Les importations relatives, qu'elles soient implicites ou explicites, démarrent à partir du module courant. Le nom du module principal est toujours "__main__". Le module principal d'une application Python doit toujours être référencé à l'aide d'un chemin absolu.
Le package fournit également un attribut supplémentaire, :attr:__path__. Il s'agit d'une liste de répertoires. Chaque répertoire qu'il contient contient un :file:__init__.py qui sert ce package. Vous devez définir un autre :file:__init__.py avant son exécution. Cette variable peut être modifiée pour affecter les modules et sous-packages contenus dans le package.
Cette fonction n'est pas couramment utilisée et est généralement utilisée pour étendre les modules du package.
