Python进阶篇05-常用内置模块及常用方法

dir()函数：返回模块的属性列表（返回值是一个列表）
参数可选，为对象、变量、类型
该方法没有参数时，返回当前范围内的属性、方法等，传入参数时，查看参数指定的对象的所有属性和方法

# 查看列表的属性和方法
dir([])
# 查看字符串的属性和方法
dir('')
# 查看sys模块的属性和方法
import sys
dir(sys)
# 自定义的模块，也可以导入之后，使用dir查看它的属性和方法
# my_test是自定义的模块
import my_test
print(dir(my_test))

os模块提供了许多能够直接操纵不同的操作系统的Python接口

导入os模块：import os

os.name 返回当前操作系统的类型

若为windows系统，则返回'nt'，如果是Linux、Unix或Mac OS X，则返回'posix'

import os

print(os.name)
----------
posix

os.sep 获取当前操作系统的路径分隔符

print(os.sep)
----------
/

os.getcwd() 获取当前的工作路径

语法：os.getcwd()，无参数
返回值：当前脚本的目录绝对路径，而非当前脚本的路径

print('当前脚本的工作目录：{}'.format(os.getcwd()))
----------
当前脚本的工作目录：/Users/........../PycharmProjects/pythonProject

os.listdir() 返回指定文件夹下的文件与文件夹的名字的列表

语法：os.listdir(path)

path：为字符串格式的目录路径，若不写参数，则默认返回当前工作目录下的文件夹与文件的名字的列表

print('当前工作目录下的文件列表：{}'.format(os.listdir()))
----------
当前工作目录下的文件列表：['main.py', '.idea']

os.walk()逐层遍历指定路径下所有的子文件夹、文件

语法：os.walk(top, topdown=True, onerror=None, followlinks=False)

top：需要遍历的文件夹路径
topdown：默认为True，从当前指定文件夹路径向下遍历，若为False，则从最下层的文件夹开始向上遍历
返回值：返回一个生成器，此生成器每次返回一个三元元组 (root, dirs, files)，可使用for循环进行遍历
root：当前遍历的文件夹路径
dirs：以list形式返回当前文件夹下的文件夹
files：以list形式返回当前文件夹下的所有文件

import os


for root, dirs, files in os.walk('/Users/test/Desktop/测试文件夹'):  # 不指定topdown，默认为True，从当前指定文件夹向下遍历
    print('root: {}'.format(root))
    print('dirs: {}'.format(dirs))
    print('files: {}'.format(files))

----------
root: /Users/test/Desktop/测试文件夹
dirs: ['图片文件夹', '文件汇总']
files: ['370600px.png', '20210905181527.png', '.DS_Store', 'AF5EB107-C05D-486B-92F0-29850694FE61.png', '3d6d7d14b2bf48718e7c96c6d1a2b1d0.png', '20210922235244.png', '1485050987244.jpeg', '530d55f2abad4d4a9751a4be37d2006a.png', '20210923001016.png']
root: /Users/test/Desktop/测试文件夹/图片文件夹
dirs: []
files: ['.DS_Store', 'banner.png', 'banner2.png', 'banner3.png', 'banner4.png']
root: /Users/test/Desktop/测试文件夹/文件汇总
dirs: []
files: ['附录4录用测试.doc', '.DS_Store', '测试测试.xlsx']

指定topdown参数为False，则反过来从下向上遍历

for root, dirs, files in os.walk('/Users/test/Desktop/测试文件夹', topdown=False):
    print('root: {}'.format(root))
    print('dirs: {}'.format(dirs))
    print('files: {}'.format(files))

----------
root: /Users/test/Desktop/测试文件夹/图片文件夹
dirs: []
files: ['.DS_Store', 'banner.png', 'banner2.png', 'banner3.png', 'banner4.png']
root: /Users/test/Desktop/测试文件夹/文件汇总
dirs: []
files: ['附录4录用测试.doc', '.DS_Store', '测试测试.xlsx']
root: /Users/test/Desktop/测试文件夹
dirs: ['图片文件夹', '文件汇总']
files: ['370600px.png', '20210905181527.png', '.DS_Store', 'AF5EB107-C05D-486B-92F0-29850694FE61.png', '3d6d7d14b2bf48718e7c96c6d1a2b1d0.png', '20210922235244.png', '1485050987244.jpeg', '530d55f2abad4d4a9751a4be37d2006a.png', '20210923001016.png']

os.mkdir()创建单级文件夹

语法：os.mkdir(path)

path：为需要创建的文件夹路径，若为绝对路径，则按照此路径创建，若仅为文件夹名称，则会在当前工作目录下创建；会创建最后一级的文件夹，若最后一级前面的不存在则报错
如果创建的文件夹已存在，则会报错，因此优雅的做法是在创建之前判断文件夹是否已存在

返回值：无

path = '/Users/test/Desktop/测试文件夹' + '/new'
if os.path.exists(path):
    print('文件夹已存在，创建失败！')
else:
    os.mkdir(path)

os.makedirs()创建单级/多级文件夹

语法：os.makedirs(path)

path：为需要创建的文件夹路径
如果创建的文件夹已存在，则会报错，相同优雅的做法也是在创建之前判断文件夹是否已存在
与os.mkdir()不同的是，os.makedirs(path)可以创建多层文件夹，即 /dir1/dir2/dir3，os.mkdir()在创建文件夹时，会创建最后一级的文件夹，因此当传入的path为多级时，os.mkdir()发现倒数第二级不存在，则会报错
返回值：无

path = '/Users/test/Desktop/测试文件夹' + '/new_1/new_2'
if os.path.exists(path):
    print('文件夹已存在，创建失败！')
else:
    os.makedirs(path)

os.remove()删除文件

语法：os.remove(path)

path：要删除的文件的路径
只能删除文件，删除文件夹则会报错

返回值：无

os.rmdir()删除空文件夹

语法：os.rmdir(path)

path：要删除的文件夹路径
要删除的文件夹必须为空文件夹，也不可为文件，否则会报错

返回值：无

os.rmdir(path)    # 删除了上述的new_2文件夹

os.system()运行shell命令

语法：os.system(command)

command：为command命令，字符串格式

返回值：若执行成功则会返回0

os.system('cd Desktop')    # 执行单条命令
os.system('cd Desktop; ls')    # 执行多条命令

os.path.split()将文件名和路径分割开

语法：os.path.split(path)，不需要考虑path是否存在，仅做分割操作
返回值：路径和文件名组成的元组

print(os.path.split('/Users/test/Desktop/测试文件夹/new_1/new_2/20210923001016.png'))
----------
('/Users/test/Desktop/测试文件夹/new_1/new_2', '20210923001016.png')

os.path.exists()判断指定给出的路径是否已存在

语法：os.path.exists(path)，可传入文件/文件夹路径
返回值：若指定路径已存在，则返回True，否则返回False

os.path.isfile()判断指定路径是否为文件

语法：os.path.isfile(path)，path为绝对路径或相对路径
返回值：若此路径为文件，则返回True，若路径不存在/路径为文件夹非文件，则返回False

print(os.path.isfile('/Users/test/Desktop/测试文件夹/new_1/new_2/20210923001016.png'))
----------
True

os.path.isdir()判断指定路径是否为文件夹

语法：os.path.isdir(path)，path为绝对路径或相对路径
返回值：若此路径为文件夹，则返回True，若路径不存在/路径为文件非文件夹，则返回False

print(os.path.isdir('/Users/test/Desktop/测试文件夹/new_1/new_2'))
----------
True

os.path.abspath()获取绝对路径

语法：os.path.abspath(path)

path：路径

返回值：若path为绝对路径，则返回path，若path不为绝对路径，则返回 当前脚本工作目录（即os.getcwd()的结果）和path拼接后的路径(是个坑啊)

print(os.path.abspath('/Desktop/测试文件夹/new_1/new_2/20210923001016.png'))
print(os.path.abspath('Desktop/测试文件夹/new_1/new_2/20210923001016.png'))
----------
/Desktop/测试文件夹/new_1/new_2/20210923001016.png
/Users/test/Desktop/codeSpace/myCode/pyCode/all_study_practice/Desktop/测试文件夹/new_1/new_2/20210923001016.png

这样看来判断是否为绝对路径是根据path前的分隔符进行判断的？

os.path.splitext()分离文件路径/文件名与扩展名

语法：os.path.splitext(path)，path为需要分离的路径
返回值：以tuple形式返回分离后的文件路径/文件名与扩展名

