[Python知识库]Python基础篇（十二）-- 常用模块

1 常用内建模块

1.1 math

????????math库是Python的标准库，提供了诸多的数学函数，可以使用整数和浮点数的数学运算。

????????学习该库更多的相关用法，可以阅读官方文档，math库

1.2 random

????????随机数是随机产生的数据（比如抛硬币），但时计算机是不可能产生随机值，真正的随机数也是在特定条件下产生的确定值，计算机不能产生真正的随机数，那么伪随机数也就被称为随机数。
????????python中用于生成伪随机数的函数库是random。因为是标准库，使用时候只需要import random

????????学习该库更多的相关用法，可以阅读官方文档，random库

1.3 time

????????Python中内置了一些与时间处理相关的库，如time、datatime和calendar库。其中time库是Python中处理时间的标准库，是最基础的时间处理库。time库的功能如下：
（1）计算机时间的表达
（2）提供获取系统时间并格式化输出功能
（3）提供系统级精确计时功能，用于程序性能分析

????????学习该库更多的相关用法，可以阅读官方文档，time库

1.4 collections

????????collections的常用类型有：

• 计数器(Counter)
• 双向队列(deque)
• 默认字典(defaultdict)
• 有序字典(OrderedDict)
• 可命名元组(namedtuple)

1. Counter
????????Counter 作为字典(dict)的一个子类用来进行hashtable计数，将元素进行数量统计、计数后返回一个字典,键值为元素：值为元素个数。

from collections import *

s = 'abcbcaccbbad'
l = ['a', 'b', 'c', 'c', 'a', 'b', 'b']
d = {'2': 3, '3': 2, '17': 2}
# Counter 获取各元素的个数，返回字典
print(Counter(s))       # Counter({'b': 4, 'c': 4, 'a': 3, 'd': 1})
print(Counter(l))       # Counter({'b': 3, 'a': 2, 'c': 2})
print(Counter(d))       # Counter({'2': 3, '3': 2, '17': 2})

# most_common(int) 按照元素出现的次数从高到低的排序，返回前int个元素的字典
m1 = Counter(s)
print(m1)                       # Counter({'b': 4, 'c': 4, 'a': 3, 'd': 1})
print(m1.most_common(3))        # [('b', 4), ('c', 4), ('a', 3)]

e1 = Counter(s)
print(''.join(sorted(e1.elements())))       # aaabbbbccccd
e2 = Counter(d)
print(sorted(e2.elements()))        # ['17', '17', '2', '2', '2', '3', '3']

u1 = Counter(s)
u1.update('123a')
print(u1)       # Counter({'a': 4, 'b': 4, 'c': 4, 'd': 1, '1': 1, '2': 1, '3': 1})

sub1 = 'which'
sub2 = 'whatw'
subset = Counter(sub1)
print(subset)       # Counter({'h': 2, 'w': 1, 'i': 1, 'c': 1})
subset.subtract(Counter(sub2))
print(subset)       # Counter({'h': 1, 'i': 1, 'c': 1, 'w': -1, 'a': -1, 't': -1})

2. deque
????????deque 包含在文件_collections.py中，属于高性能的数据结构(High performance data structures)之一。可以从两端添加和删除元素，常用的结构是它的简化版。

str1 = 'abc123cd'
dq = deque(str1)
print(dq)       # deque(['a', 'b', 'c', '1', '2', '3', 'c', 'd'])

dq = deque('abc123')
dq.extend({1:10, 2:20})
dq.extendleft('L')
print(dq)               # deque(['L', 'a', 'b', 'c', '1', '2', '3', 1, 2])

dq = deque([1, 2, 3, 4, 5])
dq.rotate(-1)
print(dq)                   # deque([2, 3, 4, 5, 1])

3. defaultdict
????????默认字典，是字典的一个子类，继承有字典的方法和属性，默认字典在进行定义初始化的时候可以指定字典值的默认类型：

dic = defaultdict(dict)
dic['k1'].update({'k2': 'aaa'})
print(dic)      # defaultdict(<class 'dict'>, {'k1': {'k2': 'aaa'}})

????????看上面的例子，字典dic在定义的时候就定义好了值为字典类型，虽然现在字典中还没有键值 k1，但仍然可以执行字典的update方法。这种操作方式在传统的字典类型中是无法实现的，必须赋值以后才能进行值得更新操作，否则会报错。看一下传统的字典类型:

b = dict()
b['k1'].append('2')
# TypeError: 'type' object is not iterable

4. OrderedDict
????????OrderDict 叫做有序字典，也是字典类型(dict)的一个子类，是对字典的一个补充。 前面我们说过，字典类型是一个无序的集合，如果要想将一个传统的字典类型进行排序一般会怎么做了，我们可能会将字典的键值取出来做排序后在根据键值来进行有序的输出，看下面的一个例子：

dic1 = dict()

dic1['a'] = '123'
dic1['b'] = 'jjj'
dic1['c'] = '394'
dic1['d'] = '999'
print(dic1)     # {'a': '123', 'b': 'jjj', 'c': '394', 'd': '999'}
# 方法一
dic1_key_list = []
for k in dic1.keys():
    dic1_key_list.append(k)
dic1_key_list.sort()
for key in dic1_key_list:
    print('dic1字典排序结果 %s:%s'%(key, dic1[key]))
