python|python学习笔记（十二）常用内建模块 python|python

datetime
datetime是python处理日期和时间的标准库
获取当前日期和时间

>>> from datetime import datetime >>> now = datetime.now() # 获取当前datetime >>> print(now) 2015-05-18 16:28:07.198690 >>> print(type(now))

datetime是模块，datetime模块还包含一个datetime类
获取指定日期和时间
要指定某个日期和时间，直接用参数构造一个datetime：

>>> from datetime import datetime >>> dt = datetime(2015, 4, 19, 12, 20) # 用指定日期时间创建datetime >>> print(dt) 2015-04-19 12:20:00

datetime抓换位timestamp
在计算机中，时间实际上是用数字表示的。
把1970.1.1的00:00:00 UTC+00:00时区的时刻称为epoch time，记为0（1970以前的时间timestamp为负数）当前时间就是对于epochtime的秒数，称为timestamp
timestamp的值与时区毫无关系，因为timestamp一旦确定，其UTC时间就确定了，转换到任意时区的时间也是完全确定的。
全球各地的计算机在任意时刻的timestamp都是完全相同的
把一个datetime类型转换为timestamp只需要调用timestamp（）方法

>>> from datetime import datetime >>> dt = datetime(2015, 4, 19, 12, 20) # 用指定日期时间创建datetime >>> dt.timestamp() # 把datetime转换为timestamp 1429417200.0

整数位表示秒
timestamp转换位datetime
要把timestamp转换为datetime，使用datetime提供的fromtimestamp（）方法：

>>> from datetime import datetime >>> t = 1429417200.0 >>> print(datetime.fromtimestamp(t)) 2015-04-19 12:20:00

timestamp是一个浮点数，没有时区的概念。
datetime是有时区的。
timestamp可以直接被转换到UTC标准时区的时间：

>>> from datetime import datetime >>> t = 1429417200.0 >>> print(datetime.fromtimestamp(t)) # 本地时间 2015-04-19 12:20:00 >>> print(datetime.utcfromtimestamp(t)) # UTC时间 2015-04-19 04:20:00

str转换为datetime

>>> from datetime import datetime >>> cday = datetime.strptime('2015-6-1 18:19:59', '%Y-%m-%d %H:%M:%S') >>> print(cday) 2015-06-01 18:19:59

%Y-%m-%d %H:%M:%S规定了日期和时间部分的格式。
转换后的datetime是没有时区信息的
【python|python学习笔记（十二）常用内建模块】datetime转换为str
如果有了datetime对象，要把它格式化位字符串显示给用户，就需要转换为str，转换方法是通过strftime()实现:

>>> from datetime import datetime >>> now = datetime.now() >>> print(now.strftime('%a, %b %d %H:%M')) Mon, May 05 16:28

datetime加减
对日期和时间进行加减实际上就是把datetime往后或往前计算，得到新的datetime。
加减可以直接用±运算符，需要导入timedalta类：

>>> from datetime import datetime, timedelta >>> now = datetime.now() >>> now datetime.datetime(2015, 5, 18, 16, 57, 3, 540997) >>> now + timedelta(hours=10) datetime.datetime(2015, 5, 19, 2, 57, 3, 540997) >>> now - timedelta(days=1) datetime.datetime(2015, 5, 17, 16, 57, 3, 540997) >>> now + timedelta(days=2, hours=12) datetime.datetime(2015, 5, 21, 4, 57, 3, 540997)

本地时间转换为UTC时间
本地时间是指系统设定时区的时间
一个datetime类型有一个时区属性tzinfo，但是默认为None，所以无法区别这个datetime到底是哪个时区，只能强行给它设置一个时区：

>>> from datetime import datetime, timedelta, timezone >>> tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00 >>> now = datetime.now() >>> now datetime.datetime(2015, 5, 18, 17, 2, 10, 871012) >>> dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00 >>> dt datetime.datetime(2015, 5, 18, 17, 2, 10, 871012, tzinfo=datetime.timezone(datetime.timedelta(0, 28800)))

时区转换
通过utcnow()拿到当前的UTC时间，再转换为任意时区的时间：

