python requests接口自动化测试工具类文件封装，加上中文代码注释，提供实例

python requests接口自动化测试工具类文件封装，加上中文代码注释，提供200个实例

以下是一个Python Requests接口自动化测试工具类文件封装的示例，包括200个实例。这个工具类文件封装可以帮助您更方便地进行接口自动化测试。

方案1

# coding=utf-8
import requests
import json


class Request:
    """
    封装requests请求类
    """

    def __init__(self):
        """
        构造函数
        """
        self.headers = {}
        self.params = {}
        self.data = {}
        self.json = {}
        self.files = {}
        self.timeout = 30
        self.verify = False
        self.cookies = None

    def set_headers(self, headers):
        """
        设置请求头
        :param headers: 请求头字典
        :return:
        """
        self.headers = headers

    def set_params(self, params):
        """
        设置请求参数
        :param params: 请求参数字典
        :return:
        """
        self.params = params

    def set_data(self, data):
        """
        设置请求body
        :param data: 请求body字典
        :return:
        """
        self.data = data

    def set_json(self, json_data):
        """
        设置请求json数据
        :param json_data: 请求json数据字典
        :return:
        """
        self.json = json_data

    def set_files(self, files):
        """
        设置上传文件
        :param files: 上传文件字典
        :return:
        """
        self.files = files

    def set_timeout(self, timeout):
        """
        设置超时时间
        :param timeout: 超时时间
        :return:
        """
        self.timeout = timeout

    def set_verify(self, verify):
        """
        设置SSL证书验证
        :param verify: 是否验证SSL证书
        :return:
        """
        self.verify = verify

    def set_cookies(self, cookies):
        """
        设置请求cookies
        :param cookies: 请求cookies字典
        :return:
        """
        self.cookies = cookies

    def get(self, url):
        """
        发送get请求
        :param url: 请求url
        :return: 响应对象
        """
        response = requests.get(url=url, headers=self.headers, params=self.params, timeout=self.timeout,
                                verify=self.verify, cookies=self.cookies)
        return response

    def post(self, url):
        """
        发送post请求
        :param url: 请求url
        :return: 响应对象
        """
        response = requests.post(url=url, headers=self.headers, params=self.params, data=self.data, json=self.json,
                                 files=self.files, timeout=self.timeout, verify=self.verify, cookies=self.cookies)
        return response


class ApiTest:
    """
    接口测试类
    """

    def __init__(self):
        """
        构造函数
        """
        self.request = Request()

    def test_get(self, url, headers=None, params=None, cookies=None):
        """
        发送get请求
        :param url: 请求url
        :param headers: 请求头字典
        :param params: 请求参数字典
        :param cookies: 请求cookies字典
        :return: 响应对象
        """
        if headers:
            self.request.set_headers(headers)
        if params:
            self.request.set_params(params)
        if cookies:
            self.request.set_cookies(cookies)

        return self.request.get(url)

    def test_post(self, url, headers=None, params=None, data=None, json_data=None, files=None, cookies=None):
        """
        发送post请求
        :param url: 请求url
        :param headers: 请求头字典
        :param params: 请求参数字典
        :param data: 请求body字典
        :param json_data: 请求json数据字典
        :param files: 上传文件字典
        :param cookies: 请求cookies字典
        :return: 响应对象
        """
        if headers:
            self.request.set_headers(headers)
        if params:
            self.request.set_params(params)
        if data:
            self.request.set_data(data)
        if json_data:
            self.request.set_json(json_data)
        if files:
            self.request.set_files(files)
        if cookies:
            self.request.set_cookies(cookies)

        return self.request.post(url)


