开讲前，告诉大家requests有他自己的官方文档：http://cn.python-requests.org/zh_CN/latest/
2.1 发get请求
前言
requests模块，也就是老污龟，为啥叫它老污龟呢，因为这个官网上的logo就是这只污龟，接下来就是学习它了。
环境准备（小编环境）：
python:2.7.12
pycharm:5.0.4
requests:2.13.0
(这学本篇之前，先要有一定的python基础，因为后面都是直接用python写代码了，小编主要以讲接口为主，python基础东西就自己去补了）
一、环境安装
1.用pip安装requests模块
>>pip install requests
二、get请求
1.导入requests后，用get方法就能直接访问url地址，如：http://www.cnblogs.com/yoyoketang/，看起来是不是很酷
2.这里的r也就是response，请求后的返回值，可以调用response里的status_code方法查看状态码
3.状态码200只能说明这个接口访问的服务器地址是对的，并不能说明功能OK，一般要查看响应的内容，r.text是返回文本信息
三、params
1.再发一个带参数的get请求，如在博客园搜索：yoyoketang,url地址为：http://zzk.cnblogs.com/s/blogpost?Keywords=yoyoketang
2.请求参数：Keywords=yoyoketang，可以以字典的形式传参:{"Keywords": "yoyoketang"}
3.多个参数格式：{"key1": "value1", "key2": "value2", "key3": "value3"}
四、content
1.百度首页如果用r.text会发现获取到的内容有乱码，因为百度首页响应内容是gzip压缩的（非text文本）
2.如果是在fiddler工具乱码，是可以点击后解码的，在代码里面可以用r.content这个方法，content会自动解码 gzip 和deflate压缩
五、response
1.response的返回内容还有其它更多信息
-- r.status_code #响应状态码
-- r.content #字节方式的响应体，会自动为你解码 gzip 和 deflate 压缩
-- r.headers #以字典对象存储服务器响应头，但是这个字典比较特殊，字典键不区分大小写，若键不存在则返回None
-- r.json() #Requests中内置的JSON解码器
-- r.url # 获取url
-- r.encoding # 编码格式
-- r.cookies # 获取cookie
-- r.raw #返回原始响应体
-- r.text #字符串方式的响应体，会自动根据响应头部的字符编码进行解码
-- r.raise_for_status() #失败请求(非200响应)抛出异常
2.2 发post请求（json）
前言
发送post的请求参考例子很简单，实际遇到的情况却是很复杂的，首先第一个post请求肯定是登录了，但登录是最难处理的。登录问题解决了，后面都简单了。
一、查看官方文档
1.学习一个新的模块，其实不用去百度什么的，直接用help函数就能查看相关注释和案例内容。
>>import requests
>>help(requests)
2.查看python发送get和post请求的案例
>>> import requests
>>> r = requests.get('https://www.python.org')
>>> r.status_code
200
>>> 'Python is a programming language' in r.content
True
... or POST:
>>> payload = dict(key1='value1', key2='value2')
>>> r = requests.post('http://httpbin.org/post', data=payload)
>>> print(r.text)
{
...
"form": {
"key2": "value2",
"key1": "value1"
},
...
}
二、发送post请求
1.用上面给的案例，做个简单修改，发个post请求
2.payload参数是字典类型，传到如下图的form里
三、json
1.post的body是json类型，也可以用json参数传入。
2.先导入json模块，用dumps方法转化成json格式。
3.返回结果，传到data里。
四、headers
1.以博客园为例，模拟登陆，实际的情况要比上面讲的几个基本内容要复杂很多，一般登陆涉及安全性方面，登陆会比较复杂
2.这里需添加请求头headers,可以用fiddler抓包
3.将请求头写成字典格式
headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64; rv:44.0) Gecko/20100101 Firefox/44.0",
"Accept": "application/json, text/javascript, */*; q=0.01",
"Accept-Language": "zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3",
"Accept-Encoding": "gzip, deflate, br",
"Content-Type": "application/json; charset=utf-8",
"X-Requested-With": "XMLHttpRequest",
"Cookie": "xxx.............", # 此处cookie省略了
"Connection": "keep-alive"
}
五、登陆博客园
1.由于这里是https请求，直接发送请求会报错误:SSLError: [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed (_ssl.c:590)
2.可以加个参数：verify=False，表示忽略对 SSL 证书的验证
3.这里请求参数payload是json格式的，用json参数传
4.红色注释那两行可以不用写
5.最后结果是json格式，可以直接用r.json返回json数据：{u'success': True}
六、参考代码
# coding:utf-8
import requests
url = "https://passport.cnblogs.com/user/signin"
headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64; rv:44.0) Gecko/20100101 Firefox/44.0",
"Accept": "application/json, text/javascript, */*; q=0.01",
"Accept-Language": "zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3",
"Accept-Encoding": "gzip, deflate, br",
"Content-Type": "application/json; charset=utf-8",
# "VerificationToken": "",
"X-Requested-With": "XMLHttpRequest",
# "Referer": "",
"Content-Length": "",
"Cookie": "xxx...", # 此处省略
"Connection": "keep-alive"
}
payload = {"input1":"xxx",
"input2":"xxx",
"remember":True}
r = requests.post(url, json=payload, headers=headers,verify=False)
print r.json()
2.3 发post请求（data）
前言：
前面登录博客园的是传json参数，有些登录不是传json的，如jenkins的登录，本篇以jenkins登录为案例，传data参数。
一、登录jenkins抓包
1.登录jenkins，输入账号和密码
2.fiddler抓包
3.这个body参数并不是json格式，是key=value格式，也就是前面介绍post请求四种数据类型里面的第二种
二、请求头部
1.上面抓包已经知道body的数据类型了，那么头部里面Content-Type类型也需要填写对应的参数类型
三、实现登录
1、登录代码如下：
# coding:utf-8
import requests
# 先打开登录首页，获取部分cookie
url = "http://localhost:8080/jenkins/j_acegi_security_check"
headers = {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64; rv:44.0) Gecko/20100101 Firefox/44.0"
} # get方法其它加个ser-Agent就可以了
d = {"from": "",
"j_password": "f7bcd85ebab14e2fbb6d76cc99bc5c6a",
"j_username": "admin",
"Jenkins-Crumb": "e677c237181756818cbbccd4296d44f1",
"json": {"j_username": "admin",
"j_password": "f7bcd85ebab14e2fbb6d76cc99bc5c6a",
"remember_me": True,
"from": "",
"Jenkins-Crumb": "e677c237181756818cbbccd4296d44f1"},
"remember_me": "on",
"Submit": u"登录"
}
s = requests.session()
r = s.post(url, headers=headers, data=d)
print r.content
2.打印结果
四、判断登录是否成功
1.首先这个登录接口有重定向，看左边会话框302，那登录成功的结果看最后一个200就行
2.返回的结果并不是跟博客园一样的json格式，返回的是一个html页面
五、判断登录成功
1.判断登录成功，可以抓取页面上的关键元素，比如：账号名称admin，注销按钮
2.通过正则表达式提出这2个关键字
六、参考代码
# coding:utf-8
import requests
# 先打开登录首页，获取部分cookie
url = "http://localhost:8080/jenkins/j_acegi_security_check"
headers = {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64; rv:44.0) Gecko/20100101 Firefox/44.0"
} # get方法其它加个ser-Agent就可以了
d = {"from": "",
"j_password": "f7bcd85ebab14e2fbb6d76cc99bc5c6a",
"j_username": "admin",
"Jenkins-Crumb": "e677c237181756818cbbccd4296d44f1",
"json": {"j_username": "admin",
"j_password": "f7bcd85ebab14e2fbb6d76cc99bc5c6a",
"remember_me": True,
"from": "",
"Jenkins-Crumb": "e677c237181756818cbbccd4296d44f1"},
"remember_me": "on",
"Submit": u"登录"
}
s = requests.session()
r = s.post(url, headers=headers, data=d)
# 正则表达式提取账号和登录按钮
import re
t = re.findall(r'<b>(.+?)</b>', r.content) # 用python3的这里r.content需要解码
print t[0]
print t[1]
2.4 data和json傻傻分不清
前言
在发post请求的时候，有时候body部分要传data参数，有时候body部分又要传json参数，那么问题来了：到底什么时候该传json，什么时候该传data?
一、识别json参数
1.在前面1.8章节讲过，post请求的body通常有四种类型，最常见的就是json格式的了，这个还是很好识别的
2.用抓包工具查看，首先点开Raw去查看body部分，如下图这种，参数最外面是大括号{ }包起来的，这种已经确诊为json格式了。
3.再一次确认，可以点开Json这一项查看，点开之后可以看到这里的几组参数是json解析后的（记住它的样子）
4.这时候，就可以用前面2.2讲的传json参数
二、识别data参数
1.data参数也就是这种格式：key1=value1&key2=value2...这种格式很明显没有大括号
点开Raw查看，跟上面的json区别还是很大的
2.因为这个是非json的，所以点开Json这个菜单是不会有解析的数据的，这种数据在WebForms里面查看
3.可以看到这种参数显示在Body部分，左边的Name这项就是key值，右边的Value就是对应的value值，像这种参数转化从python的字典格式就行了
4.这一种发post时候就传data参数就可以了，格式如下：
s = requests.session()
r = s.post(url, headers=headers, data=d) # 这里的d就是上一步的字典格式的参数
现在能分得清data参数和json参数的不？
2.5 发https请求（ssl）
前言
本来最新的requests库V2.13.0是支持https请求的，但是一般写脚本时候，我们会用抓包工具fiddler，这时候会 报：requests.exceptions.SSLError: [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed (_ssl.c:590)
小编环境：
python：2.7.12
requests：2.13.0
fiddler：v4.6.2.0
一、SSL问题
1.不启用fiddler，直接发https请求，不会有SSL问题（也就是说不想看到SSL问题，关掉fiddler就行）
2.启动fiddler抓包，会出现这个错误：requests.exceptions.SSLError: [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed (_ssl.c:590)
二、verify参数设置
1.Requests的请求默认verify=True
2.如果你将 verify设置为 False，Requests 也能忽略对 SSL 证书的验证
3.但是依然会出现两行Warning,可以不用管
三、忽略Warning
1.有些小伙伴有强迫症看到红色的心里就发慌，这里加两行代码可以忽略掉警告，眼不见为净！
2.参考代码：
# coding:utf-8
import requests
# 禁用安全请求警告
from requests.packages.urllib3.exceptions import InsecureRequestWarning
requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
url = "https://passport.cnblogs.com/user/signin"
headers = {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64; rv:44.0) Gecko/20100101 Firefox/44.0"
}
r = requests.get(url, headers=headers, verify=False)
print(r.status_code)
2.6 session关联接口
前言
上一篇模拟登录博客园，但这只是第一步，一般登录后，还会有其它的操作，如发帖，评论等，这时候如何保持会话呢？
一、session简介
1.查看帮助文档,贴了一部分，后面省略了
>>import requests
>>help(requests.session())
class Session(SessionRedirectMixin)
| A Requests session.
|
| Provides cookie persistence, connection-pooling, and configuration.
|
| Basic Usage::
|
| >>> import requests
| >>> s = requests.Session()
| >>> s.get('http://httpbin.org/get')
| <Response [200]>
|
| Or as a context manager::
|
| >>> with requests.Session() as s:
| >>> s.get('http://httpbin.org/get')
| <Response [200]>
二、使用session登录
1.使用session登录只需在上一篇基础上稍做修改
# coding:utf-8
import requests
url = "https://passport.cnblogs.com/user/signin"
headers = {
#头部信息已省略
}
payload = {"input1":"xxx",
"input2":"xxx",
"remember":True}
# r = requests.post(url, json=payload, headers=headers,verify=False)
# 修改后如下
s = requests.session()
r = s.post(url, json=payload, headers=headers,verify=False)
print r.json()
三、保存编辑
1.先打开我的随笔，手动输入内容后，打开fiddler抓包
2.把body的参数内容写成字典格式，有几个空的参数不是必填的，可以去掉
body = {"__VIEWSTATE": "",
"__VIEWSTATEGENERATOR":"FE27D343",
"Editor$Edit$txbTitle":"这是我的标题：上海-悠悠",
"Editor$Edit$EditorBody":"<p>这里是中文内容：http://www.cnblogs.com/yoyoketang/</p>",
"Editor$Edit$Advanced$ckbPublished":"on",
"Editor$Edit$Advanced$chkDisplayHomePage":"on",
"Editor$Edit$Advanced$chkComments":"on",
"Editor$Edit$Advanced$chkMainSyndication":"on",
"Editor$Edit$lkbDraft":"存为草稿",
}
3.用上面的session继续发送post请求
4.执行后，查看我的草稿箱就多了一条新增的了
四、参考代码
# coding:utf-8
import requests
url = "https://passport.cnblogs.com/user/signin"
headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64; rv:44.0) Gecko/20100101 Firefox/44.0",
"Accept": "application/json, text/javascript, */*; q=0.01",
"Accept-Language": "zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3",
"Accept-Encoding": "gzip, deflate, br",
"Content-Type": "application/json; charset=utf-8",
# "VerificationToken": "xxx...", # 已省略
"X-Requested-With": "XMLHttpRequest",
# "Referer":
"https://passport.cnblogs.com/user/signin?ReturnUrl=http%3a%2f%2fmsg.cnblogs.com%2fsend%2f%e4%b8%8a%e6%b5%b7-%e6%82%a0%e6%82%a0",
"Content-Length": "",
"Cookie": "xxx.....", # 已省略
"Connection": "keep-alive"
}
# 登录的参数
payload = {"input1":"xxx",
"input2":"xxx",
"remember":True}
s = requests.session()
r = s.post(url, json=payload, headers=headers,verify=False)
print r.json()
# 保存草稿箱
url2= "https://i.cnblogs.com/EditPosts.aspx?opt=1"
body = {"__VIEWSTATE": "",
"__VIEWSTATEGENERATOR":"FE27D343",
"Editor$Edit$txbTitle":"这是我的标题：上海-悠悠",
"Editor$Edit$EditorBody":"<p>这里是中文内容：http://www.cnblogs.com/yoyoketang/</p>",
"Editor$Edit$Advanced$ckbPublished":"on",
"Editor$Edit$Advanced$chkDisplayHomePage":"on",
"Editor$Edit$Advanced$chkComments":"on",
"Editor$Edit$Advanced$chkMainSyndication":"on",
"Editor$Edit$lkbDraft":"存为草稿",
}
r2 = s.post(url2, data=body, verify=False)
print r.content
这里我是用保存草稿箱写的案例，小伙伴们可以试下自动发帖
（备注：别使用太频繁了哦，小心封号嘿嘿！！！）
2.7 cookie绕过验证码登录
前言
有些登录的接口会有验证码：短信验证码，图形验证码等，这种登录的话验证码参数可以从后台获取的（或者查数据库最直接）。
获取不到也没关系，可以通过添加cookie的方式绕过验证码。
（注意：并不是所有的登录都是用cookie来保持登录的，有些是2.11章节讲的token）
一、抓登录cookie
1.如博客园登录后会生成一个已登录状态的cookie，那么只需要直接把这个值添加到cookies里面就可以了。
2.可以先手动登录一次，然后抓取这个cookie，这里就需要用抓包工具fiddler了
3.先打开博客园登录界面，手动输入账号和密码（勾选下次自动登录）
4.打开fiddler抓包工具，刷新下登录首页，就是登录前的cookie了
5.登录成功后，再查看cookie变化，发现多了两组参数，多的这两组参数就是我们想要的，copy出来，一会有用
二、cookie组成结构
1.用抓包工具fidller只能看到cookie的name和value两个参数，实际上cookie还有其它参数
2.以下是一个完整的cookie组成结构
cookie ={u'domain': u'.cnblogs.com',
u'name': u'.CNBlogsCookie',
u'value': u'xxxx',
u'expiry': 1491887887,
u'path': u'/',
u'httpOnly': True,
u'secure': False}
name：cookie的名称
value：cookie对应的值，动态生成的
domain：服务器域名
expiry：Cookie有效终止日期
path：Path属性定义了Web服务器上哪些路径下的页面可获取服务器设置的Cookie
httpOnly：防脚本攻击
secure:在Cookie中标记该变量，表明只有当浏览器和Web Server之间的通信协议为加密认证协议时，
浏览器才向服务器提交相应的Cookie。当前这种协议只有一种，即为HTTPS。
三、添加cookie
1.往session里面添加cookie可以用以下方式
2.set里面参数按括号里面的参数格式
coo = requests.cookies.RequestsCookieJar()
coo.set('cookie-name', 'cookie-value', path='/', domain='.xxx.com')
s.cookies.update(c)
3.于是添加登录的cookie，把第一步fiddler抓到的内容填进去就可以了
c = requests.cookies.RequestsCookieJar()
c.set('.CNBlogsCookie', 'xxx')
c.set('.Cnblogs.AspNetCore.Cookies','xxx')
s.cookies.update(c)
print(s.cookies)
四、参考代码
1.由于登录时候是多加2个cookie，我们可以先用get方法打开登录首页，获取部分cookie
2.再把登录需要的cookie添加到session里
3.添加成功后，随便编辑正文和标题保存到草稿箱
# coding:utf-8
import requests
# 先打开登录首页，获取部分cookie
url = "https://passport.cnblogs.com/user/signin"
headers = {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64; rv:44.0) Gecko/20100101 Firefox/44.0"
} # get方法其它加个ser-Agent就可以了
s = requests.session()
r = s.get(url, headers=headers,verify=False)
print s.cookies
# 添加登录需要的两个cookie
c = requests.cookies.RequestsCookieJar()
c.set('.CNBlogsCookie', 'xxx') # 填上面抓包内容
c.set('.Cnblogs.AspNetCore.Cookies','xxx') # 填上面抓包内容
s.cookies.update(c)
print s.cookies
# 登录成功后保存编辑内容
url2= "https://i.cnblogs.com/EditPosts.aspx?opt=1"
body = {"__VIEWSTATE": "",
"__VIEWSTATEGENERATOR":"FE27D343",
"Editor$Edit$txbTitle":"这是绕过登录的标题：上海-悠悠",
"Editor$Edit$EditorBody":"<p>这里是中文内容：http://www.cnblogs.com/yoyoketang/</p>",
"Editor$Edit$Advanced$ckbPublished":"on",
"Editor$Edit$Advanced$chkDisplayHomePage":"on",
"Editor$Edit$Advanced$chkComments":"on",
"Editor$Edit$Advanced$chkMainSyndication":"on",
"Editor$Edit$lkbDraft":"存为草稿",
}
r2 = s.post(url2, data=body, verify=False)
print r.content
2.8 json数据处理
前言
有些post的请求参数是json格式的，这个前面第二篇post请求里面提到过，需要导入json模块处理。
一般常见的接口返回数据也是json格式的，我们在做判断时候，往往只需要提取其中几个关键的参数就行，这时候就需要json来解析返回的数据了。
一、json模块简介
1.Json简介：Json，全名 JavaScript Object Notation，是一种轻量级的数据交换格式,常用于http请求中
2.可以用help(json),查看对应的源码注释内容：
Encoding basic Python object hierarchies::
>>> import json
>>> json.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}])
'["foo", {"bar": ["baz", null, 1.0, 2]}]'
>>> print json.dumps("\"foo\bar")
"\"foo\bar"
>>> print json.dumps(u'\u1234')
"\u1234"
>>> print json.dumps('\\')
"\\"
>>> print json.dumps({"c": 0, "b": 0, "a": 0}, sort_keys=True)
{"a": 0, "b": 0, "c": 0}
>>> from StringIO import StringIO
>>> io = StringIO()
>>> json.dump(['streaming API'], io)
>>> io.getvalue()
'["streaming API"]'
二、Encode（python->json）
1.首先说下为什么要encode，python里面bool值是True和False,json里面bool值是true和false,并且区分大小写，这就尴尬了，明明都是bool值。
在python里面写的代码，传到json里，肯定识别不了，所以需要把python的代码经过encode后成为json可识别的数据类型。
2.举个简单例子，下图中dict类型经过json.dumps（）后变成str，True变成了true,False变成了fasle
3.以下对应关系表是从json模块的源码里面爬出来的.python的数据类，经过encode成json的数据类型，对应的表如下：
| | Python | JSON |
| +===================+===============+
| | dict | object |
| +-------------------+---------------+
| | list, tuple | array |
| +-------------------+---------------+
| | str, unicode | string |
| +-------------------+---------------+
| | int, long, float | number |
| +-------------------+---------------+
| | True | true |
| +-------------------+---------------+
| | False | false |
| +-------------------+---------------+
| | None | null |
| +-------------------+---------------+
三、decode(json->python)
1.以第三篇的登录成功结果：{"success":true}为例，我们其实最想知道的是success这个字段返回的是True还是False
2.如果以content字节输出，返回的是一个字符串：{"success":true}，这样获取后面那个结果就不方便了
3.如果经过json解码后，返回的就是一个字典：{u'success': True}，这样获取后面那个结果，就用字典的方式去取值：result2["success"]
4.同样json数据转化成python可识别的数据，对应的表关系如下
| +---------------+-------------------+
| | JSON | Python |
| +===============+===================+
| | object | dict |
| +---------------+-------------------+
| | array | list |
| +---------------+-------------------+
| | string | unicode |
| +---------------+-------------------+
| | number (int) | int, long |
| +---------------+-------------------+
| | number (real) | float |
| +---------------+-------------------+
| | true | True |
| +---------------+-------------------+
| | false | False |
| +---------------+-------------------+
| | null | None |
| +---------------+-------------------+
四、案例分析
1.比如打开快递网：http://www.kuaidi.com/，搜索某个单号，判断它的状态是不是已签收
2. 实现代码如下
五、参考代码：
# coding:utf-8
import requests
url = "http://www.kuaidi.com/index-ajaxselectcourierinfo-1202247993797-yunda.html"
headers = {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64; rv:44.0) Gecko/20100101 Firefox/44.0"
} # get方法其它加个User-Agent就可以了
s = requests.session()
r = s.get(url, headers=headers,verify=False)
result = r.json()
data = result["data"] # 获取data里面内容
print data
print data[0] # 获取data里最上面的那个
get_result = data[0]['context'] # 获取已签收状态
print get_result
if u"已签收" in get_result:
print "快递单已签收成功"
else:
print "未签收"
2.9 重定向Location
前言
某屌丝男A鼓起勇气向女神B打电话表白，女神B是个心机婊觉得屌丝男A是好人，不想直接拒绝于是设置呼叫转移给闺蜜C了，最终屌丝男A和女神闺蜜C表白成功了，这种场景其实就是重定向了。
一、重定向
1. (Redirect)就是通过各种方法将各种网络请求重新定个方向转到其它位置,从地址A跳转到地址B了。
2.重定向状态码:
--301 redirect: 301 代表永久性转移(Permanently Moved)
--302 redirect: 302 代表暂时性转移(Temporarily Moved )
3.举个简单的场景案例，先登录博客园打开我的博客首页，进我的随笔编辑界面，记住这个地址：https://i.cnblogs.com/EditPosts.aspx?opt=1
4.退出博客园登录，把刚才我的随笔这个地址输入浏览器回车，抓包会看到这个请求状态码是302，浏览器地址栏瞬间刷新跳到登录首页去了
二、禁止重定向（allow_redirects）
1.用get方法请求：https://i.cnblogs.com/EditPosts.aspx?opt=1
2.打印状态码是200，这是因为requets库自动处理了重定向请求了
3.自动处理重定向地址后，我们就获取不到重定向后的url了，就无法走下一步，这里我们可以设置一个参数禁止重定向：allow_redirects=False
（allow_redirects=True是启动重定向），然后就可以看到status_code是302了
三、获取重定向后地址
1.在第一个请求后，服务器会下发一个新的请求链接，在response的headers里，如下抓包：Location
2.用脚本去获取Location地址
四、参考代码：
# coding:utf-8
import requests
# 请求头
headers = {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64; rv:44.0) Gecko/20100101 Firefox/44.0"
}
s = requests.session()
# 打开我的随笔
r = s.get('https://i.cnblogs.com/EditPosts.aspx?opt=1',
headers=headers,
allow_redirects=True,
verify=False)
# 打印状态码，自动处理重定向请求
print r.status_code
new_url = r.headers["Location"]
print new_url
2.10 参数关联
前言
我们用自动化发帖之后，要想接着对这篇帖子操作，那就需要用参数关联了，发帖之后会有一个帖子的id，获取到这个id，继续操作传这个帖子id就可以了
一、删除草稿箱
1.我们前面讲过登录后保存草稿箱，那可以继续接着操作：删除刚才保存的草稿
2.用fiddler抓包，抓到删除帖子的请求，从抓包结果可以看出，传的json参数是postId
3.这个postId哪里来的呢？可以看上个请求url地址
4.也就是说保存草稿箱成功之后，重定向一个url地址，里面带有postId这个参数。那接下来我们提取出来就可以了
二、提取参数
1.我们需要的参数postId是在保存成功后url地址，这时候从url地址提出对应的参数值就行了，先获取保存成功后url
2.通过正则提取需要的字符串，这个参数值前面（postid=）和后面（&）字符串都是固定的
3.这里正则提出来的是list类型，取第一个值就可以是字符串了（注意：每次保存需要修改内容，不能重复）
三，传参
1.删除草稿箱的json参数传上面取到的参数：{"postId": postid[0]}
2.json数据类型post里面填json就行，会自动转json
3.接着前面的保存草稿箱操作，就可以删除成功了
四、参考代码
# coding:utf-8
import requests
url = "https://passport.cnblogs.com/user/signin"
headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64; rv:44.0) Gecko/20100101 Firefox/44.0",
"Accept": "application/json, text/javascript, */*; q=0.01",
"Accept-Language": "zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3",
"Accept-Encoding": "gzip, deflate, br",
"Content-Type": "application/json; charset=utf-8",
"X-Requested-With": "XMLHttpRequest",
"Content-Length": "",
"Cookie": "xxx已省略",
"Connection": "keep-alive"
}
payload = {
"input1": "xxx",
"input2": "xxx",
"remember": True}
# 第一步：session登录
s = requests.session()
r = s.post(url, json=payload, headers=headers, verify=False)
print r.json()
# 第二步：保存草稿
url2 = "https://i.cnblogs.com/EditPosts.aspx?opt=1"
body = {"__VIEWSTATE": "",
"__VIEWSTATEGENERATOR": "FE27D343",
"Editor$Edit$txbTitle": "这是我的标题：上海-悠悠",
"Editor$Edit$EditorBody": "<p>这里是中文内容：http://www.cnblogs.com/yoyoketang/</p>",
"Editor$Edit$Advanced$ckbPublished": "on",
"Editor$Edit$Advanced$chkDisplayHomePage": "on",
"Editor$Edit$Advanced$chkComments": "on",
"Editor$Edit$Advanced$chkMainSyndication": "on",
"Editor$Edit$lkbDraft": "存为草稿",
}
r2 = s.post(url2, data=body, verify=False)
# 获取当前url地址
print r2.url
# 第三步：正则提取需要的参数值
import re
postid = re.findall(r"postid=(.+?)&", r2.url)
print postid # 这里是list
# 提取为字符串
print postid[0]
# 第四步：删除草稿箱
url3 = "https://i.cnblogs.com/post/delete"
json3 = {"postId": postid[0]}
r3 = s.post(url3, json=json3, verify=False)
print r3.json()
2.11 token登录
前言
有些登录不是用cookie来验证的，是用token参数来判断是否登录。
token传参有两种一种是放在请求头里，本质上是跟cookie是一样的，只是换个单词而已；另外一种是在url请求参数里，这种更直观。
一、登录返回token
1.如下图的这个登录，无cookies
2.但是登录成功后有返回token
二、请求头带token
1.登录成功后继续操作其它页面，发现post请求的请求头，都会带token参数
2.这种请求其实比cookie更简单，直接把登录后的token放到头部就行
三、token关联
1.用脚本实现登录，获取token参数，获取后传参到请求头就可以了
2.如果登录有验证码，前面的脚本登录步骤就省略了，自己手动登录后获取token
# coding:utf-8
import requests
header = { # 登录抓包获取的头部
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64; rv:44.0) Gecko/20100101 Firefox/44.0",
"Accept": "*/*",
"Accept-Language": "zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3",
"Accept-Encoding": "gzip, deflate",
"Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
"X-Requested-With": "XMLHttpRequest",
"Content-Length": "",
"Connection": "keep-alive"
}
body = {"key1": "value1",
"key2": "value2"} # 这里账号密码就是抓包的数据
s = requests.session()
login_url = "http://xxx.login" # 自己找带token网址
login_ret = s.post(login_url, headers=header, data=body)
# 这里token在返回的json里，可以直接提取
token = login_ret.json()["token"]
# 这是登录后发的一个post请求
post_url = "http://xxx"
# 添加token到请求头
header["token"] = token
# 如果这个post请求的头部其它参数变了，也可以直接更新
header["Content-Length"]=""
body1 = {
"key": "value"
}
post_ret = s.post(post_url, headers=header, data=body1)
print post_ret.content
2.12登录案例分析(csrfToken)
前言：
有些网站的登录方式跟前面讲的博客园cookies登录和token登录会不一样，把csrfToken放到cookies里，登录前后cookies是没有任何变化的，这种情况下如何绕过前端的验证码登录呢？
一、登录前后对比
1.如果登录页面有图形验证码，这种我们一般都是绕过登录的方式，如下图通过抓包分析，首先不输入密码，抓包
（由于这个是别人公司内部网站，所以网址不能公开，仅提供解决问题的思路）
2.在登录页面输入账号和密码手动登录后，抓包信息如下
3.抓包后cookies信息在登录前后没任何变化,这里主要有三个参数:
--businessUsername:这个是账号名称
--JSESSIONID: 这个是一串字符串，主要看这个会不会变（一般有有效期）copy出来就行
--csrfToken: 这个是一串字符串，主要看这个会不会变（一般有有效期）copy出来就行
二、get请求
1.像这种登录方式的get请求，请求头部cookie没任何变化，这种可以直接忽略登录，不用管登录过程，直接发请求就行
2.代码实现
# coding:utf-8
import requests
# 优惠券列表
url = 'http://xxx/xxx/coupon/list'
h = {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64; rv:44.0) Gecko/20100101 Firefox/44.0",
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
"Accept-Language": "zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3",
"Accept-Encoding": "gzip, deflate",
"Cookie": "csrfToken=xxx(复制抓包的信息); JSESSIONID=xxx(复制抓包的信息); businessUsername=（用户名）",
"Connection": "keep-alive"
}
r = requests.get(url, headers=h)
print r.content
三、post请求遇到的坑
1.post请求其实也可以忽略登录的过程，直接抓包把cookie里的三个参数(businessUsername、JSESSIONID、csrfToken）加到头部也是可以的。
2.但是这里遇到一个坑:用Composer发请求，重定向回到登录页了
3.主要原因：重定向的请求，cookie参数丢失了
四、重定向
1.解决上面问题，其实很简单，把重定向禁用（具体看2.8重定向Location这篇）后的链接获取到，重新发个get请求，头部带上cookies的三个参数就行了
# coding:utf-8
import requests
# 主要是post请求后重定向，cookie丢失，所以回到登录页面了
# 解决办法，禁止重定向，获取重定向的url后，重新发重定向的url地址请求就行了
# 三个主要参数
csrfToken = '获取到的csrftoken，一般有有效期的'
jsessionId = '获取到的jsessionid'
userName = '用户名'
url = 'http://xxx/xxxx/update'
h1 = {
"User-Agent": "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:46.0) Gecko/20100101 Firefox/46.0",
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
"Accept-Language": "zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3",
"Accept-Encoding": "gzip, deflate",
"Cookie": "csrfToken=%s; JSESSIONID=%s; businessUsername=%s" % (csrfToken, jsessionId, userName),
"Connection": "keep-alive",
"Content-Type": "application/x-www-form-urlencoded",
"Content-Length": ""
}
body = {"instantMessageId":"",
"name": u"哈哈1",
"order": "",
"csrfToken": csrfToken,
"type": "qq",
"account": ""}
s = requests.session()
r1 = s.post(url, headers=h1, data=body, allow_redirects=False)
print r1.status_code
# 获取重定向的url地址
redirect_url = r1.headers["Location"]
print redirect_url
h2 = {
"User-Agent": "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:46.0) Gecko/20100101 Firefox/46.0",
"Accept":
"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
"Accept-Language": "zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3",
"Accept-Encoding": "gzip, deflate",
"Cookie": "csrfToken=%s; JSESSIONID=%s; businessUsername=%s" % (csrfToken, jsessionId, userName),
"Connection": "keep-alive"
}
r2 = s.get(redirect_url, headers=h2)
print r2.content