Python入门（二十一）- 常见模块

上一章介绍了Python模块的相关知识，在实际开发中，Python的很多功能都已经有了成熟的第三方实现，一般不需要开发者”重复造轮子“，当开发者需要完成某种功能时，通过搜索引擎进行搜索，通常可以找到第三方在Python中为该功能所提供的扩展模块。实际上，Python语言本身也内置了大量模块，对于常规的日期、时间、正则表达式、JSON支持、容器类等，Python内置的模块已经非常完备。
Python内置模块总是在不断更新中，本文只是起到抛砖引玉的作用

sys模块代表了Python解释器，主要用于获取和Python解释器相关的信息。
如下示例，查看sys模块包含的程序单元（包括变量、函数等）。

>>> import sys
>>> [e for e in dir(sys) if not e.startswith('_')]
['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', 'last_traceback', 'last_type', 'last_value', 'maxsize', 'maxunicode',
  'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 
  'platlibdir', 'prefix', 'ps1', 'ps2', '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模块里很冷僻的功能，本节只介绍sys模块中常用属性和函数。

• sys.argv ： 获取运行Python程序的命令行参数。其中sys.argv[0]通常指该Python程序，sys.argv[1]代表Python程序提供的第一个参数，sys.argv[2]代表第二个参数…以此类推。
• sys.byteorder : 显示本地字节序的指示符。如果本地字节序时大端模式。则该属性返回big；否则返回little。
• sys.copyright : 该属性返回与Python解释器相关的版权信息。
• sys.executable : 该属性返回Python解释器在磁盘上的存储路径。
• sys.flags : 该只读属性返回运行Python命令时指定的旗标。
• sys.getfilesystemencoding() : 返回在当前系统中保存文件所用的字符集。
• sys.getrefcount(object) : 返回指定对象的引用计算。前面介绍过，当object对象的引用计算为0时，系统会回收该对象。
• sys.getrecursionlimit() : 返回Python解释器当前支持的递归深度，该属性可通过setrecursionlimit()方法重置。
• sys.getswitchinterval() : 返回在当前Python解释器中线程切换的时间间隔，该属性可以通过setswitchinterval()函数改变。
• sys.implementation:返回当前Python解释器的实现。
• sys.maxsize: 返回Python整数支持的最大值。在32位平台上，该属性值位231-1；在64位平台上，该属性值为263-1.
• sys.modules : 返回模块名和载入模块对应关系的字典。
• sys.path : 该属性指定Python产找模块的路径列表。程序可通过修改该属性来动态增加Python加载模块的路径。
• sys.platform ： 返回Python解释器所在平台的标识符。
• sys.stdin : 返回系统的标准输入流（类文件对象）
• sys.stdout : 返回系统的标准输出流（类文件对象）
• sys.stderr : 返回系统的错误输出流（类文件对象）
• sys.version : 返回当前Python解释器的版本信息。
• sys.winver : 返回当前Python解释器的主版本号。
  示例：

>>> import sys
>>> print(sys.argv)
['']
>>> print(sys.copyright)
Copyright (c) 2001-2021 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)
D:Administrator5-PersonalSoftwarepython-3.9.9-embed-amd64python.exe
>>> print(sys.getfilesystemencoding())
utf-8
>>>

os模块代表了程序所在的操作系统，主要用于获取程序运行所在操作系统的相关信息。
在Python交互解释器中先导入os模块，使用all命令查看该模块对外开放的全部属性和函数。示例如下：