if __name__ == '__main__':
    api_test = ApiTest()

    # 1. 发送一个get请求，不带参数和请求头
    response = api_test.test_get('https://www.baidu.com')
    print('1. 发送一个get请求，不带参数和请求头')
    print(response.status_code)
    print(response.content.decode('utf-8'))

    # 2. 发送一个get请求，带参数，不带请求头
    response = api_test.test_get('https://www.baidu.com/s', params={'wd': 'python'})
    print('2. 发送一个get请求，带参数，不带请求头')
    print(response.status_code)
    print(response.content.decode('utf-8'))

    # 3. 发送一个get请求，带请求头，不带参数
    headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) '
                             'Chrome/58.0.3029.110 Safari/537.36 Edge/16.16299'}
    response = api_test.test_get('https://www.baidu.com', headers=headers)
    print('3. 发送一个get请求，带请求头，不带参数')
    print(response.status_code)
    print(response.content.decode('utf-8'))

    # 4. 发送一个get请求，带请求头和参数
    response = api_test.test_get('https://www.baidu.com/s', headers=headers, params={'wd': 'python'})
    print('4. 发送一个get请求，带请求头和参数')
    print(response.status_code)
    print(response.content.decode('utf-8'))

    # 5. 发送一个post请求，不带参数和请求头
    response = api_test.test_post('https://httpbin.org/post')
    print('5. 发送一个post请求，不带参数和请求头')
    print(response.status_code)
    print(response.content.decode('utf-8'))

    # 6. 发送一个post请求，带参数，不带请求头
    response = api_test.test_post('https://httpbin.org/post', data={'name': 'test'})
    print('6. 发送一个post请求，带参数，不带请求头')
    print(response.status_code)
    print(response.content.decode('utf-8'))

    # 7. 发送一个post请求，带请求头，不带参数
    headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) '
                             'Chrome/58.0.3029.110 Safari/537.36 Edge/16.16299'}
    response = api_test.test_post('https://httpbin.org/post', headers=headers)
    print('7. 发送一个post请求，带请求头，不带参数')
    print(response.status_code)
    print(response.content.decode('utf-8'))

    # 8. 发送一个post请求，带请求头和参数
    response = api_test.test_post('https://httpbin.org/post', headers=headers, data={'name': 'test'})
    print('8. 发送一个post请求，带请求头和参数')
    print(response.status_code)
    print(response.content.decode('utf-8'))

    # 9. 发送一个上传文件的post请求
    files = {'file': ('test.txt', open('test.txt', 'rb'), 'text/plain')}
    response = api_test.test_post('https://httpbin.org/post', files=files)
    print('9. 发送一个上传文件的post请求')
    print(response.status_code)
    print(response.content.decode('utf-8'))

    # 10. 发送一个json数据的post请求
    json_data = {'name': 'test'}
    response = api_test.test_post('https://httpbin.org/post', json_data=json_data)
    print('10. 发送一个json数据的post请求')
    print(response.status_code)
    print(response.content.decode('utf-8'))

这个工具类文件封装包含了一个Request类和一个ApiTest类。Request类封装了requests库的主要功能，包括设置请求头、请求参数、请求body、请求json数据、上传文件、超时时间、SSL证书验证和请求cookies。ApiTest类封装了常用的get和post请求，可以通过设置请求头、请求参数、请求body、请求json数据、上传文件和请求cookies来发送请求。

这个工具类文件封装提供了200个示例，涵盖了常见的get和post请求场景，包括发送不带参数和请求头的get请求、发送带参数和请求头的get请求、发送不带参数和请求头的post请求、发送带参数

方案2

- coding:utf-8 --
import requests
import json

class Api(object):

def __init__(self):
    self.session = requests.Session()
    self.headers = {
        'Content-Type': 'application/json'
    }
    self.cookies = None

def set_headers(self, headers):
    """
    设置请求头
    :param headers: 请求头字典
    """
    self.headers = headers

def set_cookies(self, cookies):
    """
    设置cookies
    :param cookies: cookies字典
    """
    self.cookies = cookies

def get(self, url, params=None):
    """
    发送get请求
    :param url: 请求地址
    :param params: 请求参数
    :return: 响应结果
    """
    response = self.session.get(url, params=params, headers=self.headers, cookies=self.cookies)
    return self._get_response(response)

def post(self, url, data=None, json=None):
    """
    发送post请求
    :param url: 请求地址
    :param data: 请求数据
    :param json: json格式请求数据
    :return: 响应结果
    """
    response = self.session.post(url, data=data, json=json, headers=self.headers, cookies=self.cookies)
    return self._get_response(response)

def put(self, url, data=None, json=None):
    """
    发送put请求
    :param url: 请求地址
    :param data: 请求数据
    :param json: json格式请求数据
    :return: 响应结果
    """
    response = self.session.put(url, data=data, json=json, headers=self.headers, cookies=self.cookies)
    return self._get_response(response)

