requests 实践

Requests 常用参数

method： 请求方式 get，或者 post，put，delete 等
url : 请求的 url 地址 接口文档标注的接口请求地址
params：请求数据中的链接，常见的一个 get 请求，请求参数都是在 url 地址中
data ：请求数据，参数 表单的数据格式
json： 接口常见的数据请求格式（当python dict中有 True,False时，使用json=data传输，会自动转成true,false）
headers：请求头信息，http 请求中，比如说编码方式，token等内容添加
cookie：保存的用户登录信息，比如做一些充值功能，但是需要用户已经登录，需要 cookie 信息的请求信息传输
file：接口中上传文件
timeout ：超时处理 proxys 设置代理
stream ：文件下载功能，通过请求方式，下载文件

json参考：https://blog.csdn.net/m0_67695717/article/details/131793666

Response 响应内容

r.encoding #获取当前的编码
r.encoding = ‘utf-8’ #设置编码
r.text #以encoding解析返回内容。字符串方式的响应体，会自动根据响应头部的字符编码进行解码。
r.cookies #返回cookie
r.headers #以字典对象存储服务器响应头，但是这个字典比较特殊，字典键不区分大小写，若键不存在则返回None
r.status_code #响应状态码
r.json() #Requests中内置的JSON解码器，以json形式返回,前提返回的内容确保是json格式的，不然解析出错会抛异常
r.content #以字节形式（二进制）返回。字节方式的响应体，会自动为你解码 gzip 和 deflate 压缩。

Post 请求

# 导入requests包
import requests
 
url = "http://localhost:65375/Login/Demo"
mydata = {"BanJName": str(vido_me), "NianJiBH": "112", "BianHao": "11", "ZuZhi": "123"}  # 字典格式，推荐使用，它会自动帮你按照k-v拼接url
res = requests.post(url=url, data=mydata)
 
print('url:', res.request.body)  # 查看发送的url
print("response:", res.text)  # 返回请求结果
1
2
3
4
5
6
7
8
9

Get 请求

# 导入requests包
import requests
 
url = "http://www.tuling123.com/openapi/api"
myParams = {"key":"username","info":"plusroax"} # 字典格式，推荐使用，它会自动帮你按照k-v拼接url
res = requests.get(url=url, params=myParams)

print('url:',res.request.url)# 查看发送的url
print("response:",res.text)  # 返回请求结果
1
2
3
4
5
6
7
8
9

Https 请求

当协议是 https 的协议的时候，有些系统，需要校验 https 证书，如果校验失败，可能会有警告提示等信息。

import requests 
url="https://www.ctrip.com/" 
# 解决方案 
# 发送请求时候忽略证书，证书的参数 verify-用的比较多 
r=requests.get(url=url,verify=False) #verify 参数默认为 True，值为 False 表示忽略证书 
print (r.text) 
#第二种解决方案，verify 里面添加证书的路径 
r=requests.get(url=url,verify='证书的路径') 
print (r.text)
1
2
3
4
5
6
7
8
9

上传文件

import requests

url = 'https://127.0.0.1:8000/UploadPhoto'  
#filename 为 liang.jpg 文件
#open('D:\\test_data\\liang.jpg','rb') 打开本地的一个文件 
files = {'file':open('D:\\test_data\\liang.jpg','rb')}
r=requests.post(url=url,files=files,verify=False) 
print (r.text)
1
2
3
4
5
6
7
8

Requests 中 timeout 参数

1、python 的requests请求都可以使用timeout参数。
2、timeout参数可以传入一个简单的浮点数，它将请求的连接部分和读取部分设为相同的超时时间。
3、timeout参数也可以传入一个包含两个简单浮点数的元组，用来分别设置请求超时时间和读取超时时间。
4、参数值设为None或者不设置该参数为一直等待，知道请求成功或错误

url = "http://127.0.0.1:66753/login"
# 表单数据格式，参数 data ，数据都是字典去保存
data = {"username": "liang001", "password": "123456"}
r_login = requests.post(url=url, json=data, timeout=0.5)
print(r_login.text)
1
2
3
4
5

访问需要登录的界面

# 导入requests包
import requests

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.87 Safari/537.36 SE 2.X MetaSr 1.0'
}
session = requests.session()
# 1.代码登录
login_url = url
login_form_data = {
        'UserName': name, # 登录用户名
        'PassWord': pwd,  # 登录密码
    }
login_resopnse = session.post(login_url, data=login_form_data, headers=headers)
# 2.登录成功后，带着有效的cookie访问member_url
files = {'file': open(r'路径', 'rb')}
member_url = 'url'
member_data = session.post(member_url, headers=headers, files=files)

print(member_data.text)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

Requests 文件下载

普通下载

1. 对于非文本请求，我们可以通过 Response 对象的 content 属性以字节的方式访问请求响应体。
   【注意】这种模式只能下载小文件。因为在这种模式下，从服务器接收到的数据是一直储存在内存中，write 时才写入硬盘，如果文件很大，那么所占用的内存也是很大的。
2. 下面将一张网络上的图片下载到本地并保存（文件名不变）：

import requests