# 拿到UTC时间，并强制设置时区为UTC+0:00: >>> utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc) >>> print(utc_dt) 2015-05-18 09:05:12.377316+00:00 # astimezone()将转换时区为北京时间: >>> bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8))) >>> print(bj_dt) 2015-05-18 17:05:12.377316+08:00 # astimezone()将转换时区为东京时间: >>> tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9))) >>> print(tokyo_dt) 2015-05-18 18:05:12.377316+09:00 # astimezone()将bj_dt转换时区为东京时间: >>> tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9))) >>> print(tokyo_dt2) 2015-05-18 18:05:12.377316+09:00

时区转换的关键在于拿到一个datetime时，要获知其正确的时区，然后强制设置时区，作为基准时间。
利用带失去的datetime，通过astimezone()方法可以转换到任意时区
collections
collection是一个集合模块，提供了许多有用的集合类
namedtuple
tuple可以表示不变集合
定义一个二维坐标：

>>> from collections import namedtuple >>> Point = namedtuple('Point', ['x', 'y']) >>> p = Point(1, 2) >>> p.x 1 >>> p.y 2

namedtuple是一个函数，用来创建一个自定义的tuple对象，并且规定了tuple元素的个数，并可以用属性而不是索引来引用tuple元素
要用坐标和半径表示一个源，可以用namedtuple定义：

# namedtuple('名称', [属性list]): Circle = namedtuple('Circle', ['x', 'y', 'r'])

deque
使用list存储数据时，按索引访问元素很快，但是插入和删除元素很慢，因为list是线性存储，数据量大的时候，插入和删除效率很低
deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈：

>>> from collections import deque >>> q = deque(['a', 'b', 'c']) >>> q.append('x') >>> q.appendleft('y') >>> q deque(['y', 'a', 'b', 'c', 'x'])

deque除了实现list的append（）和pop（）外，还支持apendleft（）和popleft（）
defaultdict
使用dict时，如果引用的Key不存在，就会抛出keyError。
defaultdict，当key不存在时，返回一个默认值

>>> from collections import defaultdict >>> dd = defaultdict(lambda: 'N/A') >>> dd['key1'] = 'abc' >>> dd['key1'] # key1存在 'abc' >>> dd['key2'] # key2不存在，返回默认值 'N/A'

默认值是调用函数返回的，而函数在创建defaultdict对象时传入
除了在key不存在时返回默认值，其他行为跟dict是完全一样的
ordereddict
使用dict时，key是无序的。在对dict做迭代时，无法确定key的顺序。
如果要保持key的顺序，可以用ordereddict：

>>> from collections import OrderedDict >>> d = dict([('a', 1), ('b', 2), ('c', 3)]) >>> d # dict的Key是无序的 {'a': 1, 'c': 3, 'b': 2} >>> od = OrderedDict([('a', 1), ('b', 2), ('c', 3)]) >>> od # OrderedDict的Key是有序的 OrderedDict([('a', 1), ('b', 2), ('c', 3)])

OrderedDict的key会按照插入的顺序排列，而不是key本身排序：

>>> od = OrderedDict() >>> od['z'] = 1 >>> od['y'] = 2 >>> od['x'] = 3 >>> list(od.keys()) # 按照插入的Key的顺序返回 ['z', 'y', 'x']

OrderedDict可以实现一个FIFO（先进先出）的dict，当容量超出限制时，先删除最早添加的key：

from collections import OrderedDictclass LastUpdatedOrderedDict(OrderedDict):def __init__(self, capacity): super(LastUpdatedOrderedDict, self).__init__() self._capacity = capacitydef __setitem__(self, key, value): containsKey = 1 if key in self else 0 if len(self) - containsKey >= self._capacity: last = self.popitem(last=False) print('remove:', last) if containsKey: del self[key] print('set:', (key, value)) else: print('add:', (key, value)) OrderedDict.__setitem__(self, key, value)

ChainMap
可以把一组dict串起来并组成一个逻辑上的dict
ChainMap本身也是一个dict，但是查找的时候，会按照顺序在内部的dict依次查找
应用程序往往都需要传入参数，参数可以通过命令行传入，可以通过环境变量传入，还可以有默认参数。可以用ChainMap实现参数的优先级查找，即先查命令行参数，如果没有传入，再查环境变量，如果没有就是用默认参数

