潭州课堂25班：Ph201805201 爬虫基础 第六课 选择器 (课堂笔记)

最新推荐文章于 2022-05-11 19:46:18 发布
最新推荐文章于 2022-05-11 19:46:18 发布
阅读量145 收藏 3
点赞数 1
文章标签： python 爬虫 c/c++
原文链接：http://www.cnblogs.com/gdwz922/p/9582285.html
版权

HTML解析库BeautifulSoup4

BeautifulSoup 是一个可以从HTML或XML文件中提取数据的Python库，它的使用方式相对于正则来说更加的简单方便，常常能够节省我们大量的时间。

BeautifulSoup也是有官方中文文档的：https://www.crummy.com/software/BeautifulSoup/bs4/doc/index.zh.html

安装

BeautifulSoup的安装也是非常方便的，pip安装即可。

pip install beautifulsoup4

简单例子

以下是一段HTML代码，作为例子被多次用到，这是 爱丽丝梦游仙境 中的一段内容。

html_doc = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p class="title"><b>The Dormouse's story</b></p>

<p class="story">Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1">Elsie</a>,
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
and they lived at the bottom of a well.</p>

<p class="story">...</p>
"""

我们获取的网页数据通常会像上面这样是完全的字符串格式，所以我们首先需要使用BeautifulSoup来解析这段字符串。然后会获得一个BeautifulSoup对象，通过这个对象我们就可以进行一系列操作了。

In [1]: from bs4 import BeautifulSoup

In [2]: soup = BeautifulSoup(html_doc)

In [3]: soup.title Out[3]: <title>The Dormouse's story</title> In [4]: soup.title.name Out[4]: 'title' In [5]: soup.title.string Out[5]: "The Dormouse's story" In [6]: soup.title.parent.name Out[6]: 'head' In [7]: soup.p Out[7]: <p class="title"><b>The Dormouse's story</b></p> In [8]: soup.p['class'] Out[8]: ['title'] In [9]: soup.a Out[9]: <a class="sister" href="http://example.com/elsie" id="link1">Elsie</a> In [10]: soup.find_all('a') Out[10]: [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>, <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>, <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>] In [11]: soup.find(id="link3") Out[11]: <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>

可以看到，相对于正则来说，操作简单了不止一个量级。

使用

指定解析器

在上面的例子中，我们可以看到在查找数据之前，是有一个解析网页的过程的：

soup = BeautifulSoup(html_doc)

BeautifulSoup会自动的在系统中选定一个可用的解析器，以下是主要的几种解析器：

解析器使用方法优势劣势
Python标准库BeautifulSoup(markup, "html.parser")Python的内置标准库执行速度适中文档容错能力强Python 2.7.3 or 3.2.2)前 的版本中文档容错能力差
lxml HTML 解析器BeautifulSoup(markup, "lxml")速度快文档容错能力强需要安装C语言库
lxml XML 解析器BeautifulSoup(markup, ["lxml", "xml"])``BeautifulSoup(markup, "xml")速度快唯一支持XML的解析器需要安装C语言库
html5libBeautifulSoup(markup, "html5lib")最好的容错性以浏览器的方式解析文档生成HTML5格式的文档速度慢不依赖外部扩展

由于这个解析的过程在大规模的爬取中是会影响到整个爬虫系统的速度的，所以推荐使用的是lxml，速度会快很多，而lxml需要单独安装：

pip install lxml

安装成功后，在解析网页的时候，指定为lxml即可。

soup = BeautifulSoup(html_doc, 'lxml')

提示：如果一段HTML或XML文档格式不正确的话,那么在不同的解析器中返回的结果可能是不一样的，所以要指定某一个解析器。

节点对象

BeautifulSoup将复杂HTML文档转换成一个复杂的树形结构，每个节点都是Python对象，所有对象可以归纳为4种：Tag，NavigableString，BeautifulSoup，Comment。

tag

tag就是标签的意思，tag还有许多的方法和属性。

>>> soup = BeautifulSoup('<b class="boldest">Extremely bold</b>')
>>> tag = soup.b
>>> type(tag)
<class 'bs4.element.Tag'>

  • name

    每一个tag对象都有name属性，为标签的名字。

    >>> tag.name
'b'

  • Attributes

    在HTML中，tag可能有多个属性，所以tag属性的取值跟字典相同。

    >>> tag['class']
'boldest'

    如果某个tag属性有多个值，那么返回的则是列表格式。

    >>> soup = BeautifulSoup('<p class="body strikeout"></p>')
>>> soup.p['class']
["body", "strikeout"]

  • get_text()

    通过get_text()方法我们可以获取某个tag下所有的文本内容。

    In [1]: soup.body.get_text()
Out[1]: "The Dormouse's story\nOnce upon a time there were three little sisters; and their names were\nElsie,\nLacie and\nTillie;\nand they lived at the bottom of a well.\n...\n"

NavigableString的意思是可以遍历的字符串，一般被标签包裹在其中的的文本就是NavigableString格式。

In [1]: soup = BeautifulSoup('<p>No longer bold</p>')

In [2]: soup.p.string
Out[2]: 'No longer bold' In [3]: type(soup.p.string) Out[3]: bs4.element.NavigableString
BeautifulSoup

BeautifulSoup对象就是解析网页获得的对象。

Comment

Comment指的是在网页中的注释以及特殊字符串。

Tag与遍历文档树

tag对象可以说是BeautifulSoup中最为重要的对象，通过BeautifulSoup来提取数据基本都围绕着这个对象来进行操作。

首先，一个节点中是可以包含多个子节点和多个字符串的。例如html节点中包含着head和body节点。所以BeautifulSoup就可以将一个HTML的网页用这样一层层嵌套的节点来进行表示。

以上方的爱丽丝梦游仙境为例：

contents和children

通过contents可以获取某个节点所有的子节点，包括里面的NavigableString对象。获取的子节点是列表格式。

In [1]: soup.head.contents
Out[1]: [<title>The Dormouse's story</title>]

而通过children同样的是获取某个节点的所有子节点，但是返回的是一个迭代器，这种方式会比列表格式更加的节省内存。

In [1]: tags = soup.head.children

In [2]: tags
Out[2]: <list_iterator at 0x110f76940>

In [3]: for tag in tags: print(tag) <title>The Dormouse's story</title>
descendants

上面的contents和children获取的是某个节点的直接子节点，而无法获得子孙节点。通过descendants可以获得所有子孙节点，返回的结果跟children一样，需要迭代或者转类型使用。

In [1]: len(list(soup.body.descendants))
Out[1]: 19

In [2]: len(list(soup.body.children))
Out[2]: 6
string和strings

我们常常会遇到需要获取某个节点中的文本值的情况，如果这个节点中只有一个字符串，那么使用string可以正常将其取出。

In [1]: soup.title.string
Out[1]: "The Dormouse's story"

而如果这个节点中有多个字符串的时候，BeautifulSoup就无法确定要取出哪个字符串了，这时候需要使用strings。

In [1]: list(soup.body.strings)
Out[1]:
["The Dormouse's story",
 '\n',
 'Once upon a time there were three little sisters; and their names were\n', 'Elsie', ',\n', 'Lacie', ' and\n', 'Tillie', ';\nand they lived at the bottom of a well.', '\n', '...', '\n']

而使用stripped_strings可以将全是空白的行去掉。

In [1]: list(soup.body.stripped_strings)
Out[1]:
["The Dormouse's story",
 'Once upon a time there were three little sisters; and their names were',
 'Elsie', ',', 'Lacie', 'and', 'Tillie', ';\nand they lived at the bottom of a well.', '...']
父节点parent和parents

有时我们也需要去获取某个节点的父节点，也就是包裹着当前节点的节点。

In [1]: soup.b.parent
Out[1]: <p class="title"><b>The Dormouse's story</b></p>

而使用parents则可以获得当前节点递归到顶层的所有父辈元素。

In [1]: [i.name for i in soup.b.parents]
Out[1]: ['p', 'body', 'html', '[document]']
兄弟节点

兄弟节点指的就是父节点相同的节点。

  • next_sibling 和 previous_sibling

    兄弟节点选取的方法与当前节点的位置有关，next_sibling获取的是当前节点的下一个兄弟节点，previous_sibling获取的是当前节点的上一个兄弟节点。

    所以，兄弟节点中排第一个的节点是没有previous_sibling的，最后一个节点是没有next_sibling的。

    In [51]: soup.head.next_sibling
Out[51]: '\n'

In [52]: soup.head.previos_sibling

In [59]: soup.body.previous_sibling Out[59]: '\n'

  • next_siblings 和 previous_siblings

    相对应的，next_siblings获取的是下方所有的兄弟节点，previous_siblings获取的上方所有的兄弟节点。

    In [47]: [i.name for i in soup.head.next_siblings]
Out[47]: [None, 'body'] In [48]: [i.name for i in soup.body.next_siblings] Out[48]: [] In [49]: [i.name for i in soup.body.previous_siblings] Out[49]: [None, 'head']

find_all()

上方这种直接通过属性来进行访问属性的方法，很多时候只能适用于比较简单的一些场景，所以BeautifulSoup还提供了搜索整个文档树的方法find_all()。

需要注意的是，find_all()方法基本所有节点对象都能调用。

通过name搜索

就像以下演示的，find_all()可以直接查找出整个文档树中所有的b标签，并返回列表。

>>> soup.find_all('b')
[<b>The Dormouse's story</b>]

而如果传入的是一个列表，则会与列表中任意一个元素进行匹配。可以看到，搜索的结果包含了所有的a标签和b标签。

>>> soup.find_all(["a", "b"])
[<b>The Dormouse's story</b>,
 <a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
 <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
 <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]
通过属性搜索

我们在搜索的时候一般只有标签名是不够的，因为可能同名的标签很多，那么这时候我们就要通过标签的属性来进行搜索。

这时候我们可以通过传递给attrs一个字典参数来搜索属性。

In [1]: soup.find_all(attrs={'class': 'sister'})
Out[1]:
[<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>, <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>, <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]

可以看到找出了所有class属性为sister的标签。

通过文本搜索

在find_all()方法中，还可以根据文本内容来进行搜索。

>>> soup.find_all(text="Elsie")
[u'Elsie']

>>> soup.find_all(text=["Tillie", "Elsie", "Lacie"]) [u'Elsie', u'Lacie', u'Tillie']

可见找到的都是字符串对象，如果想要找到包含某个文本的tag，加上tag名即可。

>>> soup.find_all("a", text="Elsie")
[<a href="http://example.com/elsie" class="sister" id="link1">Elsie</a>]
限制查找范围为子节点

find_all()方法会默认的去所有的子孙节点中搜索，而如果将recursive参数设置为False，则可以将搜索范围限制在直接子节点中。

>>> soup.html.find_all("title")
[<title>The Dormouse's story</title>]

>>> soup.html.find_all("title", recursive=False)
[]
通过正则表达式来筛选查找结果

在BeautifulSoup中，也是可以与re模块进行相互配合的，将re.compile编译的对象传入find_all()方法，即可通过正则来进行搜索。

In [1]: import re

In [2]: tags = soup.find_all(re.compile("^b"))

In [3]: [i.name for i in tags] Out[3]: ['body', 'b']

可以看到，找到了标签名是以'b'开头的两个标签。

同样的，也能够以正则来筛选tag的属性。

In [1]: soup.find_all(attrs={'class': re.compile("si")})
Out[1]:
[<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>, <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>, <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]

CSS选择器

在BeautifulSoup中，同样也支持使用CSS选择器来进行搜索。使用select()，在其中传入字符串参数，就可以使用CSS选择器的语法来找到tag。

>>> soup.select("title")
[<title>The Dormouse's story</title>]

>>> soup.select("p > a")
[<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
 <a class="sister" href="http://example.com/lacie"  id="link2">Lacie</a>,
 <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]

 

beautifulSoupbs4的使用
# -*- coding: utf-8 -*-
# 斌彬电脑
# @Time : 2018/9/4 0004 4:43
from bs4 import BeautifulSoup
import lxml     #pin install lxml   安装 解释器


#HTML代码
html = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p class="title"><b>The Dormouse's story</b></p>

<p class="story">Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1">Elsie</a>,
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
and they lived at the bottom of a well.</p>

<p class="story">...</p>
"""

