python模块
sys模块
2022年7月12日
21:13
sys.argv：
参数字符串列表（动态对象），第一个参数为当前程序主文件的绝对路径或空字符串，如果在命令提示符界面给``Python``文件传了参数（不同的参数以空格分隔，无论传入的时候写的是什么类型，最终都会转成字符串），可以在这里面获取（从第二个位置开始），比如命令提示符中运行``“``python main.py 111 aaa``”``，那``sys.argv``就有三个元素，第二个和第三个元素分别为``“``111``”``和``“``aaa``”``。
返回传递给`` Python ``脚本的命令行参数列表。看下示例：
Import sys
if__name__=='__main__':
args=sys.argvprint(args)
print(args[1])
上面文件名为：``test.py``，我们在控制台使用命令：``python test.py 123 abc`` ``执行一下，执行结果如下：
['test.py','123','abc']123
sys.path：
搜索模块路径字符串列表（动态对象），搜索查找模块时会优先到这里面去搜索，第一个参数为主文件所在目录的路径或空字符串。
sys.modules：
已经加载的模块信息字典，key为模块名称，value为模块对象，在使用__import__导入模块时，可以先判断下是否有同名模块已经在sys.modules中加载了，如果已经存在了，可以先删除或者不再导入了。
以字典类型返回系统导入的模块。
sys.getsizeof(object)：
获取一个对象的内存占用字节数大小。
sys.getdefaultencoding()：
返回``Python``默认的字符串编码格式。
sys.exit([status])：
退出``Python``解释器，并抛出一个``SystemExit``异常，``status``默认为``0``，即``“``成功``”``，如果``status``是一个整数，则被用作一个系统退出状态，如果``status``是其他对象，则它将会被``print``并系统退出状态为``1``，即``“``失败``”``。所以使用这个方法的话，一般是需要进行异常处理的，运行完这条语句后如果有异常捕获和处理的，会去运行后面的异常处理代码的（而``os._exit()``方法则不会，它不会抛出异常）。
sys.excutable：
代码运行时表示运行的解释器绝对路径，如``C:\Python36\python.exe``，在打包的程序中就是``exe``程序文件的绝对路径，这个是用来定位用户运行该程序的真实位置。
version
返回`` Python ``解释器的版本信息。
winver
返回`` Python ``解释器主版号。
platform
返回操作系统平台名称。
path
返回模块的搜索路径列表。
maxsize
返回支持的最大整数值。
maxunicode
返回支持的最大`` Unicode ``值。
copyright
返回`` Python ``版权信息。
byteorder
返回本地字节规则的指示器。
executable
返回`` Python ``解释器所在路径。
Import sys
print(sys.version)
print(sys.winver)
print(sys.platform)
print(sys.path)
print(sys.maxsize)
print(sys.maxunicode)
print(sys.copyright)
print(sys.modules)
print(sys.byteorder)
print(sys.executable)
stdout
标准输出。看下示例：
import sys # ``下面两行代码等价
sys.stdout.write('Hi'+'\n')
print('Hi')
stdin
标准输入。看下示例：
import sys
s1=input()
s2=sys.stdin.readline()
print(s1)
print(s2)
stderr
错误输出。看下示例：
import sys
sys.stderr.write('this is a error message')
exit()
退出当前程序。看下示例：
import sys
print('Hi')
sys.exit()
print('Jhon')
getdefaultencoding()
返回当前默认字符串编码的名称。
getrefcount(obj)
返回对象的引用计数。
getrecursionlimit()
返回支持的递归深度。
getsizeof(object[, default])
以字节为单位返回对象的大小。
setswitchinterval(interval)
设置线程切换的时间间隔。
getswitchinterval()
返回线程切换时间间隔。
pip命令
2021年11月30日
13:23
pip使用
安装包
pip install package_name
查看某个已安装包
pip show --files package_name
检查哪些包需要更新
pip list --outdated
升级包
pip install --upgrade package_name
卸载包
pip uninstall package_name
八 安装包或者模块
可以通过pip或者easy_install安装。pip是现代化的一种安装包的方式，以下讲解pip的常用命令:
1.安装包
pip install requests
2. 安装指定版本的包
pip install django == 1.10.6
3.卸载包
pip uninstall django
4.升级包
pip install -U requests
列出可升级的包：
pip list --outdate
一行命令升级所有pip安装的Python包
pip freeze --local | grep -v ‘^-e‘ | cut -d = -f 1 | xargs pip install -U
建议在执行前先执行：
pip install -U distribute
5.升级pip
pip install -U pip
6.查看当前pip是哪个版本
pip --version
7.显示某个已安装的包的信息
pip show -f <包名>
8.列出当前环境下安装了哪些包
pip list
9. 将当前环境安装的包全部列出来放在文件中
pip freeze > requirements.txt
10.从某个文件中安装包
pip install -r requirements.txt
11.临时更改安装源，以豆瓣源为例
pip install <包名> -i https://pypi.douban.com/simple
12.永久更改安装源
windows操作系统：在当前用户目录下新建pip/pip.ini，然后在文件中添加以下代码：
[global]
index-url = https://pypi.douban.com/simple
Linux/Mac：在用户目录下新建.pip/pip.conf，然后在文件中添加以下代码：
[global]
index-url = https://pypi.douban.com/simple
# pip --help
Usage:
pip [options]
Commands:
install Install packages. ``安装包
download Download packages. ``下载包
uninstall Uninstall packages. ``卸载包
freeze Output installed packages in requirements format. ``按着一定格式输出已安装包列表
list List installed packages. ``列出已安装包
show Show information about installed packages. ``显示包详细信息
check Verify installed packages have compatible dependencies.``检查包的依赖关系是否完整
config Manage local and global configuration.``管理配置
search Search PyPI for packages.``搜索包
wheel Build wheels from your requirements.
hash Compute hashes of package archives.``计算包的hash值
completion A helper command used for command completion.
help Show help for commands.
General Options:
-h, --help Show help.
--isolated Run pip in an isolated mode, ignoring environment variables and user configuration.
-v, --verbose Give more output. Option is additive, and can be used up to 3 times.
-V, --version Show version and exit.
-q, --quiet Give less output. Option is additive, and can be used up to 3 times (corresponding to WARNING, ERROR, and CRITICAL logging levels).
--log <path> Path to a verbose appending log.
--proxy <proxy> Specify a proxy in the form [user:passwd@]proxy.server:port.
--retries <retries> Maximum number of retries each connection should attempt (default 5 times).
--timeout <sec> Set the socket timeout (default 15 seconds).
--exists-action <action> Default action when a path already exists: (s)witch, (i)gnore, (w)ipe, (b)ackup, (a)bort).
--trusted-host <hostname> Mark this host as trusted, even though it does not have valid or any HTTPS.
--cert <path> Path to alternate CA bundle.
--client-cert <path> Path to SSL client certificate, a single file containing the private key and the certificate in PEM format.
--cache-dir <dir> Store the cache data in <dir>.
--no-cache-dir Disable the cache.
--disable-pip-version-check
Don't periodically check PyPI to determine whether a new version of pip is available for download. Implied with --no-index.
--no-color Suppress colored output
os文件模块
2021年11月26日
15:09
获取指定文件夹下的目录和文件的实现
一、os.listdir 方法
os.listdir() 方法用于返回指定的目列表录下包含的文件或子目录的名字的。这个列表以字母顺序。其得到的是仅当前路径下的文件名，不包括子目录中的文件，如果需要得到所有文件需要递归。 它也不包括 '.' 和 '..' 即使它在目录中。
语法格式如下：
os.listdir(path)
案列：
def list_dir(file_dir):
'''
``通过`` listdir ``得到的是仅当前路径下的文件名，不包括子目录中的文件，如果需要得到所有文件需要递归
'''
print'\n\n<><><><><><> listdir <><><><><><>'
print "current dir : {0}".format(file_dir)
dir_list = os.listdir(file_dir)
for cur_file in dir_list:
# ``获取文件的绝对路径
path = os.path.join(file_dir, cur_file)
if os.path.isfile(path): # ``判断是否是文件还是目录需要用绝对路径
print "{0} : is file!".format(cur_file)
if os.path.isdir(path):
print "{0} : is dir!".format(cur_file)
list_dir(path) # ``递归子目录
os.walk 方法
os.walk() 方法用于通过在目录树中游走输出在目录中的文件名，向上或者向下。是一个简单易用的文件、目录遍历器，可以帮助我们高效的处理文件、目录方面的事情。
语法格式：
os.walk(top[, topdown=True[, onerror=None[, followlinks=False]]])
方法参数说明：
- top：要遍历的目录的路径
- topdown：可选，如果为 True，则优先遍历 top 目录，以及 top 目录下的每一个子目录，否则优先遍历 top 的子目录，默认为 True
- onerror: 可选， 需要一个 callable 对象，当 walk 异常时调用
- followlinks：可选， 如果为 True，则会遍历目录下的快捷方式(linux 下是 symbolic link)实际所指的目录，默认为 False
- args：包含那些没有 '-' 或 '--' 的参数列表
返回值: 三元组 (root, dirs, files)
- root ：所指的是当前正在遍历的目录的地址
- dirs ：当前文件夹中所有目录名字的 list (不包括子目录)
- files ：当前文件夹中所有的文件 (不包括子目录中的文件)
#文件名称
file_name=os.path.splitext(file)[0]
#文件根据‘。点’分割
返回一个列表，【0代表文件名字】【1为点之后的文件后缀名】
file_suffix=os.path.splitext(file)[1]
#文件具体绝对路径：文件的具体地址
具体到每一层目录，直到文件
file_path=os.path.join(root,file)
#文件相对路径：
结束是文件存在在某一级目录下，但是不具体
file_abs_path=os.path.abspath(file)
#文件父路径：文件在哪一层目录下
，结果给出的是文件的上一层目录
file_parent=os.path.dirname(file_path)
其他跟文件相关的常用方法
分离文件名和扩展名
os.path.splitext()：
file = "file_test.txt"
file_name = os.path.splitext(file)[0] # ``输出：``file_test
file_suffix = os.path.splitext(file)[1] # ``输出：``.txt
判断文件或目录是否存在
os.path.exists()：
判断是否是文件
os.path.isfile()：
判断是否是目录
os.path.isdir()：
获取当前文件所在的目录，即父目录
os.path.dirname()：
创建多级目录
os.makedirs()：
创建单级目录
os.mkdir()：
获取文件大小
os.path.getsize()：
路径相同重命名文件或目录，从 src 到 dst，路径不同移动
若是路径不同还文件名字也不同这是吧src的文件，移动并重命名到dst中
os.rename(src, dst)
删除路径为path的文件。
如果path 是一个文件夹，将抛出OSError; 查看下面的
os.remove(path)
删除path指定的空目录，如果目录非空，则抛出一个OSError异常。
os.rmdir(path)
a文件复制到b目录
import shutil
Shutil.Copyfile(a,b)
os.getcwd() ``获取当前工作目录，即当前``python``脚本工作的目录路径`
`os.chdir("dirname") ``改变当前脚本工作目录；相当于``shell``下``cd`
`os.curdir ``返回当前目录``: ('.')`
`os.pardir ``获取当前目录的父目录字符串名：``('..')`
`os.makedirs('dirname1/dirname2') ``可生成多层递归目录`
`os.removedirs('dirname1') ``若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推`
`os.mkdir('dirname') ``生成单级目录；相当于``shell``中``mkdir dirname`
`os.rmdir('dirname') ``删除单级空目录，若目录不为空则无法删除，报错；相当于``shell``中``rmdir dirname`
`os.listdir('dirname') ``列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印`
`os.remove() ``删除一个文件`
`os.rename("oldname","newname") ``重命名文件``/``目录`
`os.stat('path/filename') ``获取文件``/``目录信息`
`os.sep ``输出操作系统特定的路径分隔符，``win``下为``"\\",Linux``下为``"/"`
`os.linesep ``输出当前平台使用的行终止符，``win``下为``"\t\n",Linux``下为``"\n"`
`os.pathsep ``输出用于分割文件路径的字符串`` win``下为``;,Linux``下为``:`
`os.name ``输出字符串指示当前使用平台。``win->'nt'; Linux->'posix'`
`os.system("bash command") ``运行``shell``命令，直接显示`
`os.environ ``获取系统环境变量`
`os.path.abspath(path) ``返回``path``规范化的绝对路径`
`os.path.split(path) ``将``path``分割成目录和文件名二元组返回`
`os.path.dirname(path) ``返回``path``的目录。其实就是``os.path.split(path)``的第一个元素`
`os.path.basename(path) ``返回``path``最后的文件名。如何``path``以／或``\``结尾，那么就会返回空值。即``os.path.split(path)``的第二个元素`
`os.path.exists(path) ``如果``path``存在，返回``True``；如果``path``不存在，返回``False`
`os.path.isabs(path) ``如果``path``是绝对路径，返回``True`
`os.path.isfile(path) ``如果``path``是一个存在的文件，返回``True``。否则返回``False`
`os.path.isdir(path) ``如果``path``是一个存在的目录，则返回``True``。否则返回``False`
`os.path.join(path1[, path2[, ...]]) ``将多个路径组合后返回，第一个绝对路径之前的参数将被忽略`
`os.path.getatime(path) ``返回``path``所指向的文件或者目录的最后存取时间`
`os.path.getmtime(path) ``返回``path``所指向的文件或者目录的最后修改时间`
`os.path.getsize(path) ``返回``path``的大小
Python OS 文件/目录方法
os 模块提供了非常丰富的方法用来处理文件和目录。常用的方法如下表所示：
| 序号 | 方法及描述 |
|---|---|
| 1 | os.access(path, mode) 检验权限模式 |
| 2 | os.chdir(path) 改变当前工作目录 |
| 3 | os.chflags(path, flags) 设置路径的标记为数字标记。 |
| 4 | os.chmod(path, mode) 更改权限 |
| 5 | os.chown(path, uid, gid) 更改文件所有者 |
| 6 | os.chroot(path) 改变当前进程的根目录 |
| 7 | os.close(fd) 关闭文件描述符 fd |
| 8 | os.closerange(fd_low, fd_high) 关闭所有文件描述符，从 fd_low (包含) 到 fd_high (不包含), 错误会忽略 |
| 9 | os.dup(fd) 复制文件描述符 fd |
| 10 | os.dup2(fd, fd2) 将一个文件描述符 fd 复制到另一个 fd2 |
| 11 | os.fchdir(fd) 通过文件描述符改变当前工作目录 |
| 12 | os.fchmod(fd, mode) 改变一个文件的访问权限，该文件由参数fd指定，参数mode是Unix下的文件访问权限。 |
| 13 | os.fchown(fd, uid, gid) 修改一个文件的所有权，这个函数修改一个文件的用户ID和用户组ID，该文件由文件描述符fd指定。 |
| 14 | os.fdatasync(fd) 强制将文件写入磁盘，该文件由文件描述符fd指定，但是不强制更新文件的状态信息。 |
| 15 | [os.fdopen(fd, mode[, bufsize]]) 通过文件描述符 fd 创建一个文件对象，并返回这个文件对象 |
| 16 | os.fpathconf(fd, name) 返回一个打开的文件的系统配置信息。name为检索的系统配置的值，它也许是一个定义系统值的字符串，这些名字在很多标准中指定（POSIX.1, Unix 95, Unix 98, 和其它）。 |
| 17 | os.fstat(fd) 返回文件描述符fd的状态，像stat()。 |
| 18 | os.fstatvfs(fd) 返回包含文件描述符fd的文件的文件系统的信息，像 statvfs() |
| 19 | os.fsync(fd) 强制将文件描述符为fd的文件写入硬盘。 |
| 20 | os.ftruncate(fd, length) 裁剪文件描述符fd对应的文件, 所以它最大不能超过文件大小。 |
| 21 | os.getcwd() 返回当前工作目录 |
| 22 | os.getcwdu() 返回一个当前工作目录的Unicode对象 |
| 23 | os.isatty(fd) 如果文件描述符fd是打开的，同时与tty(-like)设备相连，则返回true, 否则False。 |
| 24 | os.lchflags(path, flags) 设置路径的标记为数字标记，类似 chflags()，但是没有软链接 |
| 25 | os.lchmod(path, mode) 修改连接文件权限 |
| 26 | os.lchown(path, uid, gid) 更改文件所有者，类似 chown，但是不追踪链接。 |
| 27 | os.link(src, dst) 创建硬链接，名为参数 dst，指向参数 src |
| 28 | os.listdir(path) 返回path指定的文件夹包含的文件或文件夹的名字的列表。 |
| 29 | os.lseek(fd, pos, how) 设置文件描述符 fd当前位置为pos, how方式修改: SEEK_SET 或者 0 设置从文件开始的计算的pos; SEEK_CUR或者 1 则从当前位置计算; os.SEEK_END或者2则从文件尾部开始. 在unix，Windows中有效 |
| 30 | os.lstat(path) 像stat(),但是没有软链接 |
| 31 | os.major(device) 从原始的设备号中提取设备major号码 (使用stat中的st_dev或者st_rdev field)。 |
| 32 | os.makedev(major, minor) 以major和minor设备号组成一个原始设备号 |
| 33 | [os.makedirs(path, mode]) 递归文件夹创建函数。像mkdir(), 但创建的所有intermediate-level文件夹需要包含子文件夹。 |
| 34 | os.minor(device) 从原始的设备号中提取设备minor号码 (使用stat中的st_dev或者st_rdev field )。 |
| 35 | [os.mkdir(path, mode]) 以数字mode的mode创建一个名为path的文件夹.默认的 mode 是 0777 (八进制)。 |
| 36 | [os.mkfifo(path, mode]) 创建命名管道，mode 为数字，默认为 0666 (八进制) |
| 37 | [os.mknod(filename, mode=0600, device]) 创建一个名为filename文件系统节点（文件，设备特别文件或者命名pipe）。 |
| 38 | [os.open(file, flags, mode]) 打开一个文件，并且设置需要的打开选项，mode参数是可选的 |
| 39 | os.openpty() 打开一个新的伪终端对。返回 pty 和 tty的文件描述符。 |
| 40 | os.pathconf(path, name) 返回相关文件的系统配置信息。 |
| 41 | os.pipe() 创建一个管道. 返回一对文件描述符(r, w) 分别为读和写 |
| 42 | [os.popen(command, mode[, bufsize]]) 从一个 command 打开一个管道 |
| 43 | os.read(fd, n) 从文件描述符 fd 中读取最多 n 个字节，返回包含读取字节的字符串，文件描述符 fd对应文件已达到结尾, 返回一个空字符串。 |
| 44 | os.readlink(path) 返回软链接所指向的文件 |
| 45 | os.remove(path) 删除路径为path的文件。如果path 是一个文件夹，将抛出OSError; 查看下面的rmdir()删除一个 directory。 |
| 46 | os.removedirs(path) 递归删除目录。 |
| 47 | os.rename(src, dst) 重命名文件或目录，从 src 到 dst |
| 48 | os.renames(old, new) 递归地对目录进行更名，也可以对文件进行更名。 |
| 49 | os.rmdir(path) 删除path指定的空目录，如果目录非空，则抛出一个OSError异常。 |
| 50 | os.stat(path) 获取path指定的路径的信息，功能等同于C API中的stat()系统调用。 |
| 51 | [os.stat_float_times(newvalue]) 决定stat_result是否以float对象显示时间戳 |
| 52 | os.statvfs(path) 获取指定路径的文件系统统计信息 |
| 53 | os.symlink(src, dst) 创建一个软链接 |
| 54 | os.tcgetpgrp(fd) 返回与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组 |
| 55 | os.tcsetpgrp(fd, pg) 设置与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组为pg。 |
| 56 | [os.tempnam(dir[, prefix]]) 返回唯一的路径名用于创建临时文件。 |
| 57 | os.tmpfile() 返回一个打开的模式为(w+b)的文件对象 .这文件对象没有文件夹入口，没有文件描述符，将会自动删除。 |
| 58 | os.tmpnam() 为创建一个临时文件返回一个唯一的路径 |
| 59 | os.ttyname(fd) 返回一个字符串，它表示与文件描述符fd 关联的终端设备。如果fd 没有与终端设备关联，则引发一个异常。 |
| 60 | os.unlink(path) 删除文件路径 |
| 61 | os.utime(path, times) 返回指定的path文件的访问和修改的时间。 |
| 62 | [os.walk(top, topdown=True[, onerror=None[, followlinks=False]]]) 输出在文件夹中的文件名通过在树中游走，向上或者向下。 |
| 63 | os.write(fd, str) 写入字符串到文件描述符 fd中. 返回实际写入的字符串长度 |
| 64 | os.path 模块 获取文件的属性信息。 |
re正则
2021年11月27日
14:50
数量词的贪婪模式与非贪婪模式
正则表达式通常用于在文本中查找匹配的字符串。Python里数量词默认是贪婪的（在少数语言里也可能是默认非贪婪），总是尝试匹配尽可能多的字符；非贪婪的则相反，总是尝试匹配尽可能少的字符。
compile 函数
compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用。
语法格式为：
re.compile(pattern[, flags])
参数：
- pattern : 一个字符串形式的正则表达式
- flags 可选，表示匹配模式，比如忽略大小写，多行模式等
re.match函数
re.match ``尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，``match()``就返回``none``。
函数语法：
re.match(pattern, string, flags=0)
函数参数说明：
参数 |
描述 |
|---|---|
pattern |
匹配的正则表达式 |
string |
要匹配的字符串。 |
flags |
标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表达式修饰符 - 可选标志 |
匹配成功re.match方法返回一个匹配的对象，否则返回None。
我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。
| 匹配对象方法 | 描述 |
|---|---|
| group(num=0) | 匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。 |
| groups() | 返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。 |
匹配对象
group（id） 获取给定子模式（组的匹配项）
start（id） 返回给定组的匹配项的起始位置
end（id） 返回给定组的匹配项的结束位置
span（id） 返回一个组的起始和结束位置
import re
m = re.match(r'(http://www|WWW).(.*)..{3}', 'http://www.python.org')
print('输出匹配到的字符串')
print(m.group())
print('匹配第一个圆括号中的内容')
print(m.group(1))
print('匹配第二个圆括号中的内容')
print(m.group(2))
print('输出第一组字符串的起始位置')
print(m.start(1))
print('输出第二组字符串的起始位置')
print(m.start(2))
print('输出字符串的结束位置')
print(m.end(0))
print('输出第一个的起始和结束位置')
print(m.span(1))
re.search方法
re.search 扫描整个字符串并返回第一个成功的匹配。
函数语法：
re.search(pattern, string, flags=0)
检索和替换
Python 的re模块提供了re.sub用于替换字符串中的匹配项。
语法：
re.sub(pattern, repl, string, count=0, flags=0)
参数：
- pattern : 正则中的模式字符串。
- repl : 替换的字符串，也可为一个函数。
- string : 要被查找替换的原始字符串。
- count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
- flags : 编译时用的匹配模式，数字形式。
re.subn(pattern, repl, string, count=0, flags=0)
返回替换后的值，和替换了几次
findall
在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果有多个匹配模式，则返回元组列表，如果没有找到匹配的，则返回空列表。
注意： match 和 search 是匹配一次 findall 匹配所有。
语法格式为：
re.findall(pattern, string, flags=0)
或
pattern.findall(string[, pos[, endpos]])
参数：
- pattern 匹配模式。
- string 待匹配的字符串。
- pos 可选参数，指定字符串的起始位置，默认为 0。
- endpos 可选参数，指定字符串的结束位置，默认为字符串的长度。
re.finditer
和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。
re.finditer(pattern, string, flags=0)
re.split
split 方法按照能够匹配的子串将字符串分割后返回列表，它的使用形式如下：
re.split(pattern, string[, maxsplit=0, flags=0])
参数：
| 参数 | 描述 |
|---|---|
| pattern | 匹配的正则表达式 |
| string | 要匹配的字符串。 |
| maxsplit | 分割次数，maxsplit=1 分割一次，默认为 0，不限制次数。 |
| flags | 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表达式修饰符 - 可选标志 |
正则表达式对象
re.RegexObject
re.compile() 返回 RegexObject 对象。
re.MatchObject
特殊字符
所谓特殊字符，就是一些有特殊含义的字符，如上面说的 runoo*b 中的 ***，简单的说就是表示任何字符串的意思。如果要查找字符串中的 ***** 符号，则需要对 ***** 进行转义，即在其前加一个 **，runo*ob 匹配字符串 runo*ob。
许多元字符要求在试图匹配它们时特别对待。若要匹配这些特殊字符，必须首先使字符"转义"，即，将反斜杠字符**** 放在它们前面。下表列出了正则表达式中的特殊字符：
| 特别字符 | 描述 |
|---|---|
| $ | 匹配输入字符串的结尾位置。如果设置了 RegExp 对象的 Multiline 属性，则 $ 也匹配 '\n' 或 '\r'。要匹配 $ 字符本身，请使用 $。 |
| ( ) | 标记一个子表达式的开始和结束位置。子表达式可以获取供以后使用。要匹配这些字符，请使用 ( 和 )。 |
| * | 匹配前面的子表达式零次或多次。要匹配 * 字符，请使用 *。 |
| + | 匹配前面的子表达式一次或多次。要匹配 + 字符，请使用 +。 |
| . | 匹配除换行符 \n 之外的任何单字符。要匹配 . ，请使用 . 。 |
| [ | 标记一个中括号表达式的开始。要匹配 [，请使用 [。 |
| ? | 匹配前面的子表达式零次或一次，或指明一个非贪婪限定符。要匹配 ? 字符，请使用 ?。 |
| \ | 将下一个字符标记为或特殊字符、或原义字符、或向后引用、或八进制转义符。例如， 'n' 匹配字符 'n'。'\n' 匹配换行符。序列 '\' 匹配 ""，而 '(' 则匹配 "("。 |
| ^ | 匹配输入字符串的开始位置，除非在方括号表达式中使用，当该符号在方括号表达式中使用时，表示不接受该方括号表达式中的字符集合。要匹配 ^ 字符本身，请使用 ^。 |
| { | 标记限定符表达式的开始。要匹配 {，请使用 {。 |
| | | 指明两项之间的一个选择。要匹配 |，请使用 |。 |
正则表达式修饰符 - 可选标志
正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位`` OR(|) ``它们来指定。如`` re.I | re.M ``被设置成`` I ``和`` M ``标志：
修饰符 |
描述 |
|---|---|
re.I |
使匹配对大小写不敏感 |
re.L |
做本地化识别（``locale-aware``）匹配 |
re.M |
多行匹配，影响`` ^ ``和`` $ |
re.S |
使`` . ``匹配包括换行在内的所有字符 |
re.U |
根据``Unicode``字符集解析字符。这个标志影响`` \w, \W, \b, \B. |
re.X |
该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。 |
正则表达式模式
模式字符串使用特殊的语法来表示一个正则表达式：
字母和数字表示他们自身。一个正则表达式模式中的字母和数字匹配同样的字符串。
多数字母和数字前加一个反斜杠时会拥有不同的含义。
标点符号只有被转义时才匹配自身，否则它们表示特殊的含义。
反斜杠本身需要使用反斜杠转义。
| 模式 | 描述 |
|---|---|
^ |
匹配字符串的开头 |
$ |
匹配字符串的末尾。 |
. |
匹配任意字符，除了换行符，当``re.DOTALL``标记被指定时，则可以匹配包括换行符的任意字符。 |
[...] |
用来表示一组字符``,``单独列出：``[amk] ``匹配`` 'a'``，``'m'``或``'k' |
[^...] |
不在``[]``中的字符：``[^abc] ``匹配除了``a,b,c``之外的字符。 |
re* |
匹配``0``个或多个的表达式。 |
re+ |
匹配``1``个或多个的表达式。 |
re? |
匹配``0``个或``1``个由前面的正则表达式定义的片段，非贪婪方式 |
re{ n} |
精确匹配`` n ``个前面表达式。例如，`` ``o{2}`` ``不能匹配`` "Bob" ``中的`` "o"``，但是能匹配`` "food" ``中的两个`` o``。 |
re{ n,} |
匹配`` n ``个前面表达式。例如，`` o{2,} ``不能匹配``"Bob"``中的``"o"``，但能匹配`` "foooood"``中的所有`` o``。``"o{1,}" ``等价于`` "o+"``。``"o{0,}" ``则等价于`` "o*"``。 |
re{ n, m} |
匹配`` n ``到`` m ``次由前面的正则表达式定义的片段，贪婪方式 |
| `a | b` |
(re) |
对正则表达式分组并记住匹配的文本 |
(?imx) |
正则表达式包含三种可选标志：``i, m, ``或`` x ``。只影响括号中的区域。 |
(?-imx) |
正则表达式关闭`` i, m, ``或`` x ``可选标志。只影响括号中的区域。 |
(?: re) |
类似`` (...), ``但是不表示一个组 |
(?imx: re) |
在括号中使用``i, m, ``或`` x ``可选标志 |
(?-imx: re) |
在括号中不使用``i, m, ``或`` x ``可选标志 |
(?#...) |
注释``. |
(?= re) |
前向肯定界定符。如果所含正则表达式，以`` ... ``表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。 |
(?! re) |
前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功 |
(?> re) |
匹配的独立模式，省去回溯。 |
\w |
匹配字母数字及下划线 |
\W |
匹配非字母数字及下划线 |
\s |
匹配任意空白字符，等价于`` ``[ \t\n\r\f]``。 |
\S |
匹配任意非空字符 |
\d |
匹配任意数字，等价于`` [0-9]. |
\D |
匹配任意非数字 |
\A |
匹配字符串开始 |
\Z |
匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。 |
\z |
匹配字符串结束 |
\G |
匹配最后匹配完成的位置。 |
\b |
匹配一个单词边界，也就是指单词和空格间的位置。例如，`` 'er\b' ``可以匹配``"never" ``中的`` 'er'``，但不能匹配`` "verb" ``中的`` 'er'``。 |
\B |
匹配非单词边界。``'er\B' ``能匹配`` "verb" ``中的`` 'er'``，但不能匹配`` "never" ``中的`` 'er'``。 |
\n, \t, ``等``. |
匹配一个换行符。匹配一个制表符。等 |
\1...\9 |
匹配第``n``个分组的内容。 |
\10 |
匹配第``n``个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。 |
正则表达式实例
实例 |
描述 |
|---|---|
[Pp]ython |
匹配`` "Python" ``或`` "python" |
rub[ye] |
匹配`` "ruby" ``或`` "rube" |
[aeiou] |
匹配中括号内的任意一个字母 |
[0-9] |
匹配任何数字。类似于`` [0123456789] |
[a-z] |
匹配任何小写字母 |
[A-Z] |
匹配任何大写字母 |
[a-zA-Z0-9] |
匹配任何字母及数字 |
[^aeiou] |
除了``aeiou``字母以外的所有字符 |
[^0-9] |
匹配除了数字外的字符 |
特殊字符类
| 实例 | 描述 |
|---|---|
. |
匹配除`` "\n" ``之外的任何单个字符。要匹配包括`` '\n' ``在内的任何字符，请使用象`` '[.\n]' ``的模式。 |
\d |
匹配一个数字字符。等价于`` [0-9]``。 |
\D |
匹配一个非数字字符。等价于`` [^0-9]``。 |
\s |
匹配任何空白字符，包括空格、制表符、换页符等等。等价于`` [ \f\n\r\t\v]``。 |
\S |
匹配任何非空白字符。等价于`` [^ \f\n\r\t\v]``。 |
\w |
匹配包括下划线的任何单词字符。等价于``'[A-Za-z0-9_]'``。 |
\W |
匹配任何非单词字符。等价于`` '[^A-Za-z0-9_]'``。 |
案例
特殊符号替换：``re.sub(`` r'[-,$()#+&*]'``," ooo ",str)
表达式
一、校验数字的表达式
1. ``数字：``^[0-9]*$
2. n``位的数字：``^\d{n}$
3. ``至少``n``位的数字：``^\d{n,}$
4. m-n``位的数字：``^\d{m,n}$
5. ``零和非零开头的数字：``^(0|[1-9][0-9]*)$
6. ``非零开头的最多带两位小数的数字：``^([1-9][0-9]*)+(.[0-9]{1,2})?$
7. ``带``1-2``位小数的正数或负数：``^(\-)?\d+(\.\d{1,2})?$
8. ``正数、负数、和小数：``^(\-|\+)?\d+(\.\d+)?$
9. ``有两位小数的正实数：``^[0-9]+(.[0-9]{2})?$
10. ``有``1~3``位小数的正实数：``^[0-9]+(.[0-9]{1,3})?$
11. ``非零的正整数：``^[1-9]\d*$ ``或`` ^([1-9][0-9]*){1,3}$ ``或`` ^\+?[1-9][0-9]*$
12. ``非零的负整数：``^\-[1-9][]0-9"*$ ``或`` ^-[1-9]\d*$
13. ``非负整数：``^\d+$ ``或`` ^[1-9]\d*|0$
14. ``非正整数：``^-[1-9]\d*|0$ ``或`` ^((-\d+)|(0+))$
15. ``非负浮点数：``^\d+(\.\d+)?$ ``或`` ^[1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0$
16. ``非正浮点数：``^((-\d+(\.\d+)?)|(0+(\.0+)?))$ ``或``
^(-([1-9]\d*\.\d*|0\.\d*[1-9]\d*))|0?\.0+|0$
17. ``正浮点数：``^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$ ``或`` ^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$
18. ``负浮点数：``^-([1-9]\d*\.\d*|0\.\d*[1-9]\d*)$ ``或`` ^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$
19. ``浮点数：``^(-?\d+)(\.\d+)?$ ``或`` ^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0)$
二、校验字符的表达式
1. ``汉字：``^[\u4e00-\u9fa5]{0,}$
2. ``英文和数字：``^[A-Za-z0-9]+$ ``或`` ^[A-Za-z0-9]{4,40}$
3. ``长度为``3-20``的所有字符：``^.{3,20}$
4. ``由``26``个英文字母组成的字符串：``^[A-Za-z]+$
5. ``由``26``个大写英文字母组成的字符串：``^[A-Z]+$
6. ``由``26``个小写英文字母组成的字符串：``^[a-z]+$
7. ``由数字和``26``个英文字母组成的字符串：``^[A-Za-z0-9]+$
8. ``由数字、``26``个英文字母或者下划线组成的字符串：``^\w+$ ``或`` ^\w{3,20}$
9. ``中文、英文、数字包括下划线：``^[\u4E00-\u9FA5A-Za-z0-9_]+$
10. ``中文、英文、数字但不包括下划线等符号：``^[\u4E00-\u9FA5A-Za-z0-9]+$
``或`` ^[\u4E00-\u9FA5A-Za-z0-9]{2,20}$
11. ``可以输入含有``^%&',;=?$\"``等字符：``[^%&',;=?$\x22]+ 12
``禁止输入含有``~``的字符：``[^~\x22]+
三、特殊需求表达式
1. Email``地址：
^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$
2. ``域名：
[a-zA-Z0-9][-a-zA-Z0-9]{0,62}(/.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+/.?
3. InternetURL``：
[a-zA-z]+://[^\s]* ``或`` ^http://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$
4. ``手机号码：
^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}$
5. ``电话号码
("XXX-XXXXXXX"``、``"XXXX-XXXXXXXX"``、``"XXX-XXXXXXX"``、
"XXX-XXXXXXXX"``、``"XXXXXXX"``和``"XXXXXXXX)``：
^(\(\d{3,4}-)|\d{3.4}-)?\d{7,8}$
6. ``国内电话号码``(0511-4405222``、``021-87888822)``：
\d{3}-\d{8}|\d{4}-\d{7}
7. ``身份证号``(15``位、``18``位数字``)``：
^\d{15}|\d{18}$
8. ``短身份证号码``(``数字、字母``x``结尾``)``：
^([0-9]){7,18}(x|X)?$
或`` ^\d{8,18}|[0-9x]{8,18}|[0-9X]{8,18}?$
9. ``帐号是否合法``(``字母开头，允许``5-16``字节，允许字母数字下划线``)``：
^[a-zA-Z][a-zA-Z0-9_]{4,15}$
10. ``密码``(``以字母开头，长度在``6~18``之间，只能包含字母、数字和下划线``)``：
^[a-zA-Z]\w{5,17}$
11. ``强密码``(``必须包含大小写字母和数字的组合，不能使用特殊字符，长度在``8-10``之间``)``：
^(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{8,10}$
12. ``日期格式：
^\d{4}-\d{1,2}-\d{1,2}
13. ``一年的``12``个月``(01``～``09``和``1``～``12)``：
^(0?[1-9]|1[0-2])$
14. ``一个月的``31``天``(01``～``09``和``1``～``31)``：
^((0?[1-9])|((1|2)[0-9])|30|31)$
15. ``钱的输入格式：
- 1.有四种钱的表示形式我们可以接受:"10000.00" 和 "10,000.00", 和没有 "分" 的 "10000" 和 "10,000"：
^[1-9][0-9]*$
- \17. 2.这表示任意一个不以0开头的数字,但是,这也意味着一个字符"0"不通过,所以我们采用下面的形式：
^(0|[1-9][0-9]*)$
- 一个0或者一个不以0开头的数字.我们还可以允许开头有一个负号：
^(0|-?[1-9][0-9]*)$
- 这表示一个0或者一个可能为负的开头不为0的数字.让用户以0开头好了.把负号的也去掉,因为钱总不能是负的吧.下面我们要加的是说明可能的小数部分：
^[0-9]+(.[0-9]+)?$
- .必须说明的是,小数点后面至少应该有1位数,所以"10."是不通过的,但是 "10" 和 "10.2" 是通过的：
^[0-9]+(.[0-9]{2})?$
- .这样我们规定小数点后面必须有两位,如果你认为太苛刻了,可以这样：
^[0-9]+(.[0-9]{1,2})?$
- 这样就允许用户只写一位小数.下面我们该考虑数字中的逗号了,我们可以这样：
^[0-9]{1,3}(,[0-9]{3})*(.[0-9]{1,2})?$
- 1到3个数字,后面跟着任意个 逗号+3个数字,逗号成为可选,而不是必须：
^([0-9]+|[0-9]{1,3}(,[0-9]{3})*)(.[0-9]{1,2})?$
``备注：这就是最终结果了``,``别忘了``"+"``可以用``"*"``替代如果你觉得空字符串也可以接受的话``(``奇怪``,``为什么``?)``最后``,``别忘了在用函数时去掉去掉那个反斜杠``,``一般的错误都在这里
25. xml``文件：
^([a-zA-Z]+-?)+[a-zA-Z0-9]+\\.[x|X][m|M][l|L]$
26. ``中文字符的正则表达式：
[\u4e00-\u9fa5]
27. ``双字节字符：
[^\x00-\xff]
(``包括汉字在内，可以用来计算字符串的长度``(``一个双字节字符长度计``2``，``ASCII``字符计``1))
28. ``空白行的正则表达式：
\n\s*\r (``可以用来删除空白行``)
29. HTML``标记的正则表达式：
<(\S*?)[^>]*>.*?</\1>|<.*? />
(``网上流传的版本太糟糕，上面这个也仅仅能部分，对于复杂的嵌套标记依旧无能为力``)
30. ``首尾空白字符的正则表达式：
^\s*|\s*$``或``(^\s*)|(\s*$)
(``可以用来删除行首行尾的空白字符``(``包括空格、制表符、换页符等等``)``，非常有用的表达式``)
31. ``腾讯``QQ``号：
[1-9][0-9]{4,}
(``腾讯``QQ``号从``10000``开始``)
32. ``中国邮政编码：
[1-9]\d{5}(?!\d) (``中国邮政编码为``6``位数字``)
33.`` ``IP``地址：
\d+\.\d+\.\d+\.\d+ (``提取``IP``地址时有用``)
34. IP``地址：
((?:(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d))
=
json模块&pickle
2022年7月14日
9:57
json
如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。
JSON表示的对象就是标准的JavaScript语言的对象，JSON和Python内置的数据类型对应如下：
 |
|
|---|---|
json序列化
json.dumps(''内容")
json反序列化
json.loads(''内容")
json验证：
json格式只能兼容所有语言通用的数据类型，不能兼容某一种语言特定的数据类型
json强调：json格式有它的要求，如json 不认单引号，不要混淆
注意：
import json`
`#dct="{'1':111}"#json ``不认单引号`
`#dct=str({"1":111})#``报错``,``因为生成的数据还是单引号``:{'one': 1}`
`dct='{"1":"111"}'print(json.loads(dct))
#conclusion:`
`# ``无论数据是怎样创建的，只要满足``json``格式，就可以``json.loads``出来``,``不一定非要``dumps``的数据才能``loads
# 一.什么是猴子补丁?
属性在运行时的动态替换，叫做猴子补丁（``Monkey Patch``）。
猴子补丁的核心就是用自己的代码替换所用模块的源代码，详细地如下
1``，这个词原来为Guerrilla Patch，杂牌军、游击队，说明这部分不是原装的，在英文里guerilla发音和gorllia(猩猩)相似，再后来就写了monkey(猴子)。
2``，还有一种解释是说由于这种方式将原来的代码弄乱了(messing with it)，在英文里叫monkeying about(顽皮的)，所以叫做Monkey Patch。
# 二. 猴子补丁的功能(一切皆对象)
1.``拥有在模块运行时替换的功能, 例如: 一个函数对象赋值给另外一个函数对象(把函数原本的执行的功能给替换了)
# 三.monkey patch的应用场景
如果我们的程序中已经基于``json``模块编写了大量代码了，发现有一个模块``ujson``比它性能更高，但用法一样，我们肯定不会想所有的代码都换成``ujson.dumps``或者``ujson.loads,
那我们可能会想到这么做`
`import ujson as json``，但是这么做的需要每个文件都重新导入一下，维护成本依然很高
此时我们就可以用到猴子补丁了只需要在入口处加上
import json`
`import ujson
def monkey_patch_json():`
` json.__name__= 'ujson'`
` json.dumps = ujson.dumps`
` json.loads = ujson.loads
monkey_patch_json() # ``之所以在入口处加，是因为模块在导入一次后，后续的导入便直接引用第一次的成果
#``其实这种场景也比较多, 比如我们引用团队通用库里的一个模块, 又想丰富模块的功能, 除了继承之外也可以考虑用MonkeyPatch.采用猴子补丁之后，如果发现ujson不符合预期，那也可以快速撤掉补丁。个人感觉Monkey`
`Patch``带了便利的同时也有搞乱源代码的风险!
Pickle
用法和json一样
注意``：``Pickle``的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于``Python``，并且可能不同版本的``Python``彼此都不兼容，因此，只能用``Pickle``保存那些不重要的数据，不能成功地反序列化也没关系。``
Shelve
shelve模块比pickle模块简单，只有一个open函数，返回类似字典的对象，可读可写;key必须为字符串，而值可以是python所支持的数据类型
import shelve
f=shelve.open(r'sheve.txt')`
`# f['stu1_info']={'name':'egon','age':18,'hobby':['piao','smoking','drinking']}`
`# f['stu2_info']={'name':'gangdan','age':53}`
`# f['school_info']={'website':'http://www.pypy.org','city':'beijing'}print(f['stu1_info']['hobby'])`
`f.close()
Faker模块
2022年6月17日
20:38
Faker
随机生成信息
1. 安装
pip install Faker
2. 简单使用
>>> from faker import Faker
>>> fake = Faker(locale='zh_CN')
>>> fake.name()
'``李洁``'
>>> fake.address()
'``上海市兴安盟县江北东莞路``r``座`` 803484'
参数 locale：为生成数据的文化选项（语种），默认为 en_US，只有使用了相关文化，才能生成相对应的随机信息
常见的文化选项：
zh_CN - Chinese (China Mainland)
zh_TW - Chinese (China Taiwan)
en_US - English (United States)
3. 其他方法
3.1 地理信息类
city_suffix() # ``市，县
country() # ``国家
country_code() # ``国家编码
district() # ``区
geo_coordinate() # ``地理坐标
latitude() # ``地理坐标``(``纬度``)
longitude() # ``地理坐标``(``经度``)
postcode() # ``邮编
province() # ``省份
address() # ``详细地址
street_address() # ``街道地址
street_name() # ``街道名
street_suffix() # ``街、路
3.2 基础信息类
ssn() # ``生成身份证号
bs() # ``随机公司服务名
company() # ``随机公司名（长）
company_prefix() # ``随机公司名（短）
company_suffix() # ``公司性质，如``'``信息有限公司``'
credit_card_expire() # ``随机信用卡到期日，如``'03/30'
credit_card_full() # ``生成完整信用卡信息
credit_card_number() # ``信用卡号
credit_card_provider() # ``信用卡类型
credit_card_security_code() # ``信用卡安全码
job() # ``随机职位
first_name_female() # ``女性名
first_name_male() # ``男性名
name() # ``随机生成全名
name_female() # ``男性全名
name_male() # ``女性全名
phone_number() # ``随机生成手机号
phonenumber_prefix() # ``随机生成手机号段，如``139
3.3 邮箱信息类
ascii_company_email() # ``随机``ASCII``公司邮箱名
ascii_email() # ``随机``ASCII``邮箱`` #
company_email() # ``公司邮箱
email() # ``普通邮箱
safe_email() # ``安全邮箱
3.4 ``网络基础信息类
domain_name() # ``生成域名
domain_word() # ``域词``(``即，不包含后缀``)
ipv4() # ``随机``IP4``地址
ipv6() # ``随机``IP6``地址
mac_address() # ``随机``MAC``地址
tld() # ``网址域名后缀``(.com,.net.cn,``等等，不包括``.)
uri() # ``随机``URI``地址
uri_extension() # ``网址文件后缀
uri_page() # ``网址文件（不包含后缀）
uri_path() # ``网址文件路径（不包含文件名）
url() # ``随机``URL``地址
user_name() # ``随机用户名
image_url() # ``随机``URL``地址
3.5 浏览器信息类
chrome() # ``随机生成``Chrome``的浏览器``user_agent``信息
firefox() # ``随机生成``FireFox``的浏览器``user_agent``信息
internet_explorer() # ``随机生成``IE``的浏览器``user_agent``信息
opera() # ``随机生成``Opera``的浏览器``user_agent``信息
safari() # ``随机生成``Safari``的浏览器``user_agent``信息
linux_platform_token() # ``随机``Linux``信息
user_agent() # ``随机``user_agent``信息
3.6 数字信息
numerify() # ``三位随机数字
random_digit() # 0~9``随机数
random_digit_not_null() # 1~9``的随机数
random_int() # ``随机数字，默认``0~9999``，可以通过设置``min,max``来设置
random_number() # ``随机数字，参数``digits``设置生成的数字位数
pyfloat() # ``随机``Float``数字
pyint() # ``随机``Int``数字（参考``random_int()``参数）
pydecimal() # ``随机``Decimal``数字（参考``pyfloat``参数）
3.7 文本加密类
pystr() # ``随机字符串
random_element() # ``随机字母
random_letter() # ``随机字母
paragraph() # ``随机生成一个段落
paragraphs() # ``随机生成多个段落
sentence() # ``随机生成一句话
sentences() # ``随机生成多句话，与段落类似
text() # ``随机生成一篇文章
word() # ``随机生成词语
words() # ``随机生成多个词语，用法与段落，句子，类似
binary() # ``随机生成二进制编码
boolean() # True/False
language_code() # ``随机生成两位语言编码
locale() # ``随机生成语言``/``国际 信息
md5() # ``随机生成``MD5
null_boolean() # NULL/True/False
password() # ``随机生成密码``,``可选参数`` # length # ``密码长度；``special_chars # ``是否能使用特殊字符；``digits # ``是否包含数字；``upper_case # ``是否包含大写字母；``lower_case # ``是否包含小写字母
sha1() # ``随机``SHA1
sha256() # ``随机``SHA256
uuid4() # ``随机``UUID
3.8 时间信息类
date() # ``随机日期
date_between() # ``随机生成指定范围内日期，参数`` # start_date``，``end_date
date_between_dates() # ``随机生成指定范围内日期，用法同上
date_object() # ``随机生产从``1970-1-1``到指定日期的随机日期。
date_time() # ``随机生成指定时间（``1970``年``1``月``1``日至今）
date_time_ad() # ``生成公元``1``年到现在的随机时间
date_time_between() # ``用法同``dates
future_date() # ``未来日期
future_datetime() # ``未来时间
month() # ``随机月份
month_name() # ``随机月份（英文）
past_date() # ``随机生成已经过去的日期
past_datetime() # ``随机生成已经过去的时间
time() # ``随机``24``小时时间
timedelta() # ``随机获取时间差
time_object() # ``随机``24``小时时间，``time``对象
time_series() # ``随机``TimeSeries``对象
timezone() # ``随机时区
unix_time() # ``随机``Unix``时间
year() # ``随机年份
4. 实战使用
在数据库建一张表，通过``Faker``造数据，插入到表中。并且打印``Faker``造的数据。
import pymysql
from faker import Faker
conn = pymysql.connect(host="114.215.129.166", port=3306, user="nice", password="", db="flask201",
charset="utf8")
cursor = conn.cursor()
sql1 = """drop table if exists faker_user"""
sql2 = """
create table faker_user(
pid int primary key auto_increment,
username varchar(20),
password varchar(20),
address varchar(35)
)
"""
cursor.execute(sql1)
cursor.execute(sql2)
fake = Faker("zh-CN")
for i in range(20):
sql = """insert into faker_user(username,password,address)
values('%s','%s','%s')""" % (fake.name(), fake.password(special_chars=False), fake.address())
cursor.execute(sql)
conn.commit()
cursor.close()
conn.close()
configparser****模块
2022年7月14日
11:14
配置文件如下：
# ``注释``1; ``注释``2
[section1]`
`k1 = v1`
`k2:v2`
`user=egon`
`age=18`
`is_admin=true`
`salary=31
[section2]`
`k1 = v1
读取
import configparser
config=configparser.ConfigParser()
config.read('a.cfg')
#``查看所有的标题
res=config.sections() #['section1', 'section2']
print(res)
#``查看标题``section1``下所有``key=value``的``key
options=config.options('section1')
print(options) #['k1', 'k2', 'user', 'age', 'is_admin', 'salary']
#``查看标题``section1``下所有``key=value``的``(key,value)``格式
item_list=config.items('section1')
print(item_list) #[('k1', 'v1'), ('k2', 'v2'), ('user', 'egon'), ('age', '18'), ('is_admin', 'true'), ('salary', '31')]
#``查看标题``section1``下``user``的值``=>``字符串格式
val=config.get('section1','user')
print(val) #egon
#``查看标题``section1``下``age``的值``=>``整数格式
val1=config.getint('section1','age')
print(val1) #18
#``查看标题``section1``下``is_admin``的值``=>``布尔值格式
val2=config.getboolean('section1','is_admin')
print(val2) #True
#``查看标题``section1``下``salary``的值``=>``浮点型格式
val3=config.getfloat('section1','salary')
print(val3) #31.0
改写
import configparser
config=configparser.ConfigParser()
config.read('a.cfg',encoding='utf-8')
#``删除整个标题``section2
config.remove_section('section2')
#``删除标题``section1``下的某个``k1``和``k2
config.remove_option('section1','k1')
config.remove_option('section1','k2')
#``判断是否存在某个标题
print(config.has_section('section1'))
#``判断标题``section1``下是否有``user
print(config.has_option('section1',''))
#``添加一个标题
config.add_section('egon')
#``在标题``egon``下添加``name=egon,age=18``的配置
config.set('egon','name','egon')
config.set('egon','age',18) #``报错``,``必须是字符串
#``最后将修改的内容写入文件``,``完成最终的修改
config.write(open('a.cfg','w'))
import configparser
config = configparser.ConfigParser()
config["DEFAULT"] = {'ServerAliveInterval': '45',
'Compression': 'yes',
'CompressionLevel': '9'}
config['bitbucket.org'] = {}
config['bitbucket.org']['User'] = 'hg'
config['topsecret.server.com'] = {}
topsecret = config['topsecret.server.com']
topsecret['Host Port'] = '50022' # mutates the parser
topsecret['ForwardX11'] = 'no' # same here
config['DEFAULT']['ForwardX11'] = 'yes'
with open('example.ini', 'w') as configfile:
config.write(configfile)
Pymysql模块
2022年5月31日
23:04
# 打开数据库连接
db = pymysql.connect("localhost","testuser","test123","TESTDB")
# 使用 cursor() 方法创建一个游标对象
cursorcursor = db.cursor(``cursor=``…)
cursor=pymysql.cursors.DictCurosr``将查询结果以字典返回
# 使用 execute() 方法执行 SQL 查询
cursor.execute(sql)
# 使用 fetchone() 方法获取单条数据.
data = cursor.fetchone()
fetchone():`` ``该方法获取下一个查询结果集。结果集是一个对象
fetchall():`` ``接收全部的返回结果行``.
fetchmany(num``）指定拿几条数据
rowcount:`` ``这是一个只读属性，并返回执行``execute()``方法后影响的行数。
关闭数据库连接要先关闭游标对象
cursorcursor.close()
db.close()
移动
corsor.scroll(1 ,'relative') 相对光标所在位置继续往后移动一位
corsor.scroll(1 ,'absolute') 相对光标起始所在位置继续往后移动一位
调用存储过程
cursor.callproc(procname，args)
procname 是存储过程的名字
args 是存储过程的参数=元组
插入
try:
# ``执行``sql``语句插入单个
cursor.execute(sql)
# ``插入多个
cursor .executemany(sql,[(),(),()``…])
# ``提交到数据库执行
db.commit()
except:
# ``如果发生错误则回滚
db.rollback()
执行事务
事务机制可以确保数据一致性。
事务应该具有4个属性：原子性、一致性、隔离性、持久性。这四个属性通常称为ACID特性。
- 原子性（atomicity）。一个事务是一个不可分割的工作单位，事务中包括的诸操作要么都做，要么都不做。
- 一致性（consistency）。事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。
- 隔离性（isolation）。一个事务的执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。
- 持久性（durability）。持续性也称永久性（permanence），指一个事务一旦提交，它对数据库中数据的改变就应该是永久性的。接下来的其他操作或故障不应该对其有任何影响。
Python DB API 2.0 的事务提供了两个方法 commit 或 rollback。
实例:
# SQL``删除记录语句`
`sql = "DELETE FROM EMPLOYEE WHERE AGE > %s" % (20)`
`try:`
` # ``执行``SQL``语句`
` cursor.execute(sql)`
` # ``向数据库提交`
` db.commit()`
`except:`
` # ``发生错误时回滚`
` db.rollback()
对于支持事务的数据库， 在Python数据库编程中，当游标建立之时，就自动开始了一个隐形的数据库事务。
commit()方法游标的所有更新操作，rollback（）方法回滚当前游标的所有操作。每一个方法都开始了一个新的事务。
错误处理
DB API中定义了一些数据库操作的错误及异常，下表列出了这些错误和异常:
Warning
当有严重警告时触发，例如插入数据是被截断等等。必须是 StandardError 的子类。
Error
警告以外所有其他错误类。必须是 StandardError 的子类。
InterfaceError
当有数据库接口模块本身的错误（而不是数据库的错误）发生时触发。 必须是Error的子类。
DatabaseError
和数据库有关的错误发生时触发。 必须是Error的子类。
DataError
当有数据处理时的错误发生时触发，例如：除零错误，数据超范围等等。 必须是DatabaseError的子类。
OperationalError
指非用户控制的，而是操作数据库时发生的错误。例如：连接意外断开、 数据库名未找到、事务处理失败、内存分配错误等等操作数据库是发生的错误。 必须是DatabaseError的子类。
IntegrityError
完整性相关的错误，例如外键检查失败等。必须是DatabaseError子类。
InternalError
数据库的内部错误，例如游标（cursor）失效了、事务同步失败等等。 必须是DatabaseError子类。
ProgrammingError
程序错误，例如数据表（table）没找到或已存在、SQL语句语法错误、 参数数量错误等等。必须是DatabaseError的子类。
NotSupportedError
不支持错误，指使用了数据库不支持的函数或API等。例如在连接对象上 使用.rollback()函数，然而数据库并不支持事务或者事务已关闭。 必须是DatabaseError的子类。
时间模块
2021年11月18日
15:33
时间的三种格式：
1.时间戳：从1970年到现在的秒数
Time. Time()
主要用于时间间隔计算
2.按照某种格式显示的时间
Time.strftime('%Y-%m-%d')
主要用于展示
3.结构化的时间
Time.localtime()
用于单独获取时间的某一部分
一、time模块
time模块中时间表现的格式主要有三种：
1、timestamp：时间戳，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量
2、struct_time：时间元组，共有九个元素组。
3、format time ：格式化时间，已格式化的结构使时间更具可读性。包括自定义格式和固定格式。
#直接生成时间元组 2>>> time.localtime()
#把时间戳转换为时间元组 5>>> time.localtime(time.time())
#把格式化时间转换为时间元组10>>> time.strptime('2017-4-8 14:12:12','%Y-%m-%d %X')
Time 模块
Time 模块包含了以下内置函数，既有时间处理的，也有转换时间格式的：
| 序号 | 函数及描述 |
|---|---|
| 1 | time.altzone 返回格林威治西部的夏令时地区的偏移秒数。如果该地区在格林威治东部会返回负值（如西欧，包括英国）。对夏令时启用地区才能使用。 |
| 2 | [time.asctime(tupletime]) 接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二18时07分14秒）的24个字符的字符串。 |
| 3 | time.clock( ) 用以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时，比time.time()更有用。 |
| 4 | [time.ctime(secs]) 作用相当于asctime(localtime(secs))，未给参数相当于asctime() |
| 5 | [time.gmtime(secs]) 接收时间戳（1970纪元后经过的浮点秒数）并返回格林威治天文时间下的时间元组t。注：t.tm_isdst始终为0 |
| 6 | [time.localtime(secs]) 接收时间戳（1970纪元后经过的浮点秒数）并返回当地时间下的时间元组t（t.tm_isdst可取0或1，取决于当地当时是不是夏令时）。 |
| 7 | time.mktime(tupletime) 接受时间元组并返回时间戳（1970纪元后经过的浮点秒数）。 |
| 8 | time.sleep(secs) 推迟调用线程的运行，secs指秒数。 |
| 9 | [time.strftime(fmt,tupletime]) 接收以时间元组，并返回以可读字符串表示的当地时间，格式由fmt决定。 |
| 10 | time.strptime(str,fmt='%a %b %d %H:%M:%S %Y') 根据fmt的格式把一个时间字符串解析为时间元组。 |
| 11 | time.time( ) 返回当前时间的时间戳（1970纪元后经过的浮点秒数）。 |
| 12 | time.tzset() 根据环境变量TZ重新初始化时间相关设置。 |
属性`` ``值
tm_year``（年）`` ``比如``2017 `
`tm_mon``（月）`` 1 - 12`
`tm_mday``（日）`` 1 - 31`
`tm_hour``（时）`` 0 - 23`
`tm_min``（分）`` 0 - 59`
`tm_sec``（秒）`` 0 - 61`
`tm_wday``（``weekday``）`` 0 - 6``（``0``表示周日）`
`tm_yday``（一年中的第几天）`` 1 - 366`
`tm_isdst``（是否是夏令时）`` ``默认为``-1
python中时间日期格式化符号：
- %y 两位数的年份表示（00-99）
- %Y 四位数的年份表示（000-9999）
- %m 月份（01-12）
- %d 月内中的一天（0-31）
- %H 24小时制小时数（0-23）
- %I 12小时制小时数（01-12）
- %M 分钟数（00-59）
- %S 秒（00-59）
- %a 本地简化星期名称
- %A 本地完整星期名称
- %b 本地简化的月份名称
- %B 本地完整的月份名称
- %c 本地相应的日期表示和时间表示
- %j 年内的一天（001-366）
- %p 本地A.M.或P.M.的等价符
- %U 一年中的星期数（00-53）星期天为星期的开始
- %w 星期（0-6），星期天为星期的开始
- %W 一年中的星期数（00-53）星期一为星期的开始
- %x 本地相应的日期表示
- %X 本地相应的时间表示
- %Z 当前时区的名称
- %% %号本身
实例
# ``格式化成``2016-03-20 11:45:39``形式``
print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
# ``格式化成``Sat Mar 28 22:24:24 2016``形式``
print time.strftime("%a %b %d %H:%M:%S %Y", time.localtime())
二、datetime模块
datatime模块重新封装了time模块，提供更多接口，提供的类有：date,time,datetime,timedelta,tzinfo。
1、date类
datetime.date(year, month, day)
静态方法和字段
date.max``、``date.min``：``date``对象所能表示的最大、最小日期；`
`date.resolution``：``date``对象表示日期的最小单位。这里是天。`
`date.today()``：返回一个表示当前本地日期的``date``对象；`
`date.fromtimestamp(timestamp)``：根据给定的时间戮，返回一个``date``对象；
方法和属性
- d1 = date(2017,4,8) #date对象（年月日都不能是以0开头 (2017,04,08)错误 ）
- d1.replace(year, month, day)：生成一个新的日期对象，用参数指定的年，月，日代替原有对象中的属性。（原有对象仍保持不变）
- d1.timetuple()：返回日期对应的time.struct_time对象；
- d1.weekday()：返回weekday，如果是星期一，返回0；如果是星期2，返回1，以此类推；
- d1.isoweekday()：返回weekday，如果是星期一，返回1；如果是星期2，返回2，以此类推；
- d1.isocalendar()：返回格式如(year，sum_week，day)的元组；
- d1.isoformat()：返回格式如'YYYY-MM-DD’的字符串；
- d1.strftime(fmt)：和time模块format相同。
可以用来去取时间的年月日
x.year, x.month, x.day
2、time类
datetime.time(hour[`` ``, minute[`` ``, second[`` ``, microsecond[`` ``, tzinfo]`` ``]`` ``]`` ``]`` ``)``
静态方法和字段
time.min``、``time.max``：``time``类所能表示的最小、最大时间
3、datetime类
datetime``相当于``date``和``time``结合起来。
datetime.datetime (year, month, day[ , hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] ] )
静态方法和字段
datetime.today()``：返回一个表示当前本地时间的``datetime``对象；`
`datetime.now([tz])``：返回一个表示当前本地时间的``datetime``对象，如果提供了参数``tz``，则获取``tz``参数所指时区的本地时间；`
`datetime.utcnow()``：返回一个当前``utc``时间的``datetime``对象；``#``格林威治时间`
`datetime.fromtimestamp(timestamp[, tz])``：根据时间戮创建一个``datetime``对象，参数``tz``指定时区信息；`
`datetime.utcfromtimestamp(timestamp)``：根据时间戮创建一个``datetime``对象；`
`datetime.combine(date, time)``：根据``date``和``time``，创建一个``datetime``对象；`
`datetime.strptime(date_string, format)``：将格式字符串转换为``datetime``对象；
阿里云—API
2022年9月19日
21:57
下载
pip install --upgrade aligo
简单使用
<br class="Apple-interchange-newline"><div></div>
"""``快速入门``"""
fromaligoimportAligo
``
if__name__=='__main__':
`` ``ali=Aligo() `` ``# ``第一次使用，会弹出二维码，供扫描登录
``
`` ``user=ali.get_user() `` ``# ``获取用户信息
`` ``print(user.user_name, user.nick_name, user.phone) `` ``# ``打印用户信息
``
`` ``ll=ali.get_file_list() `` ``# ``获取网盘根目录文件列表
`` ``forfileinll: `` ``# ``遍历文件列表
`` ``print(file.file_id, file.name, file.type) `` ``# ``打印文件信息
持久化登录、多帐户登录
ali=Aligo() `` ``# ``第一次使用，会弹出二维码，供扫描登录
网页扫码登录
from aligo import Aligo
# ``提供`` port ``参数即可``, ``之后打开浏览器访问 http://<YOUR_IP>:
ali = Aligo(port=8080)
## 发送登录二维码到邮箱（推荐）
最佳实践：建议将邮箱绑定到微信，这样能实时收到提醒，登录过期后也可以第一时间收到登录请求。
安全性问题：虽然自带公开邮箱，但是他人并不能通过这个获取任何人发送的邮件，所以 防伪字符串 策略是安全的。
```python
from aligo import Aligo
"""
email: 发送扫码登录邮件 ("接收邮件的邮箱地址", "防伪字符串"). 提供此值时，将不再弹出或打印二维码
关于防伪字符串: 为了方便大家使用, aligo 自带公开邮箱, 省去邮箱配置的麻烦.
所以收到登录邮件后, 一定要对比确认防伪字符串和你设置一致才可扫码登录, 否则将导致: 包括但不限于云盘文件泄露.
"""
# 提供 email 参数即可
ali = Aligo(email=('xxx@qq.com', '防伪字符串，可任意字符串'))
```
##
文件夹同步
在线解压缩
支持功能扩展
搜索文件/标签
获取重复文件列表
文件（夹）重命名
文件（夹）上传下载
文件（夹）移动复制
文件（夹）删除恢复
获取文档在线预览接口
文件（夹）分享 保存 收藏
文件（夹）自定义分享（无限制）
获取帐户、云盘（容量）等基本信息
相册 创建 删除 修改 添加文件 获取文件
hashlib模块
2022年7月14日
14:53
1、什么叫hash:
hash``是一种算法（``3.x``里代替了``md5``模块和``sha``模块，主要提供`` SHA1, SHA224, SHA256, SHA384, SHA512 ``，``MD5 ``算法），该算法接受传入的内容，经过运算得到一串``hash``值
# 2、hash值的特点是：
#2.1 ``只要传入的内容一样，得到的``hash``值必然一样``=====>``要用明文传输密码文件完整性校验
#2.2 ``不能由``hash``值返解成内容``=======``》把密码做成``hash``值，不应该在网络传输明文密码
#2.3 ``只要使用的``hash``算法不变，无论校验的内容有多大，得到的``hash``值长度是固定的
hash算法就像一座工厂，工厂接收你送来的原材料（可以用m.update()为工厂运送原材料），经过加工返回的产品就是hash值
import hashlib
m=hashlib.md5()# m=hashlib.sha256()
m.update('hello'.encode('utf8'))
print(m.hexdigest()) #5d41402abc4b2a76b9719d911017c592
m.update('alvin'.encode('utf8'))
print(m.hexdigest()) #92a7e713c30abbb0319fa07da2a5c4af
m2=hashlib.md5()
m2.update('helloalvin'.encode('utf8'))
print(m2.hexdigest()) #92a7e713c30abbb0319fa07da2a5c4af
'''
注意：把一段很长的数据``update``多次，与一次``update``这段长数据，得到的结果一样
但是``update``多次为校验大文件提供了可能。
'''
以上加密算法虽然依然非常厉害，但时候存在缺陷，即：通过撞库可以反解。所以，有必要对加密算法中添加自定义key再来做加密。
import hashlib
# ######## 256 ########
hash = hashlib.sha256('898oaFs09f'.encode('utf8'))
hash.update('alvin'.encode('utf8'))
print (hash.hexdigest())#e79e68f070cdedcfe63eaf1a2e92c83b4cfb1b5c6bc452d214c1b7e77cdfd1c7
动态加盐
"""
在对铭文数据做加密处理过程前添加一些变化的干扰项
"""
import hashlib
# # 1.``先确定算法类型``(md5``普遍使用``)
# md5 = hashlib.md5()
# # 2.``将明文数据传递给``md5``算法``(update``只能接受``bytes``类型数据``)
# md5.update(b'123')
# # ``加盐``(``干扰项``) ``格式为``md5.update(b'``公司内部自定义的盐``')
# md5.update(b'abc') # a906449d5769fa7361d7ecc6aa3f6d28
# # ``动态加盐``(``干扰项``) ``当前时间 用户名的部分`` uuid(``随机字符串``(``永远不会重复``))
# import time
# res1 = str(time.time())
# md5.update(res1.encode('utf8'))
# # ``真实数据
# md5.update(b'123abc')
# # 3.``获取加密之后的密文数据``(``没有规则的一串随机字符串``)
# res = md5.hexdigest()
# print(res) # 68f128bc611544f439426ceea3dae3a7
密文一致性校验
"""
文件不是很大的情况下 可以将所有的文件内容全部加密处理
但是如果文件特别大 全部加密处理相当的耗时耗资源 如何解决???
针对大文件可以使用切片读取的方式
"""
# import hashlib
# md5 = hashlib.md5()
# with open(r'a.txt','rb') as f:
# for line in f:
# md5.update(line)
# real_data = md5.hexdigest()
# print(real_data) # e5f6700043d90045f2eed3bab8e08cfa
# md5 = hashlib.md5()
# with open(r'a.txt','rb') as f:
# for line in f:
# md5.update(line)
# error_data = md5.hexdigest()
# print(error_data) # e5f6700043d90045f2eed3bab8e08cfa
#
# import os
# res = os.path.getsize(r'a.txt')
# read_method = [0,res//4,res//2,res]
logging****模块
2022年7月14日
15:35
日志命名格式：
日志名是区别日志业务归属的一种重要的标识
注：可以在日志字典中定义一个空key，这样当日志字典中找不到key时可以调用这个空key
案例：
'loggers': {
#logging.getLogger(__name__)``拿到的``logger``配置
'': {
'handlers': ['default', 'console'],
# ``这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
'level': 'DEBUG',
# loggers(``第一层日志级别关限制)--->handlers(第二层日志级别关卡限制)
'propagate': False,
# ``默认为True，向上（更高level的logger）传递，通常设置为False即可，否则会一份日志向上层层传递
},
'``专门的采集``': {
'handlers': ['other',],
'level': 'DEBUG',
'propagate': False,
},
},
日志轮转：
日志记录着程序运行过程的关键信息
案例：
'default': {
'level': 'DEBUG',
'class': 'logging.handlers.RotatingFileHandler', # ``保存到文件``,``日志轮转
'formatter': 'standard',
# ``可以定制日志文件路径
# BASE_DIR = os.path.dirname(os.path.abspath(__file__)) # log``文件的目录
# LOG_PATH = os.path.join(BASE_DIR,'a1.log')
'filename': 'a1.log', # ``日志文件
'maxBytes': 1024*1024*5, # ``日志大小`` 5M
'backupCount': 5,``# ``最多保存几份
'encoding': 'utf-8', # ``日志文件的编码，再也不用担心中文``log``乱码了
日志原理
一 日志级别
CRITICAL = 50 #FATAL = CRITICAL
ERROR = 40
WARNING = 30 #WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0 #``不设置
二 默认级别为warning，默认打印到终端
import logging
logging.debug('``调试``debug')
logging.info('``消息``info')
logging.warning('``警告``warn')
logging.error('``错误``error')
logging.critical('``严重``critical')
'''
WARNING:root:``警告``warn
ERROR:root:``错误``error
CRITICAL:root:``严重``critical
'''
三 为logging模块指定全局配置，针对所有logger有效，控制打印到文件中
可在``logging.basicConfig()``函数中通过具体参数来更改``logging``模块默认行为，可用参数有
filename``：用指定的文件名创建``FiledHandler``（后边会具体讲解``handler``的概念），这样日志会被存储在指定的文件中。
filemode``：文件打开方式，在指定了``filename``时使用这个参数，默认值为``“a”``还可指定为``“w”``。
format``：指定``handler``使用的日志显示格式。
datefmt``：指定日期时间格式。
level``：设置``rootlogger``（后边会讲解具体概念）的日志级别
stream``：用指定的``stream``创建``StreamHandler``。可以指定输出到``sys.stderr,sys.stdout``或者文件，默认为``sys.stderr``。若同时列出了``filename``和``stream``两个参数，则``stream``参数会被忽略。
#``格式
%(name)s``：``Logger``的名字，并非用户名，详细查看
%(levelno)s``：数字形式的日志级别
%(levelname)s``：文本形式的日志级别
%(pathname)s``：调用日志输出函数的模块的完整路径名，可能没有
%(filename)s``：调用日志输出函数的模块的文件名
%(module)s``：调用日志输出函数的模块名
%(funcName)s``：调用日志输出函数的函数名
%(lineno)d``：调用日志输出函数的语句所在的代码行
%(created)f``：当前时间，用``UNIX``标准的表示时间的浮 点数表示
%(relativeCreated)d``：输出日志信息时的，自``Logger``创建以 来的毫秒数
%(asctime)s``：字符串形式的当前时间。默认格式是`` “2003-07-08 16:49:45,896”``。逗号后面的是毫秒
%(thread)d``：线程``ID``。可能没有
%(threadName)s``：线程名。可能没有
%(process)d``：进程``ID``。可能没有
%(message)s``：用户输出的消息
#======介绍
可在``logging.basicConfig()``函数中可通过具体参数来更改``logging``模块默认行为，可用参数有
filename``：用指定的文件名创建``FiledHandler``（后边会具体讲解``handler``的概念），这样日志会被存储在指定的文件中。
filemode``：文件打开方式，在指定了``filename``时使用这个参数，默认值为``“a”``还可指定为``“w”``。
format``：指定``handler``使用的日志显示格式。
datefmt``：指定日期时间格式。
level``：设置``rootlogger``（后边会讲解具体概念）的日志级别
stream``：用指定的``stream``创建``StreamHandler``。可以指定输出到``sys.stderr,sys.stdout``或者文件，默认为``sys.stderr``。若同时列出了``filename``和``stream``两个参数，则``stream``参数会被忽略。
format``参数中可能用到的格式化串：
%(name)s``=`` Logger``的名字
%(levelno)s``=`` ``数字形式的日志级别
%(levelname)s``=`` ``文本形式的日志级别
%(pathname)s ``=``调用日志输出函数的模块的完整路径名，可能没有
%(filename)s ``=``调用日志输出函数的模块的文件名
%(module)s ``=``调用日志输出函数的模块名
%(funcName)s ``=``调用日志输出函数的函数名
%(lineno)d ``=``调用日志输出函数的语句所在的代码行
%(created)f ``=``当前时间，用``UNIX``标准的表示时间的浮 点数表示
%(relativeCreated)d ``=``输出日志信息时的，自``Logger``创建以 来的毫秒数
%(asctime)s ``=``字符串形式的当前时间。默认格式是`` “2003-07-08 16:49:45,896”``。逗号后面的是毫秒
%(thread)d ``=``线程``ID``。可能没有
%(threadName)s ``=``线程名。可能没有
%(process)d``=`` ``进程``ID``。可能没有
%(message)s``=``用户输出的消息
#========使用
import logging
logging.basicConfig(filename='access.log',
format='%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S %p',
level=10)
logging.debug('``调试``debug')
logging.info('``消息``info')
logging.warning('``警告``warn')
logging.error('``错误``error')
logging.critical('``严重``critical')
#========结果
access.log``内容``:
2017-07-28 20:32:17 PM - root - DEBUG -test: ``调试``debug
2017-07-28 20:32:17 PM - root - INFO -test: ``消息``info
2017-07-28 20:32:17 PM - root - WARNING -test: ``警告``warn
2017-07-28 20:32:17 PM - root - ERROR -test: ``错误``error
2017-07-28 20:32:17 PM - root - CRITICAL -test: ``严重``critical
part2: ``可以为``logging``模块指定模块级的配置``,``即所有``logger``的配置
四 logging模块的Formatter，Handler，Logger，Filter对象
原理图：``https://pan.baidu.com/s/1skWyTT7
#logger``：产生日志的对象
#Filter``：过滤日志的对象
#Handler``：接收日志然后控制打印到不同的地方，``FileHandler``用来打印到文件中，``StreamHandler``用来打印到终端
#Formatter``对象：可以定制不同的日志格式对象，然后绑定给不同的``Handler``对象使用，以此来控制不同的``Handler``的日志格式
'''
critical=50
error =40
warning =30
info = 20
debug =10
'''
import logging
#1``、``logger``对象：负责产生日志，然后交给``Filter``过滤，然后交给不同的``Handler``输出
logger=logging.getLogger(__file__)
#2``、``Filter``对象：不常用，略
#3``、``Handler``对象：接收``logger``传来的日志，然后控制输出
h1=logging.FileHandler('t1.log') #``打印到文件
h2=logging.FileHandler('t2.log') #``打印到文件
h3=logging.StreamHandler() #``打印到终端
#4``、``Formatter``对象：日志格式
formmater1=logging.Formatter('%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S %p',)
formmater2=logging.Formatter('%(asctime)s : %(message)s',
datefmt='%Y-%m-%d %H:%M:%S %p',)
formmater3=logging.Formatter('%(name)s %(message)s',)
#5``、为``Handler``对象绑定格式
h1.setFormatter(formmater1)
h2.setFormatter(formmater2)
h3.setFormatter(formmater3)
#6``、将``Handler``添加给``logger``并设置日志级别
logger.addHandler(h1)
logger.addHandler(h2)
logger.addHandler(h3)
logger.setLevel(10)
#7``、测试
logger.debug('debug')
logger.info('info')
logger.warning('warning')
logger.error('error')
logger.critical('critical')
五 Logger与Handler的级别
logger``是第一级过滤，然后才能到``handler``，我们可以给``logger``和``handler``同时设置``level``，但是需要注意的是
Logger is also the first to filter the message based on a level — if you set the logger to INFO, and all handlers to DEBUG, you still won't receive DEBUG messages on handlers — they'll be rejected by the logger itself. If you set logger to DEBUG, but all handlers to INFO, you won't receive any DEBUG messages either — because while the logger says "ok, process this", the handlers reject it (DEBUG < INFO).
#``验证
import logging
form=logging.Formatter('%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S %p',)
ch=logging.StreamHandler()
ch.setFormatter(form)
# ch.setLevel(10)
ch.setLevel(20)
l1=logging.getLogger('root')
# l1.setLevel(20)
l1.setLevel(10)
l1.addHandler(ch)
l1.debug('l1 debug')
六 Logger的继承（了解）
import logging
formatter=logging.Formatter('%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S %p',)
ch=logging.StreamHandler()
ch.setFormatter(formatter)
logger1=logging.getLogger('root')
logger1.addHandler(ch)
logger1.setLevel(10)
logger1.debug('log1 debug')
七 应用
"""
logging``配置
"""
import os
import logging.config
# ``定义三种日志输出格式 开始
standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' \
'[%(levelname)s][%(message)s]' #``其中``name``为``getlogger``指定的名字
simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'
id_simple_format = '[%(levelname)s][%(asctime)s] %(message)s'
# ``定义日志输出格式 结束
logfile_dir = os.path.dirname(os.path.abspath(__file__)) # log``文件的目录
logfile_name = 'all2.log' # log``文件名
# ``如果不存在定义的日志目录就创建一个
if not os.path.isdir(logfile_dir):
os.mkdir(logfile_dir)
# log``文件的全路径
logfile_path = os.path.join(logfile_dir, logfile_name)
# log``配置字典
"""
logging配置
"""
import os
# 1、定义三种日志输出格式，日志中可能用到的格式化串如下
# %(name)s Logger的名字
# %(levelno)s 数字形式的日志级别
# %(levelname)s 文本形式的日志级别
# %(pathname)s 调用日志输出函数的模块的完整路径名，可能没有
# %(filename)s 调用日志输出函数的模块的文件名
# %(module)s 调用日志输出函数的模块名
# %(funcName)s 调用日志输出函数的函数名
# %(lineno)d 调用日志输出函数的语句所在的代码行
# %(created)f 当前时间，用UNIX标准的表示时间的浮 点数表示
# %(relativeCreated)d 输出日志信息时的，自Logger创建以 来的毫秒数
# %(asctime)s 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒
# %(thread)d 线程ID。可能没有
# %(threadName)s 线程名。可能没有
# %(process)d 进程ID。可能没有
# %(message)s用户输出的消息
# 2、强调：其中的%(name)s为getlogger时指定的名字
standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' \
'[%(levelname)s][%(message)s]'
simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'
test_format = '%(asctime)s] %(message)s'
# 3、日志配置字典
LOGGING_DIC = {
'version': 1,
'disable_existing_loggers': False,
'formatters': {
'standard': {
'format': standard_format
},
'simple': {
'format': simple_format
},
'test': {
'format': test_format
},
},
'filters': {},
'handlers': {
#``打印到终端的日志
'console': {
'level': 'DEBUG',
'class': 'logging.StreamHandler', # ``打印到屏幕
'formatter': 'simple'
},
#``打印到文件的日志``,``收集``info``及以上的日志
'default': {
'level': 'DEBUG',
'class': 'logging.handlers.RotatingFileHandler', # ``保存到文件``,``日志轮转
'formatter': 'standard',
# ``可以定制日志文件路径
# BASE_DIR = os.path.dirname(os.path.abspath(__file__)) # log``文件的目录
# LOG_PATH = os.path.join(BASE_DIR,'a1.log')
'filename': 'a1.log', # ``日志文件
'maxBytes': 1024*1024*5, # ``日志大小`` 5M
'backupCount': 5,
'encoding': 'utf-8', # ``日志文件的编码，再也不用担心中文``log``乱码了
},
'other': {
'level': 'DEBUG',
'class': 'logging.FileHandler', # ``保存到文件
'formatter': 'test',
'filename': 'a2.log',
'encoding': 'utf-8',
},
},
'loggers': {
#logging.getLogger(__name__)``拿到的``logger``配置
'': {
'handlers': ['default', 'console'], # ``这里把上面定义的两个``handler``都加上，即``log``数据既写入文件又打印到屏幕
'level': 'DEBUG', # loggers(``第一层日志级别关限制``)--->handlers(``第二层日志级别关卡限制``)
'propagate': False, # ``默认为``True``，向上（更高``level``的``logger``）传递，通常设置为``False``即可，否则会一份日志向上层层传递
},
'``专门的采集``': {
'handlers': ['other',],
'level': 'DEBUG',
'propagate': False,
},
},
}
def load_my_logging_cfg():
logging.config.dictConfig(LOGGING_DIC) # ``导入上面定义的``logging``配置
logger = logging.getLogger(__name__) # ``生成一个``log``实例
logger.info('It works!') # ``记录该文件的运行状态
if __name__ == '__main__':
load_my_logging_cfg()
"""
MyLogging Test
"""
import time
import logging
import my_logging # ``导入自定义的``logging``配置
logger = logging.getLogger(__name__) # ``生成``logger``实例
def demo():
logger.debug("start range... time:{}".format(time.time()))
logger.info("``中文测试开始。。。``")
for i in range(10):
logger.debug("i:{}".format(i))
time.sleep(0.2)
else:
logger.debug("over range... time:{}".format(time.time()))
logger.info("``中文测试结束。。。``")
if __name__ == "__main__":
my_logging.load_my_logging_cfg() # ``在你程序文件的入口加载自定义``logging``配置
demo()
注意注意注意：
#1``、有了上述方式我们的好处是：所有与``logging``模块有关的配置都写到字典中就可以了，更加清晰，方便管理
#2``、我们需要解决的问题是：
1``、从字典加载配置：``logging.config.dictConfig(settings.LOGGING_DIC)
2``、拿到``logger``对象来产生日志
logger``对象都是配置到字典的``loggers ``键对应的子字典中的
``按照我们对``logging``模块的理解，要想获取某个东西都是通过名字，也就是``key``来获取的
``于是我们要获取不同的``logger``对象就是
logger=logging.getLogger('loggers``子字典的``key``名``')
``但问题是：如果我们想要不同``logger``名的``logger``对象都共用一段配置，那么肯定不能在``loggers``子字典中定义``n``个``key
'loggers': {
'l1': {
'handlers': ['default', 'console'], #
'level': 'DEBUG',
'propagate': True, # ``向上（更高``level``的``logger``）传递
},
'l2: {
'handlers': ['default', 'console' ],
'level': 'DEBUG',
'propagate': False, # ``向上（更高``level``的``logger``）传递
},
'l3': {
'handlers': ['default', 'console'], #
'level': 'DEBUG',
'propagate': True, # ``向上（更高``level``的``logger``）传递
},
}
#``我们的解决方式是，定义一个空的``key
'loggers': {
'': {
'handlers': ['default', 'console'],
'level': 'DEBUG',
'propagate': True,
},
}
这样我们再取``logger``对象时
logging.getLogger(__name__)``，不同的文件``__name__``不同，这保证了打印日志时标识信息不同，但是拿着该名字去``loggers``里找``key``名时却发现找不到，于是默认使用``key=''``的配置
另外一个django的配置，瞄一眼就可以，跟上面的一样
#logging_config.py
LOGGING = {
'version': 1,
'disable_existing_loggers': False,
'formatters': {
'standard': {
'format': '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]'
'[%(levelname)s][%(message)s]'
},
'simple': {
'format': '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'
},
'collect': {
'format': '%(message)s'
}
},
'filters': {
'require_debug_true': {
'()': 'django.utils.log.RequireDebugTrue',
},
},
'handlers': {
#``打印到终端的日志
'console': {
'level': 'DEBUG',
'filters': ['require_debug_true'],
'class': 'logging.StreamHandler',
'formatter': 'simple'
},
#``打印到文件的日志``,``收集``info``及以上的日志
'default': {
'level': 'INFO',
'class': 'logging.handlers.RotatingFileHandler', # ``保存到文件，自动切
'filename': os.path.join(BASE_LOG_DIR, "xxx_info.log"), # ``日志文件
'maxBytes': 1024 * 1024 * 5, # ``日志大小`` 5M
'backupCount': 3,
'formatter': 'standard',
'encoding': 'utf-8',
},
#``打印到文件的日志``:``收集错误及以上的日志
'error': {
'level': 'ERROR',
'class': 'logging.handlers.RotatingFileHandler', # ``保存到文件，自动切
'filename': os.path.join(BASE_LOG_DIR, "xxx_err.log"), # ``日志文件
'maxBytes': 1024 * 1024 * 5, # ``日志大小`` 5M
'backupCount': 5,
'formatter': 'standard',
'encoding': 'utf-8',
},
#``打印到文件的日志
'collect': {
'level': 'INFO',
'class': 'logging.handlers.RotatingFileHandler', # ``保存到文件，自动切
'filename': os.path.join(BASE_LOG_DIR, "xxx_collect.log"),
'maxBytes': 1024 * 1024 * 5, # ``日志大小`` 5M
'backupCount': 5,
'formatter': 'collect',
'encoding': "utf-8"
}
},
'loggers': {
#logging.getLogger(__name__)``拿到的``logger``配置
'': {
'handlers': ['default', 'console', 'error'],
'level': 'DEBUG',
'propagate': True,
},
#logging.getLogger('collect')``拿到的``logger``配置
'collect': {
'handlers': ['console', 'collect'],
'level': 'INFO',
}
},
}
# -----------
# ``用法``:``拿到俩个``logger
logger = logging.getLogger(__name__) #``线上正常的日志
collect_logger = logging.getLogger("collect") #``领导说``,``需要为领导们单独定制领导们看的日志
应用
paramiko模块
2022年7月31日
19:18
介绍
Paramiko是用python语言写的一个模块，远程连接到Linux服务器，查看上面的日志状态，批量配置远程服务器，文件上传，文件下载等
paramiko是一个基于SSH用于连接远程服务器并执行相关操作（SSHClient和SFTPClinet,即一个是远程连接，一个是上传下载服务），使用该模块可以对远程服务器进行命令或文件操作，值得一说的是，fabric和ansible内部的远程管理就是使用的paramiko来现实
ssh是一个协议，OpenSSH是其中一个开源实现，paramiko是Python的一个库，实现了SSHv2协议(底层使用cryptography)。
有了Paramiko以后，我们就可以在Python代码中直接使用SSH协议对远程服务器执行操作，而不是通过ssh命令对远程服务器进行操作。
Paramiko介绍
paramiko包含两个核心组件：SSHClient和SFTPClient。
- SSHClient的作用类似于Linux的ssh命令，是对SSH会话的封装，该类封装了传输(Transport)，通道(Channel)及SFTPClient建立的方法(open_sftp)，通常用于执行远程命令。
- SFTPClient的作用类似与Linux的sftp命令，是对SFTP客户端的封装，用以实现远程文件操作，如文件上传、下载、修改文件权限等操作。
# Paramiko中的几个基础名词：
1``、``Channel``：是一种类``Socket``，一种安全的``SSH``传输通道；
2``、``Transport``：是一种加密的会话，使用时会同步创建了一个加密的``Tunnels(``通道``)``，这个``Tunnels``叫做``Channel``；
3``、``Session``：是``client``与``Server``保持连接的对象，用``connect()/start_client()/start_server()``开始会话。
Paramiko的基本使用
SSHClient常用的方法介绍
connect()：实现远程服务器的连接与认证，对于该方法只有hostname是必传参数。
常用参数
hostname ``连接的目标主机`
`port=SSH_PORT ``指定端口`
`username=None ``验证的用户名`
`password=None ``验证的用户密码`
`pkey=None ``私钥方式用于身份验证`
`key_filename=None ``一个文件名或文件列表，指定私钥文件`
`timeout=None ``可选的``tcp``连接超时时间`
`allow_agent=True, ``是否允许连接到``ssh``代理，默认为``True ``允许`
`look_for_keys=True ``是否在``~/.ssh``中搜索私钥文件，默认为``True ``允许`
`compress=False, ``是否打开压缩
set_missing_host_key_policy()：
设置远程服务器没有在know_hosts文件中记录时的应对策略。目前支持三种策略：
AutoAddPolicy 自动添加主机名及主机密钥到本地HostKeys对象，不依赖load_system_host_key的配置。即新建立ssh连接时不需要再输入yes或no进行确认
WarningPolicy 用于记录一个未知的主机密钥的python警告。并接受，功能上和AutoAddPolicy类似，但是会提示是新连接
RejectPolicy 自动拒绝未知的主机名和密钥，依赖load_system_host_key的配置。此为默认选项
exec_command()：
在远程服务器执行Linux命令的方法。
open_sftp()：
在当前``ssh``会话的基础上创建一个``sftp``会话。该方法会返回一个``SFTPClient``对象。
# ``利用``SSHClient``对象的``open_sftp()``方法，可以直接返回一个基于当前连接的``sftp``对象，可以进行文件的上传等操作``. sftp=client.open_sftp()sftp.put('local.txt','remote.txt'
SSHClient常用的方法举例
import paramiko
# ``实例化``SSHClient
ssh_client = paramiko.SSHClient()
# ``自动添加策略，保存服务器的主机名和密钥信息，如果不添加，那么不再本地``know_hosts``文件中记录的主机将无法连接 ，此方法必须放在``connect``方法的前面
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
# ``连接``SSH``服务端，以用户名和密码进行认证 ，调用``connect``方法连接服务器
ssh_client.connect(hostname='192.168.137.105', port=22, username='root', password='123456')
# ``打开一个``Channel``并执行命令 `` ``结果放到``stdout``中，如果有错误将放到``stderr``中
stdin, stdout, stderr = ssh_client.exec_command('df -hT ')
# stdout ``为正确输出，``stderr``为错误输出，同时是有``1``个变量有值 `` # ``打印执行结果 `` print(stdout.read().decode('utf-8'))
# ``关闭``SSHClient``连接
ssh_client.close()
密钥连接方式
# ``配置私人密钥文件位置
private = paramiko.RSAKey.from_private_key_file('/root/.ssh/id_rsa')
#``实例化``SSHClient
ssh_client = paramiko.SSHClient()
#``自动添加策略，保存服务器的主机名和密钥信息，如果不添加，那么不再本地``know_hosts``文件中记录的主机将无法连接
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
#``连接``SSH``服务端，以用户名和密码进行认证
ssh_client.connect(
hostname='192.168.137.100',
port=22,
username='root',
pkey=private
)
SFTPClient常用方法介绍
SFTPCLient作为一个sftp的客户端对象，根据ssh传输协议的sftp会话，实现远程文件操作，如上传、下载、权限、状态
from_transport(cls,t) ``创建一个已连通的``SFTP``客户端通道
put(localpath, remotepath, callback=None, confirm=True) ``将本地文件上传到服务器
参数``confirm``：是否调用``stat()``方法检查文件状态，返回``ls -l``的结果
get(remotepath, localpath, callback=None) ``从服务器下载文件到本地
mkdir() ``在服务器上创建目录
remove() ``在服务器上删除目录
rename() ``在服务器上重命名目录
stat() ``查看服务器文件状态
listdir() ``列出服务器目录下的文件
SFTPClient常用方法举例
import paramiko
# ``实例化一个``transport``对象
tran = paramiko.Transport(('192.168.137.100', 22))
# ``连接``SSH``服务端，使用``password
tran.connect(username="root", password='123456')
# ``或使用
# ``配置私人密钥文件位置
private = paramiko.RSAKey.from_private_key_file('/root/.ssh/id_rsa')
# ``连接``SSH``服务端，使用``pkey``指定私钥
tran.connect(username="root", pkey=private)
# ``获取``SFTP``实例
sftp = paramiko.SFTPClient.from_transport(tran)
# ``设置上传的本地``/``远程文件路径
local_path = "/home/1.txt"
remote_path = "/tmp/1.txt"
# ``执行上传动作
sftp.put(local_path, remote_path)
# ``执行下载动作
sftp.get(remote_path, local_path)
# ``关闭``Transport``通道
tran.close()
openpyxl模块
2022年7月31日
14:08
方法
打开方式
wb=Workbook()#``新建``Excel``工作簿
wb=load_workbook("data\``领料单（每日）``.xlsx") ``# ``打开存在的表格
保存方式
wb.save("data\``领料单（每日）``-``更改后``.xlsx") # ``保存表格
获取工作表的方式
sheet_names=wb.get_sheet_names()`` # ``获取每个表的名字
ws=wb[sheet_name] # ``获取指定的表格
ws=wb.active #``读取活动工作表
设置数据的方式
直接指定单元格
ws['A4'].value="``零件测试领料单``" #``直接将``A4``单元格的值改为需要的值
ws['A4'].value ``获取数据
指定行列
ws.cell(``行``,column=``列``,value=``值``)
ws.cell(``行``,``列``).value ``# ``获取值
设置样式
第一步导包
from openpyxl.styles import Border, Side, PatternFill, Font, GradientFill, Alignment
第二步获取单元格
c = ws.cell(row=row_number,column=col_number)
第三部设置
c.font = Font(name='Arial'``，``size=10) # ``设置字体 和大小
c.border = Border(top=thin, left=thin, right=thin, bottom=thin) # ``设置边框
c.alignment = Alignment(horizontal="left", vertical="center") ``# ``设置对其
案例
from openpyxl import load_workbook
wb=load_workbook("data\``领料单（每日）``.xlsx") ``# ``打开存在的表格
sheet_names=wb.get_sheet_names()#``获得工作簿的所有工作表名
for sheet_name in sheet_names:#``遍历每个工作表，更改``A4``单元格的数据
ws=wb[sheet_name] # ``获取指定的表格
ws['A4'].value="``零件测试领料单``" #``直接将``A4``单元格的值改为需要的值
wb.save("data\``领料单（每日）``-``更改后``.xlsx") # ``保存表格
Python-docx模块
2022年10月9日
15:10
写word
案例一：
# -*- coding: utf-8 -*-
# All Rights Reserved
# @Time : 2022/10/914:31
# @Author : Small Fu
# @Email : 2737454073@qq.com
# @File : word_xiaoy.py
__author__ = 'Small Fu'
from docx import Document # ``初始化``word
from docx.enum.text import WD_PARAGRAPH_ALIGNMENT # ``段落对其
from docx.shared import Pt # ``字体磅数
from docx.oxml.ns import qn # ``设置中文格式
import time
price = input("``今日价格：``")
# ``这是客户
customer_list = [f"``客户``{i}" for i in range(10)]
time_sameDay = time.strftime("%Y``年`` %m``月`` %d``日``", time.localtime())
# ``开始设置
for customer in customer_list:
doc = Document()
# ``设置基础字体``,``这个值设置英文和数字
doc.styles["Normal"].font.name = u"``宋体``"
# ``增加中文支持
doc.styles["Normal"]._element.rPr.rFonts.set(qn("w:eastAsia"), u"``宋体``")
# ``初始化一个段落
p1 = doc.add_paragraph()
# ``设置文字对齐居中，没有的话默认左对齐
p1.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
# ``添加第一段的内容
run1 = p1.add_run(f"``关于下达``{time_sameDay}``产品价格通知``")
# ``设置这一段的字体是微软雅黑西文
run1.font.name = "``微软雅黑``"
# ``设置中文
run1._element.rPr.rFonts.set(qn("w:eastAsia"), u"``宋体``")
# ``设置字体大小
run1.font.size = Pt(21)
# ``是否加粗，默认不加粗，``False
run1.font.bold = True
# ``设置这一段前面的字体大小和后面的
p1.space_after = Pt(5)
p1.space_before = Pt(5)
# ``第二段内容
p2 = doc.add_paragraph()
# ``这里是添加尊称
run2 = p2.add_run(f"{customer}: \n ``您好``")
# ``设置这一段的字体是微软雅黑西文
run2.font.name = "``仿宋``_GB2312"
# ``设置中文
run2._element.rPr.rFonts.set(qn("w:eastAsia"), u"``仿宋``_GB2312 ")
# ``设置字体大小
run2.font.size = Pt(16)
# ``是否加粗，默认不加粗，``False
run2.font.bold = True
# ``第三段内容
p3 = doc.add_paragraph()
# ``这里是添加尊称
run3 = p3.add_run(f" ``根据公司安排，为提供优质客户需求，我单位拟定了今日黄金价格为``{price}``元，特此通知``")
# ``设置这一段的字体是微软雅黑西文
run3.font.name = "``仿宋``_GB2312"
# ``设置中文
run3._element.rPr.rFonts.set(qn("w:eastAsia"), u"``仿宋``_GB2312 ")
# ``设置字体大小
run3.font.size = Pt(16)
# ``是否加粗，默认不加粗，``False
run3.font.bold = True
# ``第四段内容
p4 = doc.add_paragraph()
# ``这里是添加尊称
run4 = p4.add_run(" ``联系人：小符`` ``电话：``176XXXXXX44 ")
# ``设置这一段的字体是微软雅黑西文
run4.font.name = "``仿宋``_GB2312"
# ``设置中文
run4._element.rPr.rFonts.set(qn("w:eastAsia"), u"``仿宋``_GB2312 ")
# ``设置字体大小
run4.font.size = Pt(16)
# ``是否加粗，默认不加粗，``False
run4.font.bold = True
# ``保存
doc.save(f"{customer}-``价格通知``.docx")
案例二图片添加
# -*- coding: utf-8 -*-
# All Rights Reserved
# @Time : 2022/10/915:13
# @Author : Small Fu
# @Email : 2737454073@qq.com
# @File : xiaofu-img.py
__author__ = 'Small Fu'
from docx import Document # ``初始化``word
from docx.enum.text import WD_PARAGRAPH_ALIGNMENT # ``段落对其
from docx.shared import Pt # ``字体磅数
from docx.oxml.ns import qn # ``设置中文格式
from docx.shared import Inches # ``图片尺寸
import time
price = input("``今日价格：``")
# ``这是客户
customer_list = [f"``客户``{i}" for i in range(10)]
time_sameDay = time.strftime("%Y``年`` %m``月`` %d``日``", time.localtime())
# ``开始设置
for customer in customer_list:
doc = Document()
# ``设置基础字体``,``这个值设置英文和数字
doc.styles["Normal"].font.name = u"``宋体``"
# ``增加中文支持
doc.styles["Normal"]._element.rPr.rFonts.set(qn("w:eastAsia"), u"``宋体``")
# ``文档添加图片``width=Inches(6) ``这里设置的是``6``英寸
doc.add_picture("./img_1.png",width=Inches(6))
# ``初始化一个段落
p1 = doc.add_paragraph()
# ``设置文字对齐居中，没有的话默认左对齐
p1.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
# ``添加第一段的内容
run1 = p1.add_run(f"``关于下达``{time_sameDay}``产品价格通知``")
# ``设置这一段的字体是微软雅黑西文
run1.font.name = "``微软雅黑``"
# ``设置中文
run1._element.rPr.rFonts.set(qn("w:eastAsia"), u"``宋体``")
# ``设置字体大小
run1.font.size = Pt(21)
# ``是否加粗，默认不加粗，``False
run1.font.bold = True
# ``设置这一段前面的字体大小和后面的
p1.space_after = Pt(5)
p1.space_before = Pt(5)
# ``第二段内容
p2 = doc.add_paragraph()
# ``这里是添加尊称
run2 = p2.add_run(f"{customer}: \n ``您好``")
# ``设置这一段的字体是微软雅黑西文
run2.font.name = "``仿宋``_GB2312"
# ``设置中文
run2._element.rPr.rFonts.set(qn("w:eastAsia"), u"``仿宋``_GB2312 ")
# ``设置字体大小
run2.font.size = Pt(16)
# ``是否加粗，默认不加粗，``False
run2.font.bold = True
# ``第三段内容
p3 = doc.add_paragraph()
# ``这里是添加尊称
run3 = p3.add_run(" ``根据公司安排，为提供优质客户服务，我单位现将价格通知如下：`` ")
# ``设置这一段的字体是仿宋``_GB2312``西文
run3.font.name = "``仿宋``_GB2312"
# ``设置中文
run3._element.rPr.rFonts.set(qn("w:eastAsia"), u"``仿宋``_GB2312 ")
# ``设置字体大小
run3.font.size = Pt(16)
# ``是否加粗，默认不加粗，``False
run3.font.bold = True
# ``添加表格``row=``行``,cols=``列``,style=``样式
table = doc.add_table(rows=3,cols=3,style="Table Grid")
# ``这里是从第``0``行``0``列合并到``0``行``2``列
table.cell(0,0).merge(table.cell(0,2))
# ``添加到合并的单元格
table_run1 = table.cell(0,0).paragraphs[0].add_run("xx``商品报表``")
table_run1.font.name = u"``隶书``"
# ``设置中文
table_run1._element.rPr.rFonts.set(qn("w:eastAsia"), u"``隶书`` ")
# ``设置居中
table.cell(0,0).paragraphs[0].alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
# ``添加
table.cell(1,0).text="``日期``"
table.cell(1,1).text="``价格``"
table.cell(1,2).text="``备注``"
table.cell(2,0).text=time_sameDay
table.cell(2,1).text=set(price)
table.cell(2,2).text=""
# ``第四段内容
p4 = doc.add_paragraph()
# ``这里是添加尊称
run4 = p4.add_run(" ``联系人：小符`` ``电话：``176XXXXXX44 ")
# ``设置这一段的字体是微软雅黑西文
run4.font.name = "``仿宋``_GB2312"
# ``设置中文
run4._element.rPr.rFonts.set(qn("w:eastAsia"), u"``仿宋``_GB2312 ")
# ``设置字体大小
run4.font.size = Pt(16)
# ``是否加粗，默认不加粗，``False
run4.font.bold = True
# ``下一页添加一个广告
# ``插入分页符
doc.add_page_break()
# ``文档添加图片``width=Inches(6) ``这里设置的是``6``英寸
doc.add_picture("./img_1.png",width=Inches(6))
doc.save(f"{customer}-``价格图片表格通知``.docx")
读word
案例一：读纯文本
# -*- coding: utf-8 -*-
# All Rights Reserved
# @Time : 2022/10/915:54
# @Author : Small Fu
# @Email : 2737454073@qq.com
# @File : ``读取简单``word``纯文本``.py
__author__ = 'Small Fu'
from docx import Document
doc = Document("``地址``.docx")
all_paragraphs = doc.paragraphs # ``读取所有的段落
for paragraphs in all_paragraphs:
print(paragraphs.text)
案例二：读取表格文本
# -*- coding: utf-8 -*-
# All Rights Reserved
# @Time : 2022/10/916:02
# @Author : Small Fu
# @Email : 2737454073@qq.com
# @File : ``读取表格文本``.py
__author__ = 'Small Fu'
from docx import Document
doc = Document("``路径``")
all_tables = doc.tables
for tables in all_tables:
for row in tables.rows:
for cell in row.cells:
print(cell.text)
案例三：读取表格嵌套纯文本
# -*- coding: utf-8 -*-
# All Rights Reserved
# @Time : 2022/10/916:06
# @Author : Small Fu
# @Email : 2737454073@qq.com
# @File : ``读取表格嵌套纯文本``.py
__author__ = 'Small Fu'
import zipfile
word = zipfile.ZipFile("``路径``")
xml = word.read("word/document.xml").decode('utf-8')
xml_list = xml.split("<w:t>")
text_file = []
for xml in xml_list:
if xml.find("</w:t>")+1:
text_file.append(
xml[:xml.find("</w:t>")]
)
else:
pass
text_file = "".join(text_file)
格式化word：函数式
案例一：
# -*- coding: utf-8 -*-
# All Rights Reserved
# @Time : 2022/10/916:23
# @Author : Small Fu
# @Email : 2737454073@qq.com
# @File : ``函数式模板``.py
__author__ = 'Small Fu'
from docx import Document # ``初始化``word
from docx.enum.text import WD_PARAGRAPH_ALIGNMENT # ``段落对其
from docx.shared import Pt # ``字体磅数
from docx.oxml.ns import qn # ``设置中文格式
doc = Document()
doc.styles["Normal"].font.name = u"``黑体``"
doc.styles["Normal"]._element.rPr.rFonts.set(qn("w:eastAsia"), u"``黑体``")
def add_context(context):
p1 = doc.add_paragraph()
p1.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
# ``添加内容
run1 = p1.add_run(str(context))
# ``设置这一段的字体是微软雅黑西文
run1.font.size = Pt(16)
# ``设置这一段前面的字体大小和后面的
p1.space_after = Pt(5)
p1.space_before = Pt(5)
word转pdf
tqdm模块
2021年12月2日
14:59
Tqdm
Tqdm 是一个快速，可扩展的Python进度条，可以在 Python 长循环中添加一个进度提示信息，用户只需要封装任意的迭代器 tqdm(iterator)。
安装
pip install tqdm
使用
#for I in tqdm(range(100)):
#time.sleep(0.0001)
#
#
#for j in trange(100):
#time.sleep(0.1)
两个效果是一样的
如果是遍历列表之类的可以用
# alist=list('letters')
# bar=tqdm(alist)
# for letter in bar:
bar.set_description(f"Nowget{letter}")
# pbar=tqdm(["a","b","c","d"])
# for char inp bar:
# time.sleep(1)
# pbar.set_description("Processing%s"%char)
tqdm模块参数说明
class tqdm(object):
"""
Decorate an iterable object, returning an iterator which acts exactly
like the original iterable, but prints a dynamically updating
progressbar every time a value is requested.
"""
def __init__(self,
iterable=None,
desc=None,
total=None,
leave=False,
file=sys.stderr,
ncols=None,
mininterval=0.1,
maxinterval=10.0,
miniters=None,
ascii=None,
disable=False,
unit='it',
unit_scale=False,
dynamic_ncols=False,
smoothing=0.3,
nested=False,
bar_format=None,
initial=0,
gui=False
):
iterable: ``可迭代的对象``, ``在手动更新时不需要进行设置
desc: ``字符串``, ``左边进度条描述文字
total: ``总的项目数
leave: bool``值``, ``迭代完成后是否保留进度条
file: ``输出指向位置``, ``默认是终端``, ``一般不需要设置
ncols: ``调整进度条宽度``, ``默认是根据环境自动调节长度``, ``如果设置为``0, ``就没有进度条``, ``只有输出的信息
unit: ``描述处理项目的文字``, ``默认是``'it', ``例如``: 100 it/s, ``处理照片的话设置为``'img' ,``则为`` 100 img/s
unit_scale: ``自动根据国际标准进行项目处理速度单位的换算``, ``例如`` 100000 it/s >> 100k it/s
爬虫下载文件结合tqdm
from tqdm import tqdm
import requests
url='https://dldir1.qq.com/qqtv/TencentVideo11.14.4043.0.exe'
response=requests.get(url,stream=True) # ``设``stream``流传输方式为真
print(response.headers) # ``打印查看基本头信息
data_size=int(response.headers['Content-Length'])/1024/1024 # ``字节``/1024/1024=MB
with open('``测试``.exe','wb') as f:
for data in tqdm(iterable=response.iter_content(1024*1024),total=data_size,desc='``正在下载``',unit='MB'):
f.write(data)
因此我将iter_content(chunk_size)->chunk_size理解为一个列表的容量，
而iterable=response.iter_content(1024*1024)理解为分割字符串的函数，
将response.content分割为每个元素的长度是1024*1024大小的列表，在对每个部分进行下载。
这只是助于理解chunk_size的一个方法
而response.iter_content 是流传输(简单说就是边下载边写入磁盘),如果将chunk_size设置的很小，意味着每次
下载和存在很小的一部分，下载的速度也会很慢,如果设置的很大，则进度条的进度会错乱，因此我们在确定chunk_size
大小的时候应该对应文件大小，data_size除以多少，chunk_size就乘以多少，才能使进度条对应。
# -*- coding: utf-8 -*-
# All Rights Reserved
# @Time : 2022/6/29 18:32
# @Author : ``符青
# @Email : 2737454073@qq.com
# @File : aa.py
# @Software: PyCharm
import pprint
import requests
from tqdm import tqdm
url = '`https://v3-default.ixigua.com/37179974c244973c87813da84e13ff61/62bc51c7/video/tos/cn/tos-cn-v-0064/25755a2b84b24deeaa48d8e3407b0baa/?libvio.cc&filename=1.mp4`'
response = requests.get(url, stream=True) # ``采用流处理传输输入
pprint.pprint(response.headers)
# ``查看数据大小
data_sice = int(response.headers['Content-Length'])
print(data_sice)
rr = tqdm(
total=data_sice,
desc='``下载恰恰丝滑``',
unit='mb',
unit_scale=True
)
with open('./``恰恰丝滑``.mp4', 'wb+') as ff:
for i in response.iter_content(1024*1024):
rr.update(len(i))
ff.write(i)
ff.close()
pyautogui模块
2022年7月20日
0:46
介绍
自动 防故障功能
pyautogui.FAILSAFE =False
默认这项功能为``True, ``这项功能意味着：当鼠标的指针在屏幕的最坐上方，程序会报错；目的是为了防止程序无法停止；
停顿功能
pyautogui.PAUSE = 1
意味着所有``pyautogui``的指令都要暂停一秒；其他指令不会停顿；这样做，可以防止键盘鼠标操作太快；
鼠标操作函数
操作鼠标点击的函数。
| 函数 | 简单说明 |
|---|---|
| move(x,y)、 moveTo(x,y) | 移动鼠标，前者移动相对位置，后者移动到指定位置 |
| click(x,y)、doubleClick、rightClick | 单击/双击/右击，无参版本在当前位置点击鼠标 |
| drag(x,y)、dragTo(x,y) | 拖动鼠标 |
| mouseDown、mouseUp | 按下按键，松开按键 |
| scroll | 向下滚动鼠标滚轮的函数 |
键盘操作函数
操作键盘按键的函数。
| 函数 | 简介 |
|---|---|
| press(‘left’,press=3) | |
| hotkey(‘ctrl’,‘s’) | 按下Ctrl+S组合键 |
| keyDown、keyUp | 按下和松开键盘按键 |
提示框函数
PyAutoGUI可以显示提示框，这时候程序会暂停运行，直到用户点击提示框。
| 函数 | 简介 |
|---|---|
| alert(text=’’,title=’’,button=[‘OK’,‘Cancle’]) | 显示警告对话框 |
| confirm() | 显示确认对话框 |
| prompt() | 显示提示对话框 |
| password() | 显示密码输入对话框 |
屏幕截图和定位函数
截取屏幕的函数，也可以从屏幕中寻找匹配的图片，并返回其坐标。你可以事先保存一些按钮的截图，然后通过这种方式定位按钮的位置，然后点击。
| 函数 | 简介 |
|---|---|
| screenshot(‘image.png’) | 保存截图并返回截图，无参版本直接返回截图不保存 |
| center(‘image.png’) | 从屏幕上寻找图片位置，返回框位置 |
| locateOnScreen(‘img’) | 从屏幕寻找图片位置，直接返回坐标 |
Pil模块
2022年6月2日
23:47
PIL``功能介绍与安装
PIL``，全称``Python Image Library``，主要作用是图像处理，可用于图片剪切、粘贴、缩放、镜像、水印、颜色块、滤镜、图像格式转换、色场空间转换、验证码、旋转图像、图像增强、直方图处理、插值和滤波等功能。不过只支持到``Python 2.7``。``Pillow``是``PIL``的一个派生分支，但如今已经发展成为比``PIL``本身更具活力的图像处理库。我们需要安装的就是``Pillow``。
PIL``具体用途：图像归档``(Image Archives)``。``PIL``非常适合于图像归档以及图像的批处理任务。你可以使用``PIL``创建缩略图，转换图像格式，打印图像等等。
``图像展示``(Image Display)``。``PIL``较新的版本支持包括``Tk PhotoImage``，``BitmapImage``还有``Windows DIB``等接口。``PIL``支持众多的``GUI``框架接口，可以用于图像展示。
``图像处理``(Image Processing)``。``PIL``包括了基础的图像处理函数，包括对点的处理，使用众多的卷积核``(convolution kernels)``做过滤``(filter),``还有颜色空间的转换。``PIL``库同样支持图像的大小转换，图像旋转，以及任意的仿射变换。``PIL``还有一些直方图的方法，允许你展示图像的一些统计特性。这个可以用来实现图像的自动对比度增强，还有全局的统计分析等。
pip install Pillow
PIL的基本操作
from PIL import Image
# 1.``打开图片
img = Image.open("image/10.png")
# 2.``显示图片``(``执行显示图片后线程会中断，关闭图像后恢复``)
img.show()
# 3.``保存图片
img.save("image/xiaomai.png")
我在尝试的过程中发现，``png``格式的图片保存为``jpg``格式时会报错：``OSError: cannot write mode RGBA as JPEG``，经过查阅资料发现错误原因主要是因为``PNG``格式和``JPG``格式图片的通道数不同。
PNG``是四通道：``RGBA``意思是红色，绿色，蓝色，``Alpha``的色彩空间，``Alpha``指透明度
JPG``是三通道：``RGB``意思是红色，绿色，蓝色
所以，``PNG``格式图片要保存成``JPG``格式就要丢弃``A``通道：
from PIL import Image
# 1.``打开图片
img = Image.open("image/10.png")
# 2.``显示图片``(``执行显示图片后线程会中断，关闭图像后恢复``)
img.show()
# 3.``保存图片
img = img.convert("RGB")
img.save("image/xiaomai.jpg")
下面是图片旋转的代码：
from PIL import Image
# 1.``打开图片
img = Image.open("pli/7.png")
# 2.``水平翻转
img1 = img.transpose(Image.FLIP_LEFT_RIGHT)
# 3.``保存图片
img1.save("pli/1.png")
# 4.``垂直翻转
img2 = img.rotate(180)
# 5.``保存照片
img2.save("pli/2.png")
# 6.``水平``+``垂直翻转
img3 = img.transpose(Image.FLIP_LEFT_RIGHT).rotate(180)
# 7.``保存图片
img3.save("pli/3.png")
给图片增加文字
要在图像上绘制文本要用到 PIL 的两个模块：ImageDraw和ImageFont。 ImageDraw 用于创建绘图对象，ImageFont用于加载字体。
from PIL import Image, ImageDraw, ImageFont
# 1.``打开图片
img = Image.open("image/10.png")
# 2.``调用画图模块
draw = ImageDraw.Draw(img)
# 3.``设置字体
tfont = ImageFont.truetype("``萌神手写体``.ttf", 24)
# 4.``添加文字
"""
``参数一：文字在图片的位置：``(x, y)
``参数二：文字内容
``参数三：字体颜色，当然颜色也可以用``RGB``值指定
``参数四：字体类型
"""
draw.text((50, 30), "eyes++", fill="green", font=tfont)
# 5.``保存图片
img.save("image/addWord.png")
# 6.``显示图片
img.show()
PIL滤镜功能
from PIL import Image, ImageFilter
img = Image.open("image/10.png")
img = img.filter(ImageFilter.CONTOUR)
img.save("image/Filter.png")
img.show()
PIL镜像功能
from PIL import Image
img = Image.open("image/10.png")
img = img.transpose(Image.FLIP_LEFT_RIGHT)
img.save("image/mirror.png")
transpose有这么几种模式
FLIP_LEFT_RIGHT：左右镜像
FLIP_TOP_BOTTOM：上下镜像
ROTATE_90：逆时针转90度
ROTATE_180：逆时针转180度
ROTATE_270：逆时针转270度
TRANSPOSE：像素矩阵转置
TRANSVERSE
最后一种模式我也不知道什么意思，也没查到，但效果是下面这样的，盲猜是对角线对转。。。。。
图片拼接功能
from PIL import Image, ImageDraw
# ``打开图片
img1 = Image.open("image/10.png")
img2 = Image.open("image/addWord.png")
# ``查看图片尺寸，便于拼接图片
print(img1.size)
print(img1.size)
# ``新建空白图片``,``三个参数分别是模式``(RGB/RGBA)``、大小、颜色
newimg = Image.new(mode="RGB", size=(1174, 614), color=(255, 100, 50))
# ``拼接图片``,``第一个参数是图片，第二个是起始位置
newimg.paste(img1, (0, 0))
newimg.paste(img2, (587, 0))
newimg.show()
PIL裁剪功能
from PIL import Image
img = Image.open("image/10.png")
print(img.size)
imgCut = img.crop((100, 200, 500, 600))
imgCut.show()
图片缩放
from PIL import Image
# :
img = Image.open('image/10.png')
# ``获得图像尺寸``:
w, h = img.size
# ``缩放到``50%:
img.thumbnail((w//2, h//2))
# ``把缩放后的图像用``jpeg``格式保存``:
img.save('image/zoom.png')
shutil****模块
2022年7月13日
11:00
高级的 文件、文件夹、压缩包 处理模块
shutil.copyfileobj(fsrc, fdst[, length])
将文件内容拷贝到另一个文件中
1import shutil`
`23shutil.copyfileobj(open('old.xml','r'), open('new.xml', 'w'))
shutil.copyfile(src, dst)
拷贝文件
shutil.copyfile('f1.log', 'f2.log') #``目标文件无需存在
shutil.copymode(src, dst)
仅拷贝权限。内容、组、用户均不变
1shutil.copymode('f1.log', 'f2.log') #``目标文件必须存在
shutil.copystat(src, dst)
仅拷贝状态的信息，包括：``mode bits, atime, mtime, flags
1shutil.copystat('f1.log', 'f2.log') #``目标文件必须存在
shutil.copy(src, dst)
拷贝文件和权限
import shutil`
`shutil.copy('f1.log', 'f2.log')
shutil.copy2(src, dst)
拷贝文件和状态信息
import shutil`
`shutil.copy2('f1.log', 'f2.log')
shutil.ignore_patterns(*patterns)
shutil.copytree(src, dst, symlinks=False, ignore=None)
递归的去拷贝文件夹
import shutil`
`shutil.copytree('folder1', 'folder2', ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))
#``目标目录不能存在，注意对``folder2``目录父级目录要有可写权限，
ignore``的意思是排除 ==》``*.pyc', 'tmp*``：这个是排除易。pyc结尾，和以tmp开头的文件
拷贝软连接
import shutil
shutil.copytree('f1', 'f2', symlinks=True, ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))
'''`
`通常的拷贝都把软连接拷贝成硬链接，即对待软连接来说，创建新的文件`
`'''
shutil.rmtree(path[, ignore_errors[, onerror]])
递归的去删除文件
import shutil`
`shutil.rmtree('folder1')
shutil.move(src, dst)
递归的去移动文件，它类似``mv``命令，其实就是重命名。
import shutil`
`shutil.move('folder1', 'folder3')
shutil.make_archive(base_name, format,...)
创建压缩包并返回文件路径，例如：``zip``、``tar
创建压缩包并返回文件路径，例如：``zip``、``tar
- base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，
如 data_bak =>保存至当前路径
如：/tmp/data_bak =>保存至/tmp/ - format： 压缩包种类，“zip”, “tar”, “bztar”，“gztar”
- root_dir： 要压缩的文件夹路径（默认当前目录）
- owner： 用户，默认当前用户
- group： 组，默认当前组
- logger： 用于记录日志，通常是logging.Logger对象
#``将`` /data ``下的文件打包放置当前程序目录
import shutil`
`ret = shutil.make_archive("data_bak", 'gztar', root_dir='/data')`
`#``将`` /data``下的文件打包放置`` /tmp/``目录
import shutil`
`ret = shutil.make_archive("/tmp/data_bak", 'gztar', root_dir='/data')``
shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的，详细：
import zipfile
# ``压缩``z = zipfile.ZipFile('laxi.zip', 'w')`
`z.write('a.log')`
`z.write('data.data')`
`z.close()
# ``解压``z = zipfile.ZipFile('laxi.zip', 'r')`
`z.extractall(path='.')`
`z.close()
import tarfile
# ``压缩``>>> t=tarfile.open('/tmp/egon.tar','w')`
`>>> t.add('/test1/a.py',arcname='a.bak')`
`>>> t.add('/test1/b.py',arcname='b.bak')`
`>>> t.close()
# ``解压``>>> t=tarfile.open('/tmp/egon.tar','r')`
`>>> t.extractall('/egon')`
`>>> t.close()
Openpyxl模块
2022年6月7日
13:24
01 首先读取已存在的 Excel 表格
使用load_workbook（）函数；我们需要先导入load_workbook;工作表为活动工作表
from openpyxl import load_workbook
# Excel表格与脚本在同一个文件，否则需要把路径写全
wb = load_workbook(r'demo.xlsx')
sheet = wb.active
# 也可以按工作表名读取
# sheet = wb.get_sheet_by_name("sheet")
02 向单个单元格赋值
可以使用['A1']形式；也可以使用标明行列数值的形式.cell(row=2, column=2).value = 5
from openpyxl import load_workbook
wb = load_workbook(r'demo.xlsx')
sheet = wb.active
sheet['A1'] = 'Devansh Sharma'
sheet['A2'] = 'hello world'
sheet.cell(row=2, column=2).value = 5
wb.save(r'demo.xlsx')
print("运行结束！")
向工作表批量赋值
from openpyxl import load_workbook
wb = load_workbook(r'demo.xlsx')
sheet = wb.active
data = (
(11, 48, 50),
(81, 30, 82),
(20, 51, 72),
(21, 14, 60),
(28, 41, 49),
(74, 65, 53),
("Peter", 'Andrew',45.63)
)
for i in data:
sheet.append(i)
wb.save(r'demo.xlsx')
print("运行结束！")
jieba模块
2021年12月10日
21:19
安装
pip install jieba
二、算法介绍
结巴中文分词涉及到的算法包括：
(1) 基于Trie树结构实现高效的词图扫描，生成句子中汉字所有可能成词情况所构成的有向无环图（DAG)；
(2) 采用了动态规划查找最大概率路径, 找出基于词频的最大切分组合；
(3) 对于未登录词，采用了基于汉字成词能力的HMM模型，使用了Viterbi算法。
三、分词模式
结巴中文分词支持的三种分词模式包括：
(1) 精确模式：试图将句子最精确地切开，适合文本分析；
(2) 全模式：把句子中所有的可以成词的词语都扫描出来, 速度非常快，但是不能解决歧义问题；
(3) 搜索引擎模式：在精确模式的基础上，对长词再次切分，提高召回率，适合用于搜索引擎分词。
import jieba
# 全模式
text = "我来到北京清华大学"
seg_list = jieba.cut(text, cut_all=True)
print(u"[全模式]: ", "/ ".join(seg_list))
返回列表
# 精确模式
seg_list = jieba.cut(text, cut_all=False)
print(u"[精确模式]: ", "/ ".join(seg_list))
# 默认是精确模式
seg_list = jieba.cut(text)
print(u"[默认模式]: ", "/ ".join(seg_list))
# 搜索引擎模式
seg_list = jieba.cut_for_search(text)
print(u"[搜索引擎模式]: ", "/ ".join(seg_list))
结果：
[全模式]: 我/ 来到/ 北京/ 清华/ 清华大学/ 华大/ 大学
[精确模式]: 我/ 来到/ 北京/ 清华大学
[默认模式]: 我/ 来到/ 北京/ 清华大学
[搜索引擎模式]: 我/ 来到/ 北京/ 清华/ 华大/ 大学/ 清华大学
jieba库的三种模式：
-精确模式：把文本精确的切分开，不存在冗余单词
#jieba.lcut(s)
jieba.lcut("中国是一个伟大的国家"
#output:['中国', '是', '一个', '伟大', '的', '国家']
-全模式：把文本中所有的可能的词语都扫描出来，有冗余
#jieba.lcut(s,cut_all=True)
jieba.lcut("中国是一个伟大的国家",cut_all=True)
#output:['中国', '国是', '一个', '伟大', '的', '国家']
-全搜索引擎模式：在精确模式的基础上，对长词再次切分
#jieba.lcut_for_search(s)
jieba.lcut_for_search("中华人民共和国是伟大的")
#output:['中华', '华人', '人民', '共和', '共和国', '中华人民共和国', '是', '伟大', '的']
向分词词典中增加新词w：
#jieba.add_word(w)
jieba.add_word("蟒蛇语言")
四、新词识别
import jieba
#新词识别 “杭研”并没有在词典中,但是也被Viterbi算法识别出来了
seg_list = jieba.cut("他来到了网易杭研大厦")
print (u"[新词识别]: ", "/ ".join(seg_list))
[新词识别]: 他/ 来到/ 了/ 网易/ 杭研/ 大厦
五、自定义词典
import jieba
text = "故宫的著名景点包括乾清宫、太和殿和黄琉璃瓦等"
# 全模式
seg_list = jieba.cut(text, cut_all=True)
print(u"[全模式]: ", "/ ".join(seg_list))
# 精确模式
seg_list = jieba.cut(text, cut_all=False)
print(u"[精确模式]: ", "/ ".join(seg_list))
# 搜索引擎模式
seg_list = jieba.cut_for_search(text)
print(u"[搜索引擎模式]: ", "/ ".join(seg_list))
结果
[全模式]: 故宫/ 的/ 著名/ 著名景点/ 景点/ 包括/ 乾/ 清宫/ / / 太和/ 太和殿/ 和/ 黄/ 琉璃/ 琉璃瓦/ 等
[精确模式]: 故宫/ 的/ 著名景点/ 包括/ 乾/ 清宫/ 、/ 太和殿/ 和/ 黄/ 琉璃瓦/ 等
[搜索引擎模式]: 故宫/ 的/ 著名/ 景点/ 著名景点/ 包括/ 乾/ 清宫/ 、/ 太和/ 太和殿/ 和/ 黄/ 琉璃/ 琉璃瓦/ 等
可以看到，结巴分词工具认出了专有名词”太和殿”，但没有认出”乾清宫”和”黄琉璃瓦”。
也就是说，专有名词”乾清宫”和”黄琉璃瓦”可能因分词而分开，这也是很多分词工具的一个缺陷。
为此，Jieba分词支持开发者使用自定定义的词典，以便包含jieba词库里没有的词语。虽然结巴有新词识别能力，但自行添加新词可以保证更高的正确率，尤其是专有名词。
基本用法：
jieba.load_userdict(file_name) #file_name为自定义词典的路径
词典格式和dict.txt一样，一个词占一行；
每一行分三部分，第一部分为词语，中间部分为词频，最后部分为词性（可省略，ns为地点名词），用空格隔开。
咱们在jieba的安装目录下添加mydict.txt，内容为
乾清宫 1 n
黄琉璃瓦 1 n
添加自定义以后的代码；主要是添加加载mydict.txt的代码：
import jieba
jieba.load_userdict("D:\Program Files\Python36\Lib\site-packages\jieba\mydict.txt")
text = "故宫的著名景点包括乾清宫、太和殿和黄琉璃瓦等"
# 全模式
seg_list = jieba.cut(text, cut_all=True)
print(u"[全模式]: ", "/ ".join(seg_list))
# 精确模式
seg_list = jieba.cut(text, cut_all=False)
print(u"[精确模式]: ", "/ ".join(seg_list))
# 搜索引擎模式
seg_list = jieba.cut_for_search(text)
print(u"[搜索引擎模式]: ", "/ ".join(seg_list))
结果
[全模式]: 故宫/ 的/ 著名/ 著名景点/ 景点/ 包括/ 乾清宫/ 清宫/ / / 太和/ 太和殿/ 和/ 黄琉璃瓦/ 琉璃/ 琉璃瓦/ 等
[精确模式]: 故宫/ 的/ 著名景点/ 包括/ 乾清宫/ 、/ 太和殿/ 和/ 黄琉璃瓦/ 等
[搜索引擎模式]: 故宫/ 的/ 著名/ 景点/ 著名景点/ 包括/ 清宫/ 乾清宫/ 、/ 太和/ 太和殿/ 和/ 琉璃/ 琉璃瓦/ 黄琉璃瓦/ 等
关键词提取
在构建VSM向量空间模型过程或者把文本转换成数学形式计算中，你需要运用到关键词提取的技术。
jieba.analyse.extract_tags(sentence, topK)
其中sentence为待提取的文本，topK为返回几个TF/IDF权重最大的关键词，默认值为20。
代码；
import jieba
import jieba.analyse
#导入自定义词典
jieba.load_userdict("D:\Program Files\Python36\Lib\site-packages\jieba\mydict.txt")
#精确模式
text = "故宫的著名景点包括乾清宫、太和殿和午门等。其中乾清宫非常精美，午门是紫禁城的正门，午门居中向阳。"
seg_list = jieba.cut(text, cut_all=False)
print (u"分词结果:")
print ("/".join(seg_list))
#获取关键词
tags = jieba.analyse.extract_tags(text, topK=5)
print (u"关键词:")
print (" ".join(tags))
结果；
故宫/的/著名景点/包括/乾清宫/、/太和殿/和/午门/等/。/其中/乾清宫/非常/精美/，/午门/是/紫禁城/的/正门/，/午门/居中/向阳/。
关键词:
午门 乾清宫 著名景点 太和殿 向阳
这里“午门”出现了3次，所以先输出。“乾清宫”出现了2次，第二个输出。
其他词都出现1次，那么为什么接下来输出的是“著名景点”、“太和殿”和“向阳”呢？
这是因为，在词频一样的前题下，根据TF/IDF的顺序来输出，因为其他词的TF一样（都是1），所以IDF小的会先输出来。
不知道结巴分词是根据什么来判断IDF的，假如是根据dict.txt中的第二列词频来判断，那么确实是“著名景点” < “太阳殿” < “向阳” < 其他词语。这样第三个输出的就是“著名景点”，最后两个依次为“太阳殿”和“向阳”。
去除停用词
在信息检索中，为节省存储空间和提高搜索效率，在处理自然语言数据（或文本）之前或之后会自动过滤掉某些字或词，比如“的”、“是”、“而且”、“但是”、”非常“等。这些字或词即被称为Stop Words（停用词）。
代码：
import jieba
# 去除停用词
stopwords = {}.fromkeys(['的', '包括', '等', '是'])
text = "故宫的著名景点包括乾清宫、太和殿和午门等。其中乾清宫非常精美，午门是紫禁城的正门。"
# 精确模式
segs = jieba.cut(text, cut_all=False)
final = ''
for seg in segs:
if seg not in stopwords:
final += seg
print (final)
seg_list = jieba.cut(final, cut_all=False)
print ("/ ".join(seg_list))
结果：
故宫著名景点乾清宫、太和殿和午门。其中乾清宫非常精美，午门紫禁城正门。
故宫/ 著名景点/ 乾/ 清宫/ 、/ 太和殿/ 和/ 午门/ 。/ 其中/ 乾/ 清宫/ 非常/ 精美/ ，/ 午门/ 紫禁城/ 正门/ 。
WordCloud模块
2021年12月16日
20:00
效果是不是看起来还不错，下面介绍wordcloud.WordCloud()的参数
font_path : string //字体路径，需要展现什么字体就把该字体路径+后缀名写上，如：font_path = '黑体.ttf'
width : int (default=400) //输出的画布宽度，默认为400像素
height : int (default=200) //输出的画布高度，默认为200像素
prefer_horizontal : float (default=0.90) //词语水平方向排版出现的频率，默认 0.9 （所以词语垂直方向排版出现频率为 0.1 ）
mask : nd-array or None (default=None) //如果参数为空，则使用二维遮罩绘制词云。如果 mask 非空，设置的宽高值将被忽略，遮罩形状被 mask 取代。除全白（#FFFFFF）的部分将不会绘制，其余部分会用于绘制词云。如：bg_pic = imread('读取一张图片.png')，背景图片的画布一定要设置为白色（#FFFFFF），然后显示的形状为不是白色的其他颜色。可以用ps工具将自己要显示的形状复制到一个纯白色的画布上再保存，就ok了。
scale : float (default=1) //按照比例进行放大画布，如设置为1.5，则长和宽都是原来画布的1.5倍。
min_font_size : int (default=4) //显示的最小的字体大小
font_step : int (default=1) //字体步长，如果步长大于1，会加快运算但是可能导致结果出现较大的误差。
max_words : number (default=200) //要显示的词的最大个数
stopwords : set of strings or None //设置需要屏蔽的词，如果为空，则使用内置的STOPWORDS
background_color : color value (default=”black”) //背景颜色，如background_color='white',背景颜色为白色。
max_font_size : int or None (default=None) //显示的最大的字体大小
mode : string (default=”RGB”) //当参数为“RGBA”并且background_color不为空时，背景为透明。
relative_scaling : float (default=.5) //词频和字体大小的关联性
color_func : callable, default=None //生成新颜色的函数，如果为空，则使用 self.color_func
regexp : string or None (optional) //使用正则表达式分隔输入的文本
collocations : bool, default=True //是否包括两个词的搭配
colormap : string or matplotlib colormap, default=”viridis” //给每个单词随机分配颜色，若指定color_func，则忽略该方法。
fit_words(frequencies) //根据词频生成词云
generate(text) //根据文本生成词云
generate_from_frequencies(frequencies[, ...]) //根据词频生成词云
generate_from_text(text) //根据文本生成词云
process_text(text) //将长文本分词并去除屏蔽词（此处指英语，中文分词还是需要自己用别的库先行实现，使用上面的 fit_words(frequencies) ）
recolor([random_state, color_func, colormap]) //对现有输出重新着色。重新上色会比重新生成整个词云快很多。
to_array() //转化为 numpy array
to_file(filename) //输出到文件
打包py文件
2022年6月18日
17:19
第一步：安装打包所需要的包（pyinstaller）
在``cmd``窗口中输入
pip install pyinstaller
并从新创建一个环境
第二步修改路径
第三步：输入打包命令
pyinstaller -F -w (-i icofile) 文件名.py
解释一下该命令：
1、-w 表示在打包好程序后，双击.exe文件不会不会不会（重要的事情说三遍）出现黑色的命令窗口。（如果你的程序有print等输出命令，就不要加）
2、小括号中的内容是可以省略的，-i 表示给.exe文件一个图标，icofile表示图标的文件名，图标的图片格式为.ico格式的。不懂.ico图片的可以百度一下。打包时如果需要给.exe加入图标，将图标文件放到和.py文件同一目录下。
3、文件名.py 这里的文件名是你要打包的.py文件的名称。
| -h，--help | 查看该模块的帮助信息 |
|---|---|
| -F，-onefile | 产生单个的可执行文件 |
| -D，--onedir | 产生一个目录（包含多个文件）作为可执行程序 |
| -a，--ascii | 不包含 Unicode 字符集支持 |
| -d，--debug | 产生 debug 版本的可执行文件 |
| -w，--windowed，--noconsolc | 指定程序运行时不显示命令行窗口（仅对 Windows 有效） |
| -c，--nowindowed，--console | 指定使用命令行窗口运行程序（仅对 Windows 有效） |
| -o DIR，--out=DIR | 指定 spec 文件的生成目录。如果没有指定，则默认使用当前目录来生成 spec 文件 |
| -p DIR，--path=DIR | 设置 Python 导入模块的路径（和设置 PYTHONPATH 环境变量的作用相似）。也可使用路径分隔符（Windows 使用分号，Linux 使用冒号）来分隔多个路径 |
| -n NAME，--name=NAME | 指定项目（产生的 spec）名字。如果省略该选项，那么第一个脚本的主文件名将作为 spec 的名字 |
转换jpg为ioc文件
PythonMagick
PythonMagick库无法用pip或者easy_install来安装，因此，需要手动安装，地址如下： https://www.lfd.uci.edu/~gohlke/pythonlibs/#pythonmagick 选择合适版本下载后，进入文件所在位置，直接pip install + 文件名即可完成安装。
"""
Author``：``Robin·QI
Notes``：将图片转换为``ico``格式
"""
# PythonMargick``包可以到``Unofficial Windows Binaries for Python Extension Packages``下载
import PythonMagick
img = PythonMagick.Image('robin.jpg') ``# ``导入图片
# ``这里要设置一下尺寸，不然会报``ico``尺寸异常错误
img.sample('128x128') ``#``设置尺寸
img.write('robin.ico') ``保存图片
python音乐格式转换
2022年6月18日
22:37
01 安装pydub库
通过下面的命令安装``Python``库``-pydub
pip`` ``install`` ``pydub
#转化函数方法
from pydub import AudioSegment
#``转化函数方法
def trans_mp3_to_wav(filepath,hz):
song = AudioSegment.from_mp3(filepath)
song.export("Python``研究者``."+str(hz), format=str(hz))
### ``参数``1``：音频路径， 参数``2``：转换后的格式
trans_mp3_to_wav("``轻音乐``.mp3","wav")
trans_mp3_to_wav("``轻音乐``.mp3","ogg")
trans_mp3_to_wav("``轻音乐``.mp3","flac")
将轻音乐.mp3 转为wav、ogg、flac等格式，并命名为Python研究者。转化后均为无损高音质，没有任何的失真。
2.wav、ogg、flac->mp3
from pydub import AudioSegment
song = AudioSegment.from_wav("Python``研究者``.wav")
song.export("Python``研究者``_wav-mp3.mp3", format="mp3")
song = AudioSegment.from_ogg("Python``研究者``.ogg")
song.export("Python``研究者``_ogg-mp3.mp3", format="mp3")
AudioSegment.from_file("Python``研究者``.flac")
song.export("Python``研究者``_flac-mp3.mp3", format="mp3")
Python 使用 webbrowser 包播放 Mp3 文件
Import webbrowser`
`webbrowser.open("sample.mp3")
代码片段将在浏览器窗口中打开一个标签页并播放当前工作目录中的 sample.mp3 文件。
大部分的模块介绍
2022年5月10日
23:05
库名称简介
Chardet字符编码探测器，可以自动检测文本、网页、xml的编码。
colorama主要用来给文本添加各种颜色，并且非常简单易用。
Prettytable主要用于在终端或浏览器端构建格式化的输出。
difflib，[Python]标准库，计算文本差异
Levenshtein，快速计算字符串相似度。
fuzzywuzzy,字符串模糊匹配。
esmre,正则表达式的加速器。
shortuuid,一组简洁URL/UUID函数库。
ftfy，Unicode文本工具7
unidecode，ascii和Unicode文本转换函数。
xpinyin，将汉字转换为拼音的函数库
pangu.py，调整对中日韩文字当中的字母、数字间距。
pyfiglet，Python写的figlet程序，使用字符组成ASCII艺术图片
uniout，提取字符串中可读写的字符
awesome slugify，一个Python slugify库，用于处理Unicode。
python-slugify，转换Unicode为ASCII内码的slugify函数库。
unicode-slugify，生成unicode内码，Django的依赖包。
ply，Python版的lex和yacc的解析工具
phonenumbers，解析电话号码，格式，存储和验证的国际电话号码。
python-user-agents，浏览器的用户代理（user-agents）的解析器。
sqlparse，SQL解析器。
pygments，一个通用的语法高亮工具。
python-nameparser，解析人名，分解为单独的成分。
pyparsing，通用解析器生成框架。
tablib，表格数据格式，包括，XLS、CSV，JSON，YAML。
python-docx，docx文档读取，查询和修改，微软Word 2007 / 2008的docx文件。
xlwt/xlrd，读写Excel格式的数据文件。
xlsxwriter，创建Excel格式的xlsx文件。
xlwings，利用Python调用Excel
csvkit，CSV文件工具包。
marmir，把Python[数据结构]，转化为电子表格。
pdfminer，从PDF文件中提取信息。
pypdf2， 合并和转换PDF页面的函数库。
Python-Markdown，轻量级标记语言Markdown的Python实现。
Mistune，,快速、全功能的纯Python编写的Markdown解释器。
dateutil，标准的Python官方datetime模块的扩展包，字符串日期工具，其中parser是根据字符串解析成datetime，而rrule是则是根据定义的规则来生成datetime。
arrow,更好的日期和时间处理Python库
chronyk，一个Python 3版函数库，用于解析人写的时间和日期。
delorean，清理期时间的函数库。
when.py，为见的日期和时间，提供人性化的功能。
moment，类似Moment.js的日期/时间Python库
pytz，世界时区，使用tz database时区信息[数据库]
BeautifulSoup，基于Python的HTML/XML解析器，简单易用, 功能很强大,即使是有bug，有问题的html代码，也可以解析
lxml，快速，易用、灵活的HTML和XML处理库，功能超强，在遇到有缺陷、不规范的xml时，Python自带的xml处理器可能无法解析。报错时，程序会尝试再用lxml的修复模式解析。
htmlparser，官方版解析HTML DOM树，偶尔搞搞命令行自动表单提交用得上。
pyyaml，Python版本的YAML解释器。
html5lib，-标准库，解析和序列化HTML文档和片段。
pyquery，类似[jQuery]的的HTML解释器函数库。
cssutils，Python CSS库。
MarkupSafe，XML或HTML / XHTML安全字符串标记工具。
cssutils - ACSS library for Python., MarkupSafe - Implements a XML/HTML/XHTML
bleach，漂白，基于HTML的白名单函数库。
xmltodict，类似JSON的XML工具包。
xhtml2pdf，HTML / CSS格式转换器，看生成pdf文档。
untangle，把XML文档，转换为Python对象，方便访问。
文件处理
库名称简介Mimetypes，Python标准库，映射文件名到MIME类型。
imghdr，Python标准库，确定图像类型。python-magic，libmagic文件类型识别库，Python接口格式。path.py，os.path模块的二次封装。
watchdog，一组API和shell实用程序，用于监视文件系统事件。
Unipath，面向对象的文件/目录的操作工具包。pathlib，-（Python 3.4版已经作为Python标准库），一个跨平台，面向path的函数库。
pickle/cPickle,python的pickle模块实现了基本的数据序列和反序列化。通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储；通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象。
cPickle是[C语言]实现的版本，速度更快。
ConfigParser，Python标准库，INI文件解析器。
configobj，INI文件解析器。config，分层次配置，logging作者编写。
profig，多格式配置转换工具。
logging，Python标准库，日志文件生成管理函数库。
logbook，logging的替换品。
Sentry，实时log服务器。Raven，哨兵Sentry的Python客户端。
Sphinx，斯芬克斯（狮身人面像），Python文档生成器。
reStructuredText，标记语法和解析工具，Docutils组件。mkdocs，Markdown格式文档生成器。
pycco，简单快速、编程风格的文档生成器。
pdoc，自动生成的Python库API文档epydoc，从源码注释中生成各种格式文档的工具
图像处理
库名称简介PIL（Python Image Library），基于Python的图像处理库，功能强大，对图形文件的格式支持广泛，内置许多图像处理函数，如图像增强、滤波[算法]等Pillow，图像处理库，PIL图像库的分支和升级替代产品。Matplotlib，著名的绘图库，提供了整套和matlab相似的命令API，用以绘制一些高质量的数学二维图形，十分适合交互式地进行制图。brewer2mpl，有一个专业的python配色工具包，提供了从美术角度来讲的精美配色。
PyGame基于Python的多媒体开发和游戏软件开发模块，包含大量游戏和图像处理功能Box2d，开源的2d物理引擎，愤怒的小鸟就是使用了这款物理引擎进行开发的，Box2d物理引擎内部模拟了一个世界，你可以设置这个世界里的重力，然后往这个世界里添加各种物体，以及他们的一些物理特性，比如质量，摩擦，阻尼等等。
Pymunk，类似box2d的开源物理图形模拟库OpenCV, 目前最好的开源图像/视觉库，包括图像处理和计算机视觉方面、[机器学习]的很多通用算法。SimpleCV，计算机视觉开源框架，类似opencv。VTK，视觉化工具函式库（VTK， Visualization Toolkit）是一个开放源码，跨平台、支援平行处理（VTK曾用于处理大小近乎1个Petabyte的资料，其平台为美国Los Alamos国家实验室所有的具1024个处理器之大型系统）的图形应用函式库。
2005年时曾被美国陆军研究实验室用于即时模拟俄罗斯制反导弹战车ZSU23-4受到平面波攻击的情形，其计算节点高达2.5兆个之多。cgkit,Python Computer Graphics Kit,其module 主要分两个部分，
\1. 与3d相关的一些python module 例如the vector, matrix and quaternion types, the RenderMan bindings, noise functions 这些模块可以在maya houdini nuke blender 等有Python扩展的程序中直接用;
\2. 提供完整的场景操作的module， 他类似其他三维软件，在内存中保留完整的描述场景的信息。
不能直接用于maya 等CGAL，
Computational Geometry Algorithms Library，计算几何算法库，提供计算几何相关的数据结构和算法，诸如三角剖分（2D约束三角剖分及二维和三维Delaunay三角剖分），
Voronoi图（二维和三维的点，2D加权Voronoi图，分割Voronoi图等），
多边形（布尔操作，偏置），多面体（布尔运算），曲线整理及其应用，
网格生成（二维Delaunay网格生成和三维表面和体积网格生成等），几何处理（表面网格简化，细分和参数化等），
凸壳算法（2D，3D和dD），搜索结构（近邻搜索，kd树等），插值，形状分析，拟合，距离等。
Aggdraw，开源图像库，几乎涵盖了2d image操作的所有功能，使用起来非常灵活Pycairo,开源矢量绘图库Cairo开罗的python接口，
cairo提供在多个背景下做2-D的绘图，高级的更可以使用硬件加速功能。wand，Python绑定魔杖工具（MagickWand），C语言API接口。
thumbor， -智能成像工具，可调整大小和翻转图像。
imgSeek，查询相似的图像。
python-qrcode，纯Python的二维码（QR码）生成器。
pyBarcode，创建条码，无需PIL模块。
pygram，Instagram像图像过滤器。
Quads，基于四叉树的计算机艺术。
nude.py，裸体检测函数。
scikit-image，scikit工具箱的图像处理库。
hmap，图像直方图工具。
bokeh，交互的Web绘图。
plotly，Web协同的Python和Matplotlib绘制。
vincent，文森特，Python Vega的函数库。
d3py，Python绘图库，基于D3.JS, ggplot -API兼容R语言的ggplot2.Kartograph.py，在Python绘制漂亮的SVG地图。pygal， SVG图表的创造者。
pygraphviz，Graphviz的Python接口。
Fonttlools，ttf字体工具函数包，用于fontforge、ttx等字体软件。
游戏和多媒体
库名称简介audiolazy，数字信号处理（DSP）的Python工具包。
audioread，跨平台（GStreamer + Core Audio + MAD + FFmpeg）音频解码库。
beets，音乐库管理。
dejavu，音频指纹识别算法。
Dejavu 听一次音频后就会记录该音频的指纹信息，然后可通过麦克风对输入的音频进行识别是否同一首歌。django-elastic-transcoder,Django +亚马逊elastic转码。eyeD3,音频文件工具，特别是MP3文件包含的ID3元数据。
id3reader，用于读取MP3的元数据。
mutagen，处理音频元数据。
pydub，-操纵音频和简单的高层次的接口。
pyechonest，Echo Nest API客户端。talkbox，语音和信号处理的Python库。
TimeSide，开放的网络音频处理框架。
tinytag，读取音乐文件元数据，包括的MP3，OGG，FLAC和wave文件。
m3u8，用于解析m3u8文件。
moviepy，多格式视频编辑脚本模块，包括GIF动画。
shorten.tv，视频摘要。
scikit视频，SciPy视频处理例程。
GeoDjango,一个世界级的地理Web框架。
geopy,Geo地理编码的工具箱。
pygeoip，纯Python写的GeoIP API。
GeoIP，Python API接口，使用高精度GeoIP Legacy Database数据库。
geojson，GeoJSON函数库django-countries，一个Django程序，提供国家选择，国旗图标的静态文件，和一个国家的地域模型。
Pygame，Python游戏设计模块。
Cocos2d，2D游戏框架，演示，和其他的图形/交互应用，基于pyglet。Cocos2d- cocos2d is a framework for building 2D games, demos, and other graphical/interactive applications. It is based on pyglet.,PySDL2，SDL2的封装库。
Panda3D- 3D游戏引擎，迪士尼开发。
用C++写的，完全兼容Python。PyOgre，OGRE 3D渲染引擎，可用于游戏，模拟，任何3D。
PyOpenGL，绑定OpenGL和它相关的API。
PySFML，Python绑定SFMLRenPy，视觉小说引擎。
大数据与科学计算
库名称简介pycuda/opencl，GPU高性能并发计算Pandas，python实现的类似R语言的数据统计、分析平台。基于NumPy和Matplotlib开发的，主要用于数据分析和数据可视化，它的数据结构DataFrame和R语言里的data.frame很像，特别是对于时间序列数据有自己的一套分析机制，非常不错。
Open Mining，商业智能（BI），Pandas的Web界面。blaze，NumPy和Pandas大数据界面。
SciPy，开源的Python算法库和数学工具包，SciPy包含的模块有最优化、线性代数、积分、插值、特殊函数、快速傅里叶变换、信号处理和图像处理、常微分方程求解和其他科学与工程中常用的计算。
其功能与软件MATLAB、Scilab和GNU Octave类似。
Numpy和Scipy常常结合着使用，Python大多数机器学习库都依赖于这两个模块。
ScientificPython，一组经过挑选的Python程序模块，用于科学计算，包括几何学（矢量、张量、变换、矢量和张量场），四元数，自动求导数，（线性）插值，多项式，基础统计学，非线性最小二乘拟合，单位计算，Fortran兼容的文本格式，通过VRML的3D显示，以及两个Tk小工具，分别用于绘制线图和3D网格模型。
此外还具有到netCDF，MPI和BSPlib库的接口。
NumPy科学计算库，提供了矩阵，线性代数，傅立叶变换等等的解决方案, 最常用的是它的N维数组对象. NumPy提供了两种基本的对象：
ndarray（N-dimensional array object）和 ufunc（universal function object）。
ndarray是存储单一数据类型的多维数组，而ufunc则是能够对数组进行处理的函数。
Cvxopt，最优化计算包，可进行线性规划、二次规划、半正定规划等的计算。
Numba，科学计算速度优化编译器。pymvpa2，是为大数据集提供统计学习分析的Python工具包，它提供了一个灵活可扩展的框架。
它提供的功能有分类、回归、特征选择、数据导入导出、可视化等NetworkX，复杂网络的优化软件包。zipline，交易算法的函数库。
PyDy， Python动态建模函数库。
SymPy,符号数学的Python库。statsmodels,Python的统计建模和计量经济学。
astropy,天文学界的Python库。
orange，橙色，数据挖掘，数据可视化，通过可视化编程或Python脚本学习机分析。
RDKit,化学信息学和机器学习的软件。
Open Babel，巴贝尔，开放的化学工具箱。
cclib，化学软件包的计算函数库。
Biopython，免费的生物计算工具包。
bccb，生物分析相关的代码集。bcbio-nextgen，提供完全自动化、高通量、测序分析的工具包。
visvis, 可视化计算模块库，可进行一维到四维数据的可视化。
MapReduce是Google提出的一个软件[架构]，用于大规模数据集（大于1TB）的并行运算。
概念“Map（映射）”和“Reduce（归纳）”，及他们的主要思想，都是从函数式编程语言借来的MapReduce函数库。Framworks and libraries for MapReduce.,PySpark，[Spark]的Python API。dpark，Spark的Python克隆，Python中的MapReduce框架。luigi，为批量工作，建立复杂的管道。mrjob，运行在[Hadoop]，或亚马逊网络服务的，MapReduce工作。
人工智能与机器学习
库名称简介NLTK（natural language toolkit)，是python的自然语言处理工具包。2001年推出，包括了大量的词料库，以及自然语言处理方面的算法实现：
分词， 词根计算， 分类， 语义分析等。
Pattern，数据挖掘模块，包括自然语言处理，机器学习工具，等等。
textblob，提供API为自然语言处理、分解NLP任务。基于NLTK和Pattern模块。
jieba，结巴，中文分词工具。snownlp，用于处理中文文本库。
loso，中文分词函数库。
genius，中文CRF基础库，条件随机场(conditional random field,简称 CRF),是一种鉴别式机率模型,是随机场的一种,常用于标注或分析序列资料,如自然语言文字或是生物序列Gensim，一个相当专业的主题模型Python工具包，无论是代码还是文档，可用于如何计算两个文档的相似度LIBSVM,是台湾大学林智仁(Lin Chih-Jen)教授等开发设计的一个简单、易于使用和快速有效的SVM模式识别与回归的软件包，他不但提供了编译好的可在Windows系列系统的执行文件，还提供了源代码，方便改进、修改以及在其它[操作系统]上应用；
该软件对SVM所涉及的参数调节相对比较少，提供了很多的默认参数，利用这些默认参数可以解决很多问题；
并提供了交互检验(Cross Validation)的功能。
该软件可以解决C-SVM、ν-SVM、ε-SVR和ν-SVR等问题，包括基于一对一算法的多类模式识别问题。
scikits.learn，构建在SciPy之上用于机器学习的 Python 模块。它包括简单而高效的工具，可用于数据挖掘和数据分析。
涵盖分类，回归和聚类算法，例如SVM， 逻辑回归，朴素贝叶斯，随机森林，k-means等算法，代码和文档都非常不错，在许多Python项目中都有应用。
例如在我们熟悉的NLTK中，分类器方面就有专门针对scikit-learn的接口，可以调用scikit-learn的分类算法以及训练数据来训练分类器模型。PyMC，机器学习采样工具包，scikit-learn似乎是所有人的宠儿，有人认为，PyMC更有魅力。
PyMC主要用来做Bayesian分析。Orange，基于组件的数据挖掘和机器学习软件套装，它的功能即友好，又很强大，快速而又多功能的可视化编程前端，以便浏览数据分析和可视化，包含了完整的一系列的组件以进行数据预处理，并提供了数据帐目，过渡，建模，模式评估和勘探的功能。
侧重数据挖掘，可以用可视化语言或Python进行操作，拥有机器学习组件，还具有生物信息学以及文本挖掘的插件。
Milk，机器学习工具箱，其重点是提供监督分类法与几种有效的分类分析：SVMs(基于libsvm)，K-NN，随机森林经济和决策树。
它还可以进行特征选择。这些分类可以在许多方面相结合，形成不同的分类系统。对于无监督学习，它提供K-means和affinity propagation聚类算法。
PyMVPA(Multivariate Pattern Analysis in Python),是为大数据集提供统计学习分析的Python工具包，它提供了一个灵活可扩展的框架。它提供的功能有分类、回归、特征选择、数据导入导出、可视化等NuPIC，开源人工智能平台。
该项目由Grok（原名 Numenta）公司开发，其中包括了公司的算法和软件架构。
NuPIC 的运作接近于人脑，“当模式变化的时候，它会忘掉旧模式，记忆新模式”。如人脑一样，CLA 算法能够适应新的变化。Pylearn2，-基于Theano的机器学习库。
hebel，GPU加速，[深度学习]Python库。
gensim，机器学习库。pybrain，机器学习模块，它的目标是为机器学习任务提供灵活、易应、强大的机器学习算法。
pybrain包括神经网络、强化学习(及二者结合)、无监督学习、进化算法。以神经网络为核心，所有的训练方法都以神经网络为一个实例Mahout,是 Apache Software Foundation（ASF） 旗下的一个开源项目，提供一些可扩展的机器学习领域经典算法的实现，旨在帮助开发人员更加方便快捷地创建智能应用程序。
Mahout包含许多实现，包括聚类、分类、推荐过滤、频繁子项挖掘。此外，通过使用 Apache Hadoop 库，Mahout 可以有效地扩展到云中。
Crab，灵活的，快速的推荐引擎。python-recsys，娱乐系统分析，推荐系统。vowpal_porpoise，Vowpal Wabbit轻量级Python封装。
Theano,用来定义、优化和模拟数学表达式计算，用于高效的解决多维数组的计算问题的python软件包。它使得写深度学习模型更加容易，同时也给出了一些关于在GPU上训练它们的选项。
系统与命令行
库名称简介threading，Python标准线程库，更高级别的线程接口。
envoy，特使，Python子线程的函数库。
sh，成熟的子线程替换函数库。sarge，封装线程。subprocess,调用shell命令的神器argparse，写命令行脚本必备，强大的命令行差数解析工具timeit，计算代码运行的时间等等unp，命令行工具，解压文件。
eventlet开销很少的多线程模块，使用的是 green threads 概念，例如，pool = eventlet.GreenPool(10000) 这样一条语句便创建了一个可以处理 10000 个客户端连接的线程池。
类似Gevent线程库Gevent，多线程模块pytools,著名的python通用函数、工具包SendKeys, 键盘鼠标操作模块, 模拟键盘鼠标模拟操作。
pyHook,基于Python的“钩子”库，主要用于监听当前电脑上鼠标和键盘的事件。
这个库依赖于另一个Python库PyWin32，如同名字所显示的，PyWin32只能运行在Windows平台，所以PyHook也只能运行在Windows平台。
pstuil,跨平台地很方便获取和控制系统的进程，以及读取系统的CPU占用内存占用等信息.cement，一个轻量级的、功能齐全的命令行工具click，简单优雅的的命令行接口。
clint，Python命令行工具。cliff，创造多层次指令的命令行程序框架。
Clime， 可以转换任何模块为多的CLI命令程序，无任何配置。
docopt，Python命令行参数分析器。
pycli，命令行应用程序，支持的标准命令行解析，测井，单元[测试]和功能测试。
Gooey，打开命令行程序，作为为一个完整的GUI应用程序,cookiecutter，命令行工具，从cookiecutters（项目模板）创建项目。
例如，Python包项目，jQuery插件项目。
percol，为UNIX传统管道pipe命令，添加交互式选择风格。
rainbowstream，聪明和漂亮的推特客户终端。Django Models，Django的一部分SQLAlchemy，Python SQL工具包和对象关系映射。
peewee，小型的ORM解析器。
PonyORM，为ORM提供了一种面向SQL的接口。MongoEngine，Python对象文件映射，使用[MongoDB]。
, Django MongoDB引擎MongoDB , Django后台。
django-mongodb-engine，Django后台.redisco,一个简单的模型和容器库，使用[Redis]flywheel，Amazon DynamoDB对象映射。
butterdb，谷歌电子表格的ORM，Python版。celery，芹菜，异步任务队列/工作，基于分布式消息队列。
huey，休伊，轻量级，多线程任务队列。
mrq，队列先生，分布式任务队列，使用redis & Gevent。rq，简单的工作队列。
Queue,Queue模块可以用来实现多线程间通讯，让各个线程共享数据，生产者把货物放到Queue中，供消费者（线程）去使用。
simpleq，简单的，可扩展的队列，Amazon SQS基础队列。
Psyco，超强的python性能优化工具，psyco 的神奇在于它只需要在代码的入口处调用短短两行代码，性能就能提升 40% 或更多，真可谓是立竿见影！如果你的客户觉得你的程序有点慢，敬请不要急着去优化代码，psyco 或许能让他立即改变看法。
psyco 堪称 Python 的 jit。fn.py，Python函数编程：缺失的功能享受FP的实现。funcy，函数编程工具。
Toolz，函数编程工具：迭代器、函数，字典。CyToolz，Toolz的Cython实现，高性能的函数编程工具。Ansible，安塞波，极为简单的自动化平台。
SaltStack，基础设施的自动化管理系统。
Fabric，织物，一个简单，远程执行和部署的语言工具。
Fabtools，Fabric的工具函数。
cuisine，热门的Fabric的工具函数。
psutil，跨平台的过程和系统工具模块。
pexpect，控制互动节目。
provy，易于使用的配置系统的Python。honcho，Foreman的Python接口，用于管理procfile应用工具。
gunnery，多任务执行工具，与网络接口的分布式系统。
fig，快速。独立的开发环境中使用泊坞窗。
APScheduler，轻量级、但功能强大的在线任务调度程序。
django-schedule,Django日程应用程序。doit,任务流道/生成工具。
Joblib,Python提供的轻量级的流水线工具函数。
Plan，简易生成crontab文件。
Spiff，纯Python实现的，功能强大的工作流引擎。
schedule，Python作业调度。TaskFlow，有助于使任务执行简单。
ctypes，Python标准库，速度更快，Python调用C代码的外部函数接口。cffi，Python调用C代码外部函数接口，类似于ctypes直接在python程序中调用c程序,但是比ctypes更方便不要求编译成so再调用。
Cytoolz，python 加速库SWIG，简化封装和接口生成器。
,Cython，Python优化静态编译器。
PyPy，Python解释器的 Python实现。
Stackless Python，一个增强版本的Python。它使程序员从基于线程的编程方式中获得好处，并避免传统线程所带来的性能与复杂度问题。
Stackless为 Python带来的微线程扩展，是一种低开销、轻量级的便利工具Pyston,使用LLVM和现代JIT技术,对python进行性能优化。
pythonlibs，非官方的Windows（32 / 64位）的Python扩展包scapy，优秀的数据包处理库。
ino，Arduino命令行工具。Pyro，Python的机器人工具包。
pluginbase，一个简单而灵活的Python的插件系统。
itsdangerous，数据安全传输工具。blinker，快速Python中的信号/事件调度系统。
pychievements，用于创建和跟踪成果框架。
python-patterns，Python中的设计模式。
pefileWindows PE文件解析器SIP，自动为C和C++库生成Python扩展模块的工具
数据库
库名称简介MySQLdb，成熟的[MySQL]数据库模块,Baresql,SQL数据库包ZODB，Python本地对象数据库。一个K-V对象图数据库。
pickledb,简单和轻量级的K-V键值存储。
TinyDB, 轻量级，面向文档的数据库。
mysql-python，MySQL的Python工具库。
mysqlclient，mysql-python分支，支持Python 3.,PyMySQL,纯Python写的 MySQL驱动程序，兼容mysql-python。mysql-connector-python,MySQL连接器,来自[Oracle]，纯Python编写。
oursql，MySQL连接器，提供本地话指令语句和BLOBs支持。
psycopg2，最流行的Python PostgreSQL适配器。txpostgres，于Twisted的异步驱动，用于PostgreSQL。
queries,psycopg2函数库，用于PostgreSQL。
dataset,存储Python字典数据,用于SQLite，MySQL和PostgreSQL。
cassandra-python-driver，开源分布式NoSQL数据库系统Apache Cassandra系统的Python驱动.pycassa,简化的cassandra数据库Python驱动。
HappyBase，友好的Apache [Hbase]的函数库。
PyMongo，MongoDB官方客户端。
Plyvel，LevelDB快速和功能丰富的Python接口。redis-py,redis客户端。
py2neo,Python客户端(基于Neo4j的RESTful接口).telephus,基于Twisted的cassandra客户端。
txRedis，基于Twisted的Redis客户端。
【网络】Curl，Pycurl包是一个libcurl的Python接口，它是由C语言编写的。
与urllib相比，它的速度要快很多。
Libcurl是一个支持FTP, FTPS, HTTP, HTTPS, GOPHER, TELNET, DICT, FILE 和 LDAP的客户端URL传输库.libcurl也支持HTTPS认证,HTTP POST,HTTP PUT,FTP上传,代理,Cookies,基本身份验证,FTP文件断点继传,HTTP代理通道等等。
Requests，用Python语言编写，基于 urllib的开源 HTTP 库。
它比 urllib 更加方便，更加 Pythoner。
支持 Python3。httpie，命令行HTTP客户端，用户友好的cURL的替换工具。
s3cmd，命令行工具，用于管理Amazon S3和CloudFront。
youtube-dl，命令行程序，从YouTube下载视频。
you-get，Python3写的视频下载工具，可用于YouTube/Youku优酷/Niconico视频下载Coursera，从coursera.org下载视频，可重新命名文件wikiteam，wiki下载工具。
subliminal，命令行工具，搜索和下载字幕的函数库requests，HTTP函数库，更加人性化。grequests，异步HTTP请求+ Gevent（高性能高并发函数库）。
urllib3，一个线程安全的HTTP连接池，支持文件post。
httplib2，综合HTTP的客户端函数库。treq， Python API接口，Twisted的HTTP客户。
Mininet，流行的网络仿真器,API采用python编写。
POX，基于Python的开源软件定义网络（SDN）控制开发平台的应用，如OpenFlow的SDN控制器。
Pyretic，SDN的编程语言，提供了强大的抽象在网络交换机或仿真器。SDX Platform，基于SDN的IXP实现，利用最小网络，痘和热。inbox.py，Python的SMTP服务器。imbox， Python版本IMAP库。inbox，收件箱，开源邮件工具包。
lamson,SMTP服务器。flanker,侧卫,电子邮件地址和MIME解析库。
marrow.mailer,高性能可扩展邮件交付框架。
django-celery-ses， Django电子邮件后台，使用AWS SES和Celery。
modoboa，邮件托管和管理平台，包括现代和简化Web UI。
envelopes，邮件工具。
mailjet，批量邮寄mailjet API接口，带统计。Talon，利爪，Mailgun库，提取消息和签名。
mailjet- Mailjet API implementation for batch mailing, statistics and more., Talon - Mailgun library to extract message quotations and signatures.,pyzmail，编写，发送和解析电子邮件。
furl，燃料，小型的的URL解析库库。purl，简单的，干净的API，操纵URL。
pyshorteners，纯Python库，URL短网址编辑。
short_url，短网址生成。
Scrapy，快速屏幕截取和网页抓取的框架。
portia，波西亚，Scrapy的可视化扩展。
feedparser，信息源解释器RoboBrowser，简单的网页浏览Python函数库，没有使用Web浏览器。
MechanicalSoup，网站自动化互动测试工具包。
mechanize，网页浏览编程工具。
Demiurge，造物主，-PyQuery的轻量级工具。
newspaper,提取报纸新闻。html2text,转换HTML为 Markdown格式的文本。
python-goose,HTML内容提取器。
lassie,莱西,人性化的网站内容检索。
micawber,通过UR抓提网页的函数库。
sumy，概要，文本和HTML网页的自动文摘模块。
Haul，距离，可扩展的图像爬虫。
python-readability,可读性工具Arc90,快速的Python接口。
opengraph,OpenGraphProtocol协议解析模块,textract，从任何文件，Word，PowerPoint，PDF文件中提取文本，等。
sanitize，消毒，使混乱的数据变的理智。
AutobahnPython， WebSocket和WAMP的函数库，使用 Twisted和PythonWebSocket-for-Python，websocket客户端和服务器端函数库。SimpleXMLRPCServer，python标准库，简单的XML-RPC服务器，单线程。
SimpleJSONRPCServer，JSON-RPC规范实施函数库。
zeroRPC，基于ZeroMQ和MessagePack的RPC实现。
apache-libcloud，所有云服务的Python接口库。
wifi，WiFi -一套个Python库和命令行工具与WiFi，用于[Linux]。
streamparse，运行Python代码和数据的实时流。
集成了Apache Storm。
boto，亚马逊网络服务接口。
twython，Twitter推特API。google-api-python-client，谷歌客户端API。
gspread，谷歌电子表格的Python API。
facebook-sdk，facebook平台Python SDK。
facepy，简易的facebook图形APIgmail，Gmail的Python接口。
django-wordpress，Django的WordPress的模型和视图。
【Web框架】Django，最流行的Python-Web框架，鼓励快速开发,并遵循MVC设计，开发周期短ActiveGrid企业级的Web2.0解决方案Karrigell简单的Web框架，自身包含了Web服务，py脚本引擎和纯python的数据库PyDBLitewebpy一个小巧灵活的Web框架，虽然简单但是功能强大CherryPy基于Python的Web应用程序开发框架Pylons基于Python的一个极其高效和可靠的Web开发框架Zope开源的Web应用服务器TurboGears基于Python的MVC风格的Web应用程序框架Twisted流行的网络编程库，大型Web框架QuixoteWeb开发框架Flask,轻量级web框架Bottle，快速，简单和轻量级的WSGI模式Web框架。
Pyramid，轻量级，快速，稳定的开源Web框架。
web2py，简单易用的全堆栈Web框架和平台。
web.py，强大、简单的Web框架。TurboGears，便于扩展的Web框架。
CherryPy，极简Python Web框架，支持，HTTP 1.1和WSGI线程池。
Grok，基于Zope3的Web框架。
Bluebream，开源的Web应用服务器，原名Zope 3。
guava，轻量级，高性能的Python-Web框架，采用c语言编写。
django-cms，基于Django企业级开源CMS。
djedi-cms轻量级但功能强大的Django CMS的插件，内联编辑和性能优化。
FeinCMS，基于Django的先进内容管理系统。
Kotte，高层次的Python的Web应用框架，基于Pyramid。Mezzanine，强大，一致，灵活的内容管理平台。
Opps，基于Django的CMS，用于高流量的报纸、杂志和门户网站。
Plone，基于Zope的开源应用服务器Zope。
Quokka，灵活，可扩展的，轻量级的CMS系统，使用Flask和MongoDB。
Wagtail，Django内容管理系统。
Widgy，CMS框架，基于Django。
django-oscar，Django奥斯卡，开源的电子商务框架。
django-shop，基于Django的网店系统。
merchant，支持多种付款处理工具。
money，可扩展的货币兑换解决方案。
python-currencies，货币显示格式。
cornice，Pyramid的REST框架。
django-rest-framework，Django框架，强大灵活的工具，可以很容易地构建Web API。
django-tastypie，创造精美的Django应用程序API接口。
django-formapi，创建JSON API、HMAC认证和Django表单验证。flask-api，提供统一的浏览器体验，基于Django框架。
flask-restful，快速构建REST API支持扩展。
flask-api-utils，flask的扩展。falcon，猎鹰，高性能的Python框架，构建云API和Web应用程序后端。
eve，夏娃，REST API框架，使用Flask，MongoDB和良好意愿。
sandman，睡魔，为现有的数据库驱动的系统，自动生成REST API。restless，类似TastyPie的框架。
savory-pie，REST API构建函数库（Django，及其他）Jinja2，现代设计师友好的语言模板。
Genshi，网络感知输出模板工具包。
Mako，马可，Python平台的超高速、轻型模板。
Chameleon，变色龙，一个HTML / XML模板引擎。
仿照ZPT，优化速度。
Spitfire，快速的Python编译模板。
django-haystack,大海捞针,Django模块搜索。
elasticsearch-py,Elasticsearch官方低级的Python客户端。
solrpy,solr客户端。
Whoosh,呼,快速，纯Python搜索引擎库。
Feedly，建立新闻和通知系统的函数库，使用Cassandra和Redis。
django-activity-stream,Django活动流,从你网站上的行动,产生通用的活动流。
Beaker，烧杯，一个缓存和会话使用的Web应用程序，独立的Python脚本和应用程序库。
dogpile.cache，是Beaker作者的下一代替代作品。HermesCache，Python的缓存库，基于标签的失效及预防Dogpile效果。
django-cache-machine，Django缓存机，自动缓存失效，使用ORM。django-cacheops，自动颗粒事件驱动，ORM缓存失效。johnny-cache,约翰尼高速缓存框架,Django应用程序。
django-viewlet,渲染模板部件扩展缓存控制。pylibmc,在libmemcached接口。
WTForms-JSON,JSON表单数据处理扩展。Deform， HTML表单生成的函数库。
django-bootstrap3，bootstrap3，集成了Django。django-crispy-forms，Django程序，可以创建优雅的表单。django-remote-forms，Django的远程表单，Django表格的序列化程序。
django-simple-spam-blocker，Django简单的垃圾邮件拦截器。
django-simple-captcha，Django简单验证码，简单的和高度可定制的Django应用程序，用于添加验证码图像Ajenti，服务器管理面板。
Grappelli，界面花哨的django皮肤。django-suit，Django替代o界面（仅用于非商业用途）。
django-xadmin，Django管理面板替代工具。
flask-admin，简单的flask管理界面框架flower，实时监控和Web管理面板。
Pelican，鹈鹕，Markdown或ReST，字王内容主题。支持 DVCS, Disqus. AGPL。
Cactus,仙人掌,设计师的网站静态生成器。
Hyde，海德， 基于Jinja2的静态网站生成器。
Nikola，尼古拉-一个静态网站和博客生成器。
Tags，标签，最简单的静态网站生成器。
Tinkerer，工匠，基于Sphinx的静态网站生成器。
asyncio，（在Python 3.4 +是Python标准库），异步I/O，事件循环，协同任务。
gevent，基于Python的网络库。
Twisted，扭曲，事件驱动的网络引擎。
Tornado，龙卷风，Web框架和异步网络的函数库。
pulsar，脉冲星，事件驱动的并行框架的Python。
diesel，柴油，绿色的，基于事件的I/O框架。
eventlet，WSGI支持异步框架。
pyzmq， 0MQ消息库的Python封装。
txZMQ,基于Twisted的0MQ消息库封Crossbar,开源统一应用路由器（WebSocket和WAMP）。
wsgiref，Python标准库，WSGI封装实现，单线程。
Werkzeug，机床，WSGI工具函数库，很容易地嵌入到你自己的项目框架。
paste，粘贴，多线程，稳定的，久经考验的WSGI工具。
rocket，火箭，多线程服务，基于Pyramid。
netius，快速的、异步WSGI服务器，gunicorn，forked前身，部分用C写的。
fapws3，异步网络，用C写的。meinheld，异步WSGI服务器，是用C写的。
bjoern，-快速的、异步WSGI服务器，用C写的。
【安全】Permissions函数库，允许或拒绝用户访问数据或函数。
django-guardian,Django守护者，管理每个对象的权限，用于Django 1.2 +Carteblanche，管理导航和权限。
Authomatic，简单强大的认证/授权客户端。
OAuthLib， 通用，规范，OAuth请求签约工具。
rauth，用于OAuth 1.0，2.0，的Python库。
python-oauth2，利用全面测试，抽象接口来创建OAuth的客户端和服务器。
python-social-auth，易于安装的社会认证机制。
,django-oauth-toolkit,Django OAuth工具包django-oauth2-provider,Django OAuth2工具包。
django-allauth，Django认证的应用程序。
Flask-OAuthlib，Flask的OAuth工具包sanction，制裁，简单的oauth2客户端。
jose，[JavaScript]对象签名和加密(JOSE)草案实施，标记状态。
python-jwt，JSON的Web令牌生成和验证模块。
pyjwt，JSON的Web令牌草案01。
python-jws，JSON的Web令牌草案02。
PyCrypto，Python的加密工具包。
Paramiko，sshv2协议的实现，提供了客户端和服务器端的功能。
cryptography，密码开发工具包。
PyNac，网络和密码（NaCl）函数库。hashids，hashids的 Python函数库。
Passlib，安全的密码存储/哈希库，非常高的水平。
hashlib,md5, sha等hash算法，用来替换md5和sha模块，并使他们的API一致。
它由OpenSSL支持，支持如下算法：md5,sha1, sha224, sha256, sha384, sha512.
GUI
PyGtk，基于Python的GUI程序开发GTK+库
PyQt用于Python的QT开发库
WxPythonPython下的GUI编程框架，其消息机制与MFC的架构相似,入门非常简单，需要快速开发相关的应用可以使用这个
TkinterPython下标准的界面编程包，因此不算是第三方库了
PySide，跨平台Qt的应用程序和用户界面框架，支撑Qt v4框架。
wxPython，混合wxWidgets的C++类库。
kivy，创建应用程序GUI函数库，看运行于Windows，Linux，MAC OS X，[Android]和[iOS]。
curse，用于创建终端GUI应用程序。
urwid，创建终端GUI应用程序窗体的函数库，支持事件，色彩丰富。
pyglet，跨平台的窗口和多媒体库的Python。
Tkinter，是Python事实上的标准GUI软件包。
enaml，创建漂亮的用户界面，语法类似QML。
Toga，托加，OS原生GUI工具包。【构建封装】
pyenv,简单的Python版本管理。
virtualenv,创建独立的Python环境，用于同时安装不同版本的python环境。
virtualenvwrapper，是virtualenv的一组扩展。
pew,一套管理多个虚拟环境的工具。
vex，使运行指定的virtualenv命令。
PyRun，一个单文件，无需安装的Python版本管理工具。
PIP，Python包和依赖的管理工具。
easy_install，软件包管理系统,提供一个标准的分配Python软件和 函式库的格式。是一个附带设置工具的模块，和一个第三方函式库。旨在加快Python函式库的分配程式的速度。类似Ruby语言的RubyGems 。
conda，跨平台，二进制软件包管理器。,
Curdling，一个管理Python包的命令行工具。
wheel，Python发行的新标准，旨在替代eggs.
cx-Freeze，跨平台的，用于打包成可执行文件的库
py2exe, Windows平台的Freeze脚本工具，Py2exe ，将python脚本转换为windows上可以独立运行的可执行程序
py2app，MAC OS X平台的Freeze脚本工具
pyinstaller，-转换成独立的可执行文件的Python程序（跨平台）。
pynsist,构建Windows安装程序的工具，用Python编写。
dh-virtualenv,建立和分发virtualenv(Debian软件包格式)
PyPI，新一代的Python包库管理工具。
warehouse,新一代的Python包库（PyPI）管理工具。
devpi，PyPI服务器和包装/测试/发布工具。
localshop，PyPI官方包镜像服务器，支持本地（私人）包上传。
buildout，创建，组装和部署应用程序的多个部分，其中一些可能是非基于Python的。
SCons，软件构造工具。
platformio，一个控制台的工具，构建的代码可用于不同的开发平台。
bitbake，特殊设计的工具，用于创建和部署[嵌入式]Linux软件包
fabricate，自动为任何编程语言，生成依赖包。
django-compressor，Django压缩机，压缩和内联JavaScript或CSS，链接到一个单一的缓存文件。
jinja-assets-compressor，金贾压缩机，一个Jinja扩展，通过编译，压缩你的资源。
webassets，优化管理，静态资源，独特的缓存清除。
fanstatic，球迷，包优化，提供静态文件。
fileconveyor，监控资源变化，，可保存到CDN（内容分发网络）和文件系统。
django-storages，一组自定义存储Django后台。
glue，胶胶，一个简单的命令行工具，生成CSS Sprites。
libsass-python，Sass (层叠样式表)的Python接口。
Flask-Assets，整合应用程序资源。【代码调试】
unittest，Python标准库，单元测试框架。
nose，鼻子，unittest延伸产品。
pytest，成熟的全功能的Python测试工具。
mamba，曼巴，Python的权威测试工具。出自BDD的旗下。
contexts，背景，BDD测试框架，基于C#。
pyshould，should风格的测试框架，基于PyHamcrest.
pyvows，BDD风格测试框架
Selenium，web测试框架，Python绑定Selenium。
splinter，分裂，测试Web应用程序的开源工具。
locust，刺槐，可扩展的用户负载测试工具，用Python写的。
sixpack，语言无关的A/B测试框架。
mock，模拟对象（英语：mock object，也译作模仿对象），模拟测试库。
responses，工具函数，用于mock模拟测试。
doublex-强大的测试框架。
freezegun，通过时间调整，测试模块。
httpretty， HTTP请求的模拟工具。
httmock，mock模拟测试。
coverage，代码覆盖度量测试。
faker，生成模拟测试数据的Python包。
mixer，混频器，产生模拟数据，用于Django ORM，SQLAlchemy，
Peewee, MongoEngine, Pony ORM等
model_mommy，在Django创建测试随机工具。
ForgeryPy，易用的模拟数据发生器。
radar，雷达，生成随机日期/时间。
FuckIt.py，测试Python代码运行。
Code Analysispysonar2，Python类型索引。
pycallgraph,可视化的流量（调用图）应用程序。
code2flow,转换Python和JavaScript代码到流程图。
LinterFlake8，源代码模块检查器
pylama，Python和JavaScript代码审计工具。
Pylint，源代码分析器，它查找编程错误，帮助执行一个代码标准和嗅探一些代码味道。注意：相比于PyChecker，Pylint是一个高阶的Python代码分析工具，它分析Python代码中的错误。
Pyflakes，一个用于检查Python源文件错误的简单程序。Pyflakes分析程序并且检查各种错误。它通过解析源文件实现，无需导入。
pdb,Python标准库,Python调试器。
ipdb,IPython使用的PDB。
winpdb独立于平台的GUI调试器。
pudb，全屏，基于python调试控制台。
pyringe，-可附着于及注入代码到Python程序的调试器。
python-statsd，statsd服务器客户端。
memory_profiler， 内存监视。
profiling，交互式Python分析器。
django-debug-toolbar, Django调试工具栏,显示各种调试信息:当前请求/响应。
django-devserver,Django调试工具。
flask-debugtoolbar,flask调试工具。
struct模块
2022年7月25日
15:15
该模块可以把一个类型，如数字，转成固定长度的bytes
data = ``struct.pack('i',1111111111111) ``封包
head_json_len=struct.unpack('i',``data ``)[0]#``解包，元组
Pil模块
2022年6月2日
23:47
PIL``功能介绍与安装
PIL``，全称``Python Image Library``，主要作用是图像处理，可用于图片剪切、粘贴、缩放、镜像、水印、颜色块、滤镜、图像格式转换、色场空间转换、验证码、旋转图像、图像增强、直方图处理、插值和滤波等功能。不过只支持到``Python 2.7``。``Pillow``是``PIL``的一个派生分支，但如今已经发展成为比``PIL``本身更具活力的图像处理库。我们需要安装的就是``Pillow``。
PIL``具体用途：图像归档``(Image Archives)``。``PIL``非常适合于图像归档以及图像的批处理任务。你可以使用``PIL``创建缩略图，转换图像格式，打印图像等等。
``图像展示``(Image Display)``。``PIL``较新的版本支持包括``Tk PhotoImage``，``BitmapImage``还有``Windows DIB``等接口。``PIL``支持众多的``GUI``框架接口，可以用于图像展示。
``图像处理``(Image Processing)``。``PIL``包括了基础的图像处理函数，包括对点的处理，使用众多的卷积核``(convolution kernels)``做过滤``(filter),``还有颜色空间的转换。``PIL``库同样支持图像的大小转换，图像旋转，以及任意的仿射变换。``PIL``还有一些直方图的方法，允许你展示图像的一些统计特性。这个可以用来实现图像的自动对比度增强，还有全局的统计分析等。
pip install Pillow
PIL的基本操作
from PIL import Image
# 1.``打开图片
img = Image.open("image/10.png")
# 2.``显示图片``(``执行显示图片后线程会中断，关闭图像后恢复``)
img.show()
# 3.``保存图片
img.save("image/xiaomai.png")
我在尝试的过程中发现，``png``格式的图片保存为``jpg``格式时会报错：``OSError: cannot write mode RGBA as JPEG``，经过查阅资料发现错误原因主要是因为``PNG``格式和``JPG``格式图片的通道数不同。
PNG``是四通道：``RGBA``意思是红色，绿色，蓝色，``Alpha``的色彩空间，``Alpha``指透明度
JPG``是三通道：``RGB``意思是红色，绿色，蓝色
所以，``PNG``格式图片要保存成``JPG``格式就要丢弃``A``通道：
from PIL import Image
# 1.``打开图片
img = Image.open("image/10.png")
# 2.``显示图片``(``执行显示图片后线程会中断，关闭图像后恢复``)
img.show()
# 3.``保存图片
img = img.convert("RGB")
img.save("image/xiaomai.jpg")
下面是图片旋转的代码：
from PIL import Image
# 1.``打开图片
img = Image.open("pli/7.png")
# 2.``水平翻转
img1 = img.transpose(Image.FLIP_LEFT_RIGHT)
# 3.``保存图片
img1.save("pli/1.png")
# 4.``垂直翻转
img2 = img.rotate(180)
# 5.``保存照片
img2.save("pli/2.png")
# 6.``水平``+``垂直翻转
img3 = img.transpose(Image.FLIP_LEFT_RIGHT).rotate(180)
# 7.``保存图片
img3.save("pli/3.png")
给图片增加文字
要在图像上绘制文本要用到 PIL 的两个模块：ImageDraw和ImageFont。 ImageDraw 用于创建绘图对象，ImageFont用于加载字体。
from PIL import Image, ImageDraw, ImageFont
# 1.``打开图片
img = Image.open("image/10.png")
# 2.``调用画图模块
draw = ImageDraw.Draw(img)
# 3.``设置字体
tfont = ImageFont.truetype("``萌神手写体``.ttf", 24)
# 4.``添加文字
"""
``参数一：文字在图片的位置：``(x, y)
``参数二：文字内容
``参数三：字体颜色，当然颜色也可以用``RGB``值指定
``参数四：字体类型
"""
draw.text((50, 30), "eyes++", fill="green", font=tfont)
# 5.``保存图片
img.save("image/addWord.png")
# 6.``显示图片
img.show()
PIL滤镜功能
from PIL import Image, ImageFilter
img = Image.open("image/10.png")
img = img.filter(ImageFilter.CONTOUR)
img.save("image/Filter.png")
img.show()
PIL镜像功能
from PIL import Image
img = Image.open("image/10.png")
img = img.transpose(Image.FLIP_LEFT_RIGHT)
img.save("image/mirror.png")
transpose有这么几种模式
FLIP_LEFT_RIGHT：左右镜像
FLIP_TOP_BOTTOM：上下镜像
ROTATE_90：逆时针转90度
ROTATE_180：逆时针转180度
ROTATE_270：逆时针转270度
TRANSPOSE：像素矩阵转置
TRANSVERSE
最后一种模式我也不知道什么意思，也没查到，但效果是下面这样的，盲猜是对角线对转。。。。。
图片拼接功能
from PIL import Image, ImageDraw
# ``打开图片
img1 = Image.open("image/10.png")
img2 = Image.open("image/addWord.png")
# ``查看图片尺寸，便于拼接图片
print(img1.size)
print(img1.size)
# ``新建空白图片``,``三个参数分别是模式``(RGB/RGBA)``、大小、颜色
newimg = Image.new(mode="RGB", size=(1174, 614), color=(255, 100, 50))
# ``拼接图片``,``第一个参数是图片，第二个是起始位置
newimg.paste(img1, (0, 0))
newimg.paste(img2, (587, 0))
newimg.show()
PIL裁剪功能
from PIL import Image
img = Image.open("image/10.png")
print(img.size)
imgCut = img.crop((100, 200, 500, 600))
imgCut.show()
图片缩放
from PIL import Image
# :
img = Image.open('image/10.png')
# ``获得图像尺寸``:
w, h = img.size
# ``缩放到``50%:
img.thumbnail((w//2, h//2))
# ``把缩放后的图像用``jpeg``格式保存``:
img.save('image/zoom.png')
warnings — 非致命提醒
2022年10月13日
16:45
warnings — 非致命提醒
目的：向用户提供有关运行程序时遇到的问题的非致命警报
warnings ``模块由`` PEP 230 ``引入，作为一种警告程序员关于语言或库功能的变化的方法，以预测`` Python 3.0 ``带来的向后不兼容的变化。它还可用于报告从丢失的库中恢复的配置错误或功能退化。不过，最好是通过`` logging ``模块提供面向用户的消息，因为发送到控制台的警告可能丢失。
由于警告不是致命的，因此程序在运行过程中可能会多次遇到相同的警告情况。``warnings ``模块抑制来自同一来源的重复消息，以减少一遍又一遍地看到相同警告的烦恼。输出可以根据具体情况进行控制，使用解释器的命令行选项或调用`` warnings ``中的函数。
Python ``通过调用`` warnings ``模块中定义的`` warn() ``函数来发出警告``。警告消息通常用于提示用户一些错误或者过时的用法，当这些情况发生时我们不希望抛出异常或者直接退出程序。警告消息通常写入`` sys.stderr``，对警告的处理方式可以灵活的更改，例如忽略或者转变为为异常。警告的处理可以根据警告类别，警告消息的文本和发出警告消息的源位置而变化。对相同源位置的特定警告的重复通常被抑制。
警告控制分为两个阶段：
- 首先，警告被触发时，确定是否应该发出消息；
- 接下来，如果要发出消息，则使用用户可设置的钩子来格式化和打印消息。
filterwarnings()--警告过滤器
警告过滤器可以用来控制是否发出警告消息，警告过滤器是一些匹配规则和动作的序列。可以通过调用`` filterwarnings() ``将规则添加到过滤器，并通过调用`` resetwarnings() ``将其重置为默认状态。
showwarning()--警告消息
警告消息的输出是通过调用`` showwarning() ``函数来完成的，其可以被覆盖；该函数的默认实现通过调用`` formatwarning() ``格式化消息，这也可以由自定义实现使用。
警告类别
內建警告类型：
Warning 所有警告类别类的基类，它是 Exception 的子类
UserWarning 函数 warn() 的默认类别
DeprecationWarning 用于已弃用功能的警告（默认被忽略）
SyntaxWarning 用于可疑语法的警告
RuntimeWarning 用于有关可疑运行时功能的警告
FutureWarning 对于未来特性更改的警告
PendingDeprecationWarning 对于未来会被弃用的功能的警告（默认将被忽略）
ImportWarning 导入模块过程中触发的警告（默认被忽略）
UnicodeWarning 与 Unicode 相关的警告
BytesWarning 与 bytes 和 bytearray 相关的警告 (Python3)
ResourceWarning 与资源使用相关的警告(Python3)
可以通过继承內建警告类型来实现自定义的警告类型，警告类型必须始终是 Warning 类的子类。
警告过滤器
警告过滤器用于控制警告的行为，如忽略，显示或转换为错误（引发异常）。警告过滤器维护着一个有序的过滤规则列表，匹配规则用于确定如何处理警告，任何特定警告都将依次与列表中的每个过滤规则匹配，直到找到匹配为止。过滤规则类型为一个元组 (action，message，category，module，lineno)，其中：
- action 为以下值：
值 处理方式
"error" 将匹配警告转换为异常
"ignore" 忽略匹配的警告
"always" 始终输出匹配的警告
"default" 对于同样的警告只输出第一次出现的警告
"module" 在一个模块中只输出第一次出现的警告
"once" 输出第一次出现的警告,而不考虑它们的位置
- message 是包含正则表达式的字符串，警告消息的开始必须匹配，不区分大小写
- category 是一个警告类型（必须是 Warning 的子类）
- module 是包含模块名称的正则表达式字符串，区分大小写
- lineno 是一个整数，警告发生的行号，为 0 则匹配所有行号
默认警告过滤器
默认情况下，``Python ``设置了几个警告过滤器，可以通过`` -W ``命令行选项和调用`` filterwarnings() ``函数来覆盖它们。
DeprecationWarning ``和`` PendingDeprecationWarning ``和`` ImportWarning ``被默认忽略。
除非`` -b ``选项给出一次或两次，否则忽略`` BytesWarning``；在这种情况下，此警告或者被输出（``-b``）或者变成异常（``-bb``）。
除非`` Python ``是在调试模式下构建的，否则将忽略`` ResourceWarning``。
在`` 3.2 ``版中的调整``: ``除`` PendingDeprecationWarning ``之外，默认情况下将忽略`` DeprecationWarning
可用函数
1. warn
warnings.warn(message, category=None, stacklevel=1, source=None)
触发异常。``category`` ``参数默认为`` ``UserWarning``。``message`` ``参数为警告消息，可以是`` ``Warning`` ``实例，在这种情况下，将忽略`` ``category`` ``并使用`` ``message.__class__``，消息文本则为`` ``str(message)``。
warn_explicit
warnings.warn_explicit(message, category, filename, lineno, module=None, registry=None, module_globals=None, source=None)
是 warn() 函数的低级接口，明确传递消息，类别，文件名和行号，以及可选的模块名称和注册表（应该是模块的 warningregistry 字典）
3.showwarning
warnings.showwarning(message, category, filename, lineno, file=None, line=None)
写入警告到文件。默认调用`` formatwarning(message, category, filename, lineno, line) ``并将结果字符串写入`` file``，默认为`` sys.stderr``。`` line ``是包含在警告消息中的一行源代码；如果未提供则尝试读取由`` filename ``和`` lineno ``指定的行。
simplefilter
warnings.simplefilter(action, category=Warning, lineno=0, append=False)
简单易用的过滤器，类似 filterwarnings() 函数，但是不需要正则表达式。
resetwarnings
warnings.resetwarnings()
重置警告过滤器。这会丢弃所有以前对 filterwarnings() 调用的影响，包括 -W 命令行选项和对 simplefilter() 的调用的影响。
生成警告
发出警告的最简单方法是使用消息作为参数调用`` ``warn()`` ``。
import warnings
print('Before the warning')
warnings.warn('This is a warning message')
print('After the warning')
Socketserver模块
2022年7月25日
21:01
基于tcp的套接字，关键就是两个循环，
一个链接循环，一个通信循环
socketserver模块中分两大类：
server类（解决链接问题）
request类（解决通信问题）
server类：
request类：
继承关系:
以下述代码为例，分析socketserver源码：
ftpserver=socketserver.ThreadingTCPServer(('17.0.0.1',8080),FtpServer)
ftpserver.serve_forever()
查找属性的顺序：ThreadingTCPServer->ThreadingMixIn->TCPServer->BaseServer
- 实例化得到ftpserver，先找类ThreadingTCPServer的__init__,在TCPServer中找到，进而执行server_bind,server_active
- 找ftpserver下的serve_forever,在BaseServer中找到，进而执行self._handle_request_noblock()，该方法同样是在BaseServer中
- 执行self._handle_request_noblock()进而执行request, client_address = self.get_request()（就是TCPServer中的self.socket.accept()），然后执行self.process_request(request, client_address)
- 在ThreadingMixIn中找到process_request，开启多线程应对并发，进而执行process_request_thread，执行self.finish_request(request, client_address)
上述四部分完成了链接循环，本部分开始进入处理通讯部分，在BaseServer中找到finish_request,触发我们自己定义的类的实例化，去找__init__方法，而我们自己定义的类没有该方法，则去它的父类也就是BaseRequestHandler中找....
源码分析总结：
基于tcp的socketserver我们自己定义的类中的
- self.server即套接字对象
- self.request即一个链接
- self.client_address即客户端地址
基于udp的socketserver我们自己定义的类中的
- self.request是一个元组
（第一个元素是客户端发来的数据，第二部分是服务端的udp套接字对象），
如(b'adsf', <socket.socket fd=200, family=AddressFamily.AF_INET, type=SocketKind.SOCK_DGRAM, proto=0, laddr=('127.0.0.1', 8080)>)
- self.client_address即客户端地址
multiprocessing模块
2022年7月27日
12:50
介绍
multiprocessing模块的功能众多：支持子进程、通信和共享数据、执行不同形式的同步，提供了Process、Queue、Pipe、Lock等组件。
与线程不同，进程没有任何共享状态，进程修改的数据，改动仅限于该进程内。
Process类的介绍
创建进程的类
Process([group [, target [, name [, args [, kwargs]]]]])``，由该类实例化得到的对象，表示一个子进程中的任务（尚未启动）
强调：`
`1. ``需要使用关键字的方式来指定参数`
`2. args``指定的为传给``target``函数的位置参数，是一个元组形式，必须有逗号
参数
group``参数未使用，值始终为``None
target``表示调用对象，即子进程要执行的任务
args``表示调用对象的位置参数元组，``args=(1,2,'egon',)
kwargs``表示调用对象的字典``,kwargs={'name':'egon','age':18}
name``为子进程的名称
方法介绍
p.start()``：启动进程，并调用该子进程中的``p.run()
p.run():``进程启动时运行的方法，正是它去调用``target``指定的函数，我们自定义类的类中一定要实现该方法
p.terminate():``强制终止进程``p``，不会进行任何清理操作，如果``p``创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果``p``还保存了一个锁那么也将不会被释放，进而导致死锁
p.is_alive():``如果``p``仍然运行，返回``True
p.join([timeout]):``主线程等待``p``终止（强调：是主线程处于等的状态，而``p``是处于运行的状态）。``timeout``是可选的超时时间，需要强调的是，``p.join``只能``join``住``start``开启的进程，而不能``join``住``run``开启的进程
属性介绍
p.daemon``：默认值为``False``，如果设为``True``，代表``p``为后台运行的守护进程，当``p``的父进程终止时，``p``也随之终止，并且设定为``True``后，``p``不能创建自己的新进程，必须在``p.start()``之前设置
p.name:``进程的名称
p.pid``：进程的``pid
p.exitcode:``进程在运行时为``None``、如果为``–``N``，表示被信号``N``结束``(``了解即可``)
p.authkey:``进程的身份验证键``,``默认是由``os.urandom()``随机生成的``32``字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性，这类连接只有在具有相同的身份验证键时才能成功（了解即可）
僵尸进程与孤儿进程
一：僵尸进程（有害）
僵尸进程：
一个进程使用fork创建子进程，如果子进程退出，而父进程并没有调用wait或waitpid获取子进程的状态信息，那么子进程的进程描述符仍然保存在系统中。这种进程称之为僵死进程。
二：孤儿进程（无害）
孤儿进程：
一个父进程退出，而它的一个或多个子进程还在运行，那么那些子进程将成为孤儿进程。孤儿进程将被init进程(进程号为1)所收养，并由init进程对它们完成状态收集工作。
孤儿进程是没有父进程的进程，孤儿进程这个重任就落到了init进程身上，init进程就好像是一个民政局，专门负责处理孤儿进程的善后工作。每当出现一个孤儿进程的时候，内核就把孤 儿进程的父进程设置为init，而init进程会循环地wait()它的已经退出的子进程。这样，当一个孤儿进程凄凉地结束了其生命周期的时候，init进程就会代表党和政府出面处理它的一切善后工作。因此孤儿进程并不会有什么危害。
解决僵尸进程
等待父进程正常结束后会调用wait／waitpid去回收僵尸进程
但如果父进程是一个死循环，永远不会结束，那么该僵尸进程就会一直存在，僵尸进程过多，就是有害的
解决方法一：杀死父进程
解决方法二：对开启的子进程应该记得使用join，join会回收僵尸进程
解决方法三：
signal(``参数一``,``参数二``)
参数一：我们要进行处理的信号。系统的信号我们可以再终端键入 kill -l查看(共64个)。其实这些信号时系统定义的宏。
参数二：我们处理的方式（是系统默认还是忽略还是捕获）。可以写一个handdle函数来处理我们捕获的信号。
SIGCHLD信号
子进程结束时, 父进程会收到这个信号。
如果父进程没有处理这个信号，也没有等待(wait)子进程，子进程虽然终止，但是还会在内核进程表中占有表项，这时的子进程称为僵尸进程。这种情 况我们应该避免(父进程或者忽略SIGCHILD信号，或者捕捉它，或者wait它派生的子进程，或者父进程先终止，这时子进程的终止自动由init进程 来接管)。
SIG_ING
忽略的意思
守护进程
主进程创建守护进程
其一：守护进程会在主进程代码执行结束后就终止
其二：守护进程内无法再开启子进程,否则抛出异常：AssertionError: daemonic processes are not allowed to have children
注意：进程之间是互相独立的，主进程代码运行结束，守护进程随即终止
使用：``p.daemon=True #``一定要在``p.start()``前设置``,``设置``p``为守护进程``,``禁止``p``创建子进程``,``并且父进程代码执行结束``,p``即终止运行
案例：
frommultiprocessing import Process`
`import time`
`import random
class Piao(Process):`
` def__init__(self,name):`
` self.name=name`
` super().__init__()`
` def run(self):`
` print('%s is piaoing'%self.name)`
` time.sleep(random.randrange(1,3))`
` print('%s is piao end'%self.name)
p=Piao('egon')`
`p.daemon=True #``一定要在``p.start()``前设置``,``设置``p``为守护进程``,``禁止``p``创建子进程``,``并且父进程代码执行结束``,p``即终止运行
p.start()`
`print('``主``')
进程锁
进程之间数据不共享,但是共享同一套文件系统,所以访问同一个文件,或同一个打印终端,是没有问题的,
而共享带来的是竞争，竞争带来的结果就是错乱，如何控制，就是加锁处理
案例一：多个进程共享同一打印终端
未加锁：#并发运行,效率高,但竞争同一打印终端,带来了打印错乱
加锁: #由并发变成了串行,牺牲了运行效率,但避免了竞争
案例二：多个进程共享同一文件
未加锁：并发写入，效率高，但是竞争同一个文件，到时数据错乱
加锁：并发变成了串行，牺牲了运行效率，但是保证了数据的安全
总结：
#加锁可以保证多个进程修改同一块数据时，同一时间只能有一个任务可以进行修改，即串行的修改，没错，速度是慢了，但牺牲了速度却保证了数据安全。虽然可以用文件共享数据实现进程间通信，但问题是：
1.效率低（共享数据基于文件，而文件是硬盘上的
数据）
2.需要自己加锁处理
#因此我们最好找寻一种解决方案能够兼顾：
1、效率高（多个进程共享一块内存的数据）
2、帮我们处理好锁问题。
这就是mutiprocessing模块为我们提供的基于消息的IPC通信机制：队列和管道。
1 队列和管道都是将数据存放于内存中
2 队列又是基于（管道+锁）实现的，可以让我们从复杂的锁问题中解脱出来，
我们应该尽量避免使用共享数据，尽可能使用消息传递和队列，避免处理复杂的同步和锁问题，而且在进程数目增多时，往往可以获得更好的可获展性。
队列
进程彼此之间互相隔离，要实现进程间通信（IPC），multiprocessing模块支持两种形式：队列和管道，这两种方式都是使用消息传递的
创建队列的类（底层就是以管道和锁定的方式实现）：
Queue([maxsize]):创建共享的进程队列，Queue是多进程安全的队列，可以使用Queue实现多进程之间的数据传递。
maxsize是队列中允许最大项数，省略则无大小限制。
方法介绍：
q.put
方法用以插入数据到队列中，``put``方法还有两个可选参数：``blocked``和``timeout``。如果``blocked``为``True``（默认值），并且``timeout``为正值，该方法会阻塞``timeout``指定的时间，直到该队列有剩余的空间。如果超时，会抛出``Queue.Full``异常。如果``blocked``为``False``，但该``Queue``已满，会立即抛出``Queue.Full``异常。
q.get
方法可以从队列读取并且删除一个元素。
get``方法有两个可选参数：``blocked``和``timeout``。
如果``blocked``为``True``（默认值），并且``timeout``为正值，那么在等待时间内没有取到任何元素，会抛出``Queue.Empty``异常。
如果``blocked``为``False``，有两种情况存在，如果``Queue``有一个值可用，则立即返回该值，否则，如果队列为空，则立即抛出``Queue.Empty``异常``.
q.get_nowait():``同``q.get(False)
q.put_nowait():``同``q.put(False)
q.empty():
调用此方法时``q``为空则返回``True``，该结果不可靠，比如在返回``True``的过程中，如果队列中又加入了项目。
q.full()``：
调用此方法时``q``已满则返回``True``，该结果不可靠，比如在返回``True``的过程中，如果队列中的项目被取走。
q.qsize():
返回队列中目前项目的正确数量，结果也不可靠，理由同``q.empty()``和``q.full()``一样
q.cancel_join_thread():
不会在进程退出时自动连接后台线程。可以防止``join_thread()``方法阻塞
q.close():
关闭队列，防止队列中加入更多数据。
调用此方法，后台线程将继续写入那些已经入队列但尚未写入的数据，但将在此方法完成时马上关闭。如果``q``被垃圾收集，将调用此方法。关闭队列不会在队列使用者中产生任何类型的数据结束信号或异常。例如，如果某个使用者正在被阻塞在``get()``操作上，关闭生产者中的队列不会导致``get()``方法返回错误。
q.join_thread()``：
连接队列的后台线程。此方法用于在调用``q.close()``方法之后，等待所有队列项被消耗。默认情况下，此方法由不是``q``的原始创建者的所有进程调用。调用``q.cancel_join_thread``方法可以禁止这种行为
进程池
在利用Python进行系统管理的时候，特别是同时操作多个文件目录，或者远程控制多台主机，并行操作可以节约大量的时间。多进程是实现并发的手段之一，需要注意的问题是：
- 很明显需要并发执行的任务通常要远大于核数
- 一个操作系统不可能无限开启进程，通常有几个核就开几个进程
- 进程开启过多，效率反而会下降（开启进程是需要占用系统资源的，而且开启多余核数目的进程也无法做到并行）
例如当被操作对象数目不大时，可以直接利用multiprocessing中的Process动态成生多个进程，十几个还好，但如果是上百个，上千个。。。手动的去限制进程数量却又太过繁琐，此时可以发挥进程池的功效。
我们就可以通过维护一个进程池来控制进程数目，比如httpd的进程模式，规定最小进程数和最大进程数...
ps：对于远程过程调用的高级应用程序而言，应该使用进程池，Pool可以提供指定数量的进程，供用户调用，当有新的请求提交到pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到规定最大值，那么该请求就会等待，直到池中有进程结束，就重用进程池中的进程。
创建进程池的类：
如果指定numprocess为3，则进程池会从无到有创建三个进程，然后自始至终使用这三个进程去执行所有任务，不会开启其他进程
Pool([numprocess [,initializer [, initargs]]]):``创建进程池``
参数介绍
1 numprocess:``要创建的进程数，如果省略，将默认使用``cpu_count()``的值`
`2 initializer``：是每个工作进程启动时要执行的可调用对象，默认为``None`
`3 initargs``：是要传给``initializer``的参数组
方法介绍
p.apply(func[,args[,kwargs]]):
在一个池工作进程中执行``func(*args,**kwargs),``然后返回结果。需要强调的是：此操作并不会在所有池工作进程中并执行``func``函数。如果要通过不同参数并发地执行``func``函数，必须从不同线程调用``p.apply()``函数或者使用``p.apply_async()
p.apply_async(func[,args[,kwargs]]):
在一个池工作进程中执行``func(*args,**kwargs),``然后返回结果。此方法的结果是``AsyncResult``类的实例，``callback``是可调用对象，接收输入参数。当``func``的结果变为可用时，将理解传递给``callback``。``callback``禁止执行任何阻塞操作，否则将接收其他异步操作中的结果。
p.close():
关闭进程池，防止进一步操作。如果所有操作持续挂起，它们将在工作进程终止前完成
P.jion():
等待所有工作进程退出。此方法只能在``close``（）或``teminate()``之后调用
obj.get():
返回结果，如果有必要则等待结果到达。``timeout``是可选的。如果在指定时间内还没有到达，将引发一场。如果远程操作中引发了异常，它将在调用此方法时再次被引发。
obj.ready():
如果调用完成，返回``True
obj.successful():
如果调用完成且没有引发异常，返回``True``，如果在结果就绪之前调用此方法，引发异常
obj.wait([timeout]):
等待结果变为可用。
obj.terminate()``：
立即终止所有工作进程，同时不执行任何清理或结束任何挂起工作。如果``p``被垃圾回收，将自动调用此函数
wsgiref
2022年9月7日
11:41
wsgiref 是Python标准库给出的 WSGI 的参考实现。
WSGI是Python Web 开发中为服务器程序和应用程序设定的标准，满足这一标准的服务器程序和应用程序可以配合使用。我在上一篇博文《WSGI简介》中对此有详细的介绍。在阅读wsgiref源代码之前，一定要对WSGI有一定了解。
WSGI 在 PEP 333 中描述，但是只靠阅读PEP 333 可能在理解上还是不够深入，所以阅读官方给出的参考实现是很有必要的。阅读完这份源代码后，不仅有利于对WSGI的理解。而且会让你对服务端程序如何对客户端请求有一个直观的理解，从相对底层的socket监听请求，到上层对HTTP请求的处理。
当然，这只是对WSGI的参考实现，目的是为了描述清楚WSGI，而不是真正用在产品中。如果想对Python Web开发中服务器端的实现有更广泛，更深入的理解，需要进一步阅读Python常用框架的源代码。
wsgiref 源代码分析
wsgiref 源代码可以在 pypi wsgiref 0.1.2 下载。另外，我在阅读的过程中作了大量注释，包含模块介绍，调用层次关系，demo的运行结果，等 等，还包含了阅读过程中制作的思维导图。GitHub地址注释版wsgiref。
结构
上图描述了wsgiref的所有模块及模块间的调用关系，可以看出，wsgiref有以下模块：
simple_server
这一模块实现了一个简单的 HTTP 服务器，并给出了一个简单的 demo，运行：
python simple_server.py
会启动这个demo，运行一次请求，并把这次请求中涉及到的环境变量在浏览器中显示出来。
handlers
simple_server模块将HTTP服务器分成了 Server 部分和Handler部分，前者负责接收请求，后者负责具体的处理， 其中Handler部分主要在handlers中实现。
headers
这一模块主要是为HTTP协议中header部分建立数据结构。
util
这一模块包含了一些工具函数，主要用于对环境变量，URL的处理。
validate
这一模块提供了一个验证工具，可以用于验证你的实现是否符合WSGI标准。
simple_server
可以看出，simple_server 模块主要有两部分内容
应用程序
函数demo_app是应用程序部分
服务器程序
服务器程序主要分成Server 和 Handler两部分，另外还有一个函数 make_server 用来生成一个服务器实例
我们先看应用程序部分。
注意：以 M:开始的都是我自己添加的注释，不包含在最初的源代码中。
def demo_app(environ,start_response):
# M: StringIO reads and writes a string buffer (also known as memory files).
from StringIO import StringIO
stdout = StringIO()
print >> stdout, "Hello world!"
print >> stdout
h = environ.items()
h.sort()
for k,v in h:
print >> stdout, k,'=',v``
start_response("200 OK", [('Content-Type','text/plain')])
return [stdout.getvalue()]
这里可以看出，这个 demo_app 是如何展示WSGI中对应用程序的要求的：
demo_app 有两个参数
第一个参数 environ是一个字典
第二个参数 start_response是一个可调用函数
demo_app 返回一个可迭代对象
demo_app 需要调用 start_response
另外，可以看出，返回的内容就是环境变量当前的内容，这一点可以运行
python simple_server.py
在浏览器中看到的内容，就是上述源代码的for循环中输出的。
这里，使用了 StringIO ，可以看出，所有输出的内容都先存储在其实例中，最后返回的时候一起在可迭代对象中返回。
接下来，我们看服务器程序。
先从 make_server 看起，它是用来生成一个server实例的：
def make_server(
host, port, app, server_class=WSGIServer, handler_class=WSGIRequestHandler
):
"""Create a new WSGI server listening on `host` and `port` for `app`"""
# M: -> HTTPServer.__init__
# -> TCPServer.__init__
# -> TCPServer.server_bind
# -> TCPServer.socket.bind
# -> TCPServer.server_activate
# -> TCPServer.socket.listen
server = server_class((host, port), handler_class)
# M: conresponding to WSGIRequestHandler.handle()
# -> handler.run(self.server.get_app())
server.set_app(app)
return server
虽然代码只有三行，但是可以看出生成一个 server 都需要些什么：
(host, port)
主机名和端口号
handler_class
用于处理请求的handler类
app 服务器程序在处理时，一定会调用我们之前写好的应用程序，这样他们才能配合起来为客户端面服务，所以，你看到了那个 set_app 调用。
另外，在注释部分，你可以看到那代码背后都发生了什么。
生成 server 实例时，默认的 server_class 是 WSGIServer，它是HTTPServer的子类，后者又是TCPServer的子类，所以初始化 server 时，会沿着类的继承关系执行下去，最终，生成 server 实例的过程，其实是最底层的 TCPServer 在初始化时，完成了对socket的bind和listen。
后面的 set_app 设置了 app，它会在 handler_class (默认为WSGIRequestHandler)的handle函数中被取出来，然后交给 handler 的 run 函数运行。
好，现在我们开始介绍Server部分的主要内容，即WSGIServer和WSGIRequestHandler，首先，我们看一下二者的继承体系。
WSGIServer
# M:
# +------------+
# | BaseServer |
# +------------+
# |
# V
# +------------+
# | TCPServer |
# +------------+
# |
# V
# +------------+
# | HTTPServer |
# +------------+
# |
# V
# +------------+
# | WSGIServer |
# +------------+
可以看出 WSGIServer 来自 HTTPServer，后者来自 Python 标准库中的BaseHTTPServer模块，更上层的TCPServer和BaseServer来自 Python 标准库中的 SocketServer 模块。
WSGIRequestHandler
# M:
# +--------------------+
# | BaseRequestHandler |
# +--------------------+
# |
# V
# +-----------------------+
# | StreamRequestHandler |
# +-----------------------+
# |
# V
# +------------------------+
# | BaseHTTPRequestHandler |
# +------------------------+
# |
# V
# +--------------------+
# | WSGIRequestHandler |
# +--------------------+
可以看出 WSGIRequestHandler 来自 BaseHTTPRequestHandler，后者来自 Python 标准库中的BaseHTTPServer模块，更上层的StreamRequestHandler和BaseRequestHandler来自 Python 标准库中的 SocketServer 模块。
这时候，三个模块之间的层次关系我们可以理清楚了。
# M:
# +-----------------------------------------------+
# | simple_server: WSGIServer, WSGIRequestHandler |
# | |
# +-----------------------------------------------+
# |
# V
# +----------------------------------------------------+
# | BaseHTTPServer: HTTPServer, BaseHTTPRequestHandler |
# +----------------------------------------------------+
# |
# V
# +----------------------------------------------------+
# | SocketServer: TCPServer,BaseSErver; |
# | StreamRequestHandler,BaseRequestHandler |
# +----------------------------------------------------+
#
另外，这一模块中还有一个类，叫ServerHandler，它继承自 handlers 模块中的 SimpleHandler，我们再看看它的继承体系：
# M:
# +-------------+
# | BaseHandler |
# +-------------+
# |
# V
# +----------------+
# | SimpleHandler |
# +----------------+
# |
# V
# +---------------+
# | ServerHandler |
# +---------------+
#
好了，现在这个模块中的继承结构都弄清楚了，现在我们看看他们如何配合起来完成对客户端请求的处理。
首先，回顾simple_server涉及的模块：
WSGIServer
WSGIRequestHandler
ServerHandler
demo_app
make_server
然后，把大脑清空，想一下要对客户端请求进行处理需要做什么
启动服务器，监听客户端请求
请求来临，处理用户请求
我们看看这几个模块是如何配合完成这两个功能的
先看看 simple_server 模块的 main 部分，即执行
python simple_server.py
时执行的内容:
httpd = make_server('', 8000, demo_app)
sa = httpd.socket.getsockname()
print "Serving HTTP on", sa[0], "port", sa[1], "..."
# M: webbrowser provides a high-level interface to allow displaying Web-based documents
# to users. Under most circumstances
import webbrowser
webbrowser.open('http://localhost:8000/xyz?abc')
httpd.handle_request() # serve one request, then exit
可以看出，主要完成的功能是：
启动服务器
模块用户请求
处理用户请求
那么，我们主要关心的就是 make_server 和 handle_request 背后都发生了什么。
make_server
上图可以看出函数之间的调用关系，也可以看出 make_server 到 使用 socket 监听用户请求的过程。
handle_request
handle_request 的过程真正将各个模块联系起来了。
上图很清楚地说明了 由handle_request到demo_app的执行过程，把这个模块的各个部分联系起来。相信无需多言了。
Handlers
从图中可以看出handler模块中的四部分，它们其实是四个类，
从基类到子类依次为：
BaseHandler
SimpleHandler
BaseCGIHandler
CGIHandler
最主要的实现在 BaseHandler中，其它几个类都是在基类基础上做了简单的实现。BaseHandler是不能直接使用的，因为有几个关键的地方没有实现，SimpleHandler是一个可以使用的简单实现。simple_server中的 ServerHandler类就是这个模块中SimpleHandler的子类。
在 BaseHandler中，最重要的是 run 函数：
def run(self, application):
"""Invoke the application"""
# Note to self: don't move the close()! Asynchronous servers shouldn't
# call close() from finish_response(), so if you close() anywhere but
# the double-error branch here, you'll break asynchronous servers by
# prematurely closing. Async servers must return from 'run()' without
# closing if there might still be output to iterate over.
try:
self.setup_environ()
self.result = application(self.environ, self.start_response)
self.finish_response()
except:
try:
self.handle_error()
except:
# If we get an error handling an error, just give up already!
self.close()
raise # ...and let the actual server figure it out.
它先设置好环境变量，再调用我们的 demo_app, 并通过 finish_response 将调用结果传送给客户端。如果处理过程遇到错误，转入 handle_error 处理。
此外，BaseHandler中还包含了 WSGI 中多次提到的 start_response，start_response 在 demo_app 中被调用，我们看看它的实现：
def start_response(self, status, headers,exc_info=None):
"""'start_response()' callable as specified by PEP 333"""
# M:
# exc_info:
# The exc_info argument, if supplied, must be a Python sys.exc_info()
# tuple. This argument should be supplied by the application only if
# start_response is being called by an error handler.
# exc_info is the most recent exception catch in except clause
# in error_output:
# start_response(
# self.error_status,self.error_headers[:],sys.exc_info())
# headers_sent:
# when send_headers is invoked, headers_sent = True
# when close is invoked, headers_sent = False
if exc_info:
try:
if self.headers_sent:
# Re-raise original exception if headers sent
raise exc_info[0], exc_info[1], exc_info[2]
finally:
exc_info = None # avoid dangling circular ref
elif self.headers is not None:
raise AssertionError("Headers already set!")
assert type(status) is StringType,"Status must be a string"
assert len(status)>=4,"Status must be at least 4 characters"
assert int(status[:3]),"Status message must begin w/3-digit code"
assert status[3]==" ", "Status message must have a space after code"
if __debug__:
for name,val in headers:
assert type(name) is StringType,"Header names must be strings"
assert type(val) is StringType,"Header values must be strings"
assert not is_hop_by_hop(name),"Hop-by-hop headers not allowed"
# M: set status and headers
self.status = status
# M:
# headers_class is Headers in module headers
self.headers = self.headers_class(headers)
return self.write
可以看出，它先对参数进行了检查，然后再将headers 存储在成员变量中，这两点 WSGI标准中都有明确说明，需要检查参数，并且这一步只能将 headers存储起来，不能直接发送给客户端。也就是说，这个 start_response 还没有真正 response。
其实刚刚介绍 run 函数的时候已经提到了，真正的 response 在 finish_response 函数中：
def finish_response(self):
"""Send any iterable data, then close self and the iterable
Subclasses intended for use in asynchronous servers will
want to redefine this method, such that it sets up callbacks
in the event loop to iterate over the data, and to call
'self.close()' once the response is finished.
"""
# M:
# result_is_file:
# True if 'self.result' is an instance of 'self.wsgi_file_wrapper'
# finish_content:
# Ensure headers and content have both been sent
# close:
# Close the iterable (if needed) and reset all instance vars
if not self.result_is_file() or not self.sendfile():
for data in self.result:
self.write(data) # send data by self.write
self.finish_content()
self.close()
另外一个需要注意的地方是错误处理，在 run 函数中通过 try/except 捕获错误，错误处理使用了 handle_error 函数，WSGI中提到，start_response 函数的第三个参数 exc_info 会在错误处理的时候使用，我们来看看它是如何被使用的：
def handle_error(self):
"""Log current error, and send error output to client if possible"""
self.log_exception(sys.exc_info())
if not self.headers_sent:
self.result = self.error_output(self.environ, self.start_response)
self.finish_response()
# XXX else: attempt advanced recovery techniques for HTML or text?
def error_output(self, environ, start_response):
"""WSGI mini-app to create error output
By default, this just uses the 'error_status', 'error_headers',
and 'error_body' attributes to generate an output page. It can
be overridden in a subclass to dynamically generate diagnostics,
choose an appropriate message for the user's preferred language, etc.
Note, however, that it's not recommended from a security perspective to
spit out diagnostics to any old user; ideally, you should have to do
something special to enable diagnostic output, which is why we don't
include any here!
"""
# M:
# sys.exc_info():
# Return information about the most recent exception caught by an except
# clause in the current stack frame or in an older stack frame.
start_response(self.error_status,self.error_headers[:],sys.exc_info())
return [self.error_body]
看到了吧，handle_error 又调用了 error_output ，后者调用 start_response，并将其第三个参数设置为 sys.exc_info()，这一点在 WSGI 中也有说明。
好了，这一部分我们就介绍到这里，不再深入过多的细节，毕竟源代码还是要自己亲自阅读的。剩下的三个部分不是核心问题，就是一些数据结构和工具函数，我们简单说一下。
Headers
这个模块是对HTTP 响应部分的头部设立的数据结构，实现了一个类似Python 中 dict的数据结构。可以看出，它实现了一些函数来支持一些运算符，例如 len, setitem, getitem, delitem, str, 另外，还实现了 dict 操作中的get, keys, values函数。
Util
这个模块主要就是一些有用的函数，用于处理URL, 环境变量。
Validate
这个模块主要是检查你对WSGI的实现，是否满足标准，包含三个部分：
validator
Wrapper
Check
validator 调用后面两个部分来完成验证工作，可以看出Check部分对WSGI中规定的各个部分进行了检查。
Jinja2
2022年9月7日
12:29
jinja2介绍
jinja2是Flask作者开发的一个模板系统，起初是仿django模板的一个模板引擎，为Flask提供模板支持，由于其灵活，快速和安全等优点被广泛使用。
jinja2的优点
jinja2之所以被广泛使用是因为它具有以下优点：
-
- 相对于Template，jinja2更加灵活，它提供了控制结构，表达式和继承等。
- 相对于Mako，jinja2仅有控制结构，不允许在模板中编写太多的业务逻辑。
- 相对于Django模板，jinja2性能更好。
- Jinja2模板的可读性很棒。
安装jinja2
由于jinja2属于第三方模块，首先需要对其进行安装
| 1 | pip3 install jinja2 |
|---|---|
测试模板是否安装成功
1 2 3 4 |
python -c "import jinja2" # ``没有报错就表示安装成功 # ``必须用双引号``" |
|---|---|
jinja2语法
作为一个模板系统，它还提供了特殊的语法，我们按照它支持的语法进行编写之后，就能使用jinja2模块进行渲染。
基本语法
在jinja2中，存在三种语法：
-
- 控制结构
- 变量取值 {{ }}
- 注释
下面是一个简单的jinja2例子
1 2 3 4 5 6 7 |
{# This is jinja code {% for file in filenames %} ... {% endfor %} #} |
|---|---|
可以看到，for循环的使用方式和Python比较类似，但是没有了句尾的冒号，另外需要使用endfor最为结尾，其实在jinja2中，if也是一样的，结尾需要使用endif。
jinja2变量
jinja2模板中使用 {{ }} 语法表示一个变量，它是一种特殊的占位符。当利用jinja2进行渲染的时候，它会把这些特殊的占位符进行填充/替换，jinja2支持python中所有的Python数据类型比如列表、字段、对象等。
1 2 3 |
<p>this is a dicectory:{{ mydict['key'] }} </p> <p>this is a list:{{ mylist[3] }} </p> <p>this is a object:{{ myobject.something() }} </p> |
|---|---|
jinja2中的过滤器
变量可以通过“过滤器”进行修改，过滤器可以理解为是jinja2里面的内置函数和字符串处理函数。
常用的过滤器有：
| 过滤器名称 | 说明 |
|---|---|
| safe | 渲染时值不转义 |
| capitialize | 把值的首字母转换成大写，其他子母转换为小写 |
| lower | 把值转换成小写形式 |
| upper | 把值转换成大写形式 |
| title | 把值中每个单词的首字母都转换成大写 |
| trim | 把值的首尾空格去掉 |
| striptags | 渲染之前把值中所有的HTML标签都删掉 |
| join | 拼接多个值为字符串 |
| replace | 替换字符串的值 |
| round | 默认对数字进行四舍五入，也可以用参数进行控制 |
| int | 把值转换成整型 |
那么如何使用这些过滤器呢？ 只需要在变量后面使用管道(|)分割，多个过滤器可以链式调用，前一个过滤器的输出会作为后一个过滤器的输入。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 | {{ 'abc' | captialize }} # Abc {{ 'abc' | upper }} # ABC {{ 'hello world' | title }} # Hello World {{ "hello world" | replace('world','daxin') | upper }} # HELLO DAXIN {{ 18.18 | round | int }} # 18 |
| ------------------------------------------------------------ | ------------------------------------------------------------ |
| | |
jinja2的控制结构
jinja2中的if语句类似与Python的if语句，它也具有单分支，多分支等多种结构，不同的是，条件语句不需要使用冒号结尾，而结束控制语句，需要使用endif关键字。
1 2 3 4 5 6 7 |
{% if daxin.safe %} daxin is safe. {% elif daxin.dead %} daxin is dead {% else %} daxin is okay {% endif %} |
|---|---|
jinja2的for循环
jinja2中的for循环用于迭代Python的数据类型，包括列表，元组和字典。在jinja2中不存在while循环。
迭代列表
| 1 2 3 4 5 | <ul> {% for user in users %} <li>{{ user.username|title }}</li> {% endfor %} </ul> |
| ----------------------- | ------------------------------------------------------------ |
| | |
迭代字典
1 2 3 4 5 6 |
<dl> {% for key, value in my_dict.iteritems() %} <dt>{{ key }}</dt> <dd>{{ value}}</dd> {% endfor %} </dl> |
|---|---|
当然也可以加入else语句，在循环正确执行完毕后，执行
在for循环中，jinja2还提供了一些特殊的变量，用以来获取当前的遍历状态：
| 变量 | 描述 |
|---|---|
| loop.index | 当前迭代的索引（从1开始） |
| loop.index0 | 当前迭代的索引（从0开始） |
| loop.first | 是否是第一次迭代，返回bool |
| loop.last | 是否是最后一次迭代，返回bool |
| loop.length | 序列中的项目数量 |
| loop.revindex | 到循环结束的次数（从1开始） |
| loop.revindex0 | 到循环结束的次数(从0开始） |
jinja2的宏
宏类似于Python中的函数，我们在宏中定义行为，还可以进行传递参数，就像Python中的函数一样一样儿的。
在宏中定义一个宏的关键字是macro，后面跟其 宏的名称和参数等
1 2 3 4 5 |
{% macro input(name,age=18) %} # ``参数``age``的默认值为``18 <input type='text' name="{{ name }}" value="{{ age }}" > {% endmacro %} |
|---|---|
调用方法也和Python的类似
1 2 |
<p>{{ input('daxin') }} </p> <p>{{ input('daxin',age=20) }} </p> |
|---|---|
jinja2的继承和Super函数
jinja2中最强大的部分就是模板继承。模板继承允许我们创建一个基本(骨架)文件，其他文件从该骨架文件继承，然后针对自己需要的地方进行修改。
jinja2的骨架文件中，利用block关键字表示其包涵的内容可以进行修改。
以下面的骨架文件base.html为例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
<!DOCTYPE html> <html lang="en"> <head> {% block head %} <link rel="stylesheet" href="style.css"/> <title>{% block title %}{% endblock %} - My Webpage</title> {% endblock %} </head> <body> <div id="content">{% block content %}{% endblock %}</div> <div id="footer"> {% block footer %} <script>This is javascript code </script> {% endblock %} </div> </body> </html> |
|---|---|
这里定义了四处 block，即：head，title，content，footer。那怎么进行继承和变量替换呢？注意看下面的文件
1 2 3 4 5 6 7 8 9 10 11 12 |
{% extend "base.html" %} # ``继承``base.html``文件 {% block title %} Dachenzi {% endblock %} # ``定制``title``部分的内容 {% block head %} {{ super() }} # ``用于获取原有的信息 <style type='text/css'> .important { color: #FFFFFF } </style> {% endblock %} # ``其他不修改的原封不同的继承 |
|---|---|
PS: super()函数 表示获取block块中定义的原来的内容。
利用jinja2进行渲染
jinja2模块中有一个名为Enviroment的类，这个类的实例用于存储配置和全局对象，然后从文件系统或其他位置中加载模板。
基本使用方法
大多数应用都在初始化的时候撞见一个Environment对象，并用它加载模板。Environment支持两种加载方式：
-
- PackageLoader：包加载器
- FileSystemLoader：文件系统加载器
PackageLoader
使用包加载器来加载文档的最简单的方式如下：
| 1 2 3 4 5 | from jinja2 import PackageLoader,Environment env = Environment(loader=PackageLoader('python_project','templates')) # 创建一个包加载器对象 template = env.get_template('bast.html') # 获取一个模板文件 template.render(name='daxin',age=18) # 渲染 |
|---|---|
其中：
-
- PackageLoader()的两个参数为：python包的名称，以及模板目录名称。
- get_template()：获取模板目录下的某个具体文件。
- render()：接受变量，对模板进行渲染
FileSystemLoader
文件系统加载器，不需要模板文件存在某个Python包下，可以直接访问系统中的文件。
查看api
2022年3月23日
18:27
python -m pydoc -p 1234
-p 端口号
csv模块
2022年11月12日
10:47
案例
1.使用CSV模块中的方法读取csv格式文件
import csv
import re
filename = "C:\\Users\\LSG\\Desktop\\info.csv"
#``文件的读操作（以只读方式打开文件。文件的指针将会放在文件的开头。这是``**``默认模式``** , ``编码方式``UTF-8``）
with open(filename, 'r' , encoding='utf-8') as file:
data_csv_reader = csv.reader(file)
# ``将文件中每行数据添加到``comments``里（数据类型``list``）
comments = []
for line in data_csv_reader:
comments.append(line)
# ``循环打印文本内容
for line in comments :
print(line)
sys模块
2022年7月12日
21:13
sys.argv：
参数字符串列表（动态对象），第一个参数为当前程序主文件的绝对路径或空字符串，如果在命令提示符界面给``Python``文件传了参数（不同的参数以空格分隔，无论传入的时候写的是什么类型，最终都会转成字符串），可以在这里面获取（从第二个位置开始），比如命令提示符中运行``“``python main.py 111 aaa``”``，那``sys.argv``就有三个元素，第二个和第三个元素分别为``“``111``”``和``“``aaa``”``。
返回传递给`` Python ``脚本的命令行参数列表。看下示例：
Import sys
if__name__=='__main__':
args=sys.argvprint(args)
print(args[1])
上面文件名为：``test.py``，我们在控制台使用命令：``python test.py 123 abc`` ``执行一下，执行结果如下：
['test.py','123','abc']123
sys.path：
搜索模块路径字符串列表（动态对象），搜索查找模块时会优先到这里面去搜索，第一个参数为主文件所在目录的路径或空字符串。
sys.modules：
已经加载的模块信息字典，key为模块名称，value为模块对象，在使用__import__导入模块时，可以先判断下是否有同名模块已经在sys.modules中加载了，如果已经存在了，可以先删除或者不再导入了。
以字典类型返回系统导入的模块。
sys.getsizeof(object)：
获取一个对象的内存占用字节数大小。
sys.getdefaultencoding()：
返回``Python``默认的字符串编码格式。
sys.exit([status])：
退出``Python``解释器，并抛出一个``SystemExit``异常，``status``默认为``0``，即``“``成功``”``，如果``status``是一个整数，则被用作一个系统退出状态，如果``status``是其他对象，则它将会被``print``并系统退出状态为``1``，即``“``失败``”``。所以使用这个方法的话，一般是需要进行异常处理的，运行完这条语句后如果有异常捕获和处理的，会去运行后面的异常处理代码的（而``os._exit()``方法则不会，它不会抛出异常）。
sys.excutable：
代码运行时表示运行的解释器绝对路径，如``C:\Python36\python.exe``，在打包的程序中就是``exe``程序文件的绝对路径，这个是用来定位用户运行该程序的真实位置。
version
返回`` Python ``解释器的版本信息。
winver
返回`` Python ``解释器主版号。
platform
返回操作系统平台名称。
path
返回模块的搜索路径列表。
maxsize
返回支持的最大整数值。
maxunicode
返回支持的最大`` Unicode ``值。
copyright
返回`` Python ``版权信息。
byteorder
返回本地字节规则的指示器。
executable
返回`` Python ``解释器所在路径。
Import sys
print(sys.version)
print(sys.winver)
print(sys.platform)
print(sys.path)
print(sys.maxsize)
print(sys.maxunicode)
print(sys.copyright)
print(sys.modules)
print(sys.byteorder)
print(sys.executable)
stdout
标准输出。看下示例：
import sys # ``下面两行代码等价
sys.stdout.write('Hi'+'\n')
print('Hi')
stdin
标准输入。看下示例：
import sys
s1=input()
s2=sys.stdin.readline()
print(s1)
print(s2)
stderr
错误输出。看下示例：
import sys
sys.stderr.write('this is a error message')
exit()
退出当前程序。看下示例：
import sys
print('Hi')
sys.exit()
print('Jhon')
getdefaultencoding()
返回当前默认字符串编码的名称。
getrefcount(obj)
返回对象的引用计数。
getrecursionlimit()
返回支持的递归深度。
getsizeof(object[, default])
以字节为单位返回对象的大小。
setswitchinterval(interval)
设置线程切换的时间间隔。
getswitchinterval()
返回线程切换时间间隔。
pip命令
2021年11月30日
13:23
pip使用
安装包
pip install package_name
查看某个已安装包
pip show --files package_name
检查哪些包需要更新
pip list --outdated
升级包
pip install --upgrade package_name
卸载包
pip uninstall package_name
八 安装包或者模块
可以通过pip或者easy_install安装。pip是现代化的一种安装包的方式，以下讲解pip的常用命令:
1.安装包
pip install requests
2. 安装指定版本的包
pip install django == 1.10.6
3.卸载包
pip uninstall django
4.升级包
pip install -U requests
列出可升级的包：
pip list --outdate
一行命令升级所有pip安装的Python包
pip freeze --local | grep -v ‘^-e‘ | cut -d = -f 1 | xargs pip install -U
建议在执行前先执行：
pip install -U distribute
5.升级pip
pip install -U pip
6.查看当前pip是哪个版本
pip --version
7.显示某个已安装的包的信息
pip show -f <包名>
8.列出当前环境下安装了哪些包
pip list
9. 将当前环境安装的包全部列出来放在文件中
pip freeze > requirements.txt
10.从某个文件中安装包
pip install -r requirements.txt
11.临时更改安装源，以豆瓣源为例
pip install <包名> -i https://pypi.douban.com/simple
12.永久更改安装源
windows操作系统：在当前用户目录下新建pip/pip.ini，然后在文件中添加以下代码：
[global]
index-url = https://pypi.douban.com/simple
Linux/Mac：在用户目录下新建.pip/pip.conf，然后在文件中添加以下代码：
[global]
index-url = https://pypi.douban.com/simple
# pip --help
Usage:
pip [options]
Commands:
install Install packages. ``安装包
download Download packages. ``下载包
uninstall Uninstall packages. ``卸载包
freeze Output installed packages in requirements format. ``按着一定格式输出已安装包列表
list List installed packages. ``列出已安装包
show Show information about installed packages. ``显示包详细信息
check Verify installed packages have compatible dependencies.``检查包的依赖关系是否完整
config Manage local and global configuration.``管理配置
search Search PyPI for packages.``搜索包
wheel Build wheels from your requirements.
hash Compute hashes of package archives.``计算包的hash值
completion A helper command used for command completion.
help Show help for commands.
General Options:
-h, --help Show help.
--isolated Run pip in an isolated mode, ignoring environment variables and user configuration.
-v, --verbose Give more output. Option is additive, and can be used up to 3 times.
-V, --version Show version and exit.
-q, --quiet Give less output. Option is additive, and can be used up to 3 times (corresponding to WARNING, ERROR, and CRITICAL logging levels).
--log <path> Path to a verbose appending log.
--proxy <proxy> Specify a proxy in the form [user:passwd@]proxy.server:port.
--retries <retries> Maximum number of retries each connection should attempt (default 5 times).
--timeout <sec> Set the socket timeout (default 15 seconds).
--exists-action <action> Default action when a path already exists: (s)witch, (i)gnore, (w)ipe, (b)ackup, (a)bort).
--trusted-host <hostname> Mark this host as trusted, even though it does not have valid or any HTTPS.
--cert <path> Path to alternate CA bundle.
--client-cert <path> Path to SSL client certificate, a single file containing the private key and the certificate in PEM format.
--cache-dir <dir> Store the cache data in <dir>.
--no-cache-dir Disable the cache.
--disable-pip-version-check
Don't periodically check PyPI to determine whether a new version of pip is available for download. Implied with --no-index.
--no-color Suppress colored output
os文件模块
2021年11月26日
15:09
获取指定文件夹下的目录和文件的实现
一、os.listdir 方法
os.listdir() 方法用于返回指定的目列表录下包含的文件或子目录的名字的。这个列表以字母顺序。其得到的是仅当前路径下的文件名，不包括子目录中的文件，如果需要得到所有文件需要递归。 它也不包括 '.' 和 '..' 即使它在目录中。
语法格式如下：
os.listdir(path)
案列：
def list_dir(file_dir):
'''
``通过`` listdir ``得到的是仅当前路径下的文件名，不包括子目录中的文件，如果需要得到所有文件需要递归
'''
print'\n\n<><><><><><> listdir <><><><><><>'
print "current dir : {0}".format(file_dir)
dir_list = os.listdir(file_dir)
for cur_file in dir_list:
# ``获取文件的绝对路径
path = os.path.join(file_dir, cur_file)
if os.path.isfile(path): # ``判断是否是文件还是目录需要用绝对路径
print "{0} : is file!".format(cur_file)
if os.path.isdir(path):
print "{0} : is dir!".format(cur_file)
list_dir(path) # ``递归子目录
os.walk 方法
os.walk() 方法用于通过在目录树中游走输出在目录中的文件名，向上或者向下。是一个简单易用的文件、目录遍历器，可以帮助我们高效的处理文件、目录方面的事情。
语法格式：
os.walk(top[, topdown=True[, onerror=None[, followlinks=False]]])
方法参数说明：
- top：要遍历的目录的路径
- topdown：可选，如果为 True，则优先遍历 top 目录，以及 top 目录下的每一个子目录，否则优先遍历 top 的子目录，默认为 True
- onerror: 可选， 需要一个 callable 对象，当 walk 异常时调用
- followlinks：可选， 如果为 True，则会遍历目录下的快捷方式(linux 下是 symbolic link)实际所指的目录，默认为 False
- args：包含那些没有 '-' 或 '--' 的参数列表
返回值: 三元组 (root, dirs, files)
- root ：所指的是当前正在遍历的目录的地址
- dirs ：当前文件夹中所有目录名字的 list (不包括子目录)
- files ：当前文件夹中所有的文件 (不包括子目录中的文件)
#文件名称
file_name=os.path.splitext(file)[0]
#文件根据‘。点’分割
返回一个列表，【0代表文件名字】【1为点之后的文件后缀名】
file_suffix=os.path.splitext(file)[1]
#文件具体绝对路径：文件的具体地址
具体到每一层目录，直到文件
file_path=os.path.join(root,file)
#文件相对路径：
结束是文件存在在某一级目录下，但是不具体
file_abs_path=os.path.abspath(file)
#文件父路径：文件在哪一层目录下
，结果给出的是文件的上一层目录
file_parent=os.path.dirname(file_path)
其他跟文件相关的常用方法
分离文件名和扩展名
os.path.splitext()：
file = "file_test.txt"
file_name = os.path.splitext(file)[0] # ``输出：``file_test
file_suffix = os.path.splitext(file)[1] # ``输出：``.txt
判断文件或目录是否存在
os.path.exists()：
判断是否是文件
os.path.isfile()：
判断是否是目录
os.path.isdir()：
获取当前文件所在的目录，即父目录
os.path.dirname()：
创建多级目录
os.makedirs()：
创建单级目录
os.mkdir()：
获取文件大小
os.path.getsize()：
路径相同重命名文件或目录，从 src 到 dst，路径不同移动
若是路径不同还文件名字也不同这是吧src的文件，移动并重命名到dst中
os.rename(src, dst)
删除路径为path的文件。
如果path 是一个文件夹，将抛出OSError; 查看下面的
os.remove(path)
删除path指定的空目录，如果目录非空，则抛出一个OSError异常。
os.rmdir(path)
a文件复制到b目录
import shutil
Shutil.Copyfile(a,b)
os.getcwd() ``获取当前工作目录，即当前``python``脚本工作的目录路径`
`os.chdir("dirname") ``改变当前脚本工作目录；相当于``shell``下``cd`
`os.curdir ``返回当前目录``: ('.')`
`os.pardir ``获取当前目录的父目录字符串名：``('..')`
`os.makedirs('dirname1/dirname2') ``可生成多层递归目录`
`os.removedirs('dirname1') ``若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推`
`os.mkdir('dirname') ``生成单级目录；相当于``shell``中``mkdir dirname`
`os.rmdir('dirname') ``删除单级空目录，若目录不为空则无法删除，报错；相当于``shell``中``rmdir dirname`
`os.listdir('dirname') ``列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印`
`os.remove() ``删除一个文件`
`os.rename("oldname","newname") ``重命名文件``/``目录`
`os.stat('path/filename') ``获取文件``/``目录信息`
`os.sep ``输出操作系统特定的路径分隔符，``win``下为``"\\",Linux``下为``"/"`
`os.linesep ``输出当前平台使用的行终止符，``win``下为``"\t\n",Linux``下为``"\n"`
`os.pathsep ``输出用于分割文件路径的字符串`` win``下为``;,Linux``下为``:`
`os.name ``输出字符串指示当前使用平台。``win->'nt'; Linux->'posix'`
`os.system("bash command") ``运行``shell``命令，直接显示`
`os.environ ``获取系统环境变量`
`os.path.abspath(path) ``返回``path``规范化的绝对路径`
`os.path.split(path) ``将``path``分割成目录和文件名二元组返回`
`os.path.dirname(path) ``返回``path``的目录。其实就是``os.path.split(path)``的第一个元素`
`os.path.basename(path) ``返回``path``最后的文件名。如何``path``以／或``\``结尾，那么就会返回空值。即``os.path.split(path)``的第二个元素`
`os.path.exists(path) ``如果``path``存在，返回``True``；如果``path``不存在，返回``False`
`os.path.isabs(path) ``如果``path``是绝对路径，返回``True`
`os.path.isfile(path) ``如果``path``是一个存在的文件，返回``True``。否则返回``False`
`os.path.isdir(path) ``如果``path``是一个存在的目录，则返回``True``。否则返回``False`
`os.path.join(path1[, path2[, ...]]) ``将多个路径组合后返回，第一个绝对路径之前的参数将被忽略`
`os.path.getatime(path) ``返回``path``所指向的文件或者目录的最后存取时间`
`os.path.getmtime(path) ``返回``path``所指向的文件或者目录的最后修改时间`
`os.path.getsize(path) ``返回``path``的大小
Python OS 文件/目录方法
os 模块提供了非常丰富的方法用来处理文件和目录。常用的方法如下表所示：
| 序号 | 方法及描述 |
|---|---|
| 1 | os.access(path, mode) 检验权限模式 |
| 2 | os.chdir(path) 改变当前工作目录 |
| 3 | os.chflags(path, flags) 设置路径的标记为数字标记。 |
| 4 | os.chmod(path, mode) 更改权限 |
| 5 | os.chown(path, uid, gid) 更改文件所有者 |
| 6 | os.chroot(path) 改变当前进程的根目录 |
| 7 | os.close(fd) 关闭文件描述符 fd |
| 8 | os.closerange(fd_low, fd_high) 关闭所有文件描述符，从 fd_low (包含) 到 fd_high (不包含), 错误会忽略 |
| 9 | os.dup(fd) 复制文件描述符 fd |
| 10 | os.dup2(fd, fd2) 将一个文件描述符 fd 复制到另一个 fd2 |
| 11 | os.fchdir(fd) 通过文件描述符改变当前工作目录 |
| 12 | os.fchmod(fd, mode) 改变一个文件的访问权限，该文件由参数fd指定，参数mode是Unix下的文件访问权限。 |
| 13 | os.fchown(fd, uid, gid) 修改一个文件的所有权，这个函数修改一个文件的用户ID和用户组ID，该文件由文件描述符fd指定。 |
| 14 | os.fdatasync(fd) 强制将文件写入磁盘，该文件由文件描述符fd指定，但是不强制更新文件的状态信息。 |
| 15 | [os.fdopen(fd, mode[, bufsize]]) 通过文件描述符 fd 创建一个文件对象，并返回这个文件对象 |
| 16 | os.fpathconf(fd, name) 返回一个打开的文件的系统配置信息。name为检索的系统配置的值，它也许是一个定义系统值的字符串，这些名字在很多标准中指定（POSIX.1, Unix 95, Unix 98, 和其它）。 |
| 17 | os.fstat(fd) 返回文件描述符fd的状态，像stat()。 |
| 18 | os.fstatvfs(fd) 返回包含文件描述符fd的文件的文件系统的信息，像 statvfs() |
| 19 | os.fsync(fd) 强制将文件描述符为fd的文件写入硬盘。 |
| 20 | os.ftruncate(fd, length) 裁剪文件描述符fd对应的文件, 所以它最大不能超过文件大小。 |
| 21 | os.getcwd() 返回当前工作目录 |
| 22 | os.getcwdu() 返回一个当前工作目录的Unicode对象 |
| 23 | os.isatty(fd) 如果文件描述符fd是打开的，同时与tty(-like)设备相连，则返回true, 否则False。 |
| 24 | os.lchflags(path, flags) 设置路径的标记为数字标记，类似 chflags()，但是没有软链接 |
| 25 | os.lchmod(path, mode) 修改连接文件权限 |
| 26 | os.lchown(path, uid, gid) 更改文件所有者，类似 chown，但是不追踪链接。 |
| 27 | os.link(src, dst) 创建硬链接，名为参数 dst，指向参数 src |
| 28 | os.listdir(path) 返回path指定的文件夹包含的文件或文件夹的名字的列表。 |
| 29 | os.lseek(fd, pos, how) 设置文件描述符 fd当前位置为pos, how方式修改: SEEK_SET 或者 0 设置从文件开始的计算的pos; SEEK_CUR或者 1 则从当前位置计算; os.SEEK_END或者2则从文件尾部开始. 在unix，Windows中有效 |
| 30 | os.lstat(path) 像stat(),但是没有软链接 |
| 31 | os.major(device) 从原始的设备号中提取设备major号码 (使用stat中的st_dev或者st_rdev field)。 |
| 32 | os.makedev(major, minor) 以major和minor设备号组成一个原始设备号 |
| 33 | [os.makedirs(path, mode]) 递归文件夹创建函数。像mkdir(), 但创建的所有intermediate-level文件夹需要包含子文件夹。 |
| 34 | os.minor(device) 从原始的设备号中提取设备minor号码 (使用stat中的st_dev或者st_rdev field )。 |
| 35 | [os.mkdir(path, mode]) 以数字mode的mode创建一个名为path的文件夹.默认的 mode 是 0777 (八进制)。 |
| 36 | [os.mkfifo(path, mode]) 创建命名管道，mode 为数字，默认为 0666 (八进制) |
| 37 | [os.mknod(filename, mode=0600, device]) 创建一个名为filename文件系统节点（文件，设备特别文件或者命名pipe）。 |
| 38 | [os.open(file, flags, mode]) 打开一个文件，并且设置需要的打开选项，mode参数是可选的 |
| 39 | os.openpty() 打开一个新的伪终端对。返回 pty 和 tty的文件描述符。 |
| 40 | os.pathconf(path, name) 返回相关文件的系统配置信息。 |
| 41 | os.pipe() 创建一个管道. 返回一对文件描述符(r, w) 分别为读和写 |
| 42 | [os.popen(command, mode[, bufsize]]) 从一个 command 打开一个管道 |
| 43 | os.read(fd, n) 从文件描述符 fd 中读取最多 n 个字节，返回包含读取字节的字符串，文件描述符 fd对应文件已达到结尾, 返回一个空字符串。 |
| 44 | os.readlink(path) 返回软链接所指向的文件 |
| 45 | os.remove(path) 删除路径为path的文件。如果path 是一个文件夹，将抛出OSError; 查看下面的rmdir()删除一个 directory。 |
| 46 | os.removedirs(path) 递归删除目录。 |
| 47 | os.rename(src, dst) 重命名文件或目录，从 src 到 dst |
| 48 | os.renames(old, new) 递归地对目录进行更名，也可以对文件进行更名。 |
| 49 | os.rmdir(path) 删除path指定的空目录，如果目录非空，则抛出一个OSError异常。 |
| 50 | os.stat(path) 获取path指定的路径的信息，功能等同于C API中的stat()系统调用。 |
| 51 | [os.stat_float_times(newvalue]) 决定stat_result是否以float对象显示时间戳 |
| 52 | os.statvfs(path) 获取指定路径的文件系统统计信息 |
| 53 | os.symlink(src, dst) 创建一个软链接 |
| 54 | os.tcgetpgrp(fd) 返回与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组 |
| 55 | os.tcsetpgrp(fd, pg) 设置与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组为pg。 |
| 56 | [os.tempnam(dir[, prefix]]) 返回唯一的路径名用于创建临时文件。 |
| 57 | os.tmpfile() 返回一个打开的模式为(w+b)的文件对象 .这文件对象没有文件夹入口，没有文件描述符，将会自动删除。 |
| 58 | os.tmpnam() 为创建一个临时文件返回一个唯一的路径 |
| 59 | os.ttyname(fd) 返回一个字符串，它表示与文件描述符fd 关联的终端设备。如果fd 没有与终端设备关联，则引发一个异常。 |
| 60 | os.unlink(path) 删除文件路径 |
| 61 | os.utime(path, times) 返回指定的path文件的访问和修改的时间。 |
| 62 | [os.walk(top, topdown=True[, onerror=None[, followlinks=False]]]) 输出在文件夹中的文件名通过在树中游走，向上或者向下。 |
| 63 | os.write(fd, str) 写入字符串到文件描述符 fd中. 返回实际写入的字符串长度 |
| 64 | os.path 模块 获取文件的属性信息。 |
re正则
2021年11月27日
14:50
数量词的贪婪模式与非贪婪模式
正则表达式通常用于在文本中查找匹配的字符串。Python里数量词默认是贪婪的（在少数语言里也可能是默认非贪婪），总是尝试匹配尽可能多的字符；非贪婪的则相反，总是尝试匹配尽可能少的字符。
compile 函数
compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用。
语法格式为：
re.compile(pattern[, flags])
参数：
- pattern : 一个字符串形式的正则表达式
- flags 可选，表示匹配模式，比如忽略大小写，多行模式等
re.match函数
re.match ``尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，``match()``就返回``none``。
函数语法：
re.match(pattern, string, flags=0)
函数参数说明：
参数 |
描述 |
|---|---|
pattern |
匹配的正则表达式 |
string |
要匹配的字符串。 |
flags |
标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表达式修饰符 - 可选标志 |
匹配成功re.match方法返回一个匹配的对象，否则返回None。
我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。
| 匹配对象方法 | 描述 |
|---|---|
| group(num=0) | 匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。 |
| groups() | 返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。 |
匹配对象
group（id） 获取给定子模式（组的匹配项）
start（id） 返回给定组的匹配项的起始位置
end（id） 返回给定组的匹配项的结束位置
span（id） 返回一个组的起始和结束位置
import re
m = re.match(r'(http://www|WWW).(.*)..{3}', 'http://www.python.org')
print('输出匹配到的字符串')
print(m.group())
print('匹配第一个圆括号中的内容')
print(m.group(1))
print('匹配第二个圆括号中的内容')
print(m.group(2))
print('输出第一组字符串的起始位置')
print(m.start(1))
print('输出第二组字符串的起始位置')
print(m.start(2))
print('输出字符串的结束位置')
print(m.end(0))
print('输出第一个的起始和结束位置')
print(m.span(1))
re.search方法
re.search 扫描整个字符串并返回第一个成功的匹配。
函数语法：
re.search(pattern, string, flags=0)
检索和替换
Python 的re模块提供了re.sub用于替换字符串中的匹配项。
语法：
re.sub(pattern, repl, string, count=0, flags=0)
参数：
- pattern : 正则中的模式字符串。
- repl : 替换的字符串，也可为一个函数。
- string : 要被查找替换的原始字符串。
- count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
- flags : 编译时用的匹配模式，数字形式。
re.subn(pattern, repl, string, count=0, flags=0)
返回替换后的值，和替换了几次
findall
在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果有多个匹配模式，则返回元组列表，如果没有找到匹配的，则返回空列表。
注意： match 和 search 是匹配一次 findall 匹配所有。
语法格式为：
re.findall(pattern, string, flags=0)
或
pattern.findall(string[, pos[, endpos]])
参数：
- pattern 匹配模式。
- string 待匹配的字符串。
- pos 可选参数，指定字符串的起始位置，默认为 0。
- endpos 可选参数，指定字符串的结束位置，默认为字符串的长度。
re.finditer
和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。
re.finditer(pattern, string, flags=0)
re.split
split 方法按照能够匹配的子串将字符串分割后返回列表，它的使用形式如下：
re.split(pattern, string[, maxsplit=0, flags=0])
参数：
| 参数 | 描述 |
|---|---|
| pattern | 匹配的正则表达式 |
| string | 要匹配的字符串。 |
| maxsplit | 分割次数，maxsplit=1 分割一次，默认为 0，不限制次数。 |
| flags | 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表达式修饰符 - 可选标志 |
正则表达式对象
re.RegexObject
re.compile() 返回 RegexObject 对象。
re.MatchObject
特殊字符
所谓特殊字符，就是一些有特殊含义的字符，如上面说的 runoo*b 中的 ***，简单的说就是表示任何字符串的意思。如果要查找字符串中的 ***** 符号，则需要对 ***** 进行转义，即在其前加一个 **，runo*ob 匹配字符串 runo*ob。
许多元字符要求在试图匹配它们时特别对待。若要匹配这些特殊字符，必须首先使字符"转义"，即，将反斜杠字符**** 放在它们前面。下表列出了正则表达式中的特殊字符：
| 特别字符 | 描述 |
|---|---|
| $ | 匹配输入字符串的结尾位置。如果设置了 RegExp 对象的 Multiline 属性，则 $ 也匹配 '\n' 或 '\r'。要匹配 $ 字符本身，请使用 $。 |
| ( ) | 标记一个子表达式的开始和结束位置。子表达式可以获取供以后使用。要匹配这些字符，请使用 ( 和 )。 |
| * | 匹配前面的子表达式零次或多次。要匹配 * 字符，请使用 *。 |
| + | 匹配前面的子表达式一次或多次。要匹配 + 字符，请使用 +。 |
| . | 匹配除换行符 \n 之外的任何单字符。要匹配 . ，请使用 . 。 |
| [ | 标记一个中括号表达式的开始。要匹配 [，请使用 [。 |
| ? | 匹配前面的子表达式零次或一次，或指明一个非贪婪限定符。要匹配 ? 字符，请使用 ?。 |
| \ | 将下一个字符标记为或特殊字符、或原义字符、或向后引用、或八进制转义符。例如， 'n' 匹配字符 'n'。'\n' 匹配换行符。序列 '\' 匹配 ""，而 '(' 则匹配 "("。 |
| ^ | 匹配输入字符串的开始位置，除非在方括号表达式中使用，当该符号在方括号表达式中使用时，表示不接受该方括号表达式中的字符集合。要匹配 ^ 字符本身，请使用 ^。 |
| { | 标记限定符表达式的开始。要匹配 {，请使用 {。 |
| | | 指明两项之间的一个选择。要匹配 |，请使用 |。 |
正则表达式修饰符 - 可选标志
正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位`` OR(|) ``它们来指定。如`` re.I | re.M ``被设置成`` I ``和`` M ``标志：
修饰符 |
描述 |
|---|---|
re.I |
使匹配对大小写不敏感 |
re.L |
做本地化识别（``locale-aware``）匹配 |
re.M |
多行匹配，影响`` ^ ``和`` $ |
re.S |
使`` . ``匹配包括换行在内的所有字符 |
re.U |
根据``Unicode``字符集解析字符。这个标志影响`` \w, \W, \b, \B. |
re.X |
该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。 |
正则表达式模式
模式字符串使用特殊的语法来表示一个正则表达式：
字母和数字表示他们自身。一个正则表达式模式中的字母和数字匹配同样的字符串。
多数字母和数字前加一个反斜杠时会拥有不同的含义。
标点符号只有被转义时才匹配自身，否则它们表示特殊的含义。
反斜杠本身需要使用反斜杠转义。
| 模式 | 描述 |
|---|---|
^ |
匹配字符串的开头 |
$ |
匹配字符串的末尾。 |
. |
匹配任意字符，除了换行符，当``re.DOTALL``标记被指定时，则可以匹配包括换行符的任意字符。 |
[...] |
用来表示一组字符``,``单独列出：``[amk] ``匹配`` 'a'``，``'m'``或``'k' |
[^...] |
不在``[]``中的字符：``[^abc] ``匹配除了``a,b,c``之外的字符。 |
re* |
匹配``0``个或多个的表达式。 |
re+ |
匹配``1``个或多个的表达式。 |
re? |
匹配``0``个或``1``个由前面的正则表达式定义的片段，非贪婪方式 |
re{ n} |
精确匹配`` n ``个前面表达式。例如，`` ``o{2}`` ``不能匹配`` "Bob" ``中的`` "o"``，但是能匹配`` "food" ``中的两个`` o``。 |
re{ n,} |
匹配`` n ``个前面表达式。例如，`` o{2,} ``不能匹配``"Bob"``中的``"o"``，但能匹配`` "foooood"``中的所有`` o``。``"o{1,}" ``等价于`` "o+"``。``"o{0,}" ``则等价于`` "o*"``。 |
re{ n, m} |
匹配`` n ``到`` m ``次由前面的正则表达式定义的片段，贪婪方式 |
| `a | b` |
(re) |
对正则表达式分组并记住匹配的文本 |
(?imx) |
正则表达式包含三种可选标志：``i, m, ``或`` x ``。只影响括号中的区域。 |
(?-imx) |
正则表达式关闭`` i, m, ``或`` x ``可选标志。只影响括号中的区域。 |
(?: re) |
类似`` (...), ``但是不表示一个组 |
(?imx: re) |
在括号中使用``i, m, ``或`` x ``可选标志 |
(?-imx: re) |
在括号中不使用``i, m, ``或`` x ``可选标志 |
(?#...) |
注释``. |
(?= re) |
前向肯定界定符。如果所含正则表达式，以`` ... ``表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。 |
(?! re) |
前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功 |
(?> re) |
匹配的独立模式，省去回溯。 |
\w |
匹配字母数字及下划线 |
\W |
匹配非字母数字及下划线 |
\s |
匹配任意空白字符，等价于`` ``[ \t\n\r\f]``。 |
\S |
匹配任意非空字符 |
\d |
匹配任意数字，等价于`` [0-9]. |
\D |
匹配任意非数字 |
\A |
匹配字符串开始 |
\Z |
匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。 |
\z |
匹配字符串结束 |
\G |
匹配最后匹配完成的位置。 |
\b |
匹配一个单词边界，也就是指单词和空格间的位置。例如，`` 'er\b' ``可以匹配``"never" ``中的`` 'er'``，但不能匹配`` "verb" ``中的`` 'er'``。 |
\B |
匹配非单词边界。``'er\B' ``能匹配`` "verb" ``中的`` 'er'``，但不能匹配`` "never" ``中的`` 'er'``。 |
\n, \t, ``等``. |
匹配一个换行符。匹配一个制表符。等 |
\1...\9 |
匹配第``n``个分组的内容。 |
\10 |
匹配第``n``个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。 |
正则表达式实例
实例 |
描述 |
|---|---|
[Pp]ython |
匹配`` "Python" ``或`` "python" |
rub[ye] |
匹配`` "ruby" ``或`` "rube" |
[aeiou] |
匹配中括号内的任意一个字母 |
[0-9] |
匹配任何数字。类似于`` [0123456789] |
[a-z] |
匹配任何小写字母 |
[A-Z] |
匹配任何大写字母 |
[a-zA-Z0-9] |
匹配任何字母及数字 |
[^aeiou] |
除了``aeiou``字母以外的所有字符 |
[^0-9] |
匹配除了数字外的字符 |
特殊字符类
| 实例 | 描述 |
|---|---|
. |
匹配除`` "\n" ``之外的任何单个字符。要匹配包括`` '\n' ``在内的任何字符，请使用象`` '[.\n]' ``的模式。 |
\d |
匹配一个数字字符。等价于`` [0-9]``。 |
\D |
匹配一个非数字字符。等价于`` [^0-9]``。 |
\s |
匹配任何空白字符，包括空格、制表符、换页符等等。等价于`` [ \f\n\r\t\v]``。 |
\S |
匹配任何非空白字符。等价于`` [^ \f\n\r\t\v]``。 |
\w |
匹配包括下划线的任何单词字符。等价于``'[A-Za-z0-9_]'``。 |
\W |
匹配任何非单词字符。等价于`` '[^A-Za-z0-9_]'``。 |
案例
特殊符号替换：``re.sub(`` r'[-,$()#+&*]'``," ooo ",str)
表达式
一、校验数字的表达式
1. ``数字：``^[0-9]*$
2. n``位的数字：``^\d{n}$
3. ``至少``n``位的数字：``^\d{n,}$
4. m-n``位的数字：``^\d{m,n}$
5. ``零和非零开头的数字：``^(0|[1-9][0-9]*)$
6. ``非零开头的最多带两位小数的数字：``^([1-9][0-9]*)+(.[0-9]{1,2})?$
7. ``带``1-2``位小数的正数或负数：``^(\-)?\d+(\.\d{1,2})?$
8. ``正数、负数、和小数：``^(\-|\+)?\d+(\.\d+)?$
9. ``有两位小数的正实数：``^[0-9]+(.[0-9]{2})?$
10. ``有``1~3``位小数的正实数：``^[0-9]+(.[0-9]{1,3})?$
11. ``非零的正整数：``^[1-9]\d*$ ``或`` ^([1-9][0-9]*){1,3}$ ``或`` ^\+?[1-9][0-9]*$
12. ``非零的负整数：``^\-[1-9][]0-9"*$ ``或`` ^-[1-9]\d*$
13. ``非负整数：``^\d+$ ``或`` ^[1-9]\d*|0$
14. ``非正整数：``^-[1-9]\d*|0$ ``或`` ^((-\d+)|(0+))$
15. ``非负浮点数：``^\d+(\.\d+)?$ ``或`` ^[1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0$
16. ``非正浮点数：``^((-\d+(\.\d+)?)|(0+(\.0+)?))$ ``或``
^(-([1-9]\d*\.\d*|0\.\d*[1-9]\d*))|0?\.0+|0$
17. ``正浮点数：``^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$ ``或`` ^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$
18. ``负浮点数：``^-([1-9]\d*\.\d*|0\.\d*[1-9]\d*)$ ``或`` ^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$
19. ``浮点数：``^(-?\d+)(\.\d+)?$ ``或`` ^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0)$
二、校验字符的表达式
1. ``汉字：``^[\u4e00-\u9fa5]{0,}$
2. ``英文和数字：``^[A-Za-z0-9]+$ ``或`` ^[A-Za-z0-9]{4,40}$
3. ``长度为``3-20``的所有字符：``^.{3,20}$
4. ``由``26``个英文字母组成的字符串：``^[A-Za-z]+$
5. ``由``26``个大写英文字母组成的字符串：``^[A-Z]+$
6. ``由``26``个小写英文字母组成的字符串：``^[a-z]+$
7. ``由数字和``26``个英文字母组成的字符串：``^[A-Za-z0-9]+$
8. ``由数字、``26``个英文字母或者下划线组成的字符串：``^\w+$ ``或`` ^\w{3,20}$
9. ``中文、英文、数字包括下划线：``^[\u4E00-\u9FA5A-Za-z0-9_]+$
10. ``中文、英文、数字但不包括下划线等符号：``^[\u4E00-\u9FA5A-Za-z0-9]+$
``或`` ^[\u4E00-\u9FA5A-Za-z0-9]{2,20}$
11. ``可以输入含有``^%&',;=?$\"``等字符：``[^%&',;=?$\x22]+ 12
``禁止输入含有``~``的字符：``[^~\x22]+
三、特殊需求表达式
1. Email``地址：
^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$
2. ``域名：
[a-zA-Z0-9][-a-zA-Z0-9]{0,62}(/.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+/.?
3. InternetURL``：
[a-zA-z]+://[^\s]* ``或`` ^http://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$
4. ``手机号码：
^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}$
5. ``电话号码
("XXX-XXXXXXX"``、``"XXXX-XXXXXXXX"``、``"XXX-XXXXXXX"``、
"XXX-XXXXXXXX"``、``"XXXXXXX"``和``"XXXXXXXX)``：
^(\(\d{3,4}-)|\d{3.4}-)?\d{7,8}$
6. ``国内电话号码``(0511-4405222``、``021-87888822)``：
\d{3}-\d{8}|\d{4}-\d{7}
7. ``身份证号``(15``位、``18``位数字``)``：
^\d{15}|\d{18}$
8. ``短身份证号码``(``数字、字母``x``结尾``)``：
^([0-9]){7,18}(x|X)?$
或`` ^\d{8,18}|[0-9x]{8,18}|[0-9X]{8,18}?$
9. ``帐号是否合法``(``字母开头，允许``5-16``字节，允许字母数字下划线``)``：
^[a-zA-Z][a-zA-Z0-9_]{4,15}$
10. ``密码``(``以字母开头，长度在``6~18``之间，只能包含字母、数字和下划线``)``：
^[a-zA-Z]\w{5,17}$
11. ``强密码``(``必须包含大小写字母和数字的组合，不能使用特殊字符，长度在``8-10``之间``)``：
^(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{8,10}$
12. ``日期格式：
^\d{4}-\d{1,2}-\d{1,2}
13. ``一年的``12``个月``(01``～``09``和``1``～``12)``：
^(0?[1-9]|1[0-2])$
14. ``一个月的``31``天``(01``～``09``和``1``～``31)``：
^((0?[1-9])|((1|2)[0-9])|30|31)$
15. ``钱的输入格式：
- 1.有四种钱的表示形式我们可以接受:"10000.00" 和 "10,000.00", 和没有 "分" 的 "10000" 和 "10,000"：
^[1-9][0-9]*$
- \17. 2.这表示任意一个不以0开头的数字,但是,这也意味着一个字符"0"不通过,所以我们采用下面的形式：
^(0|[1-9][0-9]*)$
- 一个0或者一个不以0开头的数字.我们还可以允许开头有一个负号：
^(0|-?[1-9][0-9]*)$
- 这表示一个0或者一个可能为负的开头不为0的数字.让用户以0开头好了.把负号的也去掉,因为钱总不能是负的吧.下面我们要加的是说明可能的小数部分：
^[0-9]+(.[0-9]+)?$
- .必须说明的是,小数点后面至少应该有1位数,所以"10."是不通过的,但是 "10" 和 "10.2" 是通过的：
^[0-9]+(.[0-9]{2})?$
- .这样我们规定小数点后面必须有两位,如果你认为太苛刻了,可以这样：
^[0-9]+(.[0-9]{1,2})?$
- 这样就允许用户只写一位小数.下面我们该考虑数字中的逗号了,我们可以这样：
^[0-9]{1,3}(,[0-9]{3})*(.[0-9]{1,2})?$
- 1到3个数字,后面跟着任意个 逗号+3个数字,逗号成为可选,而不是必须：
^([0-9]+|[0-9]{1,3}(,[0-9]{3})*)(.[0-9]{1,2})?$
``备注：这就是最终结果了``,``别忘了``"+"``可以用``"*"``替代如果你觉得空字符串也可以接受的话``(``奇怪``,``为什么``?)``最后``,``别忘了在用函数时去掉去掉那个反斜杠``,``一般的错误都在这里
25. xml``文件：
^([a-zA-Z]+-?)+[a-zA-Z0-9]+\\.[x|X][m|M][l|L]$
26. ``中文字符的正则表达式：
[\u4e00-\u9fa5]
27. ``双字节字符：
[^\x00-\xff]
(``包括汉字在内，可以用来计算字符串的长度``(``一个双字节字符长度计``2``，``ASCII``字符计``1))
28. ``空白行的正则表达式：
\n\s*\r (``可以用来删除空白行``)
29. HTML``标记的正则表达式：
<(\S*?)[^>]*>.*?</\1>|<.*? />
(``网上流传的版本太糟糕，上面这个也仅仅能部分，对于复杂的嵌套标记依旧无能为力``)
30. ``首尾空白字符的正则表达式：
^\s*|\s*$``或``(^\s*)|(\s*$)
(``可以用来删除行首行尾的空白字符``(``包括空格、制表符、换页符等等``)``，非常有用的表达式``)
31. ``腾讯``QQ``号：
[1-9][0-9]{4,}
(``腾讯``QQ``号从``10000``开始``)
32. ``中国邮政编码：
[1-9]\d{5}(?!\d) (``中国邮政编码为``6``位数字``)
33.`` ``IP``地址：
\d+\.\d+\.\d+\.\d+ (``提取``IP``地址时有用``)
34. IP``地址：
((?:(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d))
=
json模块&pickle
2022年7月14日
9:57
json
如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。
JSON表示的对象就是标准的JavaScript语言的对象，JSON和Python内置的数据类型对应如下：
|
|
|---|---|
json序列化
json.dumps(''内容")
json反序列化
json.loads(''内容")
json验证：
json格式只能兼容所有语言通用的数据类型，不能兼容某一种语言特定的数据类型
json强调：json格式有它的要求，如json 不认单引号，不要混淆
注意：
import json`
`#dct="{'1':111}"#json ``不认单引号`
`#dct=str({"1":111})#``报错``,``因为生成的数据还是单引号``:{'one': 1}`
`dct='{"1":"111"}'print(json.loads(dct))
#conclusion:`
`# ``无论数据是怎样创建的，只要满足``json``格式，就可以``json.loads``出来``,``不一定非要``dumps``的数据才能``loads
# 一.什么是猴子补丁?
属性在运行时的动态替换，叫做猴子补丁（``Monkey Patch``）。
猴子补丁的核心就是用自己的代码替换所用模块的源代码，详细地如下
1``，这个词原来为Guerrilla Patch，杂牌军、游击队，说明这部分不是原装的，在英文里guerilla发音和gorllia(猩猩)相似，再后来就写了monkey(猴子)。
2``，还有一种解释是说由于这种方式将原来的代码弄乱了(messing with it)，在英文里叫monkeying about(顽皮的)，所以叫做Monkey Patch。
# 二. 猴子补丁的功能(一切皆对象)
1.``拥有在模块运行时替换的功能, 例如: 一个函数对象赋值给另外一个函数对象(把函数原本的执行的功能给替换了)
# 三.monkey patch的应用场景
如果我们的程序中已经基于``json``模块编写了大量代码了，发现有一个模块``ujson``比它性能更高，但用法一样，我们肯定不会想所有的代码都换成``ujson.dumps``或者``ujson.loads,
那我们可能会想到这么做`
`import ujson as json``，但是这么做的需要每个文件都重新导入一下，维护成本依然很高
此时我们就可以用到猴子补丁了只需要在入口处加上
import json`
`import ujson
def monkey_patch_json():`
` json.__name__= 'ujson'`
` json.dumps = ujson.dumps`
` json.loads = ujson.loads
monkey_patch_json() # ``之所以在入口处加，是因为模块在导入一次后，后续的导入便直接引用第一次的成果
#``其实这种场景也比较多, 比如我们引用团队通用库里的一个模块, 又想丰富模块的功能, 除了继承之外也可以考虑用MonkeyPatch.采用猴子补丁之后，如果发现ujson不符合预期，那也可以快速撤掉补丁。个人感觉Monkey`
`Patch``带了便利的同时也有搞乱源代码的风险!
Pickle
用法和json一样
注意``：``Pickle``的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于``Python``，并且可能不同版本的``Python``彼此都不兼容，因此，只能用``Pickle``保存那些不重要的数据，不能成功地反序列化也没关系。``
Shelve
shelve模块比pickle模块简单，只有一个open函数，返回类似字典的对象，可读可写;key必须为字符串，而值可以是python所支持的数据类型
import shelve
f=shelve.open(r'sheve.txt')`
`# f['stu1_info']={'name':'egon','age':18,'hobby':['piao','smoking','drinking']}`
`# f['stu2_info']={'name':'gangdan','age':53}`
`# f['school_info']={'website':'http://www.pypy.org','city':'beijing'}print(f['stu1_info']['hobby'])`
`f.close()
Faker模块
2022年6月17日
20:38
Faker
随机生成信息
1. 安装
pip install Faker
2. 简单使用
>>> from faker import Faker
>>> fake = Faker(locale='zh_CN')
>>> fake.name()
'``李洁``'
>>> fake.address()
'``上海市兴安盟县江北东莞路``r``座`` 803484'
参数 locale：为生成数据的文化选项（语种），默认为 en_US，只有使用了相关文化，才能生成相对应的随机信息
常见的文化选项：
zh_CN - Chinese (China Mainland)
zh_TW - Chinese (China Taiwan)
en_US - English (United States)
3. 其他方法
3.1 地理信息类
city_suffix() # ``市，县
country() # ``国家
country_code() # ``国家编码
district() # ``区
geo_coordinate() # ``地理坐标
latitude() # ``地理坐标``(``纬度``)
longitude() # ``地理坐标``(``经度``)
postcode() # ``邮编
province() # ``省份
address() # ``详细地址
street_address() # ``街道地址
street_name() # ``街道名
street_suffix() # ``街、路
3.2 基础信息类
ssn() # ``生成身份证号
bs() # ``随机公司服务名
company() # ``随机公司名（长）
company_prefix() # ``随机公司名（短）
company_suffix() # ``公司性质，如``'``信息有限公司``'
credit_card_expire() # ``随机信用卡到期日，如``'03/30'
credit_card_full() # ``生成完整信用卡信息
credit_card_number() # ``信用卡号
credit_card_provider() # ``信用卡类型
credit_card_security_code() # ``信用卡安全码
job() # ``随机职位
first_name_female() # ``女性名
first_name_male() # ``男性名
name() # ``随机生成全名
name_female() # ``男性全名
name_male() # ``女性全名
phone_number() # ``随机生成手机号
phonenumber_prefix() # ``随机生成手机号段，如``139
3.3 邮箱信息类
ascii_company_email() # ``随机``ASCII``公司邮箱名
ascii_email() # ``随机``ASCII``邮箱`` #
company_email() # ``公司邮箱
email() # ``普通邮箱
safe_email() # ``安全邮箱
3.4 ``网络基础信息类
domain_name() # ``生成域名
domain_word() # ``域词``(``即，不包含后缀``)
ipv4() # ``随机``IP4``地址
ipv6() # ``随机``IP6``地址
mac_address() # ``随机``MAC``地址
tld() # ``网址域名后缀``(.com,.net.cn,``等等，不包括``.)
uri() # ``随机``URI``地址
uri_extension() # ``网址文件后缀
uri_page() # ``网址文件（不包含后缀）
uri_path() # ``网址文件路径（不包含文件名）
url() # ``随机``URL``地址
user_name() # ``随机用户名
image_url() # ``随机``URL``地址
3.5 浏览器信息类
chrome() # ``随机生成``Chrome``的浏览器``user_agent``信息
firefox() # ``随机生成``FireFox``的浏览器``user_agent``信息
internet_explorer() # ``随机生成``IE``的浏览器``user_agent``信息
opera() # ``随机生成``Opera``的浏览器``user_agent``信息
safari() # ``随机生成``Safari``的浏览器``user_agent``信息
linux_platform_token() # ``随机``Linux``信息
user_agent() # ``随机``user_agent``信息
3.6 数字信息
numerify() # ``三位随机数字
random_digit() # 0~9``随机数
random_digit_not_null() # 1~9``的随机数
random_int() # ``随机数字，默认``0~9999``，可以通过设置``min,max``来设置
random_number() # ``随机数字，参数``digits``设置生成的数字位数
pyfloat() # ``随机``Float``数字
pyint() # ``随机``Int``数字（参考``random_int()``参数）
pydecimal() # ``随机``Decimal``数字（参考``pyfloat``参数）
3.7 文本加密类
pystr() # ``随机字符串
random_element() # ``随机字母
random_letter() # ``随机字母
paragraph() # ``随机生成一个段落
paragraphs() # ``随机生成多个段落
sentence() # ``随机生成一句话
sentences() # ``随机生成多句话，与段落类似
text() # ``随机生成一篇文章
word() # ``随机生成词语
words() # ``随机生成多个词语，用法与段落，句子，类似
binary() # ``随机生成二进制编码
boolean() # True/False
language_code() # ``随机生成两位语言编码
locale() # ``随机生成语言``/``国际 信息
md5() # ``随机生成``MD5
null_boolean() # NULL/True/False
password() # ``随机生成密码``,``可选参数`` # length # ``密码长度；``special_chars # ``是否能使用特殊字符；``digits # ``是否包含数字；``upper_case # ``是否包含大写字母；``lower_case # ``是否包含小写字母
sha1() # ``随机``SHA1
sha256() # ``随机``SHA256
uuid4() # ``随机``UUID
3.8 时间信息类
date() # ``随机日期
date_between() # ``随机生成指定范围内日期，参数`` # start_date``，``end_date
date_between_dates() # ``随机生成指定范围内日期，用法同上
date_object() # ``随机生产从``1970-1-1``到指定日期的随机日期。
date_time() # ``随机生成指定时间（``1970``年``1``月``1``日至今）
date_time_ad() # ``生成公元``1``年到现在的随机时间
date_time_between() # ``用法同``dates
future_date() # ``未来日期
future_datetime() # ``未来时间
month() # ``随机月份
month_name() # ``随机月份（英文）
past_date() # ``随机生成已经过去的日期
past_datetime() # ``随机生成已经过去的时间
time() # ``随机``24``小时时间
timedelta() # ``随机获取时间差
time_object() # ``随机``24``小时时间，``time``对象
time_series() # ``随机``TimeSeries``对象
timezone() # ``随机时区
unix_time() # ``随机``Unix``时间
year() # ``随机年份
4. 实战使用
在数据库建一张表，通过``Faker``造数据，插入到表中。并且打印``Faker``造的数据。
import pymysql
from faker import Faker
conn = pymysql.connect(host="114.215.129.166", port=3306, user="nice", password="", db="flask201",
charset="utf8")
cursor = conn.cursor()
sql1 = """drop table if exists faker_user"""
sql2 = """
create table faker_user(
pid int primary key auto_increment,
username varchar(20),
password varchar(20),
address varchar(35)
)
"""
cursor.execute(sql1)
cursor.execute(sql2)
fake = Faker("zh-CN")
for i in range(20):
sql = """insert into faker_user(username,password,address)
values('%s','%s','%s')""" % (fake.name(), fake.password(special_chars=False), fake.address())
cursor.execute(sql)
conn.commit()
cursor.close()
conn.close()
configparser****模块
2022年7月14日
11:14
配置文件如下：
# ``注释``1; ``注释``2
[section1]`
`k1 = v1`
`k2:v2`
`user=egon`
`age=18`
`is_admin=true`
`salary=31
[section2]`
`k1 = v1
读取
import configparser
config=configparser.ConfigParser()
config.read('a.cfg')
#``查看所有的标题
res=config.sections() #['section1', 'section2']
print(res)
#``查看标题``section1``下所有``key=value``的``key
options=config.options('section1')
print(options) #['k1', 'k2', 'user', 'age', 'is_admin', 'salary']
#``查看标题``section1``下所有``key=value``的``(key,value)``格式
item_list=config.items('section1')
print(item_list) #[('k1', 'v1'), ('k2', 'v2'), ('user', 'egon'), ('age', '18'), ('is_admin', 'true'), ('salary', '31')]
#``查看标题``section1``下``user``的值``=>``字符串格式
val=config.get('section1','user')
print(val) #egon
#``查看标题``section1``下``age``的值``=>``整数格式
val1=config.getint('section1','age')
print(val1) #18
#``查看标题``section1``下``is_admin``的值``=>``布尔值格式
val2=config.getboolean('section1','is_admin')
print(val2) #True
#``查看标题``section1``下``salary``的值``=>``浮点型格式
val3=config.getfloat('section1','salary')
print(val3) #31.0
改写
import configparser
config=configparser.ConfigParser()
config.read('a.cfg',encoding='utf-8')
#``删除整个标题``section2
config.remove_section('section2')
#``删除标题``section1``下的某个``k1``和``k2
config.remove_option('section1','k1')
config.remove_option('section1','k2')
#``判断是否存在某个标题
print(config.has_section('section1'))
#``判断标题``section1``下是否有``user
print(config.has_option('section1',''))
#``添加一个标题
config.add_section('egon')
#``在标题``egon``下添加``name=egon,age=18``的配置
config.set('egon','name','egon')
config.set('egon','age',18) #``报错``,``必须是字符串
#``最后将修改的内容写入文件``,``完成最终的修改
config.write(open('a.cfg','w'))
import configparser
config = configparser.ConfigParser()
config["DEFAULT"] = {'ServerAliveInterval': '45',
'Compression': 'yes',
'CompressionLevel': '9'}
config['bitbucket.org'] = {}
config['bitbucket.org']['User'] = 'hg'
config['topsecret.server.com'] = {}
topsecret = config['topsecret.server.com']
topsecret['Host Port'] = '50022' # mutates the parser
topsecret['ForwardX11'] = 'no' # same here
config['DEFAULT']['ForwardX11'] = 'yes'
with open('example.ini', 'w') as configfile:
config.write(configfile)
Pymysql模块
2022年5月31日
23:04
# 打开数据库连接
db = pymysql.connect("localhost","testuser","test123","TESTDB")
# 使用 cursor() 方法创建一个游标对象
cursorcursor = db.cursor(``cursor=``…)
cursor=pymysql.cursors.DictCurosr``将查询结果以字典返回
# 使用 execute() 方法执行 SQL 查询
cursor.execute(sql)
# 使用 fetchone() 方法获取单条数据.
data = cursor.fetchone()
fetchone():`` ``该方法获取下一个查询结果集。结果集是一个对象
fetchall():`` ``接收全部的返回结果行``.
fetchmany(num``）指定拿几条数据
rowcount:`` ``这是一个只读属性，并返回执行``execute()``方法后影响的行数。
关闭数据库连接要先关闭游标对象
cursorcursor.close()
db.close()
移动
corsor.scroll(1 ,'relative') 相对光标所在位置继续往后移动一位
corsor.scroll(1 ,'absolute') 相对光标起始所在位置继续往后移动一位
调用存储过程
cursor.callproc(procname，args)
procname 是存储过程的名字
args 是存储过程的参数=元组
插入
try:
# ``执行``sql``语句插入单个
cursor.execute(sql)
# ``插入多个
cursor .executemany(sql,[(),(),()``…])
# ``提交到数据库执行
db.commit()
except:
# ``如果发生错误则回滚
db.rollback()
执行事务
事务机制可以确保数据一致性。
事务应该具有4个属性：原子性、一致性、隔离性、持久性。这四个属性通常称为ACID特性。
- 原子性（atomicity）。一个事务是一个不可分割的工作单位，事务中包括的诸操作要么都做，要么都不做。
- 一致性（consistency）。事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。
- 隔离性（isolation）。一个事务的执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。
- 持久性（durability）。持续性也称永久性（permanence），指一个事务一旦提交，它对数据库中数据的改变就应该是永久性的。接下来的其他操作或故障不应该对其有任何影响。
Python DB API 2.0 的事务提供了两个方法 commit 或 rollback。
实例:
# SQL``删除记录语句`
`sql = "DELETE FROM EMPLOYEE WHERE AGE > %s" % (20)`
`try:`
` # ``执行``SQL``语句`
` cursor.execute(sql)`
` # ``向数据库提交`
` db.commit()`
`except:`
` # ``发生错误时回滚`
` db.rollback()
对于支持事务的数据库， 在Python数据库编程中，当游标建立之时，就自动开始了一个隐形的数据库事务。
commit()方法游标的所有更新操作，rollback（）方法回滚当前游标的所有操作。每一个方法都开始了一个新的事务。
错误处理
DB API中定义了一些数据库操作的错误及异常，下表列出了这些错误和异常:
Warning
当有严重警告时触发，例如插入数据是被截断等等。必须是 StandardError 的子类。
Error
警告以外所有其他错误类。必须是 StandardError 的子类。
InterfaceError
当有数据库接口模块本身的错误（而不是数据库的错误）发生时触发。 必须是Error的子类。
DatabaseError
和数据库有关的错误发生时触发。 必须是Error的子类。
DataError
当有数据处理时的错误发生时触发，例如：除零错误，数据超范围等等。 必须是DatabaseError的子类。
OperationalError
指非用户控制的，而是操作数据库时发生的错误。例如：连接意外断开、 数据库名未找到、事务处理失败、内存分配错误等等操作数据库是发生的错误。 必须是DatabaseError的子类。
IntegrityError
完整性相关的错误，例如外键检查失败等。必须是DatabaseError子类。
InternalError
数据库的内部错误，例如游标（cursor）失效了、事务同步失败等等。 必须是DatabaseError子类。
ProgrammingError
程序错误，例如数据表（table）没找到或已存在、SQL语句语法错误、 参数数量错误等等。必须是DatabaseError的子类。
NotSupportedError
不支持错误，指使用了数据库不支持的函数或API等。例如在连接对象上 使用.rollback()函数，然而数据库并不支持事务或者事务已关闭。 必须是DatabaseError的子类。
时间模块
2021年11月18日
15:33
时间的三种格式：
1.时间戳：从1970年到现在的秒数
Time. Time()
主要用于时间间隔计算
2.按照某种格式显示的时间
Time.strftime('%Y-%m-%d')
主要用于展示
3.结构化的时间
Time.localtime()
用于单独获取时间的某一部分
一、time模块
time模块中时间表现的格式主要有三种：
1、timestamp：时间戳，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量
2、struct_time：时间元组，共有九个元素组。
3、format time ：格式化时间，已格式化的结构使时间更具可读性。包括自定义格式和固定格式。
#直接生成时间元组 2>>> time.localtime()
#把时间戳转换为时间元组 5>>> time.localtime(time.time())
#把格式化时间转换为时间元组10>>> time.strptime('2017-4-8 14:12:12','%Y-%m-%d %X')
Time 模块
Time 模块包含了以下内置函数，既有时间处理的，也有转换时间格式的：
| 序号 | 函数及描述 |
|---|---|
| 1 | time.altzone 返回格林威治西部的夏令时地区的偏移秒数。如果该地区在格林威治东部会返回负值（如西欧，包括英国）。对夏令时启用地区才能使用。 |
| 2 | [time.asctime(tupletime]) 接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二18时07分14秒）的24个字符的字符串。 |
| 3 | time.clock( ) 用以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时，比time.time()更有用。 |
| 4 | [time.ctime(secs]) 作用相当于asctime(localtime(secs))，未给参数相当于asctime() |
| 5 | [time.gmtime(secs]) 接收时间戳（1970纪元后经过的浮点秒数）并返回格林威治天文时间下的时间元组t。注：t.tm_isdst始终为0 |
| 6 | [time.localtime(secs]) 接收时间戳（1970纪元后经过的浮点秒数）并返回当地时间下的时间元组t（t.tm_isdst可取0或1，取决于当地当时是不是夏令时）。 |
| 7 | time.mktime(tupletime) 接受时间元组并返回时间戳（1970纪元后经过的浮点秒数）。 |
| 8 | time.sleep(secs) 推迟调用线程的运行，secs指秒数。 |
| 9 | [time.strftime(fmt,tupletime]) 接收以时间元组，并返回以可读字符串表示的当地时间，格式由fmt决定。 |
| 10 | time.strptime(str,fmt='%a %b %d %H:%M:%S %Y') 根据fmt的格式把一个时间字符串解析为时间元组。 |
| 11 | time.time( ) 返回当前时间的时间戳（1970纪元后经过的浮点秒数）。 |
| 12 | time.tzset() 根据环境变量TZ重新初始化时间相关设置。 |
属性`` ``值
tm_year``（年）`` ``比如``2017 `
`tm_mon``（月）`` 1 - 12`
`tm_mday``（日）`` 1 - 31`
`tm_hour``（时）`` 0 - 23`
`tm_min``（分）`` 0 - 59`
`tm_sec``（秒）`` 0 - 61`
`tm_wday``（``weekday``）`` 0 - 6``（``0``表示周日）`
`tm_yday``（一年中的第几天）`` 1 - 366`
`tm_isdst``（是否是夏令时）`` ``默认为``-1
python中时间日期格式化符号：
- %y 两位数的年份表示（00-99）
- %Y 四位数的年份表示（000-9999）
- %m 月份（01-12）
- %d 月内中的一天（0-31）
- %H 24小时制小时数（0-23）
- %I 12小时制小时数（01-12）
- %M 分钟数（00-59）
- %S 秒（00-59）
- %a 本地简化星期名称
- %A 本地完整星期名称
- %b 本地简化的月份名称
- %B 本地完整的月份名称
- %c 本地相应的日期表示和时间表示
- %j 年内的一天（001-366）
- %p 本地A.M.或P.M.的等价符
- %U 一年中的星期数（00-53）星期天为星期的开始
- %w 星期（0-6），星期天为星期的开始
- %W 一年中的星期数（00-53）星期一为星期的开始
- %x 本地相应的日期表示
- %X 本地相应的时间表示
- %Z 当前时区的名称
- %% %号本身
实例
# ``格式化成``2016-03-20 11:45:39``形式``
print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
# ``格式化成``Sat Mar 28 22:24:24 2016``形式``
print time.strftime("%a %b %d %H:%M:%S %Y", time.localtime())
二、datetime模块
datatime模块重新封装了time模块，提供更多接口，提供的类有：date,time,datetime,timedelta,tzinfo。
1、date类
datetime.date(year, month, day)
静态方法和字段
date.max``、``date.min``：``date``对象所能表示的最大、最小日期；`
`date.resolution``：``date``对象表示日期的最小单位。这里是天。`
`date.today()``：返回一个表示当前本地日期的``date``对象；`
`date.fromtimestamp(timestamp)``：根据给定的时间戮，返回一个``date``对象；
方法和属性
- d1 = date(2017,4,8) #date对象（年月日都不能是以0开头 (2017,04,08)错误 ）
- d1.replace(year, month, day)：生成一个新的日期对象，用参数指定的年，月，日代替原有对象中的属性。（原有对象仍保持不变）
- d1.timetuple()：返回日期对应的time.struct_time对象；
- d1.weekday()：返回weekday，如果是星期一，返回0；如果是星期2，返回1，以此类推；
- d1.isoweekday()：返回weekday，如果是星期一，返回1；如果是星期2，返回2，以此类推；
- d1.isocalendar()：返回格式如(year，sum_week，day)的元组；
- d1.isoformat()：返回格式如'YYYY-MM-DD’的字符串；
- d1.strftime(fmt)：和time模块format相同。
可以用来去取时间的年月日
x.year, x.month, x.day
2、time类
datetime.time(hour[`` ``, minute[`` ``, second[`` ``, microsecond[`` ``, tzinfo]`` ``]`` ``]`` ``]`` ``)``
静态方法和字段
time.min``、``time.max``：``time``类所能表示的最小、最大时间
3、datetime类
datetime``相当于``date``和``time``结合起来。
datetime.datetime (year, month, day[ , hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] ] )
静态方法和字段
datetime.today()``：返回一个表示当前本地时间的``datetime``对象；`
`datetime.now([tz])``：返回一个表示当前本地时间的``datetime``对象，如果提供了参数``tz``，则获取``tz``参数所指时区的本地时间；`
`datetime.utcnow()``：返回一个当前``utc``时间的``datetime``对象；``#``格林威治时间`
`datetime.fromtimestamp(timestamp[, tz])``：根据时间戮创建一个``datetime``对象，参数``tz``指定时区信息；`
`datetime.utcfromtimestamp(timestamp)``：根据时间戮创建一个``datetime``对象；`
`datetime.combine(date, time)``：根据``date``和``time``，创建一个``datetime``对象；`
`datetime.strptime(date_string, format)``：将格式字符串转换为``datetime``对象；
阿里云—API
2022年9月19日
21:57
下载
pip install --upgrade aligo
简单使用
<br class="Apple-interchange-newline"><div></div>
"""``快速入门``"""
fromaligoimportAligo
``
if__name__=='__main__':
`` ``ali=Aligo() `` ``# ``第一次使用，会弹出二维码，供扫描登录
``
`` ``user=ali.get_user() `` ``# ``获取用户信息
`` ``print(user.user_name, user.nick_name, user.phone) `` ``# ``打印用户信息
``
`` ``ll=ali.get_file_list() `` ``# ``获取网盘根目录文件列表
`` ``forfileinll: `` ``# ``遍历文件列表
`` ``print(file.file_id, file.name, file.type) `` ``# ``打印文件信息
持久化登录、多帐户登录
ali=Aligo() `` ``# ``第一次使用，会弹出二维码，供扫描登录
网页扫码登录
from aligo import Aligo
# ``提供`` port ``参数即可``, ``之后打开浏览器访问 http://<YOUR_IP>:
ali = Aligo(port=8080)
## 发送登录二维码到邮箱（推荐）
最佳实践：建议将邮箱绑定到微信，这样能实时收到提醒，登录过期后也可以第一时间收到登录请求。
安全性问题：虽然自带公开邮箱，但是他人并不能通过这个获取任何人发送的邮件，所以 防伪字符串 策略是安全的。
```python
from aligo import Aligo
"""
email: 发送扫码登录邮件 ("接收邮件的邮箱地址", "防伪字符串"). 提供此值时，将不再弹出或打印二维码
关于防伪字符串: 为了方便大家使用, aligo 自带公开邮箱, 省去邮箱配置的麻烦.
所以收到登录邮件后, 一定要对比确认防伪字符串和你设置一致才可扫码登录, 否则将导致: 包括但不限于云盘文件泄露.
"""
# 提供 email 参数即可
ali = Aligo(email=('xxx@qq.com', '防伪字符串，可任意字符串'))
```
##
文件夹同步
在线解压缩
支持功能扩展
搜索文件/标签
获取重复文件列表
文件（夹）重命名
文件（夹）上传下载
文件（夹）移动复制
文件（夹）删除恢复
获取文档在线预览接口
文件（夹）分享 保存 收藏
文件（夹）自定义分享（无限制）
获取帐户、云盘（容量）等基本信息
相册 创建 删除 修改 添加文件 获取文件
hashlib模块
2022年7月14日
14:53
1、什么叫hash:
hash``是一种算法（``3.x``里代替了``md5``模块和``sha``模块，主要提供`` SHA1, SHA224, SHA256, SHA384, SHA512 ``，``MD5 ``算法），该算法接受传入的内容，经过运算得到一串``hash``值
# 2、hash值的特点是：
#2.1 ``只要传入的内容一样，得到的``hash``值必然一样``=====>``要用明文传输密码文件完整性校验
#2.2 ``不能由``hash``值返解成内容``=======``》把密码做成``hash``值，不应该在网络传输明文密码
#2.3 ``只要使用的``hash``算法不变，无论校验的内容有多大，得到的``hash``值长度是固定的
hash算法就像一座工厂，工厂接收你送来的原材料（可以用m.update()为工厂运送原材料），经过加工返回的产品就是hash值
import hashlib
m=hashlib.md5()# m=hashlib.sha256()
m.update('hello'.encode('utf8'))
print(m.hexdigest()) #5d41402abc4b2a76b9719d911017c592
m.update('alvin'.encode('utf8'))
print(m.hexdigest()) #92a7e713c30abbb0319fa07da2a5c4af
m2=hashlib.md5()
m2.update('helloalvin'.encode('utf8'))
print(m2.hexdigest()) #92a7e713c30abbb0319fa07da2a5c4af
'''
注意：把一段很长的数据``update``多次，与一次``update``这段长数据，得到的结果一样
但是``update``多次为校验大文件提供了可能。
'''
以上加密算法虽然依然非常厉害，但时候存在缺陷，即：通过撞库可以反解。所以，有必要对加密算法中添加自定义key再来做加密。
import hashlib
# ######## 256 ########
hash = hashlib.sha256('898oaFs09f'.encode('utf8'))
hash.update('alvin'.encode('utf8'))
print (hash.hexdigest())#e79e68f070cdedcfe63eaf1a2e92c83b4cfb1b5c6bc452d214c1b7e77cdfd1c7
动态加盐
"""
在对铭文数据做加密处理过程前添加一些变化的干扰项
"""
import hashlib
# # 1.``先确定算法类型``(md5``普遍使用``)
# md5 = hashlib.md5()
# # 2.``将明文数据传递给``md5``算法``(update``只能接受``bytes``类型数据``)
# md5.update(b'123')
# # ``加盐``(``干扰项``) ``格式为``md5.update(b'``公司内部自定义的盐``')
# md5.update(b'abc') # a906449d5769fa7361d7ecc6aa3f6d28
# # ``动态加盐``(``干扰项``) ``当前时间 用户名的部分`` uuid(``随机字符串``(``永远不会重复``))
# import time
# res1 = str(time.time())
# md5.update(res1.encode('utf8'))
# # ``真实数据
# md5.update(b'123abc')
# # 3.``获取加密之后的密文数据``(``没有规则的一串随机字符串``)
# res = md5.hexdigest()
# print(res) # 68f128bc611544f439426ceea3dae3a7
密文一致性校验
"""
文件不是很大的情况下 可以将所有的文件内容全部加密处理
但是如果文件特别大 全部加密处理相当的耗时耗资源 如何解决???
针对大文件可以使用切片读取的方式
"""
# import hashlib
# md5 = hashlib.md5()
# with open(r'a.txt','rb') as f:
# for line in f:
# md5.update(line)
# real_data = md5.hexdigest()
# print(real_data) # e5f6700043d90045f2eed3bab8e08cfa
# md5 = hashlib.md5()
# with open(r'a.txt','rb') as f:
# for line in f:
# md5.update(line)
# error_data = md5.hexdigest()
# print(error_data) # e5f6700043d90045f2eed3bab8e08cfa
#
# import os
# res = os.path.getsize(r'a.txt')
# read_method = [0,res//4,res//2,res]
logging****模块
2022年7月14日
15:35
日志命名格式：
日志名是区别日志业务归属的一种重要的标识
注：可以在日志字典中定义一个空key，这样当日志字典中找不到key时可以调用这个空key
案例：
'loggers': {
#logging.getLogger(__name__)``拿到的``logger``配置
'': {
'handlers': ['default', 'console'],
# ``这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
'level': 'DEBUG',
# loggers(``第一层日志级别关限制)--->handlers(第二层日志级别关卡限制)
'propagate': False,
# ``默认为True，向上（更高level的logger）传递，通常设置为False即可，否则会一份日志向上层层传递
},
'``专门的采集``': {
'handlers': ['other',],
'level': 'DEBUG',
'propagate': False,
},
},
日志轮转：
日志记录着程序运行过程的关键信息
案例：
'default': {
'level': 'DEBUG',
'class': 'logging.handlers.RotatingFileHandler', # ``保存到文件``,``日志轮转
'formatter': 'standard',
# ``可以定制日志文件路径
# BASE_DIR = os.path.dirname(os.path.abspath(__file__)) # log``文件的目录
# LOG_PATH = os.path.join(BASE_DIR,'a1.log')
'filename': 'a1.log', # ``日志文件
'maxBytes': 1024*1024*5, # ``日志大小`` 5M
'backupCount': 5,``# ``最多保存几份
'encoding': 'utf-8', # ``日志文件的编码，再也不用担心中文``log``乱码了
日志原理
一 日志级别
CRITICAL = 50 #FATAL = CRITICAL
ERROR = 40
WARNING = 30 #WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0 #``不设置
二 默认级别为warning，默认打印到终端
import logging
logging.debug('``调试``debug')
logging.info('``消息``info')
logging.warning('``警告``warn')
logging.error('``错误``error')
logging.critical('``严重``critical')
'''
WARNING:root:``警告``warn
ERROR:root:``错误``error
CRITICAL:root:``严重``critical
'''
三 为logging模块指定全局配置，针对所有logger有效，控制打印到文件中
可在``logging.basicConfig()``函数中通过具体参数来更改``logging``模块默认行为，可用参数有
filename``：用指定的文件名创建``FiledHandler``（后边会具体讲解``handler``的概念），这样日志会被存储在指定的文件中。
filemode``：文件打开方式，在指定了``filename``时使用这个参数，默认值为``“a”``还可指定为``“w”``。
format``：指定``handler``使用的日志显示格式。
datefmt``：指定日期时间格式。
level``：设置``rootlogger``（后边会讲解具体概念）的日志级别
stream``：用指定的``stream``创建``StreamHandler``。可以指定输出到``sys.stderr,sys.stdout``或者文件，默认为``sys.stderr``。若同时列出了``filename``和``stream``两个参数，则``stream``参数会被忽略。
#``格式
%(name)s``：``Logger``的名字，并非用户名，详细查看
%(levelno)s``：数字形式的日志级别
%(levelname)s``：文本形式的日志级别
%(pathname)s``：调用日志输出函数的模块的完整路径名，可能没有
%(filename)s``：调用日志输出函数的模块的文件名
%(module)s``：调用日志输出函数的模块名
%(funcName)s``：调用日志输出函数的函数名
%(lineno)d``：调用日志输出函数的语句所在的代码行
%(created)f``：当前时间，用``UNIX``标准的表示时间的浮 点数表示
%(relativeCreated)d``：输出日志信息时的，自``Logger``创建以 来的毫秒数
%(asctime)s``：字符串形式的当前时间。默认格式是`` “2003-07-08 16:49:45,896”``。逗号后面的是毫秒
%(thread)d``：线程``ID``。可能没有
%(threadName)s``：线程名。可能没有
%(process)d``：进程``ID``。可能没有
%(message)s``：用户输出的消息
#======介绍
可在``logging.basicConfig()``函数中可通过具体参数来更改``logging``模块默认行为，可用参数有
filename``：用指定的文件名创建``FiledHandler``（后边会具体讲解``handler``的概念），这样日志会被存储在指定的文件中。
filemode``：文件打开方式，在指定了``filename``时使用这个参数，默认值为``“a”``还可指定为``“w”``。
format``：指定``handler``使用的日志显示格式。
datefmt``：指定日期时间格式。
level``：设置``rootlogger``（后边会讲解具体概念）的日志级别
stream``：用指定的``stream``创建``StreamHandler``。可以指定输出到``sys.stderr,sys.stdout``或者文件，默认为``sys.stderr``。若同时列出了``filename``和``stream``两个参数，则``stream``参数会被忽略。
format``参数中可能用到的格式化串：
%(name)s``=`` Logger``的名字
%(levelno)s``=`` ``数字形式的日志级别
%(levelname)s``=`` ``文本形式的日志级别
%(pathname)s ``=``调用日志输出函数的模块的完整路径名，可能没有
%(filename)s ``=``调用日志输出函数的模块的文件名
%(module)s ``=``调用日志输出函数的模块名
%(funcName)s ``=``调用日志输出函数的函数名
%(lineno)d ``=``调用日志输出函数的语句所在的代码行
%(created)f ``=``当前时间，用``UNIX``标准的表示时间的浮 点数表示
%(relativeCreated)d ``=``输出日志信息时的，自``Logger``创建以 来的毫秒数
%(asctime)s ``=``字符串形式的当前时间。默认格式是`` “2003-07-08 16:49:45,896”``。逗号后面的是毫秒
%(thread)d ``=``线程``ID``。可能没有
%(threadName)s ``=``线程名。可能没有
%(process)d``=`` ``进程``ID``。可能没有
%(message)s``=``用户输出的消息
#========使用
import logging
logging.basicConfig(filename='access.log',
format='%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S %p',
level=10)
logging.debug('``调试``debug')
logging.info('``消息``info')
logging.warning('``警告``warn')
logging.error('``错误``error')
logging.critical('``严重``critical')
#========结果
access.log``内容``:
2017-07-28 20:32:17 PM - root - DEBUG -test: ``调试``debug
2017-07-28 20:32:17 PM - root - INFO -test: ``消息``info
2017-07-28 20:32:17 PM - root - WARNING -test: ``警告``warn
2017-07-28 20:32:17 PM - root - ERROR -test: ``错误``error
2017-07-28 20:32:17 PM - root - CRITICAL -test: ``严重``critical
part2: ``可以为``logging``模块指定模块级的配置``,``即所有``logger``的配置
四 logging模块的Formatter，Handler，Logger，Filter对象
原理图：``https://pan.baidu.com/s/1skWyTT7
#logger``：产生日志的对象
#Filter``：过滤日志的对象
#Handler``：接收日志然后控制打印到不同的地方，``FileHandler``用来打印到文件中，``StreamHandler``用来打印到终端
#Formatter``对象：可以定制不同的日志格式对象，然后绑定给不同的``Handler``对象使用，以此来控制不同的``Handler``的日志格式
'''
critical=50
error =40
warning =30
info = 20
debug =10
'''
import logging
#1``、``logger``对象：负责产生日志，然后交给``Filter``过滤，然后交给不同的``Handler``输出
logger=logging.getLogger(__file__)
#2``、``Filter``对象：不常用，略
#3``、``Handler``对象：接收``logger``传来的日志，然后控制输出
h1=logging.FileHandler('t1.log') #``打印到文件
h2=logging.FileHandler('t2.log') #``打印到文件
h3=logging.StreamHandler() #``打印到终端
#4``、``Formatter``对象：日志格式
formmater1=logging.Formatter('%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S %p',)
formmater2=logging.Formatter('%(asctime)s : %(message)s',
datefmt='%Y-%m-%d %H:%M:%S %p',)
formmater3=logging.Formatter('%(name)s %(message)s',)
#5``、为``Handler``对象绑定格式
h1.setFormatter(formmater1)
h2.setFormatter(formmater2)
h3.setFormatter(formmater3)
#6``、将``Handler``添加给``logger``并设置日志级别
logger.addHandler(h1)
logger.addHandler(h2)
logger.addHandler(h3)
logger.setLevel(10)
#7``、测试
logger.debug('debug')
logger.info('info')
logger.warning('warning')
logger.error('error')
logger.critical('critical')
五 Logger与Handler的级别
logger``是第一级过滤，然后才能到``handler``，我们可以给``logger``和``handler``同时设置``level``，但是需要注意的是
Logger is also the first to filter the message based on a level — if you set the logger to INFO, and all handlers to DEBUG, you still won't receive DEBUG messages on handlers — they'll be rejected by the logger itself. If you set logger to DEBUG, but all handlers to INFO, you won't receive any DEBUG messages either — because while the logger says "ok, process this", the handlers reject it (DEBUG < INFO).
#``验证
import logging
form=logging.Formatter('%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S %p',)
ch=logging.StreamHandler()
ch.setFormatter(form)
# ch.setLevel(10)
ch.setLevel(20)
l1=logging.getLogger('root')
# l1.setLevel(20)
l1.setLevel(10)
l1.addHandler(ch)
l1.debug('l1 debug')
六 Logger的继承（了解）
import logging
formatter=logging.Formatter('%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S %p',)
ch=logging.StreamHandler()
ch.setFormatter(formatter)
logger1=logging.getLogger('root')
logger1.addHandler(ch)
logger1.setLevel(10)
logger1.debug('log1 debug')
七 应用
"""
logging``配置
"""
import os
import logging.config
# ``定义三种日志输出格式 开始
standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' \
'[%(levelname)s][%(message)s]' #``其中``name``为``getlogger``指定的名字
simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'
id_simple_format = '[%(levelname)s][%(asctime)s] %(message)s'
# ``定义日志输出格式 结束
logfile_dir = os.path.dirname(os.path.abspath(__file__)) # log``文件的目录
logfile_name = 'all2.log' # log``文件名
# ``如果不存在定义的日志目录就创建一个
if not os.path.isdir(logfile_dir):
os.mkdir(logfile_dir)
# log``文件的全路径
logfile_path = os.path.join(logfile_dir, logfile_name)
# log``配置字典
"""
logging配置
"""
import os
# 1、定义三种日志输出格式，日志中可能用到的格式化串如下
# %(name)s Logger的名字
# %(levelno)s 数字形式的日志级别
# %(levelname)s 文本形式的日志级别
# %(pathname)s 调用日志输出函数的模块的完整路径名，可能没有
# %(filename)s 调用日志输出函数的模块的文件名
# %(module)s 调用日志输出函数的模块名
# %(funcName)s 调用日志输出函数的函数名
# %(lineno)d 调用日志输出函数的语句所在的代码行
# %(created)f 当前时间，用UNIX标准的表示时间的浮 点数表示
# %(relativeCreated)d 输出日志信息时的，自Logger创建以 来的毫秒数
# %(asctime)s 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒
# %(thread)d 线程ID。可能没有
# %(threadName)s 线程名。可能没有
# %(process)d 进程ID。可能没有
# %(message)s用户输出的消息
# 2、强调：其中的%(name)s为getlogger时指定的名字
standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' \
'[%(levelname)s][%(message)s]'
simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'
test_format = '%(asctime)s] %(message)s'
# 3、日志配置字典
LOGGING_DIC = {
'version': 1,
'disable_existing_loggers': False,
'formatters': {
'standard': {
'format': standard_format
},
'simple': {
'format': simple_format
},
'test': {
'format': test_format
},
},
'filters': {},
'handlers': {
#``打印到终端的日志
'console': {
'level': 'DEBUG',
'class': 'logging.StreamHandler', # ``打印到屏幕
'formatter': 'simple'
},
#``打印到文件的日志``,``收集``info``及以上的日志
'default': {
'level': 'DEBUG',
'class': 'logging.handlers.RotatingFileHandler', # ``保存到文件``,``日志轮转
'formatter': 'standard',
# ``可以定制日志文件路径
# BASE_DIR = os.path.dirname(os.path.abspath(__file__)) # log``文件的目录
# LOG_PATH = os.path.join(BASE_DIR,'a1.log')
'filename': 'a1.log', # ``日志文件
'maxBytes': 1024*1024*5, # ``日志大小`` 5M
'backupCount': 5,
'encoding': 'utf-8', # ``日志文件的编码，再也不用担心中文``log``乱码了
},
'other': {
'level': 'DEBUG',
'class': 'logging.FileHandler', # ``保存到文件
'formatter': 'test',
'filename': 'a2.log',
'encoding': 'utf-8',
},
},
'loggers': {
#logging.getLogger(__name__)``拿到的``logger``配置
'': {
'handlers': ['default', 'console'], # ``这里把上面定义的两个``handler``都加上，即``log``数据既写入文件又打印到屏幕
'level': 'DEBUG', # loggers(``第一层日志级别关限制``)--->handlers(``第二层日志级别关卡限制``)
'propagate': False, # ``默认为``True``，向上（更高``level``的``logger``）传递，通常设置为``False``即可，否则会一份日志向上层层传递
},
'``专门的采集``': {
'handlers': ['other',],
'level': 'DEBUG',
'propagate': False,
},
},
}
def load_my_logging_cfg():
logging.config.dictConfig(LOGGING_DIC) # ``导入上面定义的``logging``配置
logger = logging.getLogger(__name__) # ``生成一个``log``实例
logger.info('It works!') # ``记录该文件的运行状态
if __name__ == '__main__':
load_my_logging_cfg()
"""
MyLogging Test
"""
import time
import logging
import my_logging # ``导入自定义的``logging``配置
logger = logging.getLogger(__name__) # ``生成``logger``实例
def demo():
logger.debug("start range... time:{}".format(time.time()))
logger.info("``中文测试开始。。。``")
for i in range(10):
logger.debug("i:{}".format(i))
time.sleep(0.2)
else:
logger.debug("over range... time:{}".format(time.time()))
logger.info("``中文测试结束。。。``")
if __name__ == "__main__":
my_logging.load_my_logging_cfg() # ``在你程序文件的入口加载自定义``logging``配置
demo()
注意注意注意：
#1``、有了上述方式我们的好处是：所有与``logging``模块有关的配置都写到字典中就可以了，更加清晰，方便管理
#2``、我们需要解决的问题是：
1``、从字典加载配置：``logging.config.dictConfig(settings.LOGGING_DIC)
2``、拿到``logger``对象来产生日志
logger``对象都是配置到字典的``loggers ``键对应的子字典中的
``按照我们对``logging``模块的理解，要想获取某个东西都是通过名字，也就是``key``来获取的
``于是我们要获取不同的``logger``对象就是
logger=logging.getLogger('loggers``子字典的``key``名``')
``但问题是：如果我们想要不同``logger``名的``logger``对象都共用一段配置，那么肯定不能在``loggers``子字典中定义``n``个``key
'loggers': {
'l1': {
'handlers': ['default', 'console'], #
'level': 'DEBUG',
'propagate': True, # ``向上（更高``level``的``logger``）传递
},
'l2: {
'handlers': ['default', 'console' ],
'level': 'DEBUG',
'propagate': False, # ``向上（更高``level``的``logger``）传递
},
'l3': {
'handlers': ['default', 'console'], #
'level': 'DEBUG',
'propagate': True, # ``向上（更高``level``的``logger``）传递
},
}
#``我们的解决方式是，定义一个空的``key
'loggers': {
'': {
'handlers': ['default', 'console'],
'level': 'DEBUG',
'propagate': True,
},
}
这样我们再取``logger``对象时
logging.getLogger(__name__)``，不同的文件``__name__``不同，这保证了打印日志时标识信息不同，但是拿着该名字去``loggers``里找``key``名时却发现找不到，于是默认使用``key=''``的配置
另外一个django的配置，瞄一眼就可以，跟上面的一样
#logging_config.py
LOGGING = {
'version': 1,
'disable_existing_loggers': False,
'formatters': {
'standard': {
'format': '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]'
'[%(levelname)s][%(message)s]'
},
'simple': {
'format': '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'
},
'collect': {
'format': '%(message)s'
}
},
'filters': {
'require_debug_true': {
'()': 'django.utils.log.RequireDebugTrue',
},
},
'handlers': {
#``打印到终端的日志
'console': {
'level': 'DEBUG',
'filters': ['require_debug_true'],
'class': 'logging.StreamHandler',
'formatter': 'simple'
},
#``打印到文件的日志``,``收集``info``及以上的日志
'default': {
'level': 'INFO',
'class': 'logging.handlers.RotatingFileHandler', # ``保存到文件，自动切
'filename': os.path.join(BASE_LOG_DIR, "xxx_info.log"), # ``日志文件
'maxBytes': 1024 * 1024 * 5, # ``日志大小`` 5M
'backupCount': 3,
'formatter': 'standard',
'encoding': 'utf-8',
},
#``打印到文件的日志``:``收集错误及以上的日志
'error': {
'level': 'ERROR',
'class': 'logging.handlers.RotatingFileHandler', # ``保存到文件，自动切
'filename': os.path.join(BASE_LOG_DIR, "xxx_err.log"), # ``日志文件
'maxBytes': 1024 * 1024 * 5, # ``日志大小`` 5M
'backupCount': 5,
'formatter': 'standard',
'encoding': 'utf-8',
},
#``打印到文件的日志
'collect': {
'level': 'INFO',
'class': 'logging.handlers.RotatingFileHandler', # ``保存到文件，自动切
'filename': os.path.join(BASE_LOG_DIR, "xxx_collect.log"),
'maxBytes': 1024 * 1024 * 5, # ``日志大小`` 5M
'backupCount': 5,
'formatter': 'collect',
'encoding': "utf-8"
}
},
'loggers': {
#logging.getLogger(__name__)``拿到的``logger``配置
'': {
'handlers': ['default', 'console', 'error'],
'level': 'DEBUG',
'propagate': True,
},
#logging.getLogger('collect')``拿到的``logger``配置
'collect': {
'handlers': ['console', 'collect'],
'level': 'INFO',
}
},
}
# -----------
# ``用法``:``拿到俩个``logger
logger = logging.getLogger(__name__) #``线上正常的日志
collect_logger = logging.getLogger("collect") #``领导说``,``需要为领导们单独定制领导们看的日志
应用
paramiko模块
2022年7月31日
19:18
介绍
Paramiko是用python语言写的一个模块，远程连接到Linux服务器，查看上面的日志状态，批量配置远程服务器，文件上传，文件下载等
paramiko是一个基于SSH用于连接远程服务器并执行相关操作（SSHClient和SFTPClinet,即一个是远程连接，一个是上传下载服务），使用该模块可以对远程服务器进行命令或文件操作，值得一说的是，fabric和ansible内部的远程管理就是使用的paramiko来现实
ssh是一个协议，OpenSSH是其中一个开源实现，paramiko是Python的一个库，实现了SSHv2协议(底层使用cryptography)。
有了Paramiko以后，我们就可以在Python代码中直接使用SSH协议对远程服务器执行操作，而不是通过ssh命令对远程服务器进行操作。
Paramiko介绍
paramiko包含两个核心组件：SSHClient和SFTPClient。
- SSHClient的作用类似于Linux的ssh命令，是对SSH会话的封装，该类封装了传输(Transport)，通道(Channel)及SFTPClient建立的方法(open_sftp)，通常用于执行远程命令。
- SFTPClient的作用类似与Linux的sftp命令，是对SFTP客户端的封装，用以实现远程文件操作，如文件上传、下载、修改文件权限等操作。
# Paramiko中的几个基础名词：
1``、``Channel``：是一种类``Socket``，一种安全的``SSH``传输通道；
2``、``Transport``：是一种加密的会话，使用时会同步创建了一个加密的``Tunnels(``通道``)``，这个``Tunnels``叫做``Channel``；
3``、``Session``：是``client``与``Server``保持连接的对象，用``connect()/start_client()/start_server()``开始会话。
Paramiko的基本使用
SSHClient常用的方法介绍
connect()：实现远程服务器的连接与认证，对于该方法只有hostname是必传参数。
常用参数
hostname ``连接的目标主机`
`port=SSH_PORT ``指定端口`
`username=None ``验证的用户名`
`password=None ``验证的用户密码`
`pkey=None ``私钥方式用于身份验证`
`key_filename=None ``一个文件名或文件列表，指定私钥文件`
`timeout=None ``可选的``tcp``连接超时时间`
`allow_agent=True, ``是否允许连接到``ssh``代理，默认为``True ``允许`
`look_for_keys=True ``是否在``~/.ssh``中搜索私钥文件，默认为``True ``允许`
`compress=False, ``是否打开压缩
set_missing_host_key_policy()：
设置远程服务器没有在know_hosts文件中记录时的应对策略。目前支持三种策略：
AutoAddPolicy 自动添加主机名及主机密钥到本地HostKeys对象，不依赖load_system_host_key的配置。即新建立ssh连接时不需要再输入yes或no进行确认
WarningPolicy 用于记录一个未知的主机密钥的python警告。并接受，功能上和AutoAddPolicy类似，但是会提示是新连接
RejectPolicy 自动拒绝未知的主机名和密钥，依赖load_system_host_key的配置。此为默认选项
exec_command()：
在远程服务器执行Linux命令的方法。
open_sftp()：
在当前``ssh``会话的基础上创建一个``sftp``会话。该方法会返回一个``SFTPClient``对象。
# ``利用``SSHClient``对象的``open_sftp()``方法，可以直接返回一个基于当前连接的``sftp``对象，可以进行文件的上传等操作``. sftp=client.open_sftp()sftp.put('local.txt','remote.txt'
SSHClient常用的方法举例
import paramiko
# ``实例化``SSHClient
ssh_client = paramiko.SSHClient()
# ``自动添加策略，保存服务器的主机名和密钥信息，如果不添加，那么不再本地``know_hosts``文件中记录的主机将无法连接 ，此方法必须放在``connect``方法的前面
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
# ``连接``SSH``服务端，以用户名和密码进行认证 ，调用``connect``方法连接服务器
ssh_client.connect(hostname='192.168.137.105', port=22, username='root', password='123456')
# ``打开一个``Channel``并执行命令 `` ``结果放到``stdout``中，如果有错误将放到``stderr``中
stdin, stdout, stderr = ssh_client.exec_command('df -hT ')
# stdout ``为正确输出，``stderr``为错误输出，同时是有``1``个变量有值 `` # ``打印执行结果 `` print(stdout.read().decode('utf-8'))
# ``关闭``SSHClient``连接
ssh_client.close()
密钥连接方式
# ``配置私人密钥文件位置
private = paramiko.RSAKey.from_private_key_file('/root/.ssh/id_rsa')
#``实例化``SSHClient
ssh_client = paramiko.SSHClient()
#``自动添加策略，保存服务器的主机名和密钥信息，如果不添加，那么不再本地``know_hosts``文件中记录的主机将无法连接
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
#``连接``SSH``服务端，以用户名和密码进行认证
ssh_client.connect(
hostname='192.168.137.100',
port=22,
username='root',
pkey=private
)
SFTPClient常用方法介绍
SFTPCLient作为一个sftp的客户端对象，根据ssh传输协议的sftp会话，实现远程文件操作，如上传、下载、权限、状态
from_transport(cls,t) ``创建一个已连通的``SFTP``客户端通道
put(localpath, remotepath, callback=None, confirm=True) ``将本地文件上传到服务器
参数``confirm``：是否调用``stat()``方法检查文件状态，返回``ls -l``的结果
get(remotepath, localpath, callback=None) ``从服务器下载文件到本地
mkdir() ``在服务器上创建目录
remove() ``在服务器上删除目录
rename() ``在服务器上重命名目录
stat() ``查看服务器文件状态
listdir() ``列出服务器目录下的文件
SFTPClient常用方法举例
import paramiko
# ``实例化一个``transport``对象
tran = paramiko.Transport(('192.168.137.100', 22))
# ``连接``SSH``服务端，使用``password
tran.connect(username="root", password='123456')
# ``或使用
# ``配置私人密钥文件位置
private = paramiko.RSAKey.from_private_key_file('/root/.ssh/id_rsa')
# ``连接``SSH``服务端，使用``pkey``指定私钥
tran.connect(username="root", pkey=private)
# ``获取``SFTP``实例
sftp = paramiko.SFTPClient.from_transport(tran)
# ``设置上传的本地``/``远程文件路径
local_path = "/home/1.txt"
remote_path = "/tmp/1.txt"
# ``执行上传动作
sftp.put(local_path, remote_path)
# ``执行下载动作
sftp.get(remote_path, local_path)
# ``关闭``Transport``通道
tran.close()
openpyxl模块
2022年7月31日
14:08
方法
打开方式
wb=Workbook()#``新建``Excel``工作簿
wb=load_workbook("data\``领料单（每日）``.xlsx") ``# ``打开存在的表格
保存方式
wb.save("data\``领料单（每日）``-``更改后``.xlsx") # ``保存表格
获取工作表的方式
sheet_names=wb.get_sheet_names()`` # ``获取每个表的名字
ws=wb[sheet_name] # ``获取指定的表格
ws=wb.active #``读取活动工作表
设置数据的方式
直接指定单元格
ws['A4'].value="``零件测试领料单``" #``直接将``A4``单元格的值改为需要的值
ws['A4'].value ``获取数据
指定行列
ws.cell(``行``,column=``列``,value=``值``)
ws.cell(``行``,``列``).value ``# ``获取值
设置样式
第一步导包
from openpyxl.styles import Border, Side, PatternFill, Font, GradientFill, Alignment
第二步获取单元格
c = ws.cell(row=row_number,column=col_number)
第三部设置
c.font = Font(name='Arial'``，``size=10) # ``设置字体 和大小
c.border = Border(top=thin, left=thin, right=thin, bottom=thin) # ``设置边框
c.alignment = Alignment(horizontal="left", vertical="center") ``# ``设置对其
案例
from openpyxl import load_workbook
wb=load_workbook("data\``领料单（每日）``.xlsx") ``# ``打开存在的表格
sheet_names=wb.get_sheet_names()#``获得工作簿的所有工作表名
for sheet_name in sheet_names:#``遍历每个工作表，更改``A4``单元格的数据
ws=wb[sheet_name] # ``获取指定的表格
ws['A4'].value="``零件测试领料单``" #``直接将``A4``单元格的值改为需要的值
wb.save("data\``领料单（每日）``-``更改后``.xlsx") # ``保存表格
Python-docx模块
2022年10月9日
15:10
写word
案例一：
# -*- coding: utf-8 -*-
# All Rights Reserved
# @Time : 2022/10/914:31
# @Author : Small Fu
# @Email : 2737454073@qq.com
# @File : word_xiaoy.py
__author__ = 'Small Fu'
from docx import Document # ``初始化``word
from docx.enum.text import WD_PARAGRAPH_ALIGNMENT # ``段落对其
from docx.shared import Pt # ``字体磅数
from docx.oxml.ns import qn # ``设置中文格式
import time
price = input("``今日价格：``")
# ``这是客户
customer_list = [f"``客户``{i}" for i in range(10)]
time_sameDay = time.strftime("%Y``年`` %m``月`` %d``日``", time.localtime())
# ``开始设置
for customer in customer_list:
doc = Document()
# ``设置基础字体``,``这个值设置英文和数字
doc.styles["Normal"].font.name = u"``宋体``"
# ``增加中文支持
doc.styles["Normal"]._element.rPr.rFonts.set(qn("w:eastAsia"), u"``宋体``")
# ``初始化一个段落
p1 = doc.add_paragraph()
# ``设置文字对齐居中，没有的话默认左对齐
p1.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
# ``添加第一段的内容
run1 = p1.add_run(f"``关于下达``{time_sameDay}``产品价格通知``")
# ``设置这一段的字体是微软雅黑西文
run1.font.name = "``微软雅黑``"
# ``设置中文
run1._element.rPr.rFonts.set(qn("w:eastAsia"), u"``宋体``")
# ``设置字体大小
run1.font.size = Pt(21)
# ``是否加粗，默认不加粗，``False
run1.font.bold = True
# ``设置这一段前面的字体大小和后面的
p1.space_after = Pt(5)
p1.space_before = Pt(5)
# ``第二段内容
p2 = doc.add_paragraph()
# ``这里是添加尊称
run2 = p2.add_run(f"{customer}: \n ``您好``")
# ``设置这一段的字体是微软雅黑西文
run2.font.name = "``仿宋``_GB2312"
# ``设置中文
run2._element.rPr.rFonts.set(qn("w:eastAsia"), u"``仿宋``_GB2312 ")
# ``设置字体大小
run2.font.size = Pt(16)
# ``是否加粗，默认不加粗，``False
run2.font.bold = True
# ``第三段内容
p3 = doc.add_paragraph()
# ``这里是添加尊称
run3 = p3.add_run(f" ``根据公司安排，为提供优质客户需求，我单位拟定了今日黄金价格为``{price}``元，特此通知``")
# ``设置这一段的字体是微软雅黑西文
run3.font.name = "``仿宋``_GB2312"
# ``设置中文
run3._element.rPr.rFonts.set(qn("w:eastAsia"), u"``仿宋``_GB2312 ")
# ``设置字体大小
run3.font.size = Pt(16)
# ``是否加粗，默认不加粗，``False
run3.font.bold = True
# ``第四段内容
p4 = doc.add_paragraph()
# ``这里是添加尊称
run4 = p4.add_run(" ``联系人：小符`` ``电话：``176XXXXXX44 ")
# ``设置这一段的字体是微软雅黑西文
run4.font.name = "``仿宋``_GB2312"
# ``设置中文
run4._element.rPr.rFonts.set(qn("w:eastAsia"), u"``仿宋``_GB2312 ")
# ``设置字体大小
run4.font.size = Pt(16)
# ``是否加粗，默认不加粗，``False
run4.font.bold = True
# ``保存
doc.save(f"{customer}-``价格通知``.docx")
案例二图片添加
# -*- coding: utf-8 -*-
# All Rights Reserved
# @Time : 2022/10/915:13
# @Author : Small Fu
# @Email : 2737454073@qq.com
# @File : xiaofu-img.py
__author__ = 'Small Fu'
from docx import Document # ``初始化``word
from docx.enum.text import WD_PARAGRAPH_ALIGNMENT # ``段落对其
from docx.shared import Pt # ``字体磅数
from docx.oxml.ns import qn # ``设置中文格式
from docx.shared import Inches # ``图片尺寸
import time
price = input("``今日价格：``")
# ``这是客户
customer_list = [f"``客户``{i}" for i in range(10)]
time_sameDay = time.strftime("%Y``年`` %m``月`` %d``日``", time.localtime())
# ``开始设置
for customer in customer_list:
doc = Document()
# ``设置基础字体``,``这个值设置英文和数字
doc.styles["Normal"].font.name = u"``宋体``"
# ``增加中文支持
doc.styles["Normal"]._element.rPr.rFonts.set(qn("w:eastAsia"), u"``宋体``")
# ``文档添加图片``width=Inches(6) ``这里设置的是``6``英寸
doc.add_picture("./img_1.png",width=Inches(6))
# ``初始化一个段落
p1 = doc.add_paragraph()
# ``设置文字对齐居中，没有的话默认左对齐
p1.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
# ``添加第一段的内容
run1 = p1.add_run(f"``关于下达``{time_sameDay}``产品价格通知``")
# ``设置这一段的字体是微软雅黑西文
run1.font.name = "``微软雅黑``"
# ``设置中文
run1._element.rPr.rFonts.set(qn("w:eastAsia"), u"``宋体``")
# ``设置字体大小
run1.font.size = Pt(21)
# ``是否加粗，默认不加粗，``False
run1.font.bold = True
# ``设置这一段前面的字体大小和后面的
p1.space_after = Pt(5)
p1.space_before = Pt(5)
# ``第二段内容
p2 = doc.add_paragraph()
# ``这里是添加尊称
run2 = p2.add_run(f"{customer}: \n ``您好``")
# ``设置这一段的字体是微软雅黑西文
run2.font.name = "``仿宋``_GB2312"
# ``设置中文
run2._element.rPr.rFonts.set(qn("w:eastAsia"), u"``仿宋``_GB2312 ")
# ``设置字体大小
run2.font.size = Pt(16)
# ``是否加粗，默认不加粗，``False
run2.font.bold = True
# ``第三段内容
p3 = doc.add_paragraph()
# ``这里是添加尊称
run3 = p3.add_run(" ``根据公司安排，为提供优质客户服务，我单位现将价格通知如下：`` ")
# ``设置这一段的字体是仿宋``_GB2312``西文
run3.font.name = "``仿宋``_GB2312"
# ``设置中文
run3._element.rPr.rFonts.set(qn("w:eastAsia"), u"``仿宋``_GB2312 ")
# ``设置字体大小
run3.font.size = Pt(16)
# ``是否加粗，默认不加粗，``False
run3.font.bold = True
# ``添加表格``row=``行``,cols=``列``,style=``样式
table = doc.add_table(rows=3,cols=3,style="Table Grid")
# ``这里是从第``0``行``0``列合并到``0``行``2``列
table.cell(0,0).merge(table.cell(0,2))
# ``添加到合并的单元格
table_run1 = table.cell(0,0).paragraphs[0].add_run("xx``商品报表``")
table_run1.font.name = u"``隶书``"
# ``设置中文
table_run1._element.rPr.rFonts.set(qn("w:eastAsia"), u"``隶书`` ")
# ``设置居中
table.cell(0,0).paragraphs[0].alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
# ``添加
table.cell(1,0).text="``日期``"
table.cell(1,1).text="``价格``"
table.cell(1,2).text="``备注``"
table.cell(2,0).text=time_sameDay
table.cell(2,1).text=set(price)
table.cell(2,2).text=""
# ``第四段内容
p4 = doc.add_paragraph()
# ``这里是添加尊称
run4 = p4.add_run(" ``联系人：小符`` ``电话：``176XXXXXX44 ")
# ``设置这一段的字体是微软雅黑西文
run4.font.name = "``仿宋``_GB2312"
# ``设置中文
run4._element.rPr.rFonts.set(qn("w:eastAsia"), u"``仿宋``_GB2312 ")
# ``设置字体大小
run4.font.size = Pt(16)
# ``是否加粗，默认不加粗，``False
run4.font.bold = True
# ``下一页添加一个广告
# ``插入分页符
doc.add_page_break()
# ``文档添加图片``width=Inches(6) ``这里设置的是``6``英寸
doc.add_picture("./img_1.png",width=Inches(6))
doc.save(f"{customer}-``价格图片表格通知``.docx")
读word
案例一：读纯文本
# -*- coding: utf-8 -*-
# All Rights Reserved
# @Time : 2022/10/915:54
# @Author : Small Fu
# @Email : 2737454073@qq.com
# @File : ``读取简单``word``纯文本``.py
__author__ = 'Small Fu'
from docx import Document
doc = Document("``地址``.docx")
all_paragraphs = doc.paragraphs # ``读取所有的段落
for paragraphs in all_paragraphs:
print(paragraphs.text)
案例二：读取表格文本
# -*- coding: utf-8 -*-
# All Rights Reserved
# @Time : 2022/10/916:02
# @Author : Small Fu
# @Email : 2737454073@qq.com
# @File : ``读取表格文本``.py
__author__ = 'Small Fu'
from docx import Document
doc = Document("``路径``")
all_tables = doc.tables
for tables in all_tables:
for row in tables.rows:
for cell in row.cells:
print(cell.text)
案例三：读取表格嵌套纯文本
# -*- coding: utf-8 -*-
# All Rights Reserved
# @Time : 2022/10/916:06
# @Author : Small Fu
# @Email : 2737454073@qq.com
# @File : ``读取表格嵌套纯文本``.py
__author__ = 'Small Fu'
import zipfile
word = zipfile.ZipFile("``路径``")
xml = word.read("word/document.xml").decode('utf-8')
xml_list = xml.split("<w:t>")
text_file = []
for xml in xml_list:
if xml.find("</w:t>")+1:
text_file.append(
xml[:xml.find("</w:t>")]
)
else:
pass
text_file = "".join(text_file)
格式化word：函数式
案例一：
# -*- coding: utf-8 -*-
# All Rights Reserved
# @Time : 2022/10/916:23
# @Author : Small Fu
# @Email : 2737454073@qq.com
# @File : ``函数式模板``.py
__author__ = 'Small Fu'
from docx import Document # ``初始化``word
from docx.enum.text import WD_PARAGRAPH_ALIGNMENT # ``段落对其
from docx.shared import Pt # ``字体磅数
from docx.oxml.ns import qn # ``设置中文格式
doc = Document()
doc.styles["Normal"].font.name = u"``黑体``"
doc.styles["Normal"]._element.rPr.rFonts.set(qn("w:eastAsia"), u"``黑体``")
def add_context(context):
p1 = doc.add_paragraph()
p1.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
# ``添加内容
run1 = p1.add_run(str(context))
# ``设置这一段的字体是微软雅黑西文
run1.font.size = Pt(16)
# ``设置这一段前面的字体大小和后面的
p1.space_after = Pt(5)
p1.space_before = Pt(5)
word转pdf
tqdm模块
2021年12月2日
14:59
Tqdm
Tqdm 是一个快速，可扩展的Python进度条，可以在 Python 长循环中添加一个进度提示信息，用户只需要封装任意的迭代器 tqdm(iterator)。
安装
pip install tqdm
使用
#for I in tqdm(range(100)):
#time.sleep(0.0001)
#
#
#for j in trange(100):
#time.sleep(0.1)
两个效果是一样的
如果是遍历列表之类的可以用
# alist=list('letters')
# bar=tqdm(alist)
# for letter in bar:
bar.set_description(f"Nowget{letter}")
# pbar=tqdm(["a","b","c","d"])
# for char inp bar:
# time.sleep(1)
# pbar.set_description("Processing%s"%char)
tqdm模块参数说明
class tqdm(object):
"""
Decorate an iterable object, returning an iterator which acts exactly
like the original iterable, but prints a dynamically updating
progressbar every time a value is requested.
"""
def __init__(self,
iterable=None,
desc=None,
total=None,
leave=False,
file=sys.stderr,
ncols=None,
mininterval=0.1,
maxinterval=10.0,
miniters=None,
ascii=None,
disable=False,
unit='it',
unit_scale=False,
dynamic_ncols=False,
smoothing=0.3,
nested=False,
bar_format=None,
initial=0,
gui=False
):
iterable: ``可迭代的对象``, ``在手动更新时不需要进行设置
desc: ``字符串``, ``左边进度条描述文字
total: ``总的项目数
leave: bool``值``, ``迭代完成后是否保留进度条
file: ``输出指向位置``, ``默认是终端``, ``一般不需要设置
ncols: ``调整进度条宽度``, ``默认是根据环境自动调节长度``, ``如果设置为``0, ``就没有进度条``, ``只有输出的信息
unit: ``描述处理项目的文字``, ``默认是``'it', ``例如``: 100 it/s, ``处理照片的话设置为``'img' ,``则为`` 100 img/s
unit_scale: ``自动根据国际标准进行项目处理速度单位的换算``, ``例如`` 100000 it/s >> 100k it/s
爬虫下载文件结合tqdm
from tqdm import tqdm
import requests
url='https://dldir1.qq.com/qqtv/TencentVideo11.14.4043.0.exe'
response=requests.get(url,stream=True) # ``设``stream``流传输方式为真
print(response.headers) # ``打印查看基本头信息
data_size=int(response.headers['Content-Length'])/1024/1024 # ``字节``/1024/1024=MB
with open('``测试``.exe','wb') as f:
for data in tqdm(iterable=response.iter_content(1024*1024),total=data_size,desc='``正在下载``',unit='MB'):
f.write(data)
因此我将iter_content(chunk_size)->chunk_size理解为一个列表的容量，
而iterable=response.iter_content(1024*1024)理解为分割字符串的函数，
将response.content分割为每个元素的长度是1024*1024大小的列表，在对每个部分进行下载。
这只是助于理解chunk_size的一个方法
而response.iter_content 是流传输(简单说就是边下载边写入磁盘),如果将chunk_size设置的很小，意味着每次
下载和存在很小的一部分，下载的速度也会很慢,如果设置的很大，则进度条的进度会错乱，因此我们在确定chunk_size
大小的时候应该对应文件大小，data_size除以多少，chunk_size就乘以多少，才能使进度条对应。
# -*- coding: utf-8 -*-
# All Rights Reserved
# @Time : 2022/6/29 18:32
# @Author : ``符青
# @Email : 2737454073@qq.com
# @File : aa.py
# @Software: PyCharm
import pprint
import requests
from tqdm import tqdm
url = '`https://v3-default.ixigua.com/37179974c244973c87813da84e13ff61/62bc51c7/video/tos/cn/tos-cn-v-0064/25755a2b84b24deeaa48d8e3407b0baa/?libvio.cc&filename=1.mp4`'
response = requests.get(url, stream=True) # ``采用流处理传输输入
pprint.pprint(response.headers)
# ``查看数据大小
data_sice = int(response.headers['Content-Length'])
print(data_sice)
rr = tqdm(
total=data_sice,
desc='``下载恰恰丝滑``',
unit='mb',
unit_scale=True
)
with open('./``恰恰丝滑``.mp4', 'wb+') as ff:
for i in response.iter_content(1024*1024):
rr.update(len(i))
ff.write(i)
ff.close()
pyautogui模块
2022年7月20日
0:46
介绍
自动 防故障功能
pyautogui.FAILSAFE =False
默认这项功能为``True, ``这项功能意味着：当鼠标的指针在屏幕的最坐上方，程序会报错；目的是为了防止程序无法停止；
停顿功能
pyautogui.PAUSE = 1
意味着所有``pyautogui``的指令都要暂停一秒；其他指令不会停顿；这样做，可以防止键盘鼠标操作太快；
鼠标操作函数
操作鼠标点击的函数。
| 函数 | 简单说明 |
|---|---|
| move(x,y)、 moveTo(x,y) | 移动鼠标，前者移动相对位置，后者移动到指定位置 |
| click(x,y)、doubleClick、rightClick | 单击/双击/右击，无参版本在当前位置点击鼠标 |
| drag(x,y)、dragTo(x,y) | 拖动鼠标 |
| mouseDown、mouseUp | 按下按键，松开按键 |
| scroll | 向下滚动鼠标滚轮的函数 |
键盘操作函数
操作键盘按键的函数。
| 函数 | 简介 |
|---|---|
| press(‘left’,press=3) | |
| hotkey(‘ctrl’,‘s’) | 按下Ctrl+S组合键 |
| keyDown、keyUp | 按下和松开键盘按键 |
提示框函数
PyAutoGUI可以显示提示框，这时候程序会暂停运行，直到用户点击提示框。
| 函数 | 简介 |
|---|---|
| alert(text=’’,title=’’,button=[‘OK’,‘Cancle’]) | 显示警告对话框 |
| confirm() | 显示确认对话框 |
| prompt() | 显示提示对话框 |
| password() | 显示密码输入对话框 |
屏幕截图和定位函数
截取屏幕的函数，也可以从屏幕中寻找匹配的图片，并返回其坐标。你可以事先保存一些按钮的截图，然后通过这种方式定位按钮的位置，然后点击。
| 函数 | 简介 |
|---|---|
| screenshot(‘image.png’) | 保存截图并返回截图，无参版本直接返回截图不保存 |
| center(‘image.png’) | 从屏幕上寻找图片位置，返回框位置 |
| locateOnScreen(‘img’) | 从屏幕寻找图片位置，直接返回坐标 |
Pil模块
2022年6月2日
23:47
PIL``功能介绍与安装
PIL``，全称``Python Image Library``，主要作用是图像处理，可用于图片剪切、粘贴、缩放、镜像、水印、颜色块、滤镜、图像格式转换、色场空间转换、验证码、旋转图像、图像增强、直方图处理、插值和滤波等功能。不过只支持到``Python 2.7``。``Pillow``是``PIL``的一个派生分支，但如今已经发展成为比``PIL``本身更具活力的图像处理库。我们需要安装的就是``Pillow``。
PIL``具体用途：图像归档``(Image Archives)``。``PIL``非常适合于图像归档以及图像的批处理任务。你可以使用``PIL``创建缩略图，转换图像格式，打印图像等等。
``图像展示``(Image Display)``。``PIL``较新的版本支持包括``Tk PhotoImage``，``BitmapImage``还有``Windows DIB``等接口。``PIL``支持众多的``GUI``框架接口，可以用于图像展示。
``图像处理``(Image Processing)``。``PIL``包括了基础的图像处理函数，包括对点的处理，使用众多的卷积核``(convolution kernels)``做过滤``(filter),``还有颜色空间的转换。``PIL``库同样支持图像的大小转换，图像旋转，以及任意的仿射变换。``PIL``还有一些直方图的方法，允许你展示图像的一些统计特性。这个可以用来实现图像的自动对比度增强，还有全局的统计分析等。
pip install Pillow
PIL的基本操作
from PIL import Image
# 1.``打开图片
img = Image.open("image/10.png")
# 2.``显示图片``(``执行显示图片后线程会中断，关闭图像后恢复``)
img.show()
# 3.``保存图片
img.save("image/xiaomai.png")
我在尝试的过程中发现，``png``格式的图片保存为``jpg``格式时会报错：``OSError: cannot write mode RGBA as JPEG``，经过查阅资料发现错误原因主要是因为``PNG``格式和``JPG``格式图片的通道数不同。
PNG``是四通道：``RGBA``意思是红色，绿色，蓝色，``Alpha``的色彩空间，``Alpha``指透明度
JPG``是三通道：``RGB``意思是红色，绿色，蓝色
所以，``PNG``格式图片要保存成``JPG``格式就要丢弃``A``通道：
from PIL import Image
# 1.``打开图片
img = Image.open("image/10.png")
# 2.``显示图片``(``执行显示图片后线程会中断，关闭图像后恢复``)
img.show()
# 3.``保存图片
img = img.convert("RGB")
img.save("image/xiaomai.jpg")
下面是图片旋转的代码：
from PIL import Image
# 1.``打开图片
img = Image.open("pli/7.png")
# 2.``水平翻转
img1 = img.transpose(Image.FLIP_LEFT_RIGHT)
# 3.``保存图片
img1.save("pli/1.png")
# 4.``垂直翻转
img2 = img.rotate(180)
# 5.``保存照片
img2.save("pli/2.png")
# 6.``水平``+``垂直翻转
img3 = img.transpose(Image.FLIP_LEFT_RIGHT).rotate(180)
# 7.``保存图片
img3.save("pli/3.png")
给图片增加文字
要在图像上绘制文本要用到 PIL 的两个模块：ImageDraw和ImageFont。 ImageDraw 用于创建绘图对象，ImageFont用于加载字体。
from PIL import Image, ImageDraw, ImageFont
# 1.``打开图片
img = Image.open("image/10.png")
# 2.``调用画图模块
draw = ImageDraw.Draw(img)
# 3.``设置字体
tfont = ImageFont.truetype("``萌神手写体``.ttf", 24)
# 4.``添加文字
"""
``参数一：文字在图片的位置：``(x, y)
``参数二：文字内容
``参数三：字体颜色，当然颜色也可以用``RGB``值指定
``参数四：字体类型
"""
draw.text((50, 30), "eyes++", fill="green", font=tfont)
# 5.``保存图片
img.save("image/addWord.png")
# 6.``显示图片
img.show()
PIL滤镜功能
from PIL import Image, ImageFilter
img = Image.open("image/10.png")
img = img.filter(ImageFilter.CONTOUR)
img.save("image/Filter.png")
img.show()
PIL镜像功能
from PIL import Image
img = Image.open("image/10.png")
img = img.transpose(Image.FLIP_LEFT_RIGHT)
img.save("image/mirror.png")
transpose有这么几种模式
FLIP_LEFT_RIGHT：左右镜像
FLIP_TOP_BOTTOM：上下镜像
ROTATE_90：逆时针转90度
ROTATE_180：逆时针转180度
ROTATE_270：逆时针转270度
TRANSPOSE：像素矩阵转置
TRANSVERSE
最后一种模式我也不知道什么意思，也没查到，但效果是下面这样的，盲猜是对角线对转。。。。。
图片拼接功能
from PIL import Image, ImageDraw
# ``打开图片
img1 = Image.open("image/10.png")
img2 = Image.open("image/addWord.png")
# ``查看图片尺寸，便于拼接图片
print(img1.size)
print(img1.size)
# ``新建空白图片``,``三个参数分别是模式``(RGB/RGBA)``、大小、颜色
newimg = Image.new(mode="RGB", size=(1174, 614), color=(255, 100, 50))
# ``拼接图片``,``第一个参数是图片，第二个是起始位置
newimg.paste(img1, (0, 0))
newimg.paste(img2, (587, 0))
newimg.show()
PIL裁剪功能
from PIL import Image
img = Image.open("image/10.png")
print(img.size)
imgCut = img.crop((100, 200, 500, 600))
imgCut.show()
图片缩放
from PIL import Image
# :
img = Image.open('image/10.png')
# ``获得图像尺寸``:
w, h = img.size
# ``缩放到``50%:
img.thumbnail((w//2, h//2))
# ``把缩放后的图像用``jpeg``格式保存``:
img.save('image/zoom.png')
shutil****模块
高级的 文件、文件夹、压缩包 处理模块
shutil.copyfileobj(fsrc, fdst[, length])
将文件内容拷贝到另一个文件中
1import shutil`
`23shutil.copyfileobj(open('old.xml','r'), open('new.xml', 'w'))
shutil.copyfile(src, dst)
拷贝文件
shutil.copyfile('f1.log', 'f2.log') #``目标文件无需存在
shutil.copymode(src, dst)
仅拷贝权限。内容、组、用户均不变
1shutil.copymode('f1.log', 'f2.log') #``目标文件必须存在
shutil.copystat(src, dst)
仅拷贝状态的信息，包括：``mode bits, atime, mtime, flags
1shutil.copystat('f1.log', 'f2.log') #``目标文件必须存在
shutil.copy(src, dst)
拷贝文件和权限
import shutil`
`shutil.copy('f1.log', 'f2.log')
shutil.copy2(src, dst)
拷贝文件和状态信息
import shutil`
`shutil.copy2('f1.log', 'f2.log')
shutil.ignore_patterns(*patterns)
shutil.copytree(src, dst, symlinks=False, ignore=None)
递归的去拷贝文件夹
import shutil`
`shutil.copytree('folder1', 'folder2', ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))
#``目标目录不能存在，注意对``folder2``目录父级目录要有可写权限，
ignore``的意思是排除 ==》``*.pyc', 'tmp*``：这个是排除易。pyc结尾，和以tmp开头的文件
拷贝软连接
import shutil
shutil.copytree('f1', 'f2', symlinks=True, ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))
'''`
`通常的拷贝都把软连接拷贝成硬链接，即对待软连接来说，创建新的文件`
`'''
shutil.rmtree(path[, ignore_errors[, onerror]])
递归的去删除文件
import shutil`
`shutil.rmtree('folder1')
shutil.move(src, dst)
递归的去移动文件，它类似``mv``命令，其实就是重命名。
import shutil`
`shutil.move('folder1', 'folder3')
shutil.make_archive(base_name, format,...)
创建压缩包并返回文件路径，例如：``zip``、``tar
创建压缩包并返回文件路径，例如：``zip``、``tar
- base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，
如 data_bak =>保存至当前路径
如：/tmp/data_bak =>保存至/tmp/ - format： 压缩包种类，“zip”, “tar”, “bztar”，“gztar”
- root_dir： 要压缩的文件夹路径（默认当前目录）
- owner： 用户，默认当前用户
- group： 组，默认当前组
- logger： 用于记录日志，通常是logging.Logger对象
#``将`` /data ``下的文件打包放置当前程序目录
import shutil`
`ret = shutil.make_archive("data_bak", 'gztar', root_dir='/data')`
`#``将`` /data``下的文件打包放置`` /tmp/``目录
import shutil`
`ret = shutil.make_archive("/tmp/data_bak", 'gztar', root_dir='/data')``
shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的，详细：
import zipfile
# ``压缩``z = zipfile.ZipFile('laxi.zip', 'w')`
`z.write('a.log')`
`z.write('data.data')`
`z.close()
# ``解压``z = zipfile.ZipFile('laxi.zip', 'r')`
`z.extractall(path='.')`
`z.close()
import tarfile
# ``压缩``>>> t=tarfile.open('/tmp/egon.tar','w')`
`>>> t.add('/test1/a.py',arcname='a.bak')`
`>>> t.add('/test1/b.py',arcname='b.bak')`
`>>> t.close()
# ``解压``>>> t=tarfile.open('/tmp/egon.tar','r')`
`>>> t.extractall('/egon')`
`>>> t.close()
Openpyxl模块
2022年6月7日
13:24
01 首先读取已存在的 Excel 表格
使用load_workbook（）函数；我们需要先导入load_workbook;工作表为活动工作表
from openpyxl import load_workbook
# Excel表格与脚本在同一个文件，否则需要把路径写全
wb = load_workbook(r'demo.xlsx')
sheet = wb.active
# 也可以按工作表名读取
# sheet = wb.get_sheet_by_name("sheet")
02 向单个单元格赋值
可以使用['A1']形式；也可以使用标明行列数值的形式.cell(row=2, column=2).value = 5
from openpyxl import load_workbook
wb = load_workbook(r'demo.xlsx')
sheet = wb.active
sheet['A1'] = 'Devansh Sharma'
sheet['A2'] = 'hello world'
sheet.cell(row=2, column=2).value = 5
wb.save(r'demo.xlsx')
print("运行结束！")
向工作表批量赋值
from openpyxl import load_workbook
wb = load_workbook(r'demo.xlsx')
sheet = wb.active
data = (
(11, 48, 50),
(81, 30, 82),
(20, 51, 72),
(21, 14, 60),
(28, 41, 49),
(74, 65, 53),
("Peter", 'Andrew',45.63)
)
for i in data:
sheet.append(i)
wb.save(r'demo.xlsx')
print("运行结束！")
jieba模块
2021年12月10日
21:19
安装
pip install jieba
二、算法介绍
结巴中文分词涉及到的算法包括：
(1) 基于Trie树结构实现高效的词图扫描，生成句子中汉字所有可能成词情况所构成的有向无环图（DAG)；
(2) 采用了动态规划查找最大概率路径, 找出基于词频的最大切分组合；
(3) 对于未登录词，采用了基于汉字成词能力的HMM模型，使用了Viterbi算法。
三、分词模式
结巴中文分词支持的三种分词模式包括：
(1) 精确模式：试图将句子最精确地切开，适合文本分析；
(2) 全模式：把句子中所有的可以成词的词语都扫描出来, 速度非常快，但是不能解决歧义问题；
(3) 搜索引擎模式：在精确模式的基础上，对长词再次切分，提高召回率，适合用于搜索引擎分词。
import jieba
# 全模式
text = "我来到北京清华大学"
seg_list = jieba.cut(text, cut_all=True)
print(u"[全模式]: ", "/ ".join(seg_list))
返回列表
# 精确模式
seg_list = jieba.cut(text, cut_all=False)
print(u"[精确模式]: ", "/ ".join(seg_list))
# 默认是精确模式
seg_list = jieba.cut(text)
print(u"[默认模式]: ", "/ ".join(seg_list))
# 搜索引擎模式
seg_list = jieba.cut_for_search(text)
print(u"[搜索引擎模式]: ", "/ ".join(seg_list))
结果：
[全模式]: 我/ 来到/ 北京/ 清华/ 清华大学/ 华大/ 大学
[精确模式]: 我/ 来到/ 北京/ 清华大学
[默认模式]: 我/ 来到/ 北京/ 清华大学
[搜索引擎模式]: 我/ 来到/ 北京/ 清华/ 华大/ 大学/ 清华大学
jieba库的三种模式：
-精确模式：把文本精确的切分开，不存在冗余单词
#jieba.lcut(s)
jieba.lcut("中国是一个伟大的国家"
#output:['中国', '是', '一个', '伟大', '的', '国家']
-全模式：把文本中所有的可能的词语都扫描出来，有冗余
#jieba.lcut(s,cut_all=True)
jieba.lcut("中国是一个伟大的国家",cut_all=True)
#output:['中国', '国是', '一个', '伟大', '的', '国家']
-全搜索引擎模式：在精确模式的基础上，对长词再次切分
#jieba.lcut_for_search(s)
jieba.lcut_for_search("中华人民共和国是伟大的")
#output:['中华', '华人', '人民', '共和', '共和国', '中华人民共和国', '是', '伟大', '的']
向分词词典中增加新词w：
#jieba.add_word(w)
jieba.add_word("蟒蛇语言")
四、新词识别
import jieba
#新词识别 “杭研”并没有在词典中,但是也被Viterbi算法识别出来了
seg_list = jieba.cut("他来到了网易杭研大厦")
print (u"[新词识别]: ", "/ ".join(seg_list))
[新词识别]: 他/ 来到/ 了/ 网易/ 杭研/ 大厦
五、自定义词典
import jieba
text = "故宫的著名景点包括乾清宫、太和殿和黄琉璃瓦等"
# 全模式
seg_list = jieba.cut(text, cut_all=True)
print(u"[全模式]: ", "/ ".join(seg_list))
# 精确模式
seg_list = jieba.cut(text, cut_all=False)
print(u"[精确模式]: ", "/ ".join(seg_list))
# 搜索引擎模式
seg_list = jieba.cut_for_search(text)
print(u"[搜索引擎模式]: ", "/ ".join(seg_list))
结果
[全模式]: 故宫/ 的/ 著名/ 著名景点/ 景点/ 包括/ 乾/ 清宫/ / / 太和/ 太和殿/ 和/ 黄/ 琉璃/ 琉璃瓦/ 等
[精确模式]: 故宫/ 的/ 著名景点/ 包括/ 乾/ 清宫/ 、/ 太和殿/ 和/ 黄/ 琉璃瓦/ 等
[搜索引擎模式]: 故宫/ 的/ 著名/ 景点/ 著名景点/ 包括/ 乾/ 清宫/ 、/ 太和/ 太和殿/ 和/ 黄/ 琉璃/ 琉璃瓦/ 等
可以看到，结巴分词工具认出了专有名词”太和殿”，但没有认出”乾清宫”和”黄琉璃瓦”。
也就是说，专有名词”乾清宫”和”黄琉璃瓦”可能因分词而分开，这也是很多分词工具的一个缺陷。
为此，Jieba分词支持开发者使用自定定义的词典，以便包含jieba词库里没有的词语。虽然结巴有新词识别能力，但自行添加新词可以保证更高的正确率，尤其是专有名词。
基本用法：
jieba.load_userdict(file_name) #file_name为自定义词典的路径
词典格式和dict.txt一样，一个词占一行；
每一行分三部分，第一部分为词语，中间部分为词频，最后部分为词性（可省略，ns为地点名词），用空格隔开。
咱们在jieba的安装目录下添加mydict.txt，内容为
乾清宫 1 n
黄琉璃瓦 1 n
添加自定义以后的代码；主要是添加加载mydict.txt的代码：
import jieba
jieba.load_userdict("D:\Program Files\Python36\Lib\site-packages\jieba\mydict.txt")
text = "故宫的著名景点包括乾清宫、太和殿和黄琉璃瓦等"
# 全模式
seg_list = jieba.cut(text, cut_all=True)
print(u"[全模式]: ", "/ ".join(seg_list))
# 精确模式
seg_list = jieba.cut(text, cut_all=False)
print(u"[精确模式]: ", "/ ".join(seg_list))
# 搜索引擎模式
seg_list = jieba.cut_for_search(text)
print(u"[搜索引擎模式]: ", "/ ".join(seg_list))
结果
[全模式]: 故宫/ 的/ 著名/ 著名景点/ 景点/ 包括/ 乾清宫/ 清宫/ / / 太和/ 太和殿/ 和/ 黄琉璃瓦/ 琉璃/ 琉璃瓦/ 等
[精确模式]: 故宫/ 的/ 著名景点/ 包括/ 乾清宫/ 、/ 太和殿/ 和/ 黄琉璃瓦/ 等
[搜索引擎模式]: 故宫/ 的/ 著名/ 景点/ 著名景点/ 包括/ 清宫/ 乾清宫/ 、/ 太和/ 太和殿/ 和/ 琉璃/ 琉璃瓦/ 黄琉璃瓦/ 等
关键词提取
在构建VSM向量空间模型过程或者把文本转换成数学形式计算中，你需要运用到关键词提取的技术。
jieba.analyse.extract_tags(sentence, topK)
其中sentence为待提取的文本，topK为返回几个TF/IDF权重最大的关键词，默认值为20。
代码；
import jieba
import jieba.analyse
#导入自定义词典
jieba.load_userdict("D:\Program Files\Python36\Lib\site-packages\jieba\mydict.txt")
#精确模式
text = "故宫的著名景点包括乾清宫、太和殿和午门等。其中乾清宫非常精美，午门是紫禁城的正门，午门居中向阳。"
seg_list = jieba.cut(text, cut_all=False)
print (u"分词结果:")
print ("/".join(seg_list))
#获取关键词
tags = jieba.analyse.extract_tags(text, topK=5)
print (u"关键词:")
print (" ".join(tags))
结果；
故宫/的/著名景点/包括/乾清宫/、/太和殿/和/午门/等/。/其中/乾清宫/非常/精美/，/午门/是/紫禁城/的/正门/，/午门/居中/向阳/。
关键词:
午门 乾清宫 著名景点 太和殿 向阳
这里“午门”出现了3次，所以先输出。“乾清宫”出现了2次，第二个输出。
其他词都出现1次，那么为什么接下来输出的是“著名景点”、“太和殿”和“向阳”呢？
这是因为，在词频一样的前题下，根据TF/IDF的顺序来输出，因为其他词的TF一样（都是1），所以IDF小的会先输出来。
不知道结巴分词是根据什么来判断IDF的，假如是根据dict.txt中的第二列词频来判断，那么确实是“著名景点” < “太阳殿” < “向阳” < 其他词语。这样第三个输出的就是“著名景点”，最后两个依次为“太阳殿”和“向阳”。
去除停用词
在信息检索中，为节省存储空间和提高搜索效率，在处理自然语言数据（或文本）之前或之后会自动过滤掉某些字或词，比如“的”、“是”、“而且”、“但是”、”非常“等。这些字或词即被称为Stop Words（停用词）。
代码：
import jieba
# 去除停用词
stopwords = {}.fromkeys(['的', '包括', '等', '是'])
text = "故宫的著名景点包括乾清宫、太和殿和午门等。其中乾清宫非常精美，午门是紫禁城的正门。"
# 精确模式
segs = jieba.cut(text, cut_all=False)
final = ''
for seg in segs:
if seg not in stopwords:
final += seg
print (final)
seg_list = jieba.cut(final, cut_all=False)
print ("/ ".join(seg_list))
结果：
故宫著名景点乾清宫、太和殿和午门。其中乾清宫非常精美，午门紫禁城正门。
故宫/ 著名景点/ 乾/ 清宫/ 、/ 太和殿/ 和/ 午门/ 。/ 其中/ 乾/ 清宫/ 非常/ 精美/ ，/ 午门/ 紫禁城/ 正门/ 。
WordCloud模块
2021年12月16日
20:00
效果是不是看起来还不错，下面介绍wordcloud.WordCloud()的参数
font_path : string //字体路径，需要展现什么字体就把该字体路径+后缀名写上，如：font_path = '黑体.ttf'
width : int (default=400) //输出的画布宽度，默认为400像素
height : int (default=200) //输出的画布高度，默认为200像素
prefer_horizontal : float (default=0.90) //词语水平方向排版出现的频率，默认 0.9 （所以词语垂直方向排版出现频率为 0.1 ）
mask : nd-array or None (default=None) //如果参数为空，则使用二维遮罩绘制词云。如果 mask 非空，设置的宽高值将被忽略，遮罩形状被 mask 取代。除全白（#FFFFFF）的部分将不会绘制，其余部分会用于绘制词云。如：bg_pic = imread('读取一张图片.png')，背景图片的画布一定要设置为白色（#FFFFFF），然后显示的形状为不是白色的其他颜色。可以用ps工具将自己要显示的形状复制到一个纯白色的画布上再保存，就ok了。
scale : float (default=1) //按照比例进行放大画布，如设置为1.5，则长和宽都是原来画布的1.5倍。
min_font_size : int (default=4) //显示的最小的字体大小
font_step : int (default=1) //字体步长，如果步长大于1，会加快运算但是可能导致结果出现较大的误差。
max_words : number (default=200) //要显示的词的最大个数
stopwords : set of strings or None //设置需要屏蔽的词，如果为空，则使用内置的STOPWORDS
background_color : color value (default=”black”) //背景颜色，如background_color='white',背景颜色为白色。
max_font_size : int or None (default=None) //显示的最大的字体大小
mode : string (default=”RGB”) //当参数为“RGBA”并且background_color不为空时，背景为透明。
relative_scaling : float (default=.5) //词频和字体大小的关联性
color_func : callable, default=None //生成新颜色的函数，如果为空，则使用 self.color_func
regexp : string or None (optional) //使用正则表达式分隔输入的文本
collocations : bool, default=True //是否包括两个词的搭配
colormap : string or matplotlib colormap, default=”viridis” //给每个单词随机分配颜色，若指定color_func，则忽略该方法。
fit_words(frequencies) //根据词频生成词云
generate(text) //根据文本生成词云
generate_from_frequencies(frequencies[, ...]) //根据词频生成词云
generate_from_text(text) //根据文本生成词云
process_text(text) //将长文本分词并去除屏蔽词（此处指英语，中文分词还是需要自己用别的库先行实现，使用上面的 fit_words(frequencies) ）
recolor([random_state, color_func, colormap]) //对现有输出重新着色。重新上色会比重新生成整个词云快很多。
to_array() //转化为 numpy array
to_file(filename) //输出到文件
打包py文件
2022年6月18日
17:19
第一步：安装打包所需要的包（pyinstaller）
在``cmd``窗口中输入
pip install pyinstaller
并从新创建一个环境
第二步修改路径
第三步：输入打包命令
pyinstaller -F -w (-i icofile) 文件名.py
解释一下该命令：
1、-w 表示在打包好程序后，双击.exe文件不会不会不会（重要的事情说三遍）出现黑色的命令窗口。（如果你的程序有print等输出命令，就不要加）
2、小括号中的内容是可以省略的，-i 表示给.exe文件一个图标，icofile表示图标的文件名，图标的图片格式为.ico格式的。不懂.ico图片的可以百度一下。打包时如果需要给.exe加入图标，将图标文件放到和.py文件同一目录下。
3、文件名.py 这里的文件名是你要打包的.py文件的名称。
| -h，--help | 查看该模块的帮助信息 |
|---|---|
| -F，-onefile | 产生单个的可执行文件 |
| -D，--onedir | 产生一个目录（包含多个文件）作为可执行程序 |
| -a，--ascii | 不包含 Unicode 字符集支持 |
| -d，--debug | 产生 debug 版本的可执行文件 |
| -w，--windowed，--noconsolc | 指定程序运行时不显示命令行窗口（仅对 Windows 有效） |
| -c，--nowindowed，--console | 指定使用命令行窗口运行程序（仅对 Windows 有效） |
| -o DIR，--out=DIR | 指定 spec 文件的生成目录。如果没有指定，则默认使用当前目录来生成 spec 文件 |
| -p DIR，--path=DIR | 设置 Python 导入模块的路径（和设置 PYTHONPATH 环境变量的作用相似）。也可使用路径分隔符（Windows 使用分号，Linux 使用冒号）来分隔多个路径 |
| -n NAME，--name=NAME | 指定项目（产生的 spec）名字。如果省略该选项，那么第一个脚本的主文件名将作为 spec 的名字 |
转换jpg为ioc文件
PythonMagick
PythonMagick库无法用pip或者easy_install来安装，因此，需要手动安装，地址如下： https://www.lfd.uci.edu/~gohlke/pythonlibs/#pythonmagick 选择合适版本下载后，进入文件所在位置，直接pip install + 文件名即可完成安装。
"""
Author``：``Robin·QI
Notes``：将图片转换为``ico``格式
"""
# PythonMargick``包可以到``Unofficial Windows Binaries for Python Extension Packages``下载
import PythonMagick
img = PythonMagick.Image('robin.jpg') ``# ``导入图片
# ``这里要设置一下尺寸，不然会报``ico``尺寸异常错误
img.sample('128x128') ``#``设置尺寸
img.write('robin.ico') ``保存图片
python音乐格式转换
2022年6月18日
22:37
01 安装pydub库
通过下面的命令安装``Python``库``-pydub
pip`` ``install`` ``pydub
#转化函数方法
from pydub import AudioSegment
#``转化函数方法
def trans_mp3_to_wav(filepath,hz):
song = AudioSegment.from_mp3(filepath)
song.export("Python``研究者``."+str(hz), format=str(hz))
### ``参数``1``：音频路径， 参数``2``：转换后的格式
trans_mp3_to_wav("``轻音乐``.mp3","wav")
trans_mp3_to_wav("``轻音乐``.mp3","ogg")
trans_mp3_to_wav("``轻音乐``.mp3","flac")
将轻音乐.mp3 转为wav、ogg、flac等格式，并命名为Python研究者。转化后均为无损高音质，没有任何的失真。
2.wav、ogg、flac->mp3
from pydub import AudioSegment
song = AudioSegment.from_wav("Python``研究者``.wav")
song.export("Python``研究者``_wav-mp3.mp3", format="mp3")
song = AudioSegment.from_ogg("Python``研究者``.ogg")
song.export("Python``研究者``_ogg-mp3.mp3", format="mp3")
AudioSegment.from_file("Python``研究者``.flac")
song.export("Python``研究者``_flac-mp3.mp3", format="mp3")
Python 使用 webbrowser 包播放 Mp3 文件
Import webbrowser`
`webbrowser.open("sample.mp3")
代码片段将在浏览器窗口中打开一个标签页并播放当前工作目录中的 sample.mp3 文件。
大部分的模块介绍
2022年5月10日
23:05
库名称简介
Chardet字符编码探测器，可以自动检测文本、网页、xml的编码。
colorama主要用来给文本添加各种颜色，并且非常简单易用。
Prettytable主要用于在终端或浏览器端构建格式化的输出。
difflib，[Python]标准库，计算文本差异
Levenshtein，快速计算字符串相似度。
fuzzywuzzy,字符串模糊匹配。
esmre,正则表达式的加速器。
shortuuid,一组简洁URL/UUID函数库。
ftfy，Unicode文本工具7
unidecode，ascii和Unicode文本转换函数。
xpinyin，将汉字转换为拼音的函数库
pangu.py，调整对中日韩文字当中的字母、数字间距。
pyfiglet，Python写的figlet程序，使用字符组成ASCII艺术图片
uniout，提取字符串中可读写的字符
awesome slugify，一个Python slugify库，用于处理Unicode。
python-slugify，转换Unicode为ASCII内码的slugify函数库。
unicode-slugify，生成unicode内码，Django的依赖包。
ply，Python版的lex和yacc的解析工具
phonenumbers，解析电话号码，格式，存储和验证的国际电话号码。
python-user-agents，浏览器的用户代理（user-agents）的解析器。
sqlparse，SQL解析器。
pygments，一个通用的语法高亮工具。
python-nameparser，解析人名，分解为单独的成分。
pyparsing，通用解析器生成框架。
tablib，表格数据格式，包括，XLS、CSV，JSON，YAML。
python-docx，docx文档读取，查询和修改，微软Word 2007 / 2008的docx文件。
xlwt/xlrd，读写Excel格式的数据文件。
xlsxwriter，创建Excel格式的xlsx文件。
xlwings，利用Python调用Excel
csvkit，CSV文件工具包。
marmir，把Python[数据结构]，转化为电子表格。
pdfminer，从PDF文件中提取信息。
pypdf2， 合并和转换PDF页面的函数库。
Python-Markdown，轻量级标记语言Markdown的Python实现。
Mistune，,快速、全功能的纯Python编写的Markdown解释器。
dateutil，标准的Python官方datetime模块的扩展包，字符串日期工具，其中parser是根据字符串解析成datetime，而rrule是则是根据定义的规则来生成datetime。
arrow,更好的日期和时间处理Python库
chronyk，一个Python 3版函数库，用于解析人写的时间和日期。
delorean，清理期时间的函数库。
when.py，为见的日期和时间，提供人性化的功能。
moment，类似Moment.js的日期/时间Python库
pytz，世界时区，使用tz database时区信息[数据库]
BeautifulSoup，基于Python的HTML/XML解析器，简单易用, 功能很强大,即使是有bug，有问题的html代码，也可以解析
lxml，快速，易用、灵活的HTML和XML处理库，功能超强，在遇到有缺陷、不规范的xml时，Python自带的xml处理器可能无法解析。报错时，程序会尝试再用lxml的修复模式解析。
htmlparser，官方版解析HTML DOM树，偶尔搞搞命令行自动表单提交用得上。
pyyaml，Python版本的YAML解释器。
html5lib，-标准库，解析和序列化HTML文档和片段。
pyquery，类似[jQuery]的的HTML解释器函数库。
cssutils，Python CSS库。
MarkupSafe，XML或HTML / XHTML安全字符串标记工具。
cssutils - ACSS library for Python., MarkupSafe - Implements a XML/HTML/XHTML
bleach，漂白，基于HTML的白名单函数库。
xmltodict，类似JSON的XML工具包。
xhtml2pdf，HTML / CSS格式转换器，看生成pdf文档。
untangle，把XML文档，转换为Python对象，方便访问。
文件处理
库名称简介Mimetypes，Python标准库，映射文件名到MIME类型。
imghdr，Python标准库，确定图像类型。python-magic，libmagic文件类型识别库，Python接口格式。path.py，os.path模块的二次封装。
watchdog，一组API和shell实用程序，用于监视文件系统事件。
Unipath，面向对象的文件/目录的操作工具包。pathlib，-（Python 3.4版已经作为Python标准库），一个跨平台，面向path的函数库。
pickle/cPickle,python的pickle模块实现了基本的数据序列和反序列化。通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储；通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象。
cPickle是[C语言]实现的版本，速度更快。
ConfigParser，Python标准库，INI文件解析器。
configobj，INI文件解析器。config，分层次配置，logging作者编写。
profig，多格式配置转换工具。
logging，Python标准库，日志文件生成管理函数库。
logbook，logging的替换品。
Sentry，实时log服务器。Raven，哨兵Sentry的Python客户端。
Sphinx，斯芬克斯（狮身人面像），Python文档生成器。
reStructuredText，标记语法和解析工具，Docutils组件。mkdocs，Markdown格式文档生成器。
pycco，简单快速、编程风格的文档生成器。
pdoc，自动生成的Python库API文档epydoc，从源码注释中生成各种格式文档的工具
图像处理
库名称简介PIL（Python Image Library），基于Python的图像处理库，功能强大，对图形文件的格式支持广泛，内置许多图像处理函数，如图像增强、滤波[算法]等Pillow，图像处理库，PIL图像库的分支和升级替代产品。Matplotlib，著名的绘图库，提供了整套和matlab相似的命令API，用以绘制一些高质量的数学二维图形，十分适合交互式地进行制图。brewer2mpl，有一个专业的python配色工具包，提供了从美术角度来讲的精美配色。
PyGame基于Python的多媒体开发和游戏软件开发模块，包含大量游戏和图像处理功能Box2d，开源的2d物理引擎，愤怒的小鸟就是使用了这款物理引擎进行开发的，Box2d物理引擎内部模拟了一个世界，你可以设置这个世界里的重力，然后往这个世界里添加各种物体，以及他们的一些物理特性，比如质量，摩擦，阻尼等等。
Pymunk，类似box2d的开源物理图形模拟库OpenCV, 目前最好的开源图像/视觉库，包括图像处理和计算机视觉方面、[机器学习]的很多通用算法。SimpleCV，计算机视觉开源框架，类似opencv。VTK，视觉化工具函式库（VTK， Visualization Toolkit）是一个开放源码，跨平台、支援平行处理（VTK曾用于处理大小近乎1个Petabyte的资料，其平台为美国Los Alamos国家实验室所有的具1024个处理器之大型系统）的图形应用函式库。
2005年时曾被美国陆军研究实验室用于即时模拟俄罗斯制反导弹战车ZSU23-4受到平面波攻击的情形，其计算节点高达2.5兆个之多。cgkit,Python Computer Graphics Kit,其module 主要分两个部分，
\1. 与3d相关的一些python module 例如the vector, matrix and quaternion types, the RenderMan bindings, noise functions 这些模块可以在maya houdini nuke blender 等有Python扩展的程序中直接用;
\2. 提供完整的场景操作的module， 他类似其他三维软件，在内存中保留完整的描述场景的信息。
不能直接用于maya 等CGAL，
Computational Geometry Algorithms Library，计算几何算法库，提供计算几何相关的数据结构和算法，诸如三角剖分（2D约束三角剖分及二维和三维Delaunay三角剖分），
Voronoi图（二维和三维的点，2D加权Voronoi图，分割Voronoi图等），
多边形（布尔操作，偏置），多面体（布尔运算），曲线整理及其应用，
网格生成（二维Delaunay网格生成和三维表面和体积网格生成等），几何处理（表面网格简化，细分和参数化等），
凸壳算法（2D，3D和dD），搜索结构（近邻搜索，kd树等），插值，形状分析，拟合，距离等。
Aggdraw，开源图像库，几乎涵盖了2d image操作的所有功能，使用起来非常灵活Pycairo,开源矢量绘图库Cairo开罗的python接口，
cairo提供在多个背景下做2-D的绘图，高级的更可以使用硬件加速功能。wand，Python绑定魔杖工具（MagickWand），C语言API接口。
thumbor， -智能成像工具，可调整大小和翻转图像。
imgSeek，查询相似的图像。
python-qrcode，纯Python的二维码（QR码）生成器。
pyBarcode，创建条码，无需PIL模块。
pygram，Instagram像图像过滤器。
Quads，基于四叉树的计算机艺术。
nude.py，裸体检测函数。
scikit-image，scikit工具箱的图像处理库。
hmap，图像直方图工具。
bokeh，交互的Web绘图。
plotly，Web协同的Python和Matplotlib绘制。
vincent，文森特，Python Vega的函数库。
d3py，Python绘图库，基于D3.JS, ggplot -API兼容R语言的ggplot2.Kartograph.py，在Python绘制漂亮的SVG地图。pygal， SVG图表的创造者。
pygraphviz，Graphviz的Python接口。
Fonttlools，ttf字体工具函数包，用于fontforge、ttx等字体软件。
游戏和多媒体
库名称简介audiolazy，数字信号处理（DSP）的Python工具包。
audioread，跨平台（GStreamer + Core Audio + MAD + FFmpeg）音频解码库。
beets，音乐库管理。
dejavu，音频指纹识别算法。
Dejavu 听一次音频后就会记录该音频的指纹信息，然后可通过麦克风对输入的音频进行识别是否同一首歌。django-elastic-transcoder,Django +亚马逊elastic转码。eyeD3,音频文件工具，特别是MP3文件包含的ID3元数据。
id3reader，用于读取MP3的元数据。
mutagen，处理音频元数据。
pydub，-操纵音频和简单的高层次的接口。
pyechonest，Echo Nest API客户端。talkbox，语音和信号处理的Python库。
TimeSide，开放的网络音频处理框架。
tinytag，读取音乐文件元数据，包括的MP3，OGG，FLAC和wave文件。
m3u8，用于解析m3u8文件。
moviepy，多格式视频编辑脚本模块，包括GIF动画。
shorten.tv，视频摘要。
scikit视频，SciPy视频处理例程。
GeoDjango,一个世界级的地理Web框架。
geopy,Geo地理编码的工具箱。
pygeoip，纯Python写的GeoIP API。
GeoIP，Python API接口，使用高精度GeoIP Legacy Database数据库。
geojson，GeoJSON函数库django-countries，一个Django程序，提供国家选择，国旗图标的静态文件，和一个国家的地域模型。
Pygame，Python游戏设计模块。
Cocos2d，2D游戏框架，演示，和其他的图形/交互应用，基于pyglet。Cocos2d- cocos2d is a framework for building 2D games, demos, and other graphical/interactive applications. It is based on pyglet.,PySDL2，SDL2的封装库。
Panda3D- 3D游戏引擎，迪士尼开发。
用C++写的，完全兼容Python。PyOgre，OGRE 3D渲染引擎，可用于游戏，模拟，任何3D。
PyOpenGL，绑定OpenGL和它相关的API。
PySFML，Python绑定SFMLRenPy，视觉小说引擎。
大数据与科学计算
库名称简介pycuda/opencl，GPU高性能并发计算Pandas，python实现的类似R语言的数据统计、分析平台。基于NumPy和Matplotlib开发的，主要用于数据分析和数据可视化，它的数据结构DataFrame和R语言里的data.frame很像，特别是对于时间序列数据有自己的一套分析机制，非常不错。
Open Mining，商业智能（BI），Pandas的Web界面。blaze，NumPy和Pandas大数据界面。
SciPy，开源的Python算法库和数学工具包，SciPy包含的模块有最优化、线性代数、积分、插值、特殊函数、快速傅里叶变换、信号处理和图像处理、常微分方程求解和其他科学与工程中常用的计算。
其功能与软件MATLAB、Scilab和GNU Octave类似。
Numpy和Scipy常常结合着使用，Python大多数机器学习库都依赖于这两个模块。
ScientificPython，一组经过挑选的Python程序模块，用于科学计算，包括几何学（矢量、张量、变换、矢量和张量场），四元数，自动求导数，（线性）插值，多项式，基础统计学，非线性最小二乘拟合，单位计算，Fortran兼容的文本格式，通过VRML的3D显示，以及两个Tk小工具，分别用于绘制线图和3D网格模型。
此外还具有到netCDF，MPI和BSPlib库的接口。
NumPy科学计算库，提供了矩阵，线性代数，傅立叶变换等等的解决方案, 最常用的是它的N维数组对象. NumPy提供了两种基本的对象：
ndarray（N-dimensional array object）和 ufunc（universal function object）。
ndarray是存储单一数据类型的多维数组，而ufunc则是能够对数组进行处理的函数。
Cvxopt，最优化计算包，可进行线性规划、二次规划、半正定规划等的计算。
Numba，科学计算速度优化编译器。pymvpa2，是为大数据集提供统计学习分析的Python工具包，它提供了一个灵活可扩展的框架。
它提供的功能有分类、回归、特征选择、数据导入导出、可视化等NetworkX，复杂网络的优化软件包。zipline，交易算法的函数库。
PyDy， Python动态建模函数库。
SymPy,符号数学的Python库。statsmodels,Python的统计建模和计量经济学。
astropy,天文学界的Python库。
orange，橙色，数据挖掘，数据可视化，通过可视化编程或Python脚本学习机分析。
RDKit,化学信息学和机器学习的软件。
Open Babel，巴贝尔，开放的化学工具箱。
cclib，化学软件包的计算函数库。
Biopython，免费的生物计算工具包。
bccb，生物分析相关的代码集。bcbio-nextgen，提供完全自动化、高通量、测序分析的工具包。
visvis, 可视化计算模块库，可进行一维到四维数据的可视化。
MapReduce是Google提出的一个软件[架构]，用于大规模数据集（大于1TB）的并行运算。
概念“Map（映射）”和“Reduce（归纳）”，及他们的主要思想，都是从函数式编程语言借来的MapReduce函数库。Framworks and libraries for MapReduce.,PySpark，[Spark]的Python API。dpark，Spark的Python克隆，Python中的MapReduce框架。luigi，为批量工作，建立复杂的管道。mrjob，运行在[Hadoop]，或亚马逊网络服务的，MapReduce工作。
人工智能与机器学习
库名称简介NLTK（natural language toolkit)，是python的自然语言处理工具包。2001年推出，包括了大量的词料库，以及自然语言处理方面的算法实现：
分词， 词根计算， 分类， 语义分析等。
Pattern，数据挖掘模块，包括自然语言处理，机器学习工具，等等。
textblob，提供API为自然语言处理、分解NLP任务。基于NLTK和Pattern模块。
jieba，结巴，中文分词工具。snownlp，用于处理中文文本库。
loso，中文分词函数库。
genius，中文CRF基础库，条件随机场(conditional random field,简称 CRF),是一种鉴别式机率模型,是随机场的一种,常用于标注或分析序列资料,如自然语言文字或是生物序列Gensim，一个相当专业的主题模型Python工具包，无论是代码还是文档，可用于如何计算两个文档的相似度LIBSVM,是台湾大学林智仁(Lin Chih-Jen)教授等开发设计的一个简单、易于使用和快速有效的SVM模式识别与回归的软件包，他不但提供了编译好的可在Windows系列系统的执行文件，还提供了源代码，方便改进、修改以及在其它[操作系统]上应用；
该软件对SVM所涉及的参数调节相对比较少，提供了很多的默认参数，利用这些默认参数可以解决很多问题；
并提供了交互检验(Cross Validation)的功能。
该软件可以解决C-SVM、ν-SVM、ε-SVR和ν-SVR等问题，包括基于一对一算法的多类模式识别问题。
scikits.learn，构建在SciPy之上用于机器学习的 Python 模块。它包括简单而高效的工具，可用于数据挖掘和数据分析。
涵盖分类，回归和聚类算法，例如SVM， 逻辑回归，朴素贝叶斯，随机森林，k-means等算法，代码和文档都非常不错，在许多Python项目中都有应用。
例如在我们熟悉的NLTK中，分类器方面就有专门针对scikit-learn的接口，可以调用scikit-learn的分类算法以及训练数据来训练分类器模型。PyMC，机器学习采样工具包，scikit-learn似乎是所有人的宠儿，有人认为，PyMC更有魅力。
PyMC主要用来做Bayesian分析。Orange，基于组件的数据挖掘和机器学习软件套装，它的功能即友好，又很强大，快速而又多功能的可视化编程前端，以便浏览数据分析和可视化，包含了完整的一系列的组件以进行数据预处理，并提供了数据帐目，过渡，建模，模式评估和勘探的功能。
侧重数据挖掘，可以用可视化语言或Python进行操作，拥有机器学习组件，还具有生物信息学以及文本挖掘的插件。
Milk，机器学习工具箱，其重点是提供监督分类法与几种有效的分类分析：SVMs(基于libsvm)，K-NN，随机森林经济和决策树。
它还可以进行特征选择。这些分类可以在许多方面相结合，形成不同的分类系统。对于无监督学习，它提供K-means和affinity propagation聚类算法。
PyMVPA(Multivariate Pattern Analysis in Python),是为大数据集提供统计学习分析的Python工具包，它提供了一个灵活可扩展的框架。它提供的功能有分类、回归、特征选择、数据导入导出、可视化等NuPIC，开源人工智能平台。
该项目由Grok（原名 Numenta）公司开发，其中包括了公司的算法和软件架构。
NuPIC 的运作接近于人脑，“当模式变化的时候，它会忘掉旧模式，记忆新模式”。如人脑一样，CLA 算法能够适应新的变化。Pylearn2，-基于Theano的机器学习库。
hebel，GPU加速，[深度学习]Python库。
gensim，机器学习库。pybrain，机器学习模块，它的目标是为机器学习任务提供灵活、易应、强大的机器学习算法。
pybrain包括神经网络、强化学习(及二者结合)、无监督学习、进化算法。以神经网络为核心，所有的训练方法都以神经网络为一个实例Mahout,是 Apache Software Foundation（ASF） 旗下的一个开源项目，提供一些可扩展的机器学习领域经典算法的实现，旨在帮助开发人员更加方便快捷地创建智能应用程序。
Mahout包含许多实现，包括聚类、分类、推荐过滤、频繁子项挖掘。此外，通过使用 Apache Hadoop 库，Mahout 可以有效地扩展到云中。
Crab，灵活的，快速的推荐引擎。python-recsys，娱乐系统分析，推荐系统。vowpal_porpoise，Vowpal Wabbit轻量级Python封装。
Theano,用来定义、优化和模拟数学表达式计算，用于高效的解决多维数组的计算问题的python软件包。它使得写深度学习模型更加容易，同时也给出了一些关于在GPU上训练它们的选项。
系统与命令行
库名称简介threading，Python标准线程库，更高级别的线程接口。
envoy，特使，Python子线程的函数库。
sh，成熟的子线程替换函数库。sarge，封装线程。subprocess,调用shell命令的神器argparse，写命令行脚本必备，强大的命令行差数解析工具timeit，计算代码运行的时间等等unp，命令行工具，解压文件。
eventlet开销很少的多线程模块，使用的是 green threads 概念，例如，pool = eventlet.GreenPool(10000) 这样一条语句便创建了一个可以处理 10000 个客户端连接的线程池。
类似Gevent线程库Gevent，多线程模块pytools,著名的python通用函数、工具包SendKeys, 键盘鼠标操作模块, 模拟键盘鼠标模拟操作。
pyHook,基于Python的“钩子”库，主要用于监听当前电脑上鼠标和键盘的事件。
这个库依赖于另一个Python库PyWin32，如同名字所显示的，PyWin32只能运行在Windows平台，所以PyHook也只能运行在Windows平台。
pstuil,跨平台地很方便获取和控制系统的进程，以及读取系统的CPU占用内存占用等信息.cement，一个轻量级的、功能齐全的命令行工具click，简单优雅的的命令行接口。
clint，Python命令行工具。cliff，创造多层次指令的命令行程序框架。
Clime， 可以转换任何模块为多的CLI命令程序，无任何配置。
docopt，Python命令行参数分析器。
pycli，命令行应用程序，支持的标准命令行解析，测井，单元[测试]和功能测试。
Gooey，打开命令行程序，作为为一个完整的GUI应用程序,cookiecutter，命令行工具，从cookiecutters（项目模板）创建项目。
例如，Python包项目，jQuery插件项目。
percol，为UNIX传统管道pipe命令，添加交互式选择风格。
rainbowstream，聪明和漂亮的推特客户终端。Django Models，Django的一部分SQLAlchemy，Python SQL工具包和对象关系映射。
peewee，小型的ORM解析器。
PonyORM，为ORM提供了一种面向SQL的接口。MongoEngine，Python对象文件映射，使用[MongoDB]。
, Django MongoDB引擎MongoDB , Django后台。
django-mongodb-engine，Django后台.redisco,一个简单的模型和容器库，使用[Redis]flywheel，Amazon DynamoDB对象映射。
butterdb，谷歌电子表格的ORM，Python版。celery，芹菜，异步任务队列/工作，基于分布式消息队列。
huey，休伊，轻量级，多线程任务队列。
mrq，队列先生，分布式任务队列，使用redis & Gevent。rq，简单的工作队列。
Queue,Queue模块可以用来实现多线程间通讯，让各个线程共享数据，生产者把货物放到Queue中，供消费者（线程）去使用。
simpleq，简单的，可扩展的队列，Amazon SQS基础队列。
Psyco，超强的python性能优化工具，psyco 的神奇在于它只需要在代码的入口处调用短短两行代码，性能就能提升 40% 或更多，真可谓是立竿见影！如果你的客户觉得你的程序有点慢，敬请不要急着去优化代码，psyco 或许能让他立即改变看法。
psyco 堪称 Python 的 jit。fn.py，Python函数编程：缺失的功能享受FP的实现。funcy，函数编程工具。
Toolz，函数编程工具：迭代器、函数，字典。CyToolz，Toolz的Cython实现，高性能的函数编程工具。Ansible，安塞波，极为简单的自动化平台。
SaltStack，基础设施的自动化管理系统。
Fabric，织物，一个简单，远程执行和部署的语言工具。
Fabtools，Fabric的工具函数。
cuisine，热门的Fabric的工具函数。
psutil，跨平台的过程和系统工具模块。
pexpect，控制互动节目。
provy，易于使用的配置系统的Python。honcho，Foreman的Python接口，用于管理procfile应用工具。
gunnery，多任务执行工具，与网络接口的分布式系统。
fig，快速。独立的开发环境中使用泊坞窗。
APScheduler，轻量级、但功能强大的在线任务调度程序。
django-schedule,Django日程应用程序。doit,任务流道/生成工具。
Joblib,Python提供的轻量级的流水线工具函数。
Plan，简易生成crontab文件。
Spiff，纯Python实现的，功能强大的工作流引擎。
schedule，Python作业调度。TaskFlow，有助于使任务执行简单。
ctypes，Python标准库，速度更快，Python调用C代码的外部函数接口。cffi，Python调用C代码外部函数接口，类似于ctypes直接在python程序中调用c程序,但是比ctypes更方便不要求编译成so再调用。
Cytoolz，python 加速库SWIG，简化封装和接口生成器。
,Cython，Python优化静态编译器。
PyPy，Python解释器的 Python实现。
Stackless Python，一个增强版本的Python。它使程序员从基于线程的编程方式中获得好处，并避免传统线程所带来的性能与复杂度问题。
Stackless为 Python带来的微线程扩展，是一种低开销、轻量级的便利工具Pyston,使用LLVM和现代JIT技术,对python进行性能优化。
pythonlibs，非官方的Windows（32 / 64位）的Python扩展包scapy，优秀的数据包处理库。
ino，Arduino命令行工具。Pyro，Python的机器人工具包。
pluginbase，一个简单而灵活的Python的插件系统。
itsdangerous，数据安全传输工具。blinker，快速Python中的信号/事件调度系统。
pychievements，用于创建和跟踪成果框架。
python-patterns，Python中的设计模式。
pefileWindows PE文件解析器SIP，自动为C和C++库生成Python扩展模块的工具
数据库
库名称简介MySQLdb，成熟的[MySQL]数据库模块,Baresql,SQL数据库包ZODB，Python本地对象数据库。一个K-V对象图数据库。
pickledb,简单和轻量级的K-V键值存储。
TinyDB, 轻量级，面向文档的数据库。
mysql-python，MySQL的Python工具库。
mysqlclient，mysql-python分支，支持Python 3.,PyMySQL,纯Python写的 MySQL驱动程序，兼容mysql-python。mysql-connector-python,MySQL连接器,来自[Oracle]，纯Python编写。
oursql，MySQL连接器，提供本地话指令语句和BLOBs支持。
psycopg2，最流行的Python PostgreSQL适配器。txpostgres，于Twisted的异步驱动，用于PostgreSQL。
queries,psycopg2函数库，用于PostgreSQL。
dataset,存储Python字典数据,用于SQLite，MySQL和PostgreSQL。
cassandra-python-driver，开源分布式NoSQL数据库系统Apache Cassandra系统的Python驱动.pycassa,简化的cassandra数据库Python驱动。
HappyBase，友好的Apache [Hbase]的函数库。
PyMongo，MongoDB官方客户端。
Plyvel，LevelDB快速和功能丰富的Python接口。redis-py,redis客户端。
py2neo,Python客户端(基于Neo4j的RESTful接口).telephus,基于Twisted的cassandra客户端。
txRedis，基于Twisted的Redis客户端。
【网络】Curl，Pycurl包是一个libcurl的Python接口，它是由C语言编写的。
与urllib相比，它的速度要快很多。
Libcurl是一个支持FTP, FTPS, HTTP, HTTPS, GOPHER, TELNET, DICT, FILE 和 LDAP的客户端URL传输库.libcurl也支持HTTPS认证,HTTP POST,HTTP PUT,FTP上传,代理,Cookies,基本身份验证,FTP文件断点继传,HTTP代理通道等等。
Requests，用Python语言编写，基于 urllib的开源 HTTP 库。
它比 urllib 更加方便，更加 Pythoner。
支持 Python3。httpie，命令行HTTP客户端，用户友好的cURL的替换工具。
s3cmd，命令行工具，用于管理Amazon S3和CloudFront。
youtube-dl，命令行程序，从YouTube下载视频。
you-get，Python3写的视频下载工具，可用于YouTube/Youku优酷/Niconico视频下载Coursera，从coursera.org下载视频，可重新命名文件wikiteam，wiki下载工具。
subliminal，命令行工具，搜索和下载字幕的函数库requests，HTTP函数库，更加人性化。grequests，异步HTTP请求+ Gevent（高性能高并发函数库）。
urllib3，一个线程安全的HTTP连接池，支持文件post。
httplib2，综合HTTP的客户端函数库。treq， Python API接口，Twisted的HTTP客户。
Mininet，流行的网络仿真器,API采用python编写。
POX，基于Python的开源软件定义网络（SDN）控制开发平台的应用，如OpenFlow的SDN控制器。
Pyretic，SDN的编程语言，提供了强大的抽象在网络交换机或仿真器。SDX Platform，基于SDN的IXP实现，利用最小网络，痘和热。inbox.py，Python的SMTP服务器。imbox， Python版本IMAP库。inbox，收件箱，开源邮件工具包。
lamson,SMTP服务器。flanker,侧卫,电子邮件地址和MIME解析库。
marrow.mailer,高性能可扩展邮件交付框架。
django-celery-ses， Django电子邮件后台，使用AWS SES和Celery。
modoboa，邮件托管和管理平台，包括现代和简化Web UI。
envelopes，邮件工具。
mailjet，批量邮寄mailjet API接口，带统计。Talon，利爪，Mailgun库，提取消息和签名。
mailjet- Mailjet API implementation for batch mailing, statistics and more., Talon - Mailgun library to extract message quotations and signatures.,pyzmail，编写，发送和解析电子邮件。
furl，燃料，小型的的URL解析库库。purl，简单的，干净的API，操纵URL。
pyshorteners，纯Python库，URL短网址编辑。
short_url，短网址生成。
Scrapy，快速屏幕截取和网页抓取的框架。
portia，波西亚，Scrapy的可视化扩展。
feedparser，信息源解释器RoboBrowser，简单的网页浏览Python函数库，没有使用Web浏览器。
MechanicalSoup，网站自动化互动测试工具包。
mechanize，网页浏览编程工具。
Demiurge，造物主，-PyQuery的轻量级工具。
newspaper,提取报纸新闻。html2text,转换HTML为 Markdown格式的文本。
python-goose,HTML内容提取器。
lassie,莱西,人性化的网站内容检索。
micawber,通过UR抓提网页的函数库。
sumy，概要，文本和HTML网页的自动文摘模块。
Haul，距离，可扩展的图像爬虫。
python-readability,可读性工具Arc90,快速的Python接口。
opengraph,OpenGraphProtocol协议解析模块,textract，从任何文件，Word，PowerPoint，PDF文件中提取文本，等。
sanitize，消毒，使混乱的数据变的理智。
AutobahnPython， WebSocket和WAMP的函数库，使用 Twisted和PythonWebSocket-for-Python，websocket客户端和服务器端函数库。SimpleXMLRPCServer，python标准库，简单的XML-RPC服务器，单线程。
SimpleJSONRPCServer，JSON-RPC规范实施函数库。
zeroRPC，基于ZeroMQ和MessagePack的RPC实现。
apache-libcloud，所有云服务的Python接口库。
wifi，WiFi -一套个Python库和命令行工具与WiFi，用于[Linux]。
streamparse，运行Python代码和数据的实时流。
集成了Apache Storm。
boto，亚马逊网络服务接口。
twython，Twitter推特API。google-api-python-client，谷歌客户端API。
gspread，谷歌电子表格的Python API。
facebook-sdk，facebook平台Python SDK。
facepy，简易的facebook图形APIgmail，Gmail的Python接口。
django-wordpress，Django的WordPress的模型和视图。
【Web框架】Django，最流行的Python-Web框架，鼓励快速开发,并遵循MVC设计，开发周期短ActiveGrid企业级的Web2.0解决方案Karrigell简单的Web框架，自身包含了Web服务，py脚本引擎和纯python的数据库PyDBLitewebpy一个小巧灵活的Web框架，虽然简单但是功能强大CherryPy基于Python的Web应用程序开发框架Pylons基于Python的一个极其高效和可靠的Web开发框架Zope开源的Web应用服务器TurboGears基于Python的MVC风格的Web应用程序框架Twisted流行的网络编程库，大型Web框架QuixoteWeb开发框架Flask,轻量级web框架Bottle，快速，简单和轻量级的WSGI模式Web框架。
Pyramid，轻量级，快速，稳定的开源Web框架。
web2py，简单易用的全堆栈Web框架和平台。
web.py，强大、简单的Web框架。TurboGears，便于扩展的Web框架。
CherryPy，极简Python Web框架，支持，HTTP 1.1和WSGI线程池。
Grok，基于Zope3的Web框架。
Bluebream，开源的Web应用服务器，原名Zope 3。
guava，轻量级，高性能的Python-Web框架，采用c语言编写。
django-cms，基于Django企业级开源CMS。
djedi-cms轻量级但功能强大的Django CMS的插件，内联编辑和性能优化。
FeinCMS，基于Django的先进内容管理系统。
Kotte，高层次的Python的Web应用框架，基于Pyramid。Mezzanine，强大，一致，灵活的内容管理平台。
Opps，基于Django的CMS，用于高流量的报纸、杂志和门户网站。
Plone，基于Zope的开源应用服务器Zope。
Quokka，灵活，可扩展的，轻量级的CMS系统，使用Flask和MongoDB。
Wagtail，Django内容管理系统。
Widgy，CMS框架，基于Django。
django-oscar，Django奥斯卡，开源的电子商务框架。
django-shop，基于Django的网店系统。
merchant，支持多种付款处理工具。
money，可扩展的货币兑换解决方案。
python-currencies，货币显示格式。
cornice，Pyramid的REST框架。
django-rest-framework，Django框架，强大灵活的工具，可以很容易地构建Web API。
django-tastypie，创造精美的Django应用程序API接口。
django-formapi，创建JSON API、HMAC认证和Django表单验证。flask-api，提供统一的浏览器体验，基于Django框架。
flask-restful，快速构建REST API支持扩展。
flask-api-utils，flask的扩展。falcon，猎鹰，高性能的Python框架，构建云API和Web应用程序后端。
eve，夏娃，REST API框架，使用Flask，MongoDB和良好意愿。
sandman，睡魔，为现有的数据库驱动的系统，自动生成REST API。restless，类似TastyPie的框架。
savory-pie，REST API构建函数库（Django，及其他）Jinja2，现代设计师友好的语言模板。
Genshi，网络感知输出模板工具包。
Mako，马可，Python平台的超高速、轻型模板。
Chameleon，变色龙，一个HTML / XML模板引擎。
仿照ZPT，优化速度。
Spitfire，快速的Python编译模板。
django-haystack,大海捞针,Django模块搜索。
elasticsearch-py,Elasticsearch官方低级的Python客户端。
solrpy,solr客户端。
Whoosh,呼,快速，纯Python搜索引擎库。
Feedly，建立新闻和通知系统的函数库，使用Cassandra和Redis。
django-activity-stream,Django活动流,从你网站上的行动,产生通用的活动流。
Beaker，烧杯，一个缓存和会话使用的Web应用程序，独立的Python脚本和应用程序库。
dogpile.cache，是Beaker作者的下一代替代作品。HermesCache，Python的缓存库，基于标签的失效及预防Dogpile效果。
django-cache-machine，Django缓存机，自动缓存失效，使用ORM。django-cacheops，自动颗粒事件驱动，ORM缓存失效。johnny-cache,约翰尼高速缓存框架,Django应用程序。
django-viewlet,渲染模板部件扩展缓存控制。pylibmc,在libmemcached接口。
WTForms-JSON,JSON表单数据处理扩展。Deform， HTML表单生成的函数库。
django-bootstrap3，bootstrap3，集成了Django。django-crispy-forms，Django程序，可以创建优雅的表单。django-remote-forms，Django的远程表单，Django表格的序列化程序。
django-simple-spam-blocker，Django简单的垃圾邮件拦截器。
django-simple-captcha，Django简单验证码，简单的和高度可定制的Django应用程序，用于添加验证码图像Ajenti，服务器管理面板。
Grappelli，界面花哨的django皮肤。django-suit，Django替代o界面（仅用于非商业用途）。
django-xadmin，Django管理面板替代工具。
flask-admin，简单的flask管理界面框架flower，实时监控和Web管理面板。
Pelican，鹈鹕，Markdown或ReST，字王内容主题。支持 DVCS, Disqus. AGPL。
Cactus,仙人掌,设计师的网站静态生成器。
Hyde，海德， 基于Jinja2的静态网站生成器。
Nikola，尼古拉-一个静态网站和博客生成器。
Tags，标签，最简单的静态网站生成器。
Tinkerer，工匠，基于Sphinx的静态网站生成器。
asyncio，（在Python 3.4 +是Python标准库），异步I/O，事件循环，协同任务。
gevent，基于Python的网络库。
Twisted，扭曲，事件驱动的网络引擎。
Tornado，龙卷风，Web框架和异步网络的函数库。
pulsar，脉冲星，事件驱动的并行框架的Python。
diesel，柴油，绿色的，基于事件的I/O框架。
eventlet，WSGI支持异步框架。
pyzmq， 0MQ消息库的Python封装。
txZMQ,基于Twisted的0MQ消息库封Crossbar,开源统一应用路由器（WebSocket和WAMP）。
wsgiref，Python标准库，WSGI封装实现，单线程。
Werkzeug，机床，WSGI工具函数库，很容易地嵌入到你自己的项目框架。
paste，粘贴，多线程，稳定的，久经考验的WSGI工具。
rocket，火箭，多线程服务，基于Pyramid。
netius，快速的、异步WSGI服务器，gunicorn，forked前身，部分用C写的。
fapws3，异步网络，用C写的。meinheld，异步WSGI服务器，是用C写的。
bjoern，-快速的、异步WSGI服务器，用C写的。
【安全】Permissions函数库，允许或拒绝用户访问数据或函数。
django-guardian,Django守护者，管理每个对象的权限，用于Django 1.2 +Carteblanche，管理导航和权限。
Authomatic，简单强大的认证/授权客户端。
OAuthLib， 通用，规范，OAuth请求签约工具。
rauth，用于OAuth 1.0，2.0，的Python库。
python-oauth2，利用全面测试，抽象接口来创建OAuth的客户端和服务器。
python-social-auth，易于安装的社会认证机制。
,django-oauth-toolkit,Django OAuth工具包django-oauth2-provider,Django OAuth2工具包。
django-allauth，Django认证的应用程序。
Flask-OAuthlib，Flask的OAuth工具包sanction，制裁，简单的oauth2客户端。
jose，[JavaScript]对象签名和加密(JOSE)草案实施，标记状态。
python-jwt，JSON的Web令牌生成和验证模块。
pyjwt，JSON的Web令牌草案01。
python-jws，JSON的Web令牌草案02。
PyCrypto，Python的加密工具包。
Paramiko，sshv2协议的实现，提供了客户端和服务器端的功能。
cryptography，密码开发工具包。
PyNac，网络和密码（NaCl）函数库。hashids，hashids的 Python函数库。
Passlib，安全的密码存储/哈希库，非常高的水平。
hashlib,md5, sha等hash算法，用来替换md5和sha模块，并使他们的API一致。
它由OpenSSL支持，支持如下算法：md5,sha1, sha224, sha256, sha384, sha512.
GUI
PyGtk，基于Python的GUI程序开发GTK+库
PyQt用于Python的QT开发库
WxPythonPython下的GUI编程框架，其消息机制与MFC的架构相似,入门非常简单，需要快速开发相关的应用可以使用这个
TkinterPython下标准的界面编程包，因此不算是第三方库了
PySide，跨平台Qt的应用程序和用户界面框架，支撑Qt v4框架。
wxPython，混合wxWidgets的C++类库。
kivy，创建应用程序GUI函数库，看运行于Windows，Linux，MAC OS X，[Android]和[iOS]。
curse，用于创建终端GUI应用程序。
urwid，创建终端GUI应用程序窗体的函数库，支持事件，色彩丰富。
pyglet，跨平台的窗口和多媒体库的Python。
Tkinter，是Python事实上的标准GUI软件包。
enaml，创建漂亮的用户界面，语法类似QML。
Toga，托加，OS原生GUI工具包。【构建封装】
pyenv,简单的Python版本管理。
virtualenv,创建独立的Python环境，用于同时安装不同版本的python环境。
virtualenvwrapper，是virtualenv的一组扩展。
pew,一套管理多个虚拟环境的工具。
vex，使运行指定的virtualenv命令。
PyRun，一个单文件，无需安装的Python版本管理工具。
PIP，Python包和依赖的管理工具。
easy_install，软件包管理系统,提供一个标准的分配Python软件和 函式库的格式。是一个附带设置工具的模块，和一个第三方函式库。旨在加快Python函式库的分配程式的速度。类似Ruby语言的RubyGems 。
conda，跨平台，二进制软件包管理器。,
Curdling，一个管理Python包的命令行工具。
wheel，Python发行的新标准，旨在替代eggs.
cx-Freeze，跨平台的，用于打包成可执行文件的库
py2exe, Windows平台的Freeze脚本工具，Py2exe ，将python脚本转换为windows上可以独立运行的可执行程序
py2app，MAC OS X平台的Freeze脚本工具
pyinstaller，-转换成独立的可执行文件的Python程序（跨平台）。
pynsist,构建Windows安装程序的工具，用Python编写。
dh-virtualenv,建立和分发virtualenv(Debian软件包格式)
PyPI，新一代的Python包库管理工具。
warehouse,新一代的Python包库（PyPI）管理工具。
devpi，PyPI服务器和包装/测试/发布工具。
localshop，PyPI官方包镜像服务器，支持本地（私人）包上传。
buildout，创建，组装和部署应用程序的多个部分，其中一些可能是非基于Python的。
SCons，软件构造工具。
platformio，一个控制台的工具，构建的代码可用于不同的开发平台。
bitbake，特殊设计的工具，用于创建和部署[嵌入式]Linux软件包
fabricate，自动为任何编程语言，生成依赖包。
django-compressor，Django压缩机，压缩和内联JavaScript或CSS，链接到一个单一的缓存文件。
jinja-assets-compressor，金贾压缩机，一个Jinja扩展，通过编译，压缩你的资源。
webassets，优化管理，静态资源，独特的缓存清除。
fanstatic，球迷，包优化，提供静态文件。
fileconveyor，监控资源变化，，可保存到CDN（内容分发网络）和文件系统。
django-storages，一组自定义存储Django后台。
glue，胶胶，一个简单的命令行工具，生成CSS Sprites。
libsass-python，Sass (层叠样式表)的Python接口。
Flask-Assets，整合应用程序资源。【代码调试】
unittest，Python标准库，单元测试框架。
nose，鼻子，unittest延伸产品。
pytest，成熟的全功能的Python测试工具。
mamba，曼巴，Python的权威测试工具。出自BDD的旗下。
contexts，背景，BDD测试框架，基于C#。
pyshould，should风格的测试框架，基于PyHamcrest.
pyvows，BDD风格测试框架
Selenium，web测试框架，Python绑定Selenium。
splinter，分裂，测试Web应用程序的开源工具。
locust，刺槐，可扩展的用户负载测试工具，用Python写的。
sixpack，语言无关的A/B测试框架。
mock，模拟对象（英语：mock object，也译作模仿对象），模拟测试库。
responses，工具函数，用于mock模拟测试。
doublex-强大的测试框架。
freezegun，通过时间调整，测试模块。
httpretty， HTTP请求的模拟工具。
httmock，mock模拟测试。
coverage，代码覆盖度量测试。
faker，生成模拟测试数据的Python包。
mixer，混频器，产生模拟数据，用于Django ORM，SQLAlchemy，
Peewee, MongoEngine, Pony ORM等
model_mommy，在Django创建测试随机工具。
ForgeryPy，易用的模拟数据发生器。
radar，雷达，生成随机日期/时间。
FuckIt.py，测试Python代码运行。
Code Analysispysonar2，Python类型索引。
pycallgraph,可视化的流量（调用图）应用程序。
code2flow,转换Python和JavaScript代码到流程图。
LinterFlake8，源代码模块检查器
pylama，Python和JavaScript代码审计工具。
Pylint，源代码分析器，它查找编程错误，帮助执行一个代码标准和嗅探一些代码味道。注意：相比于PyChecker，Pylint是一个高阶的Python代码分析工具，它分析Python代码中的错误。
Pyflakes，一个用于检查Python源文件错误的简单程序。Pyflakes分析程序并且检查各种错误。它通过解析源文件实现，无需导入。
pdb,Python标准库,Python调试器。
ipdb,IPython使用的PDB。
winpdb独立于平台的GUI调试器。
pudb，全屏，基于python调试控制台。
pyringe，-可附着于及注入代码到Python程序的调试器。
python-statsd，statsd服务器客户端。
memory_profiler， 内存监视。
profiling，交互式Python分析器。
django-debug-toolbar, Django调试工具栏,显示各种调试信息:当前请求/响应。
django-devserver,Django调试工具。
flask-debugtoolbar,flask调试工具。
struct模块
2022年7月25日
15:15
该模块可以把一个类型，如数字，转成固定长度的bytes
data = ``struct.pack('i',1111111111111) ``封包
head_json_len=struct.unpack('i',``data ``)[0]#``解包，元组
Pil模块
2022年6月2日
23:47
PIL``功能介绍与安装
PIL``，全称``Python Image Library``，主要作用是图像处理，可用于图片剪切、粘贴、缩放、镜像、水印、颜色块、滤镜、图像格式转换、色场空间转换、验证码、旋转图像、图像增强、直方图处理、插值和滤波等功能。不过只支持到``Python 2.7``。``Pillow``是``PIL``的一个派生分支，但如今已经发展成为比``PIL``本身更具活力的图像处理库。我们需要安装的就是``Pillow``。
PIL``具体用途：图像归档``(Image Archives)``。``PIL``非常适合于图像归档以及图像的批处理任务。你可以使用``PIL``创建缩略图，转换图像格式，打印图像等等。
``图像展示``(Image Display)``。``PIL``较新的版本支持包括``Tk PhotoImage``，``BitmapImage``还有``Windows DIB``等接口。``PIL``支持众多的``GUI``框架接口，可以用于图像展示。
``图像处理``(Image Processing)``。``PIL``包括了基础的图像处理函数，包括对点的处理，使用众多的卷积核``(convolution kernels)``做过滤``(filter),``还有颜色空间的转换。``PIL``库同样支持图像的大小转换，图像旋转，以及任意的仿射变换。``PIL``还有一些直方图的方法，允许你展示图像的一些统计特性。这个可以用来实现图像的自动对比度增强，还有全局的统计分析等。
pip install Pillow
PIL的基本操作
from PIL import Image
# 1.``打开图片
img = Image.open("image/10.png")
# 2.``显示图片``(``执行显示图片后线程会中断，关闭图像后恢复``)
img.show()
# 3.``保存图片
img.save("image/xiaomai.png")
我在尝试的过程中发现，``png``格式的图片保存为``jpg``格式时会报错：``OSError: cannot write mode RGBA as JPEG``，经过查阅资料发现错误原因主要是因为``PNG``格式和``JPG``格式图片的通道数不同。
PNG``是四通道：``RGBA``意思是红色，绿色，蓝色，``Alpha``的色彩空间，``Alpha``指透明度
JPG``是三通道：``RGB``意思是红色，绿色，蓝色
所以，``PNG``格式图片要保存成``JPG``格式就要丢弃``A``通道：
from PIL import Image
# 1.``打开图片
img = Image.open("image/10.png")
# 2.``显示图片``(``执行显示图片后线程会中断，关闭图像后恢复``)
img.show()
# 3.``保存图片
img = img.convert("RGB")
img.save("image/xiaomai.jpg")
下面是图片旋转的代码：
from PIL import Image
# 1.``打开图片
img = Image.open("pli/7.png")
# 2.``水平翻转
img1 = img.transpose(Image.FLIP_LEFT_RIGHT)
# 3.``保存图片
img1.save("pli/1.png")
# 4.``垂直翻转
img2 = img.rotate(180)
# 5.``保存照片
img2.save("pli/2.png")
# 6.``水平``+``垂直翻转
img3 = img.transpose(Image.FLIP_LEFT_RIGHT).rotate(180)
# 7.``保存图片
img3.save("pli/3.png")
给图片增加文字
要在图像上绘制文本要用到 PIL 的两个模块：ImageDraw和ImageFont。 ImageDraw 用于创建绘图对象，ImageFont用于加载字体。
from PIL import Image, ImageDraw, ImageFont
# 1.``打开图片
img = Image.open("image/10.png")
# 2.``调用画图模块
draw = ImageDraw.Draw(img)
# 3.``设置字体
tfont = ImageFont.truetype("``萌神手写体``.ttf", 24)
# 4.``添加文字
"""
``参数一：文字在图片的位置：``(x, y)
``参数二：文字内容
``参数三：字体颜色，当然颜色也可以用``RGB``值指定
``参数四：字体类型
"""
draw.text((50, 30), "eyes++", fill="green", font=tfont)
# 5.``保存图片
img.save("image/addWord.png")
# 6.``显示图片
img.show()
PIL滤镜功能
from PIL import Image, ImageFilter
img = Image.open("image/10.png")
img = img.filter(ImageFilter.CONTOUR)
img.save("image/Filter.png")
img.show()
PIL镜像功能
from PIL import Image
img = Image.open("image/10.png")
img = img.transpose(Image.FLIP_LEFT_RIGHT)
img.save("image/mirror.png")
transpose有这么几种模式
FLIP_LEFT_RIGHT：左右镜像
FLIP_TOP_BOTTOM：上下镜像
ROTATE_90：逆时针转90度
ROTATE_180：逆时针转180度
ROTATE_270：逆时针转270度
TRANSPOSE：像素矩阵转置
TRANSVERSE
最后一种模式我也不知道什么意思，也没查到，但效果是下面这样的，盲猜是对角线对转。。。。。
图片拼接功能
from PIL import Image, ImageDraw
# ``打开图片
img1 = Image.open("image/10.png")
img2 = Image.open("image/addWord.png")
# ``查看图片尺寸，便于拼接图片
print(img1.size)
print(img1.size)
# ``新建空白图片``,``三个参数分别是模式``(RGB/RGBA)``、大小、颜色
newimg = Image.new(mode="RGB", size=(1174, 614), color=(255, 100, 50))
# ``拼接图片``,``第一个参数是图片，第二个是起始位置
newimg.paste(img1, (0, 0))
newimg.paste(img2, (587, 0))
newimg.show()
PIL裁剪功能
from PIL import Image
img = Image.open("image/10.png")
print(img.size)
imgCut = img.crop((100, 200, 500, 600))
imgCut.show()
图片缩放
from PIL import Image
# :
img = Image.open('image/10.png')
# ``获得图像尺寸``:
w, h = img.size
# ``缩放到``50%:
img.thumbnail((w//2, h//2))
# ``把缩放后的图像用``jpeg``格式保存``:
img.save('image/zoom.png')
warnings — 非致命提醒
2022年10月13日
16:45
warnings — 非致命提醒
目的：向用户提供有关运行程序时遇到的问题的非致命警报
warnings ``模块由`` PEP 230 ``引入，作为一种警告程序员关于语言或库功能的变化的方法，以预测`` Python 3.0 ``带来的向后不兼容的变化。它还可用于报告从丢失的库中恢复的配置错误或功能退化。不过，最好是通过`` logging ``模块提供面向用户的消息，因为发送到控制台的警告可能丢失。
由于警告不是致命的，因此程序在运行过程中可能会多次遇到相同的警告情况。``warnings ``模块抑制来自同一来源的重复消息，以减少一遍又一遍地看到相同警告的烦恼。输出可以根据具体情况进行控制，使用解释器的命令行选项或调用`` warnings ``中的函数。
Python ``通过调用`` warnings ``模块中定义的`` warn() ``函数来发出警告``。警告消息通常用于提示用户一些错误或者过时的用法，当这些情况发生时我们不希望抛出异常或者直接退出程序。警告消息通常写入`` sys.stderr``，对警告的处理方式可以灵活的更改，例如忽略或者转变为为异常。警告的处理可以根据警告类别，警告消息的文本和发出警告消息的源位置而变化。对相同源位置的特定警告的重复通常被抑制。
警告控制分为两个阶段：
- 首先，警告被触发时，确定是否应该发出消息；
- 接下来，如果要发出消息，则使用用户可设置的钩子来格式化和打印消息。
filterwarnings()--警告过滤器
警告过滤器可以用来控制是否发出警告消息，警告过滤器是一些匹配规则和动作的序列。可以通过调用`` filterwarnings() ``将规则添加到过滤器，并通过调用`` resetwarnings() ``将其重置为默认状态。
showwarning()--警告消息
警告消息的输出是通过调用`` showwarning() ``函数来完成的，其可以被覆盖；该函数的默认实现通过调用`` formatwarning() ``格式化消息，这也可以由自定义实现使用。
警告类别
內建警告类型：
Warning 所有警告类别类的基类，它是 Exception 的子类
UserWarning 函数 warn() 的默认类别
DeprecationWarning 用于已弃用功能的警告（默认被忽略）
SyntaxWarning 用于可疑语法的警告
RuntimeWarning 用于有关可疑运行时功能的警告
FutureWarning 对于未来特性更改的警告
PendingDeprecationWarning 对于未来会被弃用的功能的警告（默认将被忽略）
ImportWarning 导入模块过程中触发的警告（默认被忽略）
UnicodeWarning 与 Unicode 相关的警告
BytesWarning 与 bytes 和 bytearray 相关的警告 (Python3)
ResourceWarning 与资源使用相关的警告(Python3)
可以通过继承內建警告类型来实现自定义的警告类型，警告类型必须始终是 Warning 类的子类。
警告过滤器
警告过滤器用于控制警告的行为，如忽略，显示或转换为错误（引发异常）。警告过滤器维护着一个有序的过滤规则列表，匹配规则用于确定如何处理警告，任何特定警告都将依次与列表中的每个过滤规则匹配，直到找到匹配为止。过滤规则类型为一个元组 (action，message，category，module，lineno)，其中：
- action 为以下值：
值 处理方式
"error" 将匹配警告转换为异常
"ignore" 忽略匹配的警告
"always" 始终输出匹配的警告
"default" 对于同样的警告只输出第一次出现的警告
"module" 在一个模块中只输出第一次出现的警告
"once" 输出第一次出现的警告,而不考虑它们的位置
- message 是包含正则表达式的字符串，警告消息的开始必须匹配，不区分大小写
- category 是一个警告类型（必须是 Warning 的子类）
- module 是包含模块名称的正则表达式字符串，区分大小写
- lineno 是一个整数，警告发生的行号，为 0 则匹配所有行号
默认警告过滤器
默认情况下，``Python ``设置了几个警告过滤器，可以通过`` -W ``命令行选项和调用`` filterwarnings() ``函数来覆盖它们。
DeprecationWarning ``和`` PendingDeprecationWarning ``和`` ImportWarning ``被默认忽略。
除非`` -b ``选项给出一次或两次，否则忽略`` BytesWarning``；在这种情况下，此警告或者被输出（``-b``）或者变成异常（``-bb``）。
除非`` Python ``是在调试模式下构建的，否则将忽略`` ResourceWarning``。
在`` 3.2 ``版中的调整``: ``除`` PendingDeprecationWarning ``之外，默认情况下将忽略`` DeprecationWarning
可用函数
1. warn
warnings.warn(message, category=None, stacklevel=1, source=None)
触发异常。``category`` ``参数默认为`` ``UserWarning``。``message`` ``参数为警告消息，可以是`` ``Warning`` ``实例，在这种情况下，将忽略`` ``category`` ``并使用`` ``message.__class__``，消息文本则为`` ``str(message)``。
warn_explicit
warnings.warn_explicit(message, category, filename, lineno, module=None, registry=None, module_globals=None, source=None)
是 warn() 函数的低级接口，明确传递消息，类别，文件名和行号，以及可选的模块名称和注册表（应该是模块的 warningregistry 字典）
3.showwarning
warnings.showwarning(message, category, filename, lineno, file=None, line=None)
写入警告到文件。默认调用`` formatwarning(message, category, filename, lineno, line) ``并将结果字符串写入`` file``，默认为`` sys.stderr``。`` line ``是包含在警告消息中的一行源代码；如果未提供则尝试读取由`` filename ``和`` lineno ``指定的行。
simplefilter
warnings.simplefilter(action, category=Warning, lineno=0, append=False)
简单易用的过滤器，类似 filterwarnings() 函数，但是不需要正则表达式。
resetwarnings
warnings.resetwarnings()
重置警告过滤器。这会丢弃所有以前对 filterwarnings() 调用的影响，包括 -W 命令行选项和对 simplefilter() 的调用的影响。
生成警告
发出警告的最简单方法是使用消息作为参数调用`` ``warn()`` ``。
import warnings
print('Before the warning')
warnings.warn('This is a warning message')
print('After the warning')
Socketserver模块
2022年7月25日
21:01
基于tcp的套接字，关键就是两个循环，
一个链接循环，一个通信循环
socketserver模块中分两大类：
server类（解决链接问题）
request类（解决通信问题）
server类：
request类：
继承关系:
以下述代码为例，分析socketserver源码：
ftpserver=socketserver.ThreadingTCPServer(('17.0.0.1',8080),FtpServer)
ftpserver.serve_forever()
查找属性的顺序：ThreadingTCPServer->ThreadingMixIn->TCPServer->BaseServer
- 实例化得到ftpserver，先找类ThreadingTCPServer的__init__,在TCPServer中找到，进而执行server_bind,server_active
- 找ftpserver下的serve_forever,在BaseServer中找到，进而执行self._handle_request_noblock()，该方法同样是在BaseServer中
- 执行self._handle_request_noblock()进而执行request, client_address = self.get_request()（就是TCPServer中的self.socket.accept()），然后执行self.process_request(request, client_address)
- 在ThreadingMixIn中找到process_request，开启多线程应对并发，进而执行process_request_thread，执行self.finish_request(request, client_address)
上述四部分完成了链接循环，本部分开始进入处理通讯部分，在BaseServer中找到finish_request,触发我们自己定义的类的实例化，去找__init__方法，而我们自己定义的类没有该方法，则去它的父类也就是BaseRequestHandler中找....
源码分析总结：
基于tcp的socketserver我们自己定义的类中的
- self.server即套接字对象
- self.request即一个链接
- self.client_address即客户端地址
基于udp的socketserver我们自己定义的类中的
- self.request是一个元组
（第一个元素是客户端发来的数据，第二部分是服务端的udp套接字对象），
如(b'adsf', <socket.socket fd=200, family=AddressFamily.AF_INET, type=SocketKind.SOCK_DGRAM, proto=0, laddr=('127.0.0.1', 8080)>)
- self.client_address即客户端地址
multiprocessing模块
2022年7月27日
12:50
介绍
multiprocessing模块的功能众多：支持子进程、通信和共享数据、执行不同形式的同步，提供了Process、Queue、Pipe、Lock等组件。
与线程不同，进程没有任何共享状态，进程修改的数据，改动仅限于该进程内。
Process类的介绍
创建进程的类
Process([group [, target [, name [, args [, kwargs]]]]])``，由该类实例化得到的对象，表示一个子进程中的任务（尚未启动）
强调：`
`1. ``需要使用关键字的方式来指定参数`
`2. args``指定的为传给``target``函数的位置参数，是一个元组形式，必须有逗号
参数
group``参数未使用，值始终为``None
target``表示调用对象，即子进程要执行的任务
args``表示调用对象的位置参数元组，``args=(1,2,'egon',)
kwargs``表示调用对象的字典``,kwargs={'name':'egon','age':18}
name``为子进程的名称
方法介绍
p.start()``：启动进程，并调用该子进程中的``p.run()
p.run():``进程启动时运行的方法，正是它去调用``target``指定的函数，我们自定义类的类中一定要实现该方法
p.terminate():``强制终止进程``p``，不会进行任何清理操作，如果``p``创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果``p``还保存了一个锁那么也将不会被释放，进而导致死锁
p.is_alive():``如果``p``仍然运行，返回``True
p.join([timeout]):``主线程等待``p``终止（强调：是主线程处于等的状态，而``p``是处于运行的状态）。``timeout``是可选的超时时间，需要强调的是，``p.join``只能``join``住``start``开启的进程，而不能``join``住``run``开启的进程
属性介绍
p.daemon``：默认值为``False``，如果设为``True``，代表``p``为后台运行的守护进程，当``p``的父进程终止时，``p``也随之终止，并且设定为``True``后，``p``不能创建自己的新进程，必须在``p.start()``之前设置
p.name:``进程的名称
p.pid``：进程的``pid
p.exitcode:``进程在运行时为``None``、如果为``–``N``，表示被信号``N``结束``(``了解即可``)
p.authkey:``进程的身份验证键``,``默认是由``os.urandom()``随机生成的``32``字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性，这类连接只有在具有相同的身份验证键时才能成功（了解即可）
僵尸进程与孤儿进程
一：僵尸进程（有害）
僵尸进程：
一个进程使用fork创建子进程，如果子进程退出，而父进程并没有调用wait或waitpid获取子进程的状态信息，那么子进程的进程描述符仍然保存在系统中。这种进程称之为僵死进程。
二：孤儿进程（无害）
孤儿进程：
一个父进程退出，而它的一个或多个子进程还在运行，那么那些子进程将成为孤儿进程。孤儿进程将被init进程(进程号为1)所收养，并由init进程对它们完成状态收集工作。
孤儿进程是没有父进程的进程，孤儿进程这个重任就落到了init进程身上，init进程就好像是一个民政局，专门负责处理孤儿进程的善后工作。每当出现一个孤儿进程的时候，内核就把孤 儿进程的父进程设置为init，而init进程会循环地wait()它的已经退出的子进程。这样，当一个孤儿进程凄凉地结束了其生命周期的时候，init进程就会代表党和政府出面处理它的一切善后工作。因此孤儿进程并不会有什么危害。
解决僵尸进程
等待父进程正常结束后会调用wait／waitpid去回收僵尸进程
但如果父进程是一个死循环，永远不会结束，那么该僵尸进程就会一直存在，僵尸进程过多，就是有害的
解决方法一：杀死父进程
解决方法二：对开启的子进程应该记得使用join，join会回收僵尸进程
解决方法三：
signal(``参数一``,``参数二``)
参数一：我们要进行处理的信号。系统的信号我们可以再终端键入 kill -l查看(共64个)。其实这些信号时系统定义的宏。
参数二：我们处理的方式（是系统默认还是忽略还是捕获）。可以写一个handdle函数来处理我们捕获的信号。
SIGCHLD信号
子进程结束时, 父进程会收到这个信号。
如果父进程没有处理这个信号，也没有等待(wait)子进程，子进程虽然终止，但是还会在内核进程表中占有表项，这时的子进程称为僵尸进程。这种情 况我们应该避免(父进程或者忽略SIGCHILD信号，或者捕捉它，或者wait它派生的子进程，或者父进程先终止，这时子进程的终止自动由init进程 来接管)。
SIG_ING
忽略的意思
守护进程
主进程创建守护进程
其一：守护进程会在主进程代码执行结束后就终止
其二：守护进程内无法再开启子进程,否则抛出异常：AssertionError: daemonic processes are not allowed to have children
注意：进程之间是互相独立的，主进程代码运行结束，守护进程随即终止
使用：``p.daemon=True #``一定要在``p.start()``前设置``,``设置``p``为守护进程``,``禁止``p``创建子进程``,``并且父进程代码执行结束``,p``即终止运行
案例：
frommultiprocessing import Process`
`import time`
`import random
class Piao(Process):`
` def__init__(self,name):`
` self.name=name`
` super().__init__()`
` def run(self):`
` print('%s is piaoing'%self.name)`
` time.sleep(random.randrange(1,3))`
` print('%s is piao end'%self.name)
p=Piao('egon')`
`p.daemon=True #``一定要在``p.start()``前设置``,``设置``p``为守护进程``,``禁止``p``创建子进程``,``并且父进程代码执行结束``,p``即终止运行
p.start()`
`print('``主``')
进程锁
进程之间数据不共享,但是共享同一套文件系统,所以访问同一个文件,或同一个打印终端,是没有问题的,
而共享带来的是竞争，竞争带来的结果就是错乱，如何控制，就是加锁处理
案例一：多个进程共享同一打印终端
未加锁：#并发运行,效率高,但竞争同一打印终端,带来了打印错乱
加锁: #由并发变成了串行,牺牲了运行效率,但避免了竞争
案例二：多个进程共享同一文件
未加锁：并发写入，效率高，但是竞争同一个文件，到时数据错乱
加锁：并发变成了串行，牺牲了运行效率，但是保证了数据的安全
总结：
#加锁可以保证多个进程修改同一块数据时，同一时间只能有一个任务可以进行修改，即串行的修改，没错，速度是慢了，但牺牲了速度却保证了数据安全。虽然可以用文件共享数据实现进程间通信，但问题是：
1.效率低（共享数据基于文件，而文件是硬盘上的
数据）
2.需要自己加锁处理
#因此我们最好找寻一种解决方案能够兼顾：
1、效率高（多个进程共享一块内存的数据）
2、帮我们处理好锁问题。
这就是mutiprocessing模块为我们提供的基于消息的IPC通信机制：队列和管道。
1 队列和管道都是将数据存放于内存中
2 队列又是基于（管道+锁）实现的，可以让我们从复杂的锁问题中解脱出来，
我们应该尽量避免使用共享数据，尽可能使用消息传递和队列，避免处理复杂的同步和锁问题，而且在进程数目增多时，往往可以获得更好的可获展性。
队列
进程彼此之间互相隔离，要实现进程间通信（IPC），multiprocessing模块支持两种形式：队列和管道，这两种方式都是使用消息传递的
创建队列的类（底层就是以管道和锁定的方式实现）：
Queue([maxsize]):创建共享的进程队列，Queue是多进程安全的队列，可以使用Queue实现多进程之间的数据传递。
maxsize是队列中允许最大项数，省略则无大小限制。
方法介绍：
q.put
方法用以插入数据到队列中，``put``方法还有两个可选参数：``blocked``和``timeout``。如果``blocked``为``True``（默认值），并且``timeout``为正值，该方法会阻塞``timeout``指定的时间，直到该队列有剩余的空间。如果超时，会抛出``Queue.Full``异常。如果``blocked``为``False``，但该``Queue``已满，会立即抛出``Queue.Full``异常。
q.get
方法可以从队列读取并且删除一个元素。
get``方法有两个可选参数：``blocked``和``timeout``。
如果``blocked``为``True``（默认值），并且``timeout``为正值，那么在等待时间内没有取到任何元素，会抛出``Queue.Empty``异常。
如果``blocked``为``False``，有两种情况存在，如果``Queue``有一个值可用，则立即返回该值，否则，如果队列为空，则立即抛出``Queue.Empty``异常``.
q.get_nowait():``同``q.get(False)
q.put_nowait():``同``q.put(False)
q.empty():
调用此方法时``q``为空则返回``True``，该结果不可靠，比如在返回``True``的过程中，如果队列中又加入了项目。
q.full()``：
调用此方法时``q``已满则返回``True``，该结果不可靠，比如在返回``True``的过程中，如果队列中的项目被取走。
q.qsize():
返回队列中目前项目的正确数量，结果也不可靠，理由同``q.empty()``和``q.full()``一样
q.cancel_join_thread():
不会在进程退出时自动连接后台线程。可以防止``join_thread()``方法阻塞
q.close():
关闭队列，防止队列中加入更多数据。
调用此方法，后台线程将继续写入那些已经入队列但尚未写入的数据，但将在此方法完成时马上关闭。如果``q``被垃圾收集，将调用此方法。关闭队列不会在队列使用者中产生任何类型的数据结束信号或异常。例如，如果某个使用者正在被阻塞在``get()``操作上，关闭生产者中的队列不会导致``get()``方法返回错误。
q.join_thread()``：
连接队列的后台线程。此方法用于在调用``q.close()``方法之后，等待所有队列项被消耗。默认情况下，此方法由不是``q``的原始创建者的所有进程调用。调用``q.cancel_join_thread``方法可以禁止这种行为
进程池
在利用Python进行系统管理的时候，特别是同时操作多个文件目录，或者远程控制多台主机，并行操作可以节约大量的时间。多进程是实现并发的手段之一，需要注意的问题是：
- 很明显需要并发执行的任务通常要远大于核数
- 一个操作系统不可能无限开启进程，通常有几个核就开几个进程
- 进程开启过多，效率反而会下降（开启进程是需要占用系统资源的，而且开启多余核数目的进程也无法做到并行）
例如当被操作对象数目不大时，可以直接利用multiprocessing中的Process动态成生多个进程，十几个还好，但如果是上百个，上千个。。。手动的去限制进程数量却又太过繁琐，此时可以发挥进程池的功效。
我们就可以通过维护一个进程池来控制进程数目，比如httpd的进程模式，规定最小进程数和最大进程数...
ps：对于远程过程调用的高级应用程序而言，应该使用进程池，Pool可以提供指定数量的进程，供用户调用，当有新的请求提交到pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到规定最大值，那么该请求就会等待，直到池中有进程结束，就重用进程池中的进程。
创建进程池的类：
如果指定numprocess为3，则进程池会从无到有创建三个进程，然后自始至终使用这三个进程去执行所有任务，不会开启其他进程
Pool([numprocess [,initializer [, initargs]]]):``创建进程池``
参数介绍
1 numprocess:``要创建的进程数，如果省略，将默认使用``cpu_count()``的值`
`2 initializer``：是每个工作进程启动时要执行的可调用对象，默认为``None`
`3 initargs``：是要传给``initializer``的参数组
方法介绍
p.apply(func[,args[,kwargs]]):
在一个池工作进程中执行``func(*args,**kwargs),``然后返回结果。需要强调的是：此操作并不会在所有池工作进程中并执行``func``函数。如果要通过不同参数并发地执行``func``函数，必须从不同线程调用``p.apply()``函数或者使用``p.apply_async()
p.apply_async(func[,args[,kwargs]]):
在一个池工作进程中执行``func(*args,**kwargs),``然后返回结果。此方法的结果是``AsyncResult``类的实例，``callback``是可调用对象，接收输入参数。当``func``的结果变为可用时，将理解传递给``callback``。``callback``禁止执行任何阻塞操作，否则将接收其他异步操作中的结果。
p.close():
关闭进程池，防止进一步操作。如果所有操作持续挂起，它们将在工作进程终止前完成
P.jion():
等待所有工作进程退出。此方法只能在``close``（）或``teminate()``之后调用
obj.get():
返回结果，如果有必要则等待结果到达。``timeout``是可选的。如果在指定时间内还没有到达，将引发一场。如果远程操作中引发了异常，它将在调用此方法时再次被引发。
obj.ready():
如果调用完成，返回``True
obj.successful():
如果调用完成且没有引发异常，返回``True``，如果在结果就绪之前调用此方法，引发异常
obj.wait([timeout]):
等待结果变为可用。
obj.terminate()``：
立即终止所有工作进程，同时不执行任何清理或结束任何挂起工作。如果``p``被垃圾回收，将自动调用此函数
wsgiref
2022年9月7日
11:41
wsgiref 是Python标准库给出的 WSGI 的参考实现。
WSGI是Python Web 开发中为服务器程序和应用程序设定的标准，满足这一标准的服务器程序和应用程序可以配合使用。我在上一篇博文《WSGI简介》中对此有详细的介绍。在阅读wsgiref源代码之前，一定要对WSGI有一定了解。
WSGI 在 PEP 333 中描述，但是只靠阅读PEP 333 可能在理解上还是不够深入，所以阅读官方给出的参考实现是很有必要的。阅读完这份源代码后，不仅有利于对WSGI的理解。而且会让你对服务端程序如何对客户端请求有一个直观的理解，从相对底层的socket监听请求，到上层对HTTP请求的处理。
当然，这只是对WSGI的参考实现，目的是为了描述清楚WSGI，而不是真正用在产品中。如果想对Python Web开发中服务器端的实现有更广泛，更深入的理解，需要进一步阅读Python常用框架的源代码。
wsgiref 源代码分析
wsgiref 源代码可以在 pypi wsgiref 0.1.2 下载。另外，我在阅读的过程中作了大量注释，包含模块介绍，调用层次关系，demo的运行结果，等 等，还包含了阅读过程中制作的思维导图。GitHub地址注释版wsgiref。
结构
上图描述了wsgiref的所有模块及模块间的调用关系，可以看出，wsgiref有以下模块：
simple_server
这一模块实现了一个简单的 HTTP 服务器，并给出了一个简单的 demo，运行：
python simple_server.py
会启动这个demo，运行一次请求，并把这次请求中涉及到的环境变量在浏览器中显示出来。
handlers
simple_server模块将HTTP服务器分成了 Server 部分和Handler部分，前者负责接收请求，后者负责具体的处理， 其中Handler部分主要在handlers中实现。
headers
这一模块主要是为HTTP协议中header部分建立数据结构。
util
这一模块包含了一些工具函数，主要用于对环境变量，URL的处理。
validate
这一模块提供了一个验证工具，可以用于验证你的实现是否符合WSGI标准。
simple_server
可以看出，simple_server 模块主要有两部分内容
应用程序
函数demo_app是应用程序部分
服务器程序
服务器程序主要分成Server 和 Handler两部分，另外还有一个函数 make_server 用来生成一个服务器实例
我们先看应用程序部分。
注意：以 M:开始的都是我自己添加的注释，不包含在最初的源代码中。
def demo_app(environ,start_response):
# M: StringIO reads and writes a string buffer (also known as memory files).
from StringIO import StringIO
stdout = StringIO()
print >> stdout, "Hello world!"
print >> stdout
h = environ.items()
h.sort()
for k,v in h:
print >> stdout, k,'=',v``
start_response("200 OK", [('Content-Type','text/plain')])
return [stdout.getvalue()]
这里可以看出，这个 demo_app 是如何展示WSGI中对应用程序的要求的：
demo_app 有两个参数
第一个参数 environ是一个字典
第二个参数 start_response是一个可调用函数
demo_app 返回一个可迭代对象
demo_app 需要调用 start_response
另外，可以看出，返回的内容就是环境变量当前的内容，这一点可以运行
python simple_server.py
在浏览器中看到的内容，就是上述源代码的for循环中输出的。
这里，使用了 StringIO ，可以看出，所有输出的内容都先存储在其实例中，最后返回的时候一起在可迭代对象中返回。
接下来，我们看服务器程序。
先从 make_server 看起，它是用来生成一个server实例的：
def make_server(
host, port, app, server_class=WSGIServer, handler_class=WSGIRequestHandler
):
"""Create a new WSGI server listening on `host` and `port` for `app`"""
# M: -> HTTPServer.__init__
# -> TCPServer.__init__
# -> TCPServer.server_bind
# -> TCPServer.socket.bind
# -> TCPServer.server_activate
# -> TCPServer.socket.listen
server = server_class((host, port), handler_class)
# M: conresponding to WSGIRequestHandler.handle()
# -> handler.run(self.server.get_app())
server.set_app(app)
return server
虽然代码只有三行，但是可以看出生成一个 server 都需要些什么：
(host, port)
主机名和端口号
handler_class
用于处理请求的handler类
app 服务器程序在处理时，一定会调用我们之前写好的应用程序，这样他们才能配合起来为客户端面服务，所以，你看到了那个 set_app 调用。
另外，在注释部分，你可以看到那代码背后都发生了什么。
生成 server 实例时，默认的 server_class 是 WSGIServer，它是HTTPServer的子类，后者又是TCPServer的子类，所以初始化 server 时，会沿着类的继承关系执行下去，最终，生成 server 实例的过程，其实是最底层的 TCPServer 在初始化时，完成了对socket的bind和listen。
后面的 set_app 设置了 app，它会在 handler_class (默认为WSGIRequestHandler)的handle函数中被取出来，然后交给 handler 的 run 函数运行。
好，现在我们开始介绍Server部分的主要内容，即WSGIServer和WSGIRequestHandler，首先，我们看一下二者的继承体系。
WSGIServer
# M:
# +------------+
# | BaseServer |
# +------------+
# |
# V
# +------------+
# | TCPServer |
# +------------+
# |
# V
# +------------+
# | HTTPServer |
# +------------+
# |
# V
# +------------+
# | WSGIServer |
# +------------+
可以看出 WSGIServer 来自 HTTPServer，后者来自 Python 标准库中的BaseHTTPServer模块，更上层的TCPServer和BaseServer来自 Python 标准库中的 SocketServer 模块。
WSGIRequestHandler
# M:
# +--------------------+
# | BaseRequestHandler |
# +--------------------+
# |
# V
# +-----------------------+
# | StreamRequestHandler |
# +-----------------------+
# |
# V
# +------------------------+
# | BaseHTTPRequestHandler |
# +------------------------+
# |
# V
# +--------------------+
# | WSGIRequestHandler |
# +--------------------+
可以看出 WSGIRequestHandler 来自 BaseHTTPRequestHandler，后者来自 Python 标准库中的BaseHTTPServer模块，更上层的StreamRequestHandler和BaseRequestHandler来自 Python 标准库中的 SocketServer 模块。
这时候，三个模块之间的层次关系我们可以理清楚了。
# M:
# +-----------------------------------------------+
# | simple_server: WSGIServer, WSGIRequestHandler |
# | |
# +-----------------------------------------------+
# |
# V
# +----------------------------------------------------+
# | BaseHTTPServer: HTTPServer, BaseHTTPRequestHandler |
# +----------------------------------------------------+
# |
# V
# +----------------------------------------------------+
# | SocketServer: TCPServer,BaseSErver; |
# | StreamRequestHandler,BaseRequestHandler |
# +----------------------------------------------------+
#
另外，这一模块中还有一个类，叫ServerHandler，它继承自 handlers 模块中的 SimpleHandler，我们再看看它的继承体系：
# M:
# +-------------+
# | BaseHandler |
# +-------------+
# |
# V
# +----------------+
# | SimpleHandler |
# +----------------+
# |
# V
# +---------------+
# | ServerHandler |
# +---------------+
#
好了，现在这个模块中的继承结构都弄清楚了，现在我们看看他们如何配合起来完成对客户端请求的处理。
首先，回顾simple_server涉及的模块：
WSGIServer
WSGIRequestHandler
ServerHandler
demo_app
make_server
然后，把大脑清空，想一下要对客户端请求进行处理需要做什么
启动服务器，监听客户端请求
请求来临，处理用户请求
我们看看这几个模块是如何配合完成这两个功能的
先看看 simple_server 模块的 main 部分，即执行
python simple_server.py
时执行的内容:
httpd = make_server('', 8000, demo_app)
sa = httpd.socket.getsockname()
print "Serving HTTP on", sa[0], "port", sa[1], "..."
# M: webbrowser provides a high-level interface to allow displaying Web-based documents
# to users. Under most circumstances
import webbrowser
webbrowser.open('http://localhost:8000/xyz?abc')
httpd.handle_request() # serve one request, then exit
可以看出，主要完成的功能是：
启动服务器
模块用户请求
处理用户请求
那么，我们主要关心的就是 make_server 和 handle_request 背后都发生了什么。
make_server
上图可以看出函数之间的调用关系，也可以看出 make_server 到 使用 socket 监听用户请求的过程。
handle_request
handle_request 的过程真正将各个模块联系起来了。
上图很清楚地说明了 由handle_request到demo_app的执行过程，把这个模块的各个部分联系起来。相信无需多言了。
Handlers
从图中可以看出handler模块中的四部分，它们其实是四个类，
从基类到子类依次为：
BaseHandler
SimpleHandler
BaseCGIHandler
CGIHandler
最主要的实现在 BaseHandler中，其它几个类都是在基类基础上做了简单的实现。BaseHandler是不能直接使用的，因为有几个关键的地方没有实现，SimpleHandler是一个可以使用的简单实现。simple_server中的 ServerHandler类就是这个模块中SimpleHandler的子类。
在 BaseHandler中，最重要的是 run 函数：
def run(self, application):
"""Invoke the application"""
# Note to self: don't move the close()! Asynchronous servers shouldn't
# call close() from finish_response(), so if you close() anywhere but
# the double-error branch here, you'll break asynchronous servers by
# prematurely closing. Async servers must return from 'run()' without
# closing if there might still be output to iterate over.
try:
self.setup_environ()
self.result = application(self.environ, self.start_response)
self.finish_response()
except:
try:
self.handle_error()
except:
# If we get an error handling an error, just give up already!
self.close()
raise # ...and let the actual server figure it out.
它先设置好环境变量，再调用我们的 demo_app, 并通过 finish_response 将调用结果传送给客户端。如果处理过程遇到错误，转入 handle_error 处理。
此外，BaseHandler中还包含了 WSGI 中多次提到的 start_response，start_response 在 demo_app 中被调用，我们看看它的实现：
def start_response(self, status, headers,exc_info=None):
"""'start_response()' callable as specified by PEP 333"""
# M:
# exc_info:
# The exc_info argument, if supplied, must be a Python sys.exc_info()
# tuple. This argument should be supplied by the application only if
# start_response is being called by an error handler.
# exc_info is the most recent exception catch in except clause
# in error_output:
# start_response(
# self.error_status,self.error_headers[:],sys.exc_info())
# headers_sent:
# when send_headers is invoked, headers_sent = True
# when close is invoked, headers_sent = False
if exc_info:
try:
if self.headers_sent:
# Re-raise original exception if headers sent
raise exc_info[0], exc_info[1], exc_info[2]
finally:
exc_info = None # avoid dangling circular ref
elif self.headers is not None:
raise AssertionError("Headers already set!")
assert type(status) is StringType,"Status must be a string"
assert len(status)>=4,"Status must be at least 4 characters"
assert int(status[:3]),"Status message must begin w/3-digit code"
assert status[3]==" ", "Status message must have a space after code"
if __debug__:
for name,val in headers:
assert type(name) is StringType,"Header names must be strings"
assert type(val) is StringType,"Header values must be strings"
assert not is_hop_by_hop(name),"Hop-by-hop headers not allowed"
# M: set status and headers
self.status = status
# M:
# headers_class is Headers in module headers
self.headers = self.headers_class(headers)
return self.write
可以看出，它先对参数进行了检查，然后再将headers 存储在成员变量中，这两点 WSGI标准中都有明确说明，需要检查参数，并且这一步只能将 headers存储起来，不能直接发送给客户端。也就是说，这个 start_response 还没有真正 response。
其实刚刚介绍 run 函数的时候已经提到了，真正的 response 在 finish_response 函数中：
def finish_response(self):
"""Send any iterable data, then close self and the iterable
Subclasses intended for use in asynchronous servers will
want to redefine this method, such that it sets up callbacks
in the event loop to iterate over the data, and to call
'self.close()' once the response is finished.
"""
# M:
# result_is_file:
# True if 'self.result' is an instance of 'self.wsgi_file_wrapper'
# finish_content:
# Ensure headers and content have both been sent
# close:
# Close the iterable (if needed) and reset all instance vars
if not self.result_is_file() or not self.sendfile():
for data in self.result:
self.write(data) # send data by self.write
self.finish_content()
self.close()
另外一个需要注意的地方是错误处理，在 run 函数中通过 try/except 捕获错误，错误处理使用了 handle_error 函数，WSGI中提到，start_response 函数的第三个参数 exc_info 会在错误处理的时候使用，我们来看看它是如何被使用的：
def handle_error(self):
"""Log current error, and send error output to client if possible"""
self.log_exception(sys.exc_info())
if not self.headers_sent:
self.result = self.error_output(self.environ, self.start_response)
self.finish_response()
# XXX else: attempt advanced recovery techniques for HTML or text?
def error_output(self, environ, start_response):
"""WSGI mini-app to create error output
By default, this just uses the 'error_status', 'error_headers',
and 'error_body' attributes to generate an output page. It can
be overridden in a subclass to dynamically generate diagnostics,
choose an appropriate message for the user's preferred language, etc.
Note, however, that it's not recommended from a security perspective to
spit out diagnostics to any old user; ideally, you should have to do
something special to enable diagnostic output, which is why we don't
include any here!
"""
# M:
# sys.exc_info():
# Return information about the most recent exception caught by an except
# clause in the current stack frame or in an older stack frame.
start_response(self.error_status,self.error_headers[:],sys.exc_info())
return [self.error_body]
看到了吧，handle_error 又调用了 error_output ，后者调用 start_response，并将其第三个参数设置为 sys.exc_info()，这一点在 WSGI 中也有说明。
好了，这一部分我们就介绍到这里，不再深入过多的细节，毕竟源代码还是要自己亲自阅读的。剩下的三个部分不是核心问题，就是一些数据结构和工具函数，我们简单说一下。
Headers
这个模块是对HTTP 响应部分的头部设立的数据结构，实现了一个类似Python 中 dict的数据结构。可以看出，它实现了一些函数来支持一些运算符，例如 len, setitem, getitem, delitem, str, 另外，还实现了 dict 操作中的get, keys, values函数。
Util
这个模块主要就是一些有用的函数，用于处理URL, 环境变量。
Validate
这个模块主要是检查你对WSGI的实现，是否满足标准，包含三个部分：
validator
Wrapper
Check
validator 调用后面两个部分来完成验证工作，可以看出Check部分对WSGI中规定的各个部分进行了检查。
Jinja2
2022年9月7日
12:29
jinja2介绍
jinja2是Flask作者开发的一个模板系统，起初是仿django模板的一个模板引擎，为Flask提供模板支持，由于其灵活，快速和安全等优点被广泛使用。
jinja2的优点
jinja2之所以被广泛使用是因为它具有以下优点：
-
- 相对于Template，jinja2更加灵活，它提供了控制结构，表达式和继承等。
- 相对于Mako，jinja2仅有控制结构，不允许在模板中编写太多的业务逻辑。
- 相对于Django模板，jinja2性能更好。
- Jinja2模板的可读性很棒。
安装jinja2
由于jinja2属于第三方模块，首先需要对其进行安装
| 1 | pip3 install jinja2 |
|---|---|
测试模板是否安装成功
1 2 3 4 |
python -c "import jinja2" # ``没有报错就表示安装成功 # ``必须用双引号``" |
|---|---|
jinja2语法
作为一个模板系统，它还提供了特殊的语法，我们按照它支持的语法进行编写之后，就能使用jinja2模块进行渲染。
基本语法
在jinja2中，存在三种语法：
-
- 控制结构
- 变量取值 {{ }}
- 注释
下面是一个简单的jinja2例子
1 2 3 4 5 6 7 |
{# This is jinja code {% for file in filenames %} ... {% endfor %} #} |
|---|---|
可以看到，for循环的使用方式和Python比较类似，但是没有了句尾的冒号，另外需要使用endfor最为结尾，其实在jinja2中，if也是一样的，结尾需要使用endif。
jinja2变量
jinja2模板中使用 {{ }} 语法表示一个变量，它是一种特殊的占位符。当利用jinja2进行渲染的时候，它会把这些特殊的占位符进行填充/替换，jinja2支持python中所有的Python数据类型比如列表、字段、对象等。
1 2 3 |
<p>this is a dicectory:{{ mydict['key'] }} </p> <p>this is a list:{{ mylist[3] }} </p> <p>this is a object:{{ myobject.something() }} </p> |
|---|---|
jinja2中的过滤器
变量可以通过“过滤器”进行修改，过滤器可以理解为是jinja2里面的内置函数和字符串处理函数。
常用的过滤器有：
| 过滤器名称 | 说明 |
|---|---|
| safe | 渲染时值不转义 |
| capitialize | 把值的首字母转换成大写，其他子母转换为小写 |
| lower | 把值转换成小写形式 |
| upper | 把值转换成大写形式 |
| title | 把值中每个单词的首字母都转换成大写 |
| trim | 把值的首尾空格去掉 |
| striptags | 渲染之前把值中所有的HTML标签都删掉 |
| join | 拼接多个值为字符串 |
| replace | 替换字符串的值 |
| round | 默认对数字进行四舍五入，也可以用参数进行控制 |
| int | 把值转换成整型 |
那么如何使用这些过滤器呢？ 只需要在变量后面使用管道(|)分割，多个过滤器可以链式调用，前一个过滤器的输出会作为后一个过滤器的输入。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 | {{ 'abc' | captialize }} # Abc {{ 'abc' | upper }} # ABC {{ 'hello world' | title }} # Hello World {{ "hello world" | replace('world','daxin') | upper }} # HELLO DAXIN {{ 18.18 | round | int }} # 18 |
| ------------------------------------------------------------ | ------------------------------------------------------------ |
| | |
jinja2的控制结构
jinja2中的if语句类似与Python的if语句，它也具有单分支，多分支等多种结构，不同的是，条件语句不需要使用冒号结尾，而结束控制语句，需要使用endif关键字。
1 2 3 4 5 6 7 |
{% if daxin.safe %} daxin is safe. {% elif daxin.dead %} daxin is dead {% else %} daxin is okay {% endif %} |
|---|---|
jinja2的for循环
jinja2中的for循环用于迭代Python的数据类型，包括列表，元组和字典。在jinja2中不存在while循环。
迭代列表
| 1 2 3 4 5 | <ul> {% for user in users %} <li>{{ user.username|title }}</li> {% endfor %} </ul> |
| ----------------------- | ------------------------------------------------------------ |
| | |
迭代字典
1 2 3 4 5 6 |
<dl> {% for key, value in my_dict.iteritems() %} <dt>{{ key }}</dt> <dd>{{ value}}</dd> {% endfor %} </dl> |
|---|---|
当然也可以加入else语句，在循环正确执行完毕后，执行
在for循环中，jinja2还提供了一些特殊的变量，用以来获取当前的遍历状态：
| 变量 | 描述 |
|---|---|
| loop.index | 当前迭代的索引（从1开始） |
| loop.index0 | 当前迭代的索引（从0开始） |
| loop.first | 是否是第一次迭代，返回bool |
| loop.last | 是否是最后一次迭代，返回bool |
| loop.length | 序列中的项目数量 |
| loop.revindex | 到循环结束的次数（从1开始） |
| loop.revindex0 | 到循环结束的次数(从0开始） |
jinja2的宏
宏类似于Python中的函数，我们在宏中定义行为，还可以进行传递参数，就像Python中的函数一样一样儿的。
在宏中定义一个宏的关键字是macro，后面跟其 宏的名称和参数等
1 2 3 4 5 |
{% macro input(name,age=18) %} # ``参数``age``的默认值为``18 <input type='text' name="{{ name }}" value="{{ age }}" > {% endmacro %} |
|---|---|
调用方法也和Python的类似
1 2 |
<p>{{ input('daxin') }} </p> <p>{{ input('daxin',age=20) }} </p> |
|---|---|
jinja2的继承和Super函数
jinja2中最强大的部分就是模板继承。模板继承允许我们创建一个基本(骨架)文件，其他文件从该骨架文件继承，然后针对自己需要的地方进行修改。
jinja2的骨架文件中，利用block关键字表示其包涵的内容可以进行修改。
以下面的骨架文件base.html为例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
<!DOCTYPE html> <html lang="en"> <head> {% block head %} <link rel="stylesheet" href="style.css"/> <title>{% block title %}{% endblock %} - My Webpage</title> {% endblock %} </head> <body> <div id="content">{% block content %}{% endblock %}</div> <div id="footer"> {% block footer %} <script>This is javascript code </script> {% endblock %} </div> </body> </html> |
|---|---|
这里定义了四处 block，即：head，title，content，footer。那怎么进行继承和变量替换呢？注意看下面的文件
1 2 3 4 5 6 7 8 9 10 11 12 |
{% extend "base.html" %} # ``继承``base.html``文件 {% block title %} Dachenzi {% endblock %} # ``定制``title``部分的内容 {% block head %} {{ super() }} # ``用于获取原有的信息 <style type='text/css'> .important { color: #FFFFFF } </style> {% endblock %} # ``其他不修改的原封不同的继承 |
|---|---|
PS: super()函数 表示获取block块中定义的原来的内容。
利用jinja2进行渲染
jinja2模块中有一个名为Enviroment的类，这个类的实例用于存储配置和全局对象，然后从文件系统或其他位置中加载模板。
基本使用方法
大多数应用都在初始化的时候撞见一个Environment对象，并用它加载模板。Environment支持两种加载方式：
-
- PackageLoader：包加载器
- FileSystemLoader：文件系绳�统加载器
PackageLoader
使用包加载器来加载文档的最简单的方式如下：
| 1 2 3 4 5 | from jinja2 import PackageLoader,Environment env = Environment(loader=PackageLoader('python_project','templates')) # 创建一个包加载器对象 template = env.get_template('bast.html') # 获取一个模板文件 template.render(name='daxin',age=18) # 渲染 |
|---|---|
其中：
-
- PackageLoader()的两个参数为：python包的名称，以及模板目录名称。
- get_template()：获取模板目录下的某个具体文件。
- render()：接受变量，对模板进行渲染
FileSystemLoader
文件系统加载器，不需要模板文件存在某个Python包下，可以直接访问系统中的文件。
查看api
2022年3月23日
18:27
python -m pydoc -p 1234
-p 端口号
csv模块
2022年11月12日
10:47
案例
1.使用CSV模块中的方法读取csv格式文件
import csv
import re
filename = "C:\\Users\\LSG\\Desktop\\info.csv"
#``文件的读操作（以只读方式打开文件。文件的指针将会放在文件的开头。这是``**``默认模式``** , ``编码方式``UTF-8``）
with open(filename, 'r' , encoding='utf-8') as file:
data_csv_reader = csv.reader(file)
# ``将文件中每行数据添加到``comments``里（数据类型``list``）
comments = []
for line in data_csv_reader:
comments.append(line)
# ``循环打印文本内容
for line in comments :
print(line)
sys模块
2022年7月12日
21:13
sys.argv：
参数字符串列表（动态对象），第一个参数为当前程序主文件的绝对路径或空字符串，如果在命令提示符界面给``Python``文件传了参数（不同的参数以空格分隔，无论传入的时候写的是什么类型，最终都会转成字符串），可以在这里面获取（从第二个位置开始），比如命令提示符中运行``“``python main.py 111 aaa``”``，那``sys.argv``就有三个元素，第二个和第三个元素分别为``“``111``”``和``“``aaa``”``。
返回传递给`` Python ``脚本的命令行参数列表。看下示例：
Import sys
if__name__=='__main__':
args=sys.argvprint(args)
print(args[1])
上面文件名为：``test.py``，我们在控制台使用命令：``python test.py 123 abc`` ``执行一下，执行结果如下：
['test.py','123','abc']123
sys.path：
搜索模块路径字符串列表（动态对象），搜索查找模块时会优先到这里面去搜索，第一个参数为主文件所在目录的路径或空字符串。
sys.modules：
已经加载的模块信息字典，key为模块名称，value为模块对象，在使用__import__导入模块时，可以先判断下是否有同名模块已经在sys.modules中加载了，如果已经存在了，可以先删除或者不再导入了。
以字典类型返回系统导入的模块。
sys.getsizeof(object)：
获取一个对象的内存占用字节数大小。
sys.getdefaultencoding()：
返回``Python``默认的字符串编码格式。
sys.exit([status])：
退出``Python``解释器，并抛出一个``SystemExit``异常，``status``默认为``0``，即``“``成功``”``，如果``status``是一个整数，则被用作一个系统退出状态，如果``status``是其他对象，则它将会被``print``并系统退出状态为``1``，即``“``失败``”``。所以使用这个方法的话，一般是需要进行异常处理的，运行完这条语句后如果有异常捕获和处理的，会去运行后面的异常处理代码的（而``os._exit()``方法则不会，它不会抛出异常）。
sys.excutable：
代码运行时表示运行的解释器绝对路径，如``C:\Python36\python.exe``，在打包的程序中就是``exe``程序文件的绝对路径，这个是用来定位用户运行该程序的真实位置。
version
返回`` Python ``解释器的版本信息。
winver
返回`` Python ``解释器主版号。
platform
返回操作系统平台名称。
path
返回模块的搜索路径列表。
maxsize
返回支持的最大整数值。
maxunicode
返回支持的最大`` Unicode ``值。
copyright
返回`` Python ``版权信息。
byteorder
返回本地字节规则的指示器。
executable
返回`` Python ``解释器所在路径。
Import sys
print(sys.version)
print(sys.winver)
print(sys.platform)
print(sys.path)
print(sys.maxsize)
print(sys.maxunicode)
print(sys.copyright)
print(sys.modules)
print(sys.byteorder)
print(sys.executable)
stdout
标准输出。看下示例：
import sys # ``下面两行代码等价
sys.stdout.write('Hi'+'\n')
print('Hi')
stdin
标准输入。看下示例：
import sys
s1=input()
s2=sys.stdin.readline()
print(s1)
print(s2)
stderr
错误输出。看下示例：
import sys
sys.stderr.write('this is a error message')
exit()
退出当前程序。看下示例：
import sys
print('Hi')
sys.exit()
print('Jhon')
getdefaultencoding()
返回当前默认字符串编码的名称。
getrefcount(obj)
返回对象的引用计数。
getrecursionlimit()
返回支持的递归深度。
getsizeof(object[, default])
以字节为单位返回对象的大小。
setswitchinterval(interval)
设置线程切换的时间间隔。
getswitchinterval()
返回线程切换时间间隔。
pip命令
2021年11月30日
13:23
pip使用
安装包
pip install package_name
查看某个已安装包
pip show --files package_name
检查哪些包需要更新
pip list --outdated
升级包
pip install --upgrade package_name
卸载包
pip uninstall package_name
八 安装包或者模块
可以通过pip或者easy_install安装。pip是现代化的一种安装包的方式，以下讲解pip的常用命令:
1.安装包
pip install requests
2. 安装指定版本的包
pip install django == 1.10.6
3.卸载包
pip uninstall django
4.升级包
pip install -U requests
列出可升级的包：
pip list --outdate
一行命令升级所有pip安装的Python包
pip freeze --local | grep -v ‘^-e‘ | cut -d = -f 1 | xargs pip install -U
建议在执行前先执行：
pip install -U distribute
5.升级pip
pip install -U pip
6.查看当前pip是哪个版本
pip --version
7.显示某个已安装的包的信息
pip show -f <包名>
8.列出当前环境下安装了哪些包
pip list
9. 将当前环境安装的包全部列出来放在文件中
pip freeze > requirements.txt
10.从某个文件中安装包
pip install -r requirements.txt
11.临时更改安装源，以豆瓣源为例
pip install <包名> -i https://pypi.douban.com/simple
12.永久更改安装源
windows操作系统：在当前用户目录下新建pip/pip.ini，然后在文件中添加以下代码：
[global]
index-url = https://pypi.douban.com/simple
Linux/Mac：在用户目录下新建.pip/pip.conf，然后在文件中添加以下代码：
[global]
index-url = https://pypi.douban.com/simple
# pip --help
Usage:
pip [options]
Commands:
install Install packages. ``安装包
download Download packages. ``下载包
uninstall Uninstall packages. ``卸载包
freeze Output installed packages in requirements format. ``按着一定格式输出已安装包列表
list List installed packages. ``列出已安装包
show Show information about installed packages. ``显示包详细信息
check Verify installed packages have compatible dependencies.``检查包的依赖关系是否完整
config Manage local and global configuration.``管理配置
search Search PyPI for packages.``搜索包
wheel Build wheels from your requirements.
hash Compute hashes of package archives.``计算包的hash值
completion A helper command used for command completion.
help Show help for commands.
General Options:
-h, --help Show help.
--isolated Run pip in an isolated mode, ignoring environment variables and user configuration.
-v, --verbose Give more output. Option is additive, and can be used up to 3 times.
-V, --version Show version and exit.
-q, --quiet Give less output. Option is additive, and can be used up to 3 times (corresponding to WARNING, ERROR, and CRITICAL logging levels).
--log <path> Path to a verbose appending log.
--proxy <proxy> Specify a proxy in the form [user:passwd@]proxy.server:port.
--retries <retries> Maximum number of retries each connection should attempt (default 5 times).
--timeout <sec> Set the socket timeout (default 15 seconds).
--exists-action <action> Default action when a path already exists: (s)witch, (i)gnore, (w)ipe, (b)ackup, (a)bort).
--trusted-host <hostname> Mark this host as trusted, even though it does not have valid or any HTTPS.
--cert <path> Path to alternate CA bundle.
--client-cert <path> Path to SSL client certificate, a single file containing the private key and the certificate in PEM format.
--cache-dir <dir> Store the cache data in <dir>.
--no-cache-dir Disable the cache.
--disable-pip-version-check
Don't periodically check PyPI to determine whether a new version of pip is available for download. Implied with --no-index.
--no-color Suppress colored output
os文件模块
2021年11月26日
15:09
获取指定文件夹下的目录和文件的实现
一、os.listdir 方法
os.listdir() 方法用于返回指定的目列表录下包含的文件或子目录的名字的。这个列表以字母顺序。其得到的是仅当前路径下的文件名，不包括子目录中的文件，如果需要得到所有文件需要递归。 它也不包括 '.' 和 '..' 即使它在目录中。
语法格式如下：
os.listdir(path)
案列：
def list_dir(file_dir):
'''
``通过`` listdir ``得到的是仅当前路径下的文件名，不包括子目录中的文件，如果需要得到所有文件需要递归
'''
print'\n\n<><><><><><> listdir <><><><><><>'
print "current dir : {0}".format(file_dir)
dir_list = os.listdir(file_dir)
for cur_file in dir_list:
# ``获取文件的绝对路径
path = os.path.join(file_dir, cur_file)
if os.path.isfile(path): # ``判断是否是文件还是目录需要用绝对路径
print "{0} : is file!".format(cur_file)
if os.path.isdir(path):
print "{0} : is dir!".format(cur_file)
list_dir(path) # ``递归子目录
os.walk 方法
os.walk() 方法用于通过在目录树中游走输出在目录中的文件名，向上或者向下。是一个简单易用的文件、目录遍历器，可以帮助我们高效的处理文件、目录方面的事情。
语法格式：
os.walk(top[, topdown=True[, onerror=None[, followlinks=False]]])
方法参数说明：
- top：要遍历的目录的路径
- topdown：可选，如果为 True，则优先遍历 top 目录，以及 top 目录下的每一个子目录，否则优先遍历 top 的子目录，默认为 True
- onerror: 可选， 需要一个 callable 对象，当 walk 异常时调用
- followlinks：可选， 如果为 True，则会遍历目录下的快捷方式(linux 下是 symbolic link)实际所指的目录，默认为 False
- args：包含那些没有 '-' 或 '--' 的参数列表
返回值: 三元组 (root, dirs, files)
- root ：所指的是当前正在遍历的目录的地址
- dirs ：当前文件夹中所有目录名字的 list (不包括子目录)
- files ：当前文件夹中所有的文件 (不包括子目录中的文件)
#文件名称
file_name=os.path.splitext(file)[0]
#文件根据‘。点’分割
返回一个列表，【0代表文件名字】【1为点之后的文件后缀名】
file_suffix=os.path.splitext(file)[1]
#文件具体绝对路径：文件的具体地址
具体到每一层目录，直到文件
file_path=os.path.join(root,file)
#文件相对路径：
结束是文件存在在某一级目录下，但是不具体
file_abs_path=os.path.abspath(file)
#文件父路径：文件在哪一层目录下
，结果给出的是文件的上一层目录
file_parent=os.path.dirname(file_path)
其他跟文件相关的常用方法
分离文件名和扩展名
os.path.splitext()：
file = "file_test.txt"
file_name = os.path.splitext(file)[0] # ``输出：``file_test
file_suffix = os.path.splitext(file)[1] # ``输出：``.txt
判断文件或目录是否存在
os.path.exists()：
判断是否是文件
os.path.isfile()：
判断是否是目录
os.path.isdir()：
获取当前文件所在的目录，即父目录
os.path.dirname()：
创建多级目录
os.makedirs()：
创建单级目录
os.mkdir()：
获取文件大小
os.path.getsize()：
路径相同重命名文件或目录，从 src 到 dst，路径不同移动
若是路径不同还文件名字也不同这是吧src的文件，移动并重命名到dst中
os.rename(src, dst)
删除路径为path的文件。
如果path 是一个文件夹，将抛出OSError; 查看下面的
os.remove(path)
删除path指定的空目录，如果目录非空，则抛出一个OSError异常。
os.rmdir(path)
a文件复制到b目录
import shutil
Shutil.Copyfile(a,b)
os.getcwd() ``获取当前工作目录，即当前``python``脚本工作的目录路径`
`os.chdir("dirname") ``改变当前脚本工作目录；相当于``shell``下``cd`
`os.curdir ``返回当前目录``: ('.')`
`os.pardir ``获取当前目录的父目录字符串名：``('..')`
`os.makedirs('dirname1/dirname2') ``可生成多层递归目录`
`os.removedirs('dirname1') ``若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推`
`os.mkdir('dirname') ``生成单级目录；相当于``shell``中``mkdir dirname`
`os.rmdir('dirname') ``删除单级空目录，若目录不为空则无法删除，报错；相当于``shell``中``rmdir dirname`
`os.listdir('dirname') ``列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印`
`os.remove() ``删除一个文件`
`os.rename("oldname","newname") ``重命名文件``/``目录`
`os.stat('path/filename') ``获取文件``/``目录信息`
`os.sep ``输出操作系统特定的路径分隔符，``win``下为``"\\",Linux``下为``"/"`
`os.linesep ``输出当前平台使用的行终止符，``win``下为``"\t\n",Linux``下为``"\n"`
`os.pathsep ``输出用于分割文件路径的字符串`` win``下为``;,Linux``下为``:`
`os.name ``输出字符串指示当前使用平台。``win->'nt'; Linux->'posix'`
`os.system("bash command") ``运行``shell``命令，直接显示`
`os.environ ``获取系统环境变量`
`os.path.abspath(path) ``返回``path``规范化的绝对路径`
`os.path.split(path) ``将``path``分割成目录和文件名二元组返回`
`os.path.dirname(path) ``返回``path``的目录。其实就是``os.path.split(path)``的第一个元素`
`os.path.basename(path) ``返回``path``最后的文件名。如何``path``以／或``\``结尾，那么就会返回空值。即``os.path.split(path)``的第二个元素`
`os.path.exists(path) ``如果``path``存在，返回``True``；如果``path``不存在，返回``False`
`os.path.isabs(path) ``如果``path``是绝对路径，返回``True`
`os.path.isfile(path) ``如果``path``是一个存在的文件，返回``True``。否则返回``False`
`os.path.isdir(path) ``如果``path``是一个存在的目录，则返回``True``。否则返回``False`
`os.path.join(path1[, path2[, ...]]) ``将多个路径组合后返回，第一个绝对路径之前的参数将被忽略`
`os.path.getatime(path) ``返回``path``所指向的文件或者目录的最后存取时间`
`os.path.getmtime(path) ``返回``path``所指向的文件或者目录的最后修改时间`
`os.path.getsize(path) ``返回``path``的大小
Python OS 文件/目录方法
os 模块提供了非常丰富的方法用来处理文件和目录。常用的方法如下表所示：
| 序号 | 方法及描述 |
|---|---|
| 1 | os.access(path, mode) 检验权限模式 |
| 2 | os.chdir(path) 改变当前工作目录 |
| 3 | os.chflags(path, flags) 设置路径的标记为数字标记。 |
| 4 | os.chmod(path, mode) 更改权限 |
| 5 | os.chown(path, uid, gid) 更改文件所有者 |
| 6 | os.chroot(path) 改变当前进程的根目录 |
| 7 | os.close(fd) 关闭文件描述符 fd |
| 8 | os.closerange(fd_low, fd_high) 关闭所有文件描述符，从 fd_low (包含) 到 fd_high (不包含), 错误会忽略 |
| 9 | os.dup(fd) 复制文件描述符 fd |
| 10 | os.dup2(fd, fd2) 将一个文件描述符 fd 复制到另一个 fd2 |
| 11 | os.fchdir(fd) 通过文件描述符改变当前工作目录 |
| 12 | os.fchmod(fd, mode) 改变一个文件的访问权限，该文件由参数fd指定，参数mode是Unix下的文件访问权限。 |
| 13 | os.fchown(fd, uid, gid) 修改一个文件的所有权，这个函数修改一个文件的用户ID和用户组ID，该文件由文件描述符fd指定。 |
| 14 | os.fdatasync(fd) 强制将文件写入磁盘，该文件由文件描述符fd指定，但是不强制更新文件的状态信息。 |
| 15 | [os.fdopen(fd, mode[, bufsize]]) 通过文件描述符 fd 创建一个文件对象，并返回这个文件对象 |
| 16 | os.fpathconf(fd, name) 返回一个打开的文件的系统配置信息。name为检索的系统配置的值，它也许是一个定义系统值的字符串，这些名字在很多标准中指定（POSIX.1, Unix 95, Unix 98, 和其它）。 |
| 17 | os.fstat(fd) 返回文件描述符fd的状态，像stat()。 |
| 18 | os.fstatvfs(fd) 返回包含文件描述符fd的文件的文件系统的信息，像 statvfs() |
| 19 | os.fsync(fd) 强制将文件描述符为fd的文件写入硬盘。 |
| 20 | os.ftruncate(fd, length) 裁剪文件描述符fd对应的文件, 所以它最大不能超过文件大小。 |
| 21 | os.getcwd() 返回当前工作目录 |
| 22 | os.getcwdu() 返回一个当前工作目录的Unicode对象 |
| 23 | os.isatty(fd) 如果文件描述符fd是打开的，同时与tty(-like)设备相连，则返回true, 否则False。 |
| 24 | os.lchflags(path, flags) 设置路径的标记为数字标记，类似 chflags()，但是没有软链接 |
| 25 | os.lchmod(path, mode) 修改连接文件权限 |
| 26 | os.lchown(path, uid, gid) 更改文件所有者，类似 chown，但是不追踪链接。 |
| 27 | os.link(src, dst) 创建硬链接，名为参数 dst，指向参数 src |
| 28 | os.listdir(path) 返回path指定的文件夹包含的文件或文件夹的名字的列表。 |
| 29 | os.lseek(fd, pos, how) 设置文件描述符 fd当前位置为pos, how方式修改: SEEK_SET 或者 0 设置从文件开始的计算的pos; SEEK_CUR或者 1 则从当前位置计算; os.SEEK_END或者2则从文件尾部开始. 在unix，Windows中有效 |
| 30 | os.lstat(path) 像stat(),但是没有软链接 |
| 31 | os.major(device) 从原始的设备号中提取设备major号码 (使用stat中的st_dev或者st_rdev field)。 |
| 32 | os.makedev(major, minor) 以major和minor设备号组成一个原始设备号 |
| 33 | [os.makedirs(path, mode]) 递归文件夹创建函数。像mkdir(), 但创建的所有intermediate-level文件夹需要包含子文件夹。 |
| 34 | os.minor(device) 从原始的设备号中提取设备minor号码 (使用stat中的st_dev或者st_rdev field )。 |
| 35 | [os.mkdir(path, mode]) 以数字mode的mode创建一个名为path的文件夹.默认的 mode 是 0777 (八进制)。 |
| 36 | [os.mkfifo(path, mode]) 创建命名管道，mode 为数字，默认为 0666 (八进制) |
| 37 | [os.mknod(filename, mode=0600, device]) 创建一个名为filename文件系统节点（文件，设备特别文件或者命名pipe）。 |
| 38 | [os.open(file, flags, mode]) 打开一个文件，并且设置需要的打开选项，mode参数是可选的 |
| 39 | os.openpty() 打开一个新的伪终端对。返回 pty 和 tty的文件描述符。 |
| 40 | os.pathconf(path, name) 返回相关文件的系统配置信息。 |
| 41 | os.pipe() 创建一个管道. 返回一对文件描述符(r, w) 分别为读和写 |
| 42 | [os.popen(command, mode[, bufsize]]) 从一个 command 打开一个管道 |
| 43 | os.read(fd, n) 从文件描述符 fd 中读取最多 n 个字节，返回包含读取字节的字符串，文件描述符 fd对应文件已达到结尾, 返回一个空字符串。 |
| 44 | os.readlink(path) 返回软链接所指向的文件 |
| 45 | os.remove(path) 删除路径为path的文件。如果path 是一个文件夹，将抛出OSError; 查看下面的rmdir()删除一个 directory。 |
| 46 | os.removedirs(path) 递归删除目录。 |
| 47 | os.rename(src, dst) 重命名文件或目录，从 src 到 dst |
| 48 | os.renames(old, new) 递归地对目录进行更名，也可以对文件进行更名。 |
| 49 | os.rmdir(path) 删除path指定的空目录，如果目录非空，则抛出一个OSError异常。 |
| 50 | os.stat(path) 获取path指定的路径的信息，功能等同于C API中的stat()系统调用。 |
| 51 | [os.stat_float_times(newvalue]) 决定stat_result是否以float对象显示时间戳 |
| 52 | os.statvfs(path) 获取指定路径的文件系统统计信息 |
| 53 | os.symlink(src, dst) 创建一个软链接 |
| 54 | os.tcgetpgrp(fd) 返回与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组 |
| 55 | os.tcsetpgrp(fd, pg) 设置与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组为pg。 |
| 56 | [os.tempnam(dir[, prefix]]) 返回唯一的路径名用于创建临时文件。 |
| 57 | os.tmpfile() 返回一个打开的模式为(w+b)的文件对象 .这文件对象没有文件夹入口，没有文件描述符，将会自动删除。 |
| 58 | os.tmpnam() 为创建一个临时文件返回一个唯一的路径 |
| 59 | os.ttyname(fd) 返回一个字符串，它表示与文件描述符fd 关联的终端设备。如果fd 没有与终端设备关联，则引发一个异常。 |
| 60 | os.unlink(path) 删除文件路径 |
| 61 | os.utime(path, times) 返回指定的path文件的访问和修改的时间。 |
| 62 | [os.walk(top, topdown=True[, onerror=None[, followlinks=False]]]) 输出在文件夹中的文件名通过在树中游走，向上或者向下。 |
| 63 | os.write(fd, str) 写入字符串到文件描述符 fd中. 返回实际写入的字符串长度 |
| 64 | os.path 模块 获取文件的属性信息。 |
re正则
2021年11月27日
14:50
数量词的贪婪模式与非贪婪模式
正则表达式通常用于在文本中查找匹配的字符串。Python里数量词默认是贪婪的（在少数语言里也可能是默认非贪婪），总是尝试匹配尽可能多的字符；非贪婪的则相反，总是尝试匹配尽可能少的字符。
compile 函数
compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用。
语法格式为：
re.compile(pattern[, flags])
参数：
- pattern : 一个字符串形式的正则表达式
- flags 可选，表示匹配模式，比如忽略大小写，多行模式等
re.match函数
re.match ``尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，``match()``就返回``none``。
函数语法：
re.match(pattern, string, flags=0)
函数参数说明：
参数 |
描述 |
|---|---|
pattern |
匹配的正则表达式 |
string |
要匹配的字符串。 |
flags |
标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表达式修饰符 - 可选标志 |
匹配成功re.match方法返回一个匹配的对象，否则返回None。
我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。
| 匹配对象方法 | 描述 |
|---|---|
| group(num=0) | 匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。 |
| groups() | 返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。 |
匹配对象
group（id） 获取给定子模式（组的匹配项）
start（id） 返回给定组的匹配项的起始位置
end（id） 返回给定组的匹配项的结束位置
span（id） 返回一个组的起始和结束位置
import re
m = re.match(r'(http://www|WWW).(.*)..{3}', 'http://www.python.org')
print('输出匹配到的字符串')
print(m.group())
print('匹配第一个圆括号中的内容')
print(m.group(1))
print('匹配第二个圆括号中的内容')
print(m.group(2))
print('输出第一组字符串的起始位置')
print(m.start(1))
print('输出第二组字符串的起始位置')
print(m.start(2))
print('输出字符串的结束位置')
print(m.end(0))
print('输出第一个的起始和结束位置')
print(m.span(1))
re.search方法
re.search 扫描整个字符串并返回第一个成功的匹配。
函数语法：
re.search(pattern, string, flags=0)
检索和替换
Python 的re模块提供了re.sub用于替换字符串中的匹配项。
语法：
re.sub(pattern, repl, string, count=0, flags=0)
参数：
- pattern : 正则中的模式字符串。
- repl : 替换的字符串，也可为一个函数。
- string : 要被查找替换的原始字符串。
- count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
- flags : 编译时用的匹配模式，数字形式。
re.subn(pattern, repl, string, count=0, flags=0)
返回替换后的值，和替换了几次
findall
在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果有多个匹配模式，则返回元组列表，如果没有找到匹配的，则返回空列表。
注意： match 和 search 是匹配一次 findall 匹配所有。
语法格式为：
re.findall(pattern, string, flags=0)
或
pattern.findall(string[, pos[, endpos]])
参数：
- pattern 匹配模式。
- string 待匹配的字符串。
- pos 可选参数，指定字符串的起始位置，默认为 0。
- endpos 可选参数，指定字符串的结束位置，默认为字符串的长度。
re.finditer
和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。
re.finditer(pattern, string, flags=0)
re.split
split 方法按照能够匹配的子串将字符串分割后返回列表，它的使用形式如下：
re.split(pattern, string[, maxsplit=0, flags=0])
参数：
| 参数 | 描述 |
|---|---|
| pattern | 匹配的正则表达式 |
| string | 要匹配的字符串。 |
| maxsplit | 分割次数，maxsplit=1 分割一次，默认为 0，不限制次数。 |
| flags | 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表达式修饰符 - 可选标志 |
正则表达式对象
re.RegexObject
re.compile() 返回 RegexObject 对象。
re.MatchObject
特殊字符
所谓特殊字符，就是一些有特殊含义的字符，如上面说的 runoo*b 中的 ***，简单的说就是表示任何字符串的意思。如果要查找字符串中的 ***** 符号，则需要对 ***** 进行转义，即在其前加一个 **，runo*ob 匹配字符串 runo*ob。
许多元字符要求在试图匹配它们时特别对待。若要匹配这些特殊字符，必须首先使字符"转义"，即，将反斜杠字符**** 放在它们前面。下表列出了正则表达式中的特殊字符：
| 特别字符 | 描述 |
|---|---|
| $ | 匹配输入字符串的结尾位置。如果设置了 RegExp 对象的 Multiline 属性，则 $ 也匹配 '\n' 或 '\r'。要匹配 $ 字符本身，请使用 $。 |
| ( ) | 标记一个子表达式的开始和结束位置。子表达式可以获取供以后使用。要匹配这些字符，请使用 ( 和 )。 |
| * | 匹配前面的子表达式零次或多次。要匹配 * 字符，请使用 *。 |
| + | 匹配前面的子表达式一次或多次。要匹配 + 字符，请使用 +。 |
| . | 匹配除换行符 \n 之外的任何单字符。要匹配 . ，请使用 . 。 |
| [ | 标记一个中括号表达式的开始。要匹配 [，请使用 [。 |
| ? | 匹配前面的子表达式零次或一次，或指明一个非贪婪限定符。要匹配 ? 字符，请使用 ?。 |
| \ | 将下一个字符标记为或特殊字符、或原义字符、或向后引用、或八进制转义符。例如， 'n' 匹配字符 'n'。'\n' 匹配换行符。序列 '\' 匹配 ""，而 '(' 则匹配 "("。 |
| ^ | 匹配输入字符串的开始位置，除非在方括号表达式中使用，当该符号在方括号表达式中使用时，表示不接受该方括号表达式中的字符集合。要匹配 ^ 字符本身，请使用 ^。 |
| { | 标记限定符表达式的开始。要匹配 {，请使用 {。 |
| | | 指明两项之间的一个选择。要匹配 |，请使用 |。 |
正则表达式修饰符 - 可选标志
正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位`` OR(|) ``它们来指定。如`` re.I | re.M ``被设置成`` I ``和`` M ``标志：
修饰符 |
描述 |
|---|---|
re.I |
使匹配对大小写不敏感 |
re.L |
做本地化识别（``locale-aware``）匹配 |
re.M |
多行匹配，影响`` ^ ``和`` $ |
re.S |
使`` . ``匹配包括换行在内的所有字符 |
re.U |
根据``Unicode``字符集解析字符。这个标志影响`` \w, \W, \b, \B. |
re.X |
该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。 |
正则表达式模式
模式字符串使用特殊的语法来表示一个正则表达式：
字母和数字表示他们自身。一个正则表达式模式中的字母和数字匹配同样的字符串。
多数字母和数字前加一个反斜杠时会拥有不同的含义。
标点符号只有被转义时才匹配自身，否则它们表示特殊的含义。
反斜杠本身需要使用反斜杠转义。
| 模式 | 描述 |
|---|---|
^ |
匹配字符串的开头 |
$ |
匹配字符串的末尾。 |
. |
匹配任意字符，除了换行符，当``re.DOTALL``标记被指定时，则可以匹配包括换行符的任意字符。 |
[...] |
用来表示一组字符``,``单独列出：``[amk] ``匹配`` 'a'``，``'m'``或``'k' |
[^...] |
不在``[]``中的字符：``[^abc] ``匹配除了``a,b,c``之外的字符。 |
re* |
匹配``0``个或多个的表达式。 |
re+ |
匹配``1``个或多个的表达式。 |
re? |
匹配``0``个或``1``个由前面的正则表达式定义的片段，非贪婪方式 |
re{ n} |
精确匹配`` n ``个前面表达式。例如，`` ``o{2}`` ``不能匹配`` "Bob" ``中的`` "o"``，但是能匹配`` "food" ``中的两个`` o``。 |
re{ n,} |
匹配`` n ``个前面表达式。例如，`` o{2,} ``不能匹配``"Bob"``中的``"o"``，但能匹配`` "foooood"``中的所有`` o``。``"o{1,}" ``等价于`` "o+"``。``"o{0,}" ``则等价于`` "o*"``。 |
re{ n, m} |
匹配`` n ``到`` m ``次由前面的正则表达式定义的片段，贪婪方式 |
| `a | b` |
(re) |
对正则表达式分组并记住匹配的文本 |
(?imx) |
正则表达式包含三种可选标志：``i, m, ``或`` x ``。只影响括号中的区域。 |
(?-imx) |
正则表达式关闭`` i, m, ``或`` x ``可选标志。只影响括号中的区域。 |
(?: re) |
类似`` (...), ``但是不表示一个组 |
(?imx: re) |
在括号中使用``i, m, ``或`` x ``可选标志 |
(?-imx: re) |
在括号中不使用``i, m, ``或`` x ``可选标志 |
(?#...) |
注释``. |
(?= re) |
前向肯定界定符。如果所含正则表达式，以`` ... ``表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。 |
(?! re) |
前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功 |
(?> re) |
匹配的独立模式，省去回溯。 |
\w |
匹配字母数字及下划线 |
\W |
匹配非字母数字及下划线 |
\s |
匹配任意空白字符，等价于`` ``[ \t\n\r\f]``。 |
\S |
匹配任意非空字符 |
\d |
匹配任意数字，等价于`` [0-9]. |
\D |
匹配任意非数字 |
\A |
匹配字符串开始 |
\Z |
匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。 |
\z |
匹配字符串结束 |
\G |
匹配最后匹配完成的位置。 |
\b |
匹配一个单词边界，也就是指单词和空格间的位置。例如，`` 'er\b' ``可以匹配``"never" ``中的`` 'er'``，但不能匹配`` "verb" ``中的`` 'er'``。 |
\B |
匹配非单词边界。``'er\B' ``能匹配`` "verb" ``中的`` 'er'``，但不能匹配`` "never" ``中的`` 'er'``。 |
\n, \t, ``等``. |
匹配一个换行符。匹配一个制表符。等 |
\1...\9 |
匹配第``n``个分组的内容。 |
\10 |
匹配第``n``个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。 |
正则表达式实例
实例 |
描述 |
|---|---|
[Pp]ython |
匹配`` "Python" ``或`` "python" |
rub[ye] |
匹配`` "ruby" ``或`` "rube" |
[aeiou] |
匹配中括号内的任意一个字母 |
[0-9] |
匹配任何数字。类似于`` [0123456789] |
[a-z] |
匹配任何小写字母 |
[A-Z] |
匹配任何大写字母 |
[a-zA-Z0-9] |
匹配任何字母及数字 |
[^aeiou] |
除了``aeiou``字母以外的所有字符 |
[^0-9] |
匹配除了数字外的字符 |
特殊字符类
| 实例 | 描述 |
|---|---|
. |
匹配除`` "\n" ``之外的任何单个字符。要匹配包括`` '\n' ``在内的任何字符，请使用象`` '[.\n]' ``的模式。 |
\d |
匹配一个数字字符。等价于`` [0-9]``。 |
\D |
匹配一个非数字字符。等价于`` [^0-9]``。 |
\s |
匹配任何空白字符，包括空格、制表符、换页符等等。等价于`` [ \f\n\r\t\v]``。 |
\S |
匹配任何非空白字符。等价于`` [^ \f\n\r\t\v]``。 |
\w |
匹配包括下划线的任何单词字符。等价于``'[A-Za-z0-9_]'``。 |
\W |
匹配任何非单词字符。等价于`` '[^A-Za-z0-9_]'``。 |
案例
特殊符号替换：``re.sub(`` r'[-,$()#+&*]'``," ooo ",str)
表达式
一、校验数字的表达式
1. ``数字：``^[0-9]*$
2. n``位的数字：``^\d{n}$
3. ``至少``n``位的数字：``^\d{n,}$
4. m-n``位的数字：``^\d{m,n}$
5. ``零和非零开头的数字：``^(0|[1-9][0-9]*)$
6. ``非零开头的最多带两位小数的数字：``^([1-9][0-9]*)+(.[0-9]{1,2})?$
7. ``带``1-2``位小数的正数或负数：``^(\-)?\d+(\.\d{1,2})?$
8. ``正数、负数、和小数：``^(\-|\+)?\d+(\.\d+)?$
9. ``有两位小数的正实数：``^[0-9]+(.[0-9]{2})?$
10. ``有``1~3``位小数的正实数：``^[0-9]+(.[0-9]{1,3})?$
11. ``非零的正整数：``^[1-9]\d*$ ``或`` ^([1-9][0-9]*){1,3}$ ``或`` ^\+?[1-9][0-9]*$
12. ``非零的负整数：``^\-[1-9][]0-9"*$ ``或`` ^-[1-9]\d*$
13. ``非负整数：``^\d+$ ``或`` ^[1-9]\d*|0$
14. ``非正整数：``^-[1-9]\d*|0$ ``或`` ^((-\d+)|(0+))$
15. ``非负浮点数：``^\d+(\.\d+)?$ ``或`` ^[1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0$
16. ``非正浮点数：``^((-\d+(\.\d+)?)|(0+(\.0+)?))$ ``或``
^(-([1-9]\d*\.\d*|0\.\d*[1-9]\d*))|0?\.0+|0$
17. ``正浮点数：``^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$ ``或`` ^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$
18. ``负浮点数：``^-([1-9]\d*\.\d*|0\.\d*[1-9]\d*)$ ``或`` ^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$
19. ``浮点数：``^(-?\d+)(\.\d+)?$ ``或`` ^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0)$
二、校验字符的表达式
1. ``汉字：``^[\u4e00-\u9fa5]{0,}$
2. ``英文和数字：``^[A-Za-z0-9]+$ ``或`` ^[A-Za-z0-9]{4,40}$
3. ``长度为``3-20``的所有字符：``^.{3,20}$
4. ``由``26``个英文字母组成的字符串：``^[A-Za-z]+$
5. ``由``26``个大写英文字母组成的字符串：``^[A-Z]+$
6. ``由``26``个小写英文字母组成的字符串：``^[a-z]+$
7. ``由数字和``26``个英文字母组成的字符串：``^[A-Za-z0-9]+$
8. ``由数字、``26``个英文字母或者下划线组成的字符串：``^\w+$ ``或`` ^\w{3,20}$
9. ``中文、英文、数字包括下划线：``^[\u4E00-\u9FA5A-Za-z0-9_]+$
10. ``中文、英文、数字但不包括下划线等符号：``^[\u4E00-\u9FA5A-Za-z0-9]+$
``或`` ^[\u4E00-\u9FA5A-Za-z0-9]{2,20}$
11. ``可以输入含有``^%&',;=?$\"``等字符：``[^%&',;=?$\x22]+ 12
``禁止输入含有``~``的字符：``[^~\x22]+
三、特殊需求表达式
1. Email``地址：
^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$
2. ``域名：
[a-zA-Z0-9][-a-zA-Z0-9]{0,62}(/.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+/.?
3. InternetURL``：
[a-zA-z]+://[^\s]* ``或`` ^http://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$
4. ``手机号码：
^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}$
5. ``电话号码
("XXX-XXXXXXX"``、``"XXXX-XXXXXXXX"``、``"XXX-XXXXXXX"``、
"XXX-XXXXXXXX"``、``"XXXXXXX"``和``"XXXXXXXX)``：
^(\(\d{3,4}-)|\d{3.4}-)?\d{7,8}$
6. ``国内电话号码``(0511-4405222``、``021-87888822)``：
\d{3}-\d{8}|\d{4}-\d{7}
7. ``身份证号``(15``位、``18``位数字``)``：
^\d{15}|\d{18}$
8. ``短身份证号码``(``数字、字母``x``结尾``)``：
^([0-9]){7,18}(x|X)?$
或`` ^\d{8,18}|[0-9x]{8,18}|[0-9X]{8,18}?$
9. ``帐号是否合法``(``字母开头，允许``5-16``字节，允许字母数字下划线``)``：
^[a-zA-Z][a-zA-Z0-9_]{4,15}$
10. ``密码``(``以字母开头，长度在``6~18``之间，只能包含字母、数字和下划线``)``：
^[a-zA-Z]\w{5,17}$
11. ``强密码``(``必须包含大小写字母和数字的组合，不能使用特殊字符，长度在``8-10``之间``)``：
^(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{8,10}$
12. ``日期格式：
^\d{4}-\d{1,2}-\d{1,2}
13. ``一年的``12``个月``(01``～``09``和``1``～``12)``：
^(0?[1-9]|1[0-2])$
14. ``一个月的``31``天``(01``～``09``和``1``～``31)``：
^((0?[1-9])|((1|2)[0-9])|30|31)$
15. ``钱的输入格式：
- 1.有四种钱的表示形式我们可以接受:"10000.00" 和 "10,000.00", 和没有 "分" 的 "10000" 和 "10,000"：
^[1-9][0-9]*$
- \17. 2.这表示任意一个不以0开头的数字,但是,这也意味着一个字符"0"不通过,所以我们采用下面的形式：
^(0|[1-9][0-9]*)$
- 一个0或者一个不以0开头的数字.我们还可以允许开头有一个负号：
^(0|-?[1-9][0-9]*)$
- 这表示一个0或者一个可能为负的开头不为0的数字.让用户以0开头好了.把负号的也去掉,因为钱总不能是负的吧.下面我们要加的是说明可能的小数部分：
^[0-9]+(.[0-9]+)?$
- .必须说明的是,小数点后面至少应该有1位数,所以"10."是不通过的,但是 "10" 和 "10.2" 是通过的：
^[0-9]+(.[0-9]{2})?$
- .这样我们规定小数点后面必须有两位,如果你认为太苛刻了,可以这样：
^[0-9]+(.[0-9]{1,2})?$
- 这样就允许用户只写一位小数.下面我们该考虑数字中的逗号了,我们可以这样：
^[0-9]{1,3}(,[0-9]{3})*(.[0-9]{1,2})?$
- 1到3个数字,后面跟着任意个 逗号+3个数字,逗号成为可选,而不是必须：
^([0-9]+|[0-9]{1,3}(,[0-9]{3})*)(.[0-9]{1,2})?$
``备注：这就是最终结果了``,``别忘了``"+"``可以用``"*"``替代如果你觉得空字符串也可以接受的话``(``奇怪``,``为什么``?)``最后``,``别忘了在用函数时去掉去掉那个反斜杠``,``一般的错误都在这里
25. xml``文件：
^([a-zA-Z]+-?)+[a-zA-Z0-9]+\\.[x|X][m|M][l|L]$
26. ``中文字符的正则表达式：
[\u4e00-\u9fa5]
27. ``双字节字符：
[^\x00-\xff]
(``包括汉字在内，可以用来计算字符串的长度``(``一个双字节字符长度计``2``，``ASCII``字符计``1))
28. ``空白行的正则表达式：
\n\s*\r (``可以用来删除空白行``)
29. HTML``标记的正则表达式：
<(\S*?)[^>]*>.*?</\1>|<.*? />
(``网上流传的版本太糟糕，上面这个也仅仅能部分，对于复杂的嵌套标记依旧无能为力``)
30. ``首尾空白字符的正则表达式：
^\s*|\s*$``或``(^\s*)|(\s*$)
(``可以用来删除行首行尾的空白字符``(``包括空格、制表符、换页符等等``)``，非常有用的表达式``)
31. ``腾讯``QQ``号：
[1-9][0-9]{4,}
(``腾讯``QQ``号从``10000``开始``)
32. ``中国邮政编码：
[1-9]\d{5}(?!\d) (``中国邮政编码为``6``位数字``)
33.`` ``IP``地址：
\d+\.\d+\.\d+\.\d+ (``提取``IP``地址时有用``)
34. IP``地址：
((?:(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d))
=
json模块&pickle
2022年7月14日
9:57
json
如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。
JSON表示的对象就是标准的JavaScript语言的对象，JSON和Python内置的数据类型对应如下：
|
|
|---|---|
json序列化
json.dumps(''内容")
json反序列化
json.loads(''内容")
json验证：
json格式只能兼容所有语言通用的数据类型，不能兼容某一种语言特定的数据类型
json强调：json格式有它的要求，如json 不认单引号，不要混淆
注意：
import json`
`#dct="{'1':111}"#json ``不认单引号`
`#dct=str({"1":111})#``报错``,``因为生成的数据还是单引号``:{'one': 1}`
`dct='{"1":"111"}'print(json.loads(dct))
#conclusion:`
`# ``无论数据是怎样创建的，只要满足``json``格式，就可以``json.loads``出来``,``不一定非要``dumps``的数据才能``loads
# 一.什么是猴子补丁?
属性在运行时的动态替换，叫做猴子补丁（``Monkey Patch``）。
猴子补丁的核心就是用自己的代码替换所用模块的源代码，详细地如下
1``，这个词原来为Guerrilla Patch，杂牌军、游击队，说明这部分不是原装的，在英文里guerilla发音和gorllia(猩猩)相似，再后来就写了monkey(猴子)。
2``，还有一种解释是说由于这种方式将原来的代码弄乱了(messing with it)，在英文里叫monkeying about(顽皮的)，所以叫做Monkey Patch。
# 二. 猴子补丁的功能(一切皆对象)
1.``拥有在模块运行时替换的功能, 例如: 一个函数对象赋值给另外一个函数对象(把函数原本的执行的功能给替换了)
# 三.monkey patch的应用场景
如果我们的程序中已经基于``json``模块编写了大量代码了，发现有一个模块``ujson``比它性能更高，但用法一样，我们肯定不会想所有的代码都换成``ujson.dumps``或者``ujson.loads,
那我们可能会想到这么做`
`import ujson as json``，但是这么做的需要每个文件都重新导入一下，维护成本依然很高
此时我们就可以用到猴子补丁了只需要在入口处加上
import json`
`import ujson
def monkey_patch_json():`
` json.__name__= 'ujson'`
` json.dumps = ujson.dumps`
` json.loads = ujson.loads
monkey_patch_json() # ``之所以在入口处加，是因为模块在导入一次后，后续的导入便直接引用第一次的成果
#``其实这种场景也比较多, 比如我们引用团队通用库里的一个模块, 又想丰富模块的功能, 除了继承之外也可以考虑用MonkeyPatch.采用猴子补丁之后，如果发现ujson不符合预期，那也可以快速撤掉补丁。个人感觉Monkey`
`Patch``带了便利的同时也有搞乱源代码的风险!
Pickle
用法和json一样
注意``：``Pickle``的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于``Python``，并且可能不同版本的``Python``彼此都不兼容，因此，只能用``Pickle``保存那些不重要的数据，不能成功地反序列化也没关系。``
Shelve
shelve模块比pickle模块简单，只有一个open函数，返回类似字典的对象，可读可写;key必须为字符串，而值可以是python所支持的数据类型
import shelve
f=shelve.open(r'sheve.txt')`
`# f['stu1_info']={'name':'egon','age':18,'hobby':['piao','smoking','drinking']}`
`# f['stu2_info']={'name':'gangdan','age':53}`
`# f['school_info']={'website':'http://www.pypy.org','city':'beijing'}print(f['stu1_info']['hobby'])`
`f.close()
Faker模块
2022年6月17日
20:38
Faker
随机生成信息
1. 安装
pip install Faker
2. 简单使用
>>> from faker import Faker
>>> fake = Faker(locale='zh_CN')
>>> fake.name()
'``李洁``'
>>> fake.address()
'``上海市兴安盟县江北东莞路``r``座`` 803484'
参数 locale：为生成数据的文化选项（语种），默认为 en_US，只有使用了相关文化，才能生成相对应的随机信息
常见的文化选项：
zh_CN - Chinese (China Mainland)
zh_TW - Chinese (China Taiwan)
en_US - English (United States)
3. 其他方法
3.1 地理信息类
city_suffix() # ``市，县
country() # ``国家
country_code() # ``国家编码
district() # ``区
geo_coordinate() # ``地理坐标
latitude() # ``地理坐标``(``纬度``)
longitude() # ``地理坐标``(``经度``)
postcode() # ``邮编
province() # ``省份
address() # ``详细地址
street_address() # ``街道地址
street_name() # ``街道名
street_suffix() # ``街、路
3.2 基础信息类
ssn() # ``生成身份证号
bs() # ``随机公司服务名
company() # ``随机公司名（长）
company_prefix() # ``随机公司名（短）
company_suffix() # ``公司性质，如``'``信息有限公司``'
credit_card_expire() # ``随机信用卡到期日，如``'03/30'
credit_card_full() # ``生成完整信用卡信息
credit_card_number() # ``信用卡号
credit_card_provider() # ``信用卡类型
credit_card_security_code() # ``信用卡安全码
job() # ``随机职位
first_name_female() # ``女性名
first_name_male() # ``男性名
name() # ``随机生成全名
name_female() # ``男性全名
name_male() # ``女性全名
phone_number() # ``随机生成手机号
phonenumber_prefix() # ``随机生成手机号段，如``139
3.3 邮箱信息类
ascii_company_email() # ``随机``ASCII``公司邮箱名
ascii_email() # ``随机``ASCII``邮箱`` #
company_email() # ``公司邮箱
email() # ``普通邮箱
safe_email() # ``安全邮箱
3.4 ``网络基础信息类
domain_name() # ``生成域名
domain_word() # ``域词``(``即，不包含后缀``)
ipv4() # ``随机``IP4``地址
ipv6() # ``随机``IP6``地址
mac_address() # ``随机``MAC``地址
tld() # ``网址域名后缀``(.com,.net.cn,``等等，不包括``.)
uri() # ``随机``URI``地址
uri_extension() # ``网址文件后缀
uri_page() # ``网址文件（不包含后缀）
uri_path() # ``网址文件路径（不包含文件名）
url() # ``随机``URL``地址
user_name() # ``随机用户名
image_url() # ``随机``URL``地址
3.5 浏览器信息类
chrome() # ``随机生成``Chrome``的浏览器``user_agent``信息
firefox() # ``随机生成``FireFox``的浏览器``user_agent``信息
internet_explorer() # ``随机生成``IE``的浏览器``user_agent``信息
opera() # ``随机生成``Opera``的浏览器``user_agent``信息
safari() # ``随机生成``Safari``的浏览器``user_agent``信息
linux_platform_token() # ``随机``Linux``信息
user_agent() # ``随机``user_agent``信息
3.6 数字信息
numerify() # ``三位随机数字
random_digit() # 0~9``随机数
random_digit_not_null() # 1~9``的随机数
random_int() # ``随机数字，默认``0~9999``，可以通过设置``min,max``来设置
random_number() # ``随机数字，参数``digits``设置生成的数字位数
pyfloat() # ``随机``Float``数字
pyint() # ``随机``Int``数字（参考``random_int()``参数）
pydecimal() # ``随机``Decimal``数字（参考``pyfloat``参数）
3.7 文本加密类
pystr() # ``随机字符串
random_element() # ``随机字母
random_letter() # ``随机字母
paragraph() # ``随机生成一个段落
paragraphs() # ``随机生成多个段落
sentence() # ``随机生成一句话
sentences() # ``随机生成多句话，与段落类似
text() # ``随机生成一篇文章
word() # ``随机生成词语
words() # ``随机生成多个词语，用法与段落，句子，类似
binary() # ``随机生成二进制编码
boolean() # True/False
language_code() # ``随机生成两位语言编码
locale() # ``随机生成语言``/``国际 信息
md5() # ``随机生成``MD5
null_boolean() # NULL/True/False
password() # ``随机生成密码``,``可选参数`` # length # ``密码长度；``special_chars # ``是否能使用特殊字符；``digits # ``是否包含数字；``upper_case # ``是否包含大写字母；``lower_case # ``是否包含小写字母
sha1() # ``随机``SHA1
sha256() # ``随机``SHA256
uuid4() # ``随机``UUID
3.8 时间信息类
date() # ``随机日期
date_between() # ``随机生成指定范围内日期，参数`` # start_date``，``end_date
date_between_dates() # ``随机生成指定范围内日期，用法同上
date_object() # ``随机生产从``1970-1-1``到指定日期的随机日期。
date_time() # ``随机生成指定时间（``1970``年``1``月``1``日至今）
date_time_ad() # ``生成公元``1``年到现在的随机时间
date_time_between() # ``用法同``dates
future_date() # ``未来日期
future_datetime() # ``未来时间
month() # ``随机月份
month_name() # ``随机月份（英文）
past_date() # ``随机生成已经过去的日期
past_datetime() # ``随机生成已经过去的时间
time() # ``随机``24``小时时间
timedelta() # ``随机获取时间差
time_object() # ``随机``24``小时时间，``time``对象
time_series() # ``随机``TimeSeries``对象
timezone() # ``随机时区
unix_time() # ``随机``Unix``时间
year() # ``随机年份
4. 实战使用
在数据库建一张表，通过``Faker``造数据，插入到表中。并且打印``Faker``造的数据。
import pymysql
from faker import Faker
conn = pymysql.connect(host="114.215.129.166", port=3306, user="nice", password="", db="flask201",
charset="utf8")
cursor = conn.cursor()
sql1 = """drop table if exists faker_user"""
sql2 = """
create table faker_user(
pid int primary key auto_increment,
username varchar(20),
password varchar(20),
address varchar(35)
)
"""
cursor.execute(sql1)
cursor.execute(sql2)
fake = Faker("zh-CN")
for i in range(20):
sql = """insert into faker_user(username,password,address)
values('%s','%s','%s')""" % (fake.name(), fake.password(special_chars=False), fake.address())
cursor.execute(sql)
conn.commit()
cursor.close()
conn.close()
configparser****模块
2022年7月14日
11:14
配置文件如下：
# ``注释``1; ``注释``2
[section1]`
`k1 = v1`
`k2:v2`
`user=egon`
`age=18`
`is_admin=true`
`salary=31
[section2]`
`k1 = v1
读取
import configparser
config=configparser.ConfigParser()
config.read('a.cfg')
#``查看所有的标题
res=config.sections() #['section1', 'section2']
print(res)
#``查看标题``section1``下所有``key=value``的``key
options=config.options('section1')
print(options) #['k1', 'k2', 'user', 'age', 'is_admin', 'salary']
#``查看标题``section1``下所有``key=value``的``(key,value)``格式
item_list=config.items('section1')
print(item_list) #[('k1', 'v1'), ('k2', 'v2'), ('user', 'egon'), ('age', '18'), ('is_admin', 'true'), ('salary', '31')]
#``查看标题``section1``下``user``的值``=>``字符串格式
val=config.get('section1','user')
print(val) #egon
#``查看标题``section1``下``age``的值``=>``整数格式
val1=config.getint('section1','age')
print(val1) #18
#``查看标题``section1``下``is_admin``的值``=>``布尔值格式
val2=config.getboolean('section1','is_admin')
print(val2) #True
#``查看标题``section1``下``salary``的值``=>``浮点型格式
val3=config.getfloat('section1','salary')
print(val3) #31.0
改写
import configparser
config=configparser.ConfigParser()
config.read('a.cfg',encoding='utf-8')
#``删除整个标题``section2
config.remove_section('section2')
#``删除标题``section1``下的某个``k1``和``k2
config.remove_option('section1','k1')
config.remove_option('section1','k2')
#``判断是否存在某个标题
print(config.has_section('section1'))
#``判断标题``section1``下是否有``user
print(config.has_option('section1',''))
#``添加一个标题
config.add_section('egon')
#``在标题``egon``下添加``name=egon,age=18``的配置
config.set('egon','name','egon')
config.set('egon','age',18) #``报错``,``必须是字符串
#``最后将修改的内容写入文件``,``完成最终的修改
config.write(open('a.cfg','w'))
import configparser
config = configparser.ConfigParser()
config["DEFAULT"] = {'ServerAliveInterval': '45',
'Compression': 'yes',
'CompressionLevel': '9'}
config['bitbucket.org'] = {}
config['bitbucket.org']['User'] = 'hg'
config['topsecret.server.com'] = {}
topsecret = config['topsecret.server.com']
topsecret['Host Port'] = '50022' # mutates the parser
topsecret['ForwardX11'] = 'no' # same here
config['DEFAULT']['ForwardX11'] = 'yes'
with open('example.ini', 'w') as configfile:
config.write(configfile)
Pymysql模块
2022年5月31日
23:04
# 打开数据库连接
db = pymysql.connect("localhost","testuser","test123","TESTDB")
# 使用 cursor() 方法创建一个游标对象
cursorcursor = db.cursor(``cursor=``…)
cursor=pymysql.cursors.DictCurosr``将查询结果以字典返回
# 使用 execute() 方法执行 SQL 查询
cursor.execute(sql)
# 使用 fetchone() 方法获取单条数据.
data = cursor.fetchone()
fetchone():`` ``该方法获取下一个查询结果集。结果集是一个对象
fetchall():`` ``接收全部的返回结果行``.
fetchmany(num``）指定拿几条数据
rowcount:`` ``这是一个只读属性，并返回执行``execute()``方法后影响的行数。
关闭数据库连接要先关闭游标对象
cursorcursor.close()
db.close()
移动
corsor.scroll(1 ,'relative') 相对光标所在位置继续往后移动一位
corsor.scroll(1 ,'absolute') 相对光标起始所在位置继续往后移动一位
调用存储过程
cursor.callproc(procname，args)
procname 是存储过程的名字
args 是存储过程的参数=元组
插入
try:
# ``执行``sql``语句插入单个
cursor.execute(sql)
# ``插入多个
cursor .executemany(sql,[(),(),()``…])
# ``提交到数据库执行
db.commit()
except:
# ``如果发生错误则回滚
db.rollback()
执行事务
事务机制可以确保数据一致性。
事务应该具有4个属性：原子性、一致性、隔离性、持久性。这四个属性通常称为ACID特性。
- 原子性（atomicity）。一个事务是一个不可分割的工作单位，事务中包括的诸操作要么都做，要么都不做。
- 一致性（consistency）。事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。
- 隔离性（isolation）。一个事务的执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。
- 持久性（durability）。持续性也称永久性（permanence），指一个事务一旦提交，它对数据库中数据的改变就应该是永久性的。接下来的其他操作或故障不应该对其有任何影响。
Python DB API 2.0 的事务提供了两个方法 commit 或 rollback。
实例:
# SQL``删除记录语句`
`sql = "DELETE FROM EMPLOYEE WHERE AGE > %s" % (20)`
`try:`
` # ``执行``SQL``语句`
` cursor.execute(sql)`
` # ``向数据库提交`
` db.commit()`
`except:`
` # ``发生错误时回滚`
` db.rollback()
对于支持事务的数据库， 在Python数据库编程中，当游标建立之时，就自动开始了一个隐形的数据库事务。
commit()方法游标的所有更新操作，rollback（）方法回滚当前游标的所有操作。每一个方法都开始了一个新的事务。
错误处理
DB API中定义了一些数据库操作的错误及异常，下表列出了这些错误和异常:
Warning
当有严重警告时触发，例如插入数据是被截断等等。必须是 StandardError 的子类。
Error
警告以外所有其他错误类。必须是 StandardError 的子类。
InterfaceError
当有数据库接口模块本身的错误（而不是数据库的错误）发生时触发。 必须是Error的子类。
DatabaseError
和数据库有关的错误发生时触发。 必须是Error的子类。
DataError
当有数据处理时的错误发生时触发，例如：除零错误，数据超范围等等。 必须是DatabaseError的子类。
OperationalError
指非用户控制的，而是操作数据库时发生的错误。例如：连接意外断开、 数据库名未找到、事务处理失败、内存分配错误等等操作数据库是发生的错误。 必须是DatabaseError的子类。
IntegrityError
完整性相关的错误，例如外键检查失败等。必须是DatabaseError子类。
InternalError
数据库的内部错误，例如游标（cursor）失效了、事务同步失败等等。 必须是DatabaseError子类。
ProgrammingError
程序错误，例如数据表（table）没找到或已存在、SQL语句语法错误、 参数数量错误等等。必须是DatabaseError的子类。
NotSupportedError
不支持错误，指使用了数据库不支持的函数或API等。例如在连接对象上 使用.rollback()函数，然而数据库并不支持事务或者事务已关闭。 必须是DatabaseError的子类。
时间模块
2021年11月18日
15:33
时间的三种格式：
1.时间戳：从1970年到现在的秒数
Time. Time()
主要用于时间间隔计算
2.按照某种格式显示的时间
Time.strftime('%Y-%m-%d')
主要用于展示
3.结构化的时间
Time.localtime()
用于单独获取时间的某一部分
一、time模块
time模块中时间表现的格式主要有三种：
1、timestamp：时间戳，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量
2、struct_time：时间元组，共有九个元素组。
3、format time ：格式化时间，已格式化的结构使时间更具可读性。包括自定义格式和固定格式。
#直接生成时间元组 2>>> time.localtime()
#把时间戳转换为时间元组 5>>> time.localtime(time.time())
#把格式化时间转换为时间元组10>>> time.strptime('2017-4-8 14:12:12','%Y-%m-%d %X')
Time 模块
Time 模块包含了以下内置函数，既有时间处理的，也有转换时间格式的：
| 序号 | 函数及描述 |
|---|---|
| 1 | time.altzone 返回格林威治西部的夏令时地区的偏移秒数。如果该地区在格林威治东部会返回负值（如西欧，包括英国）。对夏令时启用地区才能使用。 |
| 2 | [time.asctime(tupletime]) 接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二18时07分14秒）的24个字符的字符串。 |
| 3 | time.clock( ) 用以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时，比time.time()更有用。 |
| 4 | [time.ctime(secs]) 作用相当于asctime(localtime(secs))，未给参数相当于asctime() |
| 5 | [time.gmtime(secs]) 接收时间戳（1970纪元后经过的浮点秒数）并返回格林威治天文时间下的时间元组t。注：t.tm_isdst始终为0 |
| 6 | [time.localtime(secs]) 接收时间戳（1970纪元后经过的浮点秒数）并返回当地时间下的时间元组t（t.tm_isdst可取0或1，取决于当地当时是不是夏令时）。 |
| 7 | time.mktime(tupletime) 接受时间元组并返回时间戳（1970纪元后经过的浮点秒数）。 |
| 8 | time.sleep(secs) 推迟调用线程的运行，secs指秒数。 |
| 9 | [time.strftime(fmt,tupletime]) 接收以时间元组，并返回以可读字符串表示的当地时间，格式由fmt决定。 |
| 10 | time.strptime(str,fmt='%a %b %d %H:%M:%S %Y') 根据fmt的格式把一个时间字符串解析为时间元组。 |
| 11 | time.time( ) 返回当前时间的时间戳（1970纪元后经过的浮点秒数）。 |
| 12 | time.tzset() 根据环境变量TZ重新初始化时间相关设置。 |
属性`` ``值
tm_year``（年）`` ``比如``2017 `
`tm_mon``（月）`` 1 - 12`
`tm_mday``（日）`` 1 - 31`
`tm_hour``（时）`` 0 - 23`
`tm_min``（分）`` 0 - 59`
`tm_sec``（秒）`` 0 - 61`
`tm_wday``（``weekday``）`` 0 - 6``（``0``表示周日）`
`tm_yday``（一年中的第几天）`` 1 - 366`
`tm_isdst``（是否是夏令时）`` ``默认为``-1
python中时间日期格式化符号：
- %y 两位数的年份表示（00-99）
- %Y 四位数的年份表示（000-9999）
- %m 月份（01-12）
- %d 月内中的一天（0-31）
- %H 24小时制小时数（0-23）
- %I 12小时制小时数（01-12）
- %M 分钟数（00-59）
- %S 秒（00-59）
- %a 本地简化星期名称
- %A 本地完整星期名称
- %b 本地简化的月份名称
- %B 本地完整的月份名称
- %c 本地相应的日期表示和时间表示
- %j 年内的一天（001-366）
- %p 本地A.M.或P.M.的等价符
- %U 一年中的星期数（00-53）星期天为星期的开始
- %w 星期（0-6），星期天为星期的开始
- %W 一年中的星期数（00-53）星期一为星期的开始
- %x 本地相应的日期表示
- %X 本地相应的时间表示
- %Z 当前时区的名称
- %% %号本身
实例
# ``格式化成``2016-03-20 11:45:39``形式``
print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
# ``格式化成``Sat Mar 28 22:24:24 2016``形式``
print time.strftime("%a %b %d %H:%M:%S %Y", time.localtime())
二、datetime模块
datatime模块重新封装了time模块，提供更多接口，提供的类有：date,time,datetime,timedelta,tzinfo。
1、date类
datetime.date(year, month, day)
静态方法和字段
date.max``、``date.min``：``date``对象所能表示的最大、最小日期；`
`date.resolution``：``date``对象表示日期的最小单位。这里是天。`
`date.today()``：返回一个表示当前本地日期的``date``对象；`
`date.fromtimestamp(timestamp)``：根据给定的时间戮，返回一个``date``对象；
方法和属性
- d1 = date(2017,4,8) #date对象（年月日都不能是以0开头 (2017,04,08)错误 ）
- d1.replace(year, month, day)：生成一个新的日期对象，用参数指定的年，月，日代替原有对象中的属性。（原有对象仍保持不变）
- d1.timetuple()：返回日期对应的time.struct_time对象；
- d1.weekday()：返回weekday，如果是星期一，返回0；如果是星期2，返回1，以此类推；
- d1.isoweekday()：返回weekday，如果是星期一，返回1；如果是星期2，返回2，以此类推；
- d1.isocalendar()：返回格式如(year，sum_week，day)的元组；
- d1.isoformat()：返回格式如'YYYY-MM-DD’的字符串；
- d1.strftime(fmt)：和time模块format相同。
可以用来去取时间的年月日
x.year, x.month, x.day
2、time类
datetime.time(hour[`` ``, minute[`` ``, second[`` ``, microsecond[`` ``, tzinfo]`` ``]`` ``]`` ``]`` ``)``
静态方法和字段
time.min``、``time.max``：``time``类所能表示的最小、最大时间
3、datetime类
datetime``相当于``date``和``time``结合起来。
datetime.datetime (year, month, day[ , hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] ] )
静态方法和字段
datetime.today()``：返回一个表示当前本地时间的``datetime``对象；`
`datetime.now([tz])``：返回一个表示当前本地时间的``datetime``对象，如果提供了参数``tz``，则获取``tz``参数所指时区的本地时间；`
`datetime.utcnow()``：返回一个当前``utc``时间的``datetime``对象；``#``格林威治时间`
`datetime.fromtimestamp(timestamp[, tz])``：根据时间戮创建一个``datetime``对象，参数``tz``指定时区信息；`
`datetime.utcfromtimestamp(timestamp)``：根据时间戮创建一个``datetime``对象；`
`datetime.combine(date, time)``：根据``date``和``time``，创建一个``datetime``对象；`
`datetime.strptime(date_string, format)``：将格式字符串转换为``datetime``对象；
阿里云—API
2022年9月19日
21:57
下载
pip install --upgrade aligo
简单使用
<br class="Apple-interchange-newline"><div></div>
"""``快速入门``"""
fromaligoimportAligo
``
if__name__=='__main__':
`` ``ali=Aligo() `` ``# ``第一次使用，会弹出二维码，供扫描登录
``
`` ``user=ali.get_user() `` ``# ``获取用户信息
`` ``print(user.user_name, user.nick_name, user.phone) `` ``# ``打印用户信息
``
`` ``ll=ali.get_file_list() `` ``# ``获取网盘根目录文件列表
`` ``forfileinll: `` ``# ``遍历文件列表
`` ``print(file.file_id, file.name, file.type) `` ``# ``打印文件信息
持久化登录、多帐户登录
ali=Aligo() `` ``# ``第一次使用，会弹出二维码，供扫描登录
网页扫码登录
from aligo import Aligo
# ``提供`` port ``参数即可``, ``之后打开浏览器访问 http://<YOUR_IP>:
ali = Aligo(port=8080)
## 发送登录二维码到邮箱（推荐）
最佳实践：建议将邮箱绑定到微信，这样能实时收到提醒，登录过期后也可以第一时间收到登录请求。
安全性问题：虽然自带公开邮箱，但是他人并不能通过这个获取任何人发送的邮件，所以 防伪字符串 策略是安全的。
```python
from aligo import Aligo
"""
email: 发送扫码登录邮件 ("接收邮件的邮箱地址", "防伪字符串"). 提供此值时，将不再弹出或打印二维码
关于防伪字符串: 为了方便大家使用, aligo 自带公开邮箱, 省去邮箱配置的麻烦.
所以收到登录邮件后, 一定要对比确认防伪字符串和你设置一致才可扫码登录, 否则将导致: 包括但不限于云盘文件泄露.
"""
# 提供 email 参数即可
ali = Aligo(email=('xxx@qq.com', '防伪字符串，可任意字符串'))
```
##
文件夹同步
在线解压缩
支持功能扩展
搜索文件/标签
获取重复文件列表
文件（夹）重命名
文件（夹）上传下载
文件（夹）移动复制
文件（夹）删除恢复
获取文档在线预览接口
文件（夹）分享 保存 收藏
文件（夹）自定义分享（无限制）
获取帐户、云盘（容量）等基本信息
相册 创建 删除 修改 添加文件 获取文件
hashlib模块
2022年7月14日
14:53
1、什么叫hash:
hash``是一种算法（``3.x``里代替了``md5``模块和``sha``模块，主要提供`` SHA1, SHA224, SHA256, SHA384, SHA512 ``，``MD5 ``算法），该算法接受传入的内容，经过运算得到一串``hash``值
# 2、hash值的特点是：
#2.1 ``只要传入的内容一样，得到的``hash``值必然一样``=====>``要用明文传输密码文件完整性校验
#2.2 ``不能由``hash``值返解成内容``=======``》把密码做成``hash``值，不应该在网络传输明文密码
#2.3 ``只要使用的``hash``算法不变，无论校验的内容有多大，得到的``hash``值长度是固定的
hash算法就像一座工厂，工厂接收你送来的原材料（可以用m.update()为工厂运送原材料），经过加工返回的产品就是hash值
import hashlib
m=hashlib.md5()# m=hashlib.sha256()
m.update('hello'.encode('utf8'))
print(m.hexdigest()) #5d41402abc4b2a76b9719d911017c592
m.update('alvin'.encode('utf8'))
print(m.hexdigest()) #92a7e713c30abbb0319fa07da2a5c4af
m2=hashlib.md5()
m2.update('helloalvin'.encode('utf8'))
print(m2.hexdigest()) #92a7e713c30abbb0319fa07da2a5c4af
'''
注意：把一段很长的数据``update``多次，与一次``update``这段长数据，得到的结果一样
但是``update``多次为校验大文件提供了可能。
'''
以上加密算法虽然依然非常厉害，但时候存在缺陷，即：通过撞库可以反解。所以，有必要对加密算法中添加自定义key再来做加密。
import hashlib
# ######## 256 ########
hash = hashlib.sha256('898oaFs09f'.encode('utf8'))
hash.update('alvin'.encode('utf8'))
print (hash.hexdigest())#e79e68f070cdedcfe63eaf1a2e92c83b4cfb1b5c6bc452d214c1b7e77cdfd1c7
动态加盐
"""
在对铭文数据做加密处理过程前添加一些变化的干扰项
"""
import hashlib
# # 1.``先确定算法类型``(md5``普遍使用``)
# md5 = hashlib.md5()
# # 2.``将明文数据传递给``md5``算法``(update``只能接受``bytes``类型数据``)
# md5.update(b'123')
# # ``加盐``(``干扰项``) ``格式为``md5.update(b'``公司内部自定义的盐``')
# md5.update(b'abc') # a906449d5769fa7361d7ecc6aa3f6d28
# # ``动态加盐``(``干扰项``) ``当前时间 用户名的部分`` uuid(``随机字符串``(``永远不会重复``))
# import time
# res1 = str(time.time())
# md5.update(res1.encode('utf8'))
# # ``真实数据
# md5.update(b'123abc')
# # 3.``获取加密之后的密文数据``(``没有规则的一串随机字符串``)
# res = md5.hexdigest()
# print(res) # 68f128bc611544f439426ceea3dae3a7
密文一致性校验
"""
文件不是很大的情况下 可以将所有的文件内容全部加密处理
但是如果文件特别大 全部加密处理相当的耗时耗资源 如何解决???
针对大文件可以使用切片读取的方式
"""
# import hashlib
# md5 = hashlib.md5()
# with open(r'a.txt','rb') as f:
# for line in f:
# md5.update(line)
# real_data = md5.hexdigest()
# print(real_data) # e5f6700043d90045f2eed3bab8e08cfa
# md5 = hashlib.md5()
# with open(r'a.txt','rb') as f:
# for line in f:
# md5.update(line)
# error_data = md5.hexdigest()
# print(error_data) # e5f6700043d90045f2eed3bab8e08cfa
#
# import os
# res = os.path.getsize(r'a.txt')
# read_method = [0,res//4,res//2,res]
logging****模块
2022年7月14日
15:35
日志命名格式：
日志名是区别日志业务归属的一种重要的标识
注：可以在日志字典中定义一个空key，这样当日志字典中找不到key时可以调用这个空key
案例：
'loggers': {
#logging.getLogger(__name__)``拿到的``logger``配置
'': {
'handlers': ['default', 'console'],
# ``这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
'level': 'DEBUG',
# loggers(``第一层日志级别关限制)--->handlers(第二层日志级别关卡限制)
'propagate': False,
# ``默认为True，向上（更高level的logger）传递，通常设置为False即可，否则会一份日志向上层层传递
},
'``专门的采集``': {
'handlers': ['other',],
'level': 'DEBUG',
'propagate': False,
},
},
日志轮转：
日志记录着程序运行过程的关键信息
案例：
'default': {
'level': 'DEBUG',
'class': 'logging.handlers.RotatingFileHandler', # ``保存到文件``,``日志轮转
'formatter': 'standard',
# ``可以定制日志文件路径
# BASE_DIR = os.path.dirname(os.path.abspath(__file__)) # log``文件的目录
# LOG_PATH = os.path.join(BASE_DIR,'a1.log')
'filename': 'a1.log', # ``日志文件
'maxBytes': 1024*1024*5, # ``日志大小`` 5M
'backupCount': 5,``# ``最多保存几份
'encoding': 'utf-8', # ``日志文件的编码，再也不用担心中文``log``乱码了
日志原理
一 日志级别
CRITICAL = 50 #FATAL = CRITICAL
ERROR = 40
WARNING = 30 #WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0 #``不设置
二 默认级别为warning，默认打印到终端
import logging
logging.debug('``调试``debug')
logging.info('``消息``info')
logging.warning('``警告``warn')
logging.error('``错误``error')
logging.critical('``严重``critical')
'''
WARNING:root:``警告``warn
ERROR:root:``错误``error
CRITICAL:root:``严重``critical
'''
三 为logging模块指定全局配置，针对所有logger有效，控制打印到文件中
可在``logging.basicConfig()``函数中通过具体参数来更改``logging``模块默认行为，可用参数有
filename``：用指定的文件名创建``FiledHandler``（后边会具体讲解``handler``的概念），这样日志会被存储在指定的文件中。
filemode``：文件打开方式，在指定了``filename``时使用这个参数，默认值为``“a”``还可指定为``“w”``。
format``：指定``handler``使用的日志显示格式。
datefmt``：指定日期时间格式。
level``：设置``rootlogger``（后边会讲解具体概念）的日志级别
stream``：用指定的``stream``创建``StreamHandler``。可以指定输出到``sys.stderr,sys.stdout``或者文件，默认为``sys.stderr``。若同时列出了``filename``和``stream``两个参数，则``stream``参数会被忽略。
#``格式
%(name)s``：``Logger``的名字，并非用户名，详细查看
%(levelno)s``：数字形式的日志级别
%(levelname)s``：文本形式的日志级别
%(pathname)s``：调用日志输出函数的模块的完整路径名，可能没有
%(filename)s``：调用日志输出函数的模块的文件名
%(module)s``：调用日志输出函数的模块名
%(funcName)s``：调用日志输出函数的函数名
%(lineno)d``：调用日志输出函数的语句所在的代码行
%(created)f``：当前时间，用``UNIX``标准的表示时间的浮 点数表示
%(relativeCreated)d``：输出日志信息时的，自``Logger``创建以 来的毫秒数
%(asctime)s``：字符串形式的当前时间。默认格式是`` “2003-07-08 16:49:45,896”``。逗号后面的是毫秒
%(thread)d``：线程``ID``。可能没有
%(threadName)s``：线程名。可能没有
%(process)d``：进程``ID``。可能没有
%(message)s``：用户输出的消息
#======介绍
可在``logging.basicConfig()``函数中可通过具体参数来更改``logging``模块默认行为，可用参数有
filename``：用指定的文件名创建``FiledHandler``（后边会具体讲解``handler``的概念），这样日志会被存储在指定的文件中。
filemode``：文件打开方式，在指定了``filename``时使用这个参数，默认值为``“a”``还可指定为``“w”``。
format``：指定``handler``使用的日志显示格式。
datefmt``：指定日期时间格式。
level``：设置``rootlogger``（后边会讲解具体概念）的日志级别
stream``：用指定的``stream``创建``StreamHandler``。可以指定输出到``sys.stderr,sys.stdout``或者文件，默认为``sys.stderr``。若同时列出了``filename``和``stream``两个参数，则``stream``参数会被忽略。
format``参数中可能用到的格式化串：
%(name)s``=`` Logger``的名字
%(levelno)s``=`` ``数字形式的日志级别
%(levelname)s``=`` ``文本形式的日志级别
%(pathname)s ``=``调用日志输出函数的模块的完整路径名，可能没有
%(filename)s ``=``调用日志输出函数的模块的文件名
%(module)s ``=``调用日志输出函数的模块名
%(funcName)s ``=``调用日志输出函数的函数名
%(lineno)d ``=``调用日志输出函数的语句所在的代码行
%(created)f ``=``当前时间，用``UNIX``标准的表示时间的浮 点数表示
%(relativeCreated)d ``=``输出日志信息时的，自``Logger``创建以 来的毫秒数
%(asctime)s ``=``字符串形式的当前时间。默认格式是`` “2003-07-08 16:49:45,896”``。逗号后面的是毫秒
%(thread)d ``=``线程``ID``。可能没有
%(threadName)s ``=``线程名。可能没有
%(process)d``=`` ``进程``ID``。可能没有
%(message)s``=``用户输出的消息
#========使用
import logging
logging.basicConfig(filename='access.log',
format='%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S %p',
level=10)
logging.debug('``调试``debug')
logging.info('``消息``info')
logging.warning('``警告``warn')
logging.error('``错误``error')
logging.critical('``严重``critical')
#========结果
access.log``内容``:
2017-07-28 20:32:17 PM - root - DEBUG -test: ``调试``debug
2017-07-28 20:32:17 PM - root - INFO -test: ``消息``info
2017-07-28 20:32:17 PM - root - WARNING -test: ``警告``warn
2017-07-28 20:32:17 PM - root - ERROR -test: ``错误``error
2017-07-28 20:32:17 PM - root - CRITICAL -test: ``严重``critical
part2: ``可以为``logging``模块指定模块级的配置``,``即所有``logger``的配置
四 logging模块的Formatter，Handler，Logger，Filter对象
原理图：``https://pan.baidu.com/s/1skWyTT7
#logger``：产生日志的对象
#Filter``：过滤日志的对象
#Handler``：接收日志然后控制打印到不同的地方，``FileHandler``用来打印到文件中，``StreamHandler``用来打印到终端
#Formatter``对象：可以定制不同的日志格式对象，然后绑定给不同的``Handler``对象使用，以此来控制不同的``Handler``的日志格式
'''
critical=50
error =40
warning =30
info = 20
debug =10
'''
import logging
#1``、``logger``对象：负责产生日志，然后交给``Filter``过滤，然后交给不同的``Handler``输出
logger=logging.getLogger(__file__)
#2``、``Filter``对象：不常用，略
#3``、``Handler``对象：接收``logger``传来的日志，然后控制输出
h1=logging.FileHandler('t1.log') #``打印到文件
h2=logging.FileHandler('t2.log') #``打印到文件
h3=logging.StreamHandler() #``打印到终端
#4``、``Formatter``对象：日志格式
formmater1=logging.Formatter('%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S %p',)
formmater2=logging.Formatter('%(asctime)s : %(message)s',
datefmt='%Y-%m-%d %H:%M:%S %p',)
formmater3=logging.Formatter('%(name)s %(message)s',)
#5``、为``Handler``对象绑定格式
h1.setFormatter(formmater1)
h2.setFormatter(formmater2)
h3.setFormatter(formmater3)
#6``、将``Handler``添加给``logger``并设置日志级别
logger.addHandler(h1)
logger.addHandler(h2)
logger.addHandler(h3)
logger.setLevel(10)
#7``、测试
logger.debug('debug')
logger.info('info')
logger.warning('warning')
logger.error('error')
logger.critical('critical')
五 Logger与Handler的级别
logger``是第一级过滤，然后才能到``handler``，我们可以给``logger``和``handler``同时设置``level``，但是需要注意的是
Logger is also the first to filter the message based on a level — if you set the logger to INFO, and all handlers to DEBUG, you still won't receive DEBUG messages on handlers — they'll be rejected by the logger itself. If you set logger to DEBUG, but all handlers to INFO, you won't receive any DEBUG messages either — because while the logger says "ok, process this", the handlers reject it (DEBUG < INFO).
#``验证
import logging
form=logging.Formatter('%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S %p',)
ch=logging.StreamHandler()
ch.setFormatter(form)
# ch.setLevel(10)
ch.setLevel(20)
l1=logging.getLogger('root')
# l1.setLevel(20)
l1.setLevel(10)
l1.addHandler(ch)
l1.debug('l1 debug')
六 Logger的继承（了解）
import logging
formatter=logging.Formatter('%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S %p',)
ch=logging.StreamHandler()
ch.setFormatter(formatter)
logger1=logging.getLogger('root')
logger1.addHandler(ch)
logger1.setLevel(10)
logger1.debug('log1 debug')
七 应用
"""
logging``配置
"""
import os
import logging.config
# ``定义三种日志输出格式 开始
standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' \
'[%(levelname)s][%(message)s]' #``其中``name``为``getlogger``指定的名字
simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'
id_simple_format = '[%(levelname)s][%(asctime)s] %(message)s'
# ``定义日志输出格式 结束
logfile_dir = os.path.dirname(os.path.abspath(__file__)) # log``文件的目录
logfile_name = 'all2.log' # log``文件名
# ``如果不存在定义的日志目录就创建一个
if not os.path.isdir(logfile_dir):
os.mkdir(logfile_dir)
# log``文件的全路径
logfile_path = os.path.join(logfile_dir, logfile_name)
# log``配置字典
"""
logging配置
"""
import os
# 1、定义三种日志输出格式，日志中可能用到的格式化串如下
# %(name)s Logger的名字
# %(levelno)s 数字形式的日志级别
# %(levelname)s 文本形式的日志级别
# %(pathname)s 调用日志输出函数的模块的完整路径名，可能没有
# %(filename)s 调用日志输出函数的模块的文件名
# %(module)s 调用日志输出函数的模块名
# %(funcName)s 调用日志输出函数的函数名
# %(lineno)d 调用日志输出函数的语句所在的代码行
# %(created)f 当前时间，用UNIX标准的表示时间的浮 点数表示
# %(relativeCreated)d 输出日志信息时的，自Logger创建以 来的毫秒数
# %(asctime)s 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒
# %(thread)d 线程ID。可能没有
# %(threadName)s 线程名。可能没有
# %(process)d 进程ID。可能没有
# %(message)s用户输出的消息
# 2、强调：其中的%(name)s为getlogger时指定的名字
standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' \
'[%(levelname)s][%(message)s]'
simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'
test_format = '%(asctime)s] %(message)s'
# 3、日志配置字典
LOGGING_DIC = {
'version': 1,
'disable_existing_loggers': False,
'formatters': {
'standard': {
'format': standard_format
},
'simple': {
'format': simple_format
},
'test': {
'format': test_format
},
},
'filters': {},
'handlers': {
#``打印到终端的日志
'console': {
'level': 'DEBUG',
'class': 'logging.StreamHandler', # ``打印到屏幕
'formatter': 'simple'
},
#``打印到文件的日志``,``收集``info``及以上的日志
'default': {
'level': 'DEBUG',
'class': 'logging.handlers.RotatingFileHandler', # ``保存到文件``,``日志轮转
'formatter': 'standard',
# ``可以定制日志文件路径
# BASE_DIR = os.path.dirname(os.path.abspath(__file__)) # log``文件的目录
# LOG_PATH = os.path.join(BASE_DIR,'a1.log')
'filename': 'a1.log', # ``日志文件
'maxBytes': 1024*1024*5, # ``日志大小`` 5M
'backupCount': 5,
'encoding': 'utf-8', # ``日志文件的编码，再也不用担心中文``log``乱码了
},
'other': {
'level': 'DEBUG',
'class': 'logging.FileHandler', # ``保存到文件
'formatter': 'test',
'filename': 'a2.log',
'encoding': 'utf-8',
},
},
'loggers': {
#logging.getLogger(__name__)``拿到的``logger``配置
'': {
'handlers': ['default', 'console'], # ``这里把上面定义的两个``handler``都加上，即``log``数据既写入文件又打印到屏幕
'level': 'DEBUG', # loggers(``第一层日志级别关限制``)--->handlers(``第二层日志级别关卡限制``)
'propagate': False, # ``默认为``True``，向上（更高``level``的``logger``）传递，通常设置为``False``即可，否则会一份日志向上层层传递
},
'``专门的采集``': {
'handlers': ['other',],
'level': 'DEBUG',
'propagate': False,
},
},
}
def load_my_logging_cfg():
logging.config.dictConfig(LOGGING_DIC) # ``导入上面定义的``logging``配置
logger = logging.getLogger(__name__) # ``生成一个``log``实例
logger.info('It works!') # ``记录该文件的运行状态
if __name__ == '__main__':
load_my_logging_cfg()
"""
MyLogging Test
"""
import time
import logging
import my_logging # ``导入自定义的``logging``配置
logger = logging.getLogger(__name__) # ``生成``logger``实例
def demo():
logger.debug("start range... time:{}".format(time.time()))
logger.info("``中文测试开始。。。``")
for i in range(10):
logger.debug("i:{}".format(i))
time.sleep(0.2)
else:
logger.debug("over range... time:{}".format(time.time()))
logger.info("``中文测试结束。。。``")
if __name__ == "__main__":
my_logging.load_my_logging_cfg() # ``在你程序文件的入口加载自定义``logging``配置
demo()
注意注意注意：
#1``、有了上述方式我们的好处是：所有与``logging``模块有关的配置都写到字典中就可以了，更加清晰，方便管理
#2``、我们需要解决的问题是：
1``、从字典加载配置：``logging.config.dictConfig(settings.LOGGING_DIC)
2``、拿到``logger``对象来产生日志
logger``对象都是配置到字典的``loggers ``键对应的子字典中的
``按照我们对``logging``模块的理解，要想获取某个东西都是通过名字，也就是``key``来获取的
``于是我们要获取不同的``logger``对象就是
logger=logging.getLogger('loggers``子字典的``key``名``')
``但问题是：如果我们想要不同``logger``名的``logger``对象都共用一段配置，那么肯定不能在``loggers``子字典中定义``n``个``key
'loggers': {
'l1': {
'handlers': ['default', 'console'], #
'level': 'DEBUG',
'propagate': True, # ``向上（更高``level``的``logger``）传递
},
'l2: {
'handlers': ['default', 'console' ],
'level': 'DEBUG',
'propagate': False, # ``向上（更高``level``的``logger``）传递
},
'l3': {
'handlers': ['default', 'console'], #
'level': 'DEBUG',
'propagate': True, # ``向上（更高``level``的``logger``）传递
},
}
#``我们的解决方式是，定义一个空的``key
'loggers': {
'': {
'handlers': ['default', 'console'],
'level': 'DEBUG',
'propagate': True,
},
}
这样我们再取``logger``对象时
logging.getLogger(__name__)``，不同的文件``__name__``不同，这保证了打印日志时标识信息不同，但是拿着该名字去``loggers``里找``key``名时却发现找不到，于是默认使用``key=''``的配置
另外一个django的配置，瞄一眼就可以，跟上面的一样
#logging_config.py
LOGGING = {
'version': 1,
'disable_existing_loggers': False,
'formatters': {
'standard': {
'format': '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]'
'[%(levelname)s][%(message)s]'
},
'simple': {
'format': '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'
},
'collect': {
'format': '%(message)s'
}
},
'filters': {
'require_debug_true': {
'()': 'django.utils.log.RequireDebugTrue',
},
},
'handlers': {
#``打印到终端的日志
'console': {
'level': 'DEBUG',
'filters': ['require_debug_true'],
'class': 'logging.StreamHandler',
'formatter': 'simple'
},
#``打印到文件的日志``,``收集``info``及以上的日志
'default': {
'level': 'INFO',
'class': 'logging.handlers.RotatingFileHandler', # ``保存到文件，自动切
'filename': os.path.join(BASE_LOG_DIR, "xxx_info.log"), # ``日志文件
'maxBytes': 1024 * 1024 * 5, # ``日志大小`` 5M
'backupCount': 3,
'formatter': 'standard',
'encoding': 'utf-8',
},
#``打印到文件的日志``:``收集错误及以上的日志
'error': {
'level': 'ERROR',
'class': 'logging.handlers.RotatingFileHandler', # ``保存到文件，自动切
'filename': os.path.join(BASE_LOG_DIR, "xxx_err.log"), # ``日志文件
'maxBytes': 1024 * 1024 * 5, # ``日志大小`` 5M
'backupCount': 5,
'formatter': 'standard',
'encoding': 'utf-8',
},
#``打印到文件的日志
'collect': {
'level': 'INFO',
'class': 'logging.handlers.RotatingFileHandler', # ``保存到文件，自动切
'filename': os.path.join(BASE_LOG_DIR, "xxx_collect.log"),
'maxBytes': 1024 * 1024 * 5, # ``日志大小`` 5M
'backupCount': 5,
'formatter': 'collect',
'encoding': "utf-8"
}
},
'loggers': {
#logging.getLogger(__name__)``拿到的``logger``配置
'': {
'handlers': ['default', 'console', 'error'],
'level': 'DEBUG',
'propagate': True,
},
#logging.getLogger('collect')``拿到的``logger``配置
'collect': {
'handlers': ['console', 'collect'],
'level': 'INFO',
}
},
}
# -----------
# ``用法``:``拿到俩个``logger
logger = logging.getLogger(__name__) #``线上正常的日志
collect_logger = logging.getLogger("collect") #``领导说``,``需要为领导们单独定制领导们看的日志
应用
paramiko模块
2022年7月31日
19:18
介绍
Paramiko是用python语言写的一个模块，远程连接到Linux服务器，查看上面的日志状态，批量配置远程服务器，文件上传，文件下载等
paramiko是一个基于SSH用于连接远程服务器并执行相关操作（SSHClient和SFTPClinet,即一个是远程连接，一个是上传下载服务），使用该模块可以对远程服务器进行命令或文件操作，值得一说的是，fabric和ansible内部的远程管理就是使用的paramiko来现实
ssh是一个协议，OpenSSH是其中一个开源实现，paramiko是Python的一个库，实现了SSHv2协议(底层使用cryptography)。
有了Paramiko以后，我们就可以在Python代码中直接使用SSH协议对远程服务器执行操作，而不是通过ssh命令对远程服务器进行操作。
Paramiko介绍
paramiko包含两个核心组件：SSHClient和SFTPClient。
- SSHClient的作用类似于Linux的ssh命令，是对SSH会话的封装，该类封装了传输(Transport)，通道(Channel)及SFTPClient建立的方法(open_sftp)，通常用于执行远程命令。
- SFTPClient的作用类似与Linux的sftp命令，是对SFTP客户端的封装，用以实现远程文件操作，如文件上传、下载、修改文件权限等操作。
# Paramiko中的几个基础名词：
1``、``Channel``：是一种类``Socket``，一种安全的``SSH``传输通道；
2``、``Transport``：是一种加密的会话，使用时会同步创建了一个加密的``Tunnels(``通道``)``，这个``Tunnels``叫做``Channel``；
3``、``Session``：是``client``与``Server``保持连接的对象，用``connect()/start_client()/start_server()``开始会话。
Paramiko的基本使用
SSHClient常用的方法介绍
connect()：实现远程服务器的连接与认证，对于该方法只有hostname是必传参数。
常用参数
hostname ``连接的目标主机`
`port=SSH_PORT ``指定端口`
`username=None ``验证的用户名`
`password=None ``验证的用户密码`
`pkey=None ``私钥方式用于身份验证`
`key_filename=None ``一个文件名或文件列表，指定私钥文件`
`timeout=None ``可选的``tcp``连接超时时间`
`allow_agent=True, ``是否允许连接到``ssh``代理，默认为``True ``允许`
`look_for_keys=True ``是否在``~/.ssh``中搜索私钥文件，默认为``True ``允许`
`compress=False, ``是否打开压缩
set_missing_host_key_policy()：
设置远程服务器没有在know_hosts文件中记录时的应对策略。目前支持三种策略：
AutoAddPolicy 自动添加主机名及主机密钥到本地HostKeys对象，不依赖load_system_host_key的配置。即新建立ssh连接时不需要再输入yes或no进行确认
WarningPolicy 用于记录一个未知的主机密钥的python警告。并接受，功能上和AutoAddPolicy类似，但是会提示是新连接
RejectPolicy 自动拒绝未知的主机名和密钥，依赖load_system_host_key的配置。此为默认选项
exec_command()：
在远程服务器执行Linux命令的方法。
open_sftp()：
在当前``ssh``会话的基础上创建一个``sftp``会话。该方法会返回一个``SFTPClient``对象。
# ``利用``SSHClient``对象的``open_sftp()``方法，可以直接返回一个基于当前连接的``sftp``对象，可以进行文件的上传等操作``. sftp=client.open_sftp()sftp.put('local.txt','remote.txt'
SSHClient常用的方法举例
import paramiko
# ``实例化``SSHClient
ssh_client = paramiko.SSHClient()
# ``自动添加策略，保存服务器的主机名和密钥信息，如果不添加，那么不再本地``know_hosts``文件中记录的主机将无法连接 ，此方法必须放在``connect``方法的前面
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
# ``连接``SSH``服务端，以用户名和密码进行认证 ，调用``connect``方法连接服务器
ssh_client.connect(hostname='192.168.137.105', port=22, username='root', password='123456')
# ``打开一个``Channel``并执行命令 `` ``结果放到``stdout``中，如果有错误将放到``stderr``中
stdin, stdout, stderr = ssh_client.exec_command('df -hT ')
# stdout ``为正确输出，``stderr``为错误输出，同时是有``1``个变量有值 `` # ``打印执行结果 `` print(stdout.read().decode('utf-8'))
# ``关闭``SSHClient``连接
ssh_client.close()
密钥连接方式
# ``配置私人密钥文件位置
private = paramiko.RSAKey.from_private_key_file('/root/.ssh/id_rsa')
#``实例化``SSHClient
ssh_client = paramiko.SSHClient()
#``自动添加策略，保存服务器的主机名和密钥信息，如果不添加，那么不再本地``know_hosts``文件中记录的主机将无法连接
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
#``连接``SSH``服务端，以用户名和密码进行认证
ssh_client.connect(
hostname='192.168.137.100',
port=22,
username='root',
pkey=private
)
SFTPClient常用方法介绍
SFTPCLient作为一个sftp的客户端对象，根据ssh传输协议的sftp会话，实现远程文件操作，如上传、下载、权限、状态
from_transport(cls,t) ``创建一个已连通的``SFTP``客户端通道
put(localpath, remotepath, callback=None, confirm=True) ``将本地文件上传到服务器
参数``confirm``：是否调用``stat()``方法检查文件状态，返回``ls -l``的结果
get(remotepath, localpath, callback=None) ``从服务器下载文件到本地
mkdir() ``在服务器上创建目录
remove() ``在服务器上删除目录
rename() ``在服务器上重命名目录
stat() ``查看服务器文件状态
listdir() ``列出服务器目录下的文件
SFTPClient常用方法举例
import paramiko
# ``实例化一个``transport``对象
tran = paramiko.Transport(('192.168.137.100', 22))
# ``连接``SSH``服务端，使用``password
tran.connect(username="root", password='123456')
# ``或使用
# ``配置私人密钥文件位置
private = paramiko.RSAKey.from_private_key_file('/root/.ssh/id_rsa')
# ``连接``SSH``服务端，使用``pkey``指定私钥
tran.connect(username="root", pkey=private)
# ``获取``SFTP``实例
sftp = paramiko.SFTPClient.from_transport(tran)
# ``设置上传的本地``/``远程文件路径
local_path = "/home/1.txt"
remote_path = "/tmp/1.txt"
# ``执行上传动作
sftp.put(local_path, remote_path)
# ``执行下载动作
sftp.get(remote_path, local_path)
# ``关闭``Transport``通道
tran.close()
openpyxl模块
2022年7月31日
14:08
方法
打开方式
wb=Workbook()#``新建``Excel``工作簿
wb=load_workbook("data\``领料单（每日）``.xlsx") ``# ``打开存在的表格
保存方式
wb.save("data\``领料单（每日）``-``更改后``.xlsx") # ``保存表格
获取工作表的方式
sheet_names=wb.get_sheet_names()`` # ``获取每个表的名字
ws=wb[sheet_name] # ``获取指定的表格
ws=wb.active #``读取活动工作表
设置数据的方式
直接指定单元格
ws['A4'].value="``零件测试领料单``" #``直接将``A4``单元格的值改为需要的值
ws['A4'].value ``获取数据
指定行列
ws.cell(``行``,column=``列``,value=``值``)
ws.cell(``行``,``列``).value ``# ``获取值
设置样式
第一步导包
from openpyxl.styles import Border, Side, PatternFill, Font, GradientFill, Alignment
第二步获取单元格
c = ws.cell(row=row_number,column=col_number)
第三部设置
c.font = Font(name='Arial'``，``size=10) # ``设置字体 和大小
c.border = Border(top=thin, left=thin, right=thin, bottom=thin) # ``设置边框
c.alignment = Alignment(horizontal="left", vertical="center") ``# ``设置对其
案例
from openpyxl import load_workbook
wb=load_workbook("data\``领料单（每日）``.xlsx") ``# ``打开存在的表格
sheet_names=wb.get_sheet_names()#``获得工作簿的所有工作表名
for sheet_name in sheet_names:#``遍历每个工作表，更改``A4``单元格的数据
ws=wb[sheet_name] # ``获取指定的表格
ws['A4'].value="``零件测试领料单``" #``直接将``A4``单元格的值改为需要的值
wb.save("data\``领料单（每日）``-``更改后``.xlsx") # ``保存表格
Python-docx模块
2022年10月9日
15:10
写word
案例一：
# -*- coding: utf-8 -*-
# All Rights Reserved
# @Time : 2022/10/914:31
# @Author : Small Fu
# @Email : 2737454073@qq.com
# @File : word_xiaoy.py
__author__ = 'Small Fu'
from docx import Document # ``初始化``word
from docx.enum.text import WD_PARAGRAPH_ALIGNMENT # ``段落对其
from docx.shared import Pt # ``字体磅数
from docx.oxml.ns import qn # ``设置中文格式
import time
price = input("``今日价格：``")
# ``这是客户
customer_list = [f"``客户``{i}" for i in range(10)]
time_sameDay = time.strftime("%Y``年`` %m``月`` %d``日``", time.localtime())
# ``开始设置
for customer in customer_list:
doc = Document()
# ``设置基础字体``,``这个值设置英文和数字
doc.styles["Normal"].font.name = u"``宋体``"
# ``增加中文支持
doc.styles["Normal"]._element.rPr.rFonts.set(qn("w:eastAsia"), u"``宋体``")
# ``初始化一个段落
p1 = doc.add_paragraph()
# ``设置文字对齐居中，没有的话默认左对齐
p1.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
# ``添加第一段的内容
run1 = p1.add_run(f"``关于下达``{time_sameDay}``产品价格通知``")
# ``设置这一段的字体是微软雅黑西文
run1.font.name = "``微软雅黑``"
# ``设置中文
run1._element.rPr.rFonts.set(qn("w:eastAsia"), u"``宋体``")
# ``设置字体大小
run1.font.size = Pt(21)
# ``是否加粗，默认不加粗，``False
run1.font.bold = True
# ``设置这一段前面的字体大小和后面的
p1.space_after = Pt(5)
p1.space_before = Pt(5)
# ``第二段内容
p2 = doc.add_paragraph()
# ``这里是添加尊称
run2 = p2.add_run(f"{customer}: \n ``您好``")
# ``设置这一段的字体是微软雅黑西文
run2.font.name = "``仿宋``_GB2312"
# ``设置中文
run2._element.rPr.rFonts.set(qn("w:eastAsia"), u"``仿宋``_GB2312 ")
# ``设置字体大小
run2.font.size = Pt(16)
# ``是否加粗，默认不加粗，``False
run2.font.bold = True
# ``第三段内容
p3 = doc.add_paragraph()
# ``这里是添加尊称
run3 = p3.add_run(f" ``根据公司安排，为提供优质客户需求，我单位拟定了今日黄金价格为``{price}``元，特此通知``")
# ``设置这一段的字体是微软雅黑西文
run3.font.name = "``仿宋``_GB2312"
# ``设置中文
run3._element.rPr.rFonts.set(qn("w:eastAsia"), u"``仿宋``_GB2312 ")
# ``设置字体大小
run3.font.size = Pt(16)
# ``是否加粗，默认不加粗，``False
run3.font.bold = True
# ``第四段内容
p4 = doc.add_paragraph()
# ``这里是添加尊称
run4 = p4.add_run(" ``联系人：小符`` ``电话：``176XXXXXX44 ")
# ``设置这一段的字体是微软雅黑西文
run4.font.name = "``仿宋``_GB2312"
# ``设置中文
run4._element.rPr.rFonts.set(qn("w:eastAsia"), u"``仿宋``_GB2312 ")
# ``设置字体大小
run4.font.size = Pt(16)
# ``是否加粗，默认不加粗，``False
run4.font.bold = True
# ``保存
doc.save(f"{customer}-``价格通知``.docx")
案例二图片添加
# -*- coding: utf-8 -*-
# All Rights Reserved
# @Time : 2022/10/915:13
# @Author : Small Fu
# @Email : 2737454073@qq.com
# @File : xiaofu-img.py
__author__ = 'Small Fu'
from docx import Document # ``初始化``word
from docx.enum.text import WD_PARAGRAPH_ALIGNMENT # ``段落对其
from docx.shared import Pt # ``字体磅数
from docx.oxml.ns import qn # ``设置中文格式
from docx.shared import Inches # ``图片尺寸
import time
price = input("``今日价格：``")
# ``这是客户
customer_list = [f"``客户``{i}" for i in range(10)]
time_sameDay = time.strftime("%Y``年`` %m``月`` %d``日``", time.localtime())
# ``开始设置
for customer in customer_list:
doc = Document()
# ``设置基础字体``,``这个值设置英文和数字
doc.styles["Normal"].font.name = u"``宋体``"
# ``增加中文支持
doc.styles["Normal"]._element.rPr.rFonts.set(qn("w:eastAsia"), u"``宋体``")
# ``文档添加图片``width=Inches(6) ``这里设置的是``6``英寸
doc.add_picture("./img_1.png",width=Inches(6))
# ``初始化一个段落
p1 = doc.add_paragraph()
# ``设置文字对齐居中，没有的话默认左对齐
p1.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
# ``添加第一段的内容
run1 = p1.add_run(f"``关于下达``{time_sameDay}``产品价格通知``")
# ``设置这一段的字体是微软雅黑西文
run1.font.name = "``微软雅黑``"
# ``设置中文
run1._element.rPr.rFonts.set(qn("w:eastAsia"), u"``宋体``")
# ``设置字体大小
run1.font.size = Pt(21)
# ``是否加粗，默认不加粗，``False
run1.font.bold = True
# ``设置这一段前面的字体大小和后面的
p1.space_after = Pt(5)
p1.space_before = Pt(5)
# ``第二段内容
p2 = doc.add_paragraph()
# ``这里是添加尊称
run2 = p2.add_run(f"{customer}: \n ``您好``")
# ``设置这一段的字体是微软雅黑西文
run2.font.name = "``仿宋``_GB2312"
# ``设置中文
run2._element.rPr.rFonts.set(qn("w:eastAsia"), u"``仿宋``_GB2312 ")
# ``设置字体大小
run2.font.size = Pt(16)
# ``是否加粗，默认不加粗，``False
run2.font.bold = True
# ``第三段内容
p3 = doc.add_paragraph()
# ``这里是添加尊称
run3 = p3.add_run(" ``根据公司安排，为提供优质客户服务，我单位现将价格通知如下：`` ")
# ``设置这一段的字体是仿宋``_GB2312``西文
run3.font.name = "``仿宋``_GB2312"
# ``设置中文
run3._element.rPr.rFonts.set(qn("w:eastAsia"), u"``仿宋``_GB2312 ")
# ``设置字体大小
run3.font.size = Pt(16)
# ``是否加粗，默认不加粗，``False
run3.font.bold = True
# ``添加表格``row=``行``,cols=``列``,style=``样式
table = doc.add_table(rows=3,cols=3,style="Table Grid")
# ``这里是从第``0``行``0``列合并到``0``行``2``列
table.cell(0,0).merge(table.cell(0,2))
# ``添加到合并的单元格
table_run1 = table.cell(0,0).paragraphs[0].add_run("xx``商品报表``")
table_run1.font.name = u"``隶书``"
# ``设置中文
table_run1._element.rPr.rFonts.set(qn("w:eastAsia"), u"``隶书`` ")
# ``设置居中
table.cell(0,0).paragraphs[0].alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
# ``添加
table.cell(1,0).text="``日期``"
table.cell(1,1).text="``价格``"
table.cell(1,2).text="``备注``"
table.cell(2,0).text=time_sameDay
table.cell(2,1).text=set(price)
table.cell(2,2).text=""
# ``第四段内容
p4 = doc.add_paragraph()
# ``这里是添加尊称
run4 = p4.add_run(" ``联系人：小符`` ``电话：``176XXXXXX44 ")
# ``设置这一段的字体是微软雅黑西文
run4.font.name = "``仿宋``_GB2312"
# ``设置中文
run4._element.rPr.rFonts.set(qn("w:eastAsia"), u"``仿宋``_GB2312 ")
# ``设置字体大小
run4.font.size = Pt(16)
# ``是否加粗，默认不加粗，``False
run4.font.bold = True
# ``下一页添加一个广告
# ``插入分页符
doc.add_page_break()
# ``文档添加图片``width=Inches(6) ``这里设置的是``6``英寸
doc.add_picture("./img_1.png",width=Inches(6))
doc.save(f"{customer}-``价格图片表格通知``.docx")
读word
案例一：读纯文本
# -*- coding: utf-8 -*-
# All Rights Reserved
# @Time : 2022/10/915:54
# @Author : Small Fu
# @Email : 2737454073@qq.com
# @File : ``读取简单``word``纯文本``.py
__author__ = 'Small Fu'
from docx import Document
doc = Document("``地址``.docx")
all_paragraphs = doc.paragraphs # ``读取所有的段落
for paragraphs in all_paragraphs:
print(paragraphs.text)
案例二：读取表格文本
# -*- coding: utf-8 -*-
# All Rights Reserved
# @Time : 2022/10/916:02
# @Author : Small Fu
# @Email : 2737454073@qq.com
# @File : ``读取表格文本``.py
__author__ = 'Small Fu'
from docx import Document
doc = Document("``路径``")
all_tables = doc.tables
for tables in all_tables:
for row in tables.rows:
for cell in row.cells:
print(cell.text)
案例三：读取表格嵌套纯文本
# -*- coding: utf-8 -*-
# All Rights Reserved
# @Time : 2022/10/916:06
# @Author : Small Fu
# @Email : 2737454073@qq.com
# @File : ``读取表格嵌套纯文本``.py
__author__ = 'Small Fu'
import zipfile
word = zipfile.ZipFile("``路径``")
xml = word.read("word/document.xml").decode('utf-8')
xml_list = xml.split("<w:t>")
text_file = []
for xml in xml_list:
if xml.find("</w:t>")+1:
text_file.append(
xml[:xml.find("</w:t>")]
)
else:
pass
text_file = "".join(text_file)
格式化word：函数式
案例一：
# -*- coding: utf-8 -*-
# All Rights Reserved
# @Time : 2022/10/916:23
# @Author : Small Fu
# @Email : 2737454073@qq.com
# @File : ``函数式模板``.py
__author__ = 'Small Fu'
from docx import Document # ``初始化``word
from docx.enum.text import WD_PARAGRAPH_ALIGNMENT # ``段落对其
from docx.shared import Pt # ``字体磅数
from docx.oxml.ns import qn # ``设置中文格式
doc = Document()
doc.styles["Normal"].font.name = u"``黑体``"
doc.styles["Normal"]._element.rPr.rFonts.set(qn("w:eastAsia"), u"``黑体``")
def add_context(context):
p1 = doc.add_paragraph()
p1.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
# ``添加内容
run1 = p1.add_run(str(context))
# ``设置这一段的字体是微软雅黑西文
run1.font.size = Pt(16)
# ``设置这一段前面的字体大小和后面的
p1.space_after = Pt(5)
p1.space_before = Pt(5)
word转pdf
tqdm模块
2021年12月2日
14:59
Tqdm
Tqdm 是一个快速，可扩展的Python进度条，可以在 Python 长循环中添加一个进度提示信息，用户只需要封装任意的迭代器 tqdm(iterator)。
安装
pip install tqdm
使用
#for I in tqdm(range(100)):
#time.sleep(0.0001)
#
#
#for j in trange(100):
#time.sleep(0.1)
两个效果是一样的
如果是遍历列表之类的可以用
# alist=list('letters')
# bar=tqdm(alist)
# for letter in bar:
bar.set_description(f"Nowget{letter}")
# pbar=tqdm(["a","b","c","d"])
# for char inp bar:
# time.sleep(1)
# pbar.set_description("Processing%s"%char)
tqdm模块参数说明
class tqdm(object):
"""
Decorate an iterable object, returning an iterator which acts exactly
like the original iterable, but prints a dynamically updating
progressbar every time a value is requested.
"""
def __init__(self,
iterable=None,
desc=None,
total=None,
leave=False,
file=sys.stderr,
ncols=None,
mininterval=0.1,
maxinterval=10.0,
miniters=None,
ascii=None,
disable=False,
unit='it',
unit_scale=False,
dynamic_ncols=False,
smoothing=0.3,
nested=False,
bar_format=None,
initial=0,
gui=False
):
iterable: ``可迭代的对象``, ``在手动更新时不需要进行设置
desc: ``字符串``, ``左边进度条描述文字
total: ``总的项目数
leave: bool``值``, ``迭代完成后是否保留进度条
file: ``输出指向位置``, ``默认是终端``, ``一般不需要设置
ncols: ``调整进度条宽度``, ``默认是根据环境自动调节长度``, ``如果设置为``0, ``就没有进度条``, ``只有输出的信息
unit: ``描述处理项目的文字``, ``默认是``'it', ``例如``: 100 it/s, ``处理照片的话设置为``'img' ,``则为`` 100 img/s
unit_scale: ``自动根据国际标准进行项目处理速度单位的换算``, ``例如`` 100000 it/s >> 100k it/s
爬虫下载文件结合tqdm
from tqdm import tqdm
import requests
url='https://dldir1.qq.com/qqtv/TencentVideo11.14.4043.0.exe'
response=requests.get(url,stream=True) # ``设``stream``流传输方式为真
print(response.headers) # ``打印查看基本头信息
data_size=int(response.headers['Content-Length'])/1024/1024 # ``字节``/1024/1024=MB
with open('``测试``.exe','wb') as f:
for data in tqdm(iterable=response.iter_content(1024*1024),total=data_size,desc='``正在下载``',unit='MB'):
f.write(data)
因此我将iter_content(chunk_size)->chunk_size理解为一个列表的容量，
而iterable=response.iter_content(1024*1024)理解为分割字符串的函数，
将response.content分割为每个元素的长度是1024*1024大小的列表，在对每个部分进行下载。
这只是助于理解chunk_size的一个方法
而response.iter_content 是流传输(简单说就是边下载边写入磁盘),如果将chunk_size设置的很小，意味着每次
下载和存在很小的一部分，下载的速度也会很慢,如果设置的很大，则进度条的进度会错乱，因此我们在确定chunk_size
大小的时候应该对应文件大小，data_size除以多少，chunk_size就乘以多少，才能使进度条对应。
# -*- coding: utf-8 -*-
# All Rights Reserved
# @Time : 2022/6/29 18:32
# @Author : ``符青
# @Email : 2737454073@qq.com
# @File : aa.py
# @Software: PyCharm
import pprint
import requests
from tqdm import tqdm
url = '`https://v3-default.ixigua.com/37179974c244973c87813da84e13ff61/62bc51c7/video/tos/cn/tos-cn-v-0064/25755a2b84b24deeaa48d8e3407b0baa/?libvio.cc&filename=1.mp4`'
response = requests.get(url, stream=True) # ``采用流处理传输输入
pprint.pprint(response.headers)
# ``查看数据大小
data_sice = int(response.headers['Content-Length'])
print(data_sice)
rr = tqdm(
total=data_sice,
desc='``下载恰恰丝滑``',
unit='mb',
unit_scale=True
)
with open('./``恰恰丝滑``.mp4', 'wb+') as ff:
for i in response.iter_content(1024*1024):
rr.update(len(i))
ff.write(i)
ff.close()
pyautogui模块
2022年7月20日
0:46
介绍
自动 防故障功能
pyautogui.FAILSAFE =False
默认这项功能为``True, ``这项功能意味着：当鼠标的指针在屏幕的最坐上方，程序会报错；目的是为了防止程序无法停止；
停顿功能
pyautogui.PAUSE = 1
意味着所有``pyautogui``的指令都要暂停一秒；其他指令不会停顿；这样做，可以防止键盘鼠标操作太快；
鼠标操作函数
操作鼠标点击的函数。
| 函数 | 简单说明 |
|---|---|
| move(x,y)、 moveTo(x,y) | 移动鼠标，前者移动相对位置，后者移动到指定位置 |
| click(x,y)、doubleClick、rightClick | 单击/双击/右击，无参版本在当前位置点击鼠标 |
| drag(x,y)、dragTo(x,y) | 拖动鼠标 |
| mouseDown、mouseUp | 按下按键，松开按键 |
| scroll | 向下滚动鼠标滚轮的函数 |
键盘操作函数
操作键盘按键的函数。
| 函数 | 简介 |
|---|---|
| press(‘left’,press=3) | |
| hotkey(‘ctrl’,‘s’) | 按下Ctrl+S组合键 |
| keyDown、keyUp | 按下和松开键盘按键 |
提示框函数
PyAutoGUI可以显示提示框，这时候程序会暂停运行，直到用户点击提示框。
| 函数 | 简介 |
|---|---|
| alert(text=’’,title=’’,button=[‘OK’,‘Cancle’]) | 显示警告对话框 |
| confirm() | 显示确认对话框 |
| prompt() | 显示提示对话框 |
| password() | 显示密码输入对话框 |
屏幕截图和定位函数
截取屏幕的函数，也可以从屏幕中寻找匹配的图片，并返回其坐标。你可以事先保存一些按钮的截图，然后通过这种方式定位按钮的位置，然后点击。
| 函数 | 简介 |
|---|---|
| screenshot(‘image.png’) | 保存截图并返回截图，无参版本直接返回截图不保存 |
| center(‘image.png’) | 从屏幕上寻找图片位置，返回框位置 |
| locateOnScreen(‘img’) | 从屏幕寻找图片位置，直接返回坐标 |
Pil模块
2022年6月2日
23:47
PIL``功能介绍与安装
PIL``，全称``Python Image Library``，主要作用是图像处理，可用于图片剪切、粘贴、缩放、镜像、水印、颜色块、滤镜、图像格式转换、色场空间转换、验证码、旋转图像、图像增强、直方图处理、插值和滤波等功能。不过只支持到``Python 2.7``。``Pillow``是``PIL``的一个派生分支，但如今已经发展成为比``PIL``本身更具活力的图像处理库。我们需要安装的就是``Pillow``。
PIL``具体用途：图像归档``(Image Archives)``。``PIL``非常适合于图像归档以及图像的批处理任务。你可以使用``PIL``创建缩略图，转换图像格式，打印图像等等。
``图像展示``(Image Display)``。``PIL``较新的版本支持包括``Tk PhotoImage``，``BitmapImage``还有``Windows DIB``等接口。``PIL``支持众多的``GUI``框架接口，可以用于图像展示。
``图像处理``(Image Processing)``。``PIL``包括了基础的图像处理函数，包括对点的处理，使用众多的卷积核``(convolution kernels)``做过滤``(filter),``还有颜色空间的转换。``PIL``库同样支持图像的大小转换，图像旋转，以及任意的仿射变换。``PIL``还有一些直方图的方法，允许你展示图像的一些统计特性。这个可以用来实现图像的自动对比度增强，还有全局的统计分析等。
pip install Pillow
PIL的基本操作
from PIL import Image
# 1.``打开图片
img = Image.open("image/10.png")
# 2.``显示图片``(``执行显示图片后线程会中断，关闭图像后恢复``)
img.show()
# 3.``保存图片
img.save("image/xiaomai.png")
我在尝试的过程中发现，``png``格式的图片保存为``jpg``格式时会报错：``OSError: cannot write mode RGBA as JPEG``，经过查阅资料发现错误原因主要是因为``PNG``格式和``JPG``格式图片的通道数不同。
PNG``是四通道：``RGBA``意思是红色，绿色，蓝色，``Alpha``的色彩空间，``Alpha``指透明度
JPG``是三通道：``RGB``意思是红色，绿色，蓝色
所以，``PNG``格式图片要保存成``JPG``格式就要丢弃``A``通道：
from PIL import Image
# 1.``打开图片
img = Image.open("image/10.png")
# 2.``显示图片``(``执行显示图片后线程会中断，关闭图像后恢复``)
img.show()
# 3.``保存图片
img = img.convert("RGB")
img.save("image/xiaomai.jpg")
下面是图片旋转的代码：
from PIL import Image
# 1.``打开图片
img = Image.open("pli/7.png")
# 2.``水平翻转
img1 = img.transpose(Image.FLIP_LEFT_RIGHT)
# 3.``保存图片
img1.save("pli/1.png")
# 4.``垂直翻转
img2 = img.rotate(180)
# 5.``保存照片
img2.save("pli/2.png")
# 6.``水平``+``垂直翻转
img3 = img.transpose(Image.FLIP_LEFT_RIGHT).rotate(180)
# 7.``保存图片
img3.save("pli/3.png")
给图片增加文字
要在图像上绘制文本要用到 PIL 的两个模块：ImageDraw和ImageFont。 ImageDraw 用于创建绘图对象，ImageFont用于加载字体。
from PIL import Image, ImageDraw, ImageFont
# 1.``打开图片
img = Image.open("image/10.png")
# 2.``调用画图模块
draw = ImageDraw.Draw(img)
# 3.``设置字体
tfont = ImageFont.truetype("``萌神手写体``.ttf", 24)
# 4.``添加文字
"""
``参数一：文字在图片的位置：``(x, y)
``参数二：文字内容
``参数三：字体颜色，当然颜色也可以用``RGB``值指定
``参数四：字体类型
"""
draw.text((50, 30), "eyes++", fill="green", font=tfont)
# 5.``保存图片
img.save("image/addWord.png")
# 6.``显示图片
img.show()
PIL滤镜功能
from PIL import Image, ImageFilter
img = Image.open("image/10.png")
img = img.filter(ImageFilter.CONTOUR)
img.save("image/Filter.png")
img.show()
PIL镜像功能
from PIL import Image
img = Image.open("image/10.png")
img = img.transpose(Image.FLIP_LEFT_RIGHT)
img.save("image/mirror.png")
transpose有这么几种模式
FLIP_LEFT_RIGHT：左右镜像
FLIP_TOP_BOTTOM：上下镜像
ROTATE_90：逆时针转90度
ROTATE_180：逆时针转180度
ROTATE_270：逆时针转270度
TRANSPOSE：像素矩阵转置
TRANSVERSE
最后一种模式我也不知道什么意思，也没查到，但效果是下面这样的，盲猜是对角线对转。。。。。
图片拼接功能
from PIL import Image, ImageDraw
# ``打开图片
img1 = Image.open("image/10.png")
img2 = Image.open("image/addWord.png")
# ``查看图片尺寸，便于拼接图片
print(img1.size)
print(img1.size)
# ``新建空白图片``,``三个参数分别是模式``(RGB/RGBA)``、大小、颜色
newimg = Image.new(mode="RGB", size=(1174, 614), color=(255, 100, 50))
# ``拼接图片``,``第一个参数是图片，第二个是起始位置
newimg.paste(img1, (0, 0))
newimg.paste(img2, (587, 0))
newimg.show()
PIL裁剪功能
from PIL import Image
img = Image.open("image/10.png")
print(img.size)
imgCut = img.crop((100, 200, 500, 600))
imgCut.show()
图片缩放
from PIL import Image
# :
img = Image.open('image/10.png')
# ``获得图像尺寸``:
w, h = img.size
# ``缩放到``50%:
img.thumbnail((w//2, h//2))
# ``把缩放后的图像用``jpeg``格式保存``:
img.save('image/zoom.png')
shutil****模块
2022年7月13日
11:00
高级的 文件、文件夹、压缩包 处理模块
shutil.copyfileobj(fsrc, fdst[, length])
将文件内容拷贝到另一个文件中
1import shutil`
`23shutil.copyfileobj(open('old.xml','r'), open('new.xml', 'w'))
shutil.copyfile(src, dst)
拷贝文件
shutil.copyfile('f1.log', 'f2.log') #``目标文件无需存在
shutil.copymode(src, dst)
仅拷贝权限。内容、组、用户均不变
1shutil.copymode('f1.log', 'f2.log') #``目标文件必须存在
shutil.copystat(src, dst)
仅拷贝状态的信息，包括：``mode bits, atime, mtime, flags
1shutil.copystat('f1.log', 'f2.log') #``目标文件必须存在
shutil.copy(src, dst)
拷贝文件和权限
import shutil`
`shutil.copy('f1.log', 'f2.log')
shutil.copy2(src, dst)
拷贝文件和状态信息
import shutil`
`shutil.copy2('f1.log', 'f2.log')
shutil.ignore_patterns(*patterns)
shutil.copytree(src, dst, symlinks=False, ignore=None)
递归的去拷贝文件夹
import shutil`
`shutil.copytree('folder1', 'folder2', ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))
#``目标目录不能存在，注意对``folder2``目录父级目录要有可写权限，
ignore``的意思是排除 ==》``*.pyc', 'tmp*``：这个是排除易。pyc结尾，和以tmp开头的文件
拷贝软连接
import shutil
shutil.copytree('f1', 'f2', symlinks=True, ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))
'''`
`通常的拷贝都把软连接拷贝成硬链接，即对待软连接来说，创建新的文件`
`'''
shutil.rmtree(path[, ignore_errors[, onerror]])
递归的去删除文件
import shutil`
`shutil.rmtree('folder1')
shutil.move(src, dst)
递归的去移动文件，它类似``mv``命令，其实就是重命名。
import shutil`
`shutil.move('folder1', 'folder3')
shutil.make_archive(base_name, format,...)
创建压缩包并返回文件路径，例如：``zip``、``tar
创建压缩包并返回文件路径，例如：``zip``、``tar
- base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，
如 data_bak =>保存至当前路径
如：/tmp/data_bak =>保存至/tmp/ - format： 压缩包种类，“zip”, “tar”, “bztar”，“gztar”
- root_dir： 要压缩的文件夹路径（默认当前目录）
- owner： 用户，默认当前用户
- group： 组，默认当前组
- logger： 用于记录日志，通常是logging.Logger对象
#``将`` /data ``下的文件打包放置当前程序目录
import shutil`
`ret = shutil.make_archive("data_bak", 'gztar', root_dir='/data')`
`#``将`` /data``下的文件打包放置`` /tmp/``目录
import shutil`
`ret = shutil.make_archive("/tmp/data_bak", 'gztar', root_dir='/data')``
shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的，详细：
import zipfile
# ``压缩``z = zipfile.ZipFile('laxi.zip', 'w')`
`z.write('a.log')`
`z.write('data.data')`
`z.close()
# ``解压``z = zipfile.ZipFile('laxi.zip', 'r')`
`z.extractall(path='.')`
`z.close()
import tarfile
# ``压缩``>>> t=tarfile.open('/tmp/egon.tar','w')`
`>>> t.add('/test1/a.py',arcname='a.bak')`
`>>> t.add('/test1/b.py',arcname='b.bak')`
`>>> t.close()
# ``解压``>>> t=tarfile.open('/tmp/egon.tar','r')`
`>>> t.extractall('/egon')`
`>>> t.close()
Openpyxl模块
2022年6月7日
13:24
01 首先读取已存在的 Excel 表格
使用load_workbook（）函数；我们需要先导入load_workbook;工作表为活动工作表
from openpyxl import load_workbook
# Excel表格与脚本在同一个文件，否则需要把路径写全
wb = load_workbook(r'demo.xlsx')
sheet = wb.active
# 也可以按工作表名读取
# sheet = wb.get_sheet_by_name("sheet")
02 向单个单元格赋值
可以使用['A1']形式；也可以使用标明行列数值的形式.cell(row=2, column=2).value = 5
from openpyxl import load_workbook
wb = load_workbook(r'demo.xlsx')
sheet = wb.active
sheet['A1'] = 'Devansh Sharma'
sheet['A2'] = 'hello world'
sheet.cell(row=2, column=2).value = 5
wb.save(r'demo.xlsx')
print("运行结束！")
向工作表批量赋值
from openpyxl import load_workbook
wb = load_workbook(r'demo.xlsx')
sheet = wb.active
data = (
(11, 48, 50),
(81, 30, 82),
(20, 51, 72),
(21, 14, 60),
(28, 41, 49),
(74, 65, 53),
("Peter", 'Andrew',45.63)
)
for i in data:
sheet.append(i)
wb.save(r'demo.xlsx')
print("运行结束！")
jieba模块
2021年12月10日
21:19
安装
pip install jieba
二、算法介绍
结巴中文分词涉及到的算法包括：
(1) 基于Trie树结构实现高效的词图扫描，生成句子中汉字所有可能成词情况所构成的有向无环图（DAG)；
(2) 采用了动态规划查找最大概率路径, 找出基于词频的最大切分组合；
(3) 对于未登录词，采用了基于汉字成词能力的HMM模型，使用了Viterbi算法。
三、分词模式
结巴中文分词支持的三种分词模式包括：
(1) 精确模式：试图将句子最精确地切开，适合文本分析；
(2) 全模式：把句子中所有的可以成词的词语都扫描出来, 速度非常快，但是不能解决歧义问题；
(3) 搜索引擎模式：在精确模式的基础上，对长词再次切分，提高召回率，适合用于搜索引擎分词。
import jieba
# 全模式
text = "我来到北京清华大学"
seg_list = jieba.cut(text, cut_all=True)
print(u"[全模式]: ", "/ ".join(seg_list))
返回列表
# 精确模式
seg_list = jieba.cut(text, cut_all=False)
print(u"[精确模式]: ", "/ ".join(seg_list))
# 默认是精确模式
seg_list = jieba.cut(text)
print(u"[默认模式]: ", "/ ".join(seg_list))
# 搜索引擎模式
seg_list = jieba.cut_for_search(text)
print(u"[搜索引擎模式]: ", "/ ".join(seg_list))
结果：
[全模式]: 我/ 来到/ 北京/ 清华/ 清华大学/ 华大/ 大学
[精确模式]: 我/ 来到/ 北京/ 清华大学
[默认模式]: 我/ 来到/ 北京/ 清华大学
[搜索引擎模式]: 我/ 来到/ 北京/ 清华/ 华大/ 大学/ 清华大学
jieba库的三种模式：
-精确模式：把文本精确的切分开，不存在冗余单词
#jieba.lcut(s)
jieba.lcut("中国是一个伟大的国家"
#output:['中国', '是', '一个', '伟大', '的', '国家']
-全模式：把文本中所有的可能的词语都扫描出来，有冗余
#jieba.lcut(s,cut_all=True)
jieba.lcut("中国是一个伟大的国家",cut_all=True)
#output:['中国', '国是', '一个', '伟大', '的', '国家']
-全搜索引擎模式：在精确模式的基础上，对长词再次切分
#jieba.lcut_for_search(s)
jieba.lcut_for_search("中华人民共和国是伟大的")
#output:['中华', '华人', '人民', '共和', '共和国', '中华人民共和国', '是', '伟大', '的']
向分词词典中增加新词w：
#jieba.add_word(w)
jieba.add_word("蟒蛇语言")
四、新词识别
import jieba
#新词识别 “杭研”并没有在词典中,但是也被Viterbi算法识别出来了
seg_list = jieba.cut("他来到了网易杭研大厦")
print (u"[新词识别]: ", "/ ".join(seg_list))
[新词识别]: 他/ 来到/ 了/ 网易/ 杭研/ 大厦
五、自定义词典
import jieba
text = "故宫的著名景点包括乾清宫、太和殿和黄琉璃瓦等"
# 全模式
seg_list = jieba.cut(text, cut_all=True)
print(u"[全模式]: ", "/ ".join(seg_list))
# 精确模式
seg_list = jieba.cut(text, cut_all=False)
print(u"[精确模式]: ", "/ ".join(seg_list))
# 搜索引擎模式
seg_list = jieba.cut_for_search(text)
print(u"[搜索引擎模式]: ", "/ ".join(seg_list))
结果
[全模式]: 故宫/ 的/ 著名/ 著名景点/ 景点/ 包括/ 乾/ 清宫/ / / 太和/ 太和殿/ 和/ 黄/ 琉璃/ 琉璃瓦/ 等
[精确模式]: 故宫/ 的/ 著名景点/ 包括/ 乾/ 清宫/ 、/ 太和殿/ 和/ 黄/ 琉璃瓦/ 等
[搜索引擎模式]: 故宫/ 的/ 著名/ 景点/ 著名景点/ 包括/ 乾/ 清宫/ 、/ 太和/ 太和殿/ 和/ 黄/ 琉璃/ 琉璃瓦/ 等
可以看到，结巴分词工具认出了专有名词”太和殿”，但没有认出”乾清宫”和”黄琉璃瓦”。
也就是说，专有名词”乾清宫”和”黄琉璃瓦”可能因分词而分开，这也是很多分词工具的一个缺陷。
为此，Jieba分词支持开发者使用自定定义的词典，以便包含jieba词库里没有的词语。虽然结巴有新词识别能力，但自行添加新词可以保证更高的正确率，尤其是专有名词。
基本用法：
jieba.load_userdict(file_name) #file_name为自定义词典的路径
词典格式和dict.txt一样，一个词占一行；
每一行分三部分，第一部分为词语，中间部分为词频，最后部分为词性（可省略，ns为地点名词），用空格隔开。
咱们在jieba的安装目录下添加mydict.txt，内容为
乾清宫 1 n
黄琉璃瓦 1 n
添加自定义以后的代码；主要是添加加载mydict.txt的代码：
import jieba
jieba.load_userdict("D:\Program Files\Python36\Lib\site-packages\jieba\mydict.txt")
text = "故宫的著名景点包括乾清宫、太和殿和黄琉璃瓦等"
# 全模式
seg_list = jieba.cut(text, cut_all=True)
print(u"[全模式]: ", "/ ".join(seg_list))
# 精确模式
seg_list = jieba.cut(text, cut_all=False)
print(u"[精确模式]: ", "/ ".join(seg_list))
# 搜索引擎模式
seg_list = jieba.cut_for_search(text)
print(u"[搜索引擎模式]: ", "/ ".join(seg_list))
结果
[全模式]: 故宫/ 的/ 著名/ 著名景点/ 景点/ 包括/ 乾清宫/ 清宫/ / / 太和/ 太和殿/ 和/ 黄琉璃瓦/ 琉璃/ 琉璃瓦/ 等
[精确模式]: 故宫/ 的/ 著名景点/ 包括/ 乾清宫/ 、/ 太和殿/ 和/ 黄琉璃瓦/ 等
[搜索引擎模式]: 故宫/ 的/ 著名/ 景点/ 著名景点/ 包括/ 清宫/ 乾清宫/ 、/ 太和/ 太和殿/ 和/ 琉璃/ 琉璃瓦/ 黄琉璃瓦/ 等
关键词提取
在构建VSM向量空间模型过程或者把文本转换成数学形式计算中，你需要运用到关键词提取的技术。
jieba.analyse.extract_tags(sentence, topK)
其中sentence为待提取的文本，topK为返回几个TF/IDF权重最大的关键词，默认值为20。
代码；
import jieba
import jieba.analyse
#导入自定义词典
jieba.load_userdict("D:\Program Files\Python36\Lib\site-packages\jieba\mydict.txt")
#精确模式
text = "故宫的著名景点包括乾清宫、太和殿和午门等。其中乾清宫非常精美，午门是紫禁城的正门，午门居中向阳。"
seg_list = jieba.cut(text, cut_all=False)
print (u"分词结果:")
print ("/".join(seg_list))
#获取关键词
tags = jieba.analyse.extract_tags(text, topK=5)
print (u"关键词:")
print (" ".join(tags))
结果；
故宫/的/著名景点/包括/乾清宫/、/太和殿/和/午门/等/。/其中/乾清宫/非常/精美/，/午门/是/紫禁城/的/正门/，/午门/居中/向阳/。
关键词:
午门 乾清宫 著名景点 太和殿 向阳
这里“午门”出现了3次，所以先输出。“乾清宫”出现了2次，第二个输出。
其他词都出现1次，那么为什么接下来输出的是“著名景点”、“太和殿”和“向阳”呢？
这是因为，在词频一样的前题下，根据TF/IDF的顺序来输出，因为其他词的TF一样（都是1），所以IDF小的会先输出来。
不知道结巴分词是根据什么来判断IDF的，假如是根据dict.txt中的第二列词频来判断，那么确实是“著名景点” < “太阳殿” < “向阳” < 其他词语。这样第三个输出的就是“著名景点”，最后两个依次为“太阳殿”和“向阳”。
去除停用词
在信息检索中，为节省存储空间和提高搜索效率，在处理自然语言数据（或文本）之前或之后会自动过滤掉某些字或词，比如“的”、“是”、“而且”、“但是”、”非常“等。这些字或词即被称为Stop Words（停用词）。
代码：
import jieba
# 去除停用词
stopwords = {}.fromkeys(['的', '包括', '等', '是'])
text = "故宫的著名景点包括乾清宫、太和殿和午门等。其中乾清宫非常精美，午门是紫禁城的正门。"
# 精确模式
segs = jieba.cut(text, cut_all=False)
final = ''
for seg in segs:
if seg not in stopwords:
final += seg
print (final)
seg_list = jieba.cut(final, cut_all=False)
print ("/ ".join(seg_list))
结果：
故宫著名景点乾清宫、太和殿和午门。其中乾清宫非常精美，午门紫禁城正门。
故宫/ 著名景点/ 乾/ 清宫/ 、/ 太和殿/ 和/ 午门/ 。/ 其中/ 乾/ 清宫/ 非常/ 精美/ ，/ 午门/ 紫禁城/ 正门/ 。
WordCloud模块
2021年12月16日
20:00
效果是不是看起来还不错，下面介绍wordcloud.WordCloud()的参数
font_path : string //字体路径，需要展现什么字体就把该字体路径+后缀名写上，如：font_path = '黑体.ttf'
width : int (default=400) //输出的画布宽度，默认为400像素
height : int (default=200) //输出的画布高度，默认为200像素
prefer_horizontal : float (default=0.90) //词语水平方向排版出现的频率，默认 0.9 （所以词语垂直方向排版出现频率为 0.1 ）
mask : nd-array or None (default=None) //如果参数为空，则使用二维遮罩绘制词云。如果 mask 非空，设置的宽高值将被忽略，遮罩形状被 mask 取代。除全白（#FFFFFF）的部分将不会绘制，其余部分会用于绘制词云。如：bg_pic = imread('读取一张图片.png')，背景图片的画布一定要设置为白色（#FFFFFF），然后显示的形状为不是白色的其他颜色。可以用ps工具将自己要显示的形状复制到一个纯白色的画布上再保存，就ok了。
scale : float (default=1) //按照比例进行放大画布，如设置为1.5，则长和宽都是原来画布的1.5倍。
min_font_size : int (default=4) //显示的最小的字体大小
font_step : int (default=1) //字体步长，如果步长大于1，会加快运算但是可能导致结果出现较大的误差。
max_words : number (default=200) //要显示的词的最大个数
stopwords : set of strings or None //设置需要屏蔽的词，如果为空，则使用内置的STOPWORDS
background_color : color value (default=”black”) //背景颜色，如background_color='white',背景颜色为白色。
max_font_size : int or None (default=None) //显示的最大的字体大小
mode : string (default=”RGB”) //当参数为“RGBA”并且background_color不为空时，背景为透明。
relative_scaling : float (default=.5) //词频和字体大小的关联性
color_func : callable, default=None //生成新颜色的函数，如果为空，则使用 self.color_func
regexp : string or None (optional) //使用正则表达式分隔输入的文本
collocations : bool, default=True //是否包括两个词的搭配
colormap : string or matplotlib colormap, default=”viridis” //给每个单词随机分配颜色，若指定color_func，则忽略该方法。
fit_words(frequencies) //根据词频生成词云
generate(text) //根据文本生成词云
generate_from_frequencies(frequencies[, ...]) //根据词频生成词云
generate_from_text(text) //根据文本生成词云
process_text(text) //将长文本分词并去除屏蔽词（此处指英语，中文分词还是需要自己用别的库先行实现，使用上面的 fit_words(frequencies) ）
recolor([random_state, color_func, colormap]) //对现有输出重新着色。重新上色会比重新生成整个词云快很多。
to_array() //转化为 numpy array
to_file(filename) //输出到文件
打包py文件
2022年6月18日
17:19
第一步：安装打包所需要的包（pyinstaller）
在``cmd``窗口中输入
pip install pyinstaller
并从新创建一个环境
第二步修改路径
第三步：输入打包命令
pyinstaller -F -w (-i icofile) 文件名.py
解释一下该命令：
1、-w 表示在打包好程序后，双击.exe文件不会不会不会（重要的事情说三遍）出现黑色的命令窗口。（如果你的程序有print等输出命令，就不要加）
2、小括号中的内容是可以省略的，-i 表示给.exe文件一个图标，icofile表示图标的文件名，图标的图片格式为.ico格式的。不懂.ico图片的可以百度一下。打包时如果需要给.exe加入图标，将图标文件放到和.py文件同一目录下。
3、文件名.py 这里的文件名是你要打包的.py文件的名称。
| -h，--help | 查看该模块的帮助信息 |
|---|---|
| -F，-onefile | 产生单个的可执行文件 |
| -D，--onedir | 产生一个目录（包含多个文件）作为可执行程序 |
| -a，--ascii | 不包含 Unicode 字符集支持 |
| -d，--debug | 产生 debug 版本的可执行文件 |
| -w，--windowed，--noconsolc | 指定程序运行时不显示命令行窗口（仅对 Windows 有效） |
| -c，--nowindowed，--console | 指定使用命令行窗口运行程序（仅对 Windows 有效） |
| -o DIR，--out=DIR | 指定 spec 文件的生成目录。如果没有指定，则默认使用当前目录来生成 spec 文件 |
| -p DIR，--path=DIR | 设置 Python 导入模块的路径（和设置 PYTHONPATH 环境变量的作用相似）。也可使用路径分隔符（Windows 使用分号，Linux 使用冒号）来分隔多个路径 |
| -n NAME，--name=NAME | 指定项目（产生的 spec）名字。如果省略该选项，那么第一个脚本的主文件名将作为 spec 的名字 |
转换jpg为ioc文件
PythonMagick
PythonMagick库无法用pip或者easy_install来安装，因此，需要手动安装，地址如下： https://www.lfd.uci.edu/~gohlke/pythonlibs/#pythonmagick 选择合适版本下载后，进入文件所在位置，直接pip install + 文件名即可完成安装。
"""
Author``：``Robin·QI
Notes``：将图片转换为``ico``格式
"""
# PythonMargick``包可以到``Unofficial Windows Binaries for Python Extension Packages``下载
import PythonMagick
img = PythonMagick.Image('robin.jpg') ``# ``导入图片
# ``这里要设置一下尺寸，不然会报``ico``尺寸异常错误
img.sample('128x128') ``#``设置尺寸
img.write('robin.ico') ``保存图片
python音乐格式转换
2022年6月18日
22:37
01 安装pydub库
通过下面的命令安装``Python``库``-pydub
pip`` ``install`` ``pydub
#转化函数方法
from pydub import AudioSegment
#``转化函数方法
def trans_mp3_to_wav(filepath,hz):
song = AudioSegment.from_mp3(filepath)
song.export("Python``研究者``."+str(hz), format=str(hz))
### ``参数``1``：音频路径， 参数``2``：转换后的格式
trans_mp3_to_wav("``轻音乐``.mp3","wav")
trans_mp3_to_wav("``轻音乐``.mp3","ogg")
trans_mp3_to_wav("``轻音乐``.mp3","flac")
将轻音乐.mp3 转为wav、ogg、flac等格式，并命名为Python研究者。转化后均为无损高音质，没有任何的失真。
2.wav、ogg、flac->mp3
from pydub import AudioSegment
song = AudioSegment.from_wav("Python``研究者``.wav")
song.export("Python``研究者``_wav-mp3.mp3", format="mp3")
song = AudioSegment.from_ogg("Python``研究者``.ogg")
song.export("Python``研究者``_ogg-mp3.mp3", format="mp3")
AudioSegment.from_file("Python``研究者``.flac")
song.export("Python``研究者``_flac-mp3.mp3", format="mp3")
Python 使用 webbrowser 包播放 Mp3 文件
Import webbrowser`
`webbrowser.open("sample.mp3")
代码片段将在浏览器窗口中打开一个标签页并播放当前工作目录中的 sample.mp3 文件。
大部分的模块介绍
2022年5月10日
23:05
库名称简介
Chardet字符编码探测器，可以自动检测文本、网页、xml的编码。
colorama主要用来给文本添加各种颜色，并且非常简单易用。
Prettytable主要用于在终端或浏览器端构建格式化的输出。
difflib，[Python]标准库，计算文本差异
Levenshtein，快速计算字符串相似度。
fuzzywuzzy,字符串模糊匹配。
esmre,正则表达式的加速器。
shortuuid,一组简洁URL/UUID函数库。
ftfy，Unicode文本工具7
unidecode，ascii和Unicode文本转换函数。
xpinyin，将汉字转换为拼音的函数库
pangu.py，调整对中日韩文字当中的字母、数字间距。
pyfiglet，Python写的figlet程序，使用字符组成ASCII艺术图片
uniout，提取字符串中可读写的字符
awesome slugify，一个Python slugify库，用于处理Unicode。
python-slugify，转换Unicode为ASCII内码的slugify函数库。
unicode-slugify，生成unicode内码，Django的依赖包。
ply，Python版的lex和yacc的解析工具
phonenumbers，解析电话号码，格式，存储和验证的国际电话号码。
python-user-agents，浏览器的用户代理（user-agents）的解析器。
sqlparse，SQL解析器。
pygments，一个通用的语法高亮工具。
python-nameparser，解析人名，分解为单独的成分。
pyparsing，通用解析器生成框架。
tablib，表格数据格式，包括，XLS、CSV，JSON，YAML。
python-docx，docx文档读取，查询和修改，微软Word 2007 / 2008的docx文件。
xlwt/xlrd，读写Excel格式的数据文件。
xlsxwriter，创建Excel格式的xlsx文件。
xlwings，利用Python调用Excel
csvkit，CSV文件工具包。
marmir，把Python[数据结构]，转化为电子表格。
pdfminer，从PDF文件中提取信息。
pypdf2， 合并和转换PDF页面的函数库。
Python-Markdown，轻量级标记语言Markdown的Python实现。
Mistune，,快速、全功能的纯Python编写的Markdown解释器。
dateutil，标准的Python官方datetime模块的扩展包，字符串日期工具，其中parser是根据字符串解析成datetime，而rrule是则是根据定义的规则来生成datetime。
arrow,更好的日期和时间处理Python库
chronyk，一个Python 3版函数库，用于解析人写的时间和日期。
delorean，清理期时间的函数库。
when.py，为见的日期和时间，提供人性化的功能。
moment，类似Moment.js的日期/时间Python库
pytz，世界时区，使用tz database时区信息[数据库]
BeautifulSoup，基于Python的HTML/XML解析器，简单易用, 功能很强大,即使是有bug，有问题的html代码，也可以解析
lxml，快速，易用、灵活的HTML和XML处理库，功能超强，在遇到有缺陷、不规范的xml时，Python自带的xml处理器可能无法解析。报错时，程序会尝试再用lxml的修复模式解析。
htmlparser，官方版解析HTML DOM树，偶尔搞搞命令行自动表单提交用得上。
pyyaml，Python版本的YAML解释器。
html5lib，-标准库，解析和序列化HTML文档和片段。
pyquery，类似[jQuery]的的HTML解释器函数库。
cssutils，Python CSS库。
MarkupSafe，XML或HTML / XHTML安全字符串标记工具。
cssutils - ACSS library for Python., MarkupSafe - Implements a XML/HTML/XHTML
bleach，漂白，基于HTML的白名单函数库。
xmltodict，类似JSON的XML工具包。
xhtml2pdf，HTML / CSS格式转换器，看生成pdf文档。
untangle，把XML文档，转换为Python对象，方便访问。
文件处理
库名称简介Mimetypes，Python标准库，映射文件名到MIME类型。
imghdr，Python标准库，确定图像类型。python-magic，libmagic文件类型识别库，Python接口格式。path.py，os.path模块的二次封装。
watchdog，一组API和shell实用程序，用于监视文件系统事件。
Unipath，面向对象的文件/目录的操作工具包。pathlib，-（Python 3.4版已经作为Python标准库），一个跨平台，面向path的函数库。
pickle/cPickle,python的pickle模块实现了基本的数据序列和反序列化。通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储；通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象。
cPickle是[C语言]实现的版本，速度更快。
ConfigParser，Python标准库，INI文件解析器。
configobj，INI文件解析器。config，分层次配置，logging作者编写。
profig，多格式配置转换工具。
logging，Python标准库，日志文件生成管理函数库。
logbook，logging的替换品。
Sentry，实时log服务器。Raven，哨兵Sentry的Python客户端。
Sphinx，斯芬克斯（狮身人面像），Python文档生成器。
reStructuredText，标记语法和解析工具，Docutils组件。mkdocs，Markdown格式文档生成器。
pycco，简单快速、编程风格的文档生成器。
pdoc，自动生成的Python库API文档epydoc，从源码注释中生成各种格式文档的工具
图像处理
库名称简介PIL（Python Image Library），基于Python的图像处理库，功能强大，对图形文件的格式支持广泛，内置许多图像处理函数，如图像增强、滤波[算法]等Pillow，图像处理库，PIL图像库的分支和升级替代产品。Matplotlib，著名的绘图库，提供了整套和matlab相似的命令API，用以绘制一些高质量的数学二维图形，十分适合交互式地进行制图。brewer2mpl，有一个专业的python配色工具包，提供了从美术角度来讲的精美配色。
PyGame基于Python的多媒体开发和游戏软件开发模块，包含大量游戏和图像处理功能Box2d，开源的2d物理引擎，愤怒的小鸟就是使用了这款物理引擎进行开发的，Box2d物理引擎内部模拟了一个世界，你可以设置这个世界里的重力，然后往这个世界里添加各种物体，以及他们的一些物理特性，比如质量，摩擦，阻尼等等。
Pymunk，类似box2d的开源物理图形模拟库OpenCV, 目前最好的开源图像/视觉库，包括图像处理和计算机视觉方面、[机器学习]的很多通用算法。SimpleCV，计算机视觉开源框架，类似opencv。VTK，视觉化工具函式库（VTK， Visualization Toolkit）是一个开放源码，跨平台、支援平行处理（VTK曾用于处理大小近乎1个Petabyte的资料，其平台为美国Los Alamos国家实验室所有的具1024个处理器之大型系统）的图形应用函式库。
2005年时曾被美国陆军研究实验室用于即时模拟俄罗斯制反导弹战车ZSU23-4受到平面波攻击的情形，其计算节点高达2.5兆个之多。cgkit,Python Computer Graphics Kit,其module 主要分两个部分，
\1. 与3d相关的一些python module 例如the vector, matrix and quaternion types, the RenderMan bindings, noise functions 这些模块可以在maya houdini nuke blender 等有Python扩展的程序中直接用;
\2. 提供完整的场景操作的module， 他类似其他三维软件，在内存中保留完整的描述场景的信息。
不能直接用于maya 等CGAL，
Computational Geometry Algorithms Library，计算几何算法库，提供计算几何相关的数据结构和算法，诸如三角剖分（2D约束三角剖分及二维和三维Delaunay三角剖分），
Voronoi图（二维和三维的点，2D加权Voronoi图，分割Voronoi图等），
多边形（布尔操作，偏置），多面体（布尔运算），曲线整理及其应用，
网格生成（二维Delaunay网格生成和三维表面和体积网格生成等），几何处理（表面网格简化，细分和参数化等），
凸壳算法（2D，3D和dD），搜索结构（近邻搜索，kd树等），插值，形状分析，拟合，距离等。
Aggdraw，开源图像库，几乎涵盖了2d image操作的所有功能，使用起来非常灵活Pycairo,开源矢量绘图库Cairo开罗的python接口，
cairo提供在多个背景下做2-D的绘图，高级的更可以使用硬件加速功能。wand，Python绑定魔杖工具（MagickWand），C语言API接口。
thumbor， -智能成像工具，可调整大小和翻转图像。
imgSeek，查询相似的图像。
python-qrcode，纯Python的二维码（QR码）生成器。
pyBarcode，创建条码，无需PIL模块。
pygram，Instagram像图像过滤器。
Quads，基于四叉树的计算机艺术。
nude.py，裸体检测函数。
scikit-image，scikit工具箱的图像处理库。
hmap，图像直方图工具。
bokeh，交互的Web绘图。
plotly，Web协同的Python和Matplotlib绘制。
vincent，文森特，Python Vega的函数库。
d3py，Python绘图库，基于D3.JS, ggplot -API兼容R语言的ggplot2.Kartograph.py，在Python绘制漂亮的SVG地图。pygal， SVG图表的创造者。
pygraphviz，Graphviz的Python接口。
Fonttlools，ttf字体工具函数包，用于fontforge、ttx等字体软件。
游戏和多媒体
库名称简介audiolazy，数字信号处理（DSP）的Python工具包。
audioread，跨平台（GStreamer + Core Audio + MAD + FFmpeg）音频解码库。
beets，音乐库管理。
dejavu，音频指纹识别算法。
Dejavu 听一次音频后就会记录该音频的指纹信息，然后可通过麦克风对输入的音频进行识别是否同一首歌。django-elastic-transcoder,Django +亚马逊elastic转码。eyeD3,音频文件工具，特别是MP3文件包含的ID3元数据。
id3reader，用于读取MP3的元数据。
mutagen，处理音频元数据。
pydub，-操纵音频和简单的高层次的接口。
pyechonest，Echo Nest API客户端。talkbox，语音和信号处理的Python库。
TimeSide，开放的网络音频处理框架。
tinytag，读取音乐文件元数据，包括的MP3，OGG，FLAC和wave文件。
m3u8，用于解析m3u8文件。
moviepy，多格式视频编辑脚本模块，包括GIF动画。
shorten.tv，视频摘要。
scikit视频，SciPy视频处理例程。
GeoDjango,一个世界级的地理Web框架。
geopy,Geo地理编码的工具箱。
pygeoip，纯Python写的GeoIP API。
GeoIP，Python API接口，使用高精度GeoIP Legacy Database数据库。
geojson，GeoJSON函数库django-countries，一个Django程序，提供国家选择，国旗图标的静态文件，和一个国家的地域模型。
Pygame，Python游戏设计模块。
Cocos2d，2D游戏框架，演示，和其他的图形/交互应用，基于pyglet。Cocos2d- cocos2d is a framework for building 2D games, demos, and other graphical/interactive applications. It is based on pyglet.,PySDL2，SDL2的封装库。
Panda3D- 3D游戏引擎，迪士尼开发。
用C++写的，完全兼容Python。PyOgre，OGRE 3D渲染引擎，可用于游戏，模拟，任何3D。
PyOpenGL，绑定OpenGL和它相关的API。
PySFML，Python绑定SFMLRenPy，视觉小说引擎。
大数据与科学计算
库名称简介pycuda/opencl，GPU高性能并发计算Pandas，python实现的类似R语言的数据统计、分析平台。基于NumPy和Matplotlib开发的，主要用于数据分析和数据可视化，它的数据结构DataFrame和R语言里的data.frame很像，特别是对于时间序列数据有自己的一套分析机制，非常不错。
Open Mining，商业智能（BI），Pandas的Web界面。blaze，NumPy和Pandas大数据界面。
SciPy，开源的Python算法库和数学工具包，SciPy包含的模块有最优化、线性代数、积分、插值、特殊函数、快速傅里叶变换、信号处理和图像处理、常微分方程求解和其他科学与工程中常用的计算。
其功能与软件MATLAB、Scilab和GNU Octave类似。
Numpy和Scipy常常结合着使用，Python大多数机器学习库都依赖于这两个模块。
ScientificPython，一组经过挑选的Python程序模块，用于科学计算，包括几何学（矢量、张量、变换、矢量和张量场），四元数，自动求导数，（线性）插值，多项式，基础统计学，非线性最小二乘拟合，单位计算，Fortran兼容的文本格式，通过VRML的3D显示，以及两个Tk小工具，分别用于绘制线图和3D网格模型。
此外还具有到netCDF，MPI和BSPlib库的接口。
NumPy科学计算库，提供了矩阵，线性代数，傅立叶变换等等的解决方案, 最常用的是它的N维数组对象. NumPy提供了两种基本的对象：
ndarray（N-dimensional array object）和 ufunc（universal function object）。
ndarray是存储单一数据类型的多维数组，而ufunc则是能够对数组进行处理的函数。
Cvxopt，最优化计算包，可进行线性规划、二次规划、半正定规划等的计算。
Numba，科学计算速度优化编译器。pymvpa2，是为大数据集提供统计学习分析的Python工具包，它提供了一个灵活可扩展的框架。
它提供的功能有分类、回归、特征选择、数据导入导出、可视化等NetworkX，复杂网络的优化软件包。zipline，交易算法的函数库。
PyDy， Python动态建模函数库。
SymPy,符号数学的Python库。statsmodels,Python的统计建模和计量经济学。
astropy,天文学界的Python库。
orange，橙色，数据挖掘，数据可视化，通过可视化编程或Python脚本学习机分析。
RDKit,化学信息学和机器学习的软件。
Open Babel，巴贝尔，开放的化学工具箱。
cclib，化学软件包的计算函数库。
Biopython，免费的生物计算工具包。
bccb，生物分析相关的代码集。bcbio-nextgen，提供完全自动化、高通量、测序分析的工具包。
visvis, 可视化计算模块库，可进行一维到四维数据的可视化。
MapReduce是Google提出的一个软件[架构]，用于大规模数据集（大于1TB）的并行运算。
概念“Map（映射）”和“Reduce（归纳）”，及他们的主要思想，都是从函数式编程语言借来的MapReduce函数库。Framworks and libraries for MapReduce.,PySpark，[Spark]的Python API。dpark，Spark的Python克隆，Python中的MapReduce框架。luigi，为批量工作，建立复杂的管道。mrjob，运行在[Hadoop]，或亚马逊网络服务的，MapReduce工作。
人工智能与机器学习
库名称简介NLTK（natural language toolkit)，是python的自然语言处理工具包。2001年推出，包括了大量的词料库，以及自然语言处理方面的算法实现：
分词， 词根计算， 分类， 语义分析等。
Pattern，数据挖掘模块，包括自然语言处理，机器学习工具，等等。
textblob，提供API为自然语言处理、分解NLP任务。基于NLTK和Pattern模块。
jieba，结巴，中文分词工具。snownlp，用于处理中文文本库。
loso，中文分词函数库。
genius，中文CRF基础库，条件随机场(conditional random field,简称 CRF),是一种鉴别式机率模型,是随机场的一种,常用于标注或分析序列资料,如自然语言文字或是生物序列Gensim，一个相当专业的主题模型Python工具包，无论是代码还是文档，可用于如何计算两个文档的相似度LIBSVM,是台湾大学林智仁(Lin Chih-Jen)教授等开发设计的一个简单、易于使用和快速有效的SVM模式识别与回归的软件包，他不但提供了编译好的可在Windows系列系统的执行文件，还提供了源代码，方便改进、修改以及在其它[操作系统]上应用；
该软件对SVM所涉及的参数调节相对比较少，提供了很多的默认参数，利用这些默认参数可以解决很多问题；
并提供了交互检验(Cross Validation)的功能。
该软件可以解决C-SVM、ν-SVM、ε-SVR和ν-SVR等问题，包括基于一对一算法的多类模式识别问题。
scikits.learn，构建在SciPy之上用于机器学习的 Python 模块。它包括简单而高效的工具，可用于数据挖掘和数据分析。
涵盖分类，回归和聚类算法，例如SVM， 逻辑回归，朴素贝叶斯，随机森林，k-means等算法，代码和文档都非常不错，在许多Python项目中都有应用。
例如在我们熟悉的NLTK中，分类器方面就有专门针对scikit-learn的接口，可以调用scikit-learn的分类算法以及训练数据来训练分类器模型。PyMC，机器学习采样工具包，scikit-learn似乎是所有人的宠儿，有人认为，PyMC更有魅力。
PyMC主要用来做Bayesian分析。Orange，基于组件的数据挖掘和机器学习软件套装，它的功能即友好，又很强大，快速而又多功能的可视化编程前端，以便浏览数据分析和可视化，包含了完整的一系列的组件以进行数据预处理，并提供了数据帐目，过渡，建模，模式评估和勘探的功能。
侧重数据挖掘，可以用可视化语言或Python进行操作，拥有机器学习组件，还具有生物信息学以及文本挖掘的插件。
Milk，机器学习工具箱，其重点是提供监督分类法与几种有效的分类分析：SVMs(基于libsvm)，K-NN，随机森林经济和决策树。
它还可以进行特征选择。这些分类可以在许多方面相结合，形成不同的分类系统。对于无监督学习，它提供K-means和affinity propagation聚类算法。
PyMVPA(Multivariate Pattern Analysis in Python),是为大数据集提供统计学习分析的Python工具包，它提供了一个灵活可扩展的框架。它提供的功能有分类、回归、特征选择、数据导入导出、可视化等NuPIC，开源人工智能平台。
该项目由Grok（原名 Numenta）公司开发，其中包括了公司的算法和软件架构。
NuPIC 的运作接近于人脑，“当模式变化的时候，它会忘掉旧模式，记忆新模式”。如人脑一样，CLA 算法能够适应新的变化。Pylearn2，-基于Theano的机器学习库。
hebel，GPU加速，[深度学习]Python库。
gensim，机器学习库。pybrain，机器学习模块，它的目标是为机器学习任务提供灵活、易应、强大的机器学习算法。
pybrain包括神经网络、强化学习(及二者结合)、无监督学习、进化算法。以神经网络为核心，所有的训练方法都以神经网络为一个实例Mahout,是 Apache Software Foundation（ASF） 旗下的一个开源项目，提供一些可扩展的机器学习领域经典算法的实现，旨在帮助开发人员更加方便快捷地创建智能应用程序。
Mahout包含许多实现，包括聚类、分类、推荐过滤、频繁子项挖掘。此外，通过使用 Apache Hadoop 库，Mahout 可以有效地扩展到云中。
Crab，灵活的，快速的推荐引擎。python-recsys，娱乐系统分析，推荐系统。vowpal_porpoise，Vowpal Wabbit轻量级Python封装。
Theano,用来定义、优化和模拟数学表达式计算，用于高效的解决多维数组的计算问题的python软件包。它使得写深度学习模型更加容易，同时也给出了一些关于在GPU上训练它们的选项。
系统与命令行
库名称简介threading，Python标准线程库，更高级别的线程接口。
envoy，特使，Python子线程的函数库。
sh，成熟的子线程替换函数库。sarge，封装线程。subprocess,调用shell命令的神器argparse，写命令行脚本必备，强大的命令行差数解析工具timeit，计算代码运行的时间等等unp，命令行工具，解压文件。
eventlet开销很少的多线程模块，使用的是 green threads 概念，例如，pool = eventlet.GreenPool(10000) 这样一条语句便创建了一个可以处理 10000 个客户端连接的线程池。
类似Gevent线程库Gevent，多线程模块pytools,著名的python通用函数、工具包SendKeys, 键盘鼠标操作模块, 模拟键盘鼠标模拟操作。
pyHook,基于Python的“钩子”库，主要用于监听当前电脑上鼠标和键盘的事件。
这个库依赖于另一个Python库PyWin32，如同名字所显示的，PyWin32只能运行在Windows平台，所以PyHook也只能运行在Windows平台。
pstuil,跨平台地很方便获取和控制系统的进程，以及读取系统的CPU占用内存占用等信息.cement，一个轻量级的、功能齐全的命令行工具click，简单优雅的的命令行接口。
clint，Python命令行工具。cliff，创造多层次指令的命令行程序框架。
Clime， 可以转换任何模块为多的CLI命令程序，无任何配置。
docopt，Python命令行参数分析器。
pycli，命令行应用程序，支持的标准命令行解析，测井，单元[测试]和功能测试。
Gooey，打开命令行程序，作为为一个完整的GUI应用程序,cookiecutter，命令行工具，从cookiecutters（项目模板）创建项目。
例如，Python包项目，jQuery插件项目。
percol，为UNIX传统管道pipe命令，添加交互式选择风格。
rainbowstream，聪明和漂亮的推特客户终端。Django Models，Django的一部分SQLAlchemy，Python SQL工具包和对象关系映射。
peewee，小型的ORM解析器。
PonyORM，为ORM提供了一种面向SQL的接口。MongoEngine，Python对象文件映射，使用[MongoDB]。
, Django MongoDB引擎MongoDB , Django后台。
django-mongodb-engine，Django后台.redisco,一个简单的模型和容器库，使用[Redis]flywheel，Amazon DynamoDB对象映射。
butterdb，谷歌电子表格的ORM，Python版。celery，芹菜，异步任务队列/工作，基于分布式消息队列。
huey，休伊，轻量级，多线程任务队列。
mrq，队列先生，分布式任务队列，使用redis & Gevent。rq，简单的工作队列。
Queue,Queue模块可以用来实现多线程间通讯，让各个线程共享数据，生产者把货物放到Queue中，供消费者（线程）去使用。
simpleq，简单的，可扩展的队列，Amazon SQS基础队列。
Psyco，超强的python性能优化工具，psyco 的神奇在于它只需要在代码的入口处调用短短两行代码，性能就能提升 40% 或更多，真可谓是立竿见影！如果你的客户觉得你的程序有点慢，敬请不要急着去优化代码，psyco 或许能让他立即改变看法。
psyco 堪称 Python 的 jit。fn.py，Python函数编程：缺失的功能享受FP的实现。funcy，函数编程工具。
Toolz，函数编程工具：迭代器、函数，字典。CyToolz，Toolz的Cython实现，高性能的函数编程工具。Ansible，安塞波，极为简单的自动化平台。
SaltStack，基础设施的自动化管理系统。
Fabric，织物，一个简单，远程执行和部署的语言工具。
Fabtools，Fabric的工具函数。
cuisine，热门的Fabric的工具函数。
psutil，跨平台的过程和系统工具模块。
pexpect，控制互动节目。
provy，易于使用的配置系统的Python。honcho，Foreman的Python接口，用于管理procfile应用工具。
gunnery，多任务执行工具，与网络接口的分布式系统。
fig，快速。独立的开发环境中使用泊坞窗。
APScheduler，轻量级、但功能强大的在线任务调度程序。
django-schedule,Django日程应用程序。doit,任务流道/生成工具。
Joblib,Python提供的轻量级的流水线工具函数。
Plan，简易生成crontab文件。
Spiff，纯Python实现的，功能强大的工作流引擎。
schedule，Python作业调度。TaskFlow，有助于使任务执行简单。
ctypes，Python标准库，速度更快，Python调用C代码的外部函数接口。cffi，Python调用C代码外部函数接口，类似于ctypes直接在python程序中调用c程序,但是比ctypes更方便不要求编译成so再调用。
Cytoolz，python 加速库SWIG，简化封装和接口生成器。
,Cython，Python优化静态编译器。
PyPy，Python解释器的 Python实现。
Stackless Python，一个增强版本的Python。它使程序员从基于线程的编程方式中获得好处，并避免传统线程所带来的性能与复杂度问题。
Stackless为 Python带来的微线程扩展，是一种低开销、轻量级的便利工具Pyston,使用LLVM和现代JIT技术,对python进行性能优化。
pythonlibs，非官方的Windows（32 / 64位）的Python扩展包scapy，优秀的数据包处理库。
ino，Arduino命令行工具。Pyro，Python的机器人工具包。
pluginbase，一个简单而灵活的Python的插件系统。
itsdangerous，数据安全传输工具。blinker，快速Python中的信号/事件调度系统。
pychievements，用于创建和跟踪成果框架。
python-patterns，Python中的设计模式。
pefileWindows PE文件解析器SIP，自动为C和C++库生成Python扩展模块的工具
数据库
库名称简介MySQLdb，成熟的[MySQL]数据库模块,Baresql,SQL数据库包ZODB，Python本地对象数据库。一个K-V对象图数据库。
pickledb,简单和轻量级的K-V键值存储。
TinyDB, 轻量级，面向文档的数据库。
mysql-python，MySQL的Python工具库。
mysqlclient，mysql-python分支，支持Python 3.,PyMySQL,纯Python写的 MySQL驱动程序，兼容mysql-python。mysql-connector-python,MySQL连接器,来自[Oracle]，纯Python编写。
oursql，MySQL连接器，提供本地话指令语句和BLOBs支持。
psycopg2，最流行的Python PostgreSQL适配器。txpostgres，于Twisted的异步驱动，用于PostgreSQL。
queries,psycopg2函数库，用于PostgreSQL。
dataset,存储Python字典数据,用于SQLite，MySQL和PostgreSQL。
cassandra-python-driver，开源分布式NoSQL数据库系统Apache Cassandra系统的Python驱动.pycassa,简化的cassandra数据库Python驱动。
HappyBase，友好的Apache [Hbase]的函数库。
PyMongo，MongoDB官方客户端。
Plyvel，LevelDB快速和功能丰富的Python接口。redis-py,redis客户端。
py2neo,Python客户端(基于Neo4j的RESTful接口).telephus,基于Twisted的cassandra客户端。
txRedis，基于Twisted的Redis客户端。
【网络】Curl，Pycurl包是一个libcurl的Python接口，它是由C语言编写的。
与urllib相比，它的速度要快很多。
Libcurl是一个支持FTP, FTPS, HTTP, HTTPS, GOPHER, TELNET, DICT, FILE 和 LDAP的客户端URL传输库.libcurl也支持HTTPS认证,HTTP POST,HTTP PUT,FTP上传,代理,Cookies,基本身份验证,FTP文件断点继传,HTTP代理通道等等。
Requests，用Python语言编写，基于 urllib的开源 HTTP 库。
它比 urllib 更加方便，更加 Pythoner。
支持 Python3。httpie，命令行HTTP客户端，用户友好的cURL的替换工具。
s3cmd，命令行工具，用于管理Amazon S3和CloudFront。
youtube-dl，命令行程序，从YouTube下载视频。
you-get，Python3写的视频下载工具，可用于YouTube/Youku优酷/Niconico视频下载Coursera，从coursera.org下载视频，可重新命名文件wikiteam，wiki下载工具。
subliminal，命令行工具，搜索和下载字幕的函数库requests，HTTP函数库，更加人性化。grequests，异步HTTP请求+ Gevent（高性能高并发函数库）。
urllib3，一个线程安全的HTTP连接池，支持文件post。
httplib2，综合HTTP的客户端函数库。treq， Python API接口，Twisted的HTTP客户。
Mininet，流行的网络仿真器,API采用python编写。
POX，基于Python的开源软件定义网络（SDN）控制开发平台的应用，如OpenFlow的SDN控制器。
Pyretic，SDN的编程语言，提供了强大的抽象在网络交换机或仿真器。SDX Platform，基于SDN的IXP实现，利用最小网络，痘和热。inbox.py，Python的SMTP服务器。imbox， Python版本IMAP库。inbox，收件箱，开源邮件工具包。
lamson,SMTP服务器。flanker,侧卫,电子邮件地址和MIME解析库。
marrow.mailer,高性能可扩展邮件交付框架。
django-celery-ses， Django电子邮件后台，使用AWS SES和Celery。
modoboa，邮件托管和管理平台，包括现代和简化Web UI。
envelopes，邮件工具。
mailjet，批量邮寄mailjet API接口，带统计。Talon，利爪，Mailgun库，提取消息和签名。
mailjet- Mailjet API implementation for batch mailing, statistics and more., Talon - Mailgun library to extract message quotations and signatures.,pyzmail，编写，发送和解析电子邮件。
furl，燃料，小型的的URL解析库库。purl，简单的，干净的API，操纵URL。
pyshorteners，纯Python库，URL短网址编辑。
short_url，短网址生成。
Scrapy，快速屏幕截取和网页抓取的框架。
portia，波西亚，Scrapy的可视化扩展。
feedparser，信息源解释器RoboBrowser，简单的网页浏览Python函数库，没有使用Web浏览器。
MechanicalSoup，网站自动化互动测试工具包。
mechanize，网页浏览编程工具。
Demiurge，造物主，-PyQuery的轻量级工具。
newspaper,提取报纸新闻。html2text,转换HTML为 Markdown格式的文本。
python-goose,HTML内容提取器。
lassie,莱西,人性化的网站内容检索。
micawber,通过UR抓提网页的函数库。
sumy，概要，文本和HTML网页的自动文摘模块。
Haul，距离，可扩展的图像爬虫。
python-readability,可读性工具Arc90,快速的Python接口。
opengraph,OpenGraphProtocol协议解析模块,textract，从任何文件，Word，PowerPoint，PDF文件中提取文本，等。
sanitize，消毒，使混乱的数据变的理智。
AutobahnPython， WebSocket和WAMP的函数库，使用 Twisted和PythonWebSocket-for-Python，websocket客户端和服务器端函数库。SimpleXMLRPCServer，python标准库，简单的XML-RPC服务器，单线程。
SimpleJSONRPCServer，JSON-RPC规范实施函数库。
zeroRPC，基于ZeroMQ和MessagePack的RPC实现。
apache-libcloud，所有云服务的Python接口库。
wifi，WiFi -一套个Python库和命令行工具与WiFi，用于[Linux]。
streamparse，运行Python代码和数据的实时流。
集成了Apache Storm。
boto，亚马逊网络服务接口。
twython，Twitter推特API。google-api-python-client，谷歌客户端API。
gspread，谷歌电子表格的Python API。
facebook-sdk，facebook平台Python SDK。
facepy，简易的facebook图形APIgmail，Gmail的Python接口。
django-wordpress，Django的WordPress的模型和视图。
【Web框架】Django，最流行的Python-Web框架，鼓励快速开发,并遵循MVC设计，开发周期短ActiveGrid企业级的Web2.0解决方案Karrigell简单的Web框架，自身包含了Web服务，py脚本引擎和纯python的数据库PyDBLitewebpy一个小巧灵活的Web框架，虽然简单但是功能强大CherryPy基于Python的Web应用程序开发框架Pylons基于Python的一个极其高效和可靠的Web开发框架Zope开源的Web应用服务器TurboGears基于Python的MVC风格的Web应用程序框架Twisted流行的网络编程库，大型Web框架QuixoteWeb开发框架Flask,轻量级web框架Bottle，快速，简单和轻量级的WSGI模式Web框架。
Pyramid，轻量级，快速，稳定的开源Web框架。
web2py，简单易用的全堆栈Web框架和平台。
web.py，强大、简单的Web框架。TurboGears，便于扩展的Web框架。
CherryPy，极简Python Web框架，支持，HTTP 1.1和WSGI线程池。
Grok，基于Zope3的Web框架。
Bluebream，开源的Web应用服务器，原名Zope 3。
guava，轻量级，高性能的Python-Web框架，采用c语言编写。
django-cms，基于Django企业级开源CMS。
djedi-cms轻量级但功能强大的Django CMS的插件，内联编辑和性能优化。
FeinCMS，基于Django的先进内容管理系统。
Kotte，高层次的Python的Web应用框架，基于Pyramid。Mezzanine，强大，一致，灵活的内容管理平台。
Opps，基于Django的CMS，用于高流量的报纸、杂志和门户网站。
Plone，基于Zope的开源应用服务器Zope。
Quokka，灵活，可扩展的，轻量级的CMS系统，使用Flask和MongoDB。
Wagtail，Django内容管理系统。
Widgy，CMS框架，基于Django。
django-oscar，Django奥斯卡，开源的电子商务框架。
django-shop，基于Django的网店系统。
merchant，支持多种付款处理工具。
money，可扩展的货币兑换解决方案。
python-currencies，货币显示格式。
cornice，Pyramid的REST框架。
django-rest-framework，Django框架，强大灵活的工具，可以很容易地构建Web API。
django-tastypie，创造精美的Django应用程序API接口。
django-formapi，创建JSON API、HMAC认证和Django表单验证。flask-api，提供统一的浏览器体验，基于Django框架。
flask-restful，快速构建REST API支持扩展。
flask-api-utils，flask的扩展。falcon，猎鹰，高性能的Python框架，构建云API和Web应用程序后端。
eve，夏娃，REST API框架，使用Flask，MongoDB和良好意愿。
sandman，睡魔，为现有的数据库驱动的系统，自动生成REST API。restless，类似TastyPie的框架。
savory-pie，REST API构建函数库（Django，及其他）Jinja2，现代设计师友好的语言模板。
Genshi，网络感知输出模板工具包。
Mako，马可，Python平台的超高速、轻型模板。
Chameleon，变色龙，一个HTML / XML模板引擎。
仿照ZPT，优化速度。
Spitfire，快速的Python编译模板。
django-haystack,大海捞针,Django模块搜索。
elasticsearch-py,Elasticsearch官方低级的Python客户端。
solrpy,solr客户端。
Whoosh,呼,快速，纯Python搜索引擎库。
Feedly，建立新闻和通知系统的函数库，使用Cassandra和Redis。
django-activity-stream,Django活动流,从你网站上的行动,产生通用的活动流。
Beaker，烧杯，一个缓存和会话使用的Web应用程序，独立的Python脚本和应用程序库。
dogpile.cache，是Beaker作者的下一代替代作品。HermesCache，Python的缓存库，基于标签的失效及预防Dogpile效果。
django-cache-machine，Django缓存机，自动缓存失效，使用ORM。django-cacheops，自动颗粒事件驱动，ORM缓存失效。johnny-cache,约翰尼高速缓存框架,Django应用程序。
django-viewlet,渲染模板部件扩展缓存控制。pylibmc,在libmemcached接口。
WTForms-JSON,JSON表单数据处理扩展。Deform， HTML表单生成的函数库。
django-bootstrap3，bootstrap3，集成了Django。django-crispy-forms，Django程序，可以创建优雅的表单。django-remote-forms，Django的远程表单，Django表格的序列化程序。
django-simple-spam-blocker，Django简单的垃圾邮件拦截器。
django-simple-captcha，Django简单验证码，简单的和高度可定制的Django应用程序，用于添加验证码图像Ajenti，服务器管理面板。
Grappelli，界面花哨的django皮肤。django-suit，Django替代o界面（仅用于非商业用途）。
django-xadmin，Django管理面板替代工具。
flask-admin，简单的flask管理界面框架flower，实时监控和Web管理面板。
Pelican，鹈鹕，Markdown或ReST，字王内容主题。支持 DVCS, Disqus. AGPL。
Cactus,仙人掌,设计师的网站静态生成器。
Hyde，海德， 基于Jinja2的静态网站生成器。
Nikola，尼古拉-一个静态网站和博客生成器。
Tags，标签，最简单的静态网站生成器。
Tinkerer，工匠，基于Sphinx的静态网站生成器。
asyncio，（在Python 3.4 +是Python标准库），异步I/O，事件循环，协同任务。
gevent，基于Python的网络库。
Twisted，扭曲，事件驱动的网络引擎。
Tornado，龙卷风，Web框架和异步网络的函数库。
pulsar，脉冲星，事件驱动的并行框架的Python。
diesel，柴油，绿色的，基于事件的I/O框架。
eventlet，WSGI支持异步框架。
pyzmq， 0MQ消息库的Python封装。
txZMQ,基于Twisted的0MQ消息库封Crossbar,开源统一应用路由器（WebSocket和WAMP）。
wsgiref，Python标准库，WSGI封装实现，单线程。
Werkzeug，机床，WSGI工具函数库，很容易地嵌入到你自己的项目框架。
paste，粘贴，多线程，稳定的，久经考验的WSGI工具。
rocket，火箭，多线程服务，基于Pyramid。
netius，快速的、异步WSGI服务器，gunicorn，forked前身，部分用C写的。
fapws3，异步网络，用C写的。meinheld，异步WSGI服务器，是用C写的。
bjoern，-快速的、异步WSGI服务器，用C写的。
【安全】Permissions函数库，允许或拒绝用户访问数据或函数。
django-guardian,Django守护者，管理每个对象的权限，用于Django 1.2 +Carteblanche，管理导航和权限。
Authomatic，简单强大的认证/授权客户端。
OAuthLib， 通用，规范，OAuth请求签约工具。
rauth，用于OAuth 1.0，2.0，的Python库。
python-oauth2，利用全面测试，抽象接口来创建OAuth的客户端和服务器。
python-social-auth，易于安装的社会认证机制。
,django-oauth-toolkit,Django OAuth工具包django-oauth2-provider,Django OAuth2工具包。
django-allauth，Django认证的应用程序。
Flask-OAuthlib，Flask的OAuth工具包sanction，制裁，简单的oauth2客户端。
jose，[JavaScript]对象签名和加密(JOSE)草案实施，标记状态。
python-jwt，JSON的Web令牌生成和验证模块。
pyjwt，JSON的Web令牌草案01。
python-jws，JSON的Web令牌草案02。
PyCrypto，Python的加密工具包。
Paramiko，sshv2协议的实现，提供了客户端和服务器端的功能。
cryptography，密码开发工具包。
PyNac，网络和密码（NaCl）函数库。hashids，hashids的 Python函数库。
Passlib，安全的密码存储/哈希库，非常高的水平。
hashlib,md5, sha等hash算法，用来替换md5和sha模块，并使他们的API一致。
它由OpenSSL支持，支持如下算法：md5,sha1, sha224, sha256, sha384, sha512.
GUI
PyGtk，基于Python的GUI程序开发GTK+库
PyQt用于Python的QT开发库
WxPythonPython下的GUI编程框架，其消息机制与MFC的架构相似,入门非常简单，需要快速开发相关的应用可以使用这个
TkinterPython下标准的界面编程包，因此不算是第三方库了
PySide，跨平台Qt的应用程序和用户界面框架，支撑Qt v4框架。
wxPython，混合wxWidgets的C++类库。
kivy，创建应用程序GUI函数库，看运行于Windows，Linux，MAC OS X，[Android]和[iOS]。
curse，用于创建终端GUI应用程序。
urwid，创建终端GUI应用程序窗体的函数库，支持事件，色彩丰富。
pyglet，跨平台的窗口和多媒体库的Python。
Tkinter，是Python事实上的标准GUI软件包。
enaml，创建漂亮的用户界面，语法类似QML。
Toga，托加，OS原生GUI工具包。【构建封装】
pyenv,简单的Python版本管理。
virtualenv,创建独立的Python环境，用于同时安装不同版本的python环境。
virtualenvwrapper，是virtualenv的一组扩展。
pew,一套管理多个虚拟环境的工具。
vex，使运行指定的virtualenv命令。
PyRun，一个单文件，无需安装的Python版本管理工具。
PIP，Python包和依赖的管理工具。
easy_install，软件包管理系统,提供一个标准的分配Python软件和 函式库的格式。是一个附带设置工具的模块，和一个第三方函式库。旨在加快Python函式库的分配程式的速度。类似Ruby语言的RubyGems 。
conda，跨平台，二进制软件包管理器。,
Curdling，一个管理Python包的命令行工具。
wheel，Python发行的新标准，旨在替代eggs.
cx-Freeze，跨平台的，用于打包成可执行文件的库
py2exe, Windows平台的Freeze脚本工具，Py2exe ，将python脚本转换为windows上可以独立运行的可执行程序
py2app，MAC OS X平台的Freeze脚本工具
pyinstaller，-转换成独立的可执行文件的Python程序（跨平台）。
pynsist,构建Windows安装程序的工具，用Python编写。
dh-virtualenv,建立和分发virtualenv(Debian软件包格式)
PyPI，新一代的Python包库管理工具。
warehouse,新一代的Python包库（PyPI）管理工具。
devpi，PyPI服务器和包装/测试/发布工具。
localshop，PyPI官方包镜像服务器，支持本地（私人）包上传。
buildout，创建，组装和部署应用程序的多个部分，其中一些可能是非基于Python的。
SCons，软件构造工具。
platformio，一个控制台的工具，构建的代码可用于不同的开发平台。
bitbake，特殊设计的工具，用于创建和部署[嵌入式]Linux软件包
fabricate，自动为任何编程语言，生成依赖包。
django-compressor，Django压缩机，压缩和内联JavaScript或CSS，链接到一个单一的缓存文件。
jinja-assets-compressor，金贾压缩机，一个Jinja扩展，通过编译，压缩你的资源。
webassets，优化管理，静态资源，独特的缓存清除。
fanstatic，球迷，包优化，提供静态文件。
fileconveyor，监控资源变化，，可保存到CDN（内容分发网络）和文件系统。
django-storages，一组自定义存储Django后台。
glue，胶胶，一个简单的命令行工具，生成CSS Sprites。
libsass-python，Sass (层叠样式表)的Python接口。
Flask-Assets，整合应用程序资源。【代码调试】
unittest，Python标准库，单元测试框架。
nose，鼻子，unittest延伸产品。
pytest，成熟的全功能的Python测试工具。
mamba，曼巴，Python的权威测试工具。出自BDD的旗下。
contexts，背景，BDD测试框架，基于C#。
pyshould，should风格的测试框架，基于PyHamcrest.
pyvows，BDD风格测试框架
Selenium，web测试框架，Python绑定Selenium。
splinter，分裂，测试Web应用程序的开源工具。
locust，刺槐，可扩展的用户负载测试工具，用Python写的。
sixpack，语言无关的A/B测试框架。
mock，模拟对象（英语：mock object，也译作模仿对象），模拟测试库。
responses，工具函数，用于mock模拟测试。
doublex-强大的测试框架。
freezegun，通过时间调整，测试模块。
httpretty， HTTP请求的模拟工具。
httmock，mock模拟测试。
coverage，代码覆盖度量测试。
faker，生成模拟测试数据的Python包。
mixer，混频器，产生模拟数据，用于Django ORM，SQLAlchemy，
Peewee, MongoEngine, Pony ORM等
model_mommy，在Django创建测试随机工具。
ForgeryPy，易用的模拟数据发生器。
radar，雷达，生成随机日期/时间。
FuckIt.py，测试Python代码运行。
Code Analysispysonar2，Python类型索引。
pycallgraph,可视化的流量（调用图）应用程序。
code2flow,转换Python和JavaScript代码到流程图。
LinterFlake8，源代码模块检查器
pylama，Python和JavaScript代码审计工具。
Pylint，源代码分析器，它查找编程错误，帮助执行一个代码标准和嗅探一些代码味道。注意：相比于PyChecker，Pylint是一个高阶的Python代码分析工具，它分析Python代码中的错误。
Pyflakes，一个用于检查Python源文件错误的简单程序。Pyflakes分析程序并且检查各种错误。它通过解析源文件实现，无需导入。
pdb,Python标准库,Python调试器。
ipdb,IPython使用的PDB。
winpdb独立于平台的GUI调试器。
pudb，全屏，基于python调试控制台。
pyringe，-可附着于及注入代码到Python程序的调试器。
python-statsd，statsd服务器客户端。
memory_profiler， 内存监视。
profiling，交互式Python分析器。
django-debug-toolbar, Django调试工具栏,显示各种调试信息:当前请求/响应。
django-devserver,Django调试工具。
flask-debugtoolbar,flask调试工具。
struct模块
2022年7月25日
15:15
该模块可以把一个类型，如数字，转成固定长度的bytes
data = ``struct.pack('i',1111111111111) ``封包
head_json_len=struct.unpack('i',``data ``)[0]#``解包，元组
Pil模块
2022年6月2日
23:47
PIL``功能介绍与安装
PIL``，全称``Python Image Library``，主要作用是图像处理，可用于图片剪切、粘贴、缩放、镜像、水印、颜色块、滤镜、图像格式转换、色场空间转换、验证码、旋转图像、图像增强、直方图处理、插值和滤波等功能。不过只支持到``Python 2.7``。``Pillow``是``PIL``的一个派生分支，但如今已经发展成为比``PIL``本身更具活力的图像处理库。我们需要安装的就是``Pillow``。
PIL``具体用途：图像归档``(Image Archives)``。``PIL``非常适合于图像归档以及图像的批处理任务。你可以使用``PIL``创建缩略图，转换图像格式，打印图像等等。
``图像展示``(Image Display)``。``PIL``较新的版本支持包括``Tk PhotoImage``，``BitmapImage``还有``Windows DIB``等接口。``PIL``支持众多的``GUI``框架接口，可以用于图像展示。
``图像处理``(Image Processing)``。``PIL``包括了基础的图像处理函数，包括对点的处理，使用众多的卷积核``(convolution kernels)``做过滤``(filter),``还有颜色空间的转换。``PIL``库同样支持图像的大小转换，图像旋转，以及任意的仿射变换。``PIL``还有一些直方图的方法，允许你展示图像的一些统计特性。这个可以用来实现图像的自动对比度增强，还有全局的统计分析等。
pip install Pillow
PIL的基本操作
from PIL import Image
# 1.``打开图片
img = Image.open("image/10.png")
# 2.``显示图片``(``执行显示图片后线程会中断，关闭图像后恢复``)
img.show()
# 3.``保存图片
img.save("image/xiaomai.png")
我在尝试的过程中发现，``png``格式的图片保存为``jpg``格式时会报错：``OSError: cannot write mode RGBA as JPEG``，经过查阅资料发现错误原因主要是因为``PNG``格式和``JPG``格式图片的通道数不同。
PNG``是四通道：``RGBA``意思是红色，绿色，蓝色，``Alpha``的色彩空间，``Alpha``指透明度
JPG``是三通道：``RGB``意思是红色，绿色，蓝色
所以，``PNG``格式图片要保存成``JPG``格式就要丢弃``A``通道：
from PIL import Image
# 1.``打开图片
img = Image.open("image/10.png")
# 2.``显示图片``(``执行显示图片后线程会中断，关闭图像后恢复``)
img.show()
# 3.``保存图片
img = img.convert("RGB")
img.save("image/xiaomai.jpg")
下面是图片旋转的代码：
from PIL import Image
# 1.``打开图片
img = Image.open("pli/7.png")
# 2.``水平翻转
img1 = img.transpose(Image.FLIP_LEFT_RIGHT)
# 3.``保存图片
img1.save("pli/1.png")
# 4.``垂直翻转
img2 = img.rotate(180)
# 5.``保存照片
img2.save("pli/2.png")
# 6.``水平``+``垂直翻转
img3 = img.transpose(Image.FLIP_LEFT_RIGHT).rotate(180)
# 7.``保存图片
img3.save("pli/3.png")
给图片增加文字
要在图像上绘制文本要用到 PIL 的两个模块：ImageDraw和ImageFont。 ImageDraw 用于创建绘图对象，ImageFont用于加载字体。
from PIL import Image, ImageDraw, ImageFont
# 1.``打开图片
img = Image.open("image/10.png")
# 2.``调用画图模块
draw = ImageDraw.Draw(img)
# 3.``设置字体
tfont = ImageFont.truetype("``萌神手写体``.ttf", 24)
# 4.``添加文字
"""
``参数一：文字在图片的位置：``(x, y)
``参数二：文字内容
``参数三：字体颜色，当然颜色也可以用``RGB``值指定
``参数四：字体类型
"""
draw.text((50, 30), "eyes++", fill="green", font=tfont)
# 5.``保存图片
img.save("image/addWord.png")
# 6.``显示图片
img.show()
PIL滤镜功能
from PIL import Image, ImageFilter
img = Image.open("image/10.png")
img = img.filter(ImageFilter.CONTOUR)
img.save("image/Filter.png")
img.show()
PIL镜像功能
from PIL import Image
img = Image.open("image/10.png")
img = img.transpose(Image.FLIP_LEFT_RIGHT)
img.save("image/mirror.png")
transpose有这么几种模式
FLIP_LEFT_RIGHT：左右镜像
FLIP_TOP_BOTTOM：上下镜像
ROTATE_90：逆时针转90度
ROTATE_180：逆时针转180度
ROTATE_270：逆时针转270度
TRANSPOSE：像素矩阵转置
TRANSVERSE
最后一种模式我也不知道什么意思，也没查到，但效果是下面这样的，盲猜是对角线对转。。。。。
图片拼接功能
from PIL import Image, ImageDraw
# ``打开图片
img1 = Image.open("image/10.png")
img2 = Image.open("image/addWord.png")
# ``查看图片尺寸，便于拼接图片
print(img1.size)
print(img1.size)
# ``新建空白图片``,``三个参数分别是模式``(RGB/RGBA)``、大小、颜色
newimg = Image.new(mode="RGB", size=(1174, 614), color=(255, 100, 50))
# ``拼接图片``,``第一个参数是图片，第二个是起始位置
newimg.paste(img1, (0, 0))
newimg.paste(img2, (587, 0))
newimg.show()
PIL裁剪功能
from PIL import Image
img = Image.open("image/10.png")
print(img.size)
imgCut = img.crop((100, 200, 500, 600))
imgCut.show()
图片缩放
from PIL import Image
# :
img = Image.open('image/10.png')
# ``获得图像尺寸``:
w, h = img.size
# ``缩放到``50%:
img.thumbnail((w//2, h//2))
# ``把缩放后的图像用``jpeg``格式保存``:
img.save('image/zoom.png')
warnings — 非致命提醒
2022年10月13日
16:45
warnings — 非致命提醒
目的：向用户提供有关运行程序时遇到的问题的非致命警报
warnings ``模块由`` PEP 230 ``引入，作为一种警告程序员关于语言或库功能的变化的方法，以预测`` Python 3.0 ``带来的向后不兼容的变化。它还可用于报告从丢失的库中恢复的配置错误或功能退化。不过，最好是通过`` logging ``模块提供面向用户的消息，因为发送到控制台的警告可能丢失。
由于警告不是致命的，因此程序在运行过程中可能会多次遇到相同的警告情况。``warnings ``模块抑制来自同一来源的重复消息，以减少一遍又一遍地看到相同警告的烦恼。输出可以根据具体情况进行控制，使用解释器的命令行选项或调用`` warnings ``中的函数。
Python ``通过调用`` warnings ``模块中定义的`` warn() ``函数来发出警告``。警告消息通常用于提示用户一些错误或者过时的用法，当这些情况发生时我们不希望抛出异常或者直接退出程序。警告消息通常写入`` sys.stderr``，对警告的处理方式可以灵活的更改，例如忽略或者转变为为异常。警告的处理可以根据警告类别，警告消息的文本和发出警告消息的源位置而变化。对相同源位置的特定警告的重复通常被抑制。
警告控制分为两个阶段：
- 首先，警告被触发时，确定是否应该发出消息；
- 接下来，如果要发出消息，则使用用户可设置的钩子来格式化和打印消息。
filterwarnings()--警告过滤器
警告过滤器可以用来控制是否发出警告消息，警告过滤器是一些匹配规则和动作的序列。可以通过调用`` filterwarnings() ``将规则添加到过滤器，并通过调用`` resetwarnings() ``将其重置为默认状态。
showwarning()--警告消息
警告消息的输出是通过调用`` showwarning() ``函数来完成的，其可以被覆盖；该函数的默认实现通过调用`` formatwarning() ``格式化消息，这也可以由自定义实现使用。
警告类别
內建警告类型：
Warning 所有警告类别类的基类，它是 Exception 的子类
UserWarning 函数 warn() 的默认类别
DeprecationWarning 用于已弃用功能的警告（默认被忽略）
SyntaxWarning 用于可疑语法的警告
RuntimeWarning 用于有关可疑运行时功能的警告
FutureWarning 对于未来特性更改的警告
PendingDeprecationWarning 对于未来会被弃用的功能的警告（默认将被忽略）
ImportWarning 导入模块过程中触发的警告（默认被忽略）
UnicodeWarning 与 Unicode 相关的警告
BytesWarning 与 bytes 和 bytearray 相关的警告 (Python3)
ResourceWarning 与资源使用相关的警告(Python3)
可以通过继承內建警告类型来实现自定义的警告类型，警告类型必须始终是 Warning 类的子类。
警告过滤器
警告过滤器用于控制警告的行为，如忽略，显示或转换为错误（引发异常）。警告过滤器维护着一个有序的过滤规则列表，匹配规则用于确定如何处理警告，任何特定警告都将依次与列表中的每个过滤规则匹配，直到找到匹配为止。过滤规则类型为一个元组 (action，message，category，module，lineno)，其中：
- action 为以下值：
值 处理方式
"error" 将匹配警告转换为异常
"ignore" 忽略匹配的警告
"always" 始终输出匹配的警告
"default" 对于同样的警告只输出第一次出现的警告
"module" 在一个模块中只输出第一次出现的警告
"once" 输出第一次出现的警告,而不考虑它们的位置
- message 是包含正则表达式的字符串，警告消息的开始必须匹配，不区分大小写
- category 是一个警告类型（必须是 Warning 的子类）
- module 是包含模块名称的正则表达式字符串，区分大小写
- lineno 是一个整数，警告发生的行号，为 0 则匹配所有行号
默认警告过滤器
默认情况下，``Python ``设置了几个警告过滤器，可以通过`` -W ``命令行选项和调用`` filterwarnings() ``函数来覆盖它们。
DeprecationWarning ``和`` PendingDeprecationWarning ``和`` ImportWarning ``被默认忽略。
除非`` -b ``选项给出一次或两次，否则忽略`` BytesWarning``；在这种情况下，此警告或者被输出（``-b``）或者变成异常（``-bb``）。
除非`` Python ``是在调试模式下构建的，否则将忽略`` ResourceWarning``。
在`` 3.2 ``版中的调整``: ``除`` PendingDeprecationWarning ``之外，默认情况下将忽略`` DeprecationWarning
可用函数
1. warn
warnings.warn(message, category=None, stacklevel=1, source=None)
触发异常。``category`` ``参数默认为`` ``UserWarning``。``message`` ``参数为警告消息，可以是`` ``Warning`` ``实例，在这种情况下，将忽略`` ``category`` ``并使用`` ``message.__class__``，消息文本则为`` ``str(message)``。
warn_explicit
warnings.warn_explicit(message, category, filename, lineno, module=None, registry=None, module_globals=None, source=None)
是 warn() 函数的低级接口，明确传递消息，类别，文件名和行号，以及可选的模块名称和注册表（应该是模块的 warningregistry 字典）
3.showwarning
warnings.showwarning(message, category, filename, lineno, file=None, line=None)
写入警告到文件。默认调用`` formatwarning(message, category, filename, lineno, line) ``并将结果字符串写入`` file``，默认为`` sys.stderr``。`` line ``是包含在警告消息中的一行源代码；如果未提供则尝试读取由`` filename ``和`` lineno ``指定的行。
simplefilter
warnings.simplefilter(action, category=Warning, lineno=0, append=False)
简单易用的过滤器，类似 filterwarnings() 函数，但是不需要正则表达式。
resetwarnings
warnings.resetwarnings()
重置警告过滤器。这会丢弃所有以前对 filterwarnings() 调用的影响，包括 -W 命令行选项和对 simplefilter() 的调用的影响。
生成警告
发出警告的最简单方法是使用消息作为参数调用`` ``warn()`` ``。
import warnings
print('Before the warning')
warnings.warn('This is a warning message')
print('After the warning')
Socketserver模块
2022年7月25日
21:01
基于tcp的套接字，关键就是两个循环，
一个链接循环，一个通信循环
socketserver模块中分两大类：
server类（解决链接问题）
request类（解决通信问题）
server类：
request类：
继承关系:
以下述代码为例，分析socketserver源码：
ftpserver=socketserver.ThreadingTCPServer(('17.0.0.1',8080),FtpServer)
ftpserver.serve_forever()
查找属性的顺序：ThreadingTCPServer->ThreadingMixIn->TCPServer->BaseServer
- 实例化得到ftpserver，先找类ThreadingTCPServer的__init__,在TCPServer中找到，进而执行server_bind,server_active
- 找ftpserver下的serve_forever,在BaseServer中找到，进而执行self._handle_request_noblock()，该方法同样是在BaseServer中
- 执行self._handle_request_noblock()进而执行request, client_address = self.get_request()（就是TCPServer中的self.socket.accept()），然后执行self.process_request(request, client_address)
- 在ThreadingMixIn中找到process_request，开启多线程应对并发，进而执行process_request_thread，执行self.finish_request(request, client_address)
上述四部分完成了链接循环，本部分开始进入处理通讯部分，在BaseServer中找到finish_request,触发我们自己定义的类的实例化，去找__init__方法，而我们自己定义的类没有该方法，则去它的父类也就是BaseRequestHandler中找....
源码分析总结：
基于tcp的socketserver我们自己定义的类中的
- self.server即套接字对象
- self.request即一个链接
- self.client_address即客户端地址
基于udp的socketserver我们自己定义的类中的
- self.request是一个元组
（第一个元素是客户端发来的数据，第二部分是服务端的udp套接字对象），
如(b'adsf', <socket.socket fd=200, family=AddressFamily.AF_INET, type=SocketKind.SOCK_DGRAM, proto=0, laddr=('127.0.0.1', 8080)>)
- self.client_address即客户端地址
multiprocessing模块
2022年7月27日
12:50
介绍
multiprocessing模块的功能众多：支持子进程、通信和共享数据、执行不同形式的同步，提供了Process、Queue、Pipe、Lock等组件。
与线程不同，进程没有任何共享状态，进程修改的数据，改动仅限于该进程内。
Process类的介绍
创建进程的类
Process([group [, target [, name [, args [, kwargs]]]]])``，由该类实例化得到的对象，表示一个子进程中的任务（尚未启动）
强调：`
`1. ``需要使用关键字的方式来指定参数`
`2. args``指定的为传给``target``函数的位置参数，是一个元组形式，必须有逗号
参数
group``参数未使用，值始终为``None
target``表示调用对象，即子进程要执行的任务
args``表示调用对象的位置参数元组，``args=(1,2,'egon',)
kwargs``表示调用对象的字典``,kwargs={'name':'egon','age':18}
name``为子进程的名称
方法介绍
p.start()``：启动进程，并调用该子进程中的``p.run()
p.run():``进程启动时运行的方法，正是它去调用``target``指定的函数，我们自定义类的类中一定要实现该方法
p.terminate():``强制终止进程``p``，不会进行任何清理操作，如果``p``创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果``p``还保存了一个锁那么也将不会被释放，进而导致死锁
p.is_alive():``如果``p``仍然运行，返回``True
p.join([timeout]):``主线程等待``p``终止（强调：是主线程处于等的状态，而``p``是处于运行的状态）。``timeout``是可选的超时时间，需要强调的是，``p.join``只能``join``住``start``开启的进程，而不能``join``住``run``开启的进程
属性介绍
p.daemon``：默认值为``False``，如果设为``True``，代表``p``为后台运行的守护进程，当``p``的父进程终止时，``p``也随之终止，并且设定为``True``后，``p``不能创建自己的新进程，必须在``p.start()``之前设置
p.name:``进程的名称
p.pid``：进程的``pid
p.exitcode:``进程在运行时为``None``、如果为``–``N``，表示被信号``N``结束``(``了解即可``)
p.authkey:``进程的身份验证键``,``默认是由``os.urandom()``随机生成的``32``字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性，这类连接只有在具有相同的身份验证键时才能成功（了解即可）
僵尸进程与孤儿进程
一：僵尸进程（有害）
僵尸进程：
一个进程使用fork创建子进程，如果子进程退出，而父进程并没有调用wait或waitpid获取子进程的状态信息，那么子进程的进程描述符仍然保存在系统中。这种进程称之为僵死进程。
二：孤儿进程（无害）
孤儿进程：
一个父进程退出，而它的一个或多个子进程还在运行，那么那些子进程将成为孤儿进程。孤儿进程将被init进程(进程号为1)所收养，并由init进程对它们完成状态收集工作。
孤儿进程是没有父进程的进程，孤儿进程这个重任就落到了init进程身上，init进程就好像是一个民政局，专门负责处理孤儿进程的善后工作。每当出现一个孤儿进程的时候，内核就把孤 儿进程的父进程设置为init，而init进程会循环地wait()它的已经退出的子进程。这样，当一个孤儿进程凄凉地结束了其生命周期的时候，init进程就会代表党和政府出面处理它的一切善后工作。因此孤儿进程并不会有什么危害。
解决僵尸进程
等待父进程正常结束后会调用wait／waitpid去回收僵尸进程
但如果父进程是一个死循环，永远不会结束，那么该僵尸进程就会一直存在，僵尸进程过多，就是有害的
解决方法一：杀死父进程
解决方法二：对开启的子进程应该记得使用join，join会回收僵尸进程
解决方法三：
signal(``参数一``,``参数二``)
参数一：我们要进行处理的信号。系统的信号我们可以再终端键入 kill -l查看(共64个)。其实这些信号时系统定义的宏。
参数二：我们处理的方式（是系统默认还是忽略还是捕获）。可以写一个handdle函数来处理我们捕获的信号。
SIGCHLD信号
子进程结束时, 父进程会收到这个信号。
如果父进程没有处理这个信号，也没有等待(wait)子进程，子进程虽然终止，但是还会在内核进程表中占有表项，这时的子进程称为僵尸进程。这种情 况我们应该避免(父进程或者忽略SIGCHILD信号，或者捕捉它，或者wait它派生的子进程，或者父进程先终止，这时子进程的终止自动由init进程 来接管)。
SIG_ING
忽略的意思
守护进程
主进程创建守护进程
其一：守护进程会在主进程代码执行结束后就终止
其二：守护进程内无法再开启子进程,否则抛出异常：AssertionError: daemonic processes are not allowed to have children
注意：进程之间是互相独立的，主进程代码运行结束，守护进程随即终止
使用：``p.daemon=True #``一定要在``p.start()``前设置``,``设置``p``为守护进程``,``禁止``p``创建子进程``,``并且父进程代码执行结束``,p``即终止运行
案例：
frommultiprocessing import Process`
`import time`
`import random
class Piao(Process):`
` def__init__(self,name):`
` self.name=name`
` super().__init__()`
` def run(self):`
` print('%s is piaoing'%self.name)`
` time.sleep(random.randrange(1,3))`
` print('%s is piao end'%self.name)
p=Piao('egon')`
`p.daemon=True #``一定要在``p.start()``前设置``,``设置``p``为守护进程``,``禁止``p``创建子进程``,``并且父进程代码执行结束``,p``即终止运行
p.start()`
`print('``主``')
进程锁
进程之间数据不共享,但是共享同一套文件系统,所以访问同一个文件,或同一个打印终端,是没有问题的,
而共享带来的是竞争，竞争带来的结果就是错乱，如何控制，就是加锁处理
案例一：多个进程共享同一打印终端
未加锁：#并发运行,效率高,但竞争同一打印终端,带来了打印错乱
加锁: #由并发变成了串行,牺牲了运行效率,但避免了竞争
案例二：多个进程共享同一文件
未加锁：并发写入，效率高，但是竞争同一个文件，到时数据错乱
加锁：并发变成了串行，牺牲了运行效率，但是保证了数据的安全
总结：
#加锁可以保证多个进程修改同一块数据时，同一时间只能有一个任务可以进行修改，即串行的修改，没错，速度是慢了，但牺牲了速度却保证了数据安全。虽然可以用文件共享数据实现进程间通信，但问题是：
1.效率低（共享数据基于文件，而文件是硬盘上的
数据）
2.需要自己加锁处理
#因此我们最好找寻一种解决方案能够兼顾：
1、效率高（多个进程共享一块内存的数据）
2、帮我们处理好锁问题。
这就是mutiprocessing模块为我们提供的基于消息的IPC通信机制：队列和管道。
1 队列和管道都是将数据存放于内存中
2 队列又是基于（管道+锁）实现的，可以让我们从复杂的锁问题中解脱出来，
我们应该尽量避免使用共享数据，尽可能使用消息传递和队列，避免处理复杂的同步和锁问题，而且在进程数目增多时，往往可以获得更好的可获展性。
队列
进程彼此之间互相隔离，要实现进程间通信（IPC），multiprocessing模块支持两种形式：队列和管道，这两种方式都是使用消息传递的
创建队列的类（底层就是以管道和锁定的方式实现）：
Queue([maxsize]):创建共享的进程队列，Queue是多进程安全的队列，可以使用Queue实现多进程之间的数据传递。
maxsize是队列中允许最大项数，省略则无大小限制。
方法介绍：
q.put
方法用以插入数据到队列中，``put``方法还有两个可选参数：``blocked``和``timeout``。如果``blocked``为``True``（默认值），并且``timeout``为正值，该方法会阻塞``timeout``指定的时间，直到该队列有剩余的空间。如果超时，会抛出``Queue.Full``异常。如果``blocked``为``False``，但该``Queue``已满，会立即抛出``Queue.Full``异常。
q.get
方法可以从队列读取并且删除一个元素。
get``方法有两个可选参数：``blocked``和``timeout``。
如果``blocked``为``True``（默认值），并且``timeout``为正值，那么在等待时间内没有取到任何元素，会抛出``Queue.Empty``异常。
如果``blocked``为``False``，有两种情况存在，如果``Queue``有一个值可用，则立即返回该值，否则，如果队列为空，则立即抛出``Queue.Empty``异常``.
q.get_nowait():``同``q.get(False)
q.put_nowait():``同``q.put(False)
q.empty():
调用此方法时``q``为空则返回``True``，该结果不可靠，比如在返回``True``的过程中，如果队列中又加入了项目。
q.full()``：
调用此方法时``q``已满则返回``True``，该结果不可靠，比如在返回``True``的过程中，如果队列中的项目被取走。
q.qsize():
返回队列中目前项目的正确数量，结果也不可靠，理由同``q.empty()``和``q.full()``一样
q.cancel_join_thread():
不会在进程退出时自动连接后台线程。可以防止``join_thread()``方法阻塞
q.close():
关闭队列，防止队列中加入更多数据。
调用此方法，后台线程将继续写入那些已经入队列但尚未写入的数据，但将在此方法完成时马上关闭。如果``q``被垃圾收集，将调用此方法。关闭队列不会在队列使用者中产生任何类型的数据结束信号或异常。例如，如果某个使用者正在被阻塞在``get()``操作上，关闭生产者中的队列不会导致``get()``方法返回错误。
q.join_thread()``：
连接队列的后台线程。此方法用于在调用``q.close()``方法之后，等待所有队列项被消耗。默认情况下，此方法由不是``q``的原始创建者的所有进程调用。调用``q.cancel_join_thread``方法可以禁止这种行为
进程池
在利用Python进行系统管理的时候，特别是同时操作多个文件目录，或者远程控制多台主机，并行操作可以节约大量的时间。多进程是实现并发的手段之一，需要注意的问题是：
- 很明显需要并发执行的任务通常要远大于核数
- 一个操作系统不可能无限开启进程，通常有几个核就开几个进程
- 进程开启过多，效率反而会下降（开启进程是需要占用系统资源的，而且开启多余核数目的进程也无法做到并行）
例如当被操作对象数目不大时，可以直接利用multiprocessing中的Process动态成生多个进程，十几个还好，但如果是上百个，上千个。。。手动的去限制进程数量却又太过繁琐，此时可以发挥进程池的功效。
我们就可以通过维护一个进程池来控制进程数目，比如httpd的进程模式，规定最小进程数和最大进程数...
ps：对于远程过程调用的高级应用程序而言，应该使用进程池，Pool可以提供指定数量的进程，供用户调用，当有新的请求提交到pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到规定最大值，那么该请求就会等待，直到池中有进程结束，就重用进程池中的进程。
创建进程池的类：
如果指定numprocess为3，则进程池会从无到有创建三个进程，然后自始至终使用这三个进程去执行所有任务，不会开启其他进程
Pool([numprocess [,initializer [, initargs]]]):``创建进程池``
参数介绍
1 numprocess:``要创建的进程数，如果省略，将默认使用``cpu_count()``的值`
`2 initializer``：是每个工作进程启动时要执行的可调用对象，默认为``None`
`3 initargs``：是要传给``initializer``的参数组
方法介绍
p.apply(func[,args[,kwargs]]):
在一个池工作进程中执行``func(*args,**kwargs),``然后返回结果。需要强调的是：此操作并不会在所有池工作进程中并执行``func``函数。如果要通过不同参数并发地执行``func``函数，必须从不同线程调用``p.apply()``函数或者使用``p.apply_async()
p.apply_async(func[,args[,kwargs]]):
在一个池工作进程中执行``func(*args,**kwargs),``然后返回结果。此方法的结果是``AsyncResult``类的实例，``callback``是可调用对象，接收输入参数。当``func``的结果变为可用时，将理解传递给``callback``。``callback``禁止执行任何阻塞操作，否则将接收其他异步操作中的结果。
p.close():
关闭进程池，防止进一步操作。如果所有操作持续挂起，它们将在工作进程终止前完成
P.jion():
等待所有工作进程退出。此方法只能在``close``（）或``teminate()``之后调用
obj.get():
返回结果，如果有必要则等待结果到达。``timeout``是可选的。如果在指定时间内还没有到达，将引发一场。如果远程操作中引发了异常，它将在调用此方法时再次被引发。
obj.ready():
如果调用完成，返回``True
obj.successful():
如果调用完成且没有引发异常，返回``True``，如果在结果就绪之前调用此方法，引发异常
obj.wait([timeout]):
等待结果变为可用。
obj.terminate()``：
立即终止所有工作进程，同时不执行任何清理或结束任何挂起工作。如果``p``被垃圾回收，将自动调用此函数
wsgiref
2022年9月7日
11:41
wsgiref 是Python标准库给出的 WSGI 的参考实现。
WSGI是Python Web 开发中为服务器程序和应用程序设定的标准，满足这一标准的服务器程序和应用程序可以配合使用。我在上一篇博文《WSGI简介》中对此有详细的介绍。在阅读wsgiref源代码之前，一定要对WSGI有一定了解。
WSGI 在 PEP 333 中描述，但是只靠阅读PEP 333 可能在理解上还是不够深入，所以阅读官方给出的参考实现是很有必要的。阅读完这份源代码后，不仅有利于对WSGI的理解。而且会让你对服务端程序如何对客户端请求有一个直观的理解，从相对底层的socket监听请求，到上层对HTTP请求的处理。
当然，这只是对WSGI的参考实现，目的是为了描述清楚WSGI，而不是真正用在产品中。如果想对Python Web开发中服务器端的实现有更广泛，更深入的理解，需要进一步阅读Python常用框架的源代码。
wsgiref 源代码分析
wsgiref 源代码可以在 pypi wsgiref 0.1.2 下载。另外，我在阅读的过程中作了大量注释，包含模块介绍，调用层次关系，demo的运行结果，等 等，还包含了阅读过程中制作的思维导图。GitHub地址注释版wsgiref。
结构
上图描述了wsgiref的所有模块及模块间的调用关系，可以看出，wsgiref有以下模块：
simple_server
这一模块实现了一个简单的 HTTP 服务器，并给出了一个简单的 demo，运行：
python simple_server.py
会启动这个demo，运行一次请求，并把这次请求中涉及到的环境变量在浏览器中显示出来。
handlers
simple_server模块将HTTP服务器分成了 Server 部分和Handler部分，前者负责接收请求，后者负责具体的处理， 其中Handler部分主要在handlers中实现。
headers
这一模块主要是为HTTP协议中header部分建立数据结构。
util
这一模块包含了一些工具函数，主要用于对环境变量，URL的处理。
validate
这一模块提供了一个验证工具，可以用于验证你的实现是否符合WSGI标准。
simple_server
可以看出，simple_server 模块主要有两部分内容
应用程序
函数demo_app是应用程序部分
服务器程序
服务器程序主要分成Server 和 Handler两部分，另外还有一个函数 make_server 用来生成一个服务器实例
我们先看应用程序部分。
注意：以 M:开始的都是我自己添加的注释，不包含在最初的源代码中。
def demo_app(environ,start_response):
# M: StringIO reads and writes a string buffer (also known as memory files).
from StringIO import StringIO
stdout = StringIO()
print >> stdout, "Hello world!"
print >> stdout
h = environ.items()
h.sort()
for k,v in h:
print >> stdout, k,'=',v``
start_response("200 OK", [('Content-Type','text/plain')])
return [stdout.getvalue()]
这里可以看出，这个 demo_app 是如何展示WSGI中对应用程序的要求的：
demo_app 有两个参数
第一个参数 environ是一个字典
第二个参数 start_response是一个可调用函数
demo_app 返回一个可迭代对象
demo_app 需要调用 start_response
另外，可以看出，返回的内容就是环境变量当前的内容，这一点可以运行
python simple_server.py
在浏览器中看到的内容，就是上述源代码的for循环中输出的。
这里，使用了 StringIO ，可以看出，所有输出的内容都先存储在其实例中，最后返回的时候一起在可迭代对象中返回。
接下来，我们看服务器程序。
先从 make_server 看起，它是用来生成一个server实例的：
def make_server(
host, port, app, server_class=WSGIServer, handler_class=WSGIRequestHandler
):
"""Create a new WSGI server listening on `host` and `port` for `app`"""
# M: -> HTTPServer.__init__
# -> TCPServer.__init__
# -> TCPServer.server_bind
# -> TCPServer.socket.bind
# -> TCPServer.server_activate
# -> TCPServer.socket.listen
server = server_class((host, port), handler_class)
# M: conresponding to WSGIRequestHandler.handle()
# -> handler.run(self.server.get_app())
server.set_app(app)
return server
虽然代码只有三行，但是可以看出生成一个 server 都需要些什么：
(host, port)
主机名和端口号
handler_class
用于处理请求的handler类
app 服务器程序在处理时，一定会调用我们之前写好的应用程序，这样他们才能配合起来为客户端面服务，所以，你看到了那个 set_app 调用。
另外，在注释部分，你可以看到那代码背后都发生了什么。
生成 server 实例时，默认的 server_class 是 WSGIServer，它是HTTPServer的子类，后者又是TCPServer的子类，所以初始化 server 时，会沿着类的继承关系执行下去，最终，生成 server 实例的过程，其实是最底层的 TCPServer 在初始化时，完成了对socket的bind和listen。
后面的 set_app 设置了 app，它会在 handler_class (默认为WSGIRequestHandler)的handle函数中被取出来，然后交给 handler 的 run 函数运行。
好，现在我们开始介绍Server部分的主要内容，即WSGIServer和WSGIRequestHandler，首先，我们看一下二者的继承体系。
WSGIServer
# M:
# +------------+
# | BaseServer |
# +------------+
# |
# V
# +------------+
# | TCPServer |
# +------------+
# |
# V
# +------------+
# | HTTPServer |
# +------------+
# |
# V
# +------------+
# | WSGIServer |
# +------------+
可以看出 WSGIServer 来自 HTTPServer，后者来自 Python 标准库中的BaseHTTPServer模块，更上层的TCPServer和BaseServer来自 Python 标准库中的 SocketServer 模块。
WSGIRequestHandler
# M:
# +--------------------+
# | BaseRequestHandler |
# +--------------------+
# |
# V
# +-----------------------+
# | StreamRequestHandler |
# +-----------------------+
# |
# V
# +------------------------+
# | BaseHTTPRequestHandler |
# +------------------------+
# |
# V
# +--------------------+
# | WSGIRequestHandler |
# +--------------------+
可以看出 WSGIRequestHandler 来自 BaseHTTPRequestHandler，后者来自 Python 标准库中的BaseHTTPServer模块，更上层的StreamRequestHandler和BaseRequestHandler来自 Python 标准库中的 SocketServer 模块。
这时候，三个模块之间的层次关系我们可以理清楚了。
# M:
# +-----------------------------------------------+
# | simple_server: WSGIServer, WSGIRequestHandler |
# | |
# +-----------------------------------------------+
# |
# V
# +----------------------------------------------------+
# | BaseHTTPServer: HTTPServer, BaseHTTPRequestHandler |
# +----------------------------------------------------+
# |
# V
# +----------------------------------------------------+
# | SocketServer: TCPServer,BaseSErver; |
# | StreamRequestHandler,BaseRequestHandler |
# +----------------------------------------------------+
#
另外，这一模块中还有一个类，叫ServerHandler，它继承自 handlers 模块中的 SimpleHandler，我们再看看它的继承体系：
# M:
# +-------------+
# | BaseHandler |
# +-------------+
# |
# V
# +----------------+
# | SimpleHandler |
# +----------------+
# |
# V
# +---------------+
# | ServerHandler |
# +---------------+
#
好了，现在这个模块中的继承结构都弄清楚了，现在我们看看他们如何配合起来完成对客户端请求的处理。
首先，回顾simple_server涉及的模块：
WSGIServer
WSGIRequestHandler
ServerHandler
demo_app
make_server
然后，把大脑清空，想一下要对客户端请求进行处理需要做什么
启动服务器，监听客户端请求
请求来临，处理用户请求
我们看看这几个模块是如何配合完成这两个功能的
先看看 simple_server 模块的 main 部分，即执行
python simple_server.py
时执行的内容:
httpd = make_server('', 8000, demo_app)
sa = httpd.socket.getsockname()
print "Serving HTTP on", sa[0], "port", sa[1], "..."
# M: webbrowser provides a high-level interface to allow displaying Web-based documents
# to users. Under most circumstances
import webbrowser
webbrowser.open('http://localhost:8000/xyz?abc')
httpd.handle_request() # serve one request, then exit
可以看出，主要完成的功能是：
启动服务器
模块用户请求
处理用户请求
那么，我们主要关心的就是 make_server 和 handle_request 背后都发生了什么。
make_server
上图可以看出函数之间的调用关系，也可以看出 make_server 到 使用 socket 监听用户请求的过程。
handle_request
handle_request 的过程真正将各个模块联系起来了。
上图很清楚地说明了 由handle_request到demo_app的执行过程，把这个模块的各个部分联系起来。相信无需多言了。
Handlers
从图中可以看出handler模块中的四部分，它们其实是四个类，
从基类到子类依次为：
BaseHandler
SimpleHandler
BaseCGIHandler
CGIHandler
最主要的实现在 BaseHandler中，其它几个类都是在基类基础上做了简单的实现。BaseHandler是不能直接使用的，因为有几个关键的地方没有实现，SimpleHandler是一个可以使用的简单实现。simple_server中的 ServerHandler类就是这个模块中SimpleHandler的子类。
在 BaseHandler中，最重要的是 run 函数：
def run(self, application):
"""Invoke the application"""
# Note to self: don't move the close()! Asynchronous servers shouldn't
# call close() from finish_response(), so if you close() anywhere but
# the double-error branch here, you'll break asynchronous servers by
# prematurely closing. Async servers must return from 'run()' without
# closing if there might still be output to iterate over.
try:
self.setup_environ()
self.result = application(self.environ, self.start_response)
self.finish_response()
except:
try:
self.handle_error()
except:
# If we get an error handling an error, just give up already!
self.close()
raise # ...and let the actual server figure it out.
它先设置好环境变量，再调用我们的 demo_app, 并通过 finish_response 将调用结果传送给客户端。如果处理过程遇到错误，转入 handle_error 处理。
此外，BaseHandler中还包含了 WSGI 中多次提到的 start_response，start_response 在 demo_app 中被调用，我们看看它的实现：
def start_response(self, status, headers,exc_info=None):
"""'start_response()' callable as specified by PEP 333"""
# M:
# exc_info:
# The exc_info argument, if supplied, must be a Python sys.exc_info()
# tuple. This argument should be supplied by the application only if
# start_response is being called by an error handler.
# exc_info is the most recent exception catch in except clause
# in error_output:
# start_response(
# self.error_status,self.error_headers[:],sys.exc_info())
# headers_sent:
# when send_headers is invoked, headers_sent = True
# when close is invoked, headers_sent = False
if exc_info:
try:
if self.headers_sent:
# Re-raise original exception if headers sent
raise exc_info[0], exc_info[1], exc_info[2]
finally:
exc_info = None # avoid dangling circular ref
elif self.headers is not None:
raise AssertionError("Headers already set!")
assert type(status) is StringType,"Status must be a string"
assert len(status)>=4,"Status must be at least 4 characters"
assert int(status[:3]),"Status message must begin w/3-digit code"
assert status[3]==" ", "Status message must have a space after code"
if __debug__:
for name,val in headers:
assert type(name) is StringType,"Header names must be strings"
assert type(val) is StringType,"Header values must be strings"
assert not is_hop_by_hop(name),"Hop-by-hop headers not allowed"
# M: set status and headers
self.status = status
# M:
# headers_class is Headers in module headers
self.headers = self.headers_class(headers)
return self.write
可以看出，它先对参数进行了检查，然后再将headers 存储在成员变量中，这两点 WSGI标准中都有明确说明，需要检查参数，并且这一步只能将 headers存储起来，不能直接发送给客户端。也就是说，这个 start_response 还没有真正 response。
其实刚刚介绍 run 函数的时候已经提到了，真正的 response 在 finish_response 函数中：
def finish_response(self):
"""Send any iterable data, then close self and the iterable
Subclasses intended for use in asynchronous servers will
want to redefine this method, such that it sets up callbacks
in the event loop to iterate over the data, and to call
'self.close()' once the response is finished.
"""
# M:
# result_is_file:
# True if 'self.result' is an instance of 'self.wsgi_file_wrapper'
# finish_content:
# Ensure headers and content have both been sent
# close:
# Close the iterable (if needed) and reset all instance vars
if not self.result_is_file() or not self.sendfile():
for data in self.result:
self.write(data) # send data by self.write
self.finish_content()
self.close()
另外一个需要注意的地方是错误处理，在 run 函数中通过 try/except 捕获错误，错误处理使用了 handle_error 函数，WSGI中提到，start_response 函数的第三个参数 exc_info 会在错误处理的时候使用，我们来看看它是如何被使用的：
def handle_error(self):
"""Log current error, and send error output to client if possible"""
self.log_exception(sys.exc_info())
if not self.headers_sent:
self.result = self.error_output(self.environ, self.start_response)
self.finish_response()
# XXX else: attempt advanced recovery techniques for HTML or text?
def error_output(self, environ, start_response):
"""WSGI mini-app to create error output
By default, this just uses the 'error_status', 'error_headers',
and 'error_body' attributes to generate an output page. It can
be overridden in a subclass to dynamically generate diagnostics,
choose an appropriate message for the user's preferred language, etc.
Note, however, that it's not recommended from a security perspective to
spit out diagnostics to any old user; ideally, you should have to do
something special to enable diagnostic output, which is why we don't
include any here!
"""
# M:
# sys.exc_info():
# Return information about the most recent exception caught by an except
# clause in the current stack frame or in an older stack frame.
start_response(self.error_status,self.error_headers[:],sys.exc_info())
return [self.error_body]
看到了吧，handle_error 又调用了 error_output ，后者调用 start_response，并将其第三个参数设置为 sys.exc_info()，这一点在 WSGI 中也有说明。
好了，这一部分我们就介绍到这里，不再深入过多的细节，毕竟源代码还是要自己亲自阅读的。剩下的三个部分不是核心问题，就是一些数据结构和工具函数，我们简单说一下。
Headers
这个模块是对HTTP 响应部分的头部设立的数据结构，实现了一个类似Python 中 dict的数据结构。可以看出，它实现了一些函数来支持一些运算符，例如 len, setitem, getitem, delitem, str, 另外，还实现了 dict 操作中的get, keys, values函数。
Util
这个模块主要就是一些有用的函数，用于处理URL, 环境变量。
Validate
这个模块主要是检查你对WSGI的实现，是否满足标准，包含三个部分：
validator
Wrapper
Check
validator 调用后面两个部分来完成验证工作，可以看出Check部分对WSGI中规定的各个部分进行了检查。
Jinja2
2022年9月7日
12:29
jinja2介绍
jinja2是Flask作者开发的一个模板系统，起初是仿django模板的一个模板引擎，为Flask提供模板支持，由于其灵活，快速和安全等优点被广泛使用。
jinja2的优点
jinja2之所以被广泛使用是因为它具有以下优点：
-
- 相对于Template，jinja2更加灵活，它提供了控制结构，表达式和继承等。
- 相对于Mako，jinja2仅有控制结构，不允许在模板中编写太多的业务逻辑。
- 相对于Django模板，jinja2性能更好。
- Jinja2模板的可读性很棒。
安装jinja2
由于jinja2属于第三方模块，首先需要对其进行安装
| 1 | pip3 install jinja2 |
|---|---|
测试模板是否安装成功
1 2 3 4 |
python -c "import jinja2" # ``没有报错就表示安装成功 # ``必须用双引号``" |
|---|---|
jinja2语法
作为一个模板系统，它还提供了特殊的语法，我们按照它支持的语法进行编写之后，就能使用jinja2模块进行渲染。
基本语法
在jinja2中，存在三种语法：
-
- 控制结构
- 变量取值 {{ }}
- 注释
下面是一个简单的jinja2例子
1 2 3 4 5 6 7 |
{# This is jinja code {% for file in filenames %} ... {% endfor %} #} |
|---|---|
可以看到，for循环的使用方式和Python比较类似，但是没有了句尾的冒号，另外需要使用endfor最为结尾，其实在jinja2中，if也是一样的，结尾需要使用endif。
jinja2变量
jinja2模板中使用 {{ }} 语法表示一个变量，它是一种特殊的占位符。当利用jinja2进行渲染的时候，它会把这些特殊的占位符进行填充/替换，jinja2支持python中所有的Python数据类型比如列表、字段、对象等。
1 2 3 |
<p>this is a dicectory:{{ mydict['key'] }} </p> <p>this is a list:{{ mylist[3] }} </p> <p>this is a object:{{ myobject.something() }} </p> |
|---|---|
jinja2中的过滤器
变量可以通过“过滤器”进行修改，过滤器可以理解为是jinja2里面的内置函数和字符串处理函数。
常用的过滤器有：
| 过滤器名称 | 说明 |
|---|---|
| safe | 渲染时值不转义 |
| capitialize | 把值的首字母转换成大写，其他子母转换为小写 |
| lower | 把值转换成小写形式 |
| upper | 把值转换成大写形式 |
| title | 把值中每个单词的首字母都转换成大写 |
| trim | 把值的首尾空格去掉 |
| striptags | 渲染之前把值中所有的HTML标签都删掉 |
| join | 拼接多个值为字符串 |
| replace | 替换字符串的值 |
| round | 默认对数字进行四舍五入，也可以用参数进行控制 |
| int | 把值转换成整型 |
那么如何使用这些过滤器呢？ 只需要在变量后面使用管道(|)分割，多个过滤器可以链式调用，前一个过滤器的输出会作为后一个过滤器的输入。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 | {{ 'abc' | captialize }} # Abc {{ 'abc' | upper }} # ABC {{ 'hello world' | title }} # Hello World {{ "hello world" | replace('world','daxin') | upper }} # HELLO DAXIN {{ 18.18 | round | int }} # 18 |
| ------------------------------------------------------------ | ------------------------------------------------------------ |
| | |
jinja2的控制结构
jinja2中的if语句类似与Python的if语句，它也具有单分支，多分支等多种结构，不同的是，条件语句不需要使用冒号结尾，而结束控制语句，需要使用endif关键字。
1 2 3 4 5 6 7 |
{% if daxin.safe %} daxin is safe. {% elif daxin.dead %} daxin is dead {% else %} daxin is okay {% endif %} |
|---|---|
jinja2的for循环
jinja2中的for循环用于迭代Python的数据类型，包括列表，元组和字典。在jinja2中不存在while循环。
迭代列表
| 1 2 3 4 5 | <ul> {% for user in users %} <li>{{ user.username|title }}</li> {% endfor %} </ul> |
| ----------------------- | ------------------------------------------------------------ |
| | |
迭代字典
1 2 3 4 5 6 |
<dl> {% for key, value in my_dict.iteritems() %} <dt>{{ key }}</dt> <dd>{{ value}}</dd> {% endfor %} </dl> |
|---|---|
当然也可以加入else语句，在循环正确执行完毕后，执行
在for循环中，jinja2还提供了一些特殊的变量，用以来获取当前的遍历状态：
| 变量 | 描述 |
|---|---|
| loop.index | 当前迭代的索引（从1开始） |
| loop.index0 | 当前迭代的索引（从0开始） |
| loop.first | 是否是第一次迭代，返回bool |
| loop.last | 是否是最后一次迭代，返回bool |
| loop.length | 序列中的项目数量 |
| loop.revindex | 到循环结束的次数（从1开始） |
| loop.revindex0 | 到循环结束的次数(从0开始） |
jinja2的宏
宏类似于Python中的函数，我们在宏中定义行为，还可以进行传递参数，就像Python中的函数一样一样儿的。
在宏中定义一个宏的关键字是macro，后面跟其 宏的名称和参数等
1 2 3 4 5 |
{% macro input(name,age=18) %} # ``参数``age``的默认值为``18 <input type='text' name="{{ name }}" value="{{ age }}" > {% endmacro %} |
|---|---|
调用方法也和Python的类似
1 2 |
<p>{{ input('daxin') }} </p> <p>{{ input('daxin',age=20) }} </p> |
|---|---|
jinja2的继承和Super函数
jinja2中最强大的部分就是模板继承。模板继承允许我们创建一个基本(骨架)文件，其他文件从该骨架文件继承，然后针对自己需要的地方进行修改。
jinja2的骨架文件中，利用block关键字表示其包涵的内容可以进行修改。
以下面的骨架文件base.html为例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
<!DOCTYPE html> <html lang="en"> <head> {% block head %} <link rel="stylesheet" href="style.css"/> <title>{% block title %}{% endblock %} - My Webpage</title> {% endblock %} </head> <body> <div id="content">{% block content %}{% endblock %}</div> <div id="footer"> {% block footer %} <script>This is javascript code </script> {% endblock %} </div> </body> </html> |
|---|---|
这里定义了四处 block，即：head，title，content，footer。那怎么进行继承和变量替换呢？注意看下面的文件
1 2 3 4 5 6 7 8 9 10 11 12 |
{% extend "base.html" %} # ``继承``base.html``文件 {% block title %} Dachenzi {% endblock %} # ``定制``title``部分的内容 {% block head %} {{ super() }} # ``用于获取原有的信息 <style type='text/css'> .important { color: #FFFFFF } </style> {% endblock %} # ``其他不修改的原封不同的继承 |
|---|---|
PS: super()函数 表示获取block块中定义的原来的内容。
利用jinja2进行渲染
jinja2模块中有一个名为Enviroment的类，这个类的实例用于存储配置和全局对象，然后从文件系统或其他位置中加载模板。
基本使用方法
大多数应用都在初始化的时候撞见一个Environment对象，并用它加载模板。Environment支持两种加载方式：
-
- PackageLoader：包加载器
- FileSystemLoader：文件系统加载器
PackageLoader
使用包加载器来加载文档的最简单的方式如下：
| 1 2 3 4 5 | from jinja2 import PackageLoader,Environment env = Environment(loader=PackageLoader('python_project','templates')) # 创建一个包加载器对象 template = env.get_template('bast.html') # 获取一个模板文件 template.render(name='daxin',age=18) # 渲染 |
|---|---|
其中：
-
- PackageLoader()的两个参数为：python包的名称，以及模板目录名称。
- get_template()：获取模板目录下的某个具体文件。
- render()：接受变量，对模板进行渲染
FileSystemLoader
文件系统加载器，不需要模板文件存在某个Python包下，可以直接访问系统中的文件。
查看api
2022年3月23日
18:27
python -m pydoc -p 1234
-p 端口号
csv模块
2022年11月12日
10:47
案例
1.使用CSV模块中的方法读取csv格式文件
import csv
import re
filename = "C:\\Users\\LSG\\Desktop\\info.csv"
#``文件的读操作（以只读方式打开文件。文件的指针将会放在文件的开头。这是``**``默认模式``** , ``编码方式``UTF-8``）
with open(filename, 'r' , encoding='utf-8') as file:
data_csv_reader = csv.reader(file)
# ``将文件中每行数据添加到``comments``里（数据类型``list``）
comments = []
for line in data_csv_reader:
comments.append(line)
# ``循环打印文本内容
for line in comments :
print(line)
sys模块
2022年7月12日
21:13
sys.argv：
参数字符串列表（动态对象），第一个参数为当前程序主文件的绝对路径或空字符串，如果在命令提示符界面给``Python``文件传了参数（不同的参数以空格分隔，无论传入的时候写的是什么类型，最终都会转成字符串），可以在这里面获取（从第二个位置开始），比如命令提示符中运行``“``python main.py 111 aaa``”``，那``sys.argv``就有三个元素，第二个和第三个元素分别为``“``111``”``和``“``aaa``”``。
返回传递给`` Python ``脚本的命令行参数列表。看下示例：
Import sys
if__name__=='__main__':
args=sys.argvprint(args)
print(args[1])
上面文件名为：``test.py``，我们在控制台使用命令：``python test.py 123 abc`` ``执行一下，执行结果如下：
['test.py','123','abc']123
sys.path：
搜索模块路径字符串列表（动态对象），搜索查找模块时会优先到这里面去搜索，第一个参数为主文件所在目录的路径或空字符串。
sys.modules：
已经加载的模块信息字典，key为模块名称，value为模块对象，在使用__import__导入模块时，可以先判断下是否有同名模块已经在sys.modules中加载了，如果已经存在了，可以先删除或者不再导入了。
以字典类型返回系统导入的模块。
sys.getsizeof(object)：
获取一个对象的内存占用字节数大小。
sys.getdefaultencoding()：
返回``Python``默认的字符串编码格式。
sys.exit([status])：
退出``Python``解释器，并抛出一个``SystemExit``异常，``status``默认为``0``，即``“``成功``”``，如果``status``是一个整数，则被用作一个系统退出状态，如果``status``是其他对象，则它将会被``print``并系统退出状态为``1``，即``“``失败``”``。所以使用这个方法的话，一般是需要进行异常处理的，运行完这条语句后如果有异常捕获和处理的，会去运行后面的异常处理代码的（而``os._exit()``方法则不会，它不会抛出异常）。
sys.excutable：
代码运行时表示运行的解释器绝对路径，如``C:\Python36\python.exe``，在打包的程序中就是``exe``程序文件的绝对路径，这个是用来定位用户运行该程序的真实位置。
version
返回`` Python ``解释器的版本信息。
winver
返回`` Python ``解释器主版号。
platform
返回操作系统平台名称。
path
返回模块的搜索路径列表。
maxsize
返回支持的最大整数值。
maxunicode
返回支持的最大`` Unicode ``值。
copyright
返回`` Python ``版权信息。
byteorder
返回本地字节规则的指示器。
executable
返回`` Python ``解释器所在路径。
Import sys
print(sys.version)
print(sys.winver)
print(sys.platform)
print(sys.path)
print(sys.maxsize)
print(sys.maxunicode)
print(sys.copyright)
print(sys.modules)
print(sys.byteorder)
print(sys.executable)
stdout
标准输出。看下示例：
import sys # ``下面两行代码等价
sys.stdout.write('Hi'+'\n')
print('Hi')
stdin
标准输入。看下示例：
import sys
s1=input()
s2=sys.stdin.readline()
print(s1)
print(s2)
stderr
错误输出。看下示例：
import sys
sys.stderr.write('this is a error message')
exit()
退出当前程序。看下示例：
import sys
print('Hi')
sys.exit()
print('Jhon')
getdefaultencoding()
返回当前默认字符串编码的名称。
getrefcount(obj)
返回对象的引用计数。
getrecursionlimit()
返回支持的递归深度。
getsizeof(object[, default])
以字节为单位返回对象的大小。
setswitchinterval(interval)
设置线程切换的时间间隔。
getswitchinterval()
返回线程切换时间间隔。
pip命令
2021年11月30日
13:23
pip使用
安装包
pip install package_name
查看某个已安装包
pip show --files package_name
检查哪些包需要更新
pip list --outdated
升级包
pip install --upgrade package_name
卸载包
pip uninstall package_name
八 安装包或者模块
可以通过pip或者easy_install安装。pip是现代化的一种安装包的方式，以下讲解pip的常用命令:
1.安装包
pip install requests
2. 安装指定版本的包
pip install django == 1.10.6
3.卸载包
pip uninstall django
4.升级包
pip install -U requests
列出可升级的包：
pip list --outdate
一行命令升级所有pip安装的Python包
pip freeze --local | grep -v ‘^-e‘ | cut -d = -f 1 | xargs pip install -U
建议在执行前先执行：
pip install -U distribute
5.升级pip
pip install -U pip
6.查看当前pip是哪个版本
pip --version
7.显示某个已安装的包的信息
pip show -f <包名>
8.列出当前环境下安装了哪些包
pip list
9. 将当前环境安装的包全部列出来放在文件中
pip freeze > requirements.txt
10.从某个文件中安装包
pip install -r requirements.txt
11.临时更改安装源，以豆瓣源为例
pip install <包名> -i https://pypi.douban.com/simple
12.永久更改安装源
windows操作系统：在当前用户目录下新建pip/pip.ini，然后在文件中添加以下代码：
[global]
index-url = https://pypi.douban.com/simple
Linux/Mac：在用户目录下新建.pip/pip.conf，然后在文件中添加以下代码：
[global]
index-url = https://pypi.douban.com/simple
# pip --help
Usage:
pip [options]
Commands:
install Install packages. ``安装包
download Download packages. ``下载包
uninstall Uninstall packages. ``卸载包
freeze Output installed packages in requirements format. ``按着一定格式输出已安装包列表
list List installed packages. ``列出已安装包
show Show information about installed packages. ``显示包详细信息
check Verify installed packages have compatible dependencies.``检查包的依赖关系是否完整
config Manage local and global configuration.``管理配置
search Search PyPI for packages.``搜索包
wheel Build wheels from your requirements.
hash Compute hashes of package archives.``计算包的hash值
completion A helper command used for command completion.
help Show help for commands.
General Options:
-h, --help Show help.
--isolated Run pip in an isolated mode, ignoring environment variables and user configuration.
-v, --verbose Give more output. Option is additive, and can be used up to 3 times.
-V, --version Show version and exit.
-q, --quiet Give less output. Option is additive, and can be used up to 3 times (corresponding to WARNING, ERROR, and CRITICAL logging levels).
--log <path> Path to a verbose appending log.
--proxy <proxy> Specify a proxy in the form [user:passwd@]proxy.server:port.
--retries <retries> Maximum number of retries each connection should attempt (default 5 times).
--timeout <sec> Set the socket timeout (default 15 seconds).
--exists-action <action> Default action when a path already exists: (s)witch, (i)gnore, (w)ipe, (b)ackup, (a)bort).
--trusted-host <hostname> Mark this host as trusted, even though it does not have valid or any HTTPS.
--cert <path> Path to alternate CA bundle.
--client-cert <path> Path to SSL client certificate, a single file containing the private key and the certificate in PEM format.
--cache-dir <dir> Store the cache data in <dir>.
--no-cache-dir Disable the cache.
--disable-pip-version-check
Don't periodically check PyPI to determine whether a new version of pip is available for download. Implied with --no-index.
--no-color Suppress colored output
os文件模块
2021年11月26日
15:09
获取指定文件夹下的目录和文件的实现
一、os.listdir 方法
os.listdir() 方法用于返回指定的目列表录下包含的文件或子目录的名字的。这个列表以字母顺序。其得到的是仅当前路径下的文件名，不包括子目录中的文件，如果需要得到所有文件需要递归。 它也不包括 '.' 和 '..' 即使它在目录中。
语法格式如下：
os.listdir(path)
案列：
def list_dir(file_dir):
'''
``通过`` listdir ``得到的是仅当前路径下的文件名，不包括子目录中的文件，如果需要得到所有文件需要递归
'''
print'\n\n<><><><><><> listdir <><><><><><>'
print "current dir : {0}".format(file_dir)
dir_list = os.listdir(file_dir)
for cur_file in dir_list:
# ``获取文件的绝对路径
path = os.path.join(file_dir, cur_file)
if os.path.isfile(path): # ``判断是否是文件还是目录需要用绝对路径
print "{0} : is file!".format(cur_file)
if os.path.isdir(path):
print "{0} : is dir!".format(cur_file)
list_dir(path) # ``递归子目录
os.walk 方法
os.walk() 方法用于通过在目录树中游走输出在目录中的文件名，向上或者向下。是一个简单易用的文件、目录遍历器，可以帮助我们高效的处理文件、目录方面的事情。
语法格式：
os.walk(top[, topdown=True[, onerror=None[, followlinks=False]]])
方法参数说明：
- top：要遍历的目录的路径
- topdown：可选，如果为 True，则优先遍历 top 目录，以及 top 目录下的每一个子目录，否则优先遍历 top 的子目录，默认为 True
- onerror: 可选， 需要一个 callable 对象，当 walk 异常时调用
- followlinks：可选， 如果为 True，则会遍历目录下的快捷方式(linux 下是 symbolic link)实际所指的目录，默认为 False
- args：包含那些没有 '-' 或 '--' 的参数列表
返回值: 三元组 (root, dirs, files)
- root ：所指的是当前正在遍历的目录的地址
- dirs ：当前文件夹中所有目录名字的 list (不包括子目录)
- files ：当前文件夹中所有的文件 (不包括子目录中的文件)
#文件名称
file_name=os.path.splitext(file)[0]
#文件根据‘。点’分割
返回一个列表，【0代表文件名字】【1为点之后的文件后缀名】
file_suffix=os.path.splitext(file)[1]
#文件具体绝对路径：文件的具体地址
具体到每一层目录，直到文件
file_path=os.path.join(root,file)
#文件相对路径：
结束是文件存在在某一级目录下，但是不具体
file_abs_path=os.path.abspath(file)
#文件父路径：文件在哪一层目录下
，结果给出的是文件的上一层目录
file_parent=os.path.dirname(file_path)
其他跟文件相关的常用方法
分离文件名和扩展名
os.path.splitext()：
file = "file_test.txt"
file_name = os.path.splitext(file)[0] # ``输出：``file_test
file_suffix = os.path.splitext(file)[1] # ``输出：``.txt
判断文件或目录是否存在
os.path.exists()：
判断是否是文件
os.path.isfile()：
判断是否是目录
os.path.isdir()：
获取当前文件所在的目录，即父目录
os.path.dirname()：
创建多级目录
os.makedirs()：
创建单级目录
os.mkdir()：
获取文件大小
os.path.getsize()：
路径相同重命名文件或目录，从 src 到 dst，路径不同移动
若是路径不同还文件名字也不同这是吧src的文件，移动并重命名到dst中
os.rename(src, dst)
删除路径为path的文件。
如果path 是一个文件夹，将抛出OSError; 查看下面的
os.remove(path)
删除path指定的空目录，如果目录非空，则抛出一个OSError异常。
os.rmdir(path)
a文件复制到b目录
import shutil
Shutil.Copyfile(a,b)
os.getcwd() ``获取当前工作目录，即当前``python``脚本工作的目录路径`
`os.chdir("dirname") ``改变当前脚本工作目录；相当于``shell``下``cd`
`os.curdir ``返回当前目录``: ('.')`
`os.pardir ``获取当前目录的父目录字符串名：``('..')`
`os.makedirs('dirname1/dirname2') ``可生成多层递归目录`
`os.removedirs('dirname1') ``若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推`
`os.mkdir('dirname') ``生成单级目录；相当于``shell``中``mkdir dirname`
`os.rmdir('dirname') ``删除单级空目录，若目录不为空则无法删除，报错；相当于``shell``中``rmdir dirname`
`os.listdir('dirname') ``列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印`
`os.remove() ``删除一个文件`
`os.rename("oldname","newname") ``重命名文件``/``目录`
`os.stat('path/filename') ``获取文件``/``目录信息`
`os.sep ``输出操作系统特定的路径分隔符，``win``下为``"\\",Linux``下为``"/"`
`os.linesep ``输出当前平台使用的行终止符，``win``下为``"\t\n",Linux``下为``"\n"`
`os.pathsep ``输出用于分割文件路径的字符串`` win``下为``;,Linux``下为``:`
`os.name ``输出字符串指示当前使用平台。``win->'nt'; Linux->'posix'`
`os.system("bash command") ``运行``shell``命令，直接显示`
`os.environ ``获取系统环境变量`
`os.path.abspath(path) ``返回``path``规范化的绝对路径`
`os.path.split(path) ``将``path``分割成目录和文件名二元组返回`
`os.path.dirname(path) ``返回``path``的目录。其实就是``os.path.split(path)``的第一个元素`
`os.path.basename(path) ``返回``path``最后的文件名。如何``path``以／或``\``结尾，那么就会返回空值。即``os.path.split(path)``的第二个元素`
`os.path.exists(path) ``如果``path``存在，返回``True``；如果``path``不存在，返回``False`
`os.path.isabs(path) ``如果``path``是绝对路径，返回``True`
`os.path.isfile(path) ``如果``path``是一个存在的文件，返回``True``。否则返回``False`
`os.path.isdir(path) ``如果``path``是一个存在的目录，则返回``True``。否则返回``False`
`os.path.join(path1[, path2[, ...]]) ``将多个路径组合后返回，第一个绝对路径之前的参数将被忽略`
`os.path.getatime(path) ``返回``path``所指向的文件或者目录的最后存取时间`
`os.path.getmtime(path) ``返回``path``所指向的文件或者目录的最后修改时间`
`os.path.getsize(path) ``返回``path``的大小
Python OS 文件/目录方法
os 模块提供了非常丰富的方法用来处理文件和目录。常用的方法如下表所示：
| 序号 | 方法及描述 |
|---|---|
| 1 | os.access(path, mode) 检验权限模式 |
| 2 | os.chdir(path) 改变当前工作目录 |
| 3 | os.chflags(path, flags) 设置路径的标记为数字标记。 |
| 4 | os.chmod(path, mode) 更改权限 |
| 5 | os.chown(path, uid, gid) 更改文件所有者 |
| 6 | os.chroot(path) 改变当前进程的根目录 |
| 7 | os.close(fd) 关闭文件描述符 fd |
| 8 | os.closerange(fd_low, fd_high) 关闭所有文件描述符，从 fd_low (包含) 到 fd_high (不包含), 错误会忽略 |
| 9 | os.dup(fd) 复制文件描述符 fd |
| 10 | os.dup2(fd, fd2) 将一个文件描述符 fd 复制到另一个 fd2 |
| 11 | os.fchdir(fd) 通过文件描述符改变当前工作目录 |
| 12 | os.fchmod(fd, mode) 改变一个文件的访问权限，该文件由参数fd指定，参数mode是Unix下的文件访问权限。 |
| 13 | os.fchown(fd, uid, gid) 修改一个文件的所有权，这个函数修改一个文件的用户ID和用户组ID，该文件由文件描述符fd指定。 |
| 14 | os.fdatasync(fd) 强制将文件写入磁盘，该文件由文件描述符fd指定，但是不强制更新文件的状态信息。 |
| 15 | [os.fdopen(fd, mode[, bufsize]]) 通过文件描述符 fd 创建一个文件对象，并返回这个文件对象 |
| 16 | os.fpathconf(fd, name) 返回一个打开的文件的系统配置信息。name为检索的系统配置的值，它也许是一个定义系统值的字符串，这些名字在很多标准中指定（POSIX.1, Unix 95, Unix 98, 和其它）。 |
| 17 | os.fstat(fd) 返回文件描述符fd的状态，像stat()。 |
| 18 | os.fstatvfs(fd) 返回包含文件描述符fd的文件的文件系统的信息，像 statvfs() |
| 19 | os.fsync(fd) 强制将文件描述符为fd的文件写入硬盘。 |
| 20 | os.ftruncate(fd, length) 裁剪文件描述符fd对应的文件, 所以它最大不能超过文件大小。 |
| 21 | os.getcwd() 返回当前工作目录 |
| 22 | os.getcwdu() 返回一个当前工作目录的Unicode对象 |
| 23 | os.isatty(fd) 如果文件描述符fd是打开的，同时与tty(-like)设备相连，则返回true, 否则False。 |
| 24 | os.lchflags(path, flags) 设置路径的标记为数字标记，类似 chflags()，但是没有软链接 |
| 25 | os.lchmod(path, mode) 修改连接文件权限 |
| 26 | os.lchown(path, uid, gid) 更改文件所有者，类似 chown，但是不追踪链接。 |
| 27 | os.link(src, dst) 创建硬链接，名为参数 dst，指向参数 src |
| 28 | os.listdir(path) 返回path指定的文件夹包含的文件或文件夹的名字的列表。 |
| 29 | os.lseek(fd, pos, how) 设置文件描述符 fd当前位置为pos, how方式修改: SEEK_SET 或者 0 设置从文件开始的计算的pos; SEEK_CUR或者 1 则从当前位置计算; os.SEEK_END或者2则从文件尾部开始. 在unix，Windows中有效 |
| 30 | os.lstat(path) 像stat(),但是没有软链接 |
| 31 | os.major(device) 从原始的设备号中提取设备major号码 (使用stat中的st_dev或者st_rdev field)。 |
| 32 | os.makedev(major, minor) 以major和minor设备号组成一个原始设备号 |
| 33 | [os.makedirs(path, mode]) 递归文件夹创建函数。像mkdir(), 但创建的所有intermediate-level文件夹需要包含子文件夹。 |
| 34 | os.minor(device) 从原始的设备号中提取设备minor号码 (使用stat中的st_dev或者st_rdev field )。 |
| 35 | [os.mkdir(path, mode]) 以数字mode的mode创建一个名为path的文件夹.默认的 mode 是 0777 (八进制)。 |
| 36 | [os.mkfifo(path, mode]) 创建命名管道，mode 为数字，默认为 0666 (八进制) |
| 37 | [os.mknod(filename, mode=0600, device]) 创建一个名为filename文件系统节点（文件，设备特别文件或者命名pipe）。 |
| 38 | [os.open(file, flags, mode]) 打开一个文件，并且设置需要的打开选项，mode参数是可选的 |
| 39 | os.openpty() 打开一个新的伪终端对。返回 pty 和 tty的文件描述符。 |
| 40 | os.pathconf(path, name) 返回相关文件的系统配置信息。 |
| 41 | os.pipe() 创建一个管道. 返回一对文件描述符(r, w) 分别为读和写 |
| 42 | [os.popen(command, mode[, bufsize]]) 从一个 command 打开一个管道 |
| 43 | os.read(fd, n) 从文件描述符 fd 中读取最多 n 个字节，返回包含读取字节的字符串，文件描述符 fd对应文件已达到结尾, 返回一个空字符串。 |
| 44 | os.readlink(path) 返回软链接所指向的文件 |
| 45 | os.remove(path) 删除路径为path的文件。如果path 是一个文件夹，将抛出OSError; 查看下面的rmdir()删除一个 directory。 |
| 46 | os.removedirs(path) 递归删除目录。 |
| 47 | os.rename(src, dst) 重命名文件或目录，从 src 到 dst |
| 48 | os.renames(old, new) 递归地对目录进行更名，也可以对文件进行更名。 |
| 49 | os.rmdir(path) 删除path指定的空目录，如果目录非空，则抛出一个OSError异常。 |
| 50 | os.stat(path) 获取path指定的路径的信息，功能等同于C API中的stat()系统调用。 |
| 51 | [os.stat_float_times(newvalue]) 决定stat_result是否以float对象显示时间戳 |
| 52 | os.statvfs(path) 获取指定路径的文件系统统计信息 |
| 53 | os.symlink(src, dst) 创建一个软链接 |
| 54 | os.tcgetpgrp(fd) 返回与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组 |
| 55 | os.tcsetpgrp(fd, pg) 设置与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组为pg。 |
| 56 | [os.tempnam(dir[, prefix]]) 返回唯一的路径名用于创建临时文件。 |
| 57 | os.tmpfile() 返回一个打开的模式为(w+b)的文件对象 .这文件对象没有文件夹入口，没有文件描述符，将会自动删除。 |
| 58 | os.tmpnam() 为创建一个临时文件返回一个唯一的路径 |
| 59 | os.ttyname(fd) 返回一个字符串，它表示与文件描述符fd 关联的终端设备。如果fd 没有与终端设备关联，则引发一个异常。 |
| 60 | os.unlink(path) 删除文件路径 |
| 61 | os.utime(path, times) 返回指定的path文件的访问和修改的时间。 |
| 62 | [os.walk(top, topdown=True[, onerror=None[, followlinks=False]]]) 输出在文件夹中的文件名通过在树中游走，向上或者向下。 |
| 63 | os.write(fd, str) 写入字符串到文件描述符 fd中. 返回实际写入的字符串长度 |
| 64 | os.path 模块 获取文件的属性信息。 |
re正则
2021年11月27日
14:50
数量词的贪婪模式与非贪婪模式
正则表达式通常用于在文本中查找匹配的字符串。Python里数量词默认是贪婪的（在少数语言里也可能是默认非贪婪），总是尝试匹配尽可能多的字符；非贪婪的则相反，总是尝试匹配尽可能少的字符。
compile 函数
compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用。
语法格式为：
re.compile(pattern[, flags])
参数：
- pattern : 一个字符串形式的正则表达式
- flags 可选，表示匹配模式，比如忽略大小写，多行模式等
re.match函数
re.match ``尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，``match()``就返回``none``。
函数语法：
re.match(pattern, string, flags=0)
函数参数说明：
参数 |
描述 |
|---|---|
pattern |
匹配的正则表达式 |
string |
要匹配的字符串。 |
flags |
标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表达式修饰符 - 可选标志 |
匹配成功re.match方法返回一个匹配的对象，否则返回None。
我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。
| 匹配对象方法 | 描述 |
|---|---|
| group(num=0) | 匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。 |
| groups() | 返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。 |
匹配对象
group（id） 获取给定子模式（组的匹配项）
start（id） 返回给定组的匹配项的起始位置
end（id） 返回给定组的匹配项的结束位置
span（id） 返回一个组的起始和结束位置
import re
m = re.match(r'(http://www|WWW).(.*)..{3}', 'http://www.python.org')
print('输出匹配到的字符串')
print(m.group())
print('匹配第一个圆括号中的内容')
print(m.group(1))
print('匹配第二个圆括号中的内容')
print(m.group(2))
print('输出第一组字符串的起始位置')
print(m.start(1))
print('输出第二组字符串的起始位置')
print(m.start(2))
print('输出字符串的结束位置')
print(m.end(0))
print('输出第一个的起始和结束位置')
print(m.span(1))
re.search方法
re.search 扫描整个字符串并返回第一个成功的匹配。
函数语法：
re.search(pattern, string, flags=0)
检索和替换
Python 的re模块提供了re.sub用于替换字符串中的匹配项。
语法：
re.sub(pattern, repl, string, count=0, flags=0)
参数：
- pattern : 正则中的模式字符串。
- repl : 替换的字符串，也可为一个函数。
- string : 要被查找替换的原始字符串。
- count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
- flags : 编译时用的匹配模式，数字形式。
re.subn(pattern, repl, string, count=0, flags=0)
返回替换后的值，和替换了几次
findall
在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果有多个匹配模式，则返回元组列表，如果没有找到匹配的，则返回空列表。
注意： match 和 search 是匹配一次 findall 匹配所有。
语法格式为：
re.findall(pattern, string, flags=0)
或
pattern.findall(string[, pos[, endpos]])
参数：
- pattern 匹配模式。
- string 待匹配的字符串。
- pos 可选参数，指定字符串的起始位置，默认为 0。
- endpos 可选参数，指定字符串的结束位置，默认为字符串的长度。
re.finditer
和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。
re.finditer(pattern, string, flags=0)
re.split
split 方法按照能够匹配的子串将字符串分割后返回列表，它的使用形式如下：
re.split(pattern, string[, maxsplit=0, flags=0])
参数：
| 参数 | 描述 |
|---|---|
| pattern | 匹配的正则表达式 |
| string | 要匹配的字符串。 |
| maxsplit | 分割次数，maxsplit=1 分割一次，默认为 0，不限制次数。 |
| flags | 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表达式修饰符 - 可选标志 |
正则表达式对象
re.RegexObject
re.compile() 返回 RegexObject 对象。
re.MatchObject
特殊字符
所谓特殊字符，就是一些有特殊含义的字符，如上面说的 runoo*b 中的 ***，简单的说就是表示任何字符串的意思。如果要查找字符串中的 ***** 符号，则需要对 ***** 进行转义，即在其前加一个 **，runo*ob 匹配字符串 runo*ob。
许多元字符要求在试图匹配它们时特别对待。若要匹配这些特殊字符，必须首先使字符"转义"，即，将反斜杠字符**** 放在它们前面。下表列出了正则表达式中的特殊字符：
| 特别字符 | 描述 |
|---|---|
| $ | 匹配输入字符串的结尾位置。如果设置了 RegExp 对象的 Multiline 属性，则 $ 也匹配 '\n' 或 '\r'。要匹配 $ 字符本身，请使用 $。 |
| ( ) | 标记一个子表达式的开始和结束位置。子表达式可以获取供以后使用。要匹配这些字符，请使用 ( 和 )。 |
| * | 匹配前面的子表达式零次或多次。要匹配 * 字符，请使用 *。 |
| + | 匹配前面的子表达式一次或多次。要匹配 + 字符，请使用 +。 |
| . | 匹配除换行符 \n 之外的任何单字符。要匹配 . ，请使用 . 。 |
| [ | 标记一个中括号表达式的开始。要匹配 [，请使用 [。 |
| ? | 匹配前面的子表达式零次或一次，或指明一个非贪婪限定符。要匹配 ? 字符，请使用 ?。 |
| \ | 将下一个字符标记为或特殊字符、或原义字符、或向后引用、或八进制转义符。例如， 'n' 匹配字符 'n'。'\n' 匹配换行符。序列 '\' 匹配 ""，而 '(' 则匹配 "("。 |
| ^ | 匹配输入字符串的开始位置，除非在方括号表达式中使用，当该符号在方括号表达式中使用时，表示不接受该方括号表达式中的字符集合。要匹配 ^ 字符本身，请使用 ^。 |
| { | 标记限定符表达式的开始。要匹配 {，请使用 {。 |
| | | 指明两项之间的一个选择。要匹配 |，请使用 |。 |
正则表达式修饰符 - 可选标志
正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位`` OR(|) ``它们来指定。如`` re.I | re.M ``被设置成`` I ``和`` M ``标志：
修饰符 |
描述 |
|---|---|
re.I |
使匹配对大小写不敏感 |
re.L |
做本地化识别（``locale-aware``）匹配 |
re.M |
多行匹配，影响`` ^ ``和`` $ |
re.S |
使`` . ``匹配包括换行在内的所有字符 |
re.U |
根据``Unicode``字符集解析字符。这个标志影响`` \w, \W, \b, \B. |
re.X |
该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。 |
正则表达式模式
模式字符串使用特殊的语法来表示一个正则表达式：
字母和数字表示他们自身。一个正则表达式模式中的字母和数字匹配同样的字符串。
多数字母和数字前加一个反斜杠时会拥有不同的含义。
标点符号只有被转义时才匹配自身，否则它们表示特殊的含义。
反斜杠本身需要使用反斜杠转义。
| 模式 | 描述 |
|---|---|
^ |
匹配字符串的开头 |
$ |
匹配字符串的末尾。 |
. |
匹配任意字符，除了换行符，当``re.DOTALL``标记被指定时，则可以匹配包括换行符的任意字符。 |
[...] |
用来表示一组字符``,``单独列出：``[amk] ``匹配`` 'a'``，``'m'``或``'k' |
[^...] |
不在``[]``中的字符：``[^abc] ``匹配除了``a,b,c``之外的字符。 |
re* |
匹配``0``个或多个的表达式。 |
re+ |
匹配``1``个或多个的表达式。 |
re? |
匹配``0``个或``1``个由前面的正则表达式定义的片段，非贪婪方式 |
re{ n} |
精确匹配`` n ``个前面表达式。例如，`` ``o{2}`` ``不能匹配`` "Bob" ``中的`` "o"``，但是能匹配`` "food" ``中的两个`` o``。 |
re{ n,} |
匹配`` n ``个前面表达式。例如，`` o{2,} ``不能匹配``"Bob"``中的``"o"``，但能匹配`` "foooood"``中的所有`` o``。``"o{1,}" ``等价于`` "o+"``。``"o{0,}" ``则等价于`` "o*"``。 |
re{ n, m} |
匹配`` n ``到`` m ``次由前面的正则表达式定义的片段，贪婪方式 |
| `a | b` |
(re) |
对正则表达式分组并记住匹配的文本 |
(?imx) |
正则表达式包含三种可选标志：``i, m, ``或`` x ``。只影响括号中的区域。 |
(?-imx) |
正则表达式关闭`` i, m, ``或`` x ``可选标志。只影响括号中的区域。 |
(?: re) |
类似`` (...), ``但是不表示一个组 |
(?imx: re) |
在括号中使用``i, m, ``或`` x ``可选标志 |
(?-imx: re) |
在括号中不使用``i, m, ``或`` x ``可选标志 |
(?#...) |
注释``. |
(?= re) |
前向肯定界定符。如果所含正则表达式，以`` ... ``表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。 |
(?! re) |
前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功 |
(?> re) |
匹配的独立模式，省去回溯。 |
\w |
匹配字母数字及下划线 |
\W |
匹配非字母数字及下划线 |
\s |
匹配任意空白字符，等价于`` ``[ \t\n\r\f]``。 |
\S |
匹配任意非空字符 |
\d |
匹配任意数字，等价于`` [0-9]. |
\D |
匹配任意非数字 |
\A |
匹配字符串开始 |
\Z |
匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。 |
\z |
匹配字符串结束 |
\G |
匹配最后匹配完成的位置。 |
\b |
匹配一个单词边界，也就是指单词和空格间的位置。例如，`` 'er\b' ``可以匹配``"never" ``中的`` 'er'``，但不能匹配`` "verb" ``中的`` 'er'``。 |
\B |
匹配非单词边界。``'er\B' ``能匹配`` "verb" ``中的`` 'er'``，但不能匹配`` "never" ``中的`` 'er'``。 |
\n, \t, ``等``. |
匹配一个换行符。匹配一个制表符。等 |
\1...\9 |
匹配第``n``个分组的内容。 |
\10 |
匹配第``n``个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。 |
正则表达式实例
实例 |
描述 |
|---|---|
[Pp]ython |
匹配`` "Python" ``或`` "python" |
rub[ye] |
匹配`` "ruby" ``或`` "rube" |
[aeiou] |
匹配中括号内的任意一个字母 |
[0-9] |
匹配任何数字。类似于`` [0123456789] |
[a-z] |
匹配任何小写字母 |
[A-Z] |
匹配任何大写字母 |
[a-zA-Z0-9] |
匹配任何字母及数字 |
[^aeiou] |
除了``aeiou``字母以外的所有字符 |
[^0-9] |
匹配除了数字外的字符 |
特殊字符类
| 实例 | 描述 |
|---|---|
. |
匹配除`` "\n" ``之外的任何单个字符。要匹配包括`` '\n' ``在内的任何字符，请使用象`` '[.\n]' ``的模式。 |
\d |
匹配一个数字字符。等价于`` [0-9]``。 |
\D |
匹配一个非数字字符。等价于`` [^0-9]``。 |
\s |
匹配任何空白字符，包括空格、制表符、换页符等等。等价于`` [ \f\n\r\t\v]``。 |
\S |
匹配任何非空白字符。等价于`` [^ \f\n\r\t\v]``。 |
\w |
匹配包括下划线的任何单词字符。等价于``'[A-Za-z0-9_]'``。 |
\W |
匹配任何非单词字符。等价于`` '[^A-Za-z0-9_]'``。 |
案例
特殊符号替换：``re.sub(`` r'[-,$()#+&*]'``," ooo ",str)
表达式
一、校验数字的表达式
1. ``数字：``^[0-9]*$
2. n``位的数字：``^\d{n}$
3. ``至少``n``位的数字：``^\d{n,}$
4. m-n``位的数字：``^\d{m,n}$
5. ``零和非零开头的数字：``^(0|[1-9][0-9]*)$
6. ``非零开头的最多带两位小数的数字：``^([1-9][0-9]*)+(.[0-9]{1,2})?$
7. ``带``1-2``位小数的正数或负数：``^(\-)?\d+(\.\d{1,2})?$
8. ``正数、负数、和小数：``^(\-|\+)?\d+(\.\d+)?$
9. ``有两位小数的正实数：``^[0-9]+(.[0-9]{2})?$
10. ``有``1~3``位小数的正实数：``^[0-9]+(.[0-9]{1,3})?$
11. ``非零的正整数：``^[1-9]\d*$ ``或`` ^([1-9][0-9]*){1,3}$ ``或`` ^\+?[1-9][0-9]*$
12. ``非零的负整数：``^\-[1-9][]0-9"*$ ``或`` ^-[1-9]\d*$
13. ``非负整数：``^\d+$ ``或`` ^[1-9]\d*|0$
14. ``非正整数：``^-[1-9]\d*|0$ ``或`` ^((-\d+)|(0+))$
15. ``非负浮点数：``^\d+(\.\d+)?$ ``或`` ^[1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0$
16. ``非正浮点数：``^((-\d+(\.\d+)?)|(0+(\.0+)?))$ ``或``
^(-([1-9]\d*\.\d*|0\.\d*[1-9]\d*))|0?\.0+|0$
17. ``正浮点数：``^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$ ``或`` ^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$
18. ``负浮点数：``^-([1-9]\d*\.\d*|0\.\d*[1-9]\d*)$ ``或`` ^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$
19. ``浮点数：``^(-?\d+)(\.\d+)?$ ``或`` ^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0)$
二、校验字符的表达式
1. ``汉字：``^[\u4e00-\u9fa5]{0,}$
2. ``英文和数字：``^[A-Za-z0-9]+$ ``或`` ^[A-Za-z0-9]{4,40}$
3. ``长度为``3-20``的所有字符：``^.{3,20}$
4. ``由``26``个英文字母组成的字符串：``^[A-Za-z]+$
5. ``由``26``个大写英文字母组成的字符串：``^[A-Z]+$
6. ``由``26``个小写英文字母组成的字符串：``^[a-z]+$
7. ``由数字和``26``个英文字母组成的字符串：``^[A-Za-z0-9]+$
8. ``由数字、``26``个英文字母或者下划线组成的字符串：``^\w+$ ``或`` ^\w{3,20}$
9. ``中文、英文、数字包括下划线：``^[\u4E00-\u9FA5A-Za-z0-9_]+$
10. ``中文、英文、数字但不包括下划线等符号：``^[\u4E00-\u9FA5A-Za-z0-9]+$
``或`` ^[\u4E00-\u9FA5A-Za-z0-9]{2,20}$
11. ``可以输入含有``^%&',;=?$\"``等字符：``[^%&',;=?$\x22]+ 12
``禁止输入含有``~``的字符：``[^~\x22]+
三、特殊需求表达式
1. Email``地址：
^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$
2. ``域名：
[a-zA-Z0-9][-a-zA-Z0-9]{0,62}(/.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+/.?
3. InternetURL``：
[a-zA-z]+://[^\s]* ``或`` ^http://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$
4. ``手机号码：
^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}$
5. ``电话号码
("XXX-XXXXXXX"``、``"XXXX-XXXXXXXX"``、``"XXX-XXXXXXX"``、
"XXX-XXXXXXXX"``、``"XXXXXXX"``和``"XXXXXXXX)``：
^(\(\d{3,4}-)|\d{3.4}-)?\d{7,8}$
6. ``国内电话号码``(0511-4405222``、``021-87888822)``：
\d{3}-\d{8}|\d{4}-\d{7}
7. ``身份证号``(15``位、``18``位数字``)``：
^\d{15}|\d{18}$
8. ``短身份证号码``(``数字、字母``x``结尾``)``：
^([0-9]){7,18}(x|X)?$
或`` ^\d{8,18}|[0-9x]{8,18}|[0-9X]{8,18}?$
9. ``帐号是否合法``(``字母开头，允许``5-16``字节，允许字母数字下划线``)``：
^[a-zA-Z][a-zA-Z0-9_]{4,15}$
10. ``密码``(``以字母开头，长度在``6~18``之间，只能包含字母、数字和下划线``)``：
^[a-zA-Z]\w{5,17}$
11. ``强密码``(``必须包含大小写字母和数字的组合，不能使用特殊字符，长度在``8-10``之间``)``：
^(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{8,10}$
12. ``日期格式：
^\d{4}-\d{1,2}-\d{1,2}
13. ``一年的``12``个月``(01``～``09``和``1``～``12)``：
^(0?[1-9]|1[0-2])$
14. ``一个月的``31``天``(01``～``09``和``1``～``31)``：
^((0?[1-9])|((1|2)[0-9])|30|31)$
15. ``钱的输入格式：
- 1.有四种钱的表示形式我们可以接受:"10000.00" 和 "10,000.00", 和没有 "分" 的 "10000" 和 "10,000"：
^[1-9][0-9]*$
- \17. 2.这表示任意一个不以0开头的数字,但是,这也意味着一个字符"0"不通过,所以我们采用下面的形式：
^(0|[1-9][0-9]*)$
- 一个0或者一个不以0开头的数字.我们还可以允许开头有一个负号：
^(0|-?[1-9][0-9]*)$
- 这表示一个0或者一个可能为负的开头不为0的数字.让用户以0开头好了.把负号的也去掉,因为钱总不能是负的吧.下面我们要加的是说明可能的小数部分：
^[0-9]+(.[0-9]+)?$
- .必须说明的是,小数点后面至少应该有1位数,所以"10."是不通过的,但是 "10" 和 "10.2" 是通过的：
^[0-9]+(.[0-9]{2})?$
- .这样我们规定小数点后面必须有两位,如果你认为太苛刻了,可以这样：
^[0-9]+(.[0-9]{1,2})?$
- 这样就允许用户只写一位小数.下面我们该考虑数字中的逗号了,我们可以这样：
^[0-9]{1,3}(,[0-9]{3})*(.[0-9]{1,2})?$
- 1到3个数字,后面跟着任意个 逗号+3个数字,逗号成为可选,而不是必须：
^([0-9]+|[0-9]{1,3}(,[0-9]{3})*)(.[0-9]{1,2})?$
``备注：这就是最终结果了``,``别忘了``"+"``可以用``"*"``替代如果你觉得空字符串也可以接受的话``(``奇怪``,``为什么``?)``最后``,``别忘了在用函数时去掉去掉那个反斜杠``,``一般的错误都在这里
25. xml``文件：
^([a-zA-Z]+-?)+[a-zA-Z0-9]+\\.[x|X][m|M][l|L]$
26. ``中文字符的正则表达式：
[\u4e00-\u9fa5]
27. ``双字节字符：
[^\x00-\xff]
(``包括汉字在内，可以用来计算字符串的长度``(``一个双字节字符长度计``2``，``ASCII``字符计``1))
28. ``空白行的正则表达式：
\n\s*\r (``可以用来删除空白行``)
29. HTML``标记的正则表达式：
<(\S*?)[^>]*>.*?</\1>|<.*? />
(``网上流传的版本太糟糕，上面这个也仅仅能部分，对于复杂的嵌套标记依旧无能为力``)
30. ``首尾空白字符的正则表达式：
^\s*|\s*$``或``(^\s*)|(\s*$)
(``可以用来删除行首行尾的空白字符``(``包括空格、制表符、换页符等等``)``，非常有用的表达式``)
31. ``腾讯``QQ``号：
[1-9][0-9]{4,}
(``腾讯``QQ``号从``10000``开始``)
32. ``中国邮政编码：
[1-9]\d{5}(?!\d) (``中国邮政编码为``6``位数字``)
33.`` ``IP``地址：
\d+\.\d+\.\d+\.\d+ (``提取``IP``地址时有用``)
34. IP``地址：
((?:(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d))
=
json模块&pickle
2022年7月14日
9:57
json
如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。
JSON表示的对象就是标准的JavaScript语言的对象，JSON和Python内置的数据类型对应如下：
|
|
|---|---|
json序列化
json.dumps(''内容")
json反序列化
json.loads(''内容")
json验证：
json格式只能兼容所有语言通用的数据类型，不能兼容某一种语言特定的数据类型
json强调：json格式有它的要求，如json 不认单引号，不要混淆
注意：
import json`
`#dct="{'1':111}"#json ``不认单引号`
`#dct=str({"1":111})#``报错``,``因为生成的数据还是单引号``:{'one': 1}`
`dct='{"1":"111"}'print(json.loads(dct))
#conclusion:`
`# ``无论数据是怎样创建的，只要满足``json``格式，就可以``json.loads``出来``,``不一定非要``dumps``的数据才能``loads
# 一.什么是猴子补丁?
属性在运行时的动态替换，叫做猴子补丁（``Monkey Patch``）。
猴子补丁的核心就是用自己的代码替换所用模块的源代码，详细地如下
1``，这个词原来为Guerrilla Patch，杂牌军、游击队，说明这部分不是原装的，在英文里guerilla发音和gorllia(猩猩)相似，再后来就写了monkey(猴子)。
2``，还有一种解释是说由于这种方式将原来的代码弄乱了(messing with it)，在英文里叫monkeying about(顽皮的)，所以叫做Monkey Patch。
# 二. 猴子补丁的功能(一切皆对象)
1.``拥有在模块运行时替换的功能, 例如: 一个函数对象赋值给另外一个函数对象(把函数原本的执行的功能给替换了)
# 三.monkey patch的应用场景
如果我们的程序中已经基于``json``模块编写了大量代码了，发现有一个模块``ujson``比它性能更高，但用法一样，我们肯定不会想所有的代码都换成``ujson.dumps``或者``ujson.loads,
那我们可能会想到这么做`
`import ujson as json``，但是这么做的需要每个文件都重新导入一下，维护成本依然很高
此时我们就可以用到猴子补丁了只需要在入口处加上
import json`
`import ujson
def monkey_patch_json():`
` json.__name__= 'ujson'`
` json.dumps = ujson.dumps`
` json.loads = ujson.loads
monkey_patch_json() # ``之所以在入口处加，是因为模块在导入一次后，后续的导入便直接引用第一次的成果
#``其实这种场景也比较多, 比如我们引用团队通用库里的一个模块, 又想丰富模块的功能, 除了继承之外也可以考虑用MonkeyPatch.采用猴子补丁之后，如果发现ujson不符合预期，那也可以快速撤掉补丁。个人感觉Monkey`
`Patch``带了便利的同时也有搞乱源代码的风险!
Pickle
用法和json一样
注意``：``Pickle``的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于``Python``，并且可能不同版本的``Python``彼此都不兼容，因此，只能用``Pickle``保存那些不重要的数据，不能成功地反序列化也没关系。``
Shelve
shelve模块比pickle模块简单，只有一个open函数，返回类似字典的对象，可读可写;key必须为字符串，而值可以是python所支持的数据类型
import shelve
f=shelve.open(r'sheve.txt')`
`# f['stu1_info']={'name':'egon','age':18,'hobby':['piao','smoking','drinking']}`
`# f['stu2_info']={'name':'gangdan','age':53}`
`# f['school_info']={'website':'http://www.pypy.org','city':'beijing'}print(f['stu1_info']['hobby'])`
`f.close()
Faker模块
2022年6月17日
20:38
Faker
随机生成信息
1. 安装
pip install Faker
2. 简单使用
>>> from faker import Faker
>>> fake = Faker(locale='zh_CN')
>>> fake.name()
'``李洁``'
>>> fake.address()
'``上海市兴安盟县江北东莞路``r``座`` 803484'
参数 locale：为生成数据的文化选项（语种），默认为 en_US，只有使用了相关文化，才能生成相对应的随机信息
常见的文化选项：
zh_CN - Chinese (China Mainland)
zh_TW - Chinese (China Taiwan)
en_US - English (United States)
3. 其他方法
3.1 地理信息类
city_suffix() # ``市，县
country() # ``国家
country_code() # ``国家编码
district() # ``区
geo_coordinate() # ``地理坐标
latitude() # ``地理坐标``(``纬度``)
longitude() # ``地理坐标``(``经度``)
postcode() # ``邮编
province() # ``省份
address() # ``详细地址
street_address() # ``街道地址
street_name() # ``街道名
street_suffix() # ``街、路
3.2 基础信息类
ssn() # ``生成身份证号
bs() # ``随机公司服务名
company() # ``随机公司名（长）
company_prefix() # ``随机公司名（短）
company_suffix() # ``公司性质，如``'``信息有限公司``'
credit_card_expire() # ``随机信用卡到期日，如``'03/30'
credit_card_full() # ``生成完整信用卡信息
credit_card_number() # ``信用卡号
credit_card_provider() # ``信用卡类型
credit_card_security_code() # ``信用卡安全码
job() # ``随机职位
first_name_female() # ``女性名
first_name_male() # ``男性名
name() # ``随机生成全名
name_female() # ``男性全名
name_male() # ``女性全名
phone_number() # ``随机生成手机号
phonenumber_prefix() # ``随机生成手机号段，如``139
3.3 邮箱信息类
ascii_company_email() # ``随机``ASCII``公司邮箱名
ascii_email() # ``随机``ASCII``邮箱`` #
company_email() # ``公司邮箱
email() # ``普通邮箱
safe_email() # ``安全邮箱
3.4 ``网络基础信息类
domain_name() # ``生成域名
domain_word() # ``域词``(``即，不包含后缀``)
ipv4() # ``随机``IP4``地址
ipv6() # ``随机``IP6``地址
mac_address() # ``随机``MAC``地址
tld() # ``网址域名后缀``(.com,.net.cn,``等等，不包括``.)
uri() # ``随机``URI``地址
uri_extension() # ``网址文件后缀
uri_page() # ``网址文件（不包含后缀）
uri_path() # ``网址文件路径（不包含文件名）
url() # ``随机``URL``地址
user_name() # ``随机用户名
image_url() # ``随机``URL``地址
3.5 浏览器信息类
chrome() # ``随机生成``Chrome``的浏览器``user_agent``信息
firefox() # ``随机生成``FireFox``的浏览器``user_agent``信息
internet_explorer() # ``随机生成``IE``的浏览器``user_agent``信息
opera() # ``随机生成``Opera``的浏览器``user_agent``信息
safari() # ``随机生成``Safari``的浏览器``user_agent``信息
linux_platform_token() # ``随机``Linux``信息
user_agent() # ``随机``user_agent``信息
3.6 数字信息
numerify() # ``三位随机数字
random_digit() # 0~9``随机数
random_digit_not_null() # 1~9``的随机数
random_int() # ``随机数字，默认``0~9999``，可以通过设置``min,max``来设置
random_number() # ``随机数字，参数``digits``设置生成的数字位数
pyfloat() # ``随机``Float``数字
pyint() # ``随机``Int``数字（参考``random_int()``参数）
pydecimal() # ``随机``Decimal``数字（参考``pyfloat``参数）
3.7 文本加密类
pystr() # ``随机字符串
random_element() # ``随机字母
random_letter() # ``随机字母
paragraph() # ``随机生成一个段落
paragraphs() # ``随机生成多个段落
sentence() # ``随机生成一句话
sentences() # ``随机生成多句话，与段落类似
text() # ``随机生成一篇文章
word() # ``随机生成词语
words() # ``随机生成多个词语，用法与段落，句子，类似
binary() # ``随机生成二进制编码
boolean() # True/False
language_code() # ``随机生成两位语言编码
locale() # ``随机生成语言``/``国际 信息
md5() # ``随机生成``MD5
null_boolean() # NULL/True/False
password() # ``随机生成密码``,``可选参数`` # length # ``密码长度；``special_chars # ``是否能使用特殊字符；``digits # ``是否包含数字；``upper_case # ``是否包含大写字母；``lower_case # ``是否包含小写字母
sha1() # ``随机``SHA1
sha256() # ``随机``SHA256
uuid4() # ``随机``UUID
3.8 时间信息类
date() # ``随机日期
date_between() # ``随机生成指定范围内日期，参数`` # start_date``，``end_date
date_between_dates() # ``随机生成指定范围内日期，用法同上
date_object() # ``随机生产从``1970-1-1``到指定日期的随机日期。
date_time() # ``随机生成指定时间（``1970``年``1``月``1``日至今）
date_time_ad() # ``生成公元``1``年到现在的随机时间
date_time_between() # ``用法同``dates
future_date() # ``未来日期
future_datetime() # ``未来时间
month() # ``随机月份
month_name() # ``随机月份（英文）
past_date() # ``随机生成已经过去的日期
past_datetime() # ``随机生成已经过去的时间
time() # ``随机``24``小时时间
timedelta() # ``随机获取时间差
time_object() # ``随机``24``小时时间，``time``对象
time_series() # ``随机``TimeSeries``对象
timezone() # ``随机时区
unix_time() # ``随机``Unix``时间
year() # ``随机年份
4. 实战使用
在数据库建一张表，通过``Faker``造数据，插入到表中。并且打印``Faker``造的数据。
import pymysql
from faker import Faker
conn = pymysql.connect(host="114.215.129.166", port=3306, user="nice", password="", db="flask201",
charset="utf8")
cursor = conn.cursor()
sql1 = """drop table if exists faker_user"""
sql2 = """
create table faker_user(
pid int primary key auto_increment,
username varchar(20),
password varchar(20),
address varchar(35)
)
"""
cursor.execute(sql1)
cursor.execute(sql2)
fake = Faker("zh-CN")
for i in range(20):
sql = """insert into faker_user(username,password,address)
values('%s','%s','%s')""" % (fake.name(), fake.password(special_chars=False), fake.address())
cursor.execute(sql)
conn.commit()
cursor.close()
conn.close()
configparser****模块
2022年7月14日
11:14
配置文件如下：
# ``注释``1; ``注释``2
[section1]`
`k1 = v1`
`k2:v2`
`user=egon`
`age=18`
`is_admin=true`
`salary=31
[section2]`
`k1 = v1
读取
import configparser
config=configparser.ConfigParser()
config.read('a.cfg')
#``查看所有的标题
res=config.sections() #['section1', 'section2']
print(res)
#``查看标题``section1``下所有``key=value``的``key
options=config.options('section1')
print(options) #['k1', 'k2', 'user', 'age', 'is_admin', 'salary']
#``查看标题``section1``下所有``key=value``的``(key,value)``格式
item_list=config.items('section1')
print(item_list) #[('k1', 'v1'), ('k2', 'v2'), ('user', 'egon'), ('age', '18'), ('is_admin', 'true'), ('salary', '31')]
#``查看标题``section1``下``user``的值``=>``字符串格式
val=config.get('section1','user')
print(val) #egon
#``查看标题``section1``下``age``的值``=>``整数格式
val1=config.getint('section1','age')
print(val1) #18
#``查看标题``section1``下``is_admin``的值``=>``布尔值格式
val2=config.getboolean('section1','is_admin')
print(val2) #True
#``查看标题``section1``下``salary``的值``=>``浮点型格式
val3=config.getfloat('section1','salary')
print(val3) #31.0
改写
import configparser
config=configparser.ConfigParser()
config.read('a.cfg',encoding='utf-8')
#``删除整个标题``section2
config.remove_section('section2')
#``删除标题``section1``下的某个``k1``和``k2
config.remove_option('section1','k1')
config.remove_option('section1','k2')
#``判断是否存在某个标题
print(config.has_section('section1'))
#``判断标题``section1``下是否有``user
print(config.has_option('section1',''))
#``添加一个标题
config.add_section('egon')
#``在标题``egon``下添加``name=egon,age=18``的配置
config.set('egon','name','egon')
config.set('egon','age',18) #``报错``,``必须是字符串
#``最后将修改的内容写入文件``,``完成最终的修改
config.write(open('a.cfg','w'))
import configparser
config = configparser.ConfigParser()
config["DEFAULT"] = {'ServerAliveInterval': '45',
'Compression': 'yes',
'CompressionLevel': '9'}
config['bitbucket.org'] = {}
config['bitbucket.org']['User'] = 'hg'
config['topsecret.server.com'] = {}
topsecret = config['topsecret.server.com']
topsecret['Host Port'] = '50022' # mutates the parser
topsecret['ForwardX11'] = 'no' # same here
config['DEFAULT']['ForwardX11'] = 'yes'
with open('example.ini', 'w') as configfile:
config.write(configfile)
Pymysql模块
2022年5月31日
23:04
# 打开数据库连接
db = pymysql.connect("localhost","testuser","test123","TESTDB")
# 使用 cursor() 方法创建一个游标对象
cursorcursor = db.cursor(``cursor=``…)
cursor=pymysql.cursors.DictCurosr``将查询结果以字典返回
# 使用 execute() 方法执行 SQL 查询
cursor.execute(sql)
# 使用 fetchone() 方法获取单条数据.
data = cursor.fetchone()
fetchone():`` ``该方法获取下一个查询结果集。结果集是一个对象
fetchall():`` ``接收全部的返回结果行``.
fetchmany(num``）指定拿几条数据
rowcount:`` ``这是一个只读属性，并返回执行``execute()``方法后影响的行数。
关闭数据库连接要先关闭游标对象
cursorcursor.close()
db.close()
移动
corsor.scroll(1 ,'relative') 相对光标所在位置继续往后移动一位
corsor.scroll(1 ,'absolute') 相对光标起始所在位置继续往后移动一位
调用存储过程
cursor.callproc(procname，args)
procname 是存储过程的名字
args 是存储过程的参数=元组
插入
try:
# ``执行``sql``语句插入单个
cursor.execute(sql)
# ``插入多个
cursor .executemany(sql,[(),(),()``…])
# ``提交到数据库执行
db.commit()
except:
# ``如果发生错误则回滚
db.rollback()
执行事务
事务机制可以确保数据一致性。
事务应该具有4个属性：原子性、一致性、隔离性、持久性。这四个属性通常称为ACID特性。
- 原子性（atomicity）。一个事务是一个不可分割的工作单位，事务中包括的诸操作要么都做，要么都不做。
- 一致性（consistency）。事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。
- 隔离性（isolation）。一个事务的执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。
- 持久性（durability）。持续性也称永久性（permanence），指一个事务一旦提交，它对数据库中数据的改变就应该是永久性的。接下来的其他操作或故障不应该对其有任何影响。
Python DB API 2.0 的事务提供了两个方法 commit 或 rollback。
实例:
# SQL``删除记录语句`
`sql = "DELETE FROM EMPLOYEE WHERE AGE > %s" % (20)`
`try:`
` # ``执行``SQL``语句`
` cursor.execute(sql)`
` # ``向数据库提交`
` db.commit()`
`except:`
` # ``发生错误时回滚`
` db.rollback()
对于支持事务的数据库， 在Python数据库编程中，当游标建立之时，就自动开始了一个隐形的数据库事务。
commit()方法游标的所有更新操作，rollback（）方法回滚当前游标的所有操作。每一个方法都开始了一个新的事务。
错误处理
DB API中定义了一些数据库操作的错误及异常，下表列出了这些错误和异常:
Warning
当有严重警告时触发，例如插入数据是被截断等等。必须是 StandardError 的子类。
Error
警告以外所有其他错误类。必须是 StandardError 的子类。
InterfaceError
当有数据库接口模块本身的错误（而不是数据库的错误）发生时触发。 必须是Error的子类。
DatabaseError
和数据库有关的错误发生时触发。 必须是Error的子类。
DataError
当有数据处理时的错误发生时触发，例如：除零错误，数据超范围等等。 必须是DatabaseError的子类。
OperationalError
指非用户控制的，而是操作数据库时发生的错误。例如：连接意外断开、 数据库名未找到、事务处理失败、内存分配错误等等操作数据库是发生的错误。 必须是DatabaseError的子类。
IntegrityError
完整性相关的错误，例如外键检查失败等。必须是DatabaseError子类。
InternalError
数据库的内部错误，例如游标（cursor）失效了、事务同步失败等等。 必须是DatabaseError子类。
ProgrammingError
程序错误，例如数据表（table）没找到或已存在、SQL语句语法错误、 参数数量错误等等。必须是DatabaseError的子类。
NotSupportedError
不支持错误，指使用了数据库不支持的函数或API等。例如在连接对象上 使用.rollback()函数，然而数据库并不支持事务或者事务已关闭。 必须是DatabaseError的子类。
时间模块
2021年11月18日
15:33
时间的三种格式：
1.时间戳：从1970年到现在的秒数
Time. Time()
主要用于时间间隔计算
2.按照某种格式显示的时间
Time.strftime('%Y-%m-%d')
主要用于展示
3.结构化的时间
Time.localtime()
用于单独获取时间的某一部分
一、time模块
time模块中时间表现的格式主要有三种：
1、timestamp：时间戳，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量
2、struct_time：时间元组，共有九个元素组。
3、format time ：格式化时间，已格式化的结构使时间更具可读性。包括自定义格式和固定格式。
#直接生成时间元组 2>>> time.localtime()
#把时间戳转换为时间元组 5>>> time.localtime(time.time())
#把格式化时间转换为时间元组10>>> time.strptime('2017-4-8 14:12:12','%Y-%m-%d %X')
Time 模块
Time 模块包含了以下内置函数，既有时间处理的，也有转换时间格式的：
| 序号 | 函数及描述 |
|---|---|
| 1 | time.altzone 返回格林威治西部的夏令时地区的偏移秒数。如果该地区在格林威治东部会返回负值（如西欧，包括英国）。对夏令时启用地区才能使用。 |
| 2 | [time.asctime(tupletime]) 接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二18时07分14秒）的24个字符的字符串。 |
| 3 | time.clock( ) 用以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时，比time.time()更有用。 |
| 4 | [time.ctime(secs]) 作用相当于asctime(localtime(secs))，未给参数相当于asctime() |
| 5 | [time.gmtime(secs]) 接收时间戳（1970纪元后经过的浮点秒数）并返回格林威治天文时间下的时间元组t。注：t.tm_isdst始终为0 |
| 6 | [time.localtime(secs]) 接收时间戳（1970纪元后经过的浮点秒数）并返回当地时间下的时间元组t（t.tm_isdst可取0或1，取决于当地当时是不是夏令时）。 |
| 7 | time.mktime(tupletime) 接受时间元组并返回时间戳（1970纪元后经过的浮点秒数）。 |
| 8 | time.sleep(secs) 推迟调用线程的运行，secs指秒数。 |
| 9 | [time.strftime(fmt,tupletime]) 接收以时间元组，并返回以可读字符串表示的当地时间，格式由fmt决定。 |
| 10 | time.strptime(str,fmt='%a %b %d %H:%M:%S %Y') 根据fmt的格式把一个时间字符串解析为时间元组。 |
| 11 | time.time( ) 返回当前时间的时间戳（1970纪元后经过的浮点秒数）。 |
| 12 | time.tzset() 根据环境变量TZ重新初始化时间相关设置。 |
属性`` ``值
tm_year``（年）`` ``比如``2017 `
`tm_mon``（月）`` 1 - 12`
`tm_mday``（日）`` 1 - 31`
`tm_hour``（时）`` 0 - 23`
`tm_min``（分）`` 0 - 59`
`tm_sec``（秒）`` 0 - 61`
`tm_wday``（``weekday``）`` 0 - 6``（``0``表示周日）`
`tm_yday``（一年中的第几天）`` 1 - 366`
`tm_isdst``（是否是夏令时）`` ``默认为``-1
python中时间日期格式化符号：
- %y 两位数的年份表示（00-99）
- %Y 四位数的年份表示（000-9999）
- %m 月份（01-12）
- %d 月内中的一天（0-31）
- %H 24小时制小时数（0-23）
- %I 12小时制小时数（01-12）
- %M 分钟数（00-59）
- %S 秒（00-59）
- %a 本地简化星期名称
- %A 本地完整星期名称
- %b 本地简化的月份名称
- %B 本地完整的月份名称
- %c 本地相应的日期表示和时间表示
- %j 年内的一天（001-366）
- %p 本地A.M.或P.M.的等价符
- %U 一年中的星期数（00-53）星期天为星期的开始
- %w 星期（0-6），星期天为星期的开始
- %W 一年中的星期数（00-53）星期一为星期的开始
- %x 本地相应的日期表示
- %X 本地相应的时间表示
- %Z 当前时区的名称
- %% %号本身
实例
# ``格式化成``2016-03-20 11:45:39``形式``
print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
# ``格式化成``Sat Mar 28 22:24:24 2016``形式``
print time.strftime("%a %b %d %H:%M:%S %Y", time.localtime())
二、datetime模块
datatime模块重新封装了time模块，提供更多接口，提供的类有：date,time,datetime,timedelta,tzinfo。
1、date类
datetime.date(year, month, day)
静态方法和字段
date.max``、``date.min``：``date``对象所能表示的最大、最小日期；`
`date.resolution``：``date``对象表示日期的最小单位。这里是天。`
`date.today()``：返回一个表示当前本地日期的``date``对象；`
`date.fromtimestamp(timestamp)``：根据给定的时间戮，返回一个``date``对象；
方法和属性
- d1 = date(2017,4,8) #date对象（年月日都不能是以0开头 (2017,04,08)错误 ）
- d1.replace(year, month, day)：生成一个新的日期对象，用参数指定的年，月，日代替原有对象中的属性。（原有对象仍保持不变）
- d1.timetuple()：返回日期对应的time.struct_time对象；
- d1.weekday()：返回weekday，如果是星期一，返回0；如果是星期2，返回1，以此类推；
- d1.isoweekday()：返回weekday，如果是星期一，返回1；如果是星期2，返回2，以此类推；
- d1.isocalendar()：返回格式如(year，sum_week，day)的元组；
- d1.isoformat()：返回格式如'YYYY-MM-DD’的字符串；
- d1.strftime(fmt)：和time模块format相同。
可以用来去取时间的年月日
x.year, x.month, x.day
2、time类
datetime.time(hour[`` ``, minute[`` ``, second[`` ``, microsecond[`` ``, tzinfo]`` ``]`` ``]`` ``]`` ``)``
静态方法和字段
time.min``、``time.max``：``time``类所能表示的最小、最大时间
3、datetime类
datetime``相当于``date``和``time``结合起来。
datetime.datetime (year, month, day[ , hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] ] )
静态方法和字段
datetime.today()``：返回一个表示当前本地时间的``datetime``对象；`
`datetime.now([tz])``：返回一个表示当前本地时间的``datetime``对象，如果提供了参数``tz``，则获取``tz``参数所指时区的本地时间；`
`datetime.utcnow()``：返回一个当前``utc``时间的``datetime``对象；``#``格林威治时间`
`datetime.fromtimestamp(timestamp[, tz])``：根据时间戮创建一个``datetime``对象，参数``tz``指定时区信息；`
`datetime.utcfromtimestamp(timestamp)``：根据时间戮创建一个``datetime``对象；`
`datetime.combine(date, time)``：根据``date``和``time``，创建一个``datetime``对象；`
`datetime.strptime(date_string, format)``：将格式字符串转换为``datetime``对象；
阿里云—API
2022年9月19日
21:57
下载
pip install --upgrade aligo
简单使用
<br class="Apple-interchange-newline"><div></div>
"""``快速入门``"""
fromaligoimportAligo
``
if__name__=='__main__':
`` ``ali=Aligo() `` ``# ``第一次使用，会弹出二维码，供扫描登录
``
`` ``user=ali.get_user() `` ``# ``获取用户信息
`` ``print(user.user_name, user.nick_name, user.phone) `` ``# ``打印用户信息
``
`` ``ll=ali.get_file_list() `` ``# ``获取网盘根目录文件列表
`` ``forfileinll: `` ``# ``遍历文件列表
`` ``print(file.file_id, file.name, file.type) `` ``# ``打印文件信息
持久化登录、多帐户登录
ali=Aligo() `` ``# ``第一次使用，会弹出二维码，供扫描登录
网页扫码登录
from aligo import Aligo
# ``提供`` port ``参数即可``, ``之后打开浏览器访问 http://<YOUR_IP>:
ali = Aligo(port=8080)
## 发送登录二维码到邮箱（推荐）
最佳实践：建议将邮箱绑定到微信，这样能实时收到提醒，登录过期后也可以第一时间收到登录请求。
安全性问题：虽然自带公开邮箱，但是他人并不能通过这个获取任何人发送的邮件，所以 防伪字符串 策略是安全的。
```python
from aligo import Aligo
"""
email: 发送扫码登录邮件 ("接收邮件的邮箱地址", "防伪字符串"). 提供此值时，将不再弹出或打印二维码
关于防伪字符串: 为了方便大家使用, aligo 自带公开邮箱, 省去邮箱配置的麻烦.
所以收到登录邮件后, 一定要对比确认防伪字符串和你设置一致才可扫码登录, 否则将导致: 包括但不限于云盘文件泄露.
"""
# 提供 email 参数即可
ali = Aligo(email=('xxx@qq.com', '防伪字符串，可任意字符串'))
```
##
文件夹同步
在线解压缩
支持功能扩展
搜索文件/标签
获取重复文件列表
文件（夹）重命名
文件（夹）上传下载
文件（夹）移动复制
文件（夹）删除恢复
获取文档在线预览接口
文件（夹）分享 保存 收藏
文件（夹）自定义分享（无限制）
获取帐户、云盘（容量）等基本信息
相册 创建 删除 修改 添加文件 获取文件
hashlib模块
2022年7月14日
14:53
1、什么叫hash:
hash``是一种算法（``3.x``里代替了``md5``模块和``sha``模块，主要提供`` SHA1, SHA224, SHA256, SHA384, SHA512 ``，``MD5 ``算法），该算法接受传入的内容，经过运算得到一串``hash``值
# 2、hash值的特点是：
#2.1 ``只要传入的内容一样，得到的``hash``值必然一样``=====>``要用明文传输密码文件完整性校验
#2.2 ``不能由``hash``值返解成内容``=======``》把密码做成``hash``值，不应该在网络传输明文密码
#2.3 ``只要使用的``hash``算法不变，无论校验的内容有多大，得到的``hash``值长度是固定的
hash算法就像一座工厂，工厂接收你送来的原材料（可以用m.update()为工厂运送原材料），经过加工返回的产品就是hash值
import hashlib
m=hashlib.md5()# m=hashlib.sha256()
m.update('hello'.encode('utf8'))
print(m.hexdigest()) #5d41402abc4b2a76b9719d911017c592
m.update('alvin'.encode('utf8'))
print(m.hexdigest()) #92a7e713c30abbb0319fa07da2a5c4af
m2=hashlib.md5()
m2.update('helloalvin'.encode('utf8'))
print(m2.hexdigest()) #92a7e713c30abbb0319fa07da2a5c4af
'''
注意：把一段很长的数据``update``多次，与一次``update``这段长数据，得到的结果一样
但是``update``多次为校验大文件提供了可能。
'''
以上加密算法虽然依然非常厉害，但时候存在缺陷，即：通过撞库可以反解。所以，有必要对加密算法中添加自定义key再来做加密。
import hashlib
# ######## 256 ########
hash = hashlib.sha256('898oaFs09f'.encode('utf8'))
hash.update('alvin'.encode('utf8'))
print (hash.hexdigest())#e79e68f070cdedcfe63eaf1a2e92c83b4cfb1b5c6bc452d214c1b7e77cdfd1c7
动态加盐
"""
在对铭文数据做加密处理过程前添加一些变化的干扰项
"""
import hashlib
# # 1.``先确定算法类型``(md5``普遍使用``)
# md5 = hashlib.md5()
# # 2.``将明文数据传递给``md5``算法``(update``只能接受``bytes``类型数据``)
# md5.update(b'123')
# # ``加盐``(``干扰项``) ``格式为``md5.update(b'``公司内部自定义的盐``')
# md5.update(b'abc') # a906449d5769fa7361d7ecc6aa3f6d28
# # ``动态加盐``(``干扰项``) ``当前时间 用户名的部分`` uuid(``随机字符串``(``永远不会重复``))
# import time
# res1 = str(time.time())
# md5.update(res1.encode('utf8'))
# # ``真实数据
# md5.update(b'123abc')
# # 3.``获取加密之后的密文数据``(``没有规则的一串随机字符串``)
# res = md5.hexdigest()
# print(res) # 68f128bc611544f439426ceea3dae3a7
密文一致性校验
"""
文件不是很大的情况下 可以将所有的文件内容全部加密处理
但是如果文件特别大 全部加密处理相当的耗时耗资源 如何解决???
针对大文件可以使用切片读取的方式
"""
# import hashlib
# md5 = hashlib.md5()
# with open(r'a.txt','rb') as f:
# for line in f:
# md5.update(line)
# real_data = md5.hexdigest()
# print(real_data) # e5f6700043d90045f2eed3bab8e08cfa
# md5 = hashlib.md5()
# with open(r'a.txt','rb') as f:
# for line in f:
# md5.update(line)
# error_data = md5.hexdigest()
# print(error_data) # e5f6700043d90045f2eed3bab8e08cfa
#
# import os
# res = os.path.getsize(r'a.txt')
# read_method = [0,res//4,res//2,res]
logging****模块
2022年7月14日
15:35
日志命名格式：
日志名是区别日志业务归属的一种重要的标识
注：可以在日志字典中定义一个空key，这样当日志字典中找不到key时可以调用这个空key
案例：
'loggers': {
#logging.getLogger(__name__)``拿到的``logger``配置
'': {
'handlers': ['default', 'console'],
# ``这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
'level': 'DEBUG',
# loggers(``第一层日志级别关限制)--->handlers(第二层日志级别关卡限制)
'propagate': False,
# ``默认为True，向上（更高level的logger）传递，通常设置为False即可，否则会一份日志向上层层传递
},
'``专门的采集``': {
'handlers': ['other',],
'level': 'DEBUG',
'propagate': False,
},
},
日志轮转：
日志记录着程序运行过程的关键信息
案例：
'default': {
'level': 'DEBUG',
'class': 'logging.handlers.RotatingFileHandler', # ``保存到文件``,``日志轮转
'formatter': 'standard',
# ``可以定制日志文件路径
# BASE_DIR = os.path.dirname(os.path.abspath(__file__)) # log``文件的目录
# LOG_PATH = os.path.join(BASE_DIR,'a1.log')
'filename': 'a1.log', # ``日志文件
'maxBytes': 1024*1024*5, # ``日志大小`` 5M
'backupCount': 5,``# ``最多保存几份
'encoding': 'utf-8', # ``日志文件的编码，再也不用担心中文``log``乱码了
日志原理
一 日志级别
CRITICAL = 50 #FATAL = CRITICAL
ERROR = 40
WARNING = 30 #WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0 #``不设置
二 默认级别为warning，默认打印到终端
import logging
logging.debug('``调试``debug')
logging.info('``消息``info')
logging.warning('``警告``warn')
logging.error('``错误``error')
logging.critical('``严重``critical')
'''
WARNING:root:``警告``warn
ERROR:root:``错误``error
CRITICAL:root:``严重``critical
'''
三 为logging模块指定全局配置，针对所有logger有效，控制打印到文件中
可在``logging.basicConfig()``函数中通过具体参数来更改``logging``模块默认行为，可用参数有
filename``：用指定的文件名创建``FiledHandler``（后边会具体讲解``handler``的概念），这样日志会被存储在指定的文件中。
filemode``：文件打开方式，在指定了``filename``时使用这个参数，默认值为``“a”``还可指定为``“w”``。
format``：指定``handler``使用的日志显示格式。
datefmt``：指定日期时间格式。
level``：设置``rootlogger``（后边会讲解具体概念）的日志级别
stream``：用指定的``stream``创建``StreamHandler``。可以指定输出到``sys.stderr,sys.stdout``或者文件，默认为``sys.stderr``。若同时列出了``filename``和``stream``两个参数，则``stream``参数会被忽略。
#``格式
%(name)s``：``Logger``的名字，并非用户名，详细查看
%(levelno)s``：数字形式的日志级别
%(levelname)s``：文本形式的日志级别
%(pathname)s``：调用日志输出函数的模块的完整路径名，可能没有
%(filename)s``：调用日志输出函数的模块的文件名
%(module)s``：调用日志输出函数的模块名
%(funcName)s``：调用日志输出函数的函数名
%(lineno)d``：调用日志输出函数的语句所在的代码行
%(created)f``：当前时间，用``UNIX``标准的表示时间的浮 点数表示
%(relativeCreated)d``：输出日志信息时的，自``Logger``创建以 来的毫秒数
%(asctime)s``：字符串形式的当前时间。默认格式是`` “2003-07-08 16:49:45,896”``。逗号后面的是毫秒
%(thread)d``：线程``ID``。可能没有
%(threadName)s``：线程名。可能没有
%(process)d``：进程``ID``。可能没有
%(message)s``：用户输出的消息
#======介绍
可在``logging.basicConfig()``函数中可通过具体参数来更改``logging``模块默认行为，可用参数有
filename``：用指定的文件名创建``FiledHandler``（后边会具体讲解``handler``的概念），这样日志会被存储在指定的文件中。
filemode``：文件打开方式，在指定了``filename``时使用这个参数，默认值为``“a”``还可指定为``“w”``。
format``：指定``handler``使用的日志显示格式。
datefmt``：指定日期时间格式。
level``：设置``rootlogger``（后边会讲解具体概念）的日志级别
stream``：用指定的``stream``创建``StreamHandler``。可以指定输出到``sys.stderr,sys.stdout``或者文件，默认为``sys.stderr``。若同时列出了``filename``和``stream``两个参数，则``stream``参数会被忽略。
format``参数中可能用到的格式化串：
%(name)s``=`` Logger``的名字
%(levelno)s``=`` ``数字形式的日志级别
%(levelname)s``=`` ``文本形式的日志级别
%(pathname)s ``=``调用日志输出函数的模块的完整路径名，可能没有
%(filename)s ``=``调用日志输出函数的模块的文件名
%(module)s ``=``调用日志输出函数的模块名
%(funcName)s ``=``调用日志输出函数的函数名
%(lineno)d ``=``调用日志输出函数的语句所在的代码行
%(created)f ``=``当前时间，用``UNIX``标准的表示时间的浮 点数表示
%(relativeCreated)d ``=``输出日志信息时的，自``Logger``创建以 来的毫秒数
%(asctime)s ``=``字符串形式的当前时间。默认格式是`` “2003-07-08 16:49:45,896”``。逗号后面的是毫秒
%(thread)d ``=``线程``ID``。可能没有
%(threadName)s ``=``线程名。可能没有
%(process)d``=`` ``进程``ID``。可能没有
%(message)s``=``用户输出的消息
#========使用
import logging
logging.basicConfig(filename='access.log',
format='%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S %p',
level=10)
logging.debug('``调试``debug')
logging.info('``消息``info')
logging.warning('``警告``warn')
logging.error('``错误``error')
logging.critical('``严重``critical')
#========结果
access.log``内容``:
2017-07-28 20:32:17 PM - root - DEBUG -test: ``调试``debug
2017-07-28 20:32:17 PM - root - INFO -test: ``消息``info
2017-07-28 20:32:17 PM - root - WARNING -test: ``警告``warn
2017-07-28 20:32:17 PM - root - ERROR -test: ``错误``error
2017-07-28 20:32:17 PM - root - CRITICAL -test: ``严重``critical
part2: ``可以为``logging``模块指定模块级的配置``,``即所有``logger``的配置
四 logging模块的Formatter，Handler，Logger，Filter对象
原理图：``https://pan.baidu.com/s/1skWyTT7
#logger``：产生日志的对象
#Filter``：过滤日志的对象
#Handler``：接收日志然后控制打印到不同的地方，``FileHandler``用来打印到文件中，``StreamHandler``用来打印到终端
#Formatter``对象：可以定制不同的日志格式对象，然后绑定给不同的``Handler``对象使用，以此来控制不同的``Handler``的日志格式
'''
critical=50
error =40
warning =30
info = 20
debug =10
'''
import logging
#1``、``logger``对象：负责产生日志，然后交给``Filter``过滤，然后交给不同的``Handler``输出
logger=logging.getLogger(__file__)
#2``、``Filter``对象：不常用，略
#3``、``Handler``对象：接收``logger``传来的日志，然后控制输出
h1=logging.FileHandler('t1.log') #``打印到文件
h2=logging.FileHandler('t2.log') #``打印到文件
h3=logging.StreamHandler() #``打印到终端
#4``、``Formatter``对象：日志格式
formmater1=logging.Formatter('%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S %p',)
formmater2=logging.Formatter('%(asctime)s : %(message)s',
datefmt='%Y-%m-%d %H:%M:%S %p',)
formmater3=logging.Formatter('%(name)s %(message)s',)
#5``、为``Handler``对象绑定格式
h1.setFormatter(formmater1)
h2.setFormatter(formmater2)
h3.setFormatter(formmater3)
#6``、将``Handler``添加给``logger``并设置日志级别
logger.addHandler(h1)
logger.addHandler(h2)
logger.addHandler(h3)
logger.setLevel(10)
#7``、测试
logger.debug('debug')
logger.info('info')
logger.warning('warning')
logger.error('error')
logger.critical('critical')
五 Logger与Handler的级别
logger``是第一级过滤，然后才能到``handler``，我们可以给``logger``和``handler``同时设置``level``，但是需要注意的是
Logger is also the first to filter the message based on a level — if you set the logger to INFO, and all handlers to DEBUG, you still won't receive DEBUG messages on handlers — they'll be rejected by the logger itself. If you set logger to DEBUG, but all handlers to INFO, you won't receive any DEBUG messages either — because while the logger says "ok, process this", the handlers reject it (DEBUG < INFO).
#``验证
import logging
form=logging.Formatter('%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S %p',)
ch=logging.StreamHandler()
ch.setFormatter(form)
# ch.setLevel(10)
ch.setLevel(20)
l1=logging.getLogger('root')
# l1.setLevel(20)
l1.setLevel(10)
l1.addHandler(ch)
l1.debug('l1 debug')
六 Logger的继承（了解）
import logging
formatter=logging.Formatter('%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S %p',)
ch=logging.StreamHandler()
ch.setFormatter(formatter)
logger1=logging.getLogger('root')
logger1.addHandler(ch)
logger1.setLevel(10)
logger1.debug('log1 debug')
七 应用
"""
logging``配置
"""
import os
import logging.config
# ``定义三种日志输出格式 开始
standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' \
'[%(levelname)s][%(message)s]' #``其中``name``为``getlogger``指定的名字
simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'
id_simple_format = '[%(levelname)s][%(asctime)s] %(message)s'
# ``定义日志输出格式 结束
logfile_dir = os.path.dirname(os.path.abspath(__file__)) # log``文件的目录
logfile_name = 'all2.log' # log``文件名
# ``如果不存在定义的日志目录就创建一个
if not os.path.isdir(logfile_dir):
os.mkdir(logfile_dir)
# log``文件的全路径
logfile_path = os.path.join(logfile_dir, logfile_name)
# log``配置字典
"""
logging配置
"""
import os
# 1、定义三种日志输出格式，日志中可能用到的格式化串如下
# %(name)s Logger的名字
# %(levelno)s 数字形式的日志级别
# %(levelname)s 文本形式的日志级别
# %(pathname)s 调用日志输出函数的模块的完整路径名，可能没有
# %(filename)s 调用日志输出函数的模块的文件名
# %(module)s 调用日志输出函数的模块名
# %(funcName)s 调用日志输出函数的函数名
# %(lineno)d 调用日志输出函数的语句所在的代码行
# %(created)f 当前时间，用UNIX标准的表示时间的浮 点数表示
# %(relativeCreated)d 输出日志信息时的，自Logger创建以 来的毫秒数
# %(asctime)s 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒
# %(thread)d 线程ID。可能没有
# %(threadName)s 线程名。可能没有
# %(process)d 进程ID。可能没有
# %(message)s用户输出的消息
# 2、强调：其中的%(name)s为getlogger时指定的名字
standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' \
'[%(levelname)s][%(message)s]'
simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'
test_format = '%(asctime)s] %(message)s'
# 3、日志配置字典
LOGGING_DIC = {
'version': 1,
'disable_existing_loggers': False,
'formatters': {
'standard': {
'format': standard_format
},
'simple': {
'format': simple_format
},
'test': {
'format': test_format
},
},
'filters': {},
'handlers': {
#``打印到终端的日志
'console': {
'level': 'DEBUG',
'class': 'logging.StreamHandler', # ``打印到屏幕
'formatter': 'simple'
},
#``打印到文件的日志``,``收集``info``及以上的日志
'default': {
'level': 'DEBUG',
'class': 'logging.handlers.RotatingFileHandler', # ``保存到文件``,``日志轮转
'formatter': 'standard',
# ``可以定制日志文件路径
# BASE_DIR = os.path.dirname(os.path.abspath(__file__)) # log``文件的目录
# LOG_PATH = os.path.join(BASE_DIR,'a1.log')
'filename': 'a1.log', # ``日志文件
'maxBytes': 1024*1024*5, # ``日志大小`` 5M
'backupCount': 5,
'encoding': 'utf-8', # ``日志文件的编码，再也不用担心中文``log``乱码了
},
'other': {
'level': 'DEBUG',
'class': 'logging.FileHandler', # ``保存到文件
'formatter': 'test',
'filename': 'a2.log',
'encoding': 'utf-8',
},
},
'loggers': {
#logging.getLogger(__name__)``拿到的``logger``配置
'': {
'handlers': ['default', 'console'], # ``这里把上面定义的两个``handler``都加上，即``log``数据既写入文件又打印到屏幕
'level': 'DEBUG', # loggers(``第一层日志级别关限制``)--->handlers(``第二层日志级别关卡限制``)
'propagate': False, # ``默认为``True``，向上（更高``level``的``logger``）传递，通常设置为``False``即可，否则会一份日志向上层层传递
},
'``专门的采集``': {
'handlers': ['other',],
'level': 'DEBUG',
'propagate': False,
},
},
}
def load_my_logging_cfg():
logging.config.dictConfig(LOGGING_DIC) # ``导入上面定义的``logging``配置
logger = logging.getLogger(__name__) # ``生成一个``log``实例
logger.info('It works!') # ``记录该文件的运行状态
if __name__ == '__main__':
load_my_logging_cfg()
"""
MyLogging Test
"""
import time
import logging
import my_logging # ``导入自定义的``logging``配置
logger = logging.getLogger(__name__) # ``生成``logger``实例
def demo():
logger.debug("start range... time:{}".format(time.time()))
logger.info("``中文测试开始。。。``")
for i in range(10):
logger.debug("i:{}".format(i))
time.sleep(0.2)
else:
logger.debug("over range... time:{}".format(time.time()))
logger.info("``中文测试结束。。。``")
if __name__ == "__main__":
my_logging.load_my_logging_cfg() # ``在你程序文件的入口加载自定义``logging``配置
demo()
注意注意注意：
#1``、有了上述方式我们的好处是：所有与``logging``模块有关的配置都写到字典中就可以了，更加清晰，方便管理
#2``、我们需要解决的问题是：
1``、从字典加载配置：``logging.config.dictConfig(settings.LOGGING_DIC)
2``、拿到``logger``对象来产生日志
logger``对象都是配置到字典的``loggers ``键对应的子字典中的
``按照我们对``logging``模块的理解，要想获取某个东西都是通过名字，也就是``key``来获取的
``于是我们要获取不同的``logger``对象就是
logger=logging.getLogger('loggers``子字典的``key``名``')
``但问题是：如果我们想要不同``logger``名的``logger``对象都共用一段配置，那么肯定不能在``loggers``子字典中定义``n``个``key
'loggers': {
'l1': {
'handlers': ['default', 'console'], #
'level': 'DEBUG',
'propagate': True, # ``向上（更高``level``的``logger``）传递
},
'l2: {
'handlers': ['default', 'console' ],
'level': 'DEBUG',
'propagate': False, # ``向上（更高``level``的``logger``）传递
},
'l3': {
'handlers': ['default', 'console'], #
'level': 'DEBUG',
'propagate': True, # ``向上（更高``level``的``logger``）传递
},
}
#``我们的解决方式是，定义一个空的``key
'loggers': {
'': {
'handlers': ['default', 'console'],
'level': 'DEBUG',
'propagate': True,
},
}
这样我们再取``logger``对象时
logging.getLogger(__name__)``，不同的文件``__name__``不同，这保证了打印日志时标识信息不同，但是拿着该名字去``loggers``里找``key``名时却发现找不到，于是默认使用``key=''``的配置
另外一个django的配置，瞄一眼就可以，跟上面的一样
#logging_config.py
LOGGING = {
'version': 1,
'disable_existing_loggers': False,
'formatters': {
'standard': {
'format': '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]'
'[%(levelname)s][%(message)s]'
},
'simple': {
'format': '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'
},
'collect': {
'format': '%(message)s'
}
},
'filters': {
'require_debug_true': {
'()': 'django.utils.log.RequireDebugTrue',
},
},
'handlers': {
#``打印到终端的日志
'console': {
'level': 'DEBUG',
'filters': ['require_debug_true'],
'class': 'logging.StreamHandler',
'formatter': 'simple'
},
#``打印到文件的日志``,``收集``info``及以上的日志
'default': {
'level': 'INFO',
'class': 'logging.handlers.RotatingFileHandler', # ``保存到文件，自动切
'filename': os.path.join(BASE_LOG_DIR, "xxx_info.log"), # ``日志文件
'maxBytes': 1024 * 1024 * 5, # ``日志大小`` 5M
'backupCount': 3,
'formatter': 'standard',
'encoding': 'utf-8',
},
#``打印到文件的日志``:``收集错误及以上的日志
'error': {
'level': 'ERROR',
'class': 'logging.handlers.RotatingFileHandler', # ``保存到文件，自动切
'filename': os.path.join(BASE_LOG_DIR, "xxx_err.log"), # ``日志文件
'maxBytes': 1024 * 1024 * 5, # ``日志大小`` 5M
'backupCount': 5,
'formatter': 'standard',
'encoding': 'utf-8',
},
#``打印到文件的日志
'collect': {
'level': 'INFO',
'class': 'logging.handlers.RotatingFileHandler', # ``保存到文件，自动切
'filename': os.path.join(BASE_LOG_DIR, "xxx_collect.log"),
'maxBytes': 1024 * 1024 * 5, # ``日志大小`` 5M
'backupCount': 5,
'formatter': 'collect',
'encoding': "utf-8"
}
},
'loggers': {
#logging.getLogger(__name__)``拿到的``logger``配置
'': {
'handlers': ['default', 'console', 'error'],
'level': 'DEBUG',
'propagate': True,
},
#logging.getLogger('collect')``拿到的``logger``配置
'collect': {
'handlers': ['console', 'collect'],
'level': 'INFO',
}
},
}
# -----------
# ``用法``:``拿到俩个``logger
logger = logging.getLogger(__name__) #``线上正常的日志
collect_logger = logging.getLogger("collect") #``领导说``,``需要为领导们单独定制领导们看的日志
应用
paramiko模块
2022年7月31日
19:18
介绍
Paramiko是用python语言写的一个模块，远程连接到Linux服务器，查看上面的日志状态，批量配置远程服务器，文件上传，文件下载等
paramiko是一个基于SSH用于连接远程服务器并执行相关操作（SSHClient和SFTPClinet,即一个是远程连接，一个是上传下载服务），使用该模块可以对远程服务器进行命令或文件操作，值得一说的是，fabric和ansible内部的远程管理就是使用的paramiko来现实
ssh是一个协议，OpenSSH是其中一个开源实现，paramiko是Python的一个库，实现了SSHv2协议(底层使用cryptography)。
有了Paramiko以后，我们就可以在Python代码中直接使用SSH协议对远程服务器执行操作，而不是通过ssh命令对远程服务器进行操作。
Paramiko介绍
paramiko包含两个核心组件：SSHClient和SFTPClient。
- SSHClient的作用类似于Linux的ssh命令，是对SSH会话的封装，该类封装了传输(Transport)，通道(Channel)及SFTPClient建立的方法(open_sftp)，通常用于执行远程命令。
- SFTPClient的作用类似与Linux的sftp命令，是对SFTP客户端的封装，用以实现远程文件操作，如文件上传、下载、修改文件权限等操作。
# Paramiko中的几个基础名词：
1``、``Channel``：是一种类``Socket``，一种安全的``SSH``传输通道；
2``、``Transport``：是一种加密的会话，使用时会同步创建了一个加密的``Tunnels(``通道``)``，这个``Tunnels``叫做``Channel``；
3``、``Session``：是``client``与``Server``保持连接的对象，用``connect()/start_client()/start_server()``开始会话。
Paramiko的基本使用
SSHClient常用的方法介绍
connect()：实现远程服务器的连接与认证，对于该方法只有hostname是必传参数。
常用参数
hostname ``连接的目标主机`
`port=SSH_PORT ``指定端口`
`username=None ``验证的用户名`
`password=None ``验证的用户密码`
`pkey=None ``私钥方式用于身份验证`
`key_filename=None ``一个文件名或文件列表，指定私钥文件`
`timeout=None ``可选的``tcp``连接超时时间`
`allow_agent=True, ``是否允许连接到``ssh``代理，默认为``True ``允许`
`look_for_keys=True ``是否在``~/.ssh``中搜索私钥文件，默认为``True ``允许`
`compress=False, ``是否打开压缩
set_missing_host_key_policy()：
设置远程服务器没有在know_hosts文件中记录时的应对策略。目前支持三种策略：
AutoAddPolicy 自动添加主机名及主机密钥到本地HostKeys对象，不依赖load_system_host_key的配置。即新建立ssh连接时不需要再输入yes或no进行确认
WarningPolicy 用于记录一个未知的主机密钥的python警告。并接受，功能上和AutoAddPolicy类似，但是会提示是新连接
RejectPolicy 自动拒绝未知的主机名和密钥，依赖load_system_host_key的配置。此为默认选项
exec_command()：
在远程服务器执行Linux命令的方法。
open_sftp()：
在当前``ssh``会话的基础上创建一个``sftp``会话。该方法会返回一个``SFTPClient``对象。
# ``利用``SSHClient``对象的``open_sftp()``方法，可以直接返回一个基于当前连接的``sftp``对象，可以进行文件的上传等操作``. sftp=client.open_sftp()sftp.put('local.txt','remote.txt'
SSHClient常用的方法举例
import paramiko
# ``实例化``SSHClient
ssh_client = paramiko.SSHClient()
# ``自动添加策略，保存服务器的主机名和密钥信息，如果不添加，那么不再本地``know_hosts``文件中记录的主机将无法连接 ，此方法必须放在``connect``方法的前面
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
# ``连接``SSH``服务端，以用户名和密码进行认证 ，调用``connect``方法连接服务器
ssh_client.connect(hostname='192.168.137.105', port=22, username='root', password='123456')
# ``打开一个``Channel``并执行命令 `` ``结果放到``stdout``中，如果有错误将放到``stderr``中
stdin, stdout, stderr = ssh_client.exec_command('df -hT ')
# stdout ``为正确输出，``stderr``为错误输出，同时是有``1``个变量有值 `` # ``打印执行结果 `` print(stdout.read().decode('utf-8'))
# ``关闭``SSHClient``连接
ssh_client.close()
密钥连接方式
# ``配置私人密钥文件位置
private = paramiko.RSAKey.from_private_key_file('/root/.ssh/id_rsa')
#``实例化``SSHClient
ssh_client = paramiko.SSHClient()
#``自动添加策略，保存服务器的主机名和密钥信息，如果不添加，那么不再本地``know_hosts``文件中记录的主机将无法连接
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
#``连接``SSH``服务端，以用户名和密码进行认证
ssh_client.connect(
hostname='192.168.137.100',
port=22,
username='root',
pkey=private
)
SFTPClient常用方法介绍
SFTPCLient作为一个sftp的客户端对象，根据ssh传输协议的sftp会话，实现远程文件操作，如上传、下载、权限、状态
from_transport(cls,t) ``创建一个已连通的``SFTP``客户端通道
put(localpath, remotepath, callback=None, confirm=True) ``将本地文件上传到服务器
参数``confirm``：是否调用``stat()``方法检查文件状态，返回``ls -l``的结果
get(remotepath, localpath, callback=None) ``从服务器下载文件到本地
mkdir() ``在服务器上创建目录
remove() ``在服务器上删除目录
rename() ``在服务器上重命名目录
stat() ``查看服务器文件状态
listdir() ``列出服务器目录下的文件
SFTPClient常用方法举例
import paramiko
# ``实例化一个``transport``对象
tran = paramiko.Transport(('192.168.137.100', 22))
# ``连接``SSH``服务端，使用``password
tran.connect(username="root", password='123456')
# ``或使用
# ``配置私人密钥文件位置
private = paramiko.RSAKey.from_private_key_file('/root/.ssh/id_rsa')
# ``连接``SSH``服务端，使用``pkey``指定私钥
tran.connect(username="root", pkey=private)
# ``获取``SFTP``实例
sftp = paramiko.SFTPClient.from_transport(tran)
# ``设置上传的本地``/``远程文件路径
local_path = "/home/1.txt"
remote_path = "/tmp/1.txt"
# ``执行上传动作
sftp.put(local_path, remote_path)
# ``执行下载动作
sftp.get(remote_path, local_path)
# ``关闭``Transport``通道
tran.close()
openpyxl模块
2022年7月31日
14:08
方法
打开方式
wb=Workbook()#``新建``Excel``工作簿
wb=load_workbook("data\``领料单（每日）``.xlsx") ``# ``打开存在的表格
保存方式
wb.save("data\``领料单（每日）``-``更改后``.xlsx") # ``保存表格
获取工作表的方式
sheet_names=wb.get_sheet_names()`` # ``获取每个表的名字
ws=wb[sheet_name] # ``获取指定的表格
ws=wb.active #``读取活动工作表
设置数据的方式
直接指定单元格
ws['A4'].value="``零件测试领料单``" #``直接将``A4``单元格的值改为需要的值
ws['A4'].value ``获取数据
指定行列
ws.cell(``行``,column=``列``,value=``值``)
ws.cell(``行``,``列``).value ``# ``获取值
设置样式
第一步导包
from openpyxl.styles import Border, Side, PatternFill, Font, GradientFill, Alignment
第二步获取单元格
c = ws.cell(row=row_number,column=col_number)
第三部设置
c.font = Font(name='Arial'``，``size=10) # ``设置字体 和大小
c.border = Border(top=thin, left=thin, right=thin, bottom=thin) # ``设置边框
c.alignment = Alignment(horizontal="left", vertical="center") ``# ``设置对其
案例
from openpyxl import load_workbook
wb=load_workbook("data\``领料单（每日）``.xlsx") ``# ``打开存在的表格
sheet_names=wb.get_sheet_names()#``获得工作簿的所有工作表名
for sheet_name in sheet_names:#``遍历每个工作表，更改``A4``单元格的数据
ws=wb[sheet_name] # ``获取指定的表格
ws['A4'].value="``零件测试领料单``" #``直接将``A4``单元格的值改为需要的值
wb.save("data\``领料单（每日）``-``更改后``.xlsx") # ``保存表格
Python-docx模块
2022年10月9日
15:10
写word
案例一：
# -*- coding: utf-8 -*-
# All Rights Reserved
# @Time : 2022/10/914:31
# @Author : Small Fu
# @Email : 2737454073@qq.com
# @File : word_xiaoy.py
__author__ = 'Small Fu'
from docx import Document # ``初始化``word
from docx.enum.text import WD_PARAGRAPH_ALIGNMENT # ``段落对其
from docx.shared import Pt # ``字体磅数
from docx.oxml.ns import qn # ``设置中文格式
import time
price = input("``今日价格：``")
# ``这是客户
customer_list = [f"``客户``{i}" for i in range(10)]
time_sameDay = time.strftime("%Y``年`` %m``月`` %d``日``", time.localtime())
# ``开始设置
for customer in customer_list:
doc = Document()
# ``设置基础字体``,``这个值设置英文和数字
doc.styles["Normal"].font.name = u"``宋体``"
# ``增加中文支持
doc.styles["Normal"]._element.rPr.rFonts.set(qn("w:eastAsia"), u"``宋体``")
# ``初始化一个段落
p1 = doc.add_paragraph()
# ``设置文字对齐居中，没有的话默认左对齐
p1.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
# ``添加第一段的内容
run1 = p1.add_run(f"``关于下达``{time_sameDay}``产品价格通知``")
# ``设置这一段的字体是微软雅黑西文
run1.font.name = "``微软雅黑``"
# ``设置中文
run1._element.rPr.rFonts.set(qn("w:eastAsia"), u"``宋体``")
# ``设置字体大小
run1.font.size = Pt(21)
# ``是否加粗，默认不加粗，``False
run1.font.bold = True
# ``设置这一段前面的字体大小和后面的
p1.space_after = Pt(5)
p1.space_before = Pt(5)
# ``第二段内容
p2 = doc.add_paragraph()
# ``这里是添加尊称
run2 = p2.add_run(f"{customer}: \n ``您好``")
# ``设置这一段的字体是微软雅黑西文
run2.font.name = "``仿宋``_GB2312"
# ``设置中文
run2._element.rPr.rFonts.set(qn("w:eastAsia"), u"``仿宋``_GB2312 ")
# ``设置字体大小
run2.font.size = Pt(16)
# ``是否加粗，默认不加粗，``False
run2.font.bold = True
# ``第三段内容
p3 = doc.add_paragraph()
# ``这里是添加尊称
run3 = p3.add_run(f" ``根据公司安排，为提供优质客户需求，我单位拟定了今日黄金价格为``{price}``元，特此通知``")
# ``设置这一段的字体是微软雅黑西文
run3.font.name = "``仿宋``_GB2312"
# ``设置中文
run3._element.rPr.rFonts.set(qn("w:eastAsia"), u"``仿宋``_GB2312 ")
# ``设置字体大小
run3.font.size = Pt(16)
# ``是否加粗，默认不加粗，``False
run3.font.bold = True
# ``第四段内容
p4 = doc.add_paragraph()
# ``这里是添加尊称
run4 = p4.add_run(" ``联系人：小符`` ``电话：``176XXXXXX44 ")
# ``设置这一段的字体是微软雅黑西文
run4.font.name = "``仿宋``_GB2312"
# ``设置中文
run4._element.rPr.rFonts.set(qn("w:eastAsia"), u"``仿宋``_GB2312 ")
# ``设置字体大小
run4.font.size = Pt(16)
# ``是否加粗，默认不加粗，``False
run4.font.bold = True
# ``保存
doc.save(f"{customer}-``价格通知``.docx")
案例二图片添加
# -*- coding: utf-8 -*-
# All Rights Reserved
# @Time : 2022/10/915:13
# @Author : Small Fu
# @Email : 2737454073@qq.com
# @File : xiaofu-img.py
__author__ = 'Small Fu'
from docx import Document # ``初始化``word
from docx.enum.text import WD_PARAGRAPH_ALIGNMENT # ``段落对其
from docx.shared import Pt # ``字体磅数
from docx.oxml.ns import qn # ``设置中文格式
from docx.shared import Inches # ``图片尺寸
import time
price = input("``今日价格：``")
# ``这是客户
customer_list = [f"``客户``{i}" for i in range(10)]
time_sameDay = time.strftime("%Y``年`` %m``月`` %d``日``", time.localtime())
# ``开始设置
for customer in customer_list:
doc = Document()
# ``设置基础字体``,``这个值设置英文和数字
doc.styles["Normal"].font.name = u"``宋体``"
# ``增加中文支持
doc.styles["Normal"]._element.rPr.rFonts.set(qn("w:eastAsia"), u"``宋体``")
# ``文档添加图片``width=Inches(6) ``这里设置的是``6``英寸
doc.add_picture("./img_1.png",width=Inches(6))
# ``初始化一个段落
p1 = doc.add_paragraph()
# ``设置文字对齐居中，没有的话默认左对齐
p1.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
# ``添加第一段的内容
run1 = p1.add_run(f"``关于下达``{time_sameDay}``产品价格通知``")
# ``设置这一段的字体是微软雅黑西文
run1.font.name = "``微软雅黑``"
# ``设置中文
run1._element.rPr.rFonts.set(qn("w:eastAsia"), u"``宋体``")
# ``设置字体大小
run1.font.size = Pt(21)
# ``是否加粗，默认不加粗，``False
run1.font.bold = True
# ``设置这一段前面的字体大小和后面的
p1.space_after = Pt(5)
p1.space_before = Pt(5)
# ``第二段内容
p2 = doc.add_paragraph()
# ``这里是添加尊称
run2 = p2.add_run(f"{customer}: \n ``您好``")
# ``设置这一段的字体是微软雅黑西文
run2.font.name = "``仿宋``_GB2312"
# ``设置中文
run2._element.rPr.rFonts.set(qn("w:eastAsia"), u"``仿宋``_GB2312 ")
# ``设置字体大小
run2.font.size = Pt(16)
# ``是否加粗，默认不加粗，``False
run2.font.bold = True
# ``第三段内容
p3 = doc.add_paragraph()
# ``这里是添加尊称
run3 = p3.add_run(" ``根据公司安排，为提供优质客户服务，我单位现将价格通知如下：`` ")
# ``设置这一段的字体是仿宋``_GB2312``西文
run3.font.name = "``仿宋``_GB2312"
# ``设置中文
run3._element.rPr.rFonts.set(qn("w:eastAsia"), u"``仿宋``_GB2312 ")
# ``设置字体大小
run3.font.size = Pt(16)
# ``是否加粗，默认不加粗，``False
run3.font.bold = True
# ``添加表格``row=``行``,cols=``列``,style=``样式
table = doc.add_table(rows=3,cols=3,style="Table Grid")
# ``这里是从第``0``行``0``列合并到``0``行``2``列
table.cell(0,0).merge(table.cell(0,2))
# ``添加到合并的单元格
table_run1 = table.cell(0,0).paragraphs[0].add_run("xx``商品报表``")
table_run1.font.name = u"``隶书``"
# ``设置中文
table_run1._element.rPr.rFonts.set(qn("w:eastAsia"), u"``隶书`` ")
# ``设置居中
table.cell(0,0).paragraphs[0].alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
# ``添加
table.cell(1,0).text="``日期``"
table.cell(1,1).text="``价格``"
table.cell(1,2).text="``备注``"
table.cell(2,0).text=time_sameDay
table.cell(2,1).text=set(price)
table.cell(2,2).text=""
# ``第四段内容
p4 = doc.add_paragraph()
# ``这里是添加尊称
run4 = p4.add_run(" ``联系人：小符`` ``电话：``176XXXXXX44 ")
# ``设置这一段的字体是微软雅黑西文
run4.font.name = "``仿宋``_GB2312"
# ``设置中文
run4._element.rPr.rFonts.set(qn("w:eastAsia"), u"``仿宋``_GB2312 ")
# ``设置字体大小
run4.font.size = Pt(16)
# ``是否加粗，默认不加粗，``False
run4.font.bold = True
# ``下一页添加一个广告
# ``插入分页符
doc.add_page_break()
# ``文档添加图片``width=Inches(6) ``这里设置的是``6``英寸
doc.add_picture("./img_1.png",width=Inches(6))
doc.save(f"{customer}-``价格图片表格通知``.docx")
读word
案例一：读纯文本
# -*- coding: utf-8 -*-
# All Rights Reserved
# @Time : 2022/10/915:54
# @Author : Small Fu
# @Email : 2737454073@qq.com
# @File : ``读取简单``word``纯文本``.py
__author__ = 'Small Fu'
from docx import Document
doc = Document("``地址``.docx")
all_paragraphs = doc.paragraphs # ``读取所有的段落
for paragraphs in all_paragraphs:
print(paragraphs.text)
案例二：读取表格文本
# -*- coding: utf-8 -*-
# All Rights Reserved
# @Time : 2022/10/916:02
# @Author : Small Fu
# @Email : 2737454073@qq.com
# @File : ``读取表格文本``.py
__author__ = 'Small Fu'
from docx import Document
doc = Document("``路径``")
all_tables = doc.tables
for tables in all_tables:
for row in tables.rows:
for cell in row.cells:
print(cell.text)
案例三：读取表格嵌套纯文本
# -*- coding: utf-8 -*-
# All Rights Reserved
# @Time : 2022/10/916:06
# @Author : Small Fu
# @Email : 2737454073@qq.com
# @File : ``读取表格嵌套纯文本``.py
__author__ = 'Small Fu'
import zipfile
word = zipfile.ZipFile("``路径``")
xml = word.read("word/document.xml").decode('utf-8')
xml_list = xml.split("<w:t>")
text_file = []
for xml in xml_list:
if xml.find("</w:t>")+1:
text_file.append(
xml[:xml.find("</w:t>")]
)
else:
pass
text_file = "".join(text_file)
格式化word：函数式
案例一：
# -*- coding: utf-8 -*-
# All Rights Reserved
# @Time : 2022/10/916:23
# @Author : Small Fu
# @Email : 2737454073@qq.com
# @File : ``函数式模板``.py
__author__ = 'Small Fu'
from docx import Document # ``初始化``word
from docx.enum.text import WD_PARAGRAPH_ALIGNMENT # ``段落对其
from docx.shared import Pt # ``字体磅数
from docx.oxml.ns import qn # ``设置中文格式
doc = Document()
doc.styles["Normal"].font.name = u"``黑体``"
doc.styles["Normal"]._element.rPr.rFonts.set(qn("w:eastAsia"), u"``黑体``")
def add_context(context):
p1 = doc.add_paragraph()
p1.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
# ``添加内容
run1 = p1.add_run(str(context))
# ``设置这一段的字体是微软雅黑西文
run1.font.size = Pt(16)
# ``设置这一段前面的字体大小和后面的
p1.space_after = Pt(5)
p1.space_before = Pt(5)
word转pdf
tqdm模块
2021年12月2日
14:59
Tqdm
Tqdm 是一个快速，可扩展的Python进度条，可以在 Python 长循环中添加一个进度提示信息，用户只需要封装任意的迭代器 tqdm(iterator)。
安装
pip install tqdm
使用
#for I in tqdm(range(100)):
#time.sleep(0.0001)
#
#
#for j in trange(100):
#time.sleep(0.1)
两个效果是一样的
如果是遍历列表之类的可以用
# alist=list('letters')
# bar=tqdm(alist)
# for letter in bar:
bar.set_description(f"Nowget{letter}")
# pbar=tqdm(["a","b","c","d"])
# for char inp bar:
# time.sleep(1)
# pbar.set_description("Processing%s"%char)
tqdm模块参数说明
class tqdm(object):
"""
Decorate an iterable object, returning an iterator which acts exactly
like the original iterable, but prints a dynamically updating
progressbar every time a value is requested.
"""
def __init__(self,
iterable=None,
desc=None,
total=None,
leave=False,
file=sys.stderr,
ncols=None,
mininterval=0.1,
maxinterval=10.0,
miniters=None,
ascii=None,
disable=False,
unit='it',
unit_scale=False,
dynamic_ncols=False,
smoothing=0.3,
nested=False,
bar_format=None,
initial=0,
gui=False
):
iterable: ``可迭代的对象``, ``在手动更新时不需要进行设置
desc: ``字符串``, ``左边进度条描述文字
total: ``总的项目数
leave: bool``值``, ``迭代完成后是否保留进度条
file: ``输出指向位置``, ``默认是终端``, ``一般不需要设置
ncols: ``调整进度条宽度``, ``默认是根据环境自动调节长度``, ``如果设置为``0, ``就没有进度条``, ``只有输出的信息
unit: ``描述处理项目的文字``, ``默认是``'it', ``例如``: 100 it/s, ``处理照片的话设置为``'img' ,``则为`` 100 img/s
unit_scale: ``自动根据国际标准进行项目处理速度单位的换算``, ``例如`` 100000 it/s >> 100k it/s
爬虫下载文件结合tqdm
from tqdm import tqdm
import requests
url='https://dldir1.qq.com/qqtv/TencentVideo11.14.4043.0.exe'
response=requests.get(url,stream=True) # ``设``stream``流传输方式为真
print(response.headers) # ``打印查看基本头信息
data_size=int(response.headers['Content-Length'])/1024/1024 # ``字节``/1024/1024=MB
with open('``测试``.exe','wb') as f:
for data in tqdm(iterable=response.iter_content(1024*1024),total=data_size,desc='``正在下载``',unit='MB'):
f.write(data)
因此我将iter_content(chunk_size)->chunk_size理解为一个列表的容量，
而iterable=response.iter_content(1024*1024)理解为分割字符串的函数，
将response.content分割为每个元素的长度是1024*1024大小的列表，在对每个部分进行下载。
这只是助于理解chunk_size的一个方法
而response.iter_content 是流传输(简单说就是边下载边写入磁盘),如果将chunk_size设置的很小，意味着每次
下载和存在很小的一部分，下载的速度也会很慢,如果设置的很大，则进度条的进度会错乱，因此我们在确定chunk_size
大小的时候应该对应文件大小，data_size除以多少，chunk_size就乘以多少，才能使进度条对应。
# -*- coding: utf-8 -*-
# All Rights Reserved
# @Time : 2022/6/29 18:32
# @Author : ``符青
# @Email : 2737454073@qq.com
# @File : aa.py
# @Software: PyCharm
import pprint
import requests
from tqdm import tqdm
url = '`https://v3-default.ixigua.com/37179974c244973c87813da84e13ff61/62bc51c7/video/tos/cn/tos-cn-v-0064/25755a2b84b24deeaa48d8e3407b0baa/?libvio.cc&filename=1.mp4`'
response = requests.get(url, stream=True) # ``采用流处理传输输入
pprint.pprint(response.headers)
# ``查看数据大小
data_sice = int(response.headers['Content-Length'])
print(data_sice)
rr = tqdm(
total=data_sice,
desc='``下载恰恰丝滑``',
unit='mb',
unit_scale=True
)
with open('./``恰恰丝滑``.mp4', 'wb+') as ff:
for i in response.iter_content(1024*1024):
rr.update(len(i))
ff.write(i)
ff.close()
pyautogui模块
2022年7月20日
0:46
介绍
自动 防故障功能
pyautogui.FAILSAFE =False
默认这项功能为``True, ``这项功能意味着：当鼠标的指针在屏幕的最坐上方，程序会报错；目的是为了防止程序无法停止；
停顿功能
pyautogui.PAUSE = 1
意味着所有``pyautogui``的指令都要暂停一秒；其他指令不会停顿；这样做，可以防止键盘鼠标操作太快；
鼠标操作函数
操作鼠标点击的函数。
| 函数 | 简单说明 |
|---|---|
| move(x,y)、 moveTo(x,y) | 移动鼠标，前者移动相对位置，后者移动到指定位置 |
| click(x,y)、doubleClick、rightClick | 单击/双击/右击，无参版本在当前位置点击鼠标 |
| drag(x,y)、dragTo(x,y) | 拖动鼠标 |
| mouseDown、mouseUp | 按下按键，松开按键 |
| scroll | 向下滚动鼠标滚轮的函数 |
键盘操作函数
操作键盘按键的函数。
| 函数 | 简介 |
|---|---|
| press(‘left’,press=3) | |
| hotkey(‘ctrl’,‘s’) | 按下Ctrl+S组合键 |
| keyDown、keyUp | 按下和松开键盘按键 |
提示框函数
PyAutoGUI可以显示提示框，这时候程序会暂停运行，直到用户点击提示框。
| 函数 | 简介 |
|---|---|
| alert(text=’’,title=’’,button=[‘OK’,‘Cancle’]) | 显示警告对话框 |
| confirm() | 显示确认对话框 |
| prompt() | 显示提示对话框 |
| password() | 显示密码输入对话框 |
屏幕截图和定位函数
截取屏幕的函数，也可以从屏幕中寻找匹配的图片，并返回其坐标。你可以事先保存一些按钮的截图，然后通过这种方式定位按钮的位置，然后点击。
| 函数 | 简介 |
|---|---|
| screenshot(‘image.png’) | 保存截图并返回截图，无参版本直接返回截图不保存 |
| center(‘image.png’) | 从屏幕上寻找图片位置，返回框位置 |
| locateOnScreen(‘img’) | 从屏幕寻找图片位置，直接返回坐标 |
Pil模块
2022年6月2日
23:47
PIL``功能介绍与安装
PIL``，全称``Python Image Library``，主要作用是图像处理，可用于图片剪切、粘贴、缩放、镜像、水印、颜色块、滤镜、图像格式转换、色场空间转换、验证码、旋转图像、图像增强、直方图处理、插值和滤波等功能。不过只支持到``Python 2.7``。``Pillow``是``PIL``的一个派生分支，但如今已经发展成为比``PIL``本身更具活力的图像处理库。我们需要安装的就是``Pillow``。
PIL``具体用途：图像归档``(Image Archives)``。``PIL``非常适合于图像归档以及图像的批处理任务。你可以使用``PIL``创建缩略图，转换图像格式，打印图像等等。
``图像展示``(Image Display)``。``PIL``较新的版本支持包括``Tk PhotoImage``，``BitmapImage``还有``Windows DIB``等接口。``PIL``支持众多的``GUI``框架接口，可以用于图像展示。
``图像处理``(Image Processing)``。``PIL``包括了基础的图像处理函数，包括对点的处理，使用众多的卷积核``(convolution kernels)``做过滤``(filter),``还有颜色空间的转换。``PIL``库同样支持图像的大小转换，图像旋转，以及任意的仿射变换。``PIL``还有一些直方图的方法，允许你展示图像的一些统计特性。这个可以用来实现图像的自动对比度增强，还有全局的统计分析等。
pip install Pillow
PIL的基本操作
from PIL import Image
# 1.``打开图片
img = Image.open("image/10.png")
# 2.``显示图片``(``执行显示图片后线程会中断，关闭图像后恢复``)
img.show()
# 3.``保存图片
img.save("image/xiaomai.png")
我在尝试的过程中发现，``png``格式的图片保存为``jpg``格式时会报错：``OSError: cannot write mode RGBA as JPEG``，经过查阅资料发现错误原因主要是因为``PNG``格式和``JPG``格式图片的通道数不同。
PNG``是四通道：``RGBA``意思是红色，绿色，蓝色，``Alpha``的色彩空间，``Alpha``指透明度
JPG``是三通道：``RGB``意思是红色，绿色，蓝色
所以，``PNG``格式图片要保存成``JPG``格式就要丢弃``A``通道：
from PIL import Image
# 1.``打开图片
img = Image.open("image/10.png")
# 2.``显示图片``(``执行显示图片后线程会中断，关闭图像后恢复``)
img.show()
# 3.``保存图片
img = img.convert("RGB")
img.save("image/xiaomai.jpg")
下面是图片旋转的代码：
from PIL import Image
# 1.``打开图片
img = Image.open("pli/7.png")
# 2.``水平翻转
img1 = img.transpose(Image.FLIP_LEFT_RIGHT)
# 3.``保存图片
img1.save("pli/1.png")
# 4.``垂直翻转
img2 = img.rotate(180)
# 5.``保存照片
img2.save("pli/2.png")
# 6.``水平``+``垂直翻转
img3 = img.transpose(Image.FLIP_LEFT_RIGHT).rotate(180)
# 7.``保存图片
img3.save("pli/3.png")
给图片增加文字
要在图像上绘制文本要用到 PIL 的两个模块：ImageDraw和ImageFont。 ImageDraw 用于创建绘图对象，ImageFont用于加载字体。
from PIL import Image, ImageDraw, ImageFont
# 1.``打开图片
img = Image.open("image/10.png")
# 2.``调用画图模块
draw = ImageDraw.Draw(img)
# 3.``设置字体
tfont = ImageFont.truetype("``萌神手写体``.ttf", 24)
# 4.``添加文字
"""
``参数一：文字在图片的位置：``(x, y)
``参数二：文字内容
``参数三：字体颜色，当然颜色也可以用``RGB``值指定
``参数四：字体类型
"""
draw.text((50, 30), "eyes++", fill="green", font=tfont)
# 5.``保存图片
img.save("image/addWord.png")
# 6.``显示图片
img.show()
PIL滤镜功能
from PIL import Image, ImageFilter
img = Image.open("image/10.png")
img = img.filter(ImageFilter.CONTOUR)
img.save("image/Filter.png")
img.show()
PIL镜像功能
from PIL import Image
img = Image.open("image/10.png")
img = img.transpose(Image.FLIP_LEFT_RIGHT)
img.save("image/mirror.png")
transpose有这么几种模式
FLIP_LEFT_RIGHT：左右镜像
FLIP_TOP_BOTTOM：上下镜像
ROTATE_90：逆时针转90度
ROTATE_180：逆时针转180度
ROTATE_270：逆时针转270度
TRANSPOSE：像素矩阵转置
TRANSVERSE
最后一种模式我也不知道什么意思，也没查到，但效果是下面这样的，盲猜是对角线对转。。。。。
图片拼接功能
from PIL import Image, ImageDraw
# ``打开图片
img1 = Image.open("image/10.png")
img2 = Image.open("image/addWord.png")
# ``查看图片尺寸，便于拼接图片
print(img1.size)
print(img1.size)
# ``新建空白图片``,``三个参数分别是模式``(RGB/RGBA)``、大小、颜色
newimg = Image.new(mode="RGB", size=(1174, 614), color=(255, 100, 50))
# ``拼接图片``,``第一个参数是图片，第二个是起始位置
newimg.paste(img1, (0, 0))
newimg.paste(img2, (587, 0))
newimg.show()
PIL裁剪功能
from PIL import Image
img = Image.open("image/10.png")
print(img.size)
imgCut = img.crop((100, 200, 500, 600))
imgCut.show()
图片缩放
from PIL import Image
# :
img = Image.open('image/10.png')
# ``获得图像尺寸``:
w, h = img.size
# ``缩放到``50%:
img.thumbnail((w//2, h//2))
# ``把缩放后的图像用``jpeg``格式保存``:
img.save('image/zoom.png')
shutil****模块
2022年7月13日
11:00
高级的 文件、文件夹、压缩包 处理模块
shutil.copyfileobj(fsrc, fdst[, length])
将文件内容拷贝到另一个文件中
1import shutil`
`23shutil.copyfileobj(open('old.xml','r'), open('new.xml', 'w'))
shutil.copyfile(src, dst)
拷贝文件
shutil.copyfile('f1.log', 'f2.log') #``目标文件无需存在
shutil.copymode(src, dst)
仅拷贝权限。内容、组、用户均不变
1shutil.copymode('f1.log', 'f2.log') #``目标文件必须存在
shutil.copystat(src, dst)
仅拷贝状态的信息，包括：``mode bits, atime, mtime, flags
1shutil.copystat('f1.log', 'f2.log') #``目标文件必须存在
shutil.copy(src, dst)
拷贝文件和权限
import shutil`
`shutil.copy('f1.log', 'f2.log')
shutil.copy2(src, dst)
拷贝文件和状态信息
import shutil`
`shutil.copy2('f1.log', 'f2.log')
shutil.ignore_patterns(*patterns)
shutil.copytree(src, dst, symlinks=False, ignore=None)
递归的去拷贝文件夹
import shutil`
`shutil.copytree('folder1', 'folder2', ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))
#``目标目录不能存在，注意对``folder2``目录父级目录要有可写权限，
ignore``的意思是排除 ==》``*.pyc', 'tmp*``：这个是排除易。pyc结尾，和以tmp开头的文件
拷贝软连接
import shutil
shutil.copytree('f1', 'f2', symlinks=True, ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))
'''`
`通常的拷贝都把软连接拷贝成硬链接，即对待软连接来说，创建新的文件`
`'''
shutil.rmtree(path[, ignore_errors[, onerror]])
递归的去删除文件
import shutil`
`shutil.rmtree('folder1')
shutil.move(src, dst)
递归的去移动文件，它类似``mv``命令，其实就是重命名。
import shutil`
`shutil.move('folder1', 'folder3')
shutil.make_archive(base_name, format,...)
创建压缩包并返回文件路径，例如：``zip``、``tar
创建压缩包并返回文件路径，例如：``zip``、``tar
- base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，
如 data_bak =>保存至当前路径
如：/tmp/data_bak =>保存至/tmp/ - format： 压缩包种类，“zip”, “tar”, “bztar”，“gztar”
- root_dir： 要压缩的文件夹路径（默认当前目录）
- owner： 用户，默认当前用户
- group： 组，默认当前组
- logger： 用于记录日志，通常是logging.Logger对象
#``将`` /data ``下的文件打包放置当前程序目录
import shutil`
`ret = shutil.make_archive("data_bak", 'gztar', root_dir='/data')`
`#``将`` /data``下的文件打包放置`` /tmp/``目录
import shutil`
`ret = shutil.make_archive("/tmp/data_bak", 'gztar', root_dir='/data')``
shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的，详细：
import zipfile
# ``压缩``z = zipfile.ZipFile('laxi.zip', 'w')`
`z.write('a.log')`
`z.write('data.data')`
`z.close()
# ``解压``z = zipfile.ZipFile('laxi.zip', 'r')`
`z.extractall(path='.')`
`z.close()
import tarfile
# ``压缩``>>> t=tarfile.open('/tmp/egon.tar','w')`
`>>> t.add('/test1/a.py',arcname='a.bak')`
`>>> t.add('/test1/b.py',arcname='b.bak')`
`>>> t.close()
# ``解压``>>> t=tarfile.open('/tmp/egon.tar','r')`
`>>> t.extractall('/egon')`
`>>> t.close()
Openpyxl模块
2022年6月7日
13:24
01 首先读取已存在的 Excel 表格
使用load_workbook（）函数；我们需要先导入load_workbook;工作表为活动工作表
from openpyxl import load_workbook
# Excel表格与脚本在同一个文件，否则需要把路径写全
wb = load_workbook(r'demo.xlsx')
sheet = wb.active
# 也可以按工作表名读取
# sheet = wb.get_sheet_by_name("sheet")
02 向单个单元格赋值
可以使用['A1']形式；也可以使用标明行列数值的形式.cell(row=2, column=2).value = 5
from openpyxl import load_workbook
wb = load_workbook(r'demo.xlsx')
sheet = wb.active
sheet['A1'] = 'Devansh Sharma'
sheet['A2'] = 'hello world'
sheet.cell(row=2, column=2).value = 5
wb.save(r'demo.xlsx')
print("运行结束！")
向工作表批量赋值
from openpyxl import load_workbook
wb = load_workbook(r'demo.xlsx')
sheet = wb.active
data = (
(11, 48, 50),
(81, 30, 82),
(20, 51, 72),
(21, 14, 60),
(28, 41, 49),
(74, 65, 53),
("Peter", 'Andrew',45.63)
)
for i in data:
sheet.append(i)
wb.save(r'demo.xlsx')
print("运行结束！")
jieba模块
2021年12月10日
21:19
安装
pip install jieba
二、算法介绍
结巴中文分词涉及到的算法包括：
(1) 基于Trie树结构实现高效的词图扫描，生成句子中汉字所有可能成词情况所构成的有向无环图（DAG)；
(2) 采用了动态规划查找最大概率路径, 找出基于词频的最大切分组合；
(3) 对于未登录词，采用了基于汉字成词能力的HMM模型，使用了Viterbi算法。
三、分词模式
结巴中文分词支持的三种分词模式包括：
(1) 精确模式：试图将句子最精确地切开，适合文本分析；
(2) 全模式：把句子中所有的可以成词的词语都扫描出来, 速度非常快，但是不能解决歧义问题；
(3) 搜索引擎模式：在精确模式的基础上，对长词再次切分，提高召回率，适合用于搜索引擎分词。
import jieba
# 全模式
text = "我来到北京清华大学"
seg_list = jieba.cut(text, cut_all=True)
print(u"[全模式]: ", "/ ".join(seg_list))
返回列表
# 精确模式
seg_list = jieba.cut(text, cut_all=False)
print(u"[精确模式]: ", "/ ".join(seg_list))
# 默认是精确模式
seg_list = jieba.cut(text)
print(u"[默认模式]: ", "/ ".join(seg_list))
# 搜索引擎模式
seg_list = jieba.cut_for_search(text)
print(u"[搜索引擎模式]: ", "/ ".join(seg_list))
结果：
[全模式]: 我/ 来到/ 北京/ 清华/ 清华大学/ 华大/ 大学
[精确模式]: 我/ 来到/ 北京/ 清华大学
[默认模式]: 我/ 来到/ 北京/ 清华大学
[搜索引擎模式]: 我/ 来到/ 北京/ 清华/ 华大/ 大学/ 清华大学
jieba库的三种模式：
-精确模式：把文本精确的切分开，不存在冗余单词
#jieba.lcut(s)
jieba.lcut("中国是一个伟大的国家"
#output:['中国', '是', '一个', '伟大', '的', '国家']
-全模式：把文本中所有的可能的词语都扫描出来，有冗余
#jieba.lcut(s,cut_all=True)
jieba.lcut("中国是一个伟大的国家",cut_all=True)
#output:['中国', '国是', '一个', '伟大', '的', '国家']
-全搜索引擎模式：在精确模式的基础上，对长词再次切分
#jieba.lcut_for_search(s)
jieba.lcut_for_search("中华人民共和国是伟大的")
#output:['中华', '华人', '人民', '共和', '共和国', '中华人民共和国', '是', '伟大', '的']
向分词词典中增加新词w：
#jieba.add_word(w)
jieba.add_word("蟒蛇语言")
四、新词识别
import jieba
#新词识别 “杭研”并没有在词典中,但是也被Viterbi算法识别出来了
seg_list = jieba.cut("他来到了网易杭研大厦")
print (u"[新词识别]: ", "/ ".join(seg_list))
[新词识别]: 他/ 来到/ 了/ 网易/ 杭研/ 大厦
五、自定义词典
import jieba
text = "故宫的著名景点包括乾清宫、太和殿和黄琉璃瓦等"
# 全模式
seg_list = jieba.cut(text, cut_all=True)
print(u"[全模式]: ", "/ ".join(seg_list))
# 精确模式
seg_list = jieba.cut(text, cut_all=False)
print(u"[精确模式]: ", "/ ".join(seg_list))
# 搜索引擎模式
seg_list = jieba.cut_for_search(text)
print(u"[搜索引擎模式]: ", "/ ".join(seg_list))
结果
[全模式]: 故宫/ 的/ 著名/ 著名景点/ 景点/ 包括/ 乾/ 清宫/ / / 太和/ 太和殿/ 和/ 黄/ 琉璃/ 琉璃瓦/ 等
[精确模式]: 故宫/ 的/ 著名景点/ 包括/ 乾/ 清宫/ 、/ 太和殿/ 和/ 黄/ 琉璃瓦/ 等
[搜索引擎模式]: 故宫/ 的/ 著名/ 景点/ 著名景点/ 包括/ 乾/ 清宫/ 、/ 太和/ 太和殿/ 和/ 黄/ 琉璃/ 琉璃瓦/ 等
可以看到，结巴分词工具认出了专有名词”太和殿”，但没有认出”乾清宫”和”黄琉璃瓦”。
也就是说，专有名词”乾清宫”和”黄琉璃瓦”可能因分词而分开，这也是很多分词工具的一个缺陷。
为此，Jieba分词支持开发者使用自定定义的词典，以便包含jieba词库里没有的词语。虽然结巴有新词识别能力，但自行添加新词可以保证更高的正确率，尤其是专有名词。
基本用法：
jieba.load_userdict(file_name) #file_name为自定义词典的路径
词典格式和dict.txt一样，一个词占一行；
每一行分三部分，第一部分为词语，中间部分为词频，最后部分为词性（可省略，ns为地点名词），用空格隔开。
咱们在jieba的安装目录下添加mydict.txt，内容为
乾清宫 1 n
黄琉璃瓦 1 n
添加自定义以后的代码；主要是添加加载mydict.txt的代码：
import jieba
jieba.load_userdict("D:\Program Files\Python36\Lib\site-packages\jieba\mydict.txt")
text = "故宫的著名景点包括乾清宫、太和殿和黄琉璃瓦等"
# 全模式
seg_list = jieba.cut(text, cut_all=True)
print(u"[全模式]: ", "/ ".join(seg_list))
# 精确模式
seg_list = jieba.cut(text, cut_all=False)
print(u"[精确模式]: ", "/ ".join(seg_list))
# 搜索引擎模式
seg_list = jieba.cut_for_search(text)
print(u"[搜索引擎模式]: ", "/ ".join(seg_list))
结果
[全模式]: 故宫/ 的/ 著名/ 著名景点/ 景点/ 包括/ 乾清宫/ 清宫/ / / 太和/ 太和殿/ 和/ 黄琉璃瓦/ 琉璃/ 琉璃瓦/ 等
[精确模式]: 故宫/ 的/ 著名景点/ 包括/ 乾清宫/ 、/ 太和殿/ 和/ 黄琉璃瓦/ 等
[搜索引擎模式]: 故宫/ 的/ 著名/ 景点/ 著名景点/ 包括/ 清宫/ 乾清宫/ 、/ 太和/ 太和殿/ 和/ 琉璃/ 琉璃瓦/ 黄琉璃瓦/ 等
关键词提取
在构建VSM向量空间模型过程或者把文本转换成数学形式计算中，你需要运用到关键词提取的技术。
jieba.analyse.extract_tags(sentence, topK)
其中sentence为待提取的文本，topK为返回几个TF/IDF权重最大的关键词，默认值为20。
代码；
import jieba
import jieba.analyse
#导入自定义词典
jieba.load_userdict("D:\Program Files\Python36\Lib\site-packages\jieba\mydict.txt")
#精确模式
text = "故宫的著名景点包括乾清宫、太和殿和午门等。其中乾清宫非常精美，午门是紫禁城的正门，午门居中向阳。"
seg_list = jieba.cut(text, cut_all=False)
print (u"分词结果:")
print ("/".join(seg_list))
#获取关键词
tags = jieba.analyse.extract_tags(text, topK=5)
print (u"关键词:")
print (" ".join(tags))
结果；
故宫/的/著名景点/包括/乾清宫/、/太和殿/和/午门/等/。/其中/乾清宫/非常/精美/，/午门/是/紫禁城/的/正门/，/午门/居中/向阳/。
关键词:
午门 乾清宫 著名景点 太和殿 向阳
这里“午门”出现了3次，所以先输出。“乾清宫”出现了2次，第二个输出。
其他词都出现1次，那么为什么接下来输出的是“著名景点”、“太和殿”和“向阳”呢？
这是因为，在词频一样的前题下，根据TF/IDF的顺序来输出，因为其他词的TF一样（都是1），所以IDF小的会先输出来。
不知道结巴分词是根据什么来判断IDF的，假如是根据dict.txt中的第二列词频来判断，那么确实是“著名景点” < “太阳殿” < “向阳” < 其他词语。这样第三个输出的就是“著名景点”，最后两个依次为“太阳殿”和“向阳”。
去除停用词
在信息检索中，为节省存储空间和提高搜索效率，在处理自然语言数据（或文本）之前或之后会自动过滤掉某些字或词，比如“的”、“是”、“而且”、“但是”、”非常“等。这些字或词即被称为Stop Words（停用词）。
代码：
import jieba
# 去除停用词
stopwords = {}.fromkeys(['的', '包括', '等', '是'])
text = "故宫的著名景点包括乾清宫、太和殿和午门等。其中乾清宫非常精美，午门是紫禁城的正门。"
# 精确模式
segs = jieba.cut(text, cut_all=False)
final = ''
for seg in segs:
if seg not in stopwords:
final += seg
print (final)
seg_list = jieba.cut(final, cut_all=False)
print ("/ ".join(seg_list))
结果：
故宫著名景点乾清宫、太和殿和午门。其中乾清宫非常精美，午门紫禁城正门。
故宫/ 著名景点/ 乾/ 清宫/ 、/ 太和殿/ 和/ 午门/ 。/ 其中/ 乾/ 清宫/ 非常/ 精美/ ，/ 午门/ 紫禁城/ 正门/ 。
WordCloud模块
2021年12月16日
20:00
效果是不是看起来还不错，下面介绍wordcloud.WordCloud()的参数
font_path : string //字体路径，需要展现什么字体就把该字体路径+后缀名写上，如：font_path = '黑体.ttf'
width : int (default=400) //输出的画布宽度，默认为400像素
height : int (default=200) //输出的画布高度，默认为200像素
prefer_horizontal : float (default=0.90) //词语水平方向排版出现的频率，默认 0.9 （所以词语垂直方向排版出现频率为 0.1 ）
mask : nd-array or None (default=None) //如果参数为空，则使用二维遮罩绘制词云。如果 mask 非空，设置的宽高值将被忽略，遮罩形状被 mask 取代。除全白（#FFFFFF）的部分将不会绘制，其余部分会用于绘制词云。如：bg_pic = imread('读取一张图片.png')，背景图片的画布一定要设置为白色（#FFFFFF），然后显示的形状为不是白色的其他颜色。可以用ps工具将自己要显示的形状复制到一个纯白色的画布上再保存，就ok了。
scale : float (default=1) //按照比例进行放大画布，如设置为1.5，则长和宽都是原来画布的1.5倍。
min_font_size : int (default=4) //显示的最小的字体大小
font_step : int (default=1) //字体步长，如果步长大于1，会加快运算但是可能导致结果出现较大的误差。
max_words : number (default=200) //要显示的词的最大个数
stopwords : set of strings or None //设置需要屏蔽的词，如果为空，则使用内置的STOPWORDS
background_color : color value (default=”black”) //背景颜色，如background_color='white',背景颜色为白色。
max_font_size : int or None (default=None) //显示的最大的字体大小
mode : string (default=”RGB”) //当参数为“RGBA”并且background_color不为空时，背景为透明。
relative_scaling : float (default=.5) //词频和字体大小的关联性
color_func : callable, default=None //生成新颜色的函数，如果为空，则使用 self.color_func
regexp : string or None (optional) //使用正则表达式分隔输入的文本
collocations : bool, default=True //是否包括两个词的搭配
colormap : string or matplotlib colormap, default=”viridis” //给每个单词随机分配颜色，若指定color_func，则忽略该方法。
fit_words(frequencies) //根据词频生成词云
generate(text) //根据文本生成词云
generate_from_frequencies(frequencies[, ...]) //根据词频生成词云
generate_from_text(text) //根据文本生成词云
process_text(text) //将长文本分词并去除屏蔽词（此处指英语，中文分词还是需要自己用别的库先行实现，使用上面的 fit_words(frequencies) ）
recolor([random_state, color_func, colormap]) //对现有输出重新着色。重新上色会比重新生成整个词云快很多。
to_array() //转化为 numpy array
to_file(filename) //输出到文件
打包py文件
2022年6月18日
17:19
第一步：安装打包所需要的包（pyinstaller）
在``cmd``窗口中输入
pip install pyinstaller
并从新创建一个环境
第二步修改路径
第三步：输入打包命令
pyinstaller -F -w (-i icofile) 文件名.py
解释一下该命令：
1、-w 表示在打包好程序后，双击.exe文件不会不会不会（重要的事情说三遍）出现黑色的命令窗口。（如果你的程序有print等输出命令，就不要加）
2、小括号中的内容是可以省略的，-i 表示给.exe文件一个图标，icofile表示图标的文件名，图标的图片格式为.ico格式的。不懂.ico图片的可以百度一下。打包时如果需要给.exe加入图标，将图标文件放到和.py文件同一目录下。
3、文件名.py 这里的文件名是你要打包的.py文件的名称。
| -h，--help | 查看该模块的帮助信息 |
|---|---|
| -F，-onefile | 产生单个的可执行文件 |
| -D，--onedir | 产生一个目录（包含多个文件）作为可执行程序 |
| -a，--ascii | 不包含 Unicode 字符集支持 |
| -d，--debug | 产生 debug 版本的可执行文件 |
| -w，--windowed，--noconsolc | 指定程序运行时不显示命令行窗口（仅对 Windows 有效） |
| -c，--nowindowed，--console | 指定使用命令行窗口运行程序（仅对 Windows 有效） |
| -o DIR，--out=DIR | 指定 spec 文件的生成目录。如果没有指定，则默认使用当前目录来生成 spec 文件 |
| -p DIR，--path=DIR | 设置 Python 导入模块的路径（和设置 PYTHONPATH 环境变量的作用相似）。也可使用路径分隔符（Windows 使用分号，Linux 使用冒号）来分隔多个路径 |
| -n NAME，--name=NAME | 指定项目（产生的 spec）名字。如果省略该选项，那么第一个脚本的主文件名将作为 spec 的名字 |
转换jpg为ioc文件
PythonMagick
PythonMagick库无法用pip或者easy_install来安装，因此，需要手动安装，地址如下： https://www.lfd.uci.edu/~gohlke/pythonlibs/#pythonmagick 选择合适版本下载后，进入文件所在位置，直接pip install + 文件名即可完成安装。
"""
Author``：``Robin·QI
Notes``：将图片转换为``ico``格式
"""
# PythonMargick``包可以到``Unofficial Windows Binaries for Python Extension Packages``下载
import PythonMagick
img = PythonMagick.Image('robin.jpg') ``# ``导入图片
# ``这里要设置一下尺寸，不然会报``ico``尺寸异常错误
img.sample('128x128') ``#``设置尺寸
img.write('robin.ico') ``保存图片
python音乐格式转换
2022年6月18日
22:37
01 安装pydub库
通过下面的命令安装``Python``库``-pydub
pip`` ``install`` ``pydub
#转化函数方法
from pydub import AudioSegment
#``转化函数方法
def trans_mp3_to_wav(filepath,hz):
song = AudioSegment.from_mp3(filepath)
song.export("Python``研究者``."+str(hz), format=str(hz))
### ``参数``1``：音频路径， 参数``2``：转换后的格式
trans_mp3_to_wav("``轻音乐``.mp3","wav")
trans_mp3_to_wav("``轻音乐``.mp3","ogg")
trans_mp3_to_wav("``轻音乐``.mp3","flac")
将轻音乐.mp3 转为wav、ogg、flac等格式，并命名为Python研究者。转化后均为无损高音质，没有任何的失真。
2.wav、ogg、flac->mp3
from pydub import AudioSegment
song = AudioSegment.from_wav("Python``研究者``.wav")
song.export("Python``研究者``_wav-mp3.mp3", format="mp3")
song = AudioSegment.from_ogg("Python``研究者``.ogg")
song.export("Python``研究者``_ogg-mp3.mp3", format="mp3")
AudioSegment.from_file("Python``研究者``.flac")
song.export("Python``研究者``_flac-mp3.mp3", format="mp3")
Python 使用 webbrowser 包播放 Mp3 文件
Import webbrowser`
`webbrowser.open("sample.mp3")
代码片段将在浏览器窗口中打开一个标签页并播放当前工作目录中的 sample.mp3 文件。
大部分的模块介绍
2022年5月10日
23:05
库名称简介
Chardet字符编码探测器，可以自动检测文本、网页、xml的编码。
colorama主要用来给文本添加各种颜色，并且非常简单易用。
Prettytable主要用于在终端或浏览器端构建格式化的输出。
difflib，[Python]标准库，计算文本差异
Levenshtein，快速计算字符串相似度。
fuzzywuzzy,字符串模糊匹配。
esmre,正则表达式的加速器。
shortuuid,一组简洁URL/UUID函数库。
ftfy，Unicode文本工具7
unidecode，ascii和Unicode文本转换函数。
xpinyin，将汉字转换为拼音的函数库
pangu.py，调整对中日韩文字当中的字母、数字间距。
pyfiglet，Python写的figlet程序，使用字符组成ASCII艺术图片
uniout，提取字符串中可读写的字符
awesome slugify，一个Python slugify库，用于处理Unicode。
python-slugify，转换Unicode为ASCII内码的slugify函数库。
unicode-slugify，生成unicode内码，Django的依赖包。
ply，Python版的lex和yacc的解析工具
phonenumbers，解析电话号码，格式，存储和验证的国际电话号码。
python-user-agents，浏览器的用户代理（user-agents）的解析器。
sqlparse，SQL解析器。
pygments，一个通用的语法高亮工具。
python-nameparser，解析人名，分解为单独的成分。
pyparsing，通用解析器生成框架。
tablib，表格数据格式，包括，XLS、CSV，JSON，YAML。
python-docx，docx文档读取，查询和修改，微软Word 2007 / 2008的docx文件。
xlwt/xlrd，读写Excel格式的数据文件。
xlsxwriter，创建Excel格式的xlsx文件。
xlwings，利用Python调用Excel
csvkit，CSV文件工具包。
marmir，把Python[数据结构]，转化为电子表格。
pdfminer，从PDF文件中提取信息。
pypdf2， 合并和转换PDF页面的函数库。
Python-Markdown，轻量级标记语言Markdown的Python实现。
Mistune，,快速、全功能的纯Python编写的Markdown解释器。
dateutil，标准的Python官方datetime模块的扩展包，字符串日期工具，其中parser是根据字符串解析成datetime，而rrule是则是根据定义的规则来生成datetime。
arrow,更好的日期和时间处理Python库
chronyk，一个Python 3版函数库，用于解析人写的时间和日期。
delorean，清理期时间的函数库。
when.py，为见的日期和时间，提供人性化的功能。
moment，类似Moment.js的日期/时间Python库
pytz，世界时区，使用tz database时区信息[数据库]
BeautifulSoup，基于Python的HTML/XML解析器，简单易用, 功能很强大,即使是有bug，有问题的html代码，也可以解析
lxml，快速，易用、灵活的HTML和XML处理库，功能超强，在遇到有缺陷、不规范的xml时，Python自带的xml处理器可能无法解析。报错时，程序会尝试再用lxml的修复模式解析。
htmlparser，官方版解析HTML DOM树，偶尔搞搞命令行自动表单提交用得上。
pyyaml，Python版本的YAML解释器。
html5lib，-标准库，解析和序列化HTML文档和片段。
pyquery，类似[jQuery]的的HTML解释器函数库。
cssutils，Python CSS库。
MarkupSafe，XML或HTML / XHTML安全字符串标记工具。
cssutils - ACSS library for Python., MarkupSafe - Implements a XML/HTML/XHTML
bleach，漂白，基于HTML的白名单函数库。
xmltodict，类似JSON的XML工具包。
xhtml2pdf，HTML / CSS格式转换器，看生成pdf文档。
untangle，把XML文档，转换为Python对象，方便访问。
文件处理
库名称简介Mimetypes，Python标准库，映射文件名到MIME类型。
imghdr，Python标准库，确定图像类型。python-magic，libmagic文件类型识别库，Python接口格式。path.py，os.path模块的二次封装。
watchdog，一组API和shell实用程序，用于监视文件系统事件。
Unipath，面向对象的文件/目录的操作工具包。pathlib，-（Python 3.4版已经作为Python标准库），一个跨平台，面向path的函数库。
pickle/cPickle,python的pickle模块实现了基本的数据序列和反序列化。通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储；通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象。
cPickle是[C语言]实现的版本，速度更快。
ConfigParser，Python标准库，INI文件解析器。
configobj，INI文件解析器。config，分层次配置，logging作者编写。
profig，多格式配置转换工具。
logging，Python标准库，日志文件生成管理函数库。
logbook，logging的替换品。
Sentry，实时log服务器。Raven，哨兵Sentry的Python客户端。
Sphinx，斯芬克斯（狮身人面像），Python文档生成器。
reStructuredText，标记语法和解析工具，Docutils组件。mkdocs，Markdown格式文档生成器。
pycco，简单快速、编程风格的文档生成器。
pdoc，自动生成的Python库API文档epydoc，从源码注释中生成各种格式文档的工具
图像处理
库名称简介PIL（Python Image Library），基于Python的图像处理库，功能强大，对图形文件的格式支持广泛，内置许多图像处理函数，如图像增强、滤波[算法]等Pillow，图像处理库，PIL图像库的分支和升级替代产品。Matplotlib，著名的绘图库，提供了整套和matlab相似的命令API，用以绘制一些高质量的数学二维图形，十分适合交互式地进行制图。brewer2mpl，有一个专业的python配色工具包，提供了从美术角度来讲的精美配色。
PyGame基于Python的多媒体开发和游戏软件开发模块，包含大量游戏和图像处理功能Box2d，开源的2d物理引擎，愤怒的小鸟就是使用了这款物理引擎进行开发的，Box2d物理引擎内部模拟了一个世界，你可以设置这个世界里的重力，然后往这个世界里添加各种物体，以及他们的一些物理特性，比如质量，摩擦，阻尼等等。
Pymunk，类似box2d的开源物理图形模拟库OpenCV, 目前最好的开源图像/视觉库，包括图像处理和计算机视觉方面、[机器学习]的很多通用算法。SimpleCV，计算机视觉开源框架，类似opencv。VTK，视觉化工具函式库（VTK， Visualization Toolkit）是一个开放源码，跨平台、支援平行处理（VTK曾用于处理大小近乎1个Petabyte的资料，其平台为美国Los Alamos国家实验室所有的具1024个处理器之大型系统）的图形应用函式库。
2005年时曾被美国陆军研究实验室用于即时模拟俄罗斯制反导弹战车ZSU23-4受到平面波攻击的情形，其计算节点高达2.5兆个之多。cgkit,Python Computer Graphics Kit,其module 主要分两个部分，
\1. 与3d相关的一些python module 例如the vector, matrix and quaternion types, the RenderMan bindings, noise functions 这些模块可以在maya houdini nuke blender 等有Python扩展的程序中直接用;
\2. 提供完整的场景操作的module， 他类似其他三维软件，在内存中保留完整的描述场景的信息。
不能直接用于maya 等CGAL，
Computational Geometry Algorithms Library，计算几何算法库，提供计算几何相关的数据结构和算法，诸如三角剖分（2D约束三角剖分及二维和三维Delaunay三角剖分），
Voronoi图（二维和三维的点，2D加权Voronoi图，分割Voronoi图等），
多边形（布尔操作，偏置），多面体（布尔运算），曲线整理及其应用，
网格生成（二维Delaunay网格生成和三维表面和体积网格生成等），几何处理（表面网格简化，细分和参数化等），
凸壳算法（2D，3D和dD），搜索结构（近邻搜索，kd树等），插值，形状分析，拟合，距离等。
Aggdraw，开源图像库，几乎涵盖了2d image操作的所有功能，使用起来非常灵活Pycairo,开源矢量绘图库Cairo开罗的python接口，
cairo提供在多个背景下做2-D的绘图，高级的更可以使用硬件加速功能。wand，Python绑定魔杖工具（MagickWand），C语言API接口。
thumbor， -智能成像工具，可调整大小和翻转图像。
imgSeek，查询相似的图像。
python-qrcode，纯Python的二维码（QR码）生成器。
pyBarcode，创建条码，无需PIL模块。
pygram，Instagram像图像过滤器。
Quads，基于四叉树的计算机艺术。
nude.py，裸体检测函数。
scikit-image，scikit工具箱的图像处理库。
hmap，图像直方图工具。
bokeh，交互的Web绘图。
plotly，Web协同的Python和Matplotlib绘制。
vincent，文森特，Python Vega的函数库。
d3py，Python绘图库，基于D3.JS, ggplot -API兼容R语言的ggplot2.Kartograph.py，在Python绘制漂亮的SVG地图。pygal， SVG图表的创造者。
pygraphviz，Graphviz的Python接口。
Fonttlools，ttf字体工具函数包，用于fontforge、ttx等字体软件。
游戏和多媒体
库名称简介audiolazy，数字信号处理（DSP）的Python工具包。
audioread，跨平台（GStreamer + Core Audio + MAD + FFmpeg）音频解码库。
beets，音乐库管理。
dejavu，音频指纹识别算法。
Dejavu 听一次音频后就会记录该音频的指纹信息，然后可通过麦克风对输入的音频进行识别是否同一首歌。django-elastic-transcoder,Django +亚马逊elastic转码。eyeD3,音频文件工具，特别是MP3文件包含的ID3元数据。
id3reader，用于读取MP3的元数据。
mutagen，处理音频元数据。
pydub，-操纵音频和简单的高层次的接口。
pyechonest，Echo Nest API客户端。talkbox，语音和信号处理的Python库。
TimeSide，开放的网络音频处理框架。
tinytag，读取音乐文件元数据，包括的MP3，OGG，FLAC和wave文件。
m3u8，用于解析m3u8文件。
moviepy，多格式视频编辑脚本模块，包括GIF动画。
shorten.tv，视频摘要。
scikit视频，SciPy视频处理例程。
GeoDjango,一个世界级的地理Web框架。
geopy,Geo地理编码的工具箱。
pygeoip，纯Python写的GeoIP API。
GeoIP，Python API接口，使用高精度GeoIP Legacy Database数据库。
geojson，GeoJSON函数库django-countries，一个Django程序，提供国家选择，国旗图标的静态文件，和一个国家的地域模型。
Pygame，Python游戏设计模块。
Cocos2d，2D游戏框架，演示，和其他的图形/交互应用，基于pyglet。Cocos2d- cocos2d is a framework for building 2D games, demos, and other graphical/interactive applications. It is based on pyglet.,PySDL2，SDL2的封装库。
Panda3D- 3D游戏引擎，迪士尼开发。
用C++写的，完全兼容Python。PyOgre，OGRE 3D渲染引擎，可用于游戏，模拟，任何3D。
PyOpenGL，绑定OpenGL和它相关的API。
PySFML，Python绑定SFMLRenPy，视觉小说引擎。
大数据与科学计算
库名称简介pycuda/opencl，GPU高性能并发计算Pandas，python实现的类似R语言的数据统计、分析平台。基于NumPy和Matplotlib开发的，主要用于数据分析和数据可视化，它的数据结构DataFrame和R语言里的data.frame很像，特别是对于时间序列数据有自己的一套分析机制，非常不错。
Open Mining，商业智能（BI），Pandas的Web界面。blaze，NumPy和Pandas大数据界面。
SciPy，开源的Python算法库和数学工具包，SciPy包含的模块有最优化、线性代数、积分、插值、特殊函数、快速傅里叶变换、信号处理和图像处理、常微分方程求解和其他科学与工程中常用的计算。
其功能与软件MATLAB、Scilab和GNU Octave类似。
Numpy和Scipy常常结合着使用，Python大多数机器学习库都依赖于这两个模块。
ScientificPython，一组经过挑选的Python程序模块，用于科学计算，包括几何学（矢量、张量、变换、矢量和张量场），四元数，自动求导数，（线性）插值，多项式，基础统计学，非线性最小二乘拟合，单位计算，Fortran兼容的文本格式，通过VRML的3D显示，以及两个Tk小工具，分别用于绘制线图和3D网格模型。
此外还具有到netCDF，MPI和BSPlib库的接口。
NumPy科学计算库，提供了矩阵，线性代数，傅立叶变换等等的解决方案, 最常用的是它的N维数组对象. NumPy提供了两种基本的对象：
ndarray（N-dimensional array object）和 ufunc（universal function object）。
ndarray是存储单一数据类型的多维数组，而ufunc则是能够对数组进行处理的函数。
Cvxopt，最优化计算包，可进行线性规划、二次规划、半正定规划等的计算。
Numba，科学计算速度优化编译器。pymvpa2，是为大数据集提供统计学习分析的Python工具包，它提供了一个灵活可扩展的框架。
它提供的功能有分类、回归、特征选择、数据导入导出、可视化等NetworkX，复杂网络的优化软件包。zipline，交易算法的函数库。
PyDy， Python动态建模函数库。
SymPy,符号数学的Python库。statsmodels,Python的统计建模和计量经济学。
astropy,天文学界的Python库。
orange，橙色，数据挖掘，数据可视化，通过可视化编程或Python脚本学习机分析。
RDKit,化学信息学和机器学习的软件。
Open Babel，巴贝尔，开放的化学工具箱。
cclib，化学软件包的计算函数库。
Biopython，免费的生物计算工具包。
bccb，生物分析相关的代码集。bcbio-nextgen，提供完全自动化、高通量、测序分析的工具包。
visvis, 可视化计算模块库，可进行一维到四维数据的可视化。
MapReduce是Google提出的一个软件[架构]，用于大规模数据集（大于1TB）的并行运算。
概念“Map（映射）”和“Reduce（归纳）”，及他们的主要思想，都是从函数式编程语言借来的MapReduce函数库。Framworks and libraries for MapReduce.,PySpark，[Spark]的Python API。dpark，Spark的Python克隆，Python中的MapReduce框架。luigi，为批量工作，建立复杂的管道。mrjob，运行在[Hadoop]，或亚马逊网络服务的，MapReduce工作。
人工智能与机器学习
库名称简介NLTK（natural language toolkit)，是python的自然语言处理工具包。2001年推出，包括了大量的词料库，以及自然语言处理方面的算法实现：
分词， 词根计算， 分类， 语义分析等。
Pattern，数据挖掘模块，包括自然语言处理，机器学习工具，等等。
textblob，提供API为自然语言处理、分解NLP任务。基于NLTK和Pattern模块。
jieba，结巴，中文分词工具。snownlp，用于处理中文文本库。
loso，中文分词函数库。
genius，中文CRF基础库，条件随机场(conditional random field,简称 CRF),是一种鉴别式机率模型,是随机场的一种,常用于标注或分析序列资料,如自然语言文字或是生物序列Gensim，一个相当专业的主题模型Python工具包，无论是代码还是文档，可用于如何计算两个文档的相似度LIBSVM,是台湾大学林智仁(Lin Chih-Jen)教授等开发设计的一个简单、易于使用和快速有效的SVM模式识别与回归的软件包，他不但提供了编译好的可在Windows系列系统的执行文件，还提供了源代码，方便改进、修改以及在其它[操作系统]上应用；
该软件对SVM所涉及的参数调节相对比较少，提供了很多的默认参数，利用这些默认参数可以解决很多问题；
并提供了交互检验(Cross Validation)的功能。
该软件可以解决C-SVM、ν-SVM、ε-SVR和ν-SVR等问题，包括基于一对一算法的多类模式识别问题。
scikits.learn，构建在SciPy之上用于机器学习的 Python 模块。它包括简单而高效的工具，可用于数据挖掘和数据分析。
涵盖分类，回归和聚类算法，例如SVM， 逻辑回归，朴素贝叶斯，随机森林，k-means等算法，代码和文档都非常不错，在许多Python项目中都有应用。
例如在我们熟悉的NLTK中，分类器方面就有专门针对scikit-learn的接口，可以调用scikit-learn的分类算法以及训练数据来训练分类器模型。PyMC，机器学习采样工具包，scikit-learn似乎是所有人的宠儿，有人认为，PyMC更有魅力。
PyMC主要用来做Bayesian分析。Orange，基于组件的数据挖掘和机器学习软件套装，它的功能即友好，又很强大，快速而又多功能的可视化编程前端，以便浏览数据分析和可视化，包含了完整的一系列的组件以进行数据预处理，并提供了数据帐目，过渡，建模，模式评估和勘探的功能。
侧重数据挖掘，可以用可视化语言或Python进行操作，拥有机器学习组件，还具有生物信息学以及文本挖掘的插件。
Milk，机器学习工具箱，其重点是提供监督分类法与几种有效的分类分析：SVMs(基于libsvm)，K-NN，随机森林经济和决策树。
它还可以进行特征选择。这些分类可以在许多方面相结合，形成不同的分类系统。对于无监督学习，它提供K-means和affinity propagation聚类算法。
PyMVPA(Multivariate Pattern Analysis in Python),是为大数据集提供统计学习分析的Python工具包，它提供了一个灵活可扩展的框架。它提供的功能有分类、回归、特征选择、数据导入导出、可视化等NuPIC，开源人工智能平台。
该项目由Grok（原名 Numenta）公司开发，其中包括了公司的算法和软件架构。
NuPIC 的运作接近于人脑，“当模式变化的时候，它会忘掉旧模式，记忆新模式”。如人脑一样，CLA 算法能够适应新的变化。Pylearn2，-基于Theano的机器学习库。
hebel，GPU加速，[深度学习]Python库。
gensim，机器学习库。pybrain，机器学习模块，它的目标是为机器学习任务提供灵活、易应、强大的机器学习算法。
pybrain包括神经网络、强化学习(及二者结合)、无监督学习、进化算法。以神经网络为核心，所有的训练方法都以神经网络为一个实例Mahout,是 Apache Software Foundation（ASF） 旗下的一个开源项目，提供一些可扩展的机器学习领域经典算法的实现，旨在帮助开发人员更加方便快捷地创建智能应用程序。
Mahout包含许多实现，包括聚类、分类、推荐过滤、频繁子项挖掘。此外，通过使用 Apache Hadoop 库，Mahout 可以有效地扩展到云中。
Crab，灵活的，快速的推荐引擎。python-recsys，娱乐系统分析，推荐系统。vowpal_porpoise，Vowpal Wabbit轻量级Python封装。
Theano,用来定义、优化和模拟数学表达式计算，用于高效的解决多维数组的计算问题的python软件包。它使得写深度学习模型更加容易，同时也给出了一些关于在GPU上训练它们的选项。
系统与命令行
库名称简介threading，Python标准线程库，更高级别的线程接口。
envoy，特使，Python子线程的函数库。
sh，成熟的子线程替换函数库。sarge，封装线程。subprocess,调用shell命令的神器argparse，写命令行脚本必备，强大的命令行差数解析工具timeit，计算代码运行的时间等等unp，命令行工具，解压文件。
eventlet开销很少的多线程模块，使用的是 green threads 概念，例如，pool = eventlet.GreenPool(10000) 这样一条语句便创建了一个可以处理 10000 个客户端连接的线程池。
类似Gevent线程库Gevent，多线程模块pytools,著名的python通用函数、工具包SendKeys, 键盘鼠标操作模块, 模拟键盘鼠标模拟操作。
pyHook,基于Python的“钩子”库，主要用于监听当前电脑上鼠标和键盘的事件。
这个库依赖于另一个Python库PyWin32，如同名字所显示的，PyWin32只能运行在Windows平台，所以PyHook也只能运行在Windows平台。
pstuil,跨平台地很方便获取和控制系统的进程，以及读取系统的CPU占用内存占用等信息.cement，一个轻量级的、功能齐全的命令行工具click，简单优雅的的命令行接口。
clint，Python命令行工具。cliff，创造多层次指令的命令行程序框架。
Clime， 可以转换任何模块为多的CLI命令程序，无任何配置。
docopt，Python命令行参数分析器。
pycli，命令行应用程序，支持的标准命令行解析，测井，单元[测试]和功能测试。
Gooey，打开命令行程序，作为为一个完整的GUI应用程序,cookiecutter，命令行工具，从cookiecutters（项目模板）创建项目。
例如，Python包项目，jQuery插件项目。
percol，为UNIX传统管道pipe命令，添加交互式选择风格。
rainbowstream，聪明和漂亮的推特客户终端。Django Models，Django的一部分SQLAlchemy，Python SQL工具包和对象关系映射。
peewee，小型的ORM解析器。
PonyORM，为ORM提供了一种面向SQL的接口。MongoEngine，Python对象文件映射，使用[MongoDB]。
, Django MongoDB引擎MongoDB , Django后台。
django-mongodb-engine，Django后台.redisco,一个简单的模型和容器库，使用[Redis]flywheel，Amazon DynamoDB对象映射。
butterdb，谷歌电子表格的ORM，Python版。celery，芹菜，异步任务队列/工作，基于分布式消息队列。
huey，休伊，轻量级，多线程任务队列。
mrq，队列先生，分布式任务队列，使用redis & Gevent。rq，简单的工作队列。
Queue,Queue模块可以用来实现多线程间通讯，让各个线程共享数据，生产者把货物放到Queue中，供消费者（线程）去使用。
simpleq，简单的，可扩展的队列，Amazon SQS基础队列。
Psyco，超强的python性能优化工具，psyco 的神奇在于它只需要在代码的入口处调用短短两行代码，性能就能提升 40% 或更多，真可谓是立竿见影！如果你的客户觉得你的程序有点慢，敬请不要急着去优化代码，psyco 或许能让他立即改变看法。
psyco 堪称 Python 的 jit。fn.py，Python函数编程：缺失的功能享受FP的实现。funcy，函数编程工具。
Toolz，函数编程工具：迭代器、函数，字典。CyToolz，Toolz的Cython实现，高性能的函数编程工具。Ansible，安塞波，极为简单的自动化平台。
SaltStack，基础设施的自动化管理系统。
Fabric，织物，一个简单，远程执行和部署的语言工具。
Fabtools，Fabric的工具函数。
cuisine，热门的Fabric的工具函数。
psutil，跨平台的过程和系统工具模块。
pexpect，控制互动节目。
provy，易于使用的配置系统的Python。honcho，Foreman的Python接口，用于管理procfile应用工具。
gunnery，多任务执行工具，与网络接口的分布式系统。
fig，快速。独立的开发环境中使用泊坞窗。
APScheduler，轻量级、但功能强大的在线任务调度程序。
django-schedule,Django日程应用程序。doit,任务流道/生成工具。
Joblib,Python提供的轻量级的流水线工具函数。
Plan，简易生成crontab文件。
Spiff，纯Python实现的，功能强大的工作流引擎。
schedule，Python作业调度。TaskFlow，有助于使任务执行简单。
ctypes，Python标准库，速度更快，Python调用C代码的外部函数接口。cffi，Python调用C代码外部函数接口，类似于ctypes直接在python程序中调用c程序,但是比ctypes更方便不要求编译成so再调用。
Cytoolz，python 加速库SWIG，简化封装和接口生成器。
,Cython，Python优化静态编译器。
PyPy，Python解释器的 Python实现。
Stackless Python，一个增强版本的Python。它使程序员从基于线程的编程方式中获得好处，并避免传统线程所带来的性能与复杂度问题。
Stackless为 Python带来的微线程扩展，是一种低开销、轻量级的便利工具Pyston,使用LLVM和现代JIT技术,对python进行性能优化。
pythonlibs，非官方的Windows（32 / 64位）的Python扩展包scapy，优秀的数据包处理库。
ino，Arduino命令行工具。Pyro，Python的机器人工具包。
pluginbase，一个简单而灵活的Python的插件系统。
itsdangerous，数据安全传输工具。blinker，快速Python中的信号/事件调度系统。
pychievements，用于创建和跟踪成果框架。
python-patterns，Python中的设计模式。
pefileWindows PE文件解析器SIP，自动为C和C++库生成Python扩展模块的工具
数据库
库名称简介MySQLdb，成熟的[MySQL]数据库模块,Baresql,SQL数据库包ZODB，Python本地对象数据库。一个K-V对象图数据库。
pickledb,简单和轻量级的K-V键值存储。
TinyDB, 轻量级，面向文档的数据库。
mysql-python，MySQL的Python工具库。
mysqlclient，mysql-python分支，支持Python 3.,PyMySQL,纯Python写的 MySQL驱动程序，兼容mysql-python。mysql-connector-python,MySQL连接器,来自[Oracle]，纯Python编写。
oursql，MySQL连接器，提供本地话指令语句和BLOBs支持。
psycopg2，最流行的Python PostgreSQL适配器。txpostgres，于Twisted的异步驱动，用于PostgreSQL。
queries,psycopg2函数库，用于PostgreSQL。
dataset,存储Python字典数据,用于SQLite，MySQL和PostgreSQL。
cassandra-python-driver，开源分布式NoSQL数据库系统Apache Cassandra系统的Python驱动.pycassa,简化的cassandra数据库Python驱动。
HappyBase，友好的Apache [Hbase]的函数库。
PyMongo，MongoDB官方客户端。
Plyvel，LevelDB快速和功能丰富的Python接口。redis-py,redis客户端。
py2neo,Python客户端(基于Neo4j的RESTful接口).telephus,基于Twisted的cassandra客户端。
txRedis，基于Twisted的Redis客户端。
【网络】Curl，Pycurl包是一个libcurl的Python接口，它是由C语言编写的。
与urllib相比，它的速度要快很多。
Libcurl是一个支持FTP, FTPS, HTTP, HTTPS, GOPHER, TELNET, DICT, FILE 和 LDAP的客户端URL传输库.libcurl也支持HTTPS认证,HTTP POST,HTTP PUT,FTP上传,代理,Cookies,基本身份验证,FTP文件断点继传,HTTP代理通道等等。
Requests，用Python语言编写，基于 urllib的开源 HTTP 库。
它比 urllib 更加方便，更加 Pythoner。
支持 Python3。httpie，命令行HTTP客户端，用户友好的cURL的替换工具。
s3cmd，命令行工具，用于管理Amazon S3和CloudFront。
youtube-dl，命令行程序，从YouTube下载视频。
you-get，Python3写的视频下载工具，可用于YouTube/Youku优酷/Niconico视频下载Coursera，从coursera.org下载视频，可重新命名文件wikiteam，wiki下载工具。
subliminal，命令行工具，搜索和下载字幕的函数库requests，HTTP函数库，更加人性化。grequests，异步HTTP请求+ Gevent（高性能高并发函数库）。
urllib3，一个线程安全的HTTP连接池，支持文件post。
httplib2，综合HTTP的客户端函数库。treq， Python API接口，Twisted的HTTP客户。
Mininet，流行的网络仿真器,API采用python编写。
POX，基于Python的开源软件定义网络（SDN）控制开发平台的应用，如OpenFlow的SDN控制器。
Pyretic，SDN的编程语言，提供了强大的抽象在网络交换机或仿真器。SDX Platform，基于SDN的IXP实现，利用最小网络，痘和热。inbox.py，Python的SMTP服务器。imbox， Python版本IMAP库。inbox，收件箱，开源邮件工具包。
lamson,SMTP服务器。flanker,侧卫,电子邮件地址和MIME解析库。
marrow.mailer,高性能可扩展邮件交付框架。
django-celery-ses， Django电子邮件后台，使用AWS SES和Celery。
modoboa，邮件托管和管理平台，包括现代和简化Web UI。
envelopes，邮件工具。
mailjet，批量邮寄mailjet API接口，带统计。Talon，利爪，Mailgun库，提取消息和签名。
mailjet- Mailjet API implementation for batch mailing, statistics and more., Talon - Mailgun library to extract message quotations and signatures.,pyzmail，编写，发送和解析电子邮件。
furl，燃料，小型的的URL解析库库。purl，简单的，干净的API，操纵URL。
pyshorteners，纯Python库，URL短网址编辑。
short_url，短网址生成。
Scrapy，快速屏幕截取和网页抓取的框架。
portia，波西亚，Scrapy的可视化扩展。
feedparser，信息源解释器RoboBrowser，简单的网页浏览Python函数库，没有使用Web浏览器。
MechanicalSoup，网站自动化互动测试工具包。
mechanize，网页浏览编程工具。
Demiurge，造物主，-PyQuery的轻量级工具。
newspaper,提取报纸新闻。html2text,转换HTML为 Markdown格式的文本。
python-goose,HTML内容提取器。
lassie,莱西,人性化的网站内容检索。
micawber,通过UR抓提网页的函数库。
sumy，概要，文本和HTML网页的自动文摘模块。
Haul，距离，可扩展的图像爬虫。
python-readability,可读性工具Arc90,快速的Python接口。
opengraph,OpenGraphProtocol协议解析模块,textract，从任何文件，Word，PowerPoint，PDF文件中提取文本，等。
sanitize，消毒，使混乱的数据变的理智。
AutobahnPython， WebSocket和WAMP的函数库，使用 Twisted和PythonWebSocket-for-Python，websocket客户端和服务器端函数库。SimpleXMLRPCServer，python标准库，简单的XML-RPC服务器，单线程。
SimpleJSONRPCServer，JSON-RPC规范实施函数库。
zeroRPC，基于ZeroMQ和MessagePack的RPC实现。
apache-libcloud，所有云服务的Python接口库。
wifi，WiFi -一套个Python库和命令行工具与WiFi，用于[Linux]。
streamparse，运行Python代码和数据的实时流。
集成了Apache Storm。
boto，亚马逊网络服务接口。
twython，Twitter推特API。google-api-python-client，谷歌客户端API。
gspread，谷歌电子表格的Python API。
facebook-sdk，facebook平台Python SDK。
facepy，简易的facebook图形APIgmail，Gmail的Python接口。
django-wordpress，Django的WordPress的模型和视图。
【Web框架】Django，最流行的Python-Web框架，鼓励快速开发,并遵循MVC设计，开发周期短ActiveGrid企业级的Web2.0解决方案Karrigell简单的Web框架，自身包含了Web服务，py脚本引擎和纯python的数据库PyDBLitewebpy一个小巧灵活的Web框架，虽然简单但是功能强大CherryPy基于Python的Web应用程序开发框架Pylons基于Python的一个极其高效和可靠的Web开发框架Zope开源的Web应用服务器TurboGears基于Python的MVC风格的Web应用程序框架Twisted流行的网络编程库，大型Web框架QuixoteWeb开发框架Flask,轻量级web框架Bottle，快速，简单和轻量级的WSGI模式Web框架。
Pyramid，轻量级，快速，稳定的开源Web框架。
web2py，简单易用的全堆栈Web框架和平台。
web.py，强大、简单的Web框架。TurboGears，便于扩展的Web框架。
CherryPy，极简Python Web框架，支持，HTTP 1.1和WSGI线程池。
Grok，基于Zope3的Web框架。
Bluebream，开源的Web应用服务器，原名Zope 3。
guava，轻量级，高性能的Python-Web框架，采用c语言编写。
django-cms，基于Django企业级开源CMS。
djedi-cms轻量级但功能强大的Django CMS的插件，内联编辑和性能优化。
FeinCMS，基于Django的先进内容管理系统。
Kotte，高层次的Python的Web应用框架，基于Pyramid。Mezzanine，强大，一致，灵活的内容管理平台。
Opps，基于Django的CMS，用于高流量的报纸、杂志和门户网站。
Plone，基于Zope的开源应用服务器Zope。
Quokka，灵活，可扩展的，轻量级的CMS系统，使用Flask和MongoDB。
Wagtail，Django内容管理系统。
Widgy，CMS框架，基于Django。
django-oscar，Django奥斯卡，开源的电子商务框架。
django-shop，基于Django的网店系统。
merchant，支持多种付款处理工具。
money，可扩展的货币兑换解决方案。
python-currencies，货币显示格式。
cornice，Pyramid的REST框架。
django-rest-framework，Django框架，强大灵活的工具，可以很容易地构建Web API。
django-tastypie，创造精美的Django应用程序API接口。
django-formapi，创建JSON API、HMAC认证和Django表单验证。flask-api，提供统一的浏览器体验，基于Django框架。
flask-restful，快速构建REST API支持扩展。
flask-api-utils，flask的扩展。falcon，猎鹰，高性能的Python框架，构建云API和Web应用程序后端。
eve，夏娃，REST API框架，使用Flask，MongoDB和良好意愿。
sandman，睡魔，为现有的数据库驱动的系统，自动生成REST API。restless，类似TastyPie的框架。
savory-pie，REST API构建函数库（Django，及其他）Jinja2，现代设计师友好的语言模板。
Genshi，网络感知输出模板工具包。
Mako，马可，Python平台的超高速、轻型模板。
Chameleon，变色龙，一个HTML / XML模板引擎。
仿照ZPT，优化速度。
Spitfire，快速的Python编译模板。
django-haystack,大海捞针,Django模块搜索。
elasticsearch-py,Elasticsearch官方低级的Python客户端。
solrpy,solr客户端。
Whoosh,呼,快速，纯Python搜索引擎库。
Feedly，建立新闻和通知系统的函数库，使用Cassandra和Redis。
django-activity-stream,Django活动流,从你网站上的行动,产生通用的活动流。
Beaker，烧杯，一个缓存和会话使用的Web应用程序，独立的Python脚本和应用程序库。
dogpile.cache，是Beaker作者的下一代替代作品。HermesCache，Python的缓存库，基于标签的失效及预防Dogpile效果。
django-cache-machine，Django缓存机，自动缓存失效，使用ORM。django-cacheops，自动颗粒事件驱动，ORM缓存失效。johnny-cache,约翰尼高速缓存框架,Django应用程序。
django-viewlet,渲染模板部件扩展缓存控制。pylibmc,在libmemcached接口。
WTForms-JSON,JSON表单数据处理扩展。Deform， HTML表单生成的函数库。
django-bootstrap3，bootstrap3，集成了Django。django-crispy-forms，Django程序，可以创建优雅的表单。django-remote-forms，Django的远程表单，Django表格的序列化程序。
django-simple-spam-blocker，Django简单的垃圾邮件拦截器。
django-simple-captcha，Django简单验证码，简单的和高度可定制的Django应用程序，用于添加验证码图像Ajenti，服务器管理面板。
Grappelli，界面花哨的django皮肤。django-suit，Django替代o界面（仅用于非商业用途）。
django-xadmin，Django管理面板替代工具。
flask-admin，简单的flask管理界面框架flower，实时监控和Web管理面板。
Pelican，鹈鹕，Markdown或ReST，字王内容主题。支持 DVCS, Disqus. AGPL。
Cactus,仙人掌,设计师的网站静态生成器。
Hyde，海德， 基于Jinja2的静态网站生成器。
Nikola，尼古拉-一个静态网站和博客生成器。
Tags，标签，最简单的静态网站生成器。
Tinkerer，工匠，基于Sphinx的静态网站生成器。
asyncio，（在Python 3.4 +是Python标准库），异步I/O，事件循环，协同任务。
gevent，基于Python的网络库。
Twisted，扭曲，事件驱动的网络引擎。
Tornado，龙卷风，Web框架和异步网络的函数库。
pulsar，脉冲星，事件驱动的并行框架的Python。
diesel，柴油，绿色的，基于事件的I/O框架。
eventlet，WSGI支持异步框架。
pyzmq， 0MQ消息库的Python封装。
txZMQ,基于Twisted的0MQ消息库封Crossbar,开源统一应用路由器（WebSocket和WAMP）。
wsgiref，Python标准库，WSGI封装实现，单线程。
Werkzeug，机床，WSGI工具函数库，很容易地嵌入到你自己的项目框架。
paste，粘贴，多线程，稳定的，久经考验的WSGI工具。
rocket，火箭，多线程服务，基于Pyramid。
netius，快速的、异步WSGI服务器，gunicorn，forked前身，部分用C写的。
fapws3，异步网络，用C写的。meinheld，异步WSGI服务器，是用C写的。
bjoern，-快速的、异步WSGI服务器，用C写的。
【安全】Permissions函数库，允许或拒绝用户访问数据或函数。
django-guardian,Django守护者，管理每个对象的权限，用于Django 1.2 +Carteblanche，管理导航和权限。
Authomatic，简单强大的认证/授权客户端。
OAuthLib， 通用，规范，OAuth请求签约工具。
rauth，用于OAuth 1.0，2.0，的Python库。
python-oauth2，利用全面测试，抽象接口来创建OAuth的客户端和服务器。
python-social-auth，易于安装的社会认证机制。
,django-oauth-toolkit,Django OAuth工具包django-oauth2-provider,Django OAuth2工具包。
django-allauth，Django认证的应用程序。
Flask-OAuthlib，Flask的OAuth工具包sanction，制裁，简单的oauth2客户端。
jose，[JavaScript]对象签名和加密(JOSE)草案实施，标记状态。
python-jwt，JSON的Web令牌生成和验证模块。
pyjwt，JSON的Web令牌草案01。
python-jws，JSON的Web令牌草案02。
PyCrypto，Python的加密工具包。
Paramiko，sshv2协议的实现，提供了客户端和服务器端的功能。
cryptography，密码开发工具包。
PyNac，网络和密码（NaCl）函数库。hashids，hashids的 Python函数库。
Passlib，安全的密码存储/哈希库，非常高的水平。
hashlib,md5, sha等hash算法，用来替换md5和sha模块，并使他们的API一致。
它由OpenSSL支持，支持如下算法：md5,sha1, sha224, sha256, sha384, sha512.
GUI
PyGtk，基于Python的GUI程序开发GTK+库
PyQt用于Python的QT开发库
WxPythonPython下的GUI编程框架，其消息机制与MFC的架构相似,入门非常简单，需要快速开发相关的应用可以使用这个
TkinterPython下标准的界面编程包，因此不算是第三方库了
PySide，跨平台Qt的应用程序和用户界面框架，支撑Qt v4框架。
wxPython，混合wxWidgets的C++类库。
kivy，创建应用程序GUI函数库，看运行于Windows，Linux，MAC OS X，[Android]和[iOS]。
curse，用于创建终端GUI应用程序。
urwid，创建终端GUI应用程序窗体的函数库，支持事件，色彩丰富。
pyglet，跨平台的窗口和多媒体库的Python。
Tkinter，是Python事实上的标准GUI软件包。
enaml，创建漂亮的用户界面，语法类似QML。
Toga，托加，OS原生GUI工具包。【构建封装】
pyenv,简单的Python版本管理。
virtualenv,创建独立的Python环境，用于同时安装不同版本的python环境。
virtualenvwrapper，是virtualenv的一组扩展。
pew,一套管理多个虚拟环境的工具。
vex，使运行指定的virtualenv命令。
PyRun，一个单文件，无需安装的Python版本管理工具。
PIP，Python包和依赖的管理工具。
easy_install，软件包管理系统,提供一个标准的分配Python软件和 函式库的格式。是一个附带设置工具的模块，和一个第三方函式库。旨在加快Python函式库的分配程式的速度。类似Ruby语言的RubyGems 。
conda，跨平台，二进制软件包管理器。,
Curdling，一个管理Python包的命令行工具。
wheel，Python发行的新标准，旨在替代eggs.
cx-Freeze，跨平台的，用于打包成可执行文件的库
py2exe, Windows平台的Freeze脚本工具，Py2exe ，将python脚本转换为windows上可以独立运行的可执行程序
py2app，MAC OS X平台的Freeze脚本工具
pyinstaller，-转换成独立的可执行文件的Python程序（跨平台）。
pynsist,构建Windows安装程序的工具，用Python编写。
dh-virtualenv,建立和分发virtualenv(Debian软件包格式)
PyPI，新一代的Python包库管理工具。
warehouse,新一代的Python包库（PyPI）管理工具。
devpi，PyPI服务器和包装/测试/发布工具。
localshop，PyPI官方包镜像服务器，支持本地（私人）包上传。
buildout，创建，组装和部署应用程序的多个部分，其中一些可能是非基于Python的。
SCons，软件构造工具。
platformio，一个控制台的工具，构建的代码可用于不同的开发平台。
bitbake，特殊设计的工具，用于创建和部署[嵌入式]Linux软件包
fabricate，自动为任何编程语言，生成依赖包。
django-compressor，Django压缩机，压缩和内联JavaScript或CSS，链接到一个单一的缓存文件。
jinja-assets-compressor，金贾压缩机，一个Jinja扩展，通过编译，压缩你的资源。
webassets，优化管理，静态资源，独特的缓存清除。
fanstatic，球迷，包优化，提供静态文件。
fileconveyor，监控资源变化，，可保存到CDN（内容分发网络）和文件系统。
django-storages，一组自定义存储Django后台。
glue，胶胶，一个简单的命令行工具，生成CSS Sprites。
libsass-python，Sass (层叠样式表)的Python接口。
Flask-Assets，整合应用程序资源。【代码调试】
unittest，Python标准库，单元测试框架。
nose，鼻子，unittest延伸产品。
pytest，成熟的全功能的Python测试工具。
mamba，曼巴，Python的权威测试工具。出自BDD的旗下。
contexts，背景，BDD测试框架，基于C#。
pyshould，should风格的测试框架，基于PyHamcrest.
pyvows，BDD风格测试框架
Selenium，web测试框架，Python绑定Selenium。
splinter，分裂，测试Web应用程序的开源工具。
locust，刺槐，可扩展的用户负载测试工具，用Python写的。
sixpack，语言无关的A/B测试框架。
mock，模拟对象（英语：mock object，也译作模仿对象），模拟测试库。
responses，工具函数，用于mock模拟测试。
doublex-强大的测试框架。
freezegun，通过时间调整，测试模块。
httpretty， HTTP请求的模拟工具。
httmock，mock模拟测试。
coverage，代码覆盖度量测试。
faker，生成模拟测试数据的Python包。
mixer，混频器，产生模拟数据，用于Django ORM，SQLAlchemy，
Peewee, MongoEngine, Pony ORM等
model_mommy，在Django创建测试随机工具。
ForgeryPy，易用的模拟数据发生器。
radar，雷达，生成随机日期/时间。
FuckIt.py，测试Python代码运行。
Code Analysispysonar2，Python类型索引。
pycallgraph,可视化的流量（调用图）应用程序。
code2flow,转换Python和JavaScript代码到流程图。
LinterFlake8，源代码模块检查器
pylama，Python和JavaScript代码审计工具。
Pylint，源代码分析器，它查找编程错误，帮助执行一个代码标准和嗅探一些代码味道。注意：相比于PyChecker，Pylint是一个高阶的Python代码分析工具，它分析Python代码中的错误。
Pyflakes，一个用于检查Python源文件错误的简单程序。Pyflakes分析程序并且检查各种错误。它通过解析源文件实现，无需导入。
pdb,Python标准库,Python调试器。
ipdb,IPython使用的PDB。
winpdb独立于平台的GUI调试器。
pudb，全屏，基于python调试控制台。
pyringe，-可附着于及注入代码到Python程序的调试器。
python-statsd，statsd服务器客户端。
memory_profiler， 内存监视。
profiling，交互式Python分析器。
django-debug-toolbar, Django调试工具栏,显示各种调试信息:当前请求/响应。
django-devserver,Django调试工具。
flask-debugtoolbar,flask调试工具。
struct模块
2022年7月25日
15:15
该模块可以把一个类型，如数字，转成固定长度的bytes
data = ``struct.pack('i',1111111111111) ``封包
head_json_len=struct.unpack('i',``data ``)[0]#``解包，元组
Pil模块
2022年6月2日
23:47
PIL``功能介绍与安装
PIL``，全称``Python Image Library``，主要作用是图像处理，可用于图片剪切、粘贴、缩放、镜像、水印、颜色块、滤镜、图像格式转换、色场空间转换、验证码、旋转图像、图像增强、直方图处理、插值和滤波等功能。不过只支持到``Python 2.7``。``Pillow``是``PIL``的一个派生分支，但如今已经发展成为比``PIL``本身更具活力的图像处理库。我们需要安装的就是``Pillow``。
PIL``具体用途：图像归档``(Image Archives)``。``PIL``非常适合于图像归档以及图像的批处理任务。你可以使用``PIL``创建缩略图，转换图像格式，打印图像等等。
``图像展示``(Image Display)``。``PIL``较新的版本支持包括``Tk PhotoImage``，``BitmapImage``还有``Windows DIB``等接口。``PIL``支持众多的``GUI``框架接口，可以用于图像展示。
``图像处理``(Image Processing)``。``PIL``包括了基础的图像处理函数，包括对点的处理，使用众多的卷积核``(convolution kernels)``做过滤``(filter),``还有颜色空间的转换。``PIL``库同样支持图像的大小转换，图像旋转，以及任意的仿射变换。``PIL``还有一些直方图的方法，允许你展示图像的一些统计特性。这个可以用来实现图像的自动对比度增强，还有全局的统计分析等。
pip install Pillow
PIL的基本操作
from PIL import Image
# 1.``打开图片
img = Image.open("image/10.png")
# 2.``显示图片``(``执行显示图片后线程会中断，关闭图像后恢复``)
img.show()
# 3.``保存图片
img.save("image/xiaomai.png")
我在尝试的过程中发现，``png``格式的图片保存为``jpg``格式时会报错：``OSError: cannot write mode RGBA as JPEG``，经过查阅资料发现错误原因主要是因为``PNG``格式和``JPG``格式图片的通道数不同。
PNG``是四通道：``RGBA``意思是红色，绿色，蓝色，``Alpha``的色彩空间，``Alpha``指透明度
JPG``是三通道：``RGB``意思是红色，绿色，蓝色
所以，``PNG``格式图片要保存成``JPG``格式就要丢弃``A``通道：
from PIL import Image
# 1.``打开图片
img = Image.open("image/10.png")
# 2.``显示图片``(``执行显示图片后线程会中断，关闭图像后恢复``)
img.show()
# 3.``保存图片
img = img.convert("RGB")
img.save("image/xiaomai.jpg")
下面是图片旋转的代码：
from PIL import Image
# 1.``打开图片
img = Image.open("pli/7.png")
# 2.``水平翻转
img1 = img.transpose(Image.FLIP_LEFT_RIGHT)
# 3.``保存图片
img1.save("pli/1.png")
# 4.``垂直翻转
img2 = img.rotate(180)
# 5.``保存照片
img2.save("pli/2.png")
# 6.``水平``+``垂直翻转
img3 = img.transpose(Image.FLIP_LEFT_RIGHT).rotate(180)
# 7.``保存图片
img3.save("pli/3.png")
给图片增加文字
要在图像上绘制文本要用到 PIL 的两个模块：ImageDraw和ImageFont。 ImageDraw 用于创建绘图对象，ImageFont用于加载字体。
from PIL import Image, ImageDraw, ImageFont
# 1.``打开图片
img = Image.open("image/10.png")
# 2.``调用画图模块
draw = ImageDraw.Draw(img)
# 3.``设置字体
tfont = ImageFont.truetype("``萌神手写体``.ttf", 24)
# 4.``添加文字
"""
``参数一：文字在图片的位置：``(x, y)
``参数二：文字内容
``参数三：字体颜色，当然颜色也可以用``RGB``值指定
``参数四：字体类型
"""
draw.text((50, 30), "eyes++", fill="green", font=tfont)
# 5.``保存图片
img.save("image/addWord.png")
# 6.``显示图片
img.show()
PIL滤镜功能
from PIL import Image, ImageFilter
img = Image.open("image/10.png")
img = img.filter(ImageFilter.CONTOUR)
img.save("image/Filter.png")
img.show()
PIL镜像功能
from PIL import Image
img = Image.open("image/10.png")
img = img.transpose(Image.FLIP_LEFT_RIGHT)
img.save("image/mirror.png")
transpose有这么几种模式
FLIP_LEFT_RIGHT：左右镜像
FLIP_TOP_BOTTOM：上下镜像
ROTATE_90：逆时针转90度
ROTATE_180：逆时针转180度
ROTATE_270：逆时针转270度
TRANSPOSE：像素矩阵转置
TRANSVERSE
最后一种模式我也不知道什么意思，也没查到，但效果是下面这样的，盲猜是对角线对转。。。。。
图片拼接功能
from PIL import Image, ImageDraw
# ``打开图片
img1 = Image.open("image/10.png")
img2 = Image.open("image/addWord.png")
# ``查看图片尺寸，便于拼接图片
print(img1.size)
print(img1.size)
# ``新建空白图片``,``三个参数分别是模式``(RGB/RGBA)``、大小、颜色
newimg = Image.new(mode="RGB", size=(1174, 614), color=(255, 100, 50))
# ``拼接图片``,``第一个参数是图片，第二个是起始位置
newimg.paste(img1, (0, 0))
newimg.paste(img2, (587, 0))
newimg.show()
PIL裁剪功能
from PIL import Image
img = Image.open("image/10.png")
print(img.size)
imgCut = img.crop((100, 200, 500, 600))
imgCut.show()
图片缩放
from PIL import Image
# :
img = Image.open('image/10.png')
# ``获得图像尺寸``:
w, h = img.size
# ``缩放到``50%:
img.thumbnail((w//2, h//2))
# ``把缩放后的图像用``jpeg``格式保存``:
img.save('image/zoom.png')
warnings — 非致命提醒
2022年10月13日
16:45
warnings — 非致命提醒
目的：向用户提供有关运行程序时遇到的问题的非致命警报
warnings ``模块由`` PEP 230 ``引入，作为一种警告程序员关于语言或库功能的变化的方法，以预测`` Python 3.0 ``带来的向后不兼容的变化。它还可用于报告从丢失的库中恢复的配置错误或功能退化。不过，最好是通过`` logging ``模块提供面向用户的消息，因为发送到控制台的警告可能丢失。
由于警告不是致命的，因此程序在运行过程中可能会多次遇到相同的警告情况。``warnings ``模块抑制来自同一来源的重复消息，以减少一遍又一遍地看到相同警告的烦恼。输出可以根据具体情况进行控制，使用解释器的命令行选项或调用`` warnings ``中的函数。
Python ``通过调用`` warnings ``模块中定义的`` warn() ``函数来发出警告``。警告消息通常用于提示用户一些错误或者过时的用法，当这些情况发生时我们不希望抛出异常或者直接退出程序。警告消息通常写入`` sys.stderr``，对警告的处理方式可以灵活的更改，例如忽略或者转变为为异常。警告的处理可以根据警告类别，警告消息的文本和发出警告消息的源位置而变化。对相同源位置的特定警告的重复通常被抑制。
警告控制分为两个阶段：
- 首先，警告被触发时，确定是否应该发出消息；
- 接下来，如果要发出消息，则使用用户可设置的钩子来格式化和打印消息。
filterwarnings()--警告过滤器
警告过滤器可以用来控制是否发出警告消息，警告过滤器是一些匹配规则和动作的序列。可以通过调用`` filterwarnings() ``将规则添加到过滤器，并通过调用`` resetwarnings() ``将其重置为默认状态。
showwarning()--警告消息
警告消息的输出是通过调用`` showwarning() ``函数来完成的，其可以被覆盖；该函数的默认实现通过调用`` formatwarning() ``格式化消息，这也可以由自定义实现使用。
警告类别
內建警告类型：
Warning 所有警告类别类的基类，它是 Exception 的子类
UserWarning 函数 warn() 的默认类别
DeprecationWarning 用于已弃用功能的警告（默认被忽略）
SyntaxWarning 用于可疑语法的警告
RuntimeWarning 用于有关可疑运行时功能的警告
FutureWarning 对于未来特性更改的警告
PendingDeprecationWarning 对于未来会被弃用的功能的警告（默认将被忽略）
ImportWarning 导入模块过程中触发的警告（默认被忽略）
UnicodeWarning 与 Unicode 相关的警告
BytesWarning 与 bytes 和 bytearray 相关的警告 (Python3)
ResourceWarning 与资源使用相关的警告(Python3)
可以通过继承內建警告类型来实现自定义的警告类型，警告类型必须始终是 Warning 类的子类。
警告过滤器
警告过滤器用于控制警告的行为，如忽略，显示或转换为错误（引发异常）。警告过滤器维护着一个有序的过滤规则列表，匹配规则用于确定如何处理警告，任何特定警告都将依次与列表中的每个过滤规则匹配，直到找到匹配为止。过滤规则类型为一个元组 (action，message，category，module，lineno)，其中：
- action 为以下值：
值 处理方式
"error" 将匹配警告转换为异常
"ignore" 忽略匹配的警告
"always" 始终输出匹配的警告
"default" 对于同样的警告只输出第一次出现的警告
"module" 在一个模块中只输出第一次出现的警告
"once" 输出第一次出现的警告,而不考虑它们的位置
- message 是包含正则表达式的字符串，警告消息的开始必须匹配，不区分大小写
- category 是一个警告类型（必须是 Warning 的子类）
- module 是包含模块名称的正则表达式字符串，区分大小写
- lineno 是一个整数，警告发生的行号，为 0 则匹配所有行号
默认警告过滤器
默认情况下，``Python ``设置了几个警告过滤器，可以通过`` -W ``命令行选项和调用`` filterwarnings() ``函数来覆盖它们。
DeprecationWarning ``和`` PendingDeprecationWarning ``和`` ImportWarning ``被默认忽略。
除非`` -b ``选项给出一次或两次，否则忽略`` BytesWarning``；在这种情况下，此警告或者被输出（``-b``）或者变成异常（``-bb``）。
除非`` Python ``是在调试模式下构建的，否则将忽略`` ResourceWarning``。
在`` 3.2 ``版中的调整``: ``除`` PendingDeprecationWarning ``之外，默认情况下将忽略`` DeprecationWarning
可用函数
1. warn
warnings.warn(message, category=None, stacklevel=1, source=None)
触发异常。``category`` ``参数默认为`` ``UserWarning``。``message`` ``参数为警告消息，可以是`` ``Warning`` ``实例，在这种情况下，将忽略`` ``category`` ``并使用`` ``message.__class__``，消息文本则为`` ``str(message)``。
warn_explicit
warnings.warn_explicit(message, category, filename, lineno, module=None, registry=None, module_globals=None, source=None)
是 warn() 函数的低级接口，明确传递消息，类别，文件名和行号，以及可选的模块名称和注册表（应该是模块的 warningregistry 字典）
3.showwarning
warnings.showwarning(message, category, filename, lineno, file=None, line=None)
写入警告到文件。默认调用`` formatwarning(message, category, filename, lineno, line) ``并将结果字符串写入`` file``，默认为`` sys.stderr``。`` line ``是包含在警告消息中的一行源代码；如果未提供则尝试读取由`` filename ``和`` lineno ``指定的行。
simplefilter
warnings.simplefilter(action, category=Warning, lineno=0, append=False)
简单易用的过滤器，类似 filterwarnings() 函数，但是不需要正则表达式。
resetwarnings
warnings.resetwarnings()
重置警告过滤器。这会丢弃所有以前对 filterwarnings() 调用的影响，包括 -W 命令行选项和对 simplefilter() 的调用的影响。
生成警告
发出警告的最简单方法是使用消息作为参数调用`` ``warn()`` ``。
import warnings
print('Before the warning')
warnings.warn('This is a warning message')
print('After the warning')
Socketserver模块
2022年7月25日
21:01
基于tcp的套接字，关键就是两个循环，
一个链接循环，一个通信循环
socketserver模块中分两大类：
server类（解决链接问题）
request类（解决通信问题）
server类：
request类：
继承关系:
以下述代码为例，分析socketserver源码：
ftpserver=socketserver.ThreadingTCPServer(('17.0.0.1',8080),FtpServer)
ftpserver.serve_forever()
查找属性的顺序：ThreadingTCPServer->ThreadingMixIn->TCPServer->BaseServer
- 实例化得到ftpserver，先找类ThreadingTCPServer的__init__,在TCPServer中找到，进而执行server_bind,server_active
- 找ftpserver下的serve_forever,在BaseServer中找到，进而执行self._handle_request_noblock()，该方法同样是在BaseServer中
- 执行self._handle_request_noblock()进而执行request, client_address = self.get_request()（就是TCPServer中的self.socket.accept()），然后执行self.process_request(request, client_address)
- 在ThreadingMixIn中找到process_request，开启多线程应对并发，进而执行process_request_thread，执行self.finish_request(request, client_address)
上述四部分完成了链接循环，本部分开始进入处理通讯部分，在BaseServer中找到finish_request,触发我们自己定义的类的实例化，去找__init__方法，而我们自己定义的类没有该方法，则去它的父类也就是BaseRequestHandler中找....
源码分析总结：
基于tcp的socketserver我们自己定义的类中的
- self.server即套接字对象
- self.request即一个链接
- self.client_address即客户端地址
基于udp的socketserver我们自己定义的类中的
- self.request是一个元组
（第一个元素是客户端发来的数据，第二部分是服务端的udp套接字对象），
如(b'adsf', <socket.socket fd=200, family=AddressFamily.AF_INET, type=SocketKind.SOCK_DGRAM, proto=0, laddr=('127.0.0.1', 8080)>)
- self.client_address即客户端地址
multiprocessing模块
2022年7月27日
12:50
介绍
multiprocessing模块的功能众多：支持子进程、通信和共享数据、执行不同形式的同步，提供了Process、Queue、Pipe、Lock等组件。
与线程不同，进程没有任何共享状态，进程修改的数据，改动仅限于该进程内。
Process类的介绍
创建进程的类
Process([group [, target [, name [, args [, kwargs]]]]])``，由该类实例化得到的对象，表示一个子进程中的任务（尚未启动）
强调：`
`1. ``需要使用关键字的方式来指定参数`
`2. args``指定的为传给``target``函数的位置参数，是一个元组形式，必须有逗号
参数
group``参数未使用，值始终为``None
target``表示调用对象，即子进程要执行的任务
args``表示调用对象的位置参数元组，``args=(1,2,'egon',)
kwargs``表示调用对象的字典``,kwargs={'name':'egon','age':18}
name``为子进程的名称
方法介绍
p.start()``：启动进程，并调用该子进程中的``p.run()
p.run():``进程启动时运行的方法，正是它去调用``target``指定的函数，我们自定义类的类中一定要实现该方法
p.terminate():``强制终止进程``p``，不会进行任何清理操作，如果``p``创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果``p``还保存了一个锁那么也将不会被释放，进而导致死锁
p.is_alive():``如果``p``仍然运行，返回``True
p.join([timeout]):``主线程等待``p``终止（强调：是主线程处于等的状态，而``p``是处于运行的状态）。``timeout``是可选的超时时间，需要强调的是，``p.join``只能``join``住``start``开启的进程，而不能``join``住``run``开启的进程
属性介绍
p.daemon``：默认值为``False``，如果设为``True``，代表``p``为后台运行的守护进程，当``p``的父进程终止时，``p``也随之终止，并且设定为``True``后，``p``不能创建自己的新进程，必须在``p.start()``之前设置
p.name:``进程的名称
p.pid``：进程的``pid
p.exitcode:``进程在运行时为``None``、如果为``–``N``，表示被信号``N``结束``(``了解即可``)
p.authkey:``进程的身份验证键``,``默认是由``os.urandom()``随机生成的``32``字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性，这类连接只有在具有相同的身份验证键时才能成功（了解即可）
僵尸进程与孤儿进程
一：僵尸进程（有害）
僵尸进程：
一个进程使用fork创建子进程，如果子进程退出，而父进程并没有调用wait或waitpid获取子进程的状态信息，那么子进程的进程描述符仍然保存在系统中。这种进程称之为僵死进程。
二：孤儿进程（无害）
孤儿进程：
一个父进程退出，而它的一个或多个子进程还在运行，那么那些子进程将成为孤儿进程。孤儿进程将被init进程(进程号为1)所收养，并由init进程对它们完成状态收集工作。
孤儿进程是没有父进程的进程，孤儿进程这个重任就落到了init进程身上，init进程就好像是一个民政局，专门负责处理孤儿进程的善后工作。每当出现一个孤儿进程的时候，内核就把孤 儿进程的父进程设置为init，而init进程会循环地wait()它的已经退出的子进程。这样，当一个孤儿进程凄凉地结束了其生命周期的时候，init进程就会代表党和政府出面处理它的一切善后工作。因此孤儿进程并不会有什么危害。
解决僵尸进程
等待父进程正常结束后会调用wait／waitpid去回收僵尸进程
但如果父进程是一个死循环，永远不会结束，那么该僵尸进程就会一直存在，僵尸进程过多，就是有害的
解决方法一：杀死父进程
解决方法二：对开启的子进程应该记得使用join，join会回收僵尸进程
解决方法三：
signal(``参数一``,``参数二``)
参数一：我们要进行处理的信号。系统的信号我们可以再终端键入 kill -l查看(共64个)。其实这些信号时系统定义的宏。
参数二：我们处理的方式（是系统默认还是忽略还是捕获）。可以写一个handdle函数来处理我们捕获的信号。
SIGCHLD信号
子进程结束时, 父进程会收到这个信号。
如果父进程没有处理这个信号，也没有等待(wait)子进程，子进程虽然终止，但是还会在内核进程表中占有表项，这时的子进程称为僵尸进程。这种情 况我们应该避免(父进程或者忽略SIGCHILD信号，或者捕捉它，或者wait它派生的子进程，或者父进程先终止，这时子进程的终止自动由init进程 来接管)。
SIG_ING
忽略的意思
守护进程
主进程创建守护进程
其一：守护进程会在主进程代码执行结束后就终止
其二：守护进程内无法再开启子进程,否则抛出异常：AssertionError: daemonic processes are not allowed to have children
注意：进程之间是互相独立的，主进程代码运行结束，守护进程随即终止
使用：``p.daemon=True #``一定要在``p.start()``前设置``,``设置``p``为守护进程``,``禁止``p``创建子进程``,``并且父进程代码执行结束``,p``即终止运行
案例：
frommultiprocessing import Process`
`import time`
`import random
class Piao(Process):`
` def__init__(self,name):`
` self.name=name`
` super().__init__()`
` def run(self):`
` print('%s is piaoing'%self.name)`
` time.sleep(random.randrange(1,3))`
` print('%s is piao end'%self.name)
p=Piao('egon')`
`p.daemon=True #``一定要在``p.start()``前设置``,``设置``p``为守护进程``,``禁止``p``创建子进程``,``并且父进程代码执行结束``,p``即终止运行
p.start()`
`print('``主``')
进程锁
进程之间数据不共享,但是共享同一套文件系统,所以访问同一个文件,或同一个打印终端,是没有问题的,
而共享带来的是竞争，竞争带来的结果就是错乱，如何控制，就是加锁处理
案例一：多个进程共享同一打印终端
未加锁：#并发运行,效率高,但竞争同一打印终端,带来了打印错乱
加锁: #由并发变成了串行,牺牲了运行效率,但避免了竞争
案例二：多个进程共享同一文件
未加锁：并发写入，效率高，但是竞争同一个文件，到时数据错乱
加锁：并发变成了串行，牺牲了运行效率，但是保证了数据的安全
总结：
#加锁可以保证多个进程修改同一块数据时，同一时间只能有一个任务可以进行修改，即串行的修改，没错，速度是慢了，但牺牲了速度却保证了数据安全。虽然可以用文件共享数据实现进程间通信，但问题是：
1.效率低（共享数据基于文件，而文件是硬盘上的
数据）
2.需要自己加锁处理
#因此我们最好找寻一种解决方案能够兼顾：
1、效率高（多个进程共享一块内存的数据）
2、帮我们处理好锁问题。
这就是mutiprocessing模块为我们提供的基于消息的IPC通信机制：队列和管道。
1 队列和管道都是将数据存放于内存中
2 队列又是基于（管道+锁）实现的，可以让我们从复杂的锁问题中解脱出来，
我们应该尽量避免使用共享数据，尽可能使用消息传递和队列，避免处理复杂的同步和锁问题，而且在进程数目增多时，往往可以获得更好的可获展性。
队列
进程彼此之间互相隔离，要实现进程间通信（IPC），multiprocessing模块支持两种形式：队列和管道，这两种方式都是使用消息传递的
创建队列的类（底层就是以管道和锁定的方式实现）：
Queue([maxsize]):创建共享的进程队列，Queue是多进程安全的队列，可以使用Queue实现多进程之间的数据传递。
maxsize是队列中允许最大项数，省略则无大小限制。
方法介绍：
q.put
方法用以插入数据到队列中，``put``方法还有两个可选参数：``blocked``和``timeout``。如果``blocked``为``True``（默认值），并且``timeout``为正值，该方法会阻塞``timeout``指定的时间，直到该队列有剩余的空间。如果超时，会抛出``Queue.Full``异常。如果``blocked``为``False``，但该``Queue``已满，会立即抛出``Queue.Full``异常。
q.get
方法可以从队列读取并且删除一个元素。
get``方法有两个可选参数：``blocked``和``timeout``。
如果``blocked``为``True``（默认值），并且``timeout``为正值，那么在等待时间内没有取到任何元素，会抛出``Queue.Empty``异常。
如果``blocked``为``False``，有两种情况存在，如果``Queue``有一个值可用，则立即返回该值，否则，如果队列为空，则立即抛出``Queue.Empty``异常``.
q.get_nowait():``同``q.get(False)
q.put_nowait():``同``q.put(False)
q.empty():
调用此方法时``q``为空则返回``True``，该结果不可靠，比如在返回``True``的过程中，如果队列中又加入了项目。
q.full()``：
调用此方法时``q``已满则返回``True``，该结果不可靠，比如在返回``True``的过程中，如果队列中的项目被取走。
q.qsize():
返回队列中目前项目的正确数量，结果也不可靠，理由同``q.empty()``和``q.full()``一样
q.cancel_join_thread():
不会在进程退出时自动连接后台线程。可以防止``join_thread()``方法阻塞
q.close():
关闭队列，防止队列中加入更多数据。
调用此方法，后台线程将继续写入那些已经入队列但尚未写入的数据，但将在此方法完成时马上关闭。如果``q``被垃圾收集，将调用此方法。关闭队列不会在队列使用者中产生任何类型的数据结束信号或异常。例如，如果某个使用者正在被阻塞在``get()``操作上，关闭生产者中的队列不会导致``get()``方法返回错误。
q.join_thread()``：
连接队列的后台线程。此方法用于在调用``q.close()``方法之后，等待所有队列项被消耗。默认情况下，此方法由不是``q``的原始创建者的所有进程调用。调用``q.cancel_join_thread``方法可以禁止这种行为
进程池
在利用Python进行系统管理的时候，特别是同时操作多个文件目录，或者远程控制多台主机，并行操作可以节约大量的时间。多进程是实现并发的手段之一，需要注意的问题是：
- 很明显需要并发执行的任务通常要远大于核数
- 一个操作系统不可能无限开启进程，通常有几个核就开几个进程
- 进程开启过多，效率反而会下降（开启进程是需要占用系统资源的，而且开启多余核数目的进程也无法做到并行）
例如当被操作对象数目不大时，可以直接利用multiprocessing中的Process动态成生多个进程，十几个还好，但如果是上百个，上千个。。。手动的去限制进程数量却又太过繁琐，此时可以发挥进程池的功效。
我们就可以通过维护一个进程池来控制进程数目，比如httpd的进程模式，规定最小进程数和最大进程数...
ps：对于远程过程调用的高级应用程序而言，应该使用进程池，Pool可以提供指定数量的进程，供用户调用，当有新的请求提交到pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到规定最大值，那么该请求就会等待，直到池中有进程结束，就重用进程池中的进程。
创建进程池的类：
如果指定numprocess为3，则进程池会从无到有创建三个进程，然后自始至终使用这三个进程去执行所有任务，不会开启其他进程
Pool([numprocess [,initializer [, initargs]]]):``创建进程池``
参数介绍
1 numprocess:``要创建的进程数，如果省略，将默认使用``cpu_count()``的值`
`2 initializer``：是每个工作进程启动时要执行的可调用对象，默认为``None`
`3 initargs``：是要传给``initializer``的参数组
方法介绍
p.apply(func[,args[,kwargs]]):
在一个池工作进程中执行``func(*args,**kwargs),``然后返回结果。需要强调的是：此操作并不会在所有池工作进程中并执行``func``函数。如果要通过不同参数并发地执行``func``函数，必须从不同线程调用``p.apply()``函数或者使用``p.apply_async()
p.apply_async(func[,args[,kwargs]]):
在一个池工作进程中执行``func(*args,**kwargs),``然后返回结果。此方法的结果是``AsyncResult``类的实例，``callback``是可调用对象，接收输入参数。当``func``的结果变为可用时，将理解传递给``callback``。``callback``禁止执行任何阻塞操作，否则将接收其他异步操作中的结果。
p.close():
关闭进程池，防止进一步操作。如果所有操作持续挂起，它们将在工作进程终止前完成
P.jion():
等待所有工作进程退出。此方法只能在``close``（）或``teminate()``之后调用
obj.get():
返回结果，如果有必要则等待结果到达。``timeout``是可选的。如果在指定时间内还没有到达，将引发一场。如果远程操作中引发了异常，它将在调用此方法时再次被引发。
obj.ready():
如果调用完成，返回``True
obj.successful():
如果调用完成且没有引发异常，返回``True``，如果在结果就绪之前调用此方法，引发异常
obj.wait([timeout]):
等待结果变为可用。
obj.terminate()``：
立即终止所有工作进程，同时不执行任何清理或结束任何挂起工作。如果``p``被垃圾回收，将自动调用此函数
wsgiref
2022年9月7日
11:41
wsgiref 是Python标准库给出的 WSGI 的参考实现。
WSGI是Python Web 开发中为服务器程序和应用程序设定的标准，满足这一标准的服务器程序和应用程序可以配合使用。我在上一篇博文《WSGI简介》中对此有详细的介绍。在阅读wsgiref源代码之前，一定要对WSGI有一定了解。
WSGI 在 PEP 333 中描述，但是只靠阅读PEP 333 可能在理解上还是不够深入，所以阅读官方给出的参考实现是很有必要的。阅读完这份源代码后，不仅有利于对WSGI的理解。而且会让你对服务端程序如何对客户端请求有一个直观的理解，从相对底层的socket监听请求，到上层对HTTP请求的处理。
当然，这只是对WSGI的参考实现，目的是为了描述清楚WSGI，而不是真正用在产品中。如果想对Python Web开发中服务器端的实现有更广泛，更深入的理解，需要进一步阅读Python常用框架的源代码。
wsgiref 源代码分析
wsgiref 源代码可以在 pypi wsgiref 0.1.2 下载。另外，我在阅读的过程中作了大量注释，包含模块介绍，调用层次关系，demo的运行结果，等 等，还包含了阅读过程中制作的思维导图。GitHub地址注释版wsgiref。
结构
上图描述了wsgiref的所有模块及模块间的调用关系，可以看出，wsgiref有以下模块：
simple_server
这一模块实现了一个简单的 HTTP 服务器，并给出了一个简单的 demo，运行：
python simple_server.py
会启动这个demo，运行一次请求，并把这次请求中涉及到的环境变量在浏览器中显示出来。
handlers
simple_server模块将HTTP服务器分成了 Server 部分和Handler部分，前者负责接收请求，后者负责具体的处理， 其中Handler部分主要在handlers中实现。
headers
这一模块主要是为HTTP协议中header部分建立数据结构。
util
这一模块包含了一些工具函数，主要用于对环境变量，URL的处理。
validate
这一模块提供了一个验证工具，可以用于验证你的实现是否符合WSGI标准。
simple_server
可以看出，simple_server 模块主要有两部分内容
应用程序
函数demo_app是应用程序部分
服务器程序
服务器程序主要分成Server 和 Handler两部分，另外还有一个函数 make_server 用来生成一个服务器实例
我们先看应用程序部分。
注意：以 M:开始的都是我自己添加的注释，不包含在最初的源代码中。
def demo_app(environ,start_response):
# M: StringIO reads and writes a string buffer (also known as memory files).
from StringIO import StringIO
stdout = StringIO()
print >> stdout, "Hello world!"
print >> stdout
h = environ.items()
h.sort()
for k,v in h:
print >> stdout, k,'=',v``
start_response("200 OK", [('Content-Type','text/plain')])
return [stdout.getvalue()]
这里可以看出，这个 demo_app 是如何展示WSGI中对应用程序的要求的：
demo_app 有两个参数
第一个参数 environ是一个字典
第二个参数 start_response是一个可调用函数
demo_app 返回一个可迭代对象
demo_app 需要调用 start_response
另外，可以看出，返回的内容就是环境变量当前的内容，这一点可以运行
python simple_server.py
在浏览器中看到的内容，就是上述源代码的for循环中输出的。
这里，使用了 StringIO ，可以看出，所有输出的内容都先存储在其实例中，最后返回的时候一起在可迭代对象中返回。
接下来，我们看服务器程序。
先从 make_server 看起，它是用来生成一个server实例的：
def make_server(
host, port, app, server_class=WSGIServer, handler_class=WSGIRequestHandler
):
"""Create a new WSGI server listening on `host` and `port` for `app`"""
# M: -> HTTPServer.__init__
# -> TCPServer.__init__
# -> TCPServer.server_bind
# -> TCPServer.socket.bind
# -> TCPServer.server_activate
# -> TCPServer.socket.listen
server = server_class((host, port), handler_class)
# M: conresponding to WSGIRequestHandler.handle()
# -> handler.run(self.server.get_app())
server.set_app(app)
return server
虽然代码只有三行，但是可以看出生成一个 server 都需要些什么：
(host, port)
主机名和端口号
handler_class
用于处理请求的handler类
app 服务器程序在处理时，一定会调用我们之前写好的应用程序，这样他们才能配合起来为客户端面服务，所以，你看到了那个 set_app 调用。
另外，在注释部分，你可以看到那代码背后都发生了什么。
生成 server 实例时，默认的 server_class 是 WSGIServer，它是HTTPServer的子类，后者又是TCPServer的子类，所以初始化 server 时，会沿着类的继承关系执行下去，最终，生成 server 实例的过程，其实是最底层的 TCPServer 在初始化时，完成了对socket的bind和listen。
后面的 set_app 设置了 app，它会在 handler_class (默认为WSGIRequestHandler)的handle函数中被取出来，然后交给 handler 的 run 函数运行。
好，现在我们开始介绍Server部分的主要内容，即WSGIServer和WSGIRequestHandler，首先，我们看一下二者的继承体系。
WSGIServer
# M:
# +------------+
# | BaseServer |
# +------------+
# |
# V
# +------------+
# | TCPServer |
# +------------+
# |
# V
# +------------+
# | HTTPServer |
# +------------+
# |
# V
# +------------+
# | WSGIServer |
# +------------+
可以看出 WSGIServer 来自 HTTPServer，后者来自 Python 标准库中的BaseHTTPServer模块，更上层的TCPServer和BaseServer来自 Python 标准库中的 SocketServer 模块。
WSGIRequestHandler
# M:
# +--------------------+
# | BaseRequestHandler |
# +--------------------+
# |
# V
# +-----------------------+
# | StreamRequestHandler |
# +-----------------------+
# |
# V
# +------------------------+
# | BaseHTTPRequestHandler |
# +------------------------+
# |
# V
# +--------------------+
# | WSGIRequestHandler |
# +--------------------+
可以看出 WSGIRequestHandler 来自 BaseHTTPRequestHandler，后者来自 Python 标准库中的BaseHTTPServer模块，更上层的StreamRequestHandler和BaseRequestHandler来自 Python 标准库中的 SocketServer 模块。
这时候，三个模块之间的层次关系我们可以理清楚了。
# M:
# +-----------------------------------------------+
# | simple_server: WSGIServer, WSGIRequestHandler |
# | |
# +-----------------------------------------------+
# |
# V
# +----------------------------------------------------+
# | BaseHTTPServer: HTTPServer, BaseHTTPRequestHandler |
# +----------------------------------------------------+
# |
# V
# +----------------------------------------------------+
# | SocketServer: TCPServer,BaseSErver; |
# | StreamRequestHandler,BaseRequestHandler |
# +----------------------------------------------------+
#
另外，这一模块中还有一个类，叫ServerHandler，它继承自 handlers 模块中的 SimpleHandler，我们再看看它的继承体系：
# M:
# +-------------+
# | BaseHandler |
# +-------------+
# |
# V
# +----------------+
# | SimpleHandler |
# +----------------+
# |
# V
# +---------------+
# | ServerHandler |
# +---------------+
#
好了，现在这个模块中的继承结构都弄清楚了，现在我们看看他们如何配合起来完成对客户端请求的处理。
首先，回顾simple_server涉及的模块：
WSGIServer
WSGIRequestHandler
ServerHandler
demo_app
make_server
然后，把大脑清空，想一下要对客户端请求进行处理需要做什么
启动服务器，监听客户端请求
请求来临，处理用户请求
我们看看这几个模块是如何配合完成这两个功能的
先看看 simple_server 模块的 main 部分，即执行
python simple_server.py
时执行的内容:
httpd = make_server('', 8000, demo_app)
sa = httpd.socket.getsockname()
print "Serving HTTP on", sa[0], "port", sa[1], "..."
# M: webbrowser provides a high-level interface to allow displaying Web-based documents
# to users. Under most circumstances
import webbrowser
webbrowser.open('http://localhost:8000/xyz?abc')
httpd.handle_request() # serve one request, then exit
可以看出，主要完成的功能是：
启动服务器
模块用户请求
处理用户请求
那么，我们主要关心的就是 make_server 和 handle_request 背后都发生了什么。
make_server
上图可以看出函数之间的调用关系，也可以看出 make_server 到 使用 socket 监听用户请求的过程。
handle_request
handle_request 的过程真正将各个模块联系起来了。
上图很清楚地说明了 由handle_request到demo_app的执行过程，把这个模块的各个部分联系起来。相信无需多言了。
Handlers
从图中可以看出handler模块中的四部分，它们其实是四个类，
从基类到子类依次为：
BaseHandler
SimpleHandler
BaseCGIHandler
CGIHandler
最主要的实现在 BaseHandler中，其它几个类都是在基类基础上做了简单的实现。BaseHandler是不能直接使用的，因为有几个关键的地方没有实现，SimpleHandler是一个可以使用的简单实现。simple_server中的 ServerHandler类就是这个模块中SimpleHandler的子类。
在 BaseHandler中，最重要的是 run 函数：
def run(self, application):
"""Invoke the application"""
# Note to self: don't move the close()! Asynchronous servers shouldn't
# call close() from finish_response(), so if you close() anywhere but
# the double-error branch here, you'll break asynchronous servers by
# prematurely closing. Async servers must return from 'run()' without
# closing if there might still be output to iterate over.
try:
self.setup_environ()
self.result = application(self.environ, self.start_response)
self.finish_response()
except:
try:
self.handle_error()
except:
# If we get an error handling an error, just give up already!
self.close()
raise # ...and let the actual server figure it out.
它先设置好环境变量，再调用我们的 demo_app, 并通过 finish_response 将调用结果传送给客户端。如果处理过程遇到错误，转入 handle_error 处理。
此外，BaseHandler中还包含了 WSGI 中多次提到的 start_response，start_response 在 demo_app 中被调用，我们看看它的实现：
def start_response(self, status, headers,exc_info=None):
"""'start_response()' callable as specified by PEP 333"""
# M:
# exc_info:
# The exc_info argument, if supplied, must be a Python sys.exc_info()
# tuple. This argument should be supplied by the application only if
# start_response is being called by an error handler.
# exc_info is the most recent exception catch in except clause
# in error_output:
# start_response(
# self.error_status,self.error_headers[:],sys.exc_info())
# headers_sent:
# when send_headers is invoked, headers_sent = True
# when close is invoked, headers_sent = False
if exc_info:
try:
if self.headers_sent:
# Re-raise original exception if headers sent
raise exc_info[0], exc_info[1], exc_info[2]
finally:
exc_info = None # avoid dangling circular ref
elif self.headers is not None:
raise AssertionError("Headers already set!")
assert type(status) is StringType,"Status must be a string"
assert len(status)>=4,"Status must be at least 4 characters"
assert int(status[:3]),"Status message must begin w/3-digit code"
assert status[3]==" ", "Status message must have a space after code"
if __debug__:
for name,val in headers:
assert type(name) is StringType,"Header names must be strings"
assert type(val) is StringType,"Header values must be strings"
assert not is_hop_by_hop(name),"Hop-by-hop headers not allowed"
# M: set status and headers
self.status = status
# M:
# headers_class is Headers in module headers
self.headers = self.headers_class(headers)
return self.write
可以看出，它先对参数进行了检查，然后再将headers 存储在成员变量中，这两点 WSGI标准中都有明确说明，需要检查参数，并且这一步只能将 headers存储起来，不能直接发送给客户端。也就是说，这个 start_response 还没有真正 response。
其实刚刚介绍 run 函数的时候已经提到了，真正的 response 在 finish_response 函数中：
def finish_response(self):
"""Send any iterable data, then close self and the iterable
Subclasses intended for use in asynchronous servers will
want to redefine this method, such that it sets up callbacks
in the event loop to iterate over the data, and to call
'self.close()' once the response is finished.
"""
# M:
# result_is_file:
# True if 'self.result' is an instance of 'self.wsgi_file_wrapper'
# finish_content:
# Ensure headers and content have both been sent
# close:
# Close the iterable (if needed) and reset all instance vars
if not self.result_is_file() or not self.sendfile():
for data in self.result:
self.write(data) # send data by self.write
self.finish_content()
self.close()
另外一个需要注意的地方是错误处理，在 run 函数中通过 try/except 捕获错误，错误处理使用了 handle_error 函数，WSGI中提到，start_response 函数的第三个参数 exc_info 会在错误处理的时候使用，我们来看看它是如何被使用的：
def handle_error(self):
"""Log current error, and send error output to client if possible"""
self.log_exception(sys.exc_info())
if not self.headers_sent:
self.result = self.error_output(self.environ, self.start_response)
self.finish_response()
# XXX else: attempt advanced recovery techniques for HTML or text?
def error_output(self, environ, start_response):
"""WSGI mini-app to create error output
By default, this just uses the 'error_status', 'error_headers',
and 'error_body' attributes to generate an output page. It can
be overridden in a subclass to dynamically generate diagnostics,
choose an appropriate message for the user's preferred language, etc.
Note, however, that it's not recommended from a security perspective to
spit out diagnostics to any old user; ideally, you should have to do
something special to enable diagnostic output, which is why we don't
include any here!
"""
# M:
# sys.exc_info():
# Return information about the most recent exception caught by an except
# clause in the current stack frame or in an older stack frame.
start_response(self.error_status,self.error_headers[:],sys.exc_info())
return [self.error_body]
看到了吧，handle_error 又调用了 error_output ，后者调用 start_response，并将其第三个参数设置为 sys.exc_info()，这一点在 WSGI 中也有说明。
好了，这一部分我们就介绍到这里，不再深入过多的细节，毕竟源代码还是要自己亲自阅读的。剩下的三个部分不是核心问题，就是一些数据结构和工具函数，我们简单说一下。
Headers
这个模块是对HTTP 响应部分的头部设立的数据结构，实现了一个类似Python 中 dict的数据结构。可以看出，它实现了一些函数来支持一些运算符，例如 len, setitem, getitem, delitem, str, 另外，还实现了 dict 操作中的get, keys, values函数。
Util
这个模块主要就是一些有用的函数，用于处理URL, 环境变量。
Validate
这个模块主要是检查你对WSGI的实现，是否满足标准，包含三个部分：
validator
Wrapper
Check
validator 调用后面两个部分来完成验证工作，可以看出Check部分对WSGI中规定的各个部分进行了检查。
Jinja2
2022年9月7日
12:29
jinja2介绍
jinja2是Flask作者开发的一个模板系统，起初是仿django模板的一个模板引擎，为Flask提供模板支持，由于其灵活，快速和安全等优点被广泛使用。
jinja2的优点
jinja2之所以被广泛使用是因为它具有以下优点：
-
- 相对于Template，jinja2更加灵活，它提供了控制结构，表达式和继承等。
- 相对于Mako，jinja2仅有控制结构，不允许在模板中编写太多的业务逻辑。
- 相对于Django模板，jinja2性能更好。
- Jinja2模板的可读性很棒。
安装jinja2
由于jinja2属于第三方模块，首先需要对其进行安装
| 1 | pip3 install jinja2 |
|---|---|
测试模板是否安装成功
1 2 3 4 |
python -c "import jinja2" # ``没有报错就表示安装成功 # ``必须用双引号``" |
|---|---|
jinja2语法
作为一个模板系统，它还提供了特殊的语法，我们按照它支持的语法进行编写之后，就能使用jinja2模块进行渲染。
基本语法
在jinja2中，存在三种语法：
-
- 控制结构
- 变量取值 {{ }}
- 注释
下面是一个简单的jinja2例子
1 2 3 4 5 6 7 |
{# This is jinja code {% for file in filenames %} ... {% endfor %} #} |
|---|---|
可以看到，for循环的使用方式和Python比较类似，但是没有了句尾的冒号，另外需要使用endfor最为结尾，其实在jinja2中，if也是一样的，结尾需要使用endif。
jinja2变量
jinja2模板中使用 {{ }} 语法表示一个变量，它是一种特殊的占位符。当利用jinja2进行渲染的时候，它会把这些特殊的占位符进行填充/替换，jinja2支持python中所有的Python数据类型比如列表、字段、对象等。
1 2 3 |
<p>this is a dicectory:{{ mydict['key'] }} </p> <p>this is a list:{{ mylist[3] }} </p> <p>this is a object:{{ myobject.something() }} </p> |
|---|---|
jinja2中的过滤器
变量可以通过“过滤器”进行修改，过滤器可以理解为是jinja2里面的内置函数和字符串处理函数。
常用的过滤器有：
| 过滤器名称 | 说明 |
|---|---|
| safe | 渲染时值不转义 |
| capitialize | 把值的首字母转换成大写，其他子母转换为小写 |
| lower | 把值转换成小写形式 |
| upper | 把值转换成大写形式 |
| title | 把值中每个单词的首字母都转换成大写 |
| trim | 把值的首尾空格去掉 |
| striptags | 渲染之前把值中所有的HTML标签都删掉 |
| join | 拼接多个值为字符串 |
| replace | 替换字符串的值 |
| round | 默认对数字进行四舍五入，也可以用参数进行控制 |
| int | 把值转换成整型 |
那么如何使用这些过滤器呢？ 只需要在变量后面使用管道(|)分割，多个过滤器可以链式调用，前一个过滤器的输出会作为后一个过滤器的输入。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 | {{ 'abc' | captialize }} # Abc {{ 'abc' | upper }} # ABC {{ 'hello world' | title }} # Hello World {{ "hello world" | replace('world','daxin') | upper }} # HELLO DAXIN {{ 18.18 | round | int }} # 18 |
| ------------------------------------------------------------ | ------------------------------------------------------------ |
| | |
jinja2的控制结构
jinja2中的if语句类似与Python的if语句，它也具有单分支，多分支等多种结构，不同的是，条件语句不需要使用冒号结尾，而结束控制语句，需要使用endif关键字。
1 2 3 4 5 6 7 |
{% if daxin.safe %} daxin is safe. {% elif daxin.dead %} daxin is dead {% else %} daxin is okay {% endif %} |
|---|---|
jinja2的for循环
jinja2中的for循环用于迭代Python的数据类型，包括列表，元组和字典。在jinja2中不存在while循环。
迭代列表
| 1 2 3 4 5 | <ul> {% for user in users %} <li>{{ user.username|title }}</li> {% endfor %} </ul> |
| ----------------------- | ------------------------------------------------------------ |
| | |
迭代字典
1 2 3 4 5 6 |
<dl> {% for key, value in my_dict.iteritems() %} <dt>{{ key }}</dt> <dd>{{ value}}</dd> {% endfor %} </dl> |
|---|---|
当然也可以加入else语句，在循环正确执行完毕后，执行
在for循环中，jinja2还提供了一些特殊的变量，用以来获取当前的遍历状态：
| 变量 | 描述 |
|---|---|
| loop.index | 当前迭代的索引（从1开始） |
| loop.index0 | 当前迭代的索引（从0开始） |
| loop.first | 是否是第一次迭代，返回bool |
| loop.last | 是否是最后一次迭代，返回bool |
| loop.length | 序列中的项目数量 |
| loop.revindex | 到循环结束的次数（从1开始） |
| loop.revindex0 | 到循环结束的次数(从0开始） |
jinja2的宏
宏类似于Python中的函数，我们在宏中定义行为，还可以进行传递参数，就像Python中的函数一样一样儿的。
在宏中定义一个宏的关键字是macro，后面跟其 宏的名称和参数等
1 2 3 4 5 |
{% macro input(name,age=18) %} # ``参数``age``的默认值为``18 <input type='text' name="{{ name }}" value="{{ age }}" > {% endmacro %} |
|---|---|
调用方法也和Python的类似
1 2 |
<p>{{ input('daxin') }} </p> <p>{{ input('daxin',age=20) }} </p> |
|---|---|
jinja2的继承和Super函数
jinja2中最强大的部分就是模板继承。模板继承允许我们创建一个基本(骨架)文件，其他文件从该骨架文件继承，然后针对自己需要的地方进行修改。
jinja2的骨架文件中，利用block关键字表示其包涵的内容可以进行修改。
以下面的骨架文件base.html为例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
<!DOCTYPE html> <html lang="en"> <head> {% block head %} <link rel="stylesheet" href="style.css"/> <title>{% block title %}{% endblock %} - My Webpage</title> {% endblock %} </head> <body> <div id="content">{% block content %}{% endblock %}</div> <div id="footer"> {% block footer %} <script>This is javascript code </script> {% endblock %} </div> </body> </html> |
|---|---|
这里定义了四处 block，即：head，title，content，footer。那怎么进行继承和变量替换呢？注意看下面的文件
1 2 3 4 5 6 7 8 9 10 11 12 |
{% extend "base.html" %} # ``继承``base.html``文件 {% block title %} Dachenzi {% endblock %} # ``定制``title``部分的内容 {% block head %} {{ super() }} # ``用于获取原有的信息 <style type='text/css'> .important { color: #FFFFFF } </style> {% endblock %} # ``其他不修改的原封不同的继承 |
|---|---|
PS: super()函数 表示获取block块中定义的原来的内容。
利用jinja2进行渲染
jinja2模块中有一个名为Enviroment的类，这个类的实例用于存储配置和全局对象，然后从文件系统或其他位置中加载模板。
基本使用方法
大多数应用都在初始化的时候撞见一个Environment对象，并用它加载模板。Environment支持两种加载方式：
-
- PackageLoader：包加载器
- FileSystemLoader：文件系统加载器
PackageLoader
使用包加载器来加载文档的最简单的方式如下：
| 1 2 3 4 5 | from jinja2 import PackageLoader,Environment env = Environment(loader=PackageLoader('python_project','templates')) # 创建一个包加载器对象 template = env.get_template('bast.html') # 获取一个模板文件 template.render(name='daxin',age=18) # 渲染 |
|---|---|
其中：
-
- PackageLoader()的两个参数为：python包的名称，以及模板目录名称。
- get_template()：获取模板目录下的某个具体文件。
- render()：接受变量，对模板进行渲染
FileSystemLoader
文件系统加载器，不需要模板文件存在某个Python包下，可以直接访问系统中的文件。
查看api
2022年3月23日
18:27
python -m pydoc -p 1234
-p 端口号
csv模块
2022年11月12日
10:47
案例
1.使用CSV模块中的方法读取csv格式文件
import csv
import re
filename = "C:\\Users\\LSG\\Desktop\\info.csv"
#``文件的读操作（以只读方式打开文件。文件的指针将会放在文件的开头。这是``**``默认模式``** , ``编码方式``UTF-8``）
with open(filename, 'r' , encoding='utf-8') as file:
data_csv_reader = csv.reader(file)
# ``将文件中每行数据添加到``comments``里（数据类型``list``）
comments = []
for line in data_csv_reader:
comments.append(line)
# ``循环打印文本内容
for line in comments :
print(line)
浙公网安备 33010602011771号