Python常用內建模块

xiaoxiao2021-02-28  59

datetime

    datetime是Python处理日期和时间的标准库。

获取当前日期和时间

>>> from datetime import datetime >>> now = datetime.now() # 获取当前datetime >>> print(now) 2015-05-18 16:28:07.198690 >>> print(type(now)) <class 'datetime.datetime'>    datetime 模块包含一个datetime类,通过from datetime import datetime导入的是datetime这个类。如果仅导入import datetime,则必须引用全名datetime.datetime。

    datetime.now()返回当前日期和时间,其类型是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为负数),当前时间就是相对于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时间就确定了,转换到任意时区的时间也是完全确定的

    把一个datetime类型转换为timestamp只需要简单调用timestamp()方法:

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

    Python的timestamp是一个浮点数。如果有小数位,小数位表示毫秒数。Java和JavaScript的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的浮点表示方法。

timestamp转换为datetime

    要把timestamp转换为datetime,使用datetime提供的fromtimestamp()方法:

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

    上述转换是在timestamp和本地时间做转换。本地时间是指当前操作系统设定的时区。

    timestamp也可以直接被转换到UTC标准时区的时间:

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

str转换为datetime

    用户输入的日期和时间是字符串,要处理日期和时间,首先必须把str转换为datetime。转换方法是通过datetime.strptime()实现,需要一个日期和时间的格式化字符串:

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

datetime转换为str

通过strftime()实现的,同样需要一个日期和时间的格式化字符串:

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

datetime加减

加减可以直接用+和-运算符,需要导入timedelta类:

>>> from datetime import datetime, timedelta >>> now = datetime.now() >>> 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)

时区转换

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

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

2015-05-18 09:05:12.377316+00:00

2015-05-18 17:05:12.377316+08:00

2015-05-18 18:05:12.377316+09:00

2015-05-18 18:05:12.377316+09:00

小结datetime表示的时间需要时区信息才能确定一个特定的时间,否则只能视为本地时间。

如果要存储datetime,最佳方法是将其转换为timestamp再存储,因为timestamp的值与时区完全无关。

练习:

    假设你获取了用户输入的日期和时间如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): dt = datetime.strptime(dt_str,'%Y-%m-%d %H:%M:%S') print(dt) utc =re.match(r'^(\w{3})(.\d*):(\d*)$',tz_str) tut = int(utc.group(2)) utc_dt = dt.replace(tzinfo=timezone(timedelta(hours=tut))) print(utc_dt) ts = utc_dt.timestamp() return ts # 测试: t1 = to_timestamp('2015-6-1 09:10:30', 'UTC+8: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')

collections

    collections是Python内建的一个集合模块,提供了许多有用的集合类。

namedtuple

    namedtuple是一个函数,它用来创建一个自定义的tuple对象,并且规定了tuple元素的个数,并可以用属性而不是索引来引用tuple的某个元素。通过用namedtuple定义一种数据类型,它具备tuple的不变性,又可以根据属性来引用,使用十分方便。

# namedtuple('名称', [属性list]): >>> from collections import namedtuple >>> Point = namedtuple('Point', ['x', 'y']) >>> p = Point(1, 2) >>> p.x 1 >>> p.y 2用坐标和半径表示一个圆,也可以用namedtuple定义: Circle = namedtuple('Circle', ['x', 'y', 'r'])验证创建的Point对象是tuple的一种子类: >>> isinstance(p, Point) True >>> isinstance(p, tuple) True deque     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: from collections import OrderedDict class LastUpdatedOrderedDict(OrderedDict): def __init__(self, capacity): super(LastUpdatedOrderedDict, self).__init__() self._capacity = capacity#定义dict容量 def __setitem__(self, key, value):     containsKey = 1 if key in self else 0 #key在dict中存在则containsKey=1 if len(self) - containsKey >= self._capacity:#len(self)值看下面测试 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) #添加 l=LastUpdatedOrderedDict(3) l['z']=1 #self=LastUpdatedOrderedDict(['z':1]) l['z']=1 l['y']=2 #self=LastUpdatedOrderedDict(['z':1],['y':2]) l['x']=3 #self=LastUpdatedOrderedDict(['z':1],['y':2],['x':3]) l['v']=4 #self=LastUpdatedOrderedDict(['y':2],['x':3],['v':4]) print(l)

Counter

Counter 类可以直接调用其构造方法,传入要统计的字符串:

>>> Counter('programming') Counter({'r': 2, 'g': 2, 'm': 2, 'p': 1, 'o': 1, 'a': 1, 'i': 1, 'n': 1}) >>> dict(Counter('programming')) {'p': 1, 'r': 2, 'o': 1, 'g': 2, 'a': 1, 'm': 2, 'i': 1, 'n': 1}

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的倍数,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字符串的长度变为4的倍数,就可以正常解码了。

小结:Base64是一种任意二进制到文本字符串的编码方法,常用于在URL、Cookie、网页中传输少量二进制数据。

练习:写一个能处理去掉=的base64解码函数

import base64 def safe_base64_decode(s): l = len(s) % 4 while l!= 0: s += b'=' l = l-1 return base64.b64decode(s) #测试 assert b'abcd' == safe_base64_decode(b'YWJjZA========'), safe_base64_decode(b'YWJjZA==') assert b'abcd' == safe_base64_decode(b'YWJjZA'), safe_base64_decode(b'YWJjZA') assert b'aU' == safe_base64_decode(b'YVU'), safe_base64_decode(b'YVU') assert b'HHL2' == safe_base64_decode(b'SEhMMg'), safe_base64_decode(b'SEhMMjIy') assert b'HHL222' == safe_base64_decode(b'SEhMMjIy'), safe_base64_decode(b'YWFLS0w') assert b'0' == safe_base64_decode(b'MA'), safe_base64_decode(b'MA') print('ok')

