第四章 Python常用模块

梦里梦外; 2021-09-25 04:16 323阅读 0赞

# 第四章 常用模块 #

## 4.1 模块介绍 ##

### 4.1.1 模块及其好处 ###

随着我们代码写的越来越多，功能越来越复杂，我们发在一个文件里维护就比较麻烦。所以我们就把不同的代码放在不同的py文件里，比如我们把连接数据库和后端和Web界面代码分开放。

一个py文件就可以当做最小的模块。模块最大的好处就是提高代码的利用率，而且避免了函数名、变量名的冲突（`a.py`下的`calc()`函数和`b.py`下的`calc()`函数不会有任何问题，导入使用的时候也不会产生冲突）

问题来了，就是我们应该怎么导入，这个我们下面马上来介绍。

### 4.1.2 模块的种类 ###

那在如何导入之前，我们介绍一下模块的分类。

模块分为三种：

*  内置模块、标准模块：安装好Python后，自带的模块，大约300多个
 *  第三方模块：全球用Python的大佬会将自己写的模块上传到社区中，供全球使用，目前总共有18w多
 *  自定义模块：自己写的，就是自己写的py文件，我们开头一开始说到的就是自定义模块。

### 4.1.3 模块的导入 ###

# 导入
    import os	# 导入
    print(os.path)	# 调用os中的变量和函数方法
    
    # 导入多个模块
    import os, sys
    
    # 前面的导入是导入模块中的所有东西，我们也可以导入一个模块中的单个东西
    from os import rename	# 导入os中的rename方法
    rename('', '')	# 不用os.rename()了
    # 导入多个方法也是同理
    # from os import rename, replace, ...
    
    # 导入模块的东西下的东西也可以
    from os.path import curdir	# 导入os模块path下的curdir
    
    # 另外，我们还可以给导入的东西重命名
    from asyncio.events import get_event_loop_policy as get_event
    get_event()  # 这样我们就可以用新的名字用了，一般是防止名字太长，才重命名
    
    # 导入模块下所有东西（不推荐使用）
    from os import *	# 和import os的不同的是，我们不用调用
    rename()	# 不用os.rename()
    # 因为from os import *导入的所有东西不用调用，就会和其他导入的模块或者你自己写的东西冲突，致使你的代码很乱

模块的导入一般全写在开头，不要在代码中间或其他地方乱写，不方便维护

### 4.1.3 自定义模块 ###

放在同目录下的两个py文件的调用

# file_1.py
    def say_hi(name):
        print('hi, ', name)
    # file_2.py
    import file_1	# pycharm可能会提示错误，不用管，我们下面解释
    file_1.say_hi('zm') 	# 输出hi, zm

但是，我们在其他地方就导入不了`file_1.py`了，而且上面的代码中自定义模块的导入pycharm也会提示错误，这些问题到底是什么原因？

因为Python默认的查找路径是固定的，从开发社区下载的第三方库都放在`site-packages`中，标准库放在第三方库的上层目录。我们在cmd中进入python，导入`os`库，打印`os.path`，我们可以看到第一个元素是空，就代表当前目录，所以`import`每次先找同目录下的，然后接着找标准库、第三方库那里，都没找到就报错。

所以我们想让所有程序在任何地方都可以调用到我们自己写的模块，我们就要把那个模块的py文件放到`site-packages`下

### 4.1.4 安装第三方模块 ###

pip或者pip3

pip install 模块名
    或者
    pip3 install 模块名

这个方法的前提条件是必须要有python的环境变量。

不过python的pip默认是去国外的python社区下载，可能会很慢或者链接不上，所以我们可以使用国内的python镜像网站，一般是豆瓣源或者是清华源，具体可以去CSDN找方案。

pip的卸载：

pip uninstall

显示安装过的库：

pip list
    或者
    pip freeze

## 4.2 常用模块应用 ##

### 4.2.1 os & sys——系统调用 ###

#### os ####