print(os.path.splitext('myProject/test.py'))
print(os.path.splitext('test.html'))
----------
('myProject/test', '.py')
('test', '.html')

os.path.join()拼接路径

语法：os.path.join(path1, path2, ......)

path：为字符串，传入多个字符串，拼接为完整路径
使用此方法的好处是可以兼容不同的系统，在拼接路径时不用考虑是'/'还是''，优雅～真是太优雅了～

返回值：拼接后的路径

print(os.path.join('/Users/test/Desktop/测试文件夹', 'new_1', 'new_2'))
----------
/Users/test/Desktop/测试文件夹/new_1/new_2

os.path.dirname()获取指定路径的目录

语法：os.path.dirname(path)，path为路径，相当于将传入的路径分割为目录+文件/文件夹后，返回其目录
返回值：字符串格式的目录

print(os.path.dirname('test/Desktop/测试文件夹/new_1/new_2'))
----------
test/Desktop/测试文件夹/new_1

os.path.basename()获取指定路径的文件名/文件夹名

语法：os.path.basename(path)，path为路径，相当于将传入的路径分割为目录+文件/文件夹后，返回其文件名/文件夹名
返回值：字符串格式的文件名/文件夹名

print(os.path.basename('test/Desktop/测试文件夹/new_1/new_2/20210923001016.png'))
----------
20210923001016.png

os.path.getsize()返回指定路径的文件/文件夹大小

语法：os.path.getsize(path)，path为绝对路径或相对路径
返回值：返回一个整数值，该值为指定路径的大小，此大小为字节单位

print(os.path.getsize('./sth_temps.py'))
----------
25441    # int类型

sys模块主要是提供了针对与Python解释器相关的变量和方法

导入sys模块：import sys

sys.argv获取脚本路径及命令行参数

语法：sys.argv
返回值：一个list，第一个元素始终是当前脚本路径，后面是使用命令行运行脚本时指定的参数

print(sys.argv)    # 不指定参数
----------
['/Users/test/Desktop/........../sth_temps.py']

在终端使用命令行执行时，第一个元素的路径即为执行时命令行写的路径

python sth_temps.py test_1 test_2 test_3
----------
['sth_temps.py', 'test_1', 'test_2', 'test_3']

python ../all_study_practice/sth_temps.py test_1 test_2
----------
['../all_study_practice/sth_temps.py', 'test_1', 'test_2']

sys.version获取Python解释程序的版本信息

语法：sys.version
返回值：Python解释程序的版本信息

>>> import sys
>>> sys.version
'3.8.2 (v3.8.2:7b3ab5921f, Feb 24 2020, 17:52:18) \n[Clang 6.0 (clang-600.0.57)]'    # 此处有个换行符，因此在脚本中使用print输出会换行

sys.getdefaultencoding()获取解释器默认编码

print(sys.getdefaultencoding())
----------
utf-8

sys.path获取Python导入模块及包的查找路径集

语法：sys.path
返回值：元素为路径的字符串list

sys.platform返回操作系统平台名称

语法：sys.platform
返回值：操作系统平台名称，Windows为win32，macOS则为darwin

sys.exit()退出程序

语法：sys.exit([n])

可不写参数，n为0时正常退出，其余为异常退出
正常情况下程序会运行到尾部，然后解释器正常退出；当我们想要程序在中途退出，就可以调用此方法
此方法是通过抛出SystemExit异常来终止程序的，因此如果使用try-except捕获了异常之后，也就不会终止程序了

返回值：无

print('before')
sys.exit()    # 此处退出程序了，因此不会执行下面的代码
print('after')
----------
before

try:
    sys.exit()
except SystemExit as e:
    print('捕获到了SystemExit异常')    # 捕获了异常，会继续往下执行
print('after')
----------
捕获到了SystemExit异常
after

sys.stdin.read()、sys.stdin.readline()、sys.stdin.readlines()

sys.stdin.read()

一次性读取多行数据，输出为字符串，不读取换行符\n到文本，换行符直接起作用
以control+D结束输入，相当于输入了一个空字符串，会被读取为空字符串

m = sys.stdin.read()
print(m)
print(m.split('\n'))
print(type(m))
----------
123
456
7777
^D    # 以control+D结束输入，会被读取为空字符串并会打印出来，换行符直接起作用所以输出时会换行
123
456
7777

['123', '456', '7777', '']    # 将这段字符串以换行符分割为list，可见输入control+D时读取的空字符串
<class 'str'>

sys.stdin.readline()

一次性读取单行数据，输出为字符串
以换行作为结束输入的标志，换行会被读取
与 input()的区别为：a、此函数会读取换行符，但input()不会读取换行符；b、input()中可以写提示文本参数

x = sys.stdin.readline()
print(x, type(x))
----------
123456
123456
 <class 'str'>    # 因为读取了输入时的换行，所以type的值换行打印了

可使用sys.stdin.readline().strip()去掉末尾的换行符

x = sys.stdin.readline().strip()
print(x, type(x))
----------
123456
123456 <class 'str'>

sys.stdin.readlines()

一次性读取多行数据，输出为字符串元素组成的list，字符串元素为每一行输入的数据，其中也包括换行符
以control+D结束输入，但不会读取为空字符串

n = sys.stdin.readlines()
print(n, type(n))
----------
1234
5678
^D
['1234\n', '5678\n'] <class 'list'>

sys.stdout.write('xxx')标准输出

sys.stdout.write('xxx')，参数只能为字符串对象，而print()参数可以为其他任何对象
sys.stdout.write('xxx')输出时不会自带换行，需要时可以自己和换行符'\n'拼接，而print()会默认换行

sys.stdout.write('stdout one')
sys.stdout.write('stdout two')
# sys.stdout.write([1, 2, 3])    会报错

print('print one')
print('print two')
print(1)
----------
stdout onestdout twoprint one
print two
1

time模块

导入time模块：import time

以下是Python中几种表示时间的方式：

时间戳：1970 年 1 月 1 日之后经过的秒数，为浮点数，可以通过time.time()获得当前时间的时间戳
结构化时间time.struct_time类型：在Python中的time模块定义了一个struct_time类型的元组，共九个元素，例如 time.struct_time(tm_year=2022, tm_mon=11, tm_mday=4, tm_hour=9, tm_min=45, tm_sec=59, tm_wday=4, tm_yday=308, tm_isdst=0)，可以通过time.localtime()获取当前时间的struct_time元组
- tm_year=年
- tm_mon=月，取值范围[0, 11]，0代表1月
- tm_mday=日，取值范围[1, 31]
- tm_hour=时，取值范围[0, 23]
- tm_min=分，取值范围[0, 59]
- tm_sec=秒，取值范围[0, 59]
- tm_wday=星期，取值范围[0, 6]，0代表周一
- tm_yday=今年第几天，取值范围为[0, 365]，0代表1月1日第一天
- tm_isdst=是否夏令时，实行夏令时的时候，tm_isdst为正；不实行夏令时的时候，tm_isdst为0；不了解情况时，tm_isdst为负
格式化的时间字符串string_time：也就是易于读懂的常见的时间字符串，例如 '2022-11-04 09:52:16'

time.time()获取当前时间的时间戳

语法：time.time()，无参数
返回值：返回当前时间的时间戳，是浮点数类型，根据需要，可对此值进行取整等计算从而获得不同位数的时间戳

import time

time_stamp = time.time()
print(time_stamp, type(time_stamp))
print(int(time_stamp))
print(int(time_stamp * 1000))
----------
1667527877.4988868 <class 'float'>
1667527877
1667527877498

time.localtime()格式化时间戳为结构化时间类型

语法：time.localtime([sec])

sec：时间戳秒数，非必填，若填写，则打印出对应的结构化时间time.struct_time类型，若不填，则打印出当前时间对应的构化时间time.struct_time类型

返回值：无返回值，直接打印出转换结果

time_stamp = time.time()
print('当前时间戳：{}'.format(time_stamp))
print('当前struct_time：{}'.format(time.localtime()))
print('将时间戳转换为struct_time：{}'.format(time.localtime(time_stamp)))
----------
当前时间戳：1667528494.262132
当前struct_time：time.struct_time(tm_year=2022, tm_mon=11, tm_mday=4, tm_hour=10, tm_min=21, tm_sec=34, tm_wday=4, tm_yday=308, tm_isdst=0)
将时间戳转换为struct_time：time.struct_time(tm_year=2022, tm_mon=11, tm_mday=4, tm_hour=10, tm_min=21, tm_sec=34, tm_wday=4, tm_yday=308, tm_isdst=0)