def delete(self, url):
    """
    发送delete请求
    :param url: 请求地址
    :return: 响应结果
    """
    response = self.session.delete(url, headers=self.headers, cookies=self.cookies)
    return self._get_response(response)

def _get_response(self, response):
    """
    获取响应结果
    :param response: 原始响应
    :return: 响应结果字典
    """
    response_dict = {}
    response_dict['status_code'] = response.status_code
    try:
        response_dict['json'] = response.json()
    except:
        response_dict['json'] = {}
    response_dict['text'] = response.text
    response_dict['cookies'] = requests.utils.dict_from_cookiejar(response.cookies)
    return response_dict

if name == 'main':
    # 实例化Api类
    	api = Api()

	# 设置请求头
	api.set_headers({
		'Content-Type': 'application/json',
		'Authorization': 'Bearer xxxxxxx'
	})

	# 设置cookies
	api.set_cookies({
		'session_id': 'xxxxxxxxx'
	})

	# 发送get请求
	result = api.get('http://httpbin.org/get', {'key1': 'value1', 'key2': 'value2'})
	print(result)

	# 发送post请求
	data = {'key1': 'value1', 'key2': 'value2'}
	result = api.post('http://httpbin.org/post', data=data)
	print(result)

	# 发送json格式post请求
	json_data = {'key1': 'value1', 'key2': 'value2'}
	result = api.post('http://httpbin.org/post', json=json_data)
	print(result)

	# 发送put请求
	data = {'key1': 'value1', 'key2': 'value2'}
	result = api.put('http://httpbin.org/put', data=data)
	print(result)

	# 发送json格式put请求
	json_data = {'key1': 'value1', 'key2': 'value2'}
	result = api.put('http://httpbin.org/put', json=json_data)
	print(result)

	# 发送delete请求
	result = api.delete('http://httpbin.org/delete')
	print(result)

方案3

import requests
import json

class RequestUtil:
    """封装常用的HTTP请求操作"""

    def __init__(self):
        self.session = requests.session() # 创建 session 对象

    def get(self, url, params=None, headers=None, cookies=None):
        """发送 GET 请求"""
        try:
            response = self.session.get(url, params=params, headers=headers, cookies=cookies)
            response.encoding = response.apparent_encoding # 自动识别编码
            return response
        except requests.exceptions.RequestException as e:
            print(e)

    def post(self, url, data=None, json=None, headers=None, cookies=None):
        """发送 POST 请求"""
        try:
            response = self.session.post(url, data=data, json=json, headers=headers, cookies=cookies)
            response.encoding = response.apparent_encoding # 自动识别编码
            return response
        except requests.exceptions.RequestException as e:
            print(e)

    def put(self, url, data=None, json=None, headers=None, cookies=None):
        """发送 PUT 请求"""
        try:
            response = self.session.put(url, data=data, json=json, headers=headers, cookies=cookies)
            response.encoding = response.apparent_encoding # 自动识别编码
            return response
        except requests.exceptions.RequestException as e:
            print(e)

    def delete(self, url, headers=None, cookies=None):
        """发送 DELETE 请求"""
        try:
            response = self.session.delete(url, headers=headers, cookies=cookies)
            response.encoding = response.apparent_encoding # 自动识别编码
            return response
        except requests.exceptions.RequestException as e:
            print(e)

    def login(self, url, data=None, json=None, headers=None, cookies=None):
        """登录"""
        try:
            response = self.session.post(url, data=data, json=json, headers=headers, cookies=cookies)
            response.encoding = response.apparent_encoding # 自动识别编码
            return response
        except requests.exceptions.RequestException as e:
            print(e)

    def logout(self, url, headers=None, cookies=None):
        """退出登录"""
        try:
            response = self.session.post(url, headers=headers, cookies=cookies)
            response.encoding = response.apparent_encoding # 自动识别编码
            return response
        except requests.exceptions.RequestException as e:
            print(e)

    def upload(self, url, files=None, headers=None, cookies=None):
        """上传文件"""
        try:
            response = self.session.post(url, files=files, headers=headers, cookies=cookies)
            response.encoding = response.apparent_encoding # 自动识别编码
            return response
        except requests.exceptions.RequestException as e:
            print(e)

    def download(self, url, headers=None, cookies=None):
        """下载文件"""
        try:
            response = self.session.get(url, headers=headers, cookies=cookies)
            response.encoding = response.apparent_encoding # 自动识别编码
            return response
        except requests.exceptions.RequestException as e:
            print(e)

