第10章 内置模块

sys Python解释器

模块下常用的函数	作用
exit()	引发SystemExit异常来退出程序
getfilesystemencoding()	返回当前系统中保存文件所用的字符集
getswitchinterval()	返回线程切换的时间间隔
setswitchinterval()	设置线程切换的时间间隔
modules	返回模块名和载入模块对应关系的字典
path	指定查找模块的路径列表，修改此属性可以动态增加路径

>>> import sys
>>> sys.getfilesystemencoding()
'utf-8'
>>> sys.getswitchinterval()
0.005
>>> sys.modules
【Squeezed text(145 lines).】
>>> sys.path
['D:\\Python 3.7.2\\Lib\\idlelib', 'D:\\Python 3.7.2\\python37.zip', 'D:\\Python 3.7.2\\DLLs', 'D:\\Python 3.7.2\\lib', 'D:\\Python 3.7.2', 'D:\\Python 3.7.2\\lib\\site-packages']

# OS模块 操作系统

模块下常用的函数	作用
cup_count()	返回当前系统的CPU数量
startfile(path,[operation])	用文件关联的工具操作文件 operation默认是open，也可以设置成edit, print
system(command)	运行操作系统上的指定命令，如：os.system(‘cmd’)

# random 生成伪随机数

分类	模块下常用的函数	随机生成
区间	random()	在0.0~1.0之间，一个浮点数
	uniform(a,b)	一个数
	randint(a, b)	一个整数
	randrange(start, stop, [step])	指定步长，一个整数
序列	shuffle(seq, [random])	将序列随机重排
	choice(seq)	随机抽取1个元素
	sample(seq, k)	从序列中抽取k个元素
	choices(seq, weight, k)	从序列中抽取k个元素，可设置各元素权重

>>> a = [1,2,3]
>>> random.shuffle(a)
>>> print(a)
[2, 3, 1]

>>> random.choices([1,2,3],[5,5,10],k=1)
[3]

# time 日期、时间与字符串的互相转换

时间元组

struct_time()：由9个元素组成的元组，代表时间

tm_year	tm_mon	tm_mday	tm_hour	tm_min	tm_sec	tm_wday	tm_yday	tm_isdst
年	月	日	时	分	秒	周中天	年中天	令时
2020等	1~12	1~31	0~23	0~59	0~59	0~6	1~366	0/1/-1

（1970，1，1，0，0，0，3，1，0）  #简写
(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=1, tm_isdst=0)  #完整形式

秒数、字符串、时间元组及其相互转化

原始数据是秒，三种数据可互相转化。除gmtime()，【sec】与【t】缺省时，默认为本地时间

模块下的函数	作用	结果类型
time()	过去的秒数（1970年1月1日0点至今）	float
ctime([sec])	秒转字符串	str
localtime([sec])	秒转时间元组（本地时间）	时间元组
gmtime([sec])	秒转时间元组（标准时间）	时间元组
mktime(t)	时间元组转秒	float
asctime([t])	时间元组转字符串，默认格式	str
strftime(format, [t])	时间元组转字符串，指定格式	str
strptime(string, [format])	字符串转时间元组，可指定格式	时间元组

format 时间格式（% + 字母）

常用分隔符：年、月、日、时、分、秒、星期、空格、【:】【-】【/】

名字	星期-完整	星期-缩写	月份-完整	月份-缩写	时区
字母	A	a	B	b	Z

日期	年-完整	年-简写	月	年中日	月中日	周中日
字母	Y	y	m	j	d	w
取值范围	0000~9999	00~99	1~12	001~366	01~31	0~6

排序	年中周（日）	年中周（一）
字母	U	W
取值范围	00~53	00~53

时间	24小时制	12小时制	分钟
字母	H	I	M
取值范围	00~23	00~12	00~59

本地化的	日期	时间	日期 + 时间	上午/下午	时区偏移
字母	x	X	c	p	z

>>> time.strftime('%c')
'Wed Jun 17 00:24:00 2020'

更多时间函数

