• Requests库POST请求

    前言

    POST请求用于向服务器提交数据，比如增删改数据，提交一个表单新建一个用户、或修改一个用户等。
    对于POST请求，我们可以通过浏览器开发者工具或者其他外部工具来进行抓包，得到请求的URL、请求头（request headers）以及请求的表单data信息，这三样恰恰是我们用Requests模拟POST请求时需要的。
    关于请求头的配置和GET请求是一样的，都是定义headers属性即可。
    而关于POST请求提交的参数，是和GET请求是不一样的。
    post请求四种传送正文方式：

    • （1）请求正文是application/x-www-form-urlencoded
    • （2）请求正文是multipart/form-data
    • （3）请求正文是raw
    • （4）请求正文是binary

    这四种提交数据的方式，是在请求头Content-Type属性中来定义。

    1、application/x-www-form-urlencoded

    Reqeusts支持以application/x-www-form-urlencoded数据格式发送POST请求（标准的POST请求数据格式，默认），只需要将请求的参数构造成一个字典，然后传给requests.post()的data参数即可。
    示例：

    1. """
    2. 1.学习目标
    3.     必须掌握requests库发送post请求方法
    4. 2.HTTP协议中post请求参数类型
    5.     requests.post(url, data=None, json=None, **kwargs)
    6.     根据不同的请求参数类型分为如下几种：
    7.         x-www-form-data-urlencoded
    8.         raw_json格式
    9.         form-data
    10.         binary
    11. 3.json格式
    12.     # 1.导入requests库
    13.     # 2.明确请求地址
    14.     # 3.明确请求参数
    15.         data = {key:value}  字典格式
    16.     # 4.发送请求
    17.         requests.post(url=url,json=data)
    18. 4.需求
    19.     通过访问http://httpbin.org/post接口，验证post参数类型
    21. """
    22. # 1.导入requests库
    23. import requests
    24. import json
    25.  
    26. # 2.明确请求地址
    27. url = "http://httpbin.org/post"
    28. # 3.明确请求参数
    29. data = {
    30.     "dep_id": "T01",
    31.     "dep_name": "Test学院",
    32.     "master_name": "Test-Master",
    33.     "slogan": "Here is Slogan"
    34. }
    35. # 4.发送请求
    36. response = requests.post(url=url, data=data)
    37.  
    38. # 将python对象转换为json字符串（格式化返回数据）
    39. result = json.dumps(response.json(), indent=2, ensure_ascii=False)
    40. # print(type(result))  # 字符串类型
    41. print(result)
    42.  
    43. """
    44. 返回结果：
    45. {
    46.   "args": {},
    47.   "data": "",
    48.   "files": {},
    49.   ****************主要看这里
    50.   "form": {
    51.     "dep_id": "T01",
    52.     "dep_name": "Test学院",
    53.     "master_name": "Test-Master",
    54.     "slogan": "Here is Slogan"
    55.   },
    56.   ***********************
    57.   "headers": {
    58.     "Accept": "*/*",
    59.     "Accept-Encoding": "gzip, deflate",
    60.     "Content-Length": "88",
    61.     *****************主要看这里
    62.     "Content-Type": "application/x-www-form-urlencoded",
    63.     *****************
    64.     "Host": "httpbin.org",
    65.     "User-Agent": "python-requests/2.18.4",
    66.     "X-Amzn-Trace-Id": "Root=1-5ff401e3-1553596b7788e77e275c4772"
    67.   },
    68.   "json": null,
    69.   "origin": "106.35.9.12",
    70.   "url": "http://httpbin.org/post"
    71. }
    72. """

    说明：

    • 发送的请求中，form属性接收了参数。
    • 在请求头中，Content-Type属性为application/x-www-form-urlencoded
    • 使用application/x-www-form-urlencoded格式发送数据，requests.post(url=url, data=data)方法中一定要使用data变量来接收参数。
    • 换句话说数据格式是字典格式，使用data变量来接收，会默认发送application/x-www-form-urlencoded数据格式的POST请求。（也可以在请求头中明确一下Content-Type属性，但没必要。）

    2、请求正文是raw

    RAW的原意就是“未经加工”。换句话说RAW方式使用的是纯字符串的数据上传方式，所以在发送POST请求之前，可能需要手工的把一些JSON格式的数据转换成字符串的(加两单引号)，在进行提交。
    RAW数据格式的POST请求有两种：

    • 一种是xml格式文本（text/xml）
    • 一种是json格式文本（application/json）

    下面我们一一说明：
    （1）json格式文本（application/json）

    1. # 1.导入requests库
    2. import requests
    3. import json
    4.  
    5. # 2.明确请求地址
    6. url = "http://httpbin.org/post"
    7. # 3.明确请求参数
    8. data = {
    9.     "data": [
    10.         {
    11.             "dep_id": "T01",
    12.             "dep_name": "Test学院",
    13.             "master_name": "Test-Master",
    14.             "slogan": "Here is Slogan"
    15.         }
    16.     ]
    17. }
    18.  
    19. # headers = {"Content-Type": "application/json"}
    20.  
    21. # 4.发送请求
    22. response = requests.post(url=url, json=data)
    23. print(response)  # <Response [200]>
    24. print(response.text)
    25.  
    26.  
    27. """
    28. 返回结果：
    29. {
    30.   "args": {}, 
    31.   "data": "{\"data\": [{\"dep_id\": \"T01\", \"dep_name\": \"Test\\u5b66\\u9662\", \"master_name\": \"Test-Master\", \"slogan\": \"Here is Slogan\"}]}", 
    32.   "files": {}, 
    33.   "form": {}, 
    34.   "headers": {
    35.     "Accept": "*/*", 
    36.     "Accept-Encoding": "gzip, deflate", 
    37.     "Content-Length": "119", 
    38.     **************************主要看这里
    39.     "Content-Type": "application/json", 
    40.     **************************
    41.     "Host": "httpbin.org", 
    42.     "User-Agent": "python-requests/2.18.4", 
    43.     "X-Amzn-Trace-Id": "Root=1-5ff40a9d-6a6f19d272ba4c1b40ff7bbb"
    44.   }, 
    45.     **************************主要看这里
    46.   "json": {
    47.     "data": [
    48.       {
    49.         "dep_id": "T01", 
    50.         "dep_name": "Test\u5b66\u9662", 
    51.         "master_name": "Test-Master", 
    52.         "slogan": "Here is Slogan"
    53.       }
    54.     ]
    55.   }, 
    56.     **************************
    57.   "origin": "106.35.9.12", 
    58.   "url": "http://httpbin.org/post"
    59. }
    60. """


    说明：

    • 发送的请求中，json属性接收了参数。
    • 在请求头中，Content-Type属性为application/json。
    • 使用application/json格式发送数据，requests.post(url=url, json=data)方法中一定要使用json变量来接收参数。
    • 换句话说数据格式是Json格式，使用json变量来接收，Requests会默认发送application/json数据格式的POST请求。（也可以在请求头中明确一下Content-Type属性，但没必要。）
    注意：
    这里我们可以发现Requests模拟post请求时，请求头格式为application/x-www-form-urlencoded与application/json的主要差别在于请求主体的构造格式（前者是键值对，后者是JSON串）,前者直接用字典传入，后者用json.dumps()函数将字典转为JSON串即可。
    也就是说在有需要的时候json模块下的dumps函数可以将dict转换为str。

    （2）xml格式文本（text/xml）

    1. # 1.导入requests库
    2. import requests
    3. import json
    4.  
    5. # 2.明确请求地址
    6. url = "http://httpbin.org/post"
    7. # 3.明确请求参数
    8. data = '' \
    9.             '' \
    10.                 '菜鸟教程' \
    11.                 'www.runoob.com' \
    12.             '' \
    13.             '' \
    14.                 'Google' \
    15.                 'www.google.com' \
    16.             '' \
    17.        ''
    18.  
    19. #  requests.post方法中适用json变量来接收数据，
    20. # 默认是"Content-Type": "application/json", 
    21. # 这里我们需要重新声明一下Content-Type属性。
    22. headers = {'Content-type': 'text/xml'}
    23.  
    24. # 4.发送请求
    25. # 如果数据用data变量来接收会报错。
    26. response = requests.post(url=url, json=data, headers=headers)
    27. print(response)  # <Response [200]>
    28. # print(response.text)
    29.  
    30. # 将python对象转换为json字符串（格式化返回数据）
    31. result = json.dumps(response.json(), indent=2, ensure_ascii=False)
    32. # print(type(result))  # 字符串类型
    33. print(result)
    34.  
    35. """
    36. 返回结果：
    37. {
    38.   "args": {},
    39.   "data": "\"\\u83dc\\u9e1f\\u6559\\u7a0bwww.runoob.comGooglewww.google.com\"",
    40.   "files": {},
    41.   "form": {},
    42.   "headers": {
    43.     "Accept": "*/*",
    44.     "Accept-Encoding": "gzip, deflate",
    45.     "Content-Length": "149",
    46.     **************************主要看这里
    47.     "Content-Type": "text/xml",
    48.     **************************
    49.     "Host": "httpbin.org",
    50.     "User-Agent": "python-requests/2.18.4",
    51.     "X-Amzn-Trace-Id": "Root=1-5ff40fa5-21a79b532b1ccf6d20173fd7"
    52.   },
    53.   **************************主要看这里
    54.   "json": "<sites><site><name>菜鸟教程</name><url>www.runoob.com</url></site><site><name>Google</name><url>www.google.com</url></site></sites>",
    55.     **************************
    56.   "origin": "106.35.9.12",
    57.   "url": "http://httpbin.org/post"
    58. }
    59. """

    说明：

    • text/xml格式相对用的少。
    • xml也可以作为一个文件来传输。
    • 需要重新声明请求头中Content-Type属性。
    • 其他和application/json一样。

    提示：其实raw格式数据可以上传text、json、xml、html等纯字符的文本。

    3、正文是binary

    使用binary格式的正文发送POST请求，是直接使用二进制流进行数据传输，多用于上传单个图片或图片。
    也可以用于把请求的参数放入一个文件中，进行数据的提交。
    示例如下：

    1. """
    2. 1.学习目标
    3.     掌握requests发送post请求
    4. 2.HTTP协议中post请求参数类型
    5.     x-www-form-data-urlencoded
    6.     raw_json格式
    7.     form-data
    8.     binary
    9. 3.binary格式
    10.     # 1.明确请求地址
    11.     # 2.明确请求参数
    12.         data = {"files":open("文件名","rb")}  字典格式
    13.     # 3.发送请求
    14.         requests.post(url= url,files=data)
    15. 4.需求
    16.     http://httpbin.org/post
    17. """
    18. # 1.导入requests
    19. import requests
    20.  
    21. # 2.请求地址
    22. url = "http://httpbin.org/post"
    23.  
    24. # 3.请求参数
    25. # 读取文件中的数据作为参数进行提交。
    26. # key位置要写files，是规范
    27. # 也可以写其他的名字，不规范
    28. data = {"files": open("test.txt", "rb")}
    29.  
    30. # 4.发送请求
    31. response = requests.post(url=url, files=data)
    32. print(response.text)
    33.  
    34.  
    35. """
    36. 请求结果如下：
    37. {
    38.   "args": {}, 
    39.   "data": "", 
    40.   **************************主要看这里
    41.   "files": {
    42.     "files": "username=\u5927\u5c0f\u59d0\r\npassword=test123456\r\nage=18"
    43.   }, 
    44.   **************************
    45.   "form": {}, 
    46.   "headers": {
    47.     "Accept": "*/*", 
    48.     "Accept-Encoding": "gzip, deflate", 
    49.     "Content-Length": "192", 
    50.     **************************主要看这里
    51.     "Content-Type": "multipart/form-data; boundary=351e0b73ea144694a9e9fdd1e10d2486", 
    52.     **************************
    53.     "Host": "httpbin.org", 
    54.     "User-Agent": "python-requests/2.18.4", 
    55.     "X-Amzn-Trace-Id": "Root=1-5ff499ea-7ad42c4e6f056b44347b3c26"
    56.   }, 
    57.   "json": null, 
    58.   "origin": "106.35.9.12", 
    59.   "url": "http://httpbin.org/post"
    60. }
    61. """

    说明：

    • 发送的请求中，files属性接收了参数。
    • 在请求头中，Content-Type属性为multipart/form-data。
    • 使用application/json格式发送数据，requests.post(url=url, files=data)方法中一定要使用files变量来接收参数。
    • 换句话说Requests也支持发送binary数据形式的POST请求，只需将文件传给requests.post()方法的files参数即可。

    4、multipart/form-data

    multipart/form-data数据格式的POST请求，多用于文件上传。
    示例1：

    1. """
    2. 1.学习目标
    3.     掌握requests发送post请求
    4. 2.HTTP协议中post请求参数类型
    5.     x-www-form-data-urlencoded
    6.     raw_json格式
    7.     form-data
    8.     binary
    9. 3.form-data格式
    10.     使用files变量来接收数据，默认是使用form-data格式发送POST请求。
    11. 4.需求
    12.     http://httpbin.org/post
    13. """
    14.  
    15. import requests
    16.  
    17. files = {'file1': open('logo.png', 'rb')}
    18. response = requests.post('http://127.0.0.1:9999/post', files=files)
    19. print(response.text)
    20.  
    21.  
    22. """
    23. 接口返回结果：
    24. {
    25.   "args": {}, 
    26.   "data": "", 
    27.   **************************主要看这里
    28.   "files": {
    29.     "file1": "data:application/octet-stream;base64,/9j/4AAQSkZJRgABAQEASABIAAD/2wBDAAgGBgcGBQgHerOCtwJPHpvQjoYqxmHighE/wO1YuuATgOKt9wGMd653WXlhe2xbcpauJjePjQYuZTOOk032eaYj+GgOQ+E1QCBj4UxtunNUFIjBmm5P05oBjLv99qoKgEpW9PSu1b0tAglXYOr2/uN4rtp6ZZay53n81IAlauN/pRH/2Q=="
    30.   }, 
    31.   **************************
    32.   "form": {}, 
    33.   "headers": {
    34.     "Accept": "*/*", 
    35.     "Accept-Encoding": "gzip, deflate", 
    36.     "Connection": "keep-alive", 
    37.     "Content-Length": "394145", 
    38.     **************************主要看这里
    39.     "Content-Type": "multipart/form-data; boundary=4efea05a2cf34e78a75508a1ebf000ec", 
    40.     **************************
    41.     "Host": "127.0.0.1:9999", 
    42.     "User-Agent": "python-requests/2.18.4"
    43.   }, 
    44.   "json": null, 
    45.   "origin": "127.0.0.1", 
    46.   "url": "http://127.0.0.1:9999/post"
    47. }
    48. """

    示例2：
    我们也可以显式地设置文件名，文件类型和请求头：

    1. import requests
    2. # hangge.png 为图片名称
    3. files = {'file1': ('hangge.png', open('logo.png', 'rb'), 'image/png', {'Expires': '0'})}
    4. response = requests.post('http://127.0.0.1:9999/post', files=files)
    5. print(response.text)
    6.  
    7.  
    8. """
    9. 接口返回结果：
    10. {
    11.   "args": {}, 
    12.   "data": "", 
    13.   **************************主要看这里
    14.   "files": {
    15.     "file1": "data:image/png;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyacMkc0Yyc0UAf/Z"
    16.   }, 
    17.   **************************
    18.   "form": {}, 
    19.   "headers": {
    20.     "Accept": "*/*", 
    21.     "Accept-Encoding": "gzip, deflate", 
    22.     "Connection": "keep-alive", 
    23.     "Content-Length": "7063", 
    24.     **************************主要看这里
    25.     "Content-Type": "multipart/form-data; boundary=382e06cba6834118a1f1efd0ea2c45e3", 
    26.     **************************
    27.     "Host": "127.0.0.1:9999", 
    28.     "User-Agent": "python-requests/2.18.4"
    29.   }, 
    30.   "json": null, 
    31.   "origin": "127.0.0.1", 
    32.   "url": "http://127.0.0.1:9999/post"
    33. }
    35. """

    示例3：多文件上传
    有时我们需要在一个请求中同时发送多个文件，同样使用 files 参数传入一个数组即可：

    1. import requests
    2. files = [
    3.         ('file1', ('1.png', open('logo.png', 'rb'), 'image/png')),
    4.         ('file2', ('2.png', open('logo.png', 'rb'), 'image/png'))
    5. ]
    6. response = requests.post('http://127.0.0.1:9999/post', files=files)
    7. print(response.text)
    8.  
    9.  
    10. """
    11. 接口返回结果：
    12. {
    13.   "args": {}, 
    14.   "data": "", 
    15.   **************************主要看这里
    16.   "files": {
    17.     "file1": "data:image/png;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgc3p8zdacMkc0Yyc0UAf/Z", 
    18.     "file2": "data:image/png;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgc3p8zdacMkc0Yyc0UAf/Z"
    19.   }, 
    20.   **************************
    21.   "form": {}, 
    22.   "headers": {
    23.     "Accept": "*/*", 
    24.     "Accept-Encoding": "gzip, deflate", 
    25.     "Connection": "keep-alive", 
    26.     "Content-Length": "14054", 
    27.     **************************主要看这里
    28.     "Content-Type": "multipart/form-data; boundary=ba662835a2364b069c99ba3ffa56b974", 
    29.     **************************
    30.     "Host": "127.0.0.1:9999", 
    31.     "User-Agent": "python-requests/2.18.4"
    32.   }, 
    33.   "json": null, 
    34.   "origin": "127.0.0.1", 
    35.   "url": "http://127.0.0.1:9999/post"
    36. }
    38. """

    示例4：上传时附带其它参数
    如果我们需要在上传文件的同时传递一些其它参数，也是可以的：

    1. import requests
    2.  
    3. data = {
    4.     "name": "ABC.com",
    5.     "age": 100
    6. }
    7. files = [
    8.     ('file1', ('1.png', open('logo.png', 'rb'), 'image/png')),
    9.     ('file2', ('2.png', open('logo.png', 'rb'), 'image/png'))
    10. ]
    11. response = requests.post('http://127.0.0.1:9999/post', data=data, files=files)
    12. print(response.text)
    13.  
    14. """
    15. 接口返回结果：
    16. {
    17.   "args": {}, 
    18.   "data": "", 
    19.   **************************主要看这里
    20.   "files": {
    21.     "file1": "data:image/png;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDA0Yyc0UAf/Z", 
    22.     "file2": "data:image/png;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDA0Yyc0UAf/Z"
    23.   }, 
    24.   "form": {
    25.     "age": "100", 
    26.     "name": "ABC.com"
    27.   }, 
    28.   **************************
    29.   "headers": {
    30.     "Accept": "*/*", 
    31.     "Accept-Encoding": "gzip, deflate", 
    32.     "Connection": "keep-alive", 
    33.     "Content-Length": "14233", 
    34.     **************************主要看这里
    35.     "Content-Type": "multipart/form-data; boundary=6bdedbde2b48465683ef4e3451f7e015", 
    36.     **************************
    37.     "Host": "127.0.0.1:9999", 
    38.     "User-Agent": "python-requests/2.18.4"
    39.   }, 
    40.   "json": null, 
    41.   "origin": "127.0.0.1", 
    42.   "url": "http://127.0.0.1:9999/post"
    43. }
    44. """

    示例5：流式上传文件

    • 有时我们需要上传一个非常大的文件（比如 1G 左右），如果像上面的方式直接使用 Requests提交，可能会造成内存不足而崩溃。
    • 所以发送大文件时还是建议将请求做成数据流。不过默认下 Requests 不支持流式上传，但有个第三方包 requests-toolbelt 是支持的（本质还是 multipart/form-data 上传）
    • 在使用 requests-toolbelt 之前，我们首先通过 pip 进行安装：
    1. # cmd命令行终端执行如下命令。
    2. pip install requests-toolbelt

    练习如下：

    1. """
    2. 1.学习目标
    3.     掌握requests发送post请求
    4. 2.HTTP协议中post请求参数类型
    5.     x-www-form-data-urlencoded
    6.     raw_json格式
    7.     form-data
    8.     binary
    9. 3.form-data格式
    10.     # 1.导入requests库,requests_toolbelt库
    11.     # 2.明确请求地址
    12.     # 3.明确请求参数
    13.         data = {}  字典格式
    14.         对请求参数加工(实例化)
    15.         m = MultipartEncoder(fields = data)
    16.     # 4.添加请求头
    17.         headers = {"Content_Type":m.content_type}
    18.     # 5.发送请求
    19.         requests.post(url= url,data=m,headers=headers)
    20. 4.需求
    21.     http://httpbin.org/post
    22. """
    23. # 1.导入requests库
    24. import requests
    25. from requests_toolbelt import MultipartEncoder
    26. # from requests_toolbelt.multipart.encoder import MultipartEncoder
    27.  
    28. # 2.明确请求地址
    29. url = "http://httpbin.org/post"
    30. # 3.明确请求参数
    31. data = {
    32.     "username": "Jerry",
    33.     "password": "1232456",
    34.     "sex": "男"
    35. }
    36.  
    37. # requests-toolbelt 还提供了个监视器（MultipartEncoderMonitor），
    38. # 该监视器接受一个回调函数，我们可以在回调中实时跟踪进度。
    39. # from requests_toolbelt import MultipartEncoderMonitor
    40. # def my_callback(monitor):
    41. #     progress = (monitor.bytes_read / monitor.len) * 100
    42. #     print("\r 文件上传进度：%d%%(%d/%d)"
    43. #           % (progress, monitor.bytes_read, monitor.len), end=" ")
    44.  
    45. # m = MultipartEncoder(
    46. #     fields={'name': 'ABC.com', "age": '100',
    47. #             'file1': ('1.png', open('logo.png', 'rb'), 'image/png'),
    48. #             'file2': ('2.png', open('logo.png', 'rb'), 'image/png')}
    49. # )
    50.  
    51. # 4.添加请求头和加工请求参数
    52. # 加工请求参数----让每个参数都要带有边界
    53. m = MultipartEncoder(fields=data)
    54.  
    55. # 添加请求头
    56. headers = {"Content_Type": m.content_type}
    57.  
    58. # 4.发送请求
    59. response = requests.post(url=url, data=m, headers=headers)
    60. print(response.text)
    61.  
    62. """
    63. 请求结果：
    65. {
    66.   "args": {}, 
    67.   "data": "", 
    68.   "files": {}, 
    69.   **************************主要看这里
    70.   "form": {    
    71.     "username": "Jerry",
    72.     "password": "1232456",
    73.     "sex": "男"
    74.     }, 
    75.   **************************
    76.   "headers": {
    77.     "Accept": "*/*", 
    78.     "Accept-Encoding": "gzip, deflate", 
    79.     "Content-Length": "192", 
    80.     **************************主要看这里
    81.     "Content-Type": "multipart/form-data; boundary=351e0b73ea144694a9e9fdd1e10d2486", 
    82.     **************************
    83.     "Host": "httpbin.org", 
    84.     "User-Agent": "python-requests/2.18.4", 
    85.     "X-Amzn-Trace-Id": "Root=1-5ff499ea-7ad42c4e6f056b44347b3c26"
    86.   }, 
    87.   "json": null, 
    88.   "origin": "106.35.9.12", 
    89.   "url": "http://httpbin.org/post"
    90. }
    91. """

    5、总结Binary和Form-data区别

    主要区别在于：

    • Binary只可以上传二进制数据，通常用来上传文件，由于没有键值，所以一次只能上传一个文件，而Form-data可以传多个。
    • Form-data既可以上传文件等二进制数据，也可以上传表单键值对。利用key-value对，可以分别对每个文件进行描述。

    最后：下面是配套学习资料，对于做【软件测试】的朋友来说应该是最全面最完整的备战仓库，这个仓库也陪伴我走过了最艰难的路程，希望也能帮助到你！【100%无套路免费领取】

    软件测试面试小程序

    被百万人刷爆的软件测试题库！！！谁用谁知道！！！全网最全面试刷题小程序，手机就可以刷题，地铁上公交上，卷起来！

    涵盖以下这些面试题板块：

    1、软件测试基础理论 ，2、web,app，接口功能测试 ，3、网络 ，4、数据库 ，5、linux

    6、web,app，接口自动化 ，7、性能测试 ，8、编程基础，9、hr面试题 ，10、开放性测试题，11、安全测试，12、计算机基础

      全套资料获取方式：点击下方小卡片自行领取即可

  • 相关阅读:
    带你一步步看vue-loader编译流程
    被环境变量虐过一遍获得的启示
    【JVM面试题】JVM分代年龄为何是15次？能设置为16吗？
    安装JAVA和java IDEA并汉化过程
    springboot基于web的游泳馆信息管理系统毕业设计源码281444
    [附源码]java毕业设计置地房屋租赁信息系统
    Rebex Total Pack R6.9 Crack
    面向OLAP的列式存储DBMS-10-[ClickHouse]的常用数组操作
    初试scikit-learn库
    人血清白蛋白功能化纳米四氧化三铁Fe3O4
  • 原文地址：https://blog.csdn.net/weixin_57794111/article/details/133882649