Python中的常用模块

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语言中的集合和数学中集合的概念非常相似。在数学中集合有如下三个特征。

1. 无序性：集合中每个元素的值都是平等的，元素之间是无序的。
2. 互异性：集合中任意两个元素都是不同的，即每个元素只能出现一次。
3. 确定性：集合中每个元素都是确定的，对于一个值来说，要么属于该集合，要么不属于该集合。
   所以，集合、列表和字典都不能作为集合的元素值，因为他们都是可变的。
   在创建集合类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.8061256

ticks变量的值是一个浮点数，这个浮点数就是从运行程序那一刻的时间点到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 2019

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