# soup = BeautifulSoup(html)
soup = BeautifulSoup(html,'lxml')       #  指定解释器

# print(soup)         #  格式化后的 html
# print(soup.title)  #  <title>The Dormouse's story</title>
# print(soup.title.name)      #   标签名  title
# print(soup.title.string)      #  标签内的内容  The Dormouse's story
# print(soup.a.parent.name)      #  a 标签的交级名字  p
# for i in (soup.title.parent.name) :     #   标签的交级名字
#     print(i)

# print(soup.a)       #  得到整个标签 <a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>
# print(soup.a['href'])       #  http://example.com/elsie
# print(soup.a['class'])       #  ['sister']

# tag = soup.a
# print(type(tag))        #  <class 'bs4.element.Tag'>    标签
# print(tag.name)         #  a            标签 名
# print(tag['class'])     #  ['sister']    属性值

# print(soup.get_text())   #  获取文本数据
# print(soup.body.get_text())   #  获取文本数据
# print(soup.b.string)   #  获取文本数据
# print(soup.b.get_text())   #  获取文本数据

# print(soup.b.strings)   #  得到对象 <generator object _all_strings at 0x00000226E13A11A8>

# for i in (soup.head.children):      #  所有子节点
#     print(i)

# s1 = soup.find_all('a')         #  所有的 a 标签
# for i in s1:
#     print(i)