from collections import ChainMap import os, argparse# 构造缺省参数: defaults = { 'color': 'red', 'user': 'guest' }# 构造命令行参数: parser = argparse.ArgumentParser() parser.add_argument('-u', '--user') parser.add_argument('-c', '--color') namespace = parser.parse_args() command_line_args = { k: v for k, v in vars(namespace).items() if v }# 组合成ChainMap: combined = ChainMap(command_line_args, os.environ, defaults)# 打印参数: print('color=%s' % combined['color']) print('user=%s' % combined['user'])

输出：

#没有任何参数时 $ python3 use_chainmap.py color=red user=guest #传入命令行参数时，优先使用命令行参数 $ python3 use_chainmap.py -u bob color=red user=bob #同时传入命令行参数和环境变量，命令行参数的优先级较高 $ user=admin color=green python3 use_chainmap.py -u bob color=green user=bob

Counter
Counter是一个简单的计数器，

>>> from collections import Counter >>> c = Counter() >>> for ch in 'programming': ...c[ch] = c[ch] + 1 ... >>> c Counter({'g': 2, 'm': 2, 'r': 2, 'a': 1, 'i': 1, 'o': 1, 'n': 1, 'p': 1}) >>> c.update('hello') # 也可以一次性update >>> c Counter({'r': 2, 'o': 2, 'g': 2, 'm': 2, 'l': 2, 'p': 1, 'a': 1, 'i': 1, 'n': 1, 'h': 1, 'e': 1})

Counter实际上也是dict的一个子类
base64
base64是一种用64个字符来表示任意二进制数据的方法
base64编码会把3字节的二进制数据编码为4字节的文本数据，长度增加33%，编码后的文本数据可以在邮件正文，网页等直接显示。
base64用\x00字节在末尾补足后，再在编码的末尾加上一个或两个=号，表示补了多少字节，解码的时候会自动去掉。

>>> import base64 >>> base64.b64encode(b'binary\x00string') b'YmluYXJ5AHN0cmluZw==' >>> base64.b64decode(b'YmluYXJ5AHN0cmluZw==') b'binary\x00string'

由于标准的base64编码后可能出现字符+和/，在url中就不能直接作为参数，所有又有一种“urlsafe”的base64编码，其实就是把字符+和/分别编程-和_

>>> base64.b64encode(b'i\xb7\x1d\xfb\xef\xff') b'abcd++//' >>> base64.urlsafe_b64encode(b'i\xb7\x1d\xfb\xef\xff') b'abcd--__' >>> base64.urlsafe_b64decode('abcd--__') b'i\xb7\x1d\xfb\xef\xff'

base64是一种任意二进制到文本字符串的编码方法，常用于在URL，cookie，网页传输少量二进制数据。
struct
python没有专门处理字节的数据类型。
b’str’可以表示字节，所以字节数组=二进制str
要把一个32位无符号整数变成字节，就是4个长度的bytes：

>>> n = 10240099 >>> b1 = (n & 0xff000000) >> 24 >>> b2 = (n & 0xff0000) >> 16 >>> b3 = (n & 0xff00) >> 8 >>> b4 = n & 0xff >>> bs = bytes([b1, b2, b3, b4]) >>> bs b'\x00\x9c@c'

struct模块解决bytes和其他二进制数据类型的转换
struct的pack函数把任意数据类型变成bytes：

>>> import struct >>> struct.pack('>I', 10240099) b'\x00\x9c@c'

pack的第一个参数是处理指令，’>I’的意思是：>表示字节顺序是big-endian，也就是网络序，I表示4字节无符号整数。
后面的参数个数要和处理指令一致。
unpack把bytes变成相应的数据类型：

>>> struct.unpack('>IH', b'\xf0\xf0\xf0\xf0\x80\x80') (4042322160, 32896)

根据>IH的说明，后面的bytes依次变为I：4字节无符号整数和H：2字节无符号整数
所以，尽管python不适合编写底层操作字节流的代码，但在对性能要求不高的地方，利用struct就方便多了。
windows的位图文件（.bmp)是一种非常简单的文件格式，用struct分析
找一个bmp文件，读入前30个字节来分析
bmp格式采用小端方式存储数据，文件头的结构按顺序：
两个字节，‘BM’表示windows位图，‘BA’表示os/2位图，一个4字节整数表示位图大小；一个4字节整数表示保留位，始终为0；一个4字节整数表示实际图像的偏移量；一个4字节整数表示hesder的字节数；一个4字节整数表示图像宽度；一个4字节整数表示图像高度；一个2字节整数始终为1；一个2字节整数表示颜色数。
组合起来用unpack读取：

