python-爬虫

2022-10-06 22:15:44

文章目录

基本流程
requests
xpath

路径
谓语
通配符、组合符
XPath 轴（Axes）
HtmlElement

beautifulSoup

四大对象种类
遍历节点树
搜索find
css选择器select

例子
tldextract
re
URL 清洗

基本流程

向网页发送请求
分析网页

requests

官方文档：https://2.python-requests.org/en/master/
官方文档中文版：https://2.python-requests.org//zh_CN/latest/user/quickstart.html

requests无论get()还是post()都会返回一个Response对象，下载到的内容就通过这个对象获取：

res.content 是得到的二进制内容，其类型是bytes；
res.text 是二进制内容content decode后的str内容；
它先从response headers里面找到encoding，没找到就通过chardet自动判断得到encoding，并赋值给res.encoding，最后把二进制的content解密为str类型。
requests还有个好用的就是Session，它部分类似浏览器，保存了cookies，在后面需要登录和与cookies相关的爬虫都可以用它的session来实现。
老猿经验: res.text判断中文编码时有时候会出错，还是自己通过cchardet（用C语言实现的chardet）获取更准确。这里，我们列举一个例子：

xpath

在 XPath 中，有七种类型的节点：元素、属性、文本、命名空间、处理指令、注释以及文档（根）节点。XML 文档是被作为节点树来对待的。树的根被称为文档节点或者根节点。

路径

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

谓语

谓语用来查找某个特定的节点或者包含某个指定的值的节点。
谓语被嵌在方括号中。

路径表达式	结果
/bookstore/book[1]	选取属于 bookstore 子元素的第一个 book 元素。
/bookstore/book[last()]	选取属于 bookstore 子元素的最后一个 book 元素。
/bookstore/book[last()-1]	选取属于 bookstore 子元素的倒数第二个 book 元素。
/bookstore/book[position()< 3]	选取最前面的两个属于 bookstore 元素的子元素的 book 元素。
//title[@lang]	选取所有拥有名为 lang 的属性的 title 元素。
//title[@lang=‘eng’]	选取所有 title 元素，且这些元素拥有值为 eng 的 lang 属性。
/bookstore/book[price>35.00]	选取 bookstore 元素的所有 book 元素，且其中的 price 元素的值须大于 35.00。
/bookstore/book[price>35.00]//title	选取 bookstore 元素中的 book 元素的所有 title 元素，且其中的 price 元素的值须大于 35.00。

通配符、组合符

