网页爬虫抓取百度图片(像是这样%AB%98%(图)(组图))
　　我最近在玩机器学习，想创建一个识别动画图片的训练集。我因没有太多动画图片而苦恼。后来突然想到可以用百度图片，于是写了一个简单的爬虫来抓取百度图片（图片关于一个关键词）
　　第一步是找到搜索图片的url。
　　打开百度图片网页，搜索“高清动画”，检查元素，检查网络，清除网络请求数据，将页面滚动到底部，看到自动加载更多，然后找到加载更多数据的url在网络请求中。像这样 %E9%AB%98%E6%B8%85%E5%8A%A8%E6%BC%AB&cl=2&lm=-1&ie=utf-8&oe=utf-8&adpicid=&st=-1&z=&ic=0&word= % E4%BA%8C%E6%AC%A1%E5%85%83&s=&se=&tab=&width=&height=&face=0&istype=2&qc=&nc=1&fr=&pn=60&rn=30&gsm=1000000001e&81=
　　对比几个加载较多的URL，发现rn参数是每页显示的次数，pn参数是已经请求的次数。通过修改rn参数和pn参数，观察返回的数据，发现每页最多只能有60个，即rn设置最大为60.
　　第二步是分析返回的数据。
　　通过浏览器请求上面的url，在页面上看到一个超级json。分析后发现图片的url是thumbURL、middleURL、hoverurl这三个属性，在返回的字符串中搜索这三个属性的编号，发现该编号与分页数一模一样. 通过浏览器打开这三个url，发现thumburl比middleUrl大，和hoverUrl是同一个url。其实还有一个objUrl（原图）可以用，但是url不稳定，有时候404，有时候访问被拒绝。
　　然后代码
　　我的 python 版本是 2.7
　　更新于 2017 年 2 月 11 日
　　1.保存的图片改成原来的高清大图OjbUrl
　　2.修改使用方法，可以在命令行输入搜索关键字
　　3.随时保存，保存前不再需要搜索所有图片。
　　百度图片搜索.py
　　#coding=utf-8
from urllib import quote
import urllib2 as urllib
import re
import os
class BaiduImage():
def __init__(self, keyword, count=2000, save_path="img", rn=60):
self.keyword = keyword
self.count = count
self.save_path = save_path
self.rn = rn
self.__imageList = []
self.__totleCount = 0
self.__encodeKeyword = quote(self.keyword)
self.__acJsonCount = self.__get_ac_json_count()
self.user_agent = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.95 Safari/537.36"
self.headers = {'User-Agent': self.user_agent, "Upgrade-Insecure-Requests": 1,
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
"Accept-Encoding": "gzip, deflate, sdch",
"Accept-Language": "zh-CN,zh;q=0.8,en;q=0.6",
"Cache-Control": "no-cache"}
# "Host": Host,
def search(self):
for i in range(0, self.__acJsonCount):
url = self.__get_search_url(i * self.rn)
response = self.__get_response(url).replace("\\", "")
image_url_list = self.__pick_image_urls(response)
self.__save(image_url_list)
def __save(self, image_url_list, save_path=None):
if save_path:
self.save_path = save_path
print "已经存储 " + str(self.__totleCount) + "张"
print "正在存储 " + str(len(image_url_list)) + "张，存储路径：" + self.save_path
if not os.path.exists(self.save_path):
os.makedirs(self.save_path)
for image in image_url_list:
host = self.get_url_host(image)
self.headers["Host"] = host
with open(self.save_path + "/%s.jpg" % self.__totleCount, "wb") as p:
try:
req = urllib.Request(image, headers=self.headers)
# 设置一个urlopen的超时，如果10秒访问不到，就跳到下一个地址，防止程序卡在一个地方。
img = urllib.urlopen(req, timeout=20)
p.write(img.read())
p.close()
self.__totleCount += 1
except Exception as e:
print "Exception" + str(e)
p.close()
if os.path.exists("img/%s.jpg" % self.__totleCount):
os.remove("img/%s.jpg" % self.__totleCount)
print "已存储 " + str(self.__totleCount) + " 张图片"
def __pick_image_urls(self, response):
reg = r'"ObjURL":"(http://img[0-9]\.imgtn.*?)"'
imgre = re.compile(reg)
imglist = re.findall(imgre, response)
return imglist
def __get_response(self, url):
page = urllib.urlopen(url)
return page.read()
def __get_search_url(self, pn):
return "http://image.baidu.com/search/ ... ot%3B + self.__encodeKeyword + "&cl=2&lm=-1&ie=utf-8&oe=utf-8&adpicid=&st=-1&z=&ic=0&word=" + self.__encodeKeyword + "&s=&se=&tab=&width=&height=&face=0&istype=2&qc=&nc=1&fr=&pn=" + str(pn) + "&rn=" + str(self.rn) + "&gsm=1000000001e&1486375820481="
def get_url_host(self, url):
reg = r'http://(.*?)/'
hostre = re.compile(reg)
host = re.findall(hostre, url)
if len(host) > 0:
return host[0]
return ""
def __get_ac_json_count(self):
a = self.count % self.rn
c = self.count / self.rn
if a:
c += 1
return c
　　使用示例
　　运行.py
　　#coding=utf-8
from BaiduImageSearch import BaiduImage
import sys
keyword = " ".join(sys.argv[1:])
save_path = "_".join(sys.argv[1:])
if not keyword:
print "亲，你忘记带搜索内容了哦~ 搜索内容关键字可多个，使用空格分开"
print "例如：python run.py 男生 头像"
else:
search = BaiduImage(keyword, save_path=save_path)
search.search()
　　ps：记得把_init_.py文件添加到两个文件的同一目录下！！！
　　run 方法，python run.py 关键字 1 关键字 2 关键字 3…
　　一般搜索超过1900条就没有了。 查看全部

