[TOC]

0x00 快速入门

(1)内置模块一览表
描述：模块是一个包含所有您定义的函数和变量的文件其后缀名为.py，模块可以被失败引入的以使用该模块中的函数等功能。

#>>>dir(random)  #查看与使用模块里的函数,前提必须引入模块,高阶用法 import 引入模块 as 模块别名;
#>>>help(random) #模块帮助

import os        #操作系统模块
import sys       #系统模块
import math      #数学计算模块 
import random    #随机数生成模块 
import pickle    #数据序列和反序列化模块
import time      #时间解析模块提供各种时间相关的功能 (time，datetime 以及 calendar)
import dlifflib  #文件对比模块 (Python自动化运维处详解)
import filecmp   #文件目录差异对比方法 (同时)
import pprint    #格式化美观输出
import requests   #Requests 发送网络请求非常简单
import smtplib   #邮件发信模块
import email     #邮件模板包
import uuid      #UUID模块

---

0x01 模块详细

os模块

描述：os模块关于文件/目录常用的函数使用方法：
getcwd() 返回当前工作目录
chdir(path) 改变工作目录
listdir(path=’.’) 列举指定目录中的文件名（’.’表示当前目录，’..’表示上一级目录）
mkdir(path) 创建单层目录，如该目录已存在抛出异常
makedirs(path) 递归创建多层目录，如该目录已存在抛出异常，注意：’E:\a\b’和’E:\a\c’并不会冲突
remove(path) 删除文件
rmdir(path) 删除单层目录，如该目录非空则抛出异常
removedirs(path) 递归删除目录，从子目录到父目录逐层尝试删除，遇到目录非空则抛出异常
rename(old, new) 将文件old重命名为new
system(command) 运行系统的shell命令，显示执行命令后的返回，与返回执行是否成功0/1
walk(top) 遍历top路径以下所有的子目录，返回一个三元组：(路径, [包含目录], [包含文件])

以下是支持路径操作中常用到的一些定义，支持所有平台（相当于常量）

os.curdir  指代当前目录（'.'）
os.pardir  指代上一级目录（'..'）
os.sep  输出操作系统特定的路径分隔符（Win下为'\\'，Linux下为'/'）
os.linesep  当前平台使用的行终止符（Win下为'\r\n'，Linux下为'\n'）
os.name  指代当前使用的操作系统（包括：'posix',  'nt', 'mac', 'os2', 'ce', 'java'）
os.popen(命令) 执行指定的系统可执行脚本的命令

os 模块案例1：

#!/usr/bin/python3
# Desc: OS 模块常规使用范例
import os
print("当前路径(命令行与脚本都可)：",os.getcwd())
print("当前路径(命令行与脚本都可)：",os.path.abspath(os.curdir))
print("当前路径(脚本中使用)：",os.path.dirname(os.path.realpath(__file__)))
print("当前路径上级(父)目录(命令行与脚本都可)：",os.path.abspath(os.pardir))

os.chdir('C:\\Users\\Administrator\\Desktop\\Python')  #修改路径
print("修改后的路径：",os.getcwd())
os.mkdir('.\\test')         #创建目录
os.makedirs('.\\web\\a\\b')  # 目录已存在时，无法创建该目录以及多级目录
#os.remove('.\\demo2-10.txt')    #删除文件
os.rmdir('.\\test')              #移除单个目录
os.removedirs('.\\web\\a\\b')    #移除多个目录
print(os.system('DATE /T'))      #执行成功返回0，否则为1
print(list(os.walk(os.curdir)))  #遍历当前目录  os.pardir()
print('指定分隔符：',os.sep)
print('当前平台的中止符号: %s' %os.linesep)  #\r\n
print('当前使用的操作吸引:',os.name)

OS模块

os 模块案例2：
描述：采用os.popen来替代os.system来执行系统命令;

#!/usr/bin/env python
# -*- coding:utf-8 -*-

#获取本机的开放端口Linux/Windwos
command = "netstat -an|findstr TCP"
command = "netstat -tnlp|egrep -i tcp|awk {'print $4'}|awk -F':' '{print $NF}'|sort"
lines = os.popen(command).readlines()  #关键点
for line in lines:
    port = line.split()
    port_list.append(port[0])

command = "netstat -an|findstr TCP" 
lines = os.popen(command).readlines()  #关键点
for line in lines:
    port=line.split()
    port=port[1].split(':')
    print(port[1])

# runfile('E:/githubProject/Study-Promgram/Python3/Day9/os.popen.py', wdir='E:/githubProject/Study-Promgram/Python3/Day9')
# 135
# 443
# 445
# 902


#示例2.获取本机的ip地址信息
for k in os.popen("ip addr").readlines():
    print(k)
# 15: eth0: <BROADCAST,MULTICAST,UP> mtu 1500 group default qlen 1
#     link/ether 98:90:96:e1:91:d6
#     inet 192.168.1.88/24 brd 10.20.172.255 scope global dynamic
#     valid_lft 691196sec preferred_lft 691196sec
#     inet6 fe80::d97d:fe6c:10bf:4244/64 scope link dynamic
#     valid_lft forever preferred_lft forever

