您的位置: 首页  >  文章  >  使用网页爬虫（高级搜索功能）搜集含关键词新浪微博数据

使用网页爬虫（高级搜索功能）搜集含关键词新浪微博数据

分类: 文章 • 2024-07-18 17:21:04

作为国内社交媒体的领航者，很遗憾，新浪微博没有提供以“关键字+时间+区域”方式获取的官方API。当我们看到国外科研成果都是基于某关键字获得的社交媒体数据，心中不免凉了一大截，或者转战推特。再次建议微博能更开放些！


1、切入点

庆幸的是，新浪提供了高级搜索功能。找不到？这个功能需要用户登录才能使用……没关系，下面将详细讲述如何在无须登录的情况下，获取“关键字+时间+区域”的新浪微博。

首先我们还是要登录一下，看看到底是个什么样的功能。

使用网页爬虫（高级搜索功能）搜集含关键词新浪微博数据

然后我们看看地址栏：

[html] view plain copy
  1. http://s.weibo.com/wb/%25E4%25B8%25AD%25E5%259B%25BD%25E5%25A5%25BD%25E5%25A3%25B0%25E9%259F%25B3&xsort=time&region=custom:11:1000&timescope=custom:2014-07-09-2:2014-07-19-4&Refer=g  


这么长？其实蛮清晰、简单的。解析如下：


固定地址部分：http://s.weibo.com/wb/

关键字（2次URLEncode编码）：%25E4%25B8%25AD%25E5%259B%25BD%25E5%25A5%25BD%25E5%25A3%25B0%25E9%259F%25B3

返回微博的排序方式（此处为“实时”）：xsort=time

搜索地区：region=custom:11:1000

搜索时间范围：timescope=custom:2013-07-02-2:2013-07-09-2

可忽略项：Refer=g

是否显示类似微博（未出现）：nodup=1    注：加上这个选项可多收集微博，建议加上。默认为省略参数，即省略部分相似微博。

某次请求的页数（未出现）：page=1


既然是这么回事，我们接下来就可以使用网页爬虫的方式获取“关键字+时间+区域”的微博了……

2、采集思路

大体思路如下：构造URL，爬取网页，然后解析网页中的微博信息，如下图所示。微博官方提供了根据微博ID进行查询的微博信息的API，故本文只负责讲述收集微博ID。

另外，高级搜索最多返回50页微博，那么时间间隔设置最小为宜。所以时间范围（timescope）可设置为1小时，如2013-07-01-2:2013-07-01-2。

目前没有模拟登陆，所以需要设置两个邻近URL请求之间的随机休眠时间，过于频繁会被认为是机器人，你懂的。

使用网页爬虫（高级搜索功能）搜集含关键词新浪微博数据

3、具体实现

作为爬虫小工具，用python非常适合。作为python初学者，不要怪我写得像java。首先实现一个爬取每个小时的类。