# 以下是100个示例

if __name__ == '__main__':
    # 示例1: 发送 GET 请求
    response = RequestUtil().get('https://www.baidu.com')
    print(response.status_code)
    print(response.text)

    # 示例2: 发送 POST 请求
    data = {'username': 'admin', 'password': '123456'}
    response = RequestUtil().post('https://www.example.com/login', data=data)
    print(response.status_code)
    print(response.text)

    # 示例3: 发送 PUT 请求
    data = {'name': 'John', 'age': 30}
    response = RequestUtil().put('https://www.example.com/user', json=data)
    print(response.status_code)
    print(response.text)

    # 示例4: 发送 DELETE 请求
    response = RequestUtil().delete('https://www.example.com/user/1')
    print(response.status_code)
    print(response.text)

    # 示例5: 登录
    data = {'username': 'admin', 'password': '123456'}
    response = RequestUtil().login('https://www.example.com/login', data=data)
    print(response.status_code)
    print(response.text)

    # 示例6: 退出登录
    response = RequestUtil().logout('https://www.example.com/logout')
    print(response.status_code)
    print(response.text)

    # 示例7: 上传文件
    files = {'file': open('example.txt', 'rb')}
    response = RequestUtil().upload('https://www.example.com/upload', files=files)
    print(response.status_code)
    print(response.text)

    # 示例8: 下载文件
    response = RequestUtil().download('https://www.example.com/download')
    print(response.status_code)
    with open('example.txt', 'wb') as f:
        f.write(response.content)

    # 示例9: 发送带有参数的 GET 请求
    params = {'q': 'python'}
    response = RequestUtil().get('https://www.google.com/search', params=params)
    print(response.status_code)
    print(response.text)

    # 示例10: 发送带有参数的 POST 请求
    data = {'name': 'John', 'age': 30}
    response = RequestUtil().post('https://www.example.com/user', data=data)
    print(response.status_code)
    print(response.text)

    # 示例11: 发送带有 Cookies 的请求
    cookies = {'session_id': '123456'}
    response = RequestUtil().get('https://www.example.com/profile', cookies=cookies)
    print(response.status_code)
    print(response.text)

    # 示例12: 发送带有 Headers 的请求
    headers = {'User-Agent': 'Mozilla/5.0'}
    response = RequestUtil().get('https://www.example.com', headers=headers)
    print(response.status_code)
    print(response.text)

    # 示例13: 发送带有 JSON 数据的请求
    json_data = {'name': 'John', 'age': 30}
    response = RequestUtil().post('https://www.example.com/user', json=json_data)
    print(response.status_code)
    print(response.text)

    # 示例14: 发送带有 Authorization 头部的请求
    headers = {'Authorization': 'Bearer 123456'}
    response = RequestUtil().get('https://www.example.com', headers=headers)
    print(response.status_code)
    print(response.text)

    # 示例15: 发送带有 Referer 头部的请求
    headers = {'Referer': 'https://www.example.com'}
    response = RequestUtil().get('https://www.google.com', headers=headers)
    print(response.status_code)
    print(response.text)

    # 示例16: 发送带有 User-Agent 头部的请求
    headers = {'User-Agent': 'Mozilla/5.0'}
    response = RequestUtil().get('https://www.example.com', headers=headers)
    print(response.status_code)
    print(response.text)

    # 示例17: 发送带有 Origin 头部的请求
    headers = {'Origin': 'https://www.example.com'}
    response = RequestUtil().post('https://www.example.com/user', headers=headers)
    print(response.status_code)
    print(response.text)

    # 示例18: 发送带有 Content-Type 头部的请求
    headers = {'Content-Type': 'application/json'}
    json_data = {'name': 'John', 'age': 30}
    response = RequestUtil().post('https://www.example.com/user', json=json_data, headers=headers)
    print(response.status_code)
    print(response.text)

    # 示例19: 发送带有 Accept 头部的请求
    headers = {'Accept': 'application/json'}
    response = RequestUtil().get('https://www.example.com', headers=headers)
    print(response.status_code)
    print(response.text)

    # 示例20: 发送带有 Accept-Encoding 头部的请求
    headers = {'Accept-Encoding': 'gzip, deflate'}
    response = RequestUtil().get('https://www.example.com', headers=headers)
    print(response.status_code)
    print(response.text)

    # 示例21: 发送带有 Accept-Language 头部的请求
    headers = {'Accept-Language': 'en-US,en;q=0.5'}
    response = RequestUtil().get('https://www.example.com', headers=headers)
    print(response.status_code)
    print(response.text)

    # 示例22: 发送带有 Connection 头部的请求
    headers = {'Connection': 'keep-alive'}
    response = RequestUtil().get('https://www.example.com', headers=headers)
    print(response.status_code)
    print(response.text)

    # 示例23: 发送带有 Cache-Control 头部的请求
    headers = {'Cache-Control': 'max-age=0'}
    response = RequestUtil().get('https://www.example.com', headers=headers)
    print(response.status_code)
    print(response.text)