os.path 类模块

描述：os.path模块路径常用的函数使用方法
basename(path) 去掉目录路径，单独返回文件名
dirname(path) 去掉文件名，单独返回目录路径
join(path1[, path2[, …]]) 将path1, path2各部分组合成一个路径名
split(path)
分割文件名与路径，返回(f_path, f_name)元组。如果完全使用目录，它也会将最后一个目录作为文件名分离，且不会判断文件或者目录是否存在
splitext(path) 分离文件名与扩展名，返回(f_name, f_extension)元组
getsize(file) 返回指定文件的尺寸，单位是字节
getatime(file)
返回指定文件最近的访问时间（浮点型秒数，用time模块的gmtime()或localtime()函数换算）
getctime(file) 返回指定文件的创建时间（浮点型秒数，同上）
getmtime(file) 返回指定文件最新的修改时间（浮点型秒数，同上）

以下为函数返回 True 或 False
exists(path) 判断指定路径（目录或文件）是否存在
isabs(path) 判断指定路径是否为绝对路径
isdir(path) 判断指定路径是否存在且是一个目录
isfile(path) 判断指定路径是否存在且是一个文件
islink(path) 判断指定路径是否存在且是一个符号链接
ismount(path) 判断指定路径是否存在且是一个挂载点
samefile(path1, paht2) 判断path1和path2两个路径是否指向同一个文件

案例：

#!/usr/bin/python3
#功能：OS模块使用

import os
print(os.path.basename('E:\\web\\conf\\test.php'))
print(os.path.dirname('E:\\web\\conf\\test.php'))
print(os.path.join('E:\\','test\\demo.php'))  #注意path1在绝对路径需要加入转义符号
print(os.path.split('E:\\web\\conf\\test.php'))
print(os.path.splitext('E:\\web\\conf\\test.php'))
print(os.path.getsize(os.curdir + '\\python.txt'),'Bytes')
print("建立时间：",os.path.getctime(os.curdir + '\\python.txt'),'ms')
print("修改时间：",os.path.getmtime(os.curdir + '\\python.txt'),'ms')
print("访问时间：",os.path.getatime(os.curdir + '\\python.txt'),'ms')

if os.path.exists('.\\python.txt'):
  print("目录或者文件存在")
else:
    print('目录或者文件不存在')

print("是否为绝对路径：",os.path.isabs('.\\python.txt'))
print("是否是文件:",os.path.isfile('.\\python.txt'),"是否是目录:",os.path.isdir(os.pardir+'\\python'))
print("判断是否是挂载点：",os.path.ismount('D:\\'))

os.path 模块

sys 模块

描述：属性与参数一览表
(1) sys.argv CMD列表参数的获取

import sys  #系统模块
sys.setdefaultenconding('utf-8|gb2312') #设置系统默认的编码格式
sys.version_info  #当前Python版本信息
# sys.version_info(major=3, minor=7, micro=3, releaselevel='final', serial=0)

math 模块

import math Python数学函数

数学常量
pi 数学常量 pi（圆周率，一般以π来表示）
e 数学常量 e，e即自然常数（自然常数）

(1)abs(x) 返回数字的绝对值，如abs(-10) 返回 10
(2)ceil(x) 返回数字的上入整数，如math.ceil(4.1) 返回 5
(3)exp(x) 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
(4)fabs(x) 返回数字的绝对值，如math.fabs(-10) 返回10.0
(5)floor(x) 返回数字的下舍整数，如math.floor(4.9)返回 4
(6)log(x) 如math.log(math.e)返回1.0,math.log(100,10)返回2.0
(6)log10(x) 返回以10为基数的x的对数，如math.log10(100)返回 2.0
(7)max(x1, x2,…) 返回给定参数的最大值，参数可以为序列。
(8)min(x1, x2,…) 返回给定参数的最小值，参数可以为序列。
(9)modf(x) 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示（存储为元组）。
(10)pow(x, y) x**y 运算后的值(即幂运算)。
(11)round(x [,n]) 返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
(12)sqrt(x) 返回数字x的平方根。
(13)sum(iterable[,start-0]) 返回序列iterable和可选参数start的总和（要求数据类型一致）

数学之三角函数:
(13)acos(x) 返回x的反余弦弧度值。
(14)asin(x) 返回x的反正弦弧度值。
(15)atan(x) 返回x的反正切弧度值。
(16)atan2(y, x) 返回给定的 X 及 Y 坐标值的反正切值。
(17)cos(x) 返回x的弧度的余弦值。
(18)hypot(x, y) 返回欧几里德范数 sqrt(xx + yy)。
(19)sin(x) 返回的x弧度的正弦值。
(20)tan(x) 返回x弧度的正切值。
(21)degrees(x) 将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
(22)radians(x) 将角度转换为弧度

Python数学函数模块案例：

#!/usr/bin/python3
#coding:utf-8
#功能：数学函数验证
import math  #需要导入数学的包

# 常量
print(math.pi,math.e)  #3.141592653589793 2.718281828459045

