本章涉及标准库：

1、sys

2、os

3、glob

4、math

5、random

6、platform

7、pikle与cPikle

8、subprocess

9、Queue

10、StringIO

11、logging

12、ConfigParser

13、urllib与urllib2

14、json

15、time

16、datetime

10.1 sys

1）sys.argv

命令行参数。

argv[0] #代表本身名字

argv[1] #第一个参数

argv[2] #第二个参数

argv[3] #第三个参数

argv[N] #第N个参数

argv #参数以空格分隔存储到列表。

看看使用方法：

#!/usr/bin/python
# -*- coding: utf-8 -*-
import sys
print sys.argv[0]
print sys.argv[1]
print sys.argv[2]
print sys.argv[3]
print sys.argv
print len(sys.argv)

# python test.py
test.py
a
b
c
c
[‘test.py‘, ‘a‘, ‘b‘, ‘c‘]
4

值得注意的是，argv既然是一个列表，那么可以通过len()函数获取这个列表的长度从而知道输入的参数数量。可以看到列表把自身文件名也写了进去，所以当我们统计的使用应该-1才是实际的参数数量，因此可以len(sys.argv[1:])获取参数长度。

2）sys.path

模块搜索路径。

>>> sys.path
[‘‘, ‘/usr/local/lib/python2.7/dist-packages/tornado-3.1-py2.7.egg‘, ‘/usr/lib/python2.7‘, ‘/usr/lib/python2.7/plat-x86_64-linux-gnu‘, ‘/usr/lib/python2.7/lib-tk‘, ‘/usr/lib/python2.7/lib-old‘, ‘/usr/lib/python2.7/lib-dynload‘, ‘/usr/local/lib/python2.7/dist-packages‘, ‘/usr/lib/python2.7/dist-packages‘]

输出的是一个列表，里面包含了当前Python解释器所能找到的模块目录。

如果想指定自己的模块目录，可以直接追加：

>>> sys.path.append(‘/opt/scripts‘)
>>> sys.path
[‘‘, ‘/usr/local/lib/python2.7/dist-packages/tornado-3.1-py2.7.egg‘, ‘/usr/lib/python2.7‘, ‘/usr/lib/python2.7/plat-x86_64-linux-gnu‘, ‘/usr/lib/python2.7/lib-tk‘, ‘/usr/lib/python2.7/lib-old‘, ‘/usr/lib/python2.7/lib-dynload‘, ‘/usr/local/lib/python2.7/dist-packages‘, ‘/usr/lib/python2.7/dist-packages‘, ‘/opt/scripts‘]

3）sys.platform

系统平台标识符。

>>> sys.platform

‘linux2‘

Python本身就是跨平台语言，但也不就意味着所有的模块都是在各种平台通用，所以可以使用这个方法判断当前平台，做相应的操作。

4）sys.subversion

在第一章讲过Python解释器有几种版本实现，而默认解释器是CPython，来看看是不是：

>>> sys.subversion
(‘CPython‘, ‘‘, ‘‘)

5）sys.version

查看Python版本：

>>> sys.version
‘2.7.6 (default, Jun 22 2015, 17:58:13) \n[GCC 4.8.2]‘

6）sys.exit()

退出解释器：

#!/usr/bin/python
# -*- coding: utf-8 -*-
import sys
print "Hello world!"
sys.exit()
print "Hello world!"

# python test.py
Hello world!

代码执行到sys.exit()就会终止程序。

7）sys.stdin、sys.stdout和sys.stderr

标准输入、标准输出和错误输出。

标准输入：一般是键盘。stdin对象为解释器提供输入字符流，一般使用raw_input()和input()函数。

例如：让用户输入信息

#!/usr/bin/python
# -*- coding: utf-8 -*-
import sys
name = raw_input("Please input your name: ")
print name

# python test.py
Please input your name: xiaoming
xiaoming

import sys
print "Please enter your name: "
name = sys.stdin.readline()
print name

# python b.py
Please enter your name:
xiaoming
xiaoming

再例如，a.py文件标准输出作为b.py文件标准输入：

