Scrapy学习笔记(5)--Selectors 选择器
Selectors选择器
基本介绍
当你在爬取网页的时候，最常见的任务就是从HTML源代码中提取数据。
有几个库可以实现这个功能：
BeautifulSoup
BeautifulSoup 在Python程序员中是一个非常受欢迎的网页爬取库， 它基于HTML代码的结构设计了一些能够很好处理坏标记(bad markup)的Python对象， 然而， 它的缺点就是——慢。lxml
lxml 是一个XML解析库(当然也可以解析HTML)， 它使用基于 ElementTree 的 pythonic API。(lxml不是Python标准库的一部分)
Scrapy 有自己的提取数据机制(mechanism技巧)。 他们被称为 selectors (选择器), 因为它们由 XPath 或 CSS 表达式选择HTML文件特定的部分。
XPath 是一种选择XML文件结点的语言， 也能用于HTML。 CSS 是一种将样式应用于HTML的语言。 它定义了选择器来将这些样式与特定的HTML元素关联起来。
Scrapy selectors 建立在lxml库的基础上， 也就是说，他们在速度与解析精确度(accuracy)上相近。
这一章解释了选择器是如何工作的， 并且描述了他们小型、简单的API， 而不像lxml API 那么大， 因为除了选择标记文档以外 lxml 库还可以应用于很多其他的任务。
使用选择器
Constructing selectors 构造选择器
Scrapy 选择器是 Selector 类的实例， 通过传递 text 或 TextResponse 对象构造。 它基于输入类型自动地选择最好的解析规则(XML vs HTML)：
>>> from scrapy.selector import Selector
>>> from scrapy.http import HtmlResponse
>>> # 从text中构造：
>>> body = 'good'
>>> Selector(text=body).xpath('//span/text()').extract()
['good']
>>> # 为了方便, response对象在.selector属性中显示一个选择器， 完全可以用下面的捷径：
>>> response.selector.xpath('//span/text()').extract()
['good']使用选择器
为了解释如何使用选择器， 我们将用 Scrapy shell 和一个位于Scrapy服务器的用于举例子的网页：
源代码：
<html>
<head>
<base href='http://example.com/' />
<title>Example websitetitle>
head>
<body>
<div id='images'>
<a href='image1.html'>Name: My image 1 <br /><img src='image1_thumb.jpg' />a>
<a href='image2.html'>Name: My image 2 <br /><img src='image2_thumb.jpg' />a>
<a href='image3.html'>Name: My image 3 <br /><img src='image3_thumb.jpg' />a>
<a href='image4.html'>Name: My image 4 <br /><img src='image4_thumb.jpg' />a>
<a href='image5.html'>Name: My image 5 <br /><img src='image5_thumb.jpg' />a>
div>
body>
html>首先，我们打开shell：
scrapy shell "http://doc.scrapy.org/en/latest/_static/selectors-sample1.html"
在shell装载完毕后， 你将会有一个response变量， 并且它的可以使用response.selector属性，比如response.xpath...
因为我们正在处理HTML， 所以选择器会自动的使用 HTML parser。
所以，通过查看HTML的源代码，我们就可以构建一个选择title标签的 XPath 路径：
>>> response.xpath('//title/text()')
[] CSS与XPath都可以使用：
>>> response.xpath('//title/text()')
[]
>>> response.css('title::text')
[] 如你所见，.xpath() 和 .css() 方法返回一个SelectorList 实例， 它是一系列新的选择器。
这个API可以用于快速选择嵌套的数据：
>>> response.css('img').xpath('@src').extract()
['image1_thumb.jpg', 'image2_thumb.jpg', 'image3_thumb.jpg', 'image4_thumb.jpg', 'image5_thumb.jpg']为了完全提取text的数据， 你必须调用.extract()方法， 如下：
>>> response.xpath('//title/text()').extract()
['Example website']如果你只想提取第一个匹配的元素， 你可以调用 .extract_first()
>>> response.xpath('//div[@id="images"]/a/text()').extract_first()
'Name: My image 1 '如果它没有找到元素则返回None:
>>> response.xpath('//div[@id="not-exists"]/text()').extract_first() is None
True默认的返回值可以被提供为一个参数， 来替换 None:
response.xpath('//div[@id="non-exists"/text()').extract_first(default='not-found')
'not-found'注意CSS 选择器可以使用 CSS3 pseudo-elements 选择 text 或者 属性结点:
response.css('title::text').extract()
['Example website']接下来我们将得到 base 的URL链接和一些图片的链接：
>>> response.xpath('//base/@href').extract()
['http://example.com/']
>>> response.css('base::attr(href)').extract()
['http://example.com/']
>>> response.xpath('//a[contains(@href, "image")]/@href').extract()
['image1.html', 'image2.html', 'image3.html', 'image4.html', 'image5.html']
>>> response.css('a[href*=image]::attr(href)').extract()
['image1.html', 'image2.html', 'image3.html', 'image4.html', 'image5.html']
>>> response.xpath('//a[contains(@href, "image")]/img/@src').extract()
['image1_thumb.jpg', 'image2_thumb.jpg', 'image3_thumb.jpg', 'image4_thumb.jpg', 'image5_thumb.jpg']
>>> response.css('a[href*=image] img::attr(src)').extract()
['image1_thumb.jpg', 'image2_thumb.jpg', 'image3_thumb.jpg', 'image4_thumb.jpg', 'image5_thumb.jpg']嵌套的选择器
选择器的方法(.xpath() or .css()) 返回一个同类型的选择器列表， 所以你也可以对这些选择器调用选择器的方法：
>>> links = response.xpath('//a[contains(@href, "image")]')
>>> links.extract()
['Name: My image 1
',
'Name: My image 2
',
'Name: My image 3
',
'Name: My image 4
',
'Name: My image 5
']
>>> for index, link in enumerate(links):
... args = (index, link.xpath('@href').extract(), link.xpath('img/@src').extract())
... print('Link number %d points to url %s and image %s' % args)
...
Link number 0 points to url ['image1.html'] and image ['image1_thumb.jpg']
Link number 1 points to url ['image2.html'] and image ['image2_thumb.jpg']
Link number 2 points to url ['image3.html'] and image ['image3_thumb.jpg']
Link number 3 points to url ['image4.html'] and image ['image4_thumb.jpg']
Link number 4 points to url ['image5.html'] and image ['image5_thumb.jpg']使用正则表达式
Selectors 也有一个.re() 方法使用正则表达式来提取数据。 然而，不像使用.xpath() 或者 .css() 方法， .re() 返回一个unicode字符串列表， 所以你不能构造嵌套的 .re()方法
下面有一个从HTML 源代码提取图片名字的例子：
>>> response.xpath('//a[contains(@href, "image")]/text()').re(r'Name:\s*(.+)')
['My image 1 ', 'My image 2 ', 'My image 3 ', 'My image 4 ', 'My image 5 ']有一个附加的辅助方法，与 .extract_first() 类似的 .re_first() 方法。 使用它来提取第一次匹配到的字符串：
>>> response.xpath('//a[contains(@href, "image")]/text()').re_first(r'Name:\s*(.*)')
'My image 1 '使用相关的 XPath
下面这一点一定要牢记于心！！！
如果你在使用嵌套选择器并且使用一个以/开始的 XPath, 这个XPath是绝对的 document， 而不是相对于调用它的选择器。
(注： document这里指response的内容，可以去了解XPath以获得更多的知识xpath-1.0、xpath-3.1)
比如， 假设你想提取所有在 首先，你可能会尝试使用以下方法，然而这是错误的，因为它实际上从document中提取了所有的 元素 下面是正确的方法1(使用 方法2： 更多的方法见Location Paths XPath允许你在表达式中引用变量， 使用 下面这个例子将会”动态”匹配一个基于 下面是另一个例子， 找到包含五个 在调用 由于Scrapy的选择器基于lxml， 所以也支持一些EXSLT extensions和这些已经预先注册的命名空间 用于XPath 表达式： regexp:match() 不过，放弃吧，使用 当 比如说选择 注意： C语言的library中 实现说明， 如果想熟练 set 的话， 就要对XPath 有一定的了解， xpath-1.0、xpath-3.1)， 我只看了1.0版本的XPath， 因为3.1版本的介绍好多又难懂， 相对1.0版本来说难。 下面的这些例子在提取元素之前有效地排除 document tree 的一部分。 例如在提取一些微数据时(从http://schema.org/Product 获得的实例)： 这个是部分源代码， 你可以复制粘贴， 然后将这个字符串用三引号赋值给doc： 下面是python shell： 我们先通过迭代所有的 这里有一些建议， 你可以使用XPath更加的有效， 基于this post from ScrapingHub’s blog， 更详细的内容还是在XPath-1.0 当你需要使用text 内容作为参数到 XPath string function时， 避免使用 这是因为表达式 例子： 例子： 因为一个元素可以包含很多的 CSS classes， 使用XPath通过class来选择元素十分地冗长(注意这里的括号， 官方文档写错了)： 如果你使用 事实证明， Scrapy 选择器允许你使用链式选择器(即一个用完再接着一个)， 所以你大多数时候可以在 XPath 与 CSS 中交替使用， 当选择类的时候切到CSS即可， 平时依然可以使用XPath： 这比使用冗长的XPath来选择类简单多了， 记住在 XPath 中使用 response 是一个 text 是一个 unicode 字符串或者 utf-8 编码的文本， 当response没法找到， 或者用一段HTML文本来测试 可以设置text， 就如上面的那些例子一样。 不可以同时使用 response 与 text。 type 定义了选择器的类型， 可以是 html, xml 或者 None(默认) 如果 type 是None， 选择器会自动根据response的类型选择最适合的类型， 如果是 text 类型的话默认是 html 如果 type 是None 并且有response传入， 选择器的类型就会被推测为一下类型： html 对应 HtmlResponse xml 对应 XmlResponse html 对应 任何其他类型 如果 type 被设置， 那么选择器会被强制使用该类型， 不会自动检测。 xpath(query) 该方法可以用response.xpath(query) 调用 css(query) 该方法可以用response.css(query) 调用 extract() re(regex) register_namespace(prefix, uri) remove_namespaces() nonzero() xpath(query) css(query) extract() re() 接下来几个小例子来说明几个概念(to illustrate several concepts)， 对所有的情况， 我们假设已经有了一个 从HTML response body 中选择所有的 提取所有的 遍历所有的 接下来几个小例子来说明几个概念。 假设已经有了一个 从 XML response body 选择所有的 从 Google Base XML feed提取所有的价格属性， 要求注册namespace: 在scrapy 项目中， 除掉 namespaces 而仅仅处理他们的元素名字是十分方便的， 来写更简单的 XPath。 你可以使用 让我们举个例子，用GitHub博客atom来说明这一点。 首先进入shell: 下面我们利用今天所学的知识写一个小爬虫，爬取的内容自己爬了就知道。 先定义我们的 看到magnet，大概就知道要爬取什么了吧 接下来定义 解释一下： 在 然后就是我们spider了: 为大家解释一下： 首先记得导入你的item类, 然后再看我们写的spider, 它的name就是 zhongziso, 然后看 然后解释一下 items[‘magnet’] 就是提取内容包含 “磁力” 的链接, items[‘size’] 就是提取内容包含 “大小” 的标签里面的内容, 也就是具体的参数啦 next_page 就是下一页的链接, 很明显, 直接指定链接的内容包含”下一页”即可。 好了, 以上是简单的说明, 爬取之前记得在 标签(假设document与div中都有p)， 首先， 你需要得到所有的div标签：
divs = response.xpath('//div') 元素，不仅是那些在for p in divs.xpath('//p'): # 这是错误的， 提取了所有的 .//p XPath，多了一个点)：>>> for p in divs.xpath('.//p'): # 正确
... print(p.extract())>>> for p in divs.xpath('p'):
... print(p.extract())XPath表达式中的变量
$somevariable 语法, 这有点类似于SQL world中的参数化查询或已经准备好的语句并且可以在其中替换一些参数，你对占位符的查询 ? 然后，将这些值替换为通过查询传递的值， 其实就类似于格式化输出。@id属性的元素， 而不像以前那样静态地写上路径：>>> # '$val' 在表达式中使用, 一个 'val' 参数需要被传入：
>>> response.xpath('//div[@id=$val]/a/text()', val='images').extract_first()
['Name: My image 1 ', 'Name: My image 2 ', 'Name: My image 3 ', 'Name: My image 4 ', 'Name: My image 5 ']子标签的>>> response.xpath('//div[count(a)=$cnt]/@id', cnt=5).extract_first()
'images'xpath() 时所有引用的变量必须有一个绑定的值对应， 否则你会报出 ValueError: XPath error: exception 。
parsel,
XPath variables使用 EXSLT extensions
prefix
namespace
usage
re
http://exslt.org/regexp/index.html
regular expressions
set
http://exslt.org/set/index.html
set manipilation
Regular expressions-正则表达式
regexp:replace()
regexp:test()
方法
语法
说明
re:test()
re:test(string, string, string?)
第一个string是要匹配的对象，这里是标签的属性， 第二个是正则表达式的字符串， 第三个是控制标记
re:match()
re:match(string, string, string?)
我感觉和test()没啥区别, 感觉和re里面的match方法有出入， 而且它不仅可以匹配开头
re:replace()
re:replace(string, string, string, string)
第一个string是要匹配的字符串，这里就是属性， 第二个string是正则表达式语法， 第三个是将要替换的新的字符串， 第四个就是控制标记（讲道理特别迷，不存在什么替换）
re:test() 就可以了， 不过它返回的是字符串，讲道理这三个都是字符串。 匹配到你想要的标签的字符串后， 再用sel = Selector(text=$你匹配到的字符串)， 这样sel就有.xpath属性了，你就可以接着解析。XPath 的 starts-with() 或 contains()方法不够用时， test() 方法显得十分地有用。 class属性结尾有 数字 的链接:>>> from scrapy import Selector
>>> doc = """
...
libxslt 不支持 EXSLT 正则表达式， 所以lxml的实现是使用python的 re 模块， 因此在XPath中使用正则表达式会使性能稍微降低。Set operations-集合
方法
语法
说明
set:difference
set:difference(node-set, node-set)
取两个XPath的并集减去交集， 也就是相异的部分
set:intersection
set:intersection(node-set, node-set)
交集， 相同的部分
set:distinct
set:distinct(node-set)
去重， 即去掉相同的部分
set:has-same-node
set:has-same-node(node-set, node-set)
集合：如果作为第一个参数传递的节点集与第二个参数传递的节点集至少有一个节点相同，则has-same-node函数将返回true。 如果两个节点集中没有相同的节点，则返回false。
set:leading
set:leading(node-set, node-set)
传递两个结点集合(也可以是单独的结点)， 根据源代码的结点顺序， 如果第二个结点集合中最前面的一个结点(用A代替名字)在第一个结点集合中， 那么第一个结点集合中在A 前面 的所有结点都会被返回(不包括A)， 如果A不在第一个结点集合中， 那么就返回空列表， 如果第二个集合为空(也就是XPath没有找到任何结点)， 那么第一个结点集合会被返回
set:trailing
set:trailing(node-set, node-set)
传递两个结点集合(也可以是单独的结点)， 根据源代码的结点顺序， 如果第二个结点集合中最前面的一个结点(用A代替名字)在第一个结点集合中， 那么第一个结点集合中在A 后面 的所有结点都会被返回(不包括A)， 如果A不在第一个结点集合中， 那么就返回空列表， 如果第二个集合为空(也就是XPath没有找到任何结点)， 那么第一个结点集合会被返回
<div itemscope itemtype="http://schema.org/Product">
<span itemprop="name">Kenmore White 17" Microwavespan>
<img src="kenmore-microwave-17in.jpg" alt='Kenmore 17" Microwave' />
<div itemprop="aggregateRating"
itemscope itemtype="http://schema.org/AggregateRating">
Rated <span itemprop="ratingValue">3.5span>/5
based on <span itemprop="reviewCount">11span> customer reviews
div>
<div itemprop="offers" itemscope itemtype="http://schema.org/Offer">
<span itemprop="price">$55.00span>
<link itemprop="availability" href="http://schema.org/InStock" />In stock
div>
Product description:
<span itemprop="description">0.7 cubic feet countertop microwave.
Has six preset cooking categories and convenience features like
Add-A-Minute and Child Lock.span>
Customer reviews:
<div itemprop="review" itemscope itemtype="http://schema.org/Review">
<span itemprop="name">Not a happy camperspan> -
by <span itemprop="author">Elliespan>,
<meta itemprop="datePublished" content="2011-04-01">April 1, 2011
<div itemprop="reviewRating" itemscope itemtype="http://schema.org/Rating">
<meta itemprop="worstRating" content = "1">
<span itemprop="ratingValue">1span>/
<span itemprop="bestRating">5span>stars
div>
<span itemprop="description">The lamp burned out and now I have to replace
it. span>
div>
<div itemprop="review" itemscope itemtype="http://schema.org/Review">
<span itemprop="name">Value purchasespan> -
by <span itemprop="author">Lucasspan>,
<meta itemprop="datePublished" content="2011-03-25">March 25, 2011
<div itemprop="reviewRating" itemscope itemtype="http://schema.org/Rating">
<meta itemprop="worstRating" content = "1"/>
<span itemprop="ratingValue">4span>/
<span itemprop="bestRating">5span>stars
div>
<span itemprop="description">Great microwave for the price. It is small and
fits in my apartment.span>
div>
div>>>> from scrapy import Selector
>>> doc = """
... itemscope元素， 然后对于每一个， 我们寻找所有的itemprops元素并且排除那些在其他itemscope的元素, 最终得到的是两个xpath中不同的属性(你可以通过将两个XPath都打印一遍来观察有什么区别， 事实上set:difference方法就是找出他们相异的属性)一些XPath 的提示
找到 text() 中的内容 “Next Page”
.//text()， 而应该使用 . 来代替。text() yield 一个text 元素的collection， 也就是结点集合(简称结点集)， 当一个结点集传入string时， 也就是当传入字符串给contains() 方法或者 starts-with()方法等， 它会导致在文本中只显示第一个元素。>>> from scrapy import Selector
>>> sel = Selector(text='Click here to go to the Next Page')
>>> # 传入一个字符串到结点集中：
>>> sel.xpath('//a//text()').extract() # 查看结点集的内容
['Click here to go to the ', 'Next Page']
>>> sel.xpath('string(//a[1]//text())').extract() # 将它传入string
['Click here to go to the ']
>>> # 然而，一个转换成字符串的节点将其本身的文本和它的所有后代组合在一起
>>> sel.xpath('(//a[1])').extract() # 查看第一个结点
['Click here to go to the Next Page']
>>> sel.xpath('string(//a[1])').extract() # 将它传给string
['Click here to go to the Next Page']
>>> # 使用 .//text() 结点集不会选择任何东西：
>>> sel.xpath('//a[contains(.//text(), "Next Page")]').extract()
[]
>>> # 使用 . 来起作用：
>>> sel.xpath('//a[contains(., "Next Page")]').extract()
['Click here to go to the Next Page']//node[1] 与 (//node)[1] 的区别//node[1] 选择所有在父类下的第一个结点(很多第一个结点)
(//node)[1] 选择文件中所有的结点， 只得到他们之中的第一个， 也就是第一个结点(只有一个结点)>>> from scrapy import Selector
>>> sel = Selector(text="""
...
...
...
...
""")
>>> xp = lambda x: sel.xpath(x).extract() # 为了使表达简单
>>> xp("//li[1]") # 选择所有ul父类下的第一个li结点
['在按 class 查询时，考虑使用CSS
*[contains(concat(' ', normalize-space(@class, ' ')), 'someclass ')]@class="someclass" 你可能失去拥有该类的同时有其他类的元素， 并且如果你仅仅使用 contains(@class, "someclass") 来补偿， 你会找到额外的更多的元素>>> from scrapy import Selector
>>> sel = Selector(text='')
>>> sel.css('.shout').xpath('./time/@datetime').extract()
['2014-07-23 19:00']. 来接着前面的css。内置 Selector 参考
Selector objects 选择器对象
class scrapy.selector.Selector(response=None, text=None, type=None)
Selector 类的实例是一个response包装器(wrapper) 来选择内容的一部分。参数
HtmlResponse 或 XmlResponse 对象， 将从它解析提取数据。
方法
找到匹配XPath 查询(query)的结点 并且将查到的元素以SelectorList对象返回结果。 List 元素也实现了 Selector 接口。
用CSS选择器查询元素并返回一个 SelectorList 实例
序列化并返回由匹配的节点组成unicode字符串的列表。百分比编码的内容不被引用。
使用给定的regex表达式匹配Unicode字符串并作为列表返回。
re() 与 re_first() 都转码为 HTML entities(除了 < 与 &)
注册在选择器中将要使用的命名空间(namespace)。 不注册namespace的话你不能从不标准的namespace选择或者提取数据。
移除所有的 namespaces， 允许使用名称空间较少的xpath遍历(traverse)文档
如果选择了任何真实的内容返回True， 否则返回False。 换言之， 选择器的 boolean 由所选内容决定。SelectorList 对象
class scrapy.selector.SelectorList
SelectorList 类是python内置类 list 的一个子类， 同时它提供了一些额外的方法。
对每个列表中的元素调用 .xpath() 方法并以新的 SelectorList 返回他们的结果。
对每个列表中的元素调用 .css() 方法并以新的 SelectorList 返回他们的结果
对每个列表中的元素调用 .extract() 方法并以 unicode 字符串列表返回
对每个列表中的元素调用 .re() 方法并以 unicode 字符串列表返回HTML response
HtmlResponse 对象:
sel = Selector(html_response)
元素：sel.xpath('//h1')h1 元素：sel.xpath('//h1').extract()
sel.xpath('//h1/text()').extract() 标签并打印他们的 class 属性：for node in sel.xpath(//p'):
print(node.xpath('@class').extract())XML response
XmlResponse 对象：
sel = Selector(xml_response)
sel.xpath('//product')sel.register_namespace("g", "http://base.google.com/ns/1.0")
sel.xpath('//g:price').extract()removing namespaces 移除命名空间
Selector.remove_namespaces() 方法>>> response.xpath('//link')
[]
>>> response.selector.remove_namespaces()
>>> response.xpath('//link')
[items.py:import scrapy
class ZhongzisouItem(scrapy.Item):
# seed 的 title
title = scrapy.Field()
# seed 的 magnet
magnet = scrapy.Field()
# resource 的 size
size = scrapy.Field()
pipelines.py:import json
class ZhongzisouPipeline(object):
def open_spider(self, spider):
self.file = open('items.jl', 'w', encoding='utf-8')
def close_spider(self, spider):
self.file.close()
def process_item(self, item, spider):
line = json.dumps(dict(item), ensure_ascii=False) + '\n'
self.file.write(line)
return itemopen_spider 中我们定义打开的文件为 items.jl (别忘了导入json库), 文件为覆盖写入, 编码为utf-8, 在process_item 中 line 就是每一行的数据， 利用 dump方法 来将它转格式, ensure_ascii=False 就是将强制ascii码关闭，这样就可以显示中文了。# -*- coding: utf-8 -*-
import scrapy
from Zhongzisou.items import ZhongzisouItem
class ZhongzisoSpider(scrapy.Spider):
name = 'zhongziso'
def __init__(self, keyword=None):
if keyword is not None:
self.start_urls = ['https://zhongziso.com/list/' + keyword + '/1']
else:
raise ValueError('You must specify a keyword using `-a keyword=your_keyword`')
def parse(self, response):
item = ZhongzisouItem()
for table in response.xpath('//table[@class="table table-bordered table-striped"]'):
item['title'] = ''.join(table.xpath('.//a/text()').extract())[:-10]
item['magnet'] = table.xpath('.//a[contains(., "磁力")]/@href').extract_first()
item['size'] = table.xpath('.//td[contains(., "大小")]/strong/text()').extract_first()
yield item
next_page = response.xpath('//a[contains(., "下一页")]/@href').extract_first()
if next_page is not None:
next_page = 'https://zhongziso.com' + next_page
next_page = response.urljoin(next_page)
yield scrapy.Request(next_page, callback=self.parse)
__init__, 我在里面添加了keyword=None, 也就是说在运行该爬虫时要求指定一个关键字参数, 也就是我们要爬取内容的关键字, 如果没有给该参数传递值, 就会引起 ValueError 异常。parse 方法, 首先创建一个item对象, 然后就是今天所学的关键部分了, 我们首先指定一个范围, 也就是for语句那一行, 下面items['title']后面的路径中, 看到了我使用 .//这样的方式, 这是为了在我们指定的范围内提取, 如果没有那个 . 的话, 就会从整个网页上提取所有的路径。后面的 [:-10]是为了过滤掉一些没用的信息settings.py 把 ITEM_PIPELINES取消注释, 我们来运行爬虫试试, 在命令行中使用如下的命令:
scrapy crawl zhongziso -a keyword=刀剑神域
然后, 你就可以看到相应的结果, 没错, 就是动漫刀剑神域的 magnet 链接, 你可以通过改变参数来爬取你想要的内容, 你当然可以换其他网站试试来满足你的好奇心