Comment utiliser les modules de base de Python

1. Module

Un module peut être vu comme un ensemble de fonctions.

Un tas de fonctions peuvent être placées dans un fichier py, donc un fichier py peut être considéré comme un module.

Si le nom de fichier de ce fichier py est module.py，模块名则是module.

1. Quatre formes de modules

En Python, il existe au total les quatre formes de modules suivantes :

• Module personnalisé : si vous écrivez vous-même un fichier py et écrivez un tas de fonctions dans le fichier, alors C'est ce qu'on appelle un module personnalisé, c'est-à-dire un fichier .py écrit en python

• Modules tiers : extensions C ou C++ qui ont été compilées sous forme de bibliothèques partagées ou de DLL, comme des requêtes

• Modules intégrés : écrits en C Et lié aux modules intégrés de l'interpréteur python, comme time

• package (dossier) : un dossier qui organise une série de modules ensemble (Remarque : il y a un fichier __init__.py sous le dossier, qui s'appelle C'est un package)

2 Pourquoi utiliser des modules ?

• L'utilisation de modules tiers ou intégrés est une sorte d'emprunt, qui peut considérablement améliorer l'efficacité du développement.

• Les modules personnalisés écrivent les fonctions publiques utilisées dans nos propres programmes dans un fichier python, puis chaque composant du programme peut référencer les fonctions du module personnalisé via l'importation.

2. Comment utiliser les modules

Généralement, nous utilisons import et from...import... pour importer des modules.

Prenez le code de fichier suivant dans spam.py comme exemple.

# spam.py
print('from the spam.py')
money = 1000
def read1():
print('spam模块：', money)
def read2():
print('spam模块')
read1()
def change():
global money
money = 0

1. La syntaxe du nom du module d'importation

est la suivante :

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

Le module importé doit être accessible avec un préfixe.

Trois choses se produisent lors de l'importation d'un module pour la première fois :

• Créer un espace de noms du module basé sur le module

• Exécuter le fichier correspondant au module, et jeter tous les noms générés lors de l'exécution dans l'espace de noms du module

• Obtenir un nom de module dans le fichier d'exécution actuel

Remarque : l'importation répétée du module fera directement référence aux résultats précédemment créés, et le fichier du module ne sera pas exécuté à plusieurs reprises.

# run.py
import spam # from the spam.py
import spam
money = 111111
spam.read1() # 'spam模块：1000'
spam.change()
print(spam.money) # 0
print(money) # 111111

Importer le renommage : la variable smt pointe vers l'espace de noms du module span

# run.py
import spam as sm
money = 111111
sm.money
sm.read1() # 'spam模块：1000'
sm.read2
sm.change()
print(money) # 1000

Importer plusieurs modules

import spam, time, os
# 推荐使用下述方式
import spam
import time
import os

2 à partir de l'importation du nom du module La fonction spécifique

La syntaxe est la suivante :

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

Cette instruction ne sera pas. importer l'intégralité du module Cela introduira uniquement une ou plusieurs fonctions du module dans l'espace de noms actuel.

Les modules importés depuis...import... n'ont pas besoin d'être accessibles avec un préfixe.

from...import...Trois choses se produisent lorsque vous importez un module pour la première fois :

• Créez un espace de noms de module basé sur le module

• Exécutez le fichier correspondant au module, et utilisez le nom généré lors de l'exécution Jetez-les tous dans l'espace de noms du module

• Obtenez un nom dans l'espace de noms du fichier d'exécution actuel, qui pointe directement vers un nom dans le module, ce qui signifie qu'il peut être utilisé directement sans en ajouter préfixe

• Avantages : Pas besoin d'ajouter de préfixes, le code est plus simple

• Inconvénients : Il est facile d'entrer en conflit avec les noms dans l'espace de noms dans le fichier d'exécution actuel

# run.py
from spam import money
from spam import money,read1
money = 10
print(money) # 10

rom &hellip ; instruction import * : Importez toutes les fonctions dans le fichier :

# spam.py
__all__ = ['money', 'read1'] # 只允许导入'money'和'read1'

# run.py
from spam import * # 导入spam.py内的所有功能，但会受限制于__all__
money = 111111
read1() # 'spam模块：1000'
change()
read1() # 'spam模块：0'
print(money) # 111111

3. Importation circulaire

L'importation circulaire se produira dans les situations suivantes :

# m1.py
print('from m1.py')
from m2 import x
y = 'm1'
# m2.py
print('from m2.py')
from m1 import y
x = 'm2'