time.gmtime()格式化时间戳为UTC时区即0时区（与北京时间相差8小时）time.struct_time类型的对象

语法：time.gmtime([sec])

sec：时间戳秒数，非必填，若填写，则打印出对应的结构化时间time.struct_time类型，若不填，则打印出当前时间对应的构化时间time.struct_time类型

返回值：无返回值，直接打印出转换结果，注意，若要将获得的时间转换为北京时间，需要在小时数上加8

time_stamp = time.time()
print('当前时间戳：{}'.format(time_stamp))
print('当前struct_time：{}'.format(time.gmtime()))
print('将时间戳转换为struct_time：{}'.format(time.gmtime(time_stamp)))
----------
当前时间戳：1667532429.976187
当前struct_time：time.struct_time(tm_year=2022, tm_mon=11, tm_mday=4, tm_hour=3, tm_min=27, tm_sec=9, tm_wday=4, tm_yday=308, tm_isdst=0)
将时间戳转换为struct_time：time.struct_time(tm_year=2022, tm_mon=11, tm_mday=4, tm_hour=3, tm_min=27, tm_sec=9, tm_wday=4, tm_yday=308, tm_isdst=0)

time.asctime()接受时间元组并返回一个可读形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日周二18时07分14秒）的24个字符的字符串

语法：time.asctime([tuple])

tuple：为9个元素组成的时间元组或者通过time.localtime()或者time.gmtime()获得的time.struct_time元组，非必填，不填则返回当前时间的可读形式字符串

返回值：返回一个可读形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日周二18时07分14秒）的24个字符的字符串

print(time.asctime())
print(time.asctime(time.localtime()))
----------
Fri Nov  4 11:20:15 2022
Fri Nov  4 11:20:15 2022

time.mktime()将struct_time对象转换为时间戳

语法：time.mktime(tuple)

tuple：必填，9位元素组成的元组或者struct_time对象

返回值：返回浮点数类型的时间戳

print(time.mktime((2009, 2, 17, 17, 3, 38, 1, 48, 0)))
print(time.mktime(time.localtime()))
----------
1234861418.0
1667541382.0

time.strftime()格式化时间元组为时间字符串

语法：time.strftime(format[, t])

format：格式字符串，必填参数，决定将时间格式化成什么样子；常用的时间格式化符号如下：
t：struct_time对象，非必填参数，若不填则为当前时间

返回值：格式化后的时间字符串

# 常用的格式化字符串如下

print(time.strftime('%Y'))    # 四位数的年份表示
print(time.strftime('%m'))    # 月份 01-12
print(time.strftime('%d'))    # 日 1-31
print(time.strftime('%H'))    # 24小时制小时数 0-23
print(time.strftime('%M'))    # 分钟 00-59
print(time.strftime('%S'))    # 秒 00-59
print(time.strftime('%w'))    # 星期 0-6 0为星期天
print(time.strftime('%x'))    # 本地相应的日期表示
print(time.strftime('%X'))    # 本地相应的时间表示
print(time.strftime('%I'))    # 12小时制小时数 01-12
print(time.strftime('%p'))    # 本地AM 或者 PM的等价符
print(time.strftime('%j'))    # 一年内的第几天
----------
2022
11
04
14
18
00
5
11/04/22
14:18:00
02
PM
308

print(time.strftime('%Y-%m-%d', (2022, 1, 1, 0, 0, 0, 0, 0, 0)))
print(time.strftime('%Y-%m-%d %w %H:%M:%S', time.localtime()))
print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(1641043672)))
print(time.strftime('一年的第%j天', time.localtime()))
print(time.strftime('%Y-%m-%d %I:%M:%S %p', time.localtime()))
----------
2022-01-01
2022-11-06 0 21:28:10
2022-01-01 21:27:52
一年的第310天
2022-11-06 09:28:10 PM

time.strptime()将时间字符串按照格式字符串解析为时间元组

语法：time.strptime(string[, format])，将时间字符串按照对应的格式字符串解析为时间元组

string：时间字符串
format：格式字符串

返回值：返回struct_time对象

print(time.strptime('2022-01-01', '%Y-%m-%d'))
print(time.strptime('2022-11-06 0 21:41:47', '%Y-%m-%d %w %H:%M:%S'))
print(time.strptime('2022-01-01 21:27:52', '%Y-%m-%d %H:%M:%S'))
print(time.strptime('310', '%j'))
print(time.strptime('2022-11-06 09:41:47 PM', '%Y-%m-%d %I:%M:%S %p'))
----------
time.struct_time(tm_year=2022, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=5, tm_yday=1, tm_isdst=-1)
time.struct_time(tm_year=2022, tm_mon=11, tm_mday=6, tm_hour=21, tm_min=41, tm_sec=47, tm_wday=6, tm_yday=310, tm_isdst=-1)
time.struct_time(tm_year=2022, tm_mon=1, tm_mday=1, tm_hour=21, tm_min=27, tm_sec=52, tm_wday=5, tm_yday=1, tm_isdst=-1)
time.struct_time(tm_year=1900, tm_mon=11, tm_mday=6, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=1, tm_yday=310, tm_isdst=-1)
time.struct_time(tm_year=2022, tm_mon=11, tm_mday=6, tm_hour=21, tm_min=41, tm_sec=47, tm_wday=6, tm_yday=310, tm_isdst=-1)

time.sleep()推迟调用线程的运行

语法：time.sleep(sec)，按照字面意思就是让线程睡一会儿

sec：推迟执行的秒数

返回值：无返回值

print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime()))
time.sleep(10)    # 执行到这里，会睡眠十秒后再继续向下执行
print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime()))
----------
2022-11-06 21:49:43
2022-11-06 21:49:53    # 可见时间差为十秒

time.perf_counter()精确计时，返回CPU级别的以秒为单位的时间浮点值

语法：time.perf_counter()
返回值：以秒为单位的时间浮点值，常用来计算程序运行耗时

start = time.perf_counter()
time.sleep(5)
end = time.perf_counter()
t = end - start
print('耗时：{}s'.format(t))
----------
耗时：5.001035958s

datetime模块

Python的内置datetime模块，其中包含六个类和两个常数，提供了用于处理日期和时间的类和对应的方法，最常用的是datetime模块下的datetime类、timedelta类；以下内容参考自这篇文章【万字长文】详解Python时间处理模块-datetime

ISO 历法：是一种被广泛使用的格列高利历。ISO 年由 52 或 53 个完整星期构成，每个星期开始于星期一结束于星期日。一个 ISO 年的第一个星期就是（格列高利）历法的一年中第一个包含星期四的星期。这被称为 1 号星期，这个星期四所在的 ISO 年与其所在的格列高利年相同。

导入datetime模块：import datetime

datetime.date类

作用：用于处理日期信息
语法：实例化一个datetime.date类对象 datetime.date(year, month, date)
返回值：返回一个datetime.date类对象

>>> x = datetime.date(2022, 10, 1)
>>> type(x)
<class 'datetime.date'>

datetime.date实例属性

datetime.date.year：返回datetime.date对象的年份
datetime.date.month：返回datetime.date对象的月份
datetime.date.day：返回datetime.date对象的日期

import datetime

d = datetime.date(2022, 11, 3)
print(d.year)
print(d.month)
print(d.day)
----------
2022
11
3

datetime.date类方法

datetime.date.today() 返回当前的本地日期，返回值为datetime.date对象

>>> datetime.date.today()
datetime.date(2022, 11, 14)
>>> print(datetime.date.today())
2022-11-14

注意：此处print直接将datetime.date对象以日期字符串的形式打印出来了，是因为在python中，调用print函数时，会去调用对象的__str__方法，而datetime.date对象的此方法就是返回日期对象对应的日期字符串

datetime.date.fromtimestamp(timestamp) 返回时间戳对应的datetime.date对象，只能接收10位时间戳（即以秒为单位）

>>> datetime.date.fromtimestamp(1668392832)
datetime.date(2022, 11, 14)

datetime.date.fromisoformat(date_string) 返回日期字符串对应的datetime.date对象

>>> datetime.date.fromisoformat('2022-11-05')
datetime.date(2022, 11, 5)

datetime.date.fromisocalendar(year, week, day) 返回某年第week星期第day天对应的datetime.date日期对象