[python] view plain copy
  1. class CollectData():  
  2.     """每小时数据收集类 
  3.         利用微博高级搜索功能，按关键字搜集一定时间范围内的微博。 
  4.  
  5.         大体思路：构造URL，爬取网页，然后解析网页中的微博ID。后续利用微博API进行数据入库。本程序只负责收集微博的ID。 
  6.  
  7.         登陆新浪微博，进入高级搜索，输入关键字”空气污染“，选择”实时“，时间为”2013-07-02-2:2013-07-09-2“，地区为”北京“，之后发送请求会发现地址栏变为如下： 
  8.         http://s.weibo.com/wb/%25E7%25A9%25BA%25E6%25B0%2594%25E6%25B1%25A1%25E6%259F%2593&xsort=time&region=custom:11:1000×cope=custom:2013-07-02-2:2013-07-09-2&Refer=g 
  9.  
  10.             固定地址部分：http://s.weibo.com/wb/ 
  11.             关键字二次UTF-8编码：%25E7%25A9%25BA%25E6%25B0%2594%25E6%25B1%25A1%25E6%259F%2593 
  12.             排序为“实时”：xsort=time 
  13.             搜索地区：region=custom:11:1000 
  14.             搜索时间范围：timescope=custom:2013-07-02-2:2013-07-09-2 
  15.             可忽略项：Refer=g 
  16.             显示类似微博：nodup=1    注：这个选项可多收集微博，建议加上。默认不加此参数，省略了部分相似微博。 
  17.             某次请求的页数：page=1 
  18.  
  19.         另外，高级搜索最多返回50页微博，那么时间间隔设置最小为宜。所以该类设置为搜集一定时间段内最多50页微博。 
  20.     """  
  21.     def __init__(self, keyword, startTime, region, savedir, interval='50', flag=True, begin_url_per = "http://s.weibo.com/weibo/"):  
  22.         self.begin_url_per = begin_url_per  #设置固定地址部分，默认为"http://s.weibo.com/weibo/"，或者"http://s.weibo.com/wb/"  
  23.         self.setKeyword(keyword)    #设置关键字  
  24.         self.setStartTimescope(startTime)   #设置搜索的开始时间  
  25.         self.setRegion(region)  #设置搜索区域  
  26.         self.setSave_dir(savedir)   #设置结果的存储目录  
  27.         self.setInterval(interval)  #设置邻近网页请求之间的基础时间间隔（注意：过于频繁会被认为是机器人）  
  28.         self.setFlag(flag)  #设置  
  29.         self.logger = logging.getLogger('main.CollectData') #初始化日志  
  30.   
  31.     ##设置关键字  
  32.     ##关键字需解码  
  33.     def setKeyword(self, keyword):  
  34.         self.keyword = keyword.decode('GBK').encode("utf-8")  
  35.         print 'twice encode:',self.getKeyWord()  
  36.   
  37.     ##设置起始范围，间隔为1小时  
  38.     ##格式为：yyyy-mm-dd-HH  
  39.     def setStartTimescope(self, startTime):  
  40.         if not (startTime == '-'):  
  41.             self.timescope = startTime + ":" + startTime  
  42.         else:  
  43.             self.timescope = '-'  
  44.   
  45.     ##设置搜索地区  
  46.     def setRegion(self, region):  
  47.         self.region = region  
  48.   
  49.     ##设置结果的存储目录  
  50.     def setSave_dir(self, save_dir):  
  51.         self.save_dir = save_dir  
  52.         if not os.path.exists(self.save_dir):  
  53.             os.mkdir(self.save_dir)  
  54.   
  55.     ##设置邻近网页请求之间的基础时间间隔  
  56.     def setInterval(self, interval):  
  57.         self.interval = int(interval)  
  58.   
  59.     ##设置是否被认为机器人的标志。若为False，需要进入页面，手动输入验证码  
  60.     def setFlag(self, flag):  
  61.         self.flag = flag  
  62.   
  63.     ##构建URL  
  64.     def getURL(self):  
  65.         return self.begin_url_per+self.getKeyWord()+"&region=custom:"+self.region+"&xsort=time×cope=custom:"+self.timescope+"&nodup=1&page="  
  66.   
  67.     ##关键字需要进行两次urlencode  
  68.     def getKeyWord(self):  
  69.         once = urllib.urlencode({"kw":self.keyword})[3:]  
  70.         return urllib.urlencode({"kw":once})[3:]  
  71.   
  72.     ##爬取一次请求中的所有网页，最多返回50页  
  73.     def download(self, url, maxTryNum=4):  
  74.         content = open(self.save_dir + os.sep + "weibo_ids.txt", "ab")  #向结果文件中写微博ID  
  75.   
  76.         hasMore = True  #某次请求可能少于50页，设置标记，判断是否还有下一页  
  77.         isCaught = False    #某次请求被认为是机器人，设置标记，判断是否被抓住。抓住后，需要复制log中的文件，进入页面，输入验证码  
  78.         mid_filter = set([])    #过滤重复的微博ID  
  79.           
  80.         i = 1   #记录本次请求所返回的页数  
  81.         while hasMore and i < 51 and (not isCaught):    #最多返回50页，对每页进行解析，并写入结果文件  
  82.             source_url = url + str(i)   #构建某页的URL  
  83.             data = ''   #存储该页的网页数据  
  84.             goon = True #网络中断标记  
  85.   
  86.             ##网络不好的情况，试着尝试请求三次  
  87.             for tryNum in range(maxTryNum):  
  88.                 try:  
  89.                     html = urllib2.urlopen(source_url, timeout=12)  
  90.                     data = html.read()  
  91.                     break  
  92.                 except:  
  93.                     if tryNum < (maxTryNum-1):  
  94.                         time.sleep(10)  
  95.                     else:  
  96.                         print 'Internet Connect Error!'  
  97.                         self.logger.error('Internet Connect Error!')  
  98.                         self.logger.info('filePath: ' + savedir)  
  99.                         self.logger.info('url: ' + source_url)  
  100.                         self.logger.info('fileNum: ' + str(fileNum))  
  101.                         self.logger.info('page: ' + str(i))  
  102.                         self.flag = False  
  103.                         goon = False  
  104.                         break  
  105.             if goon:  
  106.                 lines = data.splitlines()  
  107.                 isCaught = True  
  108.                 for line in lines:  
  109.                     ## 判断是否有微博内容，出现这一行，则说明没有被认为是机器人  
  110.                     if line.startswith('<script>STK && STK.pageletM && STK.pageletM.view({"pid":"pl_weibo_direct"'):  
  111.                         isCaught = False  
  112.                         n = line.find('html":"')  
  113.                         if n > 0:  
  114.                             j = line[n + 7: -12].encode("utf-8").decode('unicode_escape').encode("utf-8").replace("\\", "")  
  115.                             ## 没有更多结果页面  
  116.                             if (j.find('<div class="search_noresult">') > 0):  
  117.                                 hasMore = False  
  118.                             ## 有结果的页面  
  119.                             else:  
  120.                                 page = etree.HTML(j)  
  121.                                 dls = page.xpath(u"//dl")   #使用xpath解析  
  122.                                 for dl in dls:  
  123.                                     mid = str(dl.attrib.get('mid'))  
  124.                                     if(mid != 'None' and mid not in mid_filter):  
  125.                                         mid_filter.add(mid)  
  126.                                         content.write(mid)  
  127.                                         content.write('\n')  
  128.                         break  
  129.                 lines = None  
  130.                 ## 处理被认为是机器人的情况  
  131.                 if isCaught:  
  132.                     print 'Be Caught!'  
  133.                     self.logger.error('Be Caught Error!')  
  134.                     self.logger.info('filePath: ' + savedir)  
  135.                     self.logger.info('url: ' + source_url)  
  136.                     self.logger.info('fileNum: ' + str(fileNum))  
  137.                     self.logger.info('page:' + str(i))  
  138.                     data = None  
  139.                     self.flag = False  
  140.                     break  
  141.                 ## 没有更多结果，结束该次请求，跳到下一个请求  
  142.                 if not hasMore:  
  143.                     print 'No More Results!'  
  144.                     if i == 1:  
  145.                         time.sleep(random.randint(55,75))  
  146.                     else:  
  147.                         time.sleep(15)  
  148.                     data = None  
  149.                     break  
  150.                 i += 1  
  151.                 ## 设置两个邻近URL请求之间的随机休眠时间，你懂的。目前没有模拟登陆  
  152.                 sleeptime_one = random.randint(self.interval-30,self.interval-10)  
  153.                 sleeptime_two = random.randint(self.interval+10,self.interval+30)  
  154.                 if i%2 == 0:  
  155.                     sleeptime = sleeptime_two  
  156.                 else:  
  157.                     sleeptime = sleeptime_one  
  158.                 print 'sleeping ' + str(sleeptime) + ' seconds...'  
  159.                 time.sleep(sleeptime)  
  160.             else:  
  161.                 break  
  162.         content.close()  
  163.         content = None  
  164.   
  165.     ##改变搜索的时间范围，有利于获取最多的数据     
  166.     def getTimescope(self, perTimescope, hours):  
  167.         if not (perTimescope=='-'):  
  168.             times_list = perTimescope.split(':')  
  169.             start_datetime = datetime.datetime.fromtimestamp(time.mktime(time.strptime(times_list[-1],"%Y-%m-%d-%H")))  
  170.             start_new_datetime = start_datetime + datetime.timedelta(seconds = 3600)  
  171.             end_new_datetime = start_new_datetime + datetime.timedelta(seconds = 3600*(hours-1))  
  172.             start_str = start_new_datetime.strftime("%Y-%m-%d-%H")  
  173.             end_str = end_new_datetime.strftime("%Y-%m-%d-%H")  
  174.             return start_str + ":" + end_str  
  175.         else:  
  176.             return '-'  

