Python疯狂讲义（常见模块：sys/os/random/time/json/正则表达式/set集合）

九、常见模块

1、sys

sys模块代表了Python解释器，主要用于获取和Python解释器相关的信息

import sys
list_sys = []
for e in dir(sys):
    if not e.startswith('_'):
        list_sys.append(e)
print(list_sys)

[‘addaudithook’, ‘api_version’, ‘argv’, ‘audit’, ‘base_exec_prefix’, ‘base_prefix’, ‘breakpointhook’, ‘builtin_module_names’, ‘byteorder’, ‘call_tracing’, ‘copyright’, ‘displayhook’, ‘dllhandle’, ‘dont_write_bytecode’, ‘exc_info’, ‘excepthook’, ‘exec_prefix’, ‘executable’, ‘exit’, ‘flags’, ‘float_info’, ‘float_repr_style’, ‘get_asyncgen_hooks’, ‘get_coroutine_origin_tracking_depth’, ‘getallocatedblocks’, ‘getdefaultencoding’, ‘getfilesystemencodeerrors’, ‘getfilesystemencoding’, ‘getprofile’, ‘getrecursionlimit’, ‘getrefcount’, ‘getsizeof’, ‘getswitchinterval’, ‘gettrace’, ‘getwindowsversion’, ‘hash_info’, ‘hexversion’, ‘implementation’, ‘int_info’, ‘intern’, ‘is_finalizing’, ‘maxsize’, ‘maxunicode’, ‘meta_path’, ‘modules’, ‘path’, ‘path_hooks’, ‘path_importer_cache’, ‘platform’, ‘platlibdir’, ‘prefix’, ‘pycache_prefix’, ‘set_asyncgen_hooks’, ‘set_coroutine_origin_tracking_depth’, ‘setprofile’, ‘setrecursionlimit’, ‘setswitchinterval’, ‘settrace’, ‘stderr’, ‘stdin’, ‘stdout’, ‘thread_info’, ‘unraisablehook’, ‘version’, ‘version_info’, ‘warnoptions’, ‘winver’]

上述列出的程序单元就是sys模块所包含的全部程序单元（包括变量、函数等）
sys模块常用的属性和函数：

1. sys.argv：获取运行Python程序的命令行参数。其中sys.argv[0]通常指该Python程序，sys.argv[1]代表Python程序提供的第一个参数，sys.argv[2]代表Python程序提供的第二个参数，…依次类推
2. sys.byteorder：显示本地字节序的指示符。如果本地字节序是大端模式，则该属性返回big；否则返回title
3. sys.copyright：该属性返回与Python解释器相关的版权信息
4. sys.executable：该属性返回Python解释器在磁盘上的存储路径
5. sys.exit()：通过引发SystemExit异常来退出程序
6. sys.flags：该只读属性返回运行Python命令时指定的旗标
7. sys.getfilesystemencoding()：返回在当前系统中保存文件所用的字符集
8. sys.getrefcount(object)：返回指定对象的引用计数
9. sys.getrecursionlimit()：返回Python解释器当前支持的递归深度。该属性方法可通过setrecursionlimit()方法重新设置
10. sys.getswitchinterval()：返回在当前Python解释器中线程切换的时间间隔。该属性方法可通过setswitchinterval()函数改变
11. sys.implementation：返回当前Python解释器的实现
12. sys.maxsize：返回Python整数支持的最大值。在32位平台：231-1；在64位平台：263-1
13. sys.modules：返回模块名和载入模块对应关系的字典
14. sys.path：返回模块的路径
15. sys.stdin：返回系统的标准输入流----一个类文件对象
16. sys.stdout：返回系统的标准输出流----一个类文件对象
17. sys.stderr：返回系统的错误输出流----一个类文件对象
18. sys.version：返回当前Python解释器的版本信息
19. sys.winver：返回当前Python解释器的主版本号