模块下的函数	作用
timezone	返回本地时区的时间偏移（秒）
tzname	本地时区的名字
process_time()	返回当前进程使用CPU的时间
sleep(secs)	暂停若干秒

# JSON支持

实现JSON字符串与Python对象的相互转换（略）

# re 正则表达式 另起一文

# 容器相关类

set 集合

特点：不接受重复元素；不记录元素添加的顺序；内部元素可改变

frozenset：元素不可改变的set。作用：字典的key不可变，不能用set，可以用frozenset

基本操作

操作	创建		添加元素	删除元素		清空
方法	a = {}	a = set()	add	remove	discard	clear

1. 删除不存在的元素时，remove会报错，discard不报错
2. 大括号中没有内容时，默认创建空字典，只用逗号分隔各元素时，默认创建set
3. 判断元素是否存在：【元素 in set名】

a = {}
print(type(a))  #<class 'dict'>
a = {1,2}
print(type(a))  #<class 'set'>

a = set([1,2])
print(a) #{1, 2}
if 1 in a: print('是')  #是

set的关系 - 包含与被包含

a是b的父集合	a包含b	a.issuperset(b)	a >= b
a是b的子集合	b包含a	a.issubset(b)	a <= b

a = {1,2}
b = {1}
a.issuperset(b)  #True
a >= b           #True
b.issubset(a)    #True
b <= a           #True

set的运算

运算	符号	不改变a	将运算结果赋值给a
并集	无	a.union(b)	a.update(b)
交集	a & b	a.intersection(b)	a.intersection_update(b)
相减	a - b	a.difference(b)	a.difference_update(b)
异或	a ^ b

• 异或：并集 - 交集

deque 双端队列

基本操作

操作	增加	弹出	增加
右边（默认）	append	pop	extend
左边	appendleft	popleft	extendleft

from collections import deque
a = deque((1,2))
a.appendleft(3)
print(a)  #deque([3, 1, 2])
a.pop()   #2
print(a)  #deque([3, 1])
a.extend(range(4,6))
print(a)  #deque([3, 1, 4, 5])

作为栈使用：append + pop
作为队列使用：append + popleft

更多操作

函数	clear()	insert()	rotate()
作用	清空	指定位置	将最右边的一个元素移动到最左边

a = deque((1,2))
a.insert(1,'b')
print(a)  #deque([1, 'b', 2])
a.rotate()
print(a)  #deque([2, 1, 'b'])
a.clear()
print(a)  #deque([])

堆操作

小顶堆条件：

，i = 0，2，… （n-1）/2，二叉树效果图：

python中，堆不是数据类型，但是列表是当成堆处理的，列表可以转化成堆

函数	参数	作用
heapify	heap	将堆属性应用到列表上
heappop		弹出最小的元素
heappush	heap, item	加入元素
heapreplace		先弹出最小元素，后加入新元素
heappushpop		先加入新元素，后弹出最小元素
nlargest	n, iterable, key=None	返回最大的n个元素
nsmallest		返回最小的n个元素
merge	*iterable, key=None, reverse=False	多个小有序堆合成一个大有序堆

from heapq import *
a = [0,1,2,3,0.5]
print(a)              #[0, 1, 2, 3, 0.5]
heapify(a)
print(a)              #[0, 0.5, 2, 3, 1]
heapreplace(a,-1)     #-1
print(a)              #[-1, 0.5, 2, 3, 1]
heappushpop(a,-2)     #-2
print(a)              #[-1, 0.5, 2, 3, 1]
b = nlargest(3,a)
print(b)              #[3, 2, 1]
c = list(merge(a,b))
print(c)              #[-1, 0.5, 2, 3, 1, 3, 2, 1]

Dict - ChainMap 字典的假合并

key相同时，排名最靠前的字典拥有最高优先级

from collections import ChainMap
a = ChainMap({1:1},{2:2},{3:3})
print(a)     #ChainMap({1: 1}, {2: 2}, {3: 3})
print(a[2])  #2

