Python爬虫：关于 广度优先 和 深度优先

广度优先和深度优先

关于广度优先和深度优先，首先,不管是广度还是深度,都需要定义一个爬取的深度 crawl_deepth，深度优先比较容易实现 显示递归嘛 爬取的层次。

所谓广度优先 就是要把当前页的 link 全部爬取完毕再进行下一深度的遍历，这就要给一些队列分类 一般分为待爬队列, 已爬队列, 新加队列, pop队列，首先要确保访问每个深度页是的待爬队列已经清空 才获取下一页的超链接，思路嘛 大概可以用 while 1 来实现 。

当然也可以直接写好 pop 方法 直接 pop 出来 到最后清空队列 继续往下走。

这里有一个简单的例子 可供参考，虽然没有解析函数 思想可行。

定义 Redis 队列

class RedisQueue(object):
    def __init__(self, name, namespace='queue', **redis_kwargs):
        self.__db = redis.Redis(host='127.0.0.1', port=6379, db=0, password=None)
        self.key = f"{name,namespace}"

    # 返回队列大小
    def qsize(self):
        return self.__db.llen(self.key)

    # 判断队列用尽
    def empty(self):
        return self.qsize() == 0

    # rpush进去或者lpush都可以
    def put(self, item):
        self.__db.rpush(self.key, item)

    # get出来
    def get(self, block=True, timeout=None)
        if block:
            item = self.__db.blpop(self.key, timeout=timeout)
        else:
            item = self.__db.lpop(self.key)
        return item

    def get_nowait(self):
        return self.get(False)

广度优先
直接上套餐

class MyCrawler:

    def __init__(self):

        # 初始化当前抓取的深度
        self.current_deepth = 1

        # 使用种子初始化url队列
        self.vistedQueue = RedisQueue("vistedQueue")
        self.unvistedQueue = RedisQueue("unvistedQueue")

    def put_unvistedQueue(self, seeds):
        if isinstance(seeds, str):
            self.unvistedQueue.put(seeds)
        if isinstance(seeds, list):
            for seed in seeds:
                self.unvistedQueue.put(seed)
        print("成功添加到未爬队列")

    # 主函数
    def crawling(self, crawl_deepth):

        # 深度 crawl_deepth
        while self.current_deepth <= crawl_deepth:

            # 确保清空队列之后再继续 先广后深
            while not self.unvistedQueue.empty():
                # 出队列
                visitUrl = self.unvistedQueue.get_nowait().decode()
                print(f"取出url {visitUrl}")

                # 获取超链接
                links = self.getHyperLinks(visitUrl)
                print(f"页面 link 数量 {len(links)}")

                # 将url放入已访问的url中
                self.vistedQueue.put(visitUrl)
                print("当前深度: " + str(self.current_deepth))

                # 未访问的url入列
                for link in links:
                    self.unvistedQueue.put(link)
                # 深度加 1
                self.current_deepth += 1

    # 获取源码中超链接
    def getHyperLinks(self, url):
        links = []
        data = self.getPageSource(url)
        if data:
            soup = BeautifulSoup(data)
            a = soup.findAll("a", {"href": re.compile('^http|^/')})
            for i in a:
                if i["href"].find("http://") != -1:
                    links.append(i["href"])
        return links

    # get html
    def getPageSource(self, url,  headers=None, timeout=15):
        try:
            request = requests.get(url,headers,timeout=timeout)
            if request.status_code in [200,201]:
                request.encoding = request.apparent_encoding
                return request.text
        except ConnectionError:
            return None

执行主函数

if __name__=="__main__":

     # 指定爬取的深度 10
     c = MyCrawler()
     c.put_unvistedQueue(["http://www.baidu.com", "http://www.google.com"])
     c.crawling(10)

我这里用的是 Redis 作为未爬 和 已爬的队列（其实用内置 set 也一样）
由于我这里是 rpush(右边进) 和 lpop(左边出) 这样就达到了 先广后深 的爬取目的了

深度优先
比广度优先好写一点 就是递归爬取 只需要定义深度

import requests
import re
import time

exist_urls = []
headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.62 Safari/537.36',
}

def get_link(url):
    try:
        response = requests.get(url=url, headers=headers)
        response.encoding = 'UTF-8'
        html = response.text
        link_lists = re.findall('.*?<a target=_blank href="/item/([^:#=<>]*?)".*?</a>', html)
        return link_lists
    except Exception as e:
        pass
    finally:
        exist_urls.append(url)

# 当爬取深度小于10层时，递归调用主函数，继续爬取第二层的所有链接
def main(start_url, depth=1):
    link_lists = get_link(start_url)
    if link_lists:
        unique_lists = list(set(link_lists) - set(exist_urls))
        for unique_url in unique_lists:
            unique_url = 'https://baike.baidu.com/item/' + unique_url
            output = 'Depth:' + str(depth) + '\t' + start_url + '======>' + unique_url + '\n'
            print(output)

            with open('url.txt', 'a+') as f:
                f.write(unique_url + '\n')
                f.close()
            if depth < 10:
                main(unique_url, depth + 1)

执行主函数

if __name__ == '__main__':
    t1 = time.time()
    start_url = 'https://baike.baidu.com/item/%E7%99%BE%E5%BA%A6%E7%99%BE%E7%A7%91'
    main(start_url)
    t2 = time.time()
    print('总时间', t2 - t1)

以上的例子实现 深度优先 和 广度优先的代码，其实没啥复杂的，也比较好理解。
提供思路，仅供参考。

欢迎转载，但要声明出处，不然我顺着网线过去就是一拳。
个人技术博客：http://www.gzky.live