>>> datetime.date.fromisocalendar(2022, 1, 1)
datetime.date(2022, 1, 3)

datetime.date类实例方法

date.replace(year=year, month=month, day=day) 通过关键字参数替换日期中的值，若无参数则返回相同的日期

>>> d = datetime.date.today()
>>> d
datetime.date(2022, 11, 14)
>>> d.replace()
datetime.date(2022, 11, 14)
>>> d.replace(month=12)
datetime.date(2022, 12, 14)

date.timetuple() 返回datetime.date对象对应的时间元组time.struct_time对象

>>> d
datetime.date(2022, 11, 14)
>>> d.timetuple()
time.struct_time(tm_year=2022, tm_mon=11, tm_mday=14, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=318, tm_isdst=-1)

date.weekday() 返回日期对应的星期，0-6，0为星期一

>>> d
datetime.date(2022, 11, 14)
>>> d.weekday()
0

date.isoweekday() 返回日期对应的星期，1-7，1为星期一

>>> d
datetime.date(2022, 11, 14)
>>> d.isoweekday()
1
>>> d.replace(day=13).isoweekday()
7

date.isoformat() 返回datetime.date日期对应的日期字符串

>>> d
datetime.date(2022, 11, 14)
>>> d.isoformat()
'2022-11-14'

date.strftime() 通过格式字符串，返回date对象对应格式的日期字符串

>>> d
datetime.date(2022, 11, 14)
>>> d.strftime('%Y年%m月%d日')
'2022年11月14日'

支持的运算

>>> d1 = datetime.date(2022, 11, 1)
>>> d2 = datetime.date(2022, 10, 31)
>>> d1 - d2
datetime.timedelta(days=1)
>>> d1 < d2
False
>>> d1 > d2
True
>>> d3 = d1 + datetime.timedelta(days=5)
>>> d3
datetime.date(2022, 11, 6)
>>> d4 = d1 - datetime.timedelta(days=3)
>>> d4
datetime.date(2022, 10, 29)

datetime.time类

作用：用于处理时间信息
语法：实例化一个datetime.time类对象 datetime.time(hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold=0)
返回值：返回一个datetime.time类对象

>>> datetime.time(12, 33, 41, 123)
datetime.time(12, 33, 41, 123)
>>> print(datetime.time(12, 33, 41, 123))
12:33:41.000123
>>> datetime.time()
datetime.time(0, 0)
>>> print(datetime.time())
00:00:00

datetime.time类实例属性

datetime.time.hour：返回datetime.time对象的小时
datetime.time.minute：返回datetime.time对象的分钟
datetime.time.second：返回datetime.time对象的秒
datetime.time.microsecond：返回datetime.time对象的微秒

>>> d = datetime.time(12, 33, 48, 3399)
>>> d.hour
12
>>> d.minute
33
>>> d.second
48
>>> d.microsecond
3399

datetime.time类实例方法

time.replace() 通过关键字参数替换时间中的值，若无参数则返回相同的时间

>>> d = datetime.time(14, 8, 32, 4567)
>>> d.replace(minute=22)
datetime.time(14, 22, 32, 4567)
>>> d.replace()
datetime.time(14, 8, 32, 4567)

time.isoformat() 返回time对象的时间字符串
语法：time.isoformat(timespec='auto')，timespec为可选参数，指定了时间字符串以哪个时间单位来输出，默认为'auto'——若有微秒则是微秒，若无则是秒，可选参数有——'hours'、'minutes'、'seconds'、'microseconds'

>>> d
datetime.time(14, 8, 32, 4567)
>>> d.isoformat()
'14:08:32.004567'
>>> d.isoformat(timespec='hours')
'14'
>>> d.isoformat(timespec='minutes')
'14:08'
>>> d.isoformat(timespec='seconds')
'14:08:32'
>>> d.isoformat(timespec='microseconds')
'14:08:32.004567'

time.fromisoformat() 返回时间字符串对应的time对象

>>> datetime.time.fromisoformat('14:08:32.004567')
datetime.time(14, 8, 32, 4567)
>>> datetime.time.fromisoformat('14:08:32')
datetime.time(14, 8, 32)

time.strftime() 返回time对象对应的时间字符串

>>> t = datetime.time(14, 8, 32, 4567)
>>> t
datetime.time(14, 8, 32, 4567)
>>> t.strftime('%H时%M分%S秒')
'14时08分32秒'

datetime.datetime类

作用：用于处理日期和时间信息，datetime类是date类和time类的结合体
语法：实例化一个datetime.datetime对象 datetime.datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold=0)，year、month、day为必填参数
返回值：返回一个datetime.datetime对象

>>> d = datetime.datetime(2022, 11, 12, 14, 9, 55, 12345)
>>> d
datetime.datetime(2022, 11, 12, 14, 9, 55, 12345)
>>> print(d)
2022-11-12 14:09:55.012345

datetime.datetime类属性

datetime.datetime.min datetime.datetime类的最小值

>>> datetime.datetime.min
datetime.datetime(1, 1, 1, 0, 0)

datetime.datetime.max datetime.datetime类的最大值

>>> datetime.datetime.max
datetime.datetime(9999, 12, 31, 23, 59, 59, 999999)

datetime.datetime类方法

datetime.datetime.today() 返回当前日期时间，返回值为datetime.datetime对象

>>> t = datetime.datetime.today()
>>> print(t)
2022-11-14 15:18:28.084717

datetime.datetime.now() 返回当前日期时间，返回值为datetime.datetime对象

>>> n = datetime.datetime.now()
>>> print(n)
2022-11-14 15:18:51.816801

datetime.datetime.fromtimestamp(timestamp) 根据时间戳返回对应的datetime.datetime对象，接收的时间戳为10位时间戳

>>> datetime.datetime.fromtimestamp(1668410370)
datetime.datetime(2022, 11, 14, 15, 19, 30)

datetime.datetime.combine(date, time) 接收date对象和time对象，并返回组合成的datetime对象

>>> datetime.datetime.combine(datetime.date(2022, 11, 23), datetime.time(9, 18, 23))
datetime.datetime(2022, 11, 23, 9, 18, 23)

datetime.datetime.fromisoformat(string) 参数为日期时间字符串，返回对应的datetime对象

>>> datetime.datetime.fromisoformat('2022-11-14 15:18:51')
datetime.datetime(2022, 11, 14, 15, 18, 51)
>>> datetime.datetime.fromisoformat('2022-11-14')
datetime.datetime(2022, 11, 14, 0, 0)

datetime.datetime.fromisocalendar(year, week, day) 返回某年第week星期第day天对应的datetime.datetime对象，时间部分会使用默认值填充

>>> datetime.datetime.fromisocalendar(2022, 10, 3)
datetime.datetime(2022, 3, 9, 0, 0)

datetime.datetime.strptime() 将日期时间字符串根据格式解析为datetime.datetime对象，并返回

>>> datetime.datetime.strptime('2022-11-14 15:18:51', '%Y-%m-%d %H:%M:%S')
datetime.datetime(2022, 11, 14, 15, 18, 51)
>>> datetime.datetime.strptime('2022-11-14', '%Y-%m-%d')
datetime.datetime(2022, 11, 14, 0, 0)

datetime.datetime实例属性

datetime.datetime.year 返回datetime.datetime实例对象的年份
datetime.datetime.month 返回datetime.datetime实例对象的月份
datetime.datetime.day 返回datetime.datetime实例对象的日期
datetime.datetime.hour 返回datetime.datetime实例对象的小时
datetime.datetime.minute 返回datetime.datetime实例对象的分钟
datetime.datetime.second 返回datetime.datetime实例对象的秒
datetime.datetime.microsecond 返回datetime.datetime实例对象的年份
datetime.datetime.tzinfo
datetime.datetime.fold

n = datetime.datetime.now()
print(n.year)
print(n.month)
print(n.day)
print(n.hour)
print(n.minute)
print(n.second)
print(n.microsecond)
print(n.tzinfo)
print(n.fold)
----------
2022
11
14
15
38
35
123229
None
0

datetime.datetime实例方法

datetime.datetime.date() 返回datetime.datetime实例对象所对应的date对象（即日期相同的date对象）
datetime.datetime.time() 返回datetime.datetime实例对象所对应的time对象（即时间相同的time对象）