import sys
print(sys.byteorder)                 # little
print(sys.copyright)
"""
Copyright (c) 2001-2020 Python Software Foundation.
All Rights Reserved.

Copyright (c) 2000 BeOpen.com.
All Rights Reserved.

Copyright (c) 1995-2001 Corporation for National Research Initiatives.
All Rights Reserved.

Copyright (c) 1991-1995 Stichting Mathematisch Centrum, Amsterdam.
All Rights Reserved.
"""
print(sys.executable)                   # F:\Python3.9\python.exe
print(sys.getfilesystemencoding())      # utf-8
print(sys.maxsize)                      # 9223372036854775807
print(sys.platform)                     # win32
print(sys.version)                      # 3.9.0 (tags/v3.9.0:9cf6752, Oct  5 2020, 15:34:40) [MSC v.1927 64 bit (AMD64)]
print(sys.winver)                       # 3.9
print(sys.getrefcount(object))          # 612
print(sys.getrecursionlimit())          # 1000
print(sys.getswitchinterval())          # 0.005
print(sys.path)
"""
['E:\\Users\\PycharmProjects\\Ceshi', 
'E:\\Users\\PycharmProjects\\Ceshi', 
'F:\\Python3.9\\python39.zip', 
'F:\\Python3.9\\DLLs', 'F:\\Python3.9\\lib', 
'F:\\Python3.9', 'C:\\Users\\admin\\AppData\\Roaming\\Python\\Python39\\site-packages', 
'F:\\Python3.9\\lib\\site-packages', 'F:\\Python3.9\\lib\\site-packages\\win32', 
'F:\\Python3.9\\lib\\site-packages\\win32\\lib', 
'F:\\Python3.9\\lib\\site-packages\\Pythonwin']
"""
print(sys.stdin)                        # <_io.TextIOWrapper name='<stdin>' mode='r' encoding='utf-8'>
print(sys.stdout)                       # <_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>
print(sys.stderr)                       # <_io.TextIOWrapper name='<stderr>' mode='w' encoding='utf-8'>

1.1、获取运行参数

from sys import argv
print(len(argv))
for arg in argv:
    print(arg)

1.2、动态修改模块加载路径

sys.path()

import sys
sys.path.append("g://ssstxt")

2、os

import os
print(os.__all__)

os模块代表了程序所在的操作系统，主要用于获取程序运行所在操作系统的相关信息

[‘altsep’, ‘curdir’, ‘pardir’, ‘sep’, ‘pathsep’, ‘linesep’, ‘defpath’, ‘name’, ‘path’, ‘devnull’, ‘SEEK_SET’, ‘SEEK_CUR’, ‘SEEK_END’, ‘fsencode’, ‘fsdecode’, ‘get_exec_path’, ‘fdopen’, ‘popen’, ‘extsep’, ‘_exit’, ‘DirEntry’, ‘F_OK’, ‘O_APPEND’, ‘O_BINARY’, ‘O_CREAT’, ‘O_EXCL’, ‘O_NOINHERIT’, ‘O_RANDOM’, ‘O_RDONLY’, ‘O_RDWR’, ‘O_SEQUENTIAL’, ‘O_SHORT_LIVED’, ‘O_TEMPORARY’, ‘O_TEXT’, ‘O_TRUNC’, ‘O_WRONLY’, ‘P_DETACH’, ‘P_NOWAIT’, ‘P_NOWAITO’, ‘P_OVERLAY’, ‘P_WAIT’, ‘R_OK’, ‘TMP_MAX’, ‘W_OK’, ‘X_OK’, ‘abort’, ‘access’, ‘chdir’, ‘chmod’, ‘close’, ‘closerange’, ‘cpu_count’, ‘device_encoding’, ‘dup’, ‘dup2’, ‘environ’, ‘error’, ‘execv’, ‘execve’, ‘fspath’, ‘fstat’, ‘fsync’, ‘ftruncate’, ‘get_handle_inheritable’, ‘get_inheritable’, ‘get_terminal_size’, ‘getcwd’, ‘getcwdb’, ‘getlogin’, ‘getpid’, ‘getppid’, ‘isatty’, ‘kill’, ‘link’, ‘listdir’, ‘lseek’, ‘lstat’, ‘mkdir’, ‘open’, ‘pipe’, ‘putenv’, ‘read’, ‘readlink’, ‘remove’, ‘rename’, ‘replace’, ‘rmdir’, ‘scandir’, ‘set_handle_inheritable’, ‘set_inheritable’, ‘spawnv’, ‘spawnve’, ‘startfile’, ‘stat’, ‘stat_result’, ‘statvfs_result’, ‘strerror’, ‘symlink’, ‘system’, ‘terminal_size’, ‘times’, ‘times_result’, ‘truncate’, ‘umask’, ‘uname_result’, ‘unlink’, ‘unsetenv’, ‘urandom’, ‘utime’, ‘waitpid’, ‘waitstatus_to_exitcode’, ‘write’, ‘makedirs’, ‘removedirs’, ‘renames’, ‘walk’, ‘execl’, ‘execle’, ‘execlp’, ‘execlpe’, ‘execvp’, ‘execvpe’, ‘getenv’, ‘supports_bytes_environ’, ‘spawnl’, ‘spawnle’]