>>> import os
>>> os.__all__
['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模块主要包含3方面的内容：

1. 系统相关的函数

下面程序演示了表 1 中部分函数的功能和用法：

>>> import os
>>> os.name
'nt'
>>> os.getenv('PYTHONPATH')
>>> os.getlogin()
'F21633C'
>>> os.getpid()
13676

其他的示例就不一一试验了，感兴趣的读者可以自己尝试。

2. 文件相关的函数
   具体的用法我们还会在后续文件操作中进行介绍。

3. 进程管理函数
   主要用于启动新进程、中止已有进程等

import os
# 运行平台cmd命令
# **os.system('cmd')**
# 使用Excel打开g:\abc.xls文件
os.startfile('g:\abc.xls')
os.spawnl(os.P_NOWAIT,'E:\Tools\Notepad++.7.5.6.bin.x64\notepad++.exe','')
# 使用python命令执行os_test.py程序
os.execl("D:\Python\Python36\Python.exe","","os_test.py",'i')

如果直接运行上面的程序，可以看到程序运行后使用Excel打开了abc.xls文件，也打开了Notepad++工具，还使用python命令运行了os_test.py文件。但如果将程序中**包裹的代码启用，将看到程序运行后只启动了cmd命令，这是因为使用os.system()函数来运行程序，新程序所在的进程会替代原有进程。
在使用os.execl()函数运行新进程之后，也会取代原有的进程，因此上面程序将这行代码放在了最后。

random模块主要包含生成伪随机数的各种功能变量和函数，我们还是先来看一下它都包含哪些函数。

>>> import random
>>> random.__all__
['Random', 'SystemRandom', 'betavariate', 'choice', 'choices', 'expovariate', 
'gammavariate', 'gauss', 'getrandbits', 'getstate', 'lognormvariate', 'normalvariate', 
'paretovariate', 'randbytes', 'randint', 'random', 'randrange', 'sample', 'seed', 
'setstate', 'shuffle', 'triangular', 'uniform', 'vonmisesvariate', 'weibullvariate']
>>>

time模块主要包含各种提供日期、时间功能的类和函数，该模块既提供了把日期、时间格式化为字符串的功能，也提供了从字符串恢复日期、时间的功能。

>>> import time
>>> [e for e in dir(time) if not e.startswith('_')]
['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个属性，每个属性的信息如下：

>>> time.localtime()
time.struct_time(tm_year=2022, tm_mon=7, tm_mday=8, tm_hour=15, tm_min=7, tm_sec=44, tm_wday=4, tm_yday=189, tm_isdst=0)
>>> time.gmtime()
time.struct_time(tm_year=2022, tm_mon=7, tm_mday=8, tm_hour=7, tm_min=8, tm_sec=18, tm_wday=4, tm_yday=189, tm_isdst=0)
>>>

time.srftime()与time.strptime()涉及到编写格式模板，时间格式字符串支持的指令如下：

在itertools模块中，主要包含了一些生成迭代器的函数，

>>> import itertools
>>> [e for e in dir(itertools) if not e.startswith('_')]
['accumulate', 'chain', 'combinations', 'combinations_with_replacement', 'compress', 
'count', 'cycle', 'dropwhile', 'filterfalse', 'groupby', 'islice', 'permutations', 
'product', 'repeat', 'starmap', 'takewhile', 'tee', 'zip_longest']
>>>

1. 生成无限迭代器

• count(start，[step]):生成start开始，步进为step（默认1）的迭代器，
• cycle§:生成序列p无限循环的迭代器，
• repeat（elem[,n]):生成n个元素elem重复的迭代器，不指定n，则生成无限循环。

2. 其他常用迭代器函数

• accumulate(p[,func]):生成按照func函数计算序列p内元素形成的迭代器，如果不指定func，默认生成序列p元素累加迭代器，p0,p0+p1,p0+p1+p2,…
• chain(p,q,…):将多个序列元素”链“在一起，形成新的迭代器
• compress(data,selectors):根据selectors序列的值对data序列的元素进行过滤，如果selectors[0]的值为真，保留data[0],否则删除，以此类推。
• dropwhile(pred,seq):使用pred函数对seq序列进行过滤，保留从第一个计算为False的元素seq[i]开始至结束的元素。
• takewhile(pred,seq):与上一函数相反，去掉从第一个计算结果为False的seq[i]至结束的元素
• filterfalse(pred,seq):保留序列seq中，使用pred计算结果为True的值
• islice(seq,[start,]stop[,step]):类似于序列的切片slice（）函数，返回seq[start:stop:step]的结果
• starmap(func,seq):使用func（）对seq的元素进行计算，返回计算结果的迭代器，支持序列解包，即seq中多个元素给func传递参数，输出结果。所以变换后的序列长度未必等于len(seq)
• zip_longers(p,q,…)将p，q等序列中的元素按索引合并成元组，这些元组将作为新学列的元素。

3. 生成排列组合的工具函数

• product(p,q,…[repeat=1]):用学了p，q中的元素进行排列组合，相当于使用嵌套循环组合。
• permutations(p,[,r]):从序列p中取出r个元素组成全排列，将排列得到的元组作为新迭代器的元素
• combinations(p,r):从序列p中取出r个元素组成全组合，元素不允许重复，将组合得到的元组作为新迭代器的元素
• conbinations_with_replacement(p,r):从序列p中取出r个元素组成全组合，元素允许重复，将组合得到的元组作为新迭代器的元素。
  示例：

import itertools as it
#product 使用两个序列进行排列组合
for e in it.product('AB','CD'):
    print(''.join(e),end=',')    # AC, AD, BC, BD,
#product 使用一个序列，重复两次进行排列组合
for e in it.product('AB',repeat=2):
    print(''.join(e),end=',')    # AA, AB, BA, BB,
>>> [e for e in it.permutations('ABCD',2)]
[('A', 'B'), ('A', 'C'), ('A', 'D'), ('B', 'A'), ('B', 'C'), ('B', 'D'), ('C', 'A'), ('C', 'B'), ('C', 'D'), ('D', 'A'), ('D', 'B'), ('D', 'C')]
>>> [e for e in it.combinations('ABCD',2)]
[('A', 'B'), ('A', 'C'), ('A', 'D'), ('B', 'C'), ('B', 'D'), ('C', 'D')]
>>> [e for e in it.combinations_with_replacement('ABCD',2)]
[('A', 'A'), ('A', 'B'), ('A', 'C'), ('A', 'D'), ('B', 'B'), ('B', 'C'), ('B', 'D'), ('C', 'C'), ('C', 'D'), ('D', 'D')]
>>>

functools模块中主要包含了一些函数装饰器和便捷的功能函数。

>>> import functools
>>> [e for e in dir(functools) if not e.startswith('_')]
['GenericAlias', 'RLock', 'WRAPPER_ASSIGNMENTS', 'WRAPPER_UPDATES', 'cache', 
'cached_property', 'cmp_to_key', 'get_cache_token', 'lru_cache', 'namedtuple', 'partial', 
'partialmethod', 'recursive_repr', 'reduce', 'singledispatch', 'singledispatchmethod', 
'total_ordering', 'update_wrapper', 'wraps']
>>>

• functools.lru_cache(maxsize=128,type=False): 该函数装饰器使用LRU（最近最少使用）缓存算法来缓存相对耗时的函数结果，避免传入相同的参数重复计算。同时，缓存并不会无限增长，不用的缓存会被释放。其中，maxsize参数用于设置缓存只占用的最大字节数。typed参数用于设置将不同类型的缓存结果分开存放
• functools.cmp_to_key（func）:将func转换为关键字函数
• @functools.total_ordering:这个类装饰器（作用类似于函数装饰器，只是它用于装饰类）用于为类自动生成比较方法。通常来说，开发者只要提供–lt–（）-、–le–（）-、–gt–（）-、–ge–（）其中之一（最好能提供–eq–（）方法），@functools.total_ordering装饰器就会为该类生成剩下的比较好的方法。
• functools.partial(func,*args,**keywords):该函数用于为func函数的部分参数指定参数值，从而得到一个转换后的函数，程序以后调用转换后的函数时，就可以少传入哪些已指定值的参数。
• functools.partialmethod(func,*args,**keywords):该函数与上一函数含义完全相同，只不过该函数用于为类中的方法设置参数
• functools.reduce(function,iterable[,initialzer]):将初始值（默认为0，可由initialzer参数指定）、迭代器的当前元素传入function函数，将计算出来的函数结果作为下一次计算的初始值、迭代器的下一元素再次调用function函数，以此类推，直到迭代器的最后一个元素。
• @functools.singledispatch:该函数装饰器用于实现函数对多个类型进行重载。比如同样的函数名称，为不同的参数类型提供不同的功能实现，该函数的本质就是根据参数类型的变换，将函数转向调用不同的函数。
• functools.update_wrapper(wrapper,wrapped,assigned=WRAPPER_ASSIGNMENTS,updated=WRAPPER_UPDATES):对wrapper函数进行包装，使之看上去就像wrapper（被包装）函数。
• functools.wraps(wrapped,assigned=WRAPPER_ASSIGNMETS,updated=WRAPPER_UPDATES):该函数装饰器用于修饰包装函数，使包装函数看上去就像wrapper函数。

from functools import *
#设初始值（默认为0）为x，当序列元素为y，将x+y作为下一次初始值
print(reduce（lambda x,y:x+y,range(5)))  #10
print(reduce(lambda x,y:x+y,range(6)))   #15
#设初始值为10
print（reduce(lambda x,y:x+y,range(6),10))   +25

