经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » Python3 » 查看文章
python3 手机App数据抓取实战
来源：cnblogs　　作者：风，又奈何　　时间：2019/9/24 8:55:23　　对本文有异议

前言

当前手机使用成为互联网主流，每天手机App产生大量数据，学习爬虫的人也不能只会爬取网页数据，我们需要学习如何从手机 APP 中获取数据，本文就以豆果美食为例，讲诉爬取手机App的流程

环境准备

  • python3
  • fiddler
  • 一款支持桥接模式的安卓虚拟机（本文使用夜神模拟器）

需要准备的知识有：

  • requests的使用
  • mongodb的使用
  • fiddler抓包工具的基本操作
  • 线程池ThreadPoolExecutor的基本使用

 

项目开始

我们项目的目标是将豆果美食App中所有的菜谱都抓取下来到我们的本地数据库中

本文不再讲解fiddler、安卓模拟器、以及某些python第三方库的安装，不会的同学可以百度，非常简单的操作

我们抓取的流程大概就是

  1. 安卓模拟器使用代理连接至fiddler
  2. 打开安卓模拟器进行操作
  3. 分析fiddler抓到的数据
  4. 使用python模拟数据给服务器发送request请求得到响应数据
  5. 使用多线程抓取并在本地保存至数据库

 

1）安卓模拟器使用代理连接至fiddler

打开fiddler，进行设置 打开最上方菜单栏中的 Tools 菜单中的 Options 选项 即配置选项进行以下配置（主要就是前3项的配置）

第三张图片中的8889就是我们fiddler监听的端口号，一会我们将模拟器配置代理就可以从fiddler中抓取数据包

打开安卓模拟器的网络连接的桥接模式（夜神模拟器包括此功能，此步骤需要重启），使用夜神的童鞋推荐使用android4 以为我一开始使用android5发现桥接模式无法联网

然后我们现在看下我们电脑的IP地址 打开命令行输入 ipconfig 命令即可

例如当前我的地址为 172.20.10.2 那么打开安卓模拟器的设置中的无线连接选项，长按网络名称如下图出现修改网络选项 接下来选择高级设置添加手动代理 将自己电脑的IP与fiddler中的端口号输入

接下来测试是否能连接到fiddler 打开fiddler 然后安卓模拟器打开浏览器随便开一个网页，看看fiddler是否可以抓到包

发现现在是可以抓到数据包的，但是浏览器一直在提醒安全证书有问题，这是因为我们模拟器中没有添加fiddler的证书，我们可以在模拟器浏览器中访问我们电脑的IP地址和端口号来安装证书

点击图中的最下方的超链接下载证书  然后安装证书，注意这一步可能需要我们设置下模拟器的锁屏密码自己设置即可

至此我们第一步模拟器连接到fiddler已经完成，接下来可以进行抓取的操作了

 

2）打开安卓模拟器进行操作

模拟器安装好豆果美食app开始操作  进入App （图一）  点击菜谱分类（即index页面（图二）） 点进去具体食材（图三）然后选择菜谱（图四）

 

分别进行以上操作后我们的fiddler就会抓取到很多数据包  然后我们现在打开fiddler来分析下到底是哪些数据包对我们有用

3）分析fiddler抓取的数据

我们先来看下这时候fiddler中出现了什么 看起来很多数据包不知道如何下手

学过编程的同学们都知道一般程序的请求数据都是通过api接口的，我们发现fiddler中抓取到一些名称为 api.douguo.net  的数据包 我们来看看是不是我们想要的数据包

我们点击名称以api 接口的几个数据包就会发现里面返回的数据正是我们想要的数据（出现了分类茄子等内容的数据），所以我们现在将其他没用的数据包删掉，只留下对我们有用的数据包

并且我们根据某些数据包的url名称也会看出点东西，因为编程的命名一般不会杂乱无章的，所以有些名称直接就暴露了数据包的内容

最后我们简单的用fiddler看返回的response可以看出来我们需要用的就是以下三个 返回的数据分别对应着刚刚模拟器操作的图二图三图四 也正是菜谱的内容

4）使用python模拟数据给服务器发送request请求得到响应数据

