网络爬虫学习第六弹：BeautifulSoup库使用

最新推荐文章于 2024-02-24 19:08:37 发布
最新推荐文章于 2024-02-24 19:08:37 发布
阅读量215 收藏 2
点赞数 1
文章标签： 网络爬虫 BeautifulSoup
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39494028/article/details/84028428
版权

BeautifulSoup库使用

BeautifulSoup库是python的一个HTML解析库，可以利用它来提取网页中的数据

from bs4 import BeautifulSoup
# BeautifulSoup依赖第三方解释器，在初始化BeautifulSoup时第二个参数改为lxml，即用lxml解释器
soup=BeautifulSoup('<p>Hello</p>','lxml') 
print(soup.p.string)

Hello

节点选择器

直接调用节点名称就可以选择节点

html = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p class="title" name="dromouse"><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>
"""
from bs4 import BeautifulSoup

# 初始化BeautifulSoup对象，第一个参数是html文本，第二个参数是依赖的解析器，在初始化过程中会进行自动格式更正
soup=BeautifulSoup(html,'lxml') 
print(soup.prettify()) # 方法prettify()将要解释的文本按标准的格式输出
print("--------------------")
print(soup.title.string) # 选出title节点，调用属性string输出文本内容

<html>
 <head>
  <title>
   The Dormouse's story
  </title>
 </head>
 <body>
  <p class="title" name="dromouse">
   <b>
    The Dormouse's story
   </b>
  </p>
  <p class="story">
   Once upon a time there were three little sisters; and their names were
   <a class="sister" href="http://example.com/elsie" id="link1">
    <!-- Elsie -->
   </a>
   ,
   <a class="sister" href="http://example.com/lacie" id="link2">
    Lacie
   </a>
   and
   <a class="sister" href="http://example.com/tillie" id="link3">
    Tillie
   </a>
   ;
and they lived at the bottom of a well.
  </p>
  <p class="story">
   ...
  </p>
 </body>
</html>
--------------------
The Dormouse's story

选择元素

html = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p class="title" name="dromouse"><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>
"""

from bs4 import BeautifulSoup

soup=BeautifulSoup(html,'lxml')
print(type(soup.title))
print(soup.title)
print(soup.title.string)
print(soup.p) # 在所构造的对象后面直接加上节点名称，但这样的选择方式只能选择到第一个节点

<class 'bs4.element.Tag'>
<title>The Dormouse's story</title>
The Dormouse's story
<p class="title" name="dromouse"><b>The Dormouse's story</b></p>

提取信息

1.获取名称
# <title>The Dormouse's story</title>
print(soup.title.name) # name属性用于获取节点名称

title
2.获取属性
# <p class="title" name="dromouse"><b>The Dormouse's story</b></p>
print(soup.p.attrs) # 调用attrs用来获取标签的所有属性及其属性值，返回一个字典的格式
print(soup.p.attrs['name']) # 因此可以根据字典的方法获取某个属性的值
print(soup.p['name']) # 也可以直接在节点后面加中括号，里面传入要获取的属性名称

{'class': ['title'], 'name': 'dromouse'}
dromouse
dromouse
3.获取内容
# <p class="title" name="dromouse"><b>The Dormouse's story</b></p>
print(soup.p.string) # 属性string用于获取节点内的文本内容 

The Dormouse's story

嵌套选择

在某个结点的基础上选择其内部的节点(内部所有节点中选，同名节点不止一个，用第一个)

from bs4 import BeautifulSoup

html='''<html><head><title>The Dormouse's story</title></head>'''
soup=BeautifulSoup(html,'lxml')
print(soup.head.title)
print(type(soup.head.title))
print(soup.head.title.string)

<title>The Dormouse's story</title>
<class 'bs4.element.Tag'>
The Dormouse's story

关联选择

1.子节点和子孙节点

contents属性将节点所有的子节点以列表的格式返回

html = """
<html>
    <head>
        <title>The Dormouse's story</title>
    </head>
    <body>
        <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">
                <span>Elsie</span>
            </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>
"""

from bs4 import BeautifulSoup

