1、datetime
datetime
是Python处理日期和时间的标准库。
datetime
表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。
如果要存储datetime
,最佳方法是将其转换为timestamp
再存储,因为timestamp
的值与时区完全无关。
获取当前日期和时间
>>> from datetime import datetime
>>> now = datetime.now()
>>> print(now)
2023-07-08 21:03:44.152158
>>> print(type(now))
<class 'datetime.datetime'>
注意到datetime
是模块,datetime
模块还包含一个datetime
类,通过from datetime import datetime
导入的才是datetime
这个类。
如果仅导入import datetime
,则必须引用全名datetime.datetime
。
datetime.now()
返回当前日期和时间,其类型是datetime
。
获取指定日期和时间
要指定某个日期和时间,我们直接用参数构造一个datetime
:
>>> from datetime import datetime
>>> dt = datetime(2024, 5, 7, 12, 24) # 用指定日期和时间创建datetime
>>> print(dt)
2024-05-07 12:24:00
datetime转换为timestamp
在计算机中,时间实际上是用数字表示的。我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time
,记为0
(1970年以前的时间timestamp
为负数),当前时间就是相对于epoch time
的秒数,称为timestamp
。
你可以认为:
timestamp = 0 = 1970-1-1 00:00:00 UTC+0:00
对应的北京时间是:
timestamp = 0 = 1970-1-1 08:00:00 UTC+8:00
可见timestamp
的值与时区毫无关系,因为timestamp
一旦确定,其UTC时间就确定了,转换到任意时区的时间也是完全确定的,这就是为什么计算机存储的当前时间是以timestamp
表示的,因为全球各地的计算机在任意时刻的timestamp
都是完全相同的(假定时间已校准)。
把一个datetime
类型转换为timestamp
只需要简单调用timestamp()
方法:
>>> from datetime import datetime
>>> >>> dt = datetime(2024, 5, 7, 12, 24) # 用指定日期时间创建datetime
>>> dt.timestamp() # 把datetime转换为timestamp
1715055840.0
注意Python的timestamp
是一个浮点数,整数位表示秒。
某些编程语言(如Java和JavaScript)的timestamp
使用整数表示毫秒数,这种情况下只需要把timestamp
除以1000就得到Python的浮点表示方法。
timestamp转换为datetime
要把timestamp
转换为datetime
,使用datetime
提供的fromtimestamp()
方法:
>>> from datetime import datetime
>>> t = 1715055840.0
>>> print(datetime.fromtimestamp(t))
2024-05-07 12:24:00
注意到timestamp
是一个浮点数,它没有时区的概念,而datetime
是有时区的。上述转换是在timestamp
和本地时间做转换。
本地时间是指当前操作系统设定的时区。例如北京时区是东8区,则本地时间:
2024-05-07 12:24:00
实际上就是UTC+8:00时区的时间:
2024-05-07 12:24:00 UTC+8:00
UTC时间:UTC+0:00时区的时间应该是:
2024-05-07 04:24:00 UTC+0:00
timestamp
也可以直接被转换到UTC标准时区的时间:
>>> from datetime import datetime
>>> t = 1429417200.0
>>> print(datetime.fromtimestamp(t)) # 本地时间
2015-04-19 12:20:00
>>> print(datetime.utcfromtimestamp(t)) # UTC时间
2024-05-07 04:24:00
str转换为datetime
str转换为datetime的方法是通过datetime.strptime()
实现,p指parse(解析),需要一个日期和时间的格式化字符串:
>>> 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'
规定了日期和时间部分的格式。详细的说明请参考Python文档。
注意转换后的datetime
是没有时区信息的。
datetime转换为str
datetime转换为str,转换方法是通过strftime()
实现的,format(格式化),同样需要一个日期和时间的格式化字符串:
>>> from datetime import datetime
>>> now = datetime.now()
>>> print(now.strftime('%a, %b %d %H:%M'))
Mon, May 05 16:28
datetime加减
对日期和时间进行加减实际上就是把datetime
往后或往前计算,得到新的datetime
。加减可以直接用+
和-
运算符,不过需要导入timedelta
这个类:
>>> 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
到底是哪个时区,除非强行给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)))
如果系统时区恰好是UTC+8:00,那么上述代码就是正确的,否则,不能强制设置为UTC+8:00时区。
时区转换
我们可以先通过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()
方法,可以转换到任意时区。
注:不是必须从UTC+0:00时区转换到其他时区,任何带时区的datetime
都可以正确转换,例如上述bj_dt
到tokyo_dt
的转换。
练习
假设你获取了用户输入的日期和时间如2015-1-21 9:01:30,以及一个时区信息如UTC+5:00,均是str,请编写一个函数将其转换为timestamp:
函数实现:
import re # 正则表达式
from datetime import datetime, timezone, timedelta
def to_timestamp(dt_str, tz_str):
# str转换为datetime
dt = datetime.strptime(dt_str, '%Y-%m-%d %H:%M:%S')
# 利用正则表达式取出时区
m = re.match(r'^UTC([+|-])([0-9]{1,2}):[0-9]{1,2}$', tz_str)
hour = int(m.group(1) + m.group(2))
# 设置时区
tz = timezone(timedelta(hours=hour))
# 根据时区转换时间
dt = dt.replace(tzinfo=tz)
# datetime转换为timestamp
return dt.timestamp()
测试:
# 测试:
t1 = to_timestamp('2015-6-1 08:10:30', 'UTC+7:00')
assert t1 == 1433121030.0, t1
t2 = to_timestamp('2015-5-31 16:10:30', 'UTC-09:00')
assert t2 == 1433121030.0, t2
print('ok')
测试结果:
PS D:\MyCode\PythonCode\Test> & D:/Tool/Python/Python311/python.exe d:/MyCode/PythonCode/Test/hello.py
ok
2、collections
collections是Python内建的一个集合模块,提供了许多有用的集合类。
namedtuple
我们知道tuple
可以表示不变集合,例如,一个点的二维坐标就可以表示成:
>>> p = (1, 2)
但是,看到(1, 2)
,很难看出这个tuple
是用来表示一个坐标的。
定义一个class又小题大做了,这时,namedtuple
就派上了用场:
>>> from collections import namedtuple
>>> Point = namedtuple('Point', ['x', 'y'])
>>> p = Point(1, 2)
>>> p.x
1
>>> p.y
2
namedtuple
是一个函数,它用来创建一个自定义的tuple
对象,并且规定了tuple
元素的个数,并可以用属性而不是索引来引用tuple
的某个元素。
用namedtuple
可以很方便地定义一种数据类型,它具备tuple
的不变性,又可以根据属性来引用。
可以验证创建的Point
对象是tuple
的一种子类:
>>> isinstance(p, Point)
True
>>> isinstance(p, tuple)
True
类似,如果要用坐标和半径表示一个圆,也可以用namedtuple
定义:
# namedtuple('名称', [属性list]):
Circle = namedtuple('Circle', ['x', 'y', 'r'])
depue
使用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()
外,还支持appendleft()
和popleft()
,这样就可以非常高效地往头部添加或删除元素。
defaultdict
使用dict
时,如果引用的Key
不存在,就会抛出KeyError
。如果希望key
不存在时,返回一个默认值,就可以用defaultdict
:
>>> from collections import defaultdict
>>> dd = defaultdict(lambda: 'N/A')
>>> dd['key1'] = 'abc'
>>> dd['key1'] # key1存在
'abc'
>>> dd['key2'] # key2不存在,返回默认值
'N/A'
默认值是调用函数返回的,而函数在创建defaultdict
对象时传入。
除了在Key
不存在时返回默认值,defaultdict
的其他行为跟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
。
ChainMap
ChainMap
可以把一组dict
串起来并组成一个逻辑上的dict
。ChainMap
本身也是一个dict
,但是查找的时候,会按照顺序在内部的dict
依次查找。
什么时候使用ChainMap
最合适?举个例子:应用程序往往都需要传入参数,参数可以通过命令行传入,可以通过环境变量传入,还可以有默认参数。我们可以用ChainMap
实现参数的优先级查找,即先查命令行参数,如果没有传入,再查环境变量,如果没有,就使用默认参数。
下面的代码演示了如何查找user
和color
这两个参数:
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
的一个子类,上面的结果可以看出每个字符出现的次数。
3、argparse
使用argparse
解析参数,只需定义好参数类型,就可以获得有效的参数输入,能大大简化获取命令行参数的工作。
假设想编写一个备份MySQL数据库的命令行程序,需要输入的参数如下:
- host参数:表示MySQL主机名或IP,不输入则默认为
localhost
; - port参数:表示MySQL的端口号,int类型,不输入则默认为
3306
; - user参数:表示登录MySQL的用户名,必须输入;
- password参数:表示登录MySQL的口令,必须输入;
- gz参数:表示是否压缩备份文件,不输入则默认为
False
; - outfile参数:表示备份文件保存在哪,必须输入。
其中,outfile
是位置参数,而其他则是类似--user root
这样的“关键字”参数。
用argparse
来解析参数,一个完整的示例如下:
# backup.py
import argparse
def main():
# 定义一个ArgumentParser实例:
parser = argparse.ArgumentParser(
prog='backup', # 程序名
description='Backup MySQL database.', # 描述
epilog='Copyright(r), 2023' # 说明信息
)
# 定义位置参数:
parser.add_argument('outfile')
# 定义关键字参数:
parser.add_argument('--host', default='localhost')
# 此参数必须为int类型:
parser.add_argument('--port', default='3306', type=int)
# 允许用户输入简写的-u:
parser.add_argument('-u', '--user', required=True)
parser.add_argument('-p', '--password', required=True)
parser.add_argument('--database', required=True)
# gz参数不跟参数值,因此指定action='store_true',意思是出现-gz表示True:
parser.add_argument('-gz', '--gzcompress', action='store_true', required=False, help='Compress backup files by gz.')
# 解析参数:
args = parser.parse_args()
# 打印参数:
print('parsed args:')
print(f'outfile = {args.outfile}')
print(f'host = {args.host}')
print(f'port = {args.port}')
print(f'user = {args.user}')
print(f'password = {args.password}')
print(f'database = {args.database}')
print(f'gzcompress = {args.gzcompress}')
if __name__ == '__main__':
main()
输入有效的参数,则程序能解析出所需的所有参数:
$ ./backup.py -u root -p hello --database testdb backup.sql
parsed args:
outfile = backup.sql
host = localhost
port = 3306
user = root
password = hello
database = testdb
gzcompress = False
缺少必要的参数,或者参数不对,将报告详细的错误信息:
$ ./backup.py --database testdb backup.sql
usage: backup [-h] [--host HOST] [--port PORT] -u USER -p PASSWORD --database DATABASE outfile
backup: error: the following arguments are required: -u/--user, -p/--password
如果输入-h
,则打印帮助信息:
$ ./backup.py -h
usage: backup [-h] [--host HOST] [--port PORT] -u USER -p PASSWORD --database DATABASE outfile
Backup MySQL database.
positional arguments:
outfile
optional arguments:
-h, --help show this help message and exit
--host HOST
--port PORT
-u USER, --user USER
-p PASSWORD, --password PASSWORD
--database DATABASE
-gz, --gzcompress Compress backup files by gz.
Copyright(r), 2023
获取有效参数的代码实际上是这一行:
args = parser.parse_args()
不必捕获异常,因为如果参数有问题,则parse_args()
打印出错误信息后,结束进程;如果参数是-h
,则它打印帮助信息后,结束进程。只有当参数全部有效时,才会返回一个NameSpace
对象,获取对应的参数就把参数名当作属性获取。
4、base64
Base64是一种用64个字符来表示任意二进制数据的方法。
Base64的原理很简单,首先,准备一个包含64个字符的数组:
['A', 'B', 'C', ... 'a', 'b', 'c', ... '0', '1', ... '+', '/']
然后,对二进制数据进行处理,每3个字节一组,一共是3x8=24bit,划为4组,每组正好6个bit:
这样我们得到4个数字作为索引,然后查表,获得相应的4个字符,就是编码后的字符串。
所以,Base64编码会把3字节的二进制数据编码为4字节的文本数据,长度增加33%,好处是编码后的文本数据可以在邮件正文、网页等直接显示。
如果要编码的二进制数据不是3的倍数,最后会剩下1个或2个字节怎么办?Base64用\x00
字节在末尾补足后,再在编码的末尾加上1个或2个=
号,表示补了多少字节,解码的时候,会自动去掉。
Python内置的base64可以直接进行base64的编解码:
>>> import base64
>>> base64.b64encode(b'binary\x00string')
b'YmluYXJ5AHN0cmluZw=='
>>> base64.b64decode(b'YmluYXJ5AHN0cmluZw==') # 解码
b'binary\x00string'
由于标准的Base64编码后可能出现字符+
和/
,在URL中就不能直接作为参数,所以又有一种"url safe"的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'
还可以自己定义64个字符的排列顺序,这样就可以自定义Base64编码,不过,通常情况下完全没有必要。
Base64是一种通过查表的编码方法,不能用于加密,即使使用自定义的编码表也不行。
Base64适用于小段内容的编码,比如数字证书签名、Cookie的内容等。
由于=
字符也可能出现在Base64编码中,但=
用在URL、Cookie里面会造成歧义,所以,很多Base64编码后会把=
去掉:
# 标准Base64:
'abcd' -> 'YWJjZA=='
# 自动去掉=:
'abcd' -> 'YWJjZA'
去掉=
后怎么解码?因为Base64是把3个字节变为4个字节,所以,Base64编码的长度永远是4的倍数,因此,需要加上=
把Base64字符串的长度变为4的倍数,就可以正常解码了。
练习
请写一个能处理去掉=
的base64解码函数:
函数实现:
# -*- coding: utf-8 -*-
import base64
def safe_base64_decode(s):
n = len(s) % 4
if n == 0:
return base64.b64decode(s)
n = 4 - n
while n > 0:
s = s + '='
n -= 1
return base64.b64decode(s)
测试:
# 测试:
assert b'abcd' == safe_base64_decode('YWJjZA=='), safe_base64_decode('YWJjZA==')
assert b'abcd' == safe_base64_decode('YWJjZA'), safe_base64_decode('YWJjZA')
print('ok')
测试结果:
PS D:\MyCode\PythonCode\Test> & D:/Tool/Python/Python311/python.exe d:/MyCode/PythonCode/Test/hello.py
ok
5、struct
Python没有专门处理字节的数据类型。但b'str'
可以表示字节,所以,字节数组=二进制str。
在Python中,比方说要把一个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'
如果换成浮点数就无能为力了。
好在Python提供了一个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字节无符号整数。
struct
模块定义的数据类型可以参考Python官方文档:
https://docs.python.org/3/library/struct.html#format-characters
Windows的位图文件(.bmp
)是一种非常简单的文件格式,用struct分析一下。
首先找一个bmp
文件,没有的话用“画图”画一个。
读入前30个字节来分析:
>>> s = b'\x42\x4d\x38\x8c\x0a\x00\x00\x00\x00\x00\x36\x00\x00\x00\x28\x00\x00\x00\x80\x02\x00\x00\x68\x01\x00\x00\x01\x00\x18\x00'
BMP格式采用小端方式存储数据,文件头的结构按顺序如下:
两个字节:'BM'
表示Windows位图,'BA'
表示OS/2位图; 一个4字节整数:表示位图大小; 一个4字节整数:保留位,始终为0; 一个4字节整数:实际图像的偏移量; 一个4字节整数:Header的字节数; 一个4字节整数:图像宽度; 一个4字节整数:图像高度; 一个2字节整数:始终为1; 一个2字节整数:颜色数。
所以,组合起来用unpack读取:
>>> struct.unpack('<ccIIIIIIHH', s)
(b'B', b'M', 691256, 0, 54, 40, 640, 360, 1, 24)
结果显示,b'B'
、b'M'
说明是Windows位图,位图大小为640x360,颜色数为24。
练习
请编写一个bmpinfo.py
,可以检查任意文件是否是位图文件,如果是,打印出图片大小和颜色数。
函数实现:
# -*- coding: utf-8 -*-
import base64, struct
bmp_data = base64.b64decode('Qk1oAgAAAAAAADYAAAAoAAAAHAAAAAoAAAABABAAAAAAADICAAASCwAAEgsAA' +
'AAAAAAAAAAA/3//f/9//3//f/9//3//f/9//3//f/9//3//f/9//3//f/9//3//f/9//3/' +
'/f/9//3//f/9//3//f/9/AHwAfAB8AHwAfAB8AHwAfP9//3//fwB8AHwAfAB8/3//f/9/A' +
'HwAfAB8AHz/f/9//3//f/9//38AfAB8AHwAfAB8AHwAfAB8AHz/f/9//38AfAB8/3//f/9' +
'//3//fwB8AHz/f/9//3//f/9//3//f/9/AHwAfP9//3//f/9/AHwAfP9//3//fwB8AHz/f' +
'/9//3//f/9/AHwAfP9//3//f/9//3//f/9//38AfAB8AHwAfAB8AHwAfP9//3//f/9/AHw' +
'AfP9//3//f/9//38AfAB8/3//f/9//3//f/9//3//fwB8AHwAfAB8AHwAfAB8/3//f/9//' +
'38AfAB8/3//f/9//3//fwB8AHz/f/9//3//f/9//3//f/9/AHwAfP9//3//f/9/AHwAfP9' +
'//3//fwB8AHz/f/9/AHz/f/9/AHwAfP9//38AfP9//3//f/9/AHwAfAB8AHwAfAB8AHwAf' +
'AB8/3//f/9/AHwAfP9//38AfAB8AHwAfAB8AHwAfAB8/3//f/9//38AfAB8AHwAfAB8AHw' +
'AfAB8/3//f/9/AHwAfAB8AHz/fwB8AHwAfAB8AHwAfAB8AHz/f/9//3//f/9//3//f/9//' +
'3//f/9//3//f/9//3//f/9//3//f/9//3//f/9//3//f/9//3//f/9//38AAA==')
def bmp_info(data):
bmp = struct.unpack('<ccIIIIIIHH', data[:30])
if bmp[0] == b'B' and bmp[1] == b'M': # 注意这里元组第一、二个元素的写法
return {
'width': int(bmp[6]),
'height': int(bmp[7]),
'color': int(bmp[9])
}
测试:
# 测试
bi = bmp_info(bmp_data)
assert bi['width'] == 28
assert bi['height'] == 10
assert bi['color'] == 16
print('ok')
测试结果:
PS D:\MyCode\PythonCode\Test> & D:/Tool/Python/Python311/python.exe d:/MyCode/PythonCode/Test/hello.py
ok
6、hashlib
摘要算法简介
Python的hashlib提供了常见的摘要算法,如MD5,SHA1等等。
摘要算法又称哈希算法、散列算法。它通过一个函数,把任意长度的数据转换为一个长度固定的数据串(通常用16进制的字符串表示)。
举个例子,你写了一篇文章,内容是一个字符串'how to use python hashlib - by Michael'
,并附上这篇文章的摘要是'2d73d4f15c0db7f5ecb321b6a65e5d6d'
。如果有人篡改了你的文章,并发表为'how to use python hashlib - by Bob'
,你可以一下子指出Bob篡改了你的文章,因为根据'how to use python hashlib - by Bob'
计算出的摘要不同于原始文章的摘要。
可见,摘要算法就是通过摘要函数f()
对任意长度的数据data
计算出固定长度的摘要digest
,目的是为了发现原始数据是否被人篡改过。
摘要算法之所以能指出数据是否被篡改过,就是因为摘要函数是一个单向函数,计算f(data)
很容易,但通过digest
反推data
却非常困难。而且,对原始数据做一个bit
的修改,都会导致计算出的摘要完全不同。
我们以常见的摘要算法MD5为例,计算出一个字符串的MD5值:
import hashlib
md5 = hashlib.md5()
md5.update('how to use md5 in python hashlib?'.encode('utf-8'))
print(md5.hexdigest())
计算结果如下:
d26a53750bc40b38b65a520292f69306
如果数据量很大,可以分块多次调用update()
,最后计算的结果是一样的:
import hashlib
md5 = hashlib.md5()
md5.update('how to use md5 in '.encode('utf-8'))
md5.update('python hashlib?'.encode('utf-8'))
print(md5.hexdigest())
MD5是最常见的摘要算法,速度很快,生成结果是固定的128 bit/16字节,通常用一个32位的16进制字符串表示。
另一种常见的摘要算法是SHA1,调用SHA1和调用MD5完全类似:
import hashlib
sha1 = hashlib.sha1()
sha1.update('how to use sha1 in '.encode('utf-8'))
sha1.update('python hashlib?'.encode('utf-8'))
print(sha1.hexdigest())
SHA1的结果是160 bit/20字节,通常用一个40位的16进制字符串表示。
比SHA1更安全的算法是SHA256和SHA512,不过越安全的算法不仅越慢,而且摘要长度更长。
有可能两个不同的数据通过某个摘要算法得到了相同的摘要,因为任何摘要算法都是把无限多的数据集合映射到一个有限的集合中。这种情况称为碰撞。
摘要算法应用
摘要算法能应用到什么地方?举个常用例子:
任何允许用户登录的网站都会存储用户登录的用户名和口令。如何存储用户名和口令呢?方法是存到数据库表中:
如果以明文保存用户口令,如果数据库泄露,所有用户的口令就落入黑客的手里。此外,网站运维人员是可以访问数据库的,也就是能获取到所有用户的口令。
正确的保存口令的方式是不存储用户的明文口令,而是存储用户口令的摘要,比如MD5:
当用户登录时,首先计算用户输入的明文口令的MD5,然后和数据库存储的MD5对比,如果一致,说明口令输入正确,如果不一致,口令肯定错误。
根据用户输入的口令,计算出存储在数据库中的MD5口令:
def calc_md5(password):
pass
存储MD5的好处是即使运维人员能访问数据库,也无法获知用户的明文口令。
由于常用口令的MD5值很容易被计算出来,所以,要确保存储的用户口令不是那些已经被计算出来的常用口令的MD5,这一方法通过对原始口令加一个复杂字符串来实现,俗称“加盐”:
def calc_md5(password):
return get_md5(password + 'the-Salt')
经过Salt处理的MD5口令,只要Salt不被黑客知道,即使用户输入简单口令,也很难通过MD5反推明文口令。
但是如果有两个用户都使用了相同的简单口令比如123456
,在数据库中,将存储两条相同的MD5值,这说明这两个用户的口令是一样的。有没有办法让使用相同口令的用户存储不同的MD5呢?
如果假定用户无法修改登录名,就可以通过把登录名作为Salt的一部分来计算MD5,从而实现相同口令的用户也存储不同的MD5。
练习
1、设计一个验证用户登录的函数,根据用户输入的口令是否正确,返回True
或False
:
函数实现:
# -*- coding: utf-8 -*-
import hashlib
db = {
'michael': 'e10adc3949ba59abbe56e057f20f883e',
'bob': '878ef96e86145580c38c87f0410ad153',
'alice': '99b1c2188db85afee403b1536010c2c9'
}
def login(user, password):
md5 = hashlib.md5()
md5.update(password.encode('utf-8'))
if db[user] == md5.hexdigest():
return True
return False
测试:
# 测试:
assert login('michael', '123456')
assert login('bob', 'abc999')
assert login('alice', 'alice2008')
assert not login('michael', '1234567')
assert not login('bob', '123456')
assert not login('alice', 'Alice2008')
print('ok')
测试结果:
PS D:\MyCode\PythonCode\Test> & D:/Tool/Python/Python311/python.exe d:/MyCode/PythonCode/Test/hello.py
ok
2、根据用户输入的登录名和口令模拟用户注册,计算更安全的MD5:
db = {}
def register(username, password):
db[username] = get_md5(password + username + 'the-Salt')
然后,根据修改后的MD5算法实现用户登录的验证:
函数实现:
# -*- coding: utf-8 -*-
import hashlib, random
def get_md5(pws):
md5 = hashlib.md5()
md5.update(pws.encode('utf-8'))
return md5.hexdigest()
class User(object):
def __init__(self, username, password):
self.username = username
self.salt = ''.join([chr(random.randint(48, 122)) for i in range(20)])
self.password = get_md5(password + self.salt)
db = {
'michael': User('michael', '123456'),
'bob': User('bob', 'abc999'),
'alice': User('alice', 'alice2008')
}
# def get_md5(pws):
# md5 = hashlib.md5()
# md5.update(pws.encode('utf-8'))
# return md5.hexdigest()
def login(username, password):
user = db[username]
return user.password == get_md5(password + user.salt)
测试:
# 测试:
assert login('michael', '123456')
assert login('bob', 'abc999')
assert login('alice', 'alice2008')
assert not login('michael', '1234567')
assert not login('bob', '123456')
assert not login('alice', 'Alice2008')
print('ok')
测试结果:
PS D:\MyCode\PythonCode\Test> & D:/Tool/Python/Python311/python.exe d:/MyCode/PythonCode/Test/hello.py
ok
7、hmac
在计算哈希的时候,不能仅针对原始输入计算,需要增加一个salt
来使得相同的输入也能得到不同的哈希,这样,大大增加了黑客破解的难度。
如果salt
是我们自己随机生成的,通常计算MD5时采用md5(message + salt)
。但实际上,把salt
看做一个“口令”,加salt
的哈希就是:计算一段message
的哈希时,根据不同口令计算出不同的哈希。要验证哈希值,必须同时提供正确的口令。
这实际上就是Hmac算法:Keyed-Hashing for Message Authentication。它通过一个标准算法,在计算哈希的过程中,把key
混入计算过程中。
和自定义的加salt
算法不同,Hmac算法针对所有哈希算法都通用,无论是MD5还是SHA-1。采用Hmac替代我们自己的salt
算法,可以使程序算法更标准化,也更安全。
Python自带的hmac
模块实现了标准的Hmac算法。我们来看看如何使用hmac
实现带key
的哈希。
我们首先需要准备待计算的原始消息message
,随机key
,哈希算法,这里采用MD5,使用hmac
的代码如下:
>>> import hmac
>>> message = b'Hello, world!' # bytes类型
>>> key = b'secret' # bytes类型
>>> h = hmac.new(key, message, digestmod='MD5')
>>> # 如果消息很长,可以多次调用h.update(msg)
>>> h.hexdigest()
'fa4ee7d173f2d97ee79022d1a7355bcf'
可见使用hmac
和普通hash
算法非常类似。hmac
输出的长度和原始哈希算法的长度一致。需要注意传入的key
和message
都是bytes
类型,str
类型需要首先编码为bytes
。
Hmac算法,它利用一个key
对message
计算“杂凑”后的hash
,使用hmac
算法比标准hash
算法更安全,因为针对相同的message
,不同的key
会产生不同的hash
。
练习
将上一节的salt改为标准的hmac算法,验证用户口令:
函数实现:
# -*- coding: utf-8 -*-
import hmac, random
def hmac_md5(key, s):
return hmac.new(key.encode('utf-8'), s.encode('utf-8'), 'MD5').hexdigest()
class User(object):
def __init__(self, username, password):
self.username = username
self.key = ''.join([chr(random.randint(48, 122)) for i in range(20)])
self.password = hmac_md5(self.key, password)
db = {
'michael': User('michael', '123456'),
'bob': User('bob', 'abc999'),
'alice': User('alice', 'alice2008')
}
def login(username, password):
user = db[username]
return user.password == hmac_md5(user.key, password)
测试:
# 测试:
assert login('michael', '123456')
assert login('bob', 'abc999')
assert login('alice', 'alice2008')
assert not login('michael', '1234567')
assert not login('bob', '123456')
assert not login('alice', 'Alice2008')
print('ok')
测试结果:
ok
8、itertools
Python的内建模块itertools
提供了非常有用的用于操作迭代对象的函数。
无限迭代器
下面介绍itertools
提供的几个 “无限”迭代器。
count()
会创建一个无限的迭代器,所以下面的代码会打印出自然数序列,根本停不下来,只能按Ctrl+C退出。
count(n, m)
表示从自然数n
开始,每次步长为m
。
>>> import itertools
>>> natuals = itertools.count(1)
>>> for n in natuals:
... print(n)
...
1
2
3
...
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()
chain()
可以把一组迭代对象串联起来,形成一个更大的迭代器:
>>> for c in itertools.chain('ABC', 'XYZ'):
... print(c)
# 迭代效果:'A' 'B' 'C' 'X' 'Y' 'Z'
groupby()
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
。如果我们要忽略大小写分组,就可以让元素’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']
练习
计算圆周率可以根据公式:
利用Python提供的itertools
模块,我们来计算这个序列的前N项和:
函数实现:
# -*- coding: utf-8 -*-
import itertools
def pi(N):
' 计算pi的值 '
# step 1: 创建一个奇数序列: 1, 3, 5, 7, 9, ...
nums = itertools.count(1, 2)
# step 2: 取该序列的前N项: 1, 3, 5, 7, 9, ..., 2*N-1.
nums = itertools.takewhile(lambda x: x <= 2*N-1, nums)
# step 3: 添加正负符号并用4除: 4/1, -4/3, 4/5, -4/7, 4/9, ...
# 利用for表达式:[表达式 for 循环计数器 in 可迭代对象]
# 利用地板除:1//2=0、3//2=1、5//2=2...
nums = ((-1)**(n//2) * 4 / n for n in nums)
# step 4: 求和:
return sum(nums)
测试:
# 测试:
print(pi(10))
print(pi(100))
print(pi(1000))
print(pi(10000))
assert 3.04 < pi(10) < 3.05
assert 3.13 < pi(100) < 3.14
assert 3.140 < pi(1000) < 3.141
assert 3.1414 < pi(10000) < 3.1415
print('ok')
测试结果:
PS D:\MyCode\PythonCode\Test> & D:/Tool/Python/Python311/python.exe d:/MyCode/PythonCode/Test/hello.py
3.0418396189294032
3.1315929035585537
3.140592653839794
3.1414926535900345
ok
9、contextlib
正确关闭文件资源的一个方法是使用try...finally
:
try:
f = open('/path/to/file', 'r')
f.read()
finally:
if f:
f.close()
Python的with
语句允许非常方便地使用资源,而不必担心资源没有关闭,所以上面的代码可以简化为:
with open('/path/to/file', 'r') as f:
f.read()
并不是只有open()
函数返回的fp
对象才能使用with
语句。实际上,任何对象,只要正确实现了上下文管理,就可以用于with
语句。
实现上下文管理是通过__enter__
和__exit__
这两个方法实现的。例如,下面的class实现了这两个方法:
class Query(object):
def __init__(self, name):
self.name = name
def __enter__(self):
print('Begin')
return self
def __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
编写__enter__
和__exit__
仍然很繁琐,因此Python的标准库contextlib
提供了更简单的写法,上面的代码可以改写如下:
from contextlib import contextmanager
class Query(object):
def __init__(self, name):
self.name = name
def 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
实现。例如:
@contextmanager
def tag(name):
print("<%s>" % name)
yield
print("</%s>" % name)
with tag("h1"):
print("hello")
print("world")
上述代码执行结果为:
<h1>
hello
world
</h1>
代码的执行顺序是:
with
语句首先执行yield
之前的语句,因此打印出<h1>
;yield
调用会执行with
语句内部的所有语句,因此打印出hello
和world
;- 最后执行
yield
之后的语句,打印出</h1>
。
因此,@contextmanager
让我们通过编写生成器generator来简化上下文管理。
@closing
如果一个对象没有实现上下文,我们就不能把它用于with
语句。这个时候,可以用closing()
来把该对象变为上下文对象。例如,用with
语句使用urlopen()
:
from contextlib import closing
from urllib.request import urlopen
with closing(urlopen('https://www.python.org')) as page:
for line in page:
print(line)
closing
也是一个经过@contextmanager
装饰的生成器generator,这个generator编写起来其实非常简单:
@contextmanager
def closing(thing):
try:
yield thing
finally:
thing.close()
它的作用就是把任意对象变为上下文对象,并支持with
语句。
10、urllib
urllib
提供了一系列用于操作URL的功能。Internet上的每一个网页都具有一个唯一的名称标识,通常称之为URL(Uniform Resource Locator,统一资源定位器)。它是www的统一资源定位标志,简单地说URL就是web地址,俗称“网址”。
Get
urllib的request
模块可以非常方便地抓取URL内容,也就是发送一个GET
请求到指定的页面,然后返回HTTP
的响应:
例如,对豆瓣的一个URLhttps://api.douban.com/v2/book/2129650
进行抓取,并返回响应:
from urllib import request
with request.urlopen('https://api.douban.com/v2/book/2129650') as f:
data = 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
头,我们就可以把请求伪装成浏览器。例如,模拟iPhone 6去请求豆瓣首页:
from urllib import request
req = 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的移动版网页:
...
<meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, minimum-scale=1.0, maximum-scale=1.0">
<meta name="format-detection" content="telephone=no">
<link rel="apple-touch-icon" sizes="57x57" href="http://img4.douban.com/pics/cardkit/launcher/57.png" />
...
Post
如果要以POST
发送一个请求,只需要把参数data
以bytes
形式传入。
我们模拟一个微博登录,先读取登录的邮箱和口令,然后按照weibo.cn
的登录页的格式以username=xxx&password=xxx
的编码传入:
from urllib import request, parse
print('Login to weibo.cn...')
email = input('Email: ')
passwd = input('Password: ')
login_data = 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=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
头就是用来标识浏览器的。
11、XML
XML虽然比JSON复杂,在Web中应用也不如以前多了,不过仍有很多地方在用,所以,有必要了解如何操作XML。
DOM vs SAX
操作XML有两种方法:DOM和SAX。
- DOM会把整个XML读入内存,解析为树,因此占用内存大,解析慢,优点是可以任意遍历树的节点。
- SAX是流模式,边读边解析,占用内存小,解析快,缺点是我们需要自己处理事件。
正常情况下,优先考虑SAX,因为DOM实在太占内存。
在Python中使用SAX解析XML非常简洁,通常我们关心的事件是start_element
,end_element
和char_data
,准备好这3个函数,然后就可以解析xml
了。
举个例子,当SAX解析器读到一个节点时:
<a href="/">python</a>
会产生3个事件:
- start_element事件,在读取
<a href="/">
时; - char_data事件,在读取
python
时; - end_element事件,在读取
</a>
时。
用代码实验一下:
from xml.parsers.expat import ParserCreate
#利用SAX解析XML文档牵涉到两个部分: 解析器和事件处理器
#解析器负责读取XML文档,并向事件处理器发送事件,如元素开始跟元素结束事件。
#而事件处理器则负责对事件作出响应,对传递的XML数据进行处理
class DefaultSaxHandler(object):
#name表示节点名称,attrs表示节点属性(字典)
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)
#text表示节点数据
def char_data(self, text):
print('sax:char_data: %s' % text)
xml = r'''<?xml version="1.0"?>
<ol>
<li><a href="/python">Python</a></li>
<li><a href="/ruby">Ruby</a></li>
</ol>
'''
# 最重要的是这些句子
#处理器实例
handler = DefaultSaxHandler()
#解析器实例
parser = ParserCreate()
#下面3句为解析器设置自定义的回调函数
#回调函数的概念:https://www.zhihu.com/question/19801131
parser.StartElementHandler = handler.start_element
parser.EndElementHandler = handler.end_element
parser.CharacterDataHandler = handler.char_data
#开始解析XML
parser.Parse(xml)
#然后就是等待expat解析,
#一旦expat解析器遇到xml的 元素开始,元素结束,元素值 事件时
#会回分别调用start_element, end_element, char_data函数
#关于XMLParser Objects的方法介绍下
#详见python文档:xml.parsers.expat
#xmlparser.StartElementHandler(name, attributes)
#遇到XML开始标签时调用,name是标签的名字,attrs是标签的属性值字典
#xmlparser.EndElementHandler(name)
#遇到XML结束标签时调用。
#xmlparser.CharacterDataHandler(data)
#调用时机:
#从行开始,遇到标签之前,存在字符,content 的值为这些字符串。
#从一个标签,遇到下一个标签之前, 存在字符,content 的值为这些字符串。
#从一个标签,遇到行结束符之前,存在字符,content 的值为这些字符串。
#标签可以是开始标签,也可以是结束标签。
#为了方便理解,我已经在下面还原来解析过程,
#标出何时调用,分别用S:表示开始;E:表示结束;D:表示data
# 如果看不明白,请配合脚本输出结果一起看
# S<ol>C
# C S<li>S<a href="/python">CPython</a>E</li>EC
# C S<li>S<a href="/ruby">CRuby</a>E</li>EC
# S</ol>E
需要注意的是读取一大段字符串时,CharacterDataHandler
可能被多次调用,所以需要自己保存起来,在EndElementHandler
里面再合并。
除了解析XML外,如何生成XML呢?99%的情况下需要生成的XML结构都是非常简单的,因此,最简单也是最有效的生成XML的方法是拼接字符串:
L = []
L.append(r'<?xml version="1.0"?>')
L.append(r'<root>')
L.append(encode('some & data'))
L.append(r'</root>')
return ''.join(L)
如果要生成复杂的XML呢?建议你不要用XML,改成JSON。
12、HTMLParser
如果我们要编写一个搜索引擎,第一步是用爬虫把目标网站的页面抓下来,第二步就是解析该HTML页面,看看里面的内容到底是新闻、图片还是视频。
假设第一步已经完成了,第二步应该如何解析HTML呢?
HTML本质上是XML的子集,但是HTML的语法没有XML那么严格,所以不能用标准的DOM或SAX来解析HTML。
好在Python提供了HTMLParser
来非常方便地解析HTML,只需简单几行代码。利用HTMLParser
,可以把网页中的文本、图像等解析出来。
from html.parser import HTMLParser
from html.entities import name2codepoint
class MyHTMLParser(HTMLParser):
def handle_starttag(self, tag, attrs):
print('<%s>' % tag)
def handle_endtag(self, tag):
print('</%s>' % tag)
def handle_startendtag(self, tag, attrs):
print('<%s/>' % tag)
def handle_data(self, data):
print(data)
def handle_comment(self, data):
print('<!--', data, '-->')
def handle_entityref(self, name):
print('&%s;' % name)
def handle_charref(self, name):
print('&#%s;' % name)
parser = MyHTMLParser()
parser.feed('''<html>
<head></head>
<body>
<!-- test html parser -->
<p>Some <a href=\"#\">html</a> HTML tutorial...<br>END</p>
</body></html>''')
feed()
方法可以多次调用,也就是不一定一次把整个HTML字符串都塞进去,可以一部分一部分塞进去。
特殊字符有两种,一种是英文表示的
,一种是数字表示的Ӓ
,这两种字符都可以通过Parser
解析出来。
练习
找一个网页,例如https://www.python.org/events/python-events/
,用浏览器查看源码并复制,然后尝试解析一下HTML,输出Python官网发布的会议时间、名称和地点。
# Python官网发布的会议时间、名称和地点的网页源码样式:
<li>
<h3 class="event-title"><a href="/events/python-events/776/">PyCon AU 2019</a></h3>
<p>
<time datetime="2019-08-02T00:00:00+00:00">02 Aug. – 06 Aug. <span class="say-no-more"> 2019</span></time>
<span class="event-location">Sydney, Australia</span>
</p>
</li>
函数实现:
from urllib import request
import re
Name = r'<h3 class="event-title"><a href=".*">(.*)</a></h3>' #匹配名称的正则
Location = r'<span class="event-location">(.*)</span>' #匹配地点的正则
Time = r'<time datetime=".*">(.*)<span class="say-no-more">' #匹配时间的正则
Year = r'<span class="say-no-more">(.*)</span></time>' #匹配年份
def main():
URL = 'https://www.python.org/events/python-events/'
data = delInf(URL)
#处理html内的信息并输出正则到的内容
def delInf(URL):
datalist = []
strInf = request.urlopen(URL).read().decode('utf-8') #整个网页的信息采用utf-8的编码格式来
name = re.findall(Name, strInf) #正则匹配内容,返回所有匹配到的项,返回的是一个列表形式
location = re.findall(Location, strInf)
time = re.findall(Time, strInf)
year = re.findall(Year, strInf)
for index in range(0, len(name)):
print('会议名称:'+name[index])
print('会议地点:' + location[index])
print('会议时间:' + time[index].replace('–','-')) #由于特殊字符的存在,这里要替换一下
print('会议年份:' + year[index]+'\n')
if __name__ == '__main__':
main()
运行结果:
会议名称:PyCon JP 2020
会议地点:Tokyo, Japan
会议时间:28 Aug. - 29 Aug.
会议年份: 2020
会议名称:PyCon TW 2020
会议地点:International Conference Hall ,No.1, University Road, Tainan City 701, Taiwan
会议时间:05 Sept. - 06 Sept.
会议年份: 2020
会议名称:PyCon SK 2020
会议地点:Bratislava, Slovakia
会议时间:11 Sept. - 13 Sept.
会议年份: 2020
会议名称:DjangoCon Europe 2020
会议地点:Porto, Portugal
会议时间:16 Sept. - 20 Sept.
会议年份: 2020
会议名称:PyCon APAC 2020
会议地点:Kota Kinabalu, Sabah, Malaysia
会议时间:19 Sept. - 20 Sept.
会议年份: 2020
会议名称:DragonPy 2020
会议地点:Ljubljana, Slovenia
会议时间:19 Sept. - 20 Sept.
会议年份: 2020
会议名称:EuroSciPy 2020 (canceled)
会议地点:Bilbao, Spain
会议时间:27 July - 31 July
会议年份: 2020
会议名称:EuroPython 2020 Online
会议地点:Online Event
会议时间:23 July - 26 July
会议年份: 2020
None
Process finished with exit code 0