#max / min 判断最大值/最小值
print(max(1,2))  #2
print(min([1,2,3],[2,3,4])) #[1,2,3]
print(math.ceil(1.2))  #2
print(math.floor(1.2)) #1
tup = math.modf(1.8) 
print("math.modf(1.8)",tup[1],tup[0])  #1.0 0.8
print(pow(5,2)) # 25
print(round(8.5)) #四舍五入（注意当小数部分只有5时候还是舍弃，整数部分不进位）8
print(round(8.51))   #9
print(math.sqrt(10)) #3.1622776601683795

#元组或者序列（list）纸盒
tuple1 = (1.1,2.2,3.3)
print(sum(tuple1)）       # 6.6
print(sum(tuple1,4.4) )   #6.6 + 4.4 = 11.0

random 模块

随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。
import random

(1)choice(seq) 从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
(2)randrange ([start,] stop [,step]) 从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1
(3)random() 随机生成下一个实数，它在[0,1)范围内。
(4)seed([x]) 改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定(5)seed，Python会帮你选择seed。
(6)shuffle(lst) 将序列的所有元素随机排序
(7)uniform(x, y) 随机生成下一个实数，它在[x,y]范围内。

案例：

#!/usr/bin/python3
#coding:utf-8
#功能：随机数函数
import random  #载入模块

print(random.choice(range(0,10)))  #0~10随机 int
print(random.randrange(0,100))     #0~100随机数 int 
print(random.random())                 #0~1 随机生成 0.47044481738738064 float
print(random.uniform(0,10))          #0~1 随机生成 13.47044481738738064 float
random.seed()   #随机数种子

list = [1,2,3,4,5,6]
print(list)  #[1, 2, 3, 4, 5, 6]
random.shuffle(list)  #将序列的所有元素随机排序
print(list) #[2, 4, 5, 1, 3, 6]

pickle 模块

利用一些算法将你的数据对象“腌制”成二进制文件;注意都要先使用’wb’的模式open文件哦;
(1) pickle.dump(data, file) # 第一个参数是待存储的数据对象，第二个参数是目标存储的文件对象
(2) pickle.load(file) # 参数是目标存储的文件对象

time 模块

在 Python 中与时间处理有关的模块包括：time，datetime 以及 calendar

术语和约定的解释：

• 时间戳（timestamp）的方式：通常来说，时间戳表示的是从 1970 年 1 月 1 日 00:00:00 开始按秒计算的偏移量（time.gmtime(0)）
• UTC（Coordinated Universal Time，世界协调时）也叫格林威治天文时间，是世界标准时间。在中国为 UTC+8
• DST（Daylight Saving Time）即夏令时的意思

注意事项：

• 模块总是可用但的功能不一定适用于各个平台。
• 模块中定义的大部分函数是调用 C 平台上的同名函数实现，所以各个平台上实现可能略有不同
• 实时函数的计算精度有可能低于它们建议的值或参数，例如在大部分 Unix 系统，时钟一秒钟“滴答”50~100 次

方法一览图：
gmtime() 转换显示格林治时间
localtime() 转换显示本地时间
strptime() #以时间元祖（struct_time）的形式返回。

#Index	Attribute 值（Values）
0	 tm_year（年）	（例如：2015）
1	 tm_mon（月）	1 ~ 12
2	 tm_mday（日）	1 ~ 31
3	 tm_hour（时）	0 ~ 23
4	 tm_min（分） 	0 ~ 59
5	 tm_sec（秒）	  0 ~ 61 #（见下方注1）
6	 tm_wday（星期几）	0 ~ 6（0 表示星期一）
7	 tm_yday（一年中的第几天）	1 ~ 366
8	 tm_isdst（是否为夏令时）	0， 1， -1（-1 代表夏令时）
#注1：范围真的是 0 ~ 61（你没有看错哦^_^）；60 代表闰秒，61 是基于历史原因保留

1. time.altzone 返回格林威治西部的夏令时地区的偏移秒数；如果该地区在格林威治东部会返回负值（如西欧，包括英国）；对夏令时启用地区才能使用。
2. time.asctime([t]) 接受时间元组并返回一个可读的形式为”Tue Dec 11 18:07:14 2015”（2015年12月11日 周二 18时07分14秒）的 24 个字符的字符串。

3. time.clock() 用以浮点数计算的秒数返回当前的 CPU 时间。用来衡量不同程序的耗时，比 time.time() 更有用。
   Python 3.3 以后不被推荐，由于该方法依赖操作系统，建议使用 perf_counter() 或 process_time() 代替（一个返回系统运行时间，一个返回进程运行时间，请按照实际需求选择）

4. time.ctime([secs]) 作用相当于 asctime(localtime(secs))，未给参数相当于 asctime()

5. time.gmtime([secs]) 接收时间辍（1970 纪元年后经过的浮点秒数）并返回格林威治天文时间下的时间元组 t（注：t.tm_isdst 始终为 0）
6. time.daylight 如果夏令时被定义，则该值为非零。
7. time.localtime([secs]) 接收时间辍（1970 纪元年后经过的浮点秒数）并返回当地时间下的时间元组 t（t.tm_isdst 可取 0 或 1，取决于当地当时是不是夏令时）
8. time.mktime(t) 接受时间元组并返回时间辍（1970纪元后经过的浮点秒数）

9. time.perf_counter() 返回计时器的精准时间（系统的运行时间），包含整个系统的睡眠时间。由于返回值的基准点是未定义的，所以只有连续调用的结果之间的差才是有效的。
10. time.process_time() 返回当前进程执行 CPU 的时间总和，不包含睡眠时间。由于返回值的基准点是未定义的，所以只有连续调用的结果之间的差才是有效的。

11. time.sleep(secs) 推迟调用线程的运行，secs 的单位是秒。

12. time.strftime(format[, t]) 把一个代表时间的元组或者 struct_time（如由 time.localtime() 和 time.gmtime() 返回）转化为格式化的时间字符串。
    如果 t 未指定，将传入 time.localtime(),如果元组中任何一个元素越界，将会抛出 ValueError 异常。

#date, datetime, 和 time 对象均支持使用 strftime(format) 方法，将指定的日期或时间转换为自定义的格式化字符串
>>> from datetime import datetime
>>> dt = datetime.now()
>>> print('(%Y-%m-%d %H:%M:%S %f): ', dt.strftime('%Y-%m-%d %H:%M:%S %f'))
(%Y-%m-%d %H:%M:%S %f):  2014-08-31 23:54:58 379804
>>> print('(%Y-%m-%d %H:%M:%S %p): ', dt.strftime('%y-%m-%d %I:%M:%S %p'))
(%Y-%m-%d %H:%M:%S %p):  14-08-31 11:54:58 PM
>>> print('%%a: %s ' % dt.strftime('%a'))
%a: Sun 
>>> print('%%A: %s ' % dt.strftime('%A'))
%A: Sunday 
>>> print('%%b: %s ' % dt.strftime('%b'))
%b: Aug 
>>> print('%%B: %s ' % dt.strftime('%B'))
%B: August 
>>> print('日期时间%%c: %s ' % dt.strftime('%c'))
日期时间%c: 08/31/14 23:54:58 
>>> print('日期%%x：%s ' % dt.strftime('%x'))
日期%x：08/31/14 
>>> print('时间%%X：%s ' % dt.strftime('%X'))
时间%X：23:54:58 
>>> print('今天是这周的第%s天 ' % dt.strftime('%w'))
今天是这周的第0天 
>>> print('今天是今年的第%s天 ' % dt.strftime('%j'))
今天是今年的第243天 
>>> print('今周是今年的第%s周 ' % dt.strftime('%U'))
今周是今年的第35周

weiyigeek.top-format格式化参数表

时间模块案例：

# 时区相差
print("格林：",time.gmtime(os.path.getctime(os.curdir + '\\python.txt')))
print("本地：",time.localtime(os.path.getctime(os.curdir + '\\python.txt')))
>>> time.localtime()
#本地： time.struct_time(tm_year=2019, tm_mon=4, tm_mday=7, tm_hour=17, tm_min=26, tm_sec=46, tm_wday=6, tm_yday=97, tm_isdst=0)
#格林： time.struct_time(tm_year=2019, tm_mon=3, tm_mday=2, tm_hour=6, tm_min=45, tm_sec=39, tm_wday=5, tm_yday=61, tm_isdst=0)


#!/usr/bin/python
# -*- coding:UTF-8 -*-
# 功能：time模块的使用

import time as t  

print("####sleep - 延迟3s执行！###")
#t.sleep(3)

#把一个格式化时间字符串转化为 struct_time 
print(t.strftime("%a %b %Y %H:%M:%S +0000", t.localtime()))
print(t.strftime("%A %B %Y %H:%M:%S +0000", t.gmtime()))

# 接受时间元组并返回一个可读的形式
print("asctime() ",t.asctime(t.localtime()))

# 作用相当于 asctime(localtime(secs))，未给参数相当于 asctime()
print("ctime() ",t.ctime())

# 接受时间元组并返回时间辍
print("mktime() 指定时间的时间戳",t.mktime(t.localtime()))

# 返回当前时间的时间戳（1970 纪元年后经过的浮点秒数）
print("time() 当前时间戳 :",t.time()) 

# 当地时区（未启动夏令时）距离格林威治的偏移秒数（美洲 >0；大部分欧洲，亚洲，非洲 <= 0）
print("timezone 距离格林威治的偏移秒数 :",t.timezone)

#返回格林威治西部的夏令时地区的偏移秒数
print("altzone 返回格林威治西部的夏令时地区的偏移秒数 :",t.altzone)

# 返回计时器的精准时间（系统的运行时间）
print("perf_counter() 计时器的精准时间 ",t.perf_counter())

#返回当前进程执行 CPU 的时间总和，不包含睡眠时间
print("process_time() 当前进程执行 CPU 的时间总和",t.process_time())

#包含两个字符串的元组：第一是当地非夏令时区的名称，第二个是当地的 DST 时区的名称。
print(t.tzname)  #乱码

####### sleep - 延迟3s执行！######
# > python demo3.14.py 
# Sun Apr 2019 17:04:21 +0000
# Sunday April 2019 09:04:21 +0000
# asctime()  Sun Apr  7 17:04:21 2019
# ctime()  Sun Apr  7 17:04:21 2019
# mktime() 指定时间的时间戳 1554627861.0
# time() 当前时间戳 : 1554627861.0564845
# timezone 距离格林威治的偏移秒数 : -28800
# altzone 返回格林威治西部的夏令时地区的偏移秒数 : -32400
# perf_counter() 计时器的精准时间  0.612054762
# process_time() 当前进程执行 CPU 的时间总和 0.59375

1 datatime 详解

描述：datetime 模块提供了各种类用于操作日期和时间，该模块侧重于高效率的格式化输出

datetime 模块定义了两个常量：

• datetime.MINYEAR - date 和 datetime 对象所能支持的最小年份，object.MINYEAR 的值为 1
• datetime.MAXYEAR - date 和 datetime 对象所能支持的最大年份，object.MAXYEAR 的值为 9999

datetime 模块中定义的类（前四个下方有详解）：

• datetime.date - 表示日期的类，常用属性：year, month, day
• datetime.time - 表示时间的类，常用属性：hour, minute, second, microsecond, tzinfo
• datetime.datetime - 表示日期和时间的类，常用属性： year, month, day, hour, minute, second, microsecond, tzinfo
• datetime.timedelta - 表示时间间隔，即两个时间点（date，time，datetime）之间的长度
• datetime.tzinfo - 表示时区的基类，为上方的 time 和 datetime 类提供调整的基准
• datetime.timezone - 表示 UTC 时区的固定偏移，是 tzinfo 基类的实现

#上边这些类的从属关系：
object
    timedelta
    tzinfo
        timezone
    time
    date
        datetime

注：上边这些类的对象是不可变的

(1) timedelta 对象
timedelta 对象表示两个日期或时间之间的间隔
timedelta 类属性：

• timedelta.min - timedelta 对象负值的极限，timedelta(-999999999)
• timedelta.max - timedelta 对象正值的极限，timedelta(days=999999999, hours=23, minutes=59, seconds=59, microseconds=999999)
• timedelta.resolution - 两个 timedelta 不相等的对象之间最小的差值，timedelta(microseconds=1)
  请注意，在正常情况下，timedelta.max > -timedelta.min，-timedelta.max 无意义。

取值范围：

## 所有的参数都是可选的（默认为 0 - 里面是属性），参数的可以是整数或浮点数，正数或负数。
datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)