url = 'http://www.hangge.com/blog/images/logo.png'
response = requests.get(url)  # 此时在内存为response响应对象开辟空间，从服务器返回的数据也是一直存储在内存中中
with open("logo.png", "wb") as code:
    code.write(response.content)  # 调用write方法时将内存中的二进制数据写入硬盘
1
2
3
4
5
6

当响应体数据量过大时，立即下载会占用系统大量内存
默认情况下，进行网络请求后，接口响应体会立即被下载。可以通过 stream 参数覆盖该行为，推迟下载响应体直到访问 Response.content 属性。请求后不立即下载响应体，而是先下载响应头，当访问 resonse.content 字节码内容的时候才会下载响应体。

import requests

url = 'https://github.com/kennethreitz/requests/tarball/master'
response = requests.get(url, stream=True)
# 注意，此时仅有响应头被下载下来了，连接保持打开状态，因此允许我们可以根据某些限制条件获取接口响应二进制内容：
if int(response.headers['content-length']) < TOO_LONG:
  content = response.content # 此时开始下载响应体
  ...
1
2
3
4
5
6
7
8

流式下载

下面代码我们改成流式下载，即边下载边保存。这种方式适合用来下载大文件。使用该方法下载大文件可以防止占用过多的内存，因为每次只下载小部分数据。

import requests

load_url = 'http://docs.python-requests.org/zh_CN/latest/_static/requests-sidebar.png'

response = requests.get(url=load_url, stream=True)
with open("D:\\python.png","wb") as f:
    for chunk in response.iter_content(chunk_size=1024):
        f.write(chunk)
1
2
3
4
5
6
7
8

stream 参数默认为 False，它会立即开始下载文件并放到内存中，如果文件过大，有可能导致内存不足。
stream 参数设置成 True 时，它不会立即开始下载，当你使用 iter_content 或 iter_lines 遍历二进制响应内容或访问内容属性时才开始下载。
iter_content ：一块一块的遍历要下载的内容。块大小是它应该循环每次读入内存的字节数【即 chunk_size=1024 ]。
iter_lines ：一行一行的遍历要下载的内容。decode_unicode=False，delimiter=b’\n\n’

带进度的文件下载

如果文件体积很大，下载时我们最好能实时显示当前的下载进度。
为方便使用应该封装一个下载方法（内部同样使用流式下载的方式）

import requests
from contextlib import closing

# 文件下载器
def down_load(file_url, file_path):
    with closing(requests.get(file_url, stream=True)) as response:
        chunk_size = 1024  # 单次请求最大值
        content_size = int(response.headers['content-length'])  # 内容体总大小
        data_count = 0
        with open(file_path, "wb") as file:
            for data in response.iter_content(chunk_size=chunk_size):
                file.write(data)
                data_count = data_count + len(data)
                now_jd = (data_count / content_size) * 100
                print("\r 文件下载进度：%d%%(%d/%d) - %s"% (now_jd, data_count, content_size, file_path), end=" ")

if __name__ == '__main__':
    fileUrl = 'http://www.hangge.com/hangge.zip'  # 文件链接
    filePath = "logo.zip"  # 文件路径
    down_load(fileUrl, filePath)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

带下载速度显示的文件下载

import requests
import time
from contextlib import closing

# 文件下载器
def down_load(file_url, file_path):
    start_time = time.time()  # 文件开始下载时的时间
    with closing(requests.get(file_url, stream=True)) as response:
        chunk_size = 1024  # 单次请求最大值
        content_size = int(response.headers['content-length'])  # 内容体总大小
        data_count = 0
        with open(file_path, "wb") as file:
            for data in response.iter_content(chunk_size=chunk_size):
                file.write(data)
                data_count = data_count + len(data)
                now_jd = (data_count / content_size) * 100
                speed = data_count / 1024 / (time.time() - start_time)
                print("\r 文件下载进度：%d%%(%d/%d) 文件下载速度：%dKB/s - %s" % (now_jd, data_count, content_size, speed, file_path), end=" ")

if __name__ == '__main__':
    fileUrl = 'http://www.hangge.com/hangge.zip'  # 文件链接
    filePath = "hangge.zip"  # 文件路径
    down_load(fileUrl, filePath)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

使用python的内置 urllib下载

使用python的内置 urllib 模块提供的 urlretrieve() 函数。

urlretrieve(url, [filename=None, [reporthook=None, [data=None]]])
# finename：指定了保存本地路径（如果参数未指定，urllib库 将会生成一个临时文件用以保存数据。）
# reporthook：是一个回调函数，当连接上服务器、以及相应的数据块传输完毕时会触发该回调，我们可以利用这个回调函数来显示当前的下载进度。
# data：是请求数据，该方法返回一个包含两个元素的 (filename, headers) 元组， filename  表示保存到本地的路径， header 表示服务器的响应头。 
1
2
3
4

实例

from urllib import request

load_url = 'http://docs.python-requests.org/zh_CN/latest/_static/requests-sidebar.png'

def Schedule(a,b,c):
    '''
    a:已经下载的数据块
    b:数据块的大小
    c:远程文件的大小
   '''
    per = 100.0 * a * b / c
    if per > 100 :
        per = 100
    print('%.2f%%' % per)

request.urlretrieve(url=load_url,filename='d:\\python.png',reporthook=Schedule)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

参考：
https://blog.csdn.net/qq_53193143/article/details/128240019