>>> struct.unpack('



 b’B’,b’M’说明是windows位图，位图大小是640x360

 hashlib
 hashlib提供常见的摘要算法
 摘要算法：哈希算法，散列算法。通过一个函数，把任意长度的数据转换为一个长度固定的数据串（通常用16进制的字符串表示）
 通过摘要函数f（）对任意长度的数据data计算出固定长度的摘要digest，目的是为了发现原始数据是否被人篡改过
 是一个单向函数

 以算法MD5为例：

 
import hashlibmd5 = hashlib.md5()
md5.update('how to use md5 in python hashlib?'.encode('utf-8'))
print(md5.hexdigest())计算结果：
d26a53750bc40b38b65a520292f69306


 如果数据量很大，可以分块多次调用update()：

 
import hashlibmd5 = hashlib.md5()
md5.update('how to use md5 in '.encode('utf-8'))
md5.update('python hashlib?'.encode('utf-8'))
print(md5.hexdigest())


 计算结果一样

 md5是最常见的摘要算法，速度很快，生成结果是固定的128bit字节，通常用一个32位的16进制字符串表示。

 另一种常见的摘要算法是sha1，调用sha1和调用md5完全类似

 
import hashlibsha1 = hashlib.sha1()
sha1.update('how to use sha1 in '.encode('utf-8'))
sha1.update('python hashlib?'.encode('utf-8'))
print(sha1.hexdigest())


 sha1的结果是160bit字节，通常用一个40位的16进制字符串表示。
 比sha1更安全的算法是sha256和sha512，但越安全的算法不仅越慢，摘要长度更长

 摘要算法应用
 任何允许用户登录的网站都会存储用户登录的用户名和口令，将这些内容存储到数据库表中
 保存口令的方式不是存储用户的铭文口令，而是存储用户口令的摘要，比如md5
 当用户登录时，首先计算用户输入的明文口令的md5，然后和数据库存储的md5对比。

 由于常用口令的md5值很容易被计算出来，所以，要确保存储的用户口令不是已经被计算出来的常用口令的md5，这一方法通过对原始口令加一个复杂字符串来实现，俗称‘加盐’：

 
def calc_md5(password):
return get_md5(password + 'the-Salt')


 hmac
 python内置的hmac模块实现了标准的hmac算法，利用一个key对message计算‘杂凑后的hash，使用hamc算法比标准的hash算法更安全。

 intertools
 itertools提供了非常有用的用于操作迭代对象的函数
 ’无限‘迭代器：

 
>>> import itertools
>>> natuals = itertools.count(1)
>>> for n in natuals:
...print(n)
...
1
2
3
...


 count（）会创建一个无限的迭代器
 cycle（）会把传入的一个序列无限重复下去：

 
>>> import itertools
>>> cs = itertools.cycle('ABC') # 注意字符串也是序列的一种
>>> for c in cs:
...print(c)
...
'A'
'B'
'C'
'A'
'B'
'C'
...


 repeat（）负责把一个元素无限重复下去，如果提供第二个参数就可以限定重复次数：

 
>>> ns = itertools.repeat('A', 3)
>>> for n in ns:
...print(n)
...
A
A
A


 无限序列只有在for迭代时才会无限的迭代下去，如果只是创建了一个迭代对象，她不会事先把无限个元素生成出来，事实上也不可能在内存中创建无限多个元素

 无限序列可以无限迭代下去，但是通常会通过takewhile()等函数根据条件判断来截取出一个有限的序列：

 
>>> natuals = itertools.count(1)
>>> ns = itertools.takewhile(lambda x: x <= 10, natuals)
>>> list(ns)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]


 chain（）可以把一组迭代对象串联起来，形成一个更大的迭代器

 
>>> for c in itertools.chain('ABC', 'XYZ'):
...print(c)
# 迭代效果：'A' 'B' 'C' 'X' 'Y' 'Z'


 groupby（）把迭代器中相邻的重复元素挑出来放在一起

 
>>> for key, group in itertools.groupby('AAABBBCCAAA'):
...print(key, list(group))
...
A ['A', 'A', 'A']
B ['B', 'B', 'B']
C ['C', 'C']
A ['A', 'A', 'A']


 挑选规则是通过函数完成的，只要作用于函数的两个元素返回值相等，这两个元素就被认为是在一组的，而函数返回值作为组的key。
 忽略大小写：

 