os模块常用的属性和函数：

1. os.name：返回导入依赖模块的操作系统名称，通常可返回‘posix’、‘nt’、‘java’等
2. os.environ：返回在当前系统上所有环境变量组成的字典
3. os.fsencode(filename)：该函数对类路径（path-like）的文件名进行编码
4. os.fsdecode(filename)：该函数对类路径（path-like）的文件名进行解码
5. os.PathLike：代表一个类路径对象
6. os.getenv(key, default=None)：获取指定环境变量的值
7. os.getlogin()：返回当前系统的登录用户名
8. os.getpid()：获取当前进程ID
9. os.getppid()：获取当前进程的父进程ID
10. os.putenv(key, value)：该函数用于设置环境变量
11. os.cpu_count()：返回当前系统的CPU数量
12. os.sep：返回路径分隔符
13. os.pathsep：返回当前系统上多条路径之间的分隔符
14. os.linesep：返回当前系统的换行符
15. os.urandom(size)：返回适合作为加密使用的bytes对象

import os
print(os.name)                      # nt
# print(os.environ)
print(os.fsencode(filename='A'))    # b'A'
print(os.fsdecode(filename='B'))    # B
print(os.PathLike)                  # <class 'os.PathLike'>
# print(os.getenv())
print(os.getlogin())                # admin
print(os.getpid())                  # 12268
print(os.getppid())                 # 2740
# print(os.putenv())
print(os.cpu_count())               # 4
print(os.sep)                       # \
print(os.pathsep)                   # ;
# print(os.linesep)
# print(os.urandom())

3、random

random模块主要包含生成伪随机数的各种功能变量和函数

import random
print(random.__all__)

[‘Random’, ‘SystemRandom’, ‘betavariate’, ‘choice’, ‘choices’, ‘expovariate’, ‘gammavariate’, ‘gauss’, ‘getrandbits’, ‘getstate’, ‘lognormvariate’, ‘normalvariate’, ‘paretovariate’, ‘randint’, ‘random’, ‘randrange’, ‘sample’, ‘seed’, ‘setstate’, ‘shuffle’, ‘triangular’, ‘uniform’, ‘vonmisesvariate’, ‘weibullvariate’]

1. random.seed(a=None, version=2)：指定种子来初始化伪随机数生成器
2. random.randrange(start=1, stop=5, step=2)：返回从start开始到stop结束，步长为step的随机数
3. random.randint(1, 10)：生成一个范围为a<=N<=b的随机数
4. random.choice([1, 2, 3])：从seq中随机抽取一个元素，如果seq为空，则引发IndexError异常
5. random.random()：生成一个从0.0（包含）到1.0（不包含）的随机数
6. random.uniform(1,5)：生成一个范围为a<=N<=b的随机数

import random
print(random.seed(a=None, version=2))
print(random.randrange(start=1, stop=5, step=2))
print(random.randint(1, 10))    # N>=1 and N<=10
print(random.choice([1, 2, 3]))
print(random.random())
print(random.uniform(1, 5))
print(random.expovariate(1 / 5))
book_list = ['Python', 'C#', 'JAVA', 'HTML']
# 对列表元素进行随机排序
random.shuffle(book_list)
print(book_list)
# 随机抽取3个独立的元素
print(random.sample([10, 12, 23, 2], k=3))

