印刷行业网站建设,专门做五金的网站,厦门网站定制,shopex网站文章目录 1 Urllib库的基本使用① 基本url请求② 查看http请求的响应信息③ 另一个请求方法#xff1a;Request④ Handler 处理请求和响应 Cookie 存储用户信息⑤ 异常处理⑥ url解析 2 Requests库的基本使用① 模块的简单使用② requests模块的各种请求方式③ 请求④ 响… 文章目录 1 Urllib库的基本使用① 基本url请求② 查看http请求的响应信息③ 另一个请求方法Request④ Handler 处理请求和响应 Cookie 存储用户信息⑤ 异常处理⑥ url解析 2 Requests库的基本使用① 模块的简单使用② requests模块的各种请求方式③ 请求④ 响应⑤ 高级操作 3 BeautifulSoup库详解① 解析库② 基本使用③ 标签选择器④ 标准选择器⑤ css选择器 4 PyQuery库详解① 初始化② 基本CSS选择器③ 查找元素④ 遍历⑤ 获取信息⑥ DOM操作⑦ 伪类选择器 5 Selenium库详解① 基本使用② 声明浏览器对象③ 访问页面④ 查找元素⑤ 元素交互操作⑥ 执行JavaScript⑦ 获取元素信息⑧ 等待⑨ 前进后退⑩ cookie十一 选项卡管理十二 异常处理 1 Urllib库的基本使用
urllib是python内置的HTTP请求库不需要额外安装模块。 有了它我们只需要关系请求的链接是什么参数是什么或者请求头的设置是什么而不用深入了解它内部的底层工作原理。
包含四个模块
urllib.request 请求模块urllib.error 异常处理模块urllib.parse url解析模块urllib.robotparser robots.txt解析模块
urllib模块用来爬虫其实不是很好用它是一个比较老的模块。在它的基础上有一个新的模块叫request模块更加好用。但是作为一个基本的模块还是要好好了解。
① 基本url请求 urlopen的get请求第一个参数的使用 先认识一个urllib.request模块中最基本的一个函数“urlopen()函数”。它主要用于打开一个URL地址帮助我们给服务器发送一个请求。
该函数语法如下
urllib.request.urlopen(url, dataNone, [timeout, ]*, cafileNone, capathNone, cadefaultFalse, contextNone)参数说明
url要打开的URL地址。data可选要发送的数据。如果设置了该参数则会使用POST请求方式发送数据否则默认使用GET请求方式。timeout可选超时时间单位为秒。如果连接或读取超时则抛出异常。如果不指定超时时间默认情况下会一直等待服务器响应。cafile可选用于验证SSL证书的CA证书文件。capath可选用于验证SSL证书的CA证书路径。cadefault可选是否使用默认的CA证书验证。context可选SSL上下文。
urlopen()函数会返回一个类似文件的对象可以像操作文件一样对其进行读取和处理。例如可以使用read()方法读取响应内容使用getcode()方法获取HTTP状态码使用getheaders()方法获取响应头信息等。
import urllib.requestresponse urllib.request.urlopen(http://www.baidu.com)
print(response.read().decode(utf-8))结果
代码执行的结果是上面网址的html代码urlopen函数的post请求第二个参数的使用 再来认识另一个函数。 urllib.parse 是 Python 中用于解析 URL 的标准库模块提供了一些实用的函数和类来操作 URL。
该模块包含以下功能
urlparse将 URL 字符串解析成 6 个部分组成的元组包括 scheme、netloc、path、params、query 和 fragment。urlunparse与 urlparse 功能相反将一个 6 元组转换成 URL 字符串。urlsplit与 urlparse 类似但只返回 5 个部分的元组不包括 params。urlunsplit与 urlunparse 类似但只接受一个包含 5 个部分的元组。urlencode将一个字典对象转换为 URL 编码的字符串。quote 和 quote_plus对 URL 中的特殊字符进行编码其中 quote_plus 还会将空格转换为加号。unquote 和 unquote_plus对 URL 编码的字符串进行解码其中 unquote_plus 还会将加号转换为空格。
所以urllib.parse.urlencode 是 Python 中的一个函数用于将字典对象转换为 URL 编码的字符串。 具体来说它将字典对象中的键值对按照 key1value1key2value2 的格式进行拼接并进行 URL 编码。
import urllib.parse
import urllib.requestdata bytes(urllib.parse.urlencode({word: hello}), encodingutf8)
response urllib.request.urlopen(http://httpbin.org/post, datadata)
print(response.read())说明
http://httpbin.org是一个专门供开发者进行HTTP测试的网址关于它的使用参考https://blog.csdn.net/m0_58656539/article/details/127321217
上述代码就是对http://httpbin.org/post网址进行post请求并传入一个参数。
所以结果form表单里增加了我们传入的参数。urlopen函数的timeout参数第三个参数的使用 import socket
import urllib.request
import urllib.errortry:response urllib.request.urlopen(http://httpbin.org/get, timeout0.1)
except urllib.error.URLError as e:if isinstance(e.reason, socket.timeout):print(TIME OUT)说明
上述try下面代码如果出现超时就会报urllib.error.URLError错误。
如果发生了 URLError 异常我们使用 isinstance() 函数检查 e.reason 是否是 socket.timeout 类型的对象。如果是说明发生了超时错误。
在 urllib.error 模块中当发生网络请求超时时会引发 URLError 异常并将超时错误的原因存储在 reason 属性中。而在 socket 模块中socket.timeout 是用于表示网络请求超时的异常类。
isinstance() 是 Python 内置函数之一用于检查一个对象是否是指定类或其子类的实例。② 查看http请求的响应信息
import urllib.requestresponse urllib.request.urlopen(https://www.python.org)
print(type(response)) # 输出响应类型
print(response.status) # 输出响应状态码
print(response.getheaders()) # 输出响应头信息
print(response.getheader(Server)) # 输出响应头Server信息结果
class http.client.HTTPResponse
200
[(Connection, close), (Content-Length, 51167), (Report-To, {group:heroku-nel,max_age:3600,endpoints:[{url:https://nel.heroku.com/reports?ts1705569764sid67ff5de4-ad2b-4112-9289-cf96be89efeds8Pjqu5Qjh5kk00GkE%2FtctVoCTr%2BYJDoO4I%2BYiwcooqk%3D}]}), (Reporting-Endpoints, heroku-nelhttps://nel.heroku.com/reports?ts1705569764sid67ff5de4-ad2b-4112-9289-cf96be89efeds8Pjqu5Qjh5kk00GkE%2FtctVoCTr%2BYJDoO4I%2BYiwcooqk%3D), (Nel, {report_to:heroku-nel,max_age:3600,success_fraction:0.005,failure_fraction:0.05,response_headers:[Via]}), (Server, nginx), (Content-Type, text/html; charsetutf-8), (X-Frame-Options, SAMEORIGIN), (Via, 1.1 vegur, 1.1 varnish, 1.1 varnish), (Accept-Ranges, bytes), (Date, Thu, 18 Jan 2024 09:58:53 GMT), (Age, 2160), (X-Served-By, cache-iad-kiad7000025-IAD, cache-nrt-rjtf7700050-NRT), (X-Cache, HIT, HIT), (X-Cache-Hits, 3, 848), (X-Timer, S1705571934.524562,VS0,VE0), (Vary, Cookie), (Strict-Transport-Security, max-age63072000; includeSubDomains; preload)]
nginx③ 另一个请求方法Request
urllib.request 模块中的 urllib.request.Request() 方法用于创建一个 HTTP 请求对象可以在请求中指定 URL、请求方法、请求头部信息和请求体数据等参数。
该方法的语法如下
urllib.request.Request(url, dataNone, headers{}, origin_req_hostNone, unverifiableFalse, methodNone)其中各参数的含义如下
url必填需要请求的 URL 地址。data选填需要在请求中传递的数据。如果不需要传递数据可以将其设为 None。headers选填指定请求头部信息。默认为空字典。origin_req_host选填指定原始请求主机名用于处理 HTTP 重定向。默认为 None。unverifiable选填指定请求是否可验证。默认为 False。method选填指定 HTTP 请求方法。如果不指定则默认使用 GET 方法。 他跟之前的方法urlopen是有一些区别的 功能不同 urllib.request.urlopen()用于发送 HTTP/HTTPS 请求并获取响应内容。urllib.request.Request()用于创建一个 HTTP 请求对象但并不直接发送请求或获取响应。之前的urlopen方法不能设置响应头等等信息Request方法就比较全面了。 使用方式不同 urllib.request.urlopen() 是一个函数直接调用即可发送请求和获取响应。示例response urllib.request.urlopen(url)urllib.request.Request() 是一个类需要使用该类的实例来创建一个请求对象然后通过 urlopen() 方法发送请求并获取响应。示例req urllib.request.Request(url) 和 response urllib.request.urlopen(req) 参数传递方式不同 urllib.request.urlopen() 直接接受 URL 字符串作为参数可以额外传递一些参数如超时时间、代理等。urllib.request.Request() 的参数更为灵活可以指定 URL、请求方法、请求头部信息、请求体数据等多个参数。 示例 from urllib import request, parseurl http://httpbin.org/post
headers {User-Agent: Mozilla/4.0 (compatible; MSIE 5.5; Windows NT),Host: httpbin.org
}
dict {name: Germey
}
data bytes(parse.urlencode(dict), encodingutf8)
req request.Request(urlurl, datadata, headersheaders, methodPOST)
response request.urlopen(req)
print(response.read().decode(utf-8))# ----------------------------------------------from urllib import request, parseurl http://httpbin.org/post
dict {name: Germey
}
data bytes(parse.urlencode(dict), encodingutf8)
req request.Request(urlurl, datadata, methodPOST)
req.add_header(User-Agent, Mozilla/4.0 (compatible; MSIE 5.5; Windows NT))
response request.urlopen(req)
print(response.read().decode(utf-8))# 说明
# 上面代码通过Request方法传入了url、data、headers、method等参数。构建了一个请求对象。
# 还可以通过add_header方法向请求对象添加header参数。④ Handler 处理请求和响应 Cookie 存储用户信息
按照前面的方法可以爬取大部分的网页了但还有一些高级用法比如设置Handler代理设置Cookie等。 Handler 在 Python 的 urllib.request 模块中Handler 是一种处理器用于处理特定类型的请求或响应。它是一个抽象基类提供了一些方法和属性可以根据需要进行子类化和自定义。 常见的 Handler 类包括 ProxyHandler、HTTPHandler、HTTPSHandler、FileHandler 等。
ProxyHandler用于设置代理服务器将请求转发到代理服务器进行访问。HTTPHandler处理 HTTP 请求的默认处理器。HTTPSHandler处理 HTTPS 请求的默认处理器。与 HTTPHandler 类似但支持 SSL 加密。FileHandler用于处理本地文件的处理器。
import urllib.requestproxy_handler urllib.request.ProxyHandler({http: http://127.0.0.1:9743,https: https://127.0.0.1:9743
})
opener urllib.request.build_opener(proxy_handler)
response opener.open(http://httpbin.org/get)
print(response.read())#说明
这段代码是使用Python的urllib库来发送HTTP请求并通过设置代理服务器来访问一个网址。
首先我们导入了urllib.request模块它提供了发送HTTP请求的功能。
然后我们创建了一个代理处理程序ProxyHandler它告诉我们要使用代理服务器来发送请求。代理服务器是一个中间服务器可以帮助我们访问其他网站。
ProxyHandler是urllib.request模块提供的一个处理器类它允许你在请求中指定代理服务器。构造ProxyHandler对象时你需要传入一个字典作为参数其中包含了不同协议对应的代理服务器地址。
在你的代码中字典中有两个键值对http: http://127.0.0.1:59242表示使用HTTP协议时要使用的代理服务器地址是http://127.0.0.1:59242。https: https://127.0.0.1:59242表示使用HTTPS协议时要使用的代理服务器地址是https://127.0.0.1:59242。
这个端口是代理服务器的端口
通过将这个ProxyHandler对象传递给build_opener()函数创建了一个自定义的URL打开器opener。这个opener会在发送请求时使用你指定的代理服务器以及其他的一些设置。
当你调用opener.open(https://www.baidu.com/)时它会使用配置好的代理服务器向https://www.baidu.com/发送GET请求并返回响应。Cookie cookie是在客户端保存的一种用来记录用户身份的文本文件。 详细来说 Cookie是一种在客户端如浏览器和服务器之间传递的小型数据文件。
它由服务器生成并发送给客户端然后客户端将其存储并在每次向服务器发送请求时将其包含在请求中。Cookie通常用于实现会话管理和状态跟踪。服务器可以使用Cookie来存储和检索有关用户的信息以便在不同的HTTP请求之间保持会话状态。例如当你登录一个网站时服务器可能会生成一个包含用户身份验证信息的Cookie并将其发送给你的浏览器。浏览器会将Cookie保存下来在以后的请求中自动包含该Cookie这样服务器就能够识别你并维持你的登录状态。
Cookie可以包含各种信息例如用户ID、购物车内容、用户首选项等。它们可以被服务器读取和修改但只能由与生成Cookie的服务器具有相同域名的服务器进行访问。此外Cookie还可以设置过期时间以控制其有效期。
虽然Cookie在提供了方便的会话管理和状态跟踪功能的同时也存在一些安全和隐私方面的考虑。因此浏览器通常提供了一些设置选项让用户可以选择是否接受或删除Cookie并限制Cookie的使用。
#示例1
import http.cookiejar, urllib.requestcookie http.cookiejar.CookieJar()
handler urllib.request.HTTPCookieProcessor(cookie)
opener urllib.request.build_opener(handler)
response opener.open(http://www.baidu.com)
for item in cookie:print(item.nameitem.value)
说明
这段代码的作用是使用http.cookiejar模块与urllib.request模块来获取并打印访问百度网站时返回的 Cookie。
首先我们创建了一个CookieJar对象来存储 Cookie。然后我们创建了一个HTTPCookieProcessor对象并将其与CookieJar对象进行绑定。接下来我们使用build_opener方法创建了一个自定义的OpenerDirector对象并将CookieHandler传递给它。这样做是为了使用包含 Cookie 的请求进行访问。CookieJar是一个容器用于存储和管理HTTP请求和响应中的Cookie的类。
HTTPCookieProcessor也是一个Handler处理器用于自动处理HTTP请求和响应中的Cookie。
简而言之HTTPCookieProcessor是处理Cookie的工具而CookieJar是存储和管理Cookie的容器。它们可以结合使用实现方便的Cookie管理和跟踪功能。总结这一段代码跟上一段很像。都是先制作一个handler处理器上面是处理代理服务器的这个是处理cookie的。而且这个处理器绑定了一个cookie容器。然后同样去创建一个url启动器opener去打开指定的网址
#示例2
import http.cookiejar, urllib.request
filename cookie.txt
cookie http.cookiejar.MozillaCookieJar(filename)
handler urllib.request.HTTPCookieProcessor(cookie)
opener urllib.request.build_opener(handler)
response opener.open(http://www.baidu.com)
cookie.save(ignore_discardTrue, ignore_expiresTrue)
说明
CookieJar类是一个通用的cookie容器可以保存所有类型的cookie而MozillaCookieJar类则是一个特定类型的cookie容器只能保存Mozilla浏览器如Firefox生成的cookie。
该对象可以将cookie保存到本地文件中。在创建MozillaCookieJar对象时需要指定一个文件名以便将cookie保存到该文件中。CookieJar有很多的子类CookieJar类以及其子类例如LWPCookieJar和MozillaCookieJar提供了许多有用的方法和属性用于加载、保存和管理cookie信息。⑤ 异常处理
error是Python标准库中urllib模块中包含的一个模块用于表示与URL操作相关的错误。 在error模块中包含了多个异常类用于表示不同类型的URL操作错误。其中比较常用的异常类包括
error中的异常类名描述说明URLError表示与URL相关的错误例如网络连接问题、DNS查询失败、URL格式错误等。HTTPError表示HTTP请求返回的错误状态码例如404 Not Found、500 Internal Server Error等。ContentTooShortError表示下载的内容过短可能是由于网络连接中断等原因导致的。HTTPWarning表示HTTP响应中包含了警告信息例如缺失的响应头部字段等。
python中的异常捕获语句 格式
try:# 可能会抛出异常的代码块
except ExceptionType1 as e1:# 处理 ExceptionType1 类型的异常
except ExceptionType2 as e2:# 处理 ExceptionType2 类型的异常
except:# 处理其他类型的异常
else:# 如果没有发生异常执行的代码块
finally:# 无论是否发生异常都会执行的代码块示例
# 1
from urllib import request, error
try:response request.urlopen(http://www.baidu.com)
except error.URLError as e:print(e.reason)
# 上述代码使用了urllib模块中的request和error子模块并结合try-except语句来处理URL操作可能出现的异常。
# e.reason属性返回一个字符串其中包含了引起异常的具体原因# 2
from urllib import request, errortry:response request.urlopen(http://www.baidu.com)
except error.HTTPError as e:print(e.reason, e.code, e.headers, sep\n)
except error.URLError as e:print(e.reason)
else:print(Request Successfully)
# 刚才的代码只处理了error.URLError异常而这段代码处理了两种类型的异常error.HTTPError和error.URLError。
# 这段代码使用了两个except语句块分别捕获error.HTTPError和error.URLError异常。在发生异常时会根据异常的类型执行对应的except语句块。如果没有发生异常则会执行else语句块表示请求成功。
# 此外error.HTTPError异常类还提供了reason、code和headers等属性用于获取错误原因、状态码和响应头信息。在捕获到该异常时可以使用这些属性来详细了解HTTP请求返回的错误信息。# 3
import socket
import urllib.request
import urllib.errortry:response urllib.request.urlopen(https://www.baidu.com, timeout0.01)
except urllib.error.URLError as e:print(type(e.reason))if isinstance(e.reason, socket.timeout):print(TIME OUT)
# 这段代码与刚才的代码相比只捕获了error.URLError异常并且增加了对超时异常的处理。当URL请求超时时会打印TIME OUT。
# isinstance()函数判断e.reason是否是socket.timeout类型的异常如果是则打印TIME OUT。
# 知识点补充
# socket.timeout是在Python中用于表示套接字超时的异常类型。当套接字在指定的时间内没有响应时将引发此异常。
# isinstance()是Python内置函数之一用于检查一个对象是否是指定类或其子类的实例。它的语法格式如下isinstance(object, classinfo)⑥ url解析 urlparse urlparse是Python标准库中urllib.parse模块提供的一个函数用于解析URL统一资源定位符字符串并将其拆分为不同的组成部分。它的作用是方便地对URL进行解析和提取信息。
urlparse函数的语法如下: urllib.parse.urlparse(urlstring, scheme‘’, allow_fragmentsTrue)
其中urlstring是要解析的URL字符串scheme是可选的默认协议前提是URL字符串没有指定协议allow_fragments表示是否允许片段标识符即#后面的部分。 urlparse函数将URL字符串解析为一个包含以下属性的命名元组namedtuple
scheme协议如http、https等netloc网络位置通常是主机名和端口号path路径部分params参数部分query查询字符串部分fragment片段标识符部分
举例
from urllib.parse import urlparseresult urlparse(http://www.baidu.com/index.html;user?id5#comment)
print(type(result), result)
print(result.scheme)
print(result.netloc)
print(result.path)# 结果
# class urllib.parse.ParseResult ParseResult(schemehttp, netlocwww.baidu.com, path/index.html, paramsuser, queryid5, fragmentcomment)
# http
# www.baidu.com
# /index.html# 示例2
from urllib.parse import urlparseresult urlparse(http://www.baidu.com/index.html#comment, schemehttpsallow_fragmentsFalse)
print(result)# 结果
# ParseResult(schemehttp, netlocwww.baidu.com, path/index.html#comment, params, query, fragment)urlunparse urlunparse 是 Python 标准库中的一个函数跟urlparse相反用于将 URL 元组由以下 6 个部分组成协议、网络位置、路径、参数、查询字符串和片段标识符转换回 URL 字符串。函数定义如下
urllib.parse.urlunparse(parts)其中参数 parts 是一个包含 6 个元素的元组分别对应 URL 的各个部分。如果某些部分没有值则可以使用空字符串表示。
举例
from urllib.parse import urlunparsedata [http, www.baidu.com, index.html, user, a6, comment]
print(urlunparse(data))# 结果
# http://www.baidu.com/index.html;user?a6#commenturljoin urljoin 是 Python 标准库中 urllib.parse 模块提供的一个函数用于将一个基础 URL 和一个相对 URL 进行合并生成一个完整的 URL。
相对 URL 是相对于基础 URL 的路径可以是一个相对路径如 /path/to/resource或一个带有协议和网络位置的相对 URL如 http://www.example.com/path/to/resource。urljoin 函数会将这两个 URL 进行合并生成最终的 URL。
urllib.parse.urljoin(base, url)其中base 参数是基础 URLurl 参数是相对 URL。urljoin 会根据这两个 URL 的关系进行合并并返回合并后的结果。
from urllib.parse import urljoinprint(urljoin(http://www.baidu.com, aaa.html))
print(urljoin(http://www.baidu.com, https://www.bilibili.com/aaa.html))
print(urljoin(http://www.baidu.com/aaa.html, https://www.bilibili.com/bbb.html))
print(urljoin(http://www.baidu.com/aaa.html, https://www.bilibili.com/bbb.html?question2))
print(urljoin(http://www.baidu.com, ?category2#comment))
print(urljoin(www.baidu.com, ?category2#comment))
print(urljoin(www.baidu.com#comment, ?category2))
print(urljoin(http://www.baidu.com#comment, ?category2))
# 说明
# http://www.baidu.com/aaa.html
# https://www.bilibili.com/aaa.html
# https://www.bilibili.com/bbb.html
# https://www.bilibili.com/bbb.html?question2
# http://www.baidu.com?category2#comment
# www.baidu.com?category2#comment
# www.baidu.com?category2
# http://www.baidu.com?category2
# 最后一句说明在URL中#符号表示片段标识符Fragment用于指定页面中的特定部分或锚点。在使用 urljoin 函数合并URL时如果相对URL中包含了查询字符串?category2那么它会替换基础URL中的查询字符串同时也会去掉基础URL中的片段标识符。urlencode urlencode 是 Python 标准库中的 urllib.parse 模块提供的一个函数用于将字典或具有类似结构的可迭代对象转换为 URL 编码的查询字符串。
格式
urllib.parse.urlencode(query, doseqFalse, safe, encodingNone, errorsNone, quote_viaquote_plus)query 参数是一个字典或可迭代对象表示要编码的查询参数。doseq 参数默认为 False指示是否处理具有相同键的多个值。safe 参数指定不需要进行编码的字符集合。encoding 参数指定编码方式默认为 UTF-8。errors 参数指定在编码过程中遇到错误时的处理方式。quote_via 参数指定引用方式默认为 quote_plus即使用加号替换空格。
举例
from urllib.parse import urlencodeparams {name: germey,age: 22
}
base_url http://www.baidu.com?
url base_url urlencode(params)
print(url)# 结果http://www.baidu.com?namegermeyage222 Requests库的基本使用
urllib库虽然可以完成很多操作但是实现起来还是有点不太方便的。比如添加代理、处理cookie等。 requests是一个更加强大的库有了它可以使用几句代码就可以完成很多功能。
requests是一个常用的 Python 第三方库用python语言编写基于urllib采⽤Apache2 Licensed 开源协议的 HTTP 库。用于发送 HTTP 请求和处理响应。它提供了简洁而直观的 API使得 HTTP 请求变得容易。
它比 urllib 更更加⽅方便便可以节约我们⼤大量量的⼯工作完全满⾜足HTTP 测试需求。 一句话——Python实现的简单易易⽤用的HTTP库
① 模块的简单使用
通过一个例子来简单说一下requests模块的使用。
import requestsresponse requests.get(https://www.baidu.com/)
print(type(response))
print(response.status_code)
print(type(response.text))
print(response.text)
print(response.cookies)# 说明
# 这段代码使用了 Python 的 requests 库发送了一个 GET 请求到百度网站并输出了一些请求的返回信息。② requests模块的各种请求方式
import requests
requests.post(http://httpbin.org/post)
requests.put(http://httpbin.org/put)
requests.delete(http://httpbin.org/delete)
requests.head(http://httpbin.org/get)
requests.options(http://httpbin.org/get)# 说明这段代码演示了使用 requests 库发送不同类型的 HTTP 请求当我们在进行网络通信时常用的HTTP请求方法有GET、POST、PUT、DELETE、HEAD和OPTIONS。 接下来详细解释一下每种请求的作用和特点
GET 作用从指定的资源请求数据。特点一般用于从服务器获取数据请求参数附加在URL后面可以被缓存有长度限制。 POST 作用向指定的资源提交要被处理的数据。特点一般用于向服务器发送数据请求参数附加在请求体中不会被缓存没有长度限制安全性更好。 PUT 作用向指定的资源位置上传最新内容。特点类似于POST但在语义上更加明确通常用于更新数据。 DELETE 作用从指定的资源位置删除内容。特点用于删除指定的资源。 HEAD 作用类似于GET请求只是返回的响应中没有具体的内容用于获取资源的元信息。特点可以用于检查资源是否存在、资源是否被修改等而不需要获取整个资源内容。 OPTIONS 作用用于获取目的URL所支持的HTTP方法。特点可以用于跨域请求时的预检请求以确定是否可以在实际请求中使用某个HTTP方法。
这些HTTP请求方法各自具有不同的作用和特点根据实际需求选择合适的请求方法可以更好地完成网络通信任务。
接下来从几个方面讲述requests模块的用法详情
③ 请求 基本GET请求 基本写法
import requestsresponse requests.get(http://httpbin.org/get)
print(response.text)带参数GET请求
# 1
import requests
response requests.get(http://httpbin.org/get?namegermeyage22)
print(response.text)# 2
import requestsdata {name: germey,age: 22
}
response requests.get(http://httpbin.org/get, paramsdata)
print(response.text)# 说明
# 1和2是一样的不过实际应用中都会用2方法方便修改
# 1中 ?namegermeyage22表示请求的查询参数以 ? 开头多个参数之间使用 进行分隔
# 2中 参数也可以以字典的形式保存通过params参数传到get方法解析json数据和str数据
import requests
import jsonresponse requests.get(http://httpbin.org/get)
print(type(response.text))
print(response.json())
print(json.loads(response.text))
print(type(response.json()))# 说明
# 上面的代码中先用get方法请求指定网址并将返回的响应保存在 response 变量中。
# 然后通过response.text方法获取响应内容的字符串格式数据
# response.json()方法是将返回的响应内容解析为 JSON 格式
# json.loads()方法用于将 JSON 格式的字符串转换为 Python 对象通常是字典或列表解析获取二进制数据
先认识一下requests中的两个语句的区别 response.content 和 response.text 是 requests 库中 Response 对象的两个属性用于获取响应内容。
返回数据类型方面
response.content 返回响应内容的字节形式bytes。response.text 返回响应内容的字符串形式str使用响应内容的编码来解码为字符串。
另外编码方面
response.content 不会对内容进行任何解码或编码处理直接返回原始的字节数据。response.text 会根据服务器返回的响应头中的编码信息如 “Content-Type” 的 charset 属性自动进行解码将字节数据转换为字符串。如果无法确定编码类型则会使用 UTF-8 进行解码。
使用场景方面
response.content 适合处理非文本文件如图片、音频、视频等二进制数据。你可以将这些数据保存到文件或进行其他的二进制处理。response.text 适合处理文本数据如 HTML、JSON、XML 等。你可以对文本数据进行字符串操作、解析或提取所需的信息。
import requestsresponse requests.get(https://github.com/favicon.ico)
print(type(response.text), type(response.content))
print(response.text)
print(response.content)添加headers
为什么要添加headers
在发送 HTTP 请求时服务器会根据请求的 User-Agent 头信息来判断发出请求的客户端类型和版本。如果该头信息缺失或不正确服务器可能会拒绝提供服务并返回错误响应。
一些网站会针对不同的 User-Agent 信息返回不同的响应内容例如移动设备版和桌面版的网站页面可能是不同的。在这种情况下如果没有正确设置 User-Agent 头信息可能会导致获取到不需要的响应内容或者被服务器拒绝访问。
# 例子
import requestsheaders {User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.116 Safari/537.36
}
response requests.get(https://www.zhihu.com/explore, headersheaders)
print(response.text)在以上的代码中我们使用了 requests 库发送了一个 GET 请求其中将 headers 参数设置为指定的 User-Agent 头信息。这样可以伪装成浏览器向服务器发送请求避免被服务器拒绝或获取到错误的响应内容。
总之添加 User-Agent 头信息可以提高请求的成功率并确保获取到正确的响应内容。 基本POST请求 POST 请求是一种 HTTP 请求方法主要用于向服务器提交数据比如表单数据、JSON 数据等。与 GET 请求不同POST 请求将请求参数放在请求体中而不是 URL 中。
POST 请求通常用于向服务器提交数据比如用户登录、注册、提交表单数据等操作。例如用户登录时需要向服务器发送用户名和密码这就可以通过 POST 请求将用户输入的数据提交到后端服务器进行验证和处理。
此外POST 请求还支持上传文件等功能。可以使用 POST 请求将文件数据提交到服务器以实现文件上传功能。
综上所述POST 请求是一种非常常见的 HTTP 请求方法用于向服务器提交数据或上传文件等操作。如果你需要向服务器传递数据或上传文件那么就需要发送一个 POST 请求。
# 举例
import requestsdata {name: germey, age: 22}
headers {User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.116 Safari/537.36
}
response requests.post(http://httpbin.org/post, datadata, headersheaders)
print(response.json())# 注意对于 requests.post 方法中的 data 参数它会被自动编码并作为请求体的内容发送到服务器。④ 响应 response属性 在使用 requests 库发送请求后返回的响应对象 response 中包含了许多有用的信息包括
status_code响应的状态码如 200 表示成功404 表示未找到资源500 表示服务器错误text响应的内容Unicode 格式。content响应的内容字节流格式。headers响应头信息是一个字典类型包含了响应的各种元数据比如 Content-Type、Content-Length 等。cookies响应的 Cookie 信息是一个字典类型包含了响应中的所有 Cookie 信息。url响应的 URL地址可能会发生重定向。encoding响应的编码方式。history它是一个列表包含了请求的历史记录。 当发送请求时如果遇到了重定向3xx 状态码requests 会自动处理重定向并将每个重定向的请求添加到 history 列表中。通过查看 history 列表你可以获取请求的完整重定向历史记录。需要注意的是response.history 列表中的第一个元素代表初始请求后续元素代表对应的重定向请求。因此如果没有发生重定向response.history 列表会为空。如果你想禁止 requests 自动处理重定向可以设置 allow_redirectsFalse 参数这样 response.history 列表将为空而响应对象中的 status_code 将是最终请求的状态码。
import requestsresponse requests.get(http://www.jianshu.com)
print(type(response.status_code), response.status_code)
print(type(response.headers), response.headers)
print(type(response.cookies), response.cookies)
print(type(response.url), response.url)
print(type(response.history), response.history)状态码判断 为什么要进行状态码的判断
在网络请求中状态码是服务器对请求的响应进行分类和传达信息的一种方式。通过检查状态码我们可以了解服务器对请求的处理情况例如是否成功、是否发生重定向、资源是否存在等。
常见的状态码有
2xx表示成功处理请求如 200 表示成功201 表示创建成功等。3xx表示重定向如 301 表示永久重定向302表示临时重定向等。4xx表示客户端错误如 404 表示资源未找到403 表示禁止访问等。5xx表示服务器错误如 500表示服务器内部错误503 表示服务不可用等。
可以根据状态码和描述信息来判断请求的处理结果并采取相应的处理措施。例如当状态码为 200 时可以继续处理返回的数据当状态码为 404 时可以提示用户请求的资源不存在当状态码为 500 时可以向用户显示服务器内部错误的提示信息。
请注意这只是常见状态码的一部分实际上还有更多的状态码可供使用。在实际开发中我们可以根据不同的业务需求和场景来选择适当的状态码。
# 1.
import requestsresponse requests.get(http://www.jianshu.com/hello.html)
exit() if not response.status_code requests.codes.not_found else print(404 Not Found)# 说明
# 1.格式操作1 if 条件 else 操作2 解释如果 条件 为真执行 操作1否则执行 操作2。
# 2.requests.codes.not_found 是 requests 库中定义的表示 404 的常量# 2.
import requestsresponse requests.get(http://www.jianshu.com)
exit() if not response.status_code 200 else print(Request Successfully)状态码及其含义
100: (continue,),
101: (switching_protocols,),
102: (processing,),
103: (checkpoint,),
122: (uri_too_long, request_uri_too_long),
200: (ok, okay, all_ok, all_okay, all_good, \\o/, ✓),
201: (created,),
202: (accepted,),
203: (non_authoritative_info, non_authoritative_information),
204: (no_content,),
205: (reset_content, reset),
206: (partial_content, partial),
207: (multi_status, multiple_status, multi_stati, multiple_stati),
208: (already_reported,),
226: (im_used,),# Redirection.
300: (multiple_choices,),
301: (moved_permanently, moved, \\o-),
302: (found,),
303: (see_other, other),
304: (not_modified,),
305: (use_proxy,),
306: (switch_proxy,),
307: (temporary_redirect, temporary_moved, temporary),
308: (permanent_redirect,resume_incomplete, resume,), # These 2 to be removed in 3.0# Client Error.
400: (bad_request, bad),
401: (unauthorized,),
402: (payment_required, payment),
403: (forbidden,),
404: (not_found, -o-),
405: (method_not_allowed, not_allowed),
406: (not_acceptable,),
407: (proxy_authentication_required, proxy_auth, proxy_authentication),
408: (request_timeout, timeout),
409: (conflict,),
410: (gone,),
411: (length_required,),
412: (precondition_failed, precondition),
413: (request_entity_too_large,),
414: (request_uri_too_large,),
415: (unsupported_media_type, unsupported_media, media_type),
416: (requested_range_not_satisfiable, requested_range, range_not_satisfiable),
417: (expectation_failed,),
418: (im_a_teapot, teapot, i_am_a_teapot),
421: (misdirected_request,),
422: (unprocessable_entity, unprocessable),
423: (locked,),
424: (failed_dependency, dependency),
425: (unordered_collection, unordered),
426: (upgrade_required, upgrade),
428: (precondition_required, precondition),
429: (too_many_requests, too_many),
431: (header_fields_too_large, fields_too_large),
444: (no_response, none),
449: (retry_with, retry),
450: (blocked_by_windows_parental_controls, parental_controls),
451: (unavailable_for_legal_reasons, legal_reasons),
499: (client_closed_request,),# Server Error.
500: (internal_server_error, server_error, /o\\, ✗),
501: (not_implemented,),
502: (bad_gateway,),
503: (service_unavailable, unavailable),
504: (gateway_timeout,),
505: (http_version_not_supported, http_version),
506: (variant_also_negotiates,),
507: (insufficient_storage,),
509: (bandwidth_limit_exceeded, bandwidth),
510: (not_extended,),
511: (network_authentication_required, network_auth, network_authentication)⑤ 高级操作 文件上传 import requestsfiles {file: open(favicon.ico, rb)}
response requests.post(http://httpbin.org/post, filesfiles)
print(response.text)可以使用post方法向服务器提交数据POST不仅可以提交简单的键值对数据还可以上传文件和传输大量数据。
requests.post() 方法是 Python requests 库中用于发送 HTTP POST 请求的函数。这个方法非常灵活提供了多个参数来定制请求。以下是 requests.post() 方法支持的常见参数及其说明
url (str): 请求的URL。data (optional, dict, bytes, or file-like object): 要发送到URL的正文数据。如果是字典类型数据会被自动编码为表单形式。json (optional, dict): JSON格式的数据如果指定了这个参数requests 会自动将其序列化为JSON字符串并设置Content-Type为application/json。headers (optional, dict): 字典类型的请求头。可以在这里指定请求头部信息如Content-Type、User-Agent等。cookies (optional, dict or CookieJar): 要随请求发送的Cookies。files (optional, dict): 文件上传。字典中的键是服务器端识别的表单字段名值是要上传的文件。值可以是一个元组(filename, fileobj)也可以是一个元组(filename, fileobj, content_type)还可以是一个元组(filename, fileobj, content_type, custom_headers)。timeout (optional, float or tuple): 设置请求超时时间以秒为单位。可以是一个浮点数表示连接和读取的总超时时间也可以是一个元组(connect_timeout, read_timeout)分别指定连接和读取的超时时间。 获取cookie import requestsresponse requests.get(https://www.baidu.com)
print(response.cookies)
for key, value in response.cookies.items():print(key value)
# 说明
# 这段Python代码使用了requests库来发送一个HTTP GET请求到百度的主页https://www.baidu.com然后打印出从响应中获得的cookies信息。
# response.cookies属性包含了服务器通过Set-Cookie头部发送回来的所有cookies。这个属性是一个RequestsCookieJar对象它提供了一个字典接口可以像操作字典那样操作cookies。# 总结
# 整个代码的作用是向百度的主页发送一个HTTP GET请求获取响应中的cookies并打印出每个cookie的名称和值。这对于理解如何使用requests库处理cookies以及如何从HTTP响应中获取和查看特定信息如cookies非常有帮助。
# Cookies通常用于服务器识别或跟踪访问者的状态例如用户登录状态、偏好设置等。通过查看响应中的cookies开发人员可以了解网站是如何配置和使用cookies的。会话维持 有了cookies就可以来完成会话维持、以及保持登陆状态的操作了
模拟登录
import requestsrequests.get(http://httpbin.org/cookies/set/number/123456789)
response requests.get(http://httpbin.org/cookies)
print(response.text)# 结果
{cookies: {}
}
# 说明
# 这段代码展示了如何使用Python的requests库来首先设置一个cookie然后获取该cookie。具体来说它通过两次对httpbin.org的GET请求演示了这一过程我们可以理解为用一个浏览器设置cookie再用下一个浏览器获取两个操作是独立的。想要完成模拟登录两次请求应该在一个浏览器中完成。
import requestss requests.Session()
s.get(http://httpbin.org/cookies/set/number/123456789)
response s.get(http://httpbin.org/cookies)
print(response.text)# 结果
{cookies: {number: 123456789}
}
# 说明
# Session对象是requests库中的一个特殊对象用于在多个HTTP请求之间保持某些参数的状态例如cookies、headers等。使用Session对象可以方便地管理和维护这些参数而不需要每次请求都重新设置它们。
# 使用Session对象设置的cookie将会在这个会话中被保留并且在第二个请求中正确返回使用Session对象的主要好处包括
自动处理cookiesSession对象会自动在每个请求中管理cookie的发送和接收。当你使用Session对象发送请求时它会自动跟踪并存储来自服务器的任何cookie并在后续的请求中自动将cookie添加到请求中。共享参数和状态Session对象可以在多个请求之间共享参数和状态。例如你可以在第一个请求中设置headers然后在后续的请求中重复使用相同的headers而无需每次请求都重新设置。提高性能使用Session对象可以更高效地执行多个请求。它会自动重用底层的TCP连接从而减少了建立和关闭连接的开销并且可以实现更好的性能。 证书验证 import requests
from requests.packages import urllib3
urllib3.disable_warnings()
response requests.get(https://www.12306.cn, verifyFalse)
print(response.status_code)# 说明
# 这段代码使用requests库发送了一个GET请求到https://www.12306.cn并打印了返回的响应状态码。和上一个例子不同的是在这个例子中还设置了verifyFalse参数并禁用了urllib3警告。
# 通过调用urllib3.disable warnings()方法禁用urllib3警告。这是因为在向HTTPS网站发送请求时ur11ib3 会发出安全警告默认情况下这些警告是启用的通常情况下这些警告是有用的可以帮助我们识别可能存在的安全问题。但在某些情况下例如访问受信任的内部网站或测试环境时这些警告可能是干扰性的。因此在这里禁用了它们。
# 接着使用 reguests.get()方法发送一个GET请求到目标URL注意到这里还设置了 verifyfa1se 参数用于关闭SSL证书验证。这是因为一些网站的安全证书可能会过期或无法验证导致reqpest库无法建立安全连接。在这种情况下如果你仍然想要向该网站发送请求可以使用 verifyfa1se参数关闭证书验证。需要注意的是关闭证书验证可能会带来安全风险因此建议仅在测试环境中使用。# from requests.packages import urllib3语句说明
# 这段代码从requests.packages模块中导入了 urllib3 模块。 urllib3模块是一个独立的HTTP库用于处理与HITP相关的底层细节例如连接池管理、请求重试、SSL验证等。reguests 库是基于 ur11ib3 库构建的因此在使用 requests 库时 ur11ib3 通常是白动加载的无需手动导入。
# 不过在某些情况下我们可能需要直接使用 urllib3库中的一些功能例如禁用SSL证书验证、关闭警告等。在这种情况下我们需要手动导入 urllib3 模块并使用其中的方法和属性需要注意的是由于 requests 库是基于 urllib3 库构建的因此在使用 requests库时也可以通过 requests.packages.urllib3 模块来访问 urllib3 库中的方法和属性例如可以使用requests.packages.urllib3.disable_warnings()方法禁用 urllib3 整告。import requestsresponse requests.get(https://www.12306.cn, cert(/path/server.crt, /path/key))
print(response.status_code)解释# 说明
# 这段代码使用 requests 库发送了一个 GET 请求到 https://www.12306.cn 网站并指定了证书文件路径。
# 在这段代码中cert 参数用于指定客户端的证书文件路径。证书文件通常由一对公私钥组成分别是 .crt 和 .key 文件。这些证书文件用于与服务器建立安全的 HTTPS 连接。
# 注意在实际使用时需要将 /path/server.crt 和 /path/key 替换为实际的证书文件路径。此外还要确保请求的网站支持客户端证书认证并且提供了正确的证书文件。代理设置 之前在urllib3里面用过类似的功能接下来使用以下requests中的代理设置
import requestsproxies {http: http://127.0.0.1:9743,https: https://127.0.0.1:9743,
}response requests.get(https://www.taobao.com, proxiesproxies)
print(response.status_code)# 说明
# 这段代码使用requests库发送一个GET请求到淘宝网并通过代理服务器进行连接。其中代理服务器的地址为http://127.0.0.1:9743HTTP和https://127.0.0.1:9743HTTPS
# 代理字典proxies其中包含了两个键值对分别用于指定HTTP和HTTPS代理服务器的地址。知识补充 requests.get()方法用于发送HTTP GET请求并可以接受多个参数来自定义请求。
以下是requests.get()方法常用的参数
url必需要发送请求的URL地址。params以字典形式传递的请求参数将会被拼接到URL中作为查询字符串。headers以字典形式传递的请求头信息用于模拟浏览器发送请求时的头部信息。cookies以字典形式传递的Cookie信息用于在请求中发送Cookie。auth用于HTTP身份验证的认证信息可以使用HTTPBasicAuth等对象进行设置。timeout设置请求超时时间单位为秒。如果在指定的时间内没有得到响应将会引发Timeout异常。allow_redirects表示是否允许重定向默认为True。如果设为False则不会自动处理重定向。proxies以字典形式传递的代理服务器信息用于将请求通过代理服务器发送。verify设置是否验证SSL证书默认为True。如果设为False将会跳过SSL证书验证。stream设置是否使用流式传输默认为False。如果设为True可以通过迭代器逐块访问响应内容。params以字典形式传递的请求参数将会被拼接到URL中作为查询字符串。其他可选参数如cert、proxies、hooks等用于进一步自定义请求。
import requestsproxies {http: http://user:password127.0.0.1:9743/,
}
response requests.get(https://www.taobao.com, proxiesproxies)
print(response.status_code)# 代码使用了代理服务器来发送HTTP请求。其中代理服务器的地址为http://127.0.0.1:9743/并且需要提供用户名和密码进行身份验证。
# 定义了一个代理字典proxies其中的http键指定了HTTP代理服务器的地址。同时在地址中user:password部分是用于代理服务器身份验证的用户名和密码你需要将它们修改为实际的值。
# 有时候服务器要求客户端提供用户名和密码进行身份验证的情况。当你使用代理服务器时服务器可以要求客户端提供身份验证信息以确定是否授权该客户端通过代理服务器访问目标资源。
# 需要注意的是代理服务器是否要求客户端提供用户名和密码进行身份验证以及具体的验证方式都是由服务器配置决定的。某些代理服务器可能不需要身份验证或者使用其他身份验证方式如令牌、证书等。因此在使用代理服务器时你需要根据实际情况提供正确的身份验证信息。
# 代理服务器需要用户名和密码进行身份验证的原因有以下几点安全性、访问控制、账单计费、追踪和监视pip3 install requests[socks]
# pip3 install requests[socks]是安装了名为requests的Python库并使用了socks附加选项。
# [socks]是一个可选的附加选项表示安装requests库时包含对SOCKS代理的支持。SOCKSSocket Secure是一种网络协议允许客户端通过代理服务器与远程主机进行通信。通过安装requests[socks]你可以在使用requests库发送请求时选择使用SOCKS代理进行连接。import requestsproxies {http: socks5://127.0.0.1:9742,https: socks5://127.0.0.1:9742
}
response requests.get(https://www.taobao.com, proxiesproxies)
print(response.status_code)# 这段代码使用requests库发送了一个GET请求到https://www.taobao.com网站并通过SOCKS代理服务器进行连接。
# 使用HTTP代理可能会导致一些限制例如不支持所有类型的网络流量无法达到SOCKS代理的灵活性和安全性等。因此如果您需要使用SOCKS代理最好还是安装requests[socks]并使用SOCKS协议进行连接。
使用SOCKS代理相对于HTTP代理有一些优点和特性这取决于你的具体需求和使用场景。- 支持更多的协议SOCKS代理可以支持TCP、UDP和ICMP等多种协议而HTTP代理仅支持HTTP协议。如果你需要在应用程序中使用非HTTP协议例如使用FTP、SMTP、SSH等协议那么使用SOCKS代理是必要的。- 支持远程DNS解析使用SOCKS代理时DNS解析通常在代理服务器上进行可以避免本地DNS污染和泄漏敏感信息。- 更高的灵活性SOCKS代理可以通过代理服务器与远程主机直接建立连接而不仅仅是通过代理服务器转发HTTP请求。这样可以实现更高级的代理功能如客户端和服务器之间的双向通信。- 更好的安全性SOCKS代理可以通过身份验证和加密来保护代理连接和传输的数据提供更高的安全性。
然而使用SOCKS代理也有一些限制和注意事项- 安装和配置复杂相对于HTTP代理设置和配置SOCKS代理可能会更加复杂需要更多的操作步骤和设置。- 不被所有应用程序支持并非所有的应用程序都直接支持SOCKS代理特别是一些移动设备上的应用程序可能只支持HTTP代理。超时设置 import requests
from requests.exceptions import ReadTimeout
try:response requests.get(http://httpbin.org/get, timeout 0.5)print(response.status_code)
except ReadTimeout:print(Timeout)
# 这段代码使用了Python的requests库来发送HTTP GET请求。它向http://httpbin.org/get发起请求并设置了一个0.5秒的超时时间。
# 这行代码导入了requests库中的ReadTimeout异常。ReadTimeout是requests库中的一个异常类它表示请求超时。当requests库在指定时间内未接收到服务器响应时就会抛出这个异常。
知识补充
requests库中的exceptions模块提供了一系列异常类用于处理在使用requests发送HTTP请求时可能出现的各种错误和异常情况。以下是一些常见的异常类- RequestException是所有requests库异常的基类用于捕获所有请求相关的异常。- HTTPError在请求返回非成功状态码时引发的异常如404 Not Found。- ConnectionError当请求遇到网络连接问题时引发的异常例如DNS解析失败、无法建立连接等。- Timeout在请求超时时引发的异常。 - TooManyRedirects当请求重定向次数过多时引发的异常。 - SSLError在与HTTPS请求相关的SSL验证问题时引发的异常。认证设置 import requests
from requests.auth import HTTPBasicAuthr requests.get(http://120.27.34.24:9001, authHTTPBasicAuth(user, 123))
print(r.status_code)
# 这段代码使用requests库来向http://120.27.34.24:9001发送HTTP GET请求并使用HTTP基本认证对请求进行身份验证。HTTPBasicAuth是requests库中的一个HTTP身份验证类它提供了基本的用户名和密码验证机制。
# 具体地说我们通过auth参数传递HTTPBasicAuth(user, 123)其中user和123分别表示用户名和密码。这样就可以在请求头中添加Authentication字段用于身份验证。
知识点补充
认证设置是在进行网络通信时验证用户身份的一种机制。它用于确保只有经过授权的用户才能访问特定的资源或执行特定的操作。
认证的目的是保护敏感数据和资源防止未经授权的访问和滥用。通过对用户进行身份验证系统可以确认用户的身份并根据其权限决定是否允许其执行请求的操作。
常见的认证方式包括- 基本认证Basic Authentication使用用户名和密码进行身份验证并将其编码后加在请求头中发送给服务器。- 摘要认证Digest Authentication类似于基本认证但在传输过程中对密码进行了摘要处理提高了安全性。- 令牌认证Token Authentication通过生成和验证令牌来进行身份验证而不是直接传输用户名和密码。- OAuth认证OAuth Authentication用于授权第三方应用程序访问用户资源而无需共享用户名和密码。
认证的主要目的是确保只有合法用户能够访问受限资源保护用户隐私和数据安全。通过身份验证系统可以对用户进行身份验证和跟踪同时也为用户提供了个性化的服务和权限管理。import requestsr requests.get(http://120.27.34.24:9001, auth(user, 123))
print(r.status_code)# 这段代码使用requests库向http://120.27.34.24:9001发送HTTP GET请求并使用HTTP基本认证对请求进行身份验证。在这里我们使用了简化的方式来设置认证通过auth参数传递元组(user, 123)其中user是用户名123是密码。总体来说如果需要更加灵活地控制认证处理过程建议使用第一种方式如果只是简单地进行身份验证可以使用第二种方式。 异常处理 import requests
from requests.exceptions import ReadTimeout, ConnectionError, RequestException
try:response requests.get(http://httpbin.org/get, timeout 0.5)print(response.status_code)
except ReadTimeout:print(Timeout)
except ConnectionError:print(Connection error)
except RequestException:print(Error)
# 这段代码使用requests库发送HTTP GET请求到http://httpbin.org/get并设置了一个超时时间为0.5秒。然后通过try-except语句捕获可能发生的异常。
# 首先如果在0.5秒内无法得到响应将触发ReadTimeout异常代码将打印Timeout。
# 其次如果在建立连接时出现问题例如网络连接不可用或服务器无响应将触发ConnectionError异常代码将打印Connection error。
# 最后如果发生其他请求相关的异常将触发RequestException异常代码将打印Error。3 BeautifulSoup库详解
BeautifulSoup是一个灵活又方便的网页解析库处理高效支持多种解析器。用于从HTML和XML文件中提取数据。它提供了一种简单的方式来遍历解析HTML或XML文档并提取所需的信息例如链接、段落、标题、图片等。
利用它不用编写正则表达式即可方便地实现网页信息的提取它提供了一组简单的API使得从HTML和XML文档中提取数据变得更加容易和直观。
在使用BeautifulSoup库时通常需要先将HTML或XML文档加载到内存中并使用指定的解析器进行解析。然后可以使用BeautifulSoup对象提供的方法和属性来查找和提取所需的信息。
① 解析库
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, “xml”)速度快、唯一支持XML的解析器需要安装C语言库html5libBeautifulSoup(markup, “html5lib”)最好的容错性、以浏览器的方式解析文档、生成HTML5格式的文档速度慢、不依赖外部扩展
② 基本使用
html
htmlheadtitleThe Dormouses story/title/head
body
p classtitle namedromousebThe Dormouses story/b/p
p classstoryOnce upon a time there were three little sisters; and their names were
a hrefhttp://example.com/elsie classsister idlink1!-- Elsie --/a,
a hrefhttp://example.com/lacie classsister idlink2Lacie/a and
a hrefhttp://example.com/tillie classsister idlink3Tillie/a;
and they lived at the bottom of a well./p
p classstory.../pfrom bs4 import BeautifulSoup
soup BeautifulSoup(html, lxml)
print(soup.prettify())
print(soup.title.string)# 说明
# 在这段代码中首先使用BeautifulSoup将HTML字符串解析成一个文档树对象soup然后通过调用prettify()方法对文档树进行格式化使其更易于阅读。接着使用print语句打印格式化后的HTML内容。
# 接下来通过soup.title.string可以提取HTML中的标题内容。这行代码的意思是从解析后的文档树对象soup中找到title标签并获取其文本内容。最后通过print语句打印标题的内容。
# prettify() 是 BeautifulSoup 对象的一个方法它可以将解析的 HTML 文档树进行缩进和格式化使其更易于阅读和理解。这对于调试和查看解析结果非常有用。③ 标签选择器
html
htmlheadtitleThe Dormouses story/title/head
body
p classtitle namedromousebThe Dormouses story/b/p
p classstoryOnce upon a time there were three little sisters; and their names were
a hrefhttp://example.com/elsie classsister idlink1!-- Elsie --/a,
a hrefhttp://example.com/lacie classsister idlink2Lacie/a and
a hrefhttp://example.com/tillie classsister idlink3Tillie/a;
and they lived at the bottom of a well./p
p classstory.../p选择元素 from bs4 import BeautifulSoup
soup BeautifulSoup(html, lxml)
print(soup.title)
print(type(soup.title))
print(soup.head)
print(soup.p)# 说明
# 这段代码使用 BeautifulSoup 库解析了一个 HTML 字符串并对解析后的对象进行了一些操作。
# print(soup.title)这行代码打印了解析后文档对象中的 title 标签以及其内容。如果存在多个 title 标签该方法只会返回第一个找到的 title 标签及其内容。
# print(type(soup.title))这行代码打印了 soup.title 的数据类型。在这里soup.title 返回的是一个 BeautifulSoup 的 Tag 对象因此打印结果应该是 class bs4.element.Tag表示这是一个标签对象。
# print(soup.head)这行代码打印了解析后文档对象中的 head 标签以及其内容。和 soup.title 类似如果存在多个 head 标签该方法只会返回第一个找到的 head 标签及其内容。
# print(soup.p)这行代码尝试打印解析后文档对象中的 p 标签以及其内容。然而在 HTML 示例中并没有 p 标签的直接子标签所以这行代码会打印出 None表示在当前文档中没有找到符合条件的标签。获取名称 from bs4 import BeautifulSoup
soup BeautifulSoup(html, lxml)
print(soup.title.name)获取属性 from bs4 import BeautifulSoup
soup BeautifulSoup(html, lxml)
print(soup.p.attrs[name])
print(soup.p[name])获取内容 from bs4 import BeautifulSoup
soup BeautifulSoup(html, lxml)
print(soup.p.string)嵌套选择 from bs4 import BeautifulSoup
soup BeautifulSoup(html, lxml)
print(soup.head.title.string)子节点和子孙节点 html
htmlheadtitleThe Dormouses story/title/headbodyp classstoryOnce upon a time there were three little sisters; and their names werea hrefhttp://example.com/elsie classsister idlink1spanElsie/span/aa hrefhttp://example.com/lacie classsister idlink2Lacie/a anda hrefhttp://example.com/tillie classsister idlink3Tillie/aand they lived at the bottom of a well./pp classstory.../pfrom bs4 import BeautifulSoup
soup BeautifulSoup(html, lxml)
print(soup.p.contents)print(soup.p.children)
for i, child in enumerate(soup.p.children):print(i, child)print(soup.p.descendants)
for i, child in enumerate(soup.p.descendants):print(i, child)# 说明
# print(soup.p.contents) 这行代码是为了获取 p 标签的所有子节点。在这里p 标签有一个文本节点和三个子链接节点a 标签。.contents 属性可以用于返回一个列表其中包含了该标签的所有子节点包括文本节点。
# print(soup.p.children) 这行代码是为了获取 p 标签的所有子节点的迭代器。与 contents 属性不同.children 属性可以用于返回一个迭代器其中包含了该标签的所有子节点同样包括文本节点。
# enumerate() 函数是 Python 内置函数之一用于将一个可迭代对象如列表、元组、字符串等转换为一个枚举对象同时返回索引和对应的值。
# soup.p.descendants 这行代码是为了获取 p 标签的所有子孙节点的迭代器。.descendants 属性会递归地遍历所有子节点包括子节点的子节点以此类推直到最底层的子节点叶子节点。父节点和祖先节点 html
htmlheadtitleThe Dormouses story/title/headbodyp classstoryOnce upon a time there were three little sisters; and their names werea hrefhttp://example.com/elsie classsister idlink1spanElsie/span/aa hrefhttp://example.com/lacie classsister idlink2Lacie/a anda hrefhttp://example.com/tillie classsister idlink3Tillie/aand they lived at the bottom of a well./pp classstory.../pfrom bs4 import BeautifulSoup
soup BeautifulSoup(html, lxml)
print(soup.a.parent)print(list(enumerate(soup.a.parents)))# 说明
# soup.a.parent 这行代码的作用是获取 a 标签的父节点。换句话说它会返回 a 标签的直接父节点即包含 a 标签的标签。在这个例子中a 标签有一个父节点是 p 标签因为 a 标签是 p 标签的子节点。
# 如果我们运行 print(soup.a.parent)会输出 p classstory.../p即 a 标签的父节点 p 标签的完整内容
# list(enumerate(soup.a.parents)) 这行代码我们将 a 标签的所有祖先节点取出并使用 enumerate() 函数给它们编号最后将它们转换为列表兄弟节点 html
htmlheadtitleThe Dormouses story/title/headbodyp classstoryOnce upon a time there were three little sisters; and their names werea hrefhttp://example.com/elsie classsister idlink1spanElsie/span/aa hrefhttp://example.com/lacie classsister idlink2Lacie/a anda hrefhttp://example.com/tillie classsister idlink3Tillie/aand they lived at the bottom of a well./pp classstory.../pfrom bs4 import BeautifulSoup
soup BeautifulSoup(html, lxml)
print(list(enumerate(soup.a.next_siblings)))
print(list(enumerate(soup.a.previous_siblings)))# 说明
# soup.a.next_siblings 这行代码是为了获取 a 标签之后的所有兄弟节点的迭代器。.next_siblings 属性会遍历节点后面的兄弟节点直到最后一个兄弟节点为止。
# soup.a.previous_siblings 这行代码是为了获取 a 标签之前的所有兄弟节点的迭代器。.previous_siblings 属性会遍历节点前面的兄弟节点直到第一个兄弟节点为止。④ 标准选择器 find_all( name , attrs , recursive , text , **kwargs ) 可根据标签名、属性、内容查找文档 name
html
div classpaneldiv classpanel-headingh4Hello/h4/divdiv classpanel-bodyul classlist idlist-1li classelementFoo/lili classelementBar/lili classelementJay/li/ulul classlist list-small idlist-2li classelementFoo/lili classelementBar/li/ul/div
/divfrom bs4 import BeautifulSoup
soup BeautifulSoup(html, lxml)
print(soup.find_all(ul))
print(type(soup.find_all(ul)[0]))for ul in soup.find_all(ul):print(ul.find_all(li))# 说明
# soup.find_all(ul) 这行代码会查找并返回所有 ul 标签的列表。在这个例子中HTML 中包含两个 ul 标签分别是 id 为 list-1 和 list-2 的列表。
# type(soup.find_all(ul)[0]) 这行代码则是获取第一个 ul 标签的类型。由于 find_all() 方法返回的是一个列表我们通过 [0] 取出第一个 ul 标签然后使用 type() 函数获取其类型。attrs
from bs4 import BeautifulSoup
soup BeautifulSoup(html, lxml)
print(soup.find_all(attrs{id: list-1}))
print(soup.find_all(attrs{name: elements}))print(soup.find_all(idlist-1))
print(soup.find_all(class_element))# 说明
# soup.find_all(attrs{id: list-1}) 这行代码尝试查找所有具有 id 属性为 list-1 的元素。
# soup.find_all(attrs{name: elements}) 这行代码尝试查找所有具有 name 属性为 elements 的元素。然而在给定的 HTML 中并不存在具有 name 属性为 elements 的元素因此输出将是一个空列表。
# soup.find_all(idlist-1) 这行代码尝试查找所有具有 id 属性为 list-1 的元素。
# soup.find_all(class_element) 这行代码尝试查找所有具有 class 属性为 element 的元素。text
from bs4 import BeautifulSoup
soup BeautifulSoup(html, lxml)
print(soup.find_all(textFoo))# 说明
# soup.find_all(textFoo) 这行代码尝试查找文本内容为 Foo 的所有元素。在给定的 HTML 中如果有任何元素的文本内容是 Foo那么它们会被返回。如果没有匹配的文本内容为 Foo 的元素则会返回一个空列表。find( name , attrs , recursive , text , **kwargs ) find返回单个元素find_all返回所有元素
html
div classpaneldiv classpanel-headingh4Hello/h4/divdiv classpanel-bodyul classlist idlist-1li classelementFoo/lili classelementBar/lili classelementJay/li/ulul classlist list-small idlist-2li classelementFoo/lili classelementBar/li/ul/div
/divfrom bs4 import BeautifulSoup
soup BeautifulSoup(html, lxml)
print(soup.find(ul))
print(type(soup.find(ul)))
print(soup.find(page))# 说明
# soup.find(ul) 这行代码尝试找到第一个 ul 标签并返回该标签及其内容。
# soup.find(page) 这行代码尝试找到名为 page 的标签其他方法 find_parents() find_parent() find_parents()返回所有祖先节点find_parent()返回直接父节点。 find_next_siblings() find_next_sibling() find_next_siblings()返回后面所有兄弟节点find_next_sibling()返回后面第一个兄弟节点。 find_previous_siblings() find_previous_sibling() find_previous_siblings()返回前面所有兄弟节点find_previous_sibling()返回前面第一个兄弟节点。 find_all_next() find_next() find_all_next()返回节点后所有符合条件的节点, find_next()返回第一个符合条件的节点 find_all_previous() 和 find_previous() find_all_previous()返回节点后所有符合条件的节点, find_previous()返回第一个符合条件的节点
⑤ css选择器
通过select()直接传入CSS选择器即可完成选择
html
div classpaneldiv classpanel-headingh4Hello/h4/divdiv classpanel-bodyul classlist idlist-1li classelementFoo/lili classelementBar/lili classelementJay/li/ulul classlist list-small idlist-2li classelementFoo/lili classelementBar/li/ul/div
/divfrom 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]))for ul in soup.select(ul):print(ul.select(li))# 说明
# soup.select(.panel .panel-heading) 这行代码使用 CSS 选择器来查找具有类名 panel 和 panel-heading 的元素。在给定的 HTML 中只有一个元素符合这个条件即包含着 Hello 文本的 h4 标签和其父级元素。因此返回的结果是包含这个元素的列表。
# soup.select(ul li) 这行代码使用 CSS 选择器来查找所有 ul 标签内部的 li 元素。在给定的 HTML 中有两组符合条件的元素分别是两个 ul 内的所有 li 元素。因此返回的结果是包含这些元素的列表。
# soup.select(#list-2 .element) 这行代码使用 CSS 选择器来查找 id 属性为 list-2 的 ul 标签内部类名为 element 的 li 元素。在给定的 HTML 中有两个符合条件的 li 元素。因此返回的结果是包含这些元素的列表。
# print(type(soup.select(ul)[0])) 这行代码打印出了 soup.select(ul)[0] 的返回结果的类型即返回的元素对象类型。
# 通过使用 Beautiful Soup 库的 select 方法可以方便地通过 CSS 选择器来选择并返回匹配条件的元素。这对于从 HTML 文档中提取特定元素非常有用。# 最后一段代码的作用是遍历 Beautiful Soup 对象中所有 ul 元素然后针对每个 ul 元素再选择其内部的所有 li 元素并打印输出这些 li 元素。获取属性 from bs4 import BeautifulSoup
soup BeautifulSoup(html, lxml)
for ul in soup.select(ul):print(ul[id])print(ul.attrs[id])获取内容 from bs4 import BeautifulSoup
soup BeautifulSoup(html, lxml)
for li in soup.select(li):print(li.get_text())总结
推荐使用lxml解析库必要时使用html.parser标签选择筛选功能弱但是速度快建议使用find()、find_all()查询匹配单个结果或者多个结果如果对CSS选择器熟悉建议使用select()记住常用的获取属性和文本值的方法
4 PyQuery库详解
强大又灵活的网页解析库。如果你觉得正则写起来太麻烦如果你觉得BeautifulSoup语法太难记如果你熟悉jQuery的语法那么PyQuery就是你的绝佳选择。
jQuery 是一个流行的 JavaScript 库旨在简化 JavaScript 在网页中的开发和操作。它提供了强大的 API 和简洁的语法使得在网页上进行 DOM 操作、事件处理、动画效果等变得更加容易和高效。
PyQuery 是一个用于解析 HTML 文档并提供类似 jQuery 的语法和方法的 Python 库。通过 PyQuery你可以使用类似于 jQuery 的 CSS 选择器语法来查找、操作和修改 HTML 文档中的元素从而方便地进行网页数据提取、信息筛选等操作。
PyQuery 的主要功能包括
使用 CSS 选择器来选择 HTML 元素。查找、遍历和操作 HTML 元素。获取元素的属性和文本内容。支持类似于 jQuery 的链式操作。可以方便地处理爬取到的网页内容提取需要的信息。
① 初始化
在用到beautifusoup的时候需要进行初始化设置例如通过soup BeautifulSoup(html, lxml)来生成一个BeautifulSoup对象那么pyquery也需要进行初始化操作。 字符串初始化 html
divulli classitem-0first item/lili classitem-1a hreflink2.htmlsecond item/a/lili classitem-0 activea hreflink3.htmlspan classboldthird item/span/a/lili classitem-1 activea hreflink4.htmlfourth item/a/lili classitem-0a hreflink5.htmlfifth item/a/li/ul/divfrom pyquery import PyQuery as pq
doc pq(html)
print(doc(li))# 说明
# 使用 pq() 方法创建一个 PyQuery 对象 doc该对象用于表示 HTML 文档的根元素。
# doc(li) 会通过css选择器li选择所有的 li 元素并返回一个 PyQuery 对象
# 注意id选择器前面加#类选择器前面加.标签选择器什么也不加。url初始化 from pyquery import PyQuery as pq
doc pq(urlhttp://www.baidu.com)
print(doc(head))# 说明
# 这段代码使用 PyQuery 库从指定的 URL 中获取 HTML 文档并进行解析然后选择文档中的 head 元素并将结果打印出来文件初始化 from pyquery import PyQuery as pq
doc pq(filenamedemo.html)
print(doc(li))# 说明
# 跟上面类似通过filename参数传入要初始化的文件② 基本CSS选择器
html
div idcontainerul classlistli classitem-0first item/lili classitem-1a hreflink2.htmlsecond item/a/lili classitem-0 activea hreflink3.htmlspan classboldthird item/span/a/lili classitem-1 activea hreflink4.htmlfourth item/a/lili classitem-0a hreflink5.htmlfifth item/a/li/ul/divfrom pyquery import PyQuery as pq
doc pq(html)
print(doc(#container .list li))# 说明
# 这段代码使用了 PyQuery 库来解析 HTML 文档并选择了 id 为 container 的 div 元素下 class 为 list 的 ul 元素下的所有 li 元素。
# #.这些符号刚说过css选择器从左往右层级变深。③ 查找元素 子元素 html
div idcontainerul classlistli classitem-0first item/lili classitem-1a hreflink2.htmlsecond item/a/lili classitem-0 activea hreflink3.htmlspan classboldthird item/span/a/lili classitem-1 activea hreflink4.htmlfourth item/a/lili classitem-0a hreflink5.htmlfifth item/a/li/ul/divfrom pyquery import PyQuery as pq
doc pq(html)
items doc(.list)
print(type(items))
print(items)
lis items.find(li)
print(type(lis))
print(lis)# 说明
# 这段代码使用 PyQuery 库解析了一个 HTML 文档并且选择了 class 为 list 的元素并查找其中的所有 li 元素。
# items.find(li) 表示在选中的元素中查找所有的 li 元素。
# 注意find() 方法返回的是一个 PyQuery 对象而不是一个真正的列表。如果您需要将结果转换为列表形式可以使用 .items() 方法例如 lis.items()。lis items.children()
print(type(lis))
print(lis)# 说明
# lis items.children() 将返回一个 PyQuery 对象其中包含了所有直接子元素。当直接打印输出 lis 时您会看到包含所有直接子元素的结果。lis items.children(.active)
print(lis)# 说明
# children是查找标签子元素也可以传入选择器单独找到某些指定的子元素父元素 html
div idcontainerul classlistli classitem-0first item/lili classitem-1a hreflink2.htmlsecond item/a/lili classitem-0 activea hreflink3.htmlspan classboldthird item/span/a/lili classitem-1 activea hreflink4.htmlfourth item/a/lili classitem-0a hreflink5.htmlfifth item/a/li/ul/divfrom pyquery import PyQuery as pq
doc pq(html)
items doc(.list)
container items.parent()
print(type(container))
print(container)# 说明
# 通过 items.parent() 方法获取了 items 的父元素并将结果存储在变量 container 中。from pyquery import PyQuery as pq
doc pq(html)
items doc(.list)
parents items.parents()
print(type(parents))
print(parents)# 说明
# 调用了 items.parents() 方法来获取所有祖先元素并将结果存储在变量 parents 中。
# 打印所有祖先元素的意思是打印选中元素的所有父级元素一直往上找到最顶层的那一个元素。也就是说如果一个元素有多个父级元素parents() 方法将返回所有的父级元素以及它们的父级元素直到 html 的根元素。parent items.parents(.wrap)
print(parent)# 说明
# 跟上面类似查找父级元素也可以插入参数找到某些指定的父级元素兄弟元素 html
div classwrapdiv idcontainerul classlistli classitem-0first item/lili classitem-1a hreflink2.htmlsecond item/a/lili classitem-0 activea hreflink3.htmlspan classboldthird item/span/a/lili classitem-1 activea hreflink4.htmlfourth item/a/lili classitem-0a hreflink5.htmlfifth item/a/li/ul/div/divfrom pyquery import PyQuery as pq
doc pq(html)
li doc(.list .item-0.active)
print(li.siblings())# 说明
# 这段代码使用 PyQuery 库来解析 HTML并选择具有类名 item-0 active 的 li 元素。然后使用 siblings() 方法来获取该元素的所有同级元素。from pyquery import PyQuery as pq
doc pq(html)
li doc(.list .item-0.active)
print(li.siblings(.active))# 这段代码的功能是选择具有类名 item-0 active 的 li 元素然后使用 siblings(.active) 方法来获取该元素的所有具有类名 active 的同级元素。④ 遍历 单个元素 html
div classwrapdiv idcontainerul classlistli classitem-0first item/lili classitem-1a hreflink2.htmlsecond item/a/lili classitem-0 activea hreflink3.htmlspan classboldthird item/span/a/lili classitem-1 activea hreflink4.htmlfourth item/a/lili classitem-0a hreflink5.htmlfifth item/a/li/ul/div/divfrom pyquery import PyQuery as pq
doc pq(html)
li doc(.item-0.active)
print(li)lis doc(li).items()
print(type(lis))
for li in lis:print(li)# li doc(.item-0.active)这个代码是获取单个标签
# 当我们使用 doc(li).items() 方法时会得到一个生成器对象它可以通过迭代来访问所有匹配的元素。在遍历这个生成器时每次迭代都会返回 PyQuery 对象它包含了一个 li 元素及其所有子元素的信息。⑤ 获取信息 获取属性 html
div classwrapdiv idcontainerul classlistli classitem-0first item/lili classitem-1a hreflink2.htmlsecond item/a/lili classitem-0 activea hreflink3.htmlspan classboldthird item/span/a/lili classitem-1 activea hreflink4.htmlfourth item/a/lili classitem-0a hreflink5.htmlfifth item/a/li/ul/div/divfrom pyquery import PyQuery as pq
doc pq(html)
a doc(.item-0.active a)
print(a)
print(a.attr(href))
print(a.attr.href)# 在 PyQuery 中获取属性值的方法有两种1.使用 attr() 方法a.attr(href) 2.直接通过属性名获取a.attr.href获取文本 from pyquery import PyQuery as pq
doc pq(html)
a doc(.item-0.active a)
print(a)
print(a.text())# 通过 text() 方法获取标签文本内容
# 如果想要获取 a 元素内部的文本内容而不包括子元素的内容可以使用 text() 方法获取文本内容前先使用 contents() 方法过滤出其中的文本节点获取HTML from pyquery import PyQuery as pq
doc pq(html)
li doc(.item-0.active)
print(li)
print(li.html())# 通过 html() 方法获取其 HTML 内容并进行打印输出⑥ DOM操作 addClass、removeClass html
div classwrapdiv idcontainerul classlistli classitem-0first item/lili classitem-1a hreflink2.htmlsecond item/a/lili classitem-0 activea hreflink3.htmlspan classboldthird item/span/a/lili classitem-1 activea hreflink4.htmlfourth item/a/lili classitem-0a hreflink5.htmlfifth item/a/li/ul/div/divfrom pyquery import PyQuery as pq
doc pq(html)
li doc(.item-0.active)
print(li)
li.removeClass(active)
print(li)
li.addClass(active)
print(li)# 通过removeClass删除属性通过addClass增加属性attr、css html
div classwrapdiv idcontainerul classlistli classitem-0first item/lili classitem-1a hreflink2.htmlsecond item/a/lili classitem-0 activea hreflink3.htmlspan classboldthird item/span/a/lili classitem-1 activea hreflink4.htmlfourth item/a/lili classitem-0a hreflink5.htmlfifth item/a/li/ul/div/divfrom pyquery import PyQuery as pq
doc pq(html)
li doc(.item-0.active)
print(li)
li.attr(name, link)
print(li)
li.css(font-size, 14px)
print(li)# 使用 attr(name, link) 方法为该元素添加了一个名为 name、值为 link 的属性。
# 使用 css(font-size, 14px) 方法为该元素设置了 CSS 样式将字体大小设定为 14px。remove html
div classwrapHello, WorldpThis is a paragraph./p/divfrom pyquery import PyQuery as pq
doc pq(html)
wrap doc(.wrap)
print(wrap.text())
wrap.find(p).remove()
print(wrap.text())其他DOM方法 http://pyquery.readthedocs.io/en/latest/api.html ⑦ 伪类选择器
html
div classwrapdiv idcontainerul classlistli classitem-0first item/lili classitem-1a hreflink2.htmlsecond item/a/lili classitem-0 activea hreflink3.htmlspan classboldthird item/span/a/lili classitem-1 activea hreflink4.htmlfourth item/a/lili classitem-0a hreflink5.htmlfifth item/a/li/ul/div/divfrom pyquery import PyQuery as pq
doc pq(html)
li doc(li:first-child)
print(li)
li doc(li:last-child)
print(li)
li doc(li:nth-child(2))
print(li)
li doc(li:gt(2))
print(li)
li doc(li:nth-child(2n))
print(li)
li doc(li:contains(second))
print(li)# li:first-child选择第一个 li 元素。
# li:last-child选择最后一个 li 元素。
# li:nth-child(2)选择第二个 li 元素。
# li:gt(2)选择索引大于 2 的所有 li 元素即除前三个 li 元素外的所有 li 元素。
# li:nth-child(2n)选择索引为偶数的所有 li 元素。
# li:contains(second)选择包含文本 second 的所有 li 元素。官方文档 http://www.w3school.com.cn/css/index.asp http://pyquery.readthedocs.io/
5 Selenium库详解
自动化测试工具支持多种浏览器。爬虫中主要用来解决JavaScript渲染的问题。
它可以模拟用户在浏览器中的交互行为。使用 Selenium您可以编写 Python 脚本来打开网页、填写表单、点击按钮等操作并获取页面内容或执行其他操作。
注意Selenium需要通过浏览器驱动来控制浏览器。因此在使用Selenium之前需要下载并安装相应浏览器的驱动比如ChromeDriver、FirefoxDriver等。
① 基本使用
以下是一个比较全面的selenium例子
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.wait import WebDriverWaitbrowser webdriver.Chrome()
try:browser.get(https://www.baidu.com)input browser.find_element_by_id(kw)input.send_keys(Python)input.send_keys(Keys.ENTER)wait WebDriverWait(browser, 10)wait.until(EC.presence_of_element_located((By.ID, content_left)))print(browser.current_url)print(browser.get_cookies())print(browser.page_source)
finally:browser.close()# 说明
# 这段代码使用了 Selenium WebDriver 来打开百度首页搜索关键词 Python等待搜索结果加载完成后获取当前页面的 URL、Cookies 以及页面源码并最终关闭浏览器。接下来解释一下代码的各个部分
# from selenium import webdriver从 Selenium 库中导入 webdriver 模块用于控制浏览器操作。
# from selenium.webdriver.common.by import By从 Selenium 的 webdriver 模块中导入 By 类用于指定元素定位方式。
# from selenium.webdriver.common.keys import Keys从 Selenium 的 webdriver 模块中导入 Keys 类用于模拟键盘输入。
# from selenium.webdriver.support import expected_conditions as EC从 Selenium 的 support 模块中导入 expected_conditions 模块并重命名为 EC用于定义等待条件。
# from selenium.webdriver.support.wait import WebDriverWait从 Selenium 的 support 模块中导入 WebDriverWait 类用于设置显示等待。
# browser webdriver.Chrome()创建一个 Chrome 浏览器对象可以通过该对象控制浏览器的行为。
# browser.get(https://www.baidu.com)使用浏览器对象打开百度首页。
# input browser.find_element_by_id(kw)通过 ID 定位方式找到百度首页搜索输入框元素并将其赋值给变量 input。
# input.send_keys(Python)在搜索输入框中输入关键词 Python。
# input.send_keys(Keys.ENTER)模拟按下回车键执行搜索操作。
# wait WebDriverWait(browser, 10)创建一个 WebDriverWait 对象设置最大等待时间为 10 秒。
# wait.until(EC.presence_of_element_located((By.ID, content_left)))等待直到搜索结果页面中的内容加载完成通过检查搜索结果容器的 ID (content_left) 来确认页面加载完成。
# print(browser.current_url)打印当前页面的 URL。
# print(browser.get_cookies())打印当前页面的 Cookies。
# print(browser.page_source)打印当前页面的 HTML 源码。
# browser.close()关闭浏览器。② 声明浏览器对象
from selenium import webdriverbrowser webdriver.Chrome()
browser webdriver.Firefox()
browser webdriver.Edge()
browser webdriver.PhantomJS()
browser webdriver.Safari()# 这段代码展示了如何使用不同的浏览器驱动程序来实例化 Selenium WebDriver 对象。每个 webdriver.* 表示一个不同的浏览器驱动程序③ 访问页面
from selenium import webdriverbrowser webdriver.Chrome()
browser.get(https://www.taobao.com)
print(browser.page_source)
browser.close()# 这段代码使用 Selenium 中的 WebDriver 对象来打开 Chrome 浏览器访问淘宝网站并输出页面的 HTML 源码然后关闭浏览器。④ 查找元素 单个元素 from selenium import webdriverbrowser webdriver.Chrome()
browser.get(https://www.taobao.com)
input_first browser.find_element_by_id(q)
input_second browser.find_element_by_css_selector(#q)
input_third browser.find_element_by_xpath(//*[idq])
print(input_first, input_second, input_third)
browser.close()# 这段代码使用 Selenium WebDriver 在打开 Chrome 浏览器并访问淘宝网站后分别通过不同的方式定位搜索输入框元素并打印这些元素的信息。
# input_first browser.find_element_by_id(q)通过 ID 定位方式找到页面中的搜索输入框元素并将其赋值给 input_first 变量。
# input_second browser.find_element_by_css_selector(#q)通过 CSS 选择器定位方式找到页面中的搜索输入框元素并将其赋值给 input_second 变量。
# input_third browser.find_element_by_xpath(//*[idq])通过 XPath 定位方式找到页面中的搜索输入框元素并将其赋值给 input_third 变量。//表示从当前节点开始选择匹配模式的任意位置的节点。*表示选择所有节点。[idq]表示选择具有id属性为q的元素。一些查找方法
find_element_by_namefind_element_by_xpathfind_element_by_link_textfind_element_by_partial_link_textfind_element_by_tag_namefind_element_by_class_namefind_element_by_css_selector
from selenium import webdriver
from selenium.webdriver.common.by import Bybrowser webdriver.Chrome()
browser.get(https://www.taobao.com)
input_first browser.find_element(By.ID, q)
print(input_first)
browser.close()# 刚才提到过By是用于指定元素定位方式。
# 通过 By.ID 方法指定使用 ID 定位方式找到页面中的搜索输入框元素并将其赋值给 input_first 变量。最后打印输出 input_first 变量关闭浏览器
# 需要注意的是Selenium 中提供了不同的定位方式如By.ID、By.CSS_SELECTOR、By.XPATH等用于根据不同的属性定位页面元素。在这段代码中使用了 By.ID 方法指定了使用 ID 定位方式。多个元素 from selenium import webdriverbrowser webdriver.Chrome()
browser.get(https://www.taobao.com)
lis browser.find_elements_by_css_selector(.service-bd li)
print(lis)
browser.close()
# ----------------------------
from selenium import webdriver
from selenium.webdriver.common.by import Bybrowser webdriver.Chrome()
browser.get(https://www.taobao.com)
lis browser.find_elements(By.CSS_SELECTOR, .service-bd li)
print(lis)
browser.close()# 获取多个元素的方法跟刚才相比就是element后面多加个s表示复数
# 上面列举的其他查找方法也是类似的⑤ 元素交互操作 对获取的元素调用交互方法 from selenium import webdriver
import timebrowser webdriver.Chrome()
browser.get(https://www.taobao.com)
input browser.find_element_by_id(q)
input.send_keys(iPhone)
time.sleep(1)
input.clear()
input.send_keys(iPad)
button browser.find_element_by_class_name(btn-search)
button.click()# 这段代码使用 Selenium 的 WebDriver 来模拟浏览器操作打开淘宝网站向搜索框输入关键词 iPhone然后清空搜索框内容重新输入关键词 iPad最后点击搜索按钮进行搜索。
# button.click() 点击搜索按钮触发搜索操作。更多操作 交互动作 将动作附加到动作链中串行执行
from selenium import webdriver
from selenium.webdriver import ActionChainsbrowser webdriver.Chrome()
url http://www.runoob.com/try/try.php?filenamejqueryui-api-droppable
browser.get(url)
browser.switch_to.frame(iframeResult)
source browser.find_element_by_css_selector(#draggable)
target browser.find_element_by_css_selector(#droppable)
actions ActionChains(browser)
actions.drag_and_drop(source, target)
actions.perform()# 首先创建了一个 Chrome 浏览器的实例然后打开了一个网页并切换到了名为 iframeResult 的 iframe 中。iframe 是嵌入到网页中的另一个独立的页面需要切换到该 iframe 才能操作其中的元素。
# from selenium.webdriver import ActionChains导入 Selenium 的 ActionChains 类用于执行鼠标操作。
# iframe内联框架是 HTML 中的一个标签用于在网页中嵌入另一个 HTML 页面。通过使用 iframe 标签我们可以将一个网页嵌入到另一个网页中并且用户可以在原始页面的某个位置看到嵌入的页面。
# browser.switch_to.frame(iframeResult)切换到名为 iframeResult 的 iframe 中以便在该 iframe 中进行操作
# source browser.find_element_by_css_selector(#draggable)在当前的 iframe 中使用 CSS 选择器找到 id 为 draggable 的源元素。
# target browser.find_element_by_css_selector(#droppable)在当前的 iframe 中使用 CSS 选择器找到 id 为 droppable 的目标元素。
# actions ActionChains(browser)创建一个 ActionChains 对象用于执行鼠标操作。
# actions.drag_and_drop(source, target)执行拖拽操作将源元素拖拽到目标元素上。
# actions.perform()执行之前定义的鼠标操作。⑥ 执行JavaScript
from selenium import webdriverbrowser webdriver.Chrome()
browser.get(https://www.zhihu.com/explore)
browser.execute_script(window.scrollTo(0, document.body.scrollHeight))
browser.execute_script(alert(To Bottom))# 这段代码使用 Selenium WebDriver 打开知乎网站然后执行 JavaScript 代码实现页面滚动和弹出警告框的效果
# browser.execute_script(window.scrollTo(0, document.body.scrollHeight))执行 JavaScript 代码将页面滚动到底部。window.scrollTo(x,y) 方法可以将页面滚动到指定的 x、y 坐标位置其中 0, document.body.scrollHeight 表示在水平方向不滚动垂直方向滚动到页面的底部。
# browser.execute_script(alert(To Bottom))执行 JavaScript 代码在页面上弹出一个警告框显示文本 To Bottom。这个警告框会阻止代码继续执行直到用户关闭它。⑦ 获取元素信息 获取属性 from selenium import webdriver
from selenium.webdriver import ActionChainsbrowser webdriver.Chrome()
url https://www.zhihu.com/explore
browser.get(url)
logo browser.find_element_by_id(zh-top-link-logo)
print(logo)
print(logo.get_attribute(class))# 这段代码的作用是使用 Selenium WebDriver 打开知乎网站的探索页面找到页面中 id 为 zh-top-link-logo 的元素知乎网站的 Logo然后打印出该元素对象以及该元素的 class 属性值。获取文本值 from selenium import webdriverbrowser webdriver.Chrome()
url https://www.zhihu.com/explore
browser.get(url)
input browser.find_element_by_class_name(zu-top-add-question)
print(input.text)# 在代码中使用 find_element_by_class_name 方法来查找具有特定类名的元素并尝试打印该元素的文本内容。但是需要注意的是find_element_by_class_name 方法用于查找具有指定类名的第一个元素而不是获取元素的文本内容。
# 如果您想要获取元素的文本内容可以使用 text 属性或者 get_attribute(textContent) 方法。获取ID、位置、标签名、大小 from selenium import webdriverbrowser webdriver.Chrome()
url https://www.zhihu.com/explore
browser.get(url)
input browser.find_element_by_class_name(zu-top-add-question)
print(input.id)
print(input.location)
print(input.tag_name)
print(input.size)frame框架 import time
from selenium import webdriver
from selenium.common.exceptions import NoSuchElementExceptionbrowser webdriver.Chrome()
url http://www.runoob.com/try/try.php?filenamejqueryui-api-droppable
browser.get(url)
browser.switch_to.frame(iframeResult)
source browser.find_element_by_css_selector(#draggable)
print(source)
try:logo browser.find_element_by_class_name(logo)
except NoSuchElementException:print(NO LOGO)
browser.switch_to.parent_frame()
logo browser.find_element_by_class_name(logo)
print(logo)
print(logo.text)# 这段代码的作用是使用 Selenium WebDriver 打开一个网页http://www.runoob.com/try/try.php?filenamejqueryui-api-droppable然后切换到该页面中的一个 iframe 框架id 为 iframeResult找到页面中的一个可拖拽元素id 为 draggable并尝试找到页面中的一个 class 为 logo 的元素。
# 如果成功找到 logo 元素则打印该元素及其文本内容如果未找到 logo 元素则打印 NO LOGO。随后代码会切换回父级 frame并再次尝试找到 class 为 logo 的元素并打印该元素及其文本内容。
# 整体来说这段代码主要演示了在使用 Selenium WebDriver 进行网页操作时如何切换到 iframe 中查找元素以及处理可能出现的 NoSuchElementException 异常。同时展示了如何获取元素对象以及元素的文本内容。⑧ 等待 隐式等待 当使用了隐式等待执行测试的时候如果 WebDriver没有在 DOM中找到元素将继续等待超出设定时间后则抛出找不到元素的异常, 换句话说当查找元素或元素并没有立即出现的时候隐式等待将等待一段时间再查找 DOM默认的时间是0
from selenium import webdriverbrowser webdriver.Chrome()
browser.implicitly_wait(10)
browser.get(https://www.zhihu.com/explore)
input browser.find_element_by_class_name(zu-top-add-question)
print(input)# 这段代码使用了 Selenium WebDriver 来打开知乎网站并尝试找到一个 class 为 zu-top-add-question 的元素。在这段代码中implicitly_wait(10) 方法设置了一个隐式等待时间为 10 秒表示如果在查找元素时未能立即找到则会等待最多 10 秒直到元素出现或超时。显式等待 from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as ECbrowser webdriver.Chrome()
browser.get(https://www.taobao.com/)
wait WebDriverWait(browser, 10)
input wait.until(EC.presence_of_element_located((By.ID, q)))
button wait.until(EC.element_to_be_clickable((By.CSS_SELECTOR, .btn-search)))
print(input, button)# 这段代码使用了 Selenium WebDriver 来打开淘宝网站并使用显示等待来等待页面加载和元素定位。
# 使用显示等待 WebDriverWait(browser, 10) 来设置等待时间为最多 10 秒。这意味着在查找元素时如果元素未能在 10 秒内出现将会抛出 TimeoutException 异常。
# 倒数第二三两行代码是使用 Selenium 的 WebDriverWait 来等待页面中的元素加载完成并返回对应的 WebElement 对象。# input wait.until(EC.presence_of_element_located((By.ID, q)))解释
# EC.presence_of_element_located 是一个预定义的条件表示等待指定的元素在 DOM 树中存在即元素已经被加载到页面中。
# (By.ID, q) 指定了要查找的元素的定位方式为 ID并且该元素的 ID 属性的值为 q。
# wait.until() 方法会一直等待直到传入的条件返回一个非 False、非空的值即找到了符合条件的元素或者超时时间到达。
# 一旦找到指定的元素ID 为 q 的元素wait.until() 方法会返回该元素的 WebElement 对象并将其赋值给变量 input。# button wait.until(EC.element_to_be_clickable((By.CSS_SELECTOR, .btn-search)))解释
# EC.element_to_be_clickable 是一个预定义的条件表示等待指定的元素可被点击即元素已经加载并且处于可交互状态。
# (By.CSS_SELECTOR, .btn-search) 指定了要查找的元素的定位方式为 CSS 选择器并且该元素的类名为 btn-search。
# 同样地wait.until() 方法会等待直到找到可点击的元素类名为 btn-search 的元素并返回该元素的 WebElement 对象赋值给变量 button。显示等待是针对某个特定条件等待一段时间而隐式等待是全局性地等待整个页面加载元素的时间。显示等待更加灵活和精准可以根据需要设置不同的等待条件和时间而隐式等待则是简单易用但可能会增加整体执行时间。根据实际需求选择合适的等待方式可以提高测试效率。
expected_conditions是一个模块其中包含了一些预定义的条件类和方法用于等待页面元素状态的变化。这些条件可以被用于 WebDriverWait 类中实现更加可靠的等待操作。 以下是模块中的一些条件
title_is 标题是某内容title_contains 标题包含某内容presence_of_element_located 元素加载出传入定位元组如(By.ID, ‘p’)visibility_of_element_located 元素可见传入定位元组visibility_of 可见传入元素对象presence_of_all_elements_located 所有元素加载出text_to_be_present_in_element 某个元素文本包含某文字text_to_be_present_in_element_value 某个元素值包含某文字frame_to_be_available_and_switch_to_it frame加载并切换invisibility_of_element_located 元素不可见element_to_be_clickable 元素可点击staleness_of 判断一个元素是否仍在DOM可判断页面是否已经刷新element_to_be_selected 元素可选择传元素对象element_located_to_be_selected 元素可选择传入定位元组element_selection_state_to_be 传入元素对象以及状态相等返回True否则返回Falseelement_located_selection_state_to_be 传入定位元组以及状态相等返回True否则返回Falsealert_is_present 是否出现Alert
⑨ 前进后退
import time
from selenium import webdriverbrowser webdriver.Chrome()
browser.get(https://www.baidu.com/)
browser.get(https://www.taobao.com/)
browser.get(https://www.python.org/)
browser.back()
time.sleep(1)
browser.forward()
browser.close()# 使用 back() 方法返回到上一个页面然后通过 forward() 方法前进到下一个页面。⑩ cookie
from selenium import webdriverbrowser webdriver.Chrome()
browser.get(https://www.zhihu.com/explore)
print(browser.get_cookies())
browser.add_cookie({name: name, domain: www.zhihu.com, value: germey})
print(browser.get_cookies())
browser.delete_all_cookies()
print(browser.get_cookies())# 这段代码使用了 Selenium 和 Chrome 浏览器来访问知乎的探索页面并对浏览器的 cookie 进行操作。
# 使用 browser.add_cookie() 方法向浏览器中添加了一个名为 name 的 cookie域名为 www.zhihu.com值为 germey。然后再次调用 browser.get_cookies() 方法获取所有 cookie 并打印输出可以看到新增的 cookie 信息。
# 最后使用 browser.delete_all_cookies() 方法删除了浏览器中的所有 cookie并再次调用 browser.get_cookies() 方法获取所有 cookie 并打印输出此时应该看不到任何 cookie 信息。十一 选项卡管理
import time
from selenium import webdriverbrowser webdriver.Chrome()
browser.get(https://www.baidu.com)
browser.execute_script(window.open())
print(browser.window_handles)
browser.switch_to_window(browser.window_handles[1])
browser.get(https://www.taobao.com)
time.sleep(1)
browser.switch_to_window(browser.window_handles[0])
browser.get(https://python.org)# 这个例子演示了如何在浏览器中使用 Selenium 控制标签页的切换。
# browser.execute_script(window.open()) 执行了 JavaScript 脚本来新打开一个空白标签页。
# browser.window_handles 返回当前所有标签页的句柄列表可以通过索引来访问各个标签页。
# browser.switch_to_window(handle) 方法用于切换到指定句柄对应的标签页。
# 需要注意的是switch_to_window 方法已经被废弃建议使用 switch_to.window 方法来代替。# execute_script() 是 Selenium WebDriver 提供的一个方法用于在浏览器中执行 JavaScript 代码。通过 execute_script() 方法可以直接在当前页面的上下文中执行自定义的 JavaScript 代码从而实现一些特定的操作或功能。十二 异常处理
from selenium import webdriverbrowser webdriver.Chrome()
browser.get(https://www.baidu.com)
browser.find_element_by_id(hello)# 页面中并不存在 id 为 hello 的元素那么 browser.find_element_by_id(hello) 将会抛出 NoSuchElementException 异常因为 Selenium 没有找到匹配的元素。
# 接下来处理一下异常from selenium import webdriver
from selenium.common.exceptions import TimeoutException, NoSuchElementExceptionbrowser webdriver.Chrome()
try:browser.get(https://www.baidu.com)
except TimeoutException:print(Time Out)
try:browser.find_element_by_id(hello)
except NoSuchElementException:print(No Element)
finally:browser.close()