# print(soup.find_all(class_='sister'))   #   按类查找所有的标签
# print(soup.find_all(id='link3'))   #   按 id 查找标签

# print(soup.find_all(text=['Tillie', 'Elsie']))   #   通过文本查找
# print(soup.find_all(text="Elsie"))   #   通过文本查找
# print(soup.find_all('a', text="Elsie"))   #   指定查看


# import re       #  与正则一起使用
# for i in ( soup.find_all(re.compile("^b")) ):       #  以 b 开头的匹配
#     # print(i)
#     print(i.name)


#  css 选择器
# print(soup.select('title'))   # 查找标签 [<title>The Dormouse's story</title>]
# print(soup.select('a'))   #
# print(soup.select('.sister'))   #  通过类名查找
# print(soup.select('#link2'))   #  通过 id 查找
# print(soup.select('p  a'))   #     p 标签下所有的 a 标签
# print(soup.select('p  #link1'))   #     p 标签下 的 id 为
# print(soup.select("a[class='sister']"))   #     a 标签下类名为

con = soup.select('title')[0].get_text()        # 获取文本
print(con)

　　

 

 

更简单高效的HTML数据提取-Xpath

 

XPath 是一门在 XML 文档中查找信息的语言。XPath 用于在 XML 文档中通过元素和属性进行导航。

 