应用：决定各变量的优先级：
b = ChainMap(locals(), globals())
for i in b: ...

Dict - Counter对象

继承dict类，以key为元素，以key出现的次数为value。转化为set, list时，只保留key

创建counter

创建途径	空	字典	关键字	可迭代对象
语法	counter()	Counter( {1:3} )	Counter(b=2)	Counter(iterator)

from collections import Counter
Counter(b=2)       #Counter({'b': 2})
Counter(range(3))  #Counter({0: 1, 1: 1, 2: 1})

Counter运算

功能	语法	备注
相加	a + b	只保留value为正的元素
相减	a - b （a.substract(b)）	只保留value为正的元素
交集	a & b	两者共有的key，其value取最小值
并集	a | b	所有key，其value取最大值
求正	+a	只保留value>=0的元素，并将出现次数改为正数
求负	-a	只保留value<=0的元素，并将出现次数改为正数

a = Counter({1:1,2:2})
b = Counter({2:2,3:3})
c = Counter({1:1,2:-1})

a + b  #Counter({2: 4, 3: 3, 1: 1})
a - b  #Counter({1: 1})
a & b  #Counter({2: 2})
a | b  #Counter({3: 3, 2: 2, 1: 1})
+c  #Counter({1: 1})
-c  #Counter({2: 1})

Counter对象的更多方法

函数	作用
elements()	以迭代器形式，返回所有key
most_common([n])	返回value最大的n个元素
sum(a.values())	计算所有元素出现次数的总和

a = Counter({1:1,2:2})
[i for i in a.elements()]  #[1, 2, 2]
a.most_common(1)           #[(2, 2)]
sum(a.values())            #3

Dict - defaultdict对象

dict的子类，区别：访问不存在的key时，不报错，直接把默认的value赋值给key

default_factory	缺省	int	str	list	set
默认值	None	0	‘’	[]	set()

from collections import defaultdict
a = defaultdict(int)
a[1]      #0
print(a)  #defaultdict(<class 'int'>, {1: 0})

也可以用普通字典的【setdefault(key, default=None)】方法逐个赋值，分两种情况：

1. key存在，直接返回value
2. key不存在，先赋值，再返回value

a = {1: 'x'}
a.setdefault(1, 'y')  #'x'
a.setdefault(2, 'z')  #'z'
a                     #{1: 'x', 2: 'z'}

Dict - OrderDict

dict的子类。区别：有序的字典

方法	参数	作用
popitem()	last=True	默认弹出最右边的元素
move_to_end	key, last=True	将指定元素移到最右边，为False时，移到最左边

tuple - namedtuple

tuple类的子类，可以为tuple的每个元素指定字段名，便于后期用字段名访问元素

namedtuple(typename, field_names, verbose=False, rename=False, module=None)

参数	含义
typename	类名（字符串格式）
field_name	字段名组成的序列
verbose=False	不自动打印类定义
rename=False	不自动替换无效字段名为位置名
module=None	将当前类放在某个模块下

字段名格式：字符串，以字母开头，由字母、数字、下划线组成，且逗号或空格分隔。

可用字符串代表所有字段名，每个字符为一个字段名。不可以用内置的关键字，不可重复

from collections import namedtuple
A = namedtuple('B',['x', 'y'])  #创建tuple类，类名为B，字段名为x, y
print(A)  #<class '__main__.B'>
a = A(1,2)  #创建元组，元素的数量与字段名的数量要相等
a[0]  #1    #通过位置访问元素
a.x   #1    #通过字段名访问元素

更多方法

函数	作用
_make(iterable)	类方法，创建对象
_asdict()	转换成OrderedDict 字段名与内容配对的列表
_replace(**kwargs)	通过字段名修改值
_fields	以元组形式，返回所有字段名

A = namedtuple('B',['x', 'y'])
a._make(range(2))  #B(x=0, y=1)
a._asdict()        #OrderedDict([('x', 1), ('y', 2)])
a._replace(y=3)    #B(x=1, y=3)
a._fields          #('x', 'y')