soup=BeautifulSoup(html,'lxml')
print(soup.p.contents) # 以列表的形式返回p节点的所有子节点

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

children属性也可以用来获取节点所有子节点，但是它返回的是一个生成器，需要用循环来遍历

print(soup.p.children)
for i,child in enumerate(soup.p.children):
    print(i,child)

<list_iterator object at 0x0000010DBF577C18>
0 
            Once upon a time there were three little sisters; and their names were
            
1 <a class="sister" href="http://example.com/elsie" id="link1">
<span>Elsie</span>
</a>
2 

3 <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>
4  
            and
            
5 <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>
6 
            and they lived at the bottom of a well.

descendants属性用于获取节点所有的子孙节点，同样返回的的一个生成器，循环来遍历

print(soup.p.descendants)
for i,child in enumerate(soup.p.descendants):
    print(i,child)

<generator object descendants at 0x0000010DBF5619E8>
0 
            Once upon a time there were three little sisters; and their names were
            
1 <a class="sister" href="http://example.com/elsie" id="link1">
<span>Elsie</span>
</a>
2 

3 <span>Elsie</span>
4 Elsie
5 

6 

7 <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>
8 Lacie
9  
            and
            
10 <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>
11 Tillie
12 
            and they lived at the bottom of a well.
2.父节点和祖先节点

parent属性用来获取节点的父节点及其内部内容

html = """
<html>
    <head>
        <title>The Dormouse's story</title>
    </head>
    <body>
        <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">
                <span>Elsie</span>
            </a>
        </p>
        <p class="story">...</p>
"""
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
print(soup.a.parent)
print(type(soup.a.parent))

<p class="story">
            Once upon a time there were three little sisters; and their names were
            <a class="sister" href="http://example.com/elsie" id="link1">
<span>Elsie</span>
</a>
</p>
<class 'bs4.element.Tag'>

parents属性用来获取节点的所有祖先节点及其内部内容，返回的是一个生成器

html = """
<html>
    <body>
        <p class="story">
            <a href="http://example.com/elsie" class="sister" id="link1">
                <span>Elsie</span>
            </a>
        </p>
"""
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
print(type(soup.a.parents))
print(list(enumerate(soup.a.parents)))

<class 'generator'>
[(0, <p class="story">
<a class="sister" href="http://example.com/elsie" id="link1">
<span>Elsie</span>
</a>
</p>), (1, <body>
<p class="story">
<a class="sister" href="http://example.com/elsie" id="link1">
<span>Elsie</span>
</a>
</p>
</body>), (2, <html>
<body>
<p class="story">
<a class="sister" href="http://example.com/elsie" id="link1">
<span>Elsie</span>
</a>
</p>
</body></html>), (3, <html>
<body>
<p class="story">
<a class="sister" href="http://example.com/elsie" id="link1">
<span>Elsie</span>
</a>
</p>
</body></html>)]
3.兄弟节点

next_sibling：返回节点的下一个兄弟元素
previous_siblings：返回节点的上一个兄弟元素
next_siblings：返回节点前面所有兄弟元素，返回一个生成器
previous_siblings：返回节点后面所有的兄弟元素，返回一个生成器

html = """
<html>
    <body>
        <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">
                <span>Elsie</span>
            </a>
            Hello
            <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>
"""

from  bs4 import BeautifulSoup

soup=BeautifulSoup(html,'lxml')
print('Next Sibling',soup.a.next_sibling)
print('Prev Sibling',soup.a.previous_sibling)
print('Next Siblings',list(enumerate(soup.a.next_siblings)))
print('Prev Siblings',list(enumerate(soup.a.previous_siblings)))

Next Sibling 
            Hello
            
Prev Sibling 
            Once upon a time there were three little sisters; and their names were
            
Next Siblings [(0, '\n            Hello\n            '), (1, <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>), (2, ' \n            and\n            '), (3, <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>), (4, '\n            and they lived at the bottom of a well.\n        ')]
Prev Siblings [(0, '\n            Once upon a time there were three little sisters; and their names were\n            ')]
4.提取信息
html = """
<html>
    <body>
        <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">Bob</a><a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> 
        </p>
"""
from bs4 import BeautifulSoup

