精华内容
下载资源
问答
  • 自制爬虫框架

    万次阅读 多人点赞 2020-10-19 17:58:48
      在平时挥手大干项目的过程中,时不时会有一些小的爬虫任务需要处理,因此专门写了一个爬虫框架,基本覆盖平常用到的网站,觉得使用效果不错,分享出来给大家使用,也请各路大神走过路过提些好的意见。...


      在平时挥手大干项目的过程中,时不时会有一些小的爬虫任务需要处理,因此专门写了一个爬虫框架,基本覆盖平常用到的网站,觉得使用效果不错,分享出来给大家使用,也请各路大神走过路过提些好的意见。
      接下来为大家简单介绍一下每个模块实现过程及思路。本文结束后处会附全部代码,前面代码只是便于大家理解,无需挨个粘贴。

    1.mysql数据库链接

      本程序使用mysql数据库读取和保存数据,为了工作过程中的安全和方便,我们通过另外一个程序将数据库链接账号密码等数据,保存中windows注册表中,可通过 win+regedit 调出查看。(此块仅适用于windows系统,若需在linux上使用,则不使用此模块链接数据库),本模块中数据库链接方式见代码:

        def read_setttings_zhuce(self, file, winn_c_u=winreg.HKEY_CURRENT_USER):
            """
                读取注册表中的设置
            """
            parentkey = winreg.OpenKey(winn_c_u, file)
            # 获取该键的所有键值,因为没有方法可以获取键值的个数,所以只能用这种方法进行遍历
            item = dict()
            try:
                i = 0
                while True:
                    # EnumValue方法用来枚举键值,EnumKey用来枚举子键
                    name, value, type = winreg.EnumValue(parentkey, i)
                    item[name] = value
                    i += 1
            except Exception as e:
                pass
            return item
        
        def __init__(self, start_p):
            # 注意,super().__init__() 一定要写
            # 而且要写在最前面,否则会报错。
            super().__init__()
            self.item_fwq = self.read_setttings_zhuce("Software\lxl\lxl_program")
            # 链接数据库
            self.conn = pymysql.connect(
                user=self.item_fwq["user"], password=self.item_fwq["password"], host=self.item_fwq["host"], port=int(self.item_fwq["port"]),
                database=self.item_fwq["database"], use_unicode=True,
                charset="utf8")
            self.start_p = start_p
            print("数据库开启中......")
            # 获取游标
            self.cursor = self.conn.cursor()
    

    2. 页面请求过程

      此处说明一下,整个模块是通过dict来传递数据的,因此在使用过程中,可以随时随地添加我们需要传递的参数。我们平常用到的页面一般是get或post请求方式,get方式通过修改传递的url链接即可请求获取数据,post方式通过data参数传递获取数据。因此将两种方式分开处理。同时将请求回来的数据做deocde解码处理,一般遇到的有utf8或者GBK的,我写了两种,如果你们使用过程中出现其他的解码,添加上去即可,此处代码比较low我就不贴在此处了,各位结尾处直接复制即可,(我贴几行重点吧,否则好像显得此处特殊)。ip代理注册购买链接:http://www.data5u.com/?developer=68f5e90ca2ad45d11f3d32561fe24bc5

            item_fwq_ip = read_setttings_zhuce("Software\lxl\lxl_program")
            # 读取实时写入windows注册表中的ip代理  本人喜欢使用无忧代理 不是打广告,而是品质确实好 
            proxies = {"http": "%s" % item_fwq_ip["ip"], "https": "%s" % item_fwq_ip["ip"]}
            headers = {
                 "user-agent": item_fwq_ip['user_agent']
            }
            try:
                response = requests.get(url=url, headers=headers, timeout=20).content
                if response:
                    return response
            except Exception as f:
                print("重新请求")
            try:
                response = requests.post(url=url, headers=headers, data=data,timeout=20).content
                if response:
                    return response
            except Exception as f:
                print("重新请求")
    

    3. 数据提取处理

      页面请求成功之后,会返回三种格式,一种是html格式,一种是json格式,还有一种是我请求不到数据返回的无数据结果(未针对此处如何处理,若有需要,自行处理)。针对html格式我们使用xpath解析数据(本来想着能不能通过代码去自动处理xpath,太忙没时间,以后补上吧);针对json格式,就简单许多了,直接对应读取出来即可。两种格式处理之后,将数据以dict格式传递至数据保存处理中即可 见代码:

        def response_json(self, response, meta={}):
            """
                json 格式解析
            """
            list_data = response['result']['data']
            for ds in list_data:
                item = dict()
                """
                    此处可以对数据进行处理,若不需特殊处理的 则直接合并到item字典中,保存入数据库
                    列: item["pid] = ds['id']
                """
                item = {**item, **meta}
                where_list = ["pid"]  # 此处添加mysql保存判断条件中查询的字段 可写多个字段
                table_name = 'your_databases_tablename'  # 此处添加你需要保存的数据表名称 注: 若没有新建数据表, 代码可自动建立新的数据表
                self.mysql_f_item(item, table_name=table_name, where_list=where_list)
        
        def response_html(self, response, meta={}):
            """
                html 格式解析
            """
            list_response = response.xpath('//div[@class="name"]')
            for resp in list_response:
                item = dict()
                """
                    此处可以对数据进行xpath解析处理,保存入数据库
                    列: item["pid] = resp.xpath('./a/@href')[0]
                """
                print(item)
                item = {**item, **meta}
                where_list = ["pid"]  # 此处添加mysql保存判断条件中查询的字段 可写多个字段
                table_name = "your_databases_tablename" # 此处添加你需要保存的数据表名称 注: 若没有新建数据表, 代码可自动建立新的数据表
                self.mysql_f_item(item, table_name, where_list=where_list)
    

    4. 数据保存处理。

      数据库选用mysql保存,在此模块中,我加入了自动创建表和自动拼接sql的功能,传入一个数据表名称,若存在则进行下一步处理,不存在会进行数据表创建,此时dict中的字段名称就起到了一定的作用,我通过字段中所带的值,作为创建字段的类型(此处也可自行添加);同时数据保存过程中,有时会需要做判重,通过在指定列表 where_list 中添加字段即可(默认为空,不判重。其他的没什么了都是一些常规操作了。见代码:

            sql = "insert into %s(" % table_name
            for item in lst:
                sql = sql + "`%s`," % item
            sql = sql.strip(',') + ") values ("
            if list_flag is False:
                for item in lst:
                    sql = sql + "'{%s}'," % item
            else:
                for i in range(len(lst)):
                    sql = sql + "'{0[%s]}'," % i
            sql = sql.strip(',') + ")"
            return sql
    
                    sql_begin = """CREATE TABLE `%s` (  `id` int(11) NOT NULL AUTO_INCREMENT,""" % table_name
            sql_end = """ PRIMARY KEY (`id`)
                        ) ENGINE=%s AUTO_INCREMENT=0 DEFAULT CHARSET=%s;""" % (engine, charset)
            sql_temp = " `%s` varchar(256) DEFAULT NULL,"
            sql_temp_time = "`%s` datetime DEFAULT NULL,"
            sql_temp_content = "`%s` text,"
            sql_temp_sgin = "`%s` enum('0','1') DEFAULT '0',"
            sql = str()
            for item in lst:
                # 生成新的数据表时 可根据item中的字段名称 来决定数据库中字段的类型
                if "time" in item:
                    sql += sql_temp_time % item
                elif "content" in item:
                    sql += sql_temp_content % item
                elif "sgin" in item:
                    sql += sql_temp_sgin % item
                else:
                    sql += sql_temp % (item)
    
            sql = sql_begin + sql + sql_end
            return sql
    

      好了,这次就写到这里吧,如果之后对这个模块做大的更新或调整再说吧。 如果对以上代码有不懂之处,可以发送至邮件 xiang_long_liu@163.com,大家共同探讨吧。
    结尾处付全部代码:

    import requests, winreg, pymysql, re, json
    from lxml import etree
    from threading import Thread
    import settings  # 将服务器数据库等链接方式写入windows注册表中,然后再在该程序中读取出来
    
    
    def read_setttings_zhuce(file, winn_c_u=winreg.HKEY_CURRENT_USER):
        """
            读取注册表中的设置
        """
        parentkey = winreg.OpenKey(winn_c_u, file)
        # 获取该键的所有键值,因为没有方法可以获取键值的个数,所以只能用这种方法进行遍历
        item = dict()
        try:
            i = 0
            while True:
                # EnumValue方法用来枚举键值,EnumKey用来枚举子键
                name, value, type = winreg.EnumValue(parentkey, i)
                # print(name, value)
                item[name] = value
                i += 1
        except Exception as e:
            pass
        return item
    
    
    class ALi_Main(Thread):
    
        def read_setttings_zhuce(self, file, winn_c_u=winreg.HKEY_CURRENT_USER):
            """
                读取注册表中的设置
            """
            parentkey = winreg.OpenKey(winn_c_u, file)
            # 获取该键的所有键值,因为没有方法可以获取键值的个数,所以只能用这种方法进行遍历
            item = dict()
            try:
                i = 0
                while True:
                    # EnumValue方法用来枚举键值,EnumKey用来枚举子键
                    name, value, type = winreg.EnumValue(parentkey, i)
                    item[name] = value
                    i += 1
            except Exception as e:
                pass
            return item
    
        def __init__(self, start_p):
            # 注意,super().__init__() 一定要写
            # 而且要写在最前面,否则会报错。
            super().__init__()
            self.item_fwq = self.read_setttings_zhuce("Software\lxl\lxl_program")
            # 链接数据库
            self.conn = pymysql.connect(
                user=self.item_fwq["user"], password=self.item_fwq["password"], host=self.item_fwq["host"], port=int(self.item_fwq["port"]),
                database=self.item_fwq["database"], use_unicode=True,
                charset="utf8")
            self.start_p = start_p
            print("数据库开启中......")
            # 获取游标
            self.cursor = self.conn.cursor()
    
        def main(self, url="https://www.baidu.com/", formdata={}, meta={}):
            """
                开关
            """
            response = self.url_f_requests(url, formdata)
            if response != "无结果":
                # 对返回的结果解码
                response = self.response_decode(response)
                print(response)
                response, fangshi = self.t_f_response_json_html(response)
                if fangshi is "json":
                    self.response_json(response, meta)
                elif fangshi is "html":
                    self.response_html(response, meta)
                else:
                    print(fangshi)
                    print("返回的页面数据有误请检查")
            else:
                print("数据无结果,未获取到")
                
        def url_f_requests(self, url, formdata):
            """
                get / post 请求发送
            """
            if formdata == {}:
                response = self.requests_url(url)
                print("{INFO}:url以 get 方式请求")
                # print(response)
            else:
                response = self.requests_url_post(url, formdata)
                print("{INFO}:url以 post 方式请求")
                # print(response)
            return response
                
        def t_f_response_json_html(self, response):
            """
                判断返回的结果
            """
            try:
                response = json.loads(response)
                print("{INFO}:数据以json格式返回")
                return response, "json"
            except Exception as f:
                try:
                    response = etree.HTML(response)
                    print("{INFO}:数据以html格式返回")
                    return response, "html"
                except Exception as f:
                    response = response
                    return response, "None"
            
        def response_decode(self, response):
            """
                对返回的结果解码
            """
            try:
                response = response.decode()
                print("{INFO}:数据以utf-8解码")
            except Exception as f:
                try:
                    response = response.decode("GBK")
                    print("{INFO}:数据以 GBK 解码")
                except Exception as f:
                    print("{INFO}:数据以未指定解码方式返回")
                    response = response
            return response
            
        def response_json(self, response, meta={}):
            """
                json 格式解析
            """
            list_data = response['result']['data']
            for ds in list_data:
                item = dict()
                """
                    此处可以对数据进行处理,若不需特殊处理的 则直接合并到item字典中,保存入数据库
                    列: item["pid] = ds['id']
                """
                item = {**item, **meta}
                where_list = ["pid"]  # 此处添加mysql保存判断条件中查询的字段 可写多个字段
                table_name = 'your_databases_tablename'  # 此处添加你需要保存的数据表名称 注: 若没有新建数据表, 代码可自动建立新的数据表
                self.mysql_f_item(item, table_name=table_name, where_list=where_list)
        
        def response_html(self, response, meta={}):
            """
                html 格式解析
            """
            list_response = response.xpath('//div[@class="name"]')
            for resp in list_response:
                item = dict()
                """
                    此处可以对数据进行xpath解析处理,保存入数据库
                    列: item["pid] = resp.xpath('./a/@href')[0]
                """
                print(item)
                item = {**item, **meta}
                where_list = ["pid"]  # 此处添加mysql保存判断条件中查询的字段 可写多个字段
                table_name = "your_databases_tablename" # 此处添加你需要保存的数据表名称 注: 若没有新建数据表, 代码可自动建立新的数据表
                self.mysql_f_item(item, table_name, where_list=where_list)
            
        def mysql_f_item(self, item, table_name="new_table_name", where_list=[]):
            """
                保存创建mysql数据库
            """
            lst = item.keys()
            # print(lst)
            insert_sql = self.create_insert_sql_for_list(table_name=table_name, lst=lst)
            insert_sql = insert_sql.format(**item)
            # print(insert_sql)
            select_sql = self.create_select_sql(table_name=table_name, where_list=where_list)
            select_sql = select_sql.format(**item)
            # print(select_sql)
            self.insert_mysql(insert_sql=insert_sql, select_sql=select_sql, table_name=table_name, lst=lst)
            print("--------------------------------")
    
        def create_insert_sql_for_list(self, table_name, lst, list_flag=False):
            """
            动态生成sql文(单条)
            :param table_name:表名
            :param lst:插入的数据列表
            :param list_flag: true:代表lst字段是 list嵌套list,   false:代表list嵌套dict
            :return:返回单条插入的sql
            """
            sql = "insert into %s(" % table_name
            for item in lst:
                sql = sql + "`%s`," % item
            sql = sql.strip(',') + ") values ("
            if list_flag is False:
                for item in lst:
                    sql = sql + "'{%s}'," % item
            else:
                for i in range(len(lst)):
                    sql = sql + "'{0[%s]}'," % i
            sql = sql.strip(',') + ")"
            return sql
    
        def create_select_sql(self, table_name, where_list):
            """
                动态生成sql文
            """
            if where_list == []:
                return ""
            else:
                sql = 'select id from %s where' % table_name
                for i in range(len(where_list)):
                    sql = sql + " `%s` = '{%s}' and " % (where_list[i], where_list[i])
                sql = sql.strip('and ')
                # print(sql)
                return sql
    
        def create_table(self, table_name, lst, engine='MyISAM', charset='utf8'):
            """
            生成建表sql
            :param table_name:表名
            :param lst:字段列表
            :param engine:数据库类型
            :param charset:字符集
            :return:sql
            """
            sql_begin = """CREATE TABLE `%s` (  `id` int(11) NOT NULL AUTO_INCREMENT,""" % table_name
            sql_end = """ PRIMARY KEY (`id`)
                        ) ENGINE=%s AUTO_INCREMENT=0 DEFAULT CHARSET=%s;""" % (engine, charset)
            sql_temp = " `%s` varchar(256) DEFAULT NULL,"
            sql_temp_time = "`%s` datetime DEFAULT NULL,"
            sql_temp_content = "`%s` text,"
            sql_temp_sgin = "`%s` enum('0','1') DEFAULT '0',"
            sql = str()
            for item in lst:
                # 生成新的数据表时 可根据item中的字段名称 来决定数据库中字段的类型
                if "time" in item:
                    sql += sql_temp_time % item
                elif "content" in item:
                    sql += sql_temp_content % item
                elif "sgin" in item:
                    sql += sql_temp_sgin % item
                else:
                    sql += sql_temp % (item)
    
            sql = sql_begin + sql + sql_end
            return sql
    
        def insert_mysql(self, insert_sql, select_sql='', update_sql='', table_name='', lst=()):
            """
                保存数据
            """
            while True:
                # 获取游标
                self.conn.ping(reconnect=True)
                if select_sql:
                    try:
                        self.cursor.execute(select_sql)
                        if self.cursor.fetchone() is None:
                            print(insert_sql)
                            try:
                                self.cursor.execute(insert_sql)
                                self.conn.commit()
                                print("数据保存中......")
                                if update_sql:
                                    self.cursor.execute(update_sql)
                                    self.conn.commit()
                                    print("数据更新中......")
                                break
                            except Exception as f:
                                # print(insert_sql)
                                print(f)
                                print("数据保存失败")
                                break
                        else:
                            print("数据已存在")
                        break
                    except Exception as f:
                        print(f)
                        # 首次执行 创建一个新的数据表
                        if "Table" in str(f) and "doesn't exist" in str(f):
                            print("*" * 100)
                            print("创建数据库中......")
                            sql = self.create_table(table_name=table_name, lst=lst)
                            self.cursor.execute(sql)
                            self.conn.commit()
                        else:
                            break
                else:
                    try:
                        print(insert_sql)
                        print("数据保存中......")
                        self.cursor.execute(insert_sql)
                        self.conn.commit()
                        break
                    except Exception as f:
                        print(f)
                        # 首次执行 创建一个新的数据表
                        if "Table" in str(f) and "doesn't exist" in str(f):
                            print("*" * 100)
                            print("创建数据库中......")
                            sql = self.create_table(table_name=table_name, lst=lst)
                            self.cursor.execute(sql)
                            self.conn.commit()
                        else:
                            print("保存失败")
                            break
    
        def getDropStr(self, l_strHtml):
            """清洗字符串"""
            strList = re.findall(
                r'[\u4e00-\u9fa5a-zA-Z0-9,.;?!_\]\'\"\[{}+-\u2014\u2026\uff1b\u3002\uff1b\uff0c\uff1a\u201c\u201d\uff08\uff09\u3001\uff1f\u300a\u300b]',
                l_strHtml)
            return "".join(strList)
    
        def requests_url(self, url, data=None):
            """
                发送请求,返回相应
            """
            item_fwq_ip = read_setttings_zhuce("Software\lxl\lxl_program")
            # 读取实时写入windows注册表中的ip代理  本人喜欢使用无忧代理 不是打广告,而是品质确实好
            proxies = {"http": "%s" % item_fwq_ip["ip"], "https": "%s" % item_fwq_ip["ip"]}
            headers = {
                 "user-agent": item_fwq_ip['user_agent']
            }
            try:
                response = requests.get(url=url, headers=headers, timeout=20).content
                if response:
                    return response
            except Exception as f:
                print("重新请求")
                i = 0
                while True:
                    i += 1
                    if i >= 5:
                        return "无结果"
                    try:
                        response = requests.get(url=url, headers=headers, proxies=proxies, timeout=20).content
                        if response:
                            return response
                    except Exception as f:
                        print("重新请求")
            
        def requests_url_post(self, url, data):
            """
                发送请求,返回相应
            """
            item_fwq_ip = read_setttings_zhuce("Software\lxl\lxl_program")
            # 读取实时写入windows注册表中的ip代理  本人喜欢使用无忧代理 不是打广告,而是品质确实好
            proxies = {"http": "%s" % item_fwq_ip["ip"], "https": "%s" % item_fwq_ip["ip"]}
            headers = {
                "user-agent": item_fwq_ip['user_agent']
            }
            try:
                response = requests.post(url=url, headers=headers, data=data,timeout=20).content
                if response:
                    return response
            except Exception as f:
                print("重新请求")
                i = 0
                while True:
                    i += 1
                    if i >= 5:
                        return "无结果"
                    try:
    
                        response = requests.post(url=url, headers=headers, data=data, proxies=proxies, timeout=20).content
                        if response:
                            return response
                    except Exception as f:
                        print("重新请求")
        
        def __del__(self):
            self.cursor.close()
            self.conn.close()
            print("数据库关闭中......")
    
    
    def main_thread(number_p):
        """
            多线程启动
            若使用多线程爬取是 将 main 函数改为 run 函数 传递参数控制url使用个数从而决定多线程条数
        """
        print("多线程启动程序")
        list_thread = list()
        for p in range(0, number_p+1000, 1000):
            thread = ALi_Main(p)
            list_thread.append(thread)
        
        for threads in list_thread:
            threads.start()
        
        for threads in list_thread:
            threads.join()
    
    
    if __name__ == '__main__':
        # 初始化
        # settings.main()
        
        alm = ALi_Main(0)
    
        meta = dict()
        meta["key_name"] = "传值"
        url = "https://search.sina.com.cn/?range=title&q=" + str(meta["key_name"]) + "&c=news&time=&ie=utf-8&col=&source=&from=&country=&size=&a=&page=1&pf=0&ps=0&dpc=1"
        print(url)
        alm.main(url=url, meta=meta)
    
    展开全文
  • 爬虫框架

    2018-08-28 10:44:41
    一、python爬虫框架 一些爬虫项目的半成品 二、常见python爬虫框架 (1)Scrapy:很强大的爬虫框架,可以满足简单的页面爬取(比如可以明确获知url pattern的情况)。用这个框架可以轻松爬下来如亚马逊商品信息之类...

    一、python爬虫框架

    一些爬虫项目的半成品

    二、常见python爬虫框架

    (1)Scrapy:很强大的爬虫框架,可以满足简单的页面爬取(比如可以明确获知url pattern的情况)。用这个框架可以轻松爬下来如亚马逊商品信息之类的数据。但是对于稍微复杂一点的页面,如weibo的页面信息,这个框架就满足不了需求了。

    (2)Crawley: 高速爬取对应网站的内容,支持关系和非关系数据库,数据可以导出为JSON、XML等

    (3)Portia:可视化爬取网页内容

    (4)newspaper:提取新闻、文章以及内容分析

    (5)python-goose:java写的文章提取工具

    (6)Beautiful Soup:名气大,整合了一些常用爬虫需求。缺点:不能加载JS。

    (7)mechanize:优点:可以加载JS。缺点:文档严重缺失。不过通过官方的example以及人肉尝试的方法,还是勉强能用的。

    (8)selenium:这是一个调用浏览器的driver,通过这个库你可以直接调用浏览器完成某些操作,比如输入验证码。

    (9)cola:一个分布式爬虫框架。项目整体设计有点糟,模块间耦合度较高。

    展开全文
  • 爬虫可以用不同的语言编写,而且爬虫框架也多,比如python,简单易学,也是有不同的爬虫框架,python最好爬虫框架是哪一种呢?这些爬虫框架都有什么优缺点?一、爬虫框架使用对比分析多学习爬虫的框架,可以强化...

    爬虫可以用不同的语言编写,而且爬虫框架也多,比如python,简单易学,也是有不同的爬虫框架,python最好爬虫框架是哪一种呢?这些爬虫框架都有什么优缺点?

    一、爬虫框架使用对比分析

    多学习爬虫的框架,可以强化Python相关知识,学习一些优秀的框架,可以应用于不同的需求的爬取任务,今天IP代理精灵为大家介绍几种爬虫框架,通过对比分析:

    以上这些开源的爬虫框架大都是把复杂的问题解决掉,然后封装,之后就是我们用的很简单、方便,不必考虑那些URL去重、代理、线程池管理等等问题,当然建议看看源码,多想想他们的设计思想以及实现逻辑。

    我们在以前项目中用的爬虫框架是java语言的WebMagic和python语言的PySpider。普通java爬虫项目中都可以考虑WebMagic和WebCollector绝对够用,上手简单易扩展,注重业务开发就好。

    如果大型分布式、业务够复杂、需求点够多、数据够庞大下的估计用哪个框架也得进行二次扩展了。所以选那个框架不必那么纠结。

    二、遇到动态网页怎么突破

    在我们编写爬虫时,可能会遇到,爬取的数据在网页源代码中并不存在或者点击下一页跳转页面时,网页的URL并没与发生变化,这是为什么呢?

    原因是页面采用了动态加载的方式,这是一个动态网页。

    其显示的页面则是经过Javascript处理数据后生成的结果,可以发生改变。这些数据的来源有多种,可能是经过Javascript计算生成的,也可能是通过Ajax加载的。

    爬虫处理动态页面可以采用逆向工程或者渲染动态网页的方法。

    通过上文,可以知道python最好爬虫框架,不同框架的爬虫都可以实现爬取信息,也不一定是越难的越好,关键是满足采集的需求即可。

    展开全文
  • 爬虫框架分析之各语言爬虫框架

    千次阅读 2018-06-27 11:46:27
    目前市场上爬虫框架有很多,不同语言不同类型的爬虫框架都有,然而在开发预研的时候对于选择那种 框架对于很多开发者来说尤为头疼; 本篇主要总结一下市场上主流的开发语言中有哪些主流的爬虫框架,以及爬虫框架的...
    > 看看有哪些爬虫框架 
    
    #一、前言
    
    目前市场上爬虫框架有很多,不同语言不同类型的爬虫框架都有,然而在开发预研的时候对于选择那种
    框架对于很多开发者来说尤为头疼;
    
    本篇主要总结一下市场上主流的开发语言中有哪些主流的爬虫框架,以及爬虫框架的优劣;希望在对你在选择合适爬虫框架中有所帮助。
    #二、主流语言爬虫框架列表
    ##常用爬虫框架列表
    JAVA | PYTHON |    PHP | C# | C/C++
    --- | --- | --- | --- | ----
    Apache Nutch2  | scrapy | phpspider |    DotnetSpider | open-source-search-engine
    webmagic | Crawley |  Beanbun    |NWebCrawler | Cobweb
    Heritrix | Portia |   PHPCrawl | SmartSpider |  upton
    WebCollector | PySpider | php selenium | Abot   | wombat
    crawler4j |    grab | |  xNet | Spidr
    Spiderman |    cola | |  AngleSharp |   Larbin
    SeimiCrawler | python selenium |     |HtmlAgilityPack   
    jsoup |          | |CSQuery     |
    java selenium |             
    htmlunit |          
    #三、主流爬虫框架简介
    ##1.Java爬虫框架
    ###Apache Nutch2
    
    地址: http://nutch.apache.org/
    
    Nutch 是一个开源Java 实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。
    Nutch 致力于让每个人能很容易, 同时花费很少就可以配置世界一流的Web搜索引擎. 为了完成这一宏伟的目标, Nutch必须能够做到:
       * 每个月取几十亿网页
       * 为这些网页维护一个索引
       * 对索引文件进行每秒上千次的搜索
       * 对索引文件进行每秒上千次的搜索
       * 提供高质量的搜索结果
    
    简单来说Nutch支持分布式,可以通过配置网站地址、规则、以及采集的深度(通用爬虫或全网爬虫)对网站进行采集,并提供了全文检索功能,可以对采集下来的海量数据进行全文检索;假如您想完成对站点所有内容进行采集,且不在乎采集和解析精度(不对特定页面特定字段内容采集)的需求,建议你使用Apache Nutch,假如您想对站点的指定内容板块指定字段采集,建议您使用垂直爬虫较为灵活。
    
    ###webmgaic(推荐)
    
    地址: http://webmagic.io/
    
    WebMagic是一个简单灵活的Java爬虫框架。基于WebMagic,你可以快速开发出一个高效、易维护的爬虫。
    特性:
    
       * 简单的API,可快速上手
       * 模块化的结构,可轻松扩展
       * 提供多线程和分布式支持
    
    ###Heritrix
    
    地址: http://crawler.archive.org/
    
    Heritrix 是一个由 java 开发的、开源的网络爬虫,用户可以使用它来从网上抓取想要的资源。其最出色之处在于它良好的可扩展性,方便用户实现自己的抓取逻辑。
    
    ###WebCollector
    
    地址: https://github.com/CrawlScript/WebCollector
    
    WebCollector是一个无须配置、便于二次开发的JAVA爬虫框架(内核),它提供精简的的API,只需少量代码即可实现一个功能强大的爬虫。WebCollector-Hadoop是WebCollector的Hadoop版本,支持分布式爬取。
    
    ###crawler4j
    
    地址: https://github.com/yasserg/crawler4j
    
    crawler4j是一款基于Java的轻量级单机开源爬虫框架,最大的一个特点就是简单。另外也支持多线程、支持代理、可以过滤重复URL
    基本上从加载jar到工程里面 通过修改示例的代码就可以简单的实现一个爬虫的全部功能,而这一切动作加起来都不需要超过半个小时。
    
    ###Spiderman
    
    地址: https://m.gitee.com/l-weiwei/spiderman
    
    Spiderman 是一个Java开源Web数据抽取工具。它能够收集指定的Web页面并从这些页面中提取有用的数据。 Spiderman主要是运用了像XPath、正则、表达式引擎等这些技术来实现数据抽取。
    
    ###SeimiCrawler
    
    地址: http://seimi.wanghaomiao.cn/
    
    一个敏捷的,独立部署的,支持分布式的Java爬虫框架
    SeimiCrawler是一个强大的,高效敏捷的,支持分布式的爬虫开发框架,希望能在最大程度上降低新手开发一个可用性高且性能不差的爬虫系统的门槛,以及提升开发爬虫系统的开发效率。在SeimiCrawler的世界里,绝大多数人只需关心去写抓取的业务逻辑就够了,其余的Seimi帮你搞定。设计思想上SeimiCrawler受Python的爬虫框架Scrapy启发很大,同时融合了Java语言本身特点与Spring的特性,并希望在国内更方便且普遍的使用更有效率的XPath解析HTML,所以SeimiCrawler默认的HTML解析器是JsoupXpath,默认解析提取HTML数据工作均使用XPath来完成(当然,数据处理亦可以自行选择其他解析器)。
    
    ###jsoup
    
    地址: https://jsoup.org/
    
    jsoup 是一款Java 的HTML解析器,可直接解析某个URL地址、HTML文本内容。它提供了一套非常省力的API,可通过DOM,CSS以及类似于jQuery的操作方法来取出和操作数据。
    ##2.Python爬虫框架
    ###scrapy (推荐)
    
    地址: https://scrapy.org/
    
    Scrapy,Python开发的一个快速、高层次的屏幕抓取和web抓取框架,用于抓取web站点并从页面中提取结构化的数据。Scrapy用途广泛,可以用于数据挖掘、监测和自动化测试。
    Scrapy吸引人的地方在于它是一个框架,任何人都可以根据需求方便的修改。它也提供了多种类型爬虫的基类,如BaseSpider、sitemap爬虫等,最新版本又提供了web2.0爬虫的支持。
    Scrap,是碎片的意思,这个Python的爬虫框架叫Scrapy。
    ###Crawley
    
    地址:http://project.crawley-cloud.com/
    
    高速爬取对应网站的内容,支持关系和非关系数据库,数据可以导出为JSON、XML等
    ###Portia
    
    地址:https://scrapinghub.com/portia
    
    Portia 是一个用 Python 编写无需任何编程知识,就能可视爬取网站数据的开源工具。无需下载或安装任何东西,因为,Portia 是运行在您的 Web 浏览器中。
    Portia 是 scrapyhub 开源的一款可视化爬虫规则编写工具。Portia 提供了可视化的 Web 页面,只需通过简单点击,标注页面上需提取的相应数据,无需任何编程知识即可完成爬取规则的开发。这些规则还可在 Scrapy 中使用,用于抓取页面。
    
    ###PySpider
    
    地址:http://www.pyspider.cn/
    
    PySpider:一个国人编写的强大的网络爬虫系统并带有强大的WebUI。采用Python语言编写,分布式架构,支持多种数据库后端,强大的WebUI支持脚本编辑器,任务监视器,项目管理器以及结果查看器。
    
    ###grab
    
    地址:http://www.imscraping.ninja/posts/introducing-grab-framework-python-webscraping/
    
    网络爬虫框架(基于pycurl/multicur)。
    ###cola
    
    地址:https://github.com/chineking/cola
    
    一个分布式爬虫框架。项目整体设计有点糟,模块间耦合度较高,不过值得借鉴。
    ##3.PHP爬虫框架
    ###phpspider
    
    地址:https://github.com/owner888/phpspider
    
    phpspider是一个爬虫开发框架。使用本框架,你不用了解爬虫的底层技术实现,爬虫被网站屏蔽、有些网站需要登录或验证码识别才能爬取等问题。简单几行PHP代码,就可以创建自己的爬虫,利用框架封装的多进程Worker类库,代码更简洁,执行效率更高速度更快。
    ###Beanbun
    
    地址:http://www.beanbun.org/#/
    
    Beanbun 是用 PHP 编写的多进程网络爬虫框架,具有良好的开放性、高可扩展性。
        
       * 支持守护进程与普通两种模式(守护进程模式只支持 Linux 服务器)
       * 默认使用 Guzzle 进行爬取
       * 支持分布式
       * 支持内存、Redis 等多种队列方式
       * 支持自定义URI过滤
       * 支持广度优先和深度优先两种爬取方式
       * 遵循 PSR-4 标准
       * 爬取网页分为多步,每步均支持自定义动作(如添加代理、修改 user-agent 等)
       * 灵活的扩展机制,可方便的为框架制作插件:自定义队列、自定义爬取方式…
    ###PHPCrawl
    
    地址:http://phpcrawl.cuab.de/
    
    PHPCrawl是一个PHP开源的Web检索蜘蛛(爬虫)类库。PHPCrawl抓取工具“ Spider ”的网站,并提供一切有关网页,链接,文件等信息。
    PHPCrawl povides可以选择性的指定的爬虫的行为,比如喜欢网址、内容类型,过滤器、cookie的处理等方式。
    ##4.c#爬虫框架
    ###DotnetSpider
    
    地址:http://www.dotnetspider.com/
    
    DotnetSpider这是国人开源的一个跨平台、高性能、轻量级的爬虫软件,采用 C# 开发。目前是.Net开源爬虫最为优秀的爬虫之一。
    ###NWebCrawler
    
    地址:http://nwebcrawler.codeplex.com/
    
    NWebCrawler是一款开源的C#网络爬虫程序更多NWebCrawler
    ###SmartSpider
    
    地址:http://www.softpedia.com/get/Internet/Download-Managers/SmartSpider.shtml
    
    SmartSpider爬虫引擎内核版,全新的设计理念,真正的极简版本。
    ###Abot
    
    地址:https://github.com/sjdirect/abot
    
    Abot是一个开源的.net爬虫,速度快,易于使用和扩展。
    ###xNet
    
    地址:https://github.com/X-rus/xNet
    
    这个一个俄国牛人写的开源工具,为啥说他强悍了,因为他将所有Http协议的底层都实现了一遍,这有啥好处?只要你是写爬虫的,都会遇到一个让人抓狂的问题,就是明明知道自己Http请求头跟浏览器一模一样了,为啥还会获取不到自己想要的数据。这时你如果使用HttpWebReaquest,你只能调试到GetRespone,底层的字节流是调试不到了。所以必须得有个更深入的底层组件,方便自己调试。
    ###AngleSharp
    
    地址:http://anglesharp.github.io/
    
    解析HTML利器AngleSharp介绍解析HTML利器AngleSharp介绍AngleSharp是基于.NET(C#)开发的专门为解析xHTML源码的DLL组件。
    ###HtmlAgilityPack
    
    地址:http://htmlagilitypack.codeplex.com/
    
    HtmlAgilityPack是 .NET 下的一个 HTML 解析类库。支持用 XPath 来解析 HTML 。命名空间: HtmlAgilityPack
    ###CSQuery
    
    地址:https://github.com/jamietre/CsQuery
    
    CsQuery 犀利的html代码分析库,像jq一样用c#处理html
    ##5.C/C++爬虫框架
    ###open-source-search-engine
    
    地址:https://github.com/gigablast/open-source-search-engine
    
    基于C/C++开发的网络爬虫和搜索引擎.
    ###Cobweb
    
    地址:https://github.com/stewartmckee/cobweb
    
    非常灵活,易于扩展的网络爬虫,可以单点部署使用.
    ###upton
    
    地址:https://github.com/propublica/upton
    
    一个易于上手的爬虫框架集合,支持CSS选择器.
    ###wombat
    
    地址:https://github.com/felipecsl/wombat
    
    基于Ruby天然的支持DSL的网络爬虫,易于提取网页正文数据.
    ###Spidr
    
    地址:https://github.com/postmodern/spidr
    
    全站数据采集,支持无限的网站链接地址采集.
    ###Larbin
    
    地址:http://larbin.sourceforge.net/download.html
    
    larbin是一种开源的网络爬虫/网络蜘蛛,由法国的年轻人Sébastien Ailleret独立开发,用c++语言实现。larbin目的是能够跟踪页面的url进行扩展的抓取,最后为搜索引擎提供广泛的数据来源。 Larbin只是一个爬虫,也就是说larbin只抓取网页,至于如何parse的事情则由用户自己完成。另外,如何存储到数据库以及建立索引的事情 larbin也不提供。
    larbin最初的设计也是依据设计简单但是高度可配置性的原则,因此我们可以看到,一个简单的larbin的爬虫可以每天获取500万的网页,实在是非常高效。
    利用larbin,我们可以轻易的获取/确定单个网站的所有联结,甚至可以镜像一个网站;也可以用它建立url 列表群,例如针对所有的网页进行 url retrive后,进行xml的联结的获取。或者是 mp3,或者定制larbin,可以作为搜索引擎的信息的来源。
    #四.总结
    
    爬虫框架很多,如果有兴趣我们自己也可以写一些。我们不需要掌握每种主流的爬虫框架,只需要根据自己擅长编写语言,深入的掌握一种爬虫框架即可。大多数爬虫框架实现起来都大同小异。
    如果你是python开发者我推荐你学习目前流行的scrapy,如果你是java开发者我推荐你学习webmagic。
    展开全文
  • 八爪鱼云采集网络爬虫软件 八爪鱼云采集网络爬虫软件 java爬虫框架有哪些各有什么特点 目前主流的Java爬虫框架主要有NutchCrawler4jWebMagicscrapyWebCollector等各有各的特点大家可以根据自己的需求选择使用下面为...
  • 爬虫框架开发分析 介绍 本节会首先了解框架概念和实现框架的好处,在这个基础上思考如何实现自己的爬虫框架;通过对scrapy框架的流程的分析,明确自己的框架要实现的模块和逻辑;最后 完成自己框架的 雏形机构 内容...
  • 近几年,Python名声大噪,爬虫框架Scrapy更是为大众所乐道。现在就让我们拿相对成熟的Java分布式爬虫框架和Scrapy作对比,看看Scrapy距离实际使用,还有哪些需要补充的地方。
  • Scrapy是一个功能强大并且非常快速的网络爬虫框架,是非常优秀的python第三方库,也是基于python实现网络爬虫的重要的技术路线。 Scrapy的安装: 直接在命令提示符窗口执行pip install scrapy貌似不行。 我们需要先...
  • python的爬虫框架有哪些?下面给大家介绍一个常用的python爬虫的十大框架:一、ScrapyScrapy框架是一套比较成熟的Python爬虫框架,是使用Python开发的快速、高层次的信息爬取框架,可以高效的爬取web页面并提取出...
  • Python中爬虫框架或模块的区别(1)爬虫框架或模块Python自带爬虫模块:urllib、urllib2 ;第三方爬虫模块:requests,aiohttp;爬虫框架: Scrapy、pyspider。(2)爬虫框架或模块的优缺点urllib和urllib2模块都用于请求...
  • Python中爬虫框架或模块的区别(1)爬虫框架或模块Python自带爬虫模块:urllib、urllib2 ;第三方爬虫模块:requests,aiohttp;爬虫框架: Scrapy、pyspider。(2)爬虫框架或模块的优缺点urllib和urllib2模块都用于请求...
  • 原标题:Python中爬虫框架或模块的区别Python中爬虫框架或模块的区别(1)爬虫框架或模块Python自带爬虫模块:urllib、urllib2 ;第三方爬虫模块:requests,aiohttp;爬虫框架: Scrapy、pyspider。(2)爬虫框架或模块的...
  • 精通python爬虫,电子书籍,课程源码,配套教学,Scrapy等常用爬虫框架的使用。
  • go爬虫框架

    2018-01-22 17:36:28
    go爬虫框架,快速的,强大的,可扩展的爬虫框架。持robots.txt * 支持自定义模块 * 支持Item管道处理 * 支持多种代理协议(socks5,http,https) * 支持XPath查询HTML/XML数据 * 做为框架,易于上手。
  • python爬虫框架

    2017-10-29 21:25:28
    最为基本python爬虫框架,适合于初学者学习如何使用python进行爬虫。
  • scrapy 爬虫框架

    2018-10-24 16:51:24
    scrapy 是 python 写的爬虫框架,代码架构借鉴于django,灵活多样,功能强大。
  • Scrapy爬虫框架

    2020-02-16 01:47:51
    1.Scrapy爬虫框架介绍 Scrapy:功能强大快速的网络爬虫框架,非常优秀的python第三方库,也是基于python实现网络爬虫的重要的技术路线 scrapy不是一个简单的函数功能库,而是一个爬虫框架 Scrapy爬虫框架结构 爬虫...
  • 目前市场上爬虫框架有很多,不同语言不同类型的爬虫框架都有,然而在开发预研的时候对于选择那种框架对于很多开发者来说尤为头疼;本篇主要总结一下市场上主流的开发语言中有哪些主流的爬虫框架,以及爬虫框架的优劣...
  • 这是一个轻量级的分布式java爬虫框架特点这是一个强大,但又轻量级的分布式爬虫框架。jlitespider天生具有分布式的特点,各个worker之间需要通过一个或者多个消息队列来连接。消息队列我的选择是rabbitmq。worker和...
  • 原标题:java爬虫框架的使用 随着互联网的发展,编程程序语言也开始被越来越多的人所掌握,但是自始至终,java语言一直是被使用范围最广的编程语言。今天,武汉中软国际主要给大家讲解的是java语言中的爬虫java框架...
  • 一个敏捷,强大,独立的分布式爬虫框架。支持spring boot和redisson。 SeimiCrawler的目标是成为Java里最实用的爬虫框架,大家一起加油。 简介 SeimiCrawler是一个敏捷的,独立部署的,支持分布式的Java爬虫框架,...
  • 目前市场上爬虫框架有很多,不同语言不同类型的爬虫框架都有。今天主要给大家安利9款我在学习Python的时候学习研究的几款爬虫框架,希望对大家选择合适的爬虫框架以及业余学习都能有所帮助。scrapy 「star:30114」...
  • 一、python爬虫框架 一些爬虫项目的半成品二、常见python爬虫框架 (1)Scrapy:很强大的爬虫框架,可以满足简单的页面爬取(比如可以明确获知url pattern的情况)。用这个框架可以轻松爬下来如亚马逊商品信息之类的...
  • Scrapy 是一套基于 Twisted 的异步处理框架,纯 Python 实现的爬虫框架,用户只需要定制开发几个模块就可以轻松的实现一个爬虫,用来抓取网页内容以及各种图片。此版本主要更新亮点包括:要求 Python 3.5.2+数据类...
  • 此处我们对Scrapy爬虫框架做进一步的解析: 回忆一下Scrapy爬虫框架的“5+2”结构: 其中整个框架的核心是 Engine。 任何模块和模块之间的数据流动都要经过 Engine 模块的调度。 Engine 控制所有模块之间的数据流 ...
  • Scrapy Web爬虫框架

    2020-08-16 08:45:46
    Scrapy 是一套基于基于Twisted的异步处理框架,纯python实现的爬虫框架,用户只需要定制开发几个模块就可以轻松的实现一个爬虫,用来抓取网页内容以及各种图片,非常之方便。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,206
精华内容 8,482
关键字:

爬虫框架

爬虫 订阅