Tutoriel de base Python 2.7 : modules

.. _tut-modules :

************************

Module Modules

*********************

Si vous quittez l'interpréteur Python et que vous le saisissez à nouveau, les définitions que vous

les fonctions et variables créées sont perdues. Par conséquent, si vous souhaitez écrire un

programme un peu plus long, il est préférable d'utiliser un éditeur de texte pour préparer l'entrée

pour le. interprète et l'exécuter avec ce fichier en entrée à la place.

est connu sous le nom de création d'un *script*. À mesure que votre programme s'allonge, vous souhaiterez peut-être

le diviser en plusieurs fichiers pour plus de facilité. maintenance. Vous souhaiterez peut-être également utiliser une

fonction pratique que vous avez écrite dans plusieurs programmes sans copier sa

définition dans chaque programme.

Si vous quittez Quand le L'interpréteur Python rentre, toutes les définitions créées précédemment (variables et fonctions) seront perdues. Par conséquent, si vous souhaitez écrire des programmes qui seront enregistrés pendant une longue période, il est préférable d'utiliser un éditeur de texte pour

écrire le programme et saisir le fichier enregistré dans l'interpréteur. Nous appelons cela créer un *script*. Soit le programme

devient plus long, et vous pouvez le séparer en plusieurs fichiers pour une maintenance plus facile. Vous souhaiterez peut-être également utiliser une fonction commune dans plusieurs

programmes, mais vous ne souhaitez pas copier sa définition dans chaque programme.

Pour prendre en charge cela, Python dispose d'un moyen de mettre des définitions dans un fichier et de les utiliser dans un

script ou dans une instance interactive de l'interpréteur. Un tel fichier est appelé un

.

*module* ; les définitions d'un module peuvent être *importées* dans d'autres modules ou dans

le module *principal* (l'ensemble des variables auxquelles vous avez accès dans un

script exécuté au niveau supérieur et en mode calculatrice).

Pour répondre à ces besoins, Python fournit une méthode pour obtenir des définitions à partir d'un fichier, dans un script ou une partie interactive de l'

interpréteur utilisé dans les exemples. Un tel fichier est appelé un *module* ; les définitions d'un module peuvent être *importées*

dans un autre module ou dans le module principal (l'ensemble des variables qui peuvent être appelées lors de l'exécution du script se trouve dans le le plus avancé, et

en mode calculatrice).

Un module est un fichier contenant des définitions et des instructions Python. Le nom du fichier

est le nom du module avec le suffixe :file:`.py` ajouté dans un module.

le nom du module (sous forme de chaîne) est disponible comme valeur de la variable globale

``__name__`` Par exemple, utilisez votre éditeur de texte préféré pour créer un fichier

appelé. :file:`fibo.py` dans le répertoire courant avec le contenu suivant :

Un module est un fichier qui contient des définitions et des déclarations Python. Le nom du fichier est le nom du module plus le suffixe :file:`.py`. Le nom du module (sous forme de chaîne) du bloc module

peut être obtenu à partir de la variable globale ``__name__``. Par exemple, vous pouvez

utiliser votre éditeur de fichiers préféré pour créer un fichier appelé :file:`fibo.py` dans le répertoire courant et saisir le

contenu suivant ::

# Module de nombres de Fibonacci

def fib(n) : # écrire des séries de Fibonacci jusqu'à n

a, b = 0, 1

tandis que b <

                                                                                                                                                                                                                                                       ]

a, b = 0, 1

while b < n :

result.append(b)

a, b = b, a b

return result

Entrez maintenant dans l'interpréteur Python et importez ce module avec la commande suivante

:

Entrez maintenant le Interpréteur Python et importez ce module avec la commande suivante Import this module ::

>>> import fibo

Cela ne saisit pas les noms des fonctions définies dans ``fibo` ` directement dans

la table des symboles actuelle ; il y entre uniquement le nom du module ``fibo`` En utilisant

le nom du module, vous pouvez accéder aux fonctions :

Ceci. ne saisira pas directement ``fibo`` La fonction importe la table sémantique actuelle ; elle importe simplement le nom du module

``fibo``. Vous pouvez accéder à cette fonction via le nom du module comme suit : :

>>> 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 lui attribuer un nom local :

Si vous souhaitez appeler la fonction directement, vous pouvez généralement lui donner un nom local ::

>>> fib = fibo.fib

>>> ; fib(500)

1 1 2 3 5 8 13 21 34 55 89 144 233 377

.. _tut-moremodules :

En savoir plus sur les modules module approfondi

==============================

Un module peut contenir des instructions exécutables ainsi que des définitions de fonctions .

Ces instructions sont destinées à initialiser le module. Elles sont exécutées uniquement

la *première* fois que le module est importé quelque part [#]_

Le module peut. être comme Les définitions de fonctions contiennent également des instructions d'exécution. Ces instructions sont généralement utilisées pour initialiser les modules. Ils ne sont exécutés

qu'une seule fois lors de la *première* importation du module. [#]_

Chaque module possède sa propre table de symboles privée, qui est utilisée comme table de symboles globale

par toutes les fonctions définies dans le module Ainsi, l'auteur d'un module peut<.>

utilisez des variables globales dans le module sans vous soucier des conflits accidentels

avec les variables globales d'un utilisateur. Par contre, si vous savez ce que vous faites

vous pouvez toucher un. les variables globales du module avec la même notation utilisée pour

faire référence à ses fonctions, ``modname.itemname``.

correspond à la table sémantique globale qui définit toutes les fonctions de chaque module. a sa propre table sémantique privée. Par conséquent

donc, l'auteur du module peut utiliser certaines variables globales dans le module sans provoquer d'erreurs

dues à des conflits avec les variables globales de l'utilisateur. D'un autre côté, si vous êtes sûr d'en avoir besoin, vous pouvez accéder aux variables globales du module tout comme vous référencez des fonctions dans le module, comme ceci : ``modname.itemname``.

Les modules peuvent importer d'autres modules. Il est d'usage mais pas obligatoire de placer toutes les instructions

:keyword:`import` au début d'un module (ou d'un script, pour cela

matter). Les noms des modules importés sont placés dans la table de symboles globale