现在我们对于抓取到的三个包的request分析进行模拟，向服务器发送请求，看看我们能否收到想要的响应

打开pycharm 编写文件  首先我们分析第一个包 也就是菜谱分类页面如下图

可以看出来request请求是 POST 方法 头部信息和发送的data 都在fiddler中可以看出来 现在编写py文件

将头部信息复制到notepad或者其他文本处理工具中将文本使用查找替换成我们要的字典格式如图（记得将空格删除）

douguo_test.py文件编写如下：

  1. import requests
  2. import json
  4. def douguo_request(url,data):
  5.     #有些头部信息不需要已经进行了注释，因为可能会造成服务器检测我们多次请求问题
  6.     headers = {
  7.         "client": "4",
  8.         "version": "6945.4",
  9.         "device": "OPPO R11",
  10.         "sdk": "19,4.4.2",
  11.         "imei": "866174010601603",
  12.         "channel": "baidu",
  13.         #"mac": "3C:A0:67:68:D1:F5",
  14.         "resolution": "1280*720",
  15.         "dpi": "1.5",
  16.         #"android-id": "3ca06768d1f58615",
  17.         #"pseudo-id": "768d1f586153ca06",
  18.         "brand": "OPPO",
  19.         "scale": "1.5",
  20.         "timezone": "28800",
  21.         "language": "zh",
  22.         "cns": "3",
  23.         "carrier": "CMCC",
  24.         #"imsi": " 460076016067682",
  25.         "User-Agent": "Mozilla/5.0 (Linux; Android 4.4.2; OPPO R11 Build/NMF26X) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/30.0.0.0 Mobile Safari/537.36",
  26.         "act-code": "9d77be448da77d86aa48ae9d822d70d0",
  27.         "act-timestamp": "1569203760",
  28.         "uuid": "b2db10e9-cb21-4c36-ba4c-be62d8b3c67c",
  29.         "newbie": "1",
  30.         "reach": "10000",
  31.         #"lon": "112.573081",
  32.         #"lat": "37.735522",
  33.         #"cid": "140100",
  34.         "Content-Type": "application/x-www-form-urlencoded; charset=utf-8",
  35.         "Accept-Encoding": "gzip, deflate",
  36.         "Connection": "Keep-Alive",
  37.         #"Cookie": "duid=61248941",
  38.         "Host": "api.douguo.net",
  39.         #"Content-Length": "68",
  40.     }
  42.     response = requests.post(url=url,data=data,headers=headers)
  43.     return response
  45. url = 'http://api.douguo.net/recipe/flatcatalogs'
  46. data = {
  47.         "client":"4",
  48.         #"_session" : "1568947372977863254011601605",
  49.         #"v" : "1568891837",
  50.         "_vs" : "2305"
  51. }
  53. response = douguo_request(url,data)
  54. print(response.text)

然后我们发现打印出一个json格式的东西，接下来我们将打印的东西放进 json.cn网站中读取一下（这样可以更方便的看json数据）

我们发现没错正是我们想要的分类数据   接下来继续下一步的操作

我们点开三个数据包会发现三个数据包的头部信息与POST方法都一样，不一样的是请求的 url 和 data 内容  所以我们编写的第一个request函数可以反复使用

第一个我们已经可以得到页面索引，现在我们来看如何进入具体食材的列表视图 如茄子 分析第二个数据包发送的data 发现data中存在些乱码，这是url编码后的结果，我们转换一下就好了

因此我们发现，其实data就是发送了具体食材的名称，那么名称从哪里获取的呢？没错就是我们刚刚返回的json中就包含，因此我们需要编写一个可以分析json结构获取名称然后组成data的函数