>>> n = datetime.datetime.now()
>>> n
datetime.datetime(2022, 11, 14, 15, 53, 9, 557603)
>>> n.date()
datetime.date(2022, 11, 14)
>>> n.time()
datetime.time(15, 53, 9, 557603)

datetime.datetime.replace() 通过关键字参数替换datetime.datetime中的值，若无参数则返回相同的日期时间

>>> n = datetime.datetime.now()
>>> n
datetime.datetime(2022, 11, 14, 15, 54, 31, 182105)
>>> n.replace(year=2019, month=1, day=1)
datetime.datetime(2019, 1, 1, 15, 54, 31, 182105)
>>> n.replace()
datetime.datetime(2022, 11, 14, 15, 54, 31, 182105)

datetime.datetime.timetuple() 返回datetime.datetime对象对应的time.struct_time时间元组对象

>>> n.timetuple()    # n = datetime.datetime(2022, 11, 14, 15, 54, 31, 182105)
time.struct_time(tm_year=2022, tm_mon=11, tm_mday=14, tm_hour=15, tm_min=54, tm_sec=31, tm_wday=0, tm_yday=318, tm_isdst=-1)

datetime.datetime.timestamp() 返回datetime.datetime实例对象对应的时间戳

>>> n.timestamp()    # n = datetime.datetime(2022, 11, 14, 15, 54, 31, 182105)
1668412471.182105

datetime.datetime.weekday() 返回datetime.datetime实例对象对应的星期数，0-6，0为星期一

>>> n.weekday()    # n = datetime.datetime(2022, 11, 14, 15, 54, 31, 182105)
0

datetime.datetime.isoweekday() 返回datetime.datetime实例对象对应的星期数，1-7，1为星期一

>>> n.isoweekday()    # n = datetime.datetime(2022, 11, 14, 15, 54, 31, 182105)
1

datetime.datetime.isocalendar() 返回一个元组 (year, week, weekday)，分别为年份、当年的第几周，这一周的第几天

>>> n.isocalendar()    # n = datetime.datetime(2022, 11, 14, 15, 54, 31, 182105)
(2022, 46, 1)

datetime.datetime.isoformat() 返回datetime.datetime对象的时间字符串
语法：datetime.datetime.isoformat(sep='T', timespec='auto')
- sep为可选参数，默认为'T'，指定了日期与时间的分隔符，只能为一个unicode character
- timespec为可选参数，指定了时间字符串以哪个时间单位来输出，默认为'auto'——若有微秒则是微秒，若无则是秒，可选参数有——'hours'、'minutes'、'seconds'、'microseconds'

>>> n = datetime.datetime.now()
>>> n
datetime.datetime(2022, 11, 14, 16, 10, 32, 28031)
>>> n.isoformat()
'2022-11-14T16:10:32.028031'
>>> n.isoformat(sep=' ', timespec='seconds')
'2022-11-14 16:10:32'

datetime.datetime.strftime(format) 根据给定的格式字符串返回日期时间对象对应的日期时间字符串

>>> n.strftime('%Y年%m月%d日 %H:%M:%S')
'2022年11月14日 16:10:32'

datetime.timedelta类

作用：表示两个日期/日期时间之间的时间间隔
语法：datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)

只有days、seconds、microseconds会存储在内部，其余参数指定之后，也会转换为这三个参数的值进行存储
两个datetime.date 或两个datetime.datetime 对象相减，得到的结果就是datetime.timedelta类（datetime.time类型不支持相减）

# weeks会转换为days并存储
# hours和minutes会转换为seconds并存储
# milliseconds毫秒会转换为microseconds微秒（1毫秒=1000微秒）
>>> datetime.timedelta(days=20, seconds=180, microseconds=10, milliseconds=20, minutes=10, hours=2, weeks=2)
datetime.timedelta(days=34, seconds=7980, microseconds=20010)

>>> d1 = datetime.date(2022, 12, 1)
>>> d2 = datetime.date(2021, 12, 31)
>>> d1 - d2
datetime.timedelta(days=335)
>>> dt1 = datetime.datetime(2022, 1, 1, 12, 30, 0)
>>> dt2 = datetime.datetime(2021, 12, 1, 12, 0, 0)
>>> dt1 - dt2
datetime.timedelta(days=31, seconds=1800)

返回值：返回datetime.timedelta实例对象

datetime.timedelta实例属性

datetime.timedelta.days 返回datetime.timedelta实例对象的days
datetime.timedelta.seconds 返回datetime.timedelta实例对象的seconds
datetime.timedelta.microseconds 回datetime.timedelta实例对象的microseconds

>>> dt = datetime.timedelta(days=34, seconds=7980, microseconds=20010)
>>> dt.days
34
>>> dt.seconds
7980
>>> dt.microseconds
20010

datetime.timedelta实例方法

datetime.timedelta.total_seconds() 返回datetime.timedelta对象（时间间隔）包含了多少秒（注意时间间隔较大时，此方法结果中的微秒会失真）

>>> dt
datetime.timedelta(days=34, seconds=7980, microseconds=20010)
>>> dt.total_seconds()
2945580.02001

datetime.timedelta支持的运算

datetime.timedelta对象之间可进行运算

初始化t1和t2如下

>>> t1 = datetime.timedelta(days=10, seconds=180, microseconds=5000)
>>> t2 = datetime.timedelta(days=2, seconds=30, microseconds=1000)

t1 + t2 两个时间间隔相加

>>> t1 + t2
datetime.timedelta(days=12, seconds=210, microseconds=6000)

t1 - t2 两个时间间隔相减

>>> t1 - t2
datetime.timedelta(days=8, seconds=150, microseconds=4000)
>>> t2 - t1
datetime.timedelta(days=-9, seconds=86249, microseconds=996000)
>>> t2 - t1 + t1
datetime.timedelta(days=2, seconds=30, microseconds=1000)

t * i 时间间隔乘整数或浮点数

>>> t1 * 5
datetime.timedelta(days=50, seconds=900, microseconds=25000)
>>> t1 * 3.123
datetime.timedelta(days=31, seconds=20434, microseconds=155615)
>>> t1 * -2
datetime.timedelta(days=-21, seconds=86039, microseconds=990000)
>>> t1 * -5
datetime.timedelta(days=-51, seconds=85499, microseconds=975000)
>>> t1 * 0
datetime.timedelta(0)

t1 / t2 或者 t1 / i
两个timedelta对象相除 t1 / t2，返回的是float，而timedelta对象和数字之间的除法运算返回的是timedelta对象（i可以为int或float）

>>> t1
datetime.timedelta(days=10, seconds=180, microseconds=5000)
>>> t2
datetime.timedelta(days=2, seconds=30, microseconds=1000)
>>> t1 / t2
5.000173580974521
>>> t3 = datetime.timedelta(days=2, seconds=36, microseconds=1000)
>>> t1 / t3
5.0
>>> t1 / 3
datetime.timedelta(days=3, seconds=28860, microseconds=1667)
>>> t1 / 2.5
datetime.timedelta(days=4, seconds=72, microseconds=2000)

t1 // t2 或者 t1 // i

>>> t1 // t2
5
>>> t1 // 3
datetime.timedelta(days=3, seconds=28860, microseconds=1666)

t1 == t2 或者 t1 != t2

>>> t1 == t2
False
>>> t1 == datetime.timedelta(days=10, seconds=180, microseconds=5000)
True
>>> t1 != t2
True

t1 < t2 或者 t1 > t2

>>> t1 < t2
False
>>> t1 > t2
True

布尔运算（当且仅当timedelta对象不等于timedelta(0)时，则视为True，timedelta(0)则为False）

>>> if t1:
...     print('it is True')
... 
it is True
>>> if datetime.timedelta(0):
...     print('it is True')
... else:
...     print('it is False')
... 
it is False

datetime.timedelta对象可与datetime.date、datetime.datetime对象进行运算，不可与datetime.time对象进行运算