路径表达式	结果
/bookstore/*	选取 bookstore 元素的所有子元素。
//title[@*]	选取所有带有属性的 title 元素。
//book/title \| //book/price	选取 book 元素的所有 title 和 price 元素。

XPath 轴（Axes）

轴可定义相对于当前节点的节点集。
设type(e) :<class ‘lxml.html.HtmlElement’>

轴名称	结果	获取
ancestor	选取当前节点的所有先辈（父、祖父等）。
ancestor-or-self	选取当前节点的所有先辈（父、祖父等）以及当前节点本身。
attribute	选取当前节点的所有属性。	e.get(attr_name)
children	选取当前节点的所有子元素。	e.getchildren()
descendant	选取当前节点的所有后代元素（子、孙等）。
descendant-or-self	选取当前节点的所有后代元素（子、孙等）以及当前节点本身。
following	选取文档中当前节点的结束标签之后的所有节点。
following-sibling	选取当前节点之后的所有兄弟节点
namespace	选取当前节点的所有命名空间节点。
parent	选取当前节点的父节点。	getparent()
preceding	选取文档中当前节点的开始标签之前的所有节点。
preceding-sibling	选取当前节点之前的所有同级节点。
self	选取当前节点。

HtmlElement

https://lxml.de/api/lxml.html.HtmlElement-class.html
参考学习网站：Codeup.cn/contest.php?cid=100000601

属性（Properties）
|名称|解释|
|–|--|
|attrib|show all attributes|
|tag、text、tail|获得相应属性值
|get(attrib_name)|获得属性值
|find()|e.find(".//div[@class='state']")返回第一个查找结果
|findall()|e.find(".//div[@class='state']") 返回所有查找结果
|.drop_tag()|移除该html tag，但保留它的子节点和文本并合并到该tag的父节点。
.drop_tree() |移除该节及其子节点和文本，而它后面的文本(tail text)合并到前面一个节点或父节点。
|find_class(class_name)|通过class名称查找所有含有class_name的元素，返回HtmlElement的列表
|getchildren()、getparent() 方法|顾名思义，获取孩子节点和父节点。需要注意的是，还是可以有多个（返回list），父亲只有一个。
|.getnext() .getprevious() 方法|获取后一个或前一个节点，如果没有则返回None。
|.getiterator()、.iter() 方法|从该节点开始，按文档顺序（深度优先）遍历所有子节点。可以指定只遍历某些tag。
.iterchildren() |只遍历子节点。
.iterancestors() .iterdescendants()|前者遍历前辈（从父亲节点开始），后者遍历后辈（从子辈开始），都跳过该节点。

beautifulSoup

参考博客：https://blog.csdn.net/chinaltx/article/details/86748766
文档：https://www.crummy.com/software/BeautifulSoup/bs4/doc/index.html?highlight=select

四大对象种类

Beautiful Soup将复杂HTML文档转换成一个复杂的树形结构,每个节点都是Python对象,所有对象可以归纳为4种:

Tag
NavigableString 标签对里面的东西 <tag>navigableString</tag>
BeautifulSoup 整个文档 soup = BeautifulSoup(html,features="lxml")
Comment 标签里面的注释 <a id="link1"></a>,
例：

from bs4 import BeautifulSoup

html = """
    <html><head><title color=#000000>The Dormouse's story</title></head>
    <body>
    <p class="title" name="dromouse"><b>The Dormouse's story</b></p>
    <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 they lived at the bottom of a well.
    <p class="story">...</p></body></html>
    """

# 四大对象1——BeautifulSoup
print("四大对象1——BeautifulSoup")
soup = BeautifulSoup(html,features="lxml")  #  <class 'bs4.BeautifulSoup'>

# 四大对象2——tag
print("四大对象2——tag")
titleTag = soup.title
print(titleTag)
print(titleTag.name)
print(titleTag.attrs)           # type_dict
print(titleTag.get('color'))    # get attr by name

# 四大对象3——NavigableString
print("四大对象3——NavigableString")
navString = soup.p.b.string     # 会自动搜索，因此路径不必写全，如：navString = soup.p.string  navString = soup.b.string
print(navString)
print(type(navString))
for string in soup.body.stripped_strings:  # .stripped_strings or .strings   stripped_strings属性获得去掉空白行的标签内的众多内容。
    print(string)

# 四大对象4——comment
print("四大对象4——comment")
comment = soup.a.string
print(soup.a)
print(comment)
print(type(comment))

遍历节点树

整个树采用先序遍历访问，每个tag、navigableString、conmments都对应树种的一个节点。navigableString一定是叶子节点，tag可能是叶子节点。

例：


# 遍历文档树——直接子节点 .contents  contents_type_list
print("遍历文档树——直接子节点 .contents")
contents = soup.body.contents  # type_list
for content in contents:
    print(content)

# 遍历文档树——.children  type_list_iterator
print("遍历文档树——.children")
children = soup.body.children  # type: list_iterator
for child in children:
    print(child)
print(type(children))

# 遍历文档树——子孙节点 .descendants
print("遍历文档树——子孙节点 .descendants")
descendants = soup.body.descendants
print(type(descendants))
for child in descendants:
    print(child)

# 访问父节点——.parent
tag = soup.p.b      # 标签的父节点
parent = tag.parent
print(parent.name)

content = soup.head.title.string    # 内容的父节点：是包在内容外的第一层标签
print(content)
print(content.parent.name)

# 访问全部父节点——.parents  :generator
content = soup.head.title.string
print(content)
for parent in content.parents:
    print(parent.name)

# 兄弟节点——.next_sibling和.previous_sibling
print(soup.p.next_sibling)
print(soup.a.previous_sibling)
print(soup.p.next_sibling.next_sibling)

# 全部兄弟节点——.next_siblings和.previous_siblings
for next in soup.a.next_siblings:
    print(next)

# 前后元素——.next_element和.previous_element
print(soup.p.b.previous_element)
print(soup.p.b.next_element)

# 所有前后元素——.next_elements和.previous_elements

搜索find

find_all(),find()
find_all(name,attrs,recursive,text,**kwargs)
搜索范围：当前tag的所有tag子节点。

# 搜索——传入字符串
print(soup.find_all('a'))

# 搜索——传入正则表达式
import re
for tag in soup.find_all(re.compile("^b")):
    print(tag)

# 搜索——列表
print(soup .find_all(["a","b"]))

# 搜索——传入方法：自行构造过滤器，方法的参数是tag对象，返回值是Ture | False。
def has_class_but_no_id(tag):
    return tag.has_attr('class') and not tag.has_attr('id')

print(soup.find_all(has_class_but_no_id))

# 搜索——keyword参数
print(soup.find_all(id='link2'))
print(soup.find_all(href=re.compile("elsie")))
print(soup.find_all(class_="sister"))  # 如果指定的key是python的内置参数，后面需要加下划线，例如class_=“sister”
data_soup = BeautifulSoup('<div data-foo="value">foo!</div>',features="lxml")
print(data_soup.find_all(attrs={"data-foo":"value"})) # html5的data-*属性是无法用来直接指定的，可以通过attr参数自定义参数字典：

# 搜索——作用和name参数类似，但是text参数的搜索范围是文档中的字符串内容（不包含注释），并且是完全匹配，当然也接受正咋表达式、列表、True。
print(soup.find_all(text="Elsie"))
print(soup.find_all(text=["Tillie", "Elsie", "Lacie"]))

# 搜索——limit参数，限制返回条目个数
print(soup.find_all("a",limit=2))

# 搜索——recuresive参数

下面是一些变种，搜索范围不一样，参数基本一样

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

soup.select("…")
返回列表类型
按标签查找 .select(“p”)
按类查找 .select(".classname")
按id查找 .select("#id")
查找组合 .select(“a#link2”)
路径组合 .select(“body a#link2”)
例：

# 选择器——通过标签查找
print(soup.select("p"))
# 选择器——通过类名查找
print(soup.select(".sister"))
# 选择器——通过id查找
print(soup.select("#link1"))
# 选择器——组合查找
print(soup.select("body a#link2"))

例子

爬取特斯拉的充电站数量及位置

from lxml import html
import numpy
import requests
import json

url2 = 'https://www.tesla.com/findus/list/superchargers/United%20States'
url4 = 'https://www.tesla.com/findus/list/chargers/United+States'
header = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64; rv:66.0) Gecko/20100101 Firefox/66.0",
          "Referer": "https://www.mzitu.com/", }
page=requests.get(url4,headers=header)      # <class 'requests.models.Response'>
tree=html.fromstring(page.text)             # <class 'lxml.html.HtmlElement'>
print(tree.attrib)
# 获取每个州的名称
result = tree.xpath("//div[@class='state']/h2/text()")
print(type(result))
print(len(result))

# 得到州的节点列表
result2 = tree.xpath("//div[@class='state']")
count = numpy.zeros((len(result)))
nums = {}
# 计算每个州加油站
for i in range(len(result)):
    children = result2[i].getchildren()
    for j in range(len(children)): #{'Alabama': 4.0, 'Alaska': 1.0, 'Arizona': 9.0, 'Arkansas': 3.0, 'California': 78.0, 'Colorado': 9.0, 'Connecticut': 8.0, 'Delaware': 2.0, 'District of Columbia': 2.0, 'Florida': 22.0, 'Georgia': 7.0, 'Hawaii': 1.0, 'Idaho': 3.0, 'Illinois': 12.0, 'Indiana': 6.0, 'Iowa': 4.0, 'Kansas': 3.0, 'Kansas City': 1.0, 'Kentucky': 3.0, 'Louisiana': 3.0, 'Maine': 5.0, 'Maryland': 8.0, 'Massachusetts': 10.0, 'Mexico': 1.0, 'Michigan': 9.0, 'Minnesota': 7.0, 'Mississippi': 2.0, 'Missouri': 7.0, 'Montana': 5.0, 'Nebraska': 2.0, 'Nevada': 6.0, 'New Hampshire': 3.0, 'New Jersey': 12.0, 'New Mexico': 5.0, 'New York': 22.0, 'North Carolina': 6.0, 'North Dakota': 2.0, 'Ohio': 7.0, 'Oklahoma': 2.0, 'Oregon': 9.0, 'Pennsylvania': 9.0, 'Rhode Island': 1.0, 'South Carolina': 2.0, 'South Dakota': 3.0, 'Tennessee': 4.0, 'Texas': 22.0, 'Utah': 6.0, 'Vermont': 2.0, 'Virginia': 10.0, 'Washington': 11.0, 'West Virginia': 3.0, 'Wisconsin': 6.0, 'Wyoming': 4.0}
        if children[j].get('class')=='clear row-state':
            grandchild = children[j].getchildren()
            count[i] = count[i]+len(grandchild)
    nums[result[i]] = count[i]
print(nums)
# 将结果写入文件
json_str = json.dumps(nums)
with open('destination-chargers.json', 'w') as json_file:
    json_file.write(json_str)

element = result2[0]
print(type(element))

tldextract

它的意思就是Top Level Domain extract，即*域名提取。

re

模式匹配
re.match(pattern, string, flags=0)
标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表达式修饰符 - 可选标志
r'(.*) are (.*?) .*' 前面的一个 r 表示字符串为非转义的原始字符串，让编译器忽略反斜杠
特殊字符

字符	说明
-	特殊字符
.	匹配任意1个字符（除了\n）
\d	匹配数字，即0-9
\D	匹配非数字，即不是数字
\s	匹配空白，即空格，tab键
\S	匹配非空白
\w	匹配非特殊字符，即a-z、A-Z、0-9、_、汉字
\W	匹配特殊字符，即非字母、非数字、非汉字、非_

URL 清洗

参考：https://www.yuanrenxue.com/crawler/news-crawler-downloader.html

zz的博客发布了56 篇原创文章 · 获赞 2 · 访问量 464 私信关注

码农公寓