Python3内置模块使用
时间:2022-07-28
本文章向大家介绍Python3内置模块使用，主要内容包括其使用实例、应用技巧、基本知识点总结和需要注意事项，具有一定的参考价值，需要的朋友可以参考一下。
[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:ab’和’E:ac’并不会冲突 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下为'rn'，Linux下为'n'）
os.name 指代当前使用的操作系统（包括：'posix', 'nt', 'mac', 'os2', 'ce', 'java'）
os.popen(命令) 执行指定的系统可执行脚本的命令os模块案例1：
#!/usr/bin/python3
#功能：OS模块的使用
import os
print("当前路径：",os.getcwd())
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) #rn
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 foreveros.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.0random 模块
随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。 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 是基于历史原因保留- time.altzone 返回格林威治西部的夏令时地区的偏移秒数；如果该地区在格林威治东部会返回负值（如西欧，包括英国）；对夏令时启用地区才能使用。
- time.asctime([t]) 接受时间元组并返回一个可读的形式为”Tue Dec 11 18:07:14 2015”（2015年12月11日 周二 18时07分14秒）的 24 个字符的字符串。
- time.clock() 用以浮点数计算的秒数返回当前的 CPU 时间。用来衡量不同程序的耗时，比 time.time() 更有用。 Python 3.3 以后不被推荐，由于该方法依赖操作系统，建议使用 perf_counter() 或 process_time() 代替（一个返回系统运行时间，一个返回进程运行时间，请按照实际需求选择）
- time.ctime([secs]) 作用相当于 asctime(localtime(secs))，未给参数相当于 asctime()
- time.gmtime([secs]) 接收时间辍（1970 纪元年后经过的浮点秒数）并返回格林威治天文时间下的时间元组 t（注：t.tm_isdst 始终为 0）
- time.daylight 如果夏令时被定义，则该值为非零。
- time.localtime([secs]) 接收时间辍（1970 纪元年后经过的浮点秒数）并返回当地时间下的时间元组 t（t.tm_isdst 可取 0 或 1，取决于当地当时是不是夏令时）
- time.mktime(t) 接受时间元组并返回时间辍（1970纪元后经过的浮点秒数）
- time.perf_counter() 返回计时器的精准时间（系统的运行时间），包含整个系统的睡眠时间。由于返回值的基准点是未定义的，所以只有连续调用的结果之间的差才是有效的。
- time.process_time() 返回当前进程执行 CPU 的时间总和，不包含睡眠时间。由于返回值的基准点是未定义的，所以只有连续调用的结果之间的差才是有效的。
- time.sleep(secs) 推迟调用线程的运行，secs 的单位是秒。
- 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.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.593751 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 <= 999999999timedelta 实例方法：
- 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.命令行参数
#命令行
>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:[email protected]:port',
# 'https': 'socks5://user:[email protected]: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,sendnanother,row,to,sendn')} #也可以发送作为文件来接收的字符串
>>> 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" '
- 在一个空ASP.NET Web项目上创建一个ASP.NET Web API 2.0应用
- 小论线性变换
- 谈谈基于OAuth 2.0的第三方认证 [下篇]
- Razor Engine，实现代码生成器的又一件利器
- 谈谈基于OAuth 2.0的第三方认证 [上篇]
- 我所理解的RESTful Web API [Web标准篇]
- ASP.NET Web API中的Controller
- iOS 转场动画探究(二)
- Swift 面向对象解析（二）
- 谈谈基于OAuth 2.0的第三方认证 [中篇]
- [ASP.NET Web API]如何Host定义在独立程序集中的Controller
- ASP.NET Web API自身对CORS的支持: EnableCorsAttribute特性背后的故事
- 【黑客解析】黑客是如何实现数据库勒索的 ?
- 直播回看：高可用架构入门 —— 腾讯云架构演变及经验
- JavaScript 教程
- JavaScript 编辑工具
- JavaScript 与HTML
- JavaScript 与Java
- JavaScript 数据结构
- JavaScript 基本数据类型
- JavaScript 特殊数据类型
- JavaScript 运算符
- JavaScript typeof 运算符
- JavaScript 表达式
- JavaScript 类型转换
- JavaScript 基本语法
- JavaScript 注释
- Javascript 基本处理流程
- Javascript 选择结构
- Javascript if 语句
- Javascript if 语句的嵌套
- Javascript switch 语句
- Javascript 循环结构
- Javascript 循环结构实例
- Javascript 跳转语句
- Javascript 控制语句总结
- Javascript 函数介绍
- Javascript 函数的定义
- Javascript 函数调用
- Javascript 几种特殊的函数
- JavaScript 内置函数简介
- Javascript eval() 函数
- Javascript isFinite() 函数
- Javascript isNaN() 函数
- parseInt() 与 parseFloat()
- escape() 与 unescape()
- Javascript 字符串介绍
- Javascript length属性
- javascript 字符串函数
- Javascript 日期对象简介
- Javascript 日期对象用途
- Date 对象属性和方法
- Javascript 数组是什么
- Javascript 创建数组
- Javascript 数组赋值与取值
- Javascript 数组属性和方法