1 millisecond -> 1000 microseconds
1 minutes -> 60 seconds
1 hours -> 3600 seconds
1 weeks -> 7 days
0 <= microseconds < 1000000
0 <= seconds < 3600 * 24（1小时的秒数 * 24小时）
-999999999 <= days <= 999999999

timedelta 实例方法：

• timedelta.total_seconds() - 返回 timedelta 对象所包含的总秒数，相当于 td / timedelta(seconds=1)
  请注意，对于非常大的时间间隔（在大多数平台上是大于270年），这种方法将失去微秒（microsecond）精度

timedelta 案例：

>>> from datetime import timedelta
>>> year = timedelta(days=365)
>>> another_year = timedelta(weeks=40, days=84, hours=23, minutes=50, seconds=600)  # adds up to 365 days
>>> year.total_seconds()
31536000.0
>>> year == another_year
True
>>> ten_years = 10 * year
>>> ten_years, ten_years.days // 365
(datetime.timedelta(3650), 10)
>>> nine_years = ten_years - year
>>> nine_years, nine_years.days // 365
(datetime.timedelta(3285), 9)
>>> three_years = nine_years // 3;
>>> three_years, three_years.days // 365
(datetime.timedelta(1095), 3)
>>> abs(three_years - ten_years) == 2 * three_years + year
True

