python抓取动态网页
python抓取动态网页(python抓取动态网页视频教程可视化的video编码方法推荐使用)
网站优化 • 优采云 发表了文章 • 0 个评论 • 26 次浏览 • 2022-04-15 21:00
python抓取动态网页(python抓取动态网页视频教程可视化的video编码方法推荐使用)
python抓取动态网页视频教程在抓取网页视频时，为了保证抓取视频的质量和速度，python必须能正确判断视频是不是用于生产环境使用。正确判断方法分为页面判断和视频编码判断两种。其中页面判断和视频编码判断根据题主给的样例，和平台有关，题主可以查阅相关资料具体实现。python抓取动态网页视频教程可视化的video编码方法推荐使用gcc-llvm一种定制化的方法。python抓取动态网页视频教程。
第一看编码判断，可以看b站的相关说明，一般来说视频编码格式，是avchar2.1,avchar2.2,dts，还有部分编码比如mp4等等。第二就是看是不是真实视频，最直接的方法就是看网站的视频实际长度。如果是真实视频，一般会有相应的画质提升，dts，xml等等。第三就是根据视频网站不同方式了。
第一点确定视频编码（avchar2）。第二点看网站传输协议（http、https，mime类型等等）。第三点手动判断。大概就这三点常用的，不常用的大家别喷，
需要判断视频类型需要根据视频编码方式和视频网站传输协议判断！下面是来自codeforces的介绍!以下是链接(videoconfigurationspecification),可以对比使用avchar编码协议方式抓取的视频url和bilibiliac3编码协议提供的抓取ac3编码视频url(videoconfigurationspecification)。 查看全部
python抓取动态网页视频教程在抓取网页视频时，为了保证抓取视频的质量和速度，python必须能正确判断视频是不是用于生产环境使用。正确判断方法分为页面判断和视频编码判断两种。其中页面判断和视频编码判断根据题主给的样例，和平台有关，题主可以查阅相关资料具体实现。python抓取动态网页视频教程可视化的video编码方法推荐使用gcc-llvm一种定制化的方法。python抓取动态网页视频教程。
第一看编码判断，可以看b站的相关说明，一般来说视频编码格式，是avchar2.1,avchar2.2,dts，还有部分编码比如mp4等等。第二就是看是不是真实视频，最直接的方法就是看网站的视频实际长度。如果是真实视频，一般会有相应的画质提升，dts，xml等等。第三就是根据视频网站不同方式了。
第一点确定视频编码（avchar2）。第二点看网站传输协议（http、https，mime类型等等）。第三点手动判断。大概就这三点常用的，不常用的大家别喷，
需要判断视频类型需要根据视频编码方式和视频网站传输协议判断！下面是来自codeforces的介绍!以下是链接(videoconfigurationspecification),可以对比使用avchar编码协议方式抓取的视频url和bilibiliac3编码协议提供的抓取ac3编码视频url(videoconfigurationspecification)。 查看全部
python抓取动态网页(python抓取动态网页视频教程可视化的video编码方法推荐使用)
python抓取动态网页视频教程在抓取网页视频时，为了保证抓取视频的质量和速度，python必须能正确判断视频是不是用于生产环境使用。正确判断方法分为页面判断和视频编码判断两种。其中页面判断和视频编码判断根据题主给的样例，和平台有关，题主可以查阅相关资料具体实现。python抓取动态网页视频教程可视化的video编码方法推荐使用gcc-llvm一种定制化的方法。python抓取动态网页视频教程。
第一看编码判断，可以看b站的相关说明，一般来说视频编码格式，是avchar2.1,avchar2.2,dts，还有部分编码比如mp4等等。第二就是看是不是真实视频，最直接的方法就是看网站的视频实际长度。如果是真实视频，一般会有相应的画质提升，dts，xml等等。第三就是根据视频网站不同方式了。
第一点确定视频编码（avchar2）。第二点看网站传输协议（http、https，mime类型等等）。第三点手动判断。大概就这三点常用的，不常用的大家别喷，
需要判断视频类型需要根据视频编码方式和视频网站传输协议判断！下面是来自codeforces的介绍!以下是链接(videoconfigurationspecification),可以对比使用avchar编码协议方式抓取的视频url和bilibiliac3编码协议提供的抓取ac3编码视频url(videoconfigurationspecification)。
python抓取动态网页(爬取网页其实就是通过URL获取网页信息的实质是什么)
网站优化 • 优采云 发表了文章 • 0 个评论 • 46 次浏览 • 2022-04-14 16:20
python抓取动态网页(爬取网页其实就是通过URL获取网页信息的实质是什么)
爬取网页实际上是通过 URL 获取网页信息。网页信息的本质是一段添加了 JavaScript 和 CSS 的 HTML 代码。Python 提供了第三方请求模块，用于抓取网页信息。requests 模块自称为“HTTP for Humans”，字面意思是专为人类设计的 HTTP 模块。该模块支持发送请求和获取响应。Python技术文章2021-11-19 | 传智教育|使用requests模块爬取网页
爬取网页实际上是通过 URL 获取网页信息。网页信息的本质是一段添加了 JavaScript 和 CSS 的 HTML 代码。Python 提供了第三方请求模块，用于抓取网页信息。requests 模块自称为“HTTP for Humans”，字面意思是专为人类设计的 HTTP 模块。该模块支持发送请求和获取响应。
1.发送请求
requests 模块提供了许多发送 HTTP 请求的功能。常用的请求函数如表10-1所示。
表 10-1 requests 模块的请求函数
2.得到响应
requests模块提供的Response类对象用于动态响应客户端的请求，控制发送给用户的信息，动态生成响应，包括状态码、网页内容等。接下来用一张表来列出Response类可以获取的信息，如表10-2所示。
表 10-2 Response 类的常用属性
接下来通过一个案例来演示如何使用requests模块爬取百度网页。具体代码如下：
# 01 requests baidu
import requests
base_url = 'http://www.baidu.com'
#发送GET请求
res = requests.get (base_url)
print("响应状态码：{}".format(res.status_code)) #获取响应状态码
print（"编码方式：{}".format(res.encoding)） #获取响应内容的编码方式
res.encoding = 'utf-8' #更新响应内容的编码方式为UIE-8
print（"网页源代码：\n{}".format(res.text）) ＃获取响应内容
在上面的代码中，第 2 行使用 import 来导入 requests 模块；第3~4行根据URL向服务器发送GET请求，并使用变量res接收服务器返回的响应内容；第 5~6 行打印响应内容的状态码和编码；第 7 行将响应内容的编码更改为“utf-8”；第 8 行打印响应内容。运行程序，程序的输出如下：
响应状态码：200
编码方式：ISO-8859-1
网页源代码：
百度一下,你就知道
…省略N行…
值得一提的是，在使用requests模块爬取网页时，可能会因未连接网络、服务器连接失败等原因出现各种异常，其中最常见的两个异常是URLError和HTTPError。这些网络异常可以与 try... except 语句捕获和处理一起使用。
相关建议：Python 绘图 Matplotlib.pyplot 显示网格 Python 培训：设置轴的标签 查看全部
爬取网页实际上是通过 URL 获取网页信息。网页信息的本质是一段添加了 JavaScript 和 CSS 的 HTML 代码。Python 提供了第三方请求模块，用于抓取网页信息。requests 模块自称为“HTTP for Humans”，字面意思是专为人类设计的 HTTP 模块。该模块支持发送请求和获取响应。Python技术文章2021-11-19 | 传智教育|使用requests模块爬取网页
爬取网页实际上是通过 URL 获取网页信息。网页信息的本质是一段添加了 JavaScript 和 CSS 的 HTML 代码。Python 提供了第三方请求模块，用于抓取网页信息。requests 模块自称为“HTTP for Humans”，字面意思是专为人类设计的 HTTP 模块。该模块支持发送请求和获取响应。
1.发送请求
requests 模块提供了许多发送 HTTP 请求的功能。常用的请求函数如表10-1所示。
表 10-1 requests 模块的请求函数
2.得到响应
requests模块提供的Response类对象用于动态响应客户端的请求，控制发送给用户的信息，动态生成响应，包括状态码、网页内容等。接下来用一张表来列出Response类可以获取的信息，如表10-2所示。
表 10-2 Response 类的常用属性
接下来通过一个案例来演示如何使用requests模块爬取百度网页。具体代码如下：
# 01 requests baidu
import requests
base_url = 'http://www.baidu.com'
#发送GET请求
res = requests.get (base_url)
print("响应状态码：{}".format(res.status_code)) #获取响应状态码
print（"编码方式：{}".format(res.encoding)） #获取响应内容的编码方式
res.encoding = 'utf-8' #更新响应内容的编码方式为UIE-8
print（"网页源代码：\n{}".format(res.text）) ＃获取响应内容
在上面的代码中，第 2 行使用 import 来导入 requests 模块；第3~4行根据URL向服务器发送GET请求，并使用变量res接收服务器返回的响应内容；第 5~6 行打印响应内容的状态码和编码；第 7 行将响应内容的编码更改为“utf-8”；第 8 行打印响应内容。运行程序，程序的输出如下：
响应状态码：200
编码方式：ISO-8859-1
网页源代码：
百度一下,你就知道
…省略N行…
值得一提的是，在使用requests模块爬取网页时，可能会因未连接网络、服务器连接失败等原因出现各种异常，其中最常见的两个异常是URLError和HTTPError。这些网络异常可以与 try... except 语句捕获和处理一起使用。
相关建议：Python 绘图 Matplotlib.pyplot 显示网格 Python 培训：设置轴的标签 查看全部
python抓取动态网页(爬取网页其实就是通过URL获取网页信息的实质是什么)
爬取网页实际上是通过 URL 获取网页信息。网页信息的本质是一段添加了 JavaScript 和 CSS 的 HTML 代码。Python 提供了第三方请求模块，用于抓取网页信息。requests 模块自称为“HTTP for Humans”，字面意思是专为人类设计的 HTTP 模块。该模块支持发送请求和获取响应。Python技术文章2021-11-19 | 传智教育|使用requests模块爬取网页
爬取网页实际上是通过 URL 获取网页信息。网页信息的本质是一段添加了 JavaScript 和 CSS 的 HTML 代码。Python 提供了第三方请求模块，用于抓取网页信息。requests 模块自称为“HTTP for Humans”，字面意思是专为人类设计的 HTTP 模块。该模块支持发送请求和获取响应。
1.发送请求
requests 模块提供了许多发送 HTTP 请求的功能。常用的请求函数如表10-1所示。
表 10-1 requests 模块的请求函数
2.得到响应
requests模块提供的Response类对象用于动态响应客户端的请求，控制发送给用户的信息，动态生成响应，包括状态码、网页内容等。接下来用一张表来列出Response类可以获取的信息，如表10-2所示。
表 10-2 Response 类的常用属性
接下来通过一个案例来演示如何使用requests模块爬取百度网页。具体代码如下：
# 01 requests baidu
import requests
base_url = 'http://www.baidu.com'
#发送GET请求
res = requests.get (base_url)
print("响应状态码：{}".format(res.status_code)) #获取响应状态码
print（"编码方式：{}".format(res.encoding)） #获取响应内容的编码方式
res.encoding = 'utf-8' #更新响应内容的编码方式为UIE-8
print（"网页源代码：\n{}".format(res.text）) ＃获取响应内容
在上面的代码中，第 2 行使用 import 来导入 requests 模块；第3~4行根据URL向服务器发送GET请求，并使用变量res接收服务器返回的响应内容；第 5~6 行打印响应内容的状态码和编码；第 7 行将响应内容的编码更改为“utf-8”；第 8 行打印响应内容。运行程序，程序的输出如下：
响应状态码：200
编码方式：ISO-8859-1
网页源代码：
百度一下,你就知道
…省略N行…
值得一提的是，在使用requests模块爬取网页时，可能会因未连接网络、服务器连接失败等原因出现各种异常，其中最常见的两个异常是URLError和HTTPError。这些网络异常可以与 try... except 语句捕获和处理一起使用。
相关建议：Python 绘图 Matplotlib.pyplot 显示网格 Python 培训：设置轴的标签
python抓取动态网页(一个爬虫项目目录结构(一)--一个 )
网站优化 • 优采云 发表了文章 • 0 个评论 • 29 次浏览 • 2022-04-12 00:05
python抓取动态网页(一个爬虫项目目录结构(一)--一个
)
我们首先创建一个爬虫项目，这里我们使用scrapy框架来创建它。
scrapy startproject poco
然后cd到poco文件夹初始化项目
scrapy genspider pocoSpider poco.com
打开项目，项目目录结构如下
我们的爬虫代码写在 pocoSpider 文件中，现在我们打开 网站 来分析网页。
我们选择人像分类爬行
可以看到页面上有很多用户id。我们需要先获取每个id的url，然后去详情页抓图。
右键查看网页源码，发现该页面是js动态生成的网页
并且页面是懒加载的，右键检查元素，查看网络
如果找到请求的图片，请获取请求参数，url地址，复制到postman中调用，成功获取返回数据
分析请求参数，猜测是否可以通过，修改参数得到响应结果，但是修改请求参数后，请求失败，看来直接修改参数的方法无法得到我们需要的url地址。
让我们随意点击查看网页源代码，看看细节是否也是js动态加载的。
好在我们可以直接在源码中查看我们需要的数据。每张图片的地址在
在标签里面，就是这么简单。我们可以先爬取这个页面的图片
import scrapy
from scrapy.crawler import CrawlerProcess
from scrapy.utils.project import get_project_settings
class PocospiderSpider(scrapy.Spider):
name = 'pocoSpider'
allowed_domains = ['poco.com']
start_urls = ['https://www.poco.cn/works/detail?works_id=20992476']
def parse(self, response):
img_list = response.xpath("//img/@data-src").extract()
for img in img_list:
print(img)
if __name__ == "__main__":
process = CrawlerProcess(get_project_settings())
process.crawl('pocoSpider')
process.start()
不出所料，我们成功拿到了当前id下的所有图片：
现在我们只需要获取所有id对应的url地址并回收请求就可以获取所有图片的地址
由于无法通过修改参数获取数据，所以我们使用selenium框架来模拟浏览器操作。
分析页面，每次拉到最后都发送一个请求。我们关闭页面的图片加载以加快访问速度。我们将爬取的数据存储在数据库中，这里我们使用mongod。定义下拉刷新函数，每次刷新后execute_times sleep 0.5秒，以便浏览器渲染页面。这里我们刷新 40 次来获取数据。
我们在setting.py文件中设置数据库的地址、端口、数据库名
LOCAL_MONGO_HOST = '127.0.0.1'
LOCAL_MONGO_PORT = 27017
DB_NAME = 'POCO'
编写 selenium 模拟操作的代码
执行完之后大概能拿到800多条数据，现在我们重写爬虫代码。
import pymongo
import scrapy
from scrapy.crawler import CrawlerProcess
from scrapy.utils.project import get_project_settings
from poco.settings import LOCAL_MONGO_HOST,LOCAL_MONGO_PORT,DB_NAME
class PocospiderSpider(scrapy.Spider):
name = 'pocoSpider'
mongo_client = pymongo.MongoClient(LOCAL_MONGO_HOST, LOCAL_MONGO_PORT)
collection = mongo_client[DB_NAME]["idlist"]
id_list = collection.find()
def start_requests(self):
for id in self.id_list:
item = {}
item["folder"]=id["_id"]
item["img_urls"]=[]
yield scrapy.Request(url=id["url"],callback=self.parse_detail,meta={"item":item})
def parse_detail(self, response):
item = response.meta["item"]
img_list = response.xpath("//img/@data-src").extract()
for img in img_list:
if img == "":
continue
img = "https:"+img
item["img_urls"].append(img)
yield item
if __name__ == "__main__":
process = CrawlerProcess(get_project_settings())
process.crawl('pocoSpider')
process.start()
我们scrapy管道下载图片，我们先写一个管道方法通过id存储图片，我们重写file_path方法修改图片的存储路径
from scrapy.exceptions import DropItem
from scrapy.pipelines.images import ImagesPipeline
from scrapy import Request
class MyImagesPipeline(ImagesPipeline):
def get_media_requests(self, item, info):
for image_url in item['img_urls']:
referer = image_url
yield Request(image_url,meta={'item':item,'referer':referer})
def file_path(self, request, response=None, info=None):
item = request.meta['item']
folder = item['folder'].strip()
img_name = request.url.split("/")[-1]
filename = u'img/{0}/{1}'.format(folder,img_name)
return filename
def item_completed(self, results, item, info):
image_path = [x['path'] for ok,x in results if ok]
if not image_path:
raise DropItem('Item contains no images')
# item['image_paths'] = image_path
return item
最后我们修改设置文件中的图片下载中间件和PipeLines
DOWNLOADER_MIDDLEWARES = {
'poco.middlewares.PocoDownloaderMiddleware': 543,
}
IMAGES_STORE=r'E:\\'
IMAGES_EXPIRES = 30
# Enable or disable extensions
# See https://doc.scrapy.org/en/late ... .html
#EXTENSIONS = {
# 'scrapy.extensions.telnet.TelnetConsole': None,
#}
ITEM_PIPELINES = {
'poco.pipelines.MyImagesPipeline': 300,
}
CONCURRENT_REQUESTS = 32
DOWNLOAD_DELAY = 0.1
# Configure item pipeli
至此，poco网站的爬虫已经写好，代码运行完毕，图片爬取成功，按照id分类存储
后记：其实爬虫代码还是有bug的。当爬虫运行 10 分钟，没有爬取到 id 时，会自动停止。仔细查看代码，发现一个mongodb的坑。那是
collection = mongo_client[DB_NAME]["idlist"]
id_list = collection.find()
当调用 db.采集.find() 时，它返回的不是所有数据，而是一个“光标”。它的默认行为是：首先在数据库中查询 101 个文档，或者 1 MB 的文档，这取决于首先满足哪个条件；然后每次光标用完文档时，查询 4 MB 的文档。此外，find() 的默认行为是返回一个在 10 分钟不活动后超时的游标。如果 10 分钟内没有处理请求，那么我们将无法获取剩余的 url，因此爬虫将停止。
解决方法也很简单，就是直接将id_list中的数据存入开头的list中。
# -*- coding: utf-8 -*-
import pymongo
import scrapy
from scrapy.crawler import CrawlerProcess
from scrapy.utils.project import get_project_settings
from poco.settings import LOCAL_MONGO_HOST,LOCAL_MONGO_PORT,DB_NAME
class PocospiderSpider(scrapy.Spider):
name = 'pocoSpider'
mongo_client = pymongo.MongoClient(LOCAL_MONGO_HOST, LOCAL_MONGO_PORT)
collection = mongo_client[DB_NAME]["idlist"]
id_list = collection.find()
ids=[]
for id in id_list:
ids.append(id)
def start_requests(self):
for id in self.ids:
item = {}
item["folder"]=id["_id"]
item["img_urls"]=[]
yield scrapy.Request(url=id["url"],callback=self.parse_detail,meta={"item":item})
def parse_detail(self, response):
item = response.meta["item"]
img_list = response.xpath("//img/@data-src").extract()
for img in img_list:
if img == "":
continue
img = "https:"+img
item["img_urls"].append(img)
yield item
if __name__ == "__main__":
process = CrawlerProcess(get_project_settings())
process.crawl('pocoSpider')
process.start() 查看全部
)
我们首先创建一个爬虫项目，这里我们使用scrapy框架来创建它。
scrapy startproject poco
然后cd到poco文件夹初始化项目
scrapy genspider pocoSpider poco.com
打开项目，项目目录结构如下
我们的爬虫代码写在 pocoSpider 文件中，现在我们打开 网站 来分析网页。
我们选择人像分类爬行
可以看到页面上有很多用户id。我们需要先获取每个id的url，然后去详情页抓图。
右键查看网页源码，发现该页面是js动态生成的网页
并且页面是懒加载的，右键检查元素，查看网络
如果找到请求的图片，请获取请求参数，url地址，复制到postman中调用，成功获取返回数据
分析请求参数，猜测是否可以通过，修改参数得到响应结果，但是修改请求参数后，请求失败，看来直接修改参数的方法无法得到我们需要的url地址。
让我们随意点击查看网页源代码，看看细节是否也是js动态加载的。
好在我们可以直接在源码中查看我们需要的数据。每张图片的地址在
在标签里面，就是这么简单。我们可以先爬取这个页面的图片
import scrapy
from scrapy.crawler import CrawlerProcess
from scrapy.utils.project import get_project_settings
class PocospiderSpider(scrapy.Spider):
name = 'pocoSpider'
allowed_domains = ['poco.com']
start_urls = ['https://www.poco.cn/works/detail?works_id=20992476']
def parse(self, response):
img_list = response.xpath("//img/@data-src").extract()
for img in img_list:
print(img)
if __name__ == "__main__":
process = CrawlerProcess(get_project_settings())
process.crawl('pocoSpider')
process.start()
不出所料，我们成功拿到了当前id下的所有图片：
现在我们只需要获取所有id对应的url地址并回收请求就可以获取所有图片的地址
由于无法通过修改参数获取数据，所以我们使用selenium框架来模拟浏览器操作。
分析页面，每次拉到最后都发送一个请求。我们关闭页面的图片加载以加快访问速度。我们将爬取的数据存储在数据库中，这里我们使用mongod。定义下拉刷新函数，每次刷新后execute_times sleep 0.5秒，以便浏览器渲染页面。这里我们刷新 40 次来获取数据。
我们在setting.py文件中设置数据库的地址、端口、数据库名
LOCAL_MONGO_HOST = '127.0.0.1'
LOCAL_MONGO_PORT = 27017
DB_NAME = 'POCO'
编写 selenium 模拟操作的代码
执行完之后大概能拿到800多条数据，现在我们重写爬虫代码。
import pymongo
import scrapy
from scrapy.crawler import CrawlerProcess
from scrapy.utils.project import get_project_settings
from poco.settings import LOCAL_MONGO_HOST,LOCAL_MONGO_PORT,DB_NAME
class PocospiderSpider(scrapy.Spider):
name = 'pocoSpider'
mongo_client = pymongo.MongoClient(LOCAL_MONGO_HOST, LOCAL_MONGO_PORT)
collection = mongo_client[DB_NAME]["idlist"]
id_list = collection.find()
def start_requests(self):
for id in self.id_list:
item = {}
item["folder"]=id["_id"]
item["img_urls"]=[]
yield scrapy.Request(url=id["url"],callback=self.parse_detail,meta={"item":item})
def parse_detail(self, response):
item = response.meta["item"]
img_list = response.xpath("//img/@data-src").extract()
for img in img_list:
if img == "":
continue
img = "https:"+img
item["img_urls"].append(img)
yield item
if __name__ == "__main__":
process = CrawlerProcess(get_project_settings())
process.crawl('pocoSpider')
process.start()
我们scrapy管道下载图片，我们先写一个管道方法通过id存储图片，我们重写file_path方法修改图片的存储路径
from scrapy.exceptions import DropItem
from scrapy.pipelines.images import ImagesPipeline
from scrapy import Request
class MyImagesPipeline(ImagesPipeline):
def get_media_requests(self, item, info):
for image_url in item['img_urls']:
referer = image_url
yield Request(image_url,meta={'item':item,'referer':referer})
def file_path(self, request, response=None, info=None):
item = request.meta['item']
folder = item['folder'].strip()
img_name = request.url.split("/")[-1]
filename = u'img/{0}/{1}'.format(folder,img_name)
return filename
def item_completed(self, results, item, info):
image_path = [x['path'] for ok,x in results if ok]
if not image_path:
raise DropItem('Item contains no images')
# item['image_paths'] = image_path
return item
最后我们修改设置文件中的图片下载中间件和PipeLines
DOWNLOADER_MIDDLEWARES = {
'poco.middlewares.PocoDownloaderMiddleware': 543,
}
IMAGES_STORE=r'E:\\'
IMAGES_EXPIRES = 30
# Enable or disable extensions
# See https://doc.scrapy.org/en/late ... .html
#EXTENSIONS = {
# 'scrapy.extensions.telnet.TelnetConsole': None,
#}
ITEM_PIPELINES = {
'poco.pipelines.MyImagesPipeline': 300,
}
CONCURRENT_REQUESTS = 32
DOWNLOAD_DELAY = 0.1
# Configure item pipeli
至此，poco网站的爬虫已经写好，代码运行完毕，图片爬取成功，按照id分类存储
后记：其实爬虫代码还是有bug的。当爬虫运行 10 分钟，没有爬取到 id 时，会自动停止。仔细查看代码，发现一个mongodb的坑。那是
collection = mongo_client[DB_NAME]["idlist"]
id_list = collection.find()
当调用 db.采集.find() 时，它返回的不是所有数据，而是一个“光标”。它的默认行为是：首先在数据库中查询 101 个文档，或者 1 MB 的文档，这取决于首先满足哪个条件；然后每次光标用完文档时，查询 4 MB 的文档。此外，find() 的默认行为是返回一个在 10 分钟不活动后超时的游标。如果 10 分钟内没有处理请求，那么我们将无法获取剩余的 url，因此爬虫将停止。
解决方法也很简单，就是直接将id_list中的数据存入开头的list中。
# -*- coding: utf-8 -*-
import pymongo
import scrapy
from scrapy.crawler import CrawlerProcess
from scrapy.utils.project import get_project_settings
from poco.settings import LOCAL_MONGO_HOST,LOCAL_MONGO_PORT,DB_NAME
class PocospiderSpider(scrapy.Spider):
name = 'pocoSpider'
mongo_client = pymongo.MongoClient(LOCAL_MONGO_HOST, LOCAL_MONGO_PORT)
collection = mongo_client[DB_NAME]["idlist"]
id_list = collection.find()
ids=[]
for id in id_list:
ids.append(id)
def start_requests(self):
for id in self.ids:
item = {}
item["folder"]=id["_id"]
item["img_urls"]=[]
yield scrapy.Request(url=id["url"],callback=self.parse_detail,meta={"item":item})
def parse_detail(self, response):
item = response.meta["item"]
img_list = response.xpath("//img/@data-src").extract()
for img in img_list:
if img == "":
continue
img = "https:"+img
item["img_urls"].append(img)
yield item
if __name__ == "__main__":
process = CrawlerProcess(get_project_settings())
process.crawl('pocoSpider')
process.start() 查看全部
python抓取动态网页(一个爬虫项目目录结构(一)--一个
)
我们首先创建一个爬虫项目，这里我们使用scrapy框架来创建它。
scrapy startproject poco
然后cd到poco文件夹初始化项目
scrapy genspider pocoSpider poco.com
打开项目，项目目录结构如下
我们的爬虫代码写在 pocoSpider 文件中，现在我们打开 网站 来分析网页。
我们选择人像分类爬行
可以看到页面上有很多用户id。我们需要先获取每个id的url，然后去详情页抓图。
右键查看网页源码，发现该页面是js动态生成的网页
并且页面是懒加载的，右键检查元素，查看网络
如果找到请求的图片，请获取请求参数，url地址，复制到postman中调用，成功获取返回数据
分析请求参数，猜测是否可以通过，修改参数得到响应结果，但是修改请求参数后，请求失败，看来直接修改参数的方法无法得到我们需要的url地址。
让我们随意点击查看网页源代码，看看细节是否也是js动态加载的。
好在我们可以直接在源码中查看我们需要的数据。每张图片的地址在
在标签里面，就是这么简单。我们可以先爬取这个页面的图片
import scrapy
from scrapy.crawler import CrawlerProcess
from scrapy.utils.project import get_project_settings
class PocospiderSpider(scrapy.Spider):
name = 'pocoSpider'
allowed_domains = ['poco.com']
start_urls = ['https://www.poco.cn/works/detail?works_id=20992476']
def parse(self, response):
img_list = response.xpath("//img/@data-src").extract()
for img in img_list:
print(img)
if __name__ == "__main__":
process = CrawlerProcess(get_project_settings())
process.crawl('pocoSpider')
process.start()
不出所料，我们成功拿到了当前id下的所有图片：
现在我们只需要获取所有id对应的url地址并回收请求就可以获取所有图片的地址
由于无法通过修改参数获取数据，所以我们使用selenium框架来模拟浏览器操作。
分析页面，每次拉到最后都发送一个请求。我们关闭页面的图片加载以加快访问速度。我们将爬取的数据存储在数据库中，这里我们使用mongod。定义下拉刷新函数，每次刷新后execute_times sleep 0.5秒，以便浏览器渲染页面。这里我们刷新 40 次来获取数据。
我们在setting.py文件中设置数据库的地址、端口、数据库名
LOCAL_MONGO_HOST = '127.0.0.1'
LOCAL_MONGO_PORT = 27017
DB_NAME = 'POCO'
编写 selenium 模拟操作的代码
执行完之后大概能拿到800多条数据，现在我们重写爬虫代码。
import pymongo
import scrapy
from scrapy.crawler import CrawlerProcess
from scrapy.utils.project import get_project_settings
from poco.settings import LOCAL_MONGO_HOST,LOCAL_MONGO_PORT,DB_NAME
class PocospiderSpider(scrapy.Spider):
name = 'pocoSpider'
mongo_client = pymongo.MongoClient(LOCAL_MONGO_HOST, LOCAL_MONGO_PORT)
collection = mongo_client[DB_NAME]["idlist"]
id_list = collection.find()
def start_requests(self):
for id in self.id_list:
item = {}
item["folder"]=id["_id"]
item["img_urls"]=[]
yield scrapy.Request(url=id["url"],callback=self.parse_detail,meta={"item":item})
def parse_detail(self, response):
item = response.meta["item"]
img_list = response.xpath("//img/@data-src").extract()
for img in img_list:
if img == "":
continue
img = "https:"+img
item["img_urls"].append(img)
yield item
if __name__ == "__main__":
process = CrawlerProcess(get_project_settings())
process.crawl('pocoSpider')
process.start()
我们scrapy管道下载图片，我们先写一个管道方法通过id存储图片，我们重写file_path方法修改图片的存储路径
from scrapy.exceptions import DropItem
from scrapy.pipelines.images import ImagesPipeline
from scrapy import Request
class MyImagesPipeline(ImagesPipeline):
def get_media_requests(self, item, info):
for image_url in item['img_urls']:
referer = image_url
yield Request(image_url,meta={'item':item,'referer':referer})
def file_path(self, request, response=None, info=None):
item = request.meta['item']
folder = item['folder'].strip()
img_name = request.url.split("/")[-1]
filename = u'img/{0}/{1}'.format(folder,img_name)
return filename
def item_completed(self, results, item, info):
image_path = [x['path'] for ok,x in results if ok]
if not image_path:
raise DropItem('Item contains no images')
# item['image_paths'] = image_path
return item
最后我们修改设置文件中的图片下载中间件和PipeLines
DOWNLOADER_MIDDLEWARES = {
'poco.middlewares.PocoDownloaderMiddleware': 543,
}
IMAGES_STORE=r'E:\\'
IMAGES_EXPIRES = 30
# Enable or disable extensions
# See https://doc.scrapy.org/en/late ... .html
#EXTENSIONS = {
# 'scrapy.extensions.telnet.TelnetConsole': None,
#}
ITEM_PIPELINES = {
'poco.pipelines.MyImagesPipeline': 300,
}
CONCURRENT_REQUESTS = 32
DOWNLOAD_DELAY = 0.1
# Configure item pipeli
至此，poco网站的爬虫已经写好，代码运行完毕，图片爬取成功，按照id分类存储
后记：其实爬虫代码还是有bug的。当爬虫运行 10 分钟，没有爬取到 id 时，会自动停止。仔细查看代码，发现一个mongodb的坑。那是
collection = mongo_client[DB_NAME]["idlist"]
id_list = collection.find()
当调用 db.采集.find() 时，它返回的不是所有数据，而是一个“光标”。它的默认行为是：首先在数据库中查询 101 个文档，或者 1 MB 的文档，这取决于首先满足哪个条件；然后每次光标用完文档时，查询 4 MB 的文档。此外，find() 的默认行为是返回一个在 10 分钟不活动后超时的游标。如果 10 分钟内没有处理请求，那么我们将无法获取剩余的 url，因此爬虫将停止。
解决方法也很简单，就是直接将id_list中的数据存入开头的list中。
# -*- coding: utf-8 -*-
import pymongo
import scrapy
from scrapy.crawler import CrawlerProcess
from scrapy.utils.project import get_project_settings
from poco.settings import LOCAL_MONGO_HOST,LOCAL_MONGO_PORT,DB_NAME
class PocospiderSpider(scrapy.Spider):
name = 'pocoSpider'
mongo_client = pymongo.MongoClient(LOCAL_MONGO_HOST, LOCAL_MONGO_PORT)
collection = mongo_client[DB_NAME]["idlist"]
id_list = collection.find()
ids=[]
for id in id_list:
ids.append(id)
def start_requests(self):
for id in self.ids:
item = {}
item["folder"]=id["_id"]
item["img_urls"]=[]
yield scrapy.Request(url=id["url"],callback=self.parse_detail,meta={"item":item})
def parse_detail(self, response):
item = response.meta["item"]
img_list = response.xpath("//img/@data-src").extract()
for img in img_list:
if img == "":
continue
img = "https:"+img
item["img_urls"].append(img)
yield item
if __name__ == "__main__":
process = CrawlerProcess(get_project_settings())
process.crawl('pocoSpider')
process.start()
python抓取动态网页( python使用xslt提取网页数据中的Ajax或动态html,)
网站优化 • 优采云 发表了文章 • 0 个评论 • 35 次浏览 • 2022-04-11 16:43
python抓取动态网页(
python使用xslt提取网页数据中的Ajax或动态html,)
上一篇python使用xslt提取网页数据，要提取的内容是直接从网页的源码中获取的。
但是对于一些Ajax或者动态html来说，要提取的内容在源代码中往往是找不到的。在这种情况下，必须找到一种方法来提取异步或动态加载的内容。
可以在python中使用selenium来执行javascript，selenium可以让浏览器自动加载页面并获取需要的数据。
Selenium没有自带浏览器，可以使用第三方浏览器如Firefox、Chrome等，也可以使用PhantomJS等无头浏览器在后台执行。
比如我们要抓取京东手机页面的手机名和价格（网页源码中找不到价格）
第一步：在几搜科谋几个控制台上通过图形界面快速生成xslt
第二步：执行以下代码（windows10下测试通过，python3.2）
#/usr/bin/python
from urllib import request
from lxml import etree
from selenium import webdriver
import time
# 京东手机商品页面
url="http://item.jd.com/1312640.html"
# 下面的xslt是通过集搜客的谋数台图形界面自动生成的
xslt_root = etree.XML("""
""")
# 使用webdriver.PhantomJS
browser=webdriver.PhantomJS(executable_path=‘C:\\phantomjs-2.1.1-windows\\bin\\phantomjs.exe‘)
browser.get(url)
time.sleep(3)
transform = etree.XSLT(xslt_root)
# 执行js得到整个dom
html = browser.execute_script("return document.documentElement.outerHTML")
doc = etree.HTML(html)
# 用xslt从dom中提取需要的字段
result_tree = transform(doc)
print(result_tree)
第三步：可以看到网页中的手机名称和价格被正确抓取了
Python爬虫使用Selenium+PhantomJS爬取Ajax和动态HTML内容
原文： 查看全部
python使用xslt提取网页数据中的Ajax或动态html,)
上一篇python使用xslt提取网页数据，要提取的内容是直接从网页的源码中获取的。
但是对于一些Ajax或者动态html来说，要提取的内容在源代码中往往是找不到的。在这种情况下，必须找到一种方法来提取异步或动态加载的内容。
可以在python中使用selenium来执行javascript，selenium可以让浏览器自动加载页面并获取需要的数据。
Selenium没有自带浏览器，可以使用第三方浏览器如Firefox、Chrome等，也可以使用PhantomJS等无头浏览器在后台执行。
比如我们要抓取京东手机页面的手机名和价格（网页源码中找不到价格）
第一步：在几搜科谋几个控制台上通过图形界面快速生成xslt
第二步：执行以下代码（windows10下测试通过，python3.2）
#/usr/bin/python
from urllib import request
from lxml import etree
from selenium import webdriver
import time
# 京东手机商品页面
url="http://item.jd.com/1312640.html"
# 下面的xslt是通过集搜客的谋数台图形界面自动生成的
xslt_root = etree.XML("""
""")
# 使用webdriver.PhantomJS
browser=webdriver.PhantomJS(executable_path=‘C:\\phantomjs-2.1.1-windows\\bin\\phantomjs.exe‘)
browser.get(url)
time.sleep(3)
transform = etree.XSLT(xslt_root)
# 执行js得到整个dom
html = browser.execute_script("return document.documentElement.outerHTML")
doc = etree.HTML(html)
# 用xslt从dom中提取需要的字段
result_tree = transform(doc)
print(result_tree)
第三步：可以看到网页中的手机名称和价格被正确抓取了
Python爬虫使用Selenium+PhantomJS爬取Ajax和动态HTML内容
原文： 查看全部
python抓取动态网页(
python使用xslt提取网页数据中的Ajax或动态html,)
上一篇python使用xslt提取网页数据，要提取的内容是直接从网页的源码中获取的。
但是对于一些Ajax或者动态html来说，要提取的内容在源代码中往往是找不到的。在这种情况下，必须找到一种方法来提取异步或动态加载的内容。
可以在python中使用selenium来执行javascript，selenium可以让浏览器自动加载页面并获取需要的数据。
Selenium没有自带浏览器，可以使用第三方浏览器如Firefox、Chrome等，也可以使用PhantomJS等无头浏览器在后台执行。
比如我们要抓取京东手机页面的手机名和价格（网页源码中找不到价格）
第一步：在几搜科谋几个控制台上通过图形界面快速生成xslt
第二步：执行以下代码（windows10下测试通过，python3.2）
#/usr/bin/python
from urllib import request
from lxml import etree
from selenium import webdriver
import time
# 京东手机商品页面
url="http://item.jd.com/1312640.html"
# 下面的xslt是通过集搜客的谋数台图形界面自动生成的
xslt_root = etree.XML("""
""")
# 使用webdriver.PhantomJS
browser=webdriver.PhantomJS(executable_path=‘C:\\phantomjs-2.1.1-windows\\bin\\phantomjs.exe‘)
browser.get(url)
time.sleep(3)
transform = etree.XSLT(xslt_root)
# 执行js得到整个dom
html = browser.execute_script("return document.documentElement.outerHTML")
doc = etree.HTML(html)
# 用xslt从dom中提取需要的字段
result_tree = transform(doc)
print(result_tree)
第三步：可以看到网页中的手机名称和价格被正确抓取了
Python爬虫使用Selenium+PhantomJS爬取Ajax和动态HTML内容
原文：
python抓取动态网页(python下抓包神技！远离sqlite，方法不对不过很久前的问题)
网站优化 • 优采云 发表了文章 • 0 个评论 • 41 次浏览 • 2022-04-11 11:08
python抓取动态网页(python下抓包神技！远离sqlite，方法不对不过很久前的问题)
python抓取动态网页，抓取成功后保存数据，网页丢失/损坏，删除数据项目失败了，数据丢失的很彻底。爬虫的设计师也是有够脆弱，面对现实随时都要崩溃了。网站问题会有web问题也会有浏览器问题问题，
我觉得抓取动态网页最实用的是抓包。network面前，需要多花点精力在设计数据包上。详见下面的博客：python下抓包神技！远离sqlite，
方法不对不过很久前的问题，根据提问背景和回答时间应该已经有一些程序逻辑上的变化了估计爬不到原因会有很多方面吧最基本的方面可能是抓取工具限制，比如现在一些工具不支持pythonrequests等工具抓取；例如动态网页翻页，如果第一页没抓取到后面的就没抓到；第二页没抓到，网页内容也就翻不到底了python和解析器兼容性有点差爬取数据的时候要做好强制转码，也就是手动设置一下url能看到的解析器的版本、去掉invalidascii（别看不起import）mozillaflask这种做法是错误的，他用了无耻的requests，如果抓取数据比较大用这样抓数据会非常慢，特别是底层请求前后端隔离做得差点，我试过有的时候再加个asyncio还好点，像爬js库之类的或者爬个api接口（其实一般都还是flask开发）还是用java或者golang好一点，对解析器兼容性更好，使用方便一点。 查看全部
python抓取动态网页，抓取成功后保存数据，网页丢失/损坏，删除数据项目失败了，数据丢失的很彻底。爬虫的设计师也是有够脆弱，面对现实随时都要崩溃了。网站问题会有web问题也会有浏览器问题问题，
我觉得抓取动态网页最实用的是抓包。network面前，需要多花点精力在设计数据包上。详见下面的博客：python下抓包神技！远离sqlite，
方法不对不过很久前的问题，根据提问背景和回答时间应该已经有一些程序逻辑上的变化了估计爬不到原因会有很多方面吧最基本的方面可能是抓取工具限制，比如现在一些工具不支持pythonrequests等工具抓取；例如动态网页翻页，如果第一页没抓取到后面的就没抓到；第二页没抓到，网页内容也就翻不到底了python和解析器兼容性有点差爬取数据的时候要做好强制转码，也就是手动设置一下url能看到的解析器的版本、去掉invalidascii（别看不起import）mozillaflask这种做法是错误的，他用了无耻的requests，如果抓取数据比较大用这样抓数据会非常慢，特别是底层请求前后端隔离做得差点，我试过有的时候再加个asyncio还好点，像爬js库之类的或者爬个api接口（其实一般都还是flask开发）还是用java或者golang好一点，对解析器兼容性更好，使用方便一点。 查看全部
python抓取动态网页(python下抓包神技！远离sqlite，方法不对不过很久前的问题)
python抓取动态网页，抓取成功后保存数据，网页丢失/损坏，删除数据项目失败了，数据丢失的很彻底。爬虫的设计师也是有够脆弱，面对现实随时都要崩溃了。网站问题会有web问题也会有浏览器问题问题，
我觉得抓取动态网页最实用的是抓包。network面前，需要多花点精力在设计数据包上。详见下面的博客：python下抓包神技！远离sqlite，
方法不对不过很久前的问题，根据提问背景和回答时间应该已经有一些程序逻辑上的变化了估计爬不到原因会有很多方面吧最基本的方面可能是抓取工具限制，比如现在一些工具不支持pythonrequests等工具抓取；例如动态网页翻页，如果第一页没抓取到后面的就没抓到；第二页没抓到，网页内容也就翻不到底了python和解析器兼容性有点差爬取数据的时候要做好强制转码，也就是手动设置一下url能看到的解析器的版本、去掉invalidascii（别看不起import）mozillaflask这种做法是错误的，他用了无耻的requests，如果抓取数据比较大用这样抓数据会非常慢，特别是底层请求前后端隔离做得差点，我试过有的时候再加个asyncio还好点，像爬js库之类的或者爬个api接口（其实一般都还是flask开发）还是用java或者golang好一点，对解析器兼容性更好，使用方便一点。
python抓取动态网页( 为啥写这篇文章?前两篇文章我们分别介绍了文章目录分析页面)
网站优化 • 优采云 发表了文章 • 0 个评论 • 52 次浏览 • 2022-04-09 05:26
python抓取动态网页(
为啥写这篇文章?前两篇文章我们分别介绍了文章目录分析页面)
为什么要写这个文章？
前两篇文章我们分别介绍
文章目录
分析页面
先打开小餐桌网站，经过简单分析我们可以得出三个结论。
点击查看更多数据后，页面地址不变，不会再次刷新页面。点击查看更多将请求界面一次。页面的数据由接口以application/json的形式返回。返回哪个页面的数据由p参数控制。n 参数控制每页返回的数据项数。什么是ajax
AJAX（Asynchronouse JavaScript And XML）中文名称是异步JavaScript和XML。主要用于前端与服务器之间的少量数据交互。Ajax 允许异步加载网页，这意味着可以对网页的某些部分进行部分更新，而无需重新加载整个网页。如果内容需要更新，传统网页（不使用 Ajax）需要重新加载整个网页。
因为传统的数据传输格式使用XML语法，所以称为AJAX。其实数据交互基本都是用JSON。AJAX加载的数据，即使使用JS，数据渲染到浏览器中，右键---->查看网页源代码，还是看不到ajax加载的数据，你只能看到url代码加载的html。
获取ajax数据的方法直接分析ajax调用的接口，然后通过代码请求这个接口。使用 Selenium+chromedriver 模拟浏览器行为获取数据。（文章后面会详述）获取数据
这个小餐桌网站的界面比较简单。它不做加密认证或任何事情。可以直接通过requests请求。下面给出了一个示例代码：
import requests
headers = {
"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.93 Safari/537.36"
}
requests.packages.urllib3.disable_warnings()
if __name__ == '__main__':
for i in range(1,10):
url = "https://www.xfz.cn/api/website/articles/?p={0}&n=20&type=".format(str(i))
resp = requests.get(url, headers=headers, verify=False)
print(resp.json())
运行结果：
总结
本文以小餐桌网站为例，简单介绍如何从动态网页中抓取数据。
粉丝专属福利
软考资料：实用软考资料
面试题：5G Java高频面试题
学习资料：各种学习资料50G 查看全部
为啥写这篇文章?前两篇文章我们分别介绍了文章目录分析页面)
为什么要写这个文章？
前两篇文章我们分别介绍
文章目录
分析页面
先打开小餐桌网站，经过简单分析我们可以得出三个结论。
点击查看更多数据后，页面地址不变，不会再次刷新页面。点击查看更多将请求界面一次。页面的数据由接口以application/json的形式返回。返回哪个页面的数据由p参数控制。n 参数控制每页返回的数据项数。什么是ajax
AJAX（Asynchronouse JavaScript And XML）中文名称是异步JavaScript和XML。主要用于前端与服务器之间的少量数据交互。Ajax 允许异步加载网页，这意味着可以对网页的某些部分进行部分更新，而无需重新加载整个网页。如果内容需要更新，传统网页（不使用 Ajax）需要重新加载整个网页。
因为传统的数据传输格式使用XML语法，所以称为AJAX。其实数据交互基本都是用JSON。AJAX加载的数据，即使使用JS，数据渲染到浏览器中，右键---->查看网页源代码，还是看不到ajax加载的数据，你只能看到url代码加载的html。
获取ajax数据的方法直接分析ajax调用的接口，然后通过代码请求这个接口。使用 Selenium+chromedriver 模拟浏览器行为获取数据。（文章后面会详述）获取数据
这个小餐桌网站的界面比较简单。它不做加密认证或任何事情。可以直接通过requests请求。下面给出了一个示例代码：
import requests
headers = {
"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.93 Safari/537.36"
}
requests.packages.urllib3.disable_warnings()
if __name__ == '__main__':
for i in range(1,10):
url = "https://www.xfz.cn/api/website/articles/?p={0}&n=20&type=".format(str(i))
resp = requests.get(url, headers=headers, verify=False)
print(resp.json())
运行结果：
总结
本文以小餐桌网站为例，简单介绍如何从动态网页中抓取数据。
粉丝专属福利
软考资料：实用软考资料
面试题：5G Java高频面试题
学习资料：各种学习资料50G 查看全部
python抓取动态网页(
为啥写这篇文章?前两篇文章我们分别介绍了文章目录分析页面)
为什么要写这个文章？
前两篇文章我们分别介绍
文章目录
分析页面
先打开小餐桌网站，经过简单分析我们可以得出三个结论。
点击查看更多数据后，页面地址不变，不会再次刷新页面。点击查看更多将请求界面一次。页面的数据由接口以application/json的形式返回。返回哪个页面的数据由p参数控制。n 参数控制每页返回的数据项数。什么是ajax
AJAX（Asynchronouse JavaScript And XML）中文名称是异步JavaScript和XML。主要用于前端与服务器之间的少量数据交互。Ajax 允许异步加载网页，这意味着可以对网页的某些部分进行部分更新，而无需重新加载整个网页。如果内容需要更新，传统网页（不使用 Ajax）需要重新加载整个网页。
因为传统的数据传输格式使用XML语法，所以称为AJAX。其实数据交互基本都是用JSON。AJAX加载的数据，即使使用JS，数据渲染到浏览器中，右键---->查看网页源代码，还是看不到ajax加载的数据，你只能看到url代码加载的html。
获取ajax数据的方法直接分析ajax调用的接口，然后通过代码请求这个接口。使用 Selenium+chromedriver 模拟浏览器行为获取数据。（文章后面会详述）获取数据
这个小餐桌网站的界面比较简单。它不做加密认证或任何事情。可以直接通过requests请求。下面给出了一个示例代码：
import requests
headers = {
"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.93 Safari/537.36"
}
requests.packages.urllib3.disable_warnings()
if __name__ == '__main__':
for i in range(1,10):
url = "https://www.xfz.cn/api/website/articles/?p={0}&n=20&type=".format(str(i))
resp = requests.get(url, headers=headers, verify=False)
print(resp.json())
运行结果：
总结
本文以小餐桌网站为例，简单介绍如何从动态网页中抓取数据。
粉丝专属福利
软考资料：实用软考资料
面试题：5G Java高频面试题
学习资料：各种学习资料50G
python抓取动态网页(python抓取动态网页获取源代码(网页动态)抓取一些音乐数据)
网站优化 • 优采云 发表了文章 • 0 个评论 • 18 次浏览 • 2022-04-08 05:04
python抓取动态网页(python抓取动态网页获取源代码(网页动态)抓取一些音乐数据)
python抓取动态网页获取源代码网页动态网页抓取，网页抓取并非结构性网页内容抓取或者最简单的就是对网页结构一目了然实现起来也容易，动态网页就是通过js代码动态生成。关键点在如何写js代码，可以利用第三方库实现快速查看源代码。数据爬取：抓取一些音乐数据本案例通过数据爬取，选取其中一首歌名为《如约而至》的歌曲下载音乐音乐下载：歌曲下载网页打开，当前页面搜索到的词汇数量最多，进入搜索结果页面。
随机词采用关键词，最多排列出6条结果，数量为3条，网页浏览器的缓存中暂时会生成3条请求，进行第一步动态抓取（本文通过python3.5及以上版本查看，python2不行）请求地址地址和url代码在上图中，window的url变成了mjmenr，同时出现了dzhomakejavajavajavascriptrequest，选择mjmenr这个data参数，选择新窗口抓取。
只要url后面加上+window就可以复制出来helloworld.py文件。其他地方不要改动，直接用python3来抓取即可。本案例以python3为例，参考以下代码抓取优采云票的下半身数据，并根据数据分析规律打标签工具部分，按照以下代码打开开始想下载的车次，回车后开始提示下载，提示不存在一次性下载多张，将密码设置为1，1，2选择第一张即可，完成后抓取如下：进入工具部分，先将模型和工具保存起来，方便后续操作，引入python工具包，用的是qt4库安装好python3软件，依次保存到本地，方便方便，为此找到和qt4库对应的工具库，双击软件包可在qt文件管理器中找到这个typeautocadtools把qt文件夹中的qtsystem文件夹复制到这个文件夹下面并把下面的图文件cmd窗口添加完工把qt4编译到python3.5中，找到autocad编译器选择python3程序路径双击运行程序，运行完成会提示对应的启动项setsource="python3"cmd窗口提示显示为-md:\python3\scripts下载好的字体，根据个人需要自行下载第三方库：选中图例中的内容，鼠标右键在开始菜单选择opendevelopmenttool选择windows下打开excel，再选择python3.6下的pandas，然后继续，根据自己需要安装numpy、scipy、matplotlib等库本案例中前4个命令为选择数据类型，在diamonds数据集中间的studio里面，一个黄色小球按一次开关，单个黄色小球对应一个参数点击下一步，根据具体操作选择第5个命令进入生成数据列表页面，生成的格式不一样，点击保存生成目录在进入控制台窗口，选择ctrl+alt+t，选择createdatalibrary并选择c盘，右键pdfs文件夹，选。 查看全部
python抓取动态网页获取源代码网页动态网页抓取，网页抓取并非结构性网页内容抓取或者最简单的就是对网页结构一目了然实现起来也容易，动态网页就是通过js代码动态生成。关键点在如何写js代码，可以利用第三方库实现快速查看源代码。数据爬取：抓取一些音乐数据本案例通过数据爬取，选取其中一首歌名为《如约而至》的歌曲下载音乐音乐下载：歌曲下载网页打开，当前页面搜索到的词汇数量最多，进入搜索结果页面。
随机词采用关键词，最多排列出6条结果，数量为3条，网页浏览器的缓存中暂时会生成3条请求，进行第一步动态抓取（本文通过python3.5及以上版本查看，python2不行）请求地址地址和url代码在上图中，window的url变成了mjmenr，同时出现了dzhomakejavajavajavascriptrequest，选择mjmenr这个data参数，选择新窗口抓取。
只要url后面加上+window就可以复制出来helloworld.py文件。其他地方不要改动，直接用python3来抓取即可。本案例以python3为例，参考以下代码抓取优采云票的下半身数据，并根据数据分析规律打标签工具部分，按照以下代码打开开始想下载的车次，回车后开始提示下载，提示不存在一次性下载多张，将密码设置为1，1，2选择第一张即可，完成后抓取如下：进入工具部分，先将模型和工具保存起来，方便后续操作，引入python工具包，用的是qt4库安装好python3软件，依次保存到本地，方便方便，为此找到和qt4库对应的工具库，双击软件包可在qt文件管理器中找到这个typeautocadtools把qt文件夹中的qtsystem文件夹复制到这个文件夹下面并把下面的图文件cmd窗口添加完工把qt4编译到python3.5中，找到autocad编译器选择python3程序路径双击运行程序，运行完成会提示对应的启动项setsource="python3"cmd窗口提示显示为-md:\python3\scripts下载好的字体，根据个人需要自行下载第三方库：选中图例中的内容，鼠标右键在开始菜单选择opendevelopmenttool选择windows下打开excel，再选择python3.6下的pandas，然后继续，根据自己需要安装numpy、scipy、matplotlib等库本案例中前4个命令为选择数据类型，在diamonds数据集中间的studio里面，一个黄色小球按一次开关，单个黄色小球对应一个参数点击下一步，根据具体操作选择第5个命令进入生成数据列表页面，生成的格式不一样，点击保存生成目录在进入控制台窗口，选择ctrl+alt+t，选择createdatalibrary并选择c盘，右键pdfs文件夹，选。 查看全部
python抓取动态网页(python抓取动态网页获取源代码(网页动态)抓取一些音乐数据)
python抓取动态网页获取源代码网页动态网页抓取，网页抓取并非结构性网页内容抓取或者最简单的就是对网页结构一目了然实现起来也容易，动态网页就是通过js代码动态生成。关键点在如何写js代码，可以利用第三方库实现快速查看源代码。数据爬取：抓取一些音乐数据本案例通过数据爬取，选取其中一首歌名为《如约而至》的歌曲下载音乐音乐下载：歌曲下载网页打开，当前页面搜索到的词汇数量最多，进入搜索结果页面。
随机词采用关键词，最多排列出6条结果，数量为3条，网页浏览器的缓存中暂时会生成3条请求，进行第一步动态抓取（本文通过python3.5及以上版本查看，python2不行）请求地址地址和url代码在上图中，window的url变成了mjmenr，同时出现了dzhomakejavajavajavascriptrequest，选择mjmenr这个data参数，选择新窗口抓取。
只要url后面加上+window就可以复制出来helloworld.py文件。其他地方不要改动，直接用python3来抓取即可。本案例以python3为例，参考以下代码抓取优采云票的下半身数据，并根据数据分析规律打标签工具部分，按照以下代码打开开始想下载的车次，回车后开始提示下载，提示不存在一次性下载多张，将密码设置为1，1，2选择第一张即可，完成后抓取如下：进入工具部分，先将模型和工具保存起来，方便后续操作，引入python工具包，用的是qt4库安装好python3软件，依次保存到本地，方便方便，为此找到和qt4库对应的工具库，双击软件包可在qt文件管理器中找到这个typeautocadtools把qt文件夹中的qtsystem文件夹复制到这个文件夹下面并把下面的图文件cmd窗口添加完工把qt4编译到python3.5中，找到autocad编译器选择python3程序路径双击运行程序，运行完成会提示对应的启动项setsource="python3"cmd窗口提示显示为-md:\python3\scripts下载好的字体，根据个人需要自行下载第三方库：选中图例中的内容，鼠标右键在开始菜单选择opendevelopmenttool选择windows下打开excel，再选择python3.6下的pandas，然后继续，根据自己需要安装numpy、scipy、matplotlib等库本案例中前4个命令为选择数据类型，在diamonds数据集中间的studio里面，一个黄色小球按一次开关，单个黄色小球对应一个参数点击下一步，根据具体操作选择第5个命令进入生成数据列表页面，生成的格式不一样，点击保存生成目录在进入控制台窗口，选择ctrl+alt+t，选择createdatalibrary并选择c盘，右键pdfs文件夹，选。
python抓取动态网页(工具分析登录页面打开登录过程从分析可以看到哪些信息)
网站优化 • 优采云 发表了文章 • 0 个评论 • 41 次浏览 • 2022-04-06 17:35
python抓取动态网页(工具分析登录页面打开登录过程从分析可以看到哪些信息)
最近的项目在做一些数据集成，各种系统对应的接口就更奇怪了。数据整合的过程可以用八个字来概括：山中开路，水中搭桥。
这两天刚遇到一个问题。我们要集成的WEB系统没有提供专门的数据集成接口，没有API可以调整，不允许访问数据库。无奈之下，我想知道我们是否可以使用python自动爬取页面。网页有SSO，应该使用开源的CAS框架，后续所有页面都是通过动态JS和AJAX异步加载的，这显然不像普通的静态页面。对页面结构和爬取内容的分析是必不可少的。
工具分析登陆页面
打开登录页面，按F12打开Chrome自带的分析工具，在Network选项卡上可以看到当前浏览器显示页面的详细信息和提交的登录信息，如下图
一个 网站 登录页面
从截图可以看到，当我们访问app/这个url的日志时，由于我们还没有登录，SSO会自动将我们重定向到登录页面，所以http状态是302重定向。
接下来，我们在页面输入账号密码，点击登录按钮，通过页面跟踪分析整个登录过程，模拟整个登录过程。这个过程需要特别小心，因为很多CAS在登录页面上埋下了很多隐藏的标记，有可能会错误的模仿一个地方。它将无法登录并被重定向到它开始的地方。
分析登录过程
从分析可以看出，在提交登录按钮的时候，会通过POST提交一个表单，而且表单中除了账号密码、密码等显眼的字段外，还有一个lt。经验告诉我们，这个字段在之前的登录页面应该是隐藏的。用于验证登录页面的合法性，因此我们需要从登录页面中查找并提取此信息。同时，注意HTTP消息头。最好根据浏览器捕获的消息头来构造，因为网站也会验证里面的信息。
以下是登录的主要代码。我们基于python3和requests包处理https访问请求，并模拟浏览器的行为构造认证所需的信息发送给网站。
import requestsimport urllib3from lxml import etreefrom ows_scrapy.ows_spider.write_csv import write_list_to_csv
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
s = requests.session()
s.trust_env = False # fastercookie = Noneusername = 'username'password = 'pwd'def login():
header = { 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8', 'Accept-Encoding': 'gzip, deflate, br', 'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8', 'Connection': 'keep-alive', 'Cookie': 'JSESSIONID=73E10849812940333A4AD2A2ABAEFB7D8CFF3E76A45340FFB687FD587D2EB97A49FC5F156D09DB1E17F129465AB8D8EBACEC', 'Host': '', 'Upgrade-Insecure-Requests': '1', 'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36'
}
form_data = { 'username': username, 'password': password, '_eventId': 'submit', 'pwdfirst': password[0:2], 'pwdsecond': password[2:5], 'pwdthird': password[5:]
}
login_url = 'https://.com/app/'
print('login...')
res = s.get(login_url, headers=header, verify=False) global cookie
cookie = res.cookies # 注意要保存cookie
print("get response from ows {0}, http status {1}".format(login_url, res.status_code))
login_url = res.url
header['Referer'] = login_url
header['Cookie'] = 'JSESSIONID=' + cookie['JSESSIONID']
form_data['lt'] = str(etree.HTML(res.content).xpath('//input[@name="lt"]/@value')[0]) #用xpath从页面上提取lt
res = s.post(login_url, headers=header, params=form_data, cookies=cookie, allow_redirects=False, verify=False)
cookie = res.cookies
print("post login params to {0}, http status {1}, cookie : {2}".format(login_url, res.status_code, cookie))
res = s.send(res.next, allow_redirects=False, verify=False)
cookie = res.cookies
print("redirect to {0}, http status {1}, cookie : {2}".format(login_url, res.status_code, cookie)) if res.status_code == 200 or res.status_code == 302: if cookie is not None and cookie.get(name='JSESSIONID', path='/app') is not None :
print('Successful login.') else:
print('WRONG w3id/password!')
sys.exit(0)
这里要特别注意，因为http是无状态的，网页需要使用cookie来保存登录状态。页面成功后，页面的响应会收录一个带有有效标记的cookie。登录的最终目的是获取和保存。这是一个有效的 cookie，因此后续访问不会被重定向到登录页面。
在requests方法中，只需要像这样将cookie带入request即可
res = s.post(login_url, headers=header, params=form_data, cookies=cookie, allow_redirects=False, verify=False)
分析动态内容页面
在动态页面中，页面上显示的内容往往是通过js或者AJAX异步获取的，这与静态html页面的分析过程明显不同。这些信息也可以通过 Chrome 的分析工具轻松获得。
分析动态页面
动态页面加载完成后，我们从所有请求中过滤XHR类型，找到我们想要的请求，然后在请求的Preview中可以看到完整的对应信息，请求的URL也可以从Received中下载从标题选项卡。
接下来要做的和上面类似，构造一个消息来模拟浏览器向网站发送请求：
def get_content(order_id):
form_data = { 'roarand': 'BW09el5W3mW2sfbGbtWe7mWlwBsWqXg6znppnqkW3woJ5fcz5DnhfWXGonqkLsd0', 'start': '0', 'limit': '20', 'orderid': order_id, 'serviceId': 'test_gscsocsecurityincidentmanage_log_getList2'
}
header = { 'Accept': 'text/plain, */*; q=0.01', 'Accept-Encoding': 'gzip, deflate, br', 'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8', 'Connection': 'keep-alive', 'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8', 'Host': '.com', 'Origin': 'https://.com', 'Referer': 'https://.com/app/104h/spl/test ... 39%3B, 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36', 'X-Requested-With': 'XMLHttpRequest'
}
print('Start to scan order id ' + order_id)
url = 'https://.com/app/pageservices/ ... og%3D{serviceName:test_gscsocsecurityincidentmanage_log_getList2,userId:571bdd42-10ca-4ce1-b41c-8a3f6632141f,tenantId:104h}&trackId=fec68f8e-f30a-4fa1-a8b1-41d3dd11fa4c'
res = s.post(url, headers=header, params=form_data, cookies=cookie, allow_redirects=False, verify=False) #要加载上面登录成功的cookie
print(res.content) return res
重点其实是从XHR中找到请求的URI，构造请求头并提交表单，最后加上登录成功cookie，否则会重定向到登录页面。
爬取动态页面的方法有很多。这种方式依赖的包比较少，代码也比较灵活。在爬取复杂的登录页面时效果更好，但在分析页面登录机制时需要特别小心。 查看全部
最近的项目在做一些数据集成，各种系统对应的接口就更奇怪了。数据整合的过程可以用八个字来概括：山中开路，水中搭桥。
这两天刚遇到一个问题。我们要集成的WEB系统没有提供专门的数据集成接口，没有API可以调整，不允许访问数据库。无奈之下，我想知道我们是否可以使用python自动爬取页面。网页有SSO，应该使用开源的CAS框架，后续所有页面都是通过动态JS和AJAX异步加载的，这显然不像普通的静态页面。对页面结构和爬取内容的分析是必不可少的。
工具分析登陆页面
打开登录页面，按F12打开Chrome自带的分析工具，在Network选项卡上可以看到当前浏览器显示页面的详细信息和提交的登录信息，如下图
一个 网站 登录页面
从截图可以看到，当我们访问app/这个url的日志时，由于我们还没有登录，SSO会自动将我们重定向到登录页面，所以http状态是302重定向。
接下来，我们在页面输入账号密码，点击登录按钮，通过页面跟踪分析整个登录过程，模拟整个登录过程。这个过程需要特别小心，因为很多CAS在登录页面上埋下了很多隐藏的标记，有可能会错误的模仿一个地方。它将无法登录并被重定向到它开始的地方。
分析登录过程
从分析可以看出，在提交登录按钮的时候，会通过POST提交一个表单，而且表单中除了账号密码、密码等显眼的字段外，还有一个lt。经验告诉我们，这个字段在之前的登录页面应该是隐藏的。用于验证登录页面的合法性，因此我们需要从登录页面中查找并提取此信息。同时，注意HTTP消息头。最好根据浏览器捕获的消息头来构造，因为网站也会验证里面的信息。
以下是登录的主要代码。我们基于python3和requests包处理https访问请求，并模拟浏览器的行为构造认证所需的信息发送给网站。
import requestsimport urllib3from lxml import etreefrom ows_scrapy.ows_spider.write_csv import write_list_to_csv
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
s = requests.session()
s.trust_env = False # fastercookie = Noneusername = 'username'password = 'pwd'def login():
header = { 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8', 'Accept-Encoding': 'gzip, deflate, br', 'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8', 'Connection': 'keep-alive', 'Cookie': 'JSESSIONID=73E10849812940333A4AD2A2ABAEFB7D8CFF3E76A45340FFB687FD587D2EB97A49FC5F156D09DB1E17F129465AB8D8EBACEC', 'Host': '', 'Upgrade-Insecure-Requests': '1', 'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36'
}
form_data = { 'username': username, 'password': password, '_eventId': 'submit', 'pwdfirst': password[0:2], 'pwdsecond': password[2:5], 'pwdthird': password[5:]
}
login_url = 'https://.com/app/'
print('login...')
res = s.get(login_url, headers=header, verify=False) global cookie
cookie = res.cookies # 注意要保存cookie
print("get response from ows {0}, http status {1}".format(login_url, res.status_code))
login_url = res.url
header['Referer'] = login_url
header['Cookie'] = 'JSESSIONID=' + cookie['JSESSIONID']
form_data['lt'] = str(etree.HTML(res.content).xpath('//input[@name="lt"]/@value')[0]) #用xpath从页面上提取lt
res = s.post(login_url, headers=header, params=form_data, cookies=cookie, allow_redirects=False, verify=False)
cookie = res.cookies
print("post login params to {0}, http status {1}, cookie : {2}".format(login_url, res.status_code, cookie))
res = s.send(res.next, allow_redirects=False, verify=False)
cookie = res.cookies
print("redirect to {0}, http status {1}, cookie : {2}".format(login_url, res.status_code, cookie)) if res.status_code == 200 or res.status_code == 302: if cookie is not None and cookie.get(name='JSESSIONID', path='/app') is not None :
print('Successful login.') else:
print('WRONG w3id/password!')
sys.exit(0)
这里要特别注意，因为http是无状态的，网页需要使用cookie来保存登录状态。页面成功后，页面的响应会收录一个带有有效标记的cookie。登录的最终目的是获取和保存。这是一个有效的 cookie，因此后续访问不会被重定向到登录页面。
在requests方法中，只需要像这样将cookie带入request即可
res = s.post(login_url, headers=header, params=form_data, cookies=cookie, allow_redirects=False, verify=False)
分析动态内容页面
在动态页面中，页面上显示的内容往往是通过js或者AJAX异步获取的，这与静态html页面的分析过程明显不同。这些信息也可以通过 Chrome 的分析工具轻松获得。
分析动态页面
动态页面加载完成后，我们从所有请求中过滤XHR类型，找到我们想要的请求，然后在请求的Preview中可以看到完整的对应信息，请求的URL也可以从Received中下载从标题选项卡。
接下来要做的和上面类似，构造一个消息来模拟浏览器向网站发送请求：
def get_content(order_id):
form_data = { 'roarand': 'BW09el5W3mW2sfbGbtWe7mWlwBsWqXg6znppnqkW3woJ5fcz5DnhfWXGonqkLsd0', 'start': '0', 'limit': '20', 'orderid': order_id, 'serviceId': 'test_gscsocsecurityincidentmanage_log_getList2'
}
header = { 'Accept': 'text/plain, */*; q=0.01', 'Accept-Encoding': 'gzip, deflate, br', 'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8', 'Connection': 'keep-alive', 'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8', 'Host': '.com', 'Origin': 'https://.com', 'Referer': 'https://.com/app/104h/spl/test ... 39%3B, 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36', 'X-Requested-With': 'XMLHttpRequest'
}
print('Start to scan order id ' + order_id)
url = 'https://.com/app/pageservices/ ... og%3D{serviceName:test_gscsocsecurityincidentmanage_log_getList2,userId:571bdd42-10ca-4ce1-b41c-8a3f6632141f,tenantId:104h}&trackId=fec68f8e-f30a-4fa1-a8b1-41d3dd11fa4c'
res = s.post(url, headers=header, params=form_data, cookies=cookie, allow_redirects=False, verify=False) #要加载上面登录成功的cookie
print(res.content) return res
重点其实是从XHR中找到请求的URI，构造请求头并提交表单，最后加上登录成功cookie，否则会重定向到登录页面。
爬取动态页面的方法有很多。这种方式依赖的包比较少，代码也比较灵活。在爬取复杂的登录页面时效果更好，但在分析页面登录机制时需要特别小心。 查看全部
python抓取动态网页(工具分析登录页面打开登录过程从分析可以看到哪些信息)
最近的项目在做一些数据集成，各种系统对应的接口就更奇怪了。数据整合的过程可以用八个字来概括：山中开路，水中搭桥。
这两天刚遇到一个问题。我们要集成的WEB系统没有提供专门的数据集成接口，没有API可以调整，不允许访问数据库。无奈之下，我想知道我们是否可以使用python自动爬取页面。网页有SSO，应该使用开源的CAS框架，后续所有页面都是通过动态JS和AJAX异步加载的，这显然不像普通的静态页面。对页面结构和爬取内容的分析是必不可少的。
工具分析登陆页面
打开登录页面，按F12打开Chrome自带的分析工具，在Network选项卡上可以看到当前浏览器显示页面的详细信息和提交的登录信息，如下图
一个 网站 登录页面
从截图可以看到，当我们访问app/这个url的日志时，由于我们还没有登录，SSO会自动将我们重定向到登录页面，所以http状态是302重定向。
接下来，我们在页面输入账号密码，点击登录按钮，通过页面跟踪分析整个登录过程，模拟整个登录过程。这个过程需要特别小心，因为很多CAS在登录页面上埋下了很多隐藏的标记，有可能会错误的模仿一个地方。它将无法登录并被重定向到它开始的地方。
分析登录过程
从分析可以看出，在提交登录按钮的时候，会通过POST提交一个表单，而且表单中除了账号密码、密码等显眼的字段外，还有一个lt。经验告诉我们，这个字段在之前的登录页面应该是隐藏的。用于验证登录页面的合法性，因此我们需要从登录页面中查找并提取此信息。同时，注意HTTP消息头。最好根据浏览器捕获的消息头来构造，因为网站也会验证里面的信息。
以下是登录的主要代码。我们基于python3和requests包处理https访问请求，并模拟浏览器的行为构造认证所需的信息发送给网站。
import requestsimport urllib3from lxml import etreefrom ows_scrapy.ows_spider.write_csv import write_list_to_csv
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
s = requests.session()
s.trust_env = False # fastercookie = Noneusername = 'username'password = 'pwd'def login():
header = { 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8', 'Accept-Encoding': 'gzip, deflate, br', 'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8', 'Connection': 'keep-alive', 'Cookie': 'JSESSIONID=73E10849812940333A4AD2A2ABAEFB7D8CFF3E76A45340FFB687FD587D2EB97A49FC5F156D09DB1E17F129465AB8D8EBACEC', 'Host': '', 'Upgrade-Insecure-Requests': '1', 'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36'
}
form_data = { 'username': username, 'password': password, '_eventId': 'submit', 'pwdfirst': password[0:2], 'pwdsecond': password[2:5], 'pwdthird': password[5:]
}
login_url = 'https://.com/app/'
print('login...')
res = s.get(login_url, headers=header, verify=False) global cookie
cookie = res.cookies # 注意要保存cookie
print("get response from ows {0}, http status {1}".format(login_url, res.status_code))
login_url = res.url
header['Referer'] = login_url
header['Cookie'] = 'JSESSIONID=' + cookie['JSESSIONID']
form_data['lt'] = str(etree.HTML(res.content).xpath('//input[@name="lt"]/@value')[0]) #用xpath从页面上提取lt
res = s.post(login_url, headers=header, params=form_data, cookies=cookie, allow_redirects=False, verify=False)
cookie = res.cookies
print("post login params to {0}, http status {1}, cookie : {2}".format(login_url, res.status_code, cookie))
res = s.send(res.next, allow_redirects=False, verify=False)
cookie = res.cookies
print("redirect to {0}, http status {1}, cookie : {2}".format(login_url, res.status_code, cookie)) if res.status_code == 200 or res.status_code == 302: if cookie is not None and cookie.get(name='JSESSIONID', path='/app') is not None :
print('Successful login.') else:
print('WRONG w3id/password!')
sys.exit(0)
这里要特别注意，因为http是无状态的，网页需要使用cookie来保存登录状态。页面成功后，页面的响应会收录一个带有有效标记的cookie。登录的最终目的是获取和保存。这是一个有效的 cookie，因此后续访问不会被重定向到登录页面。
在requests方法中，只需要像这样将cookie带入request即可
res = s.post(login_url, headers=header, params=form_data, cookies=cookie, allow_redirects=False, verify=False)
分析动态内容页面
在动态页面中，页面上显示的内容往往是通过js或者AJAX异步获取的，这与静态html页面的分析过程明显不同。这些信息也可以通过 Chrome 的分析工具轻松获得。
分析动态页面
动态页面加载完成后，我们从所有请求中过滤XHR类型，找到我们想要的请求，然后在请求的Preview中可以看到完整的对应信息，请求的URL也可以从Received中下载从标题选项卡。
接下来要做的和上面类似，构造一个消息来模拟浏览器向网站发送请求：
def get_content(order_id):
form_data = { 'roarand': 'BW09el5W3mW2sfbGbtWe7mWlwBsWqXg6znppnqkW3woJ5fcz5DnhfWXGonqkLsd0', 'start': '0', 'limit': '20', 'orderid': order_id, 'serviceId': 'test_gscsocsecurityincidentmanage_log_getList2'
}
header = { 'Accept': 'text/plain, */*; q=0.01', 'Accept-Encoding': 'gzip, deflate, br', 'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8', 'Connection': 'keep-alive', 'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8', 'Host': '.com', 'Origin': 'https://.com', 'Referer': 'https://.com/app/104h/spl/test ... 39%3B, 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36', 'X-Requested-With': 'XMLHttpRequest'
}
print('Start to scan order id ' + order_id)
url = 'https://.com/app/pageservices/ ... og%3D{serviceName:test_gscsocsecurityincidentmanage_log_getList2,userId:571bdd42-10ca-4ce1-b41c-8a3f6632141f,tenantId:104h}&trackId=fec68f8e-f30a-4fa1-a8b1-41d3dd11fa4c'
res = s.post(url, headers=header, params=form_data, cookies=cookie, allow_redirects=False, verify=False) #要加载上面登录成功的cookie
print(res.content) return res
重点其实是从XHR中找到请求的URI，构造请求头并提交表单，最后加上登录成功cookie，否则会重定向到登录页面。
爬取动态页面的方法有很多。这种方式依赖的包比较少，代码也比较灵活。在爬取复杂的登录页面时效果更好，但在分析页面登录机制时需要特别小心。
python抓取动态网页(使用selenium爬取动态网页信息Pythonselenium自动控制 )
网站优化 • 优采云 发表了文章 • 0 个评论 • 53 次浏览 • 2022-04-06 14:07
python抓取动态网页(使用selenium爬取动态网页信息Pythonselenium自动控制
)
使用selenium爬取动态网页信息
python selenium自动控制浏览器抓取网页数据，包括按钮点击、页面跳转、搜索框输入、页面值数据存储、mongodb自动id识别等。
首先介绍一下Python selenium——一个自动化测试工具，用来控制浏览器对网页的操作。当与爬虫中的 BeautifulSoup 结合使用时，它是无缝的。除了国外的一些异常验证页面，图片验证码我自己写了破解。图片验证码源码，成功率85%。
使用 conda 管家安装：
在cmd命令行输入“conda install selenium”进行安装
还需要安装 Google Chrome Drive 或 Firefox 插件
设置环境变量
通过selenium访问百度
from selenium import webdriver
#打开一个浏览器
browser = webdriver.Chrome()
#准备一个网址
url = 'http://www.baidu.com'
browser.get(url)
#获取元素
login = browser.find_elements_by_class_name('lb')[0]
print(login)
获取网易云音乐
from selenium import webdriver
#打开浏览器
brower = webdriver.Chrome()
url='https://music.163.com/#/discover/toplist'
brower.get(url)
#寻找logo文字
#logo = brower.find_elements_by_class_name('logo')[0]
#print(logo.text)
#一般情况下动态加载的内容都可以找到
#有一种情况就没有
#就是网页内存在网页框架iframe
#需要切换网页的层级
#语法：brower.switch_to.frame(iframe的id或者你提前获取这个对象，放入此处）
#方法一：id
#brower.switch_to.frame('g_iframe')
#方法二：name
#brower.switch_to.frame('contentFrame')
#方法三：提前用变量存iframe
iframe = brower.find_element_by_id('g_iframe')
brower.switch_to.frame(iframe)
#寻找大容器
toplist = brower.find_element_by_id('toplist')
#寻找tbody 通过标签名
tbody = toplist.find_elements_by_tag_name('tbody')[0]
#寻找所有tr
trs = tbody.find_elements_by_tag_name('tr')
dataList = []
for each in trs:
#排名
rank = each.find_elements_by_tag_name('td')[0].find_elements_by_class_name('num')[0].text
musicName = each.find_elements_by_tag_name('td')[1].find_elements_by_class_name('txt')[0].\
find_element_by_tag_name('b').get_attribute('title')
#print(musicName)
singer = each.find_elements_by_tag_name('td')[3].find_elements_by_class_name('text')[0].\
get_attribute('title')
#print(singer)
dataList.append([rank,musicName,singer])
#print(dataList)
from openpyxl import Workbook
wb = Workbook()
ws = wb.active
ws.title = '云音乐飙升榜'
ws.append(['排名','歌名','歌手'])
for data in dataList:
ws.append(data)
wb.save("云音乐飙升榜.xlsx") 查看全部
)
使用selenium爬取动态网页信息
python selenium自动控制浏览器抓取网页数据，包括按钮点击、页面跳转、搜索框输入、页面值数据存储、mongodb自动id识别等。
首先介绍一下Python selenium——一个自动化测试工具，用来控制浏览器对网页的操作。当与爬虫中的 BeautifulSoup 结合使用时，它是无缝的。除了国外的一些异常验证页面，图片验证码我自己写了破解。图片验证码源码，成功率85%。
使用 conda 管家安装：
在cmd命令行输入“conda install selenium”进行安装
还需要安装 Google Chrome Drive 或 Firefox 插件
设置环境变量
通过selenium访问百度
from selenium import webdriver
#打开一个浏览器
browser = webdriver.Chrome()
#准备一个网址
url = 'http://www.baidu.com'
browser.get(url)
#获取元素
login = browser.find_elements_by_class_name('lb')[0]
print(login)
获取网易云音乐
from selenium import webdriver
#打开浏览器
brower = webdriver.Chrome()
url='https://music.163.com/#/discover/toplist'
brower.get(url)
#寻找logo文字
#logo = brower.find_elements_by_class_name('logo')[0]
#print(logo.text)
#一般情况下动态加载的内容都可以找到
#有一种情况就没有
#就是网页内存在网页框架iframe
#需要切换网页的层级
#语法：brower.switch_to.frame(iframe的id或者你提前获取这个对象，放入此处）
#方法一：id
#brower.switch_to.frame('g_iframe')
#方法二：name
#brower.switch_to.frame('contentFrame')
#方法三：提前用变量存iframe
iframe = brower.find_element_by_id('g_iframe')
brower.switch_to.frame(iframe)
#寻找大容器
toplist = brower.find_element_by_id('toplist')
#寻找tbody 通过标签名
tbody = toplist.find_elements_by_tag_name('tbody')[0]
#寻找所有tr
trs = tbody.find_elements_by_tag_name('tr')
dataList = []
for each in trs:
#排名
rank = each.find_elements_by_tag_name('td')[0].find_elements_by_class_name('num')[0].text
musicName = each.find_elements_by_tag_name('td')[1].find_elements_by_class_name('txt')[0].\
find_element_by_tag_name('b').get_attribute('title')
#print(musicName)
singer = each.find_elements_by_tag_name('td')[3].find_elements_by_class_name('text')[0].\
get_attribute('title')
#print(singer)
dataList.append([rank,musicName,singer])
#print(dataList)
from openpyxl import Workbook
wb = Workbook()
ws = wb.active
ws.title = '云音乐飙升榜'
ws.append(['排名','歌名','歌手'])
for data in dataList:
ws.append(data)
wb.save("云音乐飙升榜.xlsx") 查看全部
python抓取动态网页(使用selenium爬取动态网页信息Pythonselenium自动控制
)
使用selenium爬取动态网页信息
python selenium自动控制浏览器抓取网页数据，包括按钮点击、页面跳转、搜索框输入、页面值数据存储、mongodb自动id识别等。
首先介绍一下Python selenium——一个自动化测试工具，用来控制浏览器对网页的操作。当与爬虫中的 BeautifulSoup 结合使用时，它是无缝的。除了国外的一些异常验证页面，图片验证码我自己写了破解。图片验证码源码，成功率85%。
使用 conda 管家安装：
在cmd命令行输入“conda install selenium”进行安装
还需要安装 Google Chrome Drive 或 Firefox 插件
设置环境变量
通过selenium访问百度
from selenium import webdriver
#打开一个浏览器
browser = webdriver.Chrome()
#准备一个网址
url = 'http://www.baidu.com'
browser.get(url)
#获取元素
login = browser.find_elements_by_class_name('lb')[0]
print(login)
获取网易云音乐
from selenium import webdriver
#打开浏览器
brower = webdriver.Chrome()
url='https://music.163.com/#/discover/toplist'
brower.get(url)
#寻找logo文字
#logo = brower.find_elements_by_class_name('logo')[0]
#print(logo.text)
#一般情况下动态加载的内容都可以找到
#有一种情况就没有
#就是网页内存在网页框架iframe
#需要切换网页的层级
#语法：brower.switch_to.frame(iframe的id或者你提前获取这个对象，放入此处）
#方法一：id
#brower.switch_to.frame('g_iframe')
#方法二：name
#brower.switch_to.frame('contentFrame')
#方法三：提前用变量存iframe
iframe = brower.find_element_by_id('g_iframe')
brower.switch_to.frame(iframe)
#寻找大容器
toplist = brower.find_element_by_id('toplist')
#寻找tbody 通过标签名
tbody = toplist.find_elements_by_tag_name('tbody')[0]
#寻找所有tr
trs = tbody.find_elements_by_tag_name('tr')
dataList = []
for each in trs:
#排名
rank = each.find_elements_by_tag_name('td')[0].find_elements_by_class_name('num')[0].text
musicName = each.find_elements_by_tag_name('td')[1].find_elements_by_class_name('txt')[0].\
find_element_by_tag_name('b').get_attribute('title')
#print(musicName)
singer = each.find_elements_by_tag_name('td')[3].find_elements_by_class_name('text')[0].\
get_attribute('title')
#print(singer)
dataList.append([rank,musicName,singer])
#print(dataList)
from openpyxl import Workbook
wb = Workbook()
ws = wb.active
ws.title = '云音乐飙升榜'
ws.append(['排名','歌名','歌手'])
for data in dataList:
ws.append(data)
wb.save("云音乐飙升榜.xlsx")
python抓取动态网页( 爬取需要安装Xpath和firebug两个插件（用于xpath定位）)
网站优化 • 优采云 发表了文章 • 0 个评论 • 41 次浏览 • 2022-04-06 06:16
python抓取动态网页(
爬取需要安装Xpath和firebug两个插件（用于xpath定位）)
browser = webdriver.Firefox() # Get local session of Firefox
browser.get("www.baidu.com") # Load page
在一般的静态网页中，我们需要爬取的信息是直接写在源码中的。我们可以很方便地使用正则表达式来抓取，例如：
rr.firstInit({"data":[{"author":"袁莉,翟坤","change":"第一次","companyCode":"80116848","datetime":"2016-01- 28T08 : 13:29","infoCode":"APPH2FEzZ2tFASearchReport","insCode":"80000031","insName":"东吴证券","insStar":"3","jlrs": ["206000000","259000000 ","352000000","",""],"rate":"Accumulation","secuFullCode":"002322.SZ","secuName":"科技监测","sratingName": "加","sy":"","syls":["24.4","19.37","14.19",""," "],"sys":["0.5","0.63","0.86","",""],"title" :"业绩有望触底，收购整合加速","profitYear":"2014","type ":"1","newPrice":"16.17"},
但是对于js生成的动态页面，我们需要模拟浏览器加载页面的行为，然后爬取：
所以我们需要准备的是python3+selenium+firefox 其中firefox需要安装Xpath checker和firebug两个插件（用于xpath定位）
首先我们需要通过：
browser = webdriver.Firefox() # Get local session of Firefox
time.sleep(5)
browser.get("https://www.baidu.com/") # Load page
加载页面。然后通过页面上的Xpath插件定位到我们需要爬取的信息。
最后一次使用
elem = browser.find_element_by_xpath("xpath")
获取我们需要抓取的信息。
最后定位翻页和跳页控件，完成所有网页的爬取。 查看全部
爬取需要安装Xpath和firebug两个插件（用于xpath定位）)
browser = webdriver.Firefox() # Get local session of Firefox
browser.get("www.baidu.com") # Load page
在一般的静态网页中，我们需要爬取的信息是直接写在源码中的。我们可以很方便地使用正则表达式来抓取，例如：
rr.firstInit({"data":[{"author":"袁莉,翟坤","change":"第一次","companyCode":"80116848","datetime":"2016-01- 28T08 : 13:29","infoCode":"APPH2FEzZ2tFASearchReport","insCode":"80000031","insName":"东吴证券","insStar":"3","jlrs": ["206000000","259000000 ","352000000","",""],"rate":"Accumulation","secuFullCode":"002322.SZ","secuName":"科技监测","sratingName": "加","sy":"","syls":["24.4","19.37","14.19",""," "],"sys":["0.5","0.63","0.86","",""],"title" :"业绩有望触底，收购整合加速","profitYear":"2014","type ":"1","newPrice":"16.17"},
但是对于js生成的动态页面，我们需要模拟浏览器加载页面的行为，然后爬取：
所以我们需要准备的是python3+selenium+firefox 其中firefox需要安装Xpath checker和firebug两个插件（用于xpath定位）
首先我们需要通过：
browser = webdriver.Firefox() # Get local session of Firefox
time.sleep(5)
browser.get("https://www.baidu.com/") # Load page
加载页面。然后通过页面上的Xpath插件定位到我们需要爬取的信息。
最后一次使用
elem = browser.find_element_by_xpath("xpath")
获取我们需要抓取的信息。
最后定位翻页和跳页控件，完成所有网页的爬取。 查看全部
python抓取动态网页(
爬取需要安装Xpath和firebug两个插件（用于xpath定位）)
browser = webdriver.Firefox() # Get local session of Firefox
browser.get("www.baidu.com") # Load page
在一般的静态网页中，我们需要爬取的信息是直接写在源码中的。我们可以很方便地使用正则表达式来抓取，例如：
rr.firstInit({"data":[{"author":"袁莉,翟坤","change":"第一次","companyCode":"80116848","datetime":"2016-01- 28T08 : 13:29","infoCode":"APPH2FEzZ2tFASearchReport","insCode":"80000031","insName":"东吴证券","insStar":"3","jlrs": ["206000000","259000000 ","352000000","",""],"rate":"Accumulation","secuFullCode":"002322.SZ","secuName":"科技监测","sratingName": "加","sy":"","syls":["24.4","19.37","14.19",""," "],"sys":["0.5","0.63","0.86","",""],"title" :"业绩有望触底，收购整合加速","profitYear":"2014","type ":"1","newPrice":"16.17"},
但是对于js生成的动态页面，我们需要模拟浏览器加载页面的行为，然后爬取：
所以我们需要准备的是python3+selenium+firefox 其中firefox需要安装Xpath checker和firebug两个插件（用于xpath定位）
首先我们需要通过：
browser = webdriver.Firefox() # Get local session of Firefox
time.sleep(5)
browser.get("https://www.baidu.com/";) # Load page
加载页面。然后通过页面上的Xpath插件定位到我们需要爬取的信息。
最后一次使用
elem = browser.find_element_by_xpath("xpath")
获取我们需要抓取的信息。
最后定位翻页和跳页控件，完成所有网页的爬取。
python抓取动态网页( 2.用正则表达式匹配获取数据(图)打印显示(组图))
网站优化 • 优采云 发表了文章 • 0 个评论 • 48 次浏览 • 2022-04-06 06:14
python抓取动态网页(
2.用正则表达式匹配获取数据(图)打印显示(组图))
爬行打印展示
通过上面的对比，我们爬取的是网页的源码。我们只需要对页面返回的内容进行过滤，提取出我们想要的部分数据，但通常很多网站都有反爬虫机制需要预处理。最后，将获取的数据写入文件或数据库，用于持久化数据存储。
步骤：通过url发送请求————>等待服务器响应————>获取网页源代码————>解析页面————>过滤————>数据保存
在上述步骤中，获取网页的源代码和解析页面是最重要的。这两个部分通常是最困难的。它们主要处理网页上的各种反爬机制。有时您的道德页面的源代码可能与网页的源代码不同。完全一样，需要对比分析。
2. 获取正则表达式匹配的数据
与其他方法相比，正则表达式是爬虫获取数据的一种非常有效的方法。它只需要在特殊模式下传递返回的网页源字符串和模式匹配，就可以找到我们想要的。所需的数据。但是，正则表达式的匹配模式对于初学者来说也有点难写，以实现快速精确的匹配。
正则表达式的使用可以概括为以下两种：
在自己写的pattern中编译，创建一个pattern对象（pattern），然后传入函数，只需要传入函数中要匹配的字符串即可。
通过 re.function name('match pattern', 'string to match') 找到需要的字符
当需要多次使用相同的匹配模式来选择第一种方法时，当匹配模式只需要使用一次来选择第二种方法时。
如果正则表达式匹配成功，则返回的数据类型为字符串，如果匹配失败，则返回None。但是，我们在查看匹配结果的时候，最好先判断一下匹配成功与否，以防报错。
常用的匹配函数如下：
函数名对应的函数描述
匹配（）
从前到后匹配，只有一次。如果匹配成功，返回re.Match对象，然后调用group()查看对应的值
全匹配（）
从前到后匹配，只匹配一次并进行完整匹配
搜索（）
搜索满足匹配模式的字符串，只匹配一次
找到所有（）
搜索所有满足匹配模式的字符并返回一个列表，列表中的每个元素都是一个满足匹配模式的字符串
在爬虫中，findall通常用于匹配查找所有符合匹配模式的字符串，通过遍历列表查看数据
正则表达式的特殊字符有以下含义：
数量限定词
特殊字符
\u4e00-\u9fa5 只匹配中文字体
位置相关字符
常见匹配字符
3. 页面源码分析
页面显示的内容
页面来源
通过对比两张图，我们可以看到，我们看到的和服务器返回给我们的还是有很大区别的。我们可以在页面上看到图片和文字，还有一些视频，但是网页的源代码都是纯文本，源代码中的图片和视频与链接一一对应。这意味着我们需要源代码提供的链接来访问图片和视频等。
在爬虫中分析网页源代码是一项非常重要的技能，需要通过不断的探索找到一些共性。最好对 CSS 和 JS 有一定的了解，了解网页显示给我的原理。
4. 通过请求爬取静态页面
对于从requests请求页面获取的源代码，需要进行预处理。常用的预处理通过 CSS 选择器和 xpath 过滤掉我们想要的内容。
4.1 css选择器基本语法选择器示例示例说明
。班级
。介绍
选择所有带有 class="intro" 的元素
＃ID
＃名
选择 id="firstname" 的所有元素
*
*
选择所有元素
元素
p
全选
元素
元素，元素
格，p
全选
元素和
元素
元素元素
分区 p
选择
全部在元素内
元素
在使用CSS选择器定位元素时，当有一个可以通过id定位的首选id时，id属性对应的值是唯一的，那么就为status元素考虑class属性。如果class属性有多个值，则需要选择一个。能。
4.2 xpath 基本语法
官方帮助文档：
表达描述
节点名
选择该节点的所有子节点
/
从当前节点中选择子节点
//
从当前节点中选择后代节点
.
选择当前节点
…
选择当前节点的父节点
@
选择属性
xpath 还可以结合运算符来定位元素
xpath 中的谓词
谓词用于查找特定节点或收录指定值的节点。
谓词用方括号括起来。
选择未知节点
选择多条路径
在以上基础上，通过案例进行如下具体分析：
通过CSS选择器方法获取豆瓣上排名前25的电影名
import requests
from bs4 import BeautifulSoup as Bs
url = 'https://movie.douban.com/top250'
# 设置请求头
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36',
# 先登录，通过开发者工具控制台获取
'Cookies': '**************************************************'
}
# 建立连接
resp = requests.get(url=url, headers=headers)
print(resp.status_code) # 查看是否访问成功，出现200就说明访问成功
if resp.status_code == 200:
soup = Bs(resp.text, 'lxml') # 进行预处理
title_list = soup.select('div.hd > a > span:nth-child(1)') # 找到标题对应的标签
for title in title_list:
print(title.text, end='\t') # 打印输出电影标题
'''
200
肖申克的救赎 霸王别姬 阿甘正传 这个杀手不太冷 泰坦尼克号 美丽人生 千与千寻 辛德勒的名单 盗梦空间 忠犬八公的故事 星际穿越 楚门的世界 海上钢琴师 三傻大闹宝莱坞 机器人总动员 放牛班的春天 无间道 疯狂动物城 大话西游之大圣娶亲 熔炉 教父 当幸福来敲门 龙猫 怦然心动 控方证人
'''
通过xpath选择器方法获取豆瓣排名前25的电影名
import requests
from bs4 import BeautifulSoup as Bs
from lxml import etree
url = 'https://movie.douban.com/top250'
# 设置请求头
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36',
'Cookies': '**************************************'
}
# 建立连接
resp = requests.get(url=url, headers=headers)
if resp.status_code == 200:
html = etree.HTML(resp.text) # 预处理
title_list = html.xpath('//div[@class= "hd"]/a[@href]/span[1]/text()')
for title in title_list:
print(title, end='\t')
'''
肖申克的救赎 霸王别姬 阿甘正传 这个杀手不太冷 泰坦尼克号 美丽人生 千与千寻 辛德勒的名单 盗梦空间 忠犬八公的故事 星际穿越 楚门的世界 海上钢琴师 三傻大闹宝莱坞 机器人总动员 放牛班的春天 无间道 疯狂动物城 大话西游之大圣娶亲 熔炉 教父 当幸福来敲门 龙猫 怦然心动 控方证人
'''
在爬取页面数据时，我们通常选择xpath进行爬取，这显然比通过css选择器定位元素更加灵活。爬取静态页面时，通过以上步骤爬取数据，但部分网页内容只能通过登录获取。
4.3 数据通过代理采集
当我们访问同一个网页太琐碎时，一些网站会使用反爬机制来屏蔽你的ip。这需要我们使用不同的 ip 地址多次访问同一个 网站。这个时候只能买ip让别人为你转发，结果返回给你。
通过运营商提供的ip链接获取有效ip
# -*- coding: UTF-8 -*-
"""
此代码为代理IP可用性检测模块，可准确筛选出尚未失效IP
注：
1.此代码只针对TXT数据格式接口。
2.尚未失效IP不一定为爬虫可用IP
3.使用时，请调用check_ip(url)，url为TXT数据格式接口地址
"""
import requests
import telnetlib
import re
from concurrent.futures.thread import ThreadPoolExecutor
# 请求接口，匹配出代理IP，多线程检测
def check_ip(url):
real_ip = []
# 检测代理IP是否失效
def telnet_ip(ip, port):
try:
telnetlib.Telnet(ip, port, timeout=1)
real_ip.append(f'{ip}:{port}')
except:
pass
while True:
try:
resp = requests.get(url)
# print(resp.text)
ip_data = re.findall('(\d+\.\d+\.\d+\.\d+):(\d+)', resp.text)
with ThreadPoolExecutor(max_workers=16) as pool:
for ip, port in ip_data:
pool.submit(telnet_ip, ip, port)
return real_ip
except:
pass
调用ip爬取
"""
example04-利用代理爬取
Version：
Author:
Date:2021/8/17
"""
from check_proxies import check_ip
import requests
from bs4 import BeautifulSoup
# ip地址链接，由运营商提供，具有一定的时效性
URL = 'http://api.66daili.cn/API/GetC ... elite,anonymous,transparent&area=%E4%B8%AD%E5%9B%BD&proxytype=https&speed=fast#api'
ip_list = check_ip(URL)
print(ip_list)
flag = True
while flag:
for i in range(len(ip_list)):
doubna_url = 'https://movie.douban.com/top250'
headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 '
'(KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
}
# 代理ip，会根据要求进行自动选择http或https协议
proxy = {
'http': 'http://' + ip_list[i],
'http': 'https://' + ip_list[i]
}
try:
resp = requests.get(url=doubna_url, headers=headers, proxies=proxy, timeout=1)
if resp.status_code == 200:
print(resp.text)
flag = False
break
except:
print('Erro')
5. 通过 selenium 驱动浏览器并爬取动态页面
通过 selenium 获取页面步骤：
先把驱动放到当前项目中
from selenium import webdriver
url = 'https://www.baidu.com/'
# 创建浏览器对象
b = webdriver.Chrome(./chromedrivers.exe)
# 访问页面
b.get(url)
# 关闭
b.quit()
使用selenium登录京东页面
<p>import getpass
import time
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
url = 'https://www.jd.com/'
options = webdriver.ChromeOptions()
options.add_experimental_option("excludeSwitches", ['enable-automation', 'enable-logging']) # 忽略警告
# options.add_argument('blink-settings=imagesEnabled=false') # 不加载图片
b = webdriver.Chrome(options=options)
b.get(url)
b.find_element_by_id('ttbar-login').click()
b.find_element_by_class_name('login-tab-r').click()
b.find_element_by_id('loginname').send_keys(input('输入账号：'))
b.find_element_by_id('nloginpwd').send_keys(getpass.getpass('输入密码：'))
b.find_element_by_id('loginsubmit').click()
time.sleep(5)
b.find_element_by_id('key').send_keys('python')
b.find_element_by_id('key').send_keys(Keys.ENTER)
max_y = 10000
y = 0
while y 查看全部
2.用正则表达式匹配获取数据(图)打印显示(组图))
爬行打印展示
通过上面的对比，我们爬取的是网页的源码。我们只需要对页面返回的内容进行过滤，提取出我们想要的部分数据，但通常很多网站都有反爬虫机制需要预处理。最后，将获取的数据写入文件或数据库，用于持久化数据存储。
步骤：通过url发送请求————>等待服务器响应————>获取网页源代码————>解析页面————>过滤————>数据保存
在上述步骤中，获取网页的源代码和解析页面是最重要的。这两个部分通常是最困难的。它们主要处理网页上的各种反爬机制。有时您的道德页面的源代码可能与网页的源代码不同。完全一样，需要对比分析。
2. 获取正则表达式匹配的数据
与其他方法相比，正则表达式是爬虫获取数据的一种非常有效的方法。它只需要在特殊模式下传递返回的网页源字符串和模式匹配，就可以找到我们想要的。所需的数据。但是，正则表达式的匹配模式对于初学者来说也有点难写，以实现快速精确的匹配。
正则表达式的使用可以概括为以下两种：
在自己写的pattern中编译，创建一个pattern对象（pattern），然后传入函数，只需要传入函数中要匹配的字符串即可。
通过 re.function name('match pattern', 'string to match') 找到需要的字符
当需要多次使用相同的匹配模式来选择第一种方法时，当匹配模式只需要使用一次来选择第二种方法时。
如果正则表达式匹配成功，则返回的数据类型为字符串，如果匹配失败，则返回None。但是，我们在查看匹配结果的时候，最好先判断一下匹配成功与否，以防报错。
常用的匹配函数如下：
函数名对应的函数描述
匹配（）
从前到后匹配，只有一次。如果匹配成功，返回re.Match对象，然后调用group()查看对应的值
全匹配（）
从前到后匹配，只匹配一次并进行完整匹配
搜索（）
搜索满足匹配模式的字符串，只匹配一次
找到所有（）
搜索所有满足匹配模式的字符并返回一个列表，列表中的每个元素都是一个满足匹配模式的字符串
在爬虫中，findall通常用于匹配查找所有符合匹配模式的字符串，通过遍历列表查看数据
正则表达式的特殊字符有以下含义：
数量限定词
特殊字符
\u4e00-\u9fa5 只匹配中文字体
位置相关字符
常见匹配字符
3. 页面源码分析
页面显示的内容
页面来源
通过对比两张图，我们可以看到，我们看到的和服务器返回给我们的还是有很大区别的。我们可以在页面上看到图片和文字，还有一些视频，但是网页的源代码都是纯文本，源代码中的图片和视频与链接一一对应。这意味着我们需要源代码提供的链接来访问图片和视频等。
在爬虫中分析网页源代码是一项非常重要的技能，需要通过不断的探索找到一些共性。最好对 CSS 和 JS 有一定的了解，了解网页显示给我的原理。
4. 通过请求爬取静态页面
对于从requests请求页面获取的源代码，需要进行预处理。常用的预处理通过 CSS 选择器和 xpath 过滤掉我们想要的内容。
4.1 css选择器基本语法选择器示例示例说明
。班级
。介绍
选择所有带有 class="intro" 的元素
＃ID
＃名
选择 id="firstname" 的所有元素
*
*
选择所有元素
元素
p
全选
元素
元素，元素
格，p
全选
元素和
元素
元素元素
分区 p
选择
全部在元素内
元素
在使用CSS选择器定位元素时，当有一个可以通过id定位的首选id时，id属性对应的值是唯一的，那么就为status元素考虑class属性。如果class属性有多个值，则需要选择一个。能。
4.2 xpath 基本语法
官方帮助文档：
表达描述
节点名
选择该节点的所有子节点
/
从当前节点中选择子节点
//
从当前节点中选择后代节点
.
选择当前节点
…
选择当前节点的父节点
@
选择属性
xpath 还可以结合运算符来定位元素
xpath 中的谓词
谓词用于查找特定节点或收录指定值的节点。
谓词用方括号括起来。
选择未知节点
选择多条路径
在以上基础上，通过案例进行如下具体分析：
通过CSS选择器方法获取豆瓣上排名前25的电影名
import requests
from bs4 import BeautifulSoup as Bs
url = 'https://movie.douban.com/top250'
# 设置请求头
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36',
# 先登录，通过开发者工具控制台获取
'Cookies': '**************************************************'
}
# 建立连接
resp = requests.get(url=url, headers=headers)
print(resp.status_code) # 查看是否访问成功，出现200就说明访问成功
if resp.status_code == 200:
soup = Bs(resp.text, 'lxml') # 进行预处理
title_list = soup.select('div.hd > a > span:nth-child(1)') # 找到标题对应的标签
for title in title_list:
print(title.text, end='\t') # 打印输出电影标题
'''
200
肖申克的救赎 霸王别姬 阿甘正传 这个杀手不太冷 泰坦尼克号 美丽人生 千与千寻 辛德勒的名单 盗梦空间 忠犬八公的故事 星际穿越 楚门的世界 海上钢琴师 三傻大闹宝莱坞 机器人总动员 放牛班的春天 无间道 疯狂动物城 大话西游之大圣娶亲 熔炉 教父 当幸福来敲门 龙猫 怦然心动 控方证人
'''
通过xpath选择器方法获取豆瓣排名前25的电影名
import requests
from bs4 import BeautifulSoup as Bs
from lxml import etree
url = 'https://movie.douban.com/top250'
# 设置请求头
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36',
'Cookies': '**************************************'
}
# 建立连接
resp = requests.get(url=url, headers=headers)
if resp.status_code == 200:
html = etree.HTML(resp.text) # 预处理
title_list = html.xpath('//div[@class= "hd"]/a[@href]/span[1]/text()')
for title in title_list:
print(title, end='\t')
'''
肖申克的救赎 霸王别姬 阿甘正传 这个杀手不太冷 泰坦尼克号 美丽人生 千与千寻 辛德勒的名单 盗梦空间 忠犬八公的故事 星际穿越 楚门的世界 海上钢琴师 三傻大闹宝莱坞 机器人总动员 放牛班的春天 无间道 疯狂动物城 大话西游之大圣娶亲 熔炉 教父 当幸福来敲门 龙猫 怦然心动 控方证人
'''
在爬取页面数据时，我们通常选择xpath进行爬取，这显然比通过css选择器定位元素更加灵活。爬取静态页面时，通过以上步骤爬取数据，但部分网页内容只能通过登录获取。
4.3 数据通过代理采集
当我们访问同一个网页太琐碎时，一些网站会使用反爬机制来屏蔽你的ip。这需要我们使用不同的 ip 地址多次访问同一个 网站。这个时候只能买ip让别人为你转发，结果返回给你。
通过运营商提供的ip链接获取有效ip
# -*- coding: UTF-8 -*-
"""
此代码为代理IP可用性检测模块，可准确筛选出尚未失效IP
注：
1.此代码只针对TXT数据格式接口。
2.尚未失效IP不一定为爬虫可用IP
3.使用时，请调用check_ip(url)，url为TXT数据格式接口地址
"""
import requests
import telnetlib
import re
from concurrent.futures.thread import ThreadPoolExecutor
# 请求接口，匹配出代理IP，多线程检测
def check_ip(url):
real_ip = []
# 检测代理IP是否失效
def telnet_ip(ip, port):
try:
telnetlib.Telnet(ip, port, timeout=1)
real_ip.append(f'{ip}:{port}')
except:
pass
while True:
try:
resp = requests.get(url)
# print(resp.text)
ip_data = re.findall('(\d+\.\d+\.\d+\.\d+):(\d+)', resp.text)
with ThreadPoolExecutor(max_workers=16) as pool:
for ip, port in ip_data:
pool.submit(telnet_ip, ip, port)
return real_ip
except:
pass
调用ip爬取
"""
example04-利用代理爬取
Version：
Author:
Date:2021/8/17
"""
from check_proxies import check_ip
import requests
from bs4 import BeautifulSoup
# ip地址链接，由运营商提供，具有一定的时效性
URL = 'http://api.66daili.cn/API/GetC ... elite,anonymous,transparent&area=%E4%B8%AD%E5%9B%BD&proxytype=https&speed=fast#api'
ip_list = check_ip(URL)
print(ip_list)
flag = True
while flag:
for i in range(len(ip_list)):
doubna_url = 'https://movie.douban.com/top250'
headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 '
'(KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
}
# 代理ip，会根据要求进行自动选择http或https协议
proxy = {
'http': 'http://' + ip_list[i],
'http': 'https://' + ip_list[i]
}
try:
resp = requests.get(url=doubna_url, headers=headers, proxies=proxy, timeout=1)
if resp.status_code == 200:
print(resp.text)
flag = False
break
except:
print('Erro')
5. 通过 selenium 驱动浏览器并爬取动态页面
通过 selenium 获取页面步骤：
先把驱动放到当前项目中
from selenium import webdriver
url = 'https://www.baidu.com/'
# 创建浏览器对象
b = webdriver.Chrome(./chromedrivers.exe)
# 访问页面
b.get(url)
# 关闭
b.quit()
使用selenium登录京东页面
<p>import getpass
import time
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
url = 'https://www.jd.com/'
options = webdriver.ChromeOptions()
options.add_experimental_option("excludeSwitches", ['enable-automation', 'enable-logging']) # 忽略警告
# options.add_argument('blink-settings=imagesEnabled=false') # 不加载图片
b = webdriver.Chrome(options=options)
b.get(url)
b.find_element_by_id('ttbar-login').click()
b.find_element_by_class_name('login-tab-r').click()
b.find_element_by_id('loginname').send_keys(input('输入账号：'))
b.find_element_by_id('nloginpwd').send_keys(getpass.getpass('输入密码：'))
b.find_element_by_id('loginsubmit').click()
time.sleep(5)
b.find_element_by_id('key').send_keys('python')
b.find_element_by_id('key').send_keys(Keys.ENTER)
max_y = 10000
y = 0
while y 查看全部
python抓取动态网页(
2.用正则表达式匹配获取数据(图)打印显示(组图))
爬行打印展示
通过上面的对比，我们爬取的是网页的源码。我们只需要对页面返回的内容进行过滤，提取出我们想要的部分数据，但通常很多网站都有反爬虫机制需要预处理。最后，将获取的数据写入文件或数据库，用于持久化数据存储。
步骤：通过url发送请求————>等待服务器响应————>获取网页源代码————>解析页面————>过滤————>数据保存
在上述步骤中，获取网页的源代码和解析页面是最重要的。这两个部分通常是最困难的。它们主要处理网页上的各种反爬机制。有时您的道德页面的源代码可能与网页的源代码不同。完全一样，需要对比分析。
2. 获取正则表达式匹配的数据
与其他方法相比，正则表达式是爬虫获取数据的一种非常有效的方法。它只需要在特殊模式下传递返回的网页源字符串和模式匹配，就可以找到我们想要的。所需的数据。但是，正则表达式的匹配模式对于初学者来说也有点难写，以实现快速精确的匹配。
正则表达式的使用可以概括为以下两种：
在自己写的pattern中编译，创建一个pattern对象（pattern），然后传入函数，只需要传入函数中要匹配的字符串即可。
通过 re.function name('match pattern', 'string to match') 找到需要的字符
当需要多次使用相同的匹配模式来选择第一种方法时，当匹配模式只需要使用一次来选择第二种方法时。
如果正则表达式匹配成功，则返回的数据类型为字符串，如果匹配失败，则返回None。但是，我们在查看匹配结果的时候，最好先判断一下匹配成功与否，以防报错。
常用的匹配函数如下：
函数名对应的函数描述
匹配（）
从前到后匹配，只有一次。如果匹配成功，返回re.Match对象，然后调用group()查看对应的值
全匹配（）
从前到后匹配，只匹配一次并进行完整匹配
搜索（）
搜索满足匹配模式的字符串，只匹配一次
找到所有（）
搜索所有满足匹配模式的字符并返回一个列表，列表中的每个元素都是一个满足匹配模式的字符串
在爬虫中，findall通常用于匹配查找所有符合匹配模式的字符串，通过遍历列表查看数据
正则表达式的特殊字符有以下含义：
数量限定词
特殊字符
\u4e00-\u9fa5 只匹配中文字体
位置相关字符
常见匹配字符
3. 页面源码分析
页面显示的内容
页面来源
通过对比两张图，我们可以看到，我们看到的和服务器返回给我们的还是有很大区别的。我们可以在页面上看到图片和文字，还有一些视频，但是网页的源代码都是纯文本，源代码中的图片和视频与链接一一对应。这意味着我们需要源代码提供的链接来访问图片和视频等。
在爬虫中分析网页源代码是一项非常重要的技能，需要通过不断的探索找到一些共性。最好对 CSS 和 JS 有一定的了解，了解网页显示给我的原理。
4. 通过请求爬取静态页面
对于从requests请求页面获取的源代码，需要进行预处理。常用的预处理通过 CSS 选择器和 xpath 过滤掉我们想要的内容。
4.1 css选择器基本语法选择器示例示例说明
。班级
。介绍
选择所有带有 class="intro" 的元素
＃ID
＃名
选择 id="firstname" 的所有元素
*
*
选择所有元素
元素
p
全选
元素
元素，元素
格，p
全选
元素和
元素
元素元素
分区 p
选择
全部在元素内
元素
在使用CSS选择器定位元素时，当有一个可以通过id定位的首选id时，id属性对应的值是唯一的，那么就为status元素考虑class属性。如果class属性有多个值，则需要选择一个。能。
4.2 xpath 基本语法
官方帮助文档：
表达描述
节点名
选择该节点的所有子节点
/
从当前节点中选择子节点
//
从当前节点中选择后代节点
.
选择当前节点
…
选择当前节点的父节点
@
选择属性
xpath 还可以结合运算符来定位元素
xpath 中的谓词
谓词用于查找特定节点或收录指定值的节点。
谓词用方括号括起来。
选择未知节点
选择多条路径
在以上基础上，通过案例进行如下具体分析：
通过CSS选择器方法获取豆瓣上排名前25的电影名
import requests
from bs4 import BeautifulSoup as Bs
url = 'https://movie.douban.com/top250'
# 设置请求头
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36',
# 先登录，通过开发者工具控制台获取
'Cookies': '**************************************************'
}
# 建立连接
resp = requests.get(url=url, headers=headers)
print(resp.status_code) # 查看是否访问成功，出现200就说明访问成功
if resp.status_code == 200:
soup = Bs(resp.text, 'lxml') # 进行预处理
title_list = soup.select('div.hd > a > span:nth-child(1)') # 找到标题对应的标签
for title in title_list:
print(title.text, end='\t') # 打印输出电影标题
'''
200
肖申克的救赎 霸王别姬 阿甘正传 这个杀手不太冷 泰坦尼克号 美丽人生 千与千寻 辛德勒的名单 盗梦空间 忠犬八公的故事 星际穿越 楚门的世界 海上钢琴师 三傻大闹宝莱坞 机器人总动员 放牛班的春天 无间道 疯狂动物城 大话西游之大圣娶亲 熔炉 教父 当幸福来敲门 龙猫 怦然心动 控方证人
'''
通过xpath选择器方法获取豆瓣排名前25的电影名
import requests
from bs4 import BeautifulSoup as Bs
from lxml import etree
url = 'https://movie.douban.com/top250'
# 设置请求头
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36',
'Cookies': '**************************************'
}
# 建立连接
resp = requests.get(url=url, headers=headers)
if resp.status_code == 200:
html = etree.HTML(resp.text) # 预处理
title_list = html.xpath('//div[@class= "hd"]/a[@href]/span[1]/text()')
for title in title_list:
print(title, end='\t')
'''
肖申克的救赎 霸王别姬 阿甘正传 这个杀手不太冷 泰坦尼克号 美丽人生 千与千寻 辛德勒的名单 盗梦空间 忠犬八公的故事 星际穿越 楚门的世界 海上钢琴师 三傻大闹宝莱坞 机器人总动员 放牛班的春天 无间道 疯狂动物城 大话西游之大圣娶亲 熔炉 教父 当幸福来敲门 龙猫 怦然心动 控方证人
'''
在爬取页面数据时，我们通常选择xpath进行爬取，这显然比通过css选择器定位元素更加灵活。爬取静态页面时，通过以上步骤爬取数据，但部分网页内容只能通过登录获取。
4.3 数据通过代理采集
当我们访问同一个网页太琐碎时，一些网站会使用反爬机制来屏蔽你的ip。这需要我们使用不同的 ip 地址多次访问同一个 网站。这个时候只能买ip让别人为你转发，结果返回给你。
通过运营商提供的ip链接获取有效ip
# -*- coding: UTF-8 -*-
"""
此代码为代理IP可用性检测模块，可准确筛选出尚未失效IP
注：
1.此代码只针对TXT数据格式接口。
2.尚未失效IP不一定为爬虫可用IP
3.使用时，请调用check_ip(url)，url为TXT数据格式接口地址
"""
import requests
import telnetlib
import re
from concurrent.futures.thread import ThreadPoolExecutor
# 请求接口，匹配出代理IP，多线程检测
def check_ip(url):
real_ip = []
# 检测代理IP是否失效
def telnet_ip(ip, port):
try:
telnetlib.Telnet(ip, port, timeout=1)
real_ip.append(f'{ip}:{port}')
except:
pass
while True:
try:
resp = requests.get(url)
# print(resp.text)
ip_data = re.findall('(\d+\.\d+\.\d+\.\d+):(\d+)', resp.text)
with ThreadPoolExecutor(max_workers=16) as pool:
for ip, port in ip_data:
pool.submit(telnet_ip, ip, port)
return real_ip
except:
pass
调用ip爬取
"""
example04-利用代理爬取
Version：
Author:
Date:2021/8/17
"""
from check_proxies import check_ip
import requests
from bs4 import BeautifulSoup
# ip地址链接，由运营商提供，具有一定的时效性
URL = 'http://api.66daili.cn/API/GetC ... elite,anonymous,transparent&area=%E4%B8%AD%E5%9B%BD&proxytype=https&speed=fast#api'
ip_list = check_ip(URL)
print(ip_list)
flag = True
while flag:
for i in range(len(ip_list)):
doubna_url = 'https://movie.douban.com/top250'
headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 '
'(KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
}
# 代理ip，会根据要求进行自动选择http或https协议
proxy = {
'http': 'http://' + ip_list[i],
'http': 'https://' + ip_list[i]
}
try:
resp = requests.get(url=doubna_url, headers=headers, proxies=proxy, timeout=1)
if resp.status_code == 200:
print(resp.text)
flag = False
break
except:
print('Erro')
5. 通过 selenium 驱动浏览器并爬取动态页面
通过 selenium 获取页面步骤：
先把驱动放到当前项目中
from selenium import webdriver
url = 'https://www.baidu.com/'
# 创建浏览器对象
b = webdriver.Chrome(./chromedrivers.exe)
# 访问页面
b.get(url)
# 关闭
b.quit()
使用selenium登录京东页面
<p>import getpass
import time
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
url = 'https://www.jd.com/'
options = webdriver.ChromeOptions()
options.add_experimental_option("excludeSwitches", ['enable-automation', 'enable-logging']) # 忽略警告
# options.add_argument('blink-settings=imagesEnabled=false') # 不加载图片
b = webdriver.Chrome(options=options)
b.get(url)
b.find_element_by_id('ttbar-login').click()
b.find_element_by_class_name('login-tab-r').click()
b.find_element_by_id('loginname').send_keys(input('输入账号：'))
b.find_element_by_id('nloginpwd').send_keys(getpass.getpass('输入密码：'))
b.find_element_by_id('loginsubmit').click()
time.sleep(5)
b.find_element_by_id('key').send_keys('python')
b.find_element_by_id('key').send_keys(Keys.ENTER)
max_y = 10000
y = 0
while y
python抓取动态网页( urllib使用js动态加载的网页--百度图片的结果页)
网站优化 • 优采云 发表了文章 • 0 个评论 • 23 次浏览 • 2022-04-06 06:14
python抓取动态网页(
urllib使用js动态加载的网页--百度图片的结果页)
我们在做网页抓取的时候，一般使用 urllib 和 urllib2 来满足我们大部分的需求。
但有时我们会遇到使用js动态加载的网页。你会发现 urllib 只能抓取部分空白的网页。就像下面百度图片的结果页：
查看元素后发现百度图片中，显示图片的div是：pullimages
这个 div 里面的内容是动态加载的。但是使用urllib&urllib2就爬不上了。
要抓取动态加载的元素，首先考虑使用 selenium 调用浏览器进行抓取。
而我们的运行环境是linux，最理想的方式是无界面抓取，所以使用selenium+phantomjs无界面抓取。
什么是phantomjs？它是一个基于webkit核心的无头浏览器，也就是没有UI界面，就是一个浏览器。
selenium和phantomjs的安装配置可以google，这里就不多说了。
代码如下：from selenium import webdriver
driver = webdriver.PhantomJS(executable_path='/bin/phantomjs/bin/phantomjs')
#如果不方便配置环境变量。也可以使用phantomjs的绝对路径
driver.get('%E5%91%A8%E6%9D%B0%E4%BC%A6')
#抓取百度图片，查询：周杰伦
driver.page_source
#这是返回页面的内容，类似于urllib2.urlopen().read()，但比urllib2强，可以捕获动态渲染的内容。
driver.quit()
去这里。成功抓取动态页面。 查看全部
urllib使用js动态加载的网页--百度图片的结果页)
我们在做网页抓取的时候，一般使用 urllib 和 urllib2 来满足我们大部分的需求。
但有时我们会遇到使用js动态加载的网页。你会发现 urllib 只能抓取部分空白的网页。就像下面百度图片的结果页：
查看元素后发现百度图片中，显示图片的div是：pullimages
这个 div 里面的内容是动态加载的。但是使用urllib&urllib2就爬不上了。
要抓取动态加载的元素，首先考虑使用 selenium 调用浏览器进行抓取。
而我们的运行环境是linux，最理想的方式是无界面抓取，所以使用selenium+phantomjs无界面抓取。
什么是phantomjs？它是一个基于webkit核心的无头浏览器，也就是没有UI界面，就是一个浏览器。
selenium和phantomjs的安装配置可以google，这里就不多说了。
代码如下：from selenium import webdriver
driver = webdriver.PhantomJS(executable_path='/bin/phantomjs/bin/phantomjs')
#如果不方便配置环境变量。也可以使用phantomjs的绝对路径
driver.get('%E5%91%A8%E6%9D%B0%E4%BC%A6')
#抓取百度图片，查询：周杰伦
driver.page_source
#这是返回页面的内容，类似于urllib2.urlopen().read()，但比urllib2强，可以捕获动态渲染的内容。
driver.quit()
去这里。成功抓取动态页面。 查看全部
python抓取动态网页(
urllib使用js动态加载的网页--百度图片的结果页)
我们在做网页抓取的时候，一般使用 urllib 和 urllib2 来满足我们大部分的需求。
但有时我们会遇到使用js动态加载的网页。你会发现 urllib 只能抓取部分空白的网页。就像下面百度图片的结果页：
查看元素后发现百度图片中，显示图片的div是：pullimages
这个 div 里面的内容是动态加载的。但是使用urllib&urllib2就爬不上了。
要抓取动态加载的元素，首先考虑使用 selenium 调用浏览器进行抓取。
而我们的运行环境是linux，最理想的方式是无界面抓取，所以使用selenium+phantomjs无界面抓取。
什么是phantomjs？它是一个基于webkit核心的无头浏览器，也就是没有UI界面，就是一个浏览器。
selenium和phantomjs的安装配置可以google，这里就不多说了。
代码如下：from selenium import webdriver
driver = webdriver.PhantomJS(executable_path='/bin/phantomjs/bin/phantomjs')
#如果不方便配置环境变量。也可以使用phantomjs的绝对路径
driver.get('%E5%91%A8%E6%9D%B0%E4%BC%A6')
#抓取百度图片，查询：周杰伦
driver.page_source
#这是返回页面的内容，类似于urllib2.urlopen().read()，但比urllib2强，可以捕获动态渲染的内容。
driver.quit()
去这里。成功抓取动态页面。
python抓取动态网页(高效处理动态网页的完美组合——爬虫)
网站优化 • 优采云 发表了文章 • 0 个评论 • 27 次浏览 • 2022-04-06 06:13
python抓取动态网页(高效处理动态网页的完美组合——爬虫)
爬虫是我们快速获取所需数据的一种非常有效的方式，而爬虫的第一步就是请求远程服务器为我们返回所需的网页信息。我们知道，一般情况下，我们只需要输入正确的Uniform Resource Locator url，即网页地址，就可以在浏览器上轻松打开我们想看到的页面。同样，在设计python爬虫程序时，我们也可以通过参数设置调用相应的库连接网络处理http协议。对于静态网页，常用的库有urllib、urllib2、requests等，通过它们可以很方便的请求服务器返回特定地址的网页内容。但是，如果我们遇到 JS 加载的动态网页，使用以前的方法，我们经常无法收到我们想要的结果。这时候可以召唤强大的自动化测试工具Selenium，召唤它的好友PhantomJS，一起升级打怪。
(一） urllib, urllib2, 直接上例子：
import urllib2
response = urllib2.urlopen("http://www.baidu.com")
print response.read()
只要给一个url，比如百度，调用urllib2库，就可以单手阅读这个url对应的网页源码，代码非常简洁。在实际爬虫中，考虑到对方的反爬机制，网络响应时间或者发送请求需要添加额外的信息，我们需要多添加几行代码，目的是让服务器尽量相信收到的请求来自正常访问对象。为了程序逻辑的清晰，我们可以设计一个请求对象作为urlopen的传入参数，例如：
import urllib
import urllib2
#添加url
url = 'xxx'
request = urllib2.Request(url)
#为了模拟浏览器行为，伪装对方识别问题，可以添加Headers属性，例如下面的agent便是设置请求身份：
user_agent = 'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.102 Safari/537.36'
headers = { 'User-Agent' : user_agent}
request = urllib2.Request(url, headers)
#有时访问某些网站需要提供一些信息，例如用户名和密码，这时可以这样：
values = {"username":"yourname","password":"????"}
data = urllib.urlencode(values)
request = urllib2.Request(url, data, headers)
#在遇到网络状况不好时可以设置timeout来设置等待多久超时
response = urllib2.urlopen(request，timeout=18)
print response.read()
有关更多相关内容，请参阅此 urllib 和 urllib2。
（二）requests，一个简单、美观、友好的外部库。
请求的所有功能都可以通过以下7种方法访问。它们都返回响应对象的一个实例。
#创建并发送一个request
requests.request(method, url, **kwargs)
参数：
method -- method for the new Request object.
url -- URL for the new Request object.
params -- (optional) Dictionary or bytes to be sent in the query string for the Request.
data -- (optional) Dictionary, bytes, or file-like object to send in the body of the Request.
json -- (optional) json data to send in the body of the Request.
headers -- (optional) Dictionary of HTTP Headers to send with the Request.
cookies -- (optional) Dict or CookieJar object to send with the Request.
files -- (optional) Dictionary of 'name': file-like-objects (or {'name': file-tuple}) for multipart encoding upload. file-tuple can be a 2-tuple ('filename', fileobj), 3-tuple ('filename', fileobj, 'content_type') or a 4-tuple ('filename', fileobj, 'content_type', custom_headers), where 'content-type' is a string defining the content type of the given file and custom_headers a dict-like object containing additional headers to add for the file.
auth -- (optional) Auth tuple to enable Basic/Digest/Custom HTTP Auth.
timeout (float or tuple) -- (optional) How long to wait for the server to send data before giving up, as a float, or a (connect timeout, read timeout) tuple.
allow_redirects (bool) -- (optional) Boolean. Set to True if POST/PUT/DELETE redirect following is allowed.
proxies -- (optional) Dictionary mapping protocol to the URL of the proxy.
verify -- (optional) whether the SSL cert will be verified. A CA_BUNDLE path can also be provided. Defaults to True.
stream -- (optional) if False, the response content will be immediately downloaded.
cert -- (optional) if String, path to ssl client cert file (.pem). If Tuple, ('cert', 'key') pair.
#例如：
import requests
url='xxxx'
headers = {'User-Agent' : 'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.102 Safari/537.36'}
proxies = { 'http' : '127.0.0.1:8118'}
response=requests.request('GET',url, timeout=20, proxies=proxies, headers=headers)
返回类型requests.Response
另：
#发送一个HEAD request.
requests.head(url, **kwargs)
#发送一个GET request
requests.get(url, params=None, **kwargs)
#发送一个POST request
requests.post(url, data=None, json=None, **kwargs)
#发送一个PUT request
requests.put(url, data=None, **kwargs)
#发送一个PATCH request
requests.patch(url, data=None, **kwargs)
#发送一个DELETE request
requests.delete(url, **kwargs)
更多详情请参考官网要求。
（三）Selenium + PhantomJs，高效处理动态网页的完美组合。
使用前面的方法我们可以简单的得到网页的html代码。如果我们遇到需要用JS渲染的网页内容，就会变得很麻烦。因此，我们需要一个可以像浏览器一样处理要被JS渲染的页面的工具，而PhantomJs是一个基于WebKit的无界面网页交互工具。它提供的JavaScript API可以实现自动浏览、截图等浏览器功能。Selenium 是一款自动化测试工具，支持火狐、Chrome、Safari 等主流浏览器。借助 selenium，可以模拟人类的各种网页操作行为，例如打开浏览器、输入信息、点击、翻页等。PhantomJS 作为没有界面的浏览器，Selenium 会不会感冒？答案很冷，因为 PhantomJs 不仅可以完成浏览器的功能，而且相对来说效率更高。例如：
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
phantomjs_path = '/data/opt/brew/lib/node_modules/phantomjs/lib/phantom/bin/phantomjs'
driver = webdriver.PhantomJS(executable_path=phantomjs_path)
url = 'xxxx'
driver.get(url)
#轻松得到到JS渲染页面的源码
page_source = driver.page_source.encode('utf8')
有时我们需要实现页面交互，即当我们可以在浏览器上模拟点击、输入、鼠标移动等各种行为时，首先需要定位页面元素。其中，WebDriver提供了多种实现元素定位的方法：
#定位一个元素的方法有
find_element_by_id
find_element_by_name
find_element_by_xpath
find_element_by_link_text
find_element_by_partial_link_text
find_element_by_tag_name
find_element_by_class_name
find_element_by_css_selector
#定位多元素，返回一个list，方法有
find_elements_by_name
find_elements_by_xpath
find_elements_by_link_text
find_elements_by_partial_link_text
find_elements_by_tag_name
find_elements_by_class_name
find_elements_by_css_selector
#例如有如下网页源码：
#form可以这样来定位
login_form = driver.find_element_by_id('loginForm')
#username&password两个元素定位如下
username = driver.find_element_by_name('username')
password = driver.find_element_by_name('password')
#如果使用xpath来定位username，以下方法都ok
username = driver.find_element_by_xpath("//form[input/@name='username']")
username = driver.find_element_by_xpath("//form[@id='loginForm']/input[1]")
username = driver.find_element_by_xpath("//input[@name='username']")
更多信息请参考 selenium_python, PhantomJS。
这篇文章简单介绍了获取网页源内容的各种方法，包括静态网页中经常使用的urllib、urllib2、requests和selenium、phantomjs的组合。在爬取过程中，我们经常需要提取和保留网页中的有用信息，所以接下来介绍如何从获取的网页源代码中提取有用信息。 查看全部
爬虫是我们快速获取所需数据的一种非常有效的方式，而爬虫的第一步就是请求远程服务器为我们返回所需的网页信息。我们知道，一般情况下，我们只需要输入正确的Uniform Resource Locator url，即网页地址，就可以在浏览器上轻松打开我们想看到的页面。同样，在设计python爬虫程序时，我们也可以通过参数设置调用相应的库连接网络处理http协议。对于静态网页，常用的库有urllib、urllib2、requests等，通过它们可以很方便的请求服务器返回特定地址的网页内容。但是，如果我们遇到 JS 加载的动态网页，使用以前的方法，我们经常无法收到我们想要的结果。这时候可以召唤强大的自动化测试工具Selenium，召唤它的好友PhantomJS，一起升级打怪。
(一） urllib, urllib2, 直接上例子：
import urllib2
response = urllib2.urlopen("http://www.baidu.com")
print response.read()
只要给一个url，比如百度，调用urllib2库，就可以单手阅读这个url对应的网页源码，代码非常简洁。在实际爬虫中，考虑到对方的反爬机制，网络响应时间或者发送请求需要添加额外的信息，我们需要多添加几行代码，目的是让服务器尽量相信收到的请求来自正常访问对象。为了程序逻辑的清晰，我们可以设计一个请求对象作为urlopen的传入参数，例如：
import urllib
import urllib2
#添加url
url = 'xxx'
request = urllib2.Request(url)
#为了模拟浏览器行为，伪装对方识别问题，可以添加Headers属性，例如下面的agent便是设置请求身份：
user_agent = 'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.102 Safari/537.36'
headers = { 'User-Agent' : user_agent}
request = urllib2.Request(url, headers)
#有时访问某些网站需要提供一些信息，例如用户名和密码，这时可以这样：
values = {"username":"yourname","password":"????"}
data = urllib.urlencode(values)
request = urllib2.Request(url, data, headers)
#在遇到网络状况不好时可以设置timeout来设置等待多久超时
response = urllib2.urlopen(request，timeout=18)
print response.read()
有关更多相关内容，请参阅此 urllib 和 urllib2。
（二）requests，一个简单、美观、友好的外部库。
请求的所有功能都可以通过以下7种方法访问。它们都返回响应对象的一个实例。
#创建并发送一个request
requests.request(method, url, **kwargs)
参数：
method -- method for the new Request object.
url -- URL for the new Request object.
params -- (optional) Dictionary or bytes to be sent in the query string for the Request.
data -- (optional) Dictionary, bytes, or file-like object to send in the body of the Request.
json -- (optional) json data to send in the body of the Request.
headers -- (optional) Dictionary of HTTP Headers to send with the Request.
cookies -- (optional) Dict or CookieJar object to send with the Request.
files -- (optional) Dictionary of 'name': file-like-objects (or {'name': file-tuple}) for multipart encoding upload. file-tuple can be a 2-tuple ('filename', fileobj), 3-tuple ('filename', fileobj, 'content_type') or a 4-tuple ('filename', fileobj, 'content_type', custom_headers), where 'content-type' is a string defining the content type of the given file and custom_headers a dict-like object containing additional headers to add for the file.
auth -- (optional) Auth tuple to enable Basic/Digest/Custom HTTP Auth.
timeout (float or tuple) -- (optional) How long to wait for the server to send data before giving up, as a float, or a (connect timeout, read timeout) tuple.
allow_redirects (bool) -- (optional) Boolean. Set to True if POST/PUT/DELETE redirect following is allowed.
proxies -- (optional) Dictionary mapping protocol to the URL of the proxy.
verify -- (optional) whether the SSL cert will be verified. A CA_BUNDLE path can also be provided. Defaults to True.
stream -- (optional) if False, the response content will be immediately downloaded.
cert -- (optional) if String, path to ssl client cert file (.pem). If Tuple, ('cert', 'key') pair.
#例如：
import requests
url='xxxx'
headers = {'User-Agent' : 'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.102 Safari/537.36'}
proxies = { 'http' : '127.0.0.1:8118'}
response=requests.request('GET',url, timeout=20, proxies=proxies, headers=headers)
返回类型requests.Response
另：
#发送一个HEAD request.
requests.head(url, **kwargs)
#发送一个GET request
requests.get(url, params=None, **kwargs)
#发送一个POST request
requests.post(url, data=None, json=None, **kwargs)
#发送一个PUT request
requests.put(url, data=None, **kwargs)
#发送一个PATCH request
requests.patch(url, data=None, **kwargs)
#发送一个DELETE request
requests.delete(url, **kwargs)
更多详情请参考官网要求。
（三）Selenium + PhantomJs，高效处理动态网页的完美组合。
使用前面的方法我们可以简单的得到网页的html代码。如果我们遇到需要用JS渲染的网页内容，就会变得很麻烦。因此，我们需要一个可以像浏览器一样处理要被JS渲染的页面的工具，而PhantomJs是一个基于WebKit的无界面网页交互工具。它提供的JavaScript API可以实现自动浏览、截图等浏览器功能。Selenium 是一款自动化测试工具，支持火狐、Chrome、Safari 等主流浏览器。借助 selenium，可以模拟人类的各种网页操作行为，例如打开浏览器、输入信息、点击、翻页等。PhantomJS 作为没有界面的浏览器，Selenium 会不会感冒？答案很冷，因为 PhantomJs 不仅可以完成浏览器的功能，而且相对来说效率更高。例如：
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
phantomjs_path = '/data/opt/brew/lib/node_modules/phantomjs/lib/phantom/bin/phantomjs'
driver = webdriver.PhantomJS(executable_path=phantomjs_path)
url = 'xxxx'
driver.get(url)
#轻松得到到JS渲染页面的源码
page_source = driver.page_source.encode('utf8')
有时我们需要实现页面交互，即当我们可以在浏览器上模拟点击、输入、鼠标移动等各种行为时，首先需要定位页面元素。其中，WebDriver提供了多种实现元素定位的方法：
#定位一个元素的方法有
find_element_by_id
find_element_by_name
find_element_by_xpath
find_element_by_link_text
find_element_by_partial_link_text
find_element_by_tag_name
find_element_by_class_name
find_element_by_css_selector
#定位多元素，返回一个list，方法有
find_elements_by_name
find_elements_by_xpath
find_elements_by_link_text
find_elements_by_partial_link_text
find_elements_by_tag_name
find_elements_by_class_name
find_elements_by_css_selector
#例如有如下网页源码：
#form可以这样来定位
login_form = driver.find_element_by_id('loginForm')
#username&password两个元素定位如下
username = driver.find_element_by_name('username')
password = driver.find_element_by_name('password')
#如果使用xpath来定位username，以下方法都ok
username = driver.find_element_by_xpath("//form[input/@name='username']")
username = driver.find_element_by_xpath("//form[@id='loginForm']/input[1]")
username = driver.find_element_by_xpath("//input[@name='username']")
更多信息请参考 selenium_python, PhantomJS。
这篇文章简单介绍了获取网页源内容的各种方法，包括静态网页中经常使用的urllib、urllib2、requests和selenium、phantomjs的组合。在爬取过程中，我们经常需要提取和保留网页中的有用信息，所以接下来介绍如何从获取的网页源代码中提取有用信息。 查看全部
python抓取动态网页(高效处理动态网页的完美组合——爬虫)
爬虫是我们快速获取所需数据的一种非常有效的方式，而爬虫的第一步就是请求远程服务器为我们返回所需的网页信息。我们知道，一般情况下，我们只需要输入正确的Uniform Resource Locator url，即网页地址，就可以在浏览器上轻松打开我们想看到的页面。同样，在设计python爬虫程序时，我们也可以通过参数设置调用相应的库连接网络处理http协议。对于静态网页，常用的库有urllib、urllib2、requests等，通过它们可以很方便的请求服务器返回特定地址的网页内容。但是，如果我们遇到 JS 加载的动态网页，使用以前的方法，我们经常无法收到我们想要的结果。这时候可以召唤强大的自动化测试工具Selenium，召唤它的好友PhantomJS，一起升级打怪。
(一） urllib, urllib2, 直接上例子：
import urllib2
response = urllib2.urlopen("http://www.baidu.com";)
print response.read()
只要给一个url，比如百度，调用urllib2库，就可以单手阅读这个url对应的网页源码，代码非常简洁。在实际爬虫中，考虑到对方的反爬机制，网络响应时间或者发送请求需要添加额外的信息，我们需要多添加几行代码，目的是让服务器尽量相信收到的请求来自正常访问对象。为了程序逻辑的清晰，我们可以设计一个请求对象作为urlopen的传入参数，例如：
import urllib
import urllib2
#添加url
url = 'xxx'
request = urllib2.Request(url)
#为了模拟浏览器行为，伪装对方识别问题，可以添加Headers属性，例如下面的agent便是设置请求身份：
user_agent = 'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.102 Safari/537.36'
headers = { 'User-Agent' : user_agent}
request = urllib2.Request(url, headers)
#有时访问某些网站需要提供一些信息，例如用户名和密码，这时可以这样：
values = {"username":"yourname","password":"????"}
data = urllib.urlencode(values)
request = urllib2.Request(url, data, headers)
#在遇到网络状况不好时可以设置timeout来设置等待多久超时
response = urllib2.urlopen(request，timeout=18)
print response.read()
有关更多相关内容，请参阅此 urllib 和 urllib2。
（二）requests，一个简单、美观、友好的外部库。
请求的所有功能都可以通过以下7种方法访问。它们都返回响应对象的一个实例。
#创建并发送一个request
requests.request(method, url, **kwargs)
参数：
method -- method for the new Request object.
url -- URL for the new Request object.
params -- (optional) Dictionary or bytes to be sent in the query string for the Request.
data -- (optional) Dictionary, bytes, or file-like object to send in the body of the Request.
json -- (optional) json data to send in the body of the Request.
headers -- (optional) Dictionary of HTTP Headers to send with the Request.
cookies -- (optional) Dict or CookieJar object to send with the Request.
files -- (optional) Dictionary of 'name': file-like-objects (or {'name': file-tuple}) for multipart encoding upload. file-tuple can be a 2-tuple ('filename', fileobj), 3-tuple ('filename', fileobj, 'content_type') or a 4-tuple ('filename', fileobj, 'content_type', custom_headers), where 'content-type' is a string defining the content type of the given file and custom_headers a dict-like object containing additional headers to add for the file.
auth -- (optional) Auth tuple to enable Basic/Digest/Custom HTTP Auth.
timeout (float or tuple) -- (optional) How long to wait for the server to send data before giving up, as a float, or a (connect timeout, read timeout) tuple.
allow_redirects (bool) -- (optional) Boolean. Set to True if POST/PUT/DELETE redirect following is allowed.
proxies -- (optional) Dictionary mapping protocol to the URL of the proxy.
verify -- (optional) whether the SSL cert will be verified. A CA_BUNDLE path can also be provided. Defaults to True.
stream -- (optional) if False, the response content will be immediately downloaded.
cert -- (optional) if String, path to ssl client cert file (.pem). If Tuple, ('cert', 'key') pair.
#例如：
import requests
url='xxxx'
headers = {'User-Agent' : 'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.102 Safari/537.36'}
proxies = { 'http' : '127.0.0.1:8118'}
response=requests.request('GET',url, timeout=20, proxies=proxies, headers=headers)
返回类型requests.Response
另：
#发送一个HEAD request.
requests.head(url, **kwargs)
#发送一个GET request
requests.get(url, params=None, **kwargs)
#发送一个POST request
requests.post(url, data=None, json=None, **kwargs)
#发送一个PUT request
requests.put(url, data=None, **kwargs)
#发送一个PATCH request
requests.patch(url, data=None, **kwargs)
#发送一个DELETE request
requests.delete(url, **kwargs)
更多详情请参考官网要求。
（三）Selenium + PhantomJs，高效处理动态网页的完美组合。
使用前面的方法我们可以简单的得到网页的html代码。如果我们遇到需要用JS渲染的网页内容，就会变得很麻烦。因此，我们需要一个可以像浏览器一样处理要被JS渲染的页面的工具，而PhantomJs是一个基于WebKit的无界面网页交互工具。它提供的JavaScript API可以实现自动浏览、截图等浏览器功能。Selenium 是一款自动化测试工具，支持火狐、Chrome、Safari 等主流浏览器。借助 selenium，可以模拟人类的各种网页操作行为，例如打开浏览器、输入信息、点击、翻页等。PhantomJS 作为没有界面的浏览器，Selenium 会不会感冒？答案很冷，因为 PhantomJs 不仅可以完成浏览器的功能，而且相对来说效率更高。例如：
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
phantomjs_path = '/data/opt/brew/lib/node_modules/phantomjs/lib/phantom/bin/phantomjs'
driver = webdriver.PhantomJS(executable_path=phantomjs_path)
url = 'xxxx'
driver.get(url)
#轻松得到到JS渲染页面的源码
page_source = driver.page_source.encode('utf8')
有时我们需要实现页面交互，即当我们可以在浏览器上模拟点击、输入、鼠标移动等各种行为时，首先需要定位页面元素。其中，WebDriver提供了多种实现元素定位的方法：
#定位一个元素的方法有
find_element_by_id
find_element_by_name
find_element_by_xpath
find_element_by_link_text
find_element_by_partial_link_text
find_element_by_tag_name
find_element_by_class_name
find_element_by_css_selector
#定位多元素，返回一个list，方法有
find_elements_by_name
find_elements_by_xpath
find_elements_by_link_text
find_elements_by_partial_link_text
find_elements_by_tag_name
find_elements_by_class_name
find_elements_by_css_selector
#例如有如下网页源码：
#form可以这样来定位
login_form = driver.find_element_by_id('loginForm')
#username&password两个元素定位如下
username = driver.find_element_by_name('username')
password = driver.find_element_by_name('password')
#如果使用xpath来定位username，以下方法都ok
username = driver.find_element_by_xpath("//form[input/@name='username']")
username = driver.find_element_by_xpath("//form[@id='loginForm']/input[1]")
username = driver.find_element_by_xpath("//input[@name='username']")
更多信息请参考 selenium_python, PhantomJS。
这篇文章简单介绍了获取网页源内容的各种方法，包括静态网页中经常使用的urllib、urllib2、requests和selenium、phantomjs的组合。在爬取过程中，我们经常需要提取和保留网页中的有用信息，所以接下来介绍如何从获取的网页源代码中提取有用信息。
python抓取动态网页(Python确是最常用的，你知道为什么吗？-天启)
网站优化 • 优采云 发表了文章 • 0 个评论 • 34 次浏览 • 2022-03-31 15:16
python抓取动态网页(Python确是最常用的，你知道为什么吗？-天启)
说起网络爬虫，相信大家都不陌生。爬虫可以捕获 网站 或应用程序的内容以提取有用的有价值信息。有很多编程语言可以用来实现爬虫，但是Python是最常用的，你知道为什么吗？一起来看看Apocalypse HTTP吧~
与C相比，Python和C Python的语言虽然是从C发展而来的，但是在使用中，Python的库是完整方便的，而C的语言就麻烦很多了。要实现同样的功能，Python 只需要 10 行代码，而 C 语言可能需要 100 行甚至更多。但是，在运行速度方面，C语言更好。
与Java相比，Java的解析器多，对网页解析的支持非常好。Java也有爬虫的相关库，但没有Python多。但是，就爬虫的效果而言，Java和Python都可以做到，只是工程量不同，实现方式也不同。如果需要处理复杂的网页、解析网页内容生成结构化数据或精细解析网页内容，java 更适合。
Python与其他语言没有本质区别，比Python语法简洁明了，开发效率高。此外，python语言的流行还有几个原因：
1.网页抓取界面简洁；
与其他动态脚本语言相比，Python 提供了更完善的访问 Web 文档的 API；与其他静态编程语言相比，Python 爬取网页文档的界面更加简洁。
2.强大的第三方库
另外，爬取网页有时需要模拟浏览器的行为，很多网站被屏蔽用于生硬的爬虫爬取。这时候我们就需要模拟User Agent的行为来构造合适的请求，比如模拟用户登录，模拟Session/Cookie的存储和设置。Python 中有一些优秀的第三方包可以为你做这件事，例如 Requests 或 Mechanize。
3.数据处理快捷方便
抓取的网页通常需要进行处理，例如过滤Html标签、提取文本等。Python的Beautiful Soup提供了简洁的文档处理功能，可以用极短的代码完成大部分文档处理。其实很多语言和工具都可以做到以上功能，但是Python可以做到最快最干净。
高效爬虫除了使用开发效率高的编程语言外，还需要代理IP的协助。天启HTTP提供优质爬虫IP、高度匿名资源、全国海量IP，帮助企业高效爬取数据。 查看全部
说起网络爬虫，相信大家都不陌生。爬虫可以捕获 网站 或应用程序的内容以提取有用的有价值信息。有很多编程语言可以用来实现爬虫，但是Python是最常用的，你知道为什么吗？一起来看看Apocalypse HTTP吧~
与C相比，Python和C Python的语言虽然是从C发展而来的，但是在使用中，Python的库是完整方便的，而C的语言就麻烦很多了。要实现同样的功能，Python 只需要 10 行代码，而 C 语言可能需要 100 行甚至更多。但是，在运行速度方面，C语言更好。
与Java相比，Java的解析器多，对网页解析的支持非常好。Java也有爬虫的相关库，但没有Python多。但是，就爬虫的效果而言，Java和Python都可以做到，只是工程量不同，实现方式也不同。如果需要处理复杂的网页、解析网页内容生成结构化数据或精细解析网页内容，java 更适合。
Python与其他语言没有本质区别，比Python语法简洁明了，开发效率高。此外，python语言的流行还有几个原因：
1.网页抓取界面简洁；
与其他动态脚本语言相比，Python 提供了更完善的访问 Web 文档的 API；与其他静态编程语言相比，Python 爬取网页文档的界面更加简洁。
2.强大的第三方库
另外，爬取网页有时需要模拟浏览器的行为，很多网站被屏蔽用于生硬的爬虫爬取。这时候我们就需要模拟User Agent的行为来构造合适的请求，比如模拟用户登录，模拟Session/Cookie的存储和设置。Python 中有一些优秀的第三方包可以为你做这件事，例如 Requests 或 Mechanize。
3.数据处理快捷方便
抓取的网页通常需要进行处理，例如过滤Html标签、提取文本等。Python的Beautiful Soup提供了简洁的文档处理功能，可以用极短的代码完成大部分文档处理。其实很多语言和工具都可以做到以上功能，但是Python可以做到最快最干净。
高效爬虫除了使用开发效率高的编程语言外，还需要代理IP的协助。天启HTTP提供优质爬虫IP、高度匿名资源、全国海量IP，帮助企业高效爬取数据。 查看全部
python抓取动态网页(Python确是最常用的，你知道为什么吗？-天启)
说起网络爬虫，相信大家都不陌生。爬虫可以捕获 网站 或应用程序的内容以提取有用的有价值信息。有很多编程语言可以用来实现爬虫，但是Python是最常用的，你知道为什么吗？一起来看看Apocalypse HTTP吧~
与C相比，Python和C Python的语言虽然是从C发展而来的，但是在使用中，Python的库是完整方便的，而C的语言就麻烦很多了。要实现同样的功能，Python 只需要 10 行代码，而 C 语言可能需要 100 行甚至更多。但是，在运行速度方面，C语言更好。
与Java相比，Java的解析器多，对网页解析的支持非常好。Java也有爬虫的相关库，但没有Python多。但是，就爬虫的效果而言，Java和Python都可以做到，只是工程量不同，实现方式也不同。如果需要处理复杂的网页、解析网页内容生成结构化数据或精细解析网页内容，java 更适合。
Python与其他语言没有本质区别，比Python语法简洁明了，开发效率高。此外，python语言的流行还有几个原因：
1.网页抓取界面简洁；
与其他动态脚本语言相比，Python 提供了更完善的访问 Web 文档的 API；与其他静态编程语言相比，Python 爬取网页文档的界面更加简洁。
2.强大的第三方库
另外，爬取网页有时需要模拟浏览器的行为，很多网站被屏蔽用于生硬的爬虫爬取。这时候我们就需要模拟User Agent的行为来构造合适的请求，比如模拟用户登录，模拟Session/Cookie的存储和设置。Python 中有一些优秀的第三方包可以为你做这件事，例如 Requests 或 Mechanize。
3.数据处理快捷方便
抓取的网页通常需要进行处理，例如过滤Html标签、提取文本等。Python的Beautiful Soup提供了简洁的文档处理功能，可以用极短的代码完成大部分文档处理。其实很多语言和工具都可以做到以上功能，但是Python可以做到最快最干净。
高效爬虫除了使用开发效率高的编程语言外，还需要代理IP的协助。天启HTTP提供优质爬虫IP、高度匿名资源、全国海量IP，帮助企业高效爬取数据。
python抓取动态网页(Python学习群：审查网页元素与网页源码是什么？)
网站优化 • 优采云 发表了文章 • 0 个评论 • 31 次浏览 • 2022-03-25 11:23
python抓取动态网页(Python学习群：审查网页元素与网页源码是什么？)
简要地
下面的代码是一个用python实现的网络爬虫，用于爬取动态网页。此页面上最新、最好的内容是由 JavaScript 动态生成的。审查网页元素与网页源代码不同。
我创建了一个Python学习的小学习圈，为大家提供了一个共同讨论学习Python的平台。欢迎来到Python学习群：960410445，一起讨论视频分享学习。Python是未来的发展方向，它正在挑战我们的分析能力和对世界的认知方式。因此，我们必须与时俱进，迎接变化，不断发展壮大。掌握核心Python技术才是掌握真正的价值。
以上是网页的源代码
以上是评论页面元素
所以这里不能简单的使用正则表达式来获取内容。
以下是获取内容并存入数据库的完整思路和源码。
实施思路：
抓取实际访问的动态页面的url——使用正则表达式获取你需要的内容——解析内容——存储内容
上述部分流程以文字说明：
抓取实际访问过的动态页面的url：
在火狐浏览器中，右键打开插件，使用**firebug review element** *（如果没有这个需要安装firebug插件），找到并打开**Network (NET)* * 标签。重新加载网页，获取网页的响应信息，包括连接地址。每个连接地址都可以在浏览器中打开。这个网站的动态网页访问地址是：
源代码
注意：使用python的版本是2.7 查看全部
简要地
下面的代码是一个用python实现的网络爬虫，用于爬取动态网页。此页面上最新、最好的内容是由 JavaScript 动态生成的。审查网页元素与网页源代码不同。
我创建了一个Python学习的小学习圈，为大家提供了一个共同讨论学习Python的平台。欢迎来到Python学习群：960410445，一起讨论视频分享学习。Python是未来的发展方向，它正在挑战我们的分析能力和对世界的认知方式。因此，我们必须与时俱进，迎接变化，不断发展壮大。掌握核心Python技术才是掌握真正的价值。
以上是网页的源代码
以上是评论页面元素
所以这里不能简单的使用正则表达式来获取内容。
以下是获取内容并存入数据库的完整思路和源码。
实施思路：
抓取实际访问的动态页面的url——使用正则表达式获取你需要的内容——解析内容——存储内容
上述部分流程以文字说明：
抓取实际访问过的动态页面的url：
在火狐浏览器中，右键打开插件，使用**firebug review element** *（如果没有这个需要安装firebug插件），找到并打开**Network (NET)* * 标签。重新加载网页，获取网页的响应信息，包括连接地址。每个连接地址都可以在浏览器中打开。这个网站的动态网页访问地址是：
源代码
注意：使用python的版本是2.7 查看全部
python抓取动态网页(Python学习群：审查网页元素与网页源码是什么？)
简要地
下面的代码是一个用python实现的网络爬虫，用于爬取动态网页。此页面上最新、最好的内容是由 JavaScript 动态生成的。审查网页元素与网页源代码不同。
我创建了一个Python学习的小学习圈，为大家提供了一个共同讨论学习Python的平台。欢迎来到Python学习群：960410445，一起讨论视频分享学习。Python是未来的发展方向，它正在挑战我们的分析能力和对世界的认知方式。因此，我们必须与时俱进，迎接变化，不断发展壮大。掌握核心Python技术才是掌握真正的价值。
以上是网页的源代码
以上是评论页面元素
所以这里不能简单的使用正则表达式来获取内容。
以下是获取内容并存入数据库的完整思路和源码。
实施思路：
抓取实际访问的动态页面的url——使用正则表达式获取你需要的内容——解析内容——存储内容
上述部分流程以文字说明：
抓取实际访问过的动态页面的url：
在火狐浏览器中，右键打开插件，使用**firebug review element** *（如果没有这个需要安装firebug插件），找到并打开**Network (NET)* * 标签。重新加载网页，获取网页的响应信息，包括连接地址。每个连接地址都可以在浏览器中打开。这个网站的动态网页访问地址是：
源代码
注意：使用python的版本是2.7
python抓取动态网页(JavaScript逆向工程如何从网络API中获取JSON格式的数据)
网站优化 • 优采云 发表了文章 • 0 个评论 • 45 次浏览 • 2022-03-24 11:00
python抓取动态网页(JavaScript逆向工程如何从网络API中获取JSON格式的数据)
解析动态内容
根据权威机构发布的《全球互联网无障碍审计报告》，全球约四分之三的网站内容或部分内容是通过JavaScript动态生成的，这意味着“以一种在HTML代码中找不到浏览器窗口“源代码”，说明我们以前抓取数据的方式并不能正常工作。解决这样的问题基本上有两种方案，一种是JavaScript逆向工程；另一种是渲染 JavaScript 以获取渲染的内容。
JavaScript 逆向工程
我们以“360图片”网站为例来说明什么是JavaScript逆向工程。其实所谓JavaScript逆向工程就是通过Ajax技术找到动态获取数据的接口。在浏览器中输入打开“360图片”的“美颜”板块，如下图所示。
[外链图片传输失败(img-ZRl9xYmn-75)(./res/image360-website.png)]
但是当我们在浏览器中使用右键菜单“显示网页的源代码”时，我们惊奇地发现页面的HTML代码中有一个链接。
没有标签，那么我们看到的图片是怎么出现的呢？原来所有的图片都是通过JavaScript动态加载的，在浏览器“开发者工具”的“网络”中可以找到获取这些图片数据的web API接口，如下图所示。
[外链图片传输失败(img-XVAx1JK3-78)(./res/api-image360.png)]
那么结论就很简单了。只要找到这些网络API接口，就可以通过这些接口获取数据。当然，在实际开发中，我们可能还需要对这些接口的参数和接口返回的数据进行分析，以了解各个参数的含义以及返回的 JSON 数据的格式，以便我们可以在我们的爬虫。
如何从网络API中获取JSON格式的数据，提取出我们需要的内容，在上一篇《文件与异常》中已经说明，这里不再赘述。
使用硒
虽然很多网站保护了自己的网络API接口，增加了获取数据的难度，但大部分只要努力够就可以进行逆向工程，但是在实际开发中，我们可以通过浏览器渲染引擎来避免这些繁琐的工作，WebKit 是一个利用的渲染引擎。
WebKit 的代码始于 1998 年的 KHTML 项目，当时它是 Konqueror 浏览器的渲染引擎。2001 年，Apple 从这个项目的代码中衍生出 WebKit，并将其应用到 Safari 浏览器中，早期的 Chrome 浏览器也使用了内核。在 Python 中，我们可以通过 Qt 框架获取 WebKit 引擎，并使用它来渲染页面以获取动态内容。此内容请阅读文章《爬虫技术：动态页面爬取超级指南》。
如果你不打算使用上面的方法来渲染页面并获取动态内容，其实还有一种替代方法可以使用自动化测试工具 Selenium，它提供了浏览器自动化的 API 接口，这样你就可以通过操纵浏览器。内容。首先，您可以使用 pip 安装 Selenium。
pip3 install selenium
下面以“阿里巴巴V任务”的“直播服务”为例，演示如何使用Selenium获取动态内容和抓拍主播的画面。
import requests
from bs4 import BeautifulSoup
def main():
resp = requests.get('https://v.taobao.com/v/content/live?catetype=704&from=taonvlang')
soup = BeautifulSoup(resp.text, 'lxml')
for img_tag in soup.select('img[src]'):
print(img_tag.attrs['src'])
if __name__ == '__main__':
main()
运行上面的程序会发现没有输出，因为页面的html代码根本找不到
标签。接下来，我们使用 Selenium 来获取页面上的动态内容，然后提取锚点图像。
from bs4 import BeautifulSoup
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
def main():
driver = webdriver.Chrome()
driver.get('https://v.taobao.com/v/content/live?catetype=704&from=taonvlang')
soup = BeautifulSoup(driver.page_source, 'lxml')
for img_tag in soup.body.select('img[src]'):
print(img_tag.attrs['src'])
if __name__ == '__main__':
main()
在上面的程序中，我们使用 Selenium 来控制 Chrome 浏览器。如果我们要控制其他浏览器，可以创建相应的浏览器对象，比如Firefox、IE等。运行上面的程序，如果看到下图的错误信息，说明我们没有添加Chrome浏览器驱动PATH环境变量，我们也没有在程序中指定Chrome浏览器驱动的位置。
selenium.common.exceptions.WebDriverException: Message: 'chromedriver' executable needs to be in PATH. Please see https://sites.google.com/a/chr ... /home
为了解决以上问题，可以到Selenium的官方网站找到浏览器驱动的下载链接，下载需要的驱动。在 Linux 或 macOS 系统中，可以通过以下命令设置 PATH 环境变量，在 Windows 下配置环境变量也很简单，不清楚的可以自行理解。
export PATH=$PATH:/Users/Hao/Downloads/Tools/chromedriver/
其中/Users/Hao/Downloads/Tools/chromedriver/是chromedriver所在的路径。 查看全部
解析动态内容
根据权威机构发布的《全球互联网无障碍审计报告》，全球约四分之三的网站内容或部分内容是通过JavaScript动态生成的，这意味着“以一种在HTML代码中找不到浏览器窗口“源代码”，说明我们以前抓取数据的方式并不能正常工作。解决这样的问题基本上有两种方案，一种是JavaScript逆向工程；另一种是渲染 JavaScript 以获取渲染的内容。
JavaScript 逆向工程
我们以“360图片”网站为例来说明什么是JavaScript逆向工程。其实所谓JavaScript逆向工程就是通过Ajax技术找到动态获取数据的接口。在浏览器中输入打开“360图片”的“美颜”板块，如下图所示。
[外链图片传输失败(img-ZRl9xYmn-75)(./res/image360-website.png)]
但是当我们在浏览器中使用右键菜单“显示网页的源代码”时，我们惊奇地发现页面的HTML代码中有一个链接。
没有标签，那么我们看到的图片是怎么出现的呢？原来所有的图片都是通过JavaScript动态加载的，在浏览器“开发者工具”的“网络”中可以找到获取这些图片数据的web API接口，如下图所示。
[外链图片传输失败(img-XVAx1JK3-78)(./res/api-image360.png)]
那么结论就很简单了。只要找到这些网络API接口，就可以通过这些接口获取数据。当然，在实际开发中，我们可能还需要对这些接口的参数和接口返回的数据进行分析，以了解各个参数的含义以及返回的 JSON 数据的格式，以便我们可以在我们的爬虫。
如何从网络API中获取JSON格式的数据，提取出我们需要的内容，在上一篇《文件与异常》中已经说明，这里不再赘述。
使用硒
虽然很多网站保护了自己的网络API接口，增加了获取数据的难度，但大部分只要努力够就可以进行逆向工程，但是在实际开发中，我们可以通过浏览器渲染引擎来避免这些繁琐的工作，WebKit 是一个利用的渲染引擎。
WebKit 的代码始于 1998 年的 KHTML 项目，当时它是 Konqueror 浏览器的渲染引擎。2001 年，Apple 从这个项目的代码中衍生出 WebKit，并将其应用到 Safari 浏览器中，早期的 Chrome 浏览器也使用了内核。在 Python 中，我们可以通过 Qt 框架获取 WebKit 引擎，并使用它来渲染页面以获取动态内容。此内容请阅读文章《爬虫技术：动态页面爬取超级指南》。
如果你不打算使用上面的方法来渲染页面并获取动态内容，其实还有一种替代方法可以使用自动化测试工具 Selenium，它提供了浏览器自动化的 API 接口，这样你就可以通过操纵浏览器。内容。首先，您可以使用 pip 安装 Selenium。
pip3 install selenium
下面以“阿里巴巴V任务”的“直播服务”为例，演示如何使用Selenium获取动态内容和抓拍主播的画面。
import requests
from bs4 import BeautifulSoup
def main():
resp = requests.get('https://v.taobao.com/v/content/live?catetype=704&from=taonvlang')
soup = BeautifulSoup(resp.text, 'lxml')
for img_tag in soup.select('img[src]'):
print(img_tag.attrs['src'])
if __name__ == '__main__':
main()
运行上面的程序会发现没有输出，因为页面的html代码根本找不到
标签。接下来，我们使用 Selenium 来获取页面上的动态内容，然后提取锚点图像。
from bs4 import BeautifulSoup
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
def main():
driver = webdriver.Chrome()
driver.get('https://v.taobao.com/v/content/live?catetype=704&from=taonvlang')
soup = BeautifulSoup(driver.page_source, 'lxml')
for img_tag in soup.body.select('img[src]'):
print(img_tag.attrs['src'])
if __name__ == '__main__':
main()
在上面的程序中，我们使用 Selenium 来控制 Chrome 浏览器。如果我们要控制其他浏览器，可以创建相应的浏览器对象，比如Firefox、IE等。运行上面的程序，如果看到下图的错误信息，说明我们没有添加Chrome浏览器驱动PATH环境变量，我们也没有在程序中指定Chrome浏览器驱动的位置。
selenium.common.exceptions.WebDriverException: Message: 'chromedriver' executable needs to be in PATH. Please see https://sites.google.com/a/chr ... /home
为了解决以上问题，可以到Selenium的官方网站找到浏览器驱动的下载链接，下载需要的驱动。在 Linux 或 macOS 系统中，可以通过以下命令设置 PATH 环境变量，在 Windows 下配置环境变量也很简单，不清楚的可以自行理解。
export PATH=$PATH:/Users/Hao/Downloads/Tools/chromedriver/
其中/Users/Hao/Downloads/Tools/chromedriver/是chromedriver所在的路径。 查看全部
python抓取动态网页(JavaScript逆向工程如何从网络API中获取JSON格式的数据)
解析动态内容
根据权威机构发布的《全球互联网无障碍审计报告》，全球约四分之三的网站内容或部分内容是通过JavaScript动态生成的，这意味着“以一种在HTML代码中找不到浏览器窗口“源代码”，说明我们以前抓取数据的方式并不能正常工作。解决这样的问题基本上有两种方案，一种是JavaScript逆向工程；另一种是渲染 JavaScript 以获取渲染的内容。
JavaScript 逆向工程
我们以“360图片”网站为例来说明什么是JavaScript逆向工程。其实所谓JavaScript逆向工程就是通过Ajax技术找到动态获取数据的接口。在浏览器中输入打开“360图片”的“美颜”板块，如下图所示。
[外链图片传输失败(img-ZRl9xYmn-75)(./res/image360-website.png)]
但是当我们在浏览器中使用右键菜单“显示网页的源代码”时，我们惊奇地发现页面的HTML代码中有一个链接。
没有标签，那么我们看到的图片是怎么出现的呢？原来所有的图片都是通过JavaScript动态加载的，在浏览器“开发者工具”的“网络”中可以找到获取这些图片数据的web API接口，如下图所示。
[外链图片传输失败(img-XVAx1JK3-78)(./res/api-image360.png)]
那么结论就很简单了。只要找到这些网络API接口，就可以通过这些接口获取数据。当然，在实际开发中，我们可能还需要对这些接口的参数和接口返回的数据进行分析，以了解各个参数的含义以及返回的 JSON 数据的格式，以便我们可以在我们的爬虫。
如何从网络API中获取JSON格式的数据，提取出我们需要的内容，在上一篇《文件与异常》中已经说明，这里不再赘述。
使用硒
虽然很多网站保护了自己的网络API接口，增加了获取数据的难度，但大部分只要努力够就可以进行逆向工程，但是在实际开发中，我们可以通过浏览器渲染引擎来避免这些繁琐的工作，WebKit 是一个利用的渲染引擎。
WebKit 的代码始于 1998 年的 KHTML 项目，当时它是 Konqueror 浏览器的渲染引擎。2001 年，Apple 从这个项目的代码中衍生出 WebKit，并将其应用到 Safari 浏览器中，早期的 Chrome 浏览器也使用了内核。在 Python 中，我们可以通过 Qt 框架获取 WebKit 引擎，并使用它来渲染页面以获取动态内容。此内容请阅读文章《爬虫技术：动态页面爬取超级指南》。
如果你不打算使用上面的方法来渲染页面并获取动态内容，其实还有一种替代方法可以使用自动化测试工具 Selenium，它提供了浏览器自动化的 API 接口，这样你就可以通过操纵浏览器。内容。首先，您可以使用 pip 安装 Selenium。
pip3 install selenium
下面以“阿里巴巴V任务”的“直播服务”为例，演示如何使用Selenium获取动态内容和抓拍主播的画面。
import requests
from bs4 import BeautifulSoup
def main():
resp = requests.get('https://v.taobao.com/v/content/live?catetype=704&from=taonvlang')
soup = BeautifulSoup(resp.text, 'lxml')
for img_tag in soup.select('img[src]'):
print(img_tag.attrs['src'])
if __name__ == '__main__':
main()
运行上面的程序会发现没有输出，因为页面的html代码根本找不到
标签。接下来，我们使用 Selenium 来获取页面上的动态内容，然后提取锚点图像。
from bs4 import BeautifulSoup
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
def main():
driver = webdriver.Chrome()
driver.get('https://v.taobao.com/v/content/live?catetype=704&from=taonvlang')
soup = BeautifulSoup(driver.page_source, 'lxml')
for img_tag in soup.body.select('img[src]'):
print(img_tag.attrs['src'])
if __name__ == '__main__':
main()
在上面的程序中，我们使用 Selenium 来控制 Chrome 浏览器。如果我们要控制其他浏览器，可以创建相应的浏览器对象，比如Firefox、IE等。运行上面的程序，如果看到下图的错误信息，说明我们没有添加Chrome浏览器驱动PATH环境变量，我们也没有在程序中指定Chrome浏览器驱动的位置。
selenium.common.exceptions.WebDriverException: Message: 'chromedriver' executable needs to be in PATH. Please see https://sites.google.com/a/chr ... /home
为了解决以上问题，可以到Selenium的官方网站找到浏览器驱动的下载链接，下载需要的驱动。在 Linux 或 macOS 系统中，可以通过以下命令设置 PATH 环境变量，在 Windows 下配置环境变量也很简单，不清楚的可以自行理解。
export PATH=$PATH:/Users/Hao/Downloads/Tools/chromedriver/
其中/Users/Hao/Downloads/Tools/chromedriver/是chromedriver所在的路径。
python抓取动态网页(利用selenium的子模块webdriver的html内容解决的问题)
网站优化 • 优采云 发表了文章 • 0 个评论 • 62 次浏览 • 2022-03-24 10:15
python抓取动态网页(利用selenium的子模块webdriver的html内容解决的问题)
文章目的
我们在使用Python爬取网页数据时，经常会用到urllib模块，它通过调用urllib模块的urlopen(url)方法返回网页对象，并使用read()方法获取url的html内容，然后使用 BeautifulSoup 抓取某个 Tag 内容，结合正则表达式过滤。但是，使用 urllib.urlopen(url).read() 得到的只是网页的静态 html 内容。很多动态数据（如网站访问者数、当前在线人数、微博点赞数等）收录在静态html中，比如我要抓取当前在线人数本bbs网站中的每一部分，不收录静态html页面（不信你尝试查看页面源代码，只有简单的一行）。
解决方案
我试过网上说的浏览器自带的开发者工具（一般是F12弹出对应网页的开发者工具），查网络获取动态数据的走势，但这需要多方寻找线索网址。我个人觉得太麻烦了。另外，用查看器查看的html内容也收录动态数据，但是有几个问题：如何实时获取查看器的html内容？如何将查看器的html导入python程序？因此，使用查看器的html内容的方法也不符合爬虫的要求。
偶然发现了selenium模块，发现这个模块可以很方便的根据url加载页面获取session，并找到当前session对应的label。本文将使用 selenium webdriver 模块来获取这些动态生成的内容，尤其是一些重要的动态数据。事实上，selenium 模块的功能并不仅限于爬取网页。它是网络自动化测试的常用模块。它广泛用于 Ruby 和 Java。虽然 Python 用的比较少，但它也是一个非常简单、高效、好用的自动化测试。模块。通过使用selenium的子模块webdriver解决动态数据的抓取问题，也可以对selenium有一个基本的了解，为进一步学习自动化测试打下基础。
实施流程操作环境
我在Windows 7系统上安装了Python 2.7版本，使用Python(X,Y) IDE，安装的Python库没有自带selenium，直接在Python程序中导入selenium会提示有没有这个模块，联网状态下，cmd直接进入pip install selenium，系统会找到Python安装目录直接下载、解压安装这个模块。终端提示完成后，可以查看C:\Python27\Lib\site-packages目录下是否有selenium模块。此目录取决于您安装 Python 的路径。如果有 selenium 和 selenium-2.47.3.dist-info 文件夹，则表示可以在 Python 程序中加载该模块。
使用 webdriver 抓取动态数据
1.先导入webdriver子模块
从硒导入网络驱动程序
2.获取浏览器的会话。浏览器可以使用 Firefox、Chrome、IE 等。这里我们以火狐为例
浏览器 = webdriver.Firefox()
3.加载页面，url本身可以指定合法字符串
浏览器.get(url)
4.获取到session对象后，定位元素，webdriver提供了一系列元素定位方法，常用的有以下几种方式：
ID
姓名
班级名称
关联
文本
部分的
关联
文本
标签
姓名
路径
选择器
比如通过id定位，返回所有元素的列表，lis=borwser.find_elements_by_id_name('kw'')
按类名定位，lis=find_elements_by_class_name('title_1')
更详细的定位方法请参考大神《博客园-昆虫大师》的selenium webdriver（python）教程第三章-定位方法部分（第一版可百度文库阅读，第二版）版将从头开始收费>- 查看全部
文章目的
我们在使用Python爬取网页数据时，经常会用到urllib模块，它通过调用urllib模块的urlopen(url)方法返回网页对象，并使用read()方法获取url的html内容，然后使用 BeautifulSoup 抓取某个 Tag 内容，结合正则表达式过滤。但是，使用 urllib.urlopen(url).read() 得到的只是网页的静态 html 内容。很多动态数据（如网站访问者数、当前在线人数、微博点赞数等）收录在静态html中，比如我要抓取当前在线人数本bbs网站中的每一部分，不收录静态html页面（不信你尝试查看页面源代码，只有简单的一行）。
解决方案
我试过网上说的浏览器自带的开发者工具（一般是F12弹出对应网页的开发者工具），查网络获取动态数据的走势，但这需要多方寻找线索网址。我个人觉得太麻烦了。另外，用查看器查看的html内容也收录动态数据，但是有几个问题：如何实时获取查看器的html内容？如何将查看器的html导入python程序？因此，使用查看器的html内容的方法也不符合爬虫的要求。
偶然发现了selenium模块，发现这个模块可以很方便的根据url加载页面获取session，并找到当前session对应的label。本文将使用 selenium webdriver 模块来获取这些动态生成的内容，尤其是一些重要的动态数据。事实上，selenium 模块的功能并不仅限于爬取网页。它是网络自动化测试的常用模块。它广泛用于 Ruby 和 Java。虽然 Python 用的比较少，但它也是一个非常简单、高效、好用的自动化测试。模块。通过使用selenium的子模块webdriver解决动态数据的抓取问题，也可以对selenium有一个基本的了解，为进一步学习自动化测试打下基础。
实施流程操作环境
我在Windows 7系统上安装了Python 2.7版本，使用Python(X,Y) IDE，安装的Python库没有自带selenium，直接在Python程序中导入selenium会提示有没有这个模块，联网状态下，cmd直接进入pip install selenium，系统会找到Python安装目录直接下载、解压安装这个模块。终端提示完成后，可以查看C:\Python27\Lib\site-packages目录下是否有selenium模块。此目录取决于您安装 Python 的路径。如果有 selenium 和 selenium-2.47.3.dist-info 文件夹，则表示可以在 Python 程序中加载该模块。
使用 webdriver 抓取动态数据
1.先导入webdriver子模块
从硒导入网络驱动程序
2.获取浏览器的会话。浏览器可以使用 Firefox、Chrome、IE 等。这里我们以火狐为例
浏览器 = webdriver.Firefox()
3.加载页面，url本身可以指定合法字符串
浏览器.get(url)
4.获取到session对象后，定位元素，webdriver提供了一系列元素定位方法，常用的有以下几种方式：
ID
姓名
班级名称
关联
文本
部分的
关联
文本
标签
姓名
路径
选择器
比如通过id定位，返回所有元素的列表，lis=borwser.find_elements_by_id_name('kw'')
按类名定位，lis=find_elements_by_class_name('title_1')
更详细的定位方法请参考大神《博客园-昆虫大师》的selenium webdriver（python）教程第三章-定位方法部分（第一版可百度文库阅读，第二版）版将从头开始收费>- 查看全部
python抓取动态网页(利用selenium的子模块webdriver的html内容解决的问题)
文章目的
我们在使用Python爬取网页数据时，经常会用到urllib模块，它通过调用urllib模块的urlopen(url)方法返回网页对象，并使用read()方法获取url的html内容，然后使用 BeautifulSoup 抓取某个 Tag 内容，结合正则表达式过滤。但是，使用 urllib.urlopen(url).read() 得到的只是网页的静态 html 内容。很多动态数据（如网站访问者数、当前在线人数、微博点赞数等）收录在静态html中，比如我要抓取当前在线人数本bbs网站中的每一部分，不收录静态html页面（不信你尝试查看页面源代码，只有简单的一行）。
解决方案
我试过网上说的浏览器自带的开发者工具（一般是F12弹出对应网页的开发者工具），查网络获取动态数据的走势，但这需要多方寻找线索网址。我个人觉得太麻烦了。另外，用查看器查看的html内容也收录动态数据，但是有几个问题：如何实时获取查看器的html内容？如何将查看器的html导入python程序？因此，使用查看器的html内容的方法也不符合爬虫的要求。
偶然发现了selenium模块，发现这个模块可以很方便的根据url加载页面获取session，并找到当前session对应的label。本文将使用 selenium webdriver 模块来获取这些动态生成的内容，尤其是一些重要的动态数据。事实上，selenium 模块的功能并不仅限于爬取网页。它是网络自动化测试的常用模块。它广泛用于 Ruby 和 Java。虽然 Python 用的比较少，但它也是一个非常简单、高效、好用的自动化测试。模块。通过使用selenium的子模块webdriver解决动态数据的抓取问题，也可以对selenium有一个基本的了解，为进一步学习自动化测试打下基础。
实施流程操作环境
我在Windows 7系统上安装了Python 2.7版本，使用Python(X,Y) IDE，安装的Python库没有自带selenium，直接在Python程序中导入selenium会提示有没有这个模块，联网状态下，cmd直接进入pip install selenium，系统会找到Python安装目录直接下载、解压安装这个模块。终端提示完成后，可以查看C:\Python27\Lib\site-packages目录下是否有selenium模块。此目录取决于您安装 Python 的路径。如果有 selenium 和 selenium-2.47.3.dist-info 文件夹，则表示可以在 Python 程序中加载该模块。
使用 webdriver 抓取动态数据
1.先导入webdriver子模块
从硒导入网络驱动程序
2.获取浏览器的会话。浏览器可以使用 Firefox、Chrome、IE 等。这里我们以火狐为例
浏览器 = webdriver.Firefox()
3.加载页面，url本身可以指定合法字符串
浏览器.get(url)
4.获取到session对象后，定位元素，webdriver提供了一系列元素定位方法，常用的有以下几种方式：
ID
姓名
班级名称
关联
文本
部分的
关联
文本
标签
姓名
路径
选择器
比如通过id定位，返回所有元素的列表，lis=borwser.find_elements_by_id_name('kw'')
按类名定位，lis=find_elements_by_class_name('title_1')
更详细的定位方法请参考大神《博客园-昆虫大师》的selenium webdriver（python）教程第三章-定位方法部分（第一版可百度文库阅读，第二版）版将从头开始收费>-
python抓取动态网页(Python进程与线程操作技巧汇总(图)实现抓取javascript动态生成)
网站优化 • 优采云 发表了文章 • 0 个评论 • 31 次浏览 • 2022-03-22 01:13
python抓取动态网页(Python进程与线程操作技巧汇总(图)实现抓取javascript动态生成)
python3实现爬取javascript动态生成的html页面示例 Python  /  Admin 发表于3年前   50
本文的例子描述了Python3爬取javascript动态生成的HTML页面的功能。分享给大家，供大家参考，如下：
使用urllib等爬取网页只能读取网页的静态源文件，不能读取javascript生成的内容。
原因是因为urllib是瞬时爬取的，不会等待javascript的加载延迟，所以页面中javascript生成的内容无法被urllib读取。
真的没有办法读取javascript生成的内容吗？也不是！
这里介绍一个python库：selenium，本文使用的版本是2.44.0
先安装：
pip install -U selenium
以下三个例子说明了它的用法：
【示例0】
打开火狐浏览器
在给定的url地址加载页面
from selenium import webdriverbrowser = webdriver.Firefox()browser.get('http://www.baidu.com/')
【示例一】
打开火狐浏览器
加载百度主页
搜索“seleniumhq”
关闭浏览器
from selenium import webdriverfrom selenium.webdriver.common.keys import Keysbrowser = webdriver.Firefox()browser.get('http://www.baidu.com')assert '百度' in browser.titleelem = browser.find_element_by_name('p') # Find the search boxelem.send_keys('seleniumhq' + Keys.RETURN) # 模拟按键browser.quit()
【示例2】
Selenium WebDriver 通常用于测试网络程序。下面是一个使用 Python 标准库 unittest 的示例：
import unittestclass BaiduTestCase(unittest.TestCase): def setUp(self): self.browser = webdriver.Firefox() self.addCleanup(self.browser.quit) def testPageTitle(self): self.browser.get('http://www.baidu.com') self.assertIn('百度', self.browser.title)if __name__ == '__main__': unittest.main(verbosity=2)
对更多Python相关内容感兴趣的读者可以查看本站专题：《Python进程和线程操作技巧总结》、《Python套接字编程技巧总结》、《Python数据结构与算法教程》、 《Python函数使用》技巧总结》、《Python字符串操作技巧总结》、《Python入门与进阶经典教程》和《Python文件和目录操作技巧总结》
希望这篇文章对你的 Python 编程有所帮助。 查看全部
python3实现爬取javascript动态生成的html页面示例 Python  /  Admin 发表于3年前   50
本文的例子描述了Python3爬取javascript动态生成的HTML页面的功能。分享给大家，供大家参考，如下：
使用urllib等爬取网页只能读取网页的静态源文件，不能读取javascript生成的内容。
原因是因为urllib是瞬时爬取的，不会等待javascript的加载延迟，所以页面中javascript生成的内容无法被urllib读取。
真的没有办法读取javascript生成的内容吗？也不是！
这里介绍一个python库：selenium，本文使用的版本是2.44.0
先安装：
pip install -U selenium
以下三个例子说明了它的用法：
【示例0】
打开火狐浏览器
在给定的url地址加载页面
from selenium import webdriverbrowser = webdriver.Firefox()browser.get('http://www.baidu.com/')
【示例一】
打开火狐浏览器
加载百度主页
搜索“seleniumhq”
关闭浏览器
from selenium import webdriverfrom selenium.webdriver.common.keys import Keysbrowser = webdriver.Firefox()browser.get('http://www.baidu.com')assert '百度' in browser.titleelem = browser.find_element_by_name('p') # Find the search boxelem.send_keys('seleniumhq' + Keys.RETURN) # 模拟按键browser.quit()
【示例2】
Selenium WebDriver 通常用于测试网络程序。下面是一个使用 Python 标准库 unittest 的示例：
import unittestclass BaiduTestCase(unittest.TestCase): def setUp(self): self.browser = webdriver.Firefox() self.addCleanup(self.browser.quit) def testPageTitle(self): self.browser.get('http://www.baidu.com') self.assertIn('百度', self.browser.title)if __name__ == '__main__': unittest.main(verbosity=2)
对更多Python相关内容感兴趣的读者可以查看本站专题：《Python进程和线程操作技巧总结》、《Python套接字编程技巧总结》、《Python数据结构与算法教程》、 《Python函数使用》技巧总结》、《Python字符串操作技巧总结》、《Python入门与进阶经典教程》和《Python文件和目录操作技巧总结》
希望这篇文章对你的 Python 编程有所帮助。 查看全部
python抓取动态网页(Python进程与线程操作技巧汇总(图)实现抓取javascript动态生成)
python3实现爬取javascript动态生成的html页面示例 Python  /  Admin 发表于3年前   50
本文的例子描述了Python3爬取javascript动态生成的HTML页面的功能。分享给大家，供大家参考，如下：
使用urllib等爬取网页只能读取网页的静态源文件，不能读取javascript生成的内容。
原因是因为urllib是瞬时爬取的，不会等待javascript的加载延迟，所以页面中javascript生成的内容无法被urllib读取。
真的没有办法读取javascript生成的内容吗？也不是！
这里介绍一个python库：selenium，本文使用的版本是2.44.0
先安装：
pip install -U selenium
以下三个例子说明了它的用法：
【示例0】
打开火狐浏览器
在给定的url地址加载页面
from selenium import webdriverbrowser = webdriver.Firefox()browser.get('http://www.baidu.com/')
【示例一】
打开火狐浏览器
加载百度主页
搜索“seleniumhq”
关闭浏览器
from selenium import webdriverfrom selenium.webdriver.common.keys import Keysbrowser = webdriver.Firefox()browser.get('http://www.baidu.com')assert '百度' in browser.titleelem = browser.find_element_by_name('p') # Find the search boxelem.send_keys('seleniumhq' + Keys.RETURN) # 模拟按键browser.quit()
【示例2】
Selenium WebDriver 通常用于测试网络程序。下面是一个使用 Python 标准库 unittest 的示例：
import unittestclass BaiduTestCase(unittest.TestCase): def setUp(self): self.browser = webdriver.Firefox() self.addCleanup(self.browser.quit) def testPageTitle(self): self.browser.get('http://www.baidu.com') self.assertIn('百度', self.browser.title)if __name__ == '__main__': unittest.main(verbosity=2)
对更多Python相关内容感兴趣的读者可以查看本站专题：《Python进程和线程操作技巧总结》、《Python套接字编程技巧总结》、《Python数据结构与算法教程》、 《Python函数使用》技巧总结》、《Python字符串操作技巧总结》、《Python入门与进阶经典教程》和《Python文件和目录操作技巧总结》
希望这篇文章对你的 Python 编程有所帮助。
python抓取动态网页(Python利用urllib2抓取网页返回乱码的问题(:输出:直接print))
网站优化 • 优采云 发表了文章 • 0 个评论 • 23 次浏览 • 2022-03-21 05:18
python抓取动态网页(Python利用urllib2抓取网页返回乱码的问题(:输出:直接print))
Python使用urllib2爬取网页，返回乱码： 输出：可以直接打印中文，而且注释的中文不会乱码，所以可以解析乱码的网页找到有用的解决方法！！ 【问题解答】从问题现象到问题本质，一点点帮你分析一下为什么会出现问题，如何解决问题1.首先根据之前Python IDE的经验：【整理】各种Python IDE（集成开发环境）的总结和对比从上面的截图，基本上可以推断出它使用：【记录】IDE使用Python：Eclipse+PyDev2.所以，在为了完全重现问题，我去PyDev搭建了一个对应的项目。代码为：?1112131415#-*-coding:utf-8-*-'''CreatedonOct18,2013***@author:CLi'''fromurllibimporturlopendefgetHtml(url):page=urlopen(url)html=page.read ( )page.close()returnhtmlif__name__=="__main__":161718url=""html=getHtml(url)printhtml 那么输出就和原来一模一样了：3.出现这种现象的原因：（根据to：详细爬取网站，模拟登录和抓取动态网页的原理与实现（Python、C#等）：【整理】关于HTML网页源码（GB2312、GBK）的字符编码（charset）格式, UTF-8, ISO8859-1 等）先）确认要处理的网页：/in:? 1（再根据：Character Encoding Concise Tutorial），我们可以看到这里的代码处理中，如果需要解码成Unicode，最好使用GBK。
这里得到的新浪网页字符串对应GB2312。在Eclipse+PyDev的控制台中输出，但是结果是乱码。可以确定：在Eclipse+PyDev的控制台中，使用的字符编码不是GB2312（也不是GBK或GB18030)猜测：估计是用的，比较常用，UTF-84.但是不管它使用什么编码，都应该可以输出Unicode字符串：5.为了验证上面PyDev的console是UTF-8的猜测，所以使用编码：?6223#-* -coding:utf -8-*-'''CreatedonOct18,2013***@author:CLi'''fromurllibimporturlopendefgetHtml(url):page=urlopen(url)html=page.read()page.close()#uniCodehtml =html.decode("GBK")#returnuniCodehtmluniCodehtml=html.decode("GBK")utf8html=uniCodehtml.encode("UTF-8")returnutf8htmlif__name__=="__main__":url=""html=getHtml(url)printhtml的结果输出是Predicted，正常：6. 接下来很明显：你需要弄清楚为什么在这里：在Eclipse+PyDev的Console中，（不是我们之前做的，调用windows的cmd，以为It是GBK编码）但它是UTF-8编码然后参考：PrintingUnicodeineclips ePydevconsoleandinIdle 看看：结果在Eclipse的Window->Preferences中，找了半天也没找到console的编码设置。
最后是：选择你的PyDev项目->Run->RunConfiguration->PythonRun->选择你当前的PyDev项目->Common->Encoding看：current，你的PyDev项目，运行时，控制台的编码used对应utf-87.，改成GBK:，然后点击运行。因此，如果在使用前有意将 Unicode 转换为 UTF-8，则此时的输出与预期的一样。到了，乱码：对应，去使用，最原创的代码，直接输出（获得GB2312新浪网页），代码未经任何转换：8.由此可以充分理解原因：（1)@ >从sina获取的html网页，这个字符串本身的字符编码为：GB2312(2)在Eclipse+PyDev中直接打印输出到控制台时，因为控制台默认为UTF-8编码，所以：将GB2312 查看全部
Python使用urllib2爬取网页，返回乱码： 输出：可以直接打印中文，而且注释的中文不会乱码，所以可以解析乱码的网页找到有用的解决方法！！ 【问题解答】从问题现象到问题本质，一点点帮你分析一下为什么会出现问题，如何解决问题1.首先根据之前Python IDE的经验：【整理】各种Python IDE（集成开发环境）的总结和对比从上面的截图，基本上可以推断出它使用：【记录】IDE使用Python：Eclipse+PyDev2.所以，在为了完全重现问题，我去PyDev搭建了一个对应的项目。代码为：?1112131415#-*-coding:utf-8-*-'''CreatedonOct18,2013***@author:CLi'''fromurllibimporturlopendefgetHtml(url):page=urlopen(url)html=page.read ( )page.close()returnhtmlif__name__=="__main__":161718url=""html=getHtml(url)printhtml 那么输出就和原来一模一样了：3.出现这种现象的原因：（根据to：详细爬取网站，模拟登录和抓取动态网页的原理与实现（Python、C#等）：【整理】关于HTML网页源码（GB2312、GBK）的字符编码（charset）格式, UTF-8, ISO8859-1 等）先）确认要处理的网页：/in:? 1（再根据：Character Encoding Concise Tutorial），我们可以看到这里的代码处理中，如果需要解码成Unicode，最好使用GBK。
这里得到的新浪网页字符串对应GB2312。在Eclipse+PyDev的控制台中输出，但是结果是乱码。可以确定：在Eclipse+PyDev的控制台中，使用的字符编码不是GB2312（也不是GBK或GB18030)猜测：估计是用的，比较常用，UTF-84.但是不管它使用什么编码，都应该可以输出Unicode字符串：5.为了验证上面PyDev的console是UTF-8的猜测，所以使用编码：?6223#-* -coding:utf -8-*-'''CreatedonOct18,2013***@author:CLi'''fromurllibimporturlopendefgetHtml(url):page=urlopen(url)html=page.read()page.close()#uniCodehtml =html.decode("GBK")#returnuniCodehtmluniCodehtml=html.decode("GBK")utf8html=uniCodehtml.encode("UTF-8")returnutf8htmlif__name__=="__main__":url=""html=getHtml(url)printhtml的结果输出是Predicted，正常：6. 接下来很明显：你需要弄清楚为什么在这里：在Eclipse+PyDev的Console中，（不是我们之前做的，调用windows的cmd，以为It是GBK编码）但它是UTF-8编码然后参考：PrintingUnicodeineclips ePydevconsoleandinIdle 看看：结果在Eclipse的Window->Preferences中，找了半天也没找到console的编码设置。
最后是：选择你的PyDev项目->Run->RunConfiguration->PythonRun->选择你当前的PyDev项目->Common->Encoding看：current，你的PyDev项目，运行时，控制台的编码used对应utf-87.，改成GBK:，然后点击运行。因此，如果在使用前有意将 Unicode 转换为 UTF-8，则此时的输出与预期的一样。到了，乱码：对应，去使用，最原创的代码，直接输出（获得GB2312新浪网页），代码未经任何转换：8.由此可以充分理解原因：（1)@ >从sina获取的html网页，这个字符串本身的字符编码为：GB2312(2)在Eclipse+PyDev中直接打印输出到控制台时，因为控制台默认为UTF-8编码，所以：将GB2312 查看全部
python抓取动态网页(Python利用urllib2抓取网页返回乱码的问题(:输出:直接print))
Python使用urllib2爬取网页，返回乱码： 输出：可以直接打印中文，而且注释的中文不会乱码，所以可以解析乱码的网页找到有用的解决方法！！ 【问题解答】从问题现象到问题本质，一点点帮你分析一下为什么会出现问题，如何解决问题1.首先根据之前Python IDE的经验：【整理】各种Python IDE（集成开发环境）的总结和对比从上面的截图，基本上可以推断出它使用：【记录】IDE使用Python：Eclipse+PyDev2.所以，在为了完全重现问题，我去PyDev搭建了一个对应的项目。代码为：?1112131415#-*-coding:utf-8-*-'''CreatedonOct18,2013***@author:CLi'''fromurllibimporturlopendefgetHtml(url):page=urlopen(url)html=page.read ( )page.close()returnhtmlif__name__=="__main__":161718url=""html=getHtml(url)printhtml 那么输出就和原来一模一样了：3.出现这种现象的原因：（根据to：详细爬取网站，模拟登录和抓取动态网页的原理与实现（Python、C#等）：【整理】关于HTML网页源码（GB2312、GBK）的字符编码（charset）格式, UTF-8, ISO8859-1 等）先）确认要处理的网页：/in:? 1（再根据：Character Encoding Concise Tutorial），我们可以看到这里的代码处理中，如果需要解码成Unicode，最好使用GBK。
这里得到的新浪网页字符串对应GB2312。在Eclipse+PyDev的控制台中输出，但是结果是乱码。可以确定：在Eclipse+PyDev的控制台中，使用的字符编码不是GB2312（也不是GBK或GB18030)猜测：估计是用的，比较常用，UTF-84.但是不管它使用什么编码，都应该可以输出Unicode字符串：5.为了验证上面PyDev的console是UTF-8的猜测，所以使用编码：?6223#-* -coding:utf -8-*-'''CreatedonOct18,2013***@author:CLi'''fromurllibimporturlopendefgetHtml(url):page=urlopen(url)html=page.read()page.close()#uniCodehtml =html.decode("GBK")#returnuniCodehtmluniCodehtml=html.decode("GBK")utf8html=uniCodehtml.encode("UTF-8")returnutf8htmlif__name__=="__main__":url=""html=getHtml(url)printhtml的结果输出是Predicted，正常：6. 接下来很明显：你需要弄清楚为什么在这里：在Eclipse+PyDev的Console中，（不是我们之前做的，调用windows的cmd，以为It是GBK编码）但它是UTF-8编码然后参考：PrintingUnicodeineclips ePydevconsoleandinIdle 看看：结果在Eclipse的Window->Preferences中，找了半天也没找到console的编码设置。
最后是：选择你的PyDev项目->Run->RunConfiguration->PythonRun->选择你当前的PyDev项目->Common->Encoding看：current，你的PyDev项目，运行时，控制台的编码used对应utf-87.，改成GBK:，然后点击运行。因此，如果在使用前有意将 Unicode 转换为 UTF-8，则此时的输出与预期的一样。到了，乱码：对应，去使用，最原创的代码，直接输出（获得GB2312新浪网页），代码未经任何转换：8.由此可以充分理解原因：（1)@ >从sina获取的html网页，这个字符串本身的字符编码为：GB2312(2)在Eclipse+PyDev中直接打印输出到控制台时，因为控制台默认为UTF-8编码，所以：将GB2312
python抓取动态网页(一个基于webkit内核的无头浏览器浏览器)
网站优化 • 优采云 发表了文章 • 0 个评论 • 15 次浏览 • 2022-03-21 05:15
python抓取动态网页(一个基于webkit内核的无头浏览器浏览器)
查看元素后发现百度图片中，显示图片的div是：pullimages
这个 div 里面的内容是动态加载的。但是使用urllib&urllib2就爬不上了。
要抓取动态加载的元素，首先考虑使用 selenium 调用浏览器进行抓取。
而我们的运行环境是linux，最理想的方式是无界面抓取，所以使用selenium+phantomjs无界面抓取。
什么是phantomjs？它是一个基于webkit核心的无头浏览器，也就是没有UI界面，就是一个浏览器。
selenium和phantomjs的安装配置可以google，这里就不多说了。
代码如下：
from selenium import webdriver
driver = webdriver.PhantomJS(executable_path='/bin/phantomjs/bin/phantomjs')
#如果不方便配置环境变量。就使用phantomjs的绝对路径也可以
driver.get('http://image.baidu.com/i%3Fie% ... %2339;)
#抓取了百度图片，query：周杰伦
driver.page_source
#这就是返回的页面内容了，与urllib2.urlopen().read()的效果是类似的，但比urllib2强在能抓取到动态渲染后的内容。
driver.quit()
去这里。成功抓取动态页面。 查看全部
查看元素后发现百度图片中，显示图片的div是：pullimages
这个 div 里面的内容是动态加载的。但是使用urllib&urllib2就爬不上了。
要抓取动态加载的元素，首先考虑使用 selenium 调用浏览器进行抓取。
而我们的运行环境是linux，最理想的方式是无界面抓取，所以使用selenium+phantomjs无界面抓取。
什么是phantomjs？它是一个基于webkit核心的无头浏览器，也就是没有UI界面，就是一个浏览器。
selenium和phantomjs的安装配置可以google，这里就不多说了。
代码如下：
from selenium import webdriver
driver = webdriver.PhantomJS(executable_path='/bin/phantomjs/bin/phantomjs')
#如果不方便配置环境变量。就使用phantomjs的绝对路径也可以
driver.get('http://image.baidu.com/i%3Fie% ... %2339;)
#抓取了百度图片，query：周杰伦
driver.page_source
#这就是返回的页面内容了，与urllib2.urlopen().read()的效果是类似的，但比urllib2强在能抓取到动态渲染后的内容。
driver.quit()
去这里。成功抓取动态页面。 查看全部
python抓取动态网页(一个基于webkit内核的无头浏览器浏览器)
查看元素后发现百度图片中，显示图片的div是：pullimages
这个 div 里面的内容是动态加载的。但是使用urllib&urllib2就爬不上了。
要抓取动态加载的元素，首先考虑使用 selenium 调用浏览器进行抓取。
而我们的运行环境是linux，最理想的方式是无界面抓取，所以使用selenium+phantomjs无界面抓取。
什么是phantomjs？它是一个基于webkit核心的无头浏览器，也就是没有UI界面，就是一个浏览器。
selenium和phantomjs的安装配置可以google，这里就不多说了。
代码如下：
from selenium import webdriver
driver = webdriver.PhantomJS(executable_path='/bin/phantomjs/bin/phantomjs')
#如果不方便配置环境变量。就使用phantomjs的绝对路径也可以
driver.get('http://image.baidu.com/i%3Fie% ... %2339;)
#抓取了百度图片，query：周杰伦
driver.page_source
#这就是返回的页面内容了，与urllib2.urlopen().read()的效果是类似的，但比urllib2强在能抓取到动态渲染后的内容。
driver.quit()
去这里。成功抓取动态页面。
python抓取动态网页(python抓取动态网页视频教程可视化的video编码方法推荐使用)
网站优化 • 优采云 发表了文章 • 0 个评论 • 26 次浏览 • 2022-04-15 21:00
python抓取动态网页(python抓取动态网页视频教程可视化的video编码方法推荐使用)
python抓取动态网页视频教程在抓取网页视频时，为了保证抓取视频的质量和速度，python必须能正确判断视频是不是用于生产环境使用。正确判断方法分为页面判断和视频编码判断两种。其中页面判断和视频编码判断根据题主给的样例，和平台有关，题主可以查阅相关资料具体实现。python抓取动态网页视频教程可视化的video编码方法推荐使用gcc-llvm一种定制化的方法。python抓取动态网页视频教程。
第一看编码判断，可以看b站的相关说明，一般来说视频编码格式，是avchar2.1,avchar2.2,dts，还有部分编码比如mp4等等。第二就是看是不是真实视频，最直接的方法就是看网站的视频实际长度。如果是真实视频，一般会有相应的画质提升，dts，xml等等。第三就是根据视频网站不同方式了。
第一点确定视频编码（avchar2）。第二点看网站传输协议（http、https，mime类型等等）。第三点手动判断。大概就这三点常用的，不常用的大家别喷，
需要判断视频类型需要根据视频编码方式和视频网站传输协议判断！下面是来自codeforces的介绍!以下是链接(videoconfigurationspecification),可以对比使用avchar编码协议方式抓取的视频url和bilibiliac3编码协议提供的抓取ac3编码视频url(videoconfigurationspecification)。 查看全部
python抓取动态网页视频教程在抓取网页视频时，为了保证抓取视频的质量和速度，python必须能正确判断视频是不是用于生产环境使用。正确判断方法分为页面判断和视频编码判断两种。其中页面判断和视频编码判断根据题主给的样例，和平台有关，题主可以查阅相关资料具体实现。python抓取动态网页视频教程可视化的video编码方法推荐使用gcc-llvm一种定制化的方法。python抓取动态网页视频教程。
第一看编码判断，可以看b站的相关说明，一般来说视频编码格式，是avchar2.1,avchar2.2,dts，还有部分编码比如mp4等等。第二就是看是不是真实视频，最直接的方法就是看网站的视频实际长度。如果是真实视频，一般会有相应的画质提升，dts，xml等等。第三就是根据视频网站不同方式了。
第一点确定视频编码（avchar2）。第二点看网站传输协议（http、https，mime类型等等）。第三点手动判断。大概就这三点常用的，不常用的大家别喷，
需要判断视频类型需要根据视频编码方式和视频网站传输协议判断！下面是来自codeforces的介绍!以下是链接(videoconfigurationspecification),可以对比使用avchar编码协议方式抓取的视频url和bilibiliac3编码协议提供的抓取ac3编码视频url(videoconfigurationspecification)。 查看全部
python抓取动态网页(python抓取动态网页视频教程可视化的video编码方法推荐使用)
python抓取动态网页视频教程在抓取网页视频时，为了保证抓取视频的质量和速度，python必须能正确判断视频是不是用于生产环境使用。正确判断方法分为页面判断和视频编码判断两种。其中页面判断和视频编码判断根据题主给的样例，和平台有关，题主可以查阅相关资料具体实现。python抓取动态网页视频教程可视化的video编码方法推荐使用gcc-llvm一种定制化的方法。python抓取动态网页视频教程。
第一看编码判断，可以看b站的相关说明，一般来说视频编码格式，是avchar2.1,avchar2.2,dts，还有部分编码比如mp4等等。第二就是看是不是真实视频，最直接的方法就是看网站的视频实际长度。如果是真实视频，一般会有相应的画质提升，dts，xml等等。第三就是根据视频网站不同方式了。
第一点确定视频编码（avchar2）。第二点看网站传输协议（http、https，mime类型等等）。第三点手动判断。大概就这三点常用的，不常用的大家别喷，
需要判断视频类型需要根据视频编码方式和视频网站传输协议判断！下面是来自codeforces的介绍!以下是链接(videoconfigurationspecification),可以对比使用avchar编码协议方式抓取的视频url和bilibiliac3编码协议提供的抓取ac3编码视频url(videoconfigurationspecification)。
python抓取动态网页(爬取网页其实就是通过URL获取网页信息的实质是什么)
网站优化 • 优采云 发表了文章 • 0 个评论 • 46 次浏览 • 2022-04-14 16:20
python抓取动态网页(爬取网页其实就是通过URL获取网页信息的实质是什么)
爬取网页实际上是通过 URL 获取网页信息。网页信息的本质是一段添加了 JavaScript 和 CSS 的 HTML 代码。Python 提供了第三方请求模块，用于抓取网页信息。requests 模块自称为“HTTP for Humans”，字面意思是专为人类设计的 HTTP 模块。该模块支持发送请求和获取响应。Python技术文章2021-11-19 | 传智教育|使用requests模块爬取网页
爬取网页实际上是通过 URL 获取网页信息。网页信息的本质是一段添加了 JavaScript 和 CSS 的 HTML 代码。Python 提供了第三方请求模块，用于抓取网页信息。requests 模块自称为“HTTP for Humans”，字面意思是专为人类设计的 HTTP 模块。该模块支持发送请求和获取响应。
1.发送请求
requests 模块提供了许多发送 HTTP 请求的功能。常用的请求函数如表10-1所示。
表 10-1 requests 模块的请求函数
2.得到响应
requests模块提供的Response类对象用于动态响应客户端的请求，控制发送给用户的信息，动态生成响应，包括状态码、网页内容等。接下来用一张表来列出Response类可以获取的信息，如表10-2所示。
表 10-2 Response 类的常用属性
接下来通过一个案例来演示如何使用requests模块爬取百度网页。具体代码如下：
# 01 requests baidu
import requests
base_url = 'http://www.baidu.com'
#发送GET请求
res = requests.get (base_url)
print("响应状态码：{}".format(res.status_code)) #获取响应状态码
print（"编码方式：{}".format(res.encoding)） #获取响应内容的编码方式
res.encoding = 'utf-8' #更新响应内容的编码方式为UIE-8
print（"网页源代码：\n{}".format(res.text）) ＃获取响应内容
在上面的代码中，第 2 行使用 import 来导入 requests 模块；第3~4行根据URL向服务器发送GET请求，并使用变量res接收服务器返回的响应内容；第 5~6 行打印响应内容的状态码和编码；第 7 行将响应内容的编码更改为“utf-8”；第 8 行打印响应内容。运行程序，程序的输出如下：
响应状态码：200
编码方式：ISO-8859-1
网页源代码：
百度一下,你就知道
…省略N行…
值得一提的是，在使用requests模块爬取网页时，可能会因未连接网络、服务器连接失败等原因出现各种异常，其中最常见的两个异常是URLError和HTTPError。这些网络异常可以与 try... except 语句捕获和处理一起使用。
相关建议：Python 绘图 Matplotlib.pyplot 显示网格 Python 培训：设置轴的标签 查看全部
爬取网页实际上是通过 URL 获取网页信息。网页信息的本质是一段添加了 JavaScript 和 CSS 的 HTML 代码。Python 提供了第三方请求模块，用于抓取网页信息。requests 模块自称为“HTTP for Humans”，字面意思是专为人类设计的 HTTP 模块。该模块支持发送请求和获取响应。Python技术文章2021-11-19 | 传智教育|使用requests模块爬取网页
爬取网页实际上是通过 URL 获取网页信息。网页信息的本质是一段添加了 JavaScript 和 CSS 的 HTML 代码。Python 提供了第三方请求模块，用于抓取网页信息。requests 模块自称为“HTTP for Humans”，字面意思是专为人类设计的 HTTP 模块。该模块支持发送请求和获取响应。
1.发送请求
requests 模块提供了许多发送 HTTP 请求的功能。常用的请求函数如表10-1所示。
表 10-1 requests 模块的请求函数
2.得到响应
requests模块提供的Response类对象用于动态响应客户端的请求，控制发送给用户的信息，动态生成响应，包括状态码、网页内容等。接下来用一张表来列出Response类可以获取的信息，如表10-2所示。
表 10-2 Response 类的常用属性
接下来通过一个案例来演示如何使用requests模块爬取百度网页。具体代码如下：
# 01 requests baidu
import requests
base_url = 'http://www.baidu.com'
#发送GET请求
res = requests.get (base_url)
print("响应状态码：{}".format(res.status_code)) #获取响应状态码
print（"编码方式：{}".format(res.encoding)） #获取响应内容的编码方式
res.encoding = 'utf-8' #更新响应内容的编码方式为UIE-8
print（"网页源代码：\n{}".format(res.text）) ＃获取响应内容
在上面的代码中，第 2 行使用 import 来导入 requests 模块；第3~4行根据URL向服务器发送GET请求，并使用变量res接收服务器返回的响应内容；第 5~6 行打印响应内容的状态码和编码；第 7 行将响应内容的编码更改为“utf-8”；第 8 行打印响应内容。运行程序，程序的输出如下：
响应状态码：200
编码方式：ISO-8859-1
网页源代码：
百度一下,你就知道
…省略N行…
值得一提的是，在使用requests模块爬取网页时，可能会因未连接网络、服务器连接失败等原因出现各种异常，其中最常见的两个异常是URLError和HTTPError。这些网络异常可以与 try... except 语句捕获和处理一起使用。
相关建议：Python 绘图 Matplotlib.pyplot 显示网格 Python 培训：设置轴的标签 查看全部
python抓取动态网页(爬取网页其实就是通过URL获取网页信息的实质是什么)
爬取网页实际上是通过 URL 获取网页信息。网页信息的本质是一段添加了 JavaScript 和 CSS 的 HTML 代码。Python 提供了第三方请求模块，用于抓取网页信息。requests 模块自称为“HTTP for Humans”，字面意思是专为人类设计的 HTTP 模块。该模块支持发送请求和获取响应。Python技术文章2021-11-19 | 传智教育|使用requests模块爬取网页
爬取网页实际上是通过 URL 获取网页信息。网页信息的本质是一段添加了 JavaScript 和 CSS 的 HTML 代码。Python 提供了第三方请求模块，用于抓取网页信息。requests 模块自称为“HTTP for Humans”，字面意思是专为人类设计的 HTTP 模块。该模块支持发送请求和获取响应。
1.发送请求
requests 模块提供了许多发送 HTTP 请求的功能。常用的请求函数如表10-1所示。
表 10-1 requests 模块的请求函数
2.得到响应
requests模块提供的Response类对象用于动态响应客户端的请求，控制发送给用户的信息，动态生成响应，包括状态码、网页内容等。接下来用一张表来列出Response类可以获取的信息，如表10-2所示。
表 10-2 Response 类的常用属性
接下来通过一个案例来演示如何使用requests模块爬取百度网页。具体代码如下：
# 01 requests baidu
import requests
base_url = 'http://www.baidu.com'
#发送GET请求
res = requests.get (base_url)
print("响应状态码：{}".format(res.status_code)) #获取响应状态码
print（"编码方式：{}".format(res.encoding)） #获取响应内容的编码方式
res.encoding = 'utf-8' #更新响应内容的编码方式为UIE-8
print（"网页源代码：\n{}".format(res.text）) ＃获取响应内容
在上面的代码中，第 2 行使用 import 来导入 requests 模块；第3~4行根据URL向服务器发送GET请求，并使用变量res接收服务器返回的响应内容；第 5~6 行打印响应内容的状态码和编码；第 7 行将响应内容的编码更改为“utf-8”；第 8 行打印响应内容。运行程序，程序的输出如下：
响应状态码：200
编码方式：ISO-8859-1
网页源代码：
百度一下,你就知道
…省略N行…
值得一提的是，在使用requests模块爬取网页时，可能会因未连接网络、服务器连接失败等原因出现各种异常，其中最常见的两个异常是URLError和HTTPError。这些网络异常可以与 try... except 语句捕获和处理一起使用。
相关建议：Python 绘图 Matplotlib.pyplot 显示网格 Python 培训：设置轴的标签
python抓取动态网页(一个爬虫项目目录结构(一)--一个 )
网站优化 • 优采云 发表了文章 • 0 个评论 • 29 次浏览 • 2022-04-12 00:05
python抓取动态网页(一个爬虫项目目录结构(一)--一个
)
我们首先创建一个爬虫项目，这里我们使用scrapy框架来创建它。
scrapy startproject poco
然后cd到poco文件夹初始化项目
scrapy genspider pocoSpider poco.com
打开项目，项目目录结构如下
我们的爬虫代码写在 pocoSpider 文件中，现在我们打开 网站 来分析网页。
我们选择人像分类爬行
可以看到页面上有很多用户id。我们需要先获取每个id的url，然后去详情页抓图。
右键查看网页源码，发现该页面是js动态生成的网页
并且页面是懒加载的，右键检查元素，查看网络
如果找到请求的图片，请获取请求参数，url地址，复制到postman中调用，成功获取返回数据
分析请求参数，猜测是否可以通过，修改参数得到响应结果，但是修改请求参数后，请求失败，看来直接修改参数的方法无法得到我们需要的url地址。
让我们随意点击查看网页源代码，看看细节是否也是js动态加载的。
好在我们可以直接在源码中查看我们需要的数据。每张图片的地址在
在标签里面，就是这么简单。我们可以先爬取这个页面的图片
import scrapy
from scrapy.crawler import CrawlerProcess
from scrapy.utils.project import get_project_settings
class PocospiderSpider(scrapy.Spider):
name = 'pocoSpider'
allowed_domains = ['poco.com']
start_urls = ['https://www.poco.cn/works/detail?works_id=20992476']
def parse(self, response):
img_list = response.xpath("//img/@data-src").extract()
for img in img_list:
print(img)
if __name__ == "__main__":
process = CrawlerProcess(get_project_settings())
process.crawl('pocoSpider')
process.start()
不出所料，我们成功拿到了当前id下的所有图片：
现在我们只需要获取所有id对应的url地址并回收请求就可以获取所有图片的地址
由于无法通过修改参数获取数据，所以我们使用selenium框架来模拟浏览器操作。
分析页面，每次拉到最后都发送一个请求。我们关闭页面的图片加载以加快访问速度。我们将爬取的数据存储在数据库中，这里我们使用mongod。定义下拉刷新函数，每次刷新后execute_times sleep 0.5秒，以便浏览器渲染页面。这里我们刷新 40 次来获取数据。
我们在setting.py文件中设置数据库的地址、端口、数据库名
LOCAL_MONGO_HOST = '127.0.0.1'
LOCAL_MONGO_PORT = 27017
DB_NAME = 'POCO'
编写 selenium 模拟操作的代码
执行完之后大概能拿到800多条数据，现在我们重写爬虫代码。
import pymongo
import scrapy
from scrapy.crawler import CrawlerProcess
from scrapy.utils.project import get_project_settings
from poco.settings import LOCAL_MONGO_HOST,LOCAL_MONGO_PORT,DB_NAME
class PocospiderSpider(scrapy.Spider):
name = 'pocoSpider'
mongo_client = pymongo.MongoClient(LOCAL_MONGO_HOST, LOCAL_MONGO_PORT)
collection = mongo_client[DB_NAME]["idlist"]
id_list = collection.find()
def start_requests(self):
for id in self.id_list:
item = {}
item["folder"]=id["_id"]
item["img_urls"]=[]
yield scrapy.Request(url=id["url"],callback=self.parse_detail,meta={"item":item})
def parse_detail(self, response):
item = response.meta["item"]
img_list = response.xpath("//img/@data-src").extract()
for img in img_list:
if img == "":
continue
img = "https:"+img
item["img_urls"].append(img)
yield item
if __name__ == "__main__":
process = CrawlerProcess(get_project_settings())
process.crawl('pocoSpider')
process.start()
我们scrapy管道下载图片，我们先写一个管道方法通过id存储图片，我们重写file_path方法修改图片的存储路径
from scrapy.exceptions import DropItem
from scrapy.pipelines.images import ImagesPipeline
from scrapy import Request
class MyImagesPipeline(ImagesPipeline):
def get_media_requests(self, item, info):
for image_url in item['img_urls']:
referer = image_url
yield Request(image_url,meta={'item':item,'referer':referer})
def file_path(self, request, response=None, info=None):
item = request.meta['item']
folder = item['folder'].strip()
img_name = request.url.split("/")[-1]
filename = u'img/{0}/{1}'.format(folder,img_name)
return filename
def item_completed(self, results, item, info):
image_path = [x['path'] for ok,x in results if ok]
if not image_path:
raise DropItem('Item contains no images')
# item['image_paths'] = image_path
return item
最后我们修改设置文件中的图片下载中间件和PipeLines
DOWNLOADER_MIDDLEWARES = {
'poco.middlewares.PocoDownloaderMiddleware': 543,
}
IMAGES_STORE=r'E:\\'
IMAGES_EXPIRES = 30
# Enable or disable extensions
# See https://doc.scrapy.org/en/late ... .html
#EXTENSIONS = {
# 'scrapy.extensions.telnet.TelnetConsole': None,
#}
ITEM_PIPELINES = {
'poco.pipelines.MyImagesPipeline': 300,
}
CONCURRENT_REQUESTS = 32
DOWNLOAD_DELAY = 0.1
# Configure item pipeli
至此，poco网站的爬虫已经写好，代码运行完毕，图片爬取成功，按照id分类存储
后记：其实爬虫代码还是有bug的。当爬虫运行 10 分钟，没有爬取到 id 时，会自动停止。仔细查看代码，发现一个mongodb的坑。那是
collection = mongo_client[DB_NAME]["idlist"]
id_list = collection.find()
当调用 db.采集.find() 时，它返回的不是所有数据，而是一个“光标”。它的默认行为是：首先在数据库中查询 101 个文档，或者 1 MB 的文档，这取决于首先满足哪个条件；然后每次光标用完文档时，查询 4 MB 的文档。此外，find() 的默认行为是返回一个在 10 分钟不活动后超时的游标。如果 10 分钟内没有处理请求，那么我们将无法获取剩余的 url，因此爬虫将停止。
解决方法也很简单，就是直接将id_list中的数据存入开头的list中。
# -*- coding: utf-8 -*-
import pymongo
import scrapy
from scrapy.crawler import CrawlerProcess
from scrapy.utils.project import get_project_settings
from poco.settings import LOCAL_MONGO_HOST,LOCAL_MONGO_PORT,DB_NAME
class PocospiderSpider(scrapy.Spider):
name = 'pocoSpider'
mongo_client = pymongo.MongoClient(LOCAL_MONGO_HOST, LOCAL_MONGO_PORT)
collection = mongo_client[DB_NAME]["idlist"]
id_list = collection.find()
ids=[]
for id in id_list:
ids.append(id)
def start_requests(self):
for id in self.ids:
item = {}
item["folder"]=id["_id"]
item["img_urls"]=[]
yield scrapy.Request(url=id["url"],callback=self.parse_detail,meta={"item":item})
def parse_detail(self, response):
item = response.meta["item"]
img_list = response.xpath("//img/@data-src").extract()
for img in img_list:
if img == "":
continue
img = "https:"+img
item["img_urls"].append(img)
yield item
if __name__ == "__main__":
process = CrawlerProcess(get_project_settings())
process.crawl('pocoSpider')
process.start() 查看全部
)
我们首先创建一个爬虫项目，这里我们使用scrapy框架来创建它。
scrapy startproject poco
然后cd到poco文件夹初始化项目
scrapy genspider pocoSpider poco.com
打开项目，项目目录结构如下
我们的爬虫代码写在 pocoSpider 文件中，现在我们打开 网站 来分析网页。
我们选择人像分类爬行
可以看到页面上有很多用户id。我们需要先获取每个id的url，然后去详情页抓图。
右键查看网页源码，发现该页面是js动态生成的网页
并且页面是懒加载的，右键检查元素，查看网络
如果找到请求的图片，请获取请求参数，url地址，复制到postman中调用，成功获取返回数据
分析请求参数，猜测是否可以通过，修改参数得到响应结果，但是修改请求参数后，请求失败，看来直接修改参数的方法无法得到我们需要的url地址。
让我们随意点击查看网页源代码，看看细节是否也是js动态加载的。
好在我们可以直接在源码中查看我们需要的数据。每张图片的地址在
在标签里面，就是这么简单。我们可以先爬取这个页面的图片
import scrapy
from scrapy.crawler import CrawlerProcess
from scrapy.utils.project import get_project_settings
class PocospiderSpider(scrapy.Spider):
name = 'pocoSpider'
allowed_domains = ['poco.com']
start_urls = ['https://www.poco.cn/works/detail?works_id=20992476']
def parse(self, response):
img_list = response.xpath("//img/@data-src").extract()
for img in img_list:
print(img)
if __name__ == "__main__":
process = CrawlerProcess(get_project_settings())
process.crawl('pocoSpider')
process.start()
不出所料，我们成功拿到了当前id下的所有图片：
现在我们只需要获取所有id对应的url地址并回收请求就可以获取所有图片的地址
由于无法通过修改参数获取数据，所以我们使用selenium框架来模拟浏览器操作。
分析页面，每次拉到最后都发送一个请求。我们关闭页面的图片加载以加快访问速度。我们将爬取的数据存储在数据库中，这里我们使用mongod。定义下拉刷新函数，每次刷新后execute_times sleep 0.5秒，以便浏览器渲染页面。这里我们刷新 40 次来获取数据。
我们在setting.py文件中设置数据库的地址、端口、数据库名
LOCAL_MONGO_HOST = '127.0.0.1'
LOCAL_MONGO_PORT = 27017
DB_NAME = 'POCO'
编写 selenium 模拟操作的代码
执行完之后大概能拿到800多条数据，现在我们重写爬虫代码。
import pymongo
import scrapy
from scrapy.crawler import CrawlerProcess
from scrapy.utils.project import get_project_settings
from poco.settings import LOCAL_MONGO_HOST,LOCAL_MONGO_PORT,DB_NAME
class PocospiderSpider(scrapy.Spider):
name = 'pocoSpider'
mongo_client = pymongo.MongoClient(LOCAL_MONGO_HOST, LOCAL_MONGO_PORT)
collection = mongo_client[DB_NAME]["idlist"]
id_list = collection.find()
def start_requests(self):
for id in self.id_list:
item = {}
item["folder"]=id["_id"]
item["img_urls"]=[]
yield scrapy.Request(url=id["url"],callback=self.parse_detail,meta={"item":item})
def parse_detail(self, response):
item = response.meta["item"]
img_list = response.xpath("//img/@data-src").extract()
for img in img_list:
if img == "":
continue
img = "https:"+img
item["img_urls"].append(img)
yield item
if __name__ == "__main__":
process = CrawlerProcess(get_project_settings())
process.crawl('pocoSpider')
process.start()
我们scrapy管道下载图片，我们先写一个管道方法通过id存储图片，我们重写file_path方法修改图片的存储路径
from scrapy.exceptions import DropItem
from scrapy.pipelines.images import ImagesPipeline
from scrapy import Request
class MyImagesPipeline(ImagesPipeline):
def get_media_requests(self, item, info):
for image_url in item['img_urls']:
referer = image_url
yield Request(image_url,meta={'item':item,'referer':referer})
def file_path(self, request, response=None, info=None):
item = request.meta['item']
folder = item['folder'].strip()
img_name = request.url.split("/")[-1]
filename = u'img/{0}/{1}'.format(folder,img_name)
return filename
def item_completed(self, results, item, info):
image_path = [x['path'] for ok,x in results if ok]
if not image_path:
raise DropItem('Item contains no images')
# item['image_paths'] = image_path
return item
最后我们修改设置文件中的图片下载中间件和PipeLines
DOWNLOADER_MIDDLEWARES = {
'poco.middlewares.PocoDownloaderMiddleware': 543,
}
IMAGES_STORE=r'E:\\'
IMAGES_EXPIRES = 30
# Enable or disable extensions
# See https://doc.scrapy.org/en/late ... .html
#EXTENSIONS = {
# 'scrapy.extensions.telnet.TelnetConsole': None,
#}
ITEM_PIPELINES = {
'poco.pipelines.MyImagesPipeline': 300,
}
CONCURRENT_REQUESTS = 32
DOWNLOAD_DELAY = 0.1
# Configure item pipeli
至此，poco网站的爬虫已经写好，代码运行完毕，图片爬取成功，按照id分类存储
后记：其实爬虫代码还是有bug的。当爬虫运行 10 分钟，没有爬取到 id 时，会自动停止。仔细查看代码，发现一个mongodb的坑。那是
collection = mongo_client[DB_NAME]["idlist"]
id_list = collection.find()
当调用 db.采集.find() 时，它返回的不是所有数据，而是一个“光标”。它的默认行为是：首先在数据库中查询 101 个文档，或者 1 MB 的文档，这取决于首先满足哪个条件；然后每次光标用完文档时，查询 4 MB 的文档。此外，find() 的默认行为是返回一个在 10 分钟不活动后超时的游标。如果 10 分钟内没有处理请求，那么我们将无法获取剩余的 url，因此爬虫将停止。
解决方法也很简单，就是直接将id_list中的数据存入开头的list中。
# -*- coding: utf-8 -*-
import pymongo
import scrapy
from scrapy.crawler import CrawlerProcess
from scrapy.utils.project import get_project_settings
from poco.settings import LOCAL_MONGO_HOST,LOCAL_MONGO_PORT,DB_NAME
class PocospiderSpider(scrapy.Spider):
name = 'pocoSpider'
mongo_client = pymongo.MongoClient(LOCAL_MONGO_HOST, LOCAL_MONGO_PORT)
collection = mongo_client[DB_NAME]["idlist"]
id_list = collection.find()
ids=[]
for id in id_list:
ids.append(id)
def start_requests(self):
for id in self.ids:
item = {}
item["folder"]=id["_id"]
item["img_urls"]=[]
yield scrapy.Request(url=id["url"],callback=self.parse_detail,meta={"item":item})
def parse_detail(self, response):
item = response.meta["item"]
img_list = response.xpath("//img/@data-src").extract()
for img in img_list:
if img == "":
continue
img = "https:"+img
item["img_urls"].append(img)
yield item
if __name__ == "__main__":
process = CrawlerProcess(get_project_settings())
process.crawl('pocoSpider')
process.start() 查看全部
python抓取动态网页(一个爬虫项目目录结构(一)--一个
)
我们首先创建一个爬虫项目，这里我们使用scrapy框架来创建它。
scrapy startproject poco
然后cd到poco文件夹初始化项目
scrapy genspider pocoSpider poco.com
打开项目，项目目录结构如下
我们的爬虫代码写在 pocoSpider 文件中，现在我们打开 网站 来分析网页。
我们选择人像分类爬行
可以看到页面上有很多用户id。我们需要先获取每个id的url，然后去详情页抓图。
右键查看网页源码，发现该页面是js动态生成的网页
并且页面是懒加载的，右键检查元素，查看网络
如果找到请求的图片，请获取请求参数，url地址，复制到postman中调用，成功获取返回数据
分析请求参数，猜测是否可以通过，修改参数得到响应结果，但是修改请求参数后，请求失败，看来直接修改参数的方法无法得到我们需要的url地址。
让我们随意点击查看网页源代码，看看细节是否也是js动态加载的。
好在我们可以直接在源码中查看我们需要的数据。每张图片的地址在
在标签里面，就是这么简单。我们可以先爬取这个页面的图片
import scrapy
from scrapy.crawler import CrawlerProcess
from scrapy.utils.project import get_project_settings
class PocospiderSpider(scrapy.Spider):
name = 'pocoSpider'
allowed_domains = ['poco.com']
start_urls = ['https://www.poco.cn/works/detail?works_id=20992476']
def parse(self, response):
img_list = response.xpath("//img/@data-src").extract()
for img in img_list:
print(img)
if __name__ == "__main__":
process = CrawlerProcess(get_project_settings())
process.crawl('pocoSpider')
process.start()
不出所料，我们成功拿到了当前id下的所有图片：
现在我们只需要获取所有id对应的url地址并回收请求就可以获取所有图片的地址
由于无法通过修改参数获取数据，所以我们使用selenium框架来模拟浏览器操作。
分析页面，每次拉到最后都发送一个请求。我们关闭页面的图片加载以加快访问速度。我们将爬取的数据存储在数据库中，这里我们使用mongod。定义下拉刷新函数，每次刷新后execute_times sleep 0.5秒，以便浏览器渲染页面。这里我们刷新 40 次来获取数据。
我们在setting.py文件中设置数据库的地址、端口、数据库名
LOCAL_MONGO_HOST = '127.0.0.1'
LOCAL_MONGO_PORT = 27017
DB_NAME = 'POCO'
编写 selenium 模拟操作的代码
执行完之后大概能拿到800多条数据，现在我们重写爬虫代码。
import pymongo
import scrapy
from scrapy.crawler import CrawlerProcess
from scrapy.utils.project import get_project_settings
from poco.settings import LOCAL_MONGO_HOST,LOCAL_MONGO_PORT,DB_NAME
class PocospiderSpider(scrapy.Spider):
name = 'pocoSpider'
mongo_client = pymongo.MongoClient(LOCAL_MONGO_HOST, LOCAL_MONGO_PORT)
collection = mongo_client[DB_NAME]["idlist"]
id_list = collection.find()
def start_requests(self):
for id in self.id_list:
item = {}
item["folder"]=id["_id"]
item["img_urls"]=[]
yield scrapy.Request(url=id["url"],callback=self.parse_detail,meta={"item":item})
def parse_detail(self, response):
item = response.meta["item"]
img_list = response.xpath("//img/@data-src").extract()
for img in img_list:
if img == "":
continue
img = "https:"+img
item["img_urls"].append(img)
yield item
if __name__ == "__main__":
process = CrawlerProcess(get_project_settings())
process.crawl('pocoSpider')
process.start()
我们scrapy管道下载图片，我们先写一个管道方法通过id存储图片，我们重写file_path方法修改图片的存储路径
from scrapy.exceptions import DropItem
from scrapy.pipelines.images import ImagesPipeline
from scrapy import Request
class MyImagesPipeline(ImagesPipeline):
def get_media_requests(self, item, info):
for image_url in item['img_urls']:
referer = image_url
yield Request(image_url,meta={'item':item,'referer':referer})
def file_path(self, request, response=None, info=None):
item = request.meta['item']
folder = item['folder'].strip()
img_name = request.url.split("/")[-1]
filename = u'img/{0}/{1}'.format(folder,img_name)
return filename
def item_completed(self, results, item, info):
image_path = [x['path'] for ok,x in results if ok]
if not image_path:
raise DropItem('Item contains no images')
# item['image_paths'] = image_path
return item
最后我们修改设置文件中的图片下载中间件和PipeLines
DOWNLOADER_MIDDLEWARES = {
'poco.middlewares.PocoDownloaderMiddleware': 543,
}
IMAGES_STORE=r'E:\\'
IMAGES_EXPIRES = 30
# Enable or disable extensions
# See https://doc.scrapy.org/en/late ... .html
#EXTENSIONS = {
# 'scrapy.extensions.telnet.TelnetConsole': None,
#}
ITEM_PIPELINES = {
'poco.pipelines.MyImagesPipeline': 300,
}
CONCURRENT_REQUESTS = 32
DOWNLOAD_DELAY = 0.1
# Configure item pipeli
至此，poco网站的爬虫已经写好，代码运行完毕，图片爬取成功，按照id分类存储
后记：其实爬虫代码还是有bug的。当爬虫运行 10 分钟，没有爬取到 id 时，会自动停止。仔细查看代码，发现一个mongodb的坑。那是
collection = mongo_client[DB_NAME]["idlist"]
id_list = collection.find()
当调用 db.采集.find() 时，它返回的不是所有数据，而是一个“光标”。它的默认行为是：首先在数据库中查询 101 个文档，或者 1 MB 的文档，这取决于首先满足哪个条件；然后每次光标用完文档时，查询 4 MB 的文档。此外，find() 的默认行为是返回一个在 10 分钟不活动后超时的游标。如果 10 分钟内没有处理请求，那么我们将无法获取剩余的 url，因此爬虫将停止。
解决方法也很简单，就是直接将id_list中的数据存入开头的list中。
# -*- coding: utf-8 -*-
import pymongo
import scrapy
from scrapy.crawler import CrawlerProcess
from scrapy.utils.project import get_project_settings
from poco.settings import LOCAL_MONGO_HOST,LOCAL_MONGO_PORT,DB_NAME
class PocospiderSpider(scrapy.Spider):
name = 'pocoSpider'
mongo_client = pymongo.MongoClient(LOCAL_MONGO_HOST, LOCAL_MONGO_PORT)
collection = mongo_client[DB_NAME]["idlist"]
id_list = collection.find()
ids=[]
for id in id_list:
ids.append(id)
def start_requests(self):
for id in self.ids:
item = {}
item["folder"]=id["_id"]
item["img_urls"]=[]
yield scrapy.Request(url=id["url"],callback=self.parse_detail,meta={"item":item})
def parse_detail(self, response):
item = response.meta["item"]
img_list = response.xpath("//img/@data-src").extract()
for img in img_list:
if img == "":
continue
img = "https:"+img
item["img_urls"].append(img)
yield item
if __name__ == "__main__":
process = CrawlerProcess(get_project_settings())
process.crawl('pocoSpider')
process.start()
python抓取动态网页( python使用xslt提取网页数据中的Ajax或动态html,)
网站优化 • 优采云 发表了文章 • 0 个评论 • 35 次浏览 • 2022-04-11 16:43
python抓取动态网页(
python使用xslt提取网页数据中的Ajax或动态html,)
上一篇python使用xslt提取网页数据，要提取的内容是直接从网页的源码中获取的。
但是对于一些Ajax或者动态html来说，要提取的内容在源代码中往往是找不到的。在这种情况下，必须找到一种方法来提取异步或动态加载的内容。
可以在python中使用selenium来执行javascript，selenium可以让浏览器自动加载页面并获取需要的数据。
Selenium没有自带浏览器，可以使用第三方浏览器如Firefox、Chrome等，也可以使用PhantomJS等无头浏览器在后台执行。
比如我们要抓取京东手机页面的手机名和价格（网页源码中找不到价格）
第一步：在几搜科谋几个控制台上通过图形界面快速生成xslt
第二步：执行以下代码（windows10下测试通过，python3.2）
#/usr/bin/python
from urllib import request
from lxml import etree
from selenium import webdriver
import time
# 京东手机商品页面
url="http://item.jd.com/1312640.html"
# 下面的xslt是通过集搜客的谋数台图形界面自动生成的
xslt_root = etree.XML("""
""")
# 使用webdriver.PhantomJS
browser=webdriver.PhantomJS(executable_path=‘C:\\phantomjs-2.1.1-windows\\bin\\phantomjs.exe‘)
browser.get(url)
time.sleep(3)
transform = etree.XSLT(xslt_root)
# 执行js得到整个dom
html = browser.execute_script("return document.documentElement.outerHTML")
doc = etree.HTML(html)
# 用xslt从dom中提取需要的字段
result_tree = transform(doc)
print(result_tree)
第三步：可以看到网页中的手机名称和价格被正确抓取了
Python爬虫使用Selenium+PhantomJS爬取Ajax和动态HTML内容
原文： 查看全部
python使用xslt提取网页数据中的Ajax或动态html,)
上一篇python使用xslt提取网页数据，要提取的内容是直接从网页的源码中获取的。
但是对于一些Ajax或者动态html来说，要提取的内容在源代码中往往是找不到的。在这种情况下，必须找到一种方法来提取异步或动态加载的内容。
可以在python中使用selenium来执行javascript，selenium可以让浏览器自动加载页面并获取需要的数据。
Selenium没有自带浏览器，可以使用第三方浏览器如Firefox、Chrome等，也可以使用PhantomJS等无头浏览器在后台执行。
比如我们要抓取京东手机页面的手机名和价格（网页源码中找不到价格）
第一步：在几搜科谋几个控制台上通过图形界面快速生成xslt
第二步：执行以下代码（windows10下测试通过，python3.2）
#/usr/bin/python
from urllib import request
from lxml import etree
from selenium import webdriver
import time
# 京东手机商品页面
url="http://item.jd.com/1312640.html"
# 下面的xslt是通过集搜客的谋数台图形界面自动生成的
xslt_root = etree.XML("""
""")
# 使用webdriver.PhantomJS
browser=webdriver.PhantomJS(executable_path=‘C:\\phantomjs-2.1.1-windows\\bin\\phantomjs.exe‘)
browser.get(url)
time.sleep(3)
transform = etree.XSLT(xslt_root)
# 执行js得到整个dom
html = browser.execute_script("return document.documentElement.outerHTML")
doc = etree.HTML(html)
# 用xslt从dom中提取需要的字段
result_tree = transform(doc)
print(result_tree)
第三步：可以看到网页中的手机名称和价格被正确抓取了
Python爬虫使用Selenium+PhantomJS爬取Ajax和动态HTML内容
原文： 查看全部
python抓取动态网页(
python使用xslt提取网页数据中的Ajax或动态html,)
上一篇python使用xslt提取网页数据，要提取的内容是直接从网页的源码中获取的。
但是对于一些Ajax或者动态html来说，要提取的内容在源代码中往往是找不到的。在这种情况下，必须找到一种方法来提取异步或动态加载的内容。
可以在python中使用selenium来执行javascript，selenium可以让浏览器自动加载页面并获取需要的数据。
Selenium没有自带浏览器，可以使用第三方浏览器如Firefox、Chrome等，也可以使用PhantomJS等无头浏览器在后台执行。
比如我们要抓取京东手机页面的手机名和价格（网页源码中找不到价格）
第一步：在几搜科谋几个控制台上通过图形界面快速生成xslt
第二步：执行以下代码（windows10下测试通过，python3.2）
#/usr/bin/python
from urllib import request
from lxml import etree
from selenium import webdriver
import time
# 京东手机商品页面
url="http://item.jd.com/1312640.html"
# 下面的xslt是通过集搜客的谋数台图形界面自动生成的
xslt_root = etree.XML("""
""")
# 使用webdriver.PhantomJS
browser=webdriver.PhantomJS(executable_path=‘C:\\phantomjs-2.1.1-windows\\bin\\phantomjs.exe‘)
browser.get(url)
time.sleep(3)
transform = etree.XSLT(xslt_root)
# 执行js得到整个dom
html = browser.execute_script("return document.documentElement.outerHTML")
doc = etree.HTML(html)
# 用xslt从dom中提取需要的字段
result_tree = transform(doc)
print(result_tree)
第三步：可以看到网页中的手机名称和价格被正确抓取了
Python爬虫使用Selenium+PhantomJS爬取Ajax和动态HTML内容
原文：
python抓取动态网页(python下抓包神技！远离sqlite，方法不对不过很久前的问题)
网站优化 • 优采云 发表了文章 • 0 个评论 • 41 次浏览 • 2022-04-11 11:08
python抓取动态网页(python下抓包神技！远离sqlite，方法不对不过很久前的问题)
python抓取动态网页，抓取成功后保存数据，网页丢失/损坏，删除数据项目失败了，数据丢失的很彻底。爬虫的设计师也是有够脆弱，面对现实随时都要崩溃了。网站问题会有web问题也会有浏览器问题问题，
我觉得抓取动态网页最实用的是抓包。network面前，需要多花点精力在设计数据包上。详见下面的博客：python下抓包神技！远离sqlite，
方法不对不过很久前的问题，根据提问背景和回答时间应该已经有一些程序逻辑上的变化了估计爬不到原因会有很多方面吧最基本的方面可能是抓取工具限制，比如现在一些工具不支持pythonrequests等工具抓取；例如动态网页翻页，如果第一页没抓取到后面的就没抓到；第二页没抓到，网页内容也就翻不到底了python和解析器兼容性有点差爬取数据的时候要做好强制转码，也就是手动设置一下url能看到的解析器的版本、去掉invalidascii（别看不起import）mozillaflask这种做法是错误的，他用了无耻的requests，如果抓取数据比较大用这样抓数据会非常慢，特别是底层请求前后端隔离做得差点，我试过有的时候再加个asyncio还好点，像爬js库之类的或者爬个api接口（其实一般都还是flask开发）还是用java或者golang好一点，对解析器兼容性更好，使用方便一点。 查看全部
python抓取动态网页，抓取成功后保存数据，网页丢失/损坏，删除数据项目失败了，数据丢失的很彻底。爬虫的设计师也是有够脆弱，面对现实随时都要崩溃了。网站问题会有web问题也会有浏览器问题问题，
我觉得抓取动态网页最实用的是抓包。network面前，需要多花点精力在设计数据包上。详见下面的博客：python下抓包神技！远离sqlite，
方法不对不过很久前的问题，根据提问背景和回答时间应该已经有一些程序逻辑上的变化了估计爬不到原因会有很多方面吧最基本的方面可能是抓取工具限制，比如现在一些工具不支持pythonrequests等工具抓取；例如动态网页翻页，如果第一页没抓取到后面的就没抓到；第二页没抓到，网页内容也就翻不到底了python和解析器兼容性有点差爬取数据的时候要做好强制转码，也就是手动设置一下url能看到的解析器的版本、去掉invalidascii（别看不起import）mozillaflask这种做法是错误的，他用了无耻的requests，如果抓取数据比较大用这样抓数据会非常慢，特别是底层请求前后端隔离做得差点，我试过有的时候再加个asyncio还好点，像爬js库之类的或者爬个api接口（其实一般都还是flask开发）还是用java或者golang好一点，对解析器兼容性更好，使用方便一点。 查看全部
python抓取动态网页(python下抓包神技！远离sqlite，方法不对不过很久前的问题)
python抓取动态网页，抓取成功后保存数据，网页丢失/损坏，删除数据项目失败了，数据丢失的很彻底。爬虫的设计师也是有够脆弱，面对现实随时都要崩溃了。网站问题会有web问题也会有浏览器问题问题，
我觉得抓取动态网页最实用的是抓包。network面前，需要多花点精力在设计数据包上。详见下面的博客：python下抓包神技！远离sqlite，
方法不对不过很久前的问题，根据提问背景和回答时间应该已经有一些程序逻辑上的变化了估计爬不到原因会有很多方面吧最基本的方面可能是抓取工具限制，比如现在一些工具不支持pythonrequests等工具抓取；例如动态网页翻页，如果第一页没抓取到后面的就没抓到；第二页没抓到，网页内容也就翻不到底了python和解析器兼容性有点差爬取数据的时候要做好强制转码，也就是手动设置一下url能看到的解析器的版本、去掉invalidascii（别看不起import）mozillaflask这种做法是错误的，他用了无耻的requests，如果抓取数据比较大用这样抓数据会非常慢，特别是底层请求前后端隔离做得差点，我试过有的时候再加个asyncio还好点，像爬js库之类的或者爬个api接口（其实一般都还是flask开发）还是用java或者golang好一点，对解析器兼容性更好，使用方便一点。
python抓取动态网页( 为啥写这篇文章?前两篇文章我们分别介绍了文章目录分析页面)
网站优化 • 优采云 发表了文章 • 0 个评论 • 52 次浏览 • 2022-04-09 05:26
python抓取动态网页(
为啥写这篇文章?前两篇文章我们分别介绍了文章目录分析页面)
为什么要写这个文章？
前两篇文章我们分别介绍
文章目录
分析页面
先打开小餐桌网站，经过简单分析我们可以得出三个结论。
点击查看更多数据后，页面地址不变，不会再次刷新页面。点击查看更多将请求界面一次。页面的数据由接口以application/json的形式返回。返回哪个页面的数据由p参数控制。n 参数控制每页返回的数据项数。什么是ajax
AJAX（Asynchronouse JavaScript And XML）中文名称是异步JavaScript和XML。主要用于前端与服务器之间的少量数据交互。Ajax 允许异步加载网页，这意味着可以对网页的某些部分进行部分更新，而无需重新加载整个网页。如果内容需要更新，传统网页（不使用 Ajax）需要重新加载整个网页。
因为传统的数据传输格式使用XML语法，所以称为AJAX。其实数据交互基本都是用JSON。AJAX加载的数据，即使使用JS，数据渲染到浏览器中，右键---->查看网页源代码，还是看不到ajax加载的数据，你只能看到url代码加载的html。
获取ajax数据的方法直接分析ajax调用的接口，然后通过代码请求这个接口。使用 Selenium+chromedriver 模拟浏览器行为获取数据。（文章后面会详述）获取数据
这个小餐桌网站的界面比较简单。它不做加密认证或任何事情。可以直接通过requests请求。下面给出了一个示例代码：
import requests
headers = {
"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.93 Safari/537.36"
}
requests.packages.urllib3.disable_warnings()
if __name__ == '__main__':
for i in range(1,10):
url = "https://www.xfz.cn/api/website/articles/?p={0}&n=20&type=".format(str(i))
resp = requests.get(url, headers=headers, verify=False)
print(resp.json())
运行结果：
总结
本文以小餐桌网站为例，简单介绍如何从动态网页中抓取数据。
粉丝专属福利
软考资料：实用软考资料
面试题：5G Java高频面试题
学习资料：各种学习资料50G 查看全部
为啥写这篇文章?前两篇文章我们分别介绍了文章目录分析页面)
为什么要写这个文章？
前两篇文章我们分别介绍
文章目录
分析页面
先打开小餐桌网站，经过简单分析我们可以得出三个结论。
点击查看更多数据后，页面地址不变，不会再次刷新页面。点击查看更多将请求界面一次。页面的数据由接口以application/json的形式返回。返回哪个页面的数据由p参数控制。n 参数控制每页返回的数据项数。什么是ajax
AJAX（Asynchronouse JavaScript And XML）中文名称是异步JavaScript和XML。主要用于前端与服务器之间的少量数据交互。Ajax 允许异步加载网页，这意味着可以对网页的某些部分进行部分更新，而无需重新加载整个网页。如果内容需要更新，传统网页（不使用 Ajax）需要重新加载整个网页。
因为传统的数据传输格式使用XML语法，所以称为AJAX。其实数据交互基本都是用JSON。AJAX加载的数据，即使使用JS，数据渲染到浏览器中，右键---->查看网页源代码，还是看不到ajax加载的数据，你只能看到url代码加载的html。
获取ajax数据的方法直接分析ajax调用的接口，然后通过代码请求这个接口。使用 Selenium+chromedriver 模拟浏览器行为获取数据。（文章后面会详述）获取数据
这个小餐桌网站的界面比较简单。它不做加密认证或任何事情。可以直接通过requests请求。下面给出了一个示例代码：
import requests
headers = {
"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.93 Safari/537.36"
}
requests.packages.urllib3.disable_warnings()
if __name__ == '__main__':
for i in range(1,10):
url = "https://www.xfz.cn/api/website/articles/?p={0}&n=20&type=".format(str(i))
resp = requests.get(url, headers=headers, verify=False)
print(resp.json())
运行结果：
总结
本文以小餐桌网站为例，简单介绍如何从动态网页中抓取数据。
粉丝专属福利
软考资料：实用软考资料
面试题：5G Java高频面试题
学习资料：各种学习资料50G 查看全部
python抓取动态网页(
为啥写这篇文章?前两篇文章我们分别介绍了文章目录分析页面)
为什么要写这个文章？
前两篇文章我们分别介绍
文章目录
分析页面
先打开小餐桌网站，经过简单分析我们可以得出三个结论。
点击查看更多数据后，页面地址不变，不会再次刷新页面。点击查看更多将请求界面一次。页面的数据由接口以application/json的形式返回。返回哪个页面的数据由p参数控制。n 参数控制每页返回的数据项数。什么是ajax
AJAX（Asynchronouse JavaScript And XML）中文名称是异步JavaScript和XML。主要用于前端与服务器之间的少量数据交互。Ajax 允许异步加载网页，这意味着可以对网页的某些部分进行部分更新，而无需重新加载整个网页。如果内容需要更新，传统网页（不使用 Ajax）需要重新加载整个网页。
因为传统的数据传输格式使用XML语法，所以称为AJAX。其实数据交互基本都是用JSON。AJAX加载的数据，即使使用JS，数据渲染到浏览器中，右键---->查看网页源代码，还是看不到ajax加载的数据，你只能看到url代码加载的html。
获取ajax数据的方法直接分析ajax调用的接口，然后通过代码请求这个接口。使用 Selenium+chromedriver 模拟浏览器行为获取数据。（文章后面会详述）获取数据
这个小餐桌网站的界面比较简单。它不做加密认证或任何事情。可以直接通过requests请求。下面给出了一个示例代码：
import requests
headers = {
"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.93 Safari/537.36"
}
requests.packages.urllib3.disable_warnings()
if __name__ == '__main__':
for i in range(1,10):
url = "https://www.xfz.cn/api/website/articles/?p={0}&n=20&type=".format(str(i))
resp = requests.get(url, headers=headers, verify=False)
print(resp.json())
运行结果：
总结
本文以小餐桌网站为例，简单介绍如何从动态网页中抓取数据。
粉丝专属福利
软考资料：实用软考资料
面试题：5G Java高频面试题
学习资料：各种学习资料50G
python抓取动态网页(python抓取动态网页获取源代码(网页动态)抓取一些音乐数据)
网站优化 • 优采云 发表了文章 • 0 个评论 • 18 次浏览 • 2022-04-08 05:04
python抓取动态网页(python抓取动态网页获取源代码(网页动态)抓取一些音乐数据)
python抓取动态网页获取源代码网页动态网页抓取，网页抓取并非结构性网页内容抓取或者最简单的就是对网页结构一目了然实现起来也容易，动态网页就是通过js代码动态生成。关键点在如何写js代码，可以利用第三方库实现快速查看源代码。数据爬取：抓取一些音乐数据本案例通过数据爬取，选取其中一首歌名为《如约而至》的歌曲下载音乐音乐下载：歌曲下载网页打开，当前页面搜索到的词汇数量最多，进入搜索结果页面。
随机词采用关键词，最多排列出6条结果，数量为3条，网页浏览器的缓存中暂时会生成3条请求，进行第一步动态抓取（本文通过python3.5及以上版本查看，python2不行）请求地址地址和url代码在上图中，window的url变成了mjmenr，同时出现了dzhomakejavajavajavascriptrequest，选择mjmenr这个data参数，选择新窗口抓取。
只要url后面加上+window就可以复制出来helloworld.py文件。其他地方不要改动，直接用python3来抓取即可。本案例以python3为例，参考以下代码抓取优采云票的下半身数据，并根据数据分析规律打标签工具部分，按照以下代码打开开始想下载的车次，回车后开始提示下载，提示不存在一次性下载多张，将密码设置为1，1，2选择第一张即可，完成后抓取如下：进入工具部分，先将模型和工具保存起来，方便后续操作，引入python工具包，用的是qt4库安装好python3软件，依次保存到本地，方便方便，为此找到和qt4库对应的工具库，双击软件包可在qt文件管理器中找到这个typeautocadtools把qt文件夹中的qtsystem文件夹复制到这个文件夹下面并把下面的图文件cmd窗口添加完工把qt4编译到python3.5中，找到autocad编译器选择python3程序路径双击运行程序，运行完成会提示对应的启动项setsource="python3"cmd窗口提示显示为-md:\python3\scripts下载好的字体，根据个人需要自行下载第三方库：选中图例中的内容，鼠标右键在开始菜单选择opendevelopmenttool选择windows下打开excel，再选择python3.6下的pandas，然后继续，根据自己需要安装numpy、scipy、matplotlib等库本案例中前4个命令为选择数据类型，在diamonds数据集中间的studio里面，一个黄色小球按一次开关，单个黄色小球对应一个参数点击下一步，根据具体操作选择第5个命令进入生成数据列表页面，生成的格式不一样，点击保存生成目录在进入控制台窗口，选择ctrl+alt+t，选择createdatalibrary并选择c盘，右键pdfs文件夹，选。 查看全部
python抓取动态网页获取源代码网页动态网页抓取，网页抓取并非结构性网页内容抓取或者最简单的就是对网页结构一目了然实现起来也容易，动态网页就是通过js代码动态生成。关键点在如何写js代码，可以利用第三方库实现快速查看源代码。数据爬取：抓取一些音乐数据本案例通过数据爬取，选取其中一首歌名为《如约而至》的歌曲下载音乐音乐下载：歌曲下载网页打开，当前页面搜索到的词汇数量最多，进入搜索结果页面。
随机词采用关键词，最多排列出6条结果，数量为3条，网页浏览器的缓存中暂时会生成3条请求，进行第一步动态抓取（本文通过python3.5及以上版本查看，python2不行）请求地址地址和url代码在上图中，window的url变成了mjmenr，同时出现了dzhomakejavajavajavascriptrequest，选择mjmenr这个data参数，选择新窗口抓取。
只要url后面加上+window就可以复制出来helloworld.py文件。其他地方不要改动，直接用python3来抓取即可。本案例以python3为例，参考以下代码抓取优采云票的下半身数据，并根据数据分析规律打标签工具部分，按照以下代码打开开始想下载的车次，回车后开始提示下载，提示不存在一次性下载多张，将密码设置为1，1，2选择第一张即可，完成后抓取如下：进入工具部分，先将模型和工具保存起来，方便后续操作，引入python工具包，用的是qt4库安装好python3软件，依次保存到本地，方便方便，为此找到和qt4库对应的工具库，双击软件包可在qt文件管理器中找到这个typeautocadtools把qt文件夹中的qtsystem文件夹复制到这个文件夹下面并把下面的图文件cmd窗口添加完工把qt4编译到python3.5中，找到autocad编译器选择python3程序路径双击运行程序，运行完成会提示对应的启动项setsource="python3"cmd窗口提示显示为-md:\python3\scripts下载好的字体，根据个人需要自行下载第三方库：选中图例中的内容，鼠标右键在开始菜单选择opendevelopmenttool选择windows下打开excel，再选择python3.6下的pandas，然后继续，根据自己需要安装numpy、scipy、matplotlib等库本案例中前4个命令为选择数据类型，在diamonds数据集中间的studio里面，一个黄色小球按一次开关，单个黄色小球对应一个参数点击下一步，根据具体操作选择第5个命令进入生成数据列表页面，生成的格式不一样，点击保存生成目录在进入控制台窗口，选择ctrl+alt+t，选择createdatalibrary并选择c盘，右键pdfs文件夹，选。 查看全部
python抓取动态网页(python抓取动态网页获取源代码(网页动态)抓取一些音乐数据)
python抓取动态网页获取源代码网页动态网页抓取，网页抓取并非结构性网页内容抓取或者最简单的就是对网页结构一目了然实现起来也容易，动态网页就是通过js代码动态生成。关键点在如何写js代码，可以利用第三方库实现快速查看源代码。数据爬取：抓取一些音乐数据本案例通过数据爬取，选取其中一首歌名为《如约而至》的歌曲下载音乐音乐下载：歌曲下载网页打开，当前页面搜索到的词汇数量最多，进入搜索结果页面。
随机词采用关键词，最多排列出6条结果，数量为3条，网页浏览器的缓存中暂时会生成3条请求，进行第一步动态抓取（本文通过python3.5及以上版本查看，python2不行）请求地址地址和url代码在上图中，window的url变成了mjmenr，同时出现了dzhomakejavajavajavascriptrequest，选择mjmenr这个data参数，选择新窗口抓取。
只要url后面加上+window就可以复制出来helloworld.py文件。其他地方不要改动，直接用python3来抓取即可。本案例以python3为例，参考以下代码抓取优采云票的下半身数据，并根据数据分析规律打标签工具部分，按照以下代码打开开始想下载的车次，回车后开始提示下载，提示不存在一次性下载多张，将密码设置为1，1，2选择第一张即可，完成后抓取如下：进入工具部分，先将模型和工具保存起来，方便后续操作，引入python工具包，用的是qt4库安装好python3软件，依次保存到本地，方便方便，为此找到和qt4库对应的工具库，双击软件包可在qt文件管理器中找到这个typeautocadtools把qt文件夹中的qtsystem文件夹复制到这个文件夹下面并把下面的图文件cmd窗口添加完工把qt4编译到python3.5中，找到autocad编译器选择python3程序路径双击运行程序，运行完成会提示对应的启动项setsource="python3"cmd窗口提示显示为-md:\python3\scripts下载好的字体，根据个人需要自行下载第三方库：选中图例中的内容，鼠标右键在开始菜单选择opendevelopmenttool选择windows下打开excel，再选择python3.6下的pandas，然后继续，根据自己需要安装numpy、scipy、matplotlib等库本案例中前4个命令为选择数据类型，在diamonds数据集中间的studio里面，一个黄色小球按一次开关，单个黄色小球对应一个参数点击下一步，根据具体操作选择第5个命令进入生成数据列表页面，生成的格式不一样，点击保存生成目录在进入控制台窗口，选择ctrl+alt+t，选择createdatalibrary并选择c盘，右键pdfs文件夹，选。
python抓取动态网页(工具分析登录页面打开登录过程从分析可以看到哪些信息)
网站优化 • 优采云 发表了文章 • 0 个评论 • 41 次浏览 • 2022-04-06 17:35
python抓取动态网页(工具分析登录页面打开登录过程从分析可以看到哪些信息)
最近的项目在做一些数据集成，各种系统对应的接口就更奇怪了。数据整合的过程可以用八个字来概括：山中开路，水中搭桥。
这两天刚遇到一个问题。我们要集成的WEB系统没有提供专门的数据集成接口，没有API可以调整，不允许访问数据库。无奈之下，我想知道我们是否可以使用python自动爬取页面。网页有SSO，应该使用开源的CAS框架，后续所有页面都是通过动态JS和AJAX异步加载的，这显然不像普通的静态页面。对页面结构和爬取内容的分析是必不可少的。
工具分析登陆页面
打开登录页面，按F12打开Chrome自带的分析工具，在Network选项卡上可以看到当前浏览器显示页面的详细信息和提交的登录信息，如下图
一个 网站 登录页面
从截图可以看到，当我们访问app/这个url的日志时，由于我们还没有登录，SSO会自动将我们重定向到登录页面，所以http状态是302重定向。
接下来，我们在页面输入账号密码，点击登录按钮，通过页面跟踪分析整个登录过程，模拟整个登录过程。这个过程需要特别小心，因为很多CAS在登录页面上埋下了很多隐藏的标记，有可能会错误的模仿一个地方。它将无法登录并被重定向到它开始的地方。
分析登录过程
从分析可以看出，在提交登录按钮的时候，会通过POST提交一个表单，而且表单中除了账号密码、密码等显眼的字段外，还有一个lt。经验告诉我们，这个字段在之前的登录页面应该是隐藏的。用于验证登录页面的合法性，因此我们需要从登录页面中查找并提取此信息。同时，注意HTTP消息头。最好根据浏览器捕获的消息头来构造，因为网站也会验证里面的信息。
以下是登录的主要代码。我们基于python3和requests包处理https访问请求，并模拟浏览器的行为构造认证所需的信息发送给网站。
import requestsimport urllib3from lxml import etreefrom ows_scrapy.ows_spider.write_csv import write_list_to_csv
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
s = requests.session()
s.trust_env = False # fastercookie = Noneusername = 'username'password = 'pwd'def login():
header = { 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8', 'Accept-Encoding': 'gzip, deflate, br', 'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8', 'Connection': 'keep-alive', 'Cookie': 'JSESSIONID=73E10849812940333A4AD2A2ABAEFB7D8CFF3E76A45340FFB687FD587D2EB97A49FC5F156D09DB1E17F129465AB8D8EBACEC', 'Host': '', 'Upgrade-Insecure-Requests': '1', 'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36'
}
form_data = { 'username': username, 'password': password, '_eventId': 'submit', 'pwdfirst': password[0:2], 'pwdsecond': password[2:5], 'pwdthird': password[5:]
}
login_url = 'https://.com/app/'
print('login...')
res = s.get(login_url, headers=header, verify=False) global cookie
cookie = res.cookies # 注意要保存cookie
print("get response from ows {0}, http status {1}".format(login_url, res.status_code))
login_url = res.url
header['Referer'] = login_url
header['Cookie'] = 'JSESSIONID=' + cookie['JSESSIONID']
form_data['lt'] = str(etree.HTML(res.content).xpath('//input[@name="lt"]/@value')[0]) #用xpath从页面上提取lt
res = s.post(login_url, headers=header, params=form_data, cookies=cookie, allow_redirects=False, verify=False)
cookie = res.cookies
print("post login params to {0}, http status {1}, cookie : {2}".format(login_url, res.status_code, cookie))
res = s.send(res.next, allow_redirects=False, verify=False)
cookie = res.cookies
print("redirect to {0}, http status {1}, cookie : {2}".format(login_url, res.status_code, cookie)) if res.status_code == 200 or res.status_code == 302: if cookie is not None and cookie.get(name='JSESSIONID', path='/app') is not None :
print('Successful login.') else:
print('WRONG w3id/password!')
sys.exit(0)
这里要特别注意，因为http是无状态的，网页需要使用cookie来保存登录状态。页面成功后，页面的响应会收录一个带有有效标记的cookie。登录的最终目的是获取和保存。这是一个有效的 cookie，因此后续访问不会被重定向到登录页面。
在requests方法中，只需要像这样将cookie带入request即可
res = s.post(login_url, headers=header, params=form_data, cookies=cookie, allow_redirects=False, verify=False)
分析动态内容页面
在动态页面中，页面上显示的内容往往是通过js或者AJAX异步获取的，这与静态html页面的分析过程明显不同。这些信息也可以通过 Chrome 的分析工具轻松获得。
分析动态页面
动态页面加载完成后，我们从所有请求中过滤XHR类型，找到我们想要的请求，然后在请求的Preview中可以看到完整的对应信息，请求的URL也可以从Received中下载从标题选项卡。
接下来要做的和上面类似，构造一个消息来模拟浏览器向网站发送请求：
def get_content(order_id):
form_data = { 'roarand': 'BW09el5W3mW2sfbGbtWe7mWlwBsWqXg6znppnqkW3woJ5fcz5DnhfWXGonqkLsd0', 'start': '0', 'limit': '20', 'orderid': order_id, 'serviceId': 'test_gscsocsecurityincidentmanage_log_getList2'
}
header = { 'Accept': 'text/plain, */*; q=0.01', 'Accept-Encoding': 'gzip, deflate, br', 'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8', 'Connection': 'keep-alive', 'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8', 'Host': '.com', 'Origin': 'https://.com', 'Referer': 'https://.com/app/104h/spl/test ... 39%3B, 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36', 'X-Requested-With': 'XMLHttpRequest'
}
print('Start to scan order id ' + order_id)
url = 'https://.com/app/pageservices/ ... og%3D{serviceName:test_gscsocsecurityincidentmanage_log_getList2,userId:571bdd42-10ca-4ce1-b41c-8a3f6632141f,tenantId:104h}&trackId=fec68f8e-f30a-4fa1-a8b1-41d3dd11fa4c'
res = s.post(url, headers=header, params=form_data, cookies=cookie, allow_redirects=False, verify=False) #要加载上面登录成功的cookie
print(res.content) return res
重点其实是从XHR中找到请求的URI，构造请求头并提交表单，最后加上登录成功cookie，否则会重定向到登录页面。
爬取动态页面的方法有很多。这种方式依赖的包比较少，代码也比较灵活。在爬取复杂的登录页面时效果更好，但在分析页面登录机制时需要特别小心。 查看全部
最近的项目在做一些数据集成，各种系统对应的接口就更奇怪了。数据整合的过程可以用八个字来概括：山中开路，水中搭桥。
这两天刚遇到一个问题。我们要集成的WEB系统没有提供专门的数据集成接口，没有API可以调整，不允许访问数据库。无奈之下，我想知道我们是否可以使用python自动爬取页面。网页有SSO，应该使用开源的CAS框架，后续所有页面都是通过动态JS和AJAX异步加载的，这显然不像普通的静态页面。对页面结构和爬取内容的分析是必不可少的。
工具分析登陆页面
打开登录页面，按F12打开Chrome自带的分析工具，在Network选项卡上可以看到当前浏览器显示页面的详细信息和提交的登录信息，如下图
一个 网站 登录页面
从截图可以看到，当我们访问app/这个url的日志时，由于我们还没有登录，SSO会自动将我们重定向到登录页面，所以http状态是302重定向。
接下来，我们在页面输入账号密码，点击登录按钮，通过页面跟踪分析整个登录过程，模拟整个登录过程。这个过程需要特别小心，因为很多CAS在登录页面上埋下了很多隐藏的标记，有可能会错误的模仿一个地方。它将无法登录并被重定向到它开始的地方。
分析登录过程
从分析可以看出，在提交登录按钮的时候，会通过POST提交一个表单，而且表单中除了账号密码、密码等显眼的字段外，还有一个lt。经验告诉我们，这个字段在之前的登录页面应该是隐藏的。用于验证登录页面的合法性，因此我们需要从登录页面中查找并提取此信息。同时，注意HTTP消息头。最好根据浏览器捕获的消息头来构造，因为网站也会验证里面的信息。
以下是登录的主要代码。我们基于python3和requests包处理https访问请求，并模拟浏览器的行为构造认证所需的信息发送给网站。
import requestsimport urllib3from lxml import etreefrom ows_scrapy.ows_spider.write_csv import write_list_to_csv
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
s = requests.session()
s.trust_env = False # fastercookie = Noneusername = 'username'password = 'pwd'def login():
header = { 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8', 'Accept-Encoding': 'gzip, deflate, br', 'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8', 'Connection': 'keep-alive', 'Cookie': 'JSESSIONID=73E10849812940333A4AD2A2ABAEFB7D8CFF3E76A45340FFB687FD587D2EB97A49FC5F156D09DB1E17F129465AB8D8EBACEC', 'Host': '', 'Upgrade-Insecure-Requests': '1', 'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36'
}
form_data = { 'username': username, 'password': password, '_eventId': 'submit', 'pwdfirst': password[0:2], 'pwdsecond': password[2:5], 'pwdthird': password[5:]
}
login_url = 'https://.com/app/'
print('login...')
res = s.get(login_url, headers=header, verify=False) global cookie
cookie = res.cookies # 注意要保存cookie
print("get response from ows {0}, http status {1}".format(login_url, res.status_code))
login_url = res.url
header['Referer'] = login_url
header['Cookie'] = 'JSESSIONID=' + cookie['JSESSIONID']
form_data['lt'] = str(etree.HTML(res.content).xpath('//input[@name="lt"]/@value')[0]) #用xpath从页面上提取lt
res = s.post(login_url, headers=header, params=form_data, cookies=cookie, allow_redirects=False, verify=False)
cookie = res.cookies
print("post login params to {0}, http status {1}, cookie : {2}".format(login_url, res.status_code, cookie))
res = s.send(res.next, allow_redirects=False, verify=False)
cookie = res.cookies
print("redirect to {0}, http status {1}, cookie : {2}".format(login_url, res.status_code, cookie)) if res.status_code == 200 or res.status_code == 302: if cookie is not None and cookie.get(name='JSESSIONID', path='/app') is not None :
print('Successful login.') else:
print('WRONG w3id/password!')
sys.exit(0)
这里要特别注意，因为http是无状态的，网页需要使用cookie来保存登录状态。页面成功后，页面的响应会收录一个带有有效标记的cookie。登录的最终目的是获取和保存。这是一个有效的 cookie，因此后续访问不会被重定向到登录页面。
在requests方法中，只需要像这样将cookie带入request即可
res = s.post(login_url, headers=header, params=form_data, cookies=cookie, allow_redirects=False, verify=False)
分析动态内容页面
在动态页面中，页面上显示的内容往往是通过js或者AJAX异步获取的，这与静态html页面的分析过程明显不同。这些信息也可以通过 Chrome 的分析工具轻松获得。
分析动态页面
动态页面加载完成后，我们从所有请求中过滤XHR类型，找到我们想要的请求，然后在请求的Preview中可以看到完整的对应信息，请求的URL也可以从Received中下载从标题选项卡。
接下来要做的和上面类似，构造一个消息来模拟浏览器向网站发送请求：
def get_content(order_id):
form_data = { 'roarand': 'BW09el5W3mW2sfbGbtWe7mWlwBsWqXg6znppnqkW3woJ5fcz5DnhfWXGonqkLsd0', 'start': '0', 'limit': '20', 'orderid': order_id, 'serviceId': 'test_gscsocsecurityincidentmanage_log_getList2'
}
header = { 'Accept': 'text/plain, */*; q=0.01', 'Accept-Encoding': 'gzip, deflate, br', 'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8', 'Connection': 'keep-alive', 'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8', 'Host': '.com', 'Origin': 'https://.com', 'Referer': 'https://.com/app/104h/spl/test ... 39%3B, 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36', 'X-Requested-With': 'XMLHttpRequest'
}
print('Start to scan order id ' + order_id)
url = 'https://.com/app/pageservices/ ... og%3D{serviceName:test_gscsocsecurityincidentmanage_log_getList2,userId:571bdd42-10ca-4ce1-b41c-8a3f6632141f,tenantId:104h}&trackId=fec68f8e-f30a-4fa1-a8b1-41d3dd11fa4c'
res = s.post(url, headers=header, params=form_data, cookies=cookie, allow_redirects=False, verify=False) #要加载上面登录成功的cookie
print(res.content) return res
重点其实是从XHR中找到请求的URI，构造请求头并提交表单，最后加上登录成功cookie，否则会重定向到登录页面。
爬取动态页面的方法有很多。这种方式依赖的包比较少，代码也比较灵活。在爬取复杂的登录页面时效果更好，但在分析页面登录机制时需要特别小心。 查看全部
python抓取动态网页(工具分析登录页面打开登录过程从分析可以看到哪些信息)
最近的项目在做一些数据集成，各种系统对应的接口就更奇怪了。数据整合的过程可以用八个字来概括：山中开路，水中搭桥。
这两天刚遇到一个问题。我们要集成的WEB系统没有提供专门的数据集成接口，没有API可以调整，不允许访问数据库。无奈之下，我想知道我们是否可以使用python自动爬取页面。网页有SSO，应该使用开源的CAS框架，后续所有页面都是通过动态JS和AJAX异步加载的，这显然不像普通的静态页面。对页面结构和爬取内容的分析是必不可少的。
工具分析登陆页面
打开登录页面，按F12打开Chrome自带的分析工具，在Network选项卡上可以看到当前浏览器显示页面的详细信息和提交的登录信息，如下图
一个 网站 登录页面
从截图可以看到，当我们访问app/这个url的日志时，由于我们还没有登录，SSO会自动将我们重定向到登录页面，所以http状态是302重定向。
接下来，我们在页面输入账号密码，点击登录按钮，通过页面跟踪分析整个登录过程，模拟整个登录过程。这个过程需要特别小心，因为很多CAS在登录页面上埋下了很多隐藏的标记，有可能会错误的模仿一个地方。它将无法登录并被重定向到它开始的地方。
分析登录过程
从分析可以看出，在提交登录按钮的时候，会通过POST提交一个表单，而且表单中除了账号密码、密码等显眼的字段外，还有一个lt。经验告诉我们，这个字段在之前的登录页面应该是隐藏的。用于验证登录页面的合法性，因此我们需要从登录页面中查找并提取此信息。同时，注意HTTP消息头。最好根据浏览器捕获的消息头来构造，因为网站也会验证里面的信息。
以下是登录的主要代码。我们基于python3和requests包处理https访问请求，并模拟浏览器的行为构造认证所需的信息发送给网站。
import requestsimport urllib3from lxml import etreefrom ows_scrapy.ows_spider.write_csv import write_list_to_csv
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
s = requests.session()
s.trust_env = False # fastercookie = Noneusername = 'username'password = 'pwd'def login():
header = { 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8', 'Accept-Encoding': 'gzip, deflate, br', 'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8', 'Connection': 'keep-alive', 'Cookie': 'JSESSIONID=73E10849812940333A4AD2A2ABAEFB7D8CFF3E76A45340FFB687FD587D2EB97A49FC5F156D09DB1E17F129465AB8D8EBACEC', 'Host': '', 'Upgrade-Insecure-Requests': '1', 'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36'
}
form_data = { 'username': username, 'password': password, '_eventId': 'submit', 'pwdfirst': password[0:2], 'pwdsecond': password[2:5], 'pwdthird': password[5:]
}
login_url = 'https://.com/app/'
print('login...')
res = s.get(login_url, headers=header, verify=False) global cookie
cookie = res.cookies # 注意要保存cookie
print("get response from ows {0}, http status {1}".format(login_url, res.status_code))
login_url = res.url
header['Referer'] = login_url
header['Cookie'] = 'JSESSIONID=' + cookie['JSESSIONID']
form_data['lt'] = str(etree.HTML(res.content).xpath('//input[@name="lt"]/@value')[0]) #用xpath从页面上提取lt
res = s.post(login_url, headers=header, params=form_data, cookies=cookie, allow_redirects=False, verify=False)
cookie = res.cookies
print("post login params to {0}, http status {1}, cookie : {2}".format(login_url, res.status_code, cookie))
res = s.send(res.next, allow_redirects=False, verify=False)
cookie = res.cookies
print("redirect to {0}, http status {1}, cookie : {2}".format(login_url, res.status_code, cookie)) if res.status_code == 200 or res.status_code == 302: if cookie is not None and cookie.get(name='JSESSIONID', path='/app') is not None :
print('Successful login.') else:
print('WRONG w3id/password!')
sys.exit(0)
这里要特别注意，因为http是无状态的，网页需要使用cookie来保存登录状态。页面成功后，页面的响应会收录一个带有有效标记的cookie。登录的最终目的是获取和保存。这是一个有效的 cookie，因此后续访问不会被重定向到登录页面。
在requests方法中，只需要像这样将cookie带入request即可
res = s.post(login_url, headers=header, params=form_data, cookies=cookie, allow_redirects=False, verify=False)
分析动态内容页面
在动态页面中，页面上显示的内容往往是通过js或者AJAX异步获取的，这与静态html页面的分析过程明显不同。这些信息也可以通过 Chrome 的分析工具轻松获得。
分析动态页面
动态页面加载完成后，我们从所有请求中过滤XHR类型，找到我们想要的请求，然后在请求的Preview中可以看到完整的对应信息，请求的URL也可以从Received中下载从标题选项卡。
接下来要做的和上面类似，构造一个消息来模拟浏览器向网站发送请求：
def get_content(order_id):
form_data = { 'roarand': 'BW09el5W3mW2sfbGbtWe7mWlwBsWqXg6znppnqkW3woJ5fcz5DnhfWXGonqkLsd0', 'start': '0', 'limit': '20', 'orderid': order_id, 'serviceId': 'test_gscsocsecurityincidentmanage_log_getList2'
}
header = { 'Accept': 'text/plain, */*; q=0.01', 'Accept-Encoding': 'gzip, deflate, br', 'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8', 'Connection': 'keep-alive', 'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8', 'Host': '.com', 'Origin': 'https://.com', 'Referer': 'https://.com/app/104h/spl/test ... 39%3B, 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36', 'X-Requested-With': 'XMLHttpRequest'
}
print('Start to scan order id ' + order_id)
url = 'https://.com/app/pageservices/ ... og%3D{serviceName:test_gscsocsecurityincidentmanage_log_getList2,userId:571bdd42-10ca-4ce1-b41c-8a3f6632141f,tenantId:104h}&trackId=fec68f8e-f30a-4fa1-a8b1-41d3dd11fa4c'
res = s.post(url, headers=header, params=form_data, cookies=cookie, allow_redirects=False, verify=False) #要加载上面登录成功的cookie
print(res.content) return res
重点其实是从XHR中找到请求的URI，构造请求头并提交表单，最后加上登录成功cookie，否则会重定向到登录页面。
爬取动态页面的方法有很多。这种方式依赖的包比较少，代码也比较灵活。在爬取复杂的登录页面时效果更好，但在分析页面登录机制时需要特别小心。
python抓取动态网页(使用selenium爬取动态网页信息Pythonselenium自动控制 )
网站优化 • 优采云 发表了文章 • 0 个评论 • 53 次浏览 • 2022-04-06 14:07
python抓取动态网页(使用selenium爬取动态网页信息Pythonselenium自动控制
)
使用selenium爬取动态网页信息
python selenium自动控制浏览器抓取网页数据，包括按钮点击、页面跳转、搜索框输入、页面值数据存储、mongodb自动id识别等。
首先介绍一下Python selenium——一个自动化测试工具，用来控制浏览器对网页的操作。当与爬虫中的 BeautifulSoup 结合使用时，它是无缝的。除了国外的一些异常验证页面，图片验证码我自己写了破解。图片验证码源码，成功率85%。
使用 conda 管家安装：
在cmd命令行输入“conda install selenium”进行安装
还需要安装 Google Chrome Drive 或 Firefox 插件
设置环境变量
通过selenium访问百度
from selenium import webdriver
#打开一个浏览器
browser = webdriver.Chrome()
#准备一个网址
url = 'http://www.baidu.com'
browser.get(url)
#获取元素
login = browser.find_elements_by_class_name('lb')[0]
print(login)
获取网易云音乐
from selenium import webdriver
#打开浏览器
brower = webdriver.Chrome()
url='https://music.163.com/#/discover/toplist'
brower.get(url)
#寻找logo文字
#logo = brower.find_elements_by_class_name('logo')[0]
#print(logo.text)
#一般情况下动态加载的内容都可以找到
#有一种情况就没有
#就是网页内存在网页框架iframe
#需要切换网页的层级
#语法：brower.switch_to.frame(iframe的id或者你提前获取这个对象，放入此处）
#方法一：id
#brower.switch_to.frame('g_iframe')
#方法二：name
#brower.switch_to.frame('contentFrame')
#方法三：提前用变量存iframe
iframe = brower.find_element_by_id('g_iframe')
brower.switch_to.frame(iframe)
#寻找大容器
toplist = brower.find_element_by_id('toplist')
#寻找tbody 通过标签名
tbody = toplist.find_elements_by_tag_name('tbody')[0]
#寻找所有tr
trs = tbody.find_elements_by_tag_name('tr')
dataList = []
for each in trs:
#排名
rank = each.find_elements_by_tag_name('td')[0].find_elements_by_class_name('num')[0].text
musicName = each.find_elements_by_tag_name('td')[1].find_elements_by_class_name('txt')[0].\
find_element_by_tag_name('b').get_attribute('title')
#print(musicName)
singer = each.find_elements_by_tag_name('td')[3].find_elements_by_class_name('text')[0].\
get_attribute('title')
#print(singer)
dataList.append([rank,musicName,singer])
#print(dataList)
from openpyxl import Workbook
wb = Workbook()
ws = wb.active
ws.title = '云音乐飙升榜'
ws.append(['排名','歌名','歌手'])
for data in dataList:
ws.append(data)
wb.save("云音乐飙升榜.xlsx") 查看全部
)
使用selenium爬取动态网页信息
python selenium自动控制浏览器抓取网页数据，包括按钮点击、页面跳转、搜索框输入、页面值数据存储、mongodb自动id识别等。
首先介绍一下Python selenium——一个自动化测试工具，用来控制浏览器对网页的操作。当与爬虫中的 BeautifulSoup 结合使用时，它是无缝的。除了国外的一些异常验证页面，图片验证码我自己写了破解。图片验证码源码，成功率85%。
使用 conda 管家安装：
在cmd命令行输入“conda install selenium”进行安装
还需要安装 Google Chrome Drive 或 Firefox 插件
设置环境变量
通过selenium访问百度
from selenium import webdriver
#打开一个浏览器
browser = webdriver.Chrome()
#准备一个网址
url = 'http://www.baidu.com'
browser.get(url)
#获取元素
login = browser.find_elements_by_class_name('lb')[0]
print(login)
获取网易云音乐
from selenium import webdriver
#打开浏览器
brower = webdriver.Chrome()
url='https://music.163.com/#/discover/toplist'
brower.get(url)
#寻找logo文字
#logo = brower.find_elements_by_class_name('logo')[0]
#print(logo.text)
#一般情况下动态加载的内容都可以找到
#有一种情况就没有
#就是网页内存在网页框架iframe
#需要切换网页的层级
#语法：brower.switch_to.frame(iframe的id或者你提前获取这个对象，放入此处）
#方法一：id
#brower.switch_to.frame('g_iframe')
#方法二：name
#brower.switch_to.frame('contentFrame')
#方法三：提前用变量存iframe
iframe = brower.find_element_by_id('g_iframe')
brower.switch_to.frame(iframe)
#寻找大容器
toplist = brower.find_element_by_id('toplist')
#寻找tbody 通过标签名
tbody = toplist.find_elements_by_tag_name('tbody')[0]
#寻找所有tr
trs = tbody.find_elements_by_tag_name('tr')
dataList = []
for each in trs:
#排名
rank = each.find_elements_by_tag_name('td')[0].find_elements_by_class_name('num')[0].text
musicName = each.find_elements_by_tag_name('td')[1].find_elements_by_class_name('txt')[0].\
find_element_by_tag_name('b').get_attribute('title')
#print(musicName)
singer = each.find_elements_by_tag_name('td')[3].find_elements_by_class_name('text')[0].\
get_attribute('title')
#print(singer)
dataList.append([rank,musicName,singer])
#print(dataList)
from openpyxl import Workbook
wb = Workbook()
ws = wb.active
ws.title = '云音乐飙升榜'
ws.append(['排名','歌名','歌手'])
for data in dataList:
ws.append(data)
wb.save("云音乐飙升榜.xlsx") 查看全部
python抓取动态网页(使用selenium爬取动态网页信息Pythonselenium自动控制
)
使用selenium爬取动态网页信息
python selenium自动控制浏览器抓取网页数据，包括按钮点击、页面跳转、搜索框输入、页面值数据存储、mongodb自动id识别等。
首先介绍一下Python selenium——一个自动化测试工具，用来控制浏览器对网页的操作。当与爬虫中的 BeautifulSoup 结合使用时，它是无缝的。除了国外的一些异常验证页面，图片验证码我自己写了破解。图片验证码源码，成功率85%。
使用 conda 管家安装：
在cmd命令行输入“conda install selenium”进行安装
还需要安装 Google Chrome Drive 或 Firefox 插件
设置环境变量
通过selenium访问百度
from selenium import webdriver
#打开一个浏览器
browser = webdriver.Chrome()
#准备一个网址
url = 'http://www.baidu.com'
browser.get(url)
#获取元素
login = browser.find_elements_by_class_name('lb')[0]
print(login)
获取网易云音乐
from selenium import webdriver
#打开浏览器
brower = webdriver.Chrome()
url='https://music.163.com/#/discover/toplist'
brower.get(url)
#寻找logo文字
#logo = brower.find_elements_by_class_name('logo')[0]
#print(logo.text)
#一般情况下动态加载的内容都可以找到
#有一种情况就没有
#就是网页内存在网页框架iframe
#需要切换网页的层级
#语法：brower.switch_to.frame(iframe的id或者你提前获取这个对象，放入此处）
#方法一：id
#brower.switch_to.frame('g_iframe')
#方法二：name
#brower.switch_to.frame('contentFrame')
#方法三：提前用变量存iframe
iframe = brower.find_element_by_id('g_iframe')
brower.switch_to.frame(iframe)
#寻找大容器
toplist = brower.find_element_by_id('toplist')
#寻找tbody 通过标签名
tbody = toplist.find_elements_by_tag_name('tbody')[0]
#寻找所有tr
trs = tbody.find_elements_by_tag_name('tr')
dataList = []
for each in trs:
#排名
rank = each.find_elements_by_tag_name('td')[0].find_elements_by_class_name('num')[0].text
musicName = each.find_elements_by_tag_name('td')[1].find_elements_by_class_name('txt')[0].\
find_element_by_tag_name('b').get_attribute('title')
#print(musicName)
singer = each.find_elements_by_tag_name('td')[3].find_elements_by_class_name('text')[0].\
get_attribute('title')
#print(singer)
dataList.append([rank,musicName,singer])
#print(dataList)
from openpyxl import Workbook
wb = Workbook()
ws = wb.active
ws.title = '云音乐飙升榜'
ws.append(['排名','歌名','歌手'])
for data in dataList:
ws.append(data)
wb.save("云音乐飙升榜.xlsx")
python抓取动态网页( 爬取需要安装Xpath和firebug两个插件（用于xpath定位）)
网站优化 • 优采云 发表了文章 • 0 个评论 • 41 次浏览 • 2022-04-06 06:16
python抓取动态网页(
爬取需要安装Xpath和firebug两个插件（用于xpath定位）)
browser = webdriver.Firefox() # Get local session of Firefox
browser.get("www.baidu.com") # Load page
在一般的静态网页中，我们需要爬取的信息是直接写在源码中的。我们可以很方便地使用正则表达式来抓取，例如：
rr.firstInit({"data":[{"author":"袁莉,翟坤","change":"第一次","companyCode":"80116848","datetime":"2016-01- 28T08 : 13:29","infoCode":"APPH2FEzZ2tFASearchReport","insCode":"80000031","insName":"东吴证券","insStar":"3","jlrs": ["206000000","259000000 ","352000000","",""],"rate":"Accumulation","secuFullCode":"002322.SZ","secuName":"科技监测","sratingName": "加","sy":"","syls":["24.4","19.37","14.19",""," "],"sys":["0.5","0.63","0.86","",""],"title" :"业绩有望触底，收购整合加速","profitYear":"2014","type ":"1","newPrice":"16.17"},
但是对于js生成的动态页面，我们需要模拟浏览器加载页面的行为，然后爬取：
所以我们需要准备的是python3+selenium+firefox 其中firefox需要安装Xpath checker和firebug两个插件（用于xpath定位）
首先我们需要通过：
browser = webdriver.Firefox() # Get local session of Firefox
time.sleep(5)
browser.get("https://www.baidu.com/") # Load page
加载页面。然后通过页面上的Xpath插件定位到我们需要爬取的信息。
最后一次使用
elem = browser.find_element_by_xpath("xpath")
获取我们需要抓取的信息。
最后定位翻页和跳页控件，完成所有网页的爬取。 查看全部
爬取需要安装Xpath和firebug两个插件（用于xpath定位）)
browser = webdriver.Firefox() # Get local session of Firefox
browser.get("www.baidu.com") # Load page
在一般的静态网页中，我们需要爬取的信息是直接写在源码中的。我们可以很方便地使用正则表达式来抓取，例如：
rr.firstInit({"data":[{"author":"袁莉,翟坤","change":"第一次","companyCode":"80116848","datetime":"2016-01- 28T08 : 13:29","infoCode":"APPH2FEzZ2tFASearchReport","insCode":"80000031","insName":"东吴证券","insStar":"3","jlrs": ["206000000","259000000 ","352000000","",""],"rate":"Accumulation","secuFullCode":"002322.SZ","secuName":"科技监测","sratingName": "加","sy":"","syls":["24.4","19.37","14.19",""," "],"sys":["0.5","0.63","0.86","",""],"title" :"业绩有望触底，收购整合加速","profitYear":"2014","type ":"1","newPrice":"16.17"},
但是对于js生成的动态页面，我们需要模拟浏览器加载页面的行为，然后爬取：
所以我们需要准备的是python3+selenium+firefox 其中firefox需要安装Xpath checker和firebug两个插件（用于xpath定位）
首先我们需要通过：
browser = webdriver.Firefox() # Get local session of Firefox
time.sleep(5)
browser.get("https://www.baidu.com/") # Load page
加载页面。然后通过页面上的Xpath插件定位到我们需要爬取的信息。
最后一次使用
elem = browser.find_element_by_xpath("xpath")
获取我们需要抓取的信息。
最后定位翻页和跳页控件，完成所有网页的爬取。 查看全部
python抓取动态网页(
爬取需要安装Xpath和firebug两个插件（用于xpath定位）)
browser = webdriver.Firefox() # Get local session of Firefox
browser.get("www.baidu.com") # Load page
在一般的静态网页中，我们需要爬取的信息是直接写在源码中的。我们可以很方便地使用正则表达式来抓取，例如：
rr.firstInit({"data":[{"author":"袁莉,翟坤","change":"第一次","companyCode":"80116848","datetime":"2016-01- 28T08 : 13:29","infoCode":"APPH2FEzZ2tFASearchReport","insCode":"80000031","insName":"东吴证券","insStar":"3","jlrs": ["206000000","259000000 ","352000000","",""],"rate":"Accumulation","secuFullCode":"002322.SZ","secuName":"科技监测","sratingName": "加","sy":"","syls":["24.4","19.37","14.19",""," "],"sys":["0.5","0.63","0.86","",""],"title" :"业绩有望触底，收购整合加速","profitYear":"2014","type ":"1","newPrice":"16.17"},
但是对于js生成的动态页面，我们需要模拟浏览器加载页面的行为，然后爬取：
所以我们需要准备的是python3+selenium+firefox 其中firefox需要安装Xpath checker和firebug两个插件（用于xpath定位）
首先我们需要通过：
browser = webdriver.Firefox() # Get local session of Firefox
time.sleep(5)
browser.get("https://www.baidu.com/";) # Load page
加载页面。然后通过页面上的Xpath插件定位到我们需要爬取的信息。
最后一次使用
elem = browser.find_element_by_xpath("xpath")
获取我们需要抓取的信息。
最后定位翻页和跳页控件，完成所有网页的爬取。
python抓取动态网页( 2.用正则表达式匹配获取数据(图)打印显示(组图))
网站优化 • 优采云 发表了文章 • 0 个评论 • 48 次浏览 • 2022-04-06 06:14
python抓取动态网页(
2.用正则表达式匹配获取数据(图)打印显示(组图))
爬行打印展示
通过上面的对比，我们爬取的是网页的源码。我们只需要对页面返回的内容进行过滤，提取出我们想要的部分数据，但通常很多网站都有反爬虫机制需要预处理。最后，将获取的数据写入文件或数据库，用于持久化数据存储。
步骤：通过url发送请求————>等待服务器响应————>获取网页源代码————>解析页面————>过滤————>数据保存
在上述步骤中，获取网页的源代码和解析页面是最重要的。这两个部分通常是最困难的。它们主要处理网页上的各种反爬机制。有时您的道德页面的源代码可能与网页的源代码不同。完全一样，需要对比分析。
2. 获取正则表达式匹配的数据
与其他方法相比，正则表达式是爬虫获取数据的一种非常有效的方法。它只需要在特殊模式下传递返回的网页源字符串和模式匹配，就可以找到我们想要的。所需的数据。但是，正则表达式的匹配模式对于初学者来说也有点难写，以实现快速精确的匹配。
正则表达式的使用可以概括为以下两种：
在自己写的pattern中编译，创建一个pattern对象（pattern），然后传入函数，只需要传入函数中要匹配的字符串即可。
通过 re.function name('match pattern', 'string to match') 找到需要的字符
当需要多次使用相同的匹配模式来选择第一种方法时，当匹配模式只需要使用一次来选择第二种方法时。
如果正则表达式匹配成功，则返回的数据类型为字符串，如果匹配失败，则返回None。但是，我们在查看匹配结果的时候，最好先判断一下匹配成功与否，以防报错。
常用的匹配函数如下：
函数名对应的函数描述
匹配（）
从前到后匹配，只有一次。如果匹配成功，返回re.Match对象，然后调用group()查看对应的值
全匹配（）
从前到后匹配，只匹配一次并进行完整匹配
搜索（）
搜索满足匹配模式的字符串，只匹配一次
找到所有（）
搜索所有满足匹配模式的字符并返回一个列表，列表中的每个元素都是一个满足匹配模式的字符串
在爬虫中，findall通常用于匹配查找所有符合匹配模式的字符串，通过遍历列表查看数据
正则表达式的特殊字符有以下含义：
数量限定词
特殊字符
\u4e00-\u9fa5 只匹配中文字体
位置相关字符
常见匹配字符
3. 页面源码分析
页面显示的内容
页面来源
通过对比两张图，我们可以看到，我们看到的和服务器返回给我们的还是有很大区别的。我们可以在页面上看到图片和文字，还有一些视频，但是网页的源代码都是纯文本，源代码中的图片和视频与链接一一对应。这意味着我们需要源代码提供的链接来访问图片和视频等。
在爬虫中分析网页源代码是一项非常重要的技能，需要通过不断的探索找到一些共性。最好对 CSS 和 JS 有一定的了解，了解网页显示给我的原理。
4. 通过请求爬取静态页面
对于从requests请求页面获取的源代码，需要进行预处理。常用的预处理通过 CSS 选择器和 xpath 过滤掉我们想要的内容。
4.1 css选择器基本语法选择器示例示例说明
。班级
。介绍
选择所有带有 class="intro" 的元素
＃ID
＃名
选择 id="firstname" 的所有元素
*
*
选择所有元素
元素
p
全选
元素
元素，元素
格，p
全选
元素和
元素
元素元素
分区 p
选择
全部在元素内
元素
在使用CSS选择器定位元素时，当有一个可以通过id定位的首选id时，id属性对应的值是唯一的，那么就为status元素考虑class属性。如果class属性有多个值，则需要选择一个。能。
4.2 xpath 基本语法
官方帮助文档：
表达描述
节点名
选择该节点的所有子节点
/
从当前节点中选择子节点
//
从当前节点中选择后代节点
.
选择当前节点
…
选择当前节点的父节点
@
选择属性
xpath 还可以结合运算符来定位元素
xpath 中的谓词
谓词用于查找特定节点或收录指定值的节点。
谓词用方括号括起来。
选择未知节点
选择多条路径
在以上基础上，通过案例进行如下具体分析：
通过CSS选择器方法获取豆瓣上排名前25的电影名
import requests
from bs4 import BeautifulSoup as Bs
url = 'https://movie.douban.com/top250'
# 设置请求头
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36',
# 先登录，通过开发者工具控制台获取
'Cookies': '**************************************************'
}
# 建立连接
resp = requests.get(url=url, headers=headers)
print(resp.status_code) # 查看是否访问成功，出现200就说明访问成功
if resp.status_code == 200:
soup = Bs(resp.text, 'lxml') # 进行预处理
title_list = soup.select('div.hd > a > span:nth-child(1)') # 找到标题对应的标签
for title in title_list:
print(title.text, end='\t') # 打印输出电影标题
'''
200
肖申克的救赎 霸王别姬 阿甘正传 这个杀手不太冷 泰坦尼克号 美丽人生 千与千寻 辛德勒的名单 盗梦空间 忠犬八公的故事 星际穿越 楚门的世界 海上钢琴师 三傻大闹宝莱坞 机器人总动员 放牛班的春天 无间道 疯狂动物城 大话西游之大圣娶亲 熔炉 教父 当幸福来敲门 龙猫 怦然心动 控方证人
'''
通过xpath选择器方法获取豆瓣排名前25的电影名
import requests
from bs4 import BeautifulSoup as Bs
from lxml import etree
url = 'https://movie.douban.com/top250'
# 设置请求头
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36',
'Cookies': '**************************************'
}
# 建立连接
resp = requests.get(url=url, headers=headers)
if resp.status_code == 200:
html = etree.HTML(resp.text) # 预处理
title_list = html.xpath('//div[@class= "hd"]/a[@href]/span[1]/text()')
for title in title_list:
print(title, end='\t')
'''
肖申克的救赎 霸王别姬 阿甘正传 这个杀手不太冷 泰坦尼克号 美丽人生 千与千寻 辛德勒的名单 盗梦空间 忠犬八公的故事 星际穿越 楚门的世界 海上钢琴师 三傻大闹宝莱坞 机器人总动员 放牛班的春天 无间道 疯狂动物城 大话西游之大圣娶亲 熔炉 教父 当幸福来敲门 龙猫 怦然心动 控方证人
'''
在爬取页面数据时，我们通常选择xpath进行爬取，这显然比通过css选择器定位元素更加灵活。爬取静态页面时，通过以上步骤爬取数据，但部分网页内容只能通过登录获取。
4.3 数据通过代理采集
当我们访问同一个网页太琐碎时，一些网站会使用反爬机制来屏蔽你的ip。这需要我们使用不同的 ip 地址多次访问同一个 网站。这个时候只能买ip让别人为你转发，结果返回给你。
通过运营商提供的ip链接获取有效ip
# -*- coding: UTF-8 -*-
"""
此代码为代理IP可用性检测模块，可准确筛选出尚未失效IP
注：
1.此代码只针对TXT数据格式接口。
2.尚未失效IP不一定为爬虫可用IP
3.使用时，请调用check_ip(url)，url为TXT数据格式接口地址
"""
import requests
import telnetlib
import re
from concurrent.futures.thread import ThreadPoolExecutor
# 请求接口，匹配出代理IP，多线程检测
def check_ip(url):
real_ip = []
# 检测代理IP是否失效
def telnet_ip(ip, port):
try:
telnetlib.Telnet(ip, port, timeout=1)
real_ip.append(f'{ip}:{port}')
except:
pass
while True:
try:
resp = requests.get(url)
# print(resp.text)
ip_data = re.findall('(\d+\.\d+\.\d+\.\d+):(\d+)', resp.text)
with ThreadPoolExecutor(max_workers=16) as pool:
for ip, port in ip_data:
pool.submit(telnet_ip, ip, port)
return real_ip
except:
pass
调用ip爬取
"""
example04-利用代理爬取
Version：
Author:
Date:2021/8/17
"""
from check_proxies import check_ip
import requests
from bs4 import BeautifulSoup
# ip地址链接，由运营商提供，具有一定的时效性
URL = 'http://api.66daili.cn/API/GetC ... elite,anonymous,transparent&area=%E4%B8%AD%E5%9B%BD&proxytype=https&speed=fast#api'
ip_list = check_ip(URL)
print(ip_list)
flag = True
while flag:
for i in range(len(ip_list)):
doubna_url = 'https://movie.douban.com/top250'
headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 '
'(KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
}
# 代理ip，会根据要求进行自动选择http或https协议
proxy = {
'http': 'http://' + ip_list[i],
'http': 'https://' + ip_list[i]
}
try:
resp = requests.get(url=doubna_url, headers=headers, proxies=proxy, timeout=1)
if resp.status_code == 200:
print(resp.text)
flag = False
break
except:
print('Erro')
5. 通过 selenium 驱动浏览器并爬取动态页面
通过 selenium 获取页面步骤：
先把驱动放到当前项目中
from selenium import webdriver
url = 'https://www.baidu.com/'
# 创建浏览器对象
b = webdriver.Chrome(./chromedrivers.exe)
# 访问页面
b.get(url)
# 关闭
b.quit()
使用selenium登录京东页面
<p>import getpass
import time
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
url = 'https://www.jd.com/'
options = webdriver.ChromeOptions()
options.add_experimental_option("excludeSwitches", ['enable-automation', 'enable-logging']) # 忽略警告
# options.add_argument('blink-settings=imagesEnabled=false') # 不加载图片
b = webdriver.Chrome(options=options)
b.get(url)
b.find_element_by_id('ttbar-login').click()
b.find_element_by_class_name('login-tab-r').click()
b.find_element_by_id('loginname').send_keys(input('输入账号：'))
b.find_element_by_id('nloginpwd').send_keys(getpass.getpass('输入密码：'))
b.find_element_by_id('loginsubmit').click()
time.sleep(5)
b.find_element_by_id('key').send_keys('python')
b.find_element_by_id('key').send_keys(Keys.ENTER)
max_y = 10000
y = 0
while y 查看全部
2.用正则表达式匹配获取数据(图)打印显示(组图))
爬行打印展示
通过上面的对比，我们爬取的是网页的源码。我们只需要对页面返回的内容进行过滤，提取出我们想要的部分数据，但通常很多网站都有反爬虫机制需要预处理。最后，将获取的数据写入文件或数据库，用于持久化数据存储。
步骤：通过url发送请求————>等待服务器响应————>获取网页源代码————>解析页面————>过滤————>数据保存
在上述步骤中，获取网页的源代码和解析页面是最重要的。这两个部分通常是最困难的。它们主要处理网页上的各种反爬机制。有时您的道德页面的源代码可能与网页的源代码不同。完全一样，需要对比分析。
2. 获取正则表达式匹配的数据
与其他方法相比，正则表达式是爬虫获取数据的一种非常有效的方法。它只需要在特殊模式下传递返回的网页源字符串和模式匹配，就可以找到我们想要的。所需的数据。但是，正则表达式的匹配模式对于初学者来说也有点难写，以实现快速精确的匹配。
正则表达式的使用可以概括为以下两种：
在自己写的pattern中编译，创建一个pattern对象（pattern），然后传入函数，只需要传入函数中要匹配的字符串即可。
通过 re.function name('match pattern', 'string to match') 找到需要的字符
当需要多次使用相同的匹配模式来选择第一种方法时，当匹配模式只需要使用一次来选择第二种方法时。
如果正则表达式匹配成功，则返回的数据类型为字符串，如果匹配失败，则返回None。但是，我们在查看匹配结果的时候，最好先判断一下匹配成功与否，以防报错。
常用的匹配函数如下：
函数名对应的函数描述
匹配（）
从前到后匹配，只有一次。如果匹配成功，返回re.Match对象，然后调用group()查看对应的值
全匹配（）
从前到后匹配，只匹配一次并进行完整匹配
搜索（）
搜索满足匹配模式的字符串，只匹配一次
找到所有（）
搜索所有满足匹配模式的字符并返回一个列表，列表中的每个元素都是一个满足匹配模式的字符串
在爬虫中，findall通常用于匹配查找所有符合匹配模式的字符串，通过遍历列表查看数据
正则表达式的特殊字符有以下含义：
数量限定词
特殊字符
\u4e00-\u9fa5 只匹配中文字体
位置相关字符
常见匹配字符
3. 页面源码分析
页面显示的内容
页面来源
通过对比两张图，我们可以看到，我们看到的和服务器返回给我们的还是有很大区别的。我们可以在页面上看到图片和文字，还有一些视频，但是网页的源代码都是纯文本，源代码中的图片和视频与链接一一对应。这意味着我们需要源代码提供的链接来访问图片和视频等。
在爬虫中分析网页源代码是一项非常重要的技能，需要通过不断的探索找到一些共性。最好对 CSS 和 JS 有一定的了解，了解网页显示给我的原理。
4. 通过请求爬取静态页面
对于从requests请求页面获取的源代码，需要进行预处理。常用的预处理通过 CSS 选择器和 xpath 过滤掉我们想要的内容。
4.1 css选择器基本语法选择器示例示例说明
。班级
。介绍
选择所有带有 class="intro" 的元素
＃ID
＃名
选择 id="firstname" 的所有元素
*
*
选择所有元素
元素
p
全选
元素
元素，元素
格，p
全选
元素和
元素
元素元素
分区 p
选择
全部在元素内
元素
在使用CSS选择器定位元素时，当有一个可以通过id定位的首选id时，id属性对应的值是唯一的，那么就为status元素考虑class属性。如果class属性有多个值，则需要选择一个。能。
4.2 xpath 基本语法
官方帮助文档：
表达描述
节点名
选择该节点的所有子节点
/
从当前节点中选择子节点
//
从当前节点中选择后代节点
.
选择当前节点
…
选择当前节点的父节点
@
选择属性
xpath 还可以结合运算符来定位元素
xpath 中的谓词
谓词用于查找特定节点或收录指定值的节点。
谓词用方括号括起来。
选择未知节点
选择多条路径
在以上基础上，通过案例进行如下具体分析：
通过CSS选择器方法获取豆瓣上排名前25的电影名
import requests
from bs4 import BeautifulSoup as Bs
url = 'https://movie.douban.com/top250'
# 设置请求头
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36',
# 先登录，通过开发者工具控制台获取
'Cookies': '**************************************************'
}
# 建立连接
resp = requests.get(url=url, headers=headers)
print(resp.status_code) # 查看是否访问成功，出现200就说明访问成功
if resp.status_code == 200:
soup = Bs(resp.text, 'lxml') # 进行预处理
title_list = soup.select('div.hd > a > span:nth-child(1)') # 找到标题对应的标签
for title in title_list:
print(title.text, end='\t') # 打印输出电影标题
'''
200
肖申克的救赎 霸王别姬 阿甘正传 这个杀手不太冷 泰坦尼克号 美丽人生 千与千寻 辛德勒的名单 盗梦空间 忠犬八公的故事 星际穿越 楚门的世界 海上钢琴师 三傻大闹宝莱坞 机器人总动员 放牛班的春天 无间道 疯狂动物城 大话西游之大圣娶亲 熔炉 教父 当幸福来敲门 龙猫 怦然心动 控方证人
'''
通过xpath选择器方法获取豆瓣排名前25的电影名
import requests
from bs4 import BeautifulSoup as Bs
from lxml import etree
url = 'https://movie.douban.com/top250'
# 设置请求头
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36',
'Cookies': '**************************************'
}
# 建立连接
resp = requests.get(url=url, headers=headers)
if resp.status_code == 200:
html = etree.HTML(resp.text) # 预处理
title_list = html.xpath('//div[@class= "hd"]/a[@href]/span[1]/text()')
for title in title_list:
print(title, end='\t')
'''
肖申克的救赎 霸王别姬 阿甘正传 这个杀手不太冷 泰坦尼克号 美丽人生 千与千寻 辛德勒的名单 盗梦空间 忠犬八公的故事 星际穿越 楚门的世界 海上钢琴师 三傻大闹宝莱坞 机器人总动员 放牛班的春天 无间道 疯狂动物城 大话西游之大圣娶亲 熔炉 教父 当幸福来敲门 龙猫 怦然心动 控方证人
'''
在爬取页面数据时，我们通常选择xpath进行爬取，这显然比通过css选择器定位元素更加灵活。爬取静态页面时，通过以上步骤爬取数据，但部分网页内容只能通过登录获取。
4.3 数据通过代理采集
当我们访问同一个网页太琐碎时，一些网站会使用反爬机制来屏蔽你的ip。这需要我们使用不同的 ip 地址多次访问同一个 网站。这个时候只能买ip让别人为你转发，结果返回给你。
通过运营商提供的ip链接获取有效ip
# -*- coding: UTF-8 -*-
"""
此代码为代理IP可用性检测模块，可准确筛选出尚未失效IP
注：
1.此代码只针对TXT数据格式接口。
2.尚未失效IP不一定为爬虫可用IP
3.使用时，请调用check_ip(url)，url为TXT数据格式接口地址
"""
import requests
import telnetlib
import re
from concurrent.futures.thread import ThreadPoolExecutor
# 请求接口，匹配出代理IP，多线程检测
def check_ip(url):
real_ip = []
# 检测代理IP是否失效
def telnet_ip(ip, port):
try:
telnetlib.Telnet(ip, port, timeout=1)
real_ip.append(f'{ip}:{port}')
except:
pass
while True:
try:
resp = requests.get(url)
# print(resp.text)
ip_data = re.findall('(\d+\.\d+\.\d+\.\d+):(\d+)', resp.text)
with ThreadPoolExecutor(max_workers=16) as pool:
for ip, port in ip_data:
pool.submit(telnet_ip, ip, port)
return real_ip
except:
pass
调用ip爬取
"""
example04-利用代理爬取
Version：
Author:
Date:2021/8/17
"""
from check_proxies import check_ip
import requests
from bs4 import BeautifulSoup
# ip地址链接，由运营商提供，具有一定的时效性
URL = 'http://api.66daili.cn/API/GetC ... elite,anonymous,transparent&area=%E4%B8%AD%E5%9B%BD&proxytype=https&speed=fast#api'
ip_list = check_ip(URL)
print(ip_list)
flag = True
while flag:
for i in range(len(ip_list)):
doubna_url = 'https://movie.douban.com/top250'
headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 '
'(KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
}
# 代理ip，会根据要求进行自动选择http或https协议
proxy = {
'http': 'http://' + ip_list[i],
'http': 'https://' + ip_list[i]
}
try:
resp = requests.get(url=doubna_url, headers=headers, proxies=proxy, timeout=1)
if resp.status_code == 200:
print(resp.text)
flag = False
break
except:
print('Erro')
5. 通过 selenium 驱动浏览器并爬取动态页面
通过 selenium 获取页面步骤：
先把驱动放到当前项目中
from selenium import webdriver
url = 'https://www.baidu.com/'
# 创建浏览器对象
b = webdriver.Chrome(./chromedrivers.exe)
# 访问页面
b.get(url)
# 关闭
b.quit()
使用selenium登录京东页面
<p>import getpass
import time
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
url = 'https://www.jd.com/'
options = webdriver.ChromeOptions()
options.add_experimental_option("excludeSwitches", ['enable-automation', 'enable-logging']) # 忽略警告
# options.add_argument('blink-settings=imagesEnabled=false') # 不加载图片
b = webdriver.Chrome(options=options)
b.get(url)
b.find_element_by_id('ttbar-login').click()
b.find_element_by_class_name('login-tab-r').click()
b.find_element_by_id('loginname').send_keys(input('输入账号：'))
b.find_element_by_id('nloginpwd').send_keys(getpass.getpass('输入密码：'))
b.find_element_by_id('loginsubmit').click()
time.sleep(5)
b.find_element_by_id('key').send_keys('python')
b.find_element_by_id('key').send_keys(Keys.ENTER)
max_y = 10000
y = 0
while y 查看全部
python抓取动态网页(
2.用正则表达式匹配获取数据(图)打印显示(组图))
爬行打印展示
通过上面的对比，我们爬取的是网页的源码。我们只需要对页面返回的内容进行过滤，提取出我们想要的部分数据，但通常很多网站都有反爬虫机制需要预处理。最后，将获取的数据写入文件或数据库，用于持久化数据存储。
步骤：通过url发送请求————>等待服务器响应————>获取网页源代码————>解析页面————>过滤————>数据保存
在上述步骤中，获取网页的源代码和解析页面是最重要的。这两个部分通常是最困难的。它们主要处理网页上的各种反爬机制。有时您的道德页面的源代码可能与网页的源代码不同。完全一样，需要对比分析。
2. 获取正则表达式匹配的数据
与其他方法相比，正则表达式是爬虫获取数据的一种非常有效的方法。它只需要在特殊模式下传递返回的网页源字符串和模式匹配，就可以找到我们想要的。所需的数据。但是，正则表达式的匹配模式对于初学者来说也有点难写，以实现快速精确的匹配。
正则表达式的使用可以概括为以下两种：
在自己写的pattern中编译，创建一个pattern对象（pattern），然后传入函数，只需要传入函数中要匹配的字符串即可。
通过 re.function name('match pattern', 'string to match') 找到需要的字符
当需要多次使用相同的匹配模式来选择第一种方法时，当匹配模式只需要使用一次来选择第二种方法时。
如果正则表达式匹配成功，则返回的数据类型为字符串，如果匹配失败，则返回None。但是，我们在查看匹配结果的时候，最好先判断一下匹配成功与否，以防报错。
常用的匹配函数如下：
函数名对应的函数描述
匹配（）
从前到后匹配，只有一次。如果匹配成功，返回re.Match对象，然后调用group()查看对应的值
全匹配（）
从前到后匹配，只匹配一次并进行完整匹配
搜索（）
搜索满足匹配模式的字符串，只匹配一次
找到所有（）
搜索所有满足匹配模式的字符并返回一个列表，列表中的每个元素都是一个满足匹配模式的字符串
在爬虫中，findall通常用于匹配查找所有符合匹配模式的字符串，通过遍历列表查看数据
正则表达式的特殊字符有以下含义：
数量限定词
特殊字符
\u4e00-\u9fa5 只匹配中文字体
位置相关字符
常见匹配字符
3. 页面源码分析
页面显示的内容
页面来源
通过对比两张图，我们可以看到，我们看到的和服务器返回给我们的还是有很大区别的。我们可以在页面上看到图片和文字，还有一些视频，但是网页的源代码都是纯文本，源代码中的图片和视频与链接一一对应。这意味着我们需要源代码提供的链接来访问图片和视频等。
在爬虫中分析网页源代码是一项非常重要的技能，需要通过不断的探索找到一些共性。最好对 CSS 和 JS 有一定的了解，了解网页显示给我的原理。
4. 通过请求爬取静态页面
对于从requests请求页面获取的源代码，需要进行预处理。常用的预处理通过 CSS 选择器和 xpath 过滤掉我们想要的内容。
4.1 css选择器基本语法选择器示例示例说明
。班级
。介绍
选择所有带有 class="intro" 的元素
＃ID
＃名
选择 id="firstname" 的所有元素
*
*
选择所有元素
元素
p
全选
元素
元素，元素
格，p
全选
元素和
元素
元素元素
分区 p
选择
全部在元素内
元素
在使用CSS选择器定位元素时，当有一个可以通过id定位的首选id时，id属性对应的值是唯一的，那么就为status元素考虑class属性。如果class属性有多个值，则需要选择一个。能。
4.2 xpath 基本语法
官方帮助文档：
表达描述
节点名
选择该节点的所有子节点
/
从当前节点中选择子节点
//
从当前节点中选择后代节点
.
选择当前节点
…
选择当前节点的父节点
@
选择属性
xpath 还可以结合运算符来定位元素
xpath 中的谓词
谓词用于查找特定节点或收录指定值的节点。
谓词用方括号括起来。
选择未知节点
选择多条路径
在以上基础上，通过案例进行如下具体分析：
通过CSS选择器方法获取豆瓣上排名前25的电影名
import requests
from bs4 import BeautifulSoup as Bs
url = 'https://movie.douban.com/top250'
# 设置请求头
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36',
# 先登录，通过开发者工具控制台获取
'Cookies': '**************************************************'
}
# 建立连接
resp = requests.get(url=url, headers=headers)
print(resp.status_code) # 查看是否访问成功，出现200就说明访问成功
if resp.status_code == 200:
soup = Bs(resp.text, 'lxml') # 进行预处理
title_list = soup.select('div.hd > a > span:nth-child(1)') # 找到标题对应的标签
for title in title_list:
print(title.text, end='\t') # 打印输出电影标题
'''
200
肖申克的救赎 霸王别姬 阿甘正传 这个杀手不太冷 泰坦尼克号 美丽人生 千与千寻 辛德勒的名单 盗梦空间 忠犬八公的故事 星际穿越 楚门的世界 海上钢琴师 三傻大闹宝莱坞 机器人总动员 放牛班的春天 无间道 疯狂动物城 大话西游之大圣娶亲 熔炉 教父 当幸福来敲门 龙猫 怦然心动 控方证人
'''
通过xpath选择器方法获取豆瓣排名前25的电影名
import requests
from bs4 import BeautifulSoup as Bs
from lxml import etree
url = 'https://movie.douban.com/top250'
# 设置请求头
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36',
'Cookies': '**************************************'
}
# 建立连接
resp = requests.get(url=url, headers=headers)
if resp.status_code == 200:
html = etree.HTML(resp.text) # 预处理
title_list = html.xpath('//div[@class= "hd"]/a[@href]/span[1]/text()')
for title in title_list:
print(title, end='\t')
'''
肖申克的救赎 霸王别姬 阿甘正传 这个杀手不太冷 泰坦尼克号 美丽人生 千与千寻 辛德勒的名单 盗梦空间 忠犬八公的故事 星际穿越 楚门的世界 海上钢琴师 三傻大闹宝莱坞 机器人总动员 放牛班的春天 无间道 疯狂动物城 大话西游之大圣娶亲 熔炉 教父 当幸福来敲门 龙猫 怦然心动 控方证人
'''
在爬取页面数据时，我们通常选择xpath进行爬取，这显然比通过css选择器定位元素更加灵活。爬取静态页面时，通过以上步骤爬取数据，但部分网页内容只能通过登录获取。
4.3 数据通过代理采集
当我们访问同一个网页太琐碎时，一些网站会使用反爬机制来屏蔽你的ip。这需要我们使用不同的 ip 地址多次访问同一个 网站。这个时候只能买ip让别人为你转发，结果返回给你。
通过运营商提供的ip链接获取有效ip
# -*- coding: UTF-8 -*-
"""
此代码为代理IP可用性检测模块，可准确筛选出尚未失效IP
注：
1.此代码只针对TXT数据格式接口。
2.尚未失效IP不一定为爬虫可用IP
3.使用时，请调用check_ip(url)，url为TXT数据格式接口地址
"""
import requests
import telnetlib
import re
from concurrent.futures.thread import ThreadPoolExecutor
# 请求接口，匹配出代理IP，多线程检测
def check_ip(url):
real_ip = []
# 检测代理IP是否失效
def telnet_ip(ip, port):
try:
telnetlib.Telnet(ip, port, timeout=1)
real_ip.append(f'{ip}:{port}')
except:
pass
while True:
try:
resp = requests.get(url)
# print(resp.text)
ip_data = re.findall('(\d+\.\d+\.\d+\.\d+):(\d+)', resp.text)
with ThreadPoolExecutor(max_workers=16) as pool:
for ip, port in ip_data:
pool.submit(telnet_ip, ip, port)
return real_ip
except:
pass
调用ip爬取
"""
example04-利用代理爬取
Version：
Author:
Date:2021/8/17
"""
from check_proxies import check_ip
import requests
from bs4 import BeautifulSoup
# ip地址链接，由运营商提供，具有一定的时效性
URL = 'http://api.66daili.cn/API/GetC ... elite,anonymous,transparent&area=%E4%B8%AD%E5%9B%BD&proxytype=https&speed=fast#api'
ip_list = check_ip(URL)
print(ip_list)
flag = True
while flag:
for i in range(len(ip_list)):
doubna_url = 'https://movie.douban.com/top250'
headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 '
'(KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
}
# 代理ip，会根据要求进行自动选择http或https协议
proxy = {
'http': 'http://' + ip_list[i],
'http': 'https://' + ip_list[i]
}
try:
resp = requests.get(url=doubna_url, headers=headers, proxies=proxy, timeout=1)
if resp.status_code == 200:
print(resp.text)
flag = False
break
except:
print('Erro')
5. 通过 selenium 驱动浏览器并爬取动态页面
通过 selenium 获取页面步骤：
先把驱动放到当前项目中
from selenium import webdriver
url = 'https://www.baidu.com/'
# 创建浏览器对象
b = webdriver.Chrome(./chromedrivers.exe)
# 访问页面
b.get(url)
# 关闭
b.quit()
使用selenium登录京东页面
<p>import getpass
import time
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
url = 'https://www.jd.com/'
options = webdriver.ChromeOptions()
options.add_experimental_option("excludeSwitches", ['enable-automation', 'enable-logging']) # 忽略警告
# options.add_argument('blink-settings=imagesEnabled=false') # 不加载图片
b = webdriver.Chrome(options=options)
b.get(url)
b.find_element_by_id('ttbar-login').click()
b.find_element_by_class_name('login-tab-r').click()
b.find_element_by_id('loginname').send_keys(input('输入账号：'))
b.find_element_by_id('nloginpwd').send_keys(getpass.getpass('输入密码：'))
b.find_element_by_id('loginsubmit').click()
time.sleep(5)
b.find_element_by_id('key').send_keys('python')
b.find_element_by_id('key').send_keys(Keys.ENTER)
max_y = 10000
y = 0
while y
python抓取动态网页( urllib使用js动态加载的网页--百度图片的结果页)
网站优化 • 优采云 发表了文章 • 0 个评论 • 23 次浏览 • 2022-04-06 06:14
python抓取动态网页(
urllib使用js动态加载的网页--百度图片的结果页)
我们在做网页抓取的时候，一般使用 urllib 和 urllib2 来满足我们大部分的需求。
但有时我们会遇到使用js动态加载的网页。你会发现 urllib 只能抓取部分空白的网页。就像下面百度图片的结果页：
查看元素后发现百度图片中，显示图片的div是：pullimages
这个 div 里面的内容是动态加载的。但是使用urllib&urllib2就爬不上了。
要抓取动态加载的元素，首先考虑使用 selenium 调用浏览器进行抓取。
而我们的运行环境是linux，最理想的方式是无界面抓取，所以使用selenium+phantomjs无界面抓取。
什么是phantomjs？它是一个基于webkit核心的无头浏览器，也就是没有UI界面，就是一个浏览器。
selenium和phantomjs的安装配置可以google，这里就不多说了。
代码如下：from selenium import webdriver
driver = webdriver.PhantomJS(executable_path='/bin/phantomjs/bin/phantomjs')
#如果不方便配置环境变量。也可以使用phantomjs的绝对路径
driver.get('%E5%91%A8%E6%9D%B0%E4%BC%A6')
#抓取百度图片，查询：周杰伦
driver.page_source
#这是返回页面的内容，类似于urllib2.urlopen().read()，但比urllib2强，可以捕获动态渲染的内容。
driver.quit()
去这里。成功抓取动态页面。 查看全部
urllib使用js动态加载的网页--百度图片的结果页)
我们在做网页抓取的时候，一般使用 urllib 和 urllib2 来满足我们大部分的需求。
但有时我们会遇到使用js动态加载的网页。你会发现 urllib 只能抓取部分空白的网页。就像下面百度图片的结果页：
查看元素后发现百度图片中，显示图片的div是：pullimages
这个 div 里面的内容是动态加载的。但是使用urllib&urllib2就爬不上了。
要抓取动态加载的元素，首先考虑使用 selenium 调用浏览器进行抓取。
而我们的运行环境是linux，最理想的方式是无界面抓取，所以使用selenium+phantomjs无界面抓取。
什么是phantomjs？它是一个基于webkit核心的无头浏览器，也就是没有UI界面，就是一个浏览器。
selenium和phantomjs的安装配置可以google，这里就不多说了。
代码如下：from selenium import webdriver
driver = webdriver.PhantomJS(executable_path='/bin/phantomjs/bin/phantomjs')
#如果不方便配置环境变量。也可以使用phantomjs的绝对路径
driver.get('%E5%91%A8%E6%9D%B0%E4%BC%A6')
#抓取百度图片，查询：周杰伦
driver.page_source
#这是返回页面的内容，类似于urllib2.urlopen().read()，但比urllib2强，可以捕获动态渲染的内容。
driver.quit()
去这里。成功抓取动态页面。 查看全部
python抓取动态网页(
urllib使用js动态加载的网页--百度图片的结果页)
我们在做网页抓取的时候，一般使用 urllib 和 urllib2 来满足我们大部分的需求。
但有时我们会遇到使用js动态加载的网页。你会发现 urllib 只能抓取部分空白的网页。就像下面百度图片的结果页：
查看元素后发现百度图片中，显示图片的div是：pullimages
这个 div 里面的内容是动态加载的。但是使用urllib&urllib2就爬不上了。
要抓取动态加载的元素，首先考虑使用 selenium 调用浏览器进行抓取。
而我们的运行环境是linux，最理想的方式是无界面抓取，所以使用selenium+phantomjs无界面抓取。
什么是phantomjs？它是一个基于webkit核心的无头浏览器，也就是没有UI界面，就是一个浏览器。
selenium和phantomjs的安装配置可以google，这里就不多说了。
代码如下：from selenium import webdriver
driver = webdriver.PhantomJS(executable_path='/bin/phantomjs/bin/phantomjs')
#如果不方便配置环境变量。也可以使用phantomjs的绝对路径
driver.get('%E5%91%A8%E6%9D%B0%E4%BC%A6')
#抓取百度图片，查询：周杰伦
driver.page_source
#这是返回页面的内容，类似于urllib2.urlopen().read()，但比urllib2强，可以捕获动态渲染的内容。
driver.quit()
去这里。成功抓取动态页面。
python抓取动态网页(高效处理动态网页的完美组合——爬虫)
网站优化 • 优采云 发表了文章 • 0 个评论 • 27 次浏览 • 2022-04-06 06:13
python抓取动态网页(高效处理动态网页的完美组合——爬虫)
爬虫是我们快速获取所需数据的一种非常有效的方式，而爬虫的第一步就是请求远程服务器为我们返回所需的网页信息。我们知道，一般情况下，我们只需要输入正确的Uniform Resource Locator url，即网页地址，就可以在浏览器上轻松打开我们想看到的页面。同样，在设计python爬虫程序时，我们也可以通过参数设置调用相应的库连接网络处理http协议。对于静态网页，常用的库有urllib、urllib2、requests等，通过它们可以很方便的请求服务器返回特定地址的网页内容。但是，如果我们遇到 JS 加载的动态网页，使用以前的方法，我们经常无法收到我们想要的结果。这时候可以召唤强大的自动化测试工具Selenium，召唤它的好友PhantomJS，一起升级打怪。
(一） urllib, urllib2, 直接上例子：
import urllib2
response = urllib2.urlopen("http://www.baidu.com")
print response.read()
只要给一个url，比如百度，调用urllib2库，就可以单手阅读这个url对应的网页源码，代码非常简洁。在实际爬虫中，考虑到对方的反爬机制，网络响应时间或者发送请求需要添加额外的信息，我们需要多添加几行代码，目的是让服务器尽量相信收到的请求来自正常访问对象。为了程序逻辑的清晰，我们可以设计一个请求对象作为urlopen的传入参数，例如：
import urllib
import urllib2
#添加url
url = 'xxx'
request = urllib2.Request(url)
#为了模拟浏览器行为，伪装对方识别问题，可以添加Headers属性，例如下面的agent便是设置请求身份：
user_agent = 'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.102 Safari/537.36'
headers = { 'User-Agent' : user_agent}
request = urllib2.Request(url, headers)
#有时访问某些网站需要提供一些信息，例如用户名和密码，这时可以这样：
values = {"username":"yourname","password":"????"}
data = urllib.urlencode(values)
request = urllib2.Request(url, data, headers)
#在遇到网络状况不好时可以设置timeout来设置等待多久超时
response = urllib2.urlopen(request，timeout=18)
print response.read()
有关更多相关内容，请参阅此 urllib 和 urllib2。
（二）requests，一个简单、美观、友好的外部库。
请求的所有功能都可以通过以下7种方法访问。它们都返回响应对象的一个实例。
#创建并发送一个request
requests.request(method, url, **kwargs)
参数：
method -- method for the new Request object.
url -- URL for the new Request object.
params -- (optional) Dictionary or bytes to be sent in the query string for the Request.
data -- (optional) Dictionary, bytes, or file-like object to send in the body of the Request.
json -- (optional) json data to send in the body of the Request.
headers -- (optional) Dictionary of HTTP Headers to send with the Request.
cookies -- (optional) Dict or CookieJar object to send with the Request.
files -- (optional) Dictionary of 'name': file-like-objects (or {'name': file-tuple}) for multipart encoding upload. file-tuple can be a 2-tuple ('filename', fileobj), 3-tuple ('filename', fileobj, 'content_type') or a 4-tuple ('filename', fileobj, 'content_type', custom_headers), where 'content-type' is a string defining the content type of the given file and custom_headers a dict-like object containing additional headers to add for the file.
auth -- (optional) Auth tuple to enable Basic/Digest/Custom HTTP Auth.
timeout (float or tuple) -- (optional) How long to wait for the server to send data before giving up, as a float, or a (connect timeout, read timeout) tuple.
allow_redirects (bool) -- (optional) Boolean. Set to True if POST/PUT/DELETE redirect following is allowed.
proxies -- (optional) Dictionary mapping protocol to the URL of the proxy.
verify -- (optional) whether the SSL cert will be verified. A CA_BUNDLE path can also be provided. Defaults to True.
stream -- (optional) if False, the response content will be immediately downloaded.
cert -- (optional) if String, path to ssl client cert file (.pem). If Tuple, ('cert', 'key') pair.
#例如：
import requests
url='xxxx'
headers = {'User-Agent' : 'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.102 Safari/537.36'}
proxies = { 'http' : '127.0.0.1:8118'}
response=requests.request('GET',url, timeout=20, proxies=proxies, headers=headers)
返回类型requests.Response
另：
#发送一个HEAD request.
requests.head(url, **kwargs)
#发送一个GET request
requests.get(url, params=None, **kwargs)
#发送一个POST request
requests.post(url, data=None, json=None, **kwargs)
#发送一个PUT request
requests.put(url, data=None, **kwargs)
#发送一个PATCH request
requests.patch(url, data=None, **kwargs)
#发送一个DELETE request
requests.delete(url, **kwargs)
更多详情请参考官网要求。
（三）Selenium + PhantomJs，高效处理动态网页的完美组合。
使用前面的方法我们可以简单的得到网页的html代码。如果我们遇到需要用JS渲染的网页内容，就会变得很麻烦。因此，我们需要一个可以像浏览器一样处理要被JS渲染的页面的工具，而PhantomJs是一个基于WebKit的无界面网页交互工具。它提供的JavaScript API可以实现自动浏览、截图等浏览器功能。Selenium 是一款自动化测试工具，支持火狐、Chrome、Safari 等主流浏览器。借助 selenium，可以模拟人类的各种网页操作行为，例如打开浏览器、输入信息、点击、翻页等。PhantomJS 作为没有界面的浏览器，Selenium 会不会感冒？答案很冷，因为 PhantomJs 不仅可以完成浏览器的功能，而且相对来说效率更高。例如：
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
phantomjs_path = '/data/opt/brew/lib/node_modules/phantomjs/lib/phantom/bin/phantomjs'
driver = webdriver.PhantomJS(executable_path=phantomjs_path)
url = 'xxxx'
driver.get(url)
#轻松得到到JS渲染页面的源码
page_source = driver.page_source.encode('utf8')
有时我们需要实现页面交互，即当我们可以在浏览器上模拟点击、输入、鼠标移动等各种行为时，首先需要定位页面元素。其中，WebDriver提供了多种实现元素定位的方法：
#定位一个元素的方法有
find_element_by_id
find_element_by_name
find_element_by_xpath
find_element_by_link_text
find_element_by_partial_link_text
find_element_by_tag_name
find_element_by_class_name
find_element_by_css_selector
#定位多元素，返回一个list，方法有
find_elements_by_name
find_elements_by_xpath
find_elements_by_link_text
find_elements_by_partial_link_text
find_elements_by_tag_name
find_elements_by_class_name
find_elements_by_css_selector
#例如有如下网页源码：
#form可以这样来定位
login_form = driver.find_element_by_id('loginForm')
#username&password两个元素定位如下
username = driver.find_element_by_name('username')
password = driver.find_element_by_name('password')
#如果使用xpath来定位username，以下方法都ok
username = driver.find_element_by_xpath("//form[input/@name='username']")
username = driver.find_element_by_xpath("//form[@id='loginForm']/input[1]")
username = driver.find_element_by_xpath("//input[@name='username']")
更多信息请参考 selenium_python, PhantomJS。
这篇文章简单介绍了获取网页源内容的各种方法，包括静态网页中经常使用的urllib、urllib2、requests和selenium、phantomjs的组合。在爬取过程中，我们经常需要提取和保留网页中的有用信息，所以接下来介绍如何从获取的网页源代码中提取有用信息。 查看全部
爬虫是我们快速获取所需数据的一种非常有效的方式，而爬虫的第一步就是请求远程服务器为我们返回所需的网页信息。我们知道，一般情况下，我们只需要输入正确的Uniform Resource Locator url，即网页地址，就可以在浏览器上轻松打开我们想看到的页面。同样，在设计python爬虫程序时，我们也可以通过参数设置调用相应的库连接网络处理http协议。对于静态网页，常用的库有urllib、urllib2、requests等，通过它们可以很方便的请求服务器返回特定地址的网页内容。但是，如果我们遇到 JS 加载的动态网页，使用以前的方法，我们经常无法收到我们想要的结果。这时候可以召唤强大的自动化测试工具Selenium，召唤它的好友PhantomJS，一起升级打怪。
(一） urllib, urllib2, 直接上例子：
import urllib2
response = urllib2.urlopen("http://www.baidu.com")
print response.read()
只要给一个url，比如百度，调用urllib2库，就可以单手阅读这个url对应的网页源码，代码非常简洁。在实际爬虫中，考虑到对方的反爬机制，网络响应时间或者发送请求需要添加额外的信息，我们需要多添加几行代码，目的是让服务器尽量相信收到的请求来自正常访问对象。为了程序逻辑的清晰，我们可以设计一个请求对象作为urlopen的传入参数，例如：
import urllib
import urllib2
#添加url
url = 'xxx'
request = urllib2.Request(url)
#为了模拟浏览器行为，伪装对方识别问题，可以添加Headers属性，例如下面的agent便是设置请求身份：
user_agent = 'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.102 Safari/537.36'
headers = { 'User-Agent' : user_agent}
request = urllib2.Request(url, headers)
#有时访问某些网站需要提供一些信息，例如用户名和密码，这时可以这样：
values = {"username":"yourname","password":"????"}
data = urllib.urlencode(values)
request = urllib2.Request(url, data, headers)
#在遇到网络状况不好时可以设置timeout来设置等待多久超时
response = urllib2.urlopen(request，timeout=18)
print response.read()
有关更多相关内容，请参阅此 urllib 和 urllib2。
（二）requests，一个简单、美观、友好的外部库。
请求的所有功能都可以通过以下7种方法访问。它们都返回响应对象的一个实例。
#创建并发送一个request
requests.request(method, url, **kwargs)
参数：
method -- method for the new Request object.
url -- URL for the new Request object.
params -- (optional) Dictionary or bytes to be sent in the query string for the Request.
data -- (optional) Dictionary, bytes, or file-like object to send in the body of the Request.
json -- (optional) json data to send in the body of the Request.
headers -- (optional) Dictionary of HTTP Headers to send with the Request.
cookies -- (optional) Dict or CookieJar object to send with the Request.
files -- (optional) Dictionary of 'name': file-like-objects (or {'name': file-tuple}) for multipart encoding upload. file-tuple can be a 2-tuple ('filename', fileobj), 3-tuple ('filename', fileobj, 'content_type') or a 4-tuple ('filename', fileobj, 'content_type', custom_headers), where 'content-type' is a string defining the content type of the given file and custom_headers a dict-like object containing additional headers to add for the file.
auth -- (optional) Auth tuple to enable Basic/Digest/Custom HTTP Auth.
timeout (float or tuple) -- (optional) How long to wait for the server to send data before giving up, as a float, or a (connect timeout, read timeout) tuple.
allow_redirects (bool) -- (optional) Boolean. Set to True if POST/PUT/DELETE redirect following is allowed.
proxies -- (optional) Dictionary mapping protocol to the URL of the proxy.
verify -- (optional) whether the SSL cert will be verified. A CA_BUNDLE path can also be provided. Defaults to True.
stream -- (optional) if False, the response content will be immediately downloaded.
cert -- (optional) if String, path to ssl client cert file (.pem). If Tuple, ('cert', 'key') pair.
#例如：
import requests
url='xxxx'
headers = {'User-Agent' : 'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.102 Safari/537.36'}
proxies = { 'http' : '127.0.0.1:8118'}
response=requests.request('GET',url, timeout=20, proxies=proxies, headers=headers)
返回类型requests.Response
另：
#发送一个HEAD request.
requests.head(url, **kwargs)
#发送一个GET request
requests.get(url, params=None, **kwargs)
#发送一个POST request
requests.post(url, data=None, json=None, **kwargs)
#发送一个PUT request
requests.put(url, data=None, **kwargs)
#发送一个PATCH request
requests.patch(url, data=None, **kwargs)
#发送一个DELETE request
requests.delete(url, **kwargs)
更多详情请参考官网要求。
（三）Selenium + PhantomJs，高效处理动态网页的完美组合。
使用前面的方法我们可以简单的得到网页的html代码。如果我们遇到需要用JS渲染的网页内容，就会变得很麻烦。因此，我们需要一个可以像浏览器一样处理要被JS渲染的页面的工具，而PhantomJs是一个基于WebKit的无界面网页交互工具。它提供的JavaScript API可以实现自动浏览、截图等浏览器功能。Selenium 是一款自动化测试工具，支持火狐、Chrome、Safari 等主流浏览器。借助 selenium，可以模拟人类的各种网页操作行为，例如打开浏览器、输入信息、点击、翻页等。PhantomJS 作为没有界面的浏览器，Selenium 会不会感冒？答案很冷，因为 PhantomJs 不仅可以完成浏览器的功能，而且相对来说效率更高。例如：
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
phantomjs_path = '/data/opt/brew/lib/node_modules/phantomjs/lib/phantom/bin/phantomjs'
driver = webdriver.PhantomJS(executable_path=phantomjs_path)
url = 'xxxx'
driver.get(url)
#轻松得到到JS渲染页面的源码
page_source = driver.page_source.encode('utf8')
有时我们需要实现页面交互，即当我们可以在浏览器上模拟点击、输入、鼠标移动等各种行为时，首先需要定位页面元素。其中，WebDriver提供了多种实现元素定位的方法：
#定位一个元素的方法有
find_element_by_id
find_element_by_name
find_element_by_xpath
find_element_by_link_text
find_element_by_partial_link_text
find_element_by_tag_name
find_element_by_class_name
find_element_by_css_selector
#定位多元素，返回一个list，方法有
find_elements_by_name
find_elements_by_xpath
find_elements_by_link_text
find_elements_by_partial_link_text
find_elements_by_tag_name
find_elements_by_class_name
find_elements_by_css_selector
#例如有如下网页源码：
#form可以这样来定位
login_form = driver.find_element_by_id('loginForm')
#username&password两个元素定位如下
username = driver.find_element_by_name('username')
password = driver.find_element_by_name('password')
#如果使用xpath来定位username，以下方法都ok
username = driver.find_element_by_xpath("//form[input/@name='username']")
username = driver.find_element_by_xpath("//form[@id='loginForm']/input[1]")
username = driver.find_element_by_xpath("//input[@name='username']")
更多信息请参考 selenium_python, PhantomJS。
这篇文章简单介绍了获取网页源内容的各种方法，包括静态网页中经常使用的urllib、urllib2、requests和selenium、phantomjs的组合。在爬取过程中，我们经常需要提取和保留网页中的有用信息，所以接下来介绍如何从获取的网页源代码中提取有用信息。 查看全部
python抓取动态网页(高效处理动态网页的完美组合——爬虫)
爬虫是我们快速获取所需数据的一种非常有效的方式，而爬虫的第一步就是请求远程服务器为我们返回所需的网页信息。我们知道，一般情况下，我们只需要输入正确的Uniform Resource Locator url，即网页地址，就可以在浏览器上轻松打开我们想看到的页面。同样，在设计python爬虫程序时，我们也可以通过参数设置调用相应的库连接网络处理http协议。对于静态网页，常用的库有urllib、urllib2、requests等，通过它们可以很方便的请求服务器返回特定地址的网页内容。但是，如果我们遇到 JS 加载的动态网页，使用以前的方法，我们经常无法收到我们想要的结果。这时候可以召唤强大的自动化测试工具Selenium，召唤它的好友PhantomJS，一起升级打怪。
(一） urllib, urllib2, 直接上例子：
import urllib2
response = urllib2.urlopen("http://www.baidu.com";)
print response.read()
只要给一个url，比如百度，调用urllib2库，就可以单手阅读这个url对应的网页源码，代码非常简洁。在实际爬虫中，考虑到对方的反爬机制，网络响应时间或者发送请求需要添加额外的信息，我们需要多添加几行代码，目的是让服务器尽量相信收到的请求来自正常访问对象。为了程序逻辑的清晰，我们可以设计一个请求对象作为urlopen的传入参数，例如：
import urllib
import urllib2
#添加url
url = 'xxx'
request = urllib2.Request(url)
#为了模拟浏览器行为，伪装对方识别问题，可以添加Headers属性，例如下面的agent便是设置请求身份：
user_agent = 'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.102 Safari/537.36'
headers = { 'User-Agent' : user_agent}
request = urllib2.Request(url, headers)
#有时访问某些网站需要提供一些信息，例如用户名和密码，这时可以这样：
values = {"username":"yourname","password":"????"}
data = urllib.urlencode(values)
request = urllib2.Request(url, data, headers)
#在遇到网络状况不好时可以设置timeout来设置等待多久超时
response = urllib2.urlopen(request，timeout=18)
print response.read()
有关更多相关内容，请参阅此 urllib 和 urllib2。
（二）requests，一个简单、美观、友好的外部库。
请求的所有功能都可以通过以下7种方法访问。它们都返回响应对象的一个实例。
#创建并发送一个request
requests.request(method, url, **kwargs)
参数：
method -- method for the new Request object.
url -- URL for the new Request object.
params -- (optional) Dictionary or bytes to be sent in the query string for the Request.
data -- (optional) Dictionary, bytes, or file-like object to send in the body of the Request.
json -- (optional) json data to send in the body of the Request.
headers -- (optional) Dictionary of HTTP Headers to send with the Request.
cookies -- (optional) Dict or CookieJar object to send with the Request.
files -- (optional) Dictionary of 'name': file-like-objects (or {'name': file-tuple}) for multipart encoding upload. file-tuple can be a 2-tuple ('filename', fileobj), 3-tuple ('filename', fileobj, 'content_type') or a 4-tuple ('filename', fileobj, 'content_type', custom_headers), where 'content-type' is a string defining the content type of the given file and custom_headers a dict-like object containing additional headers to add for the file.
auth -- (optional) Auth tuple to enable Basic/Digest/Custom HTTP Auth.
timeout (float or tuple) -- (optional) How long to wait for the server to send data before giving up, as a float, or a (connect timeout, read timeout) tuple.
allow_redirects (bool) -- (optional) Boolean. Set to True if POST/PUT/DELETE redirect following is allowed.
proxies -- (optional) Dictionary mapping protocol to the URL of the proxy.
verify -- (optional) whether the SSL cert will be verified. A CA_BUNDLE path can also be provided. Defaults to True.
stream -- (optional) if False, the response content will be immediately downloaded.
cert -- (optional) if String, path to ssl client cert file (.pem). If Tuple, ('cert', 'key') pair.
#例如：
import requests
url='xxxx'
headers = {'User-Agent' : 'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.102 Safari/537.36'}
proxies = { 'http' : '127.0.0.1:8118'}
response=requests.request('GET',url, timeout=20, proxies=proxies, headers=headers)
返回类型requests.Response
另：
#发送一个HEAD request.
requests.head(url, **kwargs)
#发送一个GET request
requests.get(url, params=None, **kwargs)
#发送一个POST request
requests.post(url, data=None, json=None, **kwargs)
#发送一个PUT request
requests.put(url, data=None, **kwargs)
#发送一个PATCH request
requests.patch(url, data=None, **kwargs)
#发送一个DELETE request
requests.delete(url, **kwargs)
更多详情请参考官网要求。
（三）Selenium + PhantomJs，高效处理动态网页的完美组合。
使用前面的方法我们可以简单的得到网页的html代码。如果我们遇到需要用JS渲染的网页内容，就会变得很麻烦。因此，我们需要一个可以像浏览器一样处理要被JS渲染的页面的工具，而PhantomJs是一个基于WebKit的无界面网页交互工具。它提供的JavaScript API可以实现自动浏览、截图等浏览器功能。Selenium 是一款自动化测试工具，支持火狐、Chrome、Safari 等主流浏览器。借助 selenium，可以模拟人类的各种网页操作行为，例如打开浏览器、输入信息、点击、翻页等。PhantomJS 作为没有界面的浏览器，Selenium 会不会感冒？答案很冷，因为 PhantomJs 不仅可以完成浏览器的功能，而且相对来说效率更高。例如：
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
phantomjs_path = '/data/opt/brew/lib/node_modules/phantomjs/lib/phantom/bin/phantomjs'
driver = webdriver.PhantomJS(executable_path=phantomjs_path)
url = 'xxxx'
driver.get(url)
#轻松得到到JS渲染页面的源码
page_source = driver.page_source.encode('utf8')
有时我们需要实现页面交互，即当我们可以在浏览器上模拟点击、输入、鼠标移动等各种行为时，首先需要定位页面元素。其中，WebDriver提供了多种实现元素定位的方法：
#定位一个元素的方法有
find_element_by_id
find_element_by_name
find_element_by_xpath
find_element_by_link_text
find_element_by_partial_link_text
find_element_by_tag_name
find_element_by_class_name
find_element_by_css_selector
#定位多元素，返回一个list，方法有
find_elements_by_name
find_elements_by_xpath
find_elements_by_link_text
find_elements_by_partial_link_text
find_elements_by_tag_name
find_elements_by_class_name
find_elements_by_css_selector
#例如有如下网页源码：
#form可以这样来定位
login_form = driver.find_element_by_id('loginForm')
#username&password两个元素定位如下
username = driver.find_element_by_name('username')
password = driver.find_element_by_name('password')
#如果使用xpath来定位username，以下方法都ok
username = driver.find_element_by_xpath("//form[input/@name='username']")
username = driver.find_element_by_xpath("//form[@id='loginForm']/input[1]")
username = driver.find_element_by_xpath("//input[@name='username']")
更多信息请参考 selenium_python, PhantomJS。
这篇文章简单介绍了获取网页源内容的各种方法，包括静态网页中经常使用的urllib、urllib2、requests和selenium、phantomjs的组合。在爬取过程中，我们经常需要提取和保留网页中的有用信息，所以接下来介绍如何从获取的网页源代码中提取有用信息。
python抓取动态网页(Python确是最常用的，你知道为什么吗？-天启)
网站优化 • 优采云 发表了文章 • 0 个评论 • 34 次浏览 • 2022-03-31 15:16
python抓取动态网页(Python确是最常用的，你知道为什么吗？-天启)
说起网络爬虫，相信大家都不陌生。爬虫可以捕获 网站 或应用程序的内容以提取有用的有价值信息。有很多编程语言可以用来实现爬虫，但是Python是最常用的，你知道为什么吗？一起来看看Apocalypse HTTP吧~
与C相比，Python和C Python的语言虽然是从C发展而来的，但是在使用中，Python的库是完整方便的，而C的语言就麻烦很多了。要实现同样的功能，Python 只需要 10 行代码，而 C 语言可能需要 100 行甚至更多。但是，在运行速度方面，C语言更好。
与Java相比，Java的解析器多，对网页解析的支持非常好。Java也有爬虫的相关库，但没有Python多。但是，就爬虫的效果而言，Java和Python都可以做到，只是工程量不同，实现方式也不同。如果需要处理复杂的网页、解析网页内容生成结构化数据或精细解析网页内容，java 更适合。
Python与其他语言没有本质区别，比Python语法简洁明了，开发效率高。此外，python语言的流行还有几个原因：
1.网页抓取界面简洁；
与其他动态脚本语言相比，Python 提供了更完善的访问 Web 文档的 API；与其他静态编程语言相比，Python 爬取网页文档的界面更加简洁。
2.强大的第三方库
另外，爬取网页有时需要模拟浏览器的行为，很多网站被屏蔽用于生硬的爬虫爬取。这时候我们就需要模拟User Agent的行为来构造合适的请求，比如模拟用户登录，模拟Session/Cookie的存储和设置。Python 中有一些优秀的第三方包可以为你做这件事，例如 Requests 或 Mechanize。
3.数据处理快捷方便
抓取的网页通常需要进行处理，例如过滤Html标签、提取文本等。Python的Beautiful Soup提供了简洁的文档处理功能，可以用极短的代码完成大部分文档处理。其实很多语言和工具都可以做到以上功能，但是Python可以做到最快最干净。
高效爬虫除了使用开发效率高的编程语言外，还需要代理IP的协助。天启HTTP提供优质爬虫IP、高度匿名资源、全国海量IP，帮助企业高效爬取数据。 查看全部
说起网络爬虫，相信大家都不陌生。爬虫可以捕获 网站 或应用程序的内容以提取有用的有价值信息。有很多编程语言可以用来实现爬虫，但是Python是最常用的，你知道为什么吗？一起来看看Apocalypse HTTP吧~
与C相比，Python和C Python的语言虽然是从C发展而来的，但是在使用中，Python的库是完整方便的，而C的语言就麻烦很多了。要实现同样的功能，Python 只需要 10 行代码，而 C 语言可能需要 100 行甚至更多。但是，在运行速度方面，C语言更好。
与Java相比，Java的解析器多，对网页解析的支持非常好。Java也有爬虫的相关库，但没有Python多。但是，就爬虫的效果而言，Java和Python都可以做到，只是工程量不同，实现方式也不同。如果需要处理复杂的网页、解析网页内容生成结构化数据或精细解析网页内容，java 更适合。
Python与其他语言没有本质区别，比Python语法简洁明了，开发效率高。此外，python语言的流行还有几个原因：
1.网页抓取界面简洁；
与其他动态脚本语言相比，Python 提供了更完善的访问 Web 文档的 API；与其他静态编程语言相比，Python 爬取网页文档的界面更加简洁。
2.强大的第三方库
另外，爬取网页有时需要模拟浏览器的行为，很多网站被屏蔽用于生硬的爬虫爬取。这时候我们就需要模拟User Agent的行为来构造合适的请求，比如模拟用户登录，模拟Session/Cookie的存储和设置。Python 中有一些优秀的第三方包可以为你做这件事，例如 Requests 或 Mechanize。
3.数据处理快捷方便
抓取的网页通常需要进行处理，例如过滤Html标签、提取文本等。Python的Beautiful Soup提供了简洁的文档处理功能，可以用极短的代码完成大部分文档处理。其实很多语言和工具都可以做到以上功能，但是Python可以做到最快最干净。
高效爬虫除了使用开发效率高的编程语言外，还需要代理IP的协助。天启HTTP提供优质爬虫IP、高度匿名资源、全国海量IP，帮助企业高效爬取数据。 查看全部
python抓取动态网页(Python确是最常用的，你知道为什么吗？-天启)
说起网络爬虫，相信大家都不陌生。爬虫可以捕获 网站 或应用程序的内容以提取有用的有价值信息。有很多编程语言可以用来实现爬虫，但是Python是最常用的，你知道为什么吗？一起来看看Apocalypse HTTP吧~
与C相比，Python和C Python的语言虽然是从C发展而来的，但是在使用中，Python的库是完整方便的，而C的语言就麻烦很多了。要实现同样的功能，Python 只需要 10 行代码，而 C 语言可能需要 100 行甚至更多。但是，在运行速度方面，C语言更好。
与Java相比，Java的解析器多，对网页解析的支持非常好。Java也有爬虫的相关库，但没有Python多。但是，就爬虫的效果而言，Java和Python都可以做到，只是工程量不同，实现方式也不同。如果需要处理复杂的网页、解析网页内容生成结构化数据或精细解析网页内容，java 更适合。
Python与其他语言没有本质区别，比Python语法简洁明了，开发效率高。此外，python语言的流行还有几个原因：
1.网页抓取界面简洁；
与其他动态脚本语言相比，Python 提供了更完善的访问 Web 文档的 API；与其他静态编程语言相比，Python 爬取网页文档的界面更加简洁。
2.强大的第三方库
另外，爬取网页有时需要模拟浏览器的行为，很多网站被屏蔽用于生硬的爬虫爬取。这时候我们就需要模拟User Agent的行为来构造合适的请求，比如模拟用户登录，模拟Session/Cookie的存储和设置。Python 中有一些优秀的第三方包可以为你做这件事，例如 Requests 或 Mechanize。
3.数据处理快捷方便
抓取的网页通常需要进行处理，例如过滤Html标签、提取文本等。Python的Beautiful Soup提供了简洁的文档处理功能，可以用极短的代码完成大部分文档处理。其实很多语言和工具都可以做到以上功能，但是Python可以做到最快最干净。
高效爬虫除了使用开发效率高的编程语言外，还需要代理IP的协助。天启HTTP提供优质爬虫IP、高度匿名资源、全国海量IP，帮助企业高效爬取数据。
python抓取动态网页(Python学习群：审查网页元素与网页源码是什么？)
网站优化 • 优采云 发表了文章 • 0 个评论 • 31 次浏览 • 2022-03-25 11:23
python抓取动态网页(Python学习群：审查网页元素与网页源码是什么？)
简要地
下面的代码是一个用python实现的网络爬虫，用于爬取动态网页。此页面上最新、最好的内容是由 JavaScript 动态生成的。审查网页元素与网页源代码不同。
我创建了一个Python学习的小学习圈，为大家提供了一个共同讨论学习Python的平台。欢迎来到Python学习群：960410445，一起讨论视频分享学习。Python是未来的发展方向，它正在挑战我们的分析能力和对世界的认知方式。因此，我们必须与时俱进，迎接变化，不断发展壮大。掌握核心Python技术才是掌握真正的价值。
以上是网页的源代码
以上是评论页面元素
所以这里不能简单的使用正则表达式来获取内容。
以下是获取内容并存入数据库的完整思路和源码。
实施思路：
抓取实际访问的动态页面的url——使用正则表达式获取你需要的内容——解析内容——存储内容
上述部分流程以文字说明：
抓取实际访问过的动态页面的url：
在火狐浏览器中，右键打开插件，使用**firebug review element** *（如果没有这个需要安装firebug插件），找到并打开**Network (NET)* * 标签。重新加载网页，获取网页的响应信息，包括连接地址。每个连接地址都可以在浏览器中打开。这个网站的动态网页访问地址是：
源代码
注意：使用python的版本是2.7 查看全部
简要地
下面的代码是一个用python实现的网络爬虫，用于爬取动态网页。此页面上最新、最好的内容是由 JavaScript 动态生成的。审查网页元素与网页源代码不同。
我创建了一个Python学习的小学习圈，为大家提供了一个共同讨论学习Python的平台。欢迎来到Python学习群：960410445，一起讨论视频分享学习。Python是未来的发展方向，它正在挑战我们的分析能力和对世界的认知方式。因此，我们必须与时俱进，迎接变化，不断发展壮大。掌握核心Python技术才是掌握真正的价值。
以上是网页的源代码
以上是评论页面元素
所以这里不能简单的使用正则表达式来获取内容。
以下是获取内容并存入数据库的完整思路和源码。
实施思路：
抓取实际访问的动态页面的url——使用正则表达式获取你需要的内容——解析内容——存储内容
上述部分流程以文字说明：
抓取实际访问过的动态页面的url：
在火狐浏览器中，右键打开插件，使用**firebug review element** *（如果没有这个需要安装firebug插件），找到并打开**Network (NET)* * 标签。重新加载网页，获取网页的响应信息，包括连接地址。每个连接地址都可以在浏览器中打开。这个网站的动态网页访问地址是：
源代码
注意：使用python的版本是2.7 查看全部
python抓取动态网页(Python学习群：审查网页元素与网页源码是什么？)
简要地
下面的代码是一个用python实现的网络爬虫，用于爬取动态网页。此页面上最新、最好的内容是由 JavaScript 动态生成的。审查网页元素与网页源代码不同。
我创建了一个Python学习的小学习圈，为大家提供了一个共同讨论学习Python的平台。欢迎来到Python学习群：960410445，一起讨论视频分享学习。Python是未来的发展方向，它正在挑战我们的分析能力和对世界的认知方式。因此，我们必须与时俱进，迎接变化，不断发展壮大。掌握核心Python技术才是掌握真正的价值。
以上是网页的源代码
以上是评论页面元素
所以这里不能简单的使用正则表达式来获取内容。
以下是获取内容并存入数据库的完整思路和源码。
实施思路：
抓取实际访问的动态页面的url——使用正则表达式获取你需要的内容——解析内容——存储内容
上述部分流程以文字说明：
抓取实际访问过的动态页面的url：
在火狐浏览器中，右键打开插件，使用**firebug review element** *（如果没有这个需要安装firebug插件），找到并打开**Network (NET)* * 标签。重新加载网页，获取网页的响应信息，包括连接地址。每个连接地址都可以在浏览器中打开。这个网站的动态网页访问地址是：
源代码
注意：使用python的版本是2.7
python抓取动态网页(JavaScript逆向工程如何从网络API中获取JSON格式的数据)
网站优化 • 优采云 发表了文章 • 0 个评论 • 45 次浏览 • 2022-03-24 11:00
python抓取动态网页(JavaScript逆向工程如何从网络API中获取JSON格式的数据)
解析动态内容
根据权威机构发布的《全球互联网无障碍审计报告》，全球约四分之三的网站内容或部分内容是通过JavaScript动态生成的，这意味着“以一种在HTML代码中找不到浏览器窗口“源代码”，说明我们以前抓取数据的方式并不能正常工作。解决这样的问题基本上有两种方案，一种是JavaScript逆向工程；另一种是渲染 JavaScript 以获取渲染的内容。
JavaScript 逆向工程
我们以“360图片”网站为例来说明什么是JavaScript逆向工程。其实所谓JavaScript逆向工程就是通过Ajax技术找到动态获取数据的接口。在浏览器中输入打开“360图片”的“美颜”板块，如下图所示。
[外链图片传输失败(img-ZRl9xYmn-75)(./res/image360-website.png)]
但是当我们在浏览器中使用右键菜单“显示网页的源代码”时，我们惊奇地发现页面的HTML代码中有一个链接。
没有标签，那么我们看到的图片是怎么出现的呢？原来所有的图片都是通过JavaScript动态加载的，在浏览器“开发者工具”的“网络”中可以找到获取这些图片数据的web API接口，如下图所示。
[外链图片传输失败(img-XVAx1JK3-78)(./res/api-image360.png)]
那么结论就很简单了。只要找到这些网络API接口，就可以通过这些接口获取数据。当然，在实际开发中，我们可能还需要对这些接口的参数和接口返回的数据进行分析，以了解各个参数的含义以及返回的 JSON 数据的格式，以便我们可以在我们的爬虫。
如何从网络API中获取JSON格式的数据，提取出我们需要的内容，在上一篇《文件与异常》中已经说明，这里不再赘述。
使用硒
虽然很多网站保护了自己的网络API接口，增加了获取数据的难度，但大部分只要努力够就可以进行逆向工程，但是在实际开发中，我们可以通过浏览器渲染引擎来避免这些繁琐的工作，WebKit 是一个利用的渲染引擎。
WebKit 的代码始于 1998 年的 KHTML 项目，当时它是 Konqueror 浏览器的渲染引擎。2001 年，Apple 从这个项目的代码中衍生出 WebKit，并将其应用到 Safari 浏览器中，早期的 Chrome 浏览器也使用了内核。在 Python 中，我们可以通过 Qt 框架获取 WebKit 引擎，并使用它来渲染页面以获取动态内容。此内容请阅读文章《爬虫技术：动态页面爬取超级指南》。
如果你不打算使用上面的方法来渲染页面并获取动态内容，其实还有一种替代方法可以使用自动化测试工具 Selenium，它提供了浏览器自动化的 API 接口，这样你就可以通过操纵浏览器。内容。首先，您可以使用 pip 安装 Selenium。
pip3 install selenium
下面以“阿里巴巴V任务”的“直播服务”为例，演示如何使用Selenium获取动态内容和抓拍主播的画面。
import requests
from bs4 import BeautifulSoup
def main():
resp = requests.get('https://v.taobao.com/v/content/live?catetype=704&from=taonvlang')
soup = BeautifulSoup(resp.text, 'lxml')
for img_tag in soup.select('img[src]'):
print(img_tag.attrs['src'])
if __name__ == '__main__':
main()
运行上面的程序会发现没有输出，因为页面的html代码根本找不到
标签。接下来，我们使用 Selenium 来获取页面上的动态内容，然后提取锚点图像。
from bs4 import BeautifulSoup
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
def main():
driver = webdriver.Chrome()
driver.get('https://v.taobao.com/v/content/live?catetype=704&from=taonvlang')
soup = BeautifulSoup(driver.page_source, 'lxml')
for img_tag in soup.body.select('img[src]'):
print(img_tag.attrs['src'])
if __name__ == '__main__':
main()
在上面的程序中，我们使用 Selenium 来控制 Chrome 浏览器。如果我们要控制其他浏览器，可以创建相应的浏览器对象，比如Firefox、IE等。运行上面的程序，如果看到下图的错误信息，说明我们没有添加Chrome浏览器驱动PATH环境变量，我们也没有在程序中指定Chrome浏览器驱动的位置。
selenium.common.exceptions.WebDriverException: Message: 'chromedriver' executable needs to be in PATH. Please see https://sites.google.com/a/chr ... /home
为了解决以上问题，可以到Selenium的官方网站找到浏览器驱动的下载链接，下载需要的驱动。在 Linux 或 macOS 系统中，可以通过以下命令设置 PATH 环境变量，在 Windows 下配置环境变量也很简单，不清楚的可以自行理解。
export PATH=$PATH:/Users/Hao/Downloads/Tools/chromedriver/
其中/Users/Hao/Downloads/Tools/chromedriver/是chromedriver所在的路径。 查看全部
解析动态内容
根据权威机构发布的《全球互联网无障碍审计报告》，全球约四分之三的网站内容或部分内容是通过JavaScript动态生成的，这意味着“以一种在HTML代码中找不到浏览器窗口“源代码”，说明我们以前抓取数据的方式并不能正常工作。解决这样的问题基本上有两种方案，一种是JavaScript逆向工程；另一种是渲染 JavaScript 以获取渲染的内容。
JavaScript 逆向工程
我们以“360图片”网站为例来说明什么是JavaScript逆向工程。其实所谓JavaScript逆向工程就是通过Ajax技术找到动态获取数据的接口。在浏览器中输入打开“360图片”的“美颜”板块，如下图所示。
[外链图片传输失败(img-ZRl9xYmn-75)(./res/image360-website.png)]
但是当我们在浏览器中使用右键菜单“显示网页的源代码”时，我们惊奇地发现页面的HTML代码中有一个链接。
没有标签，那么我们看到的图片是怎么出现的呢？原来所有的图片都是通过JavaScript动态加载的，在浏览器“开发者工具”的“网络”中可以找到获取这些图片数据的web API接口，如下图所示。
[外链图片传输失败(img-XVAx1JK3-78)(./res/api-image360.png)]
那么结论就很简单了。只要找到这些网络API接口，就可以通过这些接口获取数据。当然，在实际开发中，我们可能还需要对这些接口的参数和接口返回的数据进行分析，以了解各个参数的含义以及返回的 JSON 数据的格式，以便我们可以在我们的爬虫。
如何从网络API中获取JSON格式的数据，提取出我们需要的内容，在上一篇《文件与异常》中已经说明，这里不再赘述。
使用硒
虽然很多网站保护了自己的网络API接口，增加了获取数据的难度，但大部分只要努力够就可以进行逆向工程，但是在实际开发中，我们可以通过浏览器渲染引擎来避免这些繁琐的工作，WebKit 是一个利用的渲染引擎。
WebKit 的代码始于 1998 年的 KHTML 项目，当时它是 Konqueror 浏览器的渲染引擎。2001 年，Apple 从这个项目的代码中衍生出 WebKit，并将其应用到 Safari 浏览器中，早期的 Chrome 浏览器也使用了内核。在 Python 中，我们可以通过 Qt 框架获取 WebKit 引擎，并使用它来渲染页面以获取动态内容。此内容请阅读文章《爬虫技术：动态页面爬取超级指南》。
如果你不打算使用上面的方法来渲染页面并获取动态内容，其实还有一种替代方法可以使用自动化测试工具 Selenium，它提供了浏览器自动化的 API 接口，这样你就可以通过操纵浏览器。内容。首先，您可以使用 pip 安装 Selenium。
pip3 install selenium
下面以“阿里巴巴V任务”的“直播服务”为例，演示如何使用Selenium获取动态内容和抓拍主播的画面。
import requests
from bs4 import BeautifulSoup
def main():
resp = requests.get('https://v.taobao.com/v/content/live?catetype=704&from=taonvlang')
soup = BeautifulSoup(resp.text, 'lxml')
for img_tag in soup.select('img[src]'):
print(img_tag.attrs['src'])
if __name__ == '__main__':
main()
运行上面的程序会发现没有输出，因为页面的html代码根本找不到
标签。接下来，我们使用 Selenium 来获取页面上的动态内容，然后提取锚点图像。
from bs4 import BeautifulSoup
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
def main():
driver = webdriver.Chrome()
driver.get('https://v.taobao.com/v/content/live?catetype=704&from=taonvlang')
soup = BeautifulSoup(driver.page_source, 'lxml')
for img_tag in soup.body.select('img[src]'):
print(img_tag.attrs['src'])
if __name__ == '__main__':
main()
在上面的程序中，我们使用 Selenium 来控制 Chrome 浏览器。如果我们要控制其他浏览器，可以创建相应的浏览器对象，比如Firefox、IE等。运行上面的程序，如果看到下图的错误信息，说明我们没有添加Chrome浏览器驱动PATH环境变量，我们也没有在程序中指定Chrome浏览器驱动的位置。
selenium.common.exceptions.WebDriverException: Message: 'chromedriver' executable needs to be in PATH. Please see https://sites.google.com/a/chr ... /home
为了解决以上问题，可以到Selenium的官方网站找到浏览器驱动的下载链接，下载需要的驱动。在 Linux 或 macOS 系统中，可以通过以下命令设置 PATH 环境变量，在 Windows 下配置环境变量也很简单，不清楚的可以自行理解。
export PATH=$PATH:/Users/Hao/Downloads/Tools/chromedriver/
其中/Users/Hao/Downloads/Tools/chromedriver/是chromedriver所在的路径。 查看全部
python抓取动态网页(JavaScript逆向工程如何从网络API中获取JSON格式的数据)
解析动态内容
根据权威机构发布的《全球互联网无障碍审计报告》，全球约四分之三的网站内容或部分内容是通过JavaScript动态生成的，这意味着“以一种在HTML代码中找不到浏览器窗口“源代码”，说明我们以前抓取数据的方式并不能正常工作。解决这样的问题基本上有两种方案，一种是JavaScript逆向工程；另一种是渲染 JavaScript 以获取渲染的内容。
JavaScript 逆向工程
我们以“360图片”网站为例来说明什么是JavaScript逆向工程。其实所谓JavaScript逆向工程就是通过Ajax技术找到动态获取数据的接口。在浏览器中输入打开“360图片”的“美颜”板块，如下图所示。
[外链图片传输失败(img-ZRl9xYmn-75)(./res/image360-website.png)]
但是当我们在浏览器中使用右键菜单“显示网页的源代码”时，我们惊奇地发现页面的HTML代码中有一个链接。
没有标签，那么我们看到的图片是怎么出现的呢？原来所有的图片都是通过JavaScript动态加载的，在浏览器“开发者工具”的“网络”中可以找到获取这些图片数据的web API接口，如下图所示。
[外链图片传输失败(img-XVAx1JK3-78)(./res/api-image360.png)]
那么结论就很简单了。只要找到这些网络API接口，就可以通过这些接口获取数据。当然，在实际开发中，我们可能还需要对这些接口的参数和接口返回的数据进行分析，以了解各个参数的含义以及返回的 JSON 数据的格式，以便我们可以在我们的爬虫。
如何从网络API中获取JSON格式的数据，提取出我们需要的内容，在上一篇《文件与异常》中已经说明，这里不再赘述。
使用硒
虽然很多网站保护了自己的网络API接口，增加了获取数据的难度，但大部分只要努力够就可以进行逆向工程，但是在实际开发中，我们可以通过浏览器渲染引擎来避免这些繁琐的工作，WebKit 是一个利用的渲染引擎。
WebKit 的代码始于 1998 年的 KHTML 项目，当时它是 Konqueror 浏览器的渲染引擎。2001 年，Apple 从这个项目的代码中衍生出 WebKit，并将其应用到 Safari 浏览器中，早期的 Chrome 浏览器也使用了内核。在 Python 中，我们可以通过 Qt 框架获取 WebKit 引擎，并使用它来渲染页面以获取动态内容。此内容请阅读文章《爬虫技术：动态页面爬取超级指南》。
如果你不打算使用上面的方法来渲染页面并获取动态内容，其实还有一种替代方法可以使用自动化测试工具 Selenium，它提供了浏览器自动化的 API 接口，这样你就可以通过操纵浏览器。内容。首先，您可以使用 pip 安装 Selenium。
pip3 install selenium
下面以“阿里巴巴V任务”的“直播服务”为例，演示如何使用Selenium获取动态内容和抓拍主播的画面。
import requests
from bs4 import BeautifulSoup
def main():
resp = requests.get('https://v.taobao.com/v/content/live?catetype=704&from=taonvlang')
soup = BeautifulSoup(resp.text, 'lxml')
for img_tag in soup.select('img[src]'):
print(img_tag.attrs['src'])
if __name__ == '__main__':
main()
运行上面的程序会发现没有输出，因为页面的html代码根本找不到
标签。接下来，我们使用 Selenium 来获取页面上的动态内容，然后提取锚点图像。
from bs4 import BeautifulSoup
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
def main():
driver = webdriver.Chrome()
driver.get('https://v.taobao.com/v/content/live?catetype=704&from=taonvlang')
soup = BeautifulSoup(driver.page_source, 'lxml')
for img_tag in soup.body.select('img[src]'):
print(img_tag.attrs['src'])
if __name__ == '__main__':
main()
在上面的程序中，我们使用 Selenium 来控制 Chrome 浏览器。如果我们要控制其他浏览器，可以创建相应的浏览器对象，比如Firefox、IE等。运行上面的程序，如果看到下图的错误信息，说明我们没有添加Chrome浏览器驱动PATH环境变量，我们也没有在程序中指定Chrome浏览器驱动的位置。
selenium.common.exceptions.WebDriverException: Message: 'chromedriver' executable needs to be in PATH. Please see https://sites.google.com/a/chr ... /home
为了解决以上问题，可以到Selenium的官方网站找到浏览器驱动的下载链接，下载需要的驱动。在 Linux 或 macOS 系统中，可以通过以下命令设置 PATH 环境变量，在 Windows 下配置环境变量也很简单，不清楚的可以自行理解。
export PATH=$PATH:/Users/Hao/Downloads/Tools/chromedriver/
其中/Users/Hao/Downloads/Tools/chromedriver/是chromedriver所在的路径。
python抓取动态网页(利用selenium的子模块webdriver的html内容解决的问题)
网站优化 • 优采云 发表了文章 • 0 个评论 • 62 次浏览 • 2022-03-24 10:15
python抓取动态网页(利用selenium的子模块webdriver的html内容解决的问题)
文章目的
我们在使用Python爬取网页数据时，经常会用到urllib模块，它通过调用urllib模块的urlopen(url)方法返回网页对象，并使用read()方法获取url的html内容，然后使用 BeautifulSoup 抓取某个 Tag 内容，结合正则表达式过滤。但是，使用 urllib.urlopen(url).read() 得到的只是网页的静态 html 内容。很多动态数据（如网站访问者数、当前在线人数、微博点赞数等）收录在静态html中，比如我要抓取当前在线人数本bbs网站中的每一部分，不收录静态html页面（不信你尝试查看页面源代码，只有简单的一行）。
解决方案
我试过网上说的浏览器自带的开发者工具（一般是F12弹出对应网页的开发者工具），查网络获取动态数据的走势，但这需要多方寻找线索网址。我个人觉得太麻烦了。另外，用查看器查看的html内容也收录动态数据，但是有几个问题：如何实时获取查看器的html内容？如何将查看器的html导入python程序？因此，使用查看器的html内容的方法也不符合爬虫的要求。
偶然发现了selenium模块，发现这个模块可以很方便的根据url加载页面获取session，并找到当前session对应的label。本文将使用 selenium webdriver 模块来获取这些动态生成的内容，尤其是一些重要的动态数据。事实上，selenium 模块的功能并不仅限于爬取网页。它是网络自动化测试的常用模块。它广泛用于 Ruby 和 Java。虽然 Python 用的比较少，但它也是一个非常简单、高效、好用的自动化测试。模块。通过使用selenium的子模块webdriver解决动态数据的抓取问题，也可以对selenium有一个基本的了解，为进一步学习自动化测试打下基础。
实施流程操作环境
我在Windows 7系统上安装了Python 2.7版本，使用Python(X,Y) IDE，安装的Python库没有自带selenium，直接在Python程序中导入selenium会提示有没有这个模块，联网状态下，cmd直接进入pip install selenium，系统会找到Python安装目录直接下载、解压安装这个模块。终端提示完成后，可以查看C:\Python27\Lib\site-packages目录下是否有selenium模块。此目录取决于您安装 Python 的路径。如果有 selenium 和 selenium-2.47.3.dist-info 文件夹，则表示可以在 Python 程序中加载该模块。
使用 webdriver 抓取动态数据
1.先导入webdriver子模块
从硒导入网络驱动程序
2.获取浏览器的会话。浏览器可以使用 Firefox、Chrome、IE 等。这里我们以火狐为例
浏览器 = webdriver.Firefox()
3.加载页面，url本身可以指定合法字符串
浏览器.get(url)
4.获取到session对象后，定位元素，webdriver提供了一系列元素定位方法，常用的有以下几种方式：
ID
姓名
班级名称
关联
文本
部分的
关联
文本
标签
姓名
路径
选择器
比如通过id定位，返回所有元素的列表，lis=borwser.find_elements_by_id_name('kw'')
按类名定位，lis=find_elements_by_class_name('title_1')
更详细的定位方法请参考大神《博客园-昆虫大师》的selenium webdriver（python）教程第三章-定位方法部分（第一版可百度文库阅读，第二版）版将从头开始收费>- 查看全部
文章目的
我们在使用Python爬取网页数据时，经常会用到urllib模块，它通过调用urllib模块的urlopen(url)方法返回网页对象，并使用read()方法获取url的html内容，然后使用 BeautifulSoup 抓取某个 Tag 内容，结合正则表达式过滤。但是，使用 urllib.urlopen(url).read() 得到的只是网页的静态 html 内容。很多动态数据（如网站访问者数、当前在线人数、微博点赞数等）收录在静态html中，比如我要抓取当前在线人数本bbs网站中的每一部分，不收录静态html页面（不信你尝试查看页面源代码，只有简单的一行）。
解决方案
我试过网上说的浏览器自带的开发者工具（一般是F12弹出对应网页的开发者工具），查网络获取动态数据的走势，但这需要多方寻找线索网址。我个人觉得太麻烦了。另外，用查看器查看的html内容也收录动态数据，但是有几个问题：如何实时获取查看器的html内容？如何将查看器的html导入python程序？因此，使用查看器的html内容的方法也不符合爬虫的要求。
偶然发现了selenium模块，发现这个模块可以很方便的根据url加载页面获取session，并找到当前session对应的label。本文将使用 selenium webdriver 模块来获取这些动态生成的内容，尤其是一些重要的动态数据。事实上，selenium 模块的功能并不仅限于爬取网页。它是网络自动化测试的常用模块。它广泛用于 Ruby 和 Java。虽然 Python 用的比较少，但它也是一个非常简单、高效、好用的自动化测试。模块。通过使用selenium的子模块webdriver解决动态数据的抓取问题，也可以对selenium有一个基本的了解，为进一步学习自动化测试打下基础。
实施流程操作环境
我在Windows 7系统上安装了Python 2.7版本，使用Python(X,Y) IDE，安装的Python库没有自带selenium，直接在Python程序中导入selenium会提示有没有这个模块，联网状态下，cmd直接进入pip install selenium，系统会找到Python安装目录直接下载、解压安装这个模块。终端提示完成后，可以查看C:\Python27\Lib\site-packages目录下是否有selenium模块。此目录取决于您安装 Python 的路径。如果有 selenium 和 selenium-2.47.3.dist-info 文件夹，则表示可以在 Python 程序中加载该模块。
使用 webdriver 抓取动态数据
1.先导入webdriver子模块
从硒导入网络驱动程序
2.获取浏览器的会话。浏览器可以使用 Firefox、Chrome、IE 等。这里我们以火狐为例
浏览器 = webdriver.Firefox()
3.加载页面，url本身可以指定合法字符串
浏览器.get(url)
4.获取到session对象后，定位元素，webdriver提供了一系列元素定位方法，常用的有以下几种方式：
ID
姓名
班级名称
关联
文本
部分的
关联
文本
标签
姓名
路径
选择器
比如通过id定位，返回所有元素的列表，lis=borwser.find_elements_by_id_name('kw'')
按类名定位，lis=find_elements_by_class_name('title_1')
更详细的定位方法请参考大神《博客园-昆虫大师》的selenium webdriver（python）教程第三章-定位方法部分（第一版可百度文库阅读，第二版）版将从头开始收费>- 查看全部
python抓取动态网页(利用selenium的子模块webdriver的html内容解决的问题)
文章目的
我们在使用Python爬取网页数据时，经常会用到urllib模块，它通过调用urllib模块的urlopen(url)方法返回网页对象，并使用read()方法获取url的html内容，然后使用 BeautifulSoup 抓取某个 Tag 内容，结合正则表达式过滤。但是，使用 urllib.urlopen(url).read() 得到的只是网页的静态 html 内容。很多动态数据（如网站访问者数、当前在线人数、微博点赞数等）收录在静态html中，比如我要抓取当前在线人数本bbs网站中的每一部分，不收录静态html页面（不信你尝试查看页面源代码，只有简单的一行）。
解决方案
我试过网上说的浏览器自带的开发者工具（一般是F12弹出对应网页的开发者工具），查网络获取动态数据的走势，但这需要多方寻找线索网址。我个人觉得太麻烦了。另外，用查看器查看的html内容也收录动态数据，但是有几个问题：如何实时获取查看器的html内容？如何将查看器的html导入python程序？因此，使用查看器的html内容的方法也不符合爬虫的要求。
偶然发现了selenium模块，发现这个模块可以很方便的根据url加载页面获取session，并找到当前session对应的label。本文将使用 selenium webdriver 模块来获取这些动态生成的内容，尤其是一些重要的动态数据。事实上，selenium 模块的功能并不仅限于爬取网页。它是网络自动化测试的常用模块。它广泛用于 Ruby 和 Java。虽然 Python 用的比较少，但它也是一个非常简单、高效、好用的自动化测试。模块。通过使用selenium的子模块webdriver解决动态数据的抓取问题，也可以对selenium有一个基本的了解，为进一步学习自动化测试打下基础。
实施流程操作环境
我在Windows 7系统上安装了Python 2.7版本，使用Python(X,Y) IDE，安装的Python库没有自带selenium，直接在Python程序中导入selenium会提示有没有这个模块，联网状态下，cmd直接进入pip install selenium，系统会找到Python安装目录直接下载、解压安装这个模块。终端提示完成后，可以查看C:\Python27\Lib\site-packages目录下是否有selenium模块。此目录取决于您安装 Python 的路径。如果有 selenium 和 selenium-2.47.3.dist-info 文件夹，则表示可以在 Python 程序中加载该模块。
使用 webdriver 抓取动态数据
1.先导入webdriver子模块
从硒导入网络驱动程序
2.获取浏览器的会话。浏览器可以使用 Firefox、Chrome、IE 等。这里我们以火狐为例
浏览器 = webdriver.Firefox()
3.加载页面，url本身可以指定合法字符串
浏览器.get(url)
4.获取到session对象后，定位元素，webdriver提供了一系列元素定位方法，常用的有以下几种方式：
ID
姓名
班级名称
关联
文本
部分的
关联
文本
标签
姓名
路径
选择器
比如通过id定位，返回所有元素的列表，lis=borwser.find_elements_by_id_name('kw'')
按类名定位，lis=find_elements_by_class_name('title_1')
更详细的定位方法请参考大神《博客园-昆虫大师》的selenium webdriver（python）教程第三章-定位方法部分（第一版可百度文库阅读，第二版）版将从头开始收费>-
python抓取动态网页(Python进程与线程操作技巧汇总(图)实现抓取javascript动态生成)
网站优化 • 优采云 发表了文章 • 0 个评论 • 31 次浏览 • 2022-03-22 01:13
python抓取动态网页(Python进程与线程操作技巧汇总(图)实现抓取javascript动态生成)
python3实现爬取javascript动态生成的html页面示例 Python  /  Admin 发表于3年前   50
本文的例子描述了Python3爬取javascript动态生成的HTML页面的功能。分享给大家，供大家参考，如下：
使用urllib等爬取网页只能读取网页的静态源文件，不能读取javascript生成的内容。
原因是因为urllib是瞬时爬取的，不会等待javascript的加载延迟，所以页面中javascript生成的内容无法被urllib读取。
真的没有办法读取javascript生成的内容吗？也不是！
这里介绍一个python库：selenium，本文使用的版本是2.44.0
先安装：
pip install -U selenium
以下三个例子说明了它的用法：
【示例0】
打开火狐浏览器
在给定的url地址加载页面
from selenium import webdriverbrowser = webdriver.Firefox()browser.get('http://www.baidu.com/')
【示例一】
打开火狐浏览器
加载百度主页
搜索“seleniumhq”
关闭浏览器
from selenium import webdriverfrom selenium.webdriver.common.keys import Keysbrowser = webdriver.Firefox()browser.get('http://www.baidu.com')assert '百度' in browser.titleelem = browser.find_element_by_name('p') # Find the search boxelem.send_keys('seleniumhq' + Keys.RETURN) # 模拟按键browser.quit()
【示例2】
Selenium WebDriver 通常用于测试网络程序。下面是一个使用 Python 标准库 unittest 的示例：
import unittestclass BaiduTestCase(unittest.TestCase): def setUp(self): self.browser = webdriver.Firefox() self.addCleanup(self.browser.quit) def testPageTitle(self): self.browser.get('http://www.baidu.com') self.assertIn('百度', self.browser.title)if __name__ == '__main__': unittest.main(verbosity=2)
对更多Python相关内容感兴趣的读者可以查看本站专题：《Python进程和线程操作技巧总结》、《Python套接字编程技巧总结》、《Python数据结构与算法教程》、 《Python函数使用》技巧总结》、《Python字符串操作技巧总结》、《Python入门与进阶经典教程》和《Python文件和目录操作技巧总结》
希望这篇文章对你的 Python 编程有所帮助。 查看全部
python3实现爬取javascript动态生成的html页面示例 Python  /  Admin 发表于3年前   50
本文的例子描述了Python3爬取javascript动态生成的HTML页面的功能。分享给大家，供大家参考，如下：
使用urllib等爬取网页只能读取网页的静态源文件，不能读取javascript生成的内容。
原因是因为urllib是瞬时爬取的，不会等待javascript的加载延迟，所以页面中javascript生成的内容无法被urllib读取。
真的没有办法读取javascript生成的内容吗？也不是！
这里介绍一个python库：selenium，本文使用的版本是2.44.0
先安装：
pip install -U selenium
以下三个例子说明了它的用法：
【示例0】
打开火狐浏览器
在给定的url地址加载页面
from selenium import webdriverbrowser = webdriver.Firefox()browser.get('http://www.baidu.com/')
【示例一】
打开火狐浏览器
加载百度主页
搜索“seleniumhq”
关闭浏览器
from selenium import webdriverfrom selenium.webdriver.common.keys import Keysbrowser = webdriver.Firefox()browser.get('http://www.baidu.com')assert '百度' in browser.titleelem = browser.find_element_by_name('p') # Find the search boxelem.send_keys('seleniumhq' + Keys.RETURN) # 模拟按键browser.quit()
【示例2】
Selenium WebDriver 通常用于测试网络程序。下面是一个使用 Python 标准库 unittest 的示例：
import unittestclass BaiduTestCase(unittest.TestCase): def setUp(self): self.browser = webdriver.Firefox() self.addCleanup(self.browser.quit) def testPageTitle(self): self.browser.get('http://www.baidu.com') self.assertIn('百度', self.browser.title)if __name__ == '__main__': unittest.main(verbosity=2)
对更多Python相关内容感兴趣的读者可以查看本站专题：《Python进程和线程操作技巧总结》、《Python套接字编程技巧总结》、《Python数据结构与算法教程》、 《Python函数使用》技巧总结》、《Python字符串操作技巧总结》、《Python入门与进阶经典教程》和《Python文件和目录操作技巧总结》
希望这篇文章对你的 Python 编程有所帮助。 查看全部
python抓取动态网页(Python进程与线程操作技巧汇总(图)实现抓取javascript动态生成)
python3实现爬取javascript动态生成的html页面示例 Python  /  Admin 发表于3年前   50
本文的例子描述了Python3爬取javascript动态生成的HTML页面的功能。分享给大家，供大家参考，如下：
使用urllib等爬取网页只能读取网页的静态源文件，不能读取javascript生成的内容。
原因是因为urllib是瞬时爬取的，不会等待javascript的加载延迟，所以页面中javascript生成的内容无法被urllib读取。
真的没有办法读取javascript生成的内容吗？也不是！
这里介绍一个python库：selenium，本文使用的版本是2.44.0
先安装：
pip install -U selenium
以下三个例子说明了它的用法：
【示例0】
打开火狐浏览器
在给定的url地址加载页面
from selenium import webdriverbrowser = webdriver.Firefox()browser.get('http://www.baidu.com/')
【示例一】
打开火狐浏览器
加载百度主页
搜索“seleniumhq”
关闭浏览器
from selenium import webdriverfrom selenium.webdriver.common.keys import Keysbrowser = webdriver.Firefox()browser.get('http://www.baidu.com')assert '百度' in browser.titleelem = browser.find_element_by_name('p') # Find the search boxelem.send_keys('seleniumhq' + Keys.RETURN) # 模拟按键browser.quit()
【示例2】
Selenium WebDriver 通常用于测试网络程序。下面是一个使用 Python 标准库 unittest 的示例：
import unittestclass BaiduTestCase(unittest.TestCase): def setUp(self): self.browser = webdriver.Firefox() self.addCleanup(self.browser.quit) def testPageTitle(self): self.browser.get('http://www.baidu.com') self.assertIn('百度', self.browser.title)if __name__ == '__main__': unittest.main(verbosity=2)
对更多Python相关内容感兴趣的读者可以查看本站专题：《Python进程和线程操作技巧总结》、《Python套接字编程技巧总结》、《Python数据结构与算法教程》、 《Python函数使用》技巧总结》、《Python字符串操作技巧总结》、《Python入门与进阶经典教程》和《Python文件和目录操作技巧总结》
希望这篇文章对你的 Python 编程有所帮助。
python抓取动态网页(Python利用urllib2抓取网页返回乱码的问题(:输出:直接print))
网站优化 • 优采云 发表了文章 • 0 个评论 • 23 次浏览 • 2022-03-21 05:18
python抓取动态网页(Python利用urllib2抓取网页返回乱码的问题(:输出:直接print))
Python使用urllib2爬取网页，返回乱码： 输出：可以直接打印中文，而且注释的中文不会乱码，所以可以解析乱码的网页找到有用的解决方法！！ 【问题解答】从问题现象到问题本质，一点点帮你分析一下为什么会出现问题，如何解决问题1.首先根据之前Python IDE的经验：【整理】各种Python IDE（集成开发环境）的总结和对比从上面的截图，基本上可以推断出它使用：【记录】IDE使用Python：Eclipse+PyDev2.所以，在为了完全重现问题，我去PyDev搭建了一个对应的项目。代码为：?1112131415#-*-coding:utf-8-*-'''CreatedonOct18,2013***@author:CLi'''fromurllibimporturlopendefgetHtml(url):page=urlopen(url)html=page.read ( )page.close()returnhtmlif__name__=="__main__":161718url=""html=getHtml(url)printhtml 那么输出就和原来一模一样了：3.出现这种现象的原因：（根据to：详细爬取网站，模拟登录和抓取动态网页的原理与实现（Python、C#等）：【整理】关于HTML网页源码（GB2312、GBK）的字符编码（charset）格式, UTF-8, ISO8859-1 等）先）确认要处理的网页：/in:? 1（再根据：Character Encoding Concise Tutorial），我们可以看到这里的代码处理中，如果需要解码成Unicode，最好使用GBK。
这里得到的新浪网页字符串对应GB2312。在Eclipse+PyDev的控制台中输出，但是结果是乱码。可以确定：在Eclipse+PyDev的控制台中，使用的字符编码不是GB2312（也不是GBK或GB18030)猜测：估计是用的，比较常用，UTF-84.但是不管它使用什么编码，都应该可以输出Unicode字符串：5.为了验证上面PyDev的console是UTF-8的猜测，所以使用编码：?6223#-* -coding:utf -8-*-'''CreatedonOct18,2013***@author:CLi'''fromurllibimporturlopendefgetHtml(url):page=urlopen(url)html=page.read()page.close()#uniCodehtml =html.decode("GBK")#returnuniCodehtmluniCodehtml=html.decode("GBK")utf8html=uniCodehtml.encode("UTF-8")returnutf8htmlif__name__=="__main__":url=""html=getHtml(url)printhtml的结果输出是Predicted，正常：6. 接下来很明显：你需要弄清楚为什么在这里：在Eclipse+PyDev的Console中，（不是我们之前做的，调用windows的cmd，以为It是GBK编码）但它是UTF-8编码然后参考：PrintingUnicodeineclips ePydevconsoleandinIdle 看看：结果在Eclipse的Window->Preferences中，找了半天也没找到console的编码设置。
最后是：选择你的PyDev项目->Run->RunConfiguration->PythonRun->选择你当前的PyDev项目->Common->Encoding看：current，你的PyDev项目，运行时，控制台的编码used对应utf-87.，改成GBK:，然后点击运行。因此，如果在使用前有意将 Unicode 转换为 UTF-8，则此时的输出与预期的一样。到了，乱码：对应，去使用，最原创的代码，直接输出（获得GB2312新浪网页），代码未经任何转换：8.由此可以充分理解原因：（1)@ >从sina获取的html网页，这个字符串本身的字符编码为：GB2312(2)在Eclipse+PyDev中直接打印输出到控制台时，因为控制台默认为UTF-8编码，所以：将GB2312 查看全部
Python使用urllib2爬取网页，返回乱码： 输出：可以直接打印中文，而且注释的中文不会乱码，所以可以解析乱码的网页找到有用的解决方法！！ 【问题解答】从问题现象到问题本质，一点点帮你分析一下为什么会出现问题，如何解决问题1.首先根据之前Python IDE的经验：【整理】各种Python IDE（集成开发环境）的总结和对比从上面的截图，基本上可以推断出它使用：【记录】IDE使用Python：Eclipse+PyDev2.所以，在为了完全重现问题，我去PyDev搭建了一个对应的项目。代码为：?1112131415#-*-coding:utf-8-*-'''CreatedonOct18,2013***@author:CLi'''fromurllibimporturlopendefgetHtml(url):page=urlopen(url)html=page.read ( )page.close()returnhtmlif__name__=="__main__":161718url=""html=getHtml(url)printhtml 那么输出就和原来一模一样了：3.出现这种现象的原因：（根据to：详细爬取网站，模拟登录和抓取动态网页的原理与实现（Python、C#等）：【整理】关于HTML网页源码（GB2312、GBK）的字符编码（charset）格式, UTF-8, ISO8859-1 等）先）确认要处理的网页：/in:? 1（再根据：Character Encoding Concise Tutorial），我们可以看到这里的代码处理中，如果需要解码成Unicode，最好使用GBK。
这里得到的新浪网页字符串对应GB2312。在Eclipse+PyDev的控制台中输出，但是结果是乱码。可以确定：在Eclipse+PyDev的控制台中，使用的字符编码不是GB2312（也不是GBK或GB18030)猜测：估计是用的，比较常用，UTF-84.但是不管它使用什么编码，都应该可以输出Unicode字符串：5.为了验证上面PyDev的console是UTF-8的猜测，所以使用编码：?6223#-* -coding:utf -8-*-'''CreatedonOct18,2013***@author:CLi'''fromurllibimporturlopendefgetHtml(url):page=urlopen(url)html=page.read()page.close()#uniCodehtml =html.decode("GBK")#returnuniCodehtmluniCodehtml=html.decode("GBK")utf8html=uniCodehtml.encode("UTF-8")returnutf8htmlif__name__=="__main__":url=""html=getHtml(url)printhtml的结果输出是Predicted，正常：6. 接下来很明显：你需要弄清楚为什么在这里：在Eclipse+PyDev的Console中，（不是我们之前做的，调用windows的cmd，以为It是GBK编码）但它是UTF-8编码然后参考：PrintingUnicodeineclips ePydevconsoleandinIdle 看看：结果在Eclipse的Window->Preferences中，找了半天也没找到console的编码设置。
最后是：选择你的PyDev项目->Run->RunConfiguration->PythonRun->选择你当前的PyDev项目->Common->Encoding看：current，你的PyDev项目，运行时，控制台的编码used对应utf-87.，改成GBK:，然后点击运行。因此，如果在使用前有意将 Unicode 转换为 UTF-8，则此时的输出与预期的一样。到了，乱码：对应，去使用，最原创的代码，直接输出（获得GB2312新浪网页），代码未经任何转换：8.由此可以充分理解原因：（1)@ >从sina获取的html网页，这个字符串本身的字符编码为：GB2312(2)在Eclipse+PyDev中直接打印输出到控制台时，因为控制台默认为UTF-8编码，所以：将GB2312 查看全部
python抓取动态网页(Python利用urllib2抓取网页返回乱码的问题(:输出:直接print))
Python使用urllib2爬取网页，返回乱码： 输出：可以直接打印中文，而且注释的中文不会乱码，所以可以解析乱码的网页找到有用的解决方法！！ 【问题解答】从问题现象到问题本质，一点点帮你分析一下为什么会出现问题，如何解决问题1.首先根据之前Python IDE的经验：【整理】各种Python IDE（集成开发环境）的总结和对比从上面的截图，基本上可以推断出它使用：【记录】IDE使用Python：Eclipse+PyDev2.所以，在为了完全重现问题，我去PyDev搭建了一个对应的项目。代码为：?1112131415#-*-coding:utf-8-*-'''CreatedonOct18,2013***@author:CLi'''fromurllibimporturlopendefgetHtml(url):page=urlopen(url)html=page.read ( )page.close()returnhtmlif__name__=="__main__":161718url=""html=getHtml(url)printhtml 那么输出就和原来一模一样了：3.出现这种现象的原因：（根据to：详细爬取网站，模拟登录和抓取动态网页的原理与实现（Python、C#等）：【整理】关于HTML网页源码（GB2312、GBK）的字符编码（charset）格式, UTF-8, ISO8859-1 等）先）确认要处理的网页：/in:? 1（再根据：Character Encoding Concise Tutorial），我们可以看到这里的代码处理中，如果需要解码成Unicode，最好使用GBK。
这里得到的新浪网页字符串对应GB2312。在Eclipse+PyDev的控制台中输出，但是结果是乱码。可以确定：在Eclipse+PyDev的控制台中，使用的字符编码不是GB2312（也不是GBK或GB18030)猜测：估计是用的，比较常用，UTF-84.但是不管它使用什么编码，都应该可以输出Unicode字符串：5.为了验证上面PyDev的console是UTF-8的猜测，所以使用编码：?6223#-* -coding:utf -8-*-'''CreatedonOct18,2013***@author:CLi'''fromurllibimporturlopendefgetHtml(url):page=urlopen(url)html=page.read()page.close()#uniCodehtml =html.decode("GBK")#returnuniCodehtmluniCodehtml=html.decode("GBK")utf8html=uniCodehtml.encode("UTF-8")returnutf8htmlif__name__=="__main__":url=""html=getHtml(url)printhtml的结果输出是Predicted，正常：6. 接下来很明显：你需要弄清楚为什么在这里：在Eclipse+PyDev的Console中，（不是我们之前做的，调用windows的cmd，以为It是GBK编码）但它是UTF-8编码然后参考：PrintingUnicodeineclips ePydevconsoleandinIdle 看看：结果在Eclipse的Window->Preferences中，找了半天也没找到console的编码设置。
最后是：选择你的PyDev项目->Run->RunConfiguration->PythonRun->选择你当前的PyDev项目->Common->Encoding看：current，你的PyDev项目，运行时，控制台的编码used对应utf-87.，改成GBK:，然后点击运行。因此，如果在使用前有意将 Unicode 转换为 UTF-8，则此时的输出与预期的一样。到了，乱码：对应，去使用，最原创的代码，直接输出（获得GB2312新浪网页），代码未经任何转换：8.由此可以充分理解原因：（1)@ >从sina获取的html网页，这个字符串本身的字符编码为：GB2312(2)在Eclipse+PyDev中直接打印输出到控制台时，因为控制台默认为UTF-8编码，所以：将GB2312
python抓取动态网页(一个基于webkit内核的无头浏览器浏览器)
网站优化 • 优采云 发表了文章 • 0 个评论 • 15 次浏览 • 2022-03-21 05:15
python抓取动态网页(一个基于webkit内核的无头浏览器浏览器)
查看元素后发现百度图片中，显示图片的div是：pullimages
这个 div 里面的内容是动态加载的。但是使用urllib&urllib2就爬不上了。
要抓取动态加载的元素，首先考虑使用 selenium 调用浏览器进行抓取。
而我们的运行环境是linux，最理想的方式是无界面抓取，所以使用selenium+phantomjs无界面抓取。
什么是phantomjs？它是一个基于webkit核心的无头浏览器，也就是没有UI界面，就是一个浏览器。
selenium和phantomjs的安装配置可以google，这里就不多说了。
代码如下：
from selenium import webdriver
driver = webdriver.PhantomJS(executable_path='/bin/phantomjs/bin/phantomjs')
#如果不方便配置环境变量。就使用phantomjs的绝对路径也可以
driver.get('http://image.baidu.com/i%3Fie% ... %2339;)
#抓取了百度图片，query：周杰伦
driver.page_source
#这就是返回的页面内容了，与urllib2.urlopen().read()的效果是类似的，但比urllib2强在能抓取到动态渲染后的内容。
driver.quit()
去这里。成功抓取动态页面。 查看全部
查看元素后发现百度图片中，显示图片的div是：pullimages
这个 div 里面的内容是动态加载的。但是使用urllib&urllib2就爬不上了。
要抓取动态加载的元素，首先考虑使用 selenium 调用浏览器进行抓取。
而我们的运行环境是linux，最理想的方式是无界面抓取，所以使用selenium+phantomjs无界面抓取。
什么是phantomjs？它是一个基于webkit核心的无头浏览器，也就是没有UI界面，就是一个浏览器。
selenium和phantomjs的安装配置可以google，这里就不多说了。
代码如下：
from selenium import webdriver
driver = webdriver.PhantomJS(executable_path='/bin/phantomjs/bin/phantomjs')
#如果不方便配置环境变量。就使用phantomjs的绝对路径也可以
driver.get('http://image.baidu.com/i%3Fie% ... %2339;)
#抓取了百度图片，query：周杰伦
driver.page_source
#这就是返回的页面内容了，与urllib2.urlopen().read()的效果是类似的，但比urllib2强在能抓取到动态渲染后的内容。
driver.quit()
去这里。成功抓取动态页面。 查看全部
python抓取动态网页(一个基于webkit内核的无头浏览器浏览器)
查看元素后发现百度图片中，显示图片的div是：pullimages
这个 div 里面的内容是动态加载的。但是使用urllib&urllib2就爬不上了。
要抓取动态加载的元素，首先考虑使用 selenium 调用浏览器进行抓取。
而我们的运行环境是linux，最理想的方式是无界面抓取，所以使用selenium+phantomjs无界面抓取。
什么是phantomjs？它是一个基于webkit核心的无头浏览器，也就是没有UI界面，就是一个浏览器。
selenium和phantomjs的安装配置可以google，这里就不多说了。
代码如下：
from selenium import webdriver
driver = webdriver.PhantomJS(executable_path='/bin/phantomjs/bin/phantomjs')
#如果不方便配置环境变量。就使用phantomjs的绝对路径也可以
driver.get('http://image.baidu.com/i%3Fie% ... %2339;)
#抓取了百度图片，query：周杰伦
driver.page_source
#这就是返回的页面内容了，与urllib2.urlopen().read()的效果是类似的，但比urllib2强在能抓取到动态渲染后的内容。
driver.quit()
去这里。成功抓取动态页面。