有了每个小时的类之后，那就可以设置开始收集的时间了。

[python] view plain copy
  1. def main():  
  2.     logger = logging.getLogger('main')  
  3.     logFile = './collect.log'  
  4.     logger.setLevel(logging.DEBUG)  
  5.     filehandler = logging.FileHandler(logFile)  
  6.     formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s: %(message)s')  
  7.     filehandler.setFormatter(formatter)  
  8.     logger.addHandler(filehandler)  
  9.   
  10.     while True:  
  11.         ## 接受键盘输入  
  12.         keyword = raw_input('Enter the keyword(type \'quit\' to exit ):')  
  13.         if keyword == 'quit':  
  14.             sys.exit()  
  15.         startTime = raw_input('Enter the start time(Format:YYYY-mm-dd-HH):')  
  16.         region = raw_input('Enter the region([BJ]11:1000,[SH]31:1000,[GZ]44:1,[CD]51:1):')  
  17.         savedir = raw_input('Enter the save directory(Like C://data//):')  
  18.         interval = raw_input('Enter the time interval( >30 and deafult:50):')  
  19.   
  20.         ##实例化收集类，收集指定关键字和起始时间的微博  
  21.         cd = CollectData(keyword, startTime, region, savedir, interval)  
  22.         while cd.flag:  
  23.             print cd.timescope  
  24.             logger.info(cd.timescope)  
  25.             url = cd.getURL()  
  26.             cd.download(url)  
  27.             cd.timescope = cd.getTimescope(cd.timescope,1)  #改变搜索的时间，到下一个小时  
  28.         else:  
  29.             cd = None  
  30.             print '-----------------------------------------------------'  
  31.             print '-----------------------------------------------------'  
  32.     else:  
  33.         logger.removeHandler(filehandler)  
  34.         logger = None  
万事俱备，跑起来吧！

[python] view plain copy
  1. if __name__ == '__main__':  
  2.     main()  

就这样了……

如果想编译成windows窗口文件或者想改造成自己小爬虫，欢迎去 github pull一下！！

相关推荐