相比于BeautifulSoup，Xpath在提取数据时会更加的方便。

 

安装

 

在Python中很多库都有提供Xpath的功能，但是最基本的还是lxml这个库，效率最高。在之前BeautifulSoup章节中我们也介绍到了lxml是如何安装的。

pip install lxml
 

语法

 

XPath 使用路径表达式在 XML 文档中选取节点。节点是通过沿着路径或者 step 来选取的。

 

我们将用以下的HTML文档来进行演示：

html_doc = '''<html>

<head></head> <body> <bookstore> <book category="COOKING"> <title lang="en">Everyday Italian</title> <author>Giada De Laurentiis</author> <year>2005</year> <price>30.00</price> </book> <book category="CHILDREN"> <title lang="en">Harry Potter</title> <author>J K. Rowling</author> <year>2005</year> <price>29.99</price> </book> <book category="WEB"> <title lang="en">XQuery Kick Start</title> <author>James McGovern</author> <author>Per Bothner</author> <author>Kurt Cagle</author> <author>James Linn</author> <author>Vaidyanathan Nagarajan</author> <year>2003</year> <price>49.99</price> </book> <book category="WEB"> <title lang="en">Learning XML</title> <author>Erik T. Ray</author> <year>2003</year> <price>39.95</price> </book> </bookstore> </body> </html>''' 
from lxml import etree