class User:
    def __init__(self,name)
        self.name = name
    def __repr__(self)
        return 'User[name]=%s'% self,name
#定义一个老式的大小比较函数，User的那么越长，该User越大
def old_cmp(u1,u2)
    return len(u1.name)-len(u2.name)
my_data = [User('kotlin'),User('Swift'),User('Go'),User('Java')]
# 对my_data排序，需要将关键字函数（调用cmp_to_key将old_cmp转换为关键字函数）
my_data.sort(key=cmp_to_key(old_cmp))
Print (my_data)  

@lru_cache(maxsize=32)
def factorial(n):
    print(’计算 %d 的阶乘',%n)
    if n==1:
        return 1
    else:
        return n*factorial(n-1)
#只有这行会计算，然后会缓存5、4、3、2、1的阶乘
print（factorial(5))
print（factorial(3))
print（factorial(5))

#内置函数int函数默认将十进制的字符串转换为整数
print(int('1234')
# 为int函数的base参数指定参数值
basetwo = partial(int,base =2 )
basetwo.__doc__ = '将二进制形式的字符串转换为整数'
#相当于执行base=2的int函数(将二进制的字符串转为十进制）
print(basetwo('10010'))    #18
print(int('10010',2))    #18

partialmethod()与partial（）函数的作用基本相似，只是用于类方法部分参数值绑定。

from functools import *
class Cell:
    def __init__(self):
        self.alive = False
    # @property装饰器指定该方法可使用属性语句访问
    @property
    def alive(self):
        return self._alive
    def set_state(self,state):
        self.alive = bool(state)
    #指定set_alive()方法，就是将set_state()方法的state参数指定为Ture
    set_alive = partialmethod(set_state,Ture)
    #指定set_dead()方法，就是将set_state()方法的state参数指定为False
    set_dead = partialmethod(set_state,False)
c = Cell()
print(c.alive) # False
#相当于调用c.set_state(Ture)
c.set_alive()
print(c.alive)   # Ture
#相当于调用c.set_state(False)
c.set_alive()
print(c.alive)   # False

下面示范@total_ording类装饰器的作用。

from functools import *
@total_ordering
class User:
    def __init__(self,name):
        self.name = name
    def __repr__(self):
        return 'User|name=%s'% self.name
    #根据是否有name属性决定是否可比较
    def _is_valid_operand(self,other):
        #内置函数hasattr()判断other对象中是否有name属性
        rentrn hasattr(other,"name")
    def __eq__(self,other):
        if not self._is_valid_operaned(other)
            return NotImplemented
        #根据name判断是否相等（都转换成小写比较，或略大小写）
        return self.name.lower() == other.lastname.lower()
    def __lt__(self,other):
        if not self._is_valid_operaned(other)
            return NotImplemented
        #根据name判断是否小于（都转换成小写比较，或略大小写）
        return self.name.lower() < other.lastname.lower()
#打印被装饰之后的User类中的__gt__方法
print(User.__gt__)   #自动生成了大于的比较

@singledispatch函数装饰器的作用使根据函数参数类型，实现调用不同的函数。

from functools import *
@singledispatch
def test(are,verbose):
    if verbose:
        print('默认参数为：',end = "")
    print(arg)
#限制test函数的第一个参数为int类型的函数版本,register()方法是使用@singledispatch修饰后，自动添加的方法，用于为指定类型注册被转向调用的函数。
@test.register(int)
def (argu,verbose):
    if verbose:
        print('整型参数为：',end = "")
    print(argu)
test('Python',True)   #默认参数为：Python
test(20,True)        #整型参数为：20