soup=BeautifulSoup(html,'lxml')
print('Next Sibling:')
print(type(soup.a.next_sibling))
print(soup.a.next_sibling)
print(soup.a.next_sibling.string)
print('Parent:')
print(type(soup.a.parents))
print(list(soup.a.parents)[0])
print(list(soup.a.parents)[0].attrs['class'])

Next Sibling:
<class 'bs4.element.Tag'>
<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>
Lacie
Parent:
<class 'generator'>
<p class="story">
            Once upon a time there were three little sisters; and their names were
            <a class="sister" href="http://example.com/elsie" id="link1">Bob</a><a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>
</p>
['story']

方法选择器

find_all()

find_all( name, attrs, recursive, text, **kwargs)
查询所有符合条件的元素，给它传入一些属性和文本就能得到所有符合条件的元素

1.name
html='''
<div class="panel">
    <div class="panel-heading">
        <h4>Hello</h4>
    </div>
    <div class="panel-body">
        <ul class="list" id="list-1">
            <li class="element">Foo</li>
            <li class="element">Bar</li>
            <li class="element">Jay</li>
        </ul>
        <ul class="list list-small" id="list-2">
            <li class="element">Foo</li>
            <li class="element">Bar</li>
        </ul>
    </div>
</div>
'''
from bs4 import BeautifulSoup

soup=BeautifulSoup(html,'lxml')
print(soup.find_all(name='ul')) # 查询名为ul的节点，返回一个包含所有ul节点的列表
print(type(soup.find_all(name='ul')[0])) # 
print('--------------------------------------')
for ul in soup.find_all(name='ul'): # 由于元素类型为bs4.element.Tag类型，因此可以继续查询
    print(ul.find_all(name='li'))
    for li in ul.find_all(name='li'):
        print(li.string)

[<ul class="list" id="list-1">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>, <ul class="list list-small" id="list-2">
<li class="element">Foo</li>
<li class="element">Bar</li>
</ul>]
<class 'bs4.element.Tag'>
--------------------------------------
[<li class="element">Foo</li>, <li class="element">Bar</li>, <li class="element">Jay</li>]
Foo
Bar
Jay
[<li class="element">Foo</li>, <li class="element">Bar</li>]
Foo
Bar
2.attrs
html='''
<div class="panel">
    <div class="panel-heading">
        <h4>Hello</h4>
    </div>
    <div class="panel-body">
        <ul class="list" id="list-1" name='elements'>
            <li class="element">Foo</li>
            <li class="element">Bar</li>
            <li class="element">Jay</li>
        </ul>
        <ul class="list list-small" id="list-2">
            <li class="element">Foo</li>
            <li class="element">Bar</li>
        </ul>
    </div>
</div>
'''
from bs4 import BeautifulSoup

soup=BeautifulSoup(html,'lxml')
# 传入attrs属性的类型是字典类型，key为属性名，value为属性值
print(soup.find_all(attrs={'id':'list-1'})) 
print(soup.find_all(attrs={'name':'elements'}))
print("----------------------------------")
# 对于常用属性id,class...我们可以不用attrs来查询
print(soup.find_all(id='list-1'))
print(soup.find_all(class_='element')) # class在python中是关键字，后跟下划线

[<ul class="list" id="list-1" name="elements">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>]
[<ul class="list" id="list-1" name="elements">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>]
----------------------------------
[<ul class="list" id="list-1" name="elements">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>]
[<li class="element">Foo</li>, <li class="element">Bar</li>, <li class="element">Jay</li>, <li class="element">Foo</li>, <li class="element">Bar</li>]
3.text
# text可以用来匹配节点的文本，传入形式可以是字符也可以是正则表达式对象
html='''
<div class="panel">
    <div class="panel-body">
        <a>Hello, this is a link</a>
        <a>Hello, this is a link, too</a>
    </div>
</div>
'''
from bs4 import BeautifulSoup
import re