(2)date 对象
对象表示一个日期，在一个理想化的日历里，日期由 year（年）、month（月）、day（日）组成
取值范围：

datetime.date(year, month, day)

MINYEAR <= year <= MAXYEAR（也就是 1 ~ 9999）
1 <= month <= 12
1 <= day <= 根据 year 和 month 来决定（例如 2015年2月 只有 28 天）

类方法（classmethod）:
today()，fromtimestamp(timestamp)，fromordinal(ordinal) 】
date 类属性： 与 datedelta 类属性一致

date 实例方法：

• date.replace(year, month, day) - 生成一个新的日期对象，用参数指定的年、月、日代替原有对象中的属性

• date.timetuple() - 返回日期对应的 time.struct_time 对象（类似于 time 模块的 time.localtime()）

• date.toordinal() - 返回日期对应的 Gregorian Calendar 日期

• date.weekday() - 返回 0 ~ 6 表示星期几（星期一是 0，依此类推）

• date.isoweekday() - 返回 1 ~ 7 表示星期几（星期一是1， 依此类推）

• date.isocalendar() - 返回一个三元组格式 (year, month, day)

• date.isoformat() - 返回一个 ISO 8601 格式的日期字符串，如 “YYYY-MM-DD” 的字符串

• date.str() - 对于 date 对象 d 来说，str(d) 相当于 d.isoformat()

• date.ctime() - 返回一个表示日期的字符串，相当于 time 模块的 time.ctime(time.mktime(d.timetuple()))

