Importation de modules Python pour implémenter les fonctions dont vous avez besoin

Les

Modules vous permettent d'organiser logiquement vos extraits de code Python.

Attribuer du code associé à un module peut rendre votre code plus utilisable et plus facile à comprendre.

Les modules sont également des objets Python avec des attributs nommés aléatoirement pour la liaison ou la référence.

En termes simples, un module est un fichier qui stocke le code Python. Les modules peuvent définir des fonctions, des classes et des variables. Les modules peuvent également contenir du code exécutable.

Exemple

Le code Python d'un module appelé aname se trouve généralement dans un fichier appelé aname.py. L'exemple suivant est un simple module support.py.

def print_func( par ):

print "Bonjour : ", par

import déclaration

Voulez-vous utiliser Python fichier source, exécutez simplement l'instruction import dans un autre fichier source, la syntaxe est la suivante :

import module1[, module2[,... moduleN]

Lorsqu'il est interprété Lorsque le compilateur 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 hello.py, vous devez mettre la commande en haut du script :

#!/usr/bin/python

# Import module

import support

# Vous pouvez maintenant appeler les fonctions contenues dans le module

support.print_func("Zara")

Le résultat de sortie de l'exemple ci-dessus :

Bonjour : Zara

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.

---

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 actuel. La syntaxe est la suivante :

>>>from modname import name1[, name2[, ... nameN]]

Par exemple, pour importer la fonction fibonacci du module fib , utilisez l'instruction suivante :

>>>from fib import fibonacci

Cette instruction n'importera pas l'intégralité du module fib dans l'espace de noms actuel, elle n'introduira qu'un seul fibonacci dans fib dans l'exécution La table des symboles globale de ce module déclaré.

---

Instruction From...import *

Il est également possible d'importer tout le contenu d'un module dans l'espace de noms actuel, utilisez simplement l'instruction suivante :

> ;>>from mod_name import *

Cela fournit un moyen simple d'importer tous les projets dans un module. Il ne faut cependant pas abuser de cette affirmation.

---

Localisation des modules

Lorsque vous importez un module, l'ordre de recherche de l'analyseur Python pour les emplacements des modules est :

• Répertoire actuel

• S'il ne se trouve pas dans le répertoire courant, Python recherche dans chaque répertoire

• sous la variable shell PYTHONPATH.

• Si aucun des deux n'est trouvé, Python vérifiera le chemin par défaut. Sous UNIX, le chemin par défaut est généralement /usr/local/lib/python/

Le chemin de recherche du module est stocké dans la variable sys.path du module système. Les variables incluent le répertoire courant, PYTHONPATH et le répertoire par défaut déterminé par le processus installation.

---

Variable PYTHONPATH

En tant que variable d'environnement, PYTHONPATH se compose de nombreux répertoires installés dans une liste. La syntaxe de PYTHONPATH est la même que celle de la variable shell PATH.

Dans les systèmes Windows, le PYTHONPATH typique est le suivant :

set PYTHONPATH=c:python20lib;

Dans les systèmes UNIX, le PYTHONPATH typique est le suivant :

set PYTHONPATH=/usr/local/lib/python

Espace de noms et portée

Une variable est le nom (identifiant) ​​qui possède l'objet correspondant. Un espace de noms est un dictionnaire contenant des noms de variables noms (clés) et leurs objets (valeurs) correspondants.

Une expression Python peut accéder aux variables dans l'espace de noms local et l'espace de noms global. Si une variable locale porte le même nom qu'une variable globale, la variable locale remplace la variable globale.

Chaque fonction a son propre espace de noms. Les règles de portée des méthodes de classe sont les mêmes que celles des fonctions régulières.

Python devinera intelligemment si une variable est locale ou globale, en supposant que toute variable affectée dans une fonction est locale.

Par conséquent, si vous souhaitez attribuer une valeur à une variable globale dans une fonction, vous devez utiliser l'instruction globale. L'expression

global VarName indique à Python que VarName est une variable globale, afin que Python ne recherchera pas cette variable dans l'espace de noms local.

Par exemple, nous définissons une variable money dans l'espace de noms global. Nous attribuons ensuite une valeur à la variable money dans la fonction, puis Python supposera que money est une variable locale. Cependant, nous n'avons pas déclaré de variable locale money avant d'y accéder, et le résultat est un UnboundLocalError. Décommenter le commentaire sur la déclaration globale peut résoudre ce problème.

>>>#!/usr/bin/python

>>>Argent = 2000

>>>def AddMoney( ):

# Si vous souhaitez corriger le code, décommentez ce qui suit :

# global Money

Money = Money + 1

>> ;>imprimer de l'argent

>>>AddMoney()

>>>imprimer de l'argent

dir() fonction

dir() est une liste triée de

chaînes dont le contenu est le nom défini dans un module.

La liste renvoyée contient tous les modules, variables et fonctions définis dans un module. Voici un exemple simple :

>>>#!/usr/bin/python

>>># Importez le module mathématique intégré

> ;>>importer des mathématiques

>>>content = dir(math)

>>>imprimer le contenu;

Le exemple de résultat de sortie ci-dessus ：

['doc', '

file', 'name', 'acos', 'asin', 'atan',

'atan2 ', 'ceil', 'cos', 'cosh', 'degrees', 'e', ​​​​​​'exp',

'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log',

'log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh',

'sqrt', 'tan', 'tanh']

Ici,

Caractères spéciauxLe nom de la variable chaîne pointe vers le nom du module, et file pointe vers le nom du fichier importé du module.

---

Fonctions globals() et locals()

Selon l'endroit où elles sont appelées, les fonctions globals() et locals() peuvent être utilisées pour renvoyer des noms dans les fichiers global et local. espaces de noms .

Si locals() est appelé dans une fonction, tous les noms accessibles dans la fonction seront renvoyés.

Si globals() est appelé dans une fonction, tous les noms globaux accessibles dans la fonction seront renvoyés.

Les types de retour des deux fonctions sont des dictionnaires. Les noms peuvent donc être extraits à l’aide de la fonction key().

Fonction reload()

Lorsqu'un module est importé dans un script, le code dans la partie de niveau supérieur du module ne sera exécuté qu'une seule fois.

Par conséquent, si vous souhaitez réexécuter le code de niveau supérieur dans le module, vous pouvez utiliser la fonction reload(). Cette fonction réimporte les modules précédemment importés. La syntaxe est la suivante :

>>>reload(module_name)

Ici, module_name doit directement mettre le nom du module au lieu d'une forme de chaîne. Par exemple, si vous souhaitez recharger le module hello, comme suit :

>>>reload(hello)

Le package en Python

Le package est une structure de répertoires de fichiers hiérarchique, qui définit un environnement d'application Python composé de modules et de sous-packages, et de sous-packages sous sous-packages.

Considérez un fichier pots.py dans l'annuaire téléphonique. Ce fichier a le code source suivant :

>>>#!/usr/bin/python

>>>def Pots():

imprimer "I'm Pots Phone"

De même, nous avons deux autres fichiers qui détiennent des fonctions différentes :

• Phone/Isdn.py contient la fonction Isdn( )

• Phone/G3.py contient la fonction G3()

Maintenant, créez le fichier init.py dans le répertoire Phone :

• Phone/init.py

Lorsque vous importez Phone, afin de pouvoir utiliser toutes les fonctions, vous devez utiliser des importations explicites dans init.py Déclaration, comme suit :

>>>from Pots import Pots

>>>from Isdn import Isdn

>>>from G3 import G3

Après avoir ajouté ces codes à init.py, toutes ces classes seront disponibles lors de l'importation du package Phone.

>>>#!/usr/bin/python

>>># Importez maintenant votre forfait téléphonique.

>>> ;importer le téléphone

>>>Phone.Pots()

>>>Phone.Isdn()

>>>Téléphone .G3()

Résultat de sortie de l'exemple ci-dessus :

Je suis un téléphone Pots

Je suis un téléphone 3G

Je suis un téléphone RNIS

Comme ci-dessus, à titre d'exemple, nous ne mettons qu'une seule fonction , mais vous pouvez en fait mettre de nombreuses fonctions. Vous pouvez également définir des classes Python dans ces fichiers, puis créer un package pour ces classes.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!