page = etree.HTML(html_doc)
 

路径查找

表达式描述
nodename选取此节点的子节点。
/从根节点选取。
//从匹配选择的当前节点选择文档中的节点，而不考虑它们的位置。
.选取当前节点。
..选取当前节点的父节点。
@选取属性。

  • 查找当前节点的子节点

    In [1]: page.xpath('head')
Out[1]: [<Element head at 0x111c74c48>]

  • 从根节点进行查找

    In [2]: page.xpath('/html')
Out[2]: [<Element html at 0x11208be88>]

  • 从整个文档中所有节点查找

    In [3]: page.xpath('//book')
Out[3]:
[<Element book at 0x1128c02c8>,
 <Element book at 0x111c74108>, <Element book at 0x111fd2288>, <Element book at 0x1128da348>]

  • 选取当前节点的父节点

    In [4]: page.xpath('//book')[0].xpath('..')
Out[4]: [<Element bookstore at 0x1128c0ac8>]

  • 选取属性

    In [5]: page.xpath('//book')[0].xpath('@category')
Out[5]: ['COOKING']
 

节点查找

表达式结果
nodename[1]选取第一个元素。
nodename[last()]选取最后一个元素。
nodename[last()-1]选取倒数第二个元素。
nodename[position()<3]选取前两个子元素。
nodename[@lang]选取拥有名为 lang 的属性的元素。
nodename[@lang='eng']选取拥有lang属性，且值为 eng 的元素。

  • 选取第二个book元素

    In [1]: page.xpath('//book[2]/@category')
Out[1]: ['CHILDREN']

  • 选取倒数第三个book元素

    In [2]: page.xpath('//book[last()-2]/@category')
Out[2]: ['CHILDREN']

  • 选取第二个元素开始的所有元素

    In [3]: page.xpath('//book[position() > 1]/@category')
Out[3]: ['CHILDREN', 'WEB', 'WEB']

  • 选取category属性为WEB的的元素

    In [4]: page.xpath('//book[@category="WEB"]/@category')
Out[4]: ['WEB', 'WEB']
 

未知节点

通配符描述
*匹配任何元素节点。
@*匹配任何属性节点。

  • 匹配第一个book元素下的所有元素

    In [1]: page.xpath('//book[1]/*')
Out[1]:
[<Element title at 0x111f76788>,
 <Element author at 0x111f76188>, <Element year at 0x1128c1a88>, <Element price at 0x1128c1cc8>]
 

获取节点中的文本

  • 用text()获取某个节点下的文本

    In [1]: page.xpath('//book[1]/author/text()')
Out[1]: ['Giada De Laurentiis']

    如果这个节点下有多个文本，则只能取到一段。

  • 用string()获取某个节点下所有的文本

    In [2]: page.xpath('string(//book[1])')
Out[2]: '\n            Everyday Italian\n            Giada De Laurentiis\n            2005\n            30.00\n        '
 

