python013 -- 常用标准库

最新推荐文章于 2023-10-30 09:58:59 发布

算法工程师000001

最新推荐文章于 2023-10-30 09:58:59 发布

阅读量1.1k

点赞数

分类专栏： learn python

learn python 专栏收录该内容

17 篇文章

订阅专栏

本章涉及标准库：

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

系统平台标识符。

系统	平台标识符
Linux	linux
Windows	win32
Windows/Cygwin	cygwin
Mac OS X	darwin

>>> 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.name	返回操作系统类型	返回值是"posix"代表linux，"nt"代表windows
os.extsep	返回一个"."标识符
os.environ	以字典形式返回系统变量
os.devnull	返回/dev/null标识符
os.linesep	返回一个换行符"\n"	>>> print "a" + os.linesep + "b" a b
os.sep	返回一个路径分隔符正斜杠"/"	>>> "a" + os.sep + "b" 'a/b'
os.listdir(path)	列表形式列出目录
os.getcwd()	获取当前路径	>>> os.getcwd() '/home/user'
os.chdir(path)	改变当前工作目录到指定目录	>>> os.chdir('/opt') >>> os.getcwd() '/opt'
os.mkdir(path [, mode=0777])	创建目录	>>> os.mkdir('/home/user/test')
os.makedirs(path [, mode=0777])	递归创建目录	>>> os.makedirs('/home/user/abc/abc')
os.rmdir(path)	移除空目录	>>> os.makedirs('/home/user/abc/abc')
os.remove(path)	移除文件
os.rename(old, new)	重命名文件或目录
os.stat(path)	获取文件或目录属性
os.chown(path, uid, gid)	改变文件或目录所有者
os.chmod(path, mode)	改变文件访问权限	>>> os.chmod('/home/user/c/a.tar.gz', 0777)
os.symlink(src, dst)	创建软链接
os.unlink(path)	移除软链接	>>> os.unlink('/home/user/ddd')
urandom(n)	返回随机字节，适合加密使用	>>> os.urandom(2) '%\xec'
os.getuid()	返回当前进程UID
os.getlogin()	返回登录用户名
os.getpid()	返回当前进程ID
os.kill(pid, sig)	发送一个信号给进程
os.walk(path)	目录树生成器，返回格式：(dirpath, [dirnames], [filenames])	>>> for root, dir, file in os.walk('/home/user/abc'): ... print root ... print dir ... print file
os.statvfs(path)
os.system(command)	执行shell命令，不能存储结果
popen(command [, mode='r' [, bufsize]])	打开管道来自shell命令，并返回一个文件对象	>>> result = os.popen('ls') >>> result.read()

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