du module importateur.

le module peut importer ( :keyword:`import` ) d'autres modules. Il est d'usage de placer toutes les instructions d'importation au début d'un module (ou d'un

script, etc.), mais ce n'est pas obligatoire. Le nom du module importé est renseigné dans la syntaxe globale

de ce module.

Il existe une variante de l'instruction :keyword:`import` qui importe les noms d'un

module directement dans la table des symboles du module d'importation. Par exemple :

:keyword. Une variante de l'instruction :`import` importe les noms directement du module importé dans la table sémantique du module.

Par exemple ::

>>> de fibo import fib, fib2

>>> 1 1 2 3 5 8 13 21 34 55 89 144 233 377

Cela n'introduit pas le nom du module à partir duquel les importations sont prises dans la

table des symboles locaux (donc dans l'exemple, ` `fibo`` n'est pas défini).

Cela n'importera pas le nom du module de la table sémantique locale (comme indiqué ci-dessus, `fibo`` n'est pas défini).

Il existe même une variante pour importer tous les noms qu'un module définit :

; from fibo import *

>>>

1 1 2 3 5 8 13 21 34 55 89 144 233 377

Ceci importe tous les noms sauf ceux commençant par un trait de soulignement (``_``).

Cela importera tous les noms sauf ceux commençant par un trait de soulignement (``_``).

Notez qu'en général, la pratique consistant à importer ``*`` à partir d'un module ou d'un package est

mal vue, car elle entraîne souvent un code peu lisible. Cependant, il est acceptable de

utilisez-le pour économiser la saisie dans les sessions interactives.

Il est à noter qu'en pratique, il est souvent déconseillé d'utiliser ``*`` pour tout importer depuis un module ou un package, car

Cela rend le code difficile à lire. Cependant, il est pratique et facile à utiliser dans les sessions interactives.

.. note ::

