爬虫：bs4介绍，遍历文档树、bs4搜索文档树、css选择器、selenium基本使用、无界面浏览器、selenium其它用法

标签：浏览器 bs4 selenium element soup 文档 print find

一、bs4介绍，遍历文档树
- 1.1bs4模块介绍
- 1.2 bs4的遍历文档树
二、bs4搜索文档树
- 1.2 find_all( name , attrs , recursive , text , **kwargs )
- 2.2 find( name , attrs , recursive , text , **kwargs )
三、css选择器
四、selenium基本使用
五、无界面浏览器
六、selenium其它用法
七、作业

一、bs4介绍，遍历文档树

1.1bs4模块介绍

Beautiful Soup 是一个可以从HTML或XML文件中提取数据的Python库.它能够通过你喜欢的转换器实现惯用的文档导航,查找,修改文档的方式.Beautiful Soup会帮你节省数小时甚至数天的工作时间.你可能在寻找 Beautiful Soup3 的文档,Beautiful Soup 3 目前已经停止开发,官网推荐在现在的项目中使用Beautiful Soup 4, 移植到BS4

安装Beautiful Soup 4

pip install beautifulsoup4

安装解析器

Beautiful Soup支持Python标准库中的HTML解析器,还支持一些第三方的解析器,其中一个是 lxml .

pip install lxml

我们在后面的操作中使用lxml作为解析器，基本使用方式如下：

soup=BeautifulSoup('要解析的内容str类型','html.parser/lxml')

另一个可供选择的解析器是纯Python实现的 html5lib , html5lib的解析方式与浏览器相同

pip install html5lib

下表列出了主要的解析器,以及它们的优缺点,官网推荐使用lxml作为解析器,因为效率更高. 在Python2.7.3之前的版本和Python3中3.2.2之前的版本,必须安装lxml或html5lib, 因为那些Python版本的标准库中内置的HTML解析方法不够稳定.

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

中文文档：https://www.crummy.com/software/BeautifulSoup/bs4/doc/index.zh.html

1.2 bs4的遍历文档树

遍历文档树：即直接通过标签名字选择，特点是选择速度快，但如果存在多个相同的标签则只返回第一个

用法：

#1、获取标签的名称
#2、获取标签的属性
#3、获取标签的内容
#4、嵌套选择
#5、子节点、子孙节点
#6、父节点、祖先节点
#7、兄弟节点

from bs4 import BeautifulSoup
html_doc = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p class="title">
lqz
<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" name='lqz'>Elsie</a>
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
and they lived at the bottom of a well.</p>

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

soup=BeautifulSoup(html_doc,'lxml')

# 1 美化，不是标准xml，完成美化
# print(soup.prettify())

# 2 遍历文档树---》通过 . 来遍历
# print(soup.html.body.p)  # 一层一层找，也是只找一个
# print(soup.p)  # 跨层  只找第一个

#2、获取标签的名称
# print(soup.a.name)
#3、获取标签的属性  ---》属性字典
# print(soup.a.attrs['href'])
# print(soup.a.attrs.get('class'))   # class 会有多个 ['sister']
# print(soup.a.attrs.get('name'))

#4、获取标签的内容
# text  获得该标签内部子子孙孙所有标签的文本内容
# print(soup.p.text)
# # string p下的文本只有一个时，取到，否则为None
# print(soup.p.string)
# # strings
# print(list(soup.p.strings)) # generator
# #5、嵌套选择
# print(soup.html.body)

# ---- 了解
#6、子节点、子孙节点
# print(soup.body.contents) #p下所有子节点，只取一层
# print(list(soup.p.children)) #list_iterator得到一个迭代器,包含p下所有子节点  只取一层
# print(list(soup.body.descendants) ) # generator  子子孙孙
#7、父节点、祖先节点

# print(soup.a.parent) #获取a标签的父节点  直接父亲
# print(list(soup.a.parents) )#找到a标签所有的祖先节点，父亲的父亲，父亲的父亲的父亲...
#8、兄弟节点
# print(soup.a.next_sibling) #下一个兄弟
# print(soup.a.previous_sibling) #上一个兄弟
#
# print(list(soup.a.next_siblings)) #下面的兄弟们=>生成器对象
print(list(soup.a.previous_siblings)) #上面的兄弟们=>生成器对象