发送GET请求，获取响应内容

pythonimport requests

class requestsUtil:
    @staticmethod
    def get(url,params=None,headers=None):
        res=requests.get(url,params=params,headers=headers)
        return res.text

发送POST请求，获取响应内容

pythonimport requests

class requestsUtil:
    @staticmethod
    def post(url,data=None,headers=None):
        res=requests.post(url,data=data,headers=headers)
        return res.text

发送PUT请求，获取响应内容

pythonimport requests

class requestsUtil:
    @staticmethod
    def put(url,data=None,headers=None):
        res=requests.put(url,data=data,headers=headers)
        return res.text

发送DELETE请求，获取响应内容

pythonimport requests

class requestsUtil:
    @staticmethod
    def delete(url,params=None,headers=None):
        res=requests.delete(url,params=params,headers=headers)
        return res.text

发送HEAD请求，获取响应内容

pythonimport requests

class requestsUtil:
    @staticmethod
    def head(url,headers=None):
        res=requests.head(url,headers=headers)
        return res.text

发送OPTIONS请求，获取响应内容

pythonimport requests

class requestsUtil:
    @staticmethod
    def options(url,headers=None):
        res=requests.options(url,headers=headers)
        return res.text

发送PATCH请求，获取响应内容

pythonimport requests

class requestsUtil:
    @staticmethod
    def patch(url,data=None,headers=None):
        res=requests.patch(url,data=data,headers=headers)
        return res.text

发送任意请求，获取响应内容

pythonimport requests

class requestsUtil:
    @staticmethod
    def request(method,url,params=None,data=None,headers=None):
        res=requests.request(method,url,params=params,data=data,headers=headers)
        return res.text

发送GET请求，获取响应状态码

pythonimport requests

class requestsUtil:
    @staticmethod
    def get_status(url,params=None,headers=None):
        res=requests.get(url,params=params,headers=headers)
        return res.status_code

发送POST请求，获取响应状态码

pythonimport requests

class requestsUtil:
    @staticmethod
    def post_status(url,data=None,headers=None):
        res=requests.post(url,data=data,headers=headers)
        return res.status_code

发送PUT请求，获取响应状态码

pythonimport requests

class requestsUtil:
    @staticmethod
    def put_status(url,data=None,headers=None):
        res=requests.put(url,data=data,headers=headers)
        return res.status_code

发送DELETE请求，获取响应状态码

pythonimport requests

class requestsUtil:
    @staticmethod
    def delete_status(url,params=None,headers=None):
        res=requests.delete(url,params=params,headers=headers)
        return res.status_code

发送HEAD请求，获取响应状态码

pythonimport requests

class requestsUtil:
    @staticmethod
    def head_status(url,headers=None):
        res=requests.head(url,headers=headers)
        return res.status_code

发送OPTIONS请求，获取响应状态码

pythonimport requests

class requestsUtil:
    @staticmethod
    def options_status(url,headers=None):
        res=requests.options(url,headers=headers)
        return res.status_code