soup=BeautifulSoup(html,'lxml')
print(soup.find_all(text=re.compile('link'))) # 返回列表形式

['Hello, this is a link', 'Hello, this is a link, too']

find()

与find_all()方法相似，不过返回的是第一个查询到的单个元素

html='''
<div class="panel">
    <div class="panel-heading">
        <h4>Hello</h4>
    </div>
    <div class="panel-body">
        <ul class="list" id="list-1">
            <li class="element">Foo</li>
            <li class="element">Bar</li>
            <li class="element">Jay</li>
        </ul>
        <ul class="list list-small" id="list-2">
            <li class="element">Foo</li>
            <li class="element">Bar</li>
        </ul>
    </div>
</div>
'''
from bs4 import BeautifulSoup

soup=BeautifulSoup(html,'lxml')
print(soup.find(name='ul'))
print(type(soup.find(name='ul')))
print(soup.find(class_='list'))

<ul class="list" id="list-1">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>
<class 'bs4.element.Tag'>
<ul class="list" id="list-1">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>
其他方法

用法与find_all和find完全相同但查询范围不同

find_parents()：返回所有祖先节点
find_parent()：返回所有直接父节点
find_next_siblings()：返回后面所有兄弟节点
find_next_sibling()：返回后面第一个兄弟节点
find_previous_siblings()：返回前面所有兄弟节点
find_previous_sibling()：返回前面第一个兄弟节点
find_all_next()：返回节点后面所有符合条件的节点
find_next()：返回节点后面第一个符合条件的节点
find_all_previous()：返回节点前面所有符合条件的节点
find_previous()：返回节点前面第一符合条件的节点

CSS选择器

利用select()方法来使用CSS选择器进行选择

html='''
<div class="panel">
    <div class="panel-heading">
        <h4>Hello</h4>
    </div>
    <div class="panel-body">
        <ul class="list" id="list-1">
            <li class="element">Foo</li>
            <li class="element">Bar</li>
            <li class="element">Jay</li>
        </ul>
        <ul class="list list-small" id="list-2">
            <li class="element">Foo</li>
            <li class="element">Bar</li>
        </ul>
    </div>
</div>
'''
from bs4 import BeautifulSoup

soup=BeautifulSoup(html,'lxml')
print(soup.select(".panel .panel-heading"))
print(soup.select("ul li"))
print(soup.select('#list-2 .element'))
print(type(soup.select('ul')[0]))

[<div class="panel-heading">
<h4>Hello</h4>
</div>]
[<li class="element">Foo</li>, <li class="element">Bar</li>, <li class="element">Jay</li>, <li class="element">Foo</li>, <li class="element">Bar</li>]
[<li class="element">Foo</li>, <li class="element">Bar</li>]
<class 'bs4.element.Tag'>
1.嵌套选择
from bs4 import BeautifulSoup

soup=BeautifulSoup(html,'lxml')
for ul in soup.select('ul'):
    print(ul.select("li"))

[<li class="element">Foo</li>, <li class="element">Bar</li>, <li class="element">Jay</li>]
[<li class="element">Foo</li>, <li class="element">Bar</li>]
2.获取属性
from bs4 import BeautifulSoup

soup=BeautifulSoup(html,'lxml')
for ul in soup.select('ul'):
    print(ul['id'])
    print(ul.attrs['id'])

list-1
list-1
list-2
list-2
3.获取文本
from bs4 import BeautifulSoup

# 获取节点文本内容，除了属性string，还有get_text()
soup=BeautifulSoup(html,'lxml')
for li in soup.select('li'):
    print('Get Text:',li.get_text())
    print('String:',li.string)

Get Text: Foo
String: Foo
Get Text: Bar
String: Bar
Get Text: Jay
String: Jay
Get Text: Foo
String: Foo
Get Text: Bar
String: Bar

参考：崔庆才《python3网络爬虫开发实战》