继续编写如下

  1. import requests
  2. import json
  4. def douguo_request(url,data):
  5.     #有些头部信息不需要已经进行了注释，因为可能会造成服务器检测我们多次请求问题
  6.     headers = {
  7.         "client": "4",
  8.         "version": "6945.4",
  9.         "device": "OPPO R11",
  10.         "sdk": "19,4.4.2",
  11.         "imei": "866174010601603",
  12.         "channel": "baidu",
  13.         #"mac": "3C:A0:67:68:D1:F5",
  14.         "resolution": "1280*720",
  15.         "dpi": "1.5",
  16.         #"android-id": "3ca06768d1f58615",
  17.         #"pseudo-id": "768d1f586153ca06",
  18.         "brand": "OPPO",
  19.         "scale": "1.5",
  20.         "timezone": "28800",
  21.         "language": "zh",
  22.         "cns": "3",
  23.         "carrier": "CMCC",
  24.         #"imsi": " 460076016067682",
  25.         "User-Agent": "Mozilla/5.0 (Linux; Android 4.4.2; OPPO R11 Build/NMF26X) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/30.0.0.0 Mobile Safari/537.36",
  26.         "act-code": "9d77be448da77d86aa48ae9d822d70d0",
  27.         "act-timestamp": "1569203760",
  28.         "uuid": "b2db10e9-cb21-4c36-ba4c-be62d8b3c67c",
  29.         "newbie": "1",
  30.         "reach": "10000",
  31.         #"lon": "112.573081",
  32.         #"lat": "37.735522",
  33.         #"cid": "140100",
  34.         "Content-Type": "application/x-www-form-urlencoded; charset=utf-8",
  35.         "Accept-Encoding": "gzip, deflate",
  36.         "Connection": "Keep-Alive",
  37.         #"Cookie": "duid=61248941",
  38.         "Host": "api.douguo.net",
  39.         #"Content-Length": "68",
  40.     }
  42.     response = requests.post(url=url,data=data,headers=headers)
  43.     return response
  45. def douguo_index():
  46.     url = 'http://api.douguo.net/recipe/flatcatalogs'
  47.     data = {
  48.             "client":"4",
  49.             #"_session" : "1568947372977863254011601605",
  50.             #"v" : "1568891837",
  51.             "_vs" : "2305"
  52.     }
  53.     response = douguo_request(url, data)
  54.     #需要把json数据变为dict
  55.     response_dict = json.loads(response.text)
  56.     for item1 in response_dict['result']['cs']:
  57.         for item2 in item1['cs']:
  58.             for item3 in item2['cs']:
  59.                 data={
  60.                     "client": "4",
  61.                     # "_session": "1568947372977863254011601605",
  62.                     "keyword": item3['name'],
  63.                     "_vs": "400"
  64.                 }
  65.                 print(data)
  67. douguo_index()

运行得到如下图

没错我们现在已经构建好了要发送的data数据 

接下来我们继续构造另一个发送的函数 来获取具体食材的菜谱列表（我们只选取食材的最火的前10个菜谱） 当前我们先测试第一个获取的也就是茄子，一会我们使用队列来多线程抓取

  1. import requests
  2. import json
  4. def douguo_request(url,data):
  5.     #有些头部信息不需要已经进行了注释，因为可能会造成服务器检测我们多次请求问题
  6.     headers = {
  7.         "client": "4",
  8.         "version": "6945.4",
  9.         "device": "OPPO R11",
  10.         "sdk": "19,4.4.2",
  11.         "imei": "866174010601603",
  12.         "channel": "baidu",
  13.         #"mac": "3C:A0:67:68:D1:F5",
  14.         "resolution": "1280*720",
  15.         "dpi": "1.5",
  16.         #"android-id": "3ca06768d1f58615",
  17.         #"pseudo-id": "768d1f586153ca06",
  18.         "brand": "OPPO",
  19.         "scale": "1.5",
  20.         "timezone": "28800",
  21.         "language": "zh",
  22.         "cns": "3",
  23.         "carrier": "CMCC",
  24.         #"imsi": " 460076016067682",
  25.         "User-Agent": "Mozilla/5.0 (Linux; Android 4.4.2; OPPO R11 Build/NMF26X) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/30.0.0.0 Mobile Safari/537.36",
  26.         "act-code": "9d77be448da77d86aa48ae9d822d70d0",
  27.         "act-timestamp": "1569203760",
  28.         "uuid": "b2db10e9-cb21-4c36-ba4c-be62d8b3c67c",
  29.         "newbie": "1",
  30.         "reach": "10000",
  31.         #"lon": "112.573081",
  32.         #"lat": "37.735522",
  33.         #"cid": "140100",
  34.         "Content-Type": "application/x-www-form-urlencoded; charset=utf-8",
  35.         "Accept-Encoding": "gzip, deflate",
  36.         "Connection": "Keep-Alive",
  37.         #"Cookie": "duid=61248941",
  38.         "Host": "api.douguo.net",
  39.         #"Content-Length": "68",
  40.     }
  42.     response = requests.post(url=url,data=data,headers=headers)
  43.     return response
  45. def douguo_index():
  46.     url = 'http://api.douguo.net/recipe/flatcatalogs'
  47.     data = {
  48.             "client":"4",
  49.             #"_session" : "1568947372977863254011601605",
  50.             #"v" : "1568891837",
  51.             "_vs" : "2305"
  52.     }
  53.     response = douguo_request(url, data)
  54.     #需要把json数据变为dict
  55.     response_dict = json.loads(response.text)
  56.     for item1 in response_dict['result']['cs']:
  57.         for item2 in item1['cs']:
  58.             for item3 in item2['cs']:
  59.                 data={
  60.                     "client": "4",
  61.                     # "_session": "1568947372977863254011601605",
  62.                     "keyword": item3['name'],
  63.                     "_vs": "400"
  64.                 }
  65.                 return data
  67. def douguo_item(data):
  68.     print('当前处理食材', data['keyword'])
  69.     url = 'http://api.douguo.net/search/universalnew/0/10'
  70.     response = douguo_request(url=url,data=data)
  71.     print(response.text)
  73. douguo_item(douguo_index())

