Python中的一些常用模块1

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()