>>> for key, group in itertools.groupby('AaaBBbcCAAa', lambda c: c.upper()):
...print(key, list(group))
...
A ['A', 'a', 'a']
B ['B', 'B', 'b']
C ['c', 'C']
A ['A', 'A', 'a']


 contextlib
 在python中，读写文件这样的资源必须在使用完毕后正确关闭
 正确关闭文件资源的一个方法是使用try…finally：

 
try:
f = open('/path/to/file', 'r')
f.read()
finally:
if f:
f.close()


 with语句也可以关闭：

 
with open('/path/to/file', 'r') as f:
f.read()


 并不是只要open()函数返回的fp对象才能使用with语句。
 任何对象，只要正确实现了上下文管理，就可以用于with语句

 实现上下文管理是通过__enter__ __exit__这两个方法实现的：

 
class Query(object):def __init__(self, name):
self.name = namedef __enter__(self):
print('Begin')
return selfdef __exit__(self, exc_type, exc_value, traceback):
if exc_type:
print('Error')
else:
print('End')def query(self):
print('Query info about %s...' % self.name)


 可以把自己写的资源对象用于with语句：

 
with Query('Bob') as q:
q.query()


 @contextmanager

 
from contextlib import contextmanagerclass Query(object):def __init__(self, name):
self.name = namedef query(self):
print('Query info about %s...' % self.name)@contextmanager
def create_query(name):
print('Begin')
q = Query(name)
yield q
print('End')


 @contextmanager这个decorator接受一个generator，用yield语句把with…as var把变量输出出去，然后，with语句就可以正常的工作

 
with create_query('Bob') as q:
q.query()


 希望在某段代码执行前后自动执行特定代码：

 
@contextmanager
def tag(name):
print("<%s>" % name)
yield
print("" % name)with tag("h1"):
print("hello")
print("world")执行结果hello
world


 代码的执行顺序：
 1 with语句首先执行yield之前的语句
 2 yield调用会执行with语句内部的所有语句
 3 最后执行yield之后的语句

 @contextmanager通过编写generator来简化上下文管理

 @closing
 如果一个对象没有实现上下文，就不能用于with语句。
 可以用closing（）来把该对象变为上下文对象。
 用with语句使用urlopen（）：

 
from contextlib import closing
from urllib.request import urlopenwith closing(urlopen('https://www.python.org')) as page:
for line in page:
print(line)


 closing也是一个经过@contextmanager装饰的generator

 
@contextmanager
def closing(thing):
try:
yield thing
finally:
thing.close()


 作用就是把任意对象变为上下文对象，并支持with语句

 urllib
 urllib提供了一i系列用于操作URL的功能

 Get
 urllib的request模块可以非常方便的抓取URL内容，就是发送一个get请求到指定的页面，然后返回http的响应：
 对豆瓣的一个url进行抓取，并返回相应：

 
from urllib import requestwith request.urlopen('https://api.douban.com/v2/book/2129650') as f:
data = https://www.it610.com/article/f.read()
print('Status:', f.status, f.reason)
for k, v in f.getheaders():
print('%s: %s' % (k, v))
print('Data:', data.decode('utf-8'))


 可以看到http响应的头和json数据：

 
Status: 200 OK
Server: nginx
Date: Tue, 26 May 2015 10:02:27 GMT
Content-Type: application/json;
 charset=utf-8
Content-Length: 2049
Connection: close
Expires: Sun, 1 Jan 2006 01:00:00 GMT
Pragma: no-cache
Cache-Control: must-revalidate, no-cache, private
X-DAE-Node: pidl1
Data: {"rating":{"max":10,"numRaters":16,"average":"7.4","min":0},"subtitle":"","author":["廖雪峰编著"],"pubdate":"2007-6",...}


 如果要模拟浏览器发送get请求，就需要request对象，通过往request对象添加http头，就可以把请求伪装成浏览器。
 模拟iPhone6请求豆瓣首页：

 
from urllib import requestreq = request.Request('http://www.douban.com/')
req.add_header('User-Agent', 'Mozilla/6.0 (iPhone;
 CPU iPhone OS 8_0 like Mac OS X) AppleWebKit/536.26 (KHTML, like Gecko) Version/8.0 Mobile/10A5376e Safari/8536.25')
