[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
#功能: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) #\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 10.20.172.109/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纪元后经过的浮点秒数)
  1. time.perf_counter() 返回计时器的精准时间(系统的运行时间),包含整个系统的睡眠时间。由于返回值的基准点是未定义的,所以只有连续调用的结果之间的差才是有效的。
  2. time.process_time() 返回当前进程执行 CPU 的时间总和,不包含睡眠时间。由于返回值的基准点是未定义的,所以只有连续调用的结果之间的差才是有效的。
  3. time.sleep(secs) 推迟调用线程的运行,secs 的单位是秒。

  4. 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.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 * 241小时的秒数 * 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 来决定(例如 20152月 只有 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,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):
4try:
44r = requests.get(url)
4except ConnectionError as e:
44print("[*] Error = "+str(e))
44exit(0)
4except TimeoutError as e:
44print("[*] Time = "+str(e))
44exit(1)
4except Exception as e:
44print("[*] Other Error = " + str(e))
44exit(2)

4print("URL:",r.url,"\nHeader:",end="")
4pprint(r.headers)
4print("Status:",r.status_code)
4print("Encoding:",r.encoding)
4r.encoding = "utf-8" #输出内容utf8编码,防止中午乱码
4print(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" '