　　网页爬虫抓取百度图片(一张前端与反爬虫这一的区别)
　　[目录]
　　1. 前言
　　对于一个网页，我们往往希望它结构合理，内容清晰，以便搜索引擎能够准确识别。另一方面，还有一些我们不希望内容被轻易获取的场景，比如电商的交易量网站、教育话题网站等。因为这些内容往往是产品的命脉，必须得到有效保护。这就是爬行动物和反爬行动物的话题的由来。爬取图片的整体操作流程可以分为三个步骤：
　　获取页面信息 读取图片链接并将图片保存在本地指定目录
　　2. 常见的反爬虫策略
　　但是世界上没有可以完美反爬虫的网站。
　　如果页面想要在不给爬虫机会的情况下正常显示在用户面前，它必须能够识别真人和机器人。因此，工程师们进行了各种尝试。这些策略大多用在后端，也是目前比较常规有效的手段，比如：
　　而爬行动物可以无限接近真人，比如：
　　所以我们说，100% 反爬策略？不存在的。这更像是一种体力活动，这是一个困难的问题。
　　不过作为前端工程师，我们可以增加游戏的难度，设计一些非常（sang）有意义（bing）思维（kuang）**的反爬虫策略。
　　3.前端和反爬虫3.1 FONT-FACE拼凑
　　示例：猫眼电影
　　在猫眼电影中，票房数据并不是纯粹的数字。页面使用font-face定义字符集，使用unicode映射显示。也就是说，除了图像识别，还要同时爬取字符集才能识别数字。
　　而且，每次页面刷新，字符集的url都会发生变化，这无疑增加了爬取成本，难度更大。
　　3.2 背景拼凑
　　例子：
　　与字体的策略类似，美团使用背景拼凑。数字实际上是图片，根据不同的背景偏移量显示不同的字符。
　　而不同的页面，图片的字符排序也不同。但是理论上只需要生成0-9和一个小数点，所以不明白为什么会有重复的字符。
　　3.3 个字符穿插
　　示例：微信公众号文章
　　一些微信公众号的文章中穿插着各种神秘的人物，这些人物都是通过样式隐藏起来的。这种方法虽然令人震惊……但其实识别过滤也不是太难，甚至可以做得更好，但也是一种脑洞。
　　3.4 伪元素隐藏
　　示例：汽车主页
　　汽车之家，关键制造商信息被放入伪元素的内容中。这也是一种思路：爬取网页，必须解析CSS，获取伪元素的内容，增加了爬虫的难度。
　　3.5 元素定位叠加
　　示例：去哪里
　　数学爱好者在哪里？对于一个4位数的票价，先用四个i标签渲染，然后用两个b标签进行绝对定位偏移，覆盖故意显示错误的i标签，最后在视觉上形成正确的价格……
　　这说明爬虫无法解析CSS，必须做数学题。
　　3.6 IFRAME 异步加载
　　例子：
　　打开网易云音乐页面时，html源码中几乎只有一个iframe，其src为空：about:blank。然后js开始运行，整个页面的frame异步塞进iframe中……
　　不过这种方式带来的难度并不大，只是在异步和iframe处理上走了弯路（或者还有其他原因，不完全基于反爬的考虑），不管你用selenium还是phantom，都有API可用于 iframe 中的内容信息。
　　3.7 个字符分割
　　示例：全网代理IP
　　在一些显示代理IP信息的页面上，IP的保护也很麻烦。
　　他们会先将 IP 号和符号划分为 dom 节点，然后在中间插入混淆数字。如果爬虫不知道这个策略，就会认为自己成功获取了值；但如果爬虫注意到，它就会被解决。.
　　3.8 个字符集替换
　　示例：去哪里移动边
　　移动版去哪儿也会欺骗爬虫。
　　3211明明写在html里，但是1233是直观显示的。原来他们重新定义了字符集，3和1的顺序刚好互换了结果……
　　4.示例：爬取百度图库
　　import re
import os
import time
import requests
# from selenium import webdriver
#########################
###此段代码不需要关心啥意思###
#########################
if not os.path.exists('百度图片'):
os.mkdir('百度图片')
#####################
###限制30张图片的代码###
####################
# 获取所有图片
response = requests.get(
'http://image.baidu.com/search/ ... rd%3D风景')
data = response.text
img_desc_dics = re.findall("app.setData(\('imgData.*?\));", data, re.S)[0]
img_desc_dics = eval(str(img_desc_dics))
# 获取所有图片的数据
img_datas = img_desc_dics[1]['data']
count = 0
for img_data in img_datas:
# 获取搜索图片的参数
os_ = img_data.get('os')
cs_ = img_data.get('cs')
if os_ and cs_:
# 获取搜索图片的信息
img_search_url = f'http://image.baidu.com/search/ ... cs%3D{cs_}&os={os_}'
img_search_response = requests.get(img_search_url)
img_search_data = img_search_response.text
# 获取图片信息
img_url = re.findall('''\('firstSc'\);" src="(.*?)"''', img_search_data)[0]
img_name = img_url.split('/')[-1]
img_name = os.path.join('百度图片', img_name) # 拼接出图片的地址，如 百度图片/3822951_144045377000_2.jpg
# 保存图片
img_response = requests.get(img_url)
img_data = img_response.content
fw = open(img_name, 'wb')
fw.write(img_data)
fw.flush()
# 提示
count += 1
print(f'{img_name}保存成功，成功保存{count}张')
# 防止百度禁ip，慢一点
time.sleep(0.01)
　　
　　#########################################################################
###自行百度selenium的用法，使用这一套代码可以无限爬取所有图片，否则将被限制30张###
## 记得加库哦
########################################################################
page_count_end = 2 # 爬取 指定数字（10）* 30 = 300张图片
chrome = webdriver.Chrome()
## 安装谷歌插件
##http://chromedriver.storage.go ... iomsg
## 查看你电脑的谷歌版本，寻找对应版本进行下载解压
try:
chrome.implicitly_wait(10)
chrome.get(
'http://image.baidu.com/search/ ... rd%3D风景')
js_code = '''
window.scrollTo(0, document.body.scrollHeight);
var lenOfPage = document.body.scrollHeight;
return lenOfPage
'''
# selenium控制爬取页数
count = 0
page_count = 0
while page_count < page_count_end:
try:
page_count += 1
chrome.execute_script(js_code)
time.sleep(0.3)
except:
continue
img_desc_search_urls = re.findall(&#39;href="(/search/detail\?.*?)"&#39;, chrome.page_source, re.S) # re.S使.可以匹配换行符
# 获取所有图片的数据
for img_data in img_desc_search_urls:
try:
# 获取搜索图片的参数
os_ = re.findall(&#39;os=(.*?)&amp;&#39;, img_data)[0]
cs_ = re.findall(&#39;cs=(.*?)&amp;&#39;, img_data)[0]
if os_ and cs_:
# 获取搜索图片的信息
img_search_url = f&#39;http://image.baidu.com/search/ ... cs%3D{cs_}&os={os_}&#39;
img_search_response = requests.get(img_search_url)
img_search_data = img_search_response.text
# 获取图片信息
img_url = re.findall(&#39;&#39;&#39;\(&#39;firstSc&#39;\);" src="(.*?)"&#39;&#39;&#39;, img_search_data)[0]
img_name = img_url.split(&#39;/&#39;)[-1]
img_name = os.path.join(&#39;百度图片&#39;, img_name) # 拼接出图片的地址，如 百度图片/3822951_144045377000_2.jpg
# 保存图片
img_response = requests.get(img_url)
img_data = img_response.content
fw = open(img_name, &#39;wb&#39;)
fw.write(img_data)
fw.flush()
# 提示
count += 1
print(f&#39;{img_name}保存成功，成功保存{count}张&#39;)
# 防止百度禁ip，慢一点
time.sleep(0.01)
except:
continue
except Exception:
pass
finally:
chrome.close()
　　结果
　　
　　
　　由于百度的反爬措施是不断更新的，如果过了一段时间还想爬，就需要寻找新的规则
　　5.总结
　　对于每个 网站 爬行，都有一定的规则。每一个网站，尤其是大的网站，都在定期排版。做爬虫，必须注意细节，慎重决策。对于成败，找到你需要的文字、图片，或者视频、文件等，找到它们的链接，进行多重分析，耐心找出规律，这是你成功的关键。 查看全部

　　网页爬虫抓取百度图片(如何使用加载加载技术的网页数据异步技术(图)
)
　　当你搜索百度图片（百度图片）时，你会发现，当你向下滑动鼠标时，会自动加载下一页的图片数据，但是网页的URL并没有改变。因此，您无法通过通常的构建 URL 的方法来抓取 Web 数据。这是由于网页使用的异步加载技术。
　　异步加载技术
　　传统网页如果需要更新网页信息，则需要重新加载整个网页的数据信息。因此，会出现加载速度慢的情况，导致用户体验不佳。但是，使用异步加载技术加载网页数据，会通过后台与服务器之间的少量数据交换来完成数据更新。
　　接下来，我们将描述如何使用异步加载技术来抓取 Web 数据。以简书网为例（）网页是《从零开始学Python网络爬虫》作者罗攀的主页。我们的目的是抓取用户文章主题
　　
　　1、在Chrome浏览器中按F12或者右键动态-&gt;勾选，继续向下滚动浏览其他没有变化的动态发现页面的URL。选择 Network-&gt;XHR-&gt;Response 选项将观察到网页返回一个 XML 文件。
　　
　　2、连续向下滑动页面观察Name列的数据，获取之前页面的URL
　　3、通过分析网页数据，我们可以得到常规的url，然后爬取数据就容易多了。下面的代码：
　　import requests
import re
#构造URL列表
urls = [&#39;https://www.jianshu.com/u/9104 ... ge%3D{0}/u&#39;.format(str(i)) for i in range(1,20)]
headers = {&#39;user-agent&#39;: &#39;Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36&#39;}
for url in urls:
res = requests.get(url,headers = headers)
selsctor = re.findall(&#39;(.*?)&#39;,res.content.decode(&#39;utf-8&#39;),re.S)
for i in selsctor:
print(i) 查看全部

　　网页爬虫抓取百度图片(Python的爬虫模块训练集图片数据采集图片集
)
　　百度图库关键词爬虫脚本本章设计了一个基于Python的爬虫模块，可以根据用户自定义的关键词和要爬取的图片数量，自动保存百度图库采集中的图片数据。功能设计与分析
　　该模块为后续模型训练提供了一个数据集，属于data采集部分。该模块的功能应解决以下问题：
　　目标网站的图片数量足够多，车辆类型涵盖基本类型，爬取难度不要太高。综合分析，百度图库可以满足上述要求。因此以百度图库为目标爬取网站。爬虫模块应该能够根据不同的输入危险车辆类别爬取不同类型的车辆图片，所以要求爬虫模块能够根据不同的车辆类别名称爬取图片采集图片爬虫模块应该是能够根据用户指定的编号爬取采集图片，然后对Python语言爬虫相关库进行编号分类
　　
<p>#/*
#* @Author: hujinlei
#* @Date: 2018-06-07 20:50:31
#* @Last Modified by: hjl
#* @Last Modified time: 2018-06-07 20:50:31
#*/
import os
import re
#import urllib
import json
import socket
import urllib.request
import urllib.parse
import urllib.error
# 设置超时
import time
timeout = 8
socket.setdefaulttimeout(timeout)
#!/usr/bin/env python
# -*- coding:utf-8 -*-
class Crawler:
# 睡眠时长
__time_sleep = 0.1
__amount = 0
__start_amount = 0
__counter = 0
headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:23.0) Gecko/20100101 Firefox/23.0'}
# 获取图片url内容等
# t 下载图片时间间隔
def __init__(self, t=0.1):
self.time_sleep = t
# 获取后缀名
def get_suffix(self, name):
m = re.search(r'\.[^\.]*$', name)
if m.group(0) and len(m.group(0)) 查看全部

　　网页爬虫抓取百度图片(Python语言程序简单高效，编写网络爬虫有特别的优势)
　　1.什么是爬虫
　　爬虫，网络爬虫，可以理解为在互联网上爬行的蜘蛛。互联网就像一张大网，爬虫就是在这张网上四处爬行的蜘蛛。如果遇到资源，就会被抢。你想抢什么？由你来控制它。例如，它正在抓取网页。在这个网页中，它找到了一条路，这条路实际上是一个指向网页的超链接。然后它可以爬到另一个网站来获取数据。这样一来，整个互联网络对这只蜘蛛来说触手可及，分分钟爬下来也不是问题。
　　网络爬虫是一组可以自动从网站的相关网页中搜索和提取数据的程序。提取和存储这些数据是进一步数据分析的关键和前提。Python语言程序简单高效，编写网络爬虫具有特殊优势。尤其是业界有专门为Python编写的各种爬虫程序框架，使得爬虫程序的编写更加简单高效。
　　Python 是一种面向对象的解释型计算机编程语言。它是开源的、免费的、功能强大的，并且语法简洁明了。它拥有丰富而强大的库。它是一种广泛使用的编程语言。
　　2.浏览网页的过程
　　在用户浏览网页的过程中，我们可能会看到很多漂亮的图片，比如我们会看到几张图片和百度搜索框，这个过程其实就是用户输入网址后，经过DNS服务器，找到服务器主机, 向服务器发送请求，服务器解析后向用户浏览器发送HTML、JS、CSS等文件。浏览器解析后，用户可以看到各种图片。
　　因此，用户看到的网页本质上是由 HTML 代码组成的，爬虫爬取这些内容。通过对这些HTML代码进行分析和过滤，实现图片、文字等资源的获取。 查看全部

　　网页爬虫抓取百度图片(本文侧重于的系统设计和实现的部分细节，内容来源于两方面)
　　网络爬虫经常被忽视，尤其是与搜索引擎的光环相比，这似乎有点黯淡。我很少看到 文章 或详细说明爬虫实现的文档。但是，爬虫其实是一个非常重要的系统，尤其是在当今数据为王的时代。如果你是一个没有任何原创数据积累的初创公司或项目，那么使用爬虫在互联网上找到那些有价值的数据，然后对数据进行清洗和整理是快速获取数据的重要手段。
　　本文重点介绍爬虫的系统设计和实现的一些细节。内容来自两个方面。一个是我做了一个多月的爬虫经验，但是我做的爬虫规模不是太大，性能要求不能满足。百度这么高的要求，二是从阅读几个文档中衍生出来的。我找到的关于爬虫系统的文献大多是2000年左右，之后就很少了，说明10年前爬虫的系统设计基本解决了（不是百度刚开始的2000年，说可能是它的爬虫）也指这些文章^-^)。
　　另外，由于本文关注的是系统问题，所以有些内容就不再赘述了，比如那些隐藏的web数据如何爬取，ajax页面如何爬取，如何动态调整爬取频率等等。
　　文本
　　一个正式的、完整的网络爬虫其实是一个非常复杂的系统：首先，它是一个海量数据处理系统，因为它要面对的是整个互联网网页，即使是一个小的、垂直的爬虫，一般它也需要抓取数十亿或数百亿的网页；其次，它也是一个性能要求不错的系统，可能需要同时下载上千个网页，快速提取网页中的url，处理海量的url。重复数据删除等；归根结底，它真的不是一个面向最终用户的系统，所以虽然也非常需要稳定性，但偶尔的宕机也不是什么灾难，也不存在流量激增的情况同时，如果性能在短时间内下降，这不是问题。从这个角度来看，
　　
　　上图是一个爬虫系统框架，基本收录了一个爬虫系统所需的所有模块。
　　在任何爬虫系统的设计图中，你都会发现有一个循环，代表了爬虫的一般工作流程：根据URL下载对应的网页，然后提取网页中收录的URL，然后根据到这些新的 URL 下载相应的网页，然后一遍又一遍地重新开始。爬虫系统的子模块都位于这个循环中，完成一个特定的功能。
　　这些子模块通常包括：
　　fetcher：用于根据url下载对应的网页；
　　DNS解析器：DNS解析；
　　看到的内容：网络内容的重复数据删除；
　　Extractor：提取网页中的url或者其他一些内容；
　　URL过滤器：过滤掉不需要下载的URL；
　　URL Seen：对 url 进行重复数据删除；
　　URL Set：存储所有的url；
　　URL Frontier：类似于调度器，决定接下来下载哪些URL对应哪些网页；
　　提取器和 DNS 解析器
　　这两个模块是两个非常简单的独立服务：DNS Resolver负责域名解析；fetcher的输入是域名解析后的url，返回的是url对应的网页内容。对于任何网页抓取，都需要调用这两个模块。
　　对于一般的爬虫来说，这两个模块可以做得很简单，甚至可以合并在一起。但是对于具有高性能要求的系统，它们可能成为潜在的性能瓶颈。主要原因是域名解析和爬取都是耗时的任务。比如抓取网页时，一般延迟在几百毫秒。如果遇到慢网站，可能需要几秒甚至十几秒，会导致工作线程阻塞等待很长时间。如果希望 Fetcher 能够每秒下载数千页或更多页面，则需要启动大量工作线程。
　　因此，对于性能要求较高的爬虫系统，一般采用epoll或类似的技术，将两个模块改成异步机制。另外，DNS解析的结果也被缓存，大大减少了DNS解析的操作。
　　看到的内容
　　互联网上有些网站经常有镜像网站（镜像），即两个网站的内容相同但网页对应的域名不同。这将导致多次重复爬取同一个网络爬虫。为了避免这种情况，对于每一个爬取的网页，首先需要进入 Content Seen 模块。模块会判断网页内容与下载的网页内容是否一致。如果它们一致，则不会发送网页进行进一步处理。这种方法可以显着减少爬虫需要下载的网页数量。
　　至于判断两个网页的内容是否一致，大致思路是这样的：不是直接比较两个网页的内容，而是计算网页的内容，生成一个FingerPrint（指纹），通常是一个指纹是固定长度。该字符串比网页的正文短得多。如果两个网页的指纹相同，则认为它们的内容相同。
　　提取器和 URL 过滤器
　　提取器的工作是从下载的网页中提取它收录的所有 URL。这是一项精细的工作，需要考虑所有可能的 url 样式，例如网页中往往收录相对路径 url，在提取时需要将其转换为绝对路径。
　　Url Filter 是对提取的 url 进行再次过滤。不同的应用有不同的筛选标准。比如baidu/google搜索一般不会被屏蔽，但是对于垂直搜索或者定向爬取的应用，可能只需要满足一定条件的url，比如不需要图片的url，比如只需要一个图片的url需要具体的网站等。Url Filter是一个与应用密切相关的模块。
　　看到的网址
　　Url Seen 用于对 url 进行重复数据删除。之前写过一篇关于url去重的博客，这里不再赘述。
　　对于一个大型爬虫系统来说，它可能已经有 100 亿或 1000 亿个 URL。如何快速判断是否出现了新的 URL 非常重要。因为大型爬虫系统可能在一秒钟内下载数千个网页，一个网页一般可以提取几十个url，每个url都需要进行去重操作。可以想象，每秒需要执行大量的去重操作。. 因此 Url Seen 是整个爬虫系统中技术含量很高的部分。（Content Seen其实有这个问题）
　　网址集
　　url经过前面的一系列处理后，会被放入到Url Set中进行调度获取。由于 url 数量众多，可能只有一小部分会放在内存中，而大部分会写入磁盘。通常，Url Set 的实现是一些文件或数据库。
　　网址边界
　　Frontier（不知道为什么叫这个名字）放在最后是因为它可以说是整个爬虫系统的引擎和驱动，组织和调用其他模块。
　　当爬虫启动时，Frontier 内部会有一些种子 url。它首先将种子url发送给Fetcher进行抓取，然后将抓取的网页发送给Extractor提取新的url，然后将新的url重放进入Url Set；而当 Frontier 里面的 url 已经被爬取完毕时，它会从 Url Set 中提取那些没有被爬取的新 url，如此循环往复。
　　Frontier的调度实现有很多，这里只介绍最常用的实现方式。在此之前，需要稍微解释一下。虽然我们在介绍 Fetcher 的时候说过，一个好的 Fetcher 每秒可以下载几十万个网页，但是对于特定的目标 网站，比如爬虫系统会爬得很慢，而且只会每十秒被抓一次。这是为了确保目标 网站 不会被爬虫捕获。
　　为了做到这一点，Frontier 内部对每个域名都有一个对应的 FIFO 队列，该队列存储了域名下的 url。Frontier 每次都会从某个队列中拉出一个 url 进行爬取。队列将保存 Frontier 上次调用它的时间。如果时间距离已经超过某个值，则可以再次调用队列。
　　Frontier 可能同时有上千个这样的队列，它会轮询得到一个可以调用的队列，然后从队列中拉出一个 url 去获取。一旦队列中的所有url都被消费到一定程度，Frontier就会从Url Set中抽取一批新的url，放入对应的队列中。
　　分散式
　　当单机版爬虫性能不能满足要求时，应考虑使用多台机器组成分布式爬虫系统。分布式爬虫架构其实比想象的要简单得多。一个简单的做法是：假设有N台机器，每台机器都有一个完整的爬虫系统在运行，每台机器的爬虫都在从Extractor模块中获取新的信息。在url之后，根据url的域名进行hash，然后取模N得到结果n，然后将url放入第n台机器的Url Set中。这样，不同的网站 URL就会在不同的机器上处理。
　　以上是完整爬虫的系统实现。当然，由于篇幅限制，有些细节被省略了。例如，在爬取每个网站之前，爬虫需要读取网站的robots.txt来判断网站是否允许被爬取（京东把robots. txt 前一段时间在 robots.txt 中）。一淘的爬虫被堵住了。需要注意的是robots.txt只是行业协议，在技术上不能强行拒绝爬虫的爬取）；再例如，一些网站 提供站点地图，它可以直接从站点地图中获取该网站 的所有url；等等。 查看全部

　　网页爬虫抓取百度图片(爬取百度百科的历史记录，结果在时隔四个月之后再次遇到的对手)
　　动态页面爬取
　　很久没有写爬虫了。今天敲了一个爬虫——爬百度百科的历史记录。结果时隔四个月再次遇到的对手居然是动态页面（我一开始觉得百度太简单了。），但经过一番努力，还是达到了自己的目标，然后就写了博客作为评论。
　　一、概念
　　动态页面实际上是相对于静态页面的。面对静态页面时，直接查看响应一般是网页的整个代码，而对于动态页面则不然。一般来说，当再次打开动态页面的响应时，会与您在网页上看到的有所不同。
　　二、练习和练习前
　　因为我很喜欢练习，所以我会一言不发地练习，练习会给你真正的知识，你多练习就会明白。
　　目标页面：万科百度百科历史版
　　实现环境：win32
　　版本：python 3.6.2
　　实用目标：获取万科百度百科历史版的历史修改时间，制作图表或csv文件
　　三、流程说明
　　和所有爬虫一样，我们的第一步会是分析网页，因为我们的目标选择的是动态网页，所以我们还需要跟踪json文件等等。
　　过程：
　　1、网页分析
　　2、查询、跟踪json等文件或xhr
　　3、 用于文本匹配
　　4、绘制或制作 csv
　　四、工具准备
　　我们需要的库是（所有最新版本）：
　　1.请求
　　2.回复
　　（以下库对于爬虫来说不是必需的，但它们是我这次需要的）
　　3.matplotlib（用于可视化）
　　4.datetime（准时运行）
　　5.Pandas（python强大的数据处理库）
　　6.os（在系统上运行）
　　（我更喜欢原来的re库，当然这里使用正则表达式可以解决所有问题）
　　你需要知道的：
　　1.python 语法基础
　　2.正则表达式匹配规则
　　（爬行动物不需要以下内容）
　　3.datetime 一些基本函数
　　4.Matplotlib 可视化操作（虽然这对于非爬虫来说是必须的，但很多情况下数据可视化会让数据更直观，更容易做出判断）
　　5.pandas库的基本使用（非爬虫必备，数据分析必备）
　　五、网页分析
　　首先我们打开我们的目标页面→万科百度百科历史版。
　　好像一切正​​常，然后我们查看url，也有前面提到的规则，但是真的一切正常吗？
　　如果你把这个页面做为静态页面，那肯定是注定要失败的，因为我从一开始就是这样做的，当你在第一页查找代码时，你会发现一切正常，但是当你在第二页查找代码时page 有时，您会发现一个事实，即您在第二页甚至最后一页上看到的最后一个代码是相同的。你觉得这有悖常理吗？
　　六、关注
　　事实上，事实并非如此。这是正常的事情。很多页面会做成动态的，使用json或者其他文件来传输数据（不准确，也可能使用java、JavaScript等代码调用端口等），这样比较安全。
　　此时很多人会选择使用fiddle等第三方软件抓包，比较方便，但是这里笔者比较难，所以直接在控制器平台上观看即可。
　　经过一番搜索，我们锁定了几个我们需要的文件和 xhr 文件。
　　很多网页的数据都会隐藏在json中。这可能是一样的吗？当然检查后失败了，然后我们看xhr，发现这个很熟悉的字段（当然我可能很熟悉）
　　显而易见的答案就在这里，只需解释一下
　　获取历史列表，获取历史数据
　　我猜这个东西是万科的quantio语句（不知道这个词是不是拼错了，不过我用的很少，前后端工作的朋友可能知道）
　　Lemmald，这不就是万科在百度的号码吗？
　　一看就知道是第七页
　　大小显示 25 条消息
　　这个发现很棒，解决了很多问题。
　　七、假的
　　作为爬虫，了解反爬虫套路是非常有必要的。如果你在xhr上进行正常爬虫，你会发现返回给你的是{error: xxxxx}，此时你应该警惕，这证明你的机器人的身份被百度识破了，它拒绝了给你数据，所以我们需要做一些简单的伪装。前面已经讲过改头文件了，这次我会多讲。
　　1.headers 伪装，服务器使用它来确定您正在使用的浏览器。当出现这种情况时，服务器会认为这是来自浏览器的正常请求。
　　2.Referer：浏览器使用它来确定您从哪个网页跳转。
　　3.ip伪装，这个只要构造好ip池就没有问题。
　　4.cookie伪装，cookie被服务器用来识别你当前的状态，比如你是否已经登录等。每次你向服务器请求cookie时，都会相应更新。
　　最常用的就是上面这些了，从上到下越来越难调整了。面对百度，光改headers显然是不够的，于是加了Referer和cookie码（关键是两个月前就建立了。IP池已经废掉了，懒得整）。
　　好了，到这里我们发现可以正常获取数据了。
　　八、文本匹配
　　不得不说，在解决了以上问题之后，文本匹配就变成了最简单的事情。
　　其实这是一种类似字典的格式，但是作者懒得想了，决定用一个简单粗暴的正则表达式。
　　九、转换时间戳
　　这时候我们就会发现，creattime给出的时间到底是什么鬼？
　　但如果你仔细想想，你会发现它是一个时间戳
　　python 中的时间戳：自 1/1/1970 12:00AM 以来的秒数
　　是不是很破？
　　幸运的是，解决这个问题只需要几段简短的代码
　　输入时间戳，好了，问题解决了。
　　十、绘图和csv
　　图片
　　CSV
　　十个一、总结和代码
　　感觉这次爬虫还行。两个多月后想起来也不容易。写这个博客纯粹是一个评论。至于怎么做图和怎么做csv的原因，我可以说博主是不是突然不想写了？
　　这是代码：
　　（注：博主懒得写评论了，不明白的可以评论提问，谢谢）
　　———————————————
　　版权声明：本文为CSDN博主“独孤天”的原创文章，遵循CC4.0 BY-SA版权协议。转载请附上原文出处链接和本声明。
　　原文链接： 查看全部

　　网页爬虫抓取百度图片(爬取百度贴模块详细解析(一)_社会万象_光明网
)
　　目录概览
　　爬取百度贴吧每篇博文的所有图片。
　　准备所需模块，涉及知识点，运行效果
　　控制台打印：
　　
　　计算机本地文件：
　　
　　完成爬虫1.分析网页
　　打开百度贴吧搜索关键字，这里的例子是python，也可以是其他关键字
　　分析前三个页面的url，得到：
　　# 第1页：http://tieba.baidu.com/f%3Fkw% ... n%3D0
# 第2页：http://tieba.baidu.com/f%3Fkw% ... %3D50
# 第3页：http://tieba.baidu.com/f%3Fkw% ... 3D100
# 比较三者三者可以得出每一页的网址公式：
# "http://tieba.baidu.com/f%3Fkw% ... 3B%2B(page_index-1)*50
# 其中tieba_name是你要搜索的贴吧名字，page_index是你要搜索的第几页
　　得到每个页面的URL后，下一步就是分析每个帖子在特定页面上的链接：
　　
　　已经可以通过页面的 URL 请求源代码。在源码中，可以通过xpath表达式提取出一串数字，然后组装出具体帖子页面的URL。
　　点击帖子进入具体页面，索取源码然后提取图片链接：
　　
　　这样想：
　　首先根据贴吧的名字获取贴吧的URL，然后组装各个页面的URL，然后根据各个页面的URL请求页面的HTML源代码，然后在源码中提取每个帖子的URL超链接信息，然后组装帖子每个具体页面的URL，然后请求帖子具体页面的HMTL源代码，提取图片的超链接，然后根据图片的超链接下载图片。
　　2.爬虫代码
　　import urllib.parse
import urllib.request
from lxml import etree
# 爬虫实践:爬取百度贴吧的图片
class Spider():
def __init__(self):
self.tiebaName = "java"
self.pageNumber = 3
self.url = "http://tieba.baidu.com/f?"
self.fileName = 1
def tiebaSpider(self):
"""构造URL"""
for page_index in range(1, self.pageNumber + 1):
pn = (page_index - 1) * 50
wo = {"pn": pn, "kw": self.tiebaName}
word = urllib.parse.urlencode(wo)
tieba_url = self.url + word
self.loadPage(tieba_url)
def loadPage(self, url):
"""爬取页面内容"""
req = urllib.request.Request(url)
data = urllib.request.urlopen(req).read()
html = etree.HTML(data)
links = html.xpath("//div[@class=&#39;threadlist_lz clearfix&#39;]/div/a/@href")
for link in links:
link = "http://tieba.baidu.com" + link
self.loadImages(link)
def loadImages(self, link):
"""爬取帖子详情页，获得图片的链接"""
req = urllib.request.Request(link)
data = urllib.request.urlopen(req).read()
html = etree.HTML(data)
links = html.xpath("//img[@class=&#39;BDE_Image&#39;]/@src")
for image_link in links:
self.writeImages(image_link)
def writeImages(self, imageslink):
"""通过图片的链接，爬取图片并保存在本地"""
print("正在存储图片：", self.fileName, "......")
image = urllib.request.urlopen(imageslink).read()
file = open(r"C:\\Users\\Administrator\\Pictures\\img\\" + str(self.fileName) + ".jpg", "wb")
file.write(image)
file.close()
self.fileName += 1
if __name__ == &#39;__main__&#39;:
# 实例化Spider类
mySpider = Spider()
# 调用方法
mySpider.tiebaSpider() 查看全部

　　网页爬虫抓取百度图片(项目工具Python3.7.1、JetBrainsPyCharm三、项目过程（四）)
　　需要编写的程序可以在任意一个贴吧页面获取帖子链接，抓取用户在帖子中发布的图片。在这个过程中，通过用户代理进行伪装和轮换，解决了爬虫ip被目标网站封禁的问题。熟悉基本的网页和url分析，能灵活使用Xmind工具分析Python爬虫（网络爬虫）的流程图。
　　一、项目分析
　　1. 网络分析
　　贴吧页面简洁，所有内容一目了然，比其他社区论坛更容易使用。注册容易，甚至不注册，发布也容易。但是，栏目创建不均，内容五花八门。
　　2. 网址解析
　　分析贴吧中post链接的拼接形式，在程序中重构post链接。
　　比如在本例的实验中，多次输入不同的贴吧后，可以看出贴吧的链接组成为：fullurl=url+key。其中 fullurl 表示 贴吧 总链接
　　url为贴吧链接的社区：
　　关键是urlencode编码的贴吧中文名
　　使用 xpath_helper_2_0_2.crx 浏览器插件，帖子的链接条目可以归结为：
　　"//li/div[@class="t_con cleafix"]/div/div/div/a/@href"，用户在帖子中张贴的图片链接表达式为："//img··[@class = "BDE_Image"]/@src"
　　二、项目工具
　　Python 3.7.1，JetBrains PyCharm 2018.3.2
　　三、项目流程
　　（一）使用Xmind工具分析Python爬虫（网络爬虫）的流程图，绘制程序逻辑框架图如图4-1
　　
　　图 4-1 程序逻辑框架图
　　（二）爬虫调试过程的Bug描述（截图）
　　
　　(三）爬虫运行结果
　　
　　
　　(四）项目经历
　　本次实验的经验总结如下：
　　1、 当程序运行结果提示错误：ModuleNotFoundError: No module named 'lxml'时，最好的解决办法是先检查lxml是否安装，再检查lxml是否导入。在本次实验中，由于项目可以成功导入lxml，解决方案如图5-1所示。在“Project Interperter”中选择python安装目录。
　　
　　图 5-1 错误解决流程
　　2、 有时候需要模拟浏览器，否则做过反爬的网站 会知道你是机器人
　　例如，对于浏览器的限制，我们可以设置 User-Agent 头。对于防盗链限制，我们可以设置Referer头。一些网站使用cookies进行限制，主要涉及登录和限流。没有通用的方法，只看能不能自动登录或者分析cookies的问题。
　　3、 第一步，我们可以从主界面的html代码中提取出这组图片的链接地址。显然，我们需要使用正则表达式来提取这些不同的地址。然后，有了每组图片的起始地址后，我们进入子页面，刷新网页，观察它的加载过程。
　　四、项目源码
　　贴吧pic.py
　　from urllib import request,parse
import ssl
import random
import time
from lxml import etree
ua_list=[
&#39;Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.98 Safari/537.36&#39;,
&#39;Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.1; WOW64; Trident/4.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; .NET4.0C; .NET4.0E)&#39;,
&#39;Mozilla/5.0 (Windows NT 6.1; WOW64; rv:45.0) Gecko/20100101 Firefox/45.0&#39;
]
def loadPage(url):
userAgent=random.choice(ua_list)
headers={"User-Agent":userAgent}
req =request.Request(url,headers=headers)
context=ssl._create_unverified_context()
response=request.urlopen(req,context=context)
html=response.read()
content=etree.HTML(html)
link_list=content.xpath(&#39;//li/div[@class="t_con cleafix"]/div/div/div/a/@href&#39;)
for link in link_list:
fullurl=&#39;http://tieba.baidu.com&#39;+link
print(fullurl)
loadImge(fullurl)
def loadImge(url):
req = request.Request(url)
context = ssl._create_unverified_context()
response = request.urlopen(req, context=context)
html = response.read()
content = etree.HTML(html)
link_list = content.xpath(&#39;//img[@class="BDE_Image"]/@src&#39;)
for link in link_list:
print(link)
writeImge(link)
def writeImge(url):
req = request.Request(url)
context = ssl._create_unverified_context()
response = request.urlopen(req, context=context)
image = response.read()
filename=url[-12:]
f=open(filename,&#39;wb&#39;)
f.write(image)
f.close()
def tiebaSpider(url,beginPage,endPage):
for page in range(beginPage,endPage+100):
pn=(page-1)*50
fullurl=url+"&pn="+str(pn)
loadPage(fullurl)
if __name__=="__main__":
print("测试成功！")
kw=input("请输入要爬的贴吧名：")
beginPage=int(input("请输入开始页："))
endPage = int(input("请输入结束页："))
url="http://tieba.baidu.com/f?"
key=parse.urlencode({"kw":kw})
fullurl=url+key
tiebaSpider(fullurl,beginPage,endPage)
　　转载于： 查看全部

　　网页爬虫抓取百度图片(爬虫的爬取步骤：具体的步骤-爬虫知乎图片
)
　　爬虫的爬取步骤：具体步骤：代码示例：
　　headers = {
"User-Agent":"Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36"
}
#获取随机ip
proxies = get_random_ip(ip_list)
req = requests.get(url=url,headers=headers,proxies=proxies)
soup = BeautifulSoup(req.text,'lxml')
targets_url_1 = soup.find('figure')
targets_url = soup.find_all('noscript')
复制代码
　　完整代码：
　　这是一个爬取知乎图片的教程代码，涉及到代理ip文件（IP.txt）
　　import requests,random,os,time
from bs4 import BeautifulSoup
from urllib.request import urlretrieve
#获取IP列表并检验IP的有效性
def get_ip_list():
f=open('IP.txt','r')
ip_list=f.readlines()
f.close()
return ip_list

#从IP列表中获取随机IP
def get_random_ip(ip_list):
proxy_ip = random.choice(ip_list)
proxy_ip=proxy_ip.strip('\n')
proxies = {'https': proxy_ip}
return proxies

def get_picture(url,ip_list):
headers = {
"User-Agent":"Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36"
}
#获取随机ip
proxies = get_random_ip(ip_list)
req = requests.get(url=url,headers=headers,proxies=proxies)
soup = BeautifulSoup(req.text,'lxml')

targets_url_1 = soup.find('figure')
targets_url = soup.find_all('noscript')

#保存图片链接
list_url = []
for each in targets_url:
list_url.append(each.img.get('src'))

for each_img in list_url:
#判断文件夹(图库)是否存在，若不存在则创建文件夹
if '图库' not in os.listdir():
os.makedirs('图库')
#下载图片
proxies = get_random_ip(ip_list)
picture = '%s.jpg' % time.time()
req = requests.get(url=each_img,headers=headers,proxies=proxies)
with open('图库/{}.jpg'.format(picture),'wb') as f:
f.write(req.content)
#每爬取一张图片暂停一秒防止ip被封
time.sleep(1)
print('{}下载完成！'.format(picture))

def main():
ip_list = get_ip_list()
url = 'https://www.zhihu.com/question/22918070'
get_picture(url,ip_list)

if __name__ == '__main__':
main()
复制代码
　　成功后截图：
　　
　　爬行动物简介：
　　网络爬虫，也称为网络蜘蛛，是一种用于自动浏览万维网的网络机器人。Web 爬虫从称为种子的统一资源地址 (URL) 列表开始。当网络爬虫访问这些统一的资源定位器时，它们会识别页面上的所有超链接，并将它们写入一个“访问列表”，即所谓的爬取域。此域上的 URL 将根据一组策略以循环方式访问。如果爬虫在执行过程中复制存档上的信息并保存网站，这些存档通常会被存储起来，以便于查看。阅读和浏览他们存储在 网站 上的信息并立即更新。这些存储的网页也称为“快照”。较大的网页意味着网络爬虫在给定时间内只能下载网页的较小部分，因此优先下载。高变化率意味着页面可能已被更新或替换。一些服务器端软件生成的 URL（统一资源定位器）也使网络爬虫难以避免检索重复的内容。（来自：维基百科）
　　通过代码访问网页并将页面内容保存在本地。url是爬虫识别网页的重要标识。通过requests.get(url)获取网页的HTML代码，通过BeautifulSoup解析HTML文件得到我们需要的内容。find()/find_all() 是 beautifulSoup 的两个重要方法。
　　补充知识点：
　　关于爬虫中的headers：在使用python爬虫爬取数据时，我们经常会遇到一些网站的反爬虫措施，一般都是针对headers中的User-Agent。如果不设置headers，User-Agent会声明它是python脚本，如果网站有反爬虫的想法，必然会拒绝这样的连接。通过修改headers，可以将自己的爬虫脚本伪装成浏览器的正常访问来避免这个问题。
　　关于爬虫中的IP/代理： 设置好用户代理后，应该考虑另一个问题。程序的运行速度非常快。如果我们使用爬虫程序来爬取网站中的东西，一个固定IP的访问频率会很高，不符合人工操作的标准，因为人工操作不可能在内部进行如此频繁的访问几毫秒。所以有些网站会设置IP访问频率的阈值。如果某个IP的访问频率超过了这个阈值，则说明这不是人在访问，而是爬虫。因此，当我们需要爬取大量数据时，一个不断变化的IP机制是必不可少的。我的代码中的 IP.txt 文件就是为此机制准备的。
　　关于 BeautifulSoup： 简单来说，Beautiful Soup 是一个 Python 库，其主要功能是从网页中抓取数据。
　　BeautifulSoup 的安装：
　　pip install beautifulsoup4
复制代码 查看全部

　　网页爬虫抓取百度图片(网页爬虫抓取百度图片都是走网页自带的httpserver，怎么办)
　　网页爬虫抓取百度图片都是走网页自带的httpserver，chrome/firefox/ie浏览器好多都是网页爬虫自带的api，但是uc在国内不能使用api，所以要要用第三方的爬虫，第三方爬虫可以选择友盟，talkingdata，360/uc等第三方，也可以去搜狗开放平台注册使用各种第三方的爬虫。第三方第三方爬虫相对用户的量多，获取数据也方便。
　　1.chrome、火狐或其他现有网页爬虫2.微博爬虫3.第三方微博爬虫，
　　百度，腾讯和好多门户网站都是自己搞一套的，
　　你怎么找这些网站不就一目了然了，知乎还有一个私家课，可以爬教程，这种不靠谱的都是虚假广告。
　　个人比较推荐talkingdata的数据，开放性比较好，数据质量也不错，并且分析逻辑比较清晰。相比于其他的要容易上手一些。但现在爬虫出来的报告，只适合做一个简单的数据分析用，不适合做长远的业务规划。还有建议爬虫的时候模仿别人做好的网站网站。实在要爬的话，
　　火狐浏览器直接设置用户过滤：
　　因为浏览器能力有限，网页爬虫都是如此，很多网站在你登录的时候就会屏蔽爬虫抓取这种网站，只能从第三方的网站进行爬取或者是联网调用一些第三方的爬虫。当然也有不少没有限制的，在利用插件方面用的人比较多，你可以学一学搜狗爬虫插件和百度爬虫插件，学会之后相信你自己就可以找到一些公司联系方式。还有一个好用的东西，uc浏览器也是可以进行网页爬虫，可以从网站爬取信息，只要能进入的网站都有接口，但是功能比较简单，比如点开百度，然后点左下角相机，打开一个页面图片什么的。 查看全部

　　网页爬虫抓取百度图片(就是爬取小编精选的图片小编精选-照片(组图))
　　更好的体验：Python 爬虫在行动中 - Pixabay上的免费图片
　　
　　Pixie，一个不错的高清未经审查的图像网站，可以免费下载。
　　/
　　一些介绍
　　超过 900,000 张高质量的照片、插图和矢量图形。免费用于商业用途。无需归属。
　　Pixabay是一个高质量的图片分享网站。网站 最初是由 Hans Braxmeier 和 Simon Steinberger 在德国开发的。截至 2013 年 2 月，网站 有大约 70,000 张免费照片和矢量图形，由社区中的电影制作人和插画家提供。公司于2010年12月在德国乌尔姆成立。
　　2012 年 3 月，Pixabay 开始从私人图片集网站 转变为支持 20 种语言的交互式在线社区 网站。同年5月，网站推出了公共应用编程接口，允许第三方用户和网站开发者搜索其图片库。网站还与 Flickr、YouTube 和 Wiki 共享资源。
　　Pixabay用户无需注册即可获得无版权的高质量图像。根据知识共享合约CC0相关的肖像权，用户通过在本网站上传图片，默认放弃图片版权，让图片得以广泛传播。网站允许任何人在未经许可和背书的情况下使用、修改图像——即使在商业应用中也是如此。
　　为确保Pixabay上的高质量图片标准，用户上传的所有图片都将由网站工作人员手动审批。大约 27% 的用户会说英语，20% 会说西班牙语，11% 会说葡萄牙语，7% 会说德语，5% 会说法语。它的用户主要是博主、平面设计师、作家、记者和广告商。
　　今天的目标是爬取小编的精选图片小编的精选-图片
　　一、分析
　　我们需要编写3个函数
　　A Download(url) 下载图片
　　一个用于获取编辑器选择的FullUrl()总共165页
　　最后用来调用main()
　　开始一一写吧~
　　编辑精选 - 照片
　　打开网页，F12，查看图片链接所在的标签
　　
　　
　　你可以看到图片链接都在那里
　　标签下，但是发现第一张和最后一张图片的属性不一样，提取出来的
　　“src”很好，使用xpath
　　import requests
from lxml import etree
header = {&#39;User-Agent&#39;: &#39;Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36&#39;}
url = &#39;https://pixabay.com/zh/editors_choice/&#39;
r = requests.get(url,headers=header).text
s = etree.HTML(r)
print(s.xpath(&#39;//img/@src&#39;))
　　结果发现
　　
　　前面是正确的图片链接，后面却出现'/static/img/blank.gif'，这是什么鬼，查看网页源代码，搜索
　　
　　可以发现确实有这个字符串，我自己也花了很多时间在这上面。感谢帮助，Python爬虫动态页面爬取问题？- 爬虫（计算机网络） - 知乎
　　浏览器中的代码是用javascript修改的，可以直接用requests打印出来看看
　　

/static/img/blank.gif



　　在requests返回的数据中可以看到，“data-lazy”总是收录我们需要的数据，修改代码
　　
　　发现现在返回的数据就是我们需要的，打开图片查看
　　
　　
　　下图更清晰，我们只需要将“__340”替换为“_960_720”即可 查看全部

　　网页爬虫抓取百度图片(像是这样%AB%98%(图)(组图))
　　我最近在玩机器学习，想创建一个识别动画图片的训练集。我因没有太多动画图片而苦恼。后来突然想到可以用百度图片，于是写了一个简单的爬虫来抓取百度图片（图片关于一个关键词）
　　第一步是找到搜索图片的url。
　　打开百度图片网页，搜索“高清动画”，检查元素，检查网络，清除网络请求数据，将页面滚动到底部，看到自动加载更多，然后找到加载更多数据的url在网络请求中。像这样 %E9%AB%98%E6%B8%85%E5%8A%A8%E6%BC%AB&amp;cl=2&amp;lm=-1&amp;ie=utf-8&amp;oe=utf-8&amp;adpicid=&amp;st=-1&amp;z=&amp;ic=0&amp;word= % E4%BA%8C%E6%AC%A1%E5%85%83&amp;s=&amp;se=&amp;tab=&amp;width=&amp;height=&amp;face=0&amp;istype=2&amp;qc=&amp;nc=1&amp;fr=&amp;pn=60&amp;rn=30&amp;gsm=1000000001e&amp;81=
　　对比几个加载较多的URL，发现rn参数是每页显示的次数，pn参数是请求的次数。通过修改rn参数和pn参数，观察返回的数据，发现每页最多只能有60个，即rn设置最大为60.
　　第二步是分析返回的数据。
　　通过浏览器请求上面的url，在页面上看到一个超级json。分析后发现图片的url是thumbURL、middleURL、hoverurl这三个属性，在返回的字符串中搜索这三个属性的编号，发现该编号与分页数一模一样. 通过浏览器打开这三个url，发现thumburl比middleUrl大，和hoverUrl是同一个url。其实还有一个objUrl（原图）可以用，但是url不稳定，有时候404，有时候访问被拒绝。
　　然后代码
　　我的 python 版本是 2.7
　　更新于 2017 年 2 月 11 日
　　1.保存的图片改成原来的高清大图OjbUrl
　　2.修改使用方法，可以在命令行输入搜索关键字
　　3.随时保存，保存前不再需要搜索所有图片。
　　百度图片搜索.py
　　#coding=utf-8
from urllib import quote
import urllib2 as urllib
import re
import os
class BaiduImage():
def __init__(self, keyword, count=2000, save_path="img", rn=60):
self.keyword = keyword
self.count = count
self.save_path = save_path
self.rn = rn
self.__imageList = []
self.__totleCount = 0
self.__encodeKeyword = quote(self.keyword)
self.__acJsonCount = self.__get_ac_json_count()
self.user_agent = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.95 Safari/537.36"
self.headers = {'User-Agent': self.user_agent, "Upgrade-Insecure-Requests": 1,
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
"Accept-Encoding": "gzip, deflate, sdch",
"Accept-Language": "zh-CN,zh;q=0.8,en;q=0.6",
"Cache-Control": "no-cache"}
# "Host": Host,
def search(self):
for i in range(0, self.__acJsonCount):
url = self.__get_search_url(i * self.rn)
response = self.__get_response(url).replace("\\", "")
image_url_list = self.__pick_image_urls(response)
self.__save(image_url_list)
def __save(self, image_url_list, save_path=None):
if save_path:
self.save_path = save_path
print "已经存储 " + str(self.__totleCount) + "张"
print "正在存储 " + str(len(image_url_list)) + "张，存储路径：" + self.save_path
if not os.path.exists(self.save_path):
os.makedirs(self.save_path)
for image in image_url_list:
host = self.get_url_host(image)
self.headers["Host"] = host
with open(self.save_path + "/%s.jpg" % self.__totleCount, "wb") as p:
try:
req = urllib.Request(image, headers=self.headers)
# 设置一个urlopen的超时，如果10秒访问不到，就跳到下一个地址，防止程序卡在一个地方。
img = urllib.urlopen(req, timeout=20)
p.write(img.read())
p.close()
self.__totleCount += 1
except Exception as e:
print "Exception" + str(e)
p.close()
if os.path.exists("img/%s.jpg" % self.__totleCount):
os.remove("img/%s.jpg" % self.__totleCount)
print "已存储 " + str(self.__totleCount) + " 张图片"
def __pick_image_urls(self, response):
reg = r'"ObjURL":"(http://img[0-9]\.imgtn.*?)"'
imgre = re.compile(reg)
imglist = re.findall(imgre, response)
return imglist
def __get_response(self, url):
page = urllib.urlopen(url)
return page.read()
def __get_search_url(self, pn):
return "http://image.baidu.com/search/ ... ot%3B + self.__encodeKeyword + "&cl=2&lm=-1&ie=utf-8&oe=utf-8&adpicid=&st=-1&z=&ic=0&word=" + self.__encodeKeyword + "&s=&se=&tab=&width=&height=&face=0&istype=2&qc=&nc=1&fr=&pn=" + str(pn) + "&rn=" + str(self.rn) + "&gsm=1000000001e&1486375820481="
def get_url_host(self, url):
reg = r'http://(.*?)/'
hostre = re.compile(reg)
host = re.findall(hostre, url)
if len(host) > 0:
return host[0]
return ""
def __get_ac_json_count(self):
a = self.count % self.rn
c = self.count / self.rn
if a:
c += 1
return c
　　使用示例
　　运行.py
　　#coding=utf-8
from BaiduImageSearch import BaiduImage
import sys
keyword = " ".join(sys.argv[1:])
save_path = "_".join(sys.argv[1:])
if not keyword:
print "亲，你忘记带搜索内容了哦~ 搜索内容关键字可多个，使用空格分开"
print "例如：python run.py 男生 头像"
else:
search = BaiduImage(keyword, save_path=save_path)
search.search()
　　ps：记得把_init_.py文件添加到两个文件的同一目录下！！！
　　run 方法，python run.py 关键字 1 关键字 2 关键字 3…
　　一般搜索超过1900条就没有了。 查看全部

　　网页爬虫抓取百度图片(如何用Python学习资料的小伙伴获取图片的url？
)
　　PS：如需Python学习资料，可点击下方链接自行获取
　　1.获取图片的url链接
　　首先，打开百度图片首页，注意下面url中的索引
　　
　　接下来，将页面切换到传统的翻页版本，因为这样可以帮助我们抓取图片！
　　
　　对比几个url，发现pn参数是请求数。通过修改pn参数，观察返回的数据，发现每页最多只能收录60张图片。
　　注意：gsm参数是pn参数的16进制表示，去掉就可以了
　　
　　然后，右键查看网页源代码，直接（ctrl+F）搜索objURL
　　
　　这样，我们就找到了需要图片的url了。
　　2.将图片链接保存到本地
　　现在，我们要做的就是抓取这些信息。
　　注意：有objURL、hoverURL...但我们使用objURL是因为这是原图
　　那么，我如何获取 objURL？使用正则表达式！
　　那我们如何用正则表达式来实现呢？其实只需要一行代码……
　　results = re.findall('"objURL":"(.*?)",', html)
　　核心代码：
　　1.获取图片url代码：
　　# 获取图片url连接def get_parse_page(pn,name): for i in range(int(pn)): # 1.获取网页 print('正在获取第{}页'.format(i+1)) # 百度图片首页的url # name是你要搜索的关键词 # pn是你想下载的页数 url = 'https://image.baidu.com/search/flip?tn=baiduimage&ie=utf-8&word=%s&pn=%d' %(name,i*20) headers = { 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.104 Safari/537.36 Core/1.53.4843.400 QQBrowser/9.7.13021.400'} # 发送请求，获取相应 response = requests.get(url, headers=headers) html = response.content.decode() # print(html) # 2.正则表达式解析网页 # "objURL":"http://n.sinaimg.cn/sports/tra ... ot%3B results = re.findall('"objURL":"(.*?)",', html) # 返回一个列表 # 根据获取到的图片链接，把图片保存到本地 save_to_txt(results, name, i)
　　2.保存图片到本地代码：
　　# 保存图片到本地def save_to_txt(results, name, i): j = 0 # 在当目录下创建文件夹 if not os.path.exists('./' + name): os.makedirs('./' + name) # 下载图片 for result in results: print('正在保存第{}个'.format(j)) try: pic = requests.get(result, timeout=10) time.sleep(1) except: print('当前图片无法下载') j += 1 continue # 可忽略，这段代码有bug # file_name = result.split('/') # file_name = file_name[len(file_name) - 1] # print(file_name) # # end = re.search('(.png|.jpg|.jpeg|.gif)$', file_name) # if end == None: # file_name = file_name + '.jpg' # 把图片保存到文件夹 file_full_name = './' + name + '/' + str(i) + '-' + str(j) + '.jpg' with open(file_full_name, 'wb') as f： f.write(pic.content) j += 1
　　3.主要功能代码：
　　# 主函数if __name__ == '__main__': name = input('请输入你要下载的关键词：') pn = input('你想下载前几页（1页有60张）:') get_parse_page(pn, name)
　　使用说明：
　　# 配置以下模块import requests import reimport osimport time# 1.运行 py源文件# 2.输入你想搜索的关键词，比如“柯基”、“泰迪”等# 3.输入你想下载的页数，比如5，那就是下载 5 x 60=300 张图片 查看全部

　　网页爬虫抓取百度图片(模拟浏览器打开网页的时候一般操作：打开同类壁纸)
　　前言
　　在设计爬虫项目时，首先要明确手动浏览页面获取图片时脑海中的步骤
　　一般来说，我们上网批量打开壁纸时，一般操作如下：
　　1、打开壁纸页面
　　2、点击壁纸图片（打开指定壁纸的页面）
　　3、选择分辨率（我们要下载高分辨率图片）
　　4、保存图片
　　在实际操作中，我们实现了以下步骤访问网页地址：打开带有壁纸的网页→点击壁纸图片打开指定页面→选择分辨率，点击打开最终保存目标图片网页→保存图片
　　在爬取过程中，我们尝试通过模拟浏览器的操作打开网页，一步一步获取并访问该网页，最终获取目标图片的下载地址，下载图片并保存到指定路径
　　*在这些中间过程中构建网页的一些特定过滤条件，需要打开指定页面的源代码，观察并找到收录有目的链接的标签
　　具体实施事项及注意事项
　　这里只是想获取一些指定的图片，所以先在网页上搜索“长门由希”，打开一个搜索结果页面，发现这个页面已经收录了其他同类型的壁纸链接，于是开始设置本次搜索结果页初次访问的目的地址
　　目标结果页面截图：
　　图中下标为“1/29”。“2/29”是同类型的其他目标壁纸。通过点击这些图片，我们可以打开新的目标下载图片页面
　　下面我们来看网页的源代码
　　图中黄底的地方就是打开这些类似壁纸的目的地址（访问时需要加前缀“”）
　　现在我们可以尝试构建爬虫：
　　打开指定页面→过滤获取所有长门由纪壁纸的目标下载页面链接
　　代码显示如下：
　　获取地址后，我们可以获取地址→打开指定页面→选择分辨率→获取目标下载地址→保存到本地指定路径
　　测试时，我输出了上一步保存在truelist中的内容
　　
　　可以看到保存的只是一个后缀，我们需要在访问的时候加上一个指定的前缀
　　实现代码如下（注释见代码）：
　　终于可以在你的目标文件夹中看到爬下来的那组图片了~
　　转载于： 查看全部

　　网页爬虫抓取百度图片(连游戏都没法玩3台电脑一般是想只用python程序运行吗)
　　网页爬虫抓取百度图片、爬虫抓取糗百、爬虫抓取ebay等美剧网页网页爬虫抓取知乎等。
　　python大法好
　　我们公司一直用通用爬虫+python的解决方案，采购的电脑一台cpu8核心15线程，主频2.7ghz的，两个服务器，加起来三千多。
　　连游戏都没法玩
　　3台电脑一般是软路由啊
　　同一个电脑同时开机游戏就打不了了
　　提主是想只用python程序运行吗？我们公司专门有两台esxi交换机，一台做服务器，一台做内网ip，web系统用的nginx，负载均衡用docker(轮询，slb)，全部用python来写，没问题，前提是不同的系统不要影响同一个程序正常运行。要是想只用python来写程序，那我建议用pypy吧，可以在同一个程序上打到linux系统中。
　　以上所有操作都可以通过gateway配置来实现，只需要改变loadlibrarylistener到pypy即可。
　　iphone4
　　一台windows一台mac
　　redhat,gentoo,linux系统有自己的内核来支持虚拟化，windows虚拟化不是很好，中国特色吧。
　　玩游戏还是玩python吧，这个没的说。
　　同时开200台电脑都不卡！开个网页嗖嗖的，服务器性能肯定够。如果是做网页爬虫，本地没有能跑python的环境，建议用阿里云ecs，给新客户送的那个，有物理隔离。如果只是单纯的用python爬数据，建议只用mysql，其他的也没啥可以折腾的。另外解决网络问题，一台主机上windows还有nginxlvssocks5mapredisapache等都安装好才是最重要的，稳定运行用linux最好，或者干脆windowsserver也行。 查看全部

　　网页爬虫抓取百度图片(url向百度发送请求import#需要用这个包进行正则匹配import)
　　宣布
　　此文章仅供学习使用，如果读者利用此方法进行违法犯罪活动，与本人无关。
　　爬虫已经触犯了法律，因此需要谨慎使用。
　　下面开始文字
　　一、导入几个需要用到的包
　　import requests #需要使用这个包向百度发送请求
　　import re #需要使用这个包进行正则匹配
　　import time #Sleep 避免对服务器造成太大压力
　　这里的requests主要作用是向百度发送请求，也就是模仿人工操作进行访问。有两种方法：post 和 get。这里我们使用get方法。
　　然后，开始向百度发送请求。当然，你需要一个百度图片的链接。首先，访问百度的图片，看看链接是什么样子的。
　　url 列如下所示：
　　皮卡丘
　　去掉一些不必要的内容后，可以长成这样
　　皮卡丘
　　如果你不相信我，你可以试试。
　　然后分析url，前者肯定是固定格式，不能更改，而后者word=Pikachu显然就是我们搜索的关键词。url就解决了，然后向百度发送请求。代码显示如下：
　　html = requests.get(url)
　　html.encoding = html.apparent_encoding #这里可以查看需要爬取的页面的源码，一般是utf-8，但不是全部。
　　html = html.text #这里需要获取对应的文本，用于后面的正则匹配操作
　　接下来就是操作源码了。最好对网络前端有所了解。如果没有，至少检查一下源码（最简单的操作是在网址栏前面加上view-source）
　　一、在源页面搜索jpg（百度图片后缀，先找到图片链接）
　　只需抓取一个链接并分析它：
　　{"ObjURL":"http:\/\/\/forum\/pic\/item\/6cad1f30e924b8998595da4079061d950b7bf6b6.jpg","ObjUrl":"http:\/\/\/forum\/pic\ /项目\/6cad1f30e924b8998595da4079061d950b7bf6b6.jpg"
　　抓取http:\/\/\/forum\/pic\/item\/6cad1f30e924b8998595da4079061d950b7bf6b6.jpg里面，访问一下，发现是可以访问的。又试了几次，发现只有objURL开头的可以访问，而objURL开头的可能无法访问。没关系，先把所有的
　　"ObjURL":"xxxx"
　　格式中的所有链接都找到了，这时候就需要使用正则匹配了。代码显示如下：
　　urls = re.findall('"objURL":"(.*?)"',html,re.S) #这里使用导入的re包
　　需要注意的是，re.findall匹配的数据是一个列表，需要用for循环逐个访问：
　　我 = 0
　　对于网址中的网址：
　　time.sleep(3) #睡眠3秒
　　imag = requests.get(url,timeout = 6).content
　　#timeout表示每个请求最多6秒，否则会卡住
　　如果想象：
　　使用 open(str(i) + '.jpg','wb') 作为 f：
　　print('正在下载第 %d 张图片：%s' %(i + 1,url))
　　f.write(imag)
　　我 += 1
　　别的：
　　print('链接超时，图片下载失败')
　　print('图片下载成功')
　　一个最简单的爬虫已经写好了，但是如果有一点错误就会报错。没有所谓的鲁棒性。如何改进爬虫将在下一篇文章文章中解释。
　　完整代码如下，大家可以自己体验一下：
　　导入请求
　　重新进口
　　进口时间
　　url = '皮卡丘'
　　html = requests.get(url)
　　html.encoding = html.apparent_encoding
　　html = html.text
　　urls = re.findall('"objURL":"(.*?)"',html,re.S)
　　我 = 0
　　对于网址中的网址：
　　time.sleep(3) #睡眠3秒
　　imag = requests.get(url,timeout = 6).content
　　#timeout表示每个请求最多6秒，否则会卡住
　　如果想象：
　　使用 open(str(i) + '.jpg','wb') 作为 f：
　　print('正在下载第 %d 张图片：%s' %(i + 1,url))
　　f.write(imag)
　　我 += 1
　　别的：
　　print('链接超时，图片下载失败')
　　print('图片下载成功')
　　注：最后给大家发一套2020年最新的企业级Python项目实战视频教程，点此领取，跟着实践。希望大家一起进步！ 查看全部

　　网页爬虫抓取百度图片(要求：爬取30张百度图片中关晓彤的照片！！
)
　　要求：在百度图片中抓取关晓彤的30张照片！ ！ ！首先，遵循一个爬虫的大致开发流程：
　　
　　(1）分析网页：由于网页的源代码太复杂，想要找到我们想要的太难了，所以随便找一张图片的url，操作是如下：
　　
　　然后，查看网页的源码，ctrl+f搜索刚刚找到的图片的url，会找到三个，我们以第一个为例：
　　
　　#观察前面有一个thumbURL，我们在这个源码中搜索：
　　
　　如你所见，我们只需要借用 thumbURL 来使用正则表达式来匹配每张图片的 url。 (2）代码编写：
　　#1.找目标数据
#2.分析请求流程 (1)每个关晓彤照片就是一个url (2)拿到这些url （3）会发现有30个thumbURL 这就刚好对应30个关晓彤照片的url(这些都在page_url里)
import urllib3
import re
import os
http = urllib3.PoolManager()
# 第一部分：获取包含这些图片的网页的代码
page_url = "https://image.baidu.com/search ... ot%3B
res = http.request("GET",page_url)
html = res.data.decode()
# print(html)
# 第二部分：利用正则锁定我们所要爬取的图片的url
img_urls = re.findall('thumbURL":"(.*?)"',html)
print(img_urls)
# 将图片扔到文件夹里
if not os.path.exists("girl_imgs"):
os.mkdir("girl_imgs")
# 遍历对每个图片url发起请求
for index,img_url in enumerate(img_urls):
res=http.request("GET",img_url)
img_data=res.data
filename="girl_imgs/"+str(index)+".jpg"
with open(filename,"wb") as f:
f.write(img_data)
　　注意：如果不能爬取，会被封禁。发送请求时添加标头。如果只在header中添加user-agent，报错，添加referer（热链）！
　　
　　 查看全部

　　网页爬虫抓取百度图片(网页爬虫抓取百度图片，需要先去重？t)
　　网页爬虫抓取百度图片，需要先去重。爬虫基础架构是httpget请求。这里需要在指定的url下去重。要知道，requestheader字段在这个过程中会被逐个尝试，acceptlanguageauthorizationcontext这几项下面是一些常见的做法。http请求逐个尝试有几个比较方便的做法：tcp抽取数据v1.0：socket编程基础googlehttprequest抽取文件http文件直接传输200,201,213之类的。
　　需要提前想好接收的url名称和文件名。http文件获取googlehttprequest抽取bulk数据bulk方式的有两种：url后缀或者/。这里教大家一个python基础里的重载get方法基础知识，考验的不是使用get方法取数据，而是获取attribute字段的字典：classme(http.get):def__init__(self,salary,b...):self.salary=salaryself.b=bself.preload=false...通过这个例子，希望你知道request请求的response属性里面的salary和b，如何去理解。
　　第一次和后续的爬虫代码基础爬虫代码基础，注意把make_auth，forwardedheader和user_agent这三个参数写好。我一般都用后缀名.string形式。ps:我自己用urllib.request库爬微博博客爬取文章过程中发现，网页很多都是重复的，很久前的。于是，我把request请求的头部信息拆解，写成了函数。
　　下面是一个python的程序，都在python库中实现。#!/usr/bin/envpython#-*-coding:utf-8-*-fromcollectionsimportordereddictfromseleniumimportwebdriverfromdatetimeimportdatetimefromflaskimportflaskdefget_auth(url,headers):returnhttp.session().get(url).select(headers=headers)defget_header(url,headers):returnhttp.session().get(url).select(headers=headers)if__name__=='__main__':urls=[微博博客爬取bulkdata'''try:headers=headersexcept:headers=headersdatetime=datetime.now()ifsys.argv[1]=='':print(sys.argv[1])returnhttp.session().get(url,headers=headers)if__name__=='__main__':client=collections.ordereddict()p_url=['''微博博客爬取bulkdata'''try:headers=headersexcept:headers=headersif__name__=='__main__':urls=['微博博客爬取bulkdata'''。 查看全部

　　网页爬虫抓取百度图片(利用python抓取网络图片的步骤：1.根据给定的网址获取)
　　使用python抓取网络图片的步骤：
　　1.根据给定的URL获取网页的源代码
　　2.使用正则表达式过滤掉源码中的图片地址
　　3.根据过滤后的图片地址下载网络图片
　　#coding=UTF-8
import urllib2
import urllib
import re
def getHtml(url):
page = urllib.urlopen(url)
html = page.read()
return html
def getJpg(html):
reg = r&#39;"largeTnImageUrl":"(.+?\.jpg)",&#39;
imgre = re.compile(reg)
imglist = re.findall(imgre, html)
x = 0
for imgurl in imglist:
print imgurl
#urllib.urlretrieve(imgurl, &#39;D:/test/%s.html&#39; % x)
header = {&#39;User-Agent&#39;:&#39;Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.64 Safari/537.11&#39;,
&#39;Accept&#39;:&#39;text/html;q=0.9,*/*;q=0.8&#39;,
&#39;Accept-Charset&#39;:&#39;ISO-8859-1,utf-8;q=0.7,*;q=0.3&#39;,
&#39;Accept-Encoding&#39;:&#39;gzip&#39;,
&#39;Connection&#39;:&#39;close&#39;,
&#39;Referer&#39;:&#39;http://image.baidu.com/i%3Ftn% ... 39%3B
}
timeout = 30
request = urllib2.Request(imgurl,None,header)
response = urllib2.urlopen(request,None,timeout)
str = response.read()
foo = open("D:/test/%s.gif" % x,"wb")
foo.write(str)
foo.close()
x += 1

html = getHtml(&#39;http://image.baidu.com/i%3Ftn% ... %2339;)
print getJpg(html)
　　博客示例参考：
　　在参考博客实现示例的过程中，我也遇到了一些问题。图片已下载，但无法预览。经过多次分析，发现百度图片设置了反爬。为了解决这个问题，我参考了另一篇博文。
　　模拟浏览器发送请求并欺骗服务器进行反爬： 查看全部