with request.urlopen(req) as f:
print('Status:', f.status, f.reason)
for k, v in f.getheaders():
print('%s: %s' % (k, v))
print('Data:', f.read().decode('utf-8'))


 豆瓣会返回适合iPhone的移动版网页：

 
...



...


 Post
 如果要以post发送一个请求，只需要把参数data以bytes形式传入
 模拟一个微博登录，先读取登录邮箱和口令，然后按照weibo.cn的登录页格式以username=xxx&password=xxx编码传入：

 
from urllib import request, parseprint('Login to weibo.cn...')
email = input('Email: ')
passwd = input('Password: ')
login_data = https://www.it610.com/article/parse.urlencode([
('username', email),
('password', passwd),
('entry', 'mweibo'),
('client_id', ''),
('savestate', '1'),
('ec', ''),
('pagerefer', 'https://passport.weibo.cn/signin/welcome?entry=mweibo&r=http%3A%2F%2Fm.weibo.cn%2F')
])req = request.Request('https://passport.weibo.cn/sso/login')
req.add_header('Origin', 'https://passport.weibo.cn')
req.add_header('User-Agent', 'Mozilla/6.0 (iPhone;
 CPU iPhone OS 8_0 like Mac OS X) AppleWebKit/536.26 (KHTML, like Gecko) Version/8.0 Mobile/10A5376e Safari/8536.25')
req.add_header('Referer', 'https://passport.weibo.cn/signin/login?entry=mweibo&res=wel&wm=3349&r=http%3A%2F%2Fm.weibo.cn%2F')with request.urlopen(req, data=https://www.it610.com/article/login_data.encode('utf-8')) as f:
print('Status:', f.status, f.reason)
for k, v in f.getheaders():
print('%s: %s' % (k, v))
print('Data:', f.read().decode('utf-8'))


 登录成功

 
Status: 200 OK
Server: nginx/1.2.0
...
Set-Cookie: SSOLoginState=1432620126;
 path=/;
 domain=weibo.cn
...
Data: {"retcode":20000000,"msg":"","data":{...,"uid":"1658384301"}}


 登录失败

 
...
Data: {"retcode":50011015,"msg":"\u7528\u6237\u540d\u6216\u5bc6\u7801\u9519\u8bef","data":{"username":"example@python.org","errline":536}}


 Handler
 更复杂的控制，通过Proxy去访问网页，需要利用ProxyHandler来处理：

 
proxy_handler = urllib.request.ProxyHandler({'http': 'http://www.example.com:3128/'})
proxy_auth_handler = urllib.request.ProxyBasicAuthHandler()
proxy_auth_handler.add_password('realm', 'host', 'username', 'password')
opener = urllib.request.build_opener(proxy_handler, proxy_auth_handler)
with opener.open('http://www.example.com/login.html') as f:
pass


 urllib提供的功能就是利用程序去执行各种http请求。
 如果要模拟浏览器完成特定功能，需要把请求伪装成浏览器。
 伪装的方法是先监控浏览器发出的请求，再根据浏览器的请求头来伪装
 User-Agent头就是用来标识浏览器的。

 XML
 XML比JSON复杂

 dom vs sax
 操作XML的两种方法：dom和sax
 dom会把整个xml入内存，解析为树，因为占用内存打，解析慢。
 优点是可以任意遍历树的节点
 sax是流模式，边读边解析，占用内存小，解析快，缺点是需要自己处理事件
 正常情况下优先考虑sax

 python中使用sax解析xml非常简洁，通常关心的事件是start_element,end_element,char_data，准备好这三个函数，然后就可以解析xml了
 当sax解析器读到一个节点时：

 
python


 会产生三个事件：
 1 start_element事件，在读取时
 2 char_data事件，在读取python时
 3 end_element事件，在读取'时

 
from xml.parsers.expat import ParserCreateclass DefaultSaxHandler(object):
def start_element(self, name, attrs):
print('sax:start_element: %s, attrs: %s' % (name, str(attrs)))def end_element(self, name):
print('sax:end_element: %s' % name)def char_data(self, text):
print('sax:char_data: %s' % text)xml = r'''

Python
Ruby

'''handler = DefaultSaxHandler()
parser = ParserCreate()
parser.StartElementHandler = handler.start_element
parser.EndElementHandler = handler.end_element
parser.CharacterDataHandler = handler.char_data
parser.Parse(xml)


 读取一大段字符串时，CharacterDataHandler可能多次被调用，所以需要自己保存起来，在EndElementHandler里面再合并

 生成XML最简单有效的方法是拼接字符：

 
L = []
L.append(r'')
L.append(r'')
L.append(encode('some & data'))
L.append(r'')
return ''.join(L)


 （习题没做）

 HTMLParser
 如果要编写一个搜索引擎，第一步是用爬虫把目标网站的的页面抓下来，第二步就是解析该HTML页面，看看里面的内容到底是新闻图片还是视频

 解析HTML
 html实质上是xml的子集

 使用HTMLParser解析html

 
from html.parser import HTMLParser
from html.entities import name2codepointclass MyHTMLParser(HTMLParser):def handle_starttag(self, tag, attrs):
print('<%s>' % tag)def handle_endtag(self, tag):
print('' % tag)def handle_startendtag(self, tag, attrs):
print('<%s/>' % tag)def handle_data(self, data):
print(data)def handle_comment(self, data):
print('')def handle_entityref(self, name):
print('&%s;
' % name)def handle_charref(self, name):
print('&#%s;
' % name)parser = MyHTMLParser()
parser.feed('''Some html HTML 
tutorial...
END

''')


 feed（）方法可以多次调用，也就是不一定一次把整个html字符串都塞进去，可以一部分一部分塞进去
 特殊字符有两种，一种是英文表示的 ；一种是数字表示的Ӓ，这两种字符都可以通过Parser解析出来

 （习题没做）


		  	

    
    




    
    
    


推荐阅读

           
                  
              
                  椰子油的生活小妙用 椰子油有什么用途和功效 
                
                   
                
              
            

                  
              
                  庆东锅炉故障代码是什么如何解决 
                
                   
                
              
            

                  
              
                  教学教务管理人员是干什么的 
                
                   
                
              
            

                  
              
                  联想yoga2 
                
                   
                
              
            

                  
              
                  如何选择抗体稀释液？ 抗体稀释液 
                
                   
                
              
            

                  
              
                  下载导航地图，导航地图下载 
                
                   
                
              
            

                  
              
                  流媒体后视镜可以当行车记录仪吗 行车记录仪有必要买流媒体吗 
                
                   
                
              
            

                  
              
                  炒苔菜用不用焯水，苔菜用不用焯水再炒 
                
                   
                
              
            

                  
              
                  昆明工业职业技术学院怎么样 
                
                   
                
              
            

                  
              
                  （152）感赏女儿|（152）感赏女儿 2020-12-4 
                
                   
                
              
            

                  
              
                  桃子核发霉外面是好的还能吃吗 
                
                   
                
              
            

                  
              
                  离散傅立叶分析,origin怎么进行傅立叶分析 
                
                   
                
              
            

                  
              
                  次密接触者的一般接触者需要隔离吗 
                
                   
                
              
            

                  
              
                  海带炖土豆的做法 海带炖土豆的做法窍门 
                
                   
                
              
            

                  
              
                  大概的近义词 大概的近义词是什么 标准答案 
                
                   
                
              
            

                  
              
                  合金筷子是塑料还是金属 合金筷子是什么材质 
                
                   
                
              
            

                  
              
                  真我与假我 
                
                   
                
              
            

                  
              
                  钢材包括哪些 钢材怎么分类 
                
                   
                
              
            

                  
              
                  heos,黑色素瘤 
                
                   
                
              
            

                  
              
                  【家事】节如流水 
                
                   
                
              
            

          

Python学习|Python学习笔记 
 软件测试|老大说要自动化测试，我是怎么做的可以看看 
 java|2022年支付宝集五福｜看这里100%扫敬业福 
 【Python】系列|【Python】面试官:元组列表都分不清，回去等通知pa 
 Python|乱世买黄金（用python分析一下最近的股票市场） 
 尚硅谷|Python爬虫 urllib -- 爬虫的相关概念介绍、urllib库的基本使用、urllib（1个类型和6个方法） 
 python|学了这么久的Python，到底是什么水平（用这两个项目就能得到检验） 
 人工智能|名校硕士苦攻5年AI无论文痛苦吐槽，导师放养怎么办（） 
 深度学习|在Android上部署TF目标检测模型