二、bs4搜索文档树

搜索文档树：BeautifulSoup定义了很多搜索方法,这里着重介绍2个: find() 和 find_all() .其它方法的参数和用法类似

ps：find和find_all我们之前单间介绍过的

html_doc = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p id="my p" class="title"><b id="bbb" class="boldest">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_doc, 'lxml')


# 五种过滤器: 字符串、正则表达式、列表、True、方法

# 1 字符串--->查询的条件是字符串，查找的是标签名
# res=soup.find_all(name='p')
# res=soup.find_all('p')
# print(res)
# 类名叫sister的所有标签
# res=soup.find_all(class_='sister')
# print(res)

# id 叫link1的标签
# res=soup.find_all(id='link1')
# print(res)

# 文本内容叫Elsie的父标签
# res=soup.find(text='Elsie').parent
# print(res)

# 另一种方式
# # res=soup.find_all(attrs={'class':'sister'})
# res=soup.find_all(attrs={'id':'link1'})
# print(res)


# 2 正则表达式
# import re
# # res=soup.find_all(id=re.compile('^l'))
# res=soup.find_all(class_=re.compile('^s'))
# print(res)

# 3 列表：如果传入列表参数,Beautiful Soup会将与列表中任一元素匹配的内容返回.下面代码找到文档中所有<a>标签和<b>标签
# res=soup.find_all(id=['link1','link2'])
# print(res)
# print(soup.find_all(name=['a','b']))
# print(soup.find_all(['a','b']))


# 4 True：可以匹配任何值,下面代码查找到所有的tag,但是不会返回字符串节点
# res=soup.find_all(id=True)  # 所有有id的标签
# res=soup.find_all(href=True)
# res=soup.find_all(class_=True)
# print(res)


# 5 方法
# 如果没有合适过滤器,那么还可以定义一个方法,方法只接受一个元素参数 ,如果这个方法返回 True 表示当前元素匹配并且被找到,如果不是则反回 False
def has_class_but_no_id(tag):
    return tag.has_attr('class') and not tag.has_attr('id')

print(soup.find_all(name=has_class_but_no_id))

1.2 find_all( name , attrs , recursive , text , **kwargs )

#2、find_all( name , attrs , recursive , text , **kwargs )
#2.1、name: 搜索name参数的值可以使任一类型的 过滤器 ,字符窜,正则表达式,列表,方法或是 True .
print(soup.find_all(name=re.compile('^t')))

#2.2、keyword: key=value的形式，value可以是过滤器：字符串 , 正则表达式 , 列表, True .
print(soup.find_all(id=re.compile('my')))
print(soup.find_all(href=re.compile('lacie'),id=re.compile('\d'))) #注意类要用class_
print(soup.find_all(id=True)) #查找有id属性的标签

# 有些tag属性在搜索不能使用,比如HTML5中的 data-* 属性:
data_soup = BeautifulSoup('<div data-foo="value">foo!</div>','lxml')
# data_soup.find_all(data-foo="value") #报错：SyntaxError: keyword can't be an expression
# 但是可以通过 find_all() 方法的 attrs 参数定义一个字典参数来搜索包含特殊属性的tag:
print(data_soup.find_all(attrs={"data-foo": "value"}))
# [<div data-foo="value">foo!</div>]

#2.3、按照类名查找，注意关键字是class_，class_=value,value可以是五种选择器之一
print(soup.find_all('a',class_='sister')) #查找类为sister的a标签
print(soup.find_all('a',class_='sister ssss')) #查找类为sister和sss的a标签，顺序错误也匹配不成功
print(soup.find_all(class_=re.compile('^sis'))) #查找类为sister的所有标签

#2.4、attrs
print(soup.find_all('p',attrs={'class':'story'}))

#2.5、text: 值可以是：字符，列表，True，正则
print(soup.find_all(text='Elsie'))
print(soup.find_all('a',text='Elsie'))