# cat a.py
import sys
sys.stdout.write("123456\n")
sys.stdout.flush()
# cat b.py
import sys
print sys.stdin.readlines()

# python a.py | python b.py
[‘123456\n‘]

sys.stdout.write()方法其实就是下面所讲的标准输出，print语句就是调用了这个方法。

标准输出：一般是屏幕。stdout对象接收到print语句产生的输出。

例如：打印一个字符串

#!/usr/bin/python
# -*- coding: utf-8 -*-
import sys
print "Hello world!"

# python test.py
Hello world!

sys.stdout是有缓冲区的，比如：

import sys
import time
for i in range(5):
    print i,
    # sys.stdout.flush()
    time.sleep(1)
# python test.py
0 1 2 3 4

本是每隔一秒输出一个数字，但现在是循环完才会打印所有结果。如果把sys.stdout.flush()去掉，就会没执行到print就会刷新stdout输出，这对实时输出信息的程序有帮助。

错误输出：一般是错误信息。stderr对象接收出错的信息。

例如：引发一个异常

>>> raise Exception, "raise..."
Traceback (most recent call last):File "<stdin>", line 1, in <module>
Exception: raise...

博客地址：http://lizhenliang.blog.51cto.com

QQ群：323779636（Shell/Python运维开发群）

10.2 os

os模块主要对目录或文件操作。

os.path类用于获取文件属性。

10.3 glob

文件查找，支持通配符（*、？、[]）