4、time

time模块主要包含各种提供日期、时间功能的类和函数。

import time
list_time = []
for e in dir(time):
    if not e.startswith('_'):
        list_time.append(e)
print(list_time)

[‘altzone’, ‘asctime’, ‘ctime’, ‘daylight’, ‘get_clock_info’, ‘gmtime’, ‘localtime’, ‘mktime’, ‘monotonic’, ‘monotonic_ns’, ‘perf_counter’, ‘perf_counter_ns’, ‘process_time’, ‘process_time_ns’, ‘sleep’, ‘strftime’, ‘strptime’, ‘struct_time’, ‘thread_time’, ‘thread_time_ns’, ‘time’, ‘time_ns’, ‘timezone’, ‘tzname’]

在time模块内提供了一个time.struct_time类，该类代表一个时间对象，主要包含9个属性

字段名	字段含义	值
tm_year	年	2017/2018
tm_mon	月	2/3(1-12)
tm_mday	日	2/3(1-31)
tm_hour	时	2/3(0-23)
tm_min	分	2/3(0-59)
tm_sec	秒	2/3(0-59)
tm_wday	周	周一为0(0-6)
tm_yday	一年内第几天	65(1-366)
tm_isdst	夏令时	0、1、-1

在日期、时间模块内常用的功能函数：

1. time.asctime([t])：将时间元组或struct_time转换为时间字符串。如果不指定参数t，则默认转换当前时间
2. time.ctime([secs])：将以描述为代表的时间转换成时间字符串
3. time.gmtime(30)：将以秒数代表的时间转换为struct_time对象，如果不传入参数，则使用当前时间
4. time.localtime(30)：将以秒数代表的时间转换为struct_time对象，如果不传入参数，则使用当前时间
5. time.mktime((2017, 2, 4, 11, 8, 23, 0, 0, 0))：是localtime的反转函数，用于将struct_time对象或元组代表的时间转换为从1970年1月1日0点到现在过了多少秒
6. time.perf_counter()：返回性能计数器的值（秒）
7. time.process_time()：返回当前进程使用CPU的时间（秒）
8. time.strftime(’%Y-%m-%d %H:%M:%S’)：将时间转换成字符串
9. time.strptime(st, ‘%Y年%m月%d日’)：将字符串转换成时间
10. time.time()：返回从1970年1月1日0点到现在过了多少秒
11. time.timezone：返回本地时区的时间偏移（秒）
12. time.tzname：返回本地时区的名字
13. time.sleep(10)：暂停几秒

import time
# 将当前时间转换成字符串
print(time.asctime())                               # Tue Sep  7 09:07:02 2021
# 将以秒数代表的时间转成时间字符串
print(time.ctime(1200))                             # Thu Jan  1 08:20:00 1970
# 将以秒数代表的时间转成struct_time对象
print(time.gmtime(30))                              # time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=30, tm_wday=3, tm_yday=1, tm_isdst=0)
# 将以秒数代表的当前时间转成struct_time对象
print(time.localtime(30))                           # time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=8, tm_min=0, tm_sec=30, tm_wday=3, tm_yday=1, tm_isdst=0)
# 将元组格式的时间转成以秒计数的时间
print(time.mktime((2017, 2, 4, 11, 8, 23, 0, 0, 0)))# 1486177703.0
# 返回性能计数器的值
print(time.perf_counter())                          # 0.0326496
# 返回当前进程使用CPU的时间
print(time.process_time())                          # 0.046875
# 将当前时间转换成指定格式的字符串
print(time.strftime('%Y-%m-%d %H:%M:%S'))           # 2021-09-07 09:12:27
st = '2018年3月20日'
# 将指定时间恢复成struct_time对象
print(time.strptime(st, '%Y年%m月%d日'))            # time.struct_time(tm_year=2018, tm_mon=3, tm_mday=20, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=1, tm_yday=79, tm_isdst=-1)
# 返回从1970/1/1 0:0:0 到现在过了多少秒
print(time.time())                                  # 1630977147.6239772
# 返回本时区的时间偏移
print(time.timezone)                                # -28800
# 返回本时区的名称
print(time.tzname)                                  # ('中国标准时间', '中国夏令时')
# 暂停
print(time.sleep(10))