# 方法二
dic1_list = list(dic1.items())
dic1_list.sort(key = lambda item: item[0])
for i in range(len(dic1_list)):
    print("dic1排序结果 %s: %s" % (dic1_list[i][0], dic1_list[i][1]))

????????以上为定义传统字典类型时的一个简单排序过程。 如果我们定义一个有序字典时，将不用再如此麻烦，字典顺序将按照录入顺序进行排序且不会改变。

dic2 = OrderedDict()
dic2['a'] = '123'
dic2['b'] = 'jjj'
dic2['c'] = '394'
dic2['d'] = '999'
for k, v in dic2.items():
    print("有序字典：%s:%s" % (k, v))

5. nametuple
????????标准的tuple类型使用数字索引来访问元素，

bob = ('Bob', 30, 'male')
print("Representation:", bob)       # Representation: ('Bob', 30, 'male')

jane = ('Jane', 29, 'female')
print('\nField by index:', jane[0]) 

print('\nFields by index:')
for p in [bob, jane]:
    print('%s is a %d year old %s' % p)

????????这种对于标准的元组访问，我们需要知道元素对应下标索引值，但当元组的元素很多时，我们可能无法知道每个元素的具体索引值，这个时候就是可命名元组登场的时候了。

????????nametuple 的创建是由自己的类工厂nametuple()进行创建，而不是由标准的元组来进行实例化，通过nametuple()创建类的参数包括类名称和一个包含元素名称的字符串

P = namedtuple('Person', 'name, age, gender')
print('Type of Person:', type(P))   # Type of Person: <class 'type'>

bob = P(name='Bob', age=30, gender='male')
print('\nRepresentation:', bob)     # Representation: Person(name='Bob', age=30, gender='male')

jane = P(name='Jane', age=29, gender='female')
print('\nField by name:', jane.name)    # Field by name: Jane

print('\nFields by index:')
for p in [bob, jane]:
    print('%s is a %d year old %s' % p)
# Fields by index:
# Bob is a 30 year old male
# Jane is a 29 year old female

????????通过上面的实例可以看出，我们通过nametuple()创建了一个Person的类，并复制给P变量，Person的类成员包括name,age,gender,并且顺序已经定了，在实例化zhangsan这个对象的时候，对张三的属性进行了定义。这样我们在访问zhangsan这个元组的时候就可以通过张三的属性来复制(zhangsan.name、zhangsan.age等)。这样就算这个元组有1000个元素我们都能通过元素的名称来访问而不用考虑元素的下标索引值。

????????学习该库更多的相关用法，可以阅读官方文档，collections库

1.5 itertools

????????Python内建模块itertools提供了非常有用的用于操作迭代对象的函数。

????????首先，看看itertools提供的几个‘无限’迭代器：

>>> import itertools
>>> natuals = itertools.count(1)
>>> for n in natuals:
...     print(n)
...
1
2
3
...

????????count()会创建一个无限的迭代器，所以上述代码会打印出自然数序列，根本停不下来，只能按Ctrl+C退出。
????????cycle()会把传入的一个序列无限重复下去：

>>> import itertools
>>> cs = itertools.cycle('ABC') # 注意字符串也是序列的一种
>>> for c in cs:
...     print(c)
...
'A'
'B'
'C'
'A'
'B'
'C'
...

????????repeat()负责把一个元素无限重复下去，不过如果提供第二个参数就可以限定重复次数：

>>> ns = itertools.repeat('A', 3)
>>> for n in ns:
...     print(n)
...
A
A
A
...

????????无限序列只有在for迭代时才会无限地迭代下去，如果只是创建了一个迭代对象，它不会事先把无限个元素生成出来，事实上也不可能在内存中创建无限多个元素。

????????无限序列虽然可以无限迭代下去，但是通常我们会通过takewhile()等函数根据条件判断来截取出一个有限的序列：

>>> natuals = itertools.count(1)
>>> ns = itertools.takewhile(lambda x: x <= 10, natuals)
>>> list(ns)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

????????chain()可以把一组迭代对象串联起来，形成一个更大的迭代器：

>>> for c in itertools.chain('ABC', 'XYZ'):
...     print(c)
# 迭代效果：'A' 'B' 'C' 'X' 'Y' 'Z'

????????groupby()把迭代器中相邻的重复元素挑出来放在一起：

>>> for key, group in itertools.groupby('AAABBBCCAAA'):
...     print(key, list(group))
...
A ['A', 'A', 'A']
B ['B', 'B', 'B']
C ['C', 'C']
A ['A', 'A', 'A']

import itertools

# 产生ABCD的全排列
itertools.permutations('ABCD')
# 产生ABCDE的五选三组合
itertools.combinations('ABCDE', 3)
# 产生ABCD和123的笛卡尔积
itertools.product('ABCD', '123')
# 产生ABC的无限循环序列
itertools.cycle(('A', 'B', 'C'))

????????学习该库更多的相关用法，可以阅读官方文档，itertools库

参考

• Python常用模块：https://www.liaoxuefeng.com/wiki/1016959663602400/1017642838127488
• 日期和时间：https://www.runoob.com/python3/python3-date-time.html
• collections库:https://www.cnblogs.com/Ironboy/p/8745874.html