Taoist_Nie
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
爬虫日记(6)：beautifulsoup的基本使用2
大坡3D软件开发
03-07 243
前面已经介绍了怎么样下载beautifulsoup库，以及初步地使用它，本文将深入一些来学习它。我们要使用beautifulsoup库，大部分的原因就是直接去搜索HTML文本很费力气，用了这个库之后就可以快速地查找到合适的元素。 beautifulsoup库为了方便地去查找到指定的元素，它需要遍历整个HTML文本，然后把它们生成一串python对象，再把这些对象构建成一颗树。Beautiful Soup将复杂HTML文档转换成一个复杂的树形结构,每个节点都是Python对象,所有对象可以归纳为4种:.
Python：BeautifulSoup库介绍
不怕猫的耗子A
05-12 2095
1、BeautifulSoup是Python中的一个第三方库，其最主要的功能是处理HTML文档⑴查找HTML文档中的指定标签⑵获取HTML文档中指定标签的标签名、标签值、标签属性等⑶修改HTML文档中指定标签2、BeautifulSoup库将HTML文档解析为一个对象，使用该对象方法能很方便的获取HTML文档中的数据3、BeautifulSoup库也可以用来处理XML文档。
Beautifulsoup分别用find、find_all和select爬取论文信息
weixin_45671979的博客
09-22 810
分别用find、find_all和select爬取论文信息 find只会爬取到第一条满足条件的信息，而find_all和select会爬取所有满足条件的信息 论文链接 find和find_all方法： import requests from bs4 import BeautifulSoup from requests import RequestException def get_html(ur...
beautiful soup find 和 find_all
hx97105的博客
11-08 271
查找功能是解析时最常用的功能，之前看示例的时候有点乱，原来存在以下关系： soup.find_all('title', limit=1) 等价于 soup.find('title') 但是find_all仍旧返回的是一个元素的列表。 soup.head.title 等价于 soup.find("head").find("title") soup.title(string=True) ...
BeautifulSoup之find_all()
Gao__xi的博客
03-18 1914
代码 import requests from bs4 import BeautifulSoup path="https://blog.csdn.net/Gao__xi/article/details/88607021" header={ "User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, ...
BeautifulSoup中find，find_all
dldl1718的博客
02-17 839
find（） 若希望会找到BeautifulSoup对象内的 任何第一个标签入口，使用find方法，返回标签内容。 find（name，attrs, recursive, text, **wargs）#recuasive 递归，循环的； 默认true 通过对name限定，查找标签 对text限定，查找文本 基于正则表达式的查找 对attrs限定，查找标签的属性例如：attrs = {‘class...
BeautifulSoup中的find，find_all
weixin_46173586的博客
10-17 162
https://www.cnblogs.com/keye/p/7868059.html.
python爬虫学习第三节：BeautifulSoup模块
qq_43132653的博客
01-31 518
1：beautifulsoup模块作用是为了完成爬虫工作中的解析数据和提取数据 2：我们平时用浏览器上网，浏览器会把服务器返回的html源代码翻译为我们能看动的样子，之后我们才能在网页上做各种操作，爬虫工作也是一样，要使用能读懂html的工具，才能提取想要的数据 3：beautifulsoup如何解析数据： 这里面的解析器，python由一个内置的库：html.parser(他不是唯一的解析器） 解析代码结构为： 在第6行代码中，第一个参数必须是字符串，到这里，我们就完成了数据解析，且把解析到的数据转换成
Python爬虫页面解析基础：BeautifulSoup库
Python-全栈开发教程-入门到精通
12-13 227
BeautifulSoup库 一.BeautifulSoup库的下载以及使用 1.下载 pip3 install beautifulsoup4 2.使用 improt bs4 二.BeautifulSoup库解析器 解析器 使用方法 优势 劣势 bs4的HTML解析器 BeautifulSoup(mk,‘html.parser’) Python 的内置标准库 执行速度适中 文...
Python爬虫学习（6）：案例练习--BeautifulSoup库爬取猫眼电影（深度爬取）
qq_41817925的博客
03-09 1136
一、分析 1、爬取网址：https://maoyan.com/films 2、爬取按“经典影片”、“按评价排序”筛选后的电影数据 3、滑动到页面底部，多点击几次不同页面发现url地址的规律 提取url为：https://maoyan.com/films?showType=3&sortId=3&offset=“0/30/60/…” 4、分析元素 先将所有的dd标签找到，得到一个存放所有dd标签的列表：filmList = bs.find_all(name=‘dd’) 再遍历dd标签列
BeautifulSoup库之find_all函数
weixin_30896763的博客
11-24 295
　　BeautifulSoup将复杂的HTML文档转换成一个复杂的树形结构.每个节点都是Python对象.所有对象可以归纳为四种:Tag,NavigableString,BeautifulSoup,Comment. 　　　　1.Tag对象最重要的属性:Name:标签的名字；attributes:属性(用class指代) 　　　　2.BeautifulSoup对象表示的...
beautifulsoup find函数返回值_再端一碗BeautifulSoup
weixin_31641077的博客
12-29 627
在上一章我们介绍了如何使用BeautifulSoup抓取安徒生童话故事《丑小鸭》，通过一个简单的例子，大家应该对于python如何进行爬取网页内容有了一个初步的认识。在这一章节，我们将延续上一章的内容进行网页内容的爬取，不过我们将难度提高一点，不再只是抓取一个页面，而是抓取很多个页面的内容。在这里，我们还是以安徒生的童话故事为例进行讲解，不过今天的内容是抓取所有的安徒生童话故事。具体内容如下图所示...
BeautifulSoup 利用Find_all（）多级标签索引和获取标签中的属性内容
learner_syj的博客
10-02 3万+
BeautifulSoup详解 BeautifulSoup是Python爬虫常用的一个库，起到解析页面的功能。但是我们课上的老师没有把这个库详细的讲，所以我利用网上的资源自己整合一下，写一篇Blog来学习一下~ 首先是BeautifulSoup库的安装： 命令行运行: pip3 install beautifulsoup4 BeautifulSoup的解析器： 我们常用html.parser解析器 解析器 使用方法 优势 Python标准库 BeautifulSoup(response
python学习之----BeautifulSoup的find()和findAll()及四大对象
weixin_30339969的博客
03-18 676
BeautifulSoup 里的find() 和findAll() 可能是你最常用的两个函数。借助它们，你可以通 过标签的不同属性轻松地过滤HTML 页面，查找需要的标签组或单个标签。 这两个函数非常相似，BeautifulSoup 文档里两者的定义就是这样： findAll(tag, attributes, recursive, text, limit, keywords) find(t...
BeautifulSoup中的find_all()及select()查找方法
最新发布
book_dw5189的博客
02-24 3408
BeautifulSoup中的find_all()及select()查找方法
BeautifulSoup库中的find与find_all方法
Road
03-11 3611
在分析一些复杂的HTML页面时候，灵活使用这两种方法十分重要，总结下这两种方法的使用 主要用用户标签组或者单个标签的查找： find_all方法：(找到所有匹配结果出现的地方) .find_all(name,attrs,recursive,text,limit,**kwargs) ① tag.find_all(…) ②soup.find_all(…) <1>name：可以传一个标签的名...
万字博文让我们携手一起走进bs4的世界【python Beautifulsoup】bs4入门 find()与find_all()
IT赵云的博客
03-15 4960
BeautifulSoup 支持从HTML或XML文件中提取数据的Python库 支持Python标准库中的HTML解析器 还支持一些第三方的解析器lxml,使用的是Xpath语法，推荐安装。 BeautifulSoup自动将输入文档转换为Unicode编码，输出文档转换为utf-8编码。你不需要考虑编码方式. 认识： find_all() | find() .text | get_text() string|strings|.stripped_strings
BeautifulSoup中find和find_all的使用
热门推荐
weixin_42970378的博客
10-17 11万+
爬虫利器BeautifulSoup中find和find_all的使用方法 二话不说，先上段HTML例子 &amp;amp;lt;html&amp;amp;gt; &amp;amp;lt;head&amp;amp;gt; &amp;amp;lt;title&amp;amp;gt; index &amp;amp;lt;/title&amp;amp;gt; &amp
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值