# 查找目录中所有以.sh为后缀的文件
>>> glob.glob(‘/home/user/*.sh‘)
[‘/home/user/1.sh‘, ‘/home/user/b.sh‘, ‘/home/user/a.sh‘, ‘/home/user/sum.sh‘]

# 查找目录中出现单个字符并以.sh为后缀的文件
>>> glob.glob(‘/home/user/?.sh‘)
[‘/home/user/1.sh‘, ‘/home/user/b.sh‘, ‘/home/user/a.sh‘]

# 查找目录中出现a.sh或b.sh的文件
>>> glob.glob(‘/home/user/[a|b].sh‘)
[‘/home/user/b.sh‘, ‘/home/user/a.sh‘]

10.4 math

数字处理。

下面列出一些自己决定会用到的：

10.5 random

生成随机数。

常用的方法：

10.6 platform

获取操作系统详细信息。

10.7 pickle与cPickle

创建可移植的Python序列化对象，持久化存储到文件。

1）pickle

pickle库有两个常用的方法，dump()、load() 和dumps()、 loads()，下面看看它们的使用方法：

dump()方法是把对象保存到文件中。

格式：dump(obj, file, protocol=None)

load()方法是从文件中读数据，重构为原来的Python对象。

格式：load(file)

示例，将字典序列化到文件：

>>> import pickle
>>> dict = {‘a‘:1, ‘b‘:2, ‘c‘:3}
>>> output = open(‘data.pkl‘, ‘wb‘)  # 二进制模式打开文件
>>> pickle.dump(dict, output)   # 执行完导入操作，当前目录会生成data.pkl文件
>>> output.close()  # 写入数据并关闭

看看pickle格式后的文件：

# cat data.pkl
(dp0
S‘a‘
p1
I1
sS‘c‘
p2
I3
sS‘b‘
p3
I2
s.

读取序列化文件：

>>> f = open(‘data.pkl‘)
>>> data = pickle.load(f)
>>> print data
{‘a‘: 1, ‘c‘: 3, ‘b‘: 2}

用法挺简单的，就是先导入文件，再读取文件。

接下来看看序列化字符串操作：

dumps()返回一个pickle格式化的字符串

格式：dumps(obj, protocol=None)

load()解析pickle字符串为对象

示例：

>>> s = ‘abc‘
>>> pickle.dumps(s) 
"S‘abc‘\np0\n."
>>> pkl = pickle.dumps(s)
>>> pkl
"S‘abc‘\np0\n."
>>> pickle.loads(pkl)
‘abc‘

需要注意的是，py2.x使用的是pickle2.0格式版本，如果用3.0、4.0版本的pickle导入会出错。可以通过pickle.format_version 查看版本。

博客地址：http://lizhenliang.blog.51cto.com

QQ群：323779636（Shell/Python运维开发群）

2）cPickle

cPickle库是C语言实现，对pickle进行了优化，提升了性能，建议在写代码中使用。

cPicke提供了与pickle相同的dump()、load() 和dumps()、 loads()方法，用法一样，不再讲解。

10.8 subprocess

subprocess库会fork一个子进程去执行任务，连接到子进程的标准输入、输出、错误，并获得它们的返回代码。这个模块将取代os.system、os.spawn*、os.popen*、popen2.*和commands.*。

提供了以下常用方法帮助我们执行bash命令的相关操作：

subprocess.call()：运行命令与参数。等待命令完成，返回执行状态码。

>>> import subprocess 
>>> retcode = subprocess.call(["ls", "-l"])
total 504
-rw-r--r-- 1 root root      54 Nov  2 06:15 data.pkl
>>> retcode
0
>>> retcode = subprocess.call(["ls", "a"]) 
ls: cannot access a: No such file or directory
>>> retcode
2

# 也可以这样写
>>> subprocess.call(‘ls -l‘, shell=True)
subprocess.check_call()：运行命令与参数。如果退出状态码非0，引发CalledProcessError异常，包含状态码。
>>> subprocess.check_call("ls a", shell=True)
ls: cannot access a: No such file or directory
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/lib/python2.7/subprocess.py", line 540, in check_call
    raise CalledProcessError(retcode, cmd)
subprocess.CalledProcessError: Command ‘ls a‘ returned non-zero exit status 2

subprocess.Popen()：这个类我们主要来使用的，参数较多。

subprocess.Popen()类又提供了以下些方法：

示例：

>>> p = subprocess.Popen(‘dmesg |grep eth0‘, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
>>> p.communicate() 
......  # 元组形式返回结果
>>> p.pid
57039
>>> p.wait()
0
>>> p.returncode
0

subprocess.PIPE提供了一个缓冲区，将stdout、stderr放到这个缓冲区中，p.communicate()方法读取缓冲区数据。

缓冲区的stdout、stderr是分开的，可以以p.stdout.read()方式获得标准输出、错误输出的内容。

再举个例子，我们以标准输出作为下个Popen任务的标准输入：

>>> p1 = subprocess.Popen(‘ls‘, stdout=subprocess.PIPE, shell=True)

>>> p2 = subprocess.Popen(‘grep data‘, stdin=p1.stdout, stdout=subprocess.PIPE, shell=True)

>>> p1.stdout.close()   # 调用后启动p2，为了获得SIGPIPE

>>> output = p2.communicate()[0]

>>> output

‘data.pkl\n‘

p1的标准输出作为p2的标准输入。这个p2的stdin、stdout也可以是个可读、可写的文件。

10.9 Queue

队列，数据存放在内存中，一般用于交换数据。

用到比较多的是Queue.Queue类，在这里主要了解下这个。

它提供了一些操作队列的方法：

示例：

>>> from Queue import Queue
>>> q = Queue.Queue()
>>> q.put(‘test‘)
>>> q.qsize()
1
>>> q.get()
‘test‘
>>> q.qsize()
0
>>> q.full()
False
>>> q.empty()
True

10.10 StringIO

StringIO库将字符串存储在内存中，像操作文件一样操作。主要提供了一个StringIO类。

可以看到，StringIO方法与文件对象方法大部分都一样，从而也就能方面的操作内存对象。

示例：

>>> f = StringIO()
>>> f.write(‘hello‘)
>>> f.getvalue()
‘hello‘

像操作文件对象一样写入。

用一个字符串初始化StringIO，可以像读文件一样读取：

>>> f = StringIO(‘hello\nworld!‘)
>>> f.read()
‘hello\nworld!‘
>>> s = StringIO(‘hello world!‘)
>>> s.seek(5)            # 指针移动到第五个字符，开始写入      
>>> s.write(‘-‘)               
>>> s.getvalue()
‘hello-world!‘

10.11 logging

记录日志库。

有几个主要的类：

日志级别：

Formatter类可以自定义日志格式，默认时间格式weight%Y-%m-%d %H:%M:%S，有以下这些属性：

示例：

#!/usr/bin/python
# -*- coding: utf-8 -*-
#--------------------------------------------------
# 日志格式
#--------------------------------------------------
# %(asctime)s       年-月-日 时-分-秒,毫秒 2013-04-26 20:10:43,745
# %(filename)s      文件名，不含目录
# %(pathname)s      目录名，完整路径
# %(funcName)s      函数名
# %(levelname)s     级别名
# %(lineno)d        行号
# %(module)s        模块名
# %(message)s       消息体
# %(name)s          日志模块名
# %(process)d       进程id
# %(processName)s   进程名
# %(thread)d        线程id
# %(threadName)s    线程名
import logging
format = logging.Formatter(‘%(asctime)s - %(levelname)s %(filename)s [line:%(lineno)d] %(message)s‘)
# 创建日志记录器
info_logger = logging.getLogger(‘info‘)
# 设置日志级别,小于INFO的日志忽略
info_logger.setLevel(logging.INFO)
# 日志记录到磁盘文件
info_file = logging.FileHandler("info.log")
# info_file.setLevel(logging.INFO)
# 设置日志格式
info_file.setFormatter(format)
info_logger.addHandler(info_file)
error_logger = logging.getLogger(‘error‘)
error_logger.setLevel(logging.ERROR)
error_file = logging.FileHandler("error.log")
error_file.setFormatter(format)
error_logger.addHandler(error_file)
# 输出控制台（stdout）
console = logging.StreamHandler()
console.setLevel(logging.DEBUG)
console.setFormatter(format)
info_logger.addHandler(console)
error_logger.addHandler(console)
if __name__ == "__main__":
    # 写日志
    info_logger.warning("info message.")
    error_logger.error("error message!")

# python test.py
2016-07-02 06:52:25,624 - WARNING test.py [line:49] info message.
2016-07-02 06:52:25,631 - ERROR test.py [line:50] error message!
# cat info.log
2016-07-02 06:52:25,624 - WARNING test.py [line:49] info message.
# cat error.log
2016-07-02 06:52:25,631 - ERROR test.py [line:50] error message!

上面代码实现了简单记录日志功能。分别定义了info和error日志，将等于或高于日志级别的日志写到日志文件中。在小项目开发中把它单独写一个模块，很方面在其他代码中调用。

需要注意的是，在定义多个日志文件时，getLogger(name=None)类的name参数需要指定一个唯一的名字，如果没有指定，日志会返回到根记录器，也就是意味着他们日志都会记录到一起。

10.12 ConfigParser

配置文件解析。

这个库我们主要用到ConfigParser.ConfigParser()类，对ini格式文件增删改查。

ini文件固定结构：有多个部分块组成，每个部分有一个[标识]，并有多个key，每个key对应每个值，以等号"="分隔。值的类型有三种：字符串、整数和布尔值。其中字符串可以不用双引号，布尔值为真用1表示，布尔值为假用0表示。注释以分号";"开头。

举例说明，写一个ini格式文件，对其操作：

# cat config.ini
[host1]   
host = 192.168.1.1
port = 22
user = zhangsan
pass = 123
[host2]
host = 192.168.1.2
port = 22
user = lisi
pass = 456
[host3]
host = 192.168.1.3
port = 22
user = wangwu
pass = 789

1）获取部分中的键值

#!/usr/bin/python
# -*- coding: utf-8 -*-
from ConfigParser import ConfigParser
conf = ConfigParser()
conf.read("config.ini")
section = conf.sections()[0]  # 获取随机的第一个部分标识
options = conf.options(section) # 获取部分中的所有键
key = options[2]
value = conf.get(section, options[2]) # 获取部分中键的值
print key, value
print type(value)

# python test.py
port 22
<type ‘str‘>

这里有意打出来了值的类型，来说明下get()方法获取的值都是字符串，如果有需要，可以getint()获取整数。测试发现，ConfigParser是从下向上读取的文件内容！

2）遍历文件中的每个部分的每个字段

#!/usr/bin/python
# -*- coding: utf-8 -*-
from ConfigParser import ConfigParser
conf = ConfigParser()
conf.read("config.ini")
sections = conf.sections()  # 获取部分名称 [‘host3‘, ‘host2‘, ‘host1‘]
for section in sections:
    options = conf.options(section) # 获取部分名称中的键 [‘user‘, ‘host‘, ‘port‘, ‘pass‘]
    for option in options:
         value = conf.get(section, option) # 获取部分中的键值
         print option + ": " + value  
    print "-------------"
    
# python test.py
user: wangwu
host: 192.168.1.3
port: 22
pass: 789
-------------
user: lisi
host: 192.168.1.2
port: 22
pass: 456
-------------
user: zhangsan
host: 192.168.1.1
port: 22
pass: 123
-------------

通过上面的例子，熟悉了sections()、options()和get()，能任意获取文件的内容了。

也可以使用items()获取部分中的每个选项：

from ConfigParser import ConfigParser
conf = ConfigParser()
conf.read("config.ini")
print conf.items(‘host1‘)

# python test.py
[(‘user‘, ‘zhangsan‘), (‘host‘, ‘192.168.1.1‘), (‘port‘, ‘22‘), (‘pass‘, ‘123‘)]

3）更新或添加选项

from ConfigParser import ConfigParser
conf = ConfigParser()
conf.read("config.ini")
fp = open("config.ini", "w")   # 写模式打开文件，供后面提交写的内容
conf.set("host1", "port", "2222")  # 有这个选项就更新，否则添加
conf.write(fp)  # 写入的操作必须执行这个方法

4）添加一部分，并添加选项

from ConfigParser import ConfigParser
conf = ConfigParser()
conf.read("config.ini")
fp = open("config.ini", "w")
conf.add_section("host4")   # 添加[host4]
conf.set("host4", "host", "192.168.1.4")
conf.set("host4", "port", "22")
conf.set("host4", "user", "zhaoliu")
conf.set("host4", "pass", "123")
conf.write(fp)

5）删除一部分

from ConfigParser import ConfigParser
conf = ConfigParser()
conf.read("config.ini")
fp = open("config.ini", "w")
conf.remove_section(‘host4‘)  # 删除[host4]
conf.remove_option(‘host3‘, ‘pass‘)  # 删除[host3]的pass选项
conf.write(fp)

10.13 urllib与urllib2

打开URL。urllib2是urllib的增强版，新增了一些功能，比如Request()用来修改Header信息。但是urllib2还去掉了一些好用的方法，比如urlencode()编码序列中的两个元素（元组或字典）为URL查询字符串。

一般情况下这两个库结合着用，那我们也结合着了解下。

urllib.urlopen()有几个常用的方法：

示例：

1）请求URL

>>> import urllib, urllib2
>>> response = urllib.urlopen("http://www.baidu.com")   # 获取的网站页面源码
>>> response.readline()
‘<!DOCTYPE html>\n‘
>>> response.getcode()
200
>>> response.geturl()
‘http://www.baidu.com‘

2）伪装chrome浏览器访问

>>> user_agent = "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.157 Safari/537.36"
>>> header = {"User-Agent": user_agent}
>>> request = urllib2.Request("http://www.baidu.com", headers=header) # 也可以通过request.add_header(‘User-Agent‘, ‘Mozilla...‘)方式添加    
>>> response = urllib2.urlopen(request)
>>> response.geturl()
‘https://www.baidu.com/‘
>>> print respose.info()  # 查看服务器返回的header信息
Server: bfe/1.0.8.18
Date: Sat, 12 Nov 2016 06:34:54 GMT
Content-Type: text/html; charset=utf-8
Transfer-Encoding: chunked
Connection: close
Vary: Accept-Encoding
Set-Cookie: BAIDUID=5979A74F742651531360C08F3BE06754:FG=1; expires=Thu, 31-Dec-37 23:55:55 GMT; max-age=2147483647; path=/; domain=.baidu.com
Set-Cookie: BIDUPSID=5979A74F742651531360C08F3BE06754; expires=Thu, 31-Dec-37 23:55:55 GMT; max-age=2147483647; path=/; domain=.baidu.com
Set-Cookie: PSTM=1478932494; expires=Thu, 31-Dec-37 23:55:55 GMT; max-age=2147483647; path=/; domain=.baidu.com
Set-Cookie: BDSVRTM=0; path=/
Set-Cookie: BD_HOME=0; path=/
Set-Cookie: H_PS_PSSID=1426_18240_17945_21118_17001_21454_21408_21394_21377_21525_21192; path=/; domain=.baidu.com
P3P: CP=" OTI DSP COR IVA OUR IND COM "
Cache-Control: private
Cxy_all: baidu+a24af77d41154f5fc0d314a73fd4c48f
Expires: Sat, 12 Nov 2016 06:34:17 GMT
X-Powered-By: HPHP
X-UA-Compatible: IE=Edge,chrome=1
Strict-Transport-Security: max-age=604800
BDPAGETYPE: 1
BDQID: 0xf51e0c970000d938
BDUSERID: 0
Set-Cookie: __bsi=12824513216883597638_00_24_N_N_3_0303_C02F_N_N_N_0; expires=Sat, 12-Nov-16 06:34:59 GMT; domain=www.baidu.com; path=/

这里header只加了一个User-Agent，防止服务器当做爬虫屏蔽了，有时为了对付防盗链也会加Referer，说明是本站过来的请求。还有跟踪用户的cookie。

3）提交用户表单

>>> post_data = {"loginform-username":"test","loginform-password":"123456"}
>>> response = urllib2.urlopen("http://home.51cto.com/index", data=http://www.mamicode.com/(urllib.urlencode(post_data)))>
提交用户名和密码表单登录到51cto网站，键是表单元素的id。其中用到了urlencode()方法，上面讲过是用于转为字典格式为URL接受的编码格式。
例如：
>>> urllib.urlencode(post_data)
‘loginform-password=123456&loginform-username=test‘
4）保存cookie到变量中
#!/usr/bin/python
# -*- coding: utf-8 -*-
import urllib, urllib2
import cookielib
# 实例化CookieJar对象来保存cookie
cookie = cookielib.CookieJar()
# 创建cookie处理器
handler = urllib2.HTTPCookieProcessor(cookie)
# 通过handler构造opener
opener = urllib2.build_opener(handler)
response = opener.open("http://www.baidu.com")
for item in cookie:
    print item.name, item.value
    
# python test.py
BAIDUID EB4BF619C95630EFD619B99C596744B0:FG=1
BIDUPSID EB4BF619C95630EFD619B99C596744B0
H_PS_PSSID 1437_20795_21099_21455_21408_21395_21377_21526_21190_21306
PSTM 1478936429
BDSVRTM 0
BD_HOME 0
urlopen()本身就是一个opener，无法满足对Cookie处理，所有就要新构造一个opener。这里用到了cookielib库，cookielib库是一个可存储cookie的对象。CookieJar类来捕获cookie。
cookie存储在客户端，用来跟踪浏览器用户身份的会话技术。
5）保存cookie到文件
#!/usr/bin/python
# -*- coding: utf-8 -*-
import urllib, urllib2
import cookielib
cookie_file = ‘cookie.txt‘
# 保存cookie到文件
cookie = cookielib.MozillaCookieJar(cookie_file)
# 创建cookie处理器
handler = urllib2.HTTPCookieProcessor(cookie)
# 通过handler构造opener
opener = urllib2.build_opener(handler)
response = opener.open("http://www.baidu.com")
# 保存
cookie.save(ignore_discard=True, ignore_expires=True)  # ignore_discard默认是false，不保存将被丢失的。ignore_expires默认flase，如果cookie存在，则不写入。

# python test.py
# cat cookie.txt

# Netscape HTTP Cookie File
# http://curl.haxx.se/rfc/cookie_spec.html
# This is a generated file!  Do not edit.
.baidu.com    TRUE    /    FALSE    3626420835    BAIDUID    687544519EA906BD0DE5AE02FB25A5B3:FG=1
.baidu.com    TRUE    /    FALSE    3626420835    BIDUPSID    687544519EA906BD0DE5AE02FB25A5B3
.baidu.com    TRUE    /    FALSE        H_PS_PSSID    1420_21450_21097_18560_21455_21408_21395_21377_21526_21192_20927
.baidu.com    TRUE    /    FALSE    3626420835    PSTM    1478937189
www.baidu.com    FALSE    /    FALSE        BDSVRTM    0
www.baidu.com    FALSE    /    FALSE        BD_HOME    0
MozillaCookieJar()这个类用来保存cookie到文件。
6）使用cookie访问URL
#!/usr/bin/python
# -*- coding: utf-8 -*-
import urllib2
import cookielib
# 实例化对象
cookie = cookielib.MozillaCookieJar()
# 从文件中读取cookie
cookie.load("cookie.txt", ignore_discard=True, ignore_expires=True)
# 创建cookie处理器
handler = urllib2.HTTPCookieProcessor(cookie)
# 通过handler构造opener
opener = urllib2.build_opener(handler)
# request = urllib2.Request("http://www.baidu.com")
response = opener.open("http://www.baidu.com")
7）使用代理服务器访问URL
import urllib2
proxy_address = {"http": "http://218.17.252.34:3128"}
handler = urllib2.ProxyHandler(proxy_address)
opener = urllib2.build_opener(handler)
response = opener.open("http://www.baidu.com")
print response.read()
8）URL访问认证
import urllib2
auth = urllib2.HTTPBasicAuthHandler()
# (realm, uri, user, passwd)
auth.add_password(None, ‘http://www.example.com‘,‘user‘,‘123456‘)
opener = urllib2.build_opener(auth)
response = opener.open(‘http://www.example.com/test.html‘)
10.14 json
JSON是一种轻量级数据交换格式，一般API返回的数据大多是JSON、XML，如果返回JSON的话，将获取的数据转换成字典，方面在程序中处理。
json库经常用的有两种方法dumps和loads()：
# 将字典转换为JSON字符串
>>> dict = {‘user‘:[{‘user1‘: 123}, {‘user2‘: 456}]}
>>> type(dict)
<type ‘dict‘>
>>> json_str = json.dumps(dict)
>>> type(json_str)
<type ‘str‘>
# 把JSON字符串转换为字典
>>> d = json.loads(json_str)
>>> type(d)
<type ‘dict‘>
 JSON与Python解码后数据类型：
JSON
Python
object
dict
array
list
string
unicode
number（int）
init，long
number（real）
float
true
Ture
false
False
null
None

10.15 time
这个time库提供了各种操作时间值。
方法
描述
示例
time.asctime([tuple])
将一个时间元组转换成一个可读的24个时间字符串
>>> time.asctime(time.localtime())
‘Sat Nov 12 01:19:00 2016‘
time.ctime(seconds)
字符串类型返回当前时间
>>> time.ctime()
‘Sat Nov 12 01:19:32 2016‘
time.localtime([seconds])
默认将当前时间转换成一个(struct_timetm_year,tm_mon,tm_mday,tm_hour,tm_min,
                              tm_sec,tm_wday,tm_yday,tm_isdst)
>>> time.localtime()
time.struct_time(tm_year=2016, tm_mon=11, tm_mday=12, tm_hour=1, tm_min=19, tm_sec=56, tm_wday=5, tm_yday=317, tm_isdst=0)
time.mktime(tuple)
将一个struct_time转换成时间戳
>>> time.mktime(time.localtime())
1478942416.0
time.sleep(seconds)
延迟执行给定的秒数
>>> time.sleep(1.5)
time.strftime(format[, tuple])
将元组时间转换成指定格式。[tuple]不指定默认以当前时间
>>> time.strftime(‘%Y-%m-%d %H:%M:%S‘)
‘2016-11-12 01:20:54‘
time.time()
返回当前时间时间戳
>>> time.time()
1478942466.45977
strftime():
指令
描述
%a
简化星期名称，如Sat
%A
完整星期名称，如Saturday
%b
简化月份名称，如Nov
%B
完整月份名称，如November
%c
当前时区日期和时间
%d
天
%H
24小时制小时数（0-23）
%I
12小时制小时数（01-12）
%j
365天中第多少天
%m
月
%M
分钟
%p
AM或PM，AM表示上午，PM表示下午
%S
秒
%U
一年中第几个星期
%w
星期几
%W
一年中第几个星期
%x
本地日期，如‘11/12/16‘
%X
本地时间，如‘17:46:20‘
%y
简写年名称，如16
%Y
完整年名称，如2016
%Z
当前时区名称（PST：太平洋标准时间）
%%
代表一个%号本身
10.16 datetime
datetime库提供了以下几个类：
类
描述
datetime.date()
日期，年月日组成
datetime.datetime()
包括日期和时间
datetime.time()
时间，时分秒及微秒组成
datetime.timedelta()
时间间隔
datetime.tzinfo()

datetime.date()类：
方法
描述
描述
date.max
对象所能表示的最大日期
datetime.date(9999, 12, 31)
date.min
对象所能表示的最小日期
datetime.date(1, 1, 1)
date.strftime()
根据datetime自定义时间格式
>>> date.strftime(datetime.now(), ‘%Y-%m-%d %H:%M:%S‘)
‘2016-11-12 07:24:15
date.today()
返回当前系统日期
>>> date.today()
datetime.date(2016, 11, 12)
date.isoformat()
返回ISO 8601格式时间（YYYY-MM-DD）
>>> date.isoformat(date.today())
‘2016-11-12‘
date.fromtimestamp()
根据时间戳返回日期
>>> date.fromtimestamp(time.time())
datetime.date(2016, 11, 12)
date.weekday()
根据日期返回星期几，周一是0，以此类推
>>> date.weekday(date.today())
5
date.isoweekday()
根据日期返回星期几，周一是1，以此类推
>>> date.isoweekday(date.today())
6
date.isocalendar()
根据日期返回日历（年，第几周，星期几）
>>> date.isocalendar(date.today())
(2016, 45, 6)
datetime.datetime()类：
方法
描述
示例
datetime.now()/datetime.today()
获取当前系统时间
>>> datetime.now()
datetime.datetime(2016, 11, 12, 7, 39, 35, 106385)
date.isoformat()
返回ISO 8601格式时间
>>> datetime.isoformat(datetime.now())
‘2016-11-12T07:42:14.250440‘
datetime.date()
返回时间日期对象，年月日
>>> datetime.date(datetime.now())
datetime.date(2016, 11, 12)
datetime.time()
返回时间对象，时分秒
>>> datetime.time(datetime.now())                   
datetime.time(7, 46, 2, 594397) 
datetime.utcnow()
UTC时间，比中国时间快8个小时
>>> datetime.utcnow()
datetime.datetime(2016, 11, 12, 15, 47, 53, 514210)
datetime.time()类：
方法
描述
示例
time.max
所能表示的最大时间
>>> time.max
datetime.time(23, 59, 59, 999999)
time.min
所能表示的最小时间
>>> time.min
datetime.time(0, 0)
time.resolution
时间最小单位，1微妙
>>> time.resolution
datetime.timedelta(0, 0, 1)
datetime.timedelta()类：
# 获取昨天日期
>>> date.today() - timedelta(days=1)         
datetime.date(2016, 11, 11)
>>> date.isoformat(date.today() - timedelta(days=1))
‘2016-11-11‘
# 获取明天日期
>>> date.today() + timedelta(days=1)               
datetime.date(2016, 11, 13)
>>> date.isoformat(date.today() + timedelta(days=1))
‘2016-11-13‘

本文出自 “李振良的技术博客” 博客，请务必保留此出处http://lizhenliang.blog.51cto.com/7876557/1872538
第十章  Python常用标准库使用（必会）