python爬虫详解_python 抓包爬虫详解 - CSDN
精华内容
参与话题
  • python全站爬虫知识点详解

    千次阅读 2017-03-07 09:34:10
    1 最简单的单页面抓取 思路: 获取页面所有url 对获取的所有url进行分类 A 获取属于本域名下的url B 获取属于其他url2 用到的模块 urllib 详细介绍见链接 ...详细介绍见链接 ...

    1 最简单的单页面抓取
    思路:
    获取页面所有url
    对获取的所有url进行分类
    A 获取属于本域名下的url
    B 获取属于其他url

    2 用到的模块
    urllib
    详细介绍见链接
    http://blog.csdn.net/dolphin_h/article/details/45296353

    bs4
    详细介绍见链接
    http://blog.csdn.net/winterto1990/article/details/47624167

    re正则表达式
    详细介绍见链接
    http://blog.csdn.net/winterto1990/article/details/47624167

    3 一下代码出自freebuf文章,链接
    http://www.freebuf.com/news/topnews/96821.html

    代码说明:

    import urllib
    from bs4 import BeautifulSoup
    import re
    
    def get_all_url(url):
       urls = []
       web = urllib.urlopen(url)#使用urllib模块的urlopen函数打开url,复制给web
    soup =BeautifulSoup(web.read())#将web内容转化为beautigulsoup格式的数据。
    
    #通过正则过滤合理的url(针对与freebuf.com来讲)
       tags_a =soup.findAll(name='a',attrs={'href':re.compile("^https?://")})
       #soup.findall函数的运用,配合正则表达式来过滤url
        try :
           for tag_a in tags_a:
    #re:^ 表示匹配字符串开头例如,^ abc 匹配 abc
        ? 表示匹配前一个字符串0次或1次,例如 abc? 匹配 ab 和 abc
           #return urls
       except:
           pass
       return  urls
    
    
    #得到所有freebuf.com下的url
    def get_local_urls(url):
       local_urls = []
       urls = get_all_url(url)
       for _url in urls:
           ret = _url
           if 'freebuf.com' in ret.replace('//','').split('/')[0]:
               local_urls.append(_url)
       return  local_urls
     #if 'freebuf.com' in ret.replace('//','').split('/')[0]:这个if语句不是很明白,通过split()函数,把域名分割,获取分割后组成的类表的第一个字符串。但是在分割前为什么要把//替换成空格???
    
    
    #得到所有的不是freebuf.com域名的url
    def get_remote_urls(url):
       remote_urls = []
       urls = get_all_url(url)
       for _url in urls:
           ret = _url
           if "freebuf.com" not in ret.replace('//','').split('/')[0]:
               remote_urls.append(_url)
       return  remote_urls
    
    
     #主函数
    def __main__():
       url = 'http://freebuf.com/'
       rurls = get_remote_urls(url)
       print "--------------------remote urls-----------------------"
       for ret in rurls:
           print ret
       print "---------------------localurls-----------------------"   
       lurls = get_local_urls(url)
       for ret in lurls:
           print ret
    
    
    if __name__ == '__main__':
    __main__()

    上面是单独对一个页面抓取。如果对整个站点抓取的话,还设计到url的处理,用作者的原话:
    我们可以把整站当成一个错综复杂的图结构,有一些算法基础的读者都会知道图的简单遍历方法:dfs和bfs(深度优先和广度优先)。如果这里读者有问题的话建议先去学习一下这两种算法。大体的算法结构我们清楚了,但是在实现中我们显然需要特殊处理url,需要可以区分当前目标站点域名下的网站和其他域名的网站,除此之外,在href的值中经常会出现相对url,这里也要特别处理。
    下面是代码:

    import urllib
    from bs4 import BeautifulSoup
    import urlparse
    import time
    import urllib2
     #urllib 和 urllib2的区别http://blog.csdn.net/dolphin_h/article/details/45296353
    
    url = "http://xxxx.xx/"
    domain = "xxxx.xx"
    deep = 0
    tmp = ""
    sites = set()
    visited = set()
    #local = set()
    #集合:
    python的set和其他语言类似, 是一个无序不重复元素集, 基本功能包括关系测试和消除重复元素. 集合对象还支持union(联合), intersection(交), difference(差)和sysmmetric difference(对称差集)等数学运算.  
    
    def get_local_pages(url,domain):
       global deep
       global sites
       global tmp
       repeat_time = 0
       pages = set()
    
    
        #防止url读取卡住
       while True:
           try:
               print "Ready to Open the web!"
               time.sleep(1)
               #time.sleep()函数,
               Python time sleep() 函数推迟调用线程的运行,可通过参数secs指秒数,表示进程挂起的时间
    
               print "Opening the web", url
               web = urllib2.urlopen(url=url,timeout=3)
               print "Success to Open the web"
               break
           except:
               print "Open Url Failed !!! Repeat"
               time.sleep(1)
               repeat_time = repeat_time+1
               if repeat_time == 5:
                    return
       #上面整段判断url能不能打开
    
    
       print "Readint the web ..."
       soup = BeautifulSoup(web.read())
       print "..."
    #提取标签 a
       for tag in tags:
    
           #避免参数传递异常
           try:
               ret = tag['href']
           except:
               print "Maybe not the attr : href"
               continue
           o = urlparse.urlparse(ret)
           #urlparse.urlparse函数的使用
           urlparse模块主要是把url拆分为6部分,并返回元组。并且可以把拆分后的部分再组成一个url。主要有函数有urljoin、urlsplit、urlunsplit、urlparse等。 
    
    urlparse.urlparse(urlstring[, scheme[, allow_fragments]])
    
        将urlstring解析成6个部分,它从urlstring中取得URL,并返回元组 (scheme, netloc, path, parameters, query, fragment),但是实际上是基于namedtuple,是tuple的子类。它支持通过名字属性或者索引访问的部分URL,每个组件是一串字符,也有可能是空的。组件不能被解析为更小的部分,%后面的也不会被解析,分割符号并不是解析结果的一部分,除非用斜线转义,注意,返回的这个元组非常有用,例如可以用来确定网络协议(HTTP、FTP等等 )、服务器地址、文件路径,等等。
           """
           #Debug I/O
           for _ret in o:
               if _ret == "":
                    pass
               else:
                    print _ret
           """
    
    
    
           #处理相对路径url
           if o[0] is "" and o[1] is "":
               print "Fix  Page: " +ret
               url_obj = urlparse.urlparse(web.geturl())
               #获取web页面的url,用urlparse函数抽离
               ret = url_obj[0] + "://" + url_obj[1] + url_obj[2] + ret
               #组成一个绝对url
               #保持url的干净
               ret = ret[:8] + ret[8:].replace('//','/')
               o = urlparse.urlparse(ret)
    
                         #这里不是太完善,但是可以应付一般情况
    
               if '../' in o[2]:
                    paths = o[2].split('/')
                   for i inrange(len(paths)):
                        if paths[i] == '..':
                            paths[i] = ''
                            if paths[i-1]:
                                paths[i-1] = ''
                    tmp_path = ''
                    for path in paths:
                        if path == '':
                            continue
                        tmp_path = tmp_path + '/' +path
                    ret =ret.replace(o[2],ret_path)
               print "FixedPage: " + ret
    
    
          上面整段都是判断获到的url是绝对url还是相对url。如果是相对url,则还需进行重组成完善的绝对url。包括url中含../的情况进行处理。但是处理../的情况不理解!!???
    
           #协议处理
           if 'http' not in o[0]:
               print "Bad  Page:" + ret.encode('ascii')
               continue
    
           #url合理性检验
           if o[0] is "" and o[1] is not "":
               print "Bad  Page: " +ret
               continue
    
           #域名检验
           if domain not in o[1]:
           #变量domain用来检验获取的所有url是否是改域名下的
               print "Bad  Page: " +ret
               continue
    
           #整理,输出
           newpage = ret
           if newpage not in sites:
               print "Add New Page: " + newpage
               pages.add(newpage)
       return pages
    
    #dfs算法遍历全站
    def dfs(pages):
        #无法获取新的url说明便利完成,即可结束dfs
       if pages is set():
           return
       global url
       global domain
       global sites
       global visited
       sites = set.union(sites,pages)
       for page in pages:
           if page not in visited:
               print "Visiting",page
               visited.add(page)
               url = page
               pages = get_local_pages(url, domain)
               dfs(pages)
    
       print "sucess"
     #整段程序下来,一直不知道 变量domain用来检验获取的所有url是否是改域名下的
    
    pages = get_local_pages(url, domain)
    dfs(pages)
    for i in sites:
    print i

    整个的大概思路是:
    传入url
    判断能否打开
    打开url,获取整个改url的web信息
    提取属性‘href’
    遍历提取到的链接,这里叫做url2
    判断url是否为相对url
    是的话
    对其进行抽离[urlparse.urlparse()]
    重组
    (处理相对url)
    最后检验协议、url域名。
    带入遍历算法。

    最后是web元素的处理
    两个模块
    bs4模块和docx模块的使用
    **bs4前面有写
    我们重点要讲findAll方法的两个参数:name和attr**
    Name: 指的是标签名,传入一个标签名的名称就可以返回所有固定名称的标签名

    Attr: 是一个字典存储需要查找的标签参数,返回对应的标签

    Tag.children 表示获取tag标签的所有子标签

    Tag.string 表示获取tag标签内的所有字符串,不用一层一层索引下去寻找字符串

    Tag.attrs[key] 表示获取tag标签内参数的键值对键为key的值

    Tag.img 表示获取tag标签的标签名为img的自标签(一个)

    docx模块:
    在使用这个模块的时候,要记清楚如果:

    pip install python-docx

    easy_install python-docx

    两种方式安装都不能正常使用的话,就需要下载tar包自己手动安装

    Docx模块是一个可以直接操作生成docx文档的python模块,使用方法极尽简单:

    Demo = Document() #在内存中建立一个doc文档

    Demo.add_paragraph(data) #在doc文档中添加一个段落

    Demo.add_picture(“pic.png”) #doc文档中添加一个图片

    Demo.save(‘demo.docx’) #存储docx文档

    观察html结构:

    b4.png这里写图片描述

    我们大致观察一下结构,定位到文章的具体内容需要找到标签,然后再遍历标签的子标签即可遍历到所有的段落,配图资料

    b5.png这里写图片描述

    这样定位到图片,那么我们怎么样来寻找

    from docx import Document
    from bs4 import BeautifulSoup
    import urllib
    
    url ="http://freebuf.com/news/94263.html"
    data = urllib.urlopen(url)
    
    document = Document()
    
    soup = BeautifulSoup(data)
    article = soup.find(name ="div",attrs={'id':'contenttxt'}).children
    #这段是提取我们所要的信息
    for e in article:
       try:
           if e.img:
               pic_name = ''
               print e.img.attrs['src']
               if 'gif' in e.img.attrs['src']:
                    pic_name = 'temp.gif'
               elif 'png' in e.img.attrs['src']:
                    pic_name = 'temp.png'
               elif 'jpg' in e.img.attrs['src']:
                    pic_name = 'temp.jpg'
               else:
                    pic_name = 'temp.jpeg'
               urllib.urlretrieve(e.img.attrs['src'], filename=pic_name)
    
               #下面我们再来看看 urllib 模块提供的 urlretrieve() 函数。urlretrieve() 方法直接将远程数据下载到本地。
    
    #1
    >>> help(urllib.urlretrieve)
    #2
    Help on function urlretrieve in module urllib:
    #3
    
    #4
    urlretrieve(url, filename=None, reporthook=None, data=None)
    #参数 finename 指定了保存本地路径(如果参数未指定,urllib会生成一个临时文件保存数据。)
    #参数 reporthook 是一个回调函数,当连接上服务器、以及相应的数据块传输完毕时会触发该回调,我们可以利用这个回调函数来显示当前的下载进度。
    #参数 data 指 post 到服务器的数据,该方法返回一个包含两个元素的(filename, headers)元组,filename 表示保存到本地的路径,header 表示服务器的响应头。
    
    
               document.add_picture(pic_name)
       except:
           pass
       if e.string:
           print e.string.encode('gbk','ignore')
           document.add_paragraph(e.string)
    
    document.save("freebuf_article.docx")
    print "success create a document"

    主要是作为笔记,记录个人学习过程。
    大部分内容转载至,如若侵权,请联系删除。
    http://www.freebuf.com/news/topnews/96821.html

    展开全文
  • Python 网络爬虫入门详解

    万次阅读 多人点赞 2018-09-25 18:15:29
    什么是网络爬虫    网络爬虫又称网络蜘蛛,是指按照某种规则在网络上爬取所需内容的脚本程序。众所周知,每个网页通常包含其他网页的入口,网络爬虫则通过一个网址依次进入其他网址获取所需内容。 优先申明:...

    什么是网络爬虫

     

           网络爬虫又称网络蜘蛛,是指按照某种规则在网络上爬取所需内容的脚本程序。众所周知,每个网页通常包含其他网页的入口,网络爬虫则通过一个网址依次进入其他网址获取所需内容。

    优先申明:我们使用的python编译环境为PyCharm

     

    一、首先一个网络爬虫的组成结构:

    • 爬虫调度程序(程序的入口,用于启动整个程序)
    • url管理器(用于管理未爬取得url及已经爬取过的url)
    • 网页下载器(用于下载网页内容用于分析)
    • 网页解析器(用于解析下载的网页,获取新的url和所需内容)
    • 网页输出器(用于把获取到的内容以文件的形式输出)

     

    二、编写网络爬虫

    (1)准备所需库

     我们需要准备一款名为BeautifulSoup(网页解析)的开源库,用于对下载的网页进行解析,我们是用的是PyCharm编译环境所以可以直接下载该开源库。

     

    步骤如下:

    选择File->Settings

     

    打开Project:PythonProject下的Project interpreter

     

    点击加号添加新的库

     

    输入bs4选择bs4点击Install Packge进行下载

     

    (2)编写爬虫调度程序

        这里的bike_spider是项目名称引入的四个类分别对应下面的四段代码url管理器,url下载器,url解析器,url输出器。

    # 爬虫调度程序
    from bike_spider import url_manager, html_downloader, html_parser, html_outputer
    
    
    # 爬虫初始化
    class SpiderMain(object):
        def __init__(self):
            self.urls = url_manager.UrlManager()
            self.downloader = html_downloader.HtmlDownloader()
            self.parser = html_parser.HtmlParser()
            self.outputer = html_outputer.HtmlOutputer()
    
        def craw(self, my_root_url):
            count = 1
            self.urls.add_new_url(my_root_url)
            while self.urls.has_new_url():
                try:
                    new_url = self.urls.get_new_url()
                    print("craw %d : %s" % (count, new_url))
                    # 下载网页
                    html_cont = self.downloader.download(new_url)
                    # 解析网页
                    new_urls, new_data = self.parser.parse(new_url, html_cont)
                    self.urls.add_new_urls(new_urls)
                    # 网页输出器收集数据
                    self.outputer.collect_data(new_data)
                    if count == 10:
                        break
                    count += 1
                except:
                    print("craw failed")
    
            self.outputer.output_html()
    
    
    if __name__ == "__main__":
        root_url = "http://baike.baidu.com/item/Python/407313"
        obj_spider = SpiderMain()
        obj_spider.craw(root_url)

     

    (3)编写url管理器

    我们把已经爬取过的url和未爬取的url分开存放以便我们不会重复爬取某些已经爬取过的网页。

    # url管理器
    class UrlManager(object):
        def __init__(self):
            self.new_urls = set()
            self.old_urls = set()
    
        def add_new_url(self, url):
            if url is None:
                return
            if url not in self.new_urls and url not in self.old_urls:
                self.new_urls.add(url)
    
        def add_new_urls(self, urls):
            if urls is None or len(urls) == 0:
                return
            for url in urls:
                self.new_urls.add(url)
    
        def get_new_url(self):
            # pop方法会帮我们获取一个url并且移除它
            new_url = self.new_urls.pop()
            self.old_urls.add(new_url)
            return new_url
    
        def has_new_url(self):
            return len(self.new_urls) != 0

     

    (4)编写网页下载器

    通过网络请求来下载页面

    # 网页下载器
    import urllib.request
    
    
    class HtmlDownloader(object):
    
        def download(self, url):
            if url is None:
                return None
            response = urllib.request.urlopen(url)
            # code不为200则请求失败
            if response.getcode() != 200:
                return None
            return response.read()

     

    (5)编写网页解析器

    对网页进行解析时我们需要知道我们要查询的内容都有哪些特征,我们可以打开一个网页点击右键审查元素来了解我们所查内容的共同之处。

    # 网页解析器
    import re
    from bs4 import BeautifulSoup
    from urllib.parse import urljoin
    
    
    class HtmlParser(object):
    
        def parse(self, page_url, html_cont):
            if page_url is None or html_cont is None:
                return
            soup = BeautifulSoup(html_cont, "html.parser", from_encoding="utf-8")
            new_urls = self._get_new_urls(page_url, soup)
            new_data = self._get_new_data(page_url, soup)
            return new_urls, new_data
    
        def _get_new_data(self, page_url, soup):
            res_data = {"url": page_url}
            # 获取标题
            title_node = soup.find("dd", class_="lemmaWgt-lemmaTitle-title").find("h1")
            res_data["title"] = title_node.get_text()
            summary_node = soup.find("div", class_="lemma-summary")
            res_data["summary"] = summary_node.get_text()
            return res_data
    
        def _get_new_urls(self, page_url, soup):
            new_urls = set()
            # 查找出所有符合下列条件的url
            links = soup.find_all("a", href=re.compile(r"/item/"))
            for link in links:
                new_url = link['href']
                # 获取到的url不完整,学要拼接
                new_full_url = urljoin(page_url, new_url)
                new_urls.add(new_full_url)
            return new_urls

     

    (6)编写网页输出器

    输出的格式有很多种,我们选择以html的形式输出,这样我们可以的到一个html页面。

    # 网页输出器
    class HtmlOutputer(object):
    
        def __init__(self):
            self.datas = []
    
        def collect_data(self, data):
            if data is None:
                return
            self.datas.append(data)
    
        # 我们以html表格形式进行输出
        def output_html(self):
            fout = open("output.html", "w", encoding='utf-8')
            fout.write("<html>")
            fout.write("<meta charset='utf-8'>")
            fout.write("<body>")
            # 以表格输出
            fout.write("<table>")
            for data in self.datas:
                # 一行
                fout.write("<tr>")
                # 每个单元行的内容
                fout.write("<td>%s</td>" % data["url"])
                fout.write("<td>%s</td>" % data["title"])
                fout.write("<td>%s</td>" % data["summary"])
                fout.write("</tr>")
            fout.write("</table>")
            fout.write("</body>")
            fout.write("</html>")
            # 输出完毕后一定要关闭输出器
            fout.close()
    

     

    写在末尾

           注意:网页经常发生变化,我们需要根据网页的变化动态修改我们的代码来获得我们所需要的内容。

           这只是一个简单的网络爬虫,如果需要完善其功能我们需要考虑更多问题。

    爬虫入门后可以看一下爬虫如何模拟登陆Python爬虫模拟登陆

     

    展开全文
  • python爬虫详解

    2018-11-21 01:06:18
    我们一般的python爬虫过程如下: 1、使用requests模块取get打开url,获取页面源码 2、使用xpath或者正则取匹配我们想要的数据 仔细看来,爬虫并不难,只是我们被他的使用给吓到了,下面我们直接上代码,在代码...

    我们一般的python爬虫过程如下:

    1、使用requests模块取get打开url,获取页面源码

    2、使用xpath或者正则取匹配我们想要的数据

    仔细看来,爬虫并不难,只是我们被他的使用给吓到了,下面我们直接上代码,在代码注释中去理解:

    import requests
    import re
    import pymysql
    from lxml import etree
    from pymongo import MongoClient
    #获取用来打开url的session
    sessions = requests.session()
    '''
    给sssion设置代理,
    因为一般的网站没有这个的话,
    会拒绝我们的爬虫访问,
    因此我们在这模拟谷歌浏览器访问
    '''
    sessions.headers['User-Agent'] = 'Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/27.0.1453.94 Safari/537.36'
    
    #进行访问获取源码
    r = sessions.get(
        'https://baike.baidu.com/item/%E4%B8%AD%E5%9B%BD%E5%9C%B0%E9%9C%87%E5%B1%80%E9%83%91%E5%B7%9E%E5%9F%BA%E7%A1%80%E5%B7%A5%E7%A8%8B%E5%8B%98%E5%AF%9F%E7%A0%94%E7%A9%B6%E9%99%A2%E6%A1%A9%E5%9F%BA%E6%A3%80%E6%B5%8B%E4%B8%AD%E5%BF%83')
    #给怕取下来的数据指定解码格式
    r.encoding = 'utf-8'
    text = r.text
    #将网页源代码进行树结构化,以便于使用xpath
    content = etree.HTML(text)
    #使用xpath提取标签h1中的内容
    h = content.xpath('//h1')
    h1 = h[0].xpath('string(.)').strip()
    d = content.xpath("//div[@label-module='lemmaSummary']")
    d1 = d[0].xpath('string(.)').strip()
    print(h1)
    print(d1)

     

    展开全文
  • 欢迎加入Python学习交流群:535993938 禁止闲聊 ! 名额有限 ! 非喜勿进 ! 用python也差不多一年多了,python应用最多的场景还是web快速开发、爬虫、自动化运维:写过简单网站、写过自动发帖...

    欢迎加入Python学习交流群:535993938  禁止闲聊 ! 名额有限 ! 非喜勿进 !


    用python也差不多一年多了,python应用最多的场景还是web快速开发、爬虫、自动化运维:写过简单网站、写过自动发帖脚本、写过收发邮件脚本、写过简单验证码识别脚本。

    爬虫在开发过程中也有很多复用的过程,这里总结一下,以后也能省些事情。

    1、基本抓取网页

    get方法

    post方法

    2、使用代理IP

        在开发爬虫过程中经常会遇到IP被封掉的情况,这时就需要用到代理IP;

    在urllib2包中有ProxyHandler类,通过此类可以设置代理访问网页,如下代码片段:

    3、Cookies处理

        cookies是某些网站为了辨别用户身份、进行session跟踪而储存在用户本地终端上的数据(通常经过加密),python提供了cookielib模块用于处理cookies,cookielib模块的主要作用是提供可存储cookie的对象,以便于与urllib2模块配合使用来访问Internet资源.

    代码片段:

        关键在于CookieJar(),它用于管理HTTP cookie值、存储HTTP请求生成的cookie、向传出的HTTP请求添加cookie的对象。整个cookie都存储在内存中,对CookieJar实例进行垃圾回收后cookie也将丢失,所有过程都不需要单独去操作。

      手动添加cookie

    4、伪装成浏览器

        某些网站反感爬虫的到访,于是对爬虫一律拒绝请求。所以用urllib2直接访问网站经常会出现HTTP Error 403: Forbidden的情况

    对有些 header 要特别留意,Server 端会针对这些 header 做检查

      1.User-Agent 有些 Server 或 Proxy 会检查该值,用来判断是否是浏览器发起的 Request

      2.Content-Type 在使用 REST 接口时,Server 会检查该值,用来确定 HTTP Body 中的内容该怎样解析。

    这时可以通过修改http包中的header来实现,代码片段如下:

    5、页面解析

        对于页面解析最强大的当然是正则表达式,这个对于不同网站不同的使用者都不一样,就不用过多的说明,附两个比较好的网址:

    正则表达式入门:http://www.cnblogs.com/huxi/archive/2010/07/04/1771073.html 

    正则表达式在线测试:http://tool.oschina.net/regex/ 

    其次就是解析库了,常用的有两个lxml和BeautifulSoup,对于这两个的使用介绍两个比较好的网站:

    lxml:http://my.oschina.net/jhao104/blog/639448 

    BeautifulSoup:http://cuiqingcai.com/1319.html 

    对于这两个库,我的评价是,都是HTML/XML的处理库,Beautifulsoup纯python实现,效率低,但是功能实用,比如能用通过结果搜索获得某个HTML节点的源码;lxmlC语言编码,高效,支持Xpath

    6、验证码的处理

    对于一些简单的验证码,可以进行简单的识别。本人也只进行过一些简单的验证码识别。但是有些反人类的验证码,比如12306,可以通过打码平台进行人工打码,当然这是要付费的。

    7、gzip压缩

        有没有遇到过某些网页,不论怎么转码都是一团乱码。哈哈,那说明你还不知道许多web服务具有发送压缩数据的能力,这可以将网络线路上传输的大量数据消减 60% 以上。这尤其适用于 XML web 服务,因为 XML 数据 的压缩率可以很高。

    但是一般服务器不会为你发送压缩数据,除非你告诉服务器你可以处理压缩数据。

    于是需要这样修改代码:

    这是关键:创建Request对象,添加一个 Accept-encoding 头信息告诉服务器你能接受 gzip 压缩数据

    然后就是解压缩数据:

    8、多线程并发抓取

        单线程太慢的话,就需要多线程了,这里给个简单的线程池模板 这个程序只是简单地打印了1-10,但是可以看出是并发的。

    虽然说python的多线程很鸡肋,但是对于爬虫这种网络频繁型,还是能一定程度提高效率的。

    欢迎加入Python学习交流群:535993938  禁止闲聊 ! 名额有限 ! 非喜勿进 !
    展开全文
  • 今天来教大家如何使用Python来爬取博海拾贝的图片,分类保存,写入文档。 项目目标 创建一个文件夹, 分类保存所有文章图片。下载成功,结果显示控制台。 项目分析 1、如何找到真正访问的地址,多网页...
  • 京东口罩爬虫,到货通知爬虫,自动下单爬虫第二篇功能效果展示无货展示有货展示撸代码修改的地方邮箱修改口罩链接获取方式自动下单所需Cookie获取 预祝大家都能抢到口罩,请大家适量购买 第一篇 马上上班了,回来的...
  • 关于Python爬虫的超详细讲解,用例子来给大家一步步分析爬虫的代码原理,由浅入深,老年人来了,我也给你整明白。
  • python爬虫的BeautifulSoup库详解

    万次阅读 2020-07-15 21:42:50
    文章目录1.解析库2.基本使用3.标签选择器3.1选择元素3.2获取名称3.3获取属性3.4获取内容3.5嵌套选择3.6子节点和子孙节点3.7父节点和祖先节点3.8兄弟节点4标准选择器4.1find_all( name , attrs , recursive , text , ...
  • Python分布式爬虫详解(一)

    千次阅读 2018-10-20 16:03:39
    当项目上升到一定境界时候,需要同时抓取几百个甚至上千个网站,这个时候,单个的爬虫已经满足不了需求。比如我们日常用的百度,它每天都会爬取大量的网站,一台服务器肯定是不够用的。所以需要各个地方的服务器一起...
  • python爬虫之lxml详解

    千次阅读 2019-04-29 12:25:22
    python爬虫解析HTML也是一项重要的任务,而选择合适的解析器就显得尤为重要了,下面为大家详细解析一下lxml解析库, 我信奉的是实践出真知,你看再多语法书不如自己动手敲出来,看看它到底实现的是什么功能,这样总...
  • Python爬虫系列:爬取小说并写入txt文件

    万次阅读 多人点赞 2019-08-31 16:27:13
    Python爬虫系列——爬取小说并写入txt文件 文章介绍了如何从网站中爬取小说并写入txt文件中,实现了单章节写取,整本写取,多线程多本写取。爬虫使用的python版本为python3,有些系统使用python指令运行本脚本,可能...
  • Python爬虫(二十一) 学习Python爬虫过程中的心得体会以及知识点的整理,方便我自己查找,也希望可以和大家一起交流。 —— 正则表达式应用详解 —— 文章目录Python爬虫(二十一)—— 正则表达式应用详解 ——1. ...
1 2 3 4 5 ... 20
收藏数 8,755
精华内容 3,502
关键字:

python爬虫详解