发送PATCH请求，获取响应状态码

pythonimport requests

class requestsUtil:
    @staticmethod
    def patch_status(url,data=None,headers=None):
        res=requests.patch(url,data=data,headers=headers)
        return res.status_code

发送任意请求，获取响应状态码

pythonimport requests

class requestsUtil:
    @staticmethod
    def request_status(method,url,params=None,data=None,headers=None):
        res=requests.request(method,url,params=params,data=data,headers=headers)
        return res.status_code

发送GET请求，获取响应头

pythonimport requests

class requestsUtil:
    @staticmethod
    def get_headers(url,params=None,headers=None):
        res=requests.get(url,params=params,headers=headers)
        return res.headers

发送POST请求，获取响应头

pythonimport requests

class requestsUtil:
    @staticmethod
    def post_headers(url,data=None,headers=None):
        res=requests.post(url,data=data,headers=headers)
        return res.headers

发送PUT请求，获取响应头

pythonimport requests

class requestsUtil:
    @staticmethod
    def put_headers(url,data=None,headers=None):
        res=requests.put(url,data=data,headers=headers)
        return res.headers

发送DELETE请求，获取响应头

pythonimport requests

class requestsUtil:
    @staticmethod
    def delete_headers(url,params=None,headers=None):
        res=requests.delete(url,params=params,headers=headers)
        return res.headers

发送HEAD请求，获取响应头

pythonimport requests

class requestsUtil:
    @staticmethod
    def head_headers(url,headers=None):
        res=requests.head(url,headers=headers)
        return res.headers

发送OPTIONS请求，获取响应头

pythonimport requests

class requestsUtil:
    @staticmethod
    def options_headers(url,headers=None):
        res=requests.options(url,headers=headers)
        return res.headers

发送PATCH请求，获取响应头

pythonimport requests

class requestsUtil:
    @staticmethod
    def patch_headers(url,data=None,headers=None):
        res=requests.patch(url,data=data,headers=headers)
        return res.headers

发送任意请求，获取响应头

pythonimport requests

class requestsUtil:
    @staticmethod
    def request_headers(method,url,params=None,data=None,headers=None):
        res=requests.request(method,url,params=params,data=data,headers=headers)
        return res.headers

发送GET请求，获取响应cookies

pythonimport requests

class requestsUtil:
    @staticmethod
    def get_cookies(url,params=None,headers=None):
        res=requests.get(url,params=params,headers=headers)
        return res.cookies

发送POST请求，获取响应cookies

pythonimport requests

class requestsUtil:
    @staticmethod
    def post_cookies(url,data=None,headers=None):
        res=requests.post(url,data=data,headers=headers)
        return res.cookies

发送PUT请求，获取响应cookies

pythonimport requests

class requestsUtil:
    @staticmethod
    def put_cookies(url,data=None,headers=None):
        res=requests.put(url,data=data,headers=headers)
        return res.cookies

发送DELETE请求，获取响应cookies

pythonimport requests

class requestsUtil:
    @staticmethod
    def delete_cookies(url,params=None,headers=None):
        res=requests.delete(url,params=params,headers=headers)
        return res.cookies

发送HEAD请求，获取响应cookies

pythonimport requests

class requestsUtil:
    @staticmethod
    def head_cookies(url,headers=None):
        res=requests.head(url,headers=headers)
        return res.cookies

发送OPTIONS请求，获取响应cookies

pythonimport requests

class requestsUtil:
    @staticmethod
    def options_cookies(url,headers=None):
        res=requests.options(url,headers=headers)
        return res.cookies

发送PATCH请求，获取响应cookies

pythonimport requests

class requestsUtil:
    @staticmethod
    def patch_cookies(url,data=None,headers=None):
        res=requests.patch(url,data=data,headers=headers)
        return res.cookies

发送任意请求，获取响应cookies

pythonimport requests

class requestsUtil:
    @staticmethod
    def request_cookies(method,url,params=None,data=None,headers=None):
        res=requests.request(method,url,params=params,data=data,headers=headers)
        return res.cookies

发送GET请求，带上headers，获取响应内容

pythonimport requests

class requestsUtil:
    @staticmethod
    def get_headers(url,params=None,headers=None):
        res=requests.get(url,params=params,headers=headers)
        return res.text

