您的位置:新葡亰496net > 奥门新萄京娱乐场 > 新葡亰496net:爬虫实战

新葡亰496net:爬虫实战

发布时间:2019-10-05 12:43编辑:奥门新萄京娱乐场浏览(128)

    Python 爬虫实战(一):使用 requests 和 BeautifulSoup,我们选用了 requests 做网络须求,得到网页数据再用 BeautifulSoup 分析,就在不久前,requests 作者 kennethreitz 出了叁个新库 requests-html,Pythonic HTML Parsing for Humans™,它能够用来剖析 HTML 文档的。requests-html 是根据现存的框架 PyQuery、Requests、lxml 等库开展了一次封装,尤其方便人民群众开荒者调用。

    Python 基础

    自个儿此前写的《Python 3 极简教程.pdf》,切合有一点点编制程序基础的长足入门,通过该类别文章学习,能够独立完成接口的编辑,写写小东西没难点。

    Python 基础

    小编前边写的《Python 3 极简教程.pdf》,符合有一点编制程序基础的急忙入门,通过该体系作品学习,能够单独达成接口的编写制定,写写小东西没难点。

    Python 基础

    自个儿在此以前写的《Python 3 极简教程.pdf》,切合有一点点编制程序基础的高效入门,通过该类别文章学习,能够单独完毕接口的编辑撰写,写写小东西没难点。

    Python安装

    安装

    Mac:

    pip3 install requests-html
    

    Windows:

    pip install requests-html
    

    requests

    requests,Python HTTP 诉求库,约等于 Android 的 Retrofit,它的功用满含Keep-Alive 和连接池、Cookie 长久化、内容自动解压、HTTP 代理、SSL 认证、连接超时、Session 等繁多表征,同期相配 Python2 和 Python3,GitHub:https://github.com/requests/requests 。

    requests

    requests,Python HTTP 央求库,相当于 Android 的 Retrofit,它的成效包罗Keep-Alive 和连接池、Cookie 长久化、内容自动解压、HTTP 代理、SSL 认证、连接超时、Session 等重重脾气,同一时间匹配 Python2 和 Python3,GitHub: 。

    requests

    requests,Python HTTP 央求库,约等于 Android 的 Retrofit,它的听从包含Keep-阿里ve 和连接池、Cookie 长久化、内容自动解压、HTTP 代理、SSL 认证、连接超时、Session 等多数表征,同一时候包容 Python2 和 Python3,GitHub: 。

    python学习 一 python语法,及变量类型

    实例

    新葡亰496net 1

    代码撸多了,让大家看会妹纸,爬的网站自己选的是 ,展开网址,观见到那是个列表,图片是缩略图,要想保留图片到本地,当然须要高清大图,由此得进来列表实际情况,进一步深入分析,完整代码如下:

    from requests_html import HTMLSession
    import requests
    import time
    
    session = HTMLSession()
    
    
    # 解析图片列表
    def get_girl_list():
        # 返回一个 response 对象
        response = session.get('http://www.win4000.com/zt/xinggan.html')  # 单位秒数
    
        content = response.html.find('div.Left_bar', first=True)
    
        li_list = content.find('li')
    
        for li in li_list:
            url = li.find('a', first=True).attrs['href']
            get_girl_detail(url)
    
    
    # 解析图片详细
    def get_girl_detail(url):
        # 返回一个 response 对象
        response = session.get(url)  # 单位秒数
        content = response.html.find('div.scroll-img-cont', first=True)
        li_list = content.find('li')
        for li in li_list:
            img_url = li.find('img', first=True).attrs['data-original']
            img_url = img_url[0:img_url.find('_')]   '.jpg'
            print(img_url   '.jpg')
            save_image(img_url)
    
    
    # 保持大图
    def save_image(img_url):
        img_response = requests.get(img_url)
        t = int(round(time.time() * 1000))  # 毫秒级时间戳
        f = open('/Users/wuxiaolong/Desktop/Girl/%d.jpg' % t, 'ab')  # 存储图片,多媒体文件需要参数b(二进制文件)
        f.write(img_response.content)  # 多媒体存储content
        f.close()
    
    
    if __name__ == '__main__':
        get_girl_list()
    

    代码就疑似此多,是否感到相当粗略啊。

    说明:

    1、requests-html 与 BeautifulSoup 区别,能够直接通过标签来 find,平日如下:
    标签
    标签.someClass
    标签#someID
    标签[target=_blank]
    参数 first 是 True,表示只回去 Element 找到的率先个,更加多接纳: ;

    2、这里保留本地路线 /Users/wuxiaolong/Desktop/Girl/自己写死了,必要读者改成本身的,若是平昔是文本名,保存路线将是体系目录下。

    安装

    Mac:

    pip3 install requests
    

    Windows:

    pip install requests
    

    安装

    Mac:

    pip3 install requests
    

    Windows:

    pip install requests
    

    安装

    Mac:

    pip3 install requests
    

    Windows:

    pip install requests
    

    python学习 二 爬叁个图纸网址上

    遗留难点

    示范所爬网址是分页的,未有做,能够定期循环来爬妹纸哦,风野趣的读者本身玩下。

    发送乞求

    HTTP 乞请方法有 get、post、put、delete。

    import requests
    
    # get 请求
    response = requests.get('http://127.0.0.1:1024/developer/api/v1.0/all')
    
    # post 请求
    response = requests.post('http://127.0.0.1:1024/developer/api/v1.0/insert')
    
    # put 请求
    response = requests.put('http://127.0.0.1:1024/developer/api/v1.0/update')
    
    # delete 请求
    response = requests.delete('http://127.0.0.1:1024/developer/api/v1.0/delete')
    

    恳请重回 Response 对象,Response 对象是对 HTTP 合同中服务端再次回到给浏览器的响应数据的包裹,响应的中的首要要素包罗:状态码、原因短语、响应首部、响应 UEvoqueL、响应 encoding、响应体等等。

    # 状态码
    print(response.status_code)
    
    # 响应 URL
    print(response.url)
    
    # 响应短语
    print(response.reason)
    
    # 响应内容
    print(response.json())
    

    发送须要

    HTTP 诉求方法有 get、post、put、delete。

    import requests
    
    # get 请求
    response = requests.get('http://127.0.0.1:1024/developer/api/v1.0/all')
    
    # post 请求
    response = requests.post('http://127.0.0.1:1024/developer/api/v1.0/insert')
    
    # put 请求
    response = requests.put('http://127.0.0.1:1024/developer/api/v1.0/update')
    
    # delete 请求
    response = requests.delete('http://127.0.0.1:1024/developer/api/v1.0/delete')
    

    恳请再次来到 Response 对象,Response 对象是对 HTTP 契约中服务端再次来到给浏览器的响应数据的包裹,响应的中的首要要素包含:状态码、原因短语、响应首部、响应 UCR-VL、响应 encoding、响应体等等。

    # 状态码
    print(response.status_code)
    
    # 响应 URL
    print(response.url)
    
    # 响应短语
    print(response.reason)
    
    # 响应内容
    print(response.json())
    

    出殡诉求

    HTTP 诉求方法有 get、post、put、delete。

    import requests
    
    # get 请求
    response = requests.get('http://127.0.0.1:1024/developer/api/v1.0/all')
    
    # post 请求
    response = requests.post('http://127.0.0.1:1024/developer/api/v1.0/insert')
    
    # put 请求
    response = requests.put('http://127.0.0.1:1024/developer/api/v1.0/update')
    
    # delete 请求
    response = requests.delete('http://127.0.0.1:1024/developer/api/v1.0/delete')
    

    恳请重临 Response 对象,Response 对象是对 HTTP 公约中服务端重临给浏览器的响应数据的包裹,响应的中的首要要素包含:状态码、原因短语、响应首部、响应 UPAJEROL、响应 encoding、响应体等等。

    # 状态码
    print(response.status_code)
    
    # 响应 URL
    print(response.url)
    
    # 响应短语
    print(response.reason)
    
    # 响应内容
    print(response.json())
    

    python学习 二 02 爬二个图形网址,获得主链接网站,并保留

    参考

    requests-html

    昨日用了一晃Requests-HTML库(Python爬虫)

    定制央浼头

    哀告增多 HTTP 尾部 Headers,只要传递二个 dict 给 headers 关键字参数就足以了。

    header = {'Application-Id': '19869a66c6',
              'Content-Type': 'application/json'
              }
    response = requests.get('http://127.0.0.1:1024/developer/api/v1.0/all/', headers=header)
    

    定制央浼头

    呼吁增加 HTTP 尾部 Headers,只要传递多个 dict 给 headers 关键字参数就足以了。

    header = {'Application-Id': '19869a66c6',
              'Content-Type': 'application/json'
              }
    response = requests.get('http://127.0.0.1:1024/developer/api/v1.0/all/', headers=header)
    

    定制需要头

    伸手增多 HTTP 尾部 Headers,只要传递八个 dict 给 headers 关键字参数就足以了。

    header = {'Application-Id': '19869a66c6',
              'Content-Type': 'application/json'
              }
    response = requests.get('http://127.0.0.1:1024/developer/api/v1.0/all/', headers=header)
    

    python学习 二 03 爬一个图纸网站-得到全数分页网站

    公众号

    自己的众生号:吴小龙同学,款待交换~
    新葡亰496net 2

    营造查询参数

    想为 U奥迪Q3L 的询问字符串(query string)传递某种数据,例如:http://127.0.0.1:1024/developer/api/v1.0/all?key1=value1&key2=value2 ,Requests 允许你利用 params 关键字参数,以三个字符串字典来提供这么些参数。

    payload = {'key1': 'value1', 'key2': 'value2'}
    response = requests.get("http://127.0.0.1:1024/developer/api/v1.0/all", params=payload)
    

    还可以够将 list 作为值传入:

    payload = {'key1': 'value1', 'key2': ['value2', 'value3']}
    response = requests.get("http://127.0.0.1:1024/developer/api/v1.0/all", params=payload)
    
    # 响应 URL
    print(response.url)# 打印:http://127.0.0.1:1024/developer/api/v1.0/all?key1=value1&key2=value2&key2=value3
    

    创设查询参数

    想为 UTucsonL 的询问字符串(query string)传递某种数据,举个例子: ,Requests 允许你使用 params 关键字参数,以三个字符串字典来提供这个参数。

    payload = {'key1': 'value1', 'key2': 'value2'}
    response = requests.get("http://127.0.0.1:1024/developer/api/v1.0/all", params=payload)
    

    还是可以将 list 作为值传入:

    payload = {'key1': 'value1', 'key2': ['value2', 'value3']}
    response = requests.get("http://127.0.0.1:1024/developer/api/v1.0/all", params=payload)
    
    # 响应 URL
    print(response.url)# 打印:http://127.0.0.1:1024/developer/api/v1.0/all?key1=value1&key2=value2&key2=value3
    

    创设查询参数

    想为 U中华VL 的查询字符串(query string)传递某种数据,举例: ,Requests 允许你使用 params 关键字参数,以三个字符串字典来提供那么些参数。

    payload = {'key1': 'value1', 'key2': 'value2'}
    response = requests.get("http://127.0.0.1:1024/developer/api/v1.0/all", params=payload)
    

    还足以将 list 作为值传入:

    payload = {'key1': 'value1', 'key2': ['value2', 'value3']}
    response = requests.get("http://127.0.0.1:1024/developer/api/v1.0/all", params=payload)
    
    # 响应 URL
    print(response.url)# 打印:http://127.0.0.1:1024/developer/api/v1.0/all?key1=value1&key2=value2&key2=value3
    

    python学习 二 04 爬二个图形网址-深入分析文件,得到全数图片链接

    post 央求数据

    要是服务器须求发送的多少是表单数据,则能够钦定关键字参数 data。

    payload = {'key1': 'value1', 'key2': 'value2'}
    response = requests.post("http://127.0.0.1:1024/developer/api/v1.0/insert", data=payload)
    

    纵然供给传递 json 格式字符串参数,则能够动用 json 关键字参数,参数的值都足以字典的款型传过去。

    obj = {
        "article_title": "小公务员之死2"
    }
    # response = requests.post('http://127.0.0.1:1024/developer/api/v1.0/insert', json=obj)
    

    post 央浼数据

    只要服务器须求发送的数目是表单数据,则足以钦定关键字参数 data。

    payload = {'key1': 'value1', 'key2': 'value2'}
    response = requests.post("http://127.0.0.1:1024/developer/api/v1.0/insert", data=payload)
    

    倘使需求传递 json 格式字符串参数,则足以应用 json 关键字参数,参数的值都得以字典的样式传过去。

    obj = {
        "article_title": "小公务员之死2"
    }
    # response = requests.post('http://127.0.0.1:1024/developer/api/v1.0/insert', json=obj)
    

    post 哀告数据

    假使服务器须要发送的多寡是表单数据,则足以钦赐关键字参数 data。

    payload = {'key1': 'value1', 'key2': 'value2'}
    response = requests.post("http://127.0.0.1:1024/developer/api/v1.0/insert", data=payload)
    

    若果供给传递 json 格式字符串参数,则足以运用 json 关键字参数,参数的值都足以字典的情势传过去。

    obj = {
        "article_title": "小公务员之死2"
    }
    # response = requests.post('http://127.0.0.1:1024/developer/api/v1.0/insert', json=obj)
    

    python学习 二 05 爬三个图形网址-下载图片链接

    响应内容

    Requests 会自动解码来自服务器的开始和结果。大许多 unicode 字符集都能被无缝地解码。央浼发出后,Requests 会基于 HTTP 底部对响应的编码作出有依附的估量。

    # 响应内容
    # 返回是 是 str 类型内容
    # print(response.text())
    # 返回是 JSON 响应内容
    print(response.json())
    # 返回是二进制响应内容
    # print(response.content())
    # 原始响应内容,初始请求中设置了 stream=True
    # response = requests.get('http://127.0.0.1:1024/developer/api/v1.0/all', stream=True)
    # print(response.raw())
    

    响应内容

    Requests 会自动解码来自服务器的剧情。大相当多 unicode 字符集都能被无缝地解码。央求发出后,Requests 会基于 HTTP 尾部对响应的编码作出有根据的推断。

    # 响应内容
    # 返回是 是 str 类型内容
    # print(response.text())
    # 返回是 JSON 响应内容
    print(response.json())
    # 返回是二进制响应内容
    # print(response.content())
    # 原始响应内容,初始请求中设置了 stream=True
    # response = requests.get('http://127.0.0.1:1024/developer/api/v1.0/all', stream=True)
    # print(response.raw())
    

    响应内容

    Requests 会自动解码来自服务器的内容。大多数 unicode 字符集都能被无缝地解码。央浼发出后,Requests 会基于 HTTP 底部对响应的编码作出有依照的推理。

    # 响应内容
    # 返回是 是 str 类型内容
    # print(response.text())
    # 返回是 JSON 响应内容
    print(response.json())
    # 返回是二进制响应内容
    # print(response.content())
    # 原始响应内容,初始请求中设置了 stream=True
    # response = requests.get('http://127.0.0.1:1024/developer/api/v1.0/all', stream=True)
    # print(response.raw())
    

    python学习 二 06 爬叁个图形网址-四线程方式下载

    超时

    若无显式内定了 timeout 值,requests 是不会自行举行过期处理的。尽管境遇服务器未有响应的情形时,整个应用程序从来处于阻塞状态而无语管理任何央浼。

    response = requests.get('http://127.0.0.1:1024/developer/api/v1.0/all', timeout=5)  # 单位秒数
    

    超时

    假定未有显式钦定了 timeout 值,requests 是不会自动进行过期管理的。倘使遭受服务器未有响应的图景时,整个应用程序一贯处在阻塞状态而无可奈何管理其余须要。

    response = requests.get('http://127.0.0.1:1024/developer/api/v1.0/all', timeout=5)  # 单位秒数
    

    超时

    若果未有显式钦点了 timeout 值,requests 是不会自行进行过期处理的。若是蒙受服务器未有响应的状态时,整个应用程序一贯处在阻塞状态而无法管理其余央浼。

    response = requests.get('http://127.0.0.1:1024/developer/api/v1.0/all', timeout=5)  # 单位秒数
    

    python学习 三 01 再爬多少个网址,几行代码,消除分类项目

    代理设置

    倘若频仍拜访一个网址,很轻巧被劳务器屏蔽掉,requests 完美支持代理。

    # 代理
    proxies = {
        'http': 'http://127.0.0.1:1024',
        'https': 'http://127.0.0.1:4000',
    }
    response = requests.get('http://127.0.0.1:1024/developer/api/v1.0/all', proxies=proxies)
    

    代理设置

    只要频仍探访一个网址,很轻巧被劳务器屏蔽掉,requests 完美补助代理。

    # 代理
    proxies = {
        'http': 'http://127.0.0.1:1024',
        'https': 'http://127.0.0.1:4000',
    }
    response = requests.get('http://127.0.0.1:1024/developer/api/v1.0/all', proxies=proxies)
    

    代理设置

    要是频繁探望贰个网址,很轻易被劳务器屏蔽掉,requests 完美扶助代理。

    # 代理
    proxies = {
        'http': 'http://127.0.0.1:1024',
        'https': 'http://127.0.0.1:4000',
    }
    response = requests.get('http://127.0.0.1:1024/developer/api/v1.0/all', proxies=proxies)
    

    python学习 三 02 再爬三个网址,获得全体分页

    BeautifulSoup

    BeautifulSoup,Python Html 解析库,相当于 Java 的 jsoup。

    BeautifulSoup

    BeautifulSoup,Python Html 解析库,相当于 Java 的 jsoup。

    BeautifulSoup

    BeautifulSoup,Python Html 解析库,相当于 Java 的 jsoup。

    python学习 三 03 再爬贰个网址,根据分页,下载图片

    安装

    BeautifulSoup 3 最近一度结束开拓,直接运用BeautifulSoup 4。

    Mac:

    pip3 install beautifulsoup4
    

    Windows:

    pip install beautifulsoup4
    

    安装

    BeautifulSoup 3 近来早已甘休开拓,直接利用BeautifulSoup 4。

    Mac:

    pip3 install beautifulsoup4
    

    Windows:

    pip install beautifulsoup4
    

    安装

    BeautifulSoup 3 近些日子曾经截止开采,间接行使BeautifulSoup 4。

    Mac:

    pip3 install beautifulsoup4
    

    Windows:

    pip install beautifulsoup4
    

    Python 爬虫 上篇

    安装解析器

    自家用的是 html5lib,纯 Python 完毕的。

    Mac:

    pip3 install html5lib
    

    Windows:

    pip install html5lib
    

    安装深入分析器

    本人用的是 html5lib,纯 Python 达成的。

    Mac:

    pip3 install html5lib
    

    Windows:

    pip install html5lib
    

    安装分析器

    自己用的是 html5lib,纯 Python 达成的。

    Mac:

    pip3 install html5lib
    

    Windows:

    pip install html5lib
    

    Python 爬虫 下篇

    简简单单利用

    BeautifulSoup 将复杂 HTML 文书档案转产生三个头晕目眩的树形结构,种种节点都是Python 对象。

    简易利用

    BeautifulSoup 将复杂 HTML 文书档案转变到叁个复杂的树形结构,每一种节点都以Python 对象。

    一言以蔽之利用

    BeautifulSoup 将复杂 HTML 文书档案调换来多个繁杂的树形结构,每一个节点都是Python 对象。

    Python 爬虫 上篇

    解析

    from bs4 import BeautifulSoup
    
    def get_html_data():
        html_doc = """
        <html>
        <head>
        <title>WuXiaolong</title>
        </head>
        <body>
        <p>分享 Android 技术,也关注 Python 等热门技术。</p>
        <p>写博客的初衷:总结经验,记录自己的成长。</p>
        <p>你必须足够的努力,才能看起来毫不费力!专注!精致!
        </p>
        <p class="Blog"><a href="http://wuxiaolong.me/">WuXiaolong's blog</a></p>
        <p class="WeChat"><a href="https://open.weixin.qq.com/qr/code?username=MrWuXiaolong">公众号:吴小龙同学</a> </p>
        <p class="GitHub"><a href="http://example.com/tillie" class="sister" id="link3">GitHub</a></p>
        </body>
        </html>   
        """
        soup = BeautifulSoup(html_doc, "html5lib")
    

    解析

    from bs4 import BeautifulSoup
    
    def get_html_data():
        html_doc = """
        <html>
        <head>
        <title>WuXiaolong</title>
        </head>
        <body>
        <p>分享 Android 技术,也关注 Python 等热门技术。</p>
        <p>写博客的初衷:总结经验,记录自己的成长。</p>
        <p>你必须足够的努力,才能看起来毫不费力!专注!精致!
        </p>
        <p class="Blog"><a href="http://wuxiaolong.me/">WuXiaolong's blog</a></p>
        <p class="WeChat"><a href="https://open.weixin.qq.com/qr/code?username=MrWuXiaolong">公众号:吴小龙同学</a> </p>
        <p class="GitHub"><a href="http://example.com/tillie" class="sister" id="link3">GitHub</a></p>
        </body>
        </html>   
        """
        soup = BeautifulSoup(html_doc, "html5lib")
    

    解析

    from bs4 import BeautifulSoup
    
    def get_html_data():
        html_doc = """
        <html>
        <head>
        <title>WuXiaolong</title>
        </head>
        <body>
        <p>分享 Android 技术,也关注 Python 等热门技术。</p>
        <p>写博客的初衷:总结经验,记录自己的成长。</p>
        <p>你必须足够的努力,才能看起来毫不费力!专注!精致!
        </p>
        <p class="Blog"><a href="http://wuxiaolong.me/">WuXiaolong's blog</a></p>
        <p class="WeChat"><a href="https://open.weixin.qq.com/qr/code?username=MrWuXiaolong">公众号:吴小龙同学</a> </p>
        <p class="GitHub"><a href="http://example.com/tillie" class="sister" id="link3">GitHub</a></p>
        </body>
        </html>   
        """
        soup = BeautifulSoup(html_doc, "html5lib")
    

    Python爬虫学习 第一篇 策画

    tag

    tag = soup.head
    print(tag)  # <head><title>WuXiaolong</title></head>
    print(tag.name)  # head
    print(tag.title)  # <title>WuXiaolong</title>
    print(soup.p)  # <p>分享 Android 技术,也关注 Python 等热门技术。</p>
    print(soup.a['href'])  # 输出 a 标签的 href 属性:http://wuxiaolong.me/
    

    在意:tag 假若四个门户大概,重回第一个,例如这里的 p 标签。

    tag

    tag = soup.head
    print(tag)  # <head><title>WuXiaolong</title></head>
    print(tag.name)  # head
    print(tag.title)  # <title>WuXiaolong</title>
    print(soup.p)  # <p>分享 Android 技术,也关注 Python 等热门技术。</p>
    print(soup.a['href'])  # 输出 a 标签的 href 属性:http://wuxiaolong.me/
    

    只顾:tag 假使多少个门道优秀,重临第1个,比方这里的 p 标签。

    tag

    tag = soup.head
    print(tag)  # <head><title>WuXiaolong</title></head>
    print(tag.name)  # head
    print(tag.title)  # <title>WuXiaolong</title>
    print(soup.p)  # <p>分享 Android 技术,也关注 Python 等热门技术。</p>
    print(soup.a['href'])  # 输出 a 标签的 href 属性:http://wuxiaolong.me/
    

    小心:tag 假若三个卓殊,再次回到第多个,比如此处的 p 标签。

    眼前使用python用来爬取互联网图片,此前也是有分章介绍,此次合併聚集介绍下自己的爬虫进程。

    查找

    print(soup.find('p'))  # <p>分享 Android 技术,也关注 Python 等热门技术。</p>
    

    find 暗中同意也是回去第贰个地位相当的竹签,没找到相称的节点则赶回 None。若是自个儿想钦赐查找,例如此处的公众号,能够钦命标签的如 class 属性值:

    # 因为 class 是 Python 关键字,所以这里指定为 class_。
    print(soup.find('p', class_="WeChat"))
    # <p class="WeChat"><a href="https://open.weixin.qq.com/qr/code?username=MrWuXiaolong">公众号</a> </p>
    

    探求全体的 P 标签:

    for p in soup.find_all('p'):
        print(p.string) 
    

    查找

    print(soup.find('p'))  # <p>分享 Android 技术,也关注 Python 等热门技术。</p>
    

    find 私下认可也是重回第多少个分外的竹签,没找到相配的节点则赶回 None。要是本人想钦命查找,比方这里的群众号,可以钦赐标签的如 class 属性值:

    # 因为 class 是 Python 关键字,所以这里指定为 class_。
    print(soup.find('p', class_="WeChat"))
    # <p class="WeChat"><a href="https://open.weixin.qq.com/qr/code?username=MrWuXiaolong">公众号</a> </p>
    

    寻觅全数的 P 标签:

    for p in soup.find_all('p'):
        print(p.string) 
    

    查找

    print(soup.find('p'))  # <p>分享 Android 技术,也关注 Python 等热门技术。</p>
    

    find 暗中认可也是回来第二个门户大概的竹签,没找到相称的节点则赶回 None。借使自身想钦点查找,举例此处的公众号,能够钦点标签的如 class 属性值:

    # 因为 class 是 Python 关键字,所以这里指定为 class_。
    print(soup.find('p', class_="WeChat"))
    # <p class="WeChat"><a href="https://open.weixin.qq.com/qr/code?username=MrWuXiaolong">公众号</a> </p>
    

    搜索全数的 P 标签:

    for p in soup.find_all('p'):
        print(p.string) 
    

    爬虫是什么

    实战

    近些日子,有客商反映,作者的个体 APP 挂了,即使这一个 APP笔者早已不复维护,可是本身也得至都督险它能符合规律运维。超过四分之二人都知晓那个 APP数据是爬来的(详见:《手把手教你做个人app》),数据爬来的补益之一正是绝不自身管数据,破绽是外人网址挂了或网址的 HTML 节点变了,笔者那边就解析不到,就不多。此次客户反映,笔者在想要不要把他们网址数量直接爬虫了,正好自学 Python,练练手,嗯说干就干,本来是想着先用 Python 爬虫,MySQL 插入本地数据库,然后 Flask 自身写接口,用 Android 的 Retrofit 调,再用 bmob sdk 插入 bmob……哎,费力,以为行不通,后来自己深知 bmob 提供了 RESTful,消除大标题,小编能够直接 Python 爬虫插入就好了,这里笔者自己要作为楷模遵循规则的是插入本地数据库,假使用 bmob,是调 bmob 提供的 RESTful 插数据。

    实战

    如今,有客商举报,笔者的个人 APP 挂了,即使这些 应用软件小编已经不复维护,不过本身也得最提辖障它能符合规律运转。大多数人都了解那些 电脑软件数据是爬来的(详见:《手把手教你做个人app》),数据爬来的裨益之一正是毫无本人管数据,弊端是人家网址挂了或网址的 HTML 节点变了,笔者那边就解析不到,就非常少。此番顾客举报,笔者在想要不要把他们网址数量间接爬虫了,正好自学 Python,练练手,嗯说干就干,本来是想着先用 Python 爬虫,MySQL 插入本地数据库,然后 Flask 自个儿写接口,用 Android 的 Retrofit 调,再用 bmob sdk 插入 bmob……哎,费事,认为行不通,后来自家意识到 bmob 提供了 RESTful,化解大难点,小编可以直接 Python 爬虫插入就好了,这里作者现身说法的是插入本地数据库,如若用 bmob,是调 bmob 提供的 RESTful 插数据。

    实战

    近来,有客商反馈,笔者的私有 APP 挂了,即便那几个 APP我已经不复维护,然而本身也得起码有限支撑它能符合规律运作。大多数人都清楚那个 APP数据是爬来的(详见:《手把手教你做个人app》),数据爬来的收益之一正是并不是自身管数据,缺欠是外人网址挂了或网址的 HTML 节点变了,作者这边就分析不到,就相当少。此番客户反馈,笔者在想要不要把他们网址数量直接爬虫了,正好自学 Python,练练手,嗯说干就干,本来是想着先用 Python 爬虫,MySQL 插入本地数据库,然后 Flask 自个儿写接口,用 Android 的 Retrofit 调,再用 bmob sdk 插入 bmob……哎,费力,以为行不通,后来本人深知 bmob 提供了 RESTful,消除大难题,小编能够直接 Python 爬虫插入就好了,这里本身亲自过问的是插入本地数据库,假使用 bmob,是调 bmob 提供的 RESTful 插数据。

    网络爬虫是怎么?

    网址选定

    自家选的亲自去做网址:https://meiriyiwen.com/random ,大家能够开采,每便诉求的稿子都不均等,正好利用那点,小编要是定时去乞求,深入分析本身须求的数量,插入数据库就 OK 了。

    网站选定

    自己选的身体力行网址: ,大家可以发掘,每便央浼的篇章都不雷同,正好利用那点,小编一旦按时去央浼,解析本人索要的多少,插入数据库就 OK 了。

    网址选定

    自家选的演示网址: ,我们能够窥见,每一次诉求的稿子都分化,正好利用那点,笔者如果定期去乞请,解析自身索要的数量,插入数据库就 OK 了。

    看意思是贰个虫子,三个如何虫子?实际上指的是蜘蛛spider。

    始建数据库

    自家一向用 NaviCat Premium 成立的,当然也得以用命令行。
    [图形上传退步...(image-50eadd-1512955991188)]

    创设数据库

    自家一贯用 NaviCat Premium 创造的,当然也足以用命令行。
    新葡亰496net 3

    创建数据库

    小编平素用 NaviCat Premium 创造的,当然也得以用命令行。
    新葡亰496net 4

    蜘蛛结成网,在网上爬来爬去的探索坠入网络中的食物。

    创建表

    创建表 article,用的 pymysql,表需要 id,article_title,article_author,article_content 字段,代码如下,只供给调一回就好了。

    import pymysql
    
    
    def create_table():
        # 建立连接
        db = pymysql.connect(host='localhost',
                             user='root',
                             password='root',
                             db='python3learn')
        # 创建名为 article 数据库语句
        sql = '''create table if not exists article (
        id int NOT NULL AUTO_INCREMENT, 
        article_title text,
        article_author text,
        article_content text,
        PRIMARY KEY (`id`)
        )'''
        # 使用 cursor() 方法创建一个游标对象 cursor
        cursor = db.cursor()
        try:
            # 执行 sql 语句
            cursor.execute(sql)
            # 提交事务
            db.commit()
            print('create table success')
        except BaseException as e:  # 如果发生错误则回滚
            db.rollback()
            print(e)
    
        finally:
            # 关闭游标连接
            cursor.close()
            # 关闭数据库连接
            db.close()
    
    
    if __name__ == '__main__':
        create_table()
    

    创建表

    创建表 article,用的 pymysql,表需要 id,article_title,article_author,article_content 字段,代码如下,只要求调一回就好了。

    import pymysql
    
    
    def create_table():
        # 建立连接
        db = pymysql.connect(host='localhost',
                             user='root',
                             password='root',
                             db='python3learn')
        # 创建名为 article 数据库语句
        sql = '''create table if not exists article (
        id int NOT NULL AUTO_INCREMENT, 
        article_title text,
        article_author text,
        article_content text,
        PRIMARY KEY (`id`)
        )'''
        # 使用 cursor() 方法创建一个游标对象 cursor
        cursor = db.cursor()
        try:
            # 执行 sql 语句
            cursor.execute(sql)
            # 提交事务
            db.commit()
            print('create table success')
        except BaseException as e:  # 如果发生错误则回滚
            db.rollback()
            print(e)
    
        finally:
            # 关闭游标连接
            cursor.close()
            # 关闭数据库连接
            db.close()
    
    
    if __name__ == '__main__':
        create_table()
    

    创建表

    创建表 article,用的 pymysql,表需要 id,article_title,article_author,article_content 字段,代码如下,只须要调三遍就好了。

    import pymysql
    
    
    def create_table():
        # 建立连接
        db = pymysql.connect(host='localhost',
                             user='root',
                             password='root',
                             db='python3learn')
        # 创建名为 article 数据库语句
        sql = '''create table if not exists article (
        id int NOT NULL AUTO_INCREMENT, 
        article_title text,
        article_author text,
        article_content text,
        PRIMARY KEY (`id`)
        )'''
        # 使用 cursor() 方法创建一个游标对象 cursor
        cursor = db.cursor()
        try:
            # 执行 sql 语句
            cursor.execute(sql)
            # 提交事务
            db.commit()
            print('create table success')
        except BaseException as e:  # 如果发生错误则回滚
            db.rollback()
            print(e)
    
        finally:
            # 关闭游标连接
            cursor.close()
            # 关闭数据库连接
            db.close()
    
    
    if __name__ == '__main__':
        create_table()
    

    互连网爬虫便是基本上的野趣,在互连网络爬来爬去的查找你的神气食品。

    分析网址

    先是供给 requests 诉求网站,然后 BeautifulSoup 解析本身索要的节点。

    import requests
    from bs4 import BeautifulSoup
    
    
    def get_html_data():
        # get 请求
        response = requests.get('https://meiriyiwen.com/random')
    
        soup = BeautifulSoup(response.content, "html5lib")
        article = soup.find("div", id='article_show')
        article_title = article.h1.string
        print('article_title=%s' % article_title)
        article_author = article.find('p', class_="article_author").string
        print('article_author=%s' % article.find('p', class_="article_author").string)
        article_contents = article.find('div', class_="article_text").find_all('p')
        article_content = ''
        for content in article_contents:
            article_content = article_content   str(content)
            print('article_content=%s' % article_content)
    

    浅析网址

    首先供给 requests 央浼网址,然后 BeautifulSoup 分析自个儿要求的节点。

    import requests
    from bs4 import BeautifulSoup
    
    
    def get_html_data():
        # get 请求
        response = requests.get('https://meiriyiwen.com/random')
    
        soup = BeautifulSoup(response.content, "html5lib")
        article = soup.find("div", id='article_show')
        article_title = article.h1.string
        print('article_title=%s' % article_title)
        article_author = article.find('p', class_="article_author").string
        print('article_author=%s' % article.find('p', class_="article_author").string)
        article_contents = article.find('div', class_="article_text").find_all('p')
        article_content = ''
        for content in article_contents:
            article_content = article_content   str(content)
            print('article_content=%s' % article_content)
    

    解析网站

    第一需求 requests 央求网址,然后 BeautifulSoup 分析自个儿索要的节点。

    import requests
    from bs4 import BeautifulSoup
    
    
    def get_html_data():
        # get 请求
        response = requests.get('https://meiriyiwen.com/random')
    
        soup = BeautifulSoup(response.content, "html5lib")
        article = soup.find("div", id='article_show')
        article_title = article.h1.string
        print('article_title=%s' % article_title)
        article_author = article.find('p', class_="article_author").string
        print('article_author=%s' % article.find('p', class_="article_author").string)
        article_contents = article.find('div', class_="article_text").find_all('p')
        article_content = ''
        for content in article_contents:
            article_content = article_content   str(content)
            print('article_content=%s' % article_content)
    

    发端爬前的企图

    布署数据库

    那边做了叁个筛选,暗中认可那些网址的稿子题目是独步一时的,插入数据时,若是有了一模二样的标题就不插入。

    import pymysql
    
    
    def insert_table(article_title, article_author, article_content):
        # 建立连接
        db = pymysql.connect(host='localhost',
                             user='root',
                             password='root',
                             db='python3learn',
                             charset="utf8")
        # 插入数据
        query_sql = 'select * from article where article_title=%s'
        sql = 'insert into article (article_title,article_author,article_content) values (%s, %s, %s)'
        # 使用 cursor() 方法创建一个游标对象 cursor
        cursor = db.cursor()
        try:
            query_value = (article_title,)
            # 执行 sql 语句
            cursor.execute(query_sql, query_value)
            results = cursor.fetchall()
            if len(results) == 0:
                value = (article_title, article_author, article_content)
                cursor.execute(sql, value)
                # 提交事务
                db.commit()
                print('--------------《%s》 insert table success-------------' % article_title)
                return True
            else:
                print('--------------《%s》 已经存在-------------' % article_title)
                return False
    
        except BaseException as e:  # 如果发生错误则回滚
            db.rollback()
            print(e)
    
        finally:  # 关闭游标连接
            cursor.close()
            # 关闭数据库连接
            db.close()
    

    插入数据库

    此间做了一个筛选,暗许这一个网址的篇章标题是独一的,插入数据时,如若有了同等的标题就不插入。

    import pymysql
    
    
    def insert_table(article_title, article_author, article_content):
        # 建立连接
        db = pymysql.connect(host='localhost',
                             user='root',
                             password='root',
                             db='python3learn',
                             charset="utf8")
        # 插入数据
        query_sql = 'select * from article where article_title=%s'
        sql = 'insert into article (article_title,article_author,article_content) values (%s, %s, %s)'
        # 使用 cursor() 方法创建一个游标对象 cursor
        cursor = db.cursor()
        try:
            query_value = (article_title,)
            # 执行 sql 语句
            cursor.execute(query_sql, query_value)
            results = cursor.fetchall()
            if len(results) == 0:
                value = (article_title, article_author, article_content)
                cursor.execute(sql, value)
                # 提交事务
                db.commit()
                print('--------------《%s》 insert table success-------------' % article_title)
                return True
            else:
                print('--------------《%s》 已经存在-------------' % article_title)
                return False
    
        except BaseException as e:  # 如果发生错误则回滚
            db.rollback()
            print(e)
    
        finally:  # 关闭游标连接
            cursor.close()
            # 关闭数据库连接
            db.close()
    

    安排数据库

    这里做了一个筛选,暗中同意这一个网址的稿子标题是头一无二的,插入数据时,如果有了同一的标题就不插入。

    import pymysql
    
    
    def insert_table(article_title, article_author, article_content):
        # 建立连接
        db = pymysql.connect(host='localhost',
                             user='root',
                             password='root',
                             db='python3learn',
                             charset="utf8")
        # 插入数据
        query_sql = 'select * from article where article_title=%s'
        sql = 'insert into article (article_title,article_author,article_content) values (%s, %s, %s)'
        # 使用 cursor() 方法创建一个游标对象 cursor
        cursor = db.cursor()
        try:
            query_value = (article_title,)
            # 执行 sql 语句
            cursor.execute(query_sql, query_value)
            results = cursor.fetchall()
            if len(results) == 0:
                value = (article_title, article_author, article_content)
                cursor.execute(sql, value)
                # 提交事务
                db.commit()
                print('--------------《%s》 insert table success-------------' % article_title)
                return True
            else:
                print('--------------《%s》 已经存在-------------' % article_title)
                return False
    
        except BaseException as e:  # 如果发生错误则回滚
            db.rollback()
            print(e)
    
        finally:  # 关闭游标连接
            cursor.close()
            # 关闭数据库连接
            db.close()
    

    要起来爬,你得先清楚爬何地啊,你得先拿走网页的源码即HTML消息吗,获得后,你要求深入分析出链接和图纸等财富吧。

    定时装置

    做了一个定时,过段时间就去爬二次。

    import sched
    import time
    
    
    # 初始化 sched 模块的 scheduler 类
    # 第一个参数是一个可以返回时间戳的函数,第二个参数可以在定时未到达之前阻塞。
    schedule = sched.scheduler(time.time, time.sleep)
    
    
    # 被周期性调度触发的函数
    def print_time(inc):
        # to do something
        print('to do something')
        schedule.enter(inc, 0, print_time, (inc,))
    
    
    # 默认参数 60 s
    def start(inc=60):
        # enter四个参数分别为:间隔事件、优先级(用于同时间到达的两个事件同时执行时定序)、被调用触发的函数,
        # 给该触发函数的参数(tuple形式)
        schedule.enter(0, 0, print_time, (inc,))
        schedule.run()
    
    
    if __name__ == '__main__':
        # 5 s 输出一次
        start(5)
    

    定服装置

    做了二个定时,过段时间就去爬一回。

    import sched
    import time
    
    
    # 初始化 sched 模块的 scheduler 类
    # 第一个参数是一个可以返回时间戳的函数,第二个参数可以在定时未到达之前阻塞。
    schedule = sched.scheduler(time.time, time.sleep)
    
    
    # 被周期性调度触发的函数
    def print_time(inc):
        # to do something
        print('to do something')
        schedule.enter(inc, 0, print_time, (inc,))
    
    
    # 默认参数 60 s
    def start(inc=60):
        # enter四个参数分别为:间隔事件、优先级(用于同时间到达的两个事件同时执行时定序)、被调用触发的函数,
        # 给该触发函数的参数(tuple形式)
        schedule.enter(0, 0, print_time, (inc,))
        schedule.run()
    
    
    if __name__ == '__main__':
        # 5 s 输出一次
        start(5)
    

    定衣裳置

    做了三个按时,过段时间就去爬一次。

    import sched
    import time
    
    
    # 初始化 sched 模块的 scheduler 类
    # 第一个参数是一个可以返回时间戳的函数,第二个参数可以在定时未到达之前阻塞。
    schedule = sched.scheduler(time.time, time.sleep)
    
    
    # 被周期性调度触发的函数
    def print_time(inc):
        # to do something
        print('to do something')
        schedule.enter(inc, 0, print_time, (inc,))
    
    
    # 默认参数 60 s
    def start(inc=60):
        # enter四个参数分别为:间隔事件、优先级(用于同时间到达的两个事件同时执行时定序)、被调用触发的函数,
        # 给该触发函数的参数(tuple形式)
        schedule.enter(0, 0, print_time, (inc,))
        schedule.run()
    
    
    if __name__ == '__main__':
        # 5 s 输出一次
        start(5)
    

    要赢得HTML并剖析网页消息,要求下载二个第三方的库requesets,下载地址:

    全部代码

    import pymysql
    import requests
    from bs4 import BeautifulSoup
    import sched
    import time
    
    
    def create_table():
        # 建立连接
        db = pymysql.connect(host='localhost',
                             user='root',
                             password='root',
                             db='python3learn')
        # 创建名为 article 数据库语句
        sql = '''create table if not exists article (
        id int NOT NULL AUTO_INCREMENT, 
        article_title text,
        article_author text,
        article_content text,
        PRIMARY KEY (`id`)
        )'''
        # 使用 cursor() 方法创建一个游标对象 cursor
        cursor = db.cursor()
        try:
            # 执行 sql 语句
            cursor.execute(sql)
            # 提交事务
            db.commit()
            print('create table success')
        except BaseException as e:  # 如果发生错误则回滚
            db.rollback()
            print(e)
    
        finally:
            # 关闭游标连接
            cursor.close()
            # 关闭数据库连接
            db.close()
    
    
    def insert_table(article_title, article_author, article_content):
        # 建立连接
        db = pymysql.connect(host='localhost',
                             user='root',
                             password='root',
                             db='python3learn',
                             charset="utf8")
        # 插入数据
        query_sql = 'select * from article where article_title=%s'
        sql = 'insert into article (article_title,article_author,article_content) values (%s, %s, %s)'
        # 使用 cursor() 方法创建一个游标对象 cursor
        cursor = db.cursor()
        try:
            query_value = (article_title,)
            # 执行 sql 语句
            cursor.execute(query_sql, query_value)
            results = cursor.fetchall()
            if len(results) == 0:
                value = (article_title, article_author, article_content)
                cursor.execute(sql, value)
                # 提交事务
                db.commit()
                print('--------------《%s》 insert table success-------------' % article_title)
                return True
            else:
                print('--------------《%s》 已经存在-------------' % article_title)
                return False
    
        except BaseException as e:  # 如果发生错误则回滚
            db.rollback()
            print(e)
    
        finally:  # 关闭游标连接
            cursor.close()
            # 关闭数据库连接
            db.close()
    
    
    def get_html_data():
        # get 请求
        response = requests.get('https://meiriyiwen.com/random')
    
        soup = BeautifulSoup(response.content, "html5lib")
        article = soup.find("div", id='article_show')
        article_title = article.h1.string
        print('article_title=%s' % article_title)
        article_author = article.find('p', class_="article_author").string
        print('article_author=%s' % article.find('p', class_="article_author").string)
        article_contents = article.find('div', class_="article_text").find_all('p')
        article_content = ''
        for content in article_contents:
            article_content = article_content   str(content)
            print('article_content=%s' % article_content)
    
        # 插入数据库
        insert_table(article_title, article_author, article_content)
    
    
    # 初始化 sched 模块的 scheduler 类
    # 第一个参数是一个可以返回时间戳的函数,第二个参数可以在定时未到达之前阻塞。
    schedule = sched.scheduler(time.time, time.sleep)
    
    
    # 被周期性调度触发的函数
    def print_time(inc):
        get_html_data()
        schedule.enter(inc, 0, print_time, (inc,))
    
    
    # 默认参数 60 s
    def start(inc=60):
        # enter四个参数分别为:间隔事件、优先级(用于同时间到达的两个事件同时执行时定序)、被调用触发的函数,
        # 给该触发函数的参数(tuple形式)
        schedule.enter(0, 0, print_time, (inc,))
        schedule.run()
    
    
    if __name__ == '__main__':
        start(60*5)
    

    难题:那只是对一篇小说爬虫,借使是这种小说列表,点击是小说详细的情况,这种怎么着爬虫剖判?首先肯定要获得列表,再循环叁个个分析小说详细情形插入数据库?还从未想好该如何做更加好,留给前边的课题吧。

    总体代码

    import pymysql
    import requests
    from bs4 import BeautifulSoup
    import sched
    import time
    
    
    def create_table():
        # 建立连接
        db = pymysql.connect(host='localhost',
                             user='root',
                             password='root',
                             db='python3learn')
        # 创建名为 article 数据库语句
        sql = '''create table if not exists article (
        id int NOT NULL AUTO_INCREMENT, 
        article_title text,
        article_author text,
        article_content text,
        PRIMARY KEY (`id`)
        )'''
        # 使用 cursor() 方法创建一个游标对象 cursor
        cursor = db.cursor()
        try:
            # 执行 sql 语句
            cursor.execute(sql)
            # 提交事务
            db.commit()
            print('create table success')
        except BaseException as e:  # 如果发生错误则回滚
            db.rollback()
            print(e)
    
        finally:
            # 关闭游标连接
            cursor.close()
            # 关闭数据库连接
            db.close()
    
    
    def insert_table(article_title, article_author, article_content):
        # 建立连接
        db = pymysql.connect(host='localhost',
                             user='root',
                             password='root',
                             db='python3learn',
                             charset="utf8")
        # 插入数据
        query_sql = 'select * from article where article_title=%s'
        sql = 'insert into article (article_title,article_author,article_content) values (%s, %s, %s)'
        # 使用 cursor() 方法创建一个游标对象 cursor
        cursor = db.cursor()
        try:
            query_value = (article_title,)
            # 执行 sql 语句
            cursor.execute(query_sql, query_value)
            results = cursor.fetchall()
            if len(results) == 0:
                value = (article_title, article_author, article_content)
                cursor.execute(sql, value)
                # 提交事务
                db.commit()
                print('--------------《%s》 insert table success-------------' % article_title)
                return True
            else:
                print('--------------《%s》 已经存在-------------' % article_title)
                return False
    
        except BaseException as e:  # 如果发生错误则回滚
            db.rollback()
            print(e)
    
        finally:  # 关闭游标连接
            cursor.close()
            # 关闭数据库连接
            db.close()
    
    
    def get_html_data():
        # get 请求
        response = requests.get('https://meiriyiwen.com/random')
    
        soup = BeautifulSoup(response.content, "html5lib")
        article = soup.find("div", id='article_show')
        article_title = article.h1.string
        print('article_title=%s' % article_title)
        article_author = article.find('p', class_="article_author").string
        print('article_author=%s' % article.find('p', class_="article_author").string)
        article_contents = article.find('div', class_="article_text").find_all('p')
        article_content = ''
        for content in article_contents:
            article_content = article_content   str(content)
            print('article_content=%s' % article_content)
    
        # 插入数据库
        insert_table(article_title, article_author, article_content)
    
    
    # 初始化 sched 模块的 scheduler 类
    # 第一个参数是一个可以返回时间戳的函数,第二个参数可以在定时未到达之前阻塞。
    schedule = sched.scheduler(time.time, time.sleep)
    
    
    # 被周期性调度触发的函数
    def print_time(inc):
        get_html_data()
        schedule.enter(inc, 0, print_time, (inc,))
    
    
    # 默认参数 60 s
    def start(inc=60):
        # enter四个参数分别为:间隔事件、优先级(用于同时间到达的两个事件同时执行时定序)、被调用触发的函数,
        # 给该触发函数的参数(tuple形式)
        schedule.enter(0, 0, print_time, (inc,))
        schedule.run()
    
    
    if __name__ == '__main__':
        start(60*5)
    

    题目:那只是对一篇小说爬虫,要是是这种文章列表,点击是文章实际情况,这种怎么样爬虫剖判?首先肯定要得到列表,再循环四个个解析小说详细的情况插入数据库?还尚无想好该咋做更加好,留给后边的课题吧。

    一体化代码

    import pymysql
    import requests
    from bs4 import BeautifulSoup
    import sched
    import time
    
    
    def create_table():
        # 建立连接
        db = pymysql.connect(host='localhost',
                             user='root',
                             password='root',
                             db='python3learn')
        # 创建名为 article 数据库语句
        sql = '''create table if not exists article (
        id int NOT NULL AUTO_INCREMENT, 
        article_title text,
        article_author text,
        article_content text,
        PRIMARY KEY (`id`)
        )'''
        # 使用 cursor() 方法创建一个游标对象 cursor
        cursor = db.cursor()
        try:
            # 执行 sql 语句
            cursor.execute(sql)
            # 提交事务
            db.commit()
            print('create table success')
        except BaseException as e:  # 如果发生错误则回滚
            db.rollback()
            print(e)
    
        finally:
            # 关闭游标连接
            cursor.close()
            # 关闭数据库连接
            db.close()
    
    
    def insert_table(article_title, article_author, article_content):
        # 建立连接
        db = pymysql.connect(host='localhost',
                             user='root',
                             password='root',
                             db='python3learn',
                             charset="utf8")
        # 插入数据
        query_sql = 'select * from article where article_title=%s'
        sql = 'insert into article (article_title,article_author,article_content) values (%s, %s, %s)'
        # 使用 cursor() 方法创建一个游标对象 cursor
        cursor = db.cursor()
        try:
            query_value = (article_title,)
            # 执行 sql 语句
            cursor.execute(query_sql, query_value)
            results = cursor.fetchall()
            if len(results) == 0:
                value = (article_title, article_author, article_content)
                cursor.execute(sql, value)
                # 提交事务
                db.commit()
                print('--------------《%s》 insert table success-------------' % article_title)
                return True
            else:
                print('--------------《%s》 已经存在-------------' % article_title)
                return False
    
        except BaseException as e:  # 如果发生错误则回滚
            db.rollback()
            print(e)
    
        finally:  # 关闭游标连接
            cursor.close()
            # 关闭数据库连接
            db.close()
    
    
    def get_html_data():
        # get 请求
        response = requests.get('https://meiriyiwen.com/random')
    
        soup = BeautifulSoup(response.content, "html5lib")
        article = soup.find("div", id='article_show')
        article_title = article.h1.string
        print('article_title=%s' % article_title)
        article_author = article.find('p', class_="article_author").string
        print('article_author=%s' % article.find('p', class_="article_author").string)
        article_contents = article.find('div', class_="article_text").find_all('p')
        article_content = ''
        for content in article_contents:
            article_content = article_content   str(content)
            print('article_content=%s' % article_content)
    
        # 插入数据库
        insert_table(article_title, article_author, article_content)
    
    
    # 初始化 sched 模块的 scheduler 类
    # 第一个参数是一个可以返回时间戳的函数,第二个参数可以在定时未到达之前阻塞。
    schedule = sched.scheduler(time.time, time.sleep)
    
    
    # 被周期性调度触发的函数
    def print_time(inc):
        get_html_data()
        schedule.enter(inc, 0, print_time, (inc,))
    
    
    # 默认参数 60 s
    def start(inc=60):
        # enter四个参数分别为:间隔事件、优先级(用于同时间到达的两个事件同时执行时定序)、被调用触发的函数,
        # 给该触发函数的参数(tuple形式)
        schedule.enter(0, 0, print_time, (inc,))
        schedule.run()
    
    
    if __name__ == '__main__':
        start(60*5)
    

    主题材料:那只是对一篇文章爬虫,要是是这种作品列表,点击是小说详细情形,这种如何爬虫解析?首先断定要得到列表,再循环一个个解析文章详细的情况插入数据库?还未曾想好该如何做越来越好,留给后边的课题吧。

    下载并解压

    最后

    即便如此自己学 Python 纯属业余爱好,可是也要学以至用,不然那几个知识非常的慢就记不清了,期望下篇 Python 方面包车型地铁小说。

    最后

    固然本人学 Python 纯属业余爱好,可是也要学以实用,不然这个知识相当慢就记不清了,期望下篇 Python 方面的作品。

    最后

    尽管本身学 Python 纯属业余爱好,不过也要学以实用,不然这几个知识相当慢就记不清了,期望下篇 Python 方面包车型大巴小说。

    新葡亰496net 5

    参考

    快捷上手 — Requests 2.18.1 文书档案

    爬虫入门连串(二):崇高的HTTP库requests

    Beautiful Soup 4.2.0 文档

    爬虫入门种类(四):HTML文本剖判库BeautifulSoup

    参考

    即刻上手 — Requests 2.18.1 文书档案

    爬虫入门类别(二):优雅的HTTP库requests

    Beautiful Soup 4.2.0 文档

    爬虫入门种类(四):HTML文本深入分析库BeautifulSoup

    参考

    十分的快上手 — Requests 2.18.1 文档

    爬虫入门体系(二):文雅的HTTP库requests

    Beautiful Soup 4.2.0 文档

    爬虫入门类别(四):HTML文本剖判库BeautifulSoup

    最重视的是 这些库有完美的汉语资料 ,讨厌蝌蚪文的能够放心的参照

    您只要和自家同一采纳pycharm来编排,加入第三方库的步调如下:

    新葡亰496net 6

    新葡亰496net 7

    新葡亰496net 8

    设置好requests第三方库后,开头测量检验

    起来获得HTML

    新葡亰496net 9

    新葡亰496net 10

    怎样,欣喜不欢畅,轻松不轻松,使用其余语言,不恐怕用这么简单的话语就获取html的音讯。

    解析HTML

    利用request获取了网页源码,下一步正是何许解析了,你只要用过C 等语言,你会意识很难找到中意的网页深入分析库,但python在那上面却很专长。

    或许用三个第三方库 Beautiful Soup

    那是个怎么样库呢?

    直译为:美貌的汤?

    难道说是将网页作为美味的汤,从那汤里逐步品尝在那之中滋味,抽丝剥茧的剖释汤的组合成分、汤的味道? 老外的思绪,真难猜,先不管那个了。

    简易,就是用来分析HTML或XML,从当中提取有用数码的库。

    何况也可以有强劲的国语援助

    新葡亰496net 11

    新葡亰496net 12

    先是深入分析,分析哪些链接

    新葡亰496net 13

    那应该是按连串来分的,大家在源码中找到这一项

    新葡亰496net 14

    为此有乱码,很或然是与自个儿Computer未有保加利亚语字体有关也说不定编码不科学,先不管它了,最近对深入分析无影响,能够看出,那些项目是身处class=menu的div下了,具体的正是以此DIV下的

    1、好了,首先第一步,获得这几个DIV

    新葡亰496net 15

    如此我们就赢得了这些DIV的内容,上面再持续分析那么些DIV

    2、解析DIV

    分析那些DIV,还要以那个DIV内容为参数,构造一个BeautifulSoup(以下简称为BS :) 注意不假使瞧不起的意味)对象,因为全篇唯有叁个menu 类型的DIV,所以具备系列都保留在位置剖判的div_menu[0]中了,将以此目的强制调换为字符串类型做BS的参数

    新葡亰496net 16

    看源码可以开掘,链接都以站内链接

    新葡亰496net 17

    当今注意了,小编要把全体的链接提抽取来

    新葡亰496net 18

    出口全部的链接

    新葡亰496net 19

    新葡亰496net 20

    对应HTML源码

    新葡亰496net 21

    能够见见,第三个a标签,是平素不href属性的,所以,会输出None,别的a标签,平常输出

    因为这一个都以站内链接,

    大家先定义三个变量,表示该站的域名

    新葡亰496net 22

    又因为,有的链接也许是none,所以需求决断下是不是留存href属性,上面是出口全部链接的代码

    新葡亰496net 23

    出口的链接如下:

    新葡亰496net 24

    那般,大家就不易的获得了这一个体系对应的网站了。

    下一步工作,下一节再说,今后还有些事,改天聊

    第二篇

    书接上回,上文书说道,我们曾经获得了独具品种的链接。

    上面作者将这几个链接保存到一个一时文件中,其实不保留也得以,但伊始学python,借那个空子,也练练如何创制目录,保存文件。

    将上文获得的主链接保存到文件中

    概念二个函数,搞不懂,为何python不用C语言那样的定义函数,也不用C语言的那样的轮回和跳转,不日常用惯了其他语言的人,很难一下子转过来。

    那是写的将链表中的链接,保存到文件中去,

    新葡亰496net 25

    写到五个文书中,有一点乱,由此,笔者又新建了二个py文件,用以编写常用的函数,取名字为common.py

    下载获得的主链接

    因为本身把具备的常用函数,写到common.py中了,所以要导入这么些文件

    新葡亰496net 26

    主程序中,要用到那一个common中自定义的保存函数

    新葡亰496net 27

    新葡亰496net 28

    透过测量试验,能够将列表内容,写入文件了。

    现在,笔者又看了看,以为很乱,笔者想单独的确立二个目录tmp,用来保存有时文件

    目录文件有关的,要引进os

    新葡亰496net 29

    新葡亰496net 30

    不管怎么说,使用下边代码,已经把具备的链接都保留在有时文件中。

    新葡亰496net 31

    新葡亰496net 32

    第三篇

    本节思路

    理一理逻辑,先不去怀恋细节,逻辑理清了,依据那个逻辑去达成细节就好了。笔者也是首先次选用python,也绝非时间看文书档案,因为想获得图片素材,直接就想爬一个网址。

    咱俩前边,已经解析了首页,获得了图片体系对应的链接,并将这一个链接保存在了当半夏件中。

    下面,

    首先步,大家会下载主链接网页,保存在地头文件中。

    其次步,解析主链接,获得相应的具有分页网站

    其三步,将主链接及分页链接,统统下载下来

    下载下来后,后续我们会分析网页,获得图片地址,下载图片,本节重要成就前三步就可以。

    下载主链接网页,保存在地面

    上文,大家将首页中主链接保存了四起,

    新葡亰496net 33

    上面,为了裁撤每一次下载网页的劳动,大家三回性下载那一个网页,并保留在地面中

    主文件中,就一句话,因为细节都封装在另四个文书中了,大家根本思虑逻辑,细节能够由此查资料去落到实处,去调治。

    新葡亰496net 34

    那是common.py中写的下载函数

    新葡亰496net 35

    其间调用了单个网站下载函数downHtml

    新葡亰496net 36

    因而上述代码,已经将链接下载到了本地。

    赢得分页链接

    上文提到,剖析了首页,将装有的主分类链接保存到了本土文件中。

    咱俩再张开贰个主链接看看

    新葡亰496net 37

    各类主链接,都有相应的分页链接

    大家上面的指标,便是赢得主链接对应的有着分页链接

    剖析网页源码

    新葡亰496net 38

    分页链接保存在class=link2的 div下

    新葡亰496net 39

    里面,获得分页链接的代码如下:

    新葡亰496net 40

    将具有的链接对应的网页,下载到当地

    新葡亰496net 41

    新葡亰496net 42

    那是下载后的地方文件

    新葡亰496net 43

    第四篇

    新葡亰496net:爬虫实战。本节指标:深入分析下载到本地的公文,得到图片链接

    新葡亰496net 44

    有着相关的网站,都下载到本地了,上面大家各类分析,得到图片链接,然后将图片链接保存起来。

    由上图,可看到

    新葡亰496net 45

    是一组,保存着背景图片,那大家深入分析的时候,将这一组图片,单独的放在贰个文件夹background中

    新葡亰496net 46

    是另一组,分析的时候,单独的放在三个文书夹中

    先是步,我们遍历目录,获得全体的文件路线

    为此,小编写了个函数

    #目录下的文书和文书夹def GetAllSubFile(dir,list):

    #目录下的公文def GetAllSubFile(dir,list,ext):

    #目录下的文本夹def GetAllSubDirs(dir,list):

    新葡亰496net 47

    调用

    txtFileList=[]common.GetAllSubFile(tmpDir "htmls",txtFileList,"txt")

    收获目录下的txt文件路线,保存在txtFileList中。

    其次步 深入分析文件,获得IMG路线

    1、 首先,针对分歧分组,创设相应的子目录

    新葡亰496net 48

    是一组,保存着背景图片,那大家解析的时候,将这一组图片,单独的放在二个文书夹background中

    咱俩将左边的数字去掉,剩下的字符串作为这一组的档案的次序

    新葡亰496net 49

    新葡亰496net 50

    浅析源码

    新葡亰496net 51

    图像链接保存在class=subcontents的div下,

    为此小编写了个函数

    新葡亰496net 52

    新葡亰496net 53

    调用

    common.FindAllImg(txtFile,"div","subcontents","data-layzr")

    获取文件中,全部图片的链接列表,、

    新葡亰496net 54

    新葡亰496net 55

    这一历程的代码如下:

    新葡亰496net 56

    第五篇

    下载图片链接

    本节的主要职责是下载文件中得到的图片链接

    新葡亰496net 57

    为此笔者写了个函数

    def downImg(httpPath,localPath):

    实地度量中,思量到某些链接不设有,有些链接超时,有些链接别的错误,所以一回下载不了,数十次尝试。

    再者动用request.urlretrieve(httpPath,local帕特h) 直接下载时,出现出现10060错误,于是利用request.urlopen(httpPath,timeout=60),然后以读的措施打开下载。

    新葡亰496net 58

    自身那的目录结构是这么的

    新葡亰496net 59

    新葡亰496net 60

    第一步,读取全部的子文件夹

    其次步,读取子文件夹下的img.txt

    其三步,下载img.txt中的链接

    为此,我又写了下边包车型的士函数

    新葡亰496net 61

    新葡亰496net 62

    DownThumbnail 是下载缩略图,因为这几个网址上,前段时间或的的这么些链接对应的是缩略图。

    运作后,就能够意识,可以下载了

    新葡亰496net 63

    当下是单线程形式下载的缩略图

    下一节牵线下二十八线程格局,下载高清图

    第六篇

    多线程方式下载

    新葡亰496net 64

    新葡亰496net 65

    使用:

    新葡亰496net 66

    下载下的图样,

    二十四线程下载速度是比单线程要快一些

    新葡亰496net 67

    对您具有启发的话,招待扫下红包奥

    新葡亰496net 68

    本文由新葡亰496net发布于奥门新萄京娱乐场,转载请注明出处:新葡亰496net:爬虫实战

    关键词:

上一篇:python与redis交互

下一篇:没有了