os.path.basename(path)	返回最后一个文件或目录名	>>> os.path.basename('/home/user/a.sh') 'a.sh'
os.path.dirname(path)	返回最后一个文件前面目录	>>> os.path.dirname('/home/user/a.sh') '/home/user'
os.path.abspath(path)	返回一个绝对路径	>>> os.path.abspath('a.sh') '/home/user/a.sh'
os.path.exists(path)	判断路径是否存在，返回布尔值	>>> os.path.exists('/home/user/abc') True
os.path.isdir(path)	判断是否是目录
os.path.isfile(path)	判断是否是文件
os.path.islink(path)	判断是否是链接
os.path.ismount(path)	判断是否挂载
os.path.getatime(filename)	返回文件访问时间戳	>>> os.path.getctime('a.sh') 1475240301.9892483
os.path.getctime(filename)	返回文件变化时间戳
os.path.getmtime(filename)	返回文件修改时间戳
os.path.getsize(filename)	返回文件大小，单位字节
os.path.join(a, *p)	加入两个或两个以上路径，以正斜杠"/"分隔。常用于拼接路径	>>> os.path.join('/home/user','test.py','a.py') '/home/user/test.py/a.py'
os.path.split(	分隔路径名	>>> os.path.split('/home/user/test.py') ('/home/user', 'test.py')
os.path.splitext(	分隔扩展名	>>> os.path.splitext('/home/user/test.py') ('/home/user/test', '.py')

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

数字处理。

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

方法	描述	示例
math.pi	返回圆周率	>>> math.pi 3.141592653589793
math.ceil(x)	返回x浮动的上限	>>> math.ceil(5.2) 6.0
math.floor(x)	返回x浮动的下限	>>> math.floor(5.2) 5.0
math.trunc(x)	将数字截尾取整	>>> math.trunc(5.2) 5
math.fabs(x)	返回x的绝对值	>>> math.fabs(-5.2) 5.2
math.fmod(x,y)	返回x%y(取余)	>>> math.fmod(5,2) 1.0
math.modf(x)	返回x小数和整数	>>> math.modf(5.2) (0.20000000000000018, 5.0)
math.factorial(x)	返回x的阶乘	>>> math.factorial(5) 120
math.pow(x,y)	返回x的y次方	>>> math.pow(2,3) 8.0
math.sprt(x)	返回x的平方根	>>> math.sqrt(5) 2.2360679774997898

10.5 random

生成随机数。

常用的方法：

方法	描述	示例
random.randint(a,b)	返回整数a和b范围内数字	>>> random.randint(1,10) 6
random.random()	返回随机数，它在0和1范围内	>>> random.random() 0.7373251914304791
random.randrange(start, stop[, step])	返回整数范围的随机数，并可以设置只返回跳数	>>> random.randrange(1,10,2) 5
random.sample(array, x)	从数组中返回随机x个元素	>>> random.sample([1,2,3,4,5],2) [2, 4]

10.6 platform

获取操作系统详细信息。

方法	描述	示例
platform.platform()	返回操作系统平台	>>> platform.platform() 'Linux-3.13.0-32-generic-x86_64-with-Ubuntu-14.04-trusty'
platform.uname()	返回操作系统信息	>>> platform.uname() ('Linux', 'ubuntu', '3.13.0-32-generic', '#57-Ubuntu SMP Tue Jul 15 03:51:08 UTC 2014', 'x86_64', 'x86_64')
platform.system()	返回操作系统平台	>>> platform.system() 'Linux'
platform.version()	返回操作系统版本	>>> platform.version() '#57-Ubuntu SMP Tue Jul 15 03:51:08 UTC 2014'
platform.machine()	返回计算机类型	>>> platform.machine() 'x86_64'
platform.processor()	返回计算机处理器类型	>>> platform.processor() 'x86_64'
platform.node()	返回计算机网络名	>>> platform.node() 'ubuntu'
platform.python_version()	返回Python版本号	>>> platform.python_version() '2.7.6'

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()：这个类我们主要来使用的，参数较多。

参数	描述
args	命令，字符串或列表
bufsize	0代表无缓冲，1代表行缓冲，其他正值代表缓冲区大小，负值采用默认系统缓冲（一般是全缓冲）
executable
stdin stdout stderr	默认没有任何重定向，可以指定重定向到管道（PIPE）、文件对象、文件描述符（整数），stderr还可以设置为STDOUT
preexec_fn	钩子函数，在fork和exec之间执行
close_fds
shell	为True，表示用当前默认解释器执行。相当于args前面添加“/bin/sh”“-c或win下"cmd.exe /c "
cwd	指定工作目录
env	设置环境变量
universal_newlines	换行符统一处理成"\n"
startupinfo	在windows下的Win32 API 发送CreateProcess()创建进程
creationflags	在windows下的Win32 API 发送CREATE_NEW_CONSOLE()创建控制台窗口

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

方法	描述
Popen.communicate(input=None)	与子进程交互。读取从stdout和stderr缓冲区内容，阻塞父进程，等待子进程结束
Popen. kill()	杀死子进程，在Posix系统上发送SIGKILL信号
Popen.pid	获取子进程PID
Popen.poll()	如果子进程终止返回状态码
Popen.returncode	返回子进程状态码
Popen.send_signal(signal)	发送信号到子进程
Popen.stderr	如果参数值是PIPE，那么这个属性是一个文件对象，提供子进程错误输出。否则为None
Popen.stdin	如果参数值是PIPE，那么这个属性是一个文件对象，提供子进程输入。否则为None
Popen.stdout	如果参数值是PIPE，那么这个属性是一个文件对象，提供子进程输出。否则为None
Popen.terminate()	终止子进程，在Posix系统上发送SIGTERM信号，在windows下的Win32 API发送TerminateProcess()到子进程
Popen.wait()	等待子进程终止，返回状态码

示例：

>>> 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.Empty	当非阻塞get()或get_nowait()对象队列上为空引发异常
Queue.Full	当非阻塞put()或put_nowait()对象队列是一个满的队列引发异常
Queue.LifoQueue(maxsize=0)	构造函数为后进先出队列。maxsize设置队列最大上限项目数量。小于或等于0代表无限。
Queue.PriorityQueue(maxsize=0)	构造函数为一个优先队列。级别越高越先出。
Queue.Queue(maxsize=0)	构造函数为一个FIFO(先进先出)队列。maxsize设置队列最大上限项目数量。小于或等于0代表无限。
Queue.deque	双端队列。实现快速append()和popleft()，无需锁。
Queue.heapq	堆排序队列。

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

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

方法	描述
Queue.empty()	如果队列为空返回True，否则返回False
Queue.full()	如果队列是满的返回True，否则返回False
Queue.get(block=True, timeout=None)	从队列中删除并返回一个项目。没有指定项目，因为是FIFO队列，如果队列为空会一直阻塞。timeout超时时间
Queue.get_nowait()	从队列中删除并返回一个项目，不阻塞。会抛出异常。
Queue.join()	等待队列为空，再执行别的操作
Queue.put(item, block=True, timeout=None)	写入项目到队列
Queue.put_nowait()	写入项目到队列，不阻塞。与get同理
Queue.qsize()	返回队列大小
Queue.task_done()	表示原队列的任务完成

示例：

>>> from Queue import Queue

>>> q = 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.close()	关闭
StringIO.flush()	刷新缓冲区
StringIO.getvalue()	获取写入的数据
StringIO.isatty()
StringIO.next()	读取下一行，没有数据抛出异常
StringIO.read(n=-1)	默认读取所有内容。n指定读取多少字节
StringIO.readline(length=None)	默认读取下一行。length指定读取多少个字符
StringIO.readlines(sizehint=0)	默认读取所有内容，以列表返回。sizehint指定读取多少字节
StringIO.seek(pos, mode=0)	在文件中移动文件指针，从mode（0代表文件起始位置，默认。1代表当前位置。2代表文件末尾）偏移pos个字节
StringIO.tell()	返回当前在文件中的位置
StringIO.truncate()	截断文件大小
StringIO.write(str)	写字符串到文件
StringIO.writelines(iterable)	写入序列，必须是一个可迭代对象，一般是一个字符串列表

可以看到，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

记录日志库。

有几个主要的类：

logging.Logger	应用程序记录日志的接口
logging.Filter	过滤哪条日志不记录
logging.FileHandler	日志写到磁盘文件
logging.Formatter	定义最终日志格式

日志级别：

级别	数字值	描述
critical	50	危险
error	40	错误
warning	30	警告
info	20	普通信息
debug	10	调试
noset	0	不设置

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

%(name)s	日志的名称
%(levelno)s	数字日志级别
%(levelname)s	文本日志级别
%(pathname)s	调用logging的完整路径（如果可用）
%(filename)s	文件名的路径名
%(module)s	模块名
%(lineno)d	调用logging的源行号
%(funcName)s	函数名
%(created)f	创建时间，返回time.time()值
%(asctime)s	字符串表示创建时间
%(msecs)d	毫秒表示创建时间
%(relativeCreated)d	毫秒为单位表示创建时间，相对于logging模块被加载，通常应用程序启动。
%(thread)d	线程ID（如果可用）
%(threadName)s	线程名字（如果可用）
%(process)d	进程ID（如果可用）
%(message)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表示。注释以分号";"开头。

方法	描述
ConfigParser.add_section(section)	创建一个新的部分配置
ConfigParser.get(section, option, raw=False, vars=None)	获取部分中的选项值，返回字符串
ConfigParser.getboolean(section, option)	获取部分中的选项值，返回布尔值
ConfigParser.getfloat(section, option)	获取部分中的选项值，返回浮点数
ConfigParser.getint(section, option)	获取部分中的选项值，返回整数
ConfigParser.has_option(section, option)	检查部分中是否存在这个选项
ConfigParser.has_section(section)	检查部分是否在配置文件中
ConfigParser.items(section, raw=False, vars=None)	列表元组形式返回部分中的每一个选项
ConfigParser.options(section)	列表形式返回指定部分选项名称
ConfigParser.read(filenames)	读取ini格式的文件
ConfigParser.remove_option( section, option)	移除部分中的选项
ConfigParser.remove_section(section, option)	移除部分
ConfigParser.sections()	列表形式返回所有部分名称
ConfigParser.set(section, option, value)	设置选项值，存在则更新，否则添加
ConfigParser.write(fp)	写一个ini格式的配置文件

举例说明，写一个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(url, data=None, proxies=None)	读取指定URL，创建类文件对象。data是随着URL提交的数据（POST）
urllib/urllib2.quote(s, safe='/')	将字符串中的特殊符号转十六进制表示。如： quote('abc def') -> 'abc%20def'
urllib/urllib2.unquote(s)	与quote相反
urllib.urlencode(query, doseq=0)	将序列中的两个元素（元组或字典）转换为URL查询字符串
urllib.urlretrieve(url, filename=None, reporthook=None, data=None)	将返回结果保存到文件，filename是文件名
urllib2.Request(url, data=None, headers={}, origin_req_host=None, unverifiable=False)	一般访问URL用urllib.urlopen()，如果要修改header信息就会用到这个。 data是随着URL提交的数据，将会把HTTP请求GET改为POST。headers是一个字典，包含提交头的键值对应内容。
urllib2.urlopen(url, data=None, timeout=<object object>)	timeout 超时时间，单位秒
urllib2.build_opener(*handlers)	构造opener
urllib2.install_opener(opener)	把新构造的opener安装到默认的opener中，以后urlopen()会自动调用
urllib2.HTTPCookieProcessor(cookiejar=None)	Cookie处理器
urllib2.HTTPBasicAuthHandler	认证处理器
urllib2.ProxyHandler	代理处理器

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

方法	描述
getcode()	获取HTTP状态码
geturl()	返回真实URL。有可能URL3xx跳转，那么这个将获得跳转后的URL
info()	返回服务器返回的header信息。可以通过它的方法获取相关值
next()	获取下一行，没有数据抛出异常
read(size=-1)	默认读取所有内容。size正整数指定读取多少字节
readline(size=-1)	默认读取下一行。size正整数指定读取多少字节
readlines(sizehint=0)	默认读取所有内容，以列表形式返回。sizehint正整数指定读取多少字节

示例：

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=(urllib.urlencode(post_data)))

>>> response.read() # 登录后网页内容

提交用户名和密码表单登录到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)

>>> json_str = json.dumps(dict)

>>> type(json_str)

# 把JSON字符串转换为字典

>>> d = json.loads(json_str)

>>> type(d)

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'