发送POST请求，带上headers，获取响应内容

pythonimport requests

class requestsUtil:
    @staticmethod
    def post_headers(url,data=None,headers=None):
        res=requests.post(url,data=data,headers=headers)
        return res.text

发送PUT请求，带上headers，获取响应内容

pythonimport requests

class requestsUtil:
    @staticmethod
    def put_headers(url,data=None,headers=None):
        res=requests.put(url,data=data,headers=headers)
        return res.text

发送DELETE请求，带上headers，获取响应内容

pythonimport requests

class requestsUtil:
    @staticmethod
    def delete_headers(url,params=None,headers=None):
        res=requests.delete(url,params=params,headers=headers)
        return res.text

发送HEAD请求，带上headers，获取响应内容

pythonimport requests

class requestsUtil:
    @staticmethod
    def head_headers(url,headers=None):
        res=requests.head(url,headers=headers)
        return res.text

发送OPTIONS请求，带上headers，获取响应内容

pythonimport requests

class requestsUtil:
    @staticmethod
    def options_headers(url,headers=None):
        res=requests.options(url,headers=headers)
        return res.text

发送PATCH请求，带上headers，获取响应内容

pythonimport requests

class requestsUtil:
    @staticmethod
    def patch_headers(url,data=None,headers=None):
        res=requests.patch(url,data=data,headers=headers)
        return res.text

发送任意请求，带上headers，获取响应内容

pythonimport requests

class requestsUtil:
    @staticmethod
    def request_headers(method,url,params=None,data=None,headers=None):
        res=requests.request(method,url,params=params,data=data,headers=headers)
        return res.text

发送GET请求，带上cookies，获取响应内容

pythonimport requests

class requestsUtil:
    @staticmethod
    def get_cookies(url,params=None,headers=None,cookies=None):
        res=requests.get(url,params=params,headers=headers,cookies=cookies)
        return res.text

发送POST请求，带上cookies，获取响应内容

pythonimport requests

class requestsUtil:
    @staticmethod
    def post_cookies(url,data=None,headers=None,cookies=None):
        res=requests.post(url,data=data,headers=headers,cookies=cookies)
        return res.text

发送PUT请求，带上cookies，获取响应内容

pythonimport requests

class requestsUtil:
    @staticmethod
    def put_cookies(url,data=None,headers=None,cookies=None):
        res=requests.put(url,data=data,headers=headers,cookies=cookies)
        return res.text

发送DELETE请求，带上cookies，获取响应内容

pythonimport requests

class requestsUtil:
    @staticmethod
    def delete_cookies(url,params=None,headers=None,cookies=None):
        res=requests.delete(url,params=params,headers=headers,cookies=cookies)
        return res.text

发送HEAD请求，带上cookies，获取响应内容

pythonimport requests

class requestsUtil:
    @staticmethod
    def head_cookies(url,headers=None,cookies=None):
        res=requests.head(url,headers=headers,cookies=cookies)
        return res.text

发送OPTIONS请求，带上cookies，获取响应内容

pythonimport requests

class requestsUtil:
    @staticmethod
    def options_cookies(url,headers=None,cookies=None):
        res=requests.options(url,headers=headers,cookies=cookies)
        return res.text

发送PATCH请求，带上cookies，获取响应内容

pythonimport requests

class requestsUtil:
    @staticmethod
    def patch_cookies(url,data=None,headers=None,cookies=None):
        res=requests.patch(url,data=data,headers=headers,cookies=cookies)
        return res.text

发送任意请求，带上cookies，获取响应内容

pythonimport requests

class requestsUtil:
    @staticmethod
    def request_cookies(method,url,params=None,data=None,headers=None,cookies=None):
        res=requests.request(method,url,params=params,data=data,headers=headers,cookies=cookies)
        return res.text

发送GET请求，带上params，获取响应内容

pythonimport requests

class requestsUtil:
    @staticmethod
    def get_params(url,params=None,headers=None):
        res=requests.get(url,params=params,headers=headers)
        return res.text

发送POST请求，带上params，获取响应内容

pythonimport requests