• date.strftime(format) - 返回自定义格式化字符串表示日期，下面有详解

• date.format(format) - 跟 date.strftime(format) 一样，这使得调用 str.format() 时可以指定 data 对象的字符串

date对象案例：

# 以下是计算天数的例子：
>>> import time
>>> from datetime import date
>>> today = date.today()
>>> today
datetime.date(2014, 8, 31)
>>> today == date.fromtimestamp(time.time())  #True
>>> my_birthday = date(today.year, 6, 24)
>>> if my_birthday < today:
        my_birthday = my_birthday.replace(year = today.year + 1)   #datetime.date(2015, 6, 24)
>>> time_to_birthday = abs(my_birthday - today)
>>> time_to_birthday.days
297

>>> d = date.fromordinal(735678)  # 自日期 1.1.0001 之后的第 735678 天
>>> d
datetime.date(2015, 3, 21)
>>> t = d.timetuple()
>>> for i in t:
        print(i,end='')
2015 3 21 0 0 0 5 80 -1

>>> ic = d.isocalendar()
>>> for i in ic:
        print(i)
2015 12 6
>>> d.isoformat()
'2015-03-21'
>>> d.strftime("%d/%m/%y")
'21/03/15'
>>> d.strftime("%A %d. %B %Y")
'Saturday 21. March 2015'
>>> 'The {1} is {0:%d}, the {2} is {0:%B}.'.format(d, "day", "month")
'The day is 21, the month is March.'

(3)time 对象
time 对象表示一天中的一个时间，并且可以通过 tzinfo 对象进行调整;
取值范围：

#里面的参数就是实例的属性但是只读的 time.hour
datetime.time(hour=0, minute=0, second=0, microsecond=0, tzinfo=None)
0 <= hour < 24
0 <= minute < 60
0 <= second < 60
0 <= microsecond < 1000000
注：如果参数超出范围，将引发 ValueError 异常

time 实例方法：
time.replace([hour[, minute[, second[, microsecond[, tzinfo]]]]])- 生成一个新的时间对象，用参数指定时间代替原有对象中的属性

time.isoformat()- 返回一个 ISO 8601 格式的日期字符串，如 “HH:MM:SS.mmmmmm” 的字符串

time.str()- 对于 time 对象 t 来说，str(t) 相当于 t.isoformat()

time.strftime(format)- 返回自定义格式化字符串表示时间，下面有详解

time.format(format) - 跟 time.strftime(format) 一样，这使得调用 str.format() 时可以指定 time 对象的字符串

time.utcoffset() - 如果 tzinfo 属性是 None，则返回 None；否则返回 self.tzinfo.utcoffset(self)

time.dst() - 如果 tzinfo 属性是 None，则返回 None；否则返回 self.tzinfo.dst(self)

time.tzname()- 如果 tzinfo 属性是 None，则返回 None；否则返回 self.tzinfo.tzname(self)

time 案例：

# 学编程，到鱼C
>>> from datetime import time, timedelta, tzinfo
>>> class GMT1(tzinfo):
        def utcoffset(self, dt):
                return timedelta(hours=1)
        def dst(self, dt):
                return timedelta(0)
        def tzname(self, dt):
                return "欧洲/布拉格"

>>> t = time(14, 10, 30, tzinfo=GMT1())
>>> t
datetime.time(14, 10, 30, tzinfo=<__main__.GMT1 object at 0x02D7FE90>)
>>> gmt = GMT1()
>>> t.isoformat()
'14:10:30+01:00'
>>> t.dst()
datetime.timedelta(0)
>>> t.tzname()
'欧洲/布拉格'
>>> t.strftime("%H:%M:%S %Z")
'14:10:30 欧洲/布拉格'
>>> 'The {} is {:%H:%M}.'.format("time", t)
'The time is 14:10.'

2 timeit 详解

timeit模块准确测量小段代码的执行时间,既可以在命令行界面直接使用，也可以通过导入模块进行调用，该模块灵活地避开了测量执行时间所容易出现的错误。

该模块定义了三个实用函数和一个公共类。

#命令行界面 语法
python -m timeit [-n N] [-r N] [-s S] [-t] [-c] [-h] [statement ...]

(1)timeit.timeit(stmt='pass', setup='pass', timer=<default timer>, number=1000000)  # 创建一个 Timer 实例，参数分别是 stmt（需要测量的语句或函数），setup（初始化代码或构建环境的导入语句），timer（计时函数），number（每一次测量中语句被执行的次数）

(2) timeit.repeat(stmt='pass', setup='pass', timer=<default timer>, repeat=3, number=1000000)  #repeat（重复测量的次数）

(3)timeit.default_timer() # 默认计时器，一般是 time.perf_counter()方法能够在任一平台提供最高精度的计时器（它也只是记录了自然时间，记录自然时间会被很多其他因素影响，例如计算机的负载）。

(4)class timeit.Timer(stmt='pass', setup='pass', timer=<timer function>)  #计算小段代码执行速度的类，前两个参数都可以包含多个语句，多个语句间使用分号（;）或新行分隔开。
# stmt 和 setup 参数也可以是可供调用但没有参数的对象，这将会在一个计时函数中嵌套调用它们，然后被 timeit() 所执行。注意由于额外的调用，计时开销会相对略到