Python时间格式字符串所支持的指令

指令	含义
%a	本地化星期的简称（Sun：星期天）
%A	本地化星期的完整名称
%b	本地化月份的简称（Jan：一月）
%B	本地化月份的完整名称
%c	本地化日期和时间的表示形式
%d	一个月中第几天（01-31）
%H	24小时制的小时（0-23）
%I	12小时制的小时（01-12）
%j	一年中第几天（1-366）
%m	月份的数值（01-12）
%M	分钟的数值（00-59）
%p	上午或下午的本地化方式
%S	代表分钟的数值
%U	代表一年中第几周，以星期天为每周的第一天（00-53）
%w	代表星期几的数值（00-06）
%W	代表一年中第几周，以星期一为每周的第一天（00-53）
%x	本地化日期的表示形式
%X	本地化时间的表示形式
%y	年份的缩写（00-99）
%Y	年份的完整形式
%z	显示时区偏移
%Z	显示时区名
%%	代表%符号

5、JSON支持

JSON是一种轻量级、跨平台、跨语言的数据交换格式

5.1、JSON的基本知识

JSON主要有两种数据结构：

1. 由key-value对组成的数据结构
2. 有序集合

在JavaScript中主要有两种JSON语法，一种用于创建对象、一种用于创建数组

5.1.1、使用JSON创建对象

在创建对象object时，总以“{”开头，以“}”结束，对象的每个属性名和属性值之间以英文冒号（:）隔开，多个属性定义之间以英文逗号（,）隔开。语法格式如下：

object = {
	propertName1 : propertValue1,
	propertName2 : propertValue2,
	...
}

并不是每个属性定义的后面都有英文逗号（,），必须当后面还有属性定义时才需要有逗号。

5.1.2、使用JSON创建数组

以英文方括号"[“开始，放入数组元素，元素与元素之间以英文逗号（,）隔开，最后一个数组元组不需要逗号，以”]"结束

var a = ['Python', 'AlySam']

语法格式：

arr = [value1, value2, ...]

6、正则表达式（还需进一步学习）

正则表达式用于描述一种字符串匹配的模式，可用于检查一个字符串是否含有某个子串，也可用于从字符串中提取匹配，或者对字符串中匹配的子串执行替换操作

6.1、Python的正则表达式支持

import re
print(re.__all__)

[‘match’, ‘fullmatch’, ‘search’, ‘sub’, ‘subn’, ‘split’, ‘findall’, ‘finditer’, ‘compile’, ‘purge’, ‘template’, ‘escape’, ‘error’, ‘Pattern’, ‘Match’, ‘A’, ‘I’, ‘L’, ‘M’, ‘S’, ‘X’, ‘U’, ‘ASCII’, ‘IGNORECASE’, ‘LOCALE’, ‘MULTILINE’, ‘DOTALL’, ‘VERBOSE’, ‘UNICODE’]

1. re.compile(pattern, flags=0)：将正则表达式字符串编译成_sre.SRE_Pattern对象，该对象代表了正则表达式编译之后再内存中的对象，可以缓存并复用正则表达式字符串。pattern参数就是所编译的正则表达式字符串。

import re
# print(re.__all__)
# 编译正则表达式
p = re.compile('abc')
# 调用search方法
p.search("www.abc.com")
print(p.search("www.abc.com"))
print(re.search('abc', "www.abc.com"))

2. re.match(pattern, string, flags=0)：尝试从字符串的开始位置来匹配正则表达式，如果从开始位置匹配不成功，match()函数返回None。其中pattern参数代表正则表达式；string代表被匹配的字符串；flags代表正则表达式的匹配旗标。该函数返回_sre.SRE_Match对象。
3. re.search(‘baidu’, ‘www.baidu.com’)：扫描整个字符串，并返回字符串中第一处匹配pattern的匹配对象。</>

