Python进阶-常用内置模块

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中几种表示时间的方式：

1. 时间戳：1970 年 1 月 1 日之后经过的秒数，为浮点数，可以通过time.time()获得当前时间的时间戳
2. 结构化时间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为负
3. 格式化的时间字符串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实例属性

1. datetime.date.year：返回datetime.date对象的年份
2. datetime.date.month：返回datetime.date对象的月份
3. 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类方法

1. 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对象的此方法就是返回日期对象对应的日期字符串

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

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

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

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

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

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

datetime.date类实例方法

1. 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)

2. 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)

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

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

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

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

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

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

6. 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类实例属性

1. datetime.time.hour：返回datetime.time对象的小时
2. datetime.time.minute：返回datetime.time对象的分钟
3. datetime.time.second：返回datetime.time对象的秒
4. 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类实例方法

1. 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)

2. 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'

3. 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)

4. 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类属性

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

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

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

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

datetime.datetime类方法

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

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

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

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

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

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

4. 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)

5. 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)

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

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

7. 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实例属性

1. datetime.datetime.year 返回datetime.datetime实例对象的年份
2. datetime.datetime.month 返回datetime.datetime实例对象的月份
3. datetime.datetime.day 返回datetime.datetime实例对象的日期
4. datetime.datetime.hour 返回datetime.datetime实例对象的小时
5. datetime.datetime.minute 返回datetime.datetime实例对象的分钟
6. datetime.datetime.second 返回datetime.datetime实例对象的秒
7. datetime.datetime.microsecond 返回datetime.datetime实例对象的年份
8. datetime.datetime.tzinfo
9. 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实例方法

1. datetime.datetime.date() 返回datetime.datetime实例对象所对应的date对象（即日期相同的date对象）
2. 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)

3. 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)

4. 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)

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

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

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

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

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

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

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

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

9. 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'

10. 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实例属性

1. datetime.timedelta.days 返回datetime.timedelta实例对象的days
2. datetime.timedelta.seconds 返回datetime.timedelta实例对象的seconds
3. 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实例方法

1. 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)

1. t1 + t2 两个时间间隔相加

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

2. 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)

3. 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)

4. 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)

5. t1 // t2 或者 t1 // i

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

6. t1 == t2 或者 t1 != t2

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

7. t1 < t2 或者 t1 > t2

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

8. 布尔运算（当且仅当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模块

json模块

原文地址：http://www.cnblogs.com/themoony/p/16852501.html