*  `getcwd()`：获取当前py文件的目录路径；
 *  `listdir()`：获取指定目录下的所有文件和目录名；
 *  `os.path.isfile()`：判断指定路径是否是文件；
 *  `os.path.isdir()`：判断是否是一个目录；
 *  `os.path.isabs()`：判断是否为绝对路径；
 *  `os.path.exists()`：检测地址是否真的存在；
 *  `os.path.abspath()`：获取绝对路径；
 *  `os.name`：显示你正在使用的操作系统（Windows是nt，Linux/Uinux是posix）；
 *  `os.rename(old, new)`：文件重命名；
 *  `os.replace(old, new)`：替换文件；
 *  `os.makedirs()`：创建多级目录，eg：`os.makedirs(r'\python\test')`，在当前目录下创建python文件夹，其中包含子文件夹test；
 *  `os.mkdir()`：创建单级目录，eg：`os.mkdir('python')`，在当前目录下创建python文件夹，但是创建多级目录就不行，会报错；
 *  `os.stat(file)`：获取文件属性；
 *  `os.path.getsize(filename)`：获取文件大小；

#### sys ####

*  `argv()`：命令行参数，以list的形式返回，list中第一个参数是程序本身的路径，前面用到过；
 *  `exit()`：`exit()`这个方法Python可以不导入就可以用，而且功能差不多，所以可以忽略；
 *  `maxint()`：获取最大的int值；
 *  `path()`：返回python模块的搜索路径；
 *  `platform()`：返回程序运行的操作系统；
 *  `getrecursionlimit()`：获取最大递归层数；
 *  `getdefaultencoding()`：获取Python解释器的编码；
 *  `getfilesystemencoding()`：获取内存数据存到文件里的默认编码。

#### 模块调用需要注意 ####

import os
    # abspath(__file__)可以获得当前py文件的绝对路径
    print(os.path.abspath(__file__))
    print(os.path.dirname(os.path.abspath(__file__)))

### 4.2.2 time等——时间处理 ###

时间模块的使用还是比较多的，我们写程序对时间的处理归为以下三种：

*  时间的显示：在屏幕显示、或者日志记录。
 *  时间的转换：吧字符串格式的日期转换成Python中可以运算的日期类型
 *  时间的运算：计算两个日期间的差值。

#### 时间通常的表示格式 ####

*  时间戳：timestamp，表示的是从1970年1月1号0点按秒开始计算到现在的秒数。1970年是第一次Unix操作系统的诞生。python中用`time.time()`获取当前时间戳。
 *  格式化的字符串：比如`"2020-10-03 17:54"`
 *  元组（`struct_time`）：一共九个元素。由于Python的time模块的实现主要调用的是C语言的库，所以各个操作系统可能会有所不同，Windows上：`time.struct_time`为`time.struct_time(tm_year=2020, tm_mon=11, tm_mday=22, tm_hour=15, tm_min=53, tm_sec=11, tm_wday=6, tm_yday=327, tm_isdst=0)`  
    ![struct\_time元组各元素含义][struct_time]
 *  UTC时间：格林威治时间，世界标准时间，在中国为UTC+8，东8区。DST（`Daylight Saving Time`）即为夏令时。

#### time ####

*  `time.localtime([secs])`：将一个时间戳转换为**当前时区**（中国全部都是东8区）的`struct_time`元组。不写参数默认是当前时间；
 *  `time.gmtime([secs])`：和`localtime()`类似，和`localtime`差八个小时，时区不一样。同样，不写参数也默认是当前时间；
 *  `time.mktime()`：将`struct_time`元组转换成时间戳，和上面相反；
 *  `time.sleep(secs)`：程序停几秒钟，单位为秒；
 *  `time.asctime([t])`：用的不多，将`struct_time`元组传入，返回英文格式的时间字符串；
 *  `time.ctime()`：将时间戳传入，返回英文格式的时间字符串；
 *  `time.strftime(format, [t])`：格式化字符串，可以按我们想要的格式来输出时间，eg：`time.strftime("%Y.%m-%d %H:%M %p", time.localtime())`，输出结果为2020.11-22 16:11 PM；
 *  `time.strptime()`：和`strftime()`相反，eg：`time.strptime('2020/04/01 19:30', "%Y/%m/%d %H:%M")`，然后就可以获得相应的时间戳。