##timeit 属性
- timeit(number=1000000) #功能：计算语句执行 number 次的时间
- repeat(repeat=3, number=1000000)  #功能：重复调用 timeit()
- print_exc(file=None)  #功能：输出计时代码的回溯（Traceback）
#标准回溯的优点是在编译模板中，源语句行会被显示出来。可选的 file 参数指定将回溯发送的位置，默认是发送到 sys.stderr。

weiyigeek.top-命令行参数

#命令行
>python -m timeit -s "for i in range(10): oct(i)" -p
50000000 loops, best of 5: 6.25 nsec per loop

>python -m timeit -s "for i in range(10): oct(i)" -r 1 -n 1
1 loop, best of 1: 365 nsec per loop


#IDLE调用执行
>>> import timeit
>>> timeit.timeit('"-".join(str(n) for n in range(100))', number=10000)
0.8187260627746582
>>> timeit.timeit('"-".join(map(str, range(100)))', number=10000)
0.5858950614929199

>>> timeit.Timer('for i in range(10): oct(i)', 'gc.enable()').timeit()
0.9954580070000247

>>> timeit.timeit('text.find(char)', setup='text = "I love FishC.com!"; char = "o"')
1.7246671520006203


#实际案例
#!/usr/bin/python
def test():
    """Stupid test timeit module function"""
    L = [i for i in range(1000)]

if __name__ == '__main__':
    import timeit   #导入模块
    t = timeit.Timer()
    try:
        print("执行时间：",end=" ")
        print(timeit.timeit(stmt="test()", setup="from __main__ import test",number=100))
    except Exception:
        print('异常抛出：')
        t.print_exc()
# >python demo6.2.py
# 执行时间： 0.0026121469999999952

注意事项：

• 只有当使用命令行界面时，timeit 才会自动确定重复的次数。
• 由于 timeit() 正在执行语句，语句中如果存在返回值的话会阻止 timeit() 返回执行时间，并且timeit() 会取代原语句中的返回值。
• repeat() 方法相当于持续多次调用 timeit() 方法并将结果返回为一个列表。

pprint 模块

描述：用于美化打印输出数据，非常实用；

使用案例：

# 示例1.
sys.path
['D:\\Program Files\\JetBrains\\PyCharm2019\\helpers\\pydev', 'D:\\Program Files\\JetBrains\\PyCharm2019\\helpers\\pycharm_display', 'D:\\Program Files\\JetBrains\\PyCharm2019\\helpers\\third_party\\thriftpy', 'E:\\githubProject\\Study-Promgram\\Python3', 'E:/githubProject/Study-Promgram/Python3']
pprint.pprint(sys.path) #美观输出
['D:\\Program Files\\JetBrains\\PyCharm2019\\helpers\\pydev',
 'D:\\Program Files\\JetBrains\\PyCharm2019\\helpers\\pycharm_display',
 'D:\\Program Files\\JetBrains\\PyCharm2019\\helpers\\third_party\\thriftpy',
 'E:\\githubProject\\Study-Promgram\\Python3',
 'E:/githubProject/Study-Promgram/Python3']

requests 模块

描述：使用 Requests 发送网络请求非常简单，导入模块即可;
参考：https://2.python-requests.org//zh_CN/latest/user/advanced.html#advanced

模块方法：

#1.get定制请求头/请求参数/设置cookies/禁用重定向
#SSL认证可以为 默认情况下 verify 是设置为 True 的。
#选项 verify 仅应用于主机证书。verify 传入 CA_BUNDLE 文件的路径，或者包含可信任 CA 证书文件的文件夹路径
#客户端证书 ：指定一个本地证书用作客户端证书，可以是单个文件（包含密钥和证书）或一个包含两个文件路径的元组
#进行网络请求后，响应体会立即被下载。可以通过 stream 参数覆盖这个行为，推迟下载响应体直到访问 Response.content 属性
r = requests.get(url, headers={'user-agent': 'my-app/0.0.1'},param={'key1':"value"}, cookies=dict(cookies_are='working'),allow_redirects=False,timeout=0.001,verify=True,verify='/path/to/certfile',cert=('/path/client.cert', '/path/client.key'),stream=Truem,proxies = {"http": "http://10.10.1.10:3128",
"https": "http://10.10.1.10:1080",})
#注意：除了基本的 HTTP 代理，Request 还支持 SOCKS 协议的代理  pip install requests[socks] , 使用方法如下
# proxies = {
#     'http': 'socks5://user:pass@host:port',
#     'https': 'socks5://user:pass@host:port'
# }


#2.post请求
r = requests.post("http://httpbin.org/post", data= {'key1': 'value1', 'key2': 'value2'})
r = requests.post("https://api.github.com/some/endpoint", data=json.dumps(payload)) #Github API v3 接受编码为 JSON 的 POST/PATCH 数据


#3.会话对象
s = requests.Session()
r = s.get('http://httpbin.org/cookies', cookies={'from-my': 'browser'})
#或者
with requests.Session() as s:
    s.get('http://httpbin.org/cookies/set/sessioncookie/123456789') #确保 with 区块退出后会话能被关闭，即使发生了异常也一样。