选取多个路径

 

通过在路径表达式中使用“|”运算符，您可以选取若干个路径。

In [1]: page.xpath('//book[1]/title/text() | //book[1]/author/text()')
Out[1]: ['Everyday Italian', 'Giada De Laurentiis']

 

 

 

 xpath 使用

# -*- coding: utf-8 -*-
# 斌彬电脑
# @Time : 2018/9/4 0004 7:07

from lxml import etree
#HTML代码
html1= '''<html>

<head></head>

<body>
    <bookstore>

        <book category="COOKING">
            <title lang="en">Everyday Italian</title>
            <author>Giada De Laurentiis</author>
            <year>2005</year>
            <price>30.00</price>
        </book>

        <book category="CHILDREN">
            <title lang="en">Harry Potter</title>
            <author>J K. Rowling</author>
            <year>2005</year>
            <price>29.99</price>
        </book>

        <book category="WEB">
            <title lang="en">XQuery Kick Start</title>
            <author>James McGovern</author>
            <author>Per Bothner</author>
            <author>Kurt Cagle</author>
            <author>James Linn</author>
            <author>Vaidyanathan Nagarajan</author>
            <year>2003</year>
            <price>49.99</price>
        </book>

        <book category="WEB">
            <title lang="en">Learning XML</title>
            <author>Erik T. Ray</author>
            <year>2003</year>
            <price>39.95</price>
        </book>

    </bookstore>
</body>

</html>'''
html = etree.HTML(html1)
# print(html)
# print(html.xpath('/html/body/bookstore/book')  )      #  从根目录开始
# print(html.xpath('/html/body/bookstore/book/title/text()')[2]  )    #  title 的文本值
# print(html.xpath('/html/body/bookstore/book/title/@lang')  )    #  title 属性值


# print(html.xpath('//title/@lang')  )    #  从任意位置找到 title

#查找节点
# conn = html.xpath('//book')[0]
# print(conn.xpath('./price'))            # 当前节点 下的 price
# print(conn.xpath('./price/text()'))            # 当前节点 下的 price
# print(conn.xpath('./price/..'))            #  price 的父级标签 [<Element book at 0x2c67fc8>]
# print(html.xpath('//book[@category="WEB"]'))    #  按属性查找 节点
# print(html.xpath('//book[@category="WEB"]/year/text()'))    #  按属性查找 节点

# 这里下标不是从 0 开始，是从 1 开始的
# print(html.xpath('//book[1]'))
# print(html.xpath('//book[2]'))
# print(html.xpath('//book[3]'))
# print(html.xpath('//book[4]'))
# print(html.xpath('//book[last()]'))     #  最后一个
# print(html.xpath('//book[last()-1]'))     #  倒数第二个
# print(html.xpath('//book[last()-2]'))     #  倒数第三个
# print(html.xpath('//book[last()-3]/author/text()'))     #  倒数第4个

# print(html.xpath('//*'))     #  所有标签
# print(html.xpath('//book/*/text()'))    # book标签下的所有文本 返回列表
# print(html.xpath('string(//book)'))    # book标签下的所有文本  返回 str
# print(html.xpath('string(//book[1])'))    # book标签下的所有文本  返回 str
# print(html.xpath('string(//book[4])'))    # book标签下的所有文本  返回 str

# print(html.xpath('//book/title/text() | //book/author/text()' ))    # 选择多个路径
# print(html.xpath('//book[1]/title/text() | //book[1]/author/text()' ))    # 选择多个路径

　　

 

　　

 

转载于:https://www.cnblogs.com/gdwz922/p/9582285.html