又输出了一个json数据，接着我们放进网页查看

现在我们已经得到了菜谱的作者、介绍等信息但是没有菜谱的详细信息，我们可以进行简单的赋值操作 

但是现在我们并没有需要的原料和具体的制作步骤，所以接下来我们分析最后一个数据包，可以得到具体的原料，制作步骤等信息

可以发现同样的我们只需要修改数据包发送的data的部分数据就可以，同上面方法类似继续编写程序然后给字典对象赋值

  1. import requests
  2. import json
  4. def douguo_request(url,data):
  5.     #有些头部信息不需要已经进行了注释，因为可能会造成服务器检测我们多次请求问题
  6.     headers = {
  7.         "client": "4",
  8.         "version": "6945.4",
  9.         "device": "OPPO R11",
  10.         "sdk": "19,4.4.2",
  11.         "imei": "866174010601603",
  12.         "channel": "baidu",
  13.         #"mac": "3C:A0:67:68:D1:F5",
  14.         "resolution": "1280*720",
  15.         "dpi": "1.5",
  16.         #"android-id": "3ca06768d1f58615",
  17.         #"pseudo-id": "768d1f586153ca06",
  18.         "brand": "OPPO",
  19.         "scale": "1.5",
  20.         "timezone": "28800",
  21.         "language": "zh",
  22.         "cns": "3",
  23.         "carrier": "CMCC",
  24.         #"imsi": " 460076016067682",
  25.         "User-Agent": "Mozilla/5.0 (Linux; Android 4.4.2; OPPO R11 Build/NMF26X) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/30.0.0.0 Mobile Safari/537.36",
  26.         "act-code": "9d77be448da77d86aa48ae9d822d70d0",
  27.         "act-timestamp": "1569203760",
  28.         "uuid": "b2db10e9-cb21-4c36-ba4c-be62d8b3c67c",
  29.         "newbie": "1",
  30.         "reach": "10000",
  31.         #"lon": "112.573081",
  32.         #"lat": "37.735522",
  33.         #"cid": "140100",
  34.         "Content-Type": "application/x-www-form-urlencoded; charset=utf-8",
  35.         "Accept-Encoding": "gzip, deflate",
  36.         "Connection": "Keep-Alive",
  37.         #"Cookie": "duid=61248941",
  38.         "Host": "api.douguo.net",
  39.         #"Content-Length": "68",
  40.     }
  42.     response = requests.post(url=url,data=data,headers=headers)
  43.     return response
  45. def douguo_index():
  46.     url = 'http://api.douguo.net/recipe/flatcatalogs'
  47.     data = {
  48.             "client":"4",
  49.             #"_session" : "1568947372977863254011601605",
  50.             #"v" : "1568891837",
  51.             "_vs" : "2305"
  52.     }
  53.     response = douguo_request(url, data)
  54.     #需要把json数据变为dict
  55.     response_dict = json.loads(response.text)
  56.     for item1 in response_dict['result']['cs']:
  57.         for item2 in item1['cs']:
  58.             for item3 in item2['cs']:
  59.                 data={
  60.                     "client": "4",
  61.                     # "_session": "1568947372977863254011601605",
  62.                     "keyword": item3['name'],
  63.                     "_vs": "400"
  64.                 }
  65.                 return data
  67. def douguo_item(data):
  68.     item_index_number = 0
  69.     print('当前处理食材', data['keyword'])
  70.     url = 'http://api.douguo.net/search/universalnew/0/10'
  71.     list_response = douguo_request(url=url,data=data)
  72.     list_response_dict = json.loads(list_response.text)
  73.     for item in list_response_dict['result']['recipe']['recipes']:
  74.         item_index_number = item_index_number + 1
  75.         #创建一个字典对象用来存放数据
  76.         caipu_info = {}
  77.         caipu_info['shicai'] = data['keyword']
  78.         caipu_info['author'] = item['an']
  79.         caipu_info['shicai_id'] = item['id']
  80.         caipu_info['shicai_name'] = item['n']
  81.         caipu_info['describe'] = item['cookstory']
  82.         caipu_info['cailiao_list'] = item['major']
  83.         #更多细节需要继续编写请求
  84.         detail_url='http://api.douguo.net/recipe/detail/'+str(caipu_info['shicai_id'])
  85.         detail_data = {
  86.             "client": "4",
  87.             "_session": "1569204243934866174010601603",
  88.             "author_id": "0",
  89.             "_vs": "11101",
  90.             #最下面一条需要我们修改为指定的参数  注意引号与加号写法
  91.             "_ext":'{"query":{"id":'+str(caipu_info['shicai_id'])+',"kw":'+str(caipu_info['shicai'])+',"idx":'+str(item_index_number)+',"src":"11101","type":"13"}}'
  92.         }
  93.         detail_response = douguo_request(url=detail_url,data=detail_data)
  94.         detail_response_dict = json.loads(detail_response.text)
  95.         caipu_info['tips'] = detail_response_dict['result']['recipe']['tips']
  96.         caipu_info['cook_step'] = detail_response_dict['result']['recipe']['cookstep']
  97.         print(caipu_info)
  99. douguo_item(douguo_index())