Vous pouvez utiliser la fonctionnalité de reconnaissance de la syntaxe uniquement lors de l'étape de définition de la fonction pour résoudre le problème. problème de l'importation circulaire, ou essentiellement résoudre le problème de l'importation circulaire, mais la meilleure solution n'est pas de Une importation circulaire se produit.

Option 1 :

# m1.py
print('from m1.py')
def func1():
from m2 import x
print(x)
y = 'm1'



# m2.py
print('from m2.py')
def func1():
from m1 import y
print(y)
x = 'm2'

Option 2 :

5、# m1.py
print('from m1.py')
y = 'm1'
from m2 import x



# m2.py
print('from m2.py')
x = 'm2'
from m1 import y

4. Fonction dir()

La fonction intégrée dir() peut trouver tous les noms définis dans le module. Renvoyé sous la forme d'une liste de chaînes :

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
print(dir()) # 得到一个当前模块中定义的属性列表
# ['__builtins__', '__name__', 'a', 'fib', 'fibo', 'sys']

b = 5 # 建立一个新的变量 'a'
print(dir())
# ['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'b']
del b # 删除变量名a
print(dir())
# ['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'a']

3 Chemin de recherche du module

1. séquence

1. Première recherche à partir des modules importés dans la mémoire

Si nous supprimons rapidement le fichier mmm.py lors de l'exécution du fichier run.py, nous constaterons que le fichier continuera à s'exécuter sans signaler d'erreur, car mmm a été importé en mémoire. Si nous exécutons à nouveau run.py, une erreur sera signalée car mmm.py a été supprimé.

# test.py
import m1 # 从m1.py文件中导入的,然后会生成m1模块的名称空间
import time
# 删除m1.py文件,m1模块的名称空间仍然存在

time.sleep(10)
import m1 # 不报错,一定不是从文件中获取了m1模块,而是从内存中获取的

2. Modules intégrés

La vérification sera trouvée en premier à partir du fichier intégré, pas du fichier time.py personnalisé en premier.

# time.py
print('from time.py')
# run.py
import time
print(time) #

3. Recherchez dans la variable d'environnement sys.path (souligné : la première valeur de sys.path est le dossier où se trouve le fichier d'exécution actuel)

import sys
for n in sys.path:
print(n)
# C:\PycharmProjects\untitled\venv\Scripts\python.exe C:/PycharmProjects/untitled/hello.py
# C:\PycharmProjects\untitled
# C:\PycharmProjects\untitled
# C:\Python\Python38\python38.zip
# C:\Python\Python38\DLLs
# C:\Python\Python38\lib
# C:\Python\Python38
# C:\PycharmProjects\untitled\venv
# C:\PycharmProjects\untitled\venv\lib\site-packages

Si mmm.py est dans le chemin C:PycharmProjectsuntitledday16, et le fichier d'exécution Le chemin est C:PycharmProjectsuntitled S'il est importé normalement, une erreur sera signalée C:PycharmProjectsuntitledday16 à la variable d'environnement sys.path pour éviter les erreurs.

# run.py
import sys
sys.path.append(r'C:\PycharmProjects\untitled\day16')
print(sys.path)
import mmm
mmm.f1()

2. Le chemin de recherche est basé sur le fichier exécutable

Supposons que nous ayons un fichier avec la structure de répertoires suivante et que les codes dans le fichier sont :

而hello和spam.py不是同目录下的，因此run.py的环境变量无法直接找到m2,需要从文件夹导入

from aa import spam
print(spam.money)

四、Python文件的两种用途

一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用__name__属性来使该程序块仅在该模块自身运行时执行。

python文件总共有两种用途，一种是执行文件；另一种是被当做模块导入。

每个模块都有一个__name__属性，当其值是'__main__'时，表明该模块自身在运行，否则是被引入。

1、当run.py运行的时候，aaa.py被当做引用模块，它的__name__ == 'aaa'（模块名），会执行aaa.py中的f1()。

# aaa.py
x = 1
def f1():
print('from f1')
f1()
# run.py
import aaa

2、aaa.py被当做可执行文件时，加上__name__ == '__main__'，单独运行aaa.py才会执行aaa.py中的f1()。 run.py运行时可以防止执行f1()。

# aaa.py
x = 1
def f1():
print('from f1')

if __name__ == '__main__':
f1()

五、包

包是一种管理 Python 模块命名空间的形式，包的本质就是一个含有.py的文件的文件夹。

包采用"点模块名称"。比如一个模块的名称是 A.B， 那么他表示一个包 A中的子模块 B 。

目录只有包含一个叫做 __init__.py 的文件才会被认作是一个包。

在导入一个包的时候，Python 会根据 sys.path 中的目录来寻找这个包中包含的子目录。

导入包发生的三件事：

• 创建一个包的名称空间