字符串转时间格式对应表：  
![字符串转时间格式对应表][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Fuc19taW4_size_16_color_FFFFFF_t_70_pic_center]

time中时间格式的转换图：  
![time中时间格式的转换图][time]

#### datetime ####

`datetime`比`time`更加直观、更加容易调用。`time`一般用来格式化时间输出或者获取时间戳；`datetime`更多用来计算时间。

`datetime`模块分为五种数据类型，分别是`date`、`datetime`、`time`、`timedelta`、`tzinfo`。

`date`：

*  `datetime.date.today()`：获取当前时间，输出一般为`datetime.date(2020, 11, 22)`
 *  `datetime.date.timetuple(date)`：将上面的`date`格式转化成`struct_time`元组，eg：`datetime.date.timetuple(datetime.date.today())`，输出：`time.struct_time(tm_year=2020, tm_mon=11, tm_mday=22, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=6, tm_yday=327, tm_isdst=-1)`
 *  `datetime.date.ctime()`：和`time.ctime()`一样，输出英文的时间格式
 *  `datetime.date.fromtimestamp()`：把时间戳转换成`date`类型

`time`：`date`输出年月日，`time`输出的是小时分钟秒等时间信息。

`datetime`：

*  `datetime.datetime.now()`：获取当前时间，类型为`datetime`类型，eg：`datetime.datetime(2020, 11, 23, 10, 57, 48, 525775)`
 *  `datetime.datetime.fromtimestamp()`：将时间戳转换成`datetime`类型

`timedelta`：

*  `datetime.timedelta()`：参数格式为默认参数，可以传入的参数有天数、毫秒和秒。eg：
    
        import datetime
        now_time = datetime.datetime.now()	# 获取当前时间
        the_time = now_time - datetime.timedelta(days=3, hours=4, minutes=5) 	# 将当前时间减去3天4小时5分钟 # 参数写负数也可以

时间替换：

`time1.replace(year=2000, month=1, day=1)`，上面的`date`、`time`、`datetime`类型都可以用这个来进行时间的替换。

`tzinfo`：与时区有关的，在金融行业的工作和时区比较常使用

`pytz`这个模块就是与时区相关的模块，`pytz.all_timezones()`输出所有时区，`pytz.all_timezone(地区)`就可以获取时区，`t1 = pytz.all_timezone('Asia/Shanghai')`获取之后，然后`datetime.datetime.now(tz=t1)`，就可以生成指定时区的时间。

### 4.2.3 random——随机 ###

#### py文件的命名 ####

py文件的命名别和内置模块名重复，不然会冲突。

#### random的方法 ####

*  `random.randint(1, 10)`：返回1到10（包括10）的一个随机数；
 *  `random.randrange(1, 10)`：返回1到10（不包括10）的一个随机数；
 *  `random.random()`：返回一个0到1之间的随机浮点数；
 *  `random.choice(the_str)`：返回给定字符串中的一个随机字符，列表、元组也可以，但`set`和`dict`不可以；
 *  `random.sample(the_str, num)`：返回num个字符串中的随机字符（列表、集合、元组都可以，字典不行），以列表形式返回；
    
        # 随机验证码
        import string
        import random
        	print(''.join(random.sample(string.digits+string.ascii_lowercase, 5)))
 *  `random.shuffle(the_list)`：将列表数据打乱，会默认修改原来的列表数据，修改成打乱的列表数据，数据就只能是列表。

### 4.2.4 pickle——序列化 ###

#### pickle ####

我们知道，字符串是可以写入文件的，因为Python自动帮我们将字符串通过编码转换写入硬盘，但是像字典、列表、集合、元组这些数据怎么存进硬盘呢？这是就涉及到序列化的知识点。

序列化即是：将字典、列表这些数据序列化转成硬盘能认识的数据类型，比如说16进制的字节。