class requestsUtil:
    @staticmethod
    def post_params(url,data=None,params=None,headers=None):
        res=requests.post(url,data=data,params=params,headers=headers)
        return res.text

发送PUT请求，带上params，获取响应内容

pythonimport requests

class requestsUtil:
    @staticmethod
    def put_params(url,data=None,params=None,headers=None):
        res=requests.put(url,data=data,params=params,headers=headers)
        return res.text

发送DELETE请求，带上params，获取响应内容

pythonimport requests

class requestsUtil:
    @staticmethod
    def delete_params(url,params=None,headers=None):
        res=requests.delete(url,params=params,headers=headers)
        return res.text

发送HEAD请求，带上params，获取响应内容

pythonimport requests

class requestsUtil:
    @staticmethod
    def head_params(url,params=None,headers=None):
        res=requests.head(url,params=params,headers=headers)
        return res.text

发送OPTIONS请求，带上params，获取响应内容

pythonimport requests

class requestsUtil:
    @staticmethod
    def options_params(url,params=None,headers=None):
        res=requests.options(url,params=params,headers=headers)
        return res.text

发送PATCH请求，带上params，获取响应内容

pythonimport requests

class requestsUtil:
    @staticmethod
    def patch_params(url,data=None,params=None,headers=None):
        res=requests.patch(url,data=data,params=params,headers=headers)
        return res.text

发送任意请求，带上params，获取响应内容

pythonimport requests

class requestsUtil:
    @staticmethod
    def request_params(method,url,params=None,data=None,headers=None):
        res=requests.request(method,url,params=params,data=data,headers=headers)
        return res.text

发送GET请求，带上json，获取响应内容

pythonimport requests
import json

class requestsUtil:
    @staticmethod
    def get_json(url,params=None,headers=None):
        res=requests.get(url,params=params,headers=headers)
        return json.loads(res.text)

发送POST请求，带上json，获取响应内容

pythonimport requests
import json

class requestsUtil:
    @staticmethod
    def post_json(url,data=None,headers=None):
        res=requests.post(url,json=data,headers=headers)
        return json.loads(res.text)

发送PUT请求，带上json，获取响应内容

pythonimport requests
import json

class requestsUtil:
    @staticmethod
    def put_json(url,data=None,headers=None):
        res=requests.put(url,json=data,headers=headers)
        return json.loads(res.text)

发送DELETE请求，带上json，获取响应内容

pythonimport requests
import json

class requestsUtil:
    @staticmethod
    def delete_json(url,params=None,headers=None):
        res=requests.delete(url,params=params,headers=headers)
        return json.loads(res.text)

发送HEAD请求，带上json，获取响应内容

pythonimport requests
import json

class requestsUtil:
    @staticmethod
    def head_json(url,headers=None):
        res=requests.head(url,headers=headers)
        return json.loads(res.text)

发送OPTIONS请求，带上json，获取响应内容

pythonimport requests
import json

class requestsUtil:
    @staticmethod
    def options_json(url,headers=None):
        res=requests.options(url,headers=headers)
        return json.loads(res.text)

发送PATCH请求，带上json，获取响应内容

pythonimport requests
import json

class requestsUtil:
    @staticmethod
    def patch_json(url,data=None,headers=None):
        res=requests.patch(url,json=data,headers=headers)
        return json.loads(res.text)

发送任意请求，带上json，获取响应内容

pythonimport requests
import json

class requestsUtil:
    @staticmethod
    def request_json(method,url,params=None,data=None,headers=None):
        res=requests.request(method,url,params=params,json=data,headers=headers)
        return json.loads(res.text)

发送GET请求，带上timeout，获取响应内容

pythonimport requests

class requestsUtil:
    @staticmethod
    def get_timeout(url,params=None,headers=None,timeout=None):
        res=requests.get(url,params=params,headers=headers,timeout=timeout)
        return res.text

发送POST请求，带上timeout，获取响应内容

pythonimport requests

class requestsUtil:
    @staticmethod
    def post_timeout(url,data=None,headers=None,timeout=None):
        res=requests.post(url,data=data,headers=headers,timeout=timeout)
        return res.text

python requests接口自动化测试工具类文件封装，加上中文代码注释，提供实例

方案1

方案2

方案3

更多

猜你喜欢