import re
m2 = re.match('www', 'www.baidu.com')
m3 = re.search('baidu', 'www.baidu.com')
print(m2)               # None  ('com')/ <re.Match object; span=(0, 3), match='www'>
# span返回匹配的位置
print(m2.span())        # (0, 3)
# group返回配置的组
print(m2.group())       # www
print(m3.span())        # (4, 9)
print(m3.group())       # baidu

二者区别： match必须从字符串开始处就匹配；search则可以搜索整个字符串，从指间任意位置开始匹配</>

1. re.findall(‘fkit’, ‘FKIT is very good , Fkit.org is my favorite’, re.I)：扫描整个字符串，返回字符串中所有匹配pattern的子串组成的列表。
2. re.finditer(‘fkit’, ‘FKIT is very good , Fkit.org is my favorite’, re.I)：扫描整个字符串，返回字符串中所有匹配pattern的子串组成的迭代器。

import re
print(re.findall('fkit', 'FKIT is very good , Fkit.org is my favorite', re.I))# ['FKIT', 'Fkit']
it = re.finditer('fkit', 'FKIT is very good , Fkit.org is my favorite', re.I)
for e in it:
    print(str(e.span()) + "-->" + e.group())	
# (0, 4)-->FKIT
# (20, 24)-->Fkit

二者区别： findall函数返回匹配pattern的子串组成的列表；finditer函数返回所有匹配pattern的子串组成的迭代器</>

1. re.fullmatch(‘abc’, ‘abcd’)：函数要求整个字符串都能匹配pattern，如果匹配则返回匹配信息的_sre.SRE_Match对象，否则返回None
2. re.sub(pattern，repl，string，count=0，flags=0)：将字符串中所有匹配pattern的内容替换repl；repl既可以是被替换的字符串，也可以是一个函数，count参数控制最多替换多少次，指定count为0，则默认为全部替换

import re
my_data = "2021-09-07"
# 替换操作 r'-'：原始字符串，避免对字符串中特殊字符进行转义
print(re.sub(r'-', '/', my_data))       # 2021/09/07
# 只替换一次
print(re.sub(r'-', '/', my_data, 1))    # 2021/09-07
print(re.fullmatch('abc', 'abcd'))      # None
str_test = re.fullmatch('abc', 'abc')
print(str_test.span())                  # (0, 3)
print(str_test.group())                 # abc

r'(?P<lang>\w+)'

正则表达式用圆括号表达式创建了一个组，并使用“?P”选项为该组起名为lang（所起的组名需要放在尖括号内）。“\w+”：表达式的内容。“\w”代表任意字符。匹配的内容可通过组名“lang”来获取。

1. re.split(pattern，string，maxsplit=0，flags=0)：使用pattern对string进行分割，该函数返回分割得到的多个子串组成的列表。其中maxsplit参数控制最多分割几次

print(re.split(',', 'fkit, Java, Python, C++'))         # ['fkit', ' Java', ' Python', ' C++']
print(re.split(',', 'fkit, Java, Python, C++', 1))      # ['fkit', ' Java, Python, C++']
print(re.split(',', 'fkit, Java, Python, C++', 2))      # ['fkit', ' Java', ' Python, C++']

1. re.purge()：清除正则表达式缓存
2. re.escape(pattern)：对模式中除ASCII字符、数值、下画线（_）之外的其他字符进行转义

print(re.purge())
print(re.escape(r'www.crazy.org is good, i love it!'))
# www\.crazy\.org\ is\ good,\ i\ love\ it!

6.2、正则表达式旗标