d = { 
        "name": "alex",
        "role": "police",
        "blood": 76,
        "weapon": "AK47",
    }
    
    d_dump = pickle.dumps(d)	# 序列化，返回16进制的字节
    print(d_dump)
    print(pickle.loads(d_dump))		# 反序列化
    
    f = open("game.pkl", "wb")
    # f.write(d_dump)
    pickle.dump(d, f)	# 和write一样，将
    f.close()
    
    f = open("game.pkl", "rb")
    # f.read()
    pickle.load(f)	# 先取先dump进去的
    pickle.load(f)	# 取第二次dump进去的
    # pickle.load(f) # 没数据时就报错
    
    # dump写入文件，load读出文件；
    # dumps是生成序列化的字符串，loads将序列化的字符串反序列化解析

当然，上面的演示代码我们`dump`和`load`了好几次，在实际开发中我们建议`dump`一次，`load`一次，不然程序很大的话，你也记不住程序到底`dump`了几次。我们可以将需要写入文件的序列化数据存在一个列表（或其他）里，然后`dump`这个列表，即可实现一次`dump`多个需要序列化的数据了。

我们将序列化的数据写入文件，文件肯定会产生乱码，因为这是通过`pickle`的规则转化的`bytes`数据，和编码的格式肯定不同，只要我们读出来不是乱码就说明数据没有被破坏，这点需要注意一下。

#### json vs pickle ####

除了`pickle`，`json`也是用来序列化的模块。他们最大的区别就是：json各种语言都能用，但是只支持`str`、`int`、`dict`、`set`、`list`、`tuple`这些基本的数据类型，以后写东西需要跨语言，就会用到`json`；`pickle`是Python专属的，支持Python所有的数据类型，比如`function`、`datetime`、`class/object`全都可以。

# json
    d = { 
        "name": "alex",
        "role": "police",
        "blood": 76,
        "weapon": "AK47",
    }
    
    print(json.dumps(d))	# dict变成了字符串
    print(type(json.dumps(d)))	# <class 'str'>
    
    with open("test.json", "w") as f:
        json.dump(d, f)
    with open("test.json", 'r') as f:
        json.load(f)

注意：`json`如果`dump`多次，`load`就会报错，因为`json`不支持多次`dump`。

而且我们可以注意到`json`和`pickle`的另一个区别：

`json`是将字典、列表这些数据先转化成字符串，然后再通过编码存入硬盘，所以我们可以看到我们json转化的时候点开文件我们看不到乱码。另外，`json`这样的方式耗费的空间比`pickle`小。

以后我们尽量使用`json`，因为`json`用的比较多，`pickle`基本不怎么用，知道就好。

### 4.2.6 hashlib——加密 ###

hash，也就是散列或者哈希，不同的值映射出来的可以是相同的（数据量极大的情况下会出现，又称**哈希碰撞**）

#### MD5 ####

我们每次进Python时，对相同数据的`hash`值都会不一样，从而hash不能直接用来加密，所以我们需要确保`hash`输出的值是稳定的，所以MD5（讯息摘要演算法）诞生了。

功能：

1.  任意长度 -> 固定的长度；
2.  不同数据会得出不同MD5值（极小可能会重复）

特点：

*  压缩性；
 *  容易计算；
 *  抗修改性；
 *  强抗碰撞（极小可能会重复）。

MD5算法和hash一样，是不可逆的。

用途：

1.  防止被篡改。
2.  防止直接看到明文。
3.  数字签名。

用法：

import hashlib
    m = hashlib.md5()	# 开启md5加密（创建md5的一个对象）
    m.update("Hello world".encode('utf-8'))		# 传入加密数据
    m.update("asd".encode('utf-8'))
    # print(m.digest()) # 加密，返回byte，不常用
    print(m.hexdigest())	# 加密，返回16进制（常用）
    
    # 多个update是放一块加密的，直接拼一起
    m2.hashlib.md5()
    m2.update("Hello worldasd".encode('utf-8'))
    print(m2.hexdigest())	# 和上面的m.hexdigest()输出一样的值

注意，如果密码是纯数字或纯小写字符组成的密码，及有可能被撞库撞出来，就是一个一个试md5密文，已达到破解md5算法的目的。

一般网站通过在md5密文后再加上一些字节（俗称加盐），这样数据库被黑客攻击，黑客拿到的md5密文也不可能反推出原来对应的明文密码。

#### SHA ####