#2.6、limit参数:如果文档树很大那么搜索会很慢.如果我们不需要全部结果,可以使用 limit 参数限制返回结果的数量.效果与SQL中的limit关键字类似,当搜索到的结果数量达到 limit 的限制时,就停止搜索返回结果
print(soup.find_all('a',limit=2))

#2.7、recursive:调用tag的 find_all() 方法时,Beautiful Soup会检索当前tag的所有子孙节点,如果只想搜索tag的直接子节点,可以使用参数 recursive=False .
print(soup.html.find_all('a'))
print(soup.html.find_all('a',recursive=False))

'''
像调用 find_all() 一样调用tag
find_all() 几乎是Beautiful Soup中最常用的搜索方法,所以我们定义了它的简写方法. BeautifulSoup 对象和 tag 对象可以被当作一个方法来使用,这个方法的执行结果与调用这个对象的 find_all() 方法相同,下面两行代码是等价的:
soup.find_all("a")
soup("a")
这两行代码也是等价的:
soup.title.find_all(text=True)
soup.title(text=True)
'''

2.2 find( name , attrs , recursive , text , **kwargs )

#3、find( name , attrs , recursive , text , **kwargs )
find_all() 方法将返回文档中符合条件的所有tag,尽管有时候我们只想得到一个结果.比如文档中只有一个<body>标签,那么使用 find_all() 方法来查找<body>标签就不太合适, 使用 find_all 方法并设置 limit=1 参数不如直接使用 find() 方法.下面两行代码是等价的:

soup.find_all('title', limit=1)
# [<title>The Dormouse's story</title>]
soup.find('title')
# <title>The Dormouse's story</title>

唯一的区别是 find_all() 方法的返回结果是值包含一个元素的列表,而 find() 方法直接返回结果.
find_all() 方法没有找到目标是返回空列表, find() 方法找不到目标时,返回 None .
print(soup.find("nosuchtag"))
# None

soup.head.title 是 tag的名字 方法的简写.这个简写的原理就是多次调用当前tag的 find() 方法:

soup.head.title
# <title>The Dormouse's story</title>
soup.find("head").find("title")
# <title>The Dormouse's story</title>

recursive参数

recursive：查找的时候，是只找第一层还是子子孙孙都找，默认是True，子子孙孙都找

三、css选择器

# 之前学过css选择器,可以很复杂
	.类名
    #id
    p
# 咱们只学了bs4，以后可能见到别的解析器(lxml)----》他们都会支持css选择器，也会支持xpath
# bs4 支持css选择器

# html_doc = """
# <html><head><title>The Dormouse's story</title></head>
# <body>
# <p class="title">
#     <b>The Dormouse's story</b>
#     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>;
#     <div class='panel-1'>
#         <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'><h1 class='yyyy'>Foo</h1></li>
#             <li class='element xxx'>Bar</li>
#             <li class='element'>Jay</li>
#         </ul>
#     </div>
#     and they lived at the bottom of a well.
# </p>
# <p class="story">...</p>
# """
from bs4 import BeautifulSoup
# soup=BeautifulSoup(html_doc,'lxml')

# 1、select内写css选择器
# print(soup.select('.sister'))

# print(soup.select('#link1'))
# print(soup.select('#link1 span'))


# 2、终极大招---》如果不会写css选择器，可以复制

import requests
res=requests.get('https://www.w3school.com.cn/css/css_selector_attribute.asp')
soup=BeautifulSoup(res.text,'lxml')
# print(soup.select('#intro > p:nth-child(1) > strong'))
print(soup.select('#intro > p:nth-child(1) > strong')[0].text)

获取方法如下

选中我们想要的标签后，如下图右键复制即可

四、selenium基本使用

4.1 selenium介绍

selenium最初是一个自动化测试工具,而爬虫中使用它主要是为了解决requests无法直接执行JavaScript代码的问题

selenium本质是通过驱动浏览器，完全模拟浏览器的操作，比如跳转、输入、点击、下拉等，来拿到网页渲染之后的结果，可支持多种浏览器

官网：http://selenium-python.readthedocs.io

在讲解selenium使用之前，我们介绍一下目前网页的一些情况

之前我们用requests模块发送请求，可能会出现一些数据我们拿不到