1. re.A或re.ASCII：该旗标控制\w \W \b \B \d \D \s \S 和只匹配ASCII字符，不匹配所有的Unicode字符。也可以在正则表达式中使用（?a）表示
2. re.DEBUG：显示编译正则表达式的Debug信息
3. re.I或re.IGNORECASE：使用正则表达式匹配时不区分大小写
4. re.L或re.LOCAIL：根据当前区域设置使用正则表达式匹配时不区分大小写（只能对bytes模式起作用）
5. re.M或re.MULTILINE：多行模式的旗标
6. re.S或re.DOTALL：让点（.）能匹配包括换行符在内的所有的字符
7. re.U或re.Unicode：该旗标控制\w \W \b \B \d \D \s \S 和只匹配Unicode字符（Python3.x不需要，默认匹配所有的Unicode字符）
8. re.X或re.VERBOSE：该旗标允许分行书写正则表达式

6.3、创建正则表达式

正则表达式所支持的合法字符

字符	解释
x	字符x（x可代表任意合法的字符）
\uhhhh	十六进制值uhhhh表示Unicode字符
\t	制表符（’\u0009’）
\n	换行符（’\u000A’）
\r	回车符（’\u000D’）
\f	换页符（’\u000C’）
\a	报警符（’\u0007’）
\e	Escape符（’\u001B’）
\cx	x对应的控制符（\cM表示ctrl+M）

特殊字符

特殊字符	说明
$	匹配一行的结尾。要匹配$字符本身，使用 “\ $”
^	匹配一行的开头。要匹配 “^” 字符本身，使用“\ ^”
()	标记子表达式的开始位置、结束位置。匹配字符本身，使用"\ (" " \ )"
[]	确定中括号表达式的开始位置、结束位置。匹配字符本身，使用"\ [" " \ ]"
{}	标记前面子表达式的出现频度。匹配字符本身，使用"\ {" " \ }"
*	指定前面子表达式可以出现零次或多次（*）
+	指定前面子表达式可以出现一次或多次（+）
?	指定前面子表达式可以出现零次或一次（?）
.	匹配除换行符之外的任意单个字符（.）
\	转义下一个字符（\）
	指在两项之间任选一项（|）

预定义字符

预定义字符	说明
.	默认匹配除换行符之外的任意字符，在使用re.S或re.DOTALL后，可匹配换行符
\d	匹配0-9所有数字
\D	匹配非数字
\s	匹配所有的空白字符（包括空格、制表符、回车符、换行符、换页符等）
\S	匹配所有的非空白符
\w	匹配所有的单词字符，包括0~9的所有数字、26个英文字母和下画线（_）
\W	匹配所有的非单词字符

7、容器相关类

set集合：把一个对象添加到set集合时，set集合无法记住添加这个元素的顺序，所以set集合里的元素不能重复（否则系统无法识别这个元素）deque（双端队列）
deque（双端队列）：特征是它的两端都可以添加、删除元素，它既可以作为栈（stack）使用，也可作为队列（queue）使用

7.1、set和frozenset

set集合有如下两个特征：

1. set不记录元素的添加顺序
2. 元素不允许重复

set集合是可变容器，程序可以改变容器中的元素。与set对应的还有frozenset集合，frozenset集合是set的不可变版本，元素是不可变的。

list_set = []
for e in dir(set):
    if not e.startswith('_'):
        list_set.append(e)
print(list_set)

[‘add’, ‘clear’, ‘copy’, ‘difference’, ‘difference_update’, ‘discard’, ‘intersection’, ‘intersection_update’, ‘isdisjoint’, ‘issubset’, ‘issuperset’, ‘pop’, ‘remove’, ‘symmetric_difference’, ‘symmetric_difference_update’, ‘union’, ‘update’]

1. add()：添加元素
2. remove()/discard()：删除元素
3. clear()：清空集合

删除集合中不包含的元素时，remove()方法会报错：KeyError；discard()方法什么也不做</>

简单示例如下：

# 使用花括号构建集合
set_test = {'红孩儿'}
set_test.add("牛魔王")
set_test.add(121)
print(set_test)     # {121, '红孩儿', '牛魔王'}
print("集合的个数为：{0}".format(len(set_test)))   # 3
set_test.remove(121)
print(set_test)     # {'红孩儿', '牛魔王'}
print("集合的个数为：{0}".format(len(set_test)))   # 2
# 使用set函数（构造器）来创建set集合
immortal = set()
immortal.add("孙悟空")
immortal.add("猪八戒")
immortal.add("沙僧")
print("神仙集合的元素：", immortal)         # 神仙集合的元素： {'孙悟空', '猪八戒', '沙僧'}