SHA对于2^64以内的数据会产生160位的消息摘要，比md5的128多了几十位，所以安全性比md5高一些。SHA是美国国家安全局设计的，目前最流行的是SHA-256。HTTPS就是基于SHA-256的，网站的加密是SSL2（以前是SSL1）也是基于SHA-256的。SHA-256是生成256位的消息摘要，更加难以破解。

用法和md5一样

s2 = hashlib.sha256()
    s2.update('zm'.encode('utf-8'))
    print(s2.hexdigest())

当然，SHA产生的消息摘要位数越多，加密耗费的时间也越多，所以md5一般用于文件校验，因为比较快；SHA-256一般就用在网站的安全维护上。

### 4.2.7 shutil——文件操作 ###

#### shutil ####

*  `shutil.copyfileobj(f1, f2)`：传入的参数必须是打开的文件就是说必须传进两个文件的对象（`f = open('filename', 'w', encoding='utf-8')`，`f`就是一个文件对象），将f1中的内容copy到f2中，不常用；
 *  `copyfile(old_filename, new_filename)`：传入两个文件名，新的文件如果和已有的文件重名就会被覆盖；
 *  `copymode()`：copy文件的权限，两个文件必须存在。将第一个文件的文件权限copy到第二个文件的文件权限，两个文件的权限改变，内容什么的都不变，不常用；
 *  `copystat()`：copy文件的状态，第二个文件必须存在，覆盖掉第二个文件的创建时间啥的文件状态，用的也不多；
 *  `copy()`：创建一个文件，然后copy权限和文件内容`copyfile()`和`copymode()`的结合；
 *  `copy2()`：copy文件内容和状态，`copyfile()`和`copystat()`的结合；
 *  `copytree()`：copy目录，新目录必须不存在，另外还可以设置`ignore`参数，可以设置不想要的文件。
    
        import shutil
        shutil.copytree("", "", ignore=shutil.ignore_patterns("", ""))
 *  `move(src, dst)`：如果第二个文件夹存在，移动文件`src`文件夹下的所有文件到`dst`文件夹下，如果第二个文件夹不存在，那`move()`本质上就是重命名；
 *  `rmtree(src)`：删除文件`src`文件夹下的所有文件；
 *  `make_archive(base_name, format, root_dir)`：`base_name`是压缩包的文件名，`format`是压缩的格式（`zip`、`tar`等），`root_dir`是需要压缩的文件夹；

#### zipfile&tarfile ####

`shutil.make_archive()`是基于`zipfile`和`tarfile`写出来的，这里我们就顺便来看看这两个模块。

import zipfile
    import tarfile
    
    # zip文件压缩
    with zipfile.ZipFile('test.zip', 'w') as z:
        z.write('test.txt')
        z.write('web.log')
    
    # zip文件解压
    with zipfile.ZipFile('test.zip', 'r') as z:
        z.extractall('new/zip/')
    
    # tar文件压缩
    with tarfile.TarFile('test.tar', 'w') as t:
        t.add('test.txt')
        t.add('web.log')
    
    # tar文件解压
    with tarfile.TarFile('test.tar', 'r') as t:
        t.extractall('new/tar/')

### 4.2.8 re——正则表达式 ###

#### 入门 ####

正则表达式是一个很重要的一个知识点，在我们后面的web开发（Python的Django）中大量用到。

首先我们有一个需求，就是读取文件中的所有手机号

# test.txt
    朱明 12345611233
    王芝伟 13265411344
    # test.py
    with open('test.txt', 'r') as f:
        phone_list = []
        for line in f:
            name, phone = line.split(' ')
            if phone[0] == '1':
                phone_list.append(phone)

现在我们有一个更加简便的方法。

import re
    with open('test.txt', 'r') as f:
        phone_list = re.findall('[0-9]{11}]', f.read())
    print(phone_list)

这就是正则表达式，你几行的代码瞬间可以写成一行代码。

#### 匹配语法 ####

那学习正则表达式的语法之前呢，我们先来学习`re`的匹配语法，分为以下几种：

