OS：operate system
模块导入方式： import os
os模块是Python标准库中的一个用于访问操作系统相关功能的模块
使用os模块中提供的接口，可以实现跨平台访问。
os模块的主要功能：系统相关、目录及文件操作、执行命令和管理进程
在使用os模块的时候，如果出现了问题，会抛出OSError异常，表明无效的路径名或文件名，或者路径名(文件名)无法访问，或者当前操作系统不支持该操作。
>>> import os
>>> os.chdir("d:11")
Traceback (most recent call last):
File "", line 1, in
os.chdir("d:11")
OSError: [WinError 123] 文件名、目录名或卷标语法不正确。: 'd:t'
系统相关
os模块提供了一些操作系统相关的变量，可以在跨平台的时候提供支持，便于编写移植性高，可用性好的代码。
下面列举os模块中常用的方法和变量，及其用途解释。
os.name #查看当前操作系统的名称。windows平台下返回‘nt’，Linux则返回‘posix’。 os.environ #获取系统环境变量 os.sep #当前平台的路径分隔符。在windows下，为‘’，在POSIX系统中，为‘/’。 os.altsep #可替代的路径分隔符，在Windows中为‘/’。 os.extsep #文件名和文件扩展名之间分隔的符号，在Windows下为‘.’。 os.pathsep #PATH环境变量中的分隔符，在POSIX系统中为‘:’，在Windows中为‘;’。
示例：
>>> import os
>>> os.name
'nt'
>>> os.environ
environ({'ALLUSERSPROFILE': 'C:\ProgramData', 'APPDATA': 'C:\Users\Administrator\AppData\Roaming', 'ASL.LOG': 'Destination=file', ......
>>> os.sep
'\'
>>> os.altsep
'/'
>>> os.extsep
'.'
>>> os.pathsep
';'
文件和目录操作
os模块中包含了一系列文件操作相关的函数，其中有一部分是Linux平台专用方法。关于Linux的相关方法，内容较为复杂，可根据需要自行查阅官方文档，这里只介绍一些常用的，各平台通用的方法。
os.getcwd() #获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname") #改变当前脚本工作目录；相当于shell下cd
os.curdir #返回当前目录: ('.')
os.pardir #获取当前目录的父目录字符串名：('..')
os.makedirs('dir1/dir2') #可生成多层递归目录
os.removedirs(‘dirname1’) #递归删除空目录（要小心）
os.mkdir('dirname') #生成单级目录
os.rmdir('dirname') #删除单级空目录，若目录不为空则无法删除并报错
os.listdir('dirname') #列出指定目录下的所有文件和子目录，包括隐藏文件
os.remove('filename') #删除一个文件
os.rename("oldname","new") #重命名文件/目录
os.stat('path/filename') #获取文件/目录信息
os.path.abspath(path) #返回path规范化的绝对路径
os.path.split(path) #将path分割成目录和文件名二元组返回
os.path.dirname(path) #返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path) #返回path最后的文件名。如果path以／或结尾，那么就会返回空值。
os.path.exists(path或者file) #如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path) #如果path是绝对路径，返回True
os.path.isfile(path) #如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path) #如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]]) #将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path) #返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path) #返回path所指向的文件或者目录的最后修改时间
os.path.getsize(filename) #返回文件包含的字符数量
一些简单使用的例子：
>>> os.getcwd()
'C:\Python36'
>>> os.chdir("d:")
>>> os.getcwd()
'D:\'
>>> os.curdir
'.'
>>> os.pardir
'..'
>>> os.makedirs("1\2")
>>> os.removedirs("1\2")
>>> os.listdir()
['$360Section', '$RECYCLE.BIN', '1.txt', 'MobileFile', 'pymysql_test.py', 'System Volume Information', '用户目录']
>>> os.mkdir("1")
>>> os.listdir()
['$360Section', '$RECYCLE.BIN', '1', '1.txt', 'MobileFile', 'pymysql_test.py', 'System Volume Information', '用户目录']
>>> os.rmdir("1")
>>> os.rename('1.txt','2.txt')
>>> os.listdir()
['$360Section', '$RECYCLE.BIN', '2.txt', 'MobileFile', 'pymysql_test.py', 'System Volume Information', '用户目录']
>>> os.remove('1.txt')
Traceback (most recent call last):
File "", line 1, in
os.remove('1.txt')
FileNotFoundError: [WinError 2] 系统找不到指定的文件。: '1.txt'
>>> os.remove('2.txt')
>>> os.stat()
Traceback (most recent call last):
File "", line 1, in
os.stat()
TypeError: Required argument 'path' (pos 1) not found
>>> os.stat(os.getcwd())
os.stat_result(st_mode=16895, st_ino=1407374883553285, st_dev=2431137650, st_nlink=1, st_uid=0, st_gid=0, st_size=32768, st_atime=1505824872, st_mtime=1505824872, st_ctime=1445187376)
更多操作：
>>> import os
>>> os.chdir("d:")
>>> os.getcwd()
'D:\'
>>> os.mkdir('test')
>>> os.listdir()
['$360Section', '$RECYCLE.BIN', 'MobileFile', 'pymysql_test.py', 'System Volume Information', 'test', '用户目录']
>>> os.chdir('test')
>>> os.getcwd()
'D:\test'
>>> os.path.abspath(os.getcwd())
'D:\test'
>>> os.path.split(os.getcwd())
('D:\', 'test')
>>> cp = os.getcwd()
>>> os.path.dirname(cp)
'D:\'
>>> os.path.basename(cp)
'test'
>>> os.path.exists(cp)
True
>>> os.path.exists("d:\123123")
False
>>> os.path.isabs(cp)
True
>>> os.path.isabs("11\1.py")
False
>>> os.path.isfile(cp)
False
>>> os.path.isfile("d:\1.txt")
False
>>> os.path.isdir(cp)
True
>>> os.path.join(cp, "test.py")
'D:\test\test.py'
>>> os.path.getatime(cp)
1505825113.4970243
>>> os.path.getmtime(cp)
1505825113.4970243
>>> os.path.getsize(cp)
0
random: 随机数模块
random模块介绍
主要用于生成随机数，大部分python人都会用，但是一般人都是使用randint()帮我们生成某个范围的整数，但其实random模块还有很多非常使用的功能供我们使用
模块导入方式： import random
random.random()方法
产生0-1之间的随机浮点数，不需要设置参数
random.randint()方法
这是人们用得最多的方法，生成某个范围的随机整数，可以设置两个参数
random.randrange()方法
此方法可以写三个参数，跟random.randint()是一样的，都是生成整数，但可以加上步长，可以设置1-3个参数
步长：每一次加几，好比循环里面的增量。默认是1。
random.randrange(开始, 结束, 步长)
random.uniform()方法
设置某个范围内的浮点数，可以设置两个参数
random.choice()方法
随机输出choice里面的参数，拥有此方法，就不再需要写遍历了
random.choice()方法
随机输出choice里面的参数，拥有此方法，就不再需要写遍历了
random.shuffe()方法
将list1打乱顺序
下面是random所有的方法
| 方法 | 描述 |
|---|---|
| seed() | 初始化随机数生成器。 |
| getstate() | 返回随机数生成器的当前内部状态。 |
| setstate() | 恢复随机数生成器的内部状态。 |
| getrandbits() | 返回表示随机位的数字。 |
| randrange() | 返回给定范围之间的随机数。 |
| randint() | 返回给定范围之间的随机数。 |
| choice() | 返回给定序列中的随机元素。 |
| choices() | 返回一个列表，其中包含给定序列中的随机选择。 |
| shuffle() | 接受一个序列，并以随机顺序返回此序列。 |
| sample() | 返回序列的给定样本。 |
| random() | 返回 0 与 1 之间的浮点数。 |
| uniform() | 返回两个给定参数之间的随机浮点数。 |
| triangular() | 返回两个给定参数之间的随机浮点数，您还可以设置模式参数以指定其他两个参数之间的中点。 |
| betavariate() | 基于 Beta 分布（用于统计学）返回 0 到 1 之间的随机浮点数。 |
| expovariate() | 基于指数分布（用于统计学），返回 0 到 1 之间的随机浮点数，如果参数为负，则返回 0 到 -1 之间的随机浮点数。 |
| gammavariate() | 基于 Gamma 分布（用于统计学）返回 0 到 1 之间的随机浮点数。 |
| gauss() | 基于高斯分布（用于概率论）返回 0 到 1 之间的随机浮点数。 |
| lognormvariate() | 基于对数正态分布（用于概率论）返回 0 到 1 之间的随机浮点数。 |
| normalvariate() | 基于正态分布（用于概率论）返回 0 到 1 之间的随机浮点数。 |
| vonmisesvariate() | 基于 von Mises 分布（用于定向统计学）返回 0 到 1 之间的随机浮点数。 |
| paretovariate() | 基于 Pareto 分布（用于概率论）返回 0 到 1 之间的随机浮点数。 |
| weibullvariate() | 基于 Weibull 分布（用于统计学）返回 0 到 1 之间的随机浮点数。 |
在数据处理当中，经常会碰到处理时间的问题。比如：在序列预测的过程中，需要通过学习一段时间的数据，去预测未来一段时间的结果。这时候就要用到时间（time、datetime、calendar）模块
表示时间的方法:
在Python中有三种表示时间的方式：
时间戳：是指某个时间与1970年1月1日00:00:00的差值，单位为秒，是一个浮点型数值；
格式化时间：格式化时间由字母和数字表示的时间，比如：’Mon Oct 29 16:04:27 2018’；
元组：将时间的信息放到一个元组中。
其中格式化时间中每个字符的含义如下：
| 符号 | 描述 |
|---|---|
| %a | 简化星期名称 |
| %A | 完整星期名称 |
| %b | 简化月份名称 |
| %B | 完整月份名称 |
| %c | 相应的日期和时间表示 |
| %d | 一个月中的第几天（01 – 31） |
| %H | 一天中的第几个小时（24小时制，00 – 23） |
| %I | 第几个小时（12小时制，01 – 12） |
| %j | 一年中的第几天（001 – 366） |
| %m | 月份（01 – 12） |
| %M | 分钟数（00 – 59） |
| %p | 本地am或者pm的相应符 |
| %S | 秒（01 – 61） |
| %U | 一年中的星期数。（00 – 53星期天是一个星期的开始。）第一个星期天之前的所有天数都放在第0周 |
| %w | 一个星期中的第几天（0 – 6，0是星期天） |
| %W | 和%U基本相同，不同的是%W以星期一为一个星期的开始 |
| %x | 相应日期 |
| %X | 相应时间 |
| %y | 去掉世纪的年份（00 – 99） |
| %Y | 完整的年份 |
| %Z | 时区的名字（如果不存在为空字符） |
| %% | ‘%’字符 |
在元组中会有9项参数，如下表所示：
| 关键字 | 描述 |
|---|---|
| tm_year | 年 |
| tm_mon | 月（1-12） |
| tm_mday | 日（1-31） |
| tm_hour | 时（0-23） |
| tm_min | 分（0-59） |
| tm_sec | 秒（0-61），闰年多两秒 |
| tm_wday | 周一-周日（0-6） |
| tm_yday | 一年中第几天（1-366） |
| tm_isdst | 是否夏令时（1：是；0：不是；-1：未知；默认 -1） |
time.time()
该函数返回当前时间的时间戳，也就是距离1970年1月1日00:00:00的差值。
代码演示：
>>>import time >>>time.time() 1540808367.8872325 >>>import time >>>time.time() 1540808367.8872325
time.localtime()
该函数能将一个时间戳转换成元组的形式，如果没有指定时间戳，默认使用当前时间的时间戳。需要注意的是返回的时间是当地时间。
代码演示：
>>>import time >>>time.localtime(1540808367.8872325) time.struct_time(tm_year=2018, tm_mon=10, tm_mday=29, tm_hour=18, tm_min=19, tm_sec=27, tm_wday=0, tm_yday=302, tm_isdst=0) >>>time.localtime() time.struct_time(tm_year=2018, tm_mon=10, tm_mday=29, tm_hour=18, tm_min=26, tm_sec=10, tm_wday=0, tm_yday=302, tm_isdst=0) >>>import time >>>time.localtime(1540808367.8872325) time.struct_time(tm_year=2018, tm_mon=10, tm_mday=29, tm_hour=18, tm_min=19, tm_sec=27, tm_wday=0, tm_yday=302, tm_isdst=0) >>>time.localtime() time.struct_time(tm_year=2018, tm_mon=10, tm_mday=29, tm_hour=18, tm_min=26, tm_sec=10, tm_wday=0, tm_yday=302, tm_isdst=0)
time.gmtime()
该函数和localtime()的功能一样，只是它返回的时间是格林威治天文时间（UTC），也就是世界标准时间。中国时间为UTC+8。
代码演示：
>>>import time >>>time.gmtime() time.struct_time(tm_year=2018, tm_mon=10, tm_mday=29, tm_hour=10, tm_min=31, tm_sec=58, tm_wday=0, tm_yday=302, tm_isdst=0) >>>import time >>>time.gmtime() time.struct_time(tm_year=2018, tm_mon=10, tm_mday=29, tm_hour=10, tm_min=31, tm_sec=58, tm_wday=0, tm_yday=302, tm_isdst=0)
time.mktime()
该函数将一个元组转换成时间戳。
代码演示：
>>>import time >>>time.mktime(time.localtime()) 1540809214.0 >>>import time >>>time.mktime(time.localtime()) 1540809214.0
time.sleep()
该函数能让程序线程暂停休息，传入几秒，休息几秒。
代码演示：
import time print(time.time()) time.sleep(3) print(time.time()) import time print(time.time()) time.sleep(3) print(time.time())
结果为：
1540809376.7814057 1540809379.7822838 1540809376.7814057 1540809379.7822838 time.asctime()
该函数将一个元组转换成格式化时间。如果没有传入参数，默认传入time.localtime()。
代码演示：
>>>import time >>>time.asctime() 'Mon Oct 29 18:39:10 2018' >>>import time >>>time.asctime() 'Mon Oct 29 18:39:10 2018'
time.ctime()
该函数将一个时间戳转换成格式化时间。如果没有传入参数，默认传入time.time()。
代码演示：
>>>import time >>>time.ctime() 'Mon Oct 29 18:41:04 2018' >>>import time >>>time.ctime() 'Mon Oct 29 18:41:04 2018'
time.strftime()
该函数按照格式化字符把一个元组转换成格式化时间字符串。如果没有传入参数，默认传入time.localtime()。
代码演示：
>>>import time
>>>time.strftime("%Y-%m-%d %X", time.localtime())
'2018-10-29 18:46:14'
>>>import time
>>>time.strftime("%Y-%m-%d %X", time.localtime())
'2018-10-29 18:46:14'
time.strptime()
该函数按照格式化字符把一个格式化时间字符串转成元组。
>>>import time
>>>time.strptime('2018-10-29 18:46:14', '%Y-%m-%d %X')
time.struct_time(tm_year=2018, tm_mon=10, tm_mday=29, tm_hour=18, tm_min=46, tm_sec=14, tm_wday=0, tm_yday=302, tm_isdst=-1)
>>>import time
>>>time.strptime('2018-10-29 18:46:14', '%Y-%m-%d %X')
time.struct_time(tm_year=2018, tm_mon=10, tm_mday=29, tm_hour=18, tm_min=46, tm_sec=14, tm_wday=0, tm_yday=302, tm_isdst=-1)
需要注意的是，当传入的时间中包括周数和天数（%U和%W），该函数才能使用。
re:正则匹配模块re模块是python本地库中匹配字符串的模块，学习re模块的前提必须要学习一些基础的正则表达式，明白正则表达式中的一些概念，你才能更好的掌握这个模块。
常用函数
==注意：==传入的被匹配对象必须是字符串str类型
compile()
re.compile(pattern,flags=0)
pattern：编译时用的表达式字符串。
flags：编译标志位，用于修改正则表达式，如：是否区分大小写，多行匹配等。
findall() 函数
find('正则表达式'，‘待匹配的字符串’) #返回匹配到字符串，并存放在列表中
search() 函数
import re
ret = re.search('abc', 'this is abcABC').group()
print(ret) #结果 : 'abc'
# 函数会在字符串内按规则匹配,当找到第一个匹配结果时就结束查找，然后返回一个包含匹配信息的对象,该对象可以 通过 调用group()方法 得到匹配的字符串,
# 如果没有匹配到字符串，则返回None
obj = re.compile('d{3}') #将正则表达式编译成为一个 正则表达式对象，规则要匹配的是3个数字
ret = obj.search('abc123eeee') #正则表达式对象调用search，参数为待匹配的字符串
print(ret.group()) #结果 ： 123
match() 函数
import re
ret = re.match('this', 'this is abcABC').group()
print(ret) #结果 : 'this'
# 在字符串开始处 就按规则匹配，其它 与search()函数使用方法一样
finditer() 函数
import re
ret = re.finditer('d', 'ds3sy4784a') #finditer返回一个存放匹配结果的迭代器
print(ret) #
print(next(ret).group()) #查看第一个结果 '3'
print(next(ret).group()) #查看第二个结果 '4'
print([i.group() for i in ret]) #查看剩余的匹配结果 ['7', '8', '4']
sub() 和 subn() 函数
import re
ret = re.sub('d', 'H', 'eva3egon4yuan4', 1)#将数字替换成'H'，参数1表示只替换1个
print(ret) #evaHegon4yuan4
ret = re.subn('d', 'H', 'eva3egon4yuan4')
print(ret)
#将数字替换成'H'，返回元组(替换的结果,替换了多少次),即('evaHegonHyuanH', 3)
复制代码
split() 函数
ret = re.split('[ab]', 'abcd') # 先按'a'分割得到''和'bcd',在对''和'bcd'分别按'b'分割
print(ret) # ['', '', 'cd']
string:字符串模块
字符串模块string包含字符串常量和两个模板类Formatter和Template，最常用还是文本序列str。
常用方法
| 常用方法 | 描述 |
|---|---|
| str.capitalize() | 把字符串的首字母大写 |
| str.center(width) | 将原字符串用空格填充成一个长度为width的字符串，原字符串内容居中 |
| str.count(s) | 返回字符串s在str中出现的次数 |
| str.decode(encoding=’UTF-8’,errors=’strict’) | 以指定编码格式解码字符串 |
| str.encode(encoding=’UTF-8’,errors=’strict’) | 以指定编码格式编码字符串 |
| str.endswith(s) | 判断字符串str是否以字符串s结尾 |
| str.find(s) | 返回字符串s在字符串str中的位置索引，没有则返回-1 |
| str.index(s) | 和find()方法一样，但是如果s不存在于str中则会抛出异常 |
| str.isalnum() | 如果str至少有一个字符并且都是字母或数字则返回True,否则返回False |
| str.isalpha() | 如果str至少有一个字符并且都是字母则返回True,否则返回False |
| str.isdigit() | 如果str只包含数字则返回 True 否则返回 False |
| str.islower() | 如果str存在区分大小写的字符，并且都是小写则返回True 否则返回False |
| str.isspace() | 如果str中只包含空格，则返回 True，否则返回 False |
| str.istitle() | 如果str是标题化的(单词首字母大写)则返回True，否则返回False |
| str.isupper() | 如果str存在区分大小写的字符，并且都是大写则返回True 否则返回False |
| str.ljust(width) | 返回一个原字符串左对齐的并使用空格填充至长度width的新字符串 |
| str.lower() | 转换str中所有大写字符为小写 |
| str.lstrip() | 去掉str左边的不可见字符 |
| str.partition(s) | 用s将str切分成三个值 |
| str.replace(a, b) | 将字符串str中的a替换成b |
| str.rfind(s) | 类似于 find()函数，不过是从右边开始查找 |
| str.rindex(s) | 类似于 index()，不过是从右边开始 |
| str.rjust(width) | 返回一个原字符串右对齐的并使用空格填充至长度width的新字符串 |
| str.rpartition(s) | 类似于 partition()函数,不过是从右边开始查找 |
字符串常量
| 常数 | 含义 |
|---|---|
| string.ascii_lowercase | 小写字母’abcdefghijklmnopqrstuvwxyz’ |
| string.ascii_uppercase | 大写的字母’ABCDEFGHIJKLMNOPQRSTUVWXYZ’ |
| string.ascii_letters | ascii_lowercase和ascii_uppercase常量的连接串 |
| string.digits | 数字0到9的字符串:’0123456789’ |
| string.hexdigits | 字符串’0123456789abcdefABCDEF’ |
| string.letters | 字符串’abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ’ |
| string.lowercase | 小写字母的字符串’abcdefghijklmnopqrstuvwxyz’ |
| string.octdigits | 字符串’01234567’ |
| string.punctuation | 所有标点字符 |
| string.printable | 可打印的字符的字符串。包含数字、字母、标点符号和空格 |
| string.uppercase | 大学字母的字符串’ABCDEFGHIJKLMNOPQRSTUVWXYZ’ |
| string.whitespace | 空白字符 ‘tnx0bx0cr ‘ |
字符串模板Template
通过string.Template可以为Python定制字符串的替换标准,下面是具体列子：
>>>from string import Template
>>>s = Template('$who like $what')
>>>print s.substitute(who='i', what='python')
i like python
>>>print s.safe_substitute(who='i') # 缺少key时不会抛错
i like $what
>>>Template('${who}LikePython').substitute(who='I') # 在字符串内时使用{}
'ILikePython'
Template还有更加高级的用法，可以通过继承string.Template, 重写变量delimiter(定界符)和idpattern(替换格式), 定制不同形式的模板。
import string
template_text = '''
Delimiter : $de
Replaced : %with_underscore
Ingored : %notunderscored
'''
d = {'de': 'not replaced',
'with_underscore': 'replaced',
'notunderscored': 'not replaced'}
class MyTemplate(string.Template):
# 重写模板 定界符(delimiter)为"%", 替换模式(idpattern)必须包含下划线(_)
delimiter = '%'
idpattern = '[a-z]+_[a-z]+'
print string.Template(template_text).safe_substitute(d) # 采用原来的Template渲染
print MyTemplate(template_text).safe_substitute(d) # 使用重写后的MyTemplate渲染
输出：
Delimiter : not replaced Replaced : %with_underscore Ingored : %notunderscored Delimiter : $de Replaced : replaced Ingored : %notunderscored
原生的Template只会渲染界定符为$的情况，重写后的MyTemplate会渲染界定符为%且替换格式带有下划线的情况。
常用字符串技巧
反转字符串
>>> s = '1234567890' >>> print s[::-1] 0987654321
关于字符串链接
尽量使用join()链接字符串，因为’+’号连接n个字符串需要申请n-1次内存,使用join()需要申请1次内存。
固定长度分割字符串
>>> import re
>>> s = '1234567890'
>>> re.findall(r'.{1,3}', s) # 已三个长度分割字符串
['123', '456', '789', '0']
使用()括号生成字符串
sql = ('SELECT count() FROM table '
'WHERe id = "10" '
'GROUP BY sex')
print sql
SELECt count() FROM table WHERe id = "10" GROUP BY sex
将print的字符串写到文件
>>> print >> open("somefile.txt", "w+"), "Hello World" # Hello World将写入文件somefile.txt
sys：系统文件模块模块
sys 模块主要负责与 Python 解释器进行交互，该模块提供了一系列用于控制 Python 运行环境的函数和变量。
== sys 模块都包含哪些内容，如下所示：==
>>> import sys >>> dir(sys) ['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames', '_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats', 'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper', 'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace', 'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']time：包含各种提供日期、时间功能的类和函数
模块time包含用于获取当前时间,操作时间和日期.从字符串中读取日期,将日期格式化为字符串的函数.
日期可表示为实数,也可表示为包含9个整数的元组
例如tuple(2018,12,24,12,2,56,-1,-1,-1)
常用函数的使用
from time import *
new_time=mktime((2018,11,5,10,30,0,-1,-1,-1)) #时间元组->秒
>>>new_time
1541385000.0
>>>localtime(new_time) #秒->时间元组
time.struct_time(tm_year=2018, tm_mon=11, tm_mday=5, tm_hour=10, tm_min=30, tm_sec=0, tm_wday=0, tm_yday=309, tm_isdst=0)
>>>asctime(localtime(new_time)) #时间元组->字符串
'Mon Nov 5 10:30:00 2018'
>>>strptime('Mon Nov 5 10:30:00 2018') #字符串->时间元组
time.struct_time(tm_year=2018, tm_mon=11, tm_mday=5, tm_hour=10, tm_min=30, tm_sec=0, tm_wday=0, tm_yday=309, tm_isdst=-1)
>>>time() #当前秒数
1541385068.0643497
>>>asctime(localtime(time())) #当前时间字符串
'Mon Nov 5 10:31:21 2018'
>>>NOW=localtime(time()) #格式化显示当前时间
>>>"{}_{}_{}_{}_{}_{}".format(NOW.tm_year,NOW.tm_mon,NOW.tm_mday,NOW.tm_hour,NOW.tm_min,NOW.tm_sec)
'2018_11_26_10_14_10'
实例:随机返回指定范围内的多个日期
import random
from time import *
from pprint import *
start = mktime((2018, 1, 1, 0, 0, 0, -1, -1, -1))
end = mktime((2018, 12, 31, 23, 59, 59, -1, -1, -1))
random_time = []
for i in range(5):
time_str = asctime(localtime(random.uniform(start, end)))
random_time.append(time_str)
pprint(random_time)
#输出
['Wed Aug 29 01:18:44 2018',
'Sun Sep 16 02:44:16 2018',
'Sun Dec 30 12:53:29 2018',
'Wed May 2 04:00:02 2018',
'Sat Feb 17 03:39:50 2018']
datetime：时间处理模块
datetime模块提供表示和处理日期和时间的一些类.此模块的大部分功能是关于创建和输出日期与信息的各种不同方式.其他的主要功能包括数学运算,如时间增量的比较和计算.
date对象
date对象代表由年,月,日组成的简单日期.
函数使用
from datetime import * new_date = date(2018, 1, 1) >>>new_date #显示日期 datetime.date(2018, 1, 1) >>>new_date.today() #显示今天日期 datetime.date(2018, 11, 5) >>>new_date.ctime() #返回字符串,与datetime.time.ctime()格式相同 'Mon Jan 1 00:00:00 2018' >>>new_date.replace(1999,12) #替换年月日并返回新的日期 datetime.date(1999, 12, 1) >>>new_date.timetuple() #将date转换为time模块中的time.struct_time对象 time.struct_time(tm_year=2018, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=1, tm_isdst=-1) >>>new_date.weekday() #返回一周内的星期 0-6 0 >>>random.uniform(date(2018,1,1),date(2018,12,31)) #随机返回日期 datetime.date(2018, 6, 25)json模块:数据结构转化
应用Json模块实现将json类型的数据转化成python类型的数据，或是将python类型的数据转化成为json类型的数据。
json是python自带的模块，用于json与python数据之间的相互转换。
json数据与python数据类型之间的对应关系：
| JSON | PYTHON |
|---|---|
| object | dict |
| array | list |
| string | str |
| number(int) | int , long |
| number(real) | float |
| true | True |
| false | False |
| null | None |
import json
#1.将json字符串与python数据相互转化
json_str = '''[{"prviceName":"美国"}]'''#json格式中字典的键必须为双引号
# print(type(json_str))
rs = json.loads(json_str)
print(rs)#此时转换成功，其中rs中的键为单引号
json_str1 = json.dumps(rs, ensure_ascii=False)#默认是否使用ascii码，选择false，显示中文
print(json_str1)#此时数据又被转化为了Json类型的数据
#2.将json文件转化为python类型的数据
# with open(r'C:UserssxnDesktopjson_text.txt') as fp:
# python_list = json.load(fp)
# print(python_list)
#python类型的数据以json格式写入文件
with open(r'C:UserssxnDesktopjson_text.txt', 'w') as fp:#构建要写入的文件对象
json.dump(json_str1,fp,ensure_ascii=False)
logging模块:日志处理
logging模块是Python内置的标准模块，主要用于输出运行日志，可以设置输出日志的等级、日志保存路径、日志文件回滚等；相比print，具备如下优点：
一条日志信息对应的是一个事件的发生，而一个事件通常需要包括以下几个内容：
事件发生时间
事件发生位置
事件的严重程度–日志级别
事件内容
上面这些都是一条日志记录中可能包含的字段信息，当然还可以包括一些其他信息，如进程ID、进程名称、线程ID、线程名称等。日志格式就是用来定义一条日志记录中包含那些字段的，且日志格式通常都是可以自定义的。
logging 模块使用
配置logging基本的设置，然后在控制台输出日志:
import logging
logging.basicConfig(level = logging.INFO,format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)
logger.info("Start print log")
logger.debug("Do something")
logger.warning("Something maybe fail.")
logger.info("Finish")
运行时，控制台输出:
2019-07-10 13:25:50,284 - __main__ - INFO - Start print log 2019-07-10 13:25:50,316 - __main__ - WARNING - Something maybe fail. 2019-07-10 13:25:50,316 - __main__ - INFO - Finishrequests模块:接口访问
导入：import requests
Request库方法介绍
| 方法 | 说明 |
|---|---|
| requests.request() | 构造一个请求，支撑一下各方法的基础方法 |
| requests.get() | 获取HTML网页的主要方法，对应于HTTP的GET |
| requests.head() | 获取HTML网页头信息的方法，对应于HTTP的HEAD |
| requests.post() | 向HTML网页提交POST请求的方法，对应于HTTP的POST |
| requests.put() | 向HTML网页提交PUT请求的方法，对应于HTTP的PUT |
| requests.delete() | 向HTML页面提交删除请求，对应于HTTP的DELETE |
request.get()使用
在Pycharm工具中导入requests模块，输入requests.get会自动提示调用该方法的参数信息
requests.get(url,params=None,**kwargs)
url : 拟获取页面的url链接
params : url中的额外参数，字典或字节流格式，可选
**kwargs: 12个控制访问的参数
代码示例：
#requests.get方法
r=requests.get("https://www.baidu.com")
print("状态码：",r.status_code)
#返回信息
状态码： 200
request.post()使用
requests.post(url,data=None,json=None,**kwargs) url : 请求的url链接 data :
字典、字节序列或文件，Request的内容
json : JSON格式的数据，Request的内容
**kwargs: 11个控制访问的参数(除data,json)
代码示例：
import requests
url='https://www.xxx.com:4438/platform/login'
data={"username":"test","password":"123456"}
r=requests.post(url,data=data)
print ("状态码:{},n返回信息:{}，n相应内容编码:{}".format(r.status_code,r.text,r.encoding))
#返回信息：
状态码:200,
返回信息:{"access_token":"5978b697-1505-4681-ae2a-1e145021b3d1","token_type":"bearer","refresh_token":"fa9e4eb0-9a29-48b4-a7ca-c5ed8bd90723","expires_in":85187,"scope":"read write"}，
相应内容编码:UTF-8
requests.request()使用 重点！！！
requests.request(method,url,**kwargs）
method：请求方式，对应get/put/post等七种
状态码： 200：拟获取页面的url链接
**kwargs：控制访问参数，共13个
**kwargs：控制访问参数，为可选项
| params | 字典或字节序列，作为参数增加到url中 |
|---|---|
| data | 字典、字节序列或文件对象，作为Request的内容 |
| json | JSON格式的数据，作为Request的内容 |
| headers | 字典，HTTP定制头 |
| cookies | 字典或CookieJar，Request中的 |
| auth | 元组支持HTTP认证功能 |
| files | 字典类型，传输文件 |
| timeout | 设定超时时间，秒为单位 |
| proxies | 字典类型，设定访问代理服务器，可以增加登录认证 |
| allow_redirects | True/False，默认为True，重定向开关 |
| cert | 本地SSL证书 |
| stream | True/False，默认为True，获取内容立即下载开关 |
| verify | True/False，默认为True，认证SSL证书开关 |
代码示例：
import requests
url='https://www.xxx.com:4438/platform/login'
data={"username":"test","password":"123456"}
r=requests.request("post",url,data=data)
print ("状态码:{},n返回信息:{}，n相应内容编码:{}".format(r.status_code,r.text,r.encoding))
#返回信息：
状态码:200,
返回信息:{"access_token":"5978b697-1505-4681-ae2a-1e145021b3d1","token_type":"bearer","refresh_token":"fa9e4eb0-9a29-48b4-a7ca-c5ed8bd90723","expires_in":85187,"scope":"read write"}，
相应内容编码:UTF-8
Response对象的属性
| 方法 | 说明 |
|---|---|
| r.status_code | HTTP请求的返回状态，200表示连接成功，404表示失败 |
| r.text | HTTP响应内容的字符串形式，即url对应的页面内容 |
| r.encoding | 从HTTP header中猜测的响应内容编码方式 |
| r.apparent_encoding | 从内容中分析出的响应内容编码方式（备选编码方式） |
| r.content | HTTP响应内容的二进制形式 |
代码示例
import requests
class Request():
def __init__(self):
self.session = requests.sessions.session()
def request_method(self,method,url,data=None):
if data is not None and type(data) == str:
data = eval(data)
self.method=method.upper()
if self.method=="GET":
resp=self.session.request(method,url=url,params=data)
return resp
elif self.method=="POST":
resp=self.session.request(method,url=url,data=data)
return resp
else:
print ("请求方式不是get和post!!!")
def close(self):
self.session.close()
if __name__ == '__main__':
url='https://www.xxx.com:4438/platform/login'
data={"username":"test","password":"123456"}
r = requests.request("post", url, data=data)
print("状态码:{},n返回信息:{}，n相应内容编码:{}".format(r.status_code, r.text, r.encoding))
