OS模块，sys模块，time模块，random模块，序列化模块
os模块是与操作系统交互的一个接口
OS模块简单的来说是一个Python的系统编程操作模块，可以处理文件和目录这些我们日常手动需要做的操作。
os.sep 更改操作系统中的路径分隔符
+-------------------+-----------------------------------+---------+
| Escape Sequence | Meaning | Notes |
+===================+===================================+=========+
| "\newline" | Backslash and newline ignored | |
+-------------------+-----------------------------------+---------+
| "\\" | Backslash ("\") | |
+-------------------+-----------------------------------+---------+
| "\'" | Single quote ("'") | |
+-------------------+-----------------------------------+---------+
| "\"" | Double quote (""") | |
+-------------------+-----------------------------------+---------+
| "\a" | ASCII Bell (BEL) | |
+-------------------+-----------------------------------+---------+
| "\b" | ASCII Backspace (BS) | |
+-------------------+-----------------------------------+---------+
| "\f" | ASCII Formfeed (FF) | |
+-------------------+-----------------------------------+---------+
| "\n" | ASCII Linefeed (LF) | |
+-------------------+-----------------------------------+---------+
| "\r" | ASCII Carriage Return (CR) | |
+-------------------+-----------------------------------+---------+
| "\t" | ASCII Horizontal Tab (TAB) | |
+-------------------+-----------------------------------+---------+
| "\v" | ASCII Vertical Tab (VT) | |
+-------------------+-----------------------------------+---------+
| "\ooo" | Character with octal value *ooo* | (1,3) |
+-------------------+-----------------------------------+---------+
| "\xhh" | Character with hex value *hh* | (2,3) |
+-------------------+-----------------------------------+---------+
Escape sequences only recognized in string literals are:
+-------------------+-----------------------------------+---------+
| Escape Sequence | Meaning | Notes |
+===================+===================================+=========+
| "\N{name}" | Character named *name* in the | (4) |
| | Unicode database | |
+-------------------+-----------------------------------+---------+
| "\uxxxx" | Character with 16-bit hex value | (5) |
| | *xxxx* | |
+-------------------+-----------------------------------+---------+
| "\Uxxxxxxxx" | Character with 32-bit hex value | (6) |
| | *xxxxxxxx* | |
+-------------------+-----------------------------------+---------+
os.getcwd()获取当前路径，这个在Python代码中比较常用。
os.listdir('dirname')列出当前目录下的所有文件和文件夹
or.remove('filename')方法可以删除指定的文件
os.system()方法用来运行shell命令
os.chdir() 改变当前目录，到指定目录中
os.name #显示当前使用的平台
os.makedirs('dirname/dirname') #可生成多层递归目录
os.rmdir('dirname') 删除单级目录
os.rename('oldname','newname') 重命名文件
os.linesep #给出当前平台使用的行终止符
os.environ #获取系统环境变量
os.path.abspath(path) #显示当前绝对路径
os.path.dirname(path) #返回该路径的父目录
os.path.basename(path) #返回该路径的而最后一个目录或者文件，如果path以/或\结尾，那么就会返回空值
ps.path.isfile(path) #如果path是一个文件，则返回True
os.path.isdir(path) #如果path是一个目录，则返回True
os.stat() #获取文件或者目录信息
os.path.split(path) #将path分割成路径名和文件名。
>>> os.path.split('/root/test')
('/root', 'test')
os.path.join(path,name) #连接目录与文件名或目录 结果为path/name
>>> os.path.join('/root/haha','test')
'/root/haha/test'
sys模块
sys模块是与Python解释器交互的一个接口
sys 模块提供了许多函数和变量来处理 Python 运行时环境的不同部分.
sys.argv 命令行参数list,第一个元素是程序本身路径
在解释器启动后, argv 列表包含了传递给脚本的所有参数, 列表的第一个元素为脚本自身的名称.
['F:/oldboy/20170725/20170808上课笔记/sys模块.py']
sys.exit(n) 退出程序，正常退出时exit(0)
调用sys.exit(n)可以中途退出程序，当参数非0时，会引发一个SystemExit异常，从而可以在主程序中捕获该异常。
# encoding: utf-8
import sys
print 'running...'
try:
sys.exit(1)
except SystemExit:
print 'SystemExit exit 1'
print 'exited'
sys.version 获取Python解释程序的版本信息
sys.maxsize 最大的int值
sys.path 返回模块的搜索路径，初始化时使用pythonpath环境变量的值
path是一个目录列表，供Python从中查找第三方扩展模块。在python启动时，sys.path根据内建规则、PYTHONPATH变量进行初始化。
# 在path的开始位置 插入test
>>> sys.path.insert(0,'test')
也可以用sys.path.append(“mine module path”)来添加自定义的module。
sys.builtin_module_names
sys.builtin_module_names返回一个列表，包含内建模块的名字。如：
>>> import sys
>>> print('sys.builtin_module_names')
sys.platform 返回操作系统平台名称
获取当前执行环境的平台，如win32表示是Windows 32bit操作系统，linux2表示是linux平台；
sys.argv
可以用sys.argv获取当前正在执行的命令行参数的参数列表(list)。
变量 解释
sys.argv[0] 当前程序名
sys.argv[1] 第一个参数
sys.argv[0] 第二个参数
时间模块
1.在Python中，通常有这几种方式来表示时间：1）时间戳 2）格式化的时间字符串 3）元组（struct_time）共九个元素。由于Python的time模块实现主要调用C库，所以各个平台可能有所不同。
2.UTC（Coordinated Universal Time，世界协调时）亦即格林威治天文时间，世界标准时间。在中国为UTC+8。DST（Daylight Saving Time）即夏令时。
3.时间戳（timestamp）的方式：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。返回时间戳方式的函数主要有time()，clock()等。
4.元组（struct_time）方式：struct_time元组共有9个元素，返回struct_time的函数主要有gmtime()，
在Python中，通常有三种方式来表示时间：
时间戳、元祖（struct_time)、格式化的时间字符串
1、时间戳（timestamp):通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。
我们运行 type(time.time()),返回的是float类型
2、格式化的时间字符串（Format String):'1999-12-06'
>>>time.strftime("%Y-%m-%d %X")
>>>time.strftime("%Y-%m-%d %H-%M-%S")
%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00=59）
%S 秒（00-59）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身
3、元祖（struct_time):struct_time元祖共有9个元素（年、月、日、时、分、秒，一年中第几周，一年中第几天等—）
索引（Index） 属性（Attribute） 值（Values）
0 tm_year（年） 比如2011
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
6 tm_wday（weekday） 0 - 6（0表示周日）
7 tm_yday（一年中的第几天） 1 - 366
8 tm_isdst（是否是夏令时） 默认为-1
>>>time.localtime()
>>>time.struct_time(tm_year=2017, tm_mon=8, tm_mday=8, tm_hour=18, tm_min=27, tm_sec=20, tm_wday=1, tm_yday=220, tm_isdst=0
小结：时间戳是计算机能够识别的时间；时间字符串是人能够看懂的时间；元祖则是用来操作时间的
几种格式之间的转换：
时间戳--->>>结构化时间
time.gtime(时间戳） UTC时间，与英国伦敦当地时间一致
time.localtime(时间戳) 当地时间。和UTC相差8个时区
>>>time.gtime(1500000000)
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=2, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)
>>>time.localtime(1500000000)
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=10, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)
结构化时间--->>>时间戳
time.mktime(结构化时间）
>>>time_tuple = time.localtime(1500000000)
>>>time.mktime(time_tuple)
1500000000.0
结构化时间---->>>字符串时间
time.strftime("格式定义","结构化时间") 结构化时间参数若不传，则显示当前时间
>>>time.strftime("%Y-%m-%d %X")
'2017-08-08/08/17 08/08/17'
>>>time.strftime("%Y-%m-%d", time.localtime(1500000000))
'2017-07-14'
字符串时间--->>>结构化时间
time.strptime("时间字符串","字符串对应格式")
>>>time.strptime("2017-03-16","%Y-%m-%d)
time.struct_time(tm_year=2017, tm_mon=3, tm_mday=16, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=75, tm_isdst=-1)
>>>time.strptime("07/24/2017","%m/%d/%Y")
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=205, tm_isdst=-1)
结构化时间---> %a %b %d %H:%M:%S %Y串
time.asctime(结构化时间）如果不传参数，直接返回当前时间的格式化串
>>>time.asctime(time.localtime(1500000000))
'Fri Jul 14 10:40:00 2017'
>>>time.ctime()
'Tue Aug 8 19:02:45 2017'
random模块简介
python标准库中的random函数，可以生成随机浮点数、整数、字符串，甚至帮助你随机选择列表序列中的一个元素，打乱一组数据等
2、random模块的重要函数
1）、random()返回0<=n<1之间的随机实数n
2）、choice(seq)从序列sqp中返回随机的元素
3）、getrandbits(n) 以长整型形式返回n个随机位
4）、shuffle(sep[,random])原始指定seq序列
5）、sample(sep,n)从序列seq中选择n个随机且独立的元素
使用方法：
随机小数
random.random() 随机生成一个随机的浮点数，范围是在0.0~1.0z之间
>>>import random
>>>random.random()
0.8177692432092588
random.uniform()正好弥补了上面函数的不足，它可以设定浮点数的范围，一个是上上限，一个是下限。
>>>random.uniform(1,3) #大于1小于3的小数
1.1024460005098076
随机整数
random.randint()随机生成一个整数int类型，可以指定这个整数的范围，同样有上限和下限值，
>>>random.randint(1,5)
4
>>>random.randrange(100,104,2) #大于等于1且小于3之间的整数 开始，结束，步长
102
random.choice()可以从任何序列，比如list列表中，选择一个随机的元素返回，可以用于字符串、列表、元祖等
>>>random.choice([1,'',[4,5]])
>>> random.choice([1,'',[4,5]])
[4, 5]
>>> random.choice([1,'',[4,5]])
''
>>> random.choice([1,'',[4,5]])
1
random.sample()可以从指定的序列中，随机的截取指定长度的片段，不做原地修改
>>> random.sample([1,'',[4,5]],2) #列表元素任意2个组合
[[4, 5], 1]
random.shuffle() 如果你想将一个序列中的元素，随机打乱的话可以用这个方法
>>>item=[1,3,5,7,9]
>>>random.shuffle(item) #打算次序
[1,7,9,3,5]
序列化模块
什么叫序列化： (在python的中json)
将原本的字典、列表等内容转换成一个字符串的过程就叫做序列化
序列化和反序列化几乎是工程师们每天都要面对的事情，但是要精确掌握这两个概念并不容易：
一方面，它们往往作为框架的一部分出现而湮没在框架之中；
另一方面，它们会以其他更容易理解的概念出现，例如加密、持久化。
然而，序列化和反序列化的选型却是系统设计或重构一个重要的环节，在分布式、大数据量系统设计里面更为显著。
恰当的序列化协议不仅可以提高系统的通用性、强健性、安全性、优化系统性能，而且会让系统更加易于调试、便于扩展
对象序列化的两种用途：
1、把对象的字节序列永久的保存到硬盘上，通常放在一个文件中
2、在网络上传送对象的字节序列
json:
JSON：JavaScript 对象表示法（JavaScript Object Notation）。
JSON 是存储和交换文本信息的语法。类似 XML。
JSON 比 XML 更小、更快，更易解析。
json模块提供了四个功能：dumps 、dump、loads、load
>>> import json
>>> dic = {'k1':'v1','k2':'v2'}
>>> dic
{'k1': 'v1', 'k2': 'v2'}
>>> str_dic = json.dumps(dic) #序列化：将一个字典转换成一个字符串
>>> str_dic
'{"k1": "v1", "k2": "v2"}'
#注意：json转换完的字符串类型的字典中的字符串是有“”表示的
>>> dic2 = json.loads(str_dic) #反序列化：将一个字典格式的字符串转换成一个字典
>>> dic2 #注意：要用json的loads功能处理的字符串类型的字典中的字符串必须由“”表示
{'k1': 'v1', 'k2': 'v2'}
>>> type(dic2)
<class 'dict'>
#也可以处理字典和列表嵌套的数据类型
>>> list_dic = [1,['a','b','c'],{'k1':'v1','k2':'v2'}]
>>> list_dic
[1, ['a', 'b', 'c'], {'k1': 'v1', 'k2': 'v2'}]
>>> str_dic = json.dumps(list_dic)
>>> str_dic
'[1, ["a", "b", "c"], {"k1": "v1", "k2": "v2"}]'
>>> str_dic2 = json.loads(str_dic)
>>> str_dic2
[1, ['a', 'b', 'c'], {'k1': 'v1', 'k2': 'v2'}]
dump和load:
import json
f = open('json_file','w')
dic = {'k1':'v1','k2':'v2'}
json.dump(dic,f) #dump方法接收一个文件句柄，直接将字典转换成json字符串写入文件
f.close()
f = open('json_file')
dic2 = json.load(f) #load方法接收一个文件句柄，直接将文件中的json字符串转换成数据结构返回
f.close()
print(type(dic2),dic2)
一般来讲，JSON解码会根据提供的数据创建dicts或lists。 如果你想要创建其他类型的对象，可以给 json.loads() 传递object_pairs_hook或object_hook参数。 例如，下面是演示如何解码JSON数据并在一个OrderedDict中保留其顺序的例子：
>>> s = '{"name": "ACME", "shares": 50, "price": 490.1}'
>>> from collections import OrderedDict
>>> data = json.loads(s, object_pairs_hook=OrderedDict)
>>> data
OrderedDict([('name', 'ACME'), ('shares', 50), ('price':490.1)
在编码JSON的时候，还有一些选项很有用。 如果你想获得漂亮的格式化字符串后输出，可以使用 json.dumps() 的indent参数。 它会使得输出和pprint()函数效果类似。比如
>>> print(json.dumps(data))
{"price": 542.23, "name": "ACME", "shares": 100}
>>> print(json.dumps(data, indent=4))
{
"price": 542.23,
"name": "ACME",
"shares": 100
}
---------------------------------------------------------------
pickle
json &pickle模块 用于序列化的两个模块
json、用于字符串和python数据类型间进行转换
pickle、用于Python特有的类型和Python的数据类型间进行转换
pickle模块提供了四个功能：dumps、dump(序列化，存）、loads(发序列化，读）、load(不仅可以序列化字典、列表，可以把Python中任意的数据类型序列化）
import pickle
dic = {'k1':'v1','k2':'v2'}
str_dic = pickle.dumps(dic)
print(str_dic) #一串二进制内容
dic2 = pickle.loads(str_dic)
print(dic2) #字典
import time
struct_time = time.localtime(1000000000)
print(struct_time)
f = open('pickle_file','wb')
pickle.dump(struct_time,f)
f.close()
f = open('pickle_file','rb')
struct_time2 = pickle.load(f)
print(struct_time.tm_year)
---------------------------------------------------------------
shelve
shelve 也是python提供给我们的序列化工具，比pickle用起来更简单一些。
shelve只提供给我们一个open方法，是用key来访问的，使用起来和字典类似。
import shelve
f = shelve.open('shelve_file')
f['key'] = {'int':10,'float':9.5,'string':'sample data'} #直接对文件句柄操作，就可以存入数据
f.close()
f1 = shelve.open('shelve_file')
existing = f1['key']#取出数据的时候也只需要直接用key获取即可，但是如果key不存在会报错
f1.close()
print(existing)
这个模块有个限制，它不支出多个应用同一时间往同一个DB进行写操作。所以当我们知道我们的应用如果只进行读操作，我们可以让shelve通过只读方式打开DB
import shelve
f = shelve.open('shelve_file', flag = 'r')
existing = f['key']
f.close()
print(existing)
由于shelve在默认情况下是不会记录持久化对象的任何修改的，所以我们在shelve.open（）时候需要修改默认参数，是否对象的修改不会保存。
import shelve
f1 = shelve.open('shelve_file')
f1['key']['new_value'] = 'this was not here before'
f1.close()
f2 = shelve.open('shelve_file',writeback=True)
print(f2['key']
f2['key']['new_value'] = 'this was not here before'
f2.close()