>>> ti = datetime.time(12, 20, 10)
>>> ti + datetime.timedelta(hours=1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'datetime.time' and 'datetime.timedelta'

>>> d = datetime.date(2021, 10, 3)
>>> d - datetime.timedelta(weeks=1)
datetime.date(2021, 9, 26)
>>> dt = datetime.datetime(2021, 10, 3, 10, 30, 15)
>>> dt + datetime.timedelta(days=3, minutes=50)
datetime.datetime(2021, 10, 6, 11, 20, 15)

datetime.tzinfo

datetime.timezone

datetime.MINYEAR 返回date 或者 datetime 对象允许的最小年份

>>> datetime.MINYEAR
1

datetime.MAXYEAR 返回date 或者 datetime 对象允许的最大年份

>>> datetime.MAXYEAR
9999

random模块实现了各种分布的伪随机数生成器

random模块生成的是伪随机数，并不是真正意义上的随机，是依赖于特殊算法和指定不确定因素（种子seed）来实现，即每次通过一个种子seed去进行一系列复杂的随机数产生算法，最终得到一个随机数，因此如果种子一致，生成的随机数也就一致；举个例子，当前种子是2，通过2去进行运算得到随机数1、随机数2...下次再使用种子2去生成随机数，得到的随机数1、随机数2...和之前的是一样的。

导入random模块 import random

以下是random模块常用方法

random.seed() 改变随机数生成器的种子

语法：random.seed([x])，x为设置的种子，非必填，若不填写参数，默认生成的种子为当前系统时间
返回值：无返回值

>>> random.seed(2)
>>> random.random()
0.9560342718892494
>>> random.random()
0.9478274870593494
>>> random.random()
0.05655136772680869
>>> random.random()
0.08487199515892163

>>> random.seed(3)    # 指定种子为3，生成的随机数与之前不同
>>> random.random()
0.23796462709189137
>>> random.random()
0.5442292252959519

>>> random.seed(2)    # 又将种子设置为2，和之前种子为2的时候生成的随机数相同
>>> random.random()
0.9560342718892494
>>> random.random()
0.9478274870593494
>>> random.random()
0.05655136772680869

random.random() 返回一个在区间[0, 1)之间的随机数

语法：random.random()
返回值：在区间[0, 1)之间的随机数

>>> random.random()
0.08487199515892163
>>> random.random()
0.8354988781294496

random.randint() 返回指定范围内的随机整数

语法：random.randint(start, end)，start和end都必填，为整数
返回值：返回区间[start, end]范围内的整数

>>> random.randint(5, 8)
7
>>> random.randint(5, 8)
7
>>> random.randint(5, 8)
6

random.randrange() 返回指定range()生成的整数列表内的随机整数

语法：random.randrange(start, end, step)

start：非必填，range()函数中的起始值，若不填则默认为0
end：必填，range()函数中的结束值
step：非必填，步长，默认为1

返回值：返回range(start=0, end, step=1)生成的整数列表 [start, end) 中的随机整数

>>> random.randrange(6)    # 只指定end，随机生成[0, 6)之间的整数
2
>>> random.randrange(3, 5)    # 指定start和end，随机生成[3, 5)之间的整数
4
>>> random.randrange(3, 5)
3
>>> random.randrange(1, 9, 3)    # 指定start、end、step，随机生成list(range(1, 9, 3)) 即 [1, 4, 7]之间的整数
7
>>> random.randrange(1, 9, 3)
1

random.choice() 返回指定序列中的随机项

语法：random.choice(seq)，seq为必填项，需要为非空系列，可以为列表、元组、字符串，不能为集合、字典（当seq为字典时，多生成几个则会报错，还没搞懂为啥，正确的做法是将字典的key或者value转换为列表来进行随机）
返回值：返回seq序列中的随机项

>>> random.choice([3, 9, 'e', 'n'])
'e'
>>> random.choice('helloworld')
'd'
>>> random.choice((2, 1, 9, 0, 8))
1

random.uniform() 返回指定范围内的随机浮点数

语法：random.uniform(a, b)，a和b都为必填项，可以为整数也可以为浮点数
返回值：随机返回[a, b]区间内的浮点数

>>> random.uniform(-1.5, 4.2)
0.015294855799840468
>>> random.uniform(-1.5, -0.2)
-0.42782823463065456
>>> random.uniform(1, 3)
2.508739568626324

random.shuffle() 将指定序列的元素打乱

语法：random.shuffle(seq)，seq为列表，此操作是在原列表的基础上进行操作，即改变原列表的元素顺序
返回值：无

>>> t = [9, 8, 7, 6]
>>> random.shuffle(t)
>>> t
[6, 7, 9, 8]

random.sample(items, n) 从序列中随机取出n个元素

语法：random.sample(items, n)，items和n都为必填项，items可以为序列、集合（若想使用字典则需要先用list()进行转换）
返回值：返回取出的元素列表

>>> random.sample((8, 's', 3), 2)
[8, 3]
>>> random.sample(['a', 'k', 2, 4], 3)
['a', 2, 4]
>>> random.sample(set('hello'), 2)
['h', 'o']

math模块此模块提供了很多数学函数

math模块提供了很多数学函数用于计算，这些函数不适用于复数

导入math模块 import math

math.nan 常量，返回一个浮点值NaN（not a number）

>>> math.nan
nan

math.pi 常量，返回一个浮点数表示圆周率

>>> math.pi
3.141592653589793

math.radians(x) 将角度x从度数转换为弧度

语法：math.radians(x)，x为必填项，数字，若不为数字则返回TypeError异常
返回值：浮点数，角度对应的弧度值

>>> math.radians(90)
1.5707963267948966

math.sin(x) 返回x弧度的正弦值

语法：math.sin(x)，x为必填项，数字，若不为数字则返回TypeError异常
返回值：浮点数，弧度对应的正弦值，-1到1之间

>>> math.sin(10)
-0.5440211108893698
>>> math.sin(math.radians(90))
1.0

math.cos(x) 返回x弧度的余弦值

语法：math.cos(x)，x为必填项，数字，若不为数字则返回TypeError异常
返回值：浮点数，弧度对应的余弦值，-1到1之间

>>> math.cos(math.radians(30))
0.8660254037844387
>>> math.cos(23)
-0.5328330203333975

math.ceil(x) 返回x向上取整（大于或等于参数并与之最接近）的整数

语法：math.ceil(x)，x为必填项，数字，若不为数字则返回TypeError异常
返回值：整数

>>> math.ceil(3.0)
3
>>> math.ceil(3.141)
4
>>> math.ceil(-3.9)
-3

math.floor(x) 返回x向下取整（小于或等于参数并与之最接近）的整数

语法：math.floor(x)，x为必填项，数字，若不为数字则返回TypeError异常
返回值：整数

>>> math.floor(3.0)
3
>>> math.floor(3.14)
3
>>> math.floor(-3.9)
-4

math.comb(n, k) 返回不重复且无顺序的从n项中选择k项的方式总数（组合）

语法：math.comb(n, k)，n、k必填，为正整数
返回值：整数，代表组合的总数

# 1 2 3 4 5
# 123 / 124 / 125 / 134 / 135 / 145 / 234 / 235 / 245 / 345
>>> math.comb(5, 3)
10
>>> math.comb(10, 1)
10

math.degrees(x) 将x从弧度转换为角度，与math.radians()相对

语法：math.degrees(x)，x为必填项，数字，若不为数字则返回TypeError异常
返回值：浮点数，表示角度

>>> math.degrees(1.233)
70.64569613963052
>>> math.degrees(math.radians(90))
90.0

math.fabs(x) 返回x的绝对值

语法：math.fabs(x)，x为必填项，数字，若不为数字则返回TypeError异常
返回值：浮点数，表示 x 的绝对值

>>> math.fabs(3.1415)
3.1415
>>> math.fabs(0)
0.0
>>> math.fabs(-3.141)
3.141

math.factorial(x) 返回正整数x的阶乘

语法：x为必填项，正整数。如果数字为负数或不是整数，则返回 ValueError。如果值不是数字，则返回 TypeError
返回值：x的阶乘

>>> math.factorial(10)
3628800
>>> 1*2*3*4*5*6*7*8*9*10
3628800

math.isnan(x) 判断数字是否为 NaN（非数字）

语法：x为必填项，数字，若不为数字则返回TypeError异常
返回值：如果x是NaN则返回True ，否则返回False

>>> math.isnan(float('NaN'))
True
>>> math.isnan(0)
False
>>> math.isnan(math.nan)
True

math.sqrt(x) 返回x的平方根

语法：x为必填项，数字，若不为数字则返回TypeError异常，如果数字小于 0，则返回 ValueError
返回值：浮点数，x的平方根

>>> math.sqrt(4)
2.0
>>> math.sqrt(5)
2.23606797749979

math.isqrt() 返回x的平方根向下取整后的整数

语法：x为必填项，数字，若不为数字则返回TypeError异常，如果数字小于 0，则返回 ValueError
返回值：x的平方根向下取整后的整数

>>> math.isqrt(5)    # 等价于 math.floor(math.sqrt(5))
2

math.perm(n, k=None) 返回不重复且有顺序的从n项中选择k项的方式总数（排列）

math.perm() 与 math.comb() 的区别就是选择出的k项是否要有顺序，math.comb()是不重复且无顺序，即从5项中选择3项，123则为一项，后续无论是132、213等三项数字顺序不一样的，都算作一项，也就是选择出的k项内部不区分顺序；而math.perm()是不重复且有顺序，即 123、132、213这样内部顺序不同的，都独立算作一种方式，也就是选择出的k项内部区分顺序。

语法：math.perm(n, k=None)，n为必填项，正整数，若不为数字则返回TypeError异常，k为可选项，正整数，不指定k时其默认值为None，
返回值：指定k时，返回从n项中选择k项的方式总数；不指定k时，返回n的阶乘 n!

# 在5项中不重复且有顺序的选择3项
# 1 2 3 4 5
# 123 / 132 / 213 / 231 / 312 / 321 ....
>>> math.perm(5, 3)
60
>>> math.perm(5)
120

math.pow(x, y) 返回x的y次方

语法：math.pow(x, y)，x和y都为必选参数，都需要为实数
返回值：浮点数，x的y次方

>>> math.pow(2, 3)
8.0

math.prod(iterable, start) 返回可迭代对象中所有元素的积

语法：math.prod(iterable)，iterable为必选参数，可迭代对象，start为可选参数，是一个命名关键字参数，默认值为1，指最终结果的起始值
返回值：浮点数或整数，可迭代对象中所有元素与 start值的积（可迭代对象中都为整数则返回整数，可迭代对象中元素有浮点数则返回浮点数）

>>> math.prod([1, 2, 3])
6
>>> math.prod([1, 2, 3], start=2)    # 可迭代对象所有元素的积再 *2
12
>>> math.prod([1, 2, 3.5])
7.0

math.trunc(x) 返回x的整数部分

语法：math.trunc(x)，x为必选参数，正数，若x不为数字则返回TypeError异常
返回值：x的整数部分

>>> math.trunc(0)
0
>>> math.trunc(-3)
-3
>>> math.trunc(-9.12)
-9
>>> math.trunc(8.819)
8

json模块进行json格式数据和Python对象之间的处理

JSON是一种轻量级的数据交换格式，是一种在各个编程语言中流通的数据格式，负责不同编程语言中的数据传递与交互；

json数据以键值对形式存在，但json中，字符串必须以双引号包裹"，不能使用单引号；
json数据中，值不允许出现函数function、undefined、NaN、None，但是可以出现null；
json数据中，最后一个键值对之后不能再有逗号；

Python中有json模块可以让我们进行json格式数据和Python对象之间的处理，将Python对象转换为json数据格式——为序列化，将json数据格式转换为Python对象——为反序列化

导入json模块import json

json.dump() 将Python对象转换（序列化）为json格式数据并存储到文件中

语法：json.dump(obj, fp, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)

obj，必选参数，为Python对象
fp，必选参数，文件对象
ensure_ascii，关键字参数、非必选，默认值为True，指非ASCII字符是否转义，为True时，非ASCII字符会转义为ASCII字符，反之则原样输出
allow_nan，关键字参数、非必选，默认值为True，指严格JSON规格范围外的float类型值（nan、inf 和 -inf）是否转换为JavaScript等价形式（NaN、Infinity 和 -Infinity），为True时会转换为等价形式，反之则会报错ValueError异常
indent，关键字参数、非必选，默认值为None，用于指定json数据键值对的缩进来进行美化
separators，关键字参数、非必选，默认值为None，指分隔符，用于指定键、值和键值对之间的分隔符，格式为元组；当indent为None时，默认为(', ', ': ')，不为None时，为(',', ': ')
sort_keys，关键字参数，非必选，默认值为False，不按照键的顺序进行排序，若指定为True，则会按照键的顺序进行排序

返回值：无

import json
import math

x = {
    'name': 'admin',
    'age': 18,
    'hobby': {
        'rowing': '擅长',
        'swimming': '优秀',
        'basketball': '一般'
    },
    'test': math.nan
}
# 将x编码为json格式数据并写入到文件对象f中（存储到test_json.txt文件中）
with open('test_json.txt', 'w') as f:
    json.dump(x, f)

----------test_json.txt文件内容如下----------
{"name": "admin", "age": 18, "hobby": {"rowing": "\u64c5\u957f", "swimming": "\u4f18\u79c0", "basketball": "\u4e00\u822c"}, "test": NaN}

将ensure_ascii参数指定为False，原样输出不进行转义

with open('test_json.txt', 'w') as f:
    json.dump(x, f, ensure_ascii=False)

----------
{"name": "admin", "age": 18, "hobby": {"rowing": "擅长", "swimming": "优秀", "basketball": "一般"}, "test": NaN}

将allow_nan参数指定为False，那么x['test']的值则不会转换为等价形式

with open('test_json.txt', 'w') as f:
    json.dump(x, f, ensure_ascii=False, allow_nan=False)

----------
........
raise ValueError(
ValueError: Out of range float values are not JSON compliant: nan

指定indent缩进为4，分隔符则为(',', ': ')

with open('test_json.txt', 'w') as f:
    json.dump(x, f, ensure_ascii=False, indent=4)

----------
{
    "name": "admin",
    "age": 18,
    "hobby": {
        "rowing": "擅长",
        "swimming": "优秀",
        "basketball": "一般"
    },
    "test": NaN
}

指定separators分隔符为(',', ':')，且与indent搭配

with open('test_json.txt', 'w') as f:
    json.dump(x, f, ensure_ascii=False, indent=4, separators=(',', ':'))

----------
{
    "name":"admin",
    "age":18,
    "hobby":{
        "rowing":"擅长",
        "swimming":"优秀",
        "basketball":"一般"
    },
    "test":NaN
}

指定sort_keys为True，按照键的顺序排序

with open('test_json.txt', 'w') as f:
    json.dump(x, f, ensure_ascii=False, indent=4, separators=(',', ':'), sort_keys=True)

----------
{
    "age":18,
    "hobby":{
        "basketball":"一般",
        "rowing":"擅长",
        "swimming":"优秀"
    },
    "name":"admin",
    "test":NaN
}

json.dumps() 将Python对象转换（序列化）为json格式数据

语法：json.dumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)，参数与json.dump()相同
返回值：返回编码后的json格式数据

x = {
    'name': 'admin',
    'age': 18,
    'hobby': {
        'rowing': '擅长',
        'swimming': '优秀',
        'basketball': '一般'
    },
    'test': math.nan
}

res = json.dumps(x, ensure_ascii=False, indent=4)
print(res)

----------
{
    "name": "admin",
    "age": 18,
    "hobby": {
        "rowing": "擅长",
        "swimming": "优秀",
        "basketball": "一般"
    },
    "test": NaN
}

json.load() 读取文件中的json数据并转换（反序列化）为Python对象

语法：json.load(fp, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)

fp，必选参数，文件对象
object_hook，关键字参数、非必选，默认为None，可指定值为函数，作用为：若指定了object_hook的值，则将json数据转换后的Python对象（dict）传递给object_hook指定的函数，并将经过此函数处理的值进行返回
parse_float，关键字参数、非必选，默认为None——相当于float(str_num)，作用为：针对json格式数据中需要转换为浮点数的str_float按照此参数值进行转换
parse_int，关键字参数、非必选，默认为None———相当于int(str_num)，作用为：针对json格式数据中需要转换为浮点数的str_int按照此参数值进行转换
parse_constant，关键字参数、非必选，默认为None，可指定值为函数，作用为：将json数据中的'-Infinity' ， 'Infinity' ， 'NaN'传递给此参数指定的函数进行处理，并将处理后的结果返回
object_pairs_hook，关键字参数、非必选，默认为None，若指定了此参数，则将json数据转换后的Python对象转换为 list(tuple) 格式传递给此参数对应的函数进行处理，并将经过此函数处理的值进行返回，如果同时指定了object_pairs_hook和object_hook，object_pairs_hook优先

返回值：返回转换后的Python对象

# test_json.txt文件中的内容如下
"""
{
    "name": "admin",
    "age": 18,
    "hobby": {
        "rowing": 4.3,
        "swimming": 5,
        "basketball": 2.8
    },
    "test": NaN
}
"""

with open('test_json.txt', 'r') as f:
    s = json.load(f)
print(s)

----------
{'name': 'admin', 'age': 18, 'hobby': {'rowing': 4.3, 'swimming': 5, 'basketball': 2.8}, 'test': nan}

指定parse_int参数

def int_test(i):
    return int(i)*2


# parse_int不指定时，则会对要转换成int的值进行int()，即最终转换出的int数字例如18（age的值）是 int('18')转换而来
# 指定了parse_int为int_test后，分别将 '18'、'5'传递给int_test，并将最终得到的结果进行返回
with open('test_json.txt', 'r') as f:
    s = json.load(f, parse_int=int_test)
print(s)

----------
{'name': 'admin', 'age': 36, 'hobby': {'rowing': 4.3, 'swimming': 10, 'basketball': 2.8}, 'test': nan}

指定parse_float参数

def float_test(str_f):
    str_f = float(str_f)*2
    return str_f


# 原理同parse_int，只不过是将要转换为浮点数的值传递给函数，例如 float_test('4.3') 
with open('test_json.txt', 'r') as f:
    s = json.load(f, parse_float=float_test)
print(s)

----------
{'name': 'admin', 'age': 18, 'hobby': {'rowing': 8.6, 'swimming': 5, 'basketball': 5.6}, 'test': nan}

指定parse_constant参数

def test_constant(c):
    if c == 'NaN':
        return None


# 原理同上，只不过是将要转换的 '-Infinity' ， 'Infinity' ， 'NaN' 传递给指定的函数，如 test_constant('NaN')
with open('test_json.txt', 'r') as f:
    s = json.load(f, parse_constant=test_constant)
print(s)

----------
{'name': 'admin', 'age': 18, 'hobby': {'rowing': 4.3, 'swimming': 5, 'basketball': 2.8}, 'test': None}

指定object_hook参数

def test_hook(d):
    res = []
    for i in d:
        res.append(i)
    return res


# 将json数据转换后的python对象以dict格式传递给指定的参数，需要注意是将转换后的python对象中的每个dict传递给函数进行处理
# 先传递 {'rowing': 4.3, 'swimming': 5, 'basketball': 2.8} 给test_hook，使用返回的结果替换原来的值
# 再传递 {'name': 'admin', 'age': 18, 'hobby': ['rowing', 'swimming', 'basketball'], 'test': nan} 给test_hook
with open('test_json.txt', 'r') as f:
    s = json.load(f, object_hook=test_hook)
print(s)

----------
['name', 'age', 'hobby', 'test']

指定object_pairs_hook参数

def test_hook(d):
    res = []
    for i in d:
        res.append(i)
    return res


# 将json数据转换后的python对象以 list(tuple) 格式（tuple即将键值对转为tuple）传递给指定的参数，同时也需要注意是将转换后的python对象中的每个dict 转换为 list(tuple) 后传递给函数进行处理
# 先传递 [('rowing', 4.3), ('swimming', 5), ('basketball', 2.8)] 给函数，使用返回的结果替换原来的值
# 再传递 [('name', 'admin'), ('age', 18), ('hobby', [('rowing', 4.3), ('swimming', 5), ('basketball', 2.8)]), ('test', nan)]（因为此处的test_hook函数就是将数据循环放入list中，所以看不太出来区别）
with open('test_json.txt', 'r') as f:
    s = json.load(f, object_pairs_hook=test_hook)
print(s)

----------
[('name', 'admin'), ('age', 18), ('hobby', [('rowing', 4.3), ('swimming', 5), ('basketball', 2.8)]), ('test', nan)]

json.loads() 将json格式数据转换（反序列化）为Python对象

语法：json.loads(s, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)，参数与json.load()相同
返回值：返回转换后的Python对象

y = '''{
    "name": "admin",
    "age": 18,
    "hobby": {
        "rowing": 4.3,
        "swimming": 5,
        "basketball": 2.8
    },
    "test": NaN
}'''

res = json.loads(y)
print(res)

----------
{'name': 'admin', 'age': 18, 'hobby': {'rowing': 4.3, 'swimming': 5, 'basketball': 2.8}, 'test': nan}

posted @ 2022-11-22 15:04 hook_what 阅读(56) 评论(0) 编辑收藏举报

刷新页面返回顶部

hook_what

Python进阶篇05-常用内置模块及常用方法

os模块 提供了许多能够直接操纵不同的操作系统的Python接口

os.name 返回当前操作系统的类型

os.sep 获取当前操作系统的路径分隔符

os.getcwd() 获取当前的工作路径

os.listdir() 返回指定文件夹下的文件与文件夹的名字的列表

os.walk()逐层遍历指定路径下所有的子文件夹、文件

os.mkdir()创建单级文件夹

os.makedirs()创建单级/多级文件夹

os.remove()删除文件

os.rmdir()删除空文件夹

os.system()运行shell命令

os.path.split()将文件名和路径分割开

os.path.exists()判断指定给出的路径是否已存在

os.path.isfile()判断指定路径是否为文件

os.path.isdir()判断指定路径是否为文件夹

os.path.abspath()获取绝对路径

os.path.splitext()分离文件路径/文件名 与 扩展名

os.path.join()拼接路径

os.path.dirname()获取指定路径的目录

os.path.basename()获取指定路径的文件名/文件夹名

os.path.getsize()返回指定路径的文件/文件夹大小

sys模块 主要是提供了针对与Python解释器相关的变量和方法

sys.argv获取脚本路径及命令行参数

sys.version获取Python解释程序的版本信息

sys.getdefaultencoding()获取解释器默认编码

sys.path获取Python导入模块及包的查找路径集

sys.platform返回操作系统平台名称

sys.exit()退出程序

sys.stdin.read()、sys.stdin.readline()、sys.stdin.readlines()

sys.stdout.write('xxx')标准输出

time模块

time.time()获取当前时间的时间戳

time.localtime()格式化时间戳为结构化时间类型

time.gmtime()格式化时间戳为UTC时区即0时区（与北京时间相差8小时）time.struct_time类型的对象

time.asctime()接受时间元组并返回一个可读形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二18时07分14秒）的24个字符的字符串

time.mktime()将struct_time对象转换为时间戳

time.strftime()格式化时间元组为时间字符串

time.strptime()将时间字符串按照格式字符串解析为时间元组

time.sleep()推迟调用线程的运行

time.perf_counter()精确计时，返回CPU级别的以秒为单位的时间浮点值

datetime模块

datetime.date类

datetime.date实例属性

datetime.date类方法

datetime.date类实例方法

支持的运算

datetime.time类

datetime.time类实例属性

datetime.time类实例方法

datetime.datetime类

datetime.datetime类属性

datetime.datetime类方法

datetime.datetime实例属性

datetime.datetime实例方法

datetime.timedelta类

datetime.timedelta实例属性

datetime.timedelta实例方法

datetime.timedelta支持的运算

datetime.timedelta对象之间可进行运算

datetime.timedelta对象可与datetime.date、datetime.datetime对象进行运算，不可与datetime.time对象进行运算

datetime.tzinfo

datetime.timezone

datetime.MINYEAR 返回date 或者 datetime 对象允许的最小年份

datetime.MAXYEAR 返回date 或者 datetime 对象允许的最大年份

random模块 实现了各种分布的伪随机数生成器

random.seed() 改变随机数生成器的种子

random.random() 返回一个在区间[0, 1)之间的随机数

random.randint() 返回指定范围内的随机整数

random.randrange() 返回指定range()生成的整数列表内的随机整数

random.choice() 返回指定序列中的随机项

random.uniform() 返回指定范围内的随机浮点数

random.shuffle() 将指定序列的元素打乱

random.sample(items, n) 从序列中随机取出n个元素

math模块 此模块提供了很多数学函数

math.nan 常量，返回一个浮点值NaN（not a number）

math.pi 常量，返回一个浮点数表示圆周率

math.radians(x) 将角度x从度数转换为弧度

math.sin(x) 返回x弧度的正弦值

os模块提供了许多能够直接操纵不同的操作系统的Python接口

os.path.splitext()分离文件路径/文件名与扩展名

sys模块主要是提供了针对与Python解释器相关的变量和方法

time.asctime()接受时间元组并返回一个可读形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日周二18时07分14秒）的24个字符的字符串

random模块实现了各种分布的伪随机数生成器

math模块此模块提供了很多数学函数

json模块进行json格式数据和Python对象之间的处理