但是在selenium这里，因为确实调用了浏览器进行操作，通过js甚至可以对网页进行一些复杂的操作，所以结合浏览器所见即所得的特性，很多的反扒措施就直接失效了，这也可以看出这个模块的强大

而现在的模块普遍都是用了vue来实现的，这里就肯定会用到ajax实现网页的局部渲染，因此市面上百分之99的网页肯定要用到JavaScript来操作网页，所以selenium并不能被简单的反扒措施给反制

4.2 安装

步骤一

下载selenium

pip install selenium

步骤二

这里操作不同的浏览器会用到不同的浏览器驱动，也是需要我们自行下载的，但是建议使用谷歌浏览器的驱动操作谷歌浏览器，别的浏览器容易出兼容问题

谷歌浏览器驱动下载：https://registry.npmmirror.com/binary.html?path=chromedriver/

如果查看自己谷歌浏览器的版本？

打开浏览器后点击右上角的三个点，进入设置，然后点击左下角的详情就可以看到版本信息了

ps：在查找对应版本的时候，可能并不会完全一样，但是前面三组数字一定要一样，最后一组数字尽量一样即可

步骤三

选择版本后，会进入下图界面，这里我们可以根据自己的操作系统选择

然后我们解压之后就可以得到这个驱动

步骤四

我们把这个驱动复制到我们要执行代码的路径下（也就是项目中）

4.2 使用代码控制谷歌浏览器（有界面浏览器）

这里我们通过代码，打开谷歌浏览器，并往百度地址访问，在地址栏中跟上搜索内容——美女，等待五秒之后再把窗口关了

    from selenium import webdriver
    import time
    bro = webdriver.Chrome(executable_path='chromedriver.exe')  # 打开一个谷歌浏览器
    bro.get('https://www.baidu.com/s?wd=%E7%BE%8E%E5%A5%B3')  # 在地址栏中输入地址
    print(bro.page_source)  # 当前页面的内容  (html格式)
    with open('1.html','w',encoding='utf-8') as f:
        f.write(bro.page_source)
    time.sleep(5)
    bro.close()  # 关闭浏览器

五、无界面浏览器

5.1 基础功能介绍

上面我们介绍了如何用浏览器驱动操作浏览器

但是在我们用浏览器驱动运行爬虫的时候，我们并不想打开浏览器，我们只是想获取数据

因此就有了无界面浏览器

from selenium import webdriver
import time

from selenium.webdriver.chrome.options import Options
# 隐藏浏览器的图形化界面，但是数据还拿到
chrome_options = Options()
chrome_options.add_argument('window-size=1920x3000') #指定浏览器分辨率
chrome_options.add_argument('--hide-scrollbars') #隐藏滚动条, 应对一些特殊页面
chrome_options.add_argument('blink-settings=imagesEnabled=false') #不加载图片, 提升速度
chrome_options.add_argument('--headless') #浏览器不提供可视化页面. linux下如果系统不支持可视化不加这条会启动失败
# chrome_options.binary_location = r"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe" #手动指定使用的浏览器位置




bro = webdriver.Chrome(executable_path='chromedriver.exe',chrome_options=chrome_options)  # 打开一个谷歌浏览器
# 隐藏浏览器的图形化界面，但是数据还拿到
bro.get('https://www.cnblogs.com/')  # 在地址栏中输入地址
print(bro.page_source)  # 当前页面的内容  (html格式)
time.sleep(5)
bro.close()  # 关闭浏览器

这里我们让代码睡了5秒再关闭浏览器，这是因为代码执行太快的话，浏览器还没加载完，数据也还没获取到，浏览器就关闭了

5.2 基本用法

By方法

from selenium.webdriver.common.by import By #按照什么方式查找，By.ID,By.CSS_SELECTOR

    #===============所有方法===================
    # 1、find_element_by_id
    # 2、find_element_by_link_text
    # 3、find_element_by_partial_link_text
    # 4、find_element_by_tag_name
    # 5、find_element_by_class_name
    # 6、find_element_by_name
    # 7、find_element_by_css_selector
    # 8、find_element_by_xpath
    # 强调：
    # 1、上述均可以改写成find_element(By.ID,'kw')的形式
    # 2、find_elements_by_xxx的形式是查找到多个元素，结果为列表