模块属性：

requestsOBJ.status_code : 响应状态码 requests.codes.ok  一个内置的状态码查询对象
requestsOBJ.headers : 服务器响应头
requestsOBJ.url : 对象请求的 URL 的查询字符串
requestsOBJ.text : 读取服务器响应的内容,自动解码来自服务器的内容，大多数 unicode 字符集都能被无缝地解码
requestsOBJ.content : 以字节的方式访问请求响应体对于非文本请求(2进制)，自动为你解码 gzip 和 deflate 传输编码的响应数据
requestsOBJ.encoding ： 查看Requests 使用了什么编码 设置解析编码r.encoding = 'ISO-8859-1'
r.history : 重定向与请求历史,默认情况下除了 HEAD, Requests 会自动处理所有重定向。
r.raw #取来自服务器的原始套接字响应，那么你可以访问 r.raw,前提是在初始请求中设置了 stream=True还能采用r.raw.read(10)
r.json() #Requests 中也有一个内置的 JSON 解码器，助你处理 JSON 数据
r.cookies['example_cookie_name']  #获取网站返回的Cookie

补充异常： 所有Requests显式抛出的异常都继承自requests.exceptions.RequestException

• ConnectionError ：遇到网络问题（如：DNS 查询失败、拒绝连接等）时
• HTTPError ：HTTP 请求返回了不成功的状态码
• Timeout : 请求超时
• TooManyRedirects : 请求超过了设定的最大重定向次数
  可以通过 Response.raise_for_status() 来抛出异常，当发送了一个错误请求(一个 4XX 客户端错误，或者 5XX 服务器错误响应)
  r.raise_for_status() # r 的 status_code 是 200 ，当我们调用 raise_for_status() 时，得到的是：None

实际案例：

#示例1.各类请求 get/post/put/delete/head/options 等等;
>>> r = requests.get('https://api.github.com/events',params = {'key1': 'value1', 'key2': 'value2'}) #传递 URL 参数
>>> r = requests.post('http://httpbin.org/post', data = {'key':'value'})
>>> r = requests.put('http://httpbin.org/put', data = {'key':'value'})
>>> r = requests.delete('http://httpbin.org/delete')
>>> r = requests.head('http://httpbin.org/get')
>>> r = requests.options('http://httpbin.org/get')


#示例2.POST一个多部分编码(Multipart-Encoded)的文件
>>> url = 'http://httpbin.org/post'
>>> files = {'file': open('report.xls', 'rb'), 'application/vnd.ms-excel', {'Expires': '0'}}
>>> files = {'file': ('report.csv', 'some,data,to,send\nanother,row,to,send\n')} #也可以发送作为文件来接收的字符串
>>> r = requests.post(url, files=files)

#示例3.POST 多个分块编码的文件
#要实现只要把文件设到一个元组的列表中，其中元组结构为 (form_field_name, file_info):
<input type="file" name="images" multiple="true" required="true"/>
>>> url = 'http://httpbin.org/post'
>>> multiple_files = [
        ('images', ('foo.png', open('foo.png', 'rb'), 'image/png')),
        ('images', ('bar.png', open('bar.png', 'rb'), 'image/png'))]
>>> r = requests.post(url, files=multiple_files)
>>> r.text

#示例3.Cookie 的返回对象为 RequestsCookieJar，它的行为和字典类似，但接口更为完整，适合跨域名跨路径使用。
>>> jar = requests.cookies.RequestsCookieJar()
>>> jar.set('tasty_cookie', 'yum', domain='httpbin.org', path='/cookies')
>>> jar.set('gross_cookie', 'blech', domain='httpbin.org', path='/elsewhere')
>>> url = 'http://httpbin.org/cookies'
>>> r = requests.get(url, cookies=jar)
>>> r.text
'{"cookies": {"tasty_cookie": "yum"}}'


#实例4.请求网站并返回信息
def get(url):
  try:
    r = requests.get(url)
  except ConnectionError as e:
    print("[*] Error = "+str(e))
    exit(0)
  except TimeoutError as e:
    print("[*] Time = "+str(e))
    exit(1)
  except Exception as e:
    print("[*] Other Error = " + str(e))
    exit(2)

  print("URL:",r.url,"\nHeader:",end="")
  pprint(r.headers)
  print("Status：",r.status_code)
  print("Encoding:",r.encoding)
  r.encoding = "utf-8"  #输出内容utf8编码，防止中午乱码
  print(r.history)


# 执行结果信息 #
# Connected to pydev debugger (build 191.7479.30)
# URL: http://127.0.0.1:4000/archives/ 
# Header:{'X-Powered-By': 'Hexo', 'Content-Type': 'text/html', 'Date': 'Fri, 12 Jul 2019 07:21:36 GMT', 'Connection': 'keep-alive', 'Transfer-Encoding': 'chunked'}
# Status： 200
# Encoding: ISO-8859-1
# []
# ('<!DOCTYPE html PUBLIC "-//WAPFORUM//DTD XHTML Mobile 1.0//EN" '