• 由于包是一个文件夹，无法执行包，因此执行包下的.py文件，将执行过程中产生的名字存放于包名称空间中（即包名称空间中存放的名字都是来自于.py）

• 在当前执行文件中拿到一个名字aaa，aaa是指向包的名称空间的

导入包就是在导入包下的.py，导入m1就是导入m1中的__init__。

1、两种方式导入：

• import ... : 
  import item.subitem.subsubitem 这种导入形式，除了最后一项，都必须是包，而最后一项则可以是模块或者是包，但是不可以是类，函数或者变量的名字。

• from ... import...: 
  当使用 from package import item 这种形式的时候，对应的 item 既可以是包里面的子模块（子包），或者包里面定义的其他名称，比如函数，类或者变量。

2、import 导入包内的模块

import 可以每次只导入一个包里面的特定模块，他必须使用全名去访问。

import aaa.bbb.m3
print(aaa.bbb.m3.func3())

import方式不能导入函数、变量：import aaa.bbb.m3.f3错误

3、from import方式：

导入模块内具体的模块

这种方式不需要那些冗长的前缀进行访问

from aaa.bbb import m3
print(m3.func3())

导入模块内具体的功能

这种方式不需要那些冗长的前缀进行访问

from aaa.bbb.m3 import func3
print(func3())

4、 绝对导入和相对导入

绝对导入：

# aaa/.py
from aaa.m1 import func1
from aaa.m2 import func2

相对导入：

• .代表当前被导入文件所在的文件夹

• ..代表当前被导入文件所在的文件夹的上一级

• ...代表当前被导入文件所在的文件夹的上一级的上一级

from .m1 import func1
from .m2 import func2

5、from...import *

导入语句遵循如下规则：如果包定义文件 __init__.py 存在一个叫做 __all__ 的列表变量，那么在使用 from package import * 的时候就把这个列表中的所有名字作为包内容导入。

这里有一个例子，在:file:sounds/effects/__init__.py中包含如下代码:

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

这表示当你使用from sound.effects import *这种用法时，你只会导入包里面这三个子模块。

六、软件开发的目录规范

为了提高程序的可读性与可维护性，我们应该为软件设计良好的目录结构，这与规范的编码风格同等重要，简而言之就是把软件代码分文件目录。假设你要写一个ATM软件，你可以按照下面的目录结构管理你的软件代码：

ATM/
|-- core/
| |-- src.py # 业务核心逻辑代码
|
|-- api/
| |-- api.py # 接口文件
|
|-- db/
| |-- db_handle.py # 操作数据文件
| |-- db.txt # 存储数据文件
|
|-- lib/
| |-- common.py # 共享功能
|
|-- conf/
| |-- settings.py # 配置相关
|
|-- bin/
| |-- run.py # 程序的启动文件，一般放在项目的根目录下，因为在运行时会默认将运行文件所在的文件夹作为sys.path的第一个路径，这样就省去了处理环境变量的步骤
|
|-- log/
| |-- log.log # 日志文件
|
|-- requirements.txt # 存放软件依赖的外部Python包列表，详见https://pip.readthedocs.io/en/1.1/requirements.html
|-- README # 项目说明文件

settings.py

# settings.py
import os
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
DB_PATH = os.path.join(BASE_DIR, 'db', 'db.txt')
LOG_PATH = os.path.join(BASE_DIR, 'log', 'user.log')
# print(DB_PATH)
# print(LOG_PATH)

common.py

# common.py
import time
from conf import settings
def logger(msg):
current_time = time.strftime('%Y-%m-%d %X')
with open(settings.LOG_PATH, mode='a', encoding='utf-8') as f:
f.write('%s %s' % (current_time, msg))

src.py

# src.py
from conf import settings
from lib import common
def login():
print('登陆')
def register():
print('注册')
name = input('username>>: ')
pwd = input('password>>: ')
with open(settings.DB_PATH, mode='a', encoding='utf-8') as f:
f.write('%s:%s\n' % (name, pwd))
# 记录日志。。。。。。
common.logger('%s注册成功' % name)
print('注册成功')
def shopping():
print('购物')
def pay():
print('支付')
def transfer():
print('转账')
func_dic = {
'1': login,
'2': register,
'3': shopping,
'4': pay,
'5': transfer,
}
def run():
while True:
print("""
1 登陆
2 注册
3 购物
4 支付
5 转账
6 退出
""")
choice = input('>>>: ').strip()
if choice == '6': break
if choice not in func_dic:
print('输入错误命令，傻叉')
continue
func_dic[choice]()

run.py

# run.py
import sys
import os
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_DIR)
from core import src
if __name__ == '__main__':
src.run()

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!