代码实操

#官网链接：http://selenium-python.readthedocs.io/locating-elements.html
from selenium import webdriver
from selenium.webdriver import ActionChains
from selenium.webdriver.common.by import By #按照什么方式查找，By.ID,By.CSS_SELECTOR
from selenium.webdriver.common.keys import Keys #键盘按键操作
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.wait import WebDriverWait #等待页面加载某些元素
import time

driver=webdriver.Chrome()
driver.get('https://www.baidu.com')
wait=WebDriverWait(driver,10)

try:

```
#===============示范用法===================
# 1、find_element_by_id
print(driver.find_element_by_id('kw'))

# 2、find_element_by_link_text
# login=driver.find_element_by_link_text('登录')
# login.click()

# 3、find_element_by_partial_link_text
login=driver.find_elements_by_partial_link_text('录')[0]
login.click()

# 4、find_element_by_tag_name
print(driver.find_element_by_tag_name('a'))

# 5、find_element_by_class_name
button=wait.until(EC.element_to_be_clickable((By.CLASS_NAME,'tang-pass-footerBarULogin')))
button.click()

# 6、find_element_by_name
input_user=wait.until(EC.presence_of_element_located((By.NAME,'userName')))
input_pwd=wait.until(EC.presence_of_element_located((By.NAME,'password')))
commit=wait.until(EC.element_to_be_clickable((By.ID,'TANGRAM__PSP_10__submit')))

input_user.send_keys('18611453110')
input_pwd.send_keys('xxxxxx')
commit.click()

# 7、find_element_by_css_selector
driver.find_element_by_css_selector('#kw')

# 8、find_element_by_xpath
```


    time.sleep(5)

finally:
    driver.close()

5.3 模拟登录百度

from selenium import webdriver
import time
from selenium.webdriver.common.by import By

bro = webdriver.Chrome(executable_path='chromedriver.exe')  # 打开一个谷歌浏览器
bro.get('https://www.baidu.com')
# 加入等待：找标签，如果找不到，就等待 x秒，如果还找不到就报错
bro.implicitly_wait(10)  # 1 等待
# 从页面中找到登录 a标签，点击它
# By.LINK_TEXT  按a标签文本内容找
btn = bro.find_element(by=By.LINK_TEXT, value='登录')
# 点击它
btn.click()

# 找到按账号登录的点击按钮，有id，优先用id，因为唯一  TANGRAM__PSP_11__changePwdCodeItem
btn_2 = bro.find_element(by=By.ID, value='TANGRAM__PSP_11__changeSmsCodeItem')
btn_2.click()
time.sleep(1)

btn_2 = bro.find_element(by=By.ID, value='TANGRAM__PSP_11__changePwdCodeItem')
btn_2.click()
time.sleep(1)

name = bro.find_element(by=By.ID, value='TANGRAM__PSP_11__userName')
password = bro.find_element(by=By.ID, value='TANGRAM__PSP_11__password')
name.send_keys('[email protected]')
password.send_keys('1234')
time.sleep(1)

submit=bro.find_element(by=By.ID,value='TANGRAM__PSP_11__submit')
submit.click()
time.sleep(2)
bro.close()  # 关闭浏览器

六、selenium其它用法

6.1 查找标签

这里我们需要区分两个查找标签方法的区别

bro.find_element 找一个
bro.find_elements 找所有

# 可以按id，标签名，name属性名，类名，a标签的文字，a标签的文字模糊匹配，css选择器，xpath【后面聊】
# input_1=bro.find_element(by=By.ID,value='wd')  # 按id找
# input_1 = bro.find_element(by=By.NAME, value='wd')  # name属性名
# input_1=bro.find_element(by=By.TAG_NAME,value='input') # 可以按标签名字找
# input_1=bro.find_element(by=By.CLASS_NAME,value='s_ipt') # 可以按类名
# input_1=bro.find_element(by=By.LINK_TEXT,value='登录') # 可以按a标签内容找
# input_1=bro.find_element(by=By.PARTIAL_LINK_TEXT,value='录') # 可以按a标签内容找
# input_1 = bro.find_element(by=By.CSS_SELECTOR, value='#su')  # 可以按css选择器