现在我们大部分的工作已经完成了，我们已经可以获取到食材的各种信息，接下来就是最后一步了。

5）使用多线程抓取并在本地保存至数据库

大家肯定会发现我们刚刚虽然抓取成功了，但是我们只抓取了茄子的数据，那么还有很多很多的食材菜谱，我们该怎样操作呢？对了就是利用线程池进行多线程抓取提升效率

下面开始编写代码：

  1. import requests
  2. import json
  3. #引入队列
  4. from multiprocessing import Queue
  5. #引入线程池
  6. from concurrent.futures import ThreadPoolExecutor
  8. #创建队列
  9. queue_list = Queue()
  11. def douguo_request(url,data):
  12.     #有些头部信息不需要已经进行了注释，因为可能会造成服务器检测我们多次请求问题
  13.     headers = {
  14.         "client": "4",
  15.         "version": "6945.4",
  16.         "device": "OPPO R11",
  17.         "sdk": "19,4.4.2",
  18.         "imei": "866174010601603",
  19.         "channel": "baidu",
  20.         #"mac": "3C:A0:67:68:D1:F5",
  21.         "resolution": "1280*720",
  22.         "dpi": "1.5",
  23.         #"android-id": "3ca06768d1f58615",
  24.         #"pseudo-id": "768d1f586153ca06",
  25.         "brand": "OPPO",
  26.         "scale": "1.5",
  27.         "timezone": "28800",
  28.         "language": "zh",
  29.         "cns": "3",
  30.         "carrier": "CMCC",
  31.         #"imsi": " 460076016067682",
  32.         "User-Agent": "Mozilla/5.0 (Linux; Android 4.4.2; OPPO R11 Build/NMF26X) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/30.0.0.0 Mobile Safari/537.36",
  33.         "act-code": "9d77be448da77d86aa48ae9d822d70d0",
  34.         "act-timestamp": "1569203760",
  35.         "uuid": "b2db10e9-cb21-4c36-ba4c-be62d8b3c67c",
  36.         "newbie": "1",
  37.         "reach": "10000",
  38.         #"lon": "112.573081",
  39.         #"lat": "37.735522",
  40.         #"cid": "140100",
  41.         "Content-Type": "application/x-www-form-urlencoded; charset=utf-8",
  42.         "Accept-Encoding": "gzip, deflate",
  43.         "Connection": "Keep-Alive",
  44.         #"Cookie": "duid=61248941",
  45.         "Host": "api.douguo.net",
  46.         #"Content-Length": "68",
  47.     }
  49.     response = requests.post(url=url,data=data,headers=headers)
  50.     return response
  52. def douguo_index():
  53.     url = 'http://api.douguo.net/recipe/flatcatalogs'
  54.     data = {
  55.             "client":"4",
  56.             #"_session" : "1568947372977863254011601605",
  57.             #"v" : "1568891837",
  58.             "_vs" : "2305"
  59.     }
  60.     response = douguo_request(url, data)
  61.     #需要把json数据变为dict
  62.     response_dict = json.loads(response.text)
  63.     for item1 in response_dict['result']['cs']:
  64.         for item2 in item1['cs']:
  65.             for item3 in item2['cs']:
  66.                 data={
  67.                     "client": "4",
  68.                     # "_session": "1568947372977863254011601605",
  69.                     "keyword": item3['name'],
  70.                     "_vs": "400"
  71.                 }
  72.                 #放入队列使用put方法
  73.                 queue_list.put(data)
  75. def douguo_item(data):
  76.     item_index_number = 0
  77.     print('当前处理食材', data['keyword'])
  78.     url = 'http://api.douguo.net/search/universalnew/0/10'
  79.     list_response = douguo_request(url=url,data=data)
  80.     list_response_dict = json.loads(list_response.text)
  81.     for item in list_response_dict['result']['recipe']['recipes']:
  82.         item_index_number = item_index_number + 1
  83.         #创建一个字典对象用来存放数据
  84.         caipu_info = {}
  85.         caipu_info['shicai'] = data['keyword']
  86.         caipu_info['author'] = item['an']
  87.         caipu_info['shicai_id'] = item['id']
  88.         caipu_info['shicai_name'] = item['n']
  89.         caipu_info['describe'] = item['cookstory']
  90.         caipu_info['cailiao_list'] = item['major']
  91.         #更多细节需要继续编写请求
  92.         detail_url='http://api.douguo.net/recipe/detail/'+str(caipu_info['shicai_id'])
  93.         detail_data = {
  94.             "client": "4",
  95.             "_session": "1569204243934866174010601603",
  96.             "author_id": "0",
  97.             "_vs": "11101",
  98.             #最下面一条需要我们修改为指定的参数  注意引号与加号写法
  99.             "_ext":'{"query":{"id":'+str(caipu_info['shicai_id'])+',"kw":'+str(caipu_info['shicai'])+',"idx":'+str(item_index_number)+',"src":"11101","type":"13"}}'
  100.         }
  101.         detail_response = douguo_request(url=detail_url,data=detail_data)
  102.         detail_response_dict = json.loads(detail_response.text)
  103.         caipu_info['tips'] = detail_response_dict['result']['recipe']['tips']
  104.         caipu_info['cook_step'] = detail_response_dict['result']['recipe']['cookstep']
  105.         print('当前处理的菜谱是：',caipu_info['shicai_name'])
  106.         print(caipu_info)
  108. douguo_index()
  109. #同时进行处理的任务数
  110. pool = ThreadPoolExecutor(max_workers=25)
  111. while(queue_list.qsize()>0):
  112.     #注意多线程写法，douguo_item函数后一定不能加括号
  113.     pool.submit(douguo_item,queue_list.get())