*  `re.match(pattern, string, flags=0)`：从起始位置开始根据模型去字符串中匹配指定内容，匹配开头的字符是否符合指定内容，不常用；
 *  `re.search(pattern, string, flags=0)`：根据模型去字符串中匹配指定内容，匹配到一个符合就返回，不往下找了；
 *  `re.findall(pattern, string, flags=0)`：`match()`和`search()`均用于匹配单值，即：只能匹配字符串中的一个，如果想要匹配到字符串中所有符合条件的元素，则需要使用 `findall()`；
 *  `re.split(pattern, string, maxsplit=0, flags=0)`：用匹配到的值做为分割点，把值分割成列表，eg：`split("[0-9]", "asd1asd2asd3zxc")`，输出的是`['asd', 'asd', 'asd', 'zxc']`；
 *  `re.sub(pattern, string, flags=0)`：用于替换匹配的字符串，比`str.replace()`功能更加强大，eg：`sub("abc", "ABC", "abcdef", count=2)`，输出`ABCdef`，`count`是指最多寻找几次；
 *  `re.fullmatch(pattern, string, flags=0)`：全部匹配，和`findall()`类似，不过返回的是match类型的数据需要`group()`来处理输出。

#### 表达式规则 ####

*  `.`：匹配任意一个字符（除了`\n`，其他符号都可以匹配），比如`print(search('.', 'zm123'))`返回的是`<re.Match object; span=(0, 1), match='z'>`，要输出的话必须加一个`group()`，`print(search('.', 'zm123').group())`输出的就是`z`；
 *  `^`：匹配字符的开头，比如\`\`
 *  `$`：匹配字符的结尾
 *  `*`：从开头匹配一个字符0次或多次，0次返回的不是None，返回`<re.Match object; span=(0, 1), match=''>`
 *  `+`：
 *  `?`：匹配一个字符0次或1次；
 *  `{m}`：匹配m次；
 *  `{m, n}`：匹配m到n次包括m和n；
 *  `|`：或，匹配左边的字符或者右边的字符；
 *  `(...)`：分组匹配；
 *  `[]`：比如`[a-z]`匹配所有小写字符，`[A-Z]`匹配所有大写，`[a-zA-Z0-9]`匹配所有小写大写和数字；
 *  `\A`：只从字符开头匹配，像`search('\Aabc', 'zmabc')`返回的就是None，相当于`match()`；
 *  `\Z`：匹配字符结尾；
 *  `\d`：匹配数字0-9；
 *  `\D`：匹配非数字；
 *  `\w`；匹配a-z，A-Z和0-9的字符；
 *  `\W`；匹配非`[a-zA-Z0-9]`
 *  `s`：匹配空白字符、\\t、\\n、\\r；
 *  `(?P<name>...)`：分组匹配，比如分组读取身份证号：`re.search(([0-9]{3})([0-9]){3}(0-9){4}, '身份证号')`，然后`groups()`输出分组的数据；我们还可以起名字：`re.search((?P<province>[0-9]{3})(?P<city>[0-9]{3})(?P<year>(0-9){4}), '身份证号')`然后用`groupdict()`输出字典。

当需要筛选的字符串中包含`-`、`+`、`*`等语法字符时，我们可以在其前面加`\`来表示非语法字符。

那这些`match`、`search`、`findall`等等几个匹配语法，都有解析正则表达式的需要，`re`模块的设计者也将这部分的功能独立编写了函数`compile()`，我们可以在需要大量解析正则表达式的时候，统一`compile()`，然后再用`match`、`search`这些方法，传入参数只需要所分析的数据就好了。

#### flags ####

在上面match、search等匹配语法中，都有一个叫flags的参数，Flags被称作标志符，有几个固定的值

*  `re.I`：忽略大小写
 *  `re.M`：多行模式，改变`^`和`$`。eg：`re.search('^zm', 'mack\nzmghd')`返回`None`，但是我们加上多行模式，就可以匹配到数据了，`re.search('^zm', 'mack\nzmghd', re.M)`就会输出找到的`zm`。`re.M`用的不多，知道即可；
 *  `re.S`：改变`.`的行为，原本`.`不能匹配出`\n`，但是加上这个就可以匹配了；
 *  `re.X`：加注释，注释语法和Python是一样的，一般写的太复杂时会用。

#### 练习 ####

1.  验证手机号是否合法；
    
        import re
        
        phone = input('请输入字符：').strip()
        # 用fullmatch是为了字符总长度需为11，用findall就不会有总长11的限制
        if re.fullmatch('[0-9]{11}', phone) and re.search('^1', phone):
            print('手机号码符合标准')
        else:
            print('输入字符不合法')
2.  验证邮箱是否合法；
    
        import re
        
        mail = input('请输入字符：').strip()
        
        if re.fullmatch('\d+@(qq|chzu)\.(com|edu|cn)', mail):
            print('合法')
        else:
            print('不合法')
3.  开发一个简单的python计算器，实现加减乘除及括号优先级解析，比如`1-2*((60-30+(-40/5)*(9-2*5/3+7/3*99/4*2998 +10*568/14))-(-4*3)/(16-3*2))`。

## 4.3 软件项目设计规范 ##

### 4.3.1 项目目录设计规范 ###

#### 目录设计规范的好处 ####

我们设计一个层次清晰的目录结构，就是为了达到以下两点：

*  可读性高
 *  可维护性高

这里看个大概就好了，我们后面写比较大的程序时，自己亲手写几遍就会了。

#### 好的目录组织方式 ####

假设现在我们写一个Foo的大项目，推荐的文件结构如下：

*  `bin/`：放一些可执行的文件，当然你也可以起名`script/`之类的也可；
 *  `foo/`：存放项目的所有源代码；
    
     *  源代码中所有模块、包都应该放这里；
     *  子目录`test/`存放单元测试代码；
     *  程序的入口最好命名为`main.py`。
 *  `doc/`：存放一些文档；
 *  `setup.py`：安装、部署、打包的脚本；
 *  `requirements.txt`：存放软件依赖的外部Python包列表，有一个pip命令可以快速生成电脑的python环境信息：
    
        pip freeze > requirements.txt
 *  `README.md`：项目说明文件。

当然，还有更多的规范内容，比如`LICENSE.txt`、`ChangeLog.txt`等，他们是项目开源时需要用到的，开源软件的目录组织可以参考[这篇文章][Link 1]。

#### 关于README ####

这个文件主要目的是让读者快速熟悉代码的主要功能和一些重要信息，需要说明以下几点：

1.  软件定位：软件的基本功能。
2.  运行代码的方法。安装环境、启动命令等。
3.  简要的使用说明。
4.  代码目录结构说明，更详细可恶意说明软件的基本原理。
5.  常见问题说明。

#### 关于requirements.txt ####

这里就写一些调用的库，包括库名和版本。

#### 关于setup.py ####

setup.py是来管理代码的打包、安装、部署问题。业界标准的写法是用Python流行的打包工具[setuptools][]来管理这些事情。

不过，我们初学的时候不是让我们养成用标准化的工具来解决这些问题，而是要知道一个项目一定要有一个安装部署的工具，能让自己的代码在一台新机器上迅速将环境装好、代码部署好，最后可以使程序正常运行起来。可以类比理解安装包中的Setup可执行文件的功能。

#### 配置文件 ####

即是`settings.py`，就是将一些全局常量写在这里面，eg：比如IP地址、协议号、字符编码格式等等，然后需要调用时，就写个`import 路径.setting.py`就OK了。

后面写到很大的程序时，我们后面再细说，这些东西刚上手时很不习惯，但是工作开发中日常会用，试写个几遍就好了。

# 回到目录 #

链接：[0基础学习Python笔记目录整理][0_Python]

[struct_time]: /images/20210923/5f806c26f6b6410dbb6a02f5e8cb0203.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Fuc19taW4_size_16_color_FFFFFF_t_70_pic_center]: /images/20210923/45f4d65828c146fd9f754697127709bf.png
[time]: /images/20210923/06c44084b39d4befa24fcd1d16f0e9fc.png
[Link 1]: http://www.jeffknupp.com/blog/2013/08/16/open-sourcing-a-python-project-the-right-way/
[setuptools]: https://pythonhosted.org/setuptools/setuptools.html#developer-s-guide
[0_Python]: https://blog.csdn.net/Ans_min/article/details/112740165