1.sys模块(内置模块)
在sys模块中定义了一些函数和变量，用来设置和获取系统的信息。
# Python中的常用模块：sys模块
import sys
sys.path.append('./test') # 向sys.path列表添加my模块所在的路径，my.py的代码在后面
import my # 导入my模块
my.greet('李宁') # 调用my模块中定义的greet函数
print(sys.modules['my']) #输出已经装载的my模块的信息（使用modules字典）
print(type(sys.modules['my'])) # 输出modules字典中存储my模块value的数据类型
print(sys.platform) # 输出当前的操作系统平台标识符
# 命令行参数
print(sys.argv[0]) # 输出当前脚本文件的文件名（包括完整路径）
# 如果有命令行参数，则输出第1个命令行参数的值，sys.argv列表的长度至少为1，因为第1个列表元素永远是当前脚本文件的路径
if len(sys.argv) == 2:
print(sys.argv[1]) # 输出第1个命令行参数的值
my.greet(sys.argv[1]) # 再次强调my模块中的greet函数，并传入该命令行参数的值
# 从标准输入流中采集长度为6的字符串
# 从终端中输入6个字符
s = sys.stdin.read(6)
print(s)
# 向标准输出流中写入一个字符串
# 向终端 或者 控制台 输出
sys.stdout.writelines("hello world")
print()
# 向标准错误流中写入一个字符串
sys.stderr.writelines("error")
# 设置执行当前脚本文件的返回值，后面会使用invoke.py调用当前脚本，以便获取这个返回值
sys.exit(123)
需要在test文件的路径下建立一个invoke.py文件
import subprocess
# 执行demo01.py脚本文件，并得到该脚本的返回的结果
output = subprocess.getstatusoutput("python demo01.py Mike")
print(output)
print(output[0])终端：
getstatusoutput函数返回了一个元组，第一个元素值就是被调用脚本文件的返回值（本例是123），第二个元素值是被调用脚本的输出结果。由于demo01.py中需要从标准输入流采集字符串，所以该脚本文件被调用时也需要输入一个长度为6的字符串（本例是“ABCDEFG”），代码才会往下执行。
2.OS模块
2.1获取与改变工作目录
工作目录：当前的操作目录
如果操作一个文件或者子目录，不指定路径，默认操作工作目录里的子目录和文件。
getcwd函数用于获取当前的工作目录
chdir函数可以改变当前的工作目录
import os
print('当前工作目录：',os.getcwd()) # 获取当前的工作目录，并输出该目录
print(os.listdir(os.getcwd())) # 输出path指定的文件夹包含的文件或文件夹名字的列表
os.chdir('../') # 改变当前工作目录
print('改变后的工作目录：',os.getcwd())结果：略
2.2 文件与目录操作
在os模块中提供了一些操作目录和文件的函数。
'''
1. mkdir(dirname, permissions) ：创建目录，diename表示目录名
在linux和Mac OS X 上可以设置目录：读 r 写 w 执行x
如果dirname存在，会抛出OSError
2. makedirs(dirname, permissions,exist_ok) 用于建立目录
(1) mkdir('a') mkdir('a/b') makedirs('a/b/c') 在a里面创建一个b，在b里面创建一个c
(2) exist_ok == False,如果目录存在，抛出OS Error
exist_ok == True，如果目录存在，什么都不做，不会抛出异常
3. rmdir(dirname):删除目录
rmdir('a')，如果a目录不为空，会抛出OSError异常
4. removedirs(dirname):删除目录
可以指定多级目录
removedirs('a/b/c')
b(c,test.txt) 只删除c，b和a目录保留
5 remove(filename):删除filename指定的文件
6. rename(src,dst)：将src参数指定的文件（目录）改名为dst参数指定的文件名（目录名）
7 renames(src,dst） 与rename函数的功能类似，只是src和dst可以使多级目录（最后一级可以是文件名）。
函数会将每一级的目录都改成对应的目录名。
a/b/c x/y/z
'''
import os
if not os.path.exists('newdir1'): # 判断当前目录下是否存在newdir1目录
os.mkdir('newdir1') # 如果不存在该目录，则创建一个newdir1目录
# 创建多级目录，并将目录的权限设为0o733（八进制），True表示即使目录存在，也不会抛出异常。
os.makedirs('x/y/z',0o733,True)
try:
# 删除单个目录，如果目录非空，则抛出一个OSError异常
os.rmdir('newdir1')
except OSError as e:
print(e)
# 删除多级目录
os.removedirs('x/y/z')
if not os.path.exists('mydir'):
os.mkdir('mydir')
os.rename('mydir','yourdir') # 将mydir目录重命名为yourdir
if os.path.exists('w/y/z'): # 如果存在w/y/z
os.renames('w/y/z','a/b/c') # 重命名多级目录w/y/z 为 a/b/c
if os.path.exists('newdir1/test.txt'):
os.remove('newdir1/test.txt') # 删除文件newdir1目录下test.txt文件2.3 软链接与硬链接
软链接与硬链接是linux和Mac OS X的概念。软链接就像Windows中的快捷方式，只是保存了源文件或目录的引用，而且只有固定尺寸。硬链接只能针对文件建立，这是因为硬链接是将整个文件复制一份，相当于一个副本，所以在建立硬链接时会进行限制。软链接和硬链接都是同步的。也就是说，只要修改软链接文件或硬链接文件，源文件的内容就会变，反之亦然。
不管是linux和Mac OS X，建立软链接和硬链接的命令都是ln，在建立软链接时，需要加“-s”命令行参数。
例：假设有一个test.txt文件，现在要对该文件建立一个软链接文件slink.txt和一个硬链接文件link.txt，则test.txt文件的内容如下：
hello world # 源文件test.txt占用的字节数是25
世界你好建立软链接和硬链接的命令如下：
ln -s test.txt slink.txt # 软链接文件slink.txt占用的字节数为8，而且即使test.txt文件的尺寸变大，slink.txt文件的尺寸仍然是8字节，说明了slink.txt文件仅仅保存了源文件test.txt的引用。
ln test.txt link.txt # 硬链接文件link.txt同样占用了25个字节，说明link.txt是test.txt文件的副本。终端命令中：
输入：“ls -al”命令查看文件详细信息。
# 软链接与硬链接
# 软链接（符号链接），相当于Windows的快捷方式
# 硬链接，是文件的副本
import os
if os.path.exists('data.txt') and not os.path.exists('slink_data.txt'):
# 建立软链接文件
os.symlink('data.txt','slink_data.txt')
if os.path.exists('data.txt') and not os.path.exists('link_data.txt'):
# 建立硬链接文件
os.link('data.txt','link_data.txt')注意：symlink函数在windows中使用时要拥有管理员权限，或用管理员权限打开命令行工具，然后才可以在命令行工具中执行symlink函数，否则会抛出“OSError:symbolic link privilege not held”异常。
2.4 OS模块中的常用函数
在OS模块中还提供了很多用于获取和设置系统信息的函数和变量。
# 在os模块
'''
1.sep变量：用于返回当前OS的路径分隔符，Windows：反斜杠（\），
Linux、Unix、Mac OS X：斜杠（/）
2. pathsep变量：返回环境变量中的路径之间的分隔符，Windows用分号（;）分隔多个路径。
Linux和Mac OS X是冒号（:）
3. name变量：返回当前OS的名称
4. environ变量：以字典的形式返回系统中所有环境变量的值
5. getenv函数：获取指定的环境变量的值，通过参数可以指定环境变量名。
6. putenv函数：设置指定环境变量的值，通过参数指定环境变量名和环境变量值。
7. system函数：执行命令，通过参数指定要执行的命令。
'''
import os
import subprocess
print('路径分隔符：',os.sep)
print('环境变量路径之间的分隔符：',os.pathsep)
print('操作系统名：',os.name)
print(os.environ) # 输出当前系统中所有环境变量的值
# 获取指定的环境变量值
print('PATH=',os.environ['PATH']) # 输出PATH环境变量的值
print('PATH=',os.getenv('PATH')) # 使用getenv函数获取了PATH环境变量的值
print("-------------------")
# 在Python脚本文件中执行另外一个程序。
output = subprocess.getstatusoutput('today') # 执行today文件
print(output) # 输出执行结果,返回一个元组。
os.putenv('PATH',os.getenv('PATH') + os.pathsep + '.') # 将today文件所在的目录(.)加到PATH环境变量中
output = subprocess.getstatusoutput('today') # 执行today文件
print(output) # 输出执行结果
os.system('today')
os.system('ls -al') # 执行"ls -al"命令，列出当前所有文件和目录的详细信息。尽管使用putenv函数可以修改环境变量，但这种修改只是临时的，并不会影响系统的环境变量，只是在当前Python进程中会使用这些修改后的环境变量。使用getenv函数或environ变量重新获取这些环境变量时获取的仍然是未修改之前的值。
3.集合、堆和双端队列（heap模块、deque类）
Python3的集合（set）、堆（heap）和双端队列（deque）的用法。
其中，集合不需要导入任何模块，set类型已经内建进Python语言；
堆和双端队列分别要导入heapq模块和collections模块。
3.1 集合
Python语言中的集合和数学中集合的概念非常相似。在数学中集合有如下三个特征。
- 无序性：集合中每个元素的值都是平等的，元素之间是无序的。
- 互异性：集合中任意两个元素都是不同的，即每个元素只能出现一次。
- 确定性：集合中每个元素都是确定的，对于一个值来说，要么属于该集合，要么不属于该集合。
所以，集合、列表和字典都不能作为集合的元素值，因为他们都是可变的。
在创建集合类set的实例时，需要为set类的构造方法提供一个列表或元组类型的值，用于建立集合的数据源。也就是说，set类可以将列表或元组转换为集合，在转换的过程中，会去除重复的值，并且列表和元组中元素的顺序可能被打乱，因为集合中的元素是无序的。
# 集合（Set）
'''
集合，必须满足下面的3个条件
1. 无序性：集合中每一个元素的值都是平等的，元素之间是无序的。
2. 互异性：集合中任意两个元素都是不同的，每个元素只能在集合中出现一次
3. 确定性：集合中每个元素都是确定的，对于一个值来说，要么属于该集合，要么
不属于该集合。所以集合、列表、字典都不能作为集合的元素值，因为他们都是可变的。
集合的操作
创建集合、合并集合、集合相交、集合的差等
'''
set1 = set(range(10)) # 创建有10个元素的集合
print(type(set1)) # 输出set1的类型，运行结果：<class 'set'>
# 将字符串中的每一个字符作为元素添加进集合，因为字符串可看作字符的列表
# 会去除重复的字符，而且顺序会打乱
set2 = set('helloabc')
print(set2) # 运行结果：{'a', 'b', 'h', 'c', 'o', 'l', 'e'}
print(set1) # 运行结果：{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
# 利用 字符串列表 建立集合，会去除重复的字符串，字符串的顺序会被打乱
set3 = set(['Pill','John','Mike','John'])
print(set3) # 运行结果：{'John', 'Mike', 'Pill'}
a = set((1,2,3)) # 利用元组创建一个集合
b = set([3,5,1,6]) # 利用列表创建一个集合
# 集合的合并
print(a.union(b)) # 运行结果：{1, 2, 3, 5, 6}
print(a | b) # 按位 或 的方式，运行结果：{1, 2, 3, 5, 6}
# 求a和b的交集，在两个集合中共同拥有的
print(a.intersection(b)) # 运行结果：{1, 3}
print(a & b) # 按位 与 运算符，运行结果：{1, 3}
c = set([2,3])
print(c.issubset(a)) # 判断c集合是否为a集合的子集，运行结果：True
print(a.issubset(c)) # 判断a集合是否为c集合的子集，运行结果：False
# 超集，c是a的子集，则a就是c的超集
print(c.issuperset(a)) # 判断c集合是否为a集合的超集，运行结果：False
print(a.issuperset(c)) # 判断a集合是否为c集合的超集，运行结果：True
# 判断集合是否相等
d = set([1,3,2])
print(a == d) # 运行结果：True
# 计算集合的差 a - c
print(a.difference(b)) # 运行结果：{2}
print(a - b) # 运行结果：{2}
# 计算集合之间的对称差
# 对称差：只在一个集合中出现的元素组成的新集合
print(a.symmetric_difference(b)) # 运行结果：{2, 5, 6}
print(a ^ b) # 运行结果：{2, 5, 6}
# 对称差相当于a-b 与 b-a 的并集
print((a - b) | (b - a)) # 运行结果：{2, 5, 6}
x = a.copy() # 使用copy方法将a复制一份，并将该副本赋给变量x，x和a是两个完全不同的集合，但是里面的元素相同
y = a # 引用，y和a都是指向了同一个集合
print(y is a) # 判断y与a 是否相同，运行结果：True
print(x is a) # 判断x与a 是否相同，运行结果：False
x.add(30) # 向集合a中添加一个新的元素
y.add(100)
print(x) # 运行结果：{1, 2, 3, 30}
print(y) # 运行结果：{1, 2, 3, 100}
print(a) # 运行结果：{1, 2, 3, 100}
print(1 in a) # 运行结果：True
print(10 in a) # 运行结果：False# 将集合作为集合的元素
#frozenset函数将集合变成只读的==不可变类型，这样就可以作为集合的元素和字典的key
# 集合的元素和字典中的key都不允许是可变的值，如集合、列表和字典，
# 元组既可以做集合的元素，也可以做字典的key
a = set([1,2])
b = set([10,20])
a.add(4)
print(a) # 运行结果：{1, 2, 4}
a.add(frozenset(b)) # 使用frozenset函数将b集合变成只读的集合，成功将其添加到集合a
print(a) # 运行结果：{1, 2, 4, frozenset({10, 20})}
# 字典的key不能是可变的，不能将字典的集合作为key来使用
d = {'Bill':30,'John':34}
#d[a] = 10 # a是可变的，会报错
d[frozenset(a)] = 10
print(d) # 运行结果 {'Bill': 30, 'John': 34, frozenset({1, 2, 4, frozenset({10, 20})}): 10}
t = (1,2,3,4)
b.add(t)
d[t] = 10
print(d) # 运行结果 {'Bill': 30, 'John': 34, frozenset({1, 2, 4, frozenset({10, 20})}): 10, (1, 2, 3, 4): 10}3.2 堆
堆也是一种数据结构，它是优先队列中的一种。使用优先队列能以任意顺序增加元素，并能快速找到最小（最大）的元素值，或前n个最小或最大的元素值，这要比用于列表的min函数和max函数高校的多。
与集合不同，在Python3中并没有独立的堆类型，只有一个包含一些堆操作函数的模块，该模块名为heapq（q是queue的缩写，即队列）。heapq模块中常用的函数如表：
# 堆（Heap）
# heapq
from heapq import *
from random import *
data = [1,2,3,4,5,6,7,8,9]
heap = [] # 定义一个堆，其实堆就是一个列表，只是通过heapq模块中的函数利用堆算法来改变列表中的元素而已。
for n in data:
value = choice(data) # 利用choice函数（随机random模块中的）从data列表中随机选择9个数（可能有重复的数）
heappush(heap,value) # 利用heappush函数将value添加进堆
print(heap) # 运行结果：[1, 1, 6, 1, 4, 9, 9, 8, 7]
heappush(heap,30)
heappush(heap,45)
print(heap) # 运行结果：[1, 1, 6, 1, 4, 9, 9, 8, 7, 30, 45]
print(heappop(heap)) # heappop()将堆中的最小值弹出，并返回最小值。运行结果：1
data1 = [6,3,1,12,9] # 定义一个列表
heapify(data1) # heapify() 将列表转换为堆，也就是重新安排列表中元素的顺序，直接修改了（data1）
print(data1) # 运行结果：[1, 3, 6, 12, 9]
print(heapreplace(data1, 123)) # 弹出data1的最小值，并将123添加进堆。 有返回值，运行结果：1
print(data1) # 运行结果：[3, 9, 6, 12, 123]
print(nlargest(1,data1)) # 得到data1中的最大值，以列表形式返回。运行结果：[123]
print(nlargest(2,data1)) # 得到data1中最大的前2个值，运行结果：[123, 12]
print(nsmallest(1,data1)) # 得到data1中的最小值，以列表形式返回。运行结果：[3]
print(nsmallest(2,data1)) # 得到data1中的最小值，以列表形式返回。运行结果：[3, 6]
print(list(merge([1,3,456,7],[0,1,-5,6],[1,7,4],[],[67]))) # 运行结果：[0, 1, 1, -5, 1, 3, 6, 7, 4, 67, 456, 7]
print(list(merge(['dog','horse'],['cat','fish','kangaroo'],key=len))) # 运行结果：['dog', 'cat', 'fish', 'horse', 'kangaroo']3.3 双端队列
双端队列不同于普通的队列。对于普通的队列来说，只能操作队列的头，而不能操作队列的尾，也就是先进先出。双端队列是普通队列的扩展，在队列的头和尾部都可以进行队列的操作，所以对一组值的两头进行操作，使用双端队列非常方便的。
使用双端队列需要导入collections模块中的deque类。该类中提供了若干个方法用于操作双端队列。
例如：append方法可以将值添加到队列的尾部，而appendleft方法可以将值添加到队列的头部；pop方法可以弹出队列尾部的最后一个值，并返回这个值；popleft方法可以弹出队列头部的第1个值，并返回这个值。
# 双端队列
from collections import deque
# 将列表转换为双端队列
q = deque(range(10))
print(q) # 运行结果： deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
# 将123追加到双端队列q的队尾
q.append(123)
q.append(-32)
print(q) # 运行结果：deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 123, -32])
# 将30添加到q的队首
q.appendleft(30)
print(q) # 运行结果：deque([30, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 123, -32])
# 弹出队尾的值
print(q.pop()) # 运行结果 -32
# 弹出队首的值
print(q.popleft()) # 运行结果： 30
print(q) # 运行结果 deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 123])
# 将q向左循环移动2个位置
q.rotate(-2)
print(q) # 运行结果 deque([2, 3, 4, 5, 6, 7, 8, 9, 123, 0, 1])
# 向右循环移动4个位置
q.rotate(4)
print(q) # 运行结果 deque([9, 123, 0, 1, 2, 3, 4, 5, 6, 7, 8])
# 创建一个双端队列q1
q1 = deque(['a','b'])
q.extend(q1) # 将q1添加到队列q的后面
print(q) # 运行结果 deque([9, 123, 0, 1, 2, 3, 4, 5, 6, 7, 8, 'a', 'b'])
q.extendleft(q1) # 将q1添加到队列q的前面
print(q) # 运行结果 deque(['b', 'a', 9, 123, 0, 1, 2, 3, 4, 5, 6, 7, 8, 'a', 'b'])时间、日期与日历（time模块）
Python提供的time、datetime和calendar模块可以用于格式化日期和时间。时间间隔是以秒为单位的浮点数。每个时间戳从1970年1月1日午夜（历元）到现在经过的时间来表示。
Python语言的time模块下有很多函数可以转换常见日期格式。例如：函数time用于获取当前时间戳，
import time
ticks=time.time()
print("当前的时间戳：", ticks)
# 运行结果 当前的时间戳： 1575013913.8061256ticks变量的值是一个浮点数，这个浮点数就是从运行程序那一刻的时间点到1970年1月1日午夜之间的秒数。
4.1 时间元组
在Python语言中，时间用一个元组来表示。表示时间的元组有9个元素，这9个元素都有其对应的属性，所以时间元组中的每一个元素值既可以通过属性获得，也可以通过索引获得。
# 时间元组（元组里面的值不可更改，元组没有属性）
import time
# 获取当前时间
localtime = time.localtime(time.time())
# 运行结果 time.struct_time(tm_year=2019, tm_mon=11, tm_mday=29, tm_hour=16, tm_min=17, tm_sec=12, tm_wday=4, tm_yday=333, tm_isdst=0)
print(localtime) # localtime是一个对象
print(type(localtime)) # 运行结果 <class 'time.struct_time'>
# 创建struct_time这个对象时，通过元组来指定每个时间，之后会把对应的值放在每个分量里面
st = time.struct_time((1,2,3,4,5,6,7,8,9))
# 运行结果 time.struct_time(tm_year=1, tm_mon=2, tm_mday=3, tm_hour=4, tm_min=5, tm_sec=6, tm_wday=7, tm_yday=8, tm_isdst=9)
print(st)
print('年','=',localtime.tm_year) # 运行结果 年 = 2019
print('月','=',localtime.tm_mon) # 运行结果 月 = 11
print('日','=',localtime.tm_mday) # 运行结果 日 = 29
print('一年的第%d天' % localtime[7]) # 运行结果 一年的第333天
# 获取一个可读的时间
localtime = time.asctime(localtime)
print(localtime) # Fri Nov 29 16:32:47 20194.2 格式化日期和时间
应用场景不同，这就要求在输出日期和时间之前要先进行格式化。
格式化日期和时间需要使用strftime函数；
strftime函数，参数1：格式化字符串 参数2：时间元组
Python语言中，所有用于格式化日期和时间的符号都以百分号（%）开头，如 %Y-%m-%d 会将日期格式化为如 “2019-11-26”。
%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00=59）
%S 秒（00-59）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身# 格式化日期和时间
# strftime函数，参数1：格式化字符串 参数2：时间元组
import time
import locale
# 2018-12-23 18:34:22
print(time.strftime('%Y-%m-%d %H:%M:%S',time.localtime())) # 运行结果 2019-11-29 17:23:00
# 设置日期和时间为中文UTF-8格式，格式化字符串中支持中文
locale.setlocale(locale.LC_ALL, 'zh_CN.UTF-8')
# 运行结果 2019年11月29日 17时23分0秒
print(time.strftime('%Y年%m月%d日 %H时%M分%S秒',time.localtime()))
# 输出星期的完整名称
# 今天是星期五
print(time.strftime('今天是%A',time.localtime()))如果格式化字符串中包含中文，必须使用locale模块中的setlocale函数将日期和时间的格式设置为中文的UTF-8格式，否则无法成功对日期和时间进行格式化。如果不清楚当前系统有哪些locale，则可以使用 locale -a命令查询，或使用locale -a|grep UTF-8 只显示UTF-8的locale。这些命令仅仅针对linux和Mac OS X。
4.3 时间戳的增量
通过time模块的time函数可以获取当前时间的时间戳（浮点数格式），时间戳可以加上或者减去一个整数（n），这就是时间戳的增量，单位是秒。也就是说，当前时间戳加10表示未来10s，将10表示过去10s。如果想得到未来1h的时间戳，需要将time函数的返回值加3600s。
import time
time1 = time.time() # 获取当前的时间戳
time2 = time1 + 60 # 当前时间戳 往后 移1分钟
print(time2) # 运行结果 1575093743.3013074
time3 = time1 - 60*60 # 当前时间戳 往前 移1个小时
time3= time.localtime(time3) # 将时间戳转化为时间元组
print(time3) # 运行结果 time.struct_time(tm_year=2019, tm_mon=11, tm_mday=30, tm_hour=13, tm_min=1, tm_sec=23, tm_wday=5, tm_yday=334, tm_isdst=0)
# 运行结果 2019-11-30 13:01:23
print(time.strftime('%Y-%m-%d %H:%M:%S', time3))4.4 计算日期和时间的差值
datetime模块中的datetime类允许计算两个日期的差值，可以得到任意两个日期之间的天数以及剩余的秒数。通过datetime模块的timedelta函数还可以得到一个时间增量，如 timedetla（hours=2）可得到往后延两个小时的时间增量。
# 计算日期和时间的差
# timedetla
import datetime
# 定义第一个日期
d1 = datetime.datetime(2017,4,12)
# 定义第二个日期
d2 = datetime.datetime(2018,12,25)
# 计算这两个日期之间的天数，运行结果 622
print((d2-d1).days)
# 定义第1个带时间的日期
d1 = datetime.datetime(2017,4,12,10,10,10)
# 定义第2个带时间的日期
d2 = datetime.datetime(2018,12,25,10,10,40)
# 输出两个日期的差，运行结果 622 days, 0:00:30
print(d2 - d1)
# 计算两个日期相差的秒数（刨除整数天），运行结果 30
print((d2 - d1).seconds)
# 获取当前的时间（datetime类型）
d1 = datetime.datetime.now()
# 将当前时间往后延 10 小时
d2 = d1 + datetime.timedelta(hours=10)
# 运行结果 2019-12-01 00:28:07.977654
print(d2)
d2 = d1 + datetime.timedelta(hours=-10)
# 运行结果 2019-11-30 04:28:07.977654
print(d2)要注意的是：在使用seconds属性获取两个日期相差的秒数时，需要刨除天数。例如，本例中 d2 和 d1实际上相差了622天30秒。刨除622天后，seconds属性的值是30s。
4.5 获取某月和某年的日历
使用calendar模块中的month函数，可以得到某月的日历，以字符串形式返回。如果使用calendar函数，可以获得某一年12个月的日历，也是以字符串形式体现。
# 获取某月和某年的日历
import calendar
import locale
# 返回2018年1月份日历（日历是英文的）
cal = calendar.month(2018,1)
print(cal)
# 恢复默认的日期格式(英文)，否则显示12个月的日历，位置会窜
# locale.setlocale(locale.LC_ALL, '')
# 输出2018年一整年的日历(共12个月)
print(calendar.calendar(2018))5.随机数（random模块）
在random模块中封装了多个函数用于产生各种类型的随机数，这些函数有的产生单值随机数，有的产生一组随机数，还有的可以打乱列表原来的顺序，类似于洗牌。
# 随机数
'''
randint(m,n):用于产生m到n之间的随机整数，包括m和n。
random()：用于产生0到1之间的随机浮点数，包括0，但不包括1。
uniform(m,n)：用于产生m到n之间的随机浮点数，m和n可以是浮点数，包括m和n。
randrange(m,n,step)：在一个递增的序列中随机选择一个整数。其中step是步长。
例如，randrange(1,6,2)，该函数就会在列表[1,3,5]中随机选择一个整数。
choice(seq)：从seq指定的序列中随机选择一个元素值。seq指定的列表元素可以是任意类型的值。
sample(seq,k)：从seq指定的序列中随机选取k个元素，然后生成一个新的序列。
shuffle(seq)：把seq指定的序列中元素的顺序打乱，该函数直接修改原有的序列。
'''
import random
# 产生1到100之间的随机整数
print(random.randint(1,100)) # 运行结果 19
# 产生0到1之间的随机数
print(random.random()) # 运行结果 0.12475554094811458
# 从[1,4,7,10,13,16,19]随机选一个数
print(random.randrange(1,20,3)) # 运行结果 19
# 产生一个从1到100.5的随机浮点数
print(random.uniform(1,100.5)) # 运行结果 46.42341579462214
# 从intList列表中随机选一个元素值
intList = [1,2,5,7,76,10,4,8]
print(random.choice(intList)) # 运行结果 1
# 从intList列表中随机选3个元素值，并生成一个新的序列
newList = random.sample(intList,3)
print(newList) # 运行结果 [2, 8, 7]
# 随机排列intList列表中的元素值，该函数直接改变了intList列表(洗牌)
random.shuffle(intList)
print(intList) # 运行结果 [1, 2, 5, 8, 10, 4, 76, 7]6.数学（math模块）
在math模块中封装了很多与数学有关的函数和变量，如取整、计算幂值、平方根、三角函数等。
# 数学函数
import math
print('圆周率','=',math.pi) # 运行结果 圆周率 = 3.141592653589793
print('自然常数','=',math.e) # 运行结果 自然常数 = 2.718281828459045
# 取绝对值
print(math.fabs(-1.2)) # 1.2
# 向上取整
print(math.ceil(1.3)) # 2
# 向下取整
print(math.floor(1.8)) # 1
# 计算2的10次方
print(math.pow(2,10)) # 1024.0
# 计算8的平方根
print(math.sqrt(8)) # 2.8284271247461903
# 计算 Π/2 的正弦
print(math.sin(math.pi/2)) # 1.0
# 计算 Π 的余弦
print(math.cos(math.pi)) # -1.0
# 计算 Π/4 的正切
print(math.tan(math.pi/4)) # 0.9999999999999999
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