再次运行，发现现在已经可以抓取所有的菜谱，然后我们只需要进行最后一步将数据保存到本地数据库就彻底大功告成了

我们可以先编写一个入库函数douguo_mongo.py

  1. import pymongo
  2. from pymongo.collection import Collection
  4. class Cnonnect_mongo(object):
  5.     def __init__(self):
  6.         #本地数据库host为127.0.0.1 端口为27017 具体可以打开mongodb查看
  7.         self.client = pymongo.MongoClient(host='127.0.0.1',port=27017)
  8.         #数据库名称
  9.         self.dbdata = self.client['douguomeishi']
  11.     def insert_item(self,item):
  12.         #数据表名称为 douguo_item
  13.         db_collection = Collection(self.dbdata,'douguo_item')
  14.         db_collection.insert(item)
  16. mongo_info = Cnonnect_mongo()

然后我们去爬虫文件引用刚刚写的入库对象类并使用插入函数

  1. import requests
  2. import json
  3. #引入队列
  4. from multiprocessing import Queue
  5. #引入线程池
  6. from concurrent.futures import ThreadPoolExecutor
  7. #引用入库类对象
  8. from handel_mongo import mongo_info
  10. #创建队列
  11. queue_list = Queue()
  13. def douguo_request(url,data):
  14.     #有些头部信息不需要已经进行了注释，因为可能会造成服务器检测我们多次请求问题
  15.     headers = {
  16.         "client": "4",
  17.         "version": "6945.4",
  18.         "device": "OPPO R11",
  19.         "sdk": "19,4.4.2",
  20.         "imei": "866174010601603",
  21.         "channel": "baidu",
  22.         #"mac": "3C:A0:67:68:D1:F5",
  23.         "resolution": "1280*720",
  24.         "dpi": "1.5",
  25.         #"android-id": "3ca06768d1f58615",
  26.         #"pseudo-id": "768d1f586153ca06",
  27.         "brand": "OPPO",
  28.         "scale": "1.5",
  29.         "timezone": "28800",
  30.         "language": "zh",
  31.         "cns": "3",
  32.         "carrier": "CMCC",
  33.         #"imsi": " 460076016067682",
  34.         "User-Agent": "Mozilla/5.0 (Linux; Android 4.4.2; OPPO R11 Build/NMF26X) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/30.0.0.0 Mobile Safari/537.36",
  35.         "act-code": "9d77be448da77d86aa48ae9d822d70d0",
  36.         "act-timestamp": "1569203760",
  37.         "uuid": "b2db10e9-cb21-4c36-ba4c-be62d8b3c67c",
  38.         "newbie": "1",
  39.         "reach": "10000",
  40.         #"lon": "112.573081",
  41.         #"lat": "37.735522",
  42.         #"cid": "140100",
  43.         "Content-Type": "application/x-www-form-urlencoded; charset=utf-8",
  44.         "Accept-Encoding": "gzip, deflate",
  45.         "Connection": "Keep-Alive",
  46.         #"Cookie": "duid=61248941",
  47.         "Host": "api.douguo.net",
  48.         #"Content-Length": "68",
  49.     }
  51.     response = requests.post(url=url,data=data,headers=headers)
  52.     return response
  54. def douguo_index():
  55.     url = 'http://api.douguo.net/recipe/flatcatalogs'
  56.     data = {
  57.             "client":"4",
  58.             #"_session" : "1568947372977863254011601605",
  59.             #"v" : "1568891837",
  60.             "_vs" : "2305"
  61.     }
  62.     response = douguo_request(url, data)
  63.     #需要把json数据变为dict
  64.     response_dict = json.loads(response.text)
  65.     for item1 in response_dict['result']['cs']:
  66.         for item2 in item1['cs']:
  67.             for item3 in item2['cs']:
  68.                 data={
  69.                     "client": "4",
  70.                     # "_session": "1568947372977863254011601605",
  71.                     "keyword": item3['name'],
  72.                     "_vs": "400"
  73.                 }
  74.                 #放入队列使用put方法
  75.                 queue_list.put(data)
  77. def douguo_item(data):
  78.     item_index_number = 0
  79.     print('当前处理食材', data['keyword'])
  80.     url = 'http://api.douguo.net/search/universalnew/0/10'
  81.     list_response = douguo_request(url=url,data=data)
  82.     list_response_dict = json.loads(list_response.text)
  83.     for item in list_response_dict['result']['recipe']['recipes']:
  84.         item_index_number = item_index_number + 1
  85.         #创建一个字典对象用来存放数据
  86.         caipu_info = {}
  87.         caipu_info['shicai'] = data['keyword']
  88.         caipu_info['author'] = item['an']
  89.         caipu_info['shicai_id'] = item['id']
  90.         caipu_info['shicai_name'] = item['n']
  91.         caipu_info['describe'] = item['cookstory']
  92.         caipu_info['cailiao_list'] = item['major']
  93.         #更多细节需要继续编写请求
  94.         detail_url='http://api.douguo.net/recipe/detail/'+str(caipu_info['shicai_id'])
  95.         detail_data = {
  96.             "client": "4",
  97.             "_session": "1569204243934866174010601603",
  98.             "author_id": "0",
  99.             "_vs": "11101",
  100.             #最下面一条需要我们修改为指定的参数  注意引号与加号写法
  101.             "_ext":'{"query":{"id":'+str(caipu_info['shicai_id'])+',"kw":'+str(caipu_info['shicai'])+',"idx":'+str(item_index_number)+',"src":"11101","type":"13"}}'
  102.         }
  103.         detail_response = douguo_request(url=detail_url,data=detail_data)
  104.         detail_response_dict = json.loads(detail_response.text)
  105.         caipu_info['tips'] = detail_response_dict['result']['recipe']['tips']
  106.         caipu_info['cook_step'] = detail_response_dict['result']['recipe']['cookstep']
  107.         print('当前处理的菜谱是：',caipu_info['shicai_name'])
  108.         #保存到数据库
  109.         mongo_info.insert_item(caipu_info)
  111. douguo_index()
  112. #同时进行处理的任务数
  113. pool = ThreadPoolExecutor(max_workers=25)
  114. while(queue_list.qsize()>0):
  115.     #注意多线程写法，douguo_item函数后一定不能加括号
  116.     pool.submit(douguo_item,queue_list.get())