6.2 获取位置属性大小，文本

print(tag.get_attribute('src'))  # 获取标签属性，用的最多
tag.text  # 文本内容
#获取标签ID，位置，名称，大小（了解）
print(tag.id)
print(tag.location)
print(tag.tag_name)
print(tag.size)

6.3 等待元素被加载

selenium只是模拟浏览器的行为，而浏览器解析页面是需要时间的（执行css，js），一些元素可能需要过一段时间才能加载出来，为了保证能查找到元素，必须等待

等待的方式分两种

隐式等待：在browser.get（'xxx'）前就设置，针对所有元素有效
显式等待：在browser.get（'xxx'）之后设置，只针对某个元素有效

代码

from selenium import webdriver
from selenium.webdriver import ActionChains
from selenium.webdriver.common.by import By #按照什么方式查找，By.ID,By.CSS_SELECTOR
from selenium.webdriver.common.keys import Keys #键盘按键操作
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.wait import WebDriverWait #等待页面加载某些元素

browser=webdriver.Chrome()

#隐式等待:在查找所有元素时，如果尚未被加载，则等10秒
browser.implicitly_wait(10)

browser.get('https://www.baidu.com')

input_tag=browser.find_element_by_id('kw')
input_tag.send_keys('美女')
input_tag.send_keys(Keys.ENTER)

contents=browser.find_element_by_id('content_left') #没有等待环节而直接查找，找不到则会报错
print(contents)

browser.close()

from selenium import webdriver
from selenium.webdriver import ActionChains
from selenium.webdriver.common.by import By #按照什么方式查找，By.ID,By.CSS_SELECTOR
from selenium.webdriver.common.keys import Keys #键盘按键操作
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.wait import WebDriverWait #等待页面加载某些元素

browser=webdriver.Chrome()
browser.get('https://www.baidu.com')



input_tag=browser.find_element_by_id('kw')
input_tag.send_keys('美女')
input_tag.send_keys(Keys.ENTER)

#显式等待：显式地等待某个元素被加载
wait=WebDriverWait(browser,10)
wait.until(EC.presence_of_element_located((By.ID,'content_left')))

contents=browser.find_element(By.CSS_SELECTOR,'#content_left')
print(contents)

browser.close()

6.4 元素操作

# 点击
tag.click()

# 输入内容
tag.send_keys()

# 清空内容
tag.clear()


# 浏览器对象 最大化
bro.maximize_window() 
#浏览器对象  截全屏
bro.save_screenshot('main.png')

6.5 执行js代码

bro.execute_script('alert("美女")')  # 引号内部的相当于 用script标签包裹了


# 可以干的事
	-获取当前访问的地址  window.location
    -打开新的标签
    -滑动屏幕--》bro.execute_script('scrollTo(0,document.documentElement.scrollHeight)')
    -获取cookie，获取定义的全局变量

#cookies的操作
from selenium import webdriver

browser=webdriver.Chrome()
browser.get('https://www.zhihu.com/explore')
print(browser.get_cookies())
browser.add_cookie({'k1':'xxx','k2':'yyy'})
print(browser.get_cookies())

# browser.delete_all_cookies()

6.6 切换选项卡

import time
from selenium import webdriver

browser=webdriver.Chrome(executable_path='chromedriver.exe')
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(2)
browser.switch_to.window(browser.window_handles[0])
browser.get('https://www.sina.com.cn')
browser.close()

6.7 浏览器前进后退

import time
from selenium import webdriver

browser=webdriver.Chrome(executable_path='chromedriver.exe')
browser.get('https://www.baidu.com')
browser.get('https://www.taobao.com')
browser.get('http://www.sina.com.cn/')

browser.back()
time.sleep(2)
browser.forward()
browser.close()

6.8 异常处理

import time
from selenium import webdriver

browser=webdriver.Chrome(executable_path='chromedriver.exe')
try:
except Exception as e:
    print(e)
    
finally:
    browser.close()

七、作业

1、http的get请求和post请求有什么区别

2、期终架构

标签：浏览器,bs4,selenium,element,soup,文档,print,find
From： https://www.cnblogs.com/wxlxl/p/17236981.html