# 使用issubset()判断是否为子集合
print("immortal集合是否为set_test集合的子集合？", immortal.issubset(set_test))  # immortal集合是否为set_test集合的子集合？ False
# 使用issubset方法与<=效果相同
print("immortal集合是否为set_test集合的子集合？", immortal <= set_test) # immortal集合是否为set_test集合的子集合？ False
# 使用issuperset()判断是否为子集合
print("set_test集合是否为immortal集合的父集合？", set_test.issuperset(immortal))    # set_test集合是否为immortal集合的父集合？ False
# 使用issuperset方法与>=效果相同
print("set_test集合是否为immortal集合的父集合？", set_test >= immortal) # set_test集合是否为immortal集合的父集合？ False

# 集合相减，不改变集合本身（set_test）
reslut1 = set_test - immortal
print(reslut1)      # {'红孩儿', '牛魔王'}
# 集合相减，不改变集合本身（set_test）(与“-”效果相同)
reslut2 = set_test.difference(immortal)
print(reslut1)      # {'红孩儿', '牛魔王'}
# 集合相减，改变集合本身（set_test）
set_test.difference_update(immortal)
print(set_test)     # {'红孩儿', '牛魔王'}
# 删除集合里面的元素
# set_test.clear()
# print(set_test)
# 直接创建集合
immortal_test = {'孙悟空', '牛魔王'}
print(immortal_test)    # {'孙悟空', '牛魔王'}
# 计算两个集合的交集(不改变集合本身)
inter1 = immortal_test & immortal
print(inter1)       # {'孙悟空'}
inter2 = immortal_test.intersection(immortal)
print(inter2)       # {'孙悟空'}
# 计算两个集合的交集(改变集合本身)
immortal_test.intersection_update(immortal)
print(immortal_test)    # {'孙悟空'}
# 将range对象包装成set集合
e = set(range(5))
f = set(range(3, 7))
print("e集合的元素：", e)     # e集合的元素： {0, 1, 2, 3, 4}
print("f集合的元素：", f)     # f集合的元素： {3, 4, 5, 6}
# 对两个集合执行异或运算
xor = e ^ f
print(xor)      # {0, 1, 2, 5, 6}
# 计算两个集合的并集（不改变集合本身）
un = e.union(f)
print(un)       # {0, 1, 2, 3, 4, 5, 6}
# 计算两个集合的并集（改变集合本身）
e.update(f)
print(e)        # {0, 1, 2, 3, 4, 5, 6}

1. “<=” 相当于调用issubset()函数：判断前面的set集合是否为后面的set集合的子集合

2. “>=” 相当于调用issuperset()函数：判断前面的set集合是否为后面的set集合的父集合

3. “-”相当于调用difference()函数：用前面的set集合减去后面的set集合

4. “&”相当于调用intersection()函数：用于获取两个集合的交集

5. “^计算两个集合的异或运算

6. 交集运算：intersection/intersection_update（前者不改变集合本身，直接返回两个集合的交集；后者会通过交集运算改变第一个集合）

7. 并集运算：union/update（前者不改变集合本身，直接返回两个集合的并集；后者会通过并集运算改变第一个集合）

8. 减法运算：difference/difference_update（前者不改变集合本身，直接返回两个集合的减法结果；后者改变第一个集合）

frozenset是set的不可变版本，set集合支持的改变集合本身的方法等frozenset都不适用；set集合支持的不改变集合本身的方法frozenset也适用。

list_frozenset = []
for e in dir(frozenset):
    if not e.startswith('_'):
        list_frozenset.append(e)
print(list_frozenset)

[‘copy’, ‘difference’, ‘intersection’, ‘isdisjoint’, ‘issubset’, ‘issuperset’, ‘symmetric_difference’, ‘union’]

frozenset的作用主要有两点：

1. 当集合元素不需要改变时，使用frozenset代替set更安全
2. 当某些API需要不可变对象时，使用frozenset