运行，我们的数据就保存在数据库了

这就是爬取一个App的整个流程，有点繁琐，但也很有趣，一步一步的解析数据，挺有挑战性的。

 

原文链接：http://www.cnblogs.com/CYHISTW/p/11561769.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Python3热门文章

  • PyQt-Fluent-Widgets：一个 Fluent Design 风格的组件库
  • Python3读取文件的操作详解
  • 口播神器,基于Edge,微软TTS(text-to-speech)文字转语音免费开源库edge-tts实践(Python3.10)
  • 向量数据库Chroma极简教程
  • 笔精墨妙,妙手丹青,微软开源可视化版本的ChatGPT:Visual ChatGPT,人工智能AI聊天发图片,Python3.10实现
  • win10+vs2019 编译webrtc m108
  • 闻其声而知雅意,基于Pytorch(mps/cpu/cuda)的人工智能AI本地语音识别库Whisper(Python3.10)
  • 靶机练习: Vikings
  • Python3 实现将bytes图片转jpg格式
  • MacBook m1芯片采用miniforge安装python3.9的方法示例

    • Python3推荐文章

  • 分页查询及其拓展应用案例
  • adorner 使用示例
  • 使用pyqt5制作简单计分桌面应用
  • cuda性能优化-2.访存优化
  • 通过钩子函数+Traceid实现Flask链路追踪
  • RCTF 2024 WEB wp
  • 【昇腾开发全流程】AscendCL开发板模型推理
  • PVT：特征金字塔在Vision Transormer的首次应用，又快又好 | ICCV 2021
  • 「网络流浅谈」最小割的模型 - E-Syrus
  • 比Selenium更优秀的playwright介绍与未来展望

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号