py内的文件代码为例（附案例）

一、模块

模块可以看成是一堆函数的集合体。

一个py文件内部就可以放一堆函数，因此一个py文件就可以看成一个模块。

如果这个py文件的文件名为.py，模块名则是。

1、模块的四种方式

在中php源码安装到空间教程，总共有下列四种方式的模块：

2、为什么要用模块？二、如何用模块

通常我们使用和from......导入模块。

以下述spam.py内的文件代码为例。

# 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、模块名

语法如下：

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

登录后复制

导入的组件，访问必须加前缀。

首次导入模块出现了3件事：

注意：模块的重复导入会直接引用之前创造好的结果，不会重复执行模块的文件。

# 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

登录后复制

导入重命名：smt变量指向span模块的名称空间

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

登录后复制

导入多个模块

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

登录后复制

2、from模块名具体的变量

语法如下：

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

登录后复制

这个声明不会把整个组件导入到当前的命名空间中，它只会将模块里的一个或多个函数引入进来。

from......导入的组件，访问不应该加前缀。

from......首次导入模块出现了3件事：

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

登录后复制

rom&;*语句：导入文件内所有的功能：

# 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、循环导入

以下状况会发生循环导入：

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

登录后复制

可以使用变量定义阶段只辨识语法的特点解决循环导入的弊端，或从本质上缓解循环导入的弊端，但是最好的解决办法是不要发生循环导入。

方案一：

# 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'

登录后复制

方案二：

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、dir()函数

内置的变量dir()可以找到模块内定义的所有名称。以一个数组串列表的形式返回:

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']

登录后复制

如果没有给定参数，那么dir()变量会罗列出当前定义的所有名称:

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']

登录后复制

三、模块搜索模式1、导入模块时查找模块的次序1、先从存储中尚未导入的组件中寻求

如果我们在运行run.py文件的之后，快速删除mmm.py文件，我们会看到文件会再次运行，而不会报错，因为mmm已经被导入内存当中。如果我们再一次运行run.py时会报错，因为mmm.py已经被删除了。

# test.py
import m1 # 从m1.py文件中导入的,然后会生成m1模块的名称空间
import time
# 删除m1.py文件,m1模块的名称空间仍然存在
time.sleep(10)
import m1 # 不报错,一定不是从文件中获取了m1模块,而是从内存中获取的

登录后复制

2、内置的模块

验证先从内置中找，不会先找自定义的time.py文件。

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

登录后复制

3、环境变量sys.path中找（指出：sys.path的第一个值是当前执行文件的所在的文件夹）

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

登录后复制

如果mmm.py在C:\\\day16路径下，而执行文件模式为C:\\，如果普通导入一定会报错，我们可以把C:\\\day16添加到环境变量sys.path中，防止报错。

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

登录后复制

2、搜索模式以执行文件为准

假设我们有如下目录结构的文件，文件内代码分别是：

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

from aa import spam
print(spam.money)

登录后复制

四、文件的两种功能

一个模块被另一个程序第一次启用时php源码安装到空间教程，其主程序将运行。如果我们想在模块被采用时，模块中的某一程序块不执行，我们可以用属性来使该程序块仅在该组件自身运行时执行。

文件总共有两种功能，一种是执行文件；另一种是被当作模块导入。

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

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

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

登录后复制

2、aaa.py被只是可执行文件时，加上==''，单独运行aaa.py才会执行aaa.py中的f1()。run.py运行时可以避免执行f1()。

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

登录后复制

五、包

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

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

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

在导入一个包的之后，会按照sys.path中的目录来寻求这个包中包括的子目录。

导入包出现的三件事：

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

1、两种方法导入：

2、导入包内的模块

可以经常只导入一个包上面的特定组件，他需要使用全名去访问。

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

登录后复制

形式不能导出数组、变量：aaa.bbb.m3.f3错误

3、from方式：导入模块内详细的模块

这些方法不应该那些冗长的前缀进行访问

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...*

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

此处有一个实例，在:file://.py中包括如下代码:

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

登录后复制

这表示当你使用fromsound.*这种用法时，你只会导入包上面这三个子模块。

六、软件开发的目录规范

为了提升程序的可读性与可维护性，我们必须为工具设计良好的目录结构，这与完善的编码风格同等重要，简而言之就是把硬件代码分文件目录。假设你要写一个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 # 项目说明文件

登录后复制

.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)

登录后复制

.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()

登录后复制

以上就是基础之模块如何使用的具体内容，更多请关注php中文网其他相关文章！

本文来自网络，如有侵权请联系网站客服进行删除