struct

    Python没有专门处理字节的数据类型。但由于str既是字符串,又可以表示字节,所以,字节数组=str。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字节无符号整数。

所以,尽管Python不适合编写底层操作字节流的代码,但在对性能要求不高的地方,利用struct就方便多了。

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,可以检查任意文件是否是位图文件,如果是,打印出图片大小和颜色数。

import base64, struct bmp_data = base64.b64decode('Qk1oAgAAAAAAADYAAAAoAAAAHAAAAAoAAAABABAAAAAAADICAAASCwAAEgsAAAAAAAAAAAAA/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/AHwAfAB8AHz/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/AHwAfP9//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/AHwAfAB8AHwAfAB8AHwAfAB8/3//f/9/AHwAfP9//38AfAB8AHwAfAB8AHwAfAB8/3//f/9//38AfAB8AHwAfAB8AHwAfAB8/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): t = struct.unpack('<ccIIIIIIHH',data[:30]) print(t) if t[0]==b'B' and t[1]==b'M' : return { 'width':t[6], 'height':t[7], 'color':t[9] } else: return None # 测试 bi = bmp_info(bmp_data) assert bi['width'] == 28 assert bi['height'] == 10 assert bi['color'] == 16 print('ok')

hashlib

    摘要算法简介:Python的hashlib提供了常见的摘要算法,如MD5,SHA1等等。摘要算法又称哈希算法、散列算法。它通过一个函数,把任意长度的数据转换为一个长度固定的数据串(通常用16进制的字符串表示)。

    摘要算法通过摘要函数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(),最后计算的结果是一样的

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

    MD5是最常见的摘要算法,速度很快,生成结果是固定的128 bit字节,通常用一个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字节,通常用一个40位的16进制字符串表示。

    比SHA1更安全的算法是SHA256和SHA512,不过越安全的算法不仅越慢,而且摘要长度更长。

    有没有可能两个不同的数据通过某个摘要算法得到了相同的摘要?完全有可能,因为任何摘要算法都是把无限多的数据集合映射到一个有限的集合中。这种情况称为碰撞。

摘要算法应用

    任何允许用户登录的网站都会存储用户登录的用户名和口令到数据库表中,如果以明文保存用户口令,如果数据库泄露,所有用户的口令就落入黑客的手里。此外,网站运维人员可以访问数据库,也能获取到所有用户的口令。   

name | password --------+---------- michael | 123456 bob | abc999 alice | alice2008     正确的保存口令的方式是不存储用户的明文口令,而是存储用户口令的摘要,比如MD5: username | password ---------+--------------------------------- michael | e10adc3949ba59abbe56e057f20f883e bob | 878ef96e86145580c38c87f0410ad153 alice | 99b1c2188db85afee403b1536010c2c9

    当用户登录时,首先计算用户输入的明文口令的MD5,然后和数据库存储的MD5对比,如果一致,说明口令输入正确,如果不一致,口令肯定错误。

练习:

1.根据用户输入的口令,计算出存储在数据库中的MD5口令;2设计一个验证用户登录的函数,根据用户输入的口令是否正确,返回True或False:

import hashlib db = { 'michael': 'e10adc3949ba59abbe56e057f20f883e', 'bob': '878ef96e86145580c38c87f0410ad153', 'alice': '99b1c2188db85afee403b1536010c2c9' } def calc_md5(password): md5 = hashlib.md5() md5.update(password.encode('utf-8')) return md5.hexdigest() def login(user,password): pw = calc_md5(password) if db[user]==pw: return True else: 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')通过对原始口令加一个复杂字符串来实现,俗称“加盐”: def calc_md5(password): return get_md5(password + 'the-Salt')

    经过Salt处理的MD5口令,只要Salt不被黑客知道,即使用户输入简单口令,也很难通过MD5反推明文口令。为了避免密码相同而存储相同MD5,假定用户无法修改登录名,就可以通过把登录名作为Salt的一部分来计算MD5,从而实现相同口令的用户也存储不同的MD5。

练习:

根据用户输入的登录名和口令模拟用户注册,计算更安全的MD5:

db = {} def register(username, password): db[username] = get_md5(password + username + 'the-Salt')然后,根据修改后的MD5算法实现用户登录的验证: import hashlib, random def get_md5(s): return hashlib.md5(s.encode('utf-8')).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 login(username, password): user = db[username] try: return user.password == get_md5(password+user.salt) except IndentationError: 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') 小结

    摘要算法不是加密算法,不能用于加密(因为无法通过摘要反推明文),只能用于防篡改,但是它的单向计算特性决定了可以在不存储明文口令的情况下验证用户口令。

itertools

Python的内建模块itertools提供了非常有用的用于操作迭代对象的函数。

    count()会创建一个无限的迭代器,所以上述代码会打印出自然数序列,

>>> 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]

urllib

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

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'))    如果我们要想模拟浏览器发送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')) 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://m.weibo.cn/') ]) 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://m.weibo.cn/') 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}}

XML

HTMLParser

转载请注明原文地址: https://www.6miu.com/read-2600296.html

最新回复(0)