# Contenu Aujourd'hui
* Module d'importation
`` Python `
" « »
1. Quel est le module
module (module de traitement de fichier de l' application de système d' exploitation, le module de temps d'application) fonction d' agrégat d'une série de
modules ont trois sources
1. intégrés dans le module
2. Les modules tiers
3 modules personnalisés à
quatre modules format performances
1. utilisez le fichier py écrit en python
2 a été compilé en tant que bibliothèque partagée ou une DLL C ou C ++ extensions
3. mettre en place une série de modules organisés dans des dossiers (dossier il __init__.py un dossier de package appelé)
4. écrit en C et est relié à l'interpréteur python Module intégré
2. Pourquoi vous utilisez le module
1. Utilisez les modules intégrés ou tiers avantages sont: isme, d' améliorer grandement l'efficacité du développement
2. Utilisez un des avantages du module sur mesure sont les suivantes : les procédures d'extraction doivent utiliser plus de lieux publics le module de fonction définie comme la réduction du code redondant
(le programme est un multi-fichiers, plusieurs fichiers devront utiliser toutes les fonctions en un seul endroit pour tout le monde de trouver l' unité)
3. Comment utiliser les modules
principe: il faut distinguer qui est le fichier exécutable, qui est un module à importer
« » "
` ``
#### recours aux importations
Python `` `
" ""
Nouveau fichier d'exécution deux py est introduit
"""
# md.py
Imprimer ( 'de The md.py')
argent = 1000
DEF Read1 ():
Imprimer ( 'MD', argent)
DEF READ2 ():
print ( 'md module')
Read1 ()
DEF Changement ():
global argent
argent = 0
# run.py
argent = 66
importation nom de fichier # md est le nom du module et md.py md
# Droit l' exécution, exécutez le fichier md, les importations multiples ne fonctionnent pas plus d'une fois
. « » "
1. La première importation de trois choses se produit le module
1. génère un module d'espace de nom
2. Exécutez le fichier md.py, effectuera nom généré dans le procédé sont placés dans l'espace de noms du module de
« argent »: adresse de mémoire 1000
« READ1 »: fonction adresse de mémoire de READ1
« de READ2 »: adresse mémoire fonction READ2
« changement »: adresse mémoire fonction de changement
icône mieux comprendre l' effet
3. nom du module pour obtenir un espace dans le nom du fichier exécutable en cours, ce qui indique le nom du module d'espace de noms
qui est:
maintenant , exécutez le fichier md, il va certainement créer un espace de noms, tous les noms de fichiers md relation de liaison avec la valeur sauvegarder jusqu'à
terme également exécuter un fichier, il va certainement créer un espace de noms, l'argent est allé au magasin md
« argent »: adresse mémoire 66 de la
« md »: nom adresse espace md.py de
2. après l'importation est une référence directe aux résultats de la première importation ne sera pas ré-exécuter le fichier
« » "
syntaxe # 1. effectuer espace de nom du module d'accès de fichier: le nom du nom du module d'
impression (md.money) # nommé nom du chemin du fichier que vous souhaitez nommer avec md l' argent, certainement pas en conflit avec le nom du fichier en cours d' exécution
au nom de l' espace de nommage de l' argent pour exécuter le fichier de l' argent #
Imprimer (md.read1)
Imprimer (md.read2)
Imprimer (md.change) print # pour obtenir l'adresse mémoire de la fonction réalisée par l'impulsion >>> placé entre crochets
# Un appel READ1, READ2, changement clair à plusieurs reprises pour trouver le nom de la loi
md.read1 () # md recherche d'un fichier dans Money
md.read2 () # recherche de fichier argent md
md.change () # modifié fichier est de l' argent md
L' introduction d' une pluralité de modules ligne de # (non recommandé)
Importation OS, SYS, Temps
depuis présenté au module # Nom Alias
xxxyyy d'importation comme xy
« » "
Importation module d' importation Résumé:
doit être préfixé lors de l'utilisation:. Le nom du module
Avantages: par nom à un nom à un espace de nom, certainement pas en conflit avec le nom d'espace de noms courant
Inconvénients: Chaque fois que l' utilisation le module devra ajouter le préfixe du nom du module
« » "
` ``
### from ... import ...
`` `Python
# toujours au- dessus de deux documents, par exemple
de l' argent à l'importation md
de l' argent à l'importation md
" ""
from ... import ... trois choses ont eu lieu, avant que les deux importations comme l' importation, seul le dernier un peu différent
1. génère un module d'espace de nom
2. exécutez le fichier md.py, le nom du processus de mise en œuvre sont générés dans le module d'espace de nom
3. directe pour obtenir un nom de fichier dans la mise en œuvre actuelle du correspondant au nom du module est le nom de
« l' argent »: fichier argent md
« » "
# 1. l'
argent = 888
de l' argent d' importation md
# 2.
de l' importation de l' argent md
argent = 888
# Résumé
« » «
avantages: pas besoin d'utiliser le préfixe plus, plus concis
Inconvénients: peut le nom du conflit actuel dans l'espace de noms
» « »
de md importation Read1
argent = 999
Read1 () appel # fonction dans la phase de définition a été fixée mort, il n'y a pas de relation avec l'emplacement d'appel est ici que la mise en œuvre du nom d'espace de noms de fichier modifié! ! ! Illustre apprécié
# autre exemple preuve
Chang () # valeur est modifiée, la mise en œuvre du fichier du module d'argent a rien d'argent
Imprimer (argent)
# En savoir
d'importation * # * md représentants pour obtenir tous les noms (non recommandé) de modules importés, parce que le nom est susceptible de conflit avec le nom de l'espace actuel
# * Le supplément d' importation est à l' intérieur __all__ énumérés tous les noms
`` `
module d'importation ### cycles
Python `` `
" ""
Module
m1.py
impression ( 'importé M1')
de M2 y # Importer trois choses à se produire dans la première importation
X = 'M1'
m2.py
Imprimer ( 'étant m2 importés)
importer le X-M1 de
la y- = « M2 »
exécuter le fichier
run.py
importation M1 # trois choses première importation se passer
. « » "
étape # par l' analyse de l' étape, réalisée première course, courir pour produire l'espace de noms correspondant
#import m1, parce qu'il est première importation va créer un espace de noms correspondant m1
code # run se trouve dans m1 m1 et guider le m2, m2 est la première importation
# créer namespace m2, exécutez le code m2
# m2 à trouver dans x m1 cette fois -ci n'a pas fait de x
« » «
le problème avec ce phénomène circule IMPORTES, le guide m2 m1, m2 m1 à son tour guider l'
émergence de moyens de circulation importés conception de votre programme est déraisonnable, doit être repensé
» " "
# Résoudre les problèmes causés par le cycle d'importation
# 1 voie: le cycle de déclaration importé dans le nom derrière la définition d'
impression ( « importé M1 »)
le X- = « M1 »
du y-M2 Importation
imprimer ( 'étant introduit M2')
Y = 'M2'
de M1 X importation
# Mode de réalisation 2: L'instruction de boucle introduite dans la fonction
print ( 'importé M1')
DEF F1 ():
de M2 Importer Y
print ( 'm1.f1 >>> Y:', Y)
X = 'M1'
imprimer ( 'étant introduit M2')
DEF F2 ():
à partir de M1 X importation
print ( 'm2.f2 >>> X:', X)
Y = 'M2'
# illustrated apprécié
# Résumé: Avant d' importer, prêt à laisser son nom
`` `
#### fichier py de jugement est importé en tant que module ou fichier exécutable
Python `
SI le __name__ == « __main__ »: # lorsqu'un fichier est directement exécuté
si __name__ == « py nom de fichier » # Lorsqu'un fichier est importé
`
Trouvez l'ordre de ### modules
`` `Python
" « »
module de séquence d'interrogation
1. commencer à chercher peut avoir été chargé en mémoire du
2 intégré dans le module
liste 3.sys.path l' intérieur d' un chemin à regarder chacun a
besoin de connaître la liste du premier chemin sys.path est le fichier en cours est le dossier dans lequel l'exécution
ps: module python prend également en charge l' importation directement à partir de l'archive zip dans
« » "
# Valider le premier point, qui cherchent à trouver un module de mémoire commencer à chercher à voir le module n'est pas déjà chargé
. « » "
Définir un module, importé dans un autre fichier, puis exécutez le fichier 10s sommeil actif, rapide à parler au cours du module supprimer le fichier, trouver le code après l' exécution du fichier peut encore être consulté le sommeil ,
mais une fois que les finitions du programme en cours d' exécution, l'erreur sera de nouveau effectuer le
temps d' importation
Importer M1
la time.sleep (10)
importation M1
m1.f1 ()
« » "
# Notez que nom de fichier py de votre nouveau meilleur pas aux conflits de noms de modules déjà existants module temps, par exemple
`` `
#### un peu plus compliqué cas
`` Python `
# Pour activer le module dans un dossier, exécuter des fichiers et des dossiers avec différents niveaux dans le même fichier module niveau
import md. # Enregistrée en raison de la mémoire, a fait intégré non, sys.path est d'exécuter le fichier en cours est situé dossier pour trouver le fichier
# afin de résoudre, besoin d'utiliser sys.path.append () dans le dossier dans lequel le module de fichier ajouté à ce
# Je ne veux pas résoudre avec ce qui précède, il peut être utilisé de différentes manières
de ... import ...
de l'importation dir1.dir2 md
`` `
importation absolu ### Module
`` `Python
# nouveau souligné: les modules importés doivent faire effacer le fichier exécutable et le fichier d'importation, sys.path est basé sur le dossier dans lequel le fichier est exécuté
- l'importation du module absolu
-dir1
-m1.py
-m2.py
-run py
fichiers à partir du dossier d'importation # m1 dir1 où le fichier exécutable run.py est « importation absolument module » dans le dossier se trouvent base dir1 et se trouvent donc à l' intérieur de l'autoroute M1
# Un autre exemple pour confondre les personnes
- module import absolu
-dir1
-m1.py
-m2.py
-run.py
# M2 Guide directement m1
# Et puis étudier à nouveau
- import absolument le module
-dir0
-dir1
-m1.py
-m2.py
-run.py
# module pour importer tous les fichiers sont soumis à exécuter le fichier
# peut utiliser sys.path.appen être ajouté à rep0 variable d'environnement
« » "
Résumé: commencer à exécuter le fichier (basé sur sys.path) trouver la relation entre les couches, appelées les importations en termes absolus
avantages: fichier exécutable à importer avec le module peut être utilisé
Inconvénients: Toutes les importations doivent sys.path à jouer point de départ, l'importation de problèmes
. "" "
` ``
Présentation de module par rapport ####
`` `Python
" « » les
importations relatives: fichier de référence réside actuellement dans le dossier de départ Trouver
Le document représente l'emplacement actuel du dossier
.. au nom d'un dossier
... au nom d'un niveau supérieur dossier
avantage: importation plus simple
inconvénients: ne peut être utilisé dans le module est importé, le fichier ne peut être exécuté avec
« » "
# Notez toutefois les importations relatives ne peuvent être utilisés dans le dossier du module importé, le fichier ne peut être exécuté d'occasion
forfait #
Trois sources parlent lorsque le module de module parlé des quatre formats de performance
`` `Python
module a trois sources
1. Module intégrées
2. Les modules tiers
3. modules personnalisés
quatre types de module de format de la performance
1. Utilisez py python document écrit
2. a été compilé en tant que bibliothèque partagée ou DLL C ou C ++ extensions
3. la série de modules regroupés dans le dossier (un dossier de fichiers __init__.py, le dossier paquet appelé)
4. écrites en C et est relié à l'interpréteur python Module intégré
L'origine des modules de présentation et forfaits #
« » "
Qu'est - ce qu'un package
fichier contenant le package est un dossier de fichiers __init__.py
essentiellement modules peuvent être importés, les fichiers sont également inclus dans l'emballage à utiliser pour l' importation
2. Pourquoi emballer les
dossiers sont utilisés pour mieux gérer les fichiers et les concepteurs de package est de faciliter un meilleur module de module d'organisation
. « » "
# Construire un dossier contenant un __init__.py (p1) a été construit dans le même niveau de fichier py dans le processus d'analyse des dossiers
. « » "
Mémoires de modules importés trois choses
1. Générer un espace de noms du module
2. Module d'exécution code dans le nom de fichier sera généré lors de l' exécution sont jetés dans l'espace de noms
3. obtenir le nom de l'un fichier en cours d' exécution, le nom pointe vers le module d'espace de noms
Question: La deuxième étape consiste à importer les documents de code du module d'exécution, est maintenant un dossier, puis l'exécutif qui ne qui a jeté?
paquet d' importation déduit trois choses
1. Les fichiers __init__.py dans le paquet en tant que référence pour générer un espace de noms
2. Exécutez le code dans le package de fichier __init__.py, le nom est généré lors de l' exécution sont jetés namespace
3. obtenir le nom d'un fichier dans l'exécution en cours p1, p1 est l'espace de noms de point de __init__.py
« » "
# python3 vérifier si un dossier qui ne contient pas __init__.py également pas donné
# commutation python2 trouvé une erreur directe
# python2 qui est à l' intérieur du paquet doit avoir __init__ fichier, python , même si aucune erreur ne sera pas
# Vérifiez que le package d'importation est le fichier point de __init__.py
accès # nom du module, en fait, allez fichier __init__.py pour trouver le nom
`` `
Trouver le nom ####
`` Python `
# ci - dessus package guide de dérivation est en fait pointer fichier __init__.py pour accéder au nom de fichier basé à l' intérieur, donc il pourrait aussi bien construire un fichier py
#import le paquet doit être trouvé à l' intérieur du paquet tout le nom du fichier py et pas seulement le fichier __init__
« » "
Ne pas faire le tour, parler trop compliqué de parler directement à deux angles
Le premier angle: package utilisateur
package après le téléchargement package final de l' utilisateur, assurez - vous juste de trouver le chemin où le paquet dans son programme normal à l' intérieur et l' importer à
savoir l'utilisation des variables d'environnement pour manipuler sys.path
le paquet est situé sur un chemin de dossier à la variable d'environnement (besoins des utilisateurs à savoir est le module de téléchargement ou un pack où se trouve un dossier, il vous suffit de télécharger un logiciel, vous devez certainement savoir où aller)
Les instructions d'importation. La gauche doit certainement être un paquet
Le deuxième angle: les concepteurs de colis
pour assurer que tous les modules sont capables d'écrire leur propre paquet de niveau supérieur __init__.py se trouve à l' aide du module par rapport à l' importation
avantages sont les faits saillants:
1. changement de nom du module ne modifie pas la recherche interne
2. Non sera confondu par le concept de couches imbriquées de relations et d' exécuter des fichiers dans le fichier
« » "
` ``