.. [#] Pour des raisons d'efficacité, chaque module n'est importé qu'une seule fois par interprète

Par conséquent, si vous modifiez vos modules, vous devez redémarrer l'interpréteur

-- ou, s'il ne s'agit que d'un module que vous souhaitez tester de manière interactive,

utilisez :func:`reload`, par exemple ``reload(modulename)``.

.. [#] Pour des raisons de performances, chaque module n'est importé qu'une seule fois par session d'interprète. Par conséquent, si vous modifiez

votre module, vous devez redémarrer l'interpréteur - ou, si vous souhaitez simplement tester un tel module de manière interactive, vous pouvez utiliser :func:` reload` Reload, tel que ``reload (nom du module)``.

.. _tut-modulesasscripts :

Exécuter des modules sous forme de scripts

---------------- ------ ----------------------------

Lorsque vous exécutez un module Python avec :

Utilisez le méthode suivante pour exécuter un module Python : :

python fibo.py

le code du module sera exécuté, comme si vous l'aviez importé, mais avec

le ``__name__`` défini sur ``"__main__"`` Cela signifie qu'en ajoutant ce code à

à la fin de votre module :

module Le code sera exécuté comme s'il était importé, mais maintenant ``__name__`` est défini sur

``"__main__"``. Cela équivaut à si vous ajoutez le code suivant après le module ::

if __name__ == "__main__":

import sys

fib(int(sys.argv[1]))

vous pouvez rendre le fichier utilisable comme script ainsi que comme module importable,

Parce que le code qui analyse la ligne de commande ne s'exécute que si le module est

exécuté en tant que fichier "principal":

permet à ce fichier d'être exécuté en tant que script tout comme lorsqu'il est importé en tant que fichier module. Ce code n'est appelé que lorsque le module est exécuté en tant que

fichier "principal"::

$ python fibo.py 50

1 1 2 3 5 8 13 21 34

Si le module est importé, le code n'est pas exécuté :

Si le module est importé, ce code ne sera pas exécuté ::

>>> ; importer fibo

>>>

Ceci est souvent utilisé soit pour fournir une interface utilisateur pratique à un module, soit

à des fins de test (exécution du module car un script exécute une suite de tests).

Ceci est généralement utilisé pour fournir une interface utilisateur au module afin de faciliter les tests (en utilisant le module comme script pour exécuter les exigences de test).

.. _tut-searchpath :

Le chemin de recherche du module Chemin de recherche du module

------------------ - -------------------------

.. index:: triple: module search;path

Quand un module nommé :mod:`spam` est importé, l'interpréteur recherche un fichier

nommé :file:`spam.py` dans le répertoire courant, puis dans la liste des

répertoires spécifiés par la variable d'environnement :envvar:`PYTHONPATH`. Ceci

a la même syntaxe que la variable shell :envvar:`PATH`, c'est-à-dire une liste de

noms de répertoires. Lorsque :envvar:`PYTHONPATH` n'est pas défini, ou lorsque le fichier n'y est pas

trouvé, la recherche continue dans un chemin par défaut dépendant de l'installation sous

Unix, il s'agit généralement de : file:`.:/usr/local/lib/python`.

Lors de l'importation d'un module appelé :mod:`spam`, l'interpréteur recherche d'abord le nom

:file:`spam.py`, puis recherchez dans la liste des répertoires

représentés par la variable d'environnement :envvar:`PYTHONPATH`, puis dans la liste des chemins dans la variable d'environnement :envvar:`PATH `. Si

:envvar:`PYTHONPATH` n'est pas défini ou si le fichier n'est pas trouvé, recherchez dans le répertoire d'installation,

Sous Unix, il s'agit généralement de :file:`.:/usr /local/ lib/python` .

En fait, les modules sont recherchés dans la liste des répertoires donnée par la variable

``sys.path`` qui est initialisée à partir du répertoire contenant le script d'entrée

( ou le répertoire actuel), :envvar:`PYTHONPATH` et la valeur par défaut

dépendante de l'installation. Cela permet aux programmes Python qui savent ce qu'ils font de modifier ou

remplacer le chemin de recherche du module. . Notez que comme le répertoire contenant le

script en cours d'exécution se trouve sur le chemin de recherche, il est important que le script n'ait pas

le même nom qu'un module standard, sinon Python tentera de le faire. charger le script en tant que

module lorsque ce module est importé. Ce sera généralement une erreur Voir

section :ref:`tut-standardmodules` pour plus d'informations.

En fait, l'interpréteur recherche les modules dans le répertoire path spécifié par la variable ``sys.path``, qui contient le script d'entrée (ou le répertoire courant) par défaut à l'initialisation

, :envvar : `PYTHONPATH` et répertoire d'installation.

Cela permet aux programmes Python de savoir comment modifier ou remplacer le répertoire de recherche du module. Il est à noter que comme

ces répertoires contiennent des scripts qui sont exécutés dans le chemin de recherche, ces scripts ne doivent pas avoir le même

nom que le module standard, sinon Python tentera de les remplacer lors de l'importation du module, les scripts sont chargés en tant que modules. Cela provoque généralement

une erreur. Voir :ref:`tut-standardmodules` pour plus d'informations.

Fichiers Python "compilés" Fichiers Python "compilés"

-------------------------- -- --------------------

Comme une accélération importante du temps de démarrage pour les programmes courts qui consomment beaucoup

des modules standards, si un fichier appelé :file:`spam.pyc` existe dans le répertoire

où :file:`spam.py` est trouvé, celui-ci est supposé contenir un

Version déjà "compilée en octets" du module :mod:`spam` L'heure de modification

de la version de :file:`spam.py` utilisée pour créer :file:. `spam.pyc` est enregistré dans

:file:`spam.pyc`, et le fichier :file:`.pyc` est ignoré s'ils ne correspondent pas.

Pour faire court programmes qui font référence à un grand nombre de modules standards, il existe un moyen important d'améliorer la vitesse de démarrage s'il y a un fichier nommé :file:`spam dans le répertoire où

:file:`spam.py`. se trouve le fichier pyc`, il sera

traité comme une version pré-"compilée en octets" (compilée en octets)

du module :mod:`spam`. L'heure de modification de la version de :file:`spam.py` utilisée pour créer :file:`spam.pyc` est enregistrée dans le fichier :file:`spam.pyc`, si les deux ne correspondent pas, le :file : Le fichier`.pyc` est ignoré.

Normalement, vous n'avez rien à faire pour créer le fichier :file:`spam.pyc`.

Chaque fois que :file:`spam.py` est compilé avec succès, une tentative est fait pour écrire

la version compilée dans :file:`spam.pyc` Ce n'est pas une erreur si cette tentative

échoue si pour une raison quelconque le fichier n'est pas complètement écrit, le résultat

:file:`spam.pyc` sera reconnu comme invalide et donc ignoré ultérieurement. Le

contenu du fichier :file:`spam.pyc` est indépendant de la plate-forme, donc un Python

Le répertoire du module peut être partagé par des machines d'architectures différentes.

Habituellement, vous n'avez besoin d'effectuer aucun travail pour créer le fichier :file:`spam.pyc`. Une fois :file:`spam.py` compilé avec succès,

tentera de générer la version correspondante de :file:`spam.pyc`. Si l'écriture échoue pour une raison quelconque, le fichier :file:`spam.pyc` généré par

sera considéré comme invalide et par la suite ignoré. :file:`spam.pyc` Le contenu du fichier est indépendant de la plateforme, le répertoire du module Python peut donc être partagé entre des machines d'architectures différentes.

Quelques conseils pour les experts :

Quelques conseils avancés :

* Lorsque l'interpréteur Python est invoqué avec le drapeau :option:`-O`, optimisé

le code est généré et stocké dans les fichiers :file:`.pyo` Actuellement

n'aide pas beaucoup ; il supprime uniquement les instructions :keyword:`assert`. :option:`-O` est utilisé, *tous* :term:`bytecode` est optimisé ; les fichiers ``.pyc`` sont

ignorés et les fichiers ``.py`` sont compilés avec un bytecode optimisé .

Lors de l'appel de l'interpréteur Python avec le paramètre :option:`-O`, du code optimisé sera généré et enregistré dans le fichier :file:`.pyo`.

L'optimiseur actuel n'aide pas beaucoup ; il supprime simplement les instructions d'assertion ( :keyword:`assert` ). En utilisant le paramètre :option:`-O`, *tous* les bytecodes ( :term:`bytecode` ) seront optimisés ; les fichiers ``.pyc``

Ignorés, les fichiers ``.py`` sont compilé dans un code optimisé.

* Passer deux indicateurs :option:`-O` à l'interpréteur Python (:option:`-OO`)

amènera le compilateur de bytecode à effectuer des optimisations qui pourraient, dans de rares cas,

les cas entraînent des dysfonctionnements dans les programmes. Actuellement, seules les chaînes ``__doc__`` sont

supprimées du bytecode, ce qui donne lieu à des fichiers :file:`.pyo` plus compacts. > Certains programmes peuvent dépendre de leur disponibilité, vous ne devez utiliser cette option

que si vous savez ce que vous faites.

Passez deux:option:`-O à l'interpréteur Python. ` argument ( :option:`-OO` ) effectue une compilation binaire entièrement

optimisée, qui peut parfois générer des programmes incorrects. L'optimiseur actuel supprime uniquement la chaîne ``__doc__`` du code de la section

pour générer un fichier :file:`.pyo` plus compact. Parce que

certains programmes dépendent de la disponibilité de ces variables, vous ne devez utiliser cette option que lorsque vous en êtes sûr.

* Un programme ne s'exécute pas plus vite lorsqu'il est lu à partir d'un fichier :file:`.pyc` ou

:file:`.pyo` que lorsqu'il est lu à partir d'un :file:`.py` fichier; la seule chose

qui est plus rapide avec les fichiers :file:`.pyc` ou :file:`.pyo` est la vitesse à laquelle

ils sont chargé.

Un programme provenant d'un fichier :file:`.pyc` ou d'un fichier :file:`.pyo` ne s'exécutera pas plus rapidement qu'un programme provenant d'un

:file:` Fichier .py` Rapide ; les fichiers :file:`.pyc` ou :file:`.pyo` sont juste

plus rapides lorsqu'ils se chargent.

* Lorsqu'un script est exécuté en donnant son nom sur la ligne de commande, le bytecode de

le script n'est jamais écrit dans un :file:`.pyc` ou :file:`. pyo`. Ainsi, le

temps de démarrage d'un script peut être réduit en déplaçant la plupart de son code vers un module

et en disposant d'un petit script d'amorçage qui importe ce module.

possibilité de nommer un fichier :file:`.pyc` ou :file:`.pyo` directement sur la ligne de commande

Lors de l'exécution d'un script, le code binaire créé pour le script. n'est pas écrit dans le fichier :file:`.pyc` ou :file:`.pyo`. Bien entendu, déplacer le code principal du script dans un bloc module

, puis importer ce module avec un petit script de démarrage, peut améliorer la vitesse de démarrage du script.

Vous pouvez également spécifier un fichier :file:`.pyc` ou :file:`.pyo` directement sur la ligne de commande.

* Il est possible d'avoir un fichier appelé :file:`spam.pyc` (ou :file:`spam.pyo`

lorsque :option:`-O` est utilisé) sans fichier :file:`spam.py` pour le même module.

Cela peut être utilisé pour distribuer une bibliothèque de code Python sous une forme

modérément difficile à rétro-ingénierie.

Pour le même module (fait ici référence à la routine:file:`spam.py` - Traducteur), vous ne pouvez

avoir que:file:`spam.pyc` (ou : file:`spam.pyc`, lors de l'utilisation du paramètre

:option:`-O`) mais il n'y a pas de fichier :file:`spam.py`. De cette façon, il peut être empaqueté et publié

Une base de code Python difficile à rétro-ingénierie.

.. index:: module: compileall

* Le module :mod:`compileall` peut créer des fichiers :file:`.pyc` (ou :file:`.pyo`

fichiers lorsque :option:`-O` est utilisé) pour tous les modules d'un répertoire.

:mod:`compileall` Le module :mod:`compileall` peut créer :file:` pour tous les modules dans le répertoire spécifié.pyc`

(ou utilisez le paramètre :file:`.pyo` pour créer un fichier :file:`.pyo`).

.. _tut-standardmodules :

Modules standards Modules standards

====================== ==========

.. index:: module: sys

Python est livré avec une bibliothèque de modules standards, décrits dans un

document séparé , la référence de la bibliothèque Python ("Référence de la bibliothèque" ci-après). Certains

modules sont intégrés à l'interpréteur ; ceux-ci donnent accès à des opérations qui

ne font pas partie du noyau du langage mais sont néanmoins intégré, soit

pour plus d'efficacité, soit pour donner accès aux primitives du système d'exploitation telles que

les appels système. L'ensemble de ces modules est une option de configuration qui dépend également

. sur la plateforme sous-jacente Par exemple, le module :mod:`winreg` n'est fourni que sur les systèmes Windows. Un module particulier mérite une certaine attention :

:mod:`sys`, qui est. intégré à chaque interpréteur Python. Les variables

``sys.ps1`` et ``sys.ps2`` définissent les chaînes utilisées comme invites primaires et secondaires

Python est livré avec une bibliothèque de modules standard et publie un document indépendant appelé Python Library Reference Manual

(ci-après dénommé « Library Reference Manual »). Certains modules sont intégrés à l'interpréteur. Les interfaces d'accès à ces opérations ne font pas partie du noyau du langage, mais sont déjà intégrées à l'interpréteur. Il ne s'agit pas seulement d'améliorer l'efficacité, mais également de fournir une interface pour un accès natif au système d'exploitation tel que les appels système. Ce type de collection de modules est une option de configuration

qui dépend de la plateforme sous-jacente. Par exemple, le module :mod:`winreg` n'est disponible que sur les systèmes Windows

. Il y a un module spécifique à noter : :mod:`sys`, ce module est intégré à tous les interpréteurs

Python. Les variables sys.ps1 et sys.ps2 définissent les chaînes d'invite principale et secondaire : :

>>> import sys

>>> >

'>>> '

>>> sys.ps2

'... '

>> ;> sys.ps1 = 'C> '

C> print 'Beurk !'

Beurk !

C>

Ces deux variables ne sont définies que si l'interprète est en mode interactif.

Ces deux variables n'ont de sens que dans le mode interactif de l'interprète.

La variable ``sys.path`` est une liste de chaînes qui détermine le

chemin de recherche des modules par l'interpréteur. Elle est initialisée à un chemin par défaut tiré du

variable d'environnement :envvar:`PYTHONPATH`, ou à partir d'une valeur par défaut intégrée si

:envvar:`PYTHONPATH` n'est pas défini Vous pouvez la modifier à l'aide de la liste standard

opérations :

La variable ``sys.path`` est une liste de chaînes pour le chemin de recherche du module interpréteur. Il est initialisé par la variable d'environnement

:envvar:`PYTHONPATH` Si :envvar:`PYTHONPATH` n'est pas défini, il est initialisé par la valeur par défaut intégrée de

. Vous pouvez le modifier à l'aide d'opérations de chaîne standard : :

>>> import sys

>>> python')

.. _tut-dir:

La fonction :func:`dir` :func:`dir` fonction

====== == ===============================================

La fonction intégrée :func:`dir` est utilisée pour savoir quels noms un module

définit. Elle renvoie une liste triée de chaînes :

Fonction intégrée :func. :`dir` est utilisé pour rechercher les définitions de module par nom de module. Il renvoie une colonne de stockage de type chaîne

table::

>>> 🎜> >>> dir(fibo)

['__name__', 'fib', 'fib2']

>>>

['__displayhook__', '__doc__', '__saufhook__', '__name__', '__stderr__',

'__stdin__', '__stdout__', '_getframe', 'api_version', 'argv' ,

'builtin_module_names', 'byteorder', 'callstats', 'copyright',

'displayhook', 'exc_clear', 'exc_info', 'exc_type', 'exception',

'exec_prefix', 'executable', 'exit', 'getdefaultencoding', 'getdlopenflags',

'getrecursionlimit', 'getrefcount', 'hexversion', 'maxint', 'maxunicode' ,

'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache',

'platform', 'prefix', 'ps1', 'ps2', 'setcheckinterval', ' setdlopenflags',

'setprofile', 'setrecursionlimit', 'settrace', 'stderr', 'stdin', 'stdout',

'version', 'version_info', 'warnoptions' ]

Sans arguments, :func:`dir` répertorie les noms que vous avez définis actuellement :

Lorsqu'elle est appelée sans paramètres, la fonction :func:`dir` renvoie les noms actuellement définis ::

>>> a = [1, 2, 3, 4, 5]

>>> ; fib = fibo.fib

>>> dir()

['__builtins__', '__doc__', '__file__', '__name__', 'a', 'fib ' , 'fibo', 'sys']

Notez qu'il répertorie tous les types de noms : variables, modules, fonctions, etc.

Notez qu'il répertorie tous les types de noms : variables, modules, fonctions, etc. , modules, fonctions, etc.

.. index:: module: __builtin__

:func:`dir` ne répertorie pas les noms des fonctions et variables intégrées Si vous

voulez une liste. parmi ceux-ci, ils sont définis dans le module standard

:mod:`__builtin__`:

:func:`dir` ne répertorie pas les noms de fonctions et de variables intégrés. Si vous souhaitez les lister, ils sont définis dans le module standard

:mod:`__builtin__`::

>>> import __builtin__

> >> dir(__builtin__)

['ArithmeticError', 'AssertionError', 'AttributeError', 'DeprecationWarning',

'EOFError', 'Ellipsis', 'EnvironmentError', ' Exception', 'False',

'FloatingPointError', 'FutureWarning', 'IOError', 'ImportError',

'IndentationError', 'IndexError', 'KeyError', 'KeyboardInterrupt' ,

'LookupError', 'MemoryError', 'NameError', 'Aucun', 'NotImplemented',

'NotImplementedError', 'OSError', 'OverflowError',

'PendingDeprecationWarning', 'ReferenceError', 'RuntimeError',

'RuntimeWarning', 'StandardError', 'StopIteration', 'SyntaxError',

'SyntaxWarning', 'SystemError', ' SystemExit', 'TabError', 'True',

'TypeError', 'UnboundLocalError', 'UnicodeDecodeError',

'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError',

'UserWarning', 'ValueError', 'Warning', 'WindowsError',

'ZeroDivisionError', '_', '__debug__', '__doc__', '__import__',

'__name__', 'abs', 'apply', 'basestring', 'bool', 'buffer',

'callable', 'chr', 'classmethod', 'cmp', 'coerce' , 'compile',

'complexe', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod',

'enumerate', ' eval', 'execfile', 'exit', 'file', 'filter', 'float',

'frozenset', 'getattr', 'globals', 'hasattr', 'hash', ' help', 'hex',

'id', 'input', 'int', 'intern', 'isinstance', 'issubclass', 'iter',

'len' , 'licence', 'list', 'locals', 'long', 'map', 'max', 'memoryview',

'min', 'object', 'oct', 'open' , 'ord', 'pow', 'property', 'quit', 'range',

'raw_input', 'reduce', 'reload', 'repr', 'reversed', 'round' , 'set',

'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super',

'tuple', ' type', 'unichr', 'unicode', 'vars', 'xrange', 'zip']

.. _tut-packages :

Packages package

==============

Les packages sont un moyen de structurer l'espace de noms de module de Python en utilisant des "noms de module en pointillés

Par exemple, le". nom du module :mod:`A.B` désigne un sous-module

nommé ``B`` dans un package nommé ``A`` Tout comme l'utilisation de modules sauve les

auteurs des différents. modules d'avoir à se soucier des noms de variables globaux

les uns des autres, l'utilisation de noms de modules en pointillés évite aux auteurs de packages multi-modules

comme NumPy ou la Python Imaging Library d'avoir à se soucier

les noms de modules les uns des autres.

Les packages utilisent généralement un espace de noms de module structuré utilisant des « noms de modules par points ». Par exemple, un module nommé

:mod:`A.B` représente un sous-module nommé ``A`` dans un package nommé ``B``. Tout comme l'utilisation de modules

pour stocker différentes architectures de modules évite les conflits entre les variables globales, utilisez les noms de modules par points

pour stocker différentes bibliothèques comme NumPy ou Python Imaging Library L'architecture peut éviter les conflits de noms entre les modules

.

Supposons que vous souhaitiez concevoir une collection de modules (un "package") pour la gestion uniforme

des fichiers audio et des données sonores

. formats (généralement reconnus par leur extension, par exemple : :file:`.wav`,

:file:`.aiff`, :file:`.au`), vous devrez donc peut-être créer et maintenir une

collection croissante de modules pour la conversion entre les différents formats de fichiers.

Il existe également de nombreuses opérations différentes que vous souhaiterez peut-être effectuer sur les données sonores

(telles que le mixage , ajout d'écho, application d'une fonction d'égalisation, création d'un

effet stéréo artificiel), donc en plus vous écrirez un

flux sans fin de modules pour effectuer ces opérations. Voici une possibilité. structure de

votre package (exprimé en termes de système de fichiers hiérarchique) :

Supposons que vous souhaitiez maintenant concevoir un ensemble de modules (un "package") pour traiter uniformément les fichiers audio et les données sonores.

Plusieurs formats sonores différents existent (souvent identifiés par leurs extensions, par exemple : :file:`.wav`

, :file:`.aiff`, :file: `.au` ), donc pour

convertir entre différents types de formats de fichiers, vous devez maintenir une collection croissante de packages. Peut-être que vous souhaitez également effectuer de nombreuses

opérations différentes sur les données sonores (par exemple mixer, ajouter de l'écho, appliquer une fonction de balance, créer un effet artificiel), vous souhaitez donc

rejoindre un module de flux infini pour effectuer ces opérations. Votre package pourrait ressembler à ceci (regroupé par un système de fichiers hiérarchique) : :

sound/le package audio

Formats/sous-package pour les conversions de formats de fichiers

__init __.

Wavread.py

Wavwrite.py

Aifread.py

                aiffwrite.py

             aure.py

                 auwrite.py

        ...

         effets/                  Sous-paquet pour les effets sonores

                                                                       … filtres/Sous-paquet pour les filtres

__init__. py

égaliseur.py

vo coder.py

karaoke.py

Lors de l'importation du package, Python recherche dans le répertoires sur

``sys.path`` à la recherche du sous-répertoire du package.

Lors de l'importation de modules, Python recherche dans `` Liste de répertoires dans sys.path`` pour rechercher les sous-répertoires où les packages sont stockés.

Les fichiers :file:`__init__.py` sont nécessaires pour que Python traite les répertoires

comme contenant des packages ; ceci est fait pour empêcher les répertoires avec un nom commun,

tel que ``string``, de masquer involontairement les modules valides qui apparaissent plus tard

lors de la recherche de module Dans le cas le plus simple, :file:`__init__.py` peut simplement être

un fichier vide, mais il peut également exécuter le code d'initialisation du package ou

définir ``__all__. `` variable, décrite plus tard.

Il doit y avoir un fichier :file:`__init__.py` pour que Python traite le répertoire comme un package

ceci afin d'empêcher certains; les répertoires utilisent un nom commun comme ``string`` et écrasent par inadvertance le module correct dans le chemin de recherche du module qui suit

. Dans le cas le plus simple,

:file:`__init__.py` peut être juste un fichier vide, mais il peut également contenir du code d'initialisation du package, ou définir la variable ``__all__``, qui sera suivie plus tard .Présentation connexe.

Les utilisateurs du package peuvent importer des modules individuels du package, par

exemple :

Les utilisateurs du package peuvent importer des modules individuels du package, par exemple ::

import sound.effects.echo

Cela charge le sous-module :mod:`sound.effects.echo` Il doit être référencé avec

son nom complet :

De cette façon, le sous-module :mod:`Sound.Effects.echo` est importé. Il doit être référencé par son nom complet. ::

sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)

Une autre façon d'importer le sous-module est :

importer Il existe un moyen facultatif de packager ::

à partir de sound.effects import echo

Cela charge également le sous-module :mod:`echo` et le rend disponible sans son

préfixe du package, il peut donc être utilisé comme suit :

Ceci charge le sous-module :mod:`echo` et le rend disponible sans le préfixe du package

utilisé, il peut donc être appelé comme suit ::

echo.echofilter(input, output, delay=0.7, atten=4)

Une autre variante consiste à importer directement la fonction ou la variable souhaitée :

Il existe une autre variante pour importer directement des fonctions ou des variables ::

depuis sound.effects.echo import echofilter

Encore une fois, cela charge le sous-module : mod:`echo`, mais cela rend sa fonction

:func:`echofilter` directement disponible :

Cela charge à nouveau le sous-module :mod:`echo`, mais cela le rend Vous pouvez appeler son

:func: Fonction `echofilter` directement ::

echofilter(input, output, delay=0.7, atten=4)

Notez que lors de l'utilisation de ``from package import item``, l'élément peut être soit un

sous-module (ou sous-package) du package, soit un autre nom défini dans le

package, comme une fonction, une classe ou une variable. L'instruction ``import`` en premier

teste si l'élément est défini dans le package ; sinon, il suppose qu'il s'agit d'un

module et tente de le charger s'il ne le trouve pas, un :exc:`ImportError`<.>

une exception est levée.

Il convient de noter que lors de l'utilisation de ``from package import item`` pour importer un package, ce sous-élément ( item) peut être soit un sous-module (ou un sous-package) dans le package, ou d'autres noms définis dans le package, tels que des fonctions, des classes ou des variables. L'instruction import vérifie d'abord si la sous-clé est présente dans le package. Sinon, elle suppose qu'il s'agit d'un module et tente de le charger. S'il n'est pas trouvé, une exception ImportError est levée.

À l'inverse, lorsque vous utilisez une syntaxe telle que ``import item.subitem.subsubitem``, chaque élément

sauf le dernier doit être un package, le dernier élément peut être un module ou un

package mais ne peut pas être une classe, une fonction ou une variable définie dans l'élément précédent

.

À la place, utilisez quelque chose comme ``import item.subitem.subsubitem`` Lors de l'utilisation de la syntaxe, ces sous-éléments doivent

être des packages. Le dernier sous-élément peut être un package ou un module, mais il ne peut pas s'agir d'une classe, d'une fonction ou d'une variable

définie dans le fichier. sous-élément précédent.

.. _tut-pkg-import-star :

Importation /* Depuis un package

---------------- -----------

.. index:: single: __all__

Maintenant, que se passe-t-il lorsque l'utilisateur écrit ``from sound.effects import *`` Idéalement ? ,

on pourrait espérer que cela soit envoyé d'une manière ou d'une autre au système de fichiers, trouve les

sous-modules présents dans le package et les importe tous.

cela pourrait prendre beaucoup de temps. le temps et l'importation de sous-modules peuvent avoir des effets secondaires indésirables qui ne devraient se produire que lorsque le sous-module est explicitement importé `` Que se passe-t-il quand ? Idéalement, vous voudriez rechercher tous les sous-modules du package dans le système de fichiers et les importer. Cela peut prendre

beaucoup de temps et avoir des effets de bord inattendus, l'exportation des packages que vous souhaitez ne peut être importée qu'explicitement.

La seule solution est que l'auteur du package fournisse un index explicite du

package. L'instruction :keyword:`import` utilise la convention suivante : si un package

:file:`__init__.py` définit une liste nommée ``__all__``, elle est considérée comme la

liste des noms de modules qui doivent être importés lorsque ``from package import *`` est

rencontrés. Il appartient à l'auteur du package de maintenir cette liste à jour lorsqu'une

nouvelle version du package est publiée. Les auteurs du package peuvent également décider de ne pas le faire

. le prend en charge, s'ils ne voient pas l'utilité d'importer /* depuis leur package. Par

exemple, le fichier :file:`sounds/effects/__init__.py` pourrait contenir ce qui suit

code :

La seule solution pour les auteurs de packages est de fournir un index de package explicite.

:keyword:`import` est convertie selon les conditions suivantes : lors de l'exécution de ``from package import

*``, si la définition de code :file:`__init__.py` dans le package Une liste nommée ``__all__``

sera importée selon le nom du module donné dans la liste. L'auteur peut

mettre à jour cette liste à volonté lorsqu'une nouvelle version du package est publiée. Si un auteur de package ne souhaite pas importer tous les modules de son package lors de l'importation *,

peut alors décider de ne pas le prendre en charge (import /*). Par exemple,

:file:`Sounds/Effects/__init__.py` Ce fichier peut inclure le code suivant ::

__all__ = ["echo", "surround", "reverse" ]

Cela signifierait que ``from sound.effects import *`` importerait les trois

sous-modules nommés du package :mod:`sound`.

Ceci cela signifierait que l'instruction ``from Sound.Effects import *`` importera les trois sous-modules nommés ci-dessus à partir du package :mod:`sound`.

Si ``__all__`` n'est pas défini, l'instruction ``from sound.effects import *``

n'importe *pas* tous les sous-modules du package :mod:`sound. effect` dans l'

espace de noms actuel ; cela garantit uniquement que le package :mod:`sound.effects` a

été importé (éventuellement en exécutant n'importe quel code d'initialisation dans :file:`__init__.py `)

puis importe tous les noms définis dans le package. Cela inclut tous

noms définis (et sous-modules explicitement chargés) par :file:`__init__.py`.

inclut également tous les sous-modules du package qui ont été explicitement chargés par

les instructions précédentes :keyword:`import` Considérez ce code :

Si ``__all__`` n'est pas défini, ` L'instruction `from Sound.Effects import *`` n'importera pas tous les sous-modules du package

:mod:`sound.effects`. Quel que soit le nombre de noms définis dans le package, il peut uniquement être déterminé que le package :mod:`sound.effects` est importé (le code d'initialisation dans __init__.py peut être exécuté) et tous les noms définis dans le package seront importé. Cela importe chaque sous-module nommé (et explicitement importé) de __init__.py

. Il inclut également des sous-modules explicitement importés du package par l'instruction

:keyword:`import` susmentionnée. Considérez le code suivant ::

import sound.effects.echo

. import sound.effects.surround

from sound.effects import *

Dans cet exemple, les modules :mod:`echo` et :mod:`surround` sont importés dans le

espace de noms actuel car ils sont définis dans le package :mod:`sound.effects`

lorsque l'instruction ``from...import`` est exécutée (cela fonctionne également lorsque

<.>``__all__`` est défini.)

Dans cet exemple, les modules :mod:`echo` et :mod:`surround` importent l'espace de noms actuel

, c'est parce que ils sont déjà définis dans le package

:mod:`sound.effects` lors de l'exécution de l'instruction ``from...import`` (la même chose fonctionnera lorsque ``__all__`` sera défini).

Bien que certains modules soient conçus pour exporter uniquement les noms qui suivent certains

modèles lorsque vous utilisez ``import *``, cela est toujours considéré comme une mauvaise pratique dans

code de production .

Bien que certains modules soient conçus pour exporter uniquement les noms qui correspondent à un certain modèle lors de l'utilisation de ``import *``,

n'est pas recommandé pour une utilisation dans le code de production.

N'oubliez pas qu'il n'y a rien de mal à utiliser ``from Package import

sous-module_spécifique`` ! sous-modules portant le même nom provenant de différents

packages.

N'oubliez pas qu'il n'y a pas d'erreur dans ``from Package import Specific_submodule`` ! En fait, à l'exception de

les modules non importés doivent utiliser des sous-modules du même nom dans d'autres packages, sinon c'est la méthode d'écriture recommandée.

Références intra-package Références du package

-------------------------------- - ------

Les sous-modules doivent souvent faire référence les uns aux autres. Par exemple, le module

:mod:`surround` peut utiliser le module :mod:`echo`. . En fait, de telles

références sont si courantes que l'instruction :keyword:`import` regarde d'abord dans le

paquet contenant avant de chercher dans le chemin de recherche du module standard. Ainsi, le

:mod:`surround` le module peut simplement utiliser ``import echo`` ou ``from echo import

echofilter`` Si le module importé n'est pas trouvé dans le package actuel (le<.>

package dont le module actuel est un sous-module), l'instruction :keyword:`import`

recherche un module de niveau supérieur avec le nom donné.

sous-module Ils ont souvent besoin de se référencer. Par exemple, le module :mod:`surround` pourrait faire référence à

:mod:`echo` module. En fait, de telles références sont si courantes que l'instruction :keyword:`import`

recherche d'abord à l'intérieur du package, puis dans le chemin de recherche standard du module. Par conséquent, le bloc :mod:`surround` module

peut simplement appeler ``import echo`` ou ``from echo import echofilter``

. Si le module à importer n'est pas trouvé dans le package actuel, l'instruction :keyword:`import` recherchera un module de niveau supérieur nommé selon l'index

.

Lorsque les packages sont structurés en sous-packages (comme avec le package :mod:`sound`

dans l'exemple), vous pouvez utiliser des importations absolues pour faire référence aux sous-modules des frères et sœurs

packages. Par exemple, si le module :mod:`sound.filters.vocoder` doit utiliser

le module :mod:`echo` dans le package :mod:`sound.effects`, il peut utilisez ``from

sound.effects import echo``.

Si une structure de sous-package est utilisée dans le package (comme le package :mod:`sound` dans l'exemple), vous pouvez appuyer sur Position absolue

importe les sous-modules des packages adjacents. Par exemple, si le package :mod:`sound.filters.vocoder` nécessite

d'utiliser le module :mod:`echo` du package :mod:`sound.effects`, il peut

` `de Sound.Effects import echo`` .

À partir de Python 2.5, en plus des importations relatives implicites décrites

ci-dessus, vous pouvez écrire des importations relatives explicites avec le formulaire ``from module import

name`` de l'instruction d'importation. Ces importations relatives explicites utilisent des

points de début pour indiquer les packages actuels et parents impliqués dans l'importation relative

à partir du module :mod:`surround` par exemple. use:

À partir de Python 2.5, l'importation de position relative explicite interne susmentionnée a été améliorée. Vous pouvez utiliser ``from module import name`` sous la forme de

pour écrire le relatif explicite. la position de la formule est importée. Ces paires d'importations

explicites sont marquées par des points pour associer les packages actuels et parents importés. En prenant le module :mod:`surround` comme exemple, vous pouvez utiliser

comme ceci ::

from .import echo

from .. import formats

.

from ..filters import égaliseur

Notez que les importations relatives explicites et implicites sont basées sur le nom de

le module actuel puisque le nom du module principal est toujours ``. "__main__" ``,

les modules destinés à être utilisés comme module principal d'une application Python doivent

toujours utiliser des importations absolues.

Il convient de noter que les importations explicites ou implicites positions relatives Les importations sont basées sur le nom du module actuel. Étant donné que le nom du module principal est toujours ``"__main__"``, le module principal d'une application Python doit toujours être importé de manière absolue.

Packages dans plusieurs répertoires

-------------------------------- -- ---------------------

Les packages prennent en charge un attribut spécial supplémentaire, :attr:`__path__`. Celui-ci est

initialisé. être une liste contenant le nom du répertoire contenant le :file:`__init__.py` du

package avant que le code de ce fichier ne soit exécuté. Cette

variable peut être modifiée en procédant ainsi ; affecte les recherches futures de modules et

sous-packages contenus dans le package. Le package

prend en charge une fonctionnalité plus spéciale, :attr:`__path__` . Cette variable initialise une liste de noms de répertoires avant que le code du fichier

:file:`__init__.py`

du package soit exécuté. Cette variable est modifiable, et elle agit sur la fonction de recherche de sous-packages et modules dans le package

.

Bien que cette fonctionnalité ne soit pas souvent nécessaire, elle peut être utilisée pour étendre l'ensemble de

modules trouvés dans un ensemble de modules, mais elle n'est pas couramment utilisée.

.. rubrique :: Footnotes

.. [#] En fait, les définitions de fonctions sont aussi des « instructions » qui sont « exécutées » l'

exécution d'un module- ; la fonction de niveau entre le nom de la fonction dans la table des symboles globaux

du module.

.. [#] En fait, la définition de la fonction est à la fois une "déclaration" et un "corps exécutable" ; le corps exécutable est composé de fonctions nommées importations dans la table sémantique globale du module.

Ce qui précède est le contenu du didacticiel de base Python 2.7 : module. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !