抓取动态网页(Selenium+Python+Selenium环境配置、网页自动化测试系统功能)
　　一、Selenium 介绍和配置1、Selenium 介绍
　　Selenium 是由 ThoughtWorks 专门为 Web 应用程序编写的验收测试工具。Selenium 测试直接在浏览器中运行，可以模拟真实用户的行为。支持的浏览器包括IE（7、8、9)、Mozilla Firefox、Mozilla Suite等。该工具的主要功能包括：测试与浏览器的兼容性-测试您的应用程序可以看是否能在不同的浏览器和操作系统下运行良好 测试系统功能——创建回归测试来验证软件功能和用户需求。
　　2、Selenium+Python 环境配置
　　pip install selenium
　　二、网页自动化测试1、启动浏览器，打开百度搜索
　　from selenium import webdriver
browser = webdriver.Chrome()
browser.get('http://www.baidu.com/')
　　2、 定位元素
　　input_btn = web.find_element_by_id('kw')
input_btn.send_keys('王者荣耀', Keys.ENTER)
　　三、爬取动态网页名言1、网页数据分析3、爬取数据存储
　　with open('Saying.csv', 'w', encoding='utf-8')as fp:
fileWrite = csv.writer(fp)
fileWrite.writerow(['名言', '名人'])
fileWrite.writerows(sayingAndAuthor)
web.close()
　　4、 爬取数据
　　from selenium.webdriver import Chrome
import time
import csv
web = Chrome(r"D:\\DevTools\\Anaconda\\download\\Anaconda3\\Lib\\site-packages\\selenium\\webdriver\\chrome\\chromedriver.exe")
web.get('http://quotes.toscrape.com/js/')
sayingAndAuthor = []
n = 5
for i in range(0, n):
div_list = web.find_elements_by_class_name('quote')
for div in div_list:
saying = div.find_element_by_class_name('text').text
author = div.find_element_by_class_name('author').text
info = [saying, author]
sayingAndAuthor.append(info)
print('成功爬取第' + str(i + 1) + '页')
if i == n-1:
break
web.find_elements_by_css_selector('[aria-hidden]')[-1].click()
time.sleep(2)
with open('Saying.csv', 'w', encoding='utf-8')as fp:
fileWrite = csv.writer(fp)
fileWrite.writerow(['名言', '名人']) # 写入表头
fileWrite.writerows(sayingAndAuthor)
web.close()
　　四、爬虫京东网站图书信息
　　from selenium.webdriver import Chrome
from selenium.webdriver.common.keys import Keys
web = Chrome(r"D:\\DevTools\\Anaconda\\download\\Anaconda3\\Lib\\site-packages\\selenium\\webdriver\\chrome\\chromedriver.exe")
web.get('https://www.jd.com/')
web.maximize_window()
web.find_element_by_id('key').send_keys('计算机图形学', Keys.ENTER) # 找到输入框输入，回车
　　
　　web.find_element_by_class_name('pn-next').click() # 点击下一页
　　with open('计算机图形学.csv', 'w', encoding='utf-8')as fp:
writer = csv.writer(fp)
writer.writerow(['书名', '价格', '作者', '出版社', '预览图片地址'])
writer.writerows(all_book_info)
　　from selenium.webdriver import Chrome
from selenium.webdriver.common.keys import Keys
import time
from lxml import etree
import csv
web = Chrome(r"D:\\DevTools\\Anaconda\\download\\Anaconda3\\Lib\\site-packages\\selenium\\webdriver\\chrome\\chromedriver.exe")
web.get('https://www.jd.com/')
web.maximize_window()
web.find_element_by_id('key').send_keys('计算机图形学', Keys.ENTER)
def get_onePage_info(web):
web.execute_script('window.scrollTo(0, document.body.scrollHeight);')
time.sleep(2)
page_text = web.page_source
# 进行解析
tree = etree.HTML(page_text)
li_list = tree.xpath('//li[contains(@class,"gl-item")]')
book_infos = []
for li in li_list:
book_name = ''.join(
li.xpath('.//div[@class="p-name"]/a/em/text()')) # 书名
price = '￥' + \
li.xpath('.//div[@class="p-price"]/strong/i/text()')[0] # 价格
author_span = li.xpath('.//span[@class="p-bi-name"]/a/text()')
if len(author_span) > 0: # 作者
author = author_span[0]
else:
author = '无'
store_span = li.xpath(
'.//span[@class="p-bi-store"]/a[1]/text()') # 出版社
if len(store_span) > 0:
store = store_span[0]
else:
store = '无'
img_url_a = li.xpath('.//div[@class="p-img"]/a/img')[0]
if len(img_url_a.xpath('./@src')) > 0:
img_url = 'https' + img_url_a.xpath('./@src')[0] # 书本图片地址
else:
img_url = 'https' + img_url_a.xpath('./@data-lazy-img')[0]
one_book_info = [book_name, price, author, store, img_url]
book_infos.append(one_book_info)
return book_infos
def main():
web = Chrome(
r"D:\\DevTools\\Anaconda\\download\\Anaconda3\\Lib\\site-packages\\selenium\\webdriver\\chrome\\chromedriver.exe")
web.get('https://www.jd.com/')
web.maximize_window()
web.find_element_by_id('key').send_keys('计算机图形学', Keys.ENTER) # 找到输入框输入，回车
time.sleep(2)
all_book_info = []
for i in range(0, 3):
all_book_info += get_onePage_info(web)
print('爬取第' + str(i+1) + '页成功')
web.find_element_by_class_name('pn-next').click() # 点击下一页
time.sleep(2)
with open('计算机图形学.csv', 'w', encoding='utf-8')as fp:
writer = csv.writer(fp)
writer.writerow(['书名', '价格', '作者', '出版社', '预览图片地址'])
writer.writerows(all_book_info)
if __name__ == '__main__':
main()
　　五、总结
　　了解有关在网络上抓取数据的更多信息
　　参考文章
　　使用Python+Selenium（一）-自动打开百度搜索
　　Python+Selenium 动态网页信息抓取 查看全部

　　抓取动态网页(url网络url=10,723,35=30)
　　块标签，打开后没有网页数据json
　　
　　点击网络选项卡，可以看到网页向服务器发送了很多请求，而且数据量很大，找起来太费时间了
　　通过点击XHR分类，我们可以减少很多不必要的文件，节省很多时间。接口
　　【XHR 类型是指通过 XMLHttpRequest 方法发送的请求。它可以在后台与服务器交换数据，这意味着它可以在不加载整个网页的情况下更新网页某一部分的内容。也就是说从数据库请求然后接收到的数据是XHR类型的]浏览器
　　然后我们开始在XHR类型下一一搜索，发现如下数据服务器
　　
　　检查请求的消息头并获取其url网络
　　
　　url=",10,723,35,469,821&limit=30" 函数
　　在 Firefox 的新窗口中打开地址
　　
　　打开后，我们可以看到上面的情况，这是一个json格式的文件。然后，它的数据信息以字典的形式存储，数据全部存储在“NewMsgs”键中。
　　
　　因此，我们可以通过访问["NewMsgs"]的键值来获取网页数据
　　然后我们会检查我们需要的“好”和“坏”对应的关键值，以及时事通讯推荐的股票和行业的关键值。
　　
　　
　　查字典后，我们可以很快发现推荐的股票是一个嵌套的字典。字典加列表加字典的情况对应的key值为["NewMsgs"][i]['Stocks']同理，对应的推荐行业key值：["NewMsgs"][i]['BkjInfoArr']
　　通过对比网页数据，我们可以找到对应的“好”和“坏”通讯。
　　
　　
　　经过比较，我们发现好标签对应的“Impact”值为1，没有标签的为“0”，坏标签对应的值为“-1”。
　　知道数据的位置后，我们开始编写代码。
　　先爬取网页，伪装成火狐浏览器，通过添加headers访问数据库地址，防止被识别后被拦截。
　　def get_page(url):
headers={
'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.79 Safari/537.36'
}
req = urllib.request.Request(url=url,headers=headers)
res = urllib.request.urlopen(req)
html = res.read().decode()
return html
　　从上面的分析可以知道，数据是以json格式存储的，所以上面爬取的网页返回的html是json格式的数据。所以我们必须格式化json。
　　json.dumps()#把python对象转化成json格式对象
json.loads()#把json格式转化成python对象
　　转换后我们可以通过下面字典的键值输出“好”、“坏”、推荐“股票”、推荐“行业”
　　行业：html["NewMsgs"][i]['BkjInfoArr']
时间：html["NewMsgs"][i]['UpdatedAt']
股票：html["NewMsgs"][i]['Stocks'][j]['Name']
利好：html["NewMsgs"][i]['Impact'] Impact = -1 --->利空 Impact = 1 --->利好
　　因此，获取数据的代码为：
　　def get_data(html,url):
html = json.loads(html)
c = len(html["NewMsgs"])
for i in range(0,c):
cun =html["NewMsgs"][i]['Impact']#获取含有信息的字典
if cun == 1 or cun == -1:#判断信息是利好仍是利空
print(html["NewMsgs"][i]['UpdatedAt'])
if cun == 1:
print("*************利好*************")
if cun == -1:
print('*************利空*************')
chang = len(html["NewMsgs"][i]['BkjInfoArr'])#获取信息下含有几个利好或利空行业
ch =html["NewMsgs"][i]['Stocks']
for j in range(0,chang):
print('行业：',html["NewMsgs"][i]['BkjInfoArr'][j]['Name'])
if ch!=None:
du = len(html["NewMsgs"][i]['Stocks'])#同理获取含有几个利好或利空股票
for k in range(0,du):
print('股票：',html["NewMsgs"][i]['Stocks'][k]['Name'])
print("**************************\n\n")#信息获取完毕，换行
return 0
　　运行后发现获取的数据并不多，只能获取“点击加载更多”上显示的内容，无法获取点击加载后的数据。
　　
　　我们的爬虫无法爬取这么少的数据。我们需要的是一个可以在点击“加载更多”按钮后抓取数据的爬虫。否则，使用爬虫并不像直接访问网站那么简单。那么如何与以下数据一起捕获呢？
　　让我们再次输入review元素的XHR类型，点击“加载更多”按钮，然后在review元素中查找与新内容一起保存的文件。
　　我们找到了保存新数据的文件和新文件的url地址
　　
　　
　　我们注意到网址已更改。点击打开连接为“,10,723,35,469,821&limit=30&tailmark=1529497523&msgIdMark=310241”
　　后面有些字符比前面的数据url多。我们再多点“加载更多”，查看新内容的文件数据，看看能不能找到一些规律。
　　让我们把新的 URL 放在一起进行比较：
　　https://api.xuangubao.cn/api/pc/msgs?subjids=9,10,723,35,469,821&limit=30&tailmark=1529497523&msgIdMark=310241
https://api.xuangubao.cn/api/pc/msgs?subjids=9,10,723,35,469,821&limit=30&tailmark=1529493624&msgIdMark=310193
https://api.xuangubao.cn/api/pc/msgs?subjids=9,10,723,35,469,821&limit=30&tailmark=1529487816&msgIdMark=310151
　　第一个网址：
　　
　　第二个网址：
　　
　　第三个网址：
　　
　　经过对比，我们可以发现加载后的json数据文件的地址与之前的json文件的['TailMark']和['TailMsgId']有关。
　　是在原来的url=",10,723,35,469,821&limit=30"的基础上加上后缀的
　　“&tailmark=['TailMark']&msgIdMark=['TailMsgId']”
　　并获取url地址。
　　因此，我们获取下一个url地址的代码是：
　　def get_newurl(html):
url="https://api.xuangubao.cn/api/pc/msgs?subjids=9,10,723,35,469,821&limit=30"
url=url+'&tailmark='+html['TailMark']+'&msgIdMark='+html['TailMsgId']
return url
　　那么我们的爬虫代码就基本完成了，下面是整个爬虫代码：
　　# -*- coding:utf-8 -*-
import urllib.request
import urllib.parse
import time
import json
#获取网页
def get_page(url):
headers={
'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.79 Safari/537.36'
}
req = urllib.request.Request(url=url,headers=headers)
res = urllib.request.urlopen(req)
html = res.read().decode()
return html
#获取下一页网址
def get_newurl(html):
url="https://api.xuangubao.cn/api/pc/msgs?subjids=9,10,723,35,469,821&limit=30"
url=url+'&tailmark='+html['TailMark']+'&msgIdMark='+html['TailMsgId']
return url

#获取数据
def get_data(html,url):
html = json.loads(html)
c = len(html["NewMsgs"])
for i in range(0,c):
cun =html["NewMsgs"][i]['Impact']#获取含有信息的字典
if cun == 1 or cun == -1:#判断信息是利好仍是利空
print(html["NewMsgs"][i]['UpdatedAt'])
if cun == 1:
print("*************利好*************")
if cun == -1:
print('*************利空*************')
chang = len(html["NewMsgs"][i]['BkjInfoArr'])#获取信息下含有几个利好或利空行业
ch =html["NewMsgs"][i]['Stocks']
for j in range(0,chang):
print('行业：',html["NewMsgs"][i]['BkjInfoArr'][j]['Name'])
if ch!=None:
du = len(html["NewMsgs"][i]['Stocks'])#同理获取含有几个利好或利空股票
for k in range(0,du):
print('股票：',html["NewMsgs"][i]['Stocks'][k]['Name'])
print("**************************\n\n")#信息获取完毕，换行
#获取经过函数获取下一页的url地址并返回该地址
url = get_newurl(html)
return url
if __name__=='__main__':
url="https://api.xuangubao.cn/api/pc/msgs?subjids=9,10,723,35,469,821&limit=30"
for i in range(0,5):#进行循环爬取下一页地址的股票信息
html=get_page(url)
url=get_data(html,url)
　　因为刚学，很多地方写的不好，比较繁琐冗长。请赐教。 查看全部

　　抓取动态网页(网站建设的基础静态网页的网址形式通常是什么)
　　网站 构建的基础是静态网页，静态网页和动态网页并不是互不兼容的。静态网页的URL形式通常是：后缀.htm、.html等，而是后缀.aspx.asp、.jsp、.php、.perl、.cgi等形式，还有一个象征符号——“？” 在动态网页 URL 中。
　　静态网页的优点
　　1）静态网页内容比较稳定，容易被搜索引擎检索到；2）静态网页加载速度快，静态网页加载时，无需在数据库中搜索；静态网页的缺点1）静态网页没有数据库支持，没有程序和非交互式网页。网站的制作和维护工作量很大，所以当网站信息量很大时，很难完全依赖静态网页的制作；有比较大的限制。
　　
　　静态网站
　　动态网页的优点
　　1）动态网页基于数据库技术，可以大大减少网站维护的工作量；2）采用动态网页技术网站可以实现更多功能，如用户注册、用户登录、在线调查、用户管理、订单管理等；动态网页的缺点1）“？” 所有网页都在网站的数据库中访问，或者由于技术考虑，搜索蜘蛛没有抓取“？”后的内容。做一定的技术处理，满足搜索引擎的要求；2） 动态页面比较麻烦。网页收到用户的指令后，将该指令带到数据库中，查找该指令对应的数据，然后传送到服务器。通过服务器的编译，将动态页面编译成标准的HTML代码传递给用户的浏览器，使用户可以看到网页。结果，加载时间变长，用户不想再次访问您的页面。
　　3） 动态网页是用户输入指令后形成的页面。没有这样的页面，搜索引擎只会抓取现成的，不会自己进入。虽然现在大多数搜索引擎都支持动态页面的抓取，但毕竟还是不完善的。 查看全部

　　抓取动态网页(Python中有之前)
　　很久以前，在学习Python web编程的时候，涉及到一个Python urllib。您可以使用 urllib.urlopen("url").read() 轻松读取页面上的静态信息。但是，随着时代的发展，越来越多的网页使用javascript、jQuery、PHP等语言来动态生成页面信息。因此，使用 urllib 抓取页面的 HTML 并不足以达到预期的效果。
　　解决方案：
　　最简单的想法之一可以动态分析页面信息。Urllib 无法解析动态信息，但浏览器可以。浏览器上显示的处理信息实际上是经过处理的HTML文档。这为我们抓取动态页面信息提供了一个很好的思路。Python-PyQt 中有一个著名的图形库。虽然 PyQt 是一个图形库，但它在 QtWebkit 内部。这是非常实用的。谷歌的Chrome和苹果的Safari都是基于WebKit核心开发的，所以我们可以通过PyQt中的QtWebKit将页面上的信息读取加载成HTML文档，然后解析HTML文档，从HTML文档中提取我们想要的内容。信息。
　　所需材料：
　　作者本人使用的是 Mac OS X，Windows 和 Linux 平台应该使用相同的方法。
　　1、Qt4 库
　　图书馆，而不是创作者。库在Mac默认安装路径下，应该是/home/username/Developor/，Qt4默认安装路径不要改。否则，安装可能会失败。
　　官方网站：
　　2、SIP、PyQt4
　　这两个软件可以在PyQt官网找到。源代码已下载。Mac和Linux需要自己编译。
　　下载地址为：
　　在终端中，切换到解压文件所在的目录。
　　在终端输入
　　蟒蛇配置.py
　　制作
　　须藤制作安装
　　安装和编译。
　　SIP 和 PyQt4 的安装方法是一样的。但是 PyQt4 依赖于 SIP。所以先安装SIP再安装PyQt4
　　1、2 两步完成后，安装Python PyQt4模块。在 Python shell 中输入 import PyQt4 看看能不能找到 PyQt4 模块。
　　3、斯宾纳
　　spynner是一个QtWebKit客户端，可以模拟浏览器完成加载页面、触发事件、填写表单等操作。
　　这个模块可以在 Python 的官方网站上找到。
　　下载链接：
　　解压后cd到安装目录，然后输入sudo python configure.py install安装模块。
　　这样Spynner模块就安装好了。在 python shell 中尝试 import spynner 看看是否安装了模块。
　　Spynner的简单使用
　　Spynner的功能很强大，但是由于本人能力有限，下面介绍一下如何显示网页的源代码。
　　 #! /usr/bin/python #-*-coding: utf-8 -*- import spynner browser = spynner.Browser() #创建一个浏览器对象 browser.hide() #打开浏览器，并隐藏。 browser.load("http://www.baidu.com") #browser 类中有一个类方法load，可以用webkit加载你想加载的页面信息。 #load(是你想要加载的网址的字符串形式) print browser.html.encode("utf-8") #browser 类中有一个成员是html，是页面进过处理后的源码的字符串. #将其转码为UTF-8编码 open("Test.html", 'w+').write(browser.html.encode("utf-8")) #你也可以将它写到文件中，用浏览器打开。 browser.close() #关闭该浏览器
　　通过这个程序，你可以方便的显示webkit处理的页面的HTML源代码。
　　旋转应用程序
　　下面介绍一下spynner的简单应用。通过一个简单的程序，你就可以得到你在浏览器中看到的页面的所有图片。可以使用 HTMLParser、BeautifulSoup 等来完成对 HTMLParser 文档的分析。我选择 HTMParser。
　　 #!/usr/bin/python import spynner import HTMLParser import os import urllib class MyParser(HTMLParser.HTMLParser): def handle_starttag(self, tag, attrs): if tag == 'img': url = dict(attrs)['src'] name = os.path.basename(dict(attrs)['src']) if name.endswith('.jpg') or name.endswith('.png') or name.endswith('gif'): print "Download.....", name urllib.urlretrieve(url, name) if __name__ == "__main__": browser = spynner.Browser() browser.show() browser.load("http://www.artist.cn/snakewu19 ... 6quot;) Parser = MyParser() Parser.feed(browser.html) print "Done" browser.close()
　　通过这个程序，您可以下载您在页面上看到的所有图片。几行简单的程序就可以完成这项艰巨的任务。实现图片的批量处理。这确实是Python语言的优势，然后把繁重的任务留给了第三方。
　　从： 查看全部

　　抓取动态网页(不使用selenium插件模拟浏览器如何获得网页上的动态加载数据)
　　如何在不使用selenium插件的情况下捕获网页的动态加载数据。针对这个问题，本文文章详细介绍了相应的分析和解答，希望能帮助更多想要解决这个问题的朋友找到更简单更简单的OK方法。
　　下面是如何在不使用selenium插件模拟浏览器的情况下获取网页的动态加载数据。
　　进行如下操作：
　　一、找到正确的网址。
　　二、填写URL对应的参数。
　　三、 参数转换成urllib可以识别的字符串数据。
　　四、 初始化请求对象。
　　五、url打开Request对象获取数据。
　　url='http://www.*****.*****/*********'
formdata = {'year': year,
'month': month,
'day': day
}
data = urllib.urlencode(formdata)
request=urllib2.Request(url,data = data)  #如果URL不带参数就是request=urllib2.Request(url)
r = urllib2.urlopen(request)
html=r.read() # html就是你要的数据，可能是html格式，也可能是json，或去他格式
　　下面的步骤都是一样的，关键是如何获取URL和参数。我们以新冠肺炎疫情统计网页为例（#/）。
　　
　　如果直接抓取浏览器的网址，会看到一个没有数据内容的html，只有标题、列名等，没有累计诊断、累计死亡等数据。 因为这个数据页面是动态加载的，而不是静态 html 页面。需要按照我上面写的步骤来获取数据，关键是获取URL和对应的参数formdata。下面我们来谈谈如何使用火狐浏览器获取这两个数据。
　　右键单击肺炎页面，从出现的菜单中选择检查元素。
　　
　　单击上面带有红色箭头的网络选项，然后刷新页面。如下，
　　
　　这里会有大量的网络传输记录。观察最右侧红色框中的“尺寸”列。此列表示此 http 请求传输的数据量。一般动态加载的数据的数据量会比其他页面元素的传输大，为119kb。与其他按字节计算的数据相比，数据量很大。当然，网页的一些装饰图片也是非常大的。这个需要根据文件类型栏来区分。
　　然后点击域名栏对应的行，如下
　　
　　可以在消息头中看到请求的url，这个就是url，点击参数可以看到url对应的参数
　　
　　你能看到网址的结尾吗？后面的参数已经写好了。
　　如果我们使用带参数的 URL，那么
　　request=urllib2.Request(url)，不带数据参数。
　　如果你使用 request=urllib2.Request(url,data = data) 查看全部

　　抓取动态网页(Python爬虫4.2—ajax[动态网页数据]用法教程综述)
　　Python爬虫4.2——ajax【动态网页数据】使用教程
　　概括
　　本系列文档用于给出Python爬虫技术学习的简单教程，巩固您的技术知识，同时，如果对您有所帮助就更好了。
　　Python版本为3.7.4
　　有时，当我们使用请求来获取页面时，我们得到的结果可能与我们在浏览器中看到的不同。在浏览器中可以看到正常显示的页面数据，但是使用requests得到的结果却看不到。这是因为获取的请求都是原创的 HTML 文档，浏览器中的页面是 JavaScript 处理数据后生成的结果。这些数据的来源有很多，可能是通过Ajax加载的，可能是收录在HTML中的，也可能是通过JavaScript和特定算法计算后生成的文档中的文档。
　　因此，如果遇到这样的页面，可以直接使用requests等库来抓取原创页面，无法获取有效数据。这时候就需要从网页后台分析发送到界面的Ajax请求。如果可以使用requests来模拟ajax请求，那么就可以成功爬取。
　　因此，在本文中，我们主要了解什么是 Ajax，以及如何分析和捕获 Ajax 请求。
　　AJAX介绍什么是AJAX
　　AJAX (Asynchronous JavaScript And XML) 异步 JavaScript 和 XML。通过后台与服务器协商的数据交换，Ajax 可以实现网页的异步更新，即不需要重新加载整个网页就可以更新网页的某一部分。如果需要更新传统网页的内容（不使用Ajax），则必须重新加载整个网页，因为传统的数据传输格式使用XML语法，所以称为Ajax。实际上，受限数据交互基本使用JSON，使用Ajax加载数据。即使使用JS，将数据渲染到浏览器，在查看网页源代码时，也看不到通过ajax加载的数据，只能看到这个。由 url 加载的 HTML 代码。
　　示例说明
　　在浏览网页时，我们会发现很多网页都有向下滚动查看更多选项的功能。比如微博、今日头条等，有的会根据鼠标下拉自动加载，这些其实就是ajax加载的过程。我们可以看到页面并没有完全刷新，也就是说页面的链接没有改变，但是页面中有新的内容，这就是获取新数据并通过ajax呈现的过程。
　　请求分析
　　使用 Chrome 开发者工具的过滤功能过滤掉所有的 Ajax 请求，这里不再详细说明。
　　Fiddler抓包工具也可以用于抓包分析。Fiddler工具的使用方法这里不做说明，大家可以网上搜索查看。
　　Ajax 响应结果一般为json 数据格式。
　　获取方法直接分析Ajax使用的接口，然后通过代码请求这个接口获取数据（下面的例子就是这么一个普通）。使用Selenium + Chromedriver模拟浏览器行为获取数据（文章后面会继续介绍）。方式优缺点
　　分析界面
　　可直接请求数据，无需分析工作，代码量小，性能高。
　　分析接口比较复杂，尤其是一些被js混淆的接口，必须有一定的js知识，发现很容易被爬取。
　　硒
　　直接模拟浏览器的行为，浏览器可以请求的也可以用selenium来请求，爬虫更稳定。
　　代码量大，性能低。
　　示例说明
　　举个例子，爬取“做一个高颜值的程序员是什么感觉？”这个问题的所有答案。在 知乎 下。示例代码如下：
<p># 引入所需库
import json
import requests
# 声明定义请求头
header = {

'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64) '
'AppleWebKit/537.36 (KHTML, '
'like Gecko) Chrome/67.0.3396.99 '
'Safari/537.36',
'Host': "www.zhihu.com",
'Referer': "https://www.zhihu.com/question/37787176"
}
def answer(url_):
"""
获取问题答案
:param url_:
:return:
"""
r = requests.get(url_, headers=header)
data = r.text
jsonobj = json.loads(data)
return jsonobj
# 问题答案接口地址
url = "https://www.zhihu.com/api/v4/q ... ot%3B
# 获取回答总数
answer_total = int(answer(url)['paging']['totals'])
offset = 0
while offset 查看全部

　　抓取动态网页(会计学跨考心理学在一个经济学院上学的历史学专业)
　　抓取动态网页，抓取页面中的每一个内容抓取某一个明星的每一条微博，并且做一个排名每一段讲座的文字描述摘抄之后放到word文档中修改并导出为xml文件，做为导航的索引网页中某一部分的截图在每一个提问者的回答下面作为标注，并加上title标签网页中有以下多个信息抓取并预览一个评论列表以及回复列表统计每个回复之间的总时间线以及该回复的完整回复列表统计时间线时点。
　　会计学跨考心理学
　　在一个经济学院上学的历史学专业的本科生，学习了最后一学期，目前正在准备考研，考试科目就是政治英语两门专业课，具体专业书籍没有去了解，有听同学推荐过一本看上去不错的书，名字叫《经济学原理》，我上考研复习班的时候，辅导班会推荐的，没有听说有考上什么c9的名校的历史学专业。目前准备考历史的研究生一方面是想系统性的学习历史，但还没想清楚为什么要选历史专业的这个问题，一方面是因为高考之后对金融那方面不感兴趣所以本科也是选择了经济学，准备读金融方面的研究生。
　　我觉得有历史方面的研究对自己来说并不是一个好的职业方向，又不是在历史专业发现了自己喜欢的领域，喜欢的东西。最后呢是想通过考历史研究生来考取一个特别不错的大学的研究生，当个老师或者做博士后。现在有三个方向，一个是方向一。经济史方向，据说清华、北大方向比较好，但我对这方面并不感兴趣，看书就去图书馆了解了一下历史学中比较好的院校，想看看其他学校的师资情况，看看这方面的研究水平如何。
　　方向二是考古学方向，这个方向其实比较稳，但是我不知道自己兴趣所在，不想做一个科研工作者，并且英语有点差，所以考古学方向要换一个兴趣所在，没有目标。方向三是风景园林史方向，因为高中已经比较喜欢画画，尤其是园林设计，对自己的要求也是比较高，考古专业的话大概是比较难考，至少报考人数会是个问题，而这方面历史学是一个跨考生，所以也尝试选择这方面。希望能有小伙伴看到我这个回答，互相交流一下各自的学习生活，也欢迎大家来参加我的知乎live。 查看全部

　　抓取动态网页(一下是喜欢动态页面还是静态页面好？(图)
)
　　很多人都在讨论网站优化到底是静态页面好还是动态页面好。一些站长说蜘蛛喜欢静态页面，就像我们捕捉动物一样。我们总是喜欢站着捕捉那些安静的动物。领导认为静态页面就像捕捉安静的动物一样。
　　在判断搜索引擎还是更喜欢静态页面还是更喜欢动态页面时，我们需要普及一下网站的基础知识，什么是静态页面，静态页面是指页面中的URL不收录一些动态元素，如“?、%、&amp;”，只有页面中收录这些元素的URL地址才称为动态页面。
　　静态页面和动态页面的区别在于它是否收录一些动态元素，而这些页面对于早期的搜索引擎来说是不可理解的，因为它被改变了，所以搜索引擎会认为它是多个不同的URL，然后才会继续抓取这个动态网址地址，造成“搜索引擎蜘蛛黑洞”。
　　早期的搜索引擎不太喜欢动态页面，更多的喜欢爬静态页面。随着搜索引擎技术的不断进步，各大搜索引擎都宣称可以抓取静态页面，动态页面。和静态页面一样处理，也包括谷歌、百度、搜搜等。
　　搜索引擎在不断改进，动态页面也能很好的抓取抓取。因此，当 URL 中的动态元素很少时，可以使用动态页面。如果 URL 中的动态元素过多，这对搜索引擎非常不友好。
　　例如，像这样的 URL：**/? URL 只收录一个“？” 动态的，可以被搜索引擎蜘蛛抓取，经过一段时间网站收录和排名都很好，那么搜索引擎喜欢动态页面还是静态页面呢？我觉得他们两个都应该喜欢。
　　 查看全部

　　抓取动态网页(
谷歌浏览器和F火狐爬取动态网页对比一下的区别)
　　
　　前言
　　当我们抓取网页时，其中一些是静态的。对于这种类型的网页，我们可以使用通用的方法轻松抓取数据。但是，一些网页抓取阈值仍然存在。它们是动态的，通过js（包括ajax）渲染。这类网页一般的爬虫方法是爬不上去的，可能爬不出来指定的数据。这个时候，我们必须转变思路来解决问题。所谓道高一尺，魔高一尺。本文文章介绍了使用Splash和selenium爬取动态网页，并比较了两者的区别。
　　版本介绍
　　本文中提到的各种工具的版本
　　硒
　　Selenium 是一种用于 Web 应用程序测试的工具。Selenium 测试直接在浏览器中运行，就像真实用户在操作一样。支持的浏览器包括IE(7, 8, 9, 10, 11）, Mozilla Firefox, Safari, Google Chrome, Opera等。本工具的主要功能包括： 测试与浏览器的兼容性-test 看看您的应用程序可以在不同的浏览器和操作系统上运行良好 测试系统功能-创建回归测试以验证软件功能和用户需求。
　　以上是百度百科的解释。通过上面的解释，我们可以很容易的理解selenium的用途了。是的，很容易想到自动化测试场景。开发者编写一个函数，然后测试者可以编写相应的测试用例来模拟浏览器来测试该函数。（会写自动化脚本的测试人员据说和普通测试人员不是一个级别的）
　　上面百科里提到，使用selenium的时候，操作就像使用浏览器一样。那么，我们以什么方式运作呢？更常用的 Google Chrome 和 F Firefox 都提供了无头版本的浏览器
　　无头浏览器
　　无头浏览器是指可以运行图形界面的浏览器。我可以通过编程来控制无头浏览器自动执行各种任务，例如测试、网页截图等。
　　我们可以通过浏览器提供的headless版本打开浏览器。第一个使用点是先在电脑上安装相应的普通版浏览器，然后通过代理购买程序操作浏览器
　　火狐无头浏览器下载地址：
　　谷歌浏览器无头下载链接：
　　这里值得注意的是，无头版谷歌浏览器需要下载与电脑上安装的谷歌浏览器类似的版本。比如电脑上安装的谷歌浏览器的版本是79.*.*，那么下载的headless版本的版本也应该是79.*.*，并且大版本要一致. Firefox 没有这个要求。
　　PhantomJS
　　说到无头浏览器，就不得不提 PhantomJS。
　　PhantomJS 是一个无界面、可编写脚本的 WebKit 浏览器引擎。它本身支持多种 Web 标准：DOM 操作、CSS 选择器、JSON、Canvas 和 SVG。
　　现在Python对PhantomJS的支持变成了Selenium，PhantomJS相关的扩展也被废弃了。这只是为了理解。
　　Python操作硒
　　Python也实现了selenium，通过selenium webdriver调用对应的浏览器进行操作，我们来看一个python使用selenium的简单案例：
　　1、 实现唤醒浏览器打开网页
　　2、设置无头操作
　　# -*- coding: utf-8 -*-
# 引入selenium webdriver类
from selenium import webdriver
# 引入火狐浏览器配置类
from selenium.webdriver import FirefoxOptions
# 实例化一个配置项
options = FirefoxOptions()
# 设置无需打开浏览器
options.add_argument('--headless')
# 设置浏览器类型为火狐
browser = webdriver.Firefox(firefox_options=options)
# 打开一个网址
browser.get('https://item.jd.com/100008348542.html')
# 获取网页源码
source = browser.page_source
print(source)
　　上面source=browser.page_source这行代码就是js渲染后得到的网页源代码。拿到源码后就可以为所欲为
　　操作方便吗？
　　溅
　　Splash 是一个 javascript 渲染服务。它是一个带有 HTTP API 的轻量级 Web 浏览器，使用 Twisted 和 QT5 在 Python 3 中实现。QT反应器用于使服务完全异步，允许通过QT主循环利用webkit并发。
　　功能介绍参考 查看全部

　　抓取动态网页(简单写一下用selenium处理动态加载页面相关的知识。)
　　自学python爬虫快半年了。目前我面临着三个爬虫技术需要解决的问题：动态加载、多线程并发爬取、模拟登录。目前，我正在不断学习相关知识。下面简单写一下用selenium动态加载页面的相关知识。目标-抓取页面上所有的高考成绩信息。
　　对于动态加载，当我一开始看到Selenium+Phantomjs的强大时，直接学会了这个。打开网页查看网页源代码（不是查看元素），会发现要爬取的信息不在源代码中。也就是说，无法从网页的源代码中解析得到数据。Selenium+Phantomjs 的强大之处在于能够捕获完整的源代码并上传代码。
　　from selenium import webdriver
def get_grade(url):
print(url)
#匿名爬虫
#假定9999端口开启tor服务
service_args = ['--proxy=localhost:9999', '--proxy-type=socks5', ]
driver = webdriver.PhantomJS(executable_path=这里是PhantomJS的绝对路径)
driver.get(url)
data = driver.page_source
print(data)
get("http://gkcx.eol.cn/soudaxue/qu ... 6quot;)
　　这里也用到了匿名爬虫，这里我只是在可以使用的级别，具体原理还不是很了解。. . 这样获取完整的源代码是不是很容易？当然很简单，但是简单的代价是牺牲了速度。
　　这个程序并不太复杂。爬行量大的时候，模拟爬行的效率会变得很低（不是多线程的……不知道多线程能不能加快速度）。下面是这个项目的完整代码：
　　import xlsxwriter
from selenium import webdriver
from bs4 import BeautifulSoup
def get_grade(url):
print(url)
#匿名爬虫
#假定9999端口开启tor服务
service_args = ['--proxy=localhost:9999', '--proxy-type=socks5', ]
driver = webdriver.PhantomJS(executable_path=r"F:\Techonolgoy\Python\file\spider\spider_tools\JS\1\phantomjs.exe")
driver.get(url)
data = driver.page_source
# print(data)
soup = BeautifulSoup(data, 'lxml')
grades = soup.find_all('tr')
for grade in grades:
global i
if '' in str(grade):
i += 1
print(i)
grade_text =grade.get_text()
print(grade_text)
grade_text = str(grade_text)
city = grade_text[:-13]
worksheet.write(i,0,city)
time = grade_text[-13:-9]
worksheet.write(i,1,time)
subs = grade_text[-9:-7]
worksheet.write(i,2,subs)
s = grade_text[-7:-3]
worksheet.write(i,3,s)
grade = grade_text[-3:]
worksheet.write(i,4,grade)
i = -1
workbook = xlsxwriter.Workbook('grades.xlsx')
worksheet = workbook.add_worksheet()
worksheet.set_column('A:A',10)
worksheet.set_column('B:B', 10)
worksheet.set_column('C:C', 10)
worksheet.set_column('D:D', 10)
worksheet.set_column('E:E', 10)
urls = ['http://gkcx.eol.cn/soudaxue/queryProvince.html?page='+str(num)
for num in range(1,166)]
for url in urls:
get_grade(url)
workbook.close()
　　家里网速太慢，20分钟就爬完了。. . 捕获的EXCEL文件格式如下：
　　
　　被这次模拟抓到的乌龟的速度折磨够了，于是在大牛们的指点下，找到了另一种处理这类问题的方法——直接问json文件获取数据！下面写这个。 查看全部

　　抓取动态网页(了解静态页面和动态页面的区别：动态网页和静态网页)
　　在了解静态页面和动态页面的区别之前，不妨先了解一下两者的概念，这有助于区分什么是动态页面，什么是静态页面。
　　
　　静态页面：
　　静态网页的内容是预先确定的。每个页面都是管理员生成页面时读取数据库生成的一个文件（通常后缀为htm、html、shtml等形式）。的形式存储在网络服务器或本地计算机/服务器上。网页内容一旦发布到网页服务器上，无论是否被用户访问，每个静态网页的内容都存储在网站服务器上。换句话说，静态网页是实际存储在服务器上的文件。每个网页都是一个独立的文件，内容相对稳定。
　　动态网页：
　　动态网页依赖于用户提供的参数，在用户访问页面时实时读取数据库中存储的数据来创建页面。换句话说，动态页面不会以文件的形式存储在 Web 服务器上。
　　动态网页和静态网页的区别：
　　1、交互性
　　由于静态网页的很多内容都是固定的，在功能上有很大的限制，所以交互性差
　　动态网页可以实现更多功能，如用户登录、注册、查询等。
　　2、更新维护
　　一旦静态网页内容发布到网站服务器上，这些网页的内容就存储在网站服务器上，无论是否有用户访问。如果需要修改网页内容，可以直接找到修改其源代码的文件，然后保存即可。数据库不支持静态网页。当信息量很大时，网页的生成和维护难度很大。
　　动态网页可以根据不同的用户请求、时间或环境要求动态生成不同的网页内容，而动态网页一般都是基于数据库技术，可以大大减少网站维护的工作量。
　　3、 响应速度：
　　静态网页内容相对固定，不需要连接数据库，响应速度快，容易被搜索引擎检索到。与动态页面相比，静态页面对搜索引擎更加友好。
　　动态网页实际上并不是独立存在于服务器上的网页文件。服务器只有在用户请求时才返回一个完整的网页，这涉及到数据连接、访问、查询等一系列过程，因此响应速度比静态页面差。.
　　（4)访问功能：
　　静态网页的每个网页都有一个固定的网址，网页网址后缀为.htm、.html、.shtml等常见形式，不收录“?”，利于搜索引擎抓取和收录。
　　这 ”？” 在动态网页中搜索引擎检索存在一定的问题。搜索引擎通常无法访问网站 数据库中的所有网页，或者由于技术考虑，它们在搜索过程中不会爬行。“？”后的内容 在网址中。 查看全部

　　抓取动态网页(python爬取js执行后输出的信息--python库)
　　Python有很多库，可以让我们轻松编写网络爬虫，抓取某些页面，获取有价值的信息！但是很多时候，爬虫抓取到的页面只是一个静态页面，也就是网页的源代码，就像在浏览器上“查看网页的源代码”一样。一些动态的东西，比如一个javascript脚本执行后产生的信息，是无法捕捉到的。这里暂时给出一些解决方案，可以用于python爬取js执行后输出的信息。
　　1、两种基本解决方案
　　1.1 使用dryscrape库动态抓取页面
　　Node.js 脚本通过浏览器执行并返回信息。所以js执行后抓取页面最直接的方法之一就是用python模拟浏览器的行为。WebKit 是一个开源浏览器引擎。Python 提供了许多库来调用这个引擎。干刮就是其中之一。它调用webkit引擎来处理收录js等的网页！
　　
import dryscrape
# 使用dryscrape库 动态抓取页面
def get_url_dynamic(url):
    session_req=dryscrape.Session()
    session_req.visit(url) #请求页面
    response=session_req.body() #网页的文本
    #print(response)
    return response
get_text_line(get_url_dynamic(url)) #将输出一条文本
　　这也适用于其他收录js的网页！虽然可以满足抓取动态页面的要求，但是缺点还是很明显：慢！太慢了。其实想想也是有道理的。Python调用webkit请求页面，页面加载完成后，加载js文件，让js执行，返回执行的页面。应该会更慢！另外，可以调用webkit的库还有很多：PythonWebkit、PyWebKitGit、Pygt（你可以用它来写浏览器）、pyjamas等等，听说它们也可以实现同样的功能！
　　1.2 selenium web 测试框架
　　Selenium 是一个网页测试框架，它允许调用本地浏览器引擎发送网页请求，因此也可以实现抓取网页的要求。
　　# 使用selenium webdriver是可行的，但是会实时打开浏览器窗口
　　
def get_url_dynamic2(url):
    driver=webdriver.Firefox() #调用本地的火狐浏览器，Chrom 甚至 Ie 也可以的
    driver.get(url) #请求页面，会打开一个浏览器窗口
    html_text=driver.page_source
    driver.quit()
    #print html_text
    return html_text
get_text_line(get_url_dynamic2(url)) #将输出一条文本
　　这也是临时解决办法！类似selenium的框架也有风车，感觉稍微复杂一点，就不赘述了！
　　2、selenium的安装和使用
　　2.1 selenium的安装
　　要在 Ubuntu 上安装，您可以直接使用 pip install selenium。由于以下原因：
　　1. selenium 3.x 启动，在 webdriver/firefox/webdriver.py 的 __init__ 中，executable_path="geckodriver"; 并且 2.x 是 executable_path="wires"
　　2. Firefox 47 及以上，需要下载第三方驱动，geckodriver
　　还需要一些特殊的操作：
　　1. 下载geckodriverckod地址：
　　
mozilla/geckodriver
　　2. 解压后，将geckodriverckod存放在/usr/local/bin/路径下：
　　
sudo mv ～/Downloads/geckodriver /usr/local/bin/
　　2.2 selenium的使用
　　1. 运行错误：
　　
driver = webdriver.chrome()
TypeError: 'module' object is not callable
　　解决方法：浏览器名称需要大写Chrome和Firefox，即
　　2. 通过
　　
content = driver.find_element_by_class_name('content')
　　为了定位元素，该方法返回 FirefoxWebElement。当你想获取收录的值时，你可以通过
　　
value = content.text
　　到此为止这篇关于python如何爬取动态网站的文章介绍到这里，更多相关python如何爬取动态网站，请搜索易速云之前的文章或者继续浏览下面的相关文章，希望大家以后多多支持易速云！ 查看全部

　　抓取动态网页(爬取页面中的新闻数据对应的数据包url和新闻详情数据)
　　要求：抓取页面中的新闻数据。
　　分析：
　　1. 首先通过对页面的分析，会发现页面中的新闻数据是动态加载的，通过抓包工具抓取数据，可以发现动态数据并不是获取到的动态数据被ajax请求（因为没有捕获到ajax请求的数据包），那么就只剩下一种可能了，动态数据由js动态生成。
　　2. 使用抓包工具找出是哪个js请求产生了动态数据：打开抓包工具，然后向首页url（要求第一行的url）发起请求，抓包所有的请求的数据包。
　　
　　分析响应js包返回的数据：
　　
　　响应数据对应的url可以在抓包工具对应的数据包的header选项卡中获取。获取到url后，发起请求获取上图中选择的对应数据。响应数据类型为application/javascript类型，所以可以通过正则表达式提取得到的响应数据，提取外大括号中的数据，然后使用json.loads转换为字典类型，然后逐步解析出数据中所有新闻详情页面的 URL。
　　- 获取详情页对应的新闻详情数据：向详情页发出请求后，会发现详情页的新闻数据也是动态加载的，所以和上面的步骤一样，获取详情页中的部分数据在抓包工具中查看详情页搜索并定位到指定的js数据包：
　　
　　js数据包的url为：
　　
　　获取到详情页url后，可以请求数据包对应的响应数据，对应的数据中收录对应的新闻详情数据。注意响应数据类型也是application/javascript，所以数据分析同上！
　　分析首页所有新闻详情页的url与新闻详情数据对应的js数据包的url的关联：
　　-首页新闻详情页url：5c39c314138da31babf0b16af5a55da4/e43e220633a65f9b6d8b53712cba9caa.html
　　-新闻详情数据对应的js数据包url：5c39c314138da31babf0b16af5a55da4/datae43e220633a65f9b6d8b53712cba9caa.js
　　-所有新闻详情对应的js数据包黄色选中部分除了红色部分不同外都是一样的，但是红色部分和新闻详情页url中红色部分是一样的！！！新闻详情页的url可以在上面的过程中解析出来。所以，现在可以批量生成js数据包对应的详细数据的url，然后批量数据请求，获取响应数据，再解析响应数据，完成最终的需求！ 查看全部

　　抓取动态网页(谷歌爬虫是如何抓取和收录什么类型的抓取JavaScript？)
　　身体的一部分
　　我们测试了 Google 爬虫如何抓取 JavaScript，这是我们从中学到的东西。
　　认为 Google 无法处理 JavaScript？再想一想。Audette Audette 分享了一系列测试结果。他和他的同事测试了 Google 和 收录 会抓取哪些类型的 JavaScript 函数。
　　
　　
　　​
　　长话短说
　　1. 我们进行了一系列测试，并确认谷歌可以以多种方式执行和收录 JavaScript。我们也确认了 Google 可以渲染整个页面并读取 DOM，从而可以收录 动态生成内容。
　　2. DOM 中的 SEO 信号（页面标题、元描述、规范标签、元机器人标签等）都受到关注。动态插入DOM的内容也可以爬取和收录。此外，在某些情况下，DOM 甚至可能优先于 HTML 源代码语句。虽然这需要更多的工作，但这是我们的几个测试之一。
　　简介：Google 执行 JavaScript 并读取 DOM
　　早在 2008 年，Google 就成功抓取了 JavaScript，但很可能仅限于某种方式。
　　今天，谷歌显然不仅可以制定他们的抓取和收录 JavaScript 类型，而且在渲染整个网页方面也取得了重大进展（尤其是最近 12 到 18 个月）。
　　在 Merkle，我们的 SEO 技术团队希望更好地了解 Google 爬虫可以抓取哪些类型的 JavaScript 事件和 收录。经过研究，我们发现了惊人的结果，并确认 Google 不仅可以执行各种 JavaScript 事件，还可以动态生成收录 内容。怎么做？Google 可以读取 DOM。
　　什么是DOM？
　　很多从事SEO的人不了解什么是文档对象模型（DOM）。
　　
　　
　　​
　　当浏览器请求一个页面时会发生什么，DOM 是如何参与的？
　　在 Web 浏览器中使用时，DOM 本质上是一个应用程序接口或 API，用于标记和构建数据（例如 HTML 和 XML）。该接口允许 Web 浏览器将它们组合成一个文档。
　　DOM 还定义了如何获取和操作结构。尽管 DOM 是一种独立于语言的 API（不依赖于特定的编程语言或库），但它通常用于 Web 应用程序中的 JavaScript 和动态内容。
　　DOM 代表接口或“桥”，将网页与编程语言连接起来。解析 HTML 并执行 JavaScript 的结果就是 DOM。网页的内容不仅（不仅）是源代码，而且是 DOM。这使它变得非常重要。
　　
　　
　　​
　　JavaScript 如何通过 DOM 接口工作。
　　我们很高兴地发现 Google 可以读取 DOM，并且可以解析信号和动态插入的内容，例如标题标签、页面文本、标题标签和元注释（例如：rel = canonical）。您可以阅读完整的详细信息。
　　这一系列的测试和结果
　　因为想知道会爬取哪些JavaScript特性和收录，所以分别在Google爬虫上创建了一系列测试。通过创建控件，确保可以独立理解 URL 活动。下面，让我们详细介绍一些有趣的测试结果。它们分为5类：
　　JavaScript 重定向
　　JavaScript 链接
　　动态插入内容
　　动态插入元数据和页面元素
　　rel = "nofollow" 的一个重要例子
　　
　　
　　​
　　示例：用于测试 Google 爬虫理解 JavaScript 能力的页面。
　　1. JavaScript 重定向
　　我们首先测试了常见的 JavaScript 重定向。URL 以不同方式表达的结果是什么？我们为两个测试选择了 window.location 对象：测试 A 使用绝对路径 URL 调用 window.location，测试 B 使用它。相对路径。
　　结果：重定向很快就被谷歌跟踪了。从收录的角度来看，它们被解释为301——最终状态URL，而不是谷歌收录中的重定向URL。
　　在随后的测试中，我们在权威网页上使用完全相同的内容来完成使用 JavaScript 重定向到同一站点的新页面。原创网址在 Google 热门查询的首页上排名。
　　结果：果然，重定向被谷歌跟踪了，但是原创页面不是收录。新的URL是收录，它立即在同一个查询页面的同一个位置上排名。这让我们感到惊讶。从排名的角度来看，JavaScript 重定向行为（有时）与永久 301 重定向非常相似。
　　下次，您的客户想要为他们的 网站 完成 JavaScript 重定向操作，您可能不需要回答，或者回答：“请不要”。因为这好像有转职排名信号的关系。这个结论得到了引用谷歌指南的支持：
　　使用 JavaScript 重定向用户可能是一种合法的做法。例如，如果您将登录用户重定向到内部页面，则可以使用 JavaScript 来完成此操作。在仔细检查 JavaScript 或其他重定向方法时，请确保您的网站遵循我们的指南并考虑其意图。请记住，将 301 重定向重定向到您的 网站 是最好的，但是如果您没有访问您的 网站 服务器的权限，您可以为此使用 JavaScript 重定向。
　　2. JavaScript 链接
　　我们使用多种编码方法测试了不同类型的 JS 链接。
　　我们测试下拉菜单的链接。历史搜索引擎一直无法跟踪此类链接。我们要确定是否会跟踪 onchange 事件处理程序。重要的是，这只是特定类型的执行，而我们需要的是：其他变化的影响，而不是像上面JavaScript重定向的强制操作。
　　
　　
　　​
　　示例：Google Work 页面上的语言选择下拉菜单。
　　结果：链接被完全抓取和跟踪。
　　我们还测试了常见的 JavaScript 链接。以下是最常见的 JavaScript 链接类型，而传统 SEO 推荐纯文本。这些测试包括 JavaScript 链接代码：
　　作用于外部 href 键值对 (AVP)，但在标签内（“onClick”）
　　函数 href 内部 AVP("javascript: window.location")
　　在 a 标签之外执行，但在 href 中调用 AVP("javascript: openlink()")
　　等等
　　结果：链接被完全抓取和跟踪。
　　我们接下来的测试是进一步测试事件处理程序，比如上面的onchange测试。具体来说，我们要使用鼠标移动的事件处理程序，然后隐藏 URL 变量，该变量仅在事件处理程序函数（在本例中为 onmousedown 和 onmouseout）被触发时执行。
　　结果：链接被完全抓取和跟踪。
　　构造链接：我们知道谷歌可以执行JavaScript，但我们想确认他们是否可以读取代码中的变量。所以在这个测试中，我们连接了可以构造 URL 字符串的字符。
　　结果：链接被完全抓取和跟踪。
　　3. 动态插入内容
　　显然，这些是要点：动态插入文本、图像、链接和导航。高质量的文本内容对于搜索引擎理解网页的主题和内容至关重要。在这个充满活力的网站时代，它的重要性是毋庸置疑的。
　　这些测试旨在检查在两种不同场景中动态插入文本的结果。
　　1)。测试搜索引擎是否可以统计动态插入的文本，文本来自页面的HTML源代码。
　　2)。测试搜索引擎是否可以统计动态插入的文本，并且文本来自页面的HTML源代码之外（在外部JavaScript文件中）。
　　结果：两种情况下都可以抓取文本和收录，页面根据内容排名。凉爽的！
　　为了深入了解，我们测试了一个用JavaScript编写的客户端全局导航，导航中的链接是通过document.writeIn函数插入的，确认可以完全爬取和跟踪。需要指出的是，Google 可以解释网站 使用AngularJS 框架和HTML5 History API (pushState) 构建，可以渲染和收录 它，并且可以像传统的静态网页一样进行排名。这就是不禁止 Google 爬虫获取外部文件和 JavaScript 的重要性，这可能也是 Google 将其从 Ajax Supporting SEO Guide 中删除的原因。当您可以简单地呈现整个页面时，谁需要 HTML 快照？
　　经过测试，发现无论是什么类型的内容，结果都是一样的。例如，在加载到 DOM 后将获取图像并收录。我们甚至做了这样一个测试：通过动态生成结构数据来制作面包屑（breadcrumb navigation），并插入到DOM中。结果？成功插入后的面包屑出现在搜索结果（搜索引擎结果页面）中。
　　值得注意的是，Google 现在推荐使用 JSON-LD 标签来形成结构化数据。我相信未来会有更多基于此的东西。
　　4. 动态插入元数据和页面元素
　　我们动态地将各种对 SEO 至关重要的标签插入到 DOM 中：
　　标题元素
　　元描述
　　元机器人
　　规范标签
　　结果：在所有情况下，标签都可以被抓取并表现得像 HTML 源代码中的元素。
　　一个有趣的补充实验可以帮助我们理解优先级的顺序。当出现相互矛盾的信号时，哪一个会获胜？如果源代码中没有index和nofollow标签，DOM中没有index和follow标签，会发生什么？在这个协议中，HTTP x-robots 响应头如何作为另一个变量使用行为？这将是未来全面测试的一部分。但是，我们的测试表明，当发生冲突时，Google 会忽略源代码中的标签并支持 DOM。
　　5. rel="nofollow" 的一个重要例子
　　我们想要测试 Google 如何响应出现在源代码和 DOM 之间的链接级别的 nofollow 属性。我们还创建了一个没有 nofollow 的控件。
　　
　　
　　​
　　对于nofollow，我们分别测试了源代码和DOM生成的注解。
　　源代码中的 nofollow 按预期工作（不跟踪链接）。但是DOM中的nofollow无效（链接被跟踪，页面为收录）。为什么？因为修改 DOM 中的 href 元素的操作发生得太晚了：Google 在执行添加 rel="nofollow" 的 JavaScript 函数之前，已准备好抓取链接并排队等待 URL。但是，如果将href="nofollow"的a元素插入到DOM中，nofollow和链接是同时插入的，所以会被跟踪。
　　结果
　　从历史的角度来看，各种 SEO 建议都尽可能关注“纯文本”内容。动态生成的内容、AJAX 和 JavaScript 链接会损害主流搜索引擎的 SEO。显然，这对谷歌来说不再是问题。JavaScript 链接的操作方式类似于普通的 HTML 链接（这只是表面，我们不知道程序在幕后做了什么）。
　　JavaScript 重定向的处理方式与 301 重定向类似。
　　动态插入的内容，即使是元标记，例如 rel 规范注释，无论是在 HTML 源代码中还是在解析初始 HTML 后触发 JavaScript 生成 DOM，都以相同的方式处理。
　　Google 依赖于完全呈现页面和理解 DOM，而不仅仅是源代码。不可思议！（记住要允许 Google 爬虫获取那些外部文件和 JavaScript。）
　　谷歌已经以惊人的速度在创新方面将其他搜索引擎甩在了后面。我们希望在其他搜索引擎中看到相同类型的创新。如果他们要在新的网络时代保持竞争力并取得实质性进展，就意味着他们必须更好地支持 HTML5、JavaScript 和动态网站。
　　对于SEO，不了解以上基本概念和谷歌技术的人应该学习学习，以追赶当前的技术。如果你不考虑 DOM，你可能会失去一半的份额。
　　并非本文所表达的所有观点均由 Search Engine Land（搜索引擎 网站）提供，部分观点由客座作者提供。所有作者的名单。 查看全部

　　抓取动态网页(抓不到数据怎么破JS开始我还想着自学一波？)
　　介绍
　　自从学了爬虫，每天不写个爬虫小姐姐就觉得难受：
　　小姐姐长得还挺好看的，就是身体一天比一天瘦，多喝营养快车吧！
　　（快来学习Python爬虫，一起爬爬可爱的小姐姐~）
　　抓了太多，发现有些小网站很狡猾，就开始反爬虫了。它们不直接生成数据，而是通过加载JS生成数据，然后你打开Chrome浏览器的开发者选项，然后你会发现Elements页面的结构和网络抓包返回的内容不一样. 网络抓包中没有对应的数据。数据应该放的地方竟然是JS代码，比如煎蛋的少女图：
　　对于我这种不懂JS的安卓狗，不禁感叹：
　　如果我无法捕获数据，如何打破数据。一开始想自己学一波JS基础语法，然后去模拟抓包获取别人的JS文件，然后自己分析逻辑，再摆弄真实的URL。后来放弃了，结果有些JS被加密了，要爬的页面太多了。什么时候分析每个这样的分析...
　　后来无意中发现有一个自动化测试框架：Selenium 可以帮助我们处理这个问题。简单说说这个东西的使用，我们可以写代码让浏览器：
　　然后这个东西不支持浏览器功能。您需要在第三方浏览器中使用它。支持以下浏览器，需要将对应的浏览器驱动下载到Python对应的路径：
　　Chrome: /a/chromium.... FireFox: /mozilla/gec... PhantomJS: / IE: /index.html Edge: /en-us/micro... Opera: /operasoftwa...
　　下面直接开始本节的内容吧~
　　1.安装硒
　　这个很简单，直接通过pip命令行安装：
　　sudo pip install selenium
复制代码
　　PS：记得公司小伙伴问我为什么在win上不能执行pip，我下载了很多pip。其实如果你安装Python3，它默认已经自带pip了。您需要配置额外的环境变量，pip。路径在Python安装目录的Scripts目录下~
　　在Path后面加上这个路径就行了~
　　2.下载浏览器驱动
　　因为 Selenium 没有浏览器，所以需要依赖第三方浏览器。如果要调用第三方浏览器，需要下载浏览器的驱动。因为作者使用的是Chrome，所以我们以Chrome为例。其他 浏览器自行搜索相关信息！打开 Chrome 浏览器并输入：
　　chrome://version
复制代码
　　可以查看Chrome浏览器版本的相关信息，这里主要注意版本号：
　　61.好的，那么到下面网站查看对应的驱动版本号：
　　/2.34/notes....
　　好的，接下来下载v2.34版本的浏览器驱动：
　　/index.html？...
　　下载完成后，解压zip文件，将解压后的chromedriver.exe复制到Python Scripts目录下。（这里不用担心win32，64位浏览器可以正常使用！）
　　PS：对于Mac，将解压后的文件复制到usr/local/bin目录下，然后再复制到usr/bin目录下。
　　接下来我们写一个简单的代码来测试：
　　from selenium import webdriver
browser = webdriver.Chrome() # 调用本地的Chrome浏览器
browser.get('http://www.baidu.com') # 请求页面，会打开一个浏览器窗口
html_text = browser.page_source # 获得页面代码
browser.quit() # 关闭浏览器
print(html_text)
复制代码
　　执行这段代码会自动调出浏览器访问百度：
　　并且控制台会输出HTML代码，也就是直接获取到的Elements页面结构，JS执行后的页面~接下来就可以抓取我们的煎蛋少女图了~
　　3.Selenium简单实战：抢煎蛋少女图
　　直接分析Elements页面的结构，找到你想要的关键节点：
　　显然这是我们抓到的那个小姐姐的照片。复制这个网址，看看我们打印的页面结构中有没有这样的东西：
　　是的这很棒。有了这个页面数据，我们再通过一波Beautiful Soup来获取我们想要的数据~
　　经过上面的过滤，我们就可以得到姐姐的图片的URL：
　　只需打开一个验证，啧：
　　看到下一页只有30个小姐姐，显然满足不了我们。第一次加载的时候，我们得到一波页码，然后我们就知道有多少页，然后我们去拼接URL来加载差异。比如这里总共有448页：
　　只需将其拼接成这样的 URL： 过滤以获取页码：
　　接下来，我将填写代码，循环抓取每个页面上的小姐姐，然后下载到本地。完整代码如下：
　　import os
from selenium import webdriver
from bs4 import BeautifulSoup
import urllib.request
import ssl
import urllib.error
base_url = 'http://jandan.net/ooxx'
pic_save_path = "output/Picture/JianDan/"
# 下载图片
def download_pic(url):
correct_url = url
if url.startswith('//'):
correct_url = url[2:]
if not url.startswith('http'):
correct_url = 'http://' + correct_url
print(correct_url)
headers = {
'Host': 'wx2.sinaimg.cn',
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) '
'Chrome/61.0.3163.100 Safari/537.36 '
}
try:
req = urllib.request.Request(correct_url, headers=headers)
resp = urllib.request.urlopen(req)
pic = resp.read()
pic_name = correct_url.split("/")[-1]
with open(pic_save_path + pic_name, "wb+") as f:
f.write(pic)
except (OSError, urllib.error.HTTPError, urllib.error.URLError, Exception) as reason:
print(str(reason))
# 打开浏览器模拟请求
def browser_get():
browser = webdriver.Chrome()
browser.get('http://jandan.net/ooxx')
html_text = browser.page_source
page_count = get_page_count(html_text)
# 循环拼接URL访问
for page in range(page_count, 0, -1):
page_url = base_url + '/' + str(page)
print('解析：' + page_url)
browser.get(page_url)
html = browser.page_source
get_meizi_url(html)
browser.quit()
# 获取总页码
def get_page_count(html):
soup = BeautifulSoup(html, 'html.parser')
page_count = soup.find('span', attrs={
'class': 'current-comment-page'})
return int(page_count.get_text()[1:-1]) - 1
# 获取每个页面的小姐姐
def get_meizi_url(html):
soup = BeautifulSoup(html, 'html.parser')
ol = soup.find('ol', attrs={
'class': 'commentlist'})
href = ol.findAll('a', attrs={
'class': 'view_img_link'})
for a in href:
download_pic(a['href'])
if __name__ == '__main__':
ssl._create_default_https_context = ssl._create_unverified_context
if not os.path.exists(pic_save_path):
os.makedirs(pic_save_path)
browser_get()
复制代码
　　操作结果：
　　看看我们的输出文件夹~
　　是的，发了这么多小姐姐，就是想骗你学Python！
　　4.PhantomJS
　　PhantomJS 没有界面浏览器。特点：将网站加载到内存中，在页面上执行JavaScript。因为它不显示图形界面，所以它比完整的浏览器运行效率更高。（如果某些Linux主机上没有图形界面，有界面的浏览器是不能使用的，可以使用PhantomJS来规避这个问题）。
　　在 Win 上安装 PhantomJS：
　　在 Ubuntu/MAC 上安装 PhantomJS：
　　sudo apt-get install phantomjs
复制代码
　　！！！关于 PhantomJS 的重要说明：
　　今年 4 月，Phantom.js 的维护者宣布退出 PhantomJS，这意味着该项目可能不再维护！！！Chrome 和 FireFox 也开始提供 Headless 模式（无需挂断浏览器），所以估计使用 PhantomJS 的小伙伴会慢慢迁移到这两个浏览器。Windows Chrome 需要 60 以上的版本才能支持 Headless 模式。启用 Headless 模式也很简单：
　　selenium 的官方文档中还写道：
　　运行时也会报这个警告：
　　5.Selenium实战：模拟登录CSDN并保存Cookie
　　CSDN登录网站:/account/log...
　　分析页面结构，不难发现对应的登录输入框和登录按钮：
　　我们要做的就是在这两个节点输入账号密码，然后触发登录按钮，并将cookie保存在本地，然后我们就可以带着cookie访问相关页面了~
　　首先写一个方法来模拟登录：
　　找到你输入账号密码的节点，设置你的账号密码，然后找到登录按钮节点，点击，然后等待登录成功。登录成功后，可以对比current_url是否发生了变化。然后保存Cookies，这里我使用的是pickle库，你可以使用其他的，比如json，或者字符串拼接，然后保存到本地。如果没有意外，应该可以拿到Cookie，然后使用Cookie访问主页。
　　通过 add_cookies 方法设置 Cookie。参数是字典类型。另外一定要先访问get链接，再设置cookie，否则会报无法设置cookie的错误！
　　通过查看右下角是否变为登录状态就可以知道是否使用Cookie登录成功：
　　6.Selenium 常用函数
　　Seleninum 作为自动化测试的工具，自然提供了很多自动化操作的功能。下面是我觉得比较常用的函数，更多的可以看官方文档： 官方API文档：seleniumhq.github.io/selenium/do...
　　1) 定位元素
　　PS：将元素更改为元素将定位所有符合条件的元素并返回一个列表，例如：find_elements_by_class_name
　　2) 鼠标操作
　　有时需要在页面上模拟鼠标操作，例如：单击、双击、右键、按住、拖动等，可以导入ActionChains类：mon.action_chains.ActionChains 使用ActionChains(driver).XXX来调用对应节点的行为
　　3) 弹出窗口
　　对应类：mon.alert.Alert，感觉用的不多……
　　如果触发某个时间，弹出对话框，可以调用如下方法获取对话框：alert = driver.switch_to_alert()，然后调用如下方法即可：
　　4)页面前进、后退、切换
　　切换窗口：driver.switch_to.window("window name") 或者在driver.window_handles中遍历window_handles获取句柄： driver.switch_to_window(handle) driver.forward() #forward driver.back() #backward
　　5) 页面截图
　　driver.save_screenshot("Screenshot.png")
　　6) 页面等待
　　现在越来越多的网页使用 Ajax 技术，因此程序无法确定元素何时完全加载。如果实际页面等待时间过长，某个dom元素没有出来，而你的代码直接使用了这个WebElement，那么就会抛出NullPointer异常。
　　为了避免元素定位困难，增加ElementNotVisibleException的概率。所以Selenium提供了两种等待方式，一种是隐式等待，一种是显式等待。
　　显式等待：
　　显式等待指定某个条件，然后设置最大等待时间。如果此时没有找到该元素，则会抛出异常。
　　from selenium import webdriver
from selenium.webdriver.common.by import By
# WebDriverWait 库，负责循环等待
from selenium.webdriver.support.ui import WebDriverWait
# expected_conditions 类，负责条件出发
from selenium.webdriver.support import expected_conditions as EC
driver = webdriver.PhantomJS()
driver.get("http://www.xxxxx.com/loading")
try:
# 每隔10秒查找页面元素 id="myDynamicElement"，直到出现则返回
element = WebDriverWait(driver, 10).until(
EC.presence_of_element_located((By.ID, "myDynamicElement"))
)
finally:
driver.quit()
复制代码
　　如果不写参数，程序会调用0.5s一次，检查元素是否默认已经生成。如果元素已经存在，它将立即返回。
　　下面是一些内置的等待条件，你可以直接调用这些条件，而不用自己编写一些等待条件。
　　title_is title_contains Presence_of_element_located visible_of_element_located visible_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 invisibility_of_element_located element_to_be_clickable -。它是 Displayed and Enabled staleness_of element_to_be_selected element_located_to_be_selected element_selection_state_to_be element_located_selection_state_to_be alert_is_present
　　隐式等待：
　　隐式等待比较简单，就是简单的设置一个等待时间，以秒为单位。
　　from selenium import webdriver
driver = webdriver.PhantomJS()
driver.implicitly_wait(10) # seconds
driver.get("http://www.xxxxx.com/loading")
myDynamicElement = driver.find_element_by_id("myDynamicElement")
复制代码
　　当然，如果不设置，则默认等待时间为0。
　　7.执行JS语句
　　driver.execute_script(js statement) 例如滚动到底部：js = document.body.scrollTop=10000 driver.execute_script(js)
　　概括
　　本节介绍一波使用 Selenium 自动化测试框架来捕获 JavaScript 动态生成的数据。Selenium 需要依赖第三方浏览器。注意 PhantomJS 无界面浏览器的过时问题。您可以使用 Chrome 和 FireFox 提供的 HeadLess 来替换它。; 抓个煎蛋女孩图和模拟CSDN自动登录的例子，熟悉Selenium的基本使用，还是收到不少货。当然，Selenium 的水还是很深的。目前我们可以用它来应对JS动态加载数据页面数据的抓取。
　　最近有点冷，大家记得适时加衣服哦~另外，因为这周事情比较多，先断更新一下。下周见。下一块要啃的骨头是 Python 多线程。我可以在视觉上，恭敬地啃几节经文。敬请期待~
　　顺便写下你的想法：
　　下载本节源码：
　　/coder-pig/R...
　　本节参考资料：
　　来吧，Py 交易
　　如果想加群一起学Py，可以加，智障机器人Pig，验证信息收录：python，python，py，Py，加群，事务，混蛋关键词之一即可经过;
　　验证通过后回复群获取群链接（不要破解机器人！！！）~~~欢迎像我这样的各类Py初学者和Py大神加入，一起开心分享学习♂Xi , 面包车 ♂转向 py。 查看全部

　　抓取动态网页(R语言爬取动态网页增加我自己爬取的爬取实例！)
　　其实我早就想给B站写个专栏了，草稿箱里还有几篇写了一半的读书报告，没想到我写的第一篇专栏是关于编程的2333333。
　　也是偶然有朋友问我能不能帮忙爬取数据，但是我没有爬取动态网页的数据，所以按照网上的教程整理了一下，然后加上了自己爬取的例子.
　　
　　一、R语言爬取动态网页的前期准备
　　R语言爬取动态网页所需的包可以使用“RSelenium”或“Rwebdriver”，两者都可以通过调用Selenium Server模拟浏览器环境进行操作。
　　Selenium 是一个用于网页测试的Java 开源软件，它可以模拟浏览器的点击、滚动、滑动和文本输入操作[1]。
　　因为RSelenium可以直接在CRAN上下载安装（Rwebdriver包需要从gethub下载安装，比较麻烦），所以我使用RSelenium包进行动态网页爬取。
　　install.packages("RSelenium") #安装RSelenium包
　　library(RSelenium) #加载RSelenium包
　　但是加载完RSelenium包后不能直接使用，需要添加相应的辅助条件：
　　1.1 JAVA安装及环境配置
　　目前网上大部分教程都推荐安装JDK（Java Development Kit），但其实安装JRE（Java Runtime Environment）就足够了。因为我自己的电脑上有现成的。
　　JAVA的安装可以到其官方网站下载：
　　下载完成后，按照默认安装一步一步来！！！！
　　环境变量配置：
　　网上很多教程教你如何配置环境变量，但是我在window10上下载安装JAVA后，实际测试不需要配置环境变量。
　　可以在命令提示符下打开运行窗口【win+R，输入cmd，点击确定】界面，输入以下命令：
　　如果上述命令有正常响应，而不是提示命令不存在或报错，则说明安装JAVA，无需配置以下环境变量。如果还是不行，请按照以下要求配置环境变量：
　　配置环境变量JAVA_HOME，【就是你安装JAVA的地址】
　　
　　配置环境变量JAVA_HOME
　　配置环境变量PATH，【一般电脑上已经有PATH的环境变量了，加进去就行了】
　　其实就是连接到JAVA的二进制文件目录
　　网上有很多教程，添加的环境变量如下：
　　%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;
　　分号代表新建目录，但其实没有必要，因为没有jre文件夹，可能是安装JDK导致的问题
　　
　　PATH环境变量配置
　　配置环境变量 CLASS_PATH
　　变量值。;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar
　　
　　CLASS_PATH 环境变量配置
　　三个变量设置好后，打开cmd（命令提示符，在Windows中搜索cmd找到），输入javac，如果没有报错，则安装成功。
　　1.2 安装 Selenium
　　硒下载地址：
　　输入网址后看到的界面是这样的：
　　
　　selenium首页截图2020.02.19
　　只需下载最新版本的 Selenium。
　　当前最新版本下载名称为：selenium-server-standalone-3.141.59.jar
　　然后使用命令提示符【win+R打开运行窗口，输入cmd，点击确定】，输入selenium的存放路径，输入如下命令：
　　java -jar selenium-server-standalone-3.141.59.jar
　　启动硒服务
　　
　　出现：Selenium Server is up and running on port XXXX 表示运行成功。
　　默认端口为 4444。
　　如果出现错误，可能是你的4444端口处于占用状态
　　运行以下程序时请保持selenium运行【即不要关闭此窗口】，否则以下R程序将无法正常运行
　　1.3 安装浏览器和驱动组件
　　我在这里推荐 Firefox，但也可以使用 Chrome。[RSelenium 支持 5 种浏览器：chrome、firefox、htmlunit、internetexplorer、iphone]。主要原因是Chrome在中国不容易安装。无法登录其官网下载Chrome浏览器。【但是我在企鹅电脑管家的软件管理中发现了Chrome浏览器的安装。我没试过，各位。看看能不能试试~】
　　安装火狐浏览器后，需要安装 GeckoDriver 来驱动火狐浏览器。
　　下载地址为：
　　然后请将下载的文件安装在火狐浏览器的安装路径下
　　Firefox 的默认安装路径为：C:\Program Files\Mozilla Firefox
　　环境变量的配置是下图中倒数第二个变量
　　
　　配置PATH环境变量
　　如果以上所有操作都完成了，我们就可以愉快的运行和编写R语言程序了。
　　
　　二、R语言爬取动态网页的例子
　　我们要抓取的是腾讯公益网站的网页。我们抓取的是项目状态结束的项目信息。
　　
　　腾讯公益专页
　　对应的代码如下：
　　【因为B博客不能插入代码块，所以我来插入图片】
　　说明因为是第一版写的程序，后来发现一个问题，就是腾讯公益的完成项目虽然显示有1448页，但实际上进入第100页时，所有的内容都是与第 100 页相同。页面都是一样的，因为我只是来学习动态网页的爬取方法，所以成功后没有修改代码~~~~~~
　　因此，下面的代码只能抓取1-100页的基本信息。
　　
　　抓取腾讯公益网页的代码
　　爬取完成后的数据存放在outdata数据框中：
　　示例结果
　　
　　结果示例（executor的数据也做了相应的混淆处理） 查看全部

　　抓取动态网页(支点电商：网站静态页面和动态页面有什么区别？)
　　网站静态页面和动态页面有什么区别？它们的优点和缺点是什么？支点电商多年来一直专注于外贸建设。现总结如下，仅供参考：
　　对于静态页面，网页的代码在页面中，不需要执行asp、php、jsp、.net等程序来生成客户端的网页。常见静态页面示例：.html 扩展名、.htm 扩展名。它实际存在，无需服务器编译，直接加载到客户端浏览器中显示。网站的后缀是htm、html、shtml、xml等静态网页的常见形式。
　　动态页面是通过执行asp、php、jsp、.net等程序生成客户端web代码的网页。动态页面常见的扩展名有：.asp、.php、.jsp、.cgi等。虽然动态页面的页面代码没有变化，但显示的内容会随着时间、环境或数据库操作的结果而变化。注意不要将动态网页与页面内容是否动态混淆。这里所说的动态网页与网页上的各种动画、滚动字幕等视觉动态效果没有直接关系。动态网页也可以是纯文本内容或收录各种动画的内容。这些只是特定的网页。内容的呈现形式，无论网页是否有动态效果，
　　那么在了解了它们的定义之后，我们再来看看它们的优缺点。
　　1、 静态页面加载速度快。加载静态页面时，无需在数据库中搜索。动态页面比较麻烦。网页接收到用户的指令后，将该指令带到数据库中，找到该指令对应的数据，然后传递给服务器，通过服务器的编译将动态页面编译成标准的HTML代码，传递给用户的浏览器，以便用户可以看到网页。结果，加载时间变长，用户不想再次访问您的页面。
　　2、静态页面内容相对稳定，容易被搜索引擎收录，有利于搜索引擎优化。动态网页是用户输入指令后形成的页面。没有这样的页面，搜索引擎只会抓取现成的，不会自己进入。虽然现在大多数搜索引擎都支持动态页面的抓取，但毕竟还是不完善的。
　　3、 与动态页面相比，静态网页在数据库支持和交互性方面都比较逊色。
　　一般来说，一个网站构建的基础是静态网页，静态网页和动态网页并不是互不兼容的。为了提高网站内的搜索速度，使用了动态网页技术网站，它还可以将网页的内容变成静态网页来运行。将网页静态化是网站开发的一个很好的方法，可以提高网页打开的速度。
　　通过对优缺点的了解，相信大家对网站页面的动静都不会那么陌生。Fulcrum电商是一个静态页面，拥有多年外贸网站建设经验。选择支点，选择未来。 查看全部

　　抓取动态网页(python爬取js执行后输出的信息--本篇内容)
　　在本期内容中，小编与大家分享了python如何抓取动态网站的相关知识点，有兴趣的朋友可以参考一下。
　　Python有很多库，可以让我们轻松编写网络爬虫，抓取某些页面，获取有价值的信息！但是很多时候，爬虫抓取的页面只是一个静态页面，也就是网页的源代码，就像在浏览器上“查看网页的源代码”一样。一些动态的东西，比如一个javascript脚本执行后产生的信息，是无法捕捉到的。这里暂时给出一些解决方案，可以用于python爬取js执行后输出的信息。
　　1、两种基本解决方案
　　1.1 使用dryscrape库动态抓取页面
　　Node.js 脚本通过浏览器执行并返回信息。所以js执行后抓取页面最直接的方法之一就是用python模拟浏览器的行为。WebKit 是一个开源浏览器引擎。Python 提供了许多库来调用这个引擎。干刮就是其中之一。它调用webkit引擎来处理收录js等的网页！
　　 import dryscrape # 使用dryscrape库 动态抓取页面 def get_url_dynamic(url):     session_req=dryscrape.Session()     session_req.visit(url) #请求页面     response=session_req.body() #网页的文本     #print(response)     return response get_text_line(get_url_dynamic(url)) #将输出一条文本
　　这也适用于其他收录js的网页！虽然可以满足抓取动态页面的要求，但是缺点还是很明显：慢！太慢了。其实想想也是有道理的。Python调用webkit来请求页面，页面加载完成后，加载js文件，让js执行，返回执行的页面。应该会更慢！另外，可以调用webkit的库还有很多：PythonWebkit、PyWebKitGit、Pygt（你可以用它来写浏览器）、pyjamas等等，听说它们也可以实现同样的功能！
　　1.2 selenium web 测试框架
　　Selenium 是一个网页测试框架，它允许调用本地浏览器引擎发送网页请求，因此也可以实现抓取网页的要求。
　　# 使用selenium webdriver是可行的，但是会实时打开浏览器窗口
　　 def get_url_dynamic2(url):     driver=webdriver.Firefox() #调用本地的火狐浏览器，Chrom 甚至 Ie 也可以的     driver.get(url) #请求页面，会打开一个浏览器窗口     html_text=driver.page_source     driver.quit()     #print html_text     return html_text get_text_line(get_url_dynamic2(url)) #将输出一条文本
　　这也是临时解决办法！类似selenium的框架也有风车，感觉稍微复杂一点，就不赘述了！
　　2、selenium的安装和使用
　　2.1 selenium的安装
　　要在 Ubuntu 上安装，您可以直接使用 pip install selenium。由于以下原因：
　　1. selenium 3.x 启动，在 webdriver/firefox/webdriver.py 的 __init__ 中，executable_path="geckodriver"; 并且 2.x 是 executable_path="wires"
　　2. Firefox 47 及以上，需要下载第三方驱动，geckodriver
　　还需要一些特殊的操作：
　　1. 下载geckodriverckod地址：
　　 mozilla/geckodriver
　　2. 解压后，将geckodriverckod存放在/usr/local/bin/路径下：
　　 sudo mv ～/Downloads/geckodriver /usr/local/bin/
　　2.2 selenium的使用
　　1. 运行错误：
　　 driver = webdriver.chrome() TypeError: 'module' object is not callable
　　解决方法：浏览器名称需要大写Chrome和Firefox，即
　　2. 通过
　　 content = driver.find_element_by_class_name('content')
　　为了定位元素，该方法返回 FirefoxWebElement。当你想获取收录的值时，你可以通过
　　 value = content.text
　　到此为止这篇关于python如何爬取动态网站的文章就介绍到这里了，更多相关python如何爬取动态网站，请搜索之前的文章in html中文网络@>或者继续浏览下面的相关文章，希望大家以后多多支持html中文站！
　　以上就是python如何抓取动态网站的详细内容，更多内容请关注其他相关html中文网站文章！ 查看全部