weixin_30344795
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
BeautifulSoup(HTMLXML解析器)v4.3.2官方安装版
07-27
Beautiful Soup是一款可以用Python写的一个HTML/XML的解析器工具，如果你需要在一些网站抓取数据，Beautiful Soup可以很好的处理不规范标记并生成剖析树，大大节省工程时间。需要此款工具的朋友们可以前来在使用。 软件特色 1.Beautiful Soup提供了一些简单的方法和Python术语，用于检索和修改语法树：一个用于解析文档并提取相关信息的工具包。这样你写一个
潭州教育：3d Max中三种对齐工具.pdf
10-29
在3D建模软件3ds Max中，对齐工具是非常基础但至关重要的功能，它们能够帮助用户精确地调整和定位模型元素。以下是关于3ds Max中三种主要对齐工具的详细说明： 一、锁轴缩放 锁轴缩放是一种通过调整对象大小来实现...
html开源库,开源Html分析器解析库对比
weixin_31626765的博客
06-05 366
几乎所有已知的HTML解析器都是实现W3C DOM API(JAXP的API一部分，用于XML处理)，并给你一个org.w3c.dom.Document，便于通过JAXP API直接使用。主要的区别通常是是否能分析有问题的html。大多数解析器是在一定程度上都宽容非结构非完整的HTML，如JTidy，NekoHTML，TagSoup和HtmlCleaner。您通常可以使用这种类型的HTML解析器对...
好用的HTML解析库BeautifulSoup
山海皆可平z
07-30 565
好用的HTML解析库BeautifulSoup
潭州课堂25班：Ph201805201 爬虫高级 第十一课 Scrapy-redis分布 项目实战 (课堂笔
weixin_30800807的博客
10-19 190
转载于:https://www.cnblogs.com/gdwz922/p/9816532.html
Python中BeautifulSoup的基础用法--附实例
you4561512的博客
06-12 1458
文章目录前言一、requests库的简单使用二、BeautifulSoup 的使用(1) 首先通过requests获取网页源码(2)通过BeautifulSoup创造一个实例(3) BeautifulSoup提供的一些方法(4)使用BeautifulSoup提供的方法处理soup，获取豆瓣排名前4的小说 前言 安装好了BeautifulSoup库 一、requests库的简单使用 通过reques...
潭州软件学院 - Java VIP系统基础学习课程表.docx
11-23
潭州软件学院的Java VIP系统基础学习课程是针对想要深入理解和掌握Java编程技术的学员设计的。本课程全面覆盖了Java的基础知识，旨在帮助学员建立起扎实的编程基础，为后续的高级开发技能学习打下坚实的基础。以下是...
潭州软件学院 - Java VIP系统基础学习课程表.pdf
11-23
潭州软件学院的Java VIP系统基础学习课程涵盖了Java编程的核心知识点，旨在帮助学员全面掌握Java编程基础和进阶技能。课程分为十章，每章都包含详细的理论讲解和实践项目，确保学员能够深入理解和应用所学知识。 第...
潭州软件学院-javavip系统基础学习课程表.pdf
11-23
潭州软件学院的Java VIP系统基础学习课程涵盖了Java编程的核心概念和重要技术，旨在帮助学员扎实地掌握Java语言基础和面向对象编程。课程分为十个章节，深入浅出地讲解了从语言基础到高级特性的各个知识点。 首先，...
潭州软件学院-javavip系统基础学习课程表.docx
11-23
潭州软件学院的Java VIP系统基础学习课程涵盖了Java编程的基础到进阶知识，旨在帮助学员全面掌握这门广泛使用的计算机语言。以下是对课程内容的详细解释： 首先，课程从计算机语言的发展史开始，讲解Java的历史及其...
python美味的汤-BeautifulSoup介绍
qq_44176343的博客
05-12 1016
1.BeautifulSoup库的理解： BeautifulSoup对应一个HTML/XML文档的全部内容； 2.BeautifulSoup库解析器： bs4的HTML解析器： 使用方法：BeautifulSoup(mk,‘html.parser’); 条件：安装bs4库 lxml的HTML解析器: 使用方法：BeautifulSoup(mk,‘lxml’); 条件：pip install lmxl lxml的XML解析器： 使用方法: BeautifulSoup(mk,‘xml’) 条件：pip i
爬虫必备Beautiful Soup包使用详解
算法channel
05-11 3212
使用Beautiful Soup解析数据Beautiful Soup是一个用于从HTML和XML文件中提取数据的Python模块。Beautiful Soup提供一些简单的函数用来处理导航、搜索、修改分析树等功能。Beautiful Soup 模块中的查找提取功能非常强大，而且非常便捷。Beautiful Soup自动输入文档转换为Unicode编码，输出文档转换为UTF...
Python爬虫(4):Beautiful Soup的常用方法
hzp666的博客
03-21 2644
Python爬虫(4):Beautiful Soup的常用方法Requests库的用法大家肯定已经熟练掌握了，但是当我们使用Requests获取到网页的 HTML 代码信息后，我们要怎样才能抓取到我们想要的信息呢？我相信大家肯定尝试过很多办法，比如字符串的 find 方法，还有高级点的正则表达式。虽然正则可以匹配到我们需要的信息，但是我相信大家在匹配某个字符串一次一次尝试着正则匹配的规则时，一定很...
Beatifulsoup 中soup的get_text()方法
aichenjiateng的博客
12-27 3515
baseurl = 'http://www.qiushibaike.com/hot/page/2?s=4837277' headers = {'User-Agent':'Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.1.6) Gecko/20091201 Firefox/3.5.6'} req = urllib2.Request(
Python网络爬虫与信息提取第二周测验答案
Divine0的博客
04-08 6740
测验2: Python网络爬虫之提取 (第2周) 1. 下面哪个Python库不能用于提取网页信息？‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬ A re B Beautiful Soup C lxml D requests 正确答案 D req...
Beautiful Soup的用法
lilong117194的博客
07-20 670
如果一个正则匹配稍有差池，那可能程序就处在永久的循环之中，而且有的小伙伴们也对写正则表 达式的写法用得不熟练，没关系，我们还有一个更强大的工具，叫Beautiful Soup，有了它我们可以很方便地提取出HTML或XML标签中的内容，实在是方便，这一节就让我们一起来感受一下Beautiful Soup的强大吧。1. Beautiful Soup的简介简单来说，Beautiful Soup是的一个库，
beautifulsoup官方文档
wang1144的专栏
10-27 3688
indexBeautiful Soup 4.2.0 documentation » Beautiful Soup 4.2.0 文档 Beautiful Soup 是一个可以从HTML或XML文件中提取数据的Python库.它能够通过你喜欢的转换器实现惯用的文档导航,查找,修改文档的方式.Beautiful Soup会帮你节省数小时甚至数天的工作时间. 这篇
beautifulsoup4 标签选择器
weixin_44818729的博客
08-27 840
from bs4 import BeautifulSoup 语法 soup = BeautifulSoup('源码', 'lxml') html = """ <html><head><title>学习爬虫好开心</title></head> <body> <p class="title" name="dromouse"&...
Python-Beautiful Soup库
weixin_43519121的博客
05-07 257
Beautiful Soup库，也叫beautifulsoup4或bs4 Beautiful Soup提供一些简单的、python式的函数用来处理导航、搜索、修改分析树等功能。它是一个工具箱，通过解析文档为用户提供需要抓取的数据，因为简单，所以不需要多少代码就可以写出一个完整的应用程序。Beautiful Soup自动将输入文档转换为Unicode编码，输出文档转换为utf-8编码。你不需要考虑...
qt潭州课堂登陆界面
最新发布
08-21
你想知道如何实现一个使用Qt和潭州课堂API的登录界面吗？以下是一个简单的示例，展示如何使用Qt进行登录界面的设计和潭州课堂API进行身份验证。 首先，你需要在Qt中创建一个新的窗口应用程序项目。然后，设计一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值