　　抓取动态网页(爬取一个图片网站，写一个比较简单的爬虫；迪丽)
　　今天我们来爬一张图网站
　　, 编写一个比较简单的图片下载爬虫；
　　
　　迪列巴
　　图片太多了，我只剪了这些，大概几千张；
　　对，没错，就是你喜欢的胖迪，
　　1、 先分析一下花瓣网图片的加载方式
　　打开花瓣网首页，搜索“迪丽热巴”，
　　
　　第一页加载20张图片
　　下拉加载第二页图片时，弹出登录框，只有登录账号才能继续加载后续所有图片；
　　
　　第二页加载了20张图片
　　可以看出的图片加载是异步的。这时候我们可以选择selenium来模拟登录网页，模仿浏览器的操作不断下拉加载所有图片；
　　2、主要思想：
　　首先，登录您的帐户并输入您要搜索的图片。每次下拉加载当前页面的图片后，提取图片的url并保存在列表中。由于每页有20张图片，我也在这里下载图片。每保存20个url就下载对应的20张图片；
　　3、准备：
　　安装selenium库，pip或者下载到本地安装都可以；
　　下面是安装Phantomjs或者Chrome
　　
　　chromedriver的安装路径
　　
　　phantomjs安装路径
　　可以自己百度下载，也可以参考下面的博客，谢谢这位博主
　　4、 直接上传下面的代码
<p>from selenium import webdriver
import time
import os
import requests
class Huaban():
#获取图片url并存到列表urls_list
def get_picture_url(self, content):
global path
path = "E:\spider\pictures\huaban" + &#39;\\&#39; + content
# 保存图片到磁盘文件夹 file_path中，默认为当前脚本运行目录下的文件夹
if not os.path.exists(path):
os.makedirs(path)
url = "http://huaban.com"
# 使用Chrome浏览器模拟打开网页，但是要把下载的chromedriver.exe放在python的文件路径下,
# 调试好之后换成PhantomJs,速度应该会快一点
# driver = webdriver.PhantomJs()
# 下拉滑动浏览器屏幕，具体下拉多少根据自己实际情况决定
driver = webdriver.PhantomJS()
#driver = webdriver.Chrome()
# 设置全屏
driver.maximize_window()
driver.get(url)
time.sleep(8)
# 点击登录、呼起登录窗口
driver.find_elements_by_xpath(&#39;//a[@class="login btn wbtn"]&#39;)[0].click()
# sign in the username
try:
driver.find_elements_by_xpath(&#39;//input[@name="email"]&#39;)[0].send_keys(&#39;花瓣账号&#39;)
print(&#39;user success!&#39;)
except:
print(&#39;user error!&#39;)
time.sleep(3)
# sign in the pasword
try:
driver.find_elements_by_xpath(&#39;//input[@name="password"]&#39;)[0].send_keys(&#39;账号密码&#39;)
print(&#39;pw success!&#39;)
except:
print(&#39;pw error!&#39;)
time.sleep(3)
# click to login
try:
driver.find_elements_by_xpath(&#39;//a[@class="btn btn18 rbtn"]&#39;)[0].click()
print(&#39;click success!&#39;)
except:
print(&#39;click error!&#39;)
time.sleep(3)
#搜索图片
driver.find_elements_by_xpath(&#39;//input[@placeholder="搜索你喜欢的"]&#39;)[0].send_keys(content)
driver.find_elements_by_xpath(&#39;//form[@id="search_form"]/a&#39;)[0].click()
time.sleep(5)
i = 0
page = 1
global name
global store_path
global urls_list
urls_list = []
#获取图片的总数
pictures_count = driver.find_elements_by_xpath(&#39;//a[@class="selected"]/i&#39;)[0].text
print(pictures_count)
pages = int(int(pictures_count) / 20)
print(pages)
#匹配到图片url所在的元素
url_elements = driver.find_elements_by_xpath(&#39;//span[@class="stop"]/../img&#39;)
#遍历图片元素的列表获取图片的url
for url_element in url_elements:
picture_url = url_element.get_attribute("src")[:-3] + "658"
#防止获取重复的图片url
if picture_url not in urls_list:
urls_list.append(picture_url)
while page 查看全部

　　抓取动态网页(近年来，网站建设趋势：越来越多的静态网站而非动态网站)
　　近年来网站的建设趋势：越来越静态的网站代替动态的网站，静态的网站越来越受到一些大公司的青睐，做小网站 时间的恩惠。
　　内容
　　关于静态 网站 和动态 网站 的 5 个事实：
　　动态网页是在检索过程中由服务器生成的。比如使用像WordPress（PHP/MySQL）这样只收录HTML/CSS/Javascript静态站点生成器的静态网页，提前生成静态网站，提供布局和内容分离，两种方案各有利弊，必须在项目之间保持平衡。大公司都用静态网站生成器给微网站等中小型网站什么是动静？是动态页面吗？
　　动态网页是在调用服务器时动态生成内容的网页。大多数内容管理系统 (cms) 都是这种情况。最著名的例子：WordPress。每次打开页面时，都会使用服务器端编程语言 PHP 从数据库中提取内容并将其组装到页面中。如果配置了缓存，它只会部分重新生成。
　　什么是静态网站？
　　静态网页由 HTML、CSS 和可选的 Javascript 组成。该页面不必由服务器端编程语言按需生成。
　　什么是静态 网站 生成器？
　　静态网页生成器在本地计算机或云端生成完整的静态网页。然后可以将它们存储在服务器或内容交付网络 (CDN) 中。
　　与内容管理系统类似，生成器提供了使用布局模板来分离内容和页框，在某些情况下甚至可以从外部cms中提取内容。
　　静态网站的优缺点更安全，因为没有数据库和服务器更快，因为不需要执行服务器端代码，网站速度是搜索排名的重要因素，更好的扩展可以放入内容分发网络（CDN），以提高全局可用性和页面加载速度。整个网站的版本控制和备份可以通过Git进行。缺点比较适合程序员或者其他技术人员。适合中小型网站（微网站、博客、企业网站）需要能够使用Git（GitHub、Gitlab）的工作流，推荐：最简单以及史上通俗易懂的Git教程！网站内搜索需要额外的JavaScript，没有cms 用于价格更新等。内容主要以 Markdown 文件的形式创建。没有足够强大的SEO插件
　　如上所述，这些缺点中有很多是可以解决的，但与已知的cms（如：WordPress）相比，需要做的工作要多得多。
　　在我看来，静态 网站 生成器仍处于起步阶段，但它具有潜力！
　　cms变成Headless（无头cms），也就是他们只提供内容创建接口，通过API提供内容。然后，静态 网站 生成器、Javascript 应用程序或移动应用程序可以访问此 API。
　　最近把PHP的接口改成了Node.js，提供了这样的API。Contentful 等其他提供商已采用 Headless cms 作为他们的商业模式。然而，这种趋势成为主流还需要一段时间。
　　强烈推荐 3 个静态站点生成器
　　下面我将介绍我已经使用过的3个静态生成器。它们只是现有解决方案的一小部分。您可以在 网站StaticGen（排名在 GitHub Stars 之后）上找到完整的介绍。
　　1. 雨果
　　
　　Hugo 基于 Go 编程语言，Go 以其非常、非常快的速度而闻名。简而言之，Hugo 是迄今为止最快的静态站点生成器。当然，具有许多独立页面的 网站 将受益于使用静态站点生成器。
　　Hugo目前的开发进度非常好，开源和下面提到的所有其他静态站点生成器，并提供各种开箱即用的功能。缺点是在 Go 的模板语言中，并不是每个人都能找到正确的方法。到目前为止，还无法通过插件对其进行扩展。
　　尽管大多数开发人员都习惯使用 Node.js、Python 或 Ruby，但基于 Go 的静态站点生成器 Hugo 因其出色的速度而获得了足够高的分数。
　　你可能感兴趣：使用Gitlab + Hugo + Netify 搭建自动部署静态网站教程
　　适用于：网站 单页数量多、类别多（类别、标签等）的中型博客
　　2. Hexo
　　
　　Hexo 是一个基于 Node.js 的快速、简洁、高效的博客框架。Hexo 使用 Markdown（也可以使用其他渲染引擎）解析 文章，几秒钟之内就可以生成主题漂亮的静态网页。
　　这使得 Hexo 成为更简单、更快捷的解决方案之一，一旦安装在本地机器上，就可以轻松操作。这使得创建较小的 网站 非常方便，例如微型 网站。Sass、Less、Markdown、Pug 等将自动转换为 HTML、CSS 和 Javascript。它比 Grunt、Gulp 更容易。
　　Hexo是台湾开发者Tommy Chen于2012年开发的一款产品，由于语言优势，Hexo在国内拥有大量用户，文档和社区非常完善。有足够多的例子可以学习，这也是我推荐 Hexo 的重要原因之一。
　　Hexo自身的功能非常简单，也就是说如果你需要做一些现场SEO优化，还需要自己寻找并安装一些Hexo插件，或者自己开发相关插件。
　　Hexo 适用于：微网站、博客网站、小产品网站
　　你可能感兴趣：《适合个人博客网站推广的10个高佣联盟》
　　3. Next.js
　　
　　Next.js 在 StaticGen 上排名第一，足以说明它的易用性。配置简单，服务端渲染，代码分离，SEO友好，内置零配置TypeScript支持等优点。
　　而世界一流的厂商也在用它来做大规模的网站。在Next.js的ShowCase中，有腾讯、优步、Hulu、Netlify、耐克等一流厂商。而腾讯新闻是使用 Next.js 开发的。
　　这些足以说明 Next.js 有多好！
　　不过我把它排在 Hugo 和 Hexo 之后，因为它是基于 React 框架开发的。也就是说，你需要一些 React 代码库来使用它来构建一个静态的 网站。
　　如果你是开发者，那我强烈推荐你试试 Next.js 构建静态网站！
　　适合：React 开发者，可以搭建中大型网站
　　总结
　　上面推荐的三个静态站点生成器基于 Go、Node.js 和 React。当然，其他语言中也有静态的 网站 生成器。您可以在 StaticGen 上查看更多信息。
　　虽然Php广泛应用于各种大中小型公司，但我认为它不适合作为静态站点生成器。为什么？因为在 Php 中读取、操作和保存文件比在 Node.js 或 Go 中慢得多。
　　静态网站的优点和缺点都很突出。没有更好的解决方案，只有哪种解决方案更合适。
　　总结一句话：为不同的工作需求选择合适的工具！
　　如果你对静态网站生成器有什么问题或者其他想法，欢迎留言一起交流~ 查看全部