urllib模块
urllib是Python自带的一个用于爬虫的库，其主要作用就是可以通过代码模拟浏览器发送请求。其常被用到的子模块在Python3中的为urllib.request和urllib.parse，在Python2中是urllib和urllib2。
一、使用流程：
- 指定url
- 基于urllib的request子模块发起请求
- 获取响应中的数据值
- 持久化存储
二、urlopen函数原型：
urllib.request.urlopen(url, data=None, timeout=<object object at 0x10af327d0>, *, cafile=None, capath=None, cadefault=False, context=None)在日常开发中，我们能用的只有url和data这两个参数。
- url参数：指定向哪个url发起请求
- url的特性：url必须为ASCII编码的数据值。所以我们在爬虫代码中编写url时，如果url中存在非ASCII编码的数据值，则必须对其进行ASCII编码后，该url方可被使用。
- get: word = urllib.parse.quote("人民币")
- post: data = { 'kw':'西瓜'} data = urllib.parse.urlencode(data) data = data.encode() urlencode(返回值类型为str)
- data参数：可以将post请求中携带的参数封装成字典的形式传递给该参数
- urlopen函数返回的响应对象，相关函数调用介绍：
- response.headers()：获取响应头信息
- response.getcode()：获取响应状态码
- response.geturl()：获取请求的url
- response.read()：获取响应中的数据值（字节类型）
三、其他
- 反爬机制：网站检查请求的UA，如果发现UA是爬虫程序，则拒绝提供网站数据。
- User-Agent(UA)：请求载体的身份标识.
- 反反爬机制：伪装爬虫程序请求的UA
- 通过自定义请求对象，用于伪装爬虫程序请求的身份。
""" 基础使用 """ # 需求：爬取搜狗首页的页面数据 import urllib.request #1.指定url url = 'https://www.sogou.com/' #2.发起请求:urlopen可以根据指定的url发起请求，切返回一个响应对象 response = urllib.request.urlopen(url=url) #3.获取页面数据:read函数返回的就是响应对象中存储的页面数据(byte) page_text = response.read() #4.持久化存储 with open('./sougou.html','wb') as fp: fp.write(page_text) print('写入数据成功') """ get: """ # 需求：爬取指定词条所对应的页面数据 import urllib.request import urllib.parse #指定url url = 'https://www.sogou.com/web?query=' #url特性：url不可以存在非ASCII编码的字符数据 word = urllib.parse.quote("人民币") url += word #有效的url #发请求 response = urllib.request.urlopen(url=url) #获取页面数据 page_text = response.read() with open('renminbi.html','wb') as fp: fp.write(page_text) """ UA伪装 """ import urllib.request url = 'https://www.baidu.com/' # UA伪装 # 1.子制定一个请求对象 headers = { # 存储任意的请求头信息 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.67 Safari/537.36' } # 该请求对象的UA进行了成功的伪装 request = urllib.request.Request(url=url, headers=headers) # 2.针对自制定的请求对象发起请求 response = urllib.request.urlopen(request) print(response.read()) """ post """ import urllib.request import urllib.parse #1.指定url url = 'https://fanyi.baidu.com/sug' #post请求携带的参数进行处理 流程： #1.将post请求参数封装到字典 data = { 'kw':'西瓜' } #2.使用parse模块中的urlencode(返回值类型为str)进行编码处理 data = urllib.parse.urlencode(data) #3.将步骤2的编码结果转换成byte类型 data = data.encode() #2.发起post请求:urlopen函数的data参数表示的就是经过处理之后的post请求携带的参数 response = urllib.request.urlopen(url=url,data=data) response.read()
requests模块
- 介绍：使用requests可以模拟浏览器的请求，比起之前用到的urllib，requests模块的api更加便捷（本质就是封装了urllib3）
- 注意：requests库发送请求将网页内容下载下来以后，并不会执行js代码，这需要我们自己分析目标站点然后发起新的request请求
- 安装：pip3 install requests
- 各种请求方式：常用的就是requests.get()和requests.post()
######## ensure_ascii=False import requests import json if __name__ == "__main__": #1.指定url post_url = 'https://fanyi.baidu.com/sug' #2.进行UA伪装 headers = { 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.121 Safari/537.36' } #3.post请求参数处理（同get请求一致） word = input('enter a word:') data = { 'kw':word } #4.请求发送 response = requests.post(url=post_url,data=data,headers=headers) #5.获取响应数据:json()方法返回的是obj（如果确认响应数据是json类型的，才可以使用json（）） dic_obj = response.json() #持久化存储 fileName = word+'.json' fp = open(fileName,'w',encoding='utf-8') json.dump(dic_obj,fp=fp,ensure_ascii=False) print('over!!!') #############response.encoding = 'utf-8' #############img_name.encode('iso-8859-1').decode('gbk') #需求：解析下载图片数据 http://pic.netbian.com/4kmeinv/ import requests from lxml import etree import os if __name__ == "__main__": url = 'http://pic.netbian.com/4kmeinv/' headers = { 'User-Agent':'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.103 Safari/537.36' } response = requests.get(url=url,headers=headers) #手动设定响应数据的编码格式 # response.encoding = 'utf-8' page_text = response.text #数据解析：src的属性值 alt属性 tree = etree.HTML(page_text) li_list = tree.xpath('//div[@class="slist"]/ul/li') #创建一个文件夹 if not os.path.exists('./picLibs'): os.mkdir('./picLibs') for li in li_list: img_src = 'http://pic.netbian.com'+li.xpath('./a/img/@src')[0] img_name = li.xpath('./a/img/@alt')[0]+'.jpg' #通用处理中文乱码的解决方案 img_name = img_name.encode('iso-8859-1').decode('gbk') # print(img_name,img_src) #请求图片进行持久化存储 img_data = requests.get(url=img_src,headers=headers).content img_path = 'picLibs/'+img_name with open(img_path,'wb') as fp: fp.write(img_data) print(img_name,'下载成功！！！') """ #解析到热门城市和所有城市对应的a标签 # //div[@class="bottom"]/ul/li/ 热门城市a标签的层级关系 # //div[@class="bottom"]/ul/div[2]/li/a 全部城市a标签的层级关系 a_list = tree.xpath('//div[@class="bottom"]/ul/li/a | //div[@class="bottom"]/ul/div[2]/li/a') """
import requests r = requests.get('https://api.github.com/events') r = requests.post('http://httpbin.org/post', data = {'key':'value'}) r = requests.put('http://httpbin.org/put', data = {'key':'value'}) r = requests.delete('http://httpbin.org/delete') r = requests.head('http://httpbin.org/get') r = requests.options('http://httpbin.org/get')
""" get请求 """ import requests #指定url url = 'https://www.sogou.com/' #发起get请求:get方法会返回请求成功的相应对象 response = requests.get(url=url) #获取响应中的数据值:text可以获取响应对象中字符串形式的页面数据 page_data = response.text print(page_data) #content获取的是response对象中二进制（byte）类型的页面数据 print(response.content) #返回一个响应状态码 print(response.status_code) #返回响应头信息 print(response.headers) #获取请求的url print(response.url) #持久化操作 with open('./sougou.html','w',encoding='utf-8') as fp: fp.write(page_data) """ get请求带参方式1： """ import requests url = 'https://www.sogou.com/web?query=周杰伦&ie=utf-8' response = requests.get(url=url) page_text = response.text with open('./zhou.html','w',encoding='utf-8') as fp: fp.write(page_text) """ get请求带参方式2： 自定义请求头信息 """ # 自定义请求头信息 import requests url = 'https://www.sogou.com/web' #将参数封装到字典中 params = { 'query':'周杰伦', 'ie':'utf-8' } #自定义请求头信息 headers = { 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36', } response = requests.get(url=url,params=params,headers=headers) response.status_code """ post请求 需求：登录豆瓣网，获取登录成功后的页面数据 """ import requests #1.指定post请求的url url = 'https://accounts.douban.com/login' #封装post请求的参数 data = { "source": "movie", "redir": "https://movie.douban.com/", "form_email": "15027900535", "form_password": "bobo@15027900535", "login": "登录", } #自定义请求头信息 headers = { 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36', } #2.发起post请求 response = requests.post(url=url,data=data,headers=headers) #3.获取响应对象中的页面数据 page_text = response.text #4.持久化操作 with open('./douban.html','w',encoding='utf-8') as fp: fp.write(page_text) """ 基于ajax的get请求 -需求：抓取豆瓣电影上电影详情的数据 """ import requests url = 'https://movie.douban.com/j/chart/top_list?' #封装ajax的get请求中携带的参数 params = { 'type':'5', 'interval_id':'100:90', 'action':'', 'start':'100', 'limit':'20' } #自定义请求头信息 headers = { 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36', } response = requests.get(url=url,params=params,headers=headers) #获取响应内容：响应内容为json串 print(response.text) """ 基于ajax的post请求 - 需求：爬去肯德基城市餐厅位置数据 """ import requests #1指定url post_url = 'http://www.kfc.com.cn/kfccda/ashx/GetStoreList.ashx?op=keyword' #处理post请求的参数 data = { "cname": "", "pid": "", "keyword": "上海", "pageIndex": "1", "pageSize": "10", } #自定义请求头信息 headers = { 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36', } #2发起基于ajax的post请求 response = requests.post(url=post_url,headers=headers,data=data) #获取响应内容：响应内容为json串 print(response.text) """ 综合项目实战 - 需求：爬取搜狗知乎某一个词条对应一定范围页码表示的页面数据 """ # 前三页页面数据（1，2，3） import requests import os # 创建一个文件夹 if not os.path.exists('./pages'): os.mkdir('./pages') word = input('enter a word:') # 动态指定页码的范围 start_pageNum = int(input('enter a start pageNum:')) end_pageNum = int(input('enter a end pageNum:')) # 自定义请求头信息 headers = { 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36', } # 1.指定url:设计成一个具有通用的url url = 'https://zhihu.sogou.com/zhihu' for page in range(start_pageNum, end_pageNum + 1): param = { 'query': word, 'page': page, 'ie': 'utf-8' } response = requests.get(url=url, params=param, headers=headers) # 获取响应中的页面数据（指定页码（page）） page_text = response.text # 进行持久化存储 fileName = word + str(page) + '.html' filePath = 'pages/' + fileName with open(filePath, 'w', encoding='utf-8') as fp: fp.write(page_text) print('第%d页数据写入成功' % page) """ requests模块高级： - cookie： 基于用户的用户数据 - 需求：爬取张三用户的豆瓣网的个人主页页面数据 - cookie作用：服务器端使用cookie来记录客户端的状态信息。 实现流程： 1.执行登录操作（获取cookie） 2.在发起个人主页请求时，需要将cookie携带到该请求中 注意：session对象：发送请求（会将cookie对象进行自动存储） """ import requests session = requests.session() #1.发起登录请求：将cookie获取，且存储到session对象中 login_url = 'https://accounts.douban.com/login' data = { "source": "None", "redir": "https://www.douban.com/people/185687620/", "form_email": "15027900535", "form_password": "bobo@15027900535", "login": "登录", } headers={ 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36', } #使用session发起post请求 login_response = session.post(url=login_url,data=data,headers=headers) #2.对个人主页发起请求（session（cookie）），获取响应页面数据 url = 'https://www.douban.com/people/185687620/' response = session.get(url=url,headers=headers) page_text = response.text with open('./douban110.html','w',encoding='utf-8') as fp: fp.write(page_text) """ 代理操作： - 1.代理：第三方代理本体执行相关的事物。生活：代购，微商，中介 - 2.为什么要使用代理？ - 反爬操作。 - 反反爬手段 - 3.分类： - 正向代理：代替客户端获取数据 - 反向代理：代理服务器端提供数据 - 4.免费代理ip的网站提供商： - www.goubanjia.com - 快代理 - 西祠代理 - 5.代码： """ import requests url = 'http://www.baidu.com/s?ie=utf-8&wd=ip' headers={ 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36', } #将代理ip封装到字典 proxy = { 'http':'77.73.69.120:3128' } #更换网路IP response = requests.get(url=url,proxies=proxy,headers=headers) with open('./daili.html','w',encoding='utf-8') as fp: fp.write(response.text)
import base64 # 想将字符串转编码成base64,要先将字符串转换成二进制数据 url = "https://www.cnblogs.com" bytes_url = url.encode("utf-8") str_url = base64.b64encode(bytes_url) # 被编码的参数必须是二进制数据 print(str_url) # b'aHR0cHM6Ly93d3cuY25ibG9ncy5jb20=' url = "aHR0cHM6Ly93d3cuY25ibG9ncy5jb20=" str_url = base64.b64decode(url).decode("utf-8") print(str_url) # 'https://www.cnblogs.com' ############################################################## #需求：爬取煎蛋网的图片数据 http://jandan.net/ooxx import requests from lxml import etree import base64 from urllib import request headers = { 'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.121 Safari/537.36' } url = 'http://jandan.net/ooxx/page-62#comments' page_text = requests.get(url=url,headers=headers).text #解析图片的密文 tree = etree.HTML(page_text) code_list = tree.xpath('//span[@class="img-hash"]/text()') for code in code_list: img_url ='http:' + base64.b64decode(code).decode() imgName = img_url.split('/')[-1] request.urlretrieve(img_url,imgName) print(imgName,'下载成功！！！')
""" - HTTPConnectionPool（host:XX）Max retries exceeded with url: - 如何让请求结束后马上断开连接且释放池中的连接资源： 'Connection':'close' - 使用代理ip： - sleep """ import requests from lxml import etree import random headers = { 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.121 Safari/537.36', 'Connection': 'close' } url_page_one = 'http://sc.chinaz.com/jianli/free.html' # 定制了一个通用的url模板 url_demo = 'http://sc.chinaz.com/jianli/free_%d.html' start_page = int(input('enter a start page num:')) end_page = int(input('enter a end page num:')) for pageNum in range(start_page, end_page + 1): if pageNum == 1: url = url_page_one else: url = format(url_demo % pageNum) response = requests.get(url=url, headers=headers) response.encoding = 'utf-8' page_text = response.text # 解析：简历详情页的url,和名称 tree = etree.HTML(page_text) div_list = tree.xpath('//div[@id="container"]/div') for div in div_list: name = div.xpath('./p/a/text()')[0] detail_url = div.xpath('./p/a/@href')[0] # 对详情页的url发起请求，获取详情页的源码数据 detail_page_text = requests.get(url=detail_url, headers=headers).text # 对详情页的源码数据进行解析：下载地址对应的url tree = etree.HTML(detail_page_text) li_list = tree.xpath('//div[@class="clearfix mt20 downlist"]/ul/li') # 随机选取一个li标签（li标签中包含了下载地址的url） li = random.choice(li_list) download_url = li.xpath('./a/@href')[0] # 进行简历数据的下载 data = requests.get(url=download_url, headers=headers).content name = name + '.rar' with open(name, 'wb') as fp: fp.write(data) print(name, '下载成功！')
""" cookie的处理 - 1.手动处理： - cookie封装到headers - 2.自动处理： - 1.获取一个session对象 - 2.使用session对象进行请求的发送 - 3.作用：在使用session进行请求发送过程中如果产生了cookie，则cookie会被自动存储到session对象中 """ #识别人人网中的验证码图片 import requests from lxml import etree from urllib import request url = 'http://www.renren.com/' headers = { 'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.121 Safari/537.36' } page_text = requests.get(url=url,headers=headers).text #解析验证码图片 tree = etree.HTML(page_text) code_img_url = tree.xpath('//*[@id="verifyPic_login"]/@src')[0] request.urlretrieve(code_img_url,'./code.jpg') code_text = getCodeText('bobo328410948','bobo328410948','./code.jpg',2004) #登录 login_url = 'http://www.renren.com/ajaxLogin/login?1=1&uniqueTimestamp=201924831467' data = { "email":"www.zhangbowudi@qq.com", "icode":code_text, "origURL":"http://www.renren.com/home", "domain":"renren.com", "key_id":"1", "captcha_type":"web_login", "password":"436e61246c5c1c36a288c0e625b4e10f9b9c8df72b7a3f6e06a182c38d2286cb", "rkey":"77a46f4376c93a80d35930b2cacb6a8d", "f":"", } #创建一个session对象 session = requests.Session() #使用session进行请求的发送：获取cookie，且将cookie保存到session中 session.post(url=login_url,data=data,headers=headers) #获取个人主页对应的页面数据 detail_url = 'http://www.renren.com/289676607/profile' #该次请求发送是就已经携带了cookie page_text = session.get(url=detail_url,headers=headers).text with open('./renren.html','w',encoding='utf-8') as fp: fp.write(page_text) ####################################################################### # 对古诗文网进行模拟登录 from lxml import etree from urllib import request headers = { 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.121 Safari/537.36' } session = requests.Session() # 获取验证码图片 url = 'https://so.gushiwen.org/user/login.aspx?from=http://so.gushiwen.org/user/collect.aspx' page_text = requests.get(url=url, headers=headers).text tree = etree.HTML(page_text) code_img_url = 'https://so.gushiwen.org' + tree.xpath('//*[@id="imgCode"]/@src')[0] # request.urlretrieve(code_img_url,'./gushiwen.jpg') img_data = session.get(url=code_img_url, headers=headers).content #####验证码也用了cookie with open('./gushiwen.jpg', 'wb') as fp: fp.write(img_data) code_text = getCodeText('bobo328410948', 'bobo328410948', './gushiwen.jpg', 1004) # 执行登录 __VIEWSTATE = tree.xpath('//*[@id="__VIEWSTATE"]/@value')[0] __VIEWSTATEGENERATOR = tree.xpath('//*[@id="__VIEWSTATEGENERATOR"]/@value')[0] login_url = 'https://so.gushiwen.org/user/login.aspx?from=http%3a%2f%2fso.gushiwen.org%2fuser%2fcollect.aspx' data = { "__VIEWSTATE": __VIEWSTATE, #####注意类似token的参数 "__VIEWSTATEGENERATOR": __VIEWSTATEGENERATOR, "from": "http://so.gushiwen.org/user/collect.aspx", "email": "www.zhangbowudi@qq.com", "pwd": "bobo328410948", "code": code_text, "denglu": "登录", } page_text = session.post(url=login_url, data=data, headers=headers).text with open('./gushiwen.html', 'w', encoding='utf-8') as fp: fp.write(page_text)
###############################同步爬虫 import requests headers = { 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.121 Safari/537.36' } urls = [ 'http://xmdx.sc.chinaz.net/Files/DownLoad/jianli/201904/jianli10231.rar', 'http://zjlt.sc.chinaz.net/Files/DownLoad/jianli/201904/jianli10229.rar', 'http://xmdx.sc.chinaz.net/Files/DownLoad/jianli/201904/jianli10231.rar' ] def get_content(url): print('正在爬取：',url) #get方法是一个阻塞的方法 response = requests.get(url=url,headers=headers) if response.status_code == 200 : return response.content def parse_content(content): print('响应数据的长度为：',len(content)) for url in urls: content = get_content(url) parse_content(content) ###############################线程池 #原则：线程池处理的是阻塞且较为耗时的操作 import requests from lxml import etree import re import random # 导入线程池模块 from multiprocessing.dummy import Pool def getVideoData(url): video_data = requests.get(url=url,headers=headers).content return video_data def saveVideoData(data): fileName = str(random.randint(0,10000))+'.mp4' with open(fileName,'wb') as fp: fp.write(data) print(fileName,'下载成功') pool = Pool(10) # 线程池的使用场景：应用在所有耗时的操作中 headers = { 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.121 Safari/537.36' } url = 'https://www.pearvideo.com/category_1' page_text = requests.get(url=url, headers=headers).text tree = etree.HTML(page_text) li_list = tree.xpath('//ul[@id="listvideoListUl"]/li') video_url_list = [] # 装所有视频的连接 for li in li_list: detail_url = "https://www.pearvideo.com/" + li.xpath('./div/a/@href')[0] detail_page_text = requests.get(url=detail_url, headers=headers).text # 使用正则对视频连接进行解析 video_url = re.findall('srcUrl="(.*?)",vdoUrl=', detail_page_text, re.S)[0] video_url_list.append(video_url) # 对视频的连接发起请求获取视频数据 video_data_list = pool.map(getVideoData, video_url_list) # video_data_list存储的就是所有视频的二进制数据 # 使用线程池进行持久化存储的操作 pool.map(saveVideoData, video_data_list) pool.close() pool.join()
###########协程 import asyncio async def request(url): print('正在请求的url是',url) print('请求成功,',url) return url #async修饰的函数，调用之后返回的一个协程对象 c = request('www.baidu.com') # #创建一个事件循环对象 # loop = asyncio.get_event_loop() # # #将协程对象注册到loop中，然后启动loop # loop.run_until_complete(c) #task的使用 # loop = asyncio.get_event_loop() # #基于loop创建了一个task对象 # task = loop.create_task(c) # print(task) # # loop.run_until_complete(task) # # print(task) #future的使用 # loop = asyncio.get_event_loop() # task = asyncio.ensure_future(c) # print(task) # loop.run_until_complete(task) # print(task) def callback_func(task): #result返回的就是任务对象中封装的协程对象对应函数的返回值 print(task.result()) #绑定回调 loop = asyncio.get_event_loop() task = asyncio.ensure_future(c) #将回调函数绑定到任务对象中 task.add_done_callback(callback_func) loop.run_until_complete(task) ################################# import asyncio import time async def request(url): print('正在下载',url) #在异步协程中如果出现了同步模块相关的代码，那么就无法实现异步。 # time.sleep(2) #当在asyncio中遇到阻塞操作必须进行手动挂起 await asyncio.sleep(2) print('下载完毕',url) start = time.time() urls = [ 'www.baidu.com', 'www.sogou.com', 'www.goubanjia.com' ] #任务列表：存放多个任务对象 stasks = [] for url in urls: c = request(url) task = asyncio.ensure_future(c) stasks.append(task) loop = asyncio.get_event_loop() #需要将任务列表封装到wait中 loop.run_until_complete(asyncio.wait(stasks)) print(time.time()-start) ########################################## import requests import asyncio import time start = time.time() urls = [ 'http://127.0.0.1:5000/bobo','http://127.0.0.1:5000/jay','http://127.0.0.1:5000/tom' ] async def get_page(url): print('正在下载',url) #requests.get是基于同步，必须使用基于异步的网络请求模块进行指定url的请求发送 #aiohttp:基于异步网络请求的模块 response = requests.get(url=url) print('下载完毕：',response.text) tasks = [] for url in urls: c = get_page(url) task = asyncio.ensure_future(c) tasks.append(task) loop = asyncio.get_event_loop() loop.run_until_complete(asyncio.wait(tasks)) end = time.time() print('总耗时:',end-start) ##########################################
""" 高性能异步爬虫 目的：在爬虫中使用异步实现高性能的数据爬取操作。 异步爬虫的方式： - 1.多线程，多进程（不建议）： 好处：可以为相关阻塞的操作单独开启线程或者进程，阻塞操作就可以异步执行。 弊端：无法无限制的开启多线程或者多进程。 - 2.线程池、进程池（适当的使用）： 好处：我们可以降低系统对进程或者线程创建和销毁的一个频率，从而很好的降低系统的开销。 弊端：池中线程或进程的数量是有上限。 - 3.单线程+异步协程（推荐）： event_loop：事件循环，相当于一个无限循环，我们可以把一些函数注册到这个事件循环上， 当满足某些条件的时候，函数就会被循环执行。 coroutine：协程对象，我们可以将协程对象注册到事件循环中，它会被事件循环调用。 我们可以使用 async 关键字来定义一个方法，这个方法在调用时不会立即被执行，而是返回 一个协程对象。 task：任务，它是对协程对象的进一步封装，包含了任务的各个状态。 future：代表将来执行或还没有执行的任务，实际上和 task 没有本质区别。 async 定义一个协程. await 用来挂起阻塞方法的执行。 """ #环境安装：pip install aiohttp #使用该模块中的ClientSession import requests import asyncio import time import aiohttp start = time.time() # urls = [ # 'http://127.0.0.1:5000/bobo','http://127.0.0.1:5000/jay','http://127.0.0.1:5000/tom', # 'http://127.0.0.1:5000/bobo', 'http://127.0.0.1:5000/jay', 'http://127.0.0.1:5000/tom', # 'http://127.0.0.1:5000/bobo', 'http://127.0.0.1:5000/jay', 'http://127.0.0.1:5000/tom', # 'http://127.0.0.1:5000/bobo', 'http://127.0.0.1:5000/jay', 'http://127.0.0.1:5000/tom', # # ] from multiprocessing.dummy import Pool pool = Pool(2) urls = [] for i in range(10): urls.append('http://127.0.0.1:5000/bobo') print(urls) async def get_page(url): async with aiohttp.ClientSession() as session: #get()、post(): #headers,params/data,proxy='http://ip:port' async with await session.get(url) as response: #text()返回字符串形式的响应数据 #read()返回的二进制形式的响应数据 #json()返回的就是json对象 #注意：获取响应数据操作之前一定要使用await进行手动挂起 page_text = await response.text() print(page_text) tasks = [] for url in urls: c = get_page(url) task = asyncio.ensure_future(c) tasks.append(task) loop = asyncio.get_event_loop() loop.run_until_complete(asyncio.wait(tasks)) end = time.time() print('总耗时:',end-start) ###################################### import requests from lxml import etree import time import os start = time.time() headers = { 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.121 Safari/537.36' } if not os.path.exists('./libs'): os.mkdir('./libs') url = 'http://pic.netbian.com/4kmeinv/index_%d.html' a = [] for page in range(2,50): new_url = format(url%page) page_text = requests.get(url=new_url,headers=headers).text tree = etree.HTML(page_text) li_list = tree.xpath('//div[@class="slist"]/ul/li') for li in li_list: img_src = 'http://pic.netbian.com' + li.xpath('./a/img/@src')[0] name = img_src.split('/')[-1] # data = requests.get(url=img_src).content # path = './libs/'+name # with open(path,'wb') as fp: # fp.write(data) # print(name,'下载成功') a.append(name) print(len(a)) print('总耗时：',time.time()-start)
""" selenium：可以让浏览器完成相关自动化的操作 环境安装： pip install selenium 编码流程： 导包 创建某一款浏览器对象 制定相关的行为动作 """ from selenium import webdriver from time import sleep bro = webdriver.Chrome(executable_path=r'C:\Users\old-boy\Desktop\chromedriver.exe') sleep(3) bro.get('https://www.baidu.com/') sleep(3) #find系列的函数可以帮助我们定位到相关的标签 text_input = bro.find_element_by_id('kw') #向文本框中录入一个关键字 text_input.send_keys('中国') sleep(3) btn = bro.find_element_by_id('su') btn.click() sleep(3) #获取当前浏览器显示的页面源码数据（动态加载的数据） page_text = bro.page_source print(page_text) bro.quit() #爬取更多的电影详情数据（豆瓣） bro = webdriver.Chrome(executable_path=r'C:\Users\old-boy\Desktop\chromedriver.exe') bro.get('https://movie.douban.com/typerank?type_name=%E7%88%B1%E6%83%85&type=13&interval_id=100:90&action=') sleep(3) bro.execute_script('window.scrollTo(0,document.body.scrollHeight)') sleep(3) bro.execute_script('window.scrollTo(0,document.body.scrollHeight)') sleep(3) bro.execute_script('window.scrollTo(0,document.body.scrollHeight)') #获取浏览器当前的页面源码数据 page_text = bro.page_source with open('douban.html','w',encoding='utf-8') as fp: fp.write(page_text) sleep(3) bro.quit() #phantomJs:浏览器（无可视化界面） #爬取更多的电影详情数据（豆瓣） bro = webdriver.PhantomJS(executable_path=r'C:\Users\old-boy\Desktop\爬虫+数据\tools\phantomjs-2.1.1-windows\bin\phantomjs.exe') bro.get('https://movie.douban.com/typerank?type_name=%E7%88%B1%E6%83%85&type=13&interval_id=100:90&action=') sleep(3) bro.save_screenshot('./1.png') ##截屏 bro.execute_script('window.scrollTo(0,document.body.scrollHeight)') sleep(3) bro.execute_script('window.scrollTo(0,document.body.scrollHeight)') sleep(3) bro.execute_script('window.scrollTo(0,document.body.scrollHeight)') bro.save_screenshot('./2.png') #获取浏览器当前的页面源码数据 page_text = bro.page_source with open('douban.html','w',encoding='utf-8') as fp: fp.write(page_text) sleep(3) bro.quit() #谷歌无头浏览器 from selenium.webdriver.chrome.options import Options chrome_options = Options() chrome_options.add_argument('--headless') chrome_options.add_argument('--disable-gpu') bro = webdriver.Chrome(executable_path=r'C:\Users\old-boy\Desktop\chromedriver.exe',chrome_options=chrome_options) sleep(3) bro.get('https://www.baidu.com/') sleep(3) #find系列的函数可以帮助我们定位到相关的标签 text_input = bro.find_element_by_id('kw') #向文本框中录入一个关键字 text_input.send_keys('中国') sleep(3) btn = bro.find_element_by_id('su') btn.click() sleep(3) #获取当前浏览器显示的页面源码数据（动态加载的数据） page_text = bro.page_source print(page_text) bro.quit() #登录qq空间 bro = webdriver.Chrome(executable_path=r'C:\Users\old-boy\Desktop\chromedriver.exe') bro.get('https://qzone.qq.com/') sleep(3) #注意：如果想要通过find系列函数去定位某一个iframe标签下的子标签的话，一定要使用如下操作： bro.switch_to.frame('login_frame')#参数表示的是iframe标签的id属性值 bro.find_element_by_id('switcher_plogin').click() sleep(3) bro.find_element_by_id('u').send_keys('592888935') bro.find_element_by_id('p').send_keys('123456789') sleep(3) bro.find_element_by_id('login_button').click() print(bro.page_source) sleep(3) bro.quit()
一、基于GET请求
- HTTP默认的请求方法就是GET
- 没有请求体
- 数据必须在1K之内！
- GET请求数据会暴露在浏览器的地址栏中
- GET请求常用的操作：
- 在浏览器的地址栏中直接给出URL，那么就一定是GET请求
- 点击页面上的超链接也一定是GET请求
- 提交表单时，表单默认使用GET请求，但可以设置为POST
#1、基本请求 import requests response=requests.get('http://dig.chouti.com/') print(response.text) #2、带参数的GET请求->params #2.1自己拼接GET参数 #在请求头内将自己伪装成浏览器，否则百度不会正常返回页面内容 import requests response=requests.get('https://www.baidu.com/s?wd=python&pn=1', headers={ 'User-Agent':'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.75 Safari/537.36', }) print(response.text) #如果查询关键词是中文或者有其他特殊符号，则不得不进行url编码 from urllib.parse import urlencode wd='egon老师' encode_res=urlencode({'k':wd},encoding='utf-8') keyword=encode_res.split('=')[1] print(keyword) # 然后拼接成url url='https://www.baidu.com/s?wd=%s&pn=1' %keyword response=requests.get(url, headers={ 'User-Agent':'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.75 Safari/537.36', }) res1=response.text #2.2params参数的使用 #上述操作可以用requests模块的一个params参数搞定，本质还是调用urlencode from urllib.parse import urlencode wd='egon老师' pn=1 response=requests.get('https://www.baidu.com/s', params={ 'wd':wd, 'pn':pn }, headers={ 'User-Agent':'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.75 Safari/537.36', }) res2=response.text #验证结果，打开a.html与b.html页面内容一样 with open('a.html','w',encoding='utf-8') as f: f.write(res1) with open('b.html', 'w', encoding='utf-8') as f: f.write(res2) #3、带参数的GET请求->headers """ #通常我们在发送请求时都需要带上请求头，请求头是将自身伪装成浏览器的关键，常见的有用的请求头如下 Host Referer #大型网站通常都会根据该参数判断请求的来源 User-Agent #客户端 Cookie #Cookie信息虽然包含在请求头里，但requests模块有单独的参数来处理他，headers={}内就不要放它了 """ #添加headers(浏览器会识别请求头,不加可能会被拒绝访问,比如访问https://www.zhihu.com/explore) import requests response=requests.get('https://www.zhihu.com/explore') response.status_code #500 #自己定制headers headers={ 'User-Agent':'Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2490.76 Mobile Safari/537.36', } respone=requests.get('https://www.zhihu.com/explore', headers=headers) print(respone.status_code) #200 #4、带参数的GET请求->cookies #登录github，然后从浏览器中获取cookies，以后就可以直接拿着cookie登录了，无需输入用户名密码 #用户名:egonlin 邮箱378533872@qq.com 密码lhf@123 import requests Cookies={ 'user_session':'wGMHFJKgDcmRIVvcA14_Wrt_3xaUyJNsBnPbYzEL6L0bHcfc', } response=requests.get('https://github.com/settings/emails', cookies=Cookies) #github对请求头没有什么限制，我们无需定制user-agent，对于其他网站可能还需要定制 print('378533872@qq.com' in response.text) #True
二、基于POST请求
- 数据不会出现在地址栏中
- 数据的大小没有上限
- 有请求体
- 请求体中如果存在中文，会使用URL编码！
- requests.post()用法与requests.get()完全一致，特殊的是requests.post()有一个data参数，用来存放请求体数据
""" 发送post请求，模拟浏览器的登录行为 对于登录来说，应该输错用户名或密码然后分析抓包流程，输对了浏览器就跳转了，就找不到包 自动登录github（自己处理cookie信息） """ ''' 一 目标站点分析 浏览器输入https://github.com/login 然后输入错误的账号密码，抓包 发现登录行为是post提交到：https://github.com/session 而且请求头包含cookie 而且请求体包含： commit:Sign in utf8:... authenticity_token:lbI8IJCwGslZS8qJPnof5e7ZkCoSoMn6jmDTsL1r/m06NLyIbw7vCrpwrFAPzHMep3Tmf/TSJVoXWrvDZaVwxQ== login:egonlin password:123 二 流程分析 先GET：https://github.com/login拿到初始cookie与authenticity_token 返回POST：https://github.com/session， 带上初始cookie，带上请求体（authenticity_token，用户名，密码等） 最后拿到登录cookie ps：如果密码时密文形式，则可以先输错账号，输对密码，然后到浏览器中拿到加密后的密码，github的密码是明文 ''' import requests import re #第一次请求 r1=requests.get('https://github.com/login') r1_cookie=r1.cookies.get_dict() #拿到初始cookie(未被授权) authenticity_token=re.findall(r'name="authenticity_token".*?value="(.*?)"',r1.text)[0] #从页面中拿到CSRF TOKEN #第二次请求：带着初始cookie和TOKEN发送POST请求给登录页面，带上账号密码 data={ 'commit':'Sign in', 'utf8':'?', 'authenticity_token':authenticity_token, 'login':'317828332@qq.com', 'password':'alex3714' } r2=requests.post('https://github.com/session', data=data, cookies=r1_cookie ) login_cookie=r2.cookies.get_dict() #第三次请求：以后的登录，拿着login_cookie就可以,比如访问一些个人配置 r3=requests.get('https://github.com/settings/emails', cookies=login_cookie) print('317828332@qq.com' in r3.text) #True """ #requests.session()自动帮我们保存cookie信息 补充： requests.post(url='xxxxxxxx', data={'xxx':'yyy'}) #没有指定请求头,#默认的请求头:application/x-www-form-urlencoed #如果我们自定义请求头是application/json,并且用data传值, 则服务端取不到值 requests.post(url='', data={'':1,}, headers={ 'content-type':'application/json' }) requests.post(url='', json={'':1,}, ) #默认的请求头:application/json """ import requests import re session=requests.session() #第一次请求 r1=session.get('https://github.com/login') authenticity_token=re.findall(r'name="authenticity_token".*?value="(.*?)"',r1.text)[0] #从页面中拿到CSRF TOKEN #第二次请求 data={ 'commit':'Sign in', 'utf8':'?', 'authenticity_token':authenticity_token, 'login':'317828332@qq.com', 'password':'alex3714' } r2=session.post('https://github.com/session', data=data, ) #第三次请求 r3=session.get('https://github.com/settings/emails') print('317828332@qq.com' in r3.text) #True
三、响应Response
#1、response属性 import requests respone=requests.get('http://www.jianshu.com') # respone属性 print(respone.text) print(respone.content) print(respone.status_code) print(respone.headers) print(respone.cookies) print(respone.cookies.get_dict()) print(respone.cookies.items()) print(respone.url) print(respone.history) print(respone.encoding) #关闭：response.close() from contextlib import closing with closing(requests.get('xxx',stream=True)) as response: for line in response.iter_content(): pass #2、编码问题 import requests response=requests.get('http://www.autohome.com/news') # response.encoding='gbk' #汽车之家网站返回的页面内容为gb2312编码的，而requests的默认编码为ISO-8859-1，如果不设置成gbk则中文乱码 print(response.text) #3、获取二进制数据 import requests response=requests.get('https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1509868306530&di=712e4ef3ab258b36e9f4b48e85a81c9d&imgtype=0&src=http%3A%2F%2Fc.hiphotos.baidu.com%2Fimage%2Fpic%2Fitem%2F11385343fbf2b211e1fb58a1c08065380dd78e0c.jpg') with open('a.jpg','wb') as f: f.write(response.content) #3.1获取二进制流 #stream参数:一点一点的取,比如下载视频时,如果视频100G,用response.content然后一下子写到文件中是不合理的 import requests response=requests.get('https://gss3.baidu.com/6LZ0ej3k1Qd3ote6lo7D0j9wehsv/tieba-smallvideo-transcode/1767502_56ec685f9c7ec542eeaf6eac93a65dc7_6fe25cd1347c_3.mp4', stream=True) with open('b.mp4','wb') as f: for line in response.iter_content(): f.write(line) #4、解析json #解析json import requests response=requests.get('http://httpbin.org/get') import json res1=json.loads(response.text) #太麻烦 res2=response.json() #直接获取json数据 print(res1 == res2) #True #5、Redirection and History #官网的解释
By default Requests will perform location redirection for all verbs except HEAD. We can use the history property of the Response object to track redirection. The Response.history list contains the Response objects that were created in order to complete the request. The list is sorted from the oldest to the most recent response. For example, GitHub redirects all HTTP requests to HTTPS: >>> r = requests.get('http://github.com') >>> r.url 'https://github.com/' >>> r.status_code 200 >>> r.history [<Response [301]>] If you're using GET, OPTIONS, POST, PUT, PATCH or DELETE, you can disable redirection handling with the allow_redirects parameter: >>> r = requests.get('http://github.com', allow_redirects=False) >>> r.status_code 301 >>> r.history [] If you're using HEAD, you can enable redirection as well: >>> r = requests.head('http://github.com', allow_redirects=True) >>> r.url 'https://github.com/' >>> r.history [<Response [301]>]
import requests import re #第一次请求 r1=requests.get('https://github.com/login') r1_cookie=r1.cookies.get_dict() #拿到初始cookie(未被授权) authenticity_token=re.findall(r'name="authenticity_token".*?value="(.*?)"',r1.text)[0] #从页面中拿到CSRF TOKEN #第二次请求：带着初始cookie和TOKEN发送POST请求给登录页面，带上账号密码 data={ 'commit':'Sign in', 'utf8':'?', 'authenticity_token':authenticity_token, 'login':'317828332@qq.com', 'password':'alex3714' } #测试一：没有指定allow_redirects=False,则响应头中出现Location就跳转到新页面，r2代表新页面的response r2=requests.post('https://github.com/session', data=data, cookies=r1_cookie ) print(r2.status_code) #200 print(r2.url) #看到的是跳转后的页面 print(r2.history) #看到的是跳转前的response print(r2.history[0].text) #看到的是跳转前的response.text #测试二：指定allow_redirects=False,则响应头中即便出现Location也不会跳转到新页面，r2代表的仍然是老页面的response r2=requests.post('https://github.com/session', data=data, cookies=r1_cookie, allow_redirects=False ) print(r2.status_code) #302 print(r2.url) #看到的是跳转前的页面https://github.com/session print(r2.history) #[] 利用github登录后跳转到主页面的例子来验证它
四、高级用法
#1、SSL Cert Verification #证书验证(大部分网站都是https) import requests respone=requests.get('https://www.12306.cn') #如果是ssl请求,首先检查证书是否合法,不合法则报错,程序终端 #改进1:去掉报错,但是会报警告 import requests respone=requests.get('https://www.12306.cn',verify=False) #不验证证书,报警告,返回200 print(respone.status_code) #改进2:去掉报错,并且去掉警报信息 import requests from requests.packages import urllib3 urllib3.disable_warnings() #关闭警告 respone=requests.get('https://www.12306.cn',verify=False) print(respone.status_code) #改进3:加上证书 #很多网站都是https,但是不用证书也可以访问,大多数情况都是可以携带也可以不携带证书 #知乎\百度等都是可带可不带 #有硬性要求的,则必须带，比如对于定向的用户,拿到证书后才有权限访问某个特定网站 import requests respone=requests.get('https://www.12306.cn', cert=('/path/server.crt', '/path/key')) print(respone.status_code) #2、使用代理 #官网链接: http://docs.python-requests.org/en/master/user/advanced/#proxies #代理设置:先发送请求给代理,然后由代理帮忙发送(封ip是常见的事情) import requests proxies={ 'http':'http://egon:123@localhost:9743',#带用户名密码的代理,@符号前是用户名与密码 'http':'http://localhost:9743', 'https':'https://localhost:9743', } respone=requests.get('https://www.12306.cn', proxies=proxies) print(respone.status_code) #支持socks代理,安装:pip install requests[socks] import requests proxies = { 'http': 'socks5://user:pass@host:port', 'https': 'socks5://user:pass@host:port' } respone=requests.get('https://www.12306.cn', proxies=proxies) print(respone.status_code) #3、超时设置 #超时设置 #两种超时:float or tuple #timeout=0.1 #代表接收数据的超时时间 #timeout=(0.1,0.2)#0.1代表链接超时 0.2代表接收数据的超时时间 import requests respone=requests.get('https://www.baidu.com', timeout=0.0001) #4、 认证设置 #官网链接：http://docs.python-requests.org/en/master/user/authentication/ #认证设置:登陆网站是,弹出一个框,要求你输入用户名密码（与alter很类似），此时是无法获取html的 # 但本质原理是拼接成请求头发送 # r.headers['Authorization'] = _basic_auth_str(self.username, self.password) # 一般的网站都不用默认的加密方式，都是自己写 # 那么我们就需要按照网站的加密方式，自己写一个类似于_basic_auth_str的方法 # 得到加密字符串后添加到请求头 # r.headers['Authorization'] =func('.....') #看一看默认的加密方式吧，通常网站都不会用默认的加密设置 import requests from requests.auth import HTTPBasicAuth r=requests.get('xxx',auth=HTTPBasicAuth('user','password')) print(r.status_code) #HTTPBasicAuth可以简写为如下格式 import requests r=requests.get('xxx',auth=('user','password')) print(r.status_code) #5、异常处理 #异常处理 import requests from requests.exceptions import * #可以查看requests.exceptions获取异常类型 try: r=requests.get('http://www.baidu.com',timeout=0.00001) except ReadTimeout: print('===:') # except ConnectionError: #网络不通 # print('-----') # except Timeout: # print('aaaaa') except RequestException: print('Error') #6、上传文件 import requests files={'file':open('a.jpg','rb')} respone=requests.post('http://httpbin.org/post',files=files) print(respone.status_code)
selenium
- 官网点击
- selenium最初是一个自动化测试工具,而爬虫中使用它主要是为了解决requests无法直接执行JavaScript代码的问题
- selenium本质是通过驱动浏览器，完全模拟浏览器的操作，比如跳转、输入、点击、下拉等，来拿到网页渲染之后的结果，可支持多种浏览器
- PhantomJS是一款无界面的浏览器，其自动化操作流程和上述操作谷歌浏览器是一致的。由于是无界面的，为了能够展示自动化操作流程，PhantomJS为用户提供了一个截屏的功能，使用save_screenshot函数实现。
- selenium+phantomjs 就是爬虫终极解决方案:有些网站上的内容信息是通过动态加载js形成的，所以使用普通爬虫程序无法回去动态加载的js内容。
- 由于PhantomJs最近已经停止了更新和维护，所以推荐大家可以使用谷歌的无头浏览器，是一款无界面的谷歌浏览器。
一、环境搭建
- 安装selenium：pip install selenium
- 获取某一款浏览器的驱动程序（以谷歌浏览器为例）谷歌浏览器驱动下载地址：http://chromedriver.storage.googleapis.com/index.html
- 下载的驱动程序必须和浏览器的版本统一，大家可以根据http://blog.csdn.net/huilan_same/article/details/51896672中提供的版本映射表进行对应
""" selenium模块的基本使用 问题：selenium模块和爬虫之间具有怎样的关联？ - 便捷的获取网站中动态加载的数据 - 便捷实现模拟登录 什么是selenium模块？ - 基于浏览器自动化的一个模块。 selenium使用流程： - 环境安装：pip install selenium - 下载一个浏览器的驱动程序（谷歌浏览器） - 下载路径：http://chromedriver.storage.googleapis.com/index.html - 驱动程序和浏览器的映射关系：http://blog.csdn.net/huilan_same/article/details/51896672 - 实例化一个浏览器对象 - 编写基于浏览器自动化的操作代码 - 发起请求：get(url) - 标签定位：find系列的方法 - 标签交互：send_keys('xxx') - 执行js程序：excute_script('jsCode') - 前进，后退：back(),forward() - 关闭浏览器：quit() - selenium处理iframe - 如果定位的标签存在于iframe标签之中，则必须使用switch_to.frame(id) - 动作链（拖动）：from selenium.webdriver import ActionChains - 实例化一个动作链对象：action = ActionChains(bro) - click_and_hold（div）：长按且点击操作 - move_by_offset(x,y) - perform()让动作链立即执行 - action.release()释放动作链对象 12306模拟登录 - 超级鹰：http://www.chaojiying.com/about.html - 注册：普通用户 - 登录：普通用户 - 题分查询：充值 - 创建一个软件（id） - 下载示例代码 - 12306模拟登录编码流程： - 使用selenium打开登录页面 - 对当前selenium打开的这张页面进行截图 - 对当前图片局部区域（验证码图片）进行裁剪 - 好处：将验证码图片和模拟登录进行一一对应。 - 使用超级鹰识别验证码图片（坐标） - 使用动作链根据坐标实现点击操作 - 录入用户名密码，点击登录按钮实现登录 """ ################################################################ from selenium import webdriver from time import sleep # 后面是你的浏览器驱动位置，记得前面加r'','r'是防止字符转义的 driver = webdriver.Chrome(r'./chromedriver.exe') # 用get打开百度页面 driver.get("http://www.baidu.com") # 查找页面的“设置”选项，并进行点击 driver.find_elements_by_link_text('设置')[0].click() sleep(10) # # 打开设置后找到“搜索设置”选项，设置为每页显示50条 driver.find_elements_by_link_text('搜索设置')[0].click() sleep(10) # 选中每页显示50条 m = driver.find_element_by_id('nr') sleep(10) m.find_element_by_xpath('//*[@id="nr"]/option[3]').click() m.find_element_by_xpath('.//option[3]').click() sleep(10) # 点击保存设置 driver.find_elements_by_class_name("prefpanelgo")[0].click() sleep(10) # 处理弹出的警告页面 确定accept() 和 取消dismiss() driver.switch_to_alert().accept() sleep(10) # 找到百度的输入框，并输入 美女 driver.find_element_by_id('kw').send_keys('美女') sleep(10) # 点击搜索按钮 driver.find_element_by_id('su').click() sleep(10) # 在打开的页面中找到“Selenium - 开源中国社区”，并打开这个页面 driver.find_elements_by_link_text('美女_百度图片')[0].click() sleep(10) # 关闭浏览器 driver.quit() ################################################################ from selenium import webdriver from lxml import etree from time import sleep #实例化一个浏览器对象（传入浏览器的驱动成） bro = webdriver.Chrome(executable_path='./chromedriver.exe') #让浏览器发起一个指定url对应请求 bro.get('http://125.35.6.84:81/xk/') #page_source获取浏览器当前页面的页面源码数据 page_text = bro.page_source #解析企业名称 tree = etree.HTML(page_text) li_list = tree.xpath('//ul[@id="gzlist"]/li') for li in li_list: name = li.xpath('./dl/@title')[0] print(name) sleep(5) bro.quit() ################################################################ from selenium import webdriver from time import sleep bro = webdriver.Chrome(executable_path='./chromedriver.exe') bro.get('https://www.taobao.com/') #标签定位 search_input = bro.find_element_by_id('q') #标签交互 search_input.send_keys('Iphone') #执行一组js程序 bro.execute_script('window.scrollTo(0,document.body.scrollHeight)') sleep(2) #点击搜索按钮 btn = bro.find_element_by_css_selector('.btn-search') btn.click() bro.get('https://www.baidu.com') sleep(2) #回退 bro.back() sleep(2) #前进 bro.forward() sleep(5) #退出 bro.quit() #############################动作链和iframe的处理################################### from selenium import webdriver from time import sleep #导入动作链对应的类 from selenium.webdriver import ActionChains bro = webdriver.Chrome(executable_path='./chromedriver') bro.get('https://www.runoob.com/try/try.php?filename=jqueryui-api-droppable') #如果定位的标签是存在于iframe标签之中的则必须通过如下操作在进行标签定位 bro.switch_to.frame('iframeResult')#切换浏览器标签定位的作用域 div = bro.find_element_by_id('draggable') #动作链 action = ActionChains(bro) #点击长按指定的标签 action.click_and_hold(div) for i in range(5): #perform()立即执行动作链操作 #move_by_offset(x,y):x水平方向 y竖直方向 action.move_by_offset(17,0).perform() sleep(0.5) #释放动作链 action.release() bro.quit() #############################模拟登录qq空间################################### from selenium import webdriver from time import sleep bro = webdriver.Chrome(executable_path='./chromedriver') bro.get('https://qzone.qq.com/') bro.switch_to.frame('login_frame') a_tag = bro.find_element_by_id("switcher_plogin") a_tag.click() userName_tag = bro.find_element_by_id('u') password_tag = bro.find_element_by_id('p') sleep(1) userName_tag.send_keys('328410948') sleep(1) password_tag.send_keys('123456789') sleep(1) btn = bro.find_element_by_id('login_button') btn.click() sleep(3) bro.quit() ############################谷歌无头浏览器+反检测##################################### from selenium import webdriver from time import sleep #实现无可视化界面 from selenium.webdriver.chrome.options import Options #实现规避检测 from selenium.webdriver import ChromeOptions #实现无可视化界面的操作 chrome_options = Options() chrome_options.add_argument('--headless') chrome_options.add_argument('--disable-gpu') #实现规避检测 option = ChromeOptions() option.add_experimental_option('excludeSwitches', ['enable-automation']) #如何实现让selenium规避被检测到的风险 bro = webdriver.Chrome(executable_path='./chromedriver',chrome_options=chrome_options,options=option) #无可视化界面（无头浏览器） phantomJs bro.get('https://www.baidu.com') print(bro.page_source) sleep(2) bro.quit()
#下述代码为超级鹰提供的示例代码 import requests from hashlib import md5 class Chaojiying_Client(object): def __init__(self, username, password, soft_id): self.username = username password = password.encode('utf8') self.password = md5(password).hexdigest() self.soft_id = soft_id self.base_params = { 'user': self.username, 'pass2': self.password, 'softid': self.soft_id, } self.headers = { 'Connection': 'Keep-Alive', 'User-Agent': 'Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.1; Trident/4.0)', } def PostPic(self, im, codetype): """ im: 图片字节 codetype: 题目类型 参考 http://www.chaojiying.com/price.html """ params = { 'codetype': codetype, } params.update(self.base_params) files = {'userfile': ('ccc.jpg', im)} r = requests.post('http://upload.chaojiying.net/Upload/Processing.php', data=params, files=files, headers=self.headers) return r.json() def ReportError(self, im_id): """ im_id:报错题目的图片ID """ params = { 'id': im_id, } params.update(self.base_params) r = requests.post('http://upload.chaojiying.net/Upload/ReportError.php', data=params, headers=self.headers) return r.json() # chaojiying = Chaojiying_Client('bobo328410948', 'bobo328410948', '899370') #用户中心>>软件ID 生成一个替换 96001 # im = open('12306.jpg', 'rb').read() #本地图片文件路径 来替换 a.jpg 有时WIN系统须要// # print(chaojiying.PostPic(im, 9004)['pic_str']) #上述代码为超级鹰提供的示例代码 #使用selenium打开登录页面 from selenium import webdriver import time from PIL import Image from selenium.webdriver import ActionChains bro = webdriver.Chrome(executable_path='./chromedriver') bro.get('https://kyfw.12306.cn/otn/login/init') time.sleep(1) #save_screenshot就是将当前页面进行截图且保存 bro.save_screenshot('aa.png') #确定验证码图片对应的左上角和右下角的坐标（裁剪的区域就确定） code_img_ele = bro.find_element_by_xpath('//*[@id="loginForm"]/div/ul[2]/li[4]/div/div/div[3]/img') location = code_img_ele.location # 验证码图片左上角的坐标 x,y print('location:',location) size = code_img_ele.size #验证码标签对应的长和宽 print('size:',size) #左上角和右下角坐标 rangle = ( int(location['x']), int(location['y']), int(location['x'] + size['width']), int(location['y'] + size['height'])) #至此验证码图片区域就确定下来了 i = Image.open('./aa.png') code_img_name = './code.png' #crop根据指定区域进行图片裁剪 frame = i.crop(rangle) frame.save(code_img_name) #将验证码图片提交给超级鹰进行识别 chaojiying = Chaojiying_Client('bobo328410948', 'bobo328410948', '899370') #用户中心>>软件ID 生成一个替换 96001 im = open('code.png', 'rb').read() #本地图片文件路径 来替换 a.jpg 有时WIN系统须要// print(chaojiying.PostPic(im, 9004)['pic_str']) result = chaojiying.PostPic(im, 9004)['pic_str'] all_list = [] #要存储即将被点击的点的坐标 [[x1,y1],[x2,y2]] if '|' in result: list_1 = result.split('|') count_1 = len(list_1) for i in range(count_1): xy_list = [] x = int(list_1[i].split(',')[0]) y = int(list_1[i].split(',')[1]) xy_list.append(x) xy_list.append(y) all_list.append(xy_list) else: x = int(result.split(',')[0]) y = int(result.split(',')[1]) xy_list = [] xy_list.append(x) xy_list.append(y) all_list.append(xy_list) print(all_list) #遍历列表，使用动作链对每一个列表元素对应的x,y指定的位置进行点击操作 for l in all_list: x = l[0] y = l[1] ActionChains(bro).move_to_element_with_offset(code_img_ele, x, y).click().perform() time.sleep(0.5) bro.find_element_by_id('username').send_keys('www.zhangbowudi@qq.com') time.sleep(2) bro.find_element_by_id('password').send_keys('bobo_15027900535') time.sleep(2) bro.find_element_by_id('loginSub').click() time.sleep(30) bro.quit()
二、图片懒加载
- 图片懒加载是一种网页优化技术。图片作为一种网络资源，在被请求时也与普通静态资源一样，将占用网络资源，而一次性将整个页面的所有图片加载完，将大大增加页面的首屏加载时间。为了解决这种问题，通过前后端配合，使图片仅在浏览器当前视窗内出现时才加载该图片，达到减少首屏图片请求数的技术就被称为“图片懒加载”。
- 在网页源码中，在img标签中首先会使用一个“伪属性”（通常使用src2，original......）去存放真正的图片链接而并非是直接存放在src属性中。当图片出现到页面的可视化区域中，会动态将伪属性替换成src属性，完成图片的加载。
#站长素材案例后续分析：通过细致观察页面的结构后发现，网页中图片的链接是存储在了src2这个伪属性中 import requests from lxml import etree if __name__ == "__main__": url = 'http://sc.chinaz.com/tupian/gudianmeinvtupian.html' headers = { 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36', } #获取页面文本数据 response = requests.get(url=url,headers=headers) response.encoding = 'utf-8' page_text = response.text #解析页面数据（获取页面中的图片链接） #创建etree对象 tree = etree.HTML(page_text) div_list = tree.xpath('//div[@id="container"]/div') #解析获取图片地址和图片的名称 for div in div_list: image_url = div.xpath('.//img/@src2') #src2伪属性 image_name = div.xpath('.//img/@alt') print(image_url) #打印图片链接 print(image_name)#打印图片名称 """ 1、有界面浏览器 selenium+chromedriver #安装：selenium+chromedriver pip3 install selenium 下载chromdriver.exe放到python安装路径的scripts目录中即可，注意最新版本是2.38，并非2.9 国内镜像网站地址：http://npm.taobao.org/mirrors/chromedriver/2.38/ 最新的版本去官网找:https://sites.google.com/a/chromium.org/chromedriver/downloads #验证安装 C:\Users\Administrator>python3 Python 3.6.1 (v3.6.1:69c0db5, Mar 21 2017, 18:41:36) [MSC v.1900 64 bit (AMD64)] on win32 Type "help", "copyright", "credits" or "license" for more information. >>> from selenium import webdriver >>> driver=webdriver.Chrome() #弹出浏览器 >>> driver.get('https://www.baidu.com') >>> driver.page_source #注意： selenium3默认支持的webdriver是Firfox，而Firefox需要安装geckodriver 下载链接：https://github.com/mozilla/geckodriver/releases """ """ 2、无界面浏览器selenium+phantomjs PhantomJS不再更新 在 PhantomJS 年久失修, 后继无人的节骨眼 Chrome 出来救场, 再次成为了反爬虫 Team 的噩梦 自Google 发布 chrome 59 / 60 正式版 开始便支持Headless mode 这意味着在无 GUI 环境下, PhantomJS 不再是唯一选择 #安装：selenium+phantomjs pip3 install selenium 下载phantomjs，解压后把phantomjs.exe所在的bin目录放到环境变量 下载链接：http://phantomjs.org/download.html #验证安装 C:\Users\Administrator>phantomjs phantomjs> console.log('egon gaga') egon gaga undefined phantomjs> ^C C:\Users\Administrator>python3 Python 3.6.1 (v3.6.1:69c0db5, Mar 21 2017, 18:41:36) [MSC v.1900 64 bit (AMD64)] on win32 Type "help", "copyright", "credits" or "license" for more information. >>> from selenium import webdriver >>> driver=webdriver.PhantomJS() #无界面浏览器 >>> driver.get('https://www.baidu.com') >>> driver.page_source """ """ selenium+谷歌浏览器headless模式 #selenium:3.12.0 #webdriver:2.38 #chrome.exe: 65.0.3325.181（正式版本） （32 位） from selenium import webdriver from selenium.webdriver.chrome.options import Options chrome_options = Options() chrome_options.add_argument('window-size=1920x3000') #指定浏览器分辨率 chrome_options.add_argument('--disable-gpu') #谷歌文档提到需要加上这个属性来规避bug chrome_options.add_argument('--hide-scrollbars') #隐藏滚动条, 应对一些特殊页面 chrome_options.add_argument('blink-settings=imagesEnabled=false') #不加载图片, 提升速度 chrome_options.add_argument('--headless') #浏览器不提供可视化页面. linux下如果系统不支持可视化不加这条会启动失败 chrome_options.binary_location = r"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe" #手动指定使用的浏览器位置 driver=webdriver.Chrome(chrome_options=chrome_options) driver.get('https://www.baidu.com') print('hao123' in driver.page_source) driver.close() #切记关闭浏览器，回收资源 """ ################################################### """ 浏览器对象 from selenium import webdriver browser=webdriver.Chrome() browser=webdriver.Firefox() browser=webdriver.PhantomJS() browser=webdriver.Safari() browser=webdriver.Edge() 问题：处理页面动态加载数据的爬取 1.selenium 2.phantomJs 1.selenum：三方库。可以实现让浏览器完成自动化的操作。 2.环境搭建 2.1 安装：pip install selenium 2.2 获取浏览器的驱动程序 下载地址：http://chromedriver.storage.googleapis.com/index.html 浏览器版本和驱动版本的对应关系表： https://blog.csdn.net/huilan_same/article/details/51896672 #使用下面的方法，查找指定的元素进行操作即可 find_element_by_id 根据id找节点 find_elements_by_name 根据name找 find_elements_by_xpath 根据xpath查找 find_elements_by_tag_name 根据标签名找 find_elements_by_class_name 根据class名字查找 """ """ phantomJs：无界面浏览器。其自动化流程上述操作谷歌自动化流程一致。 """ from selenium import webdriver bro = webdriver.PhantomJS(executable_path='/Users/bobo/Desktop/phantomjs-2.1.1-macosx/bin/phantomjs') #打开浏览器 bro.get('https://www.baidu.com') #截屏 bro.save_screenshot('./1.png') text = bro.find_element_by_id('kw')#定位到了text文本框 text.send_keys('人民币') #send_keys表示向文本框中录入指定内容 bro.save_screenshot('./2.png') bro.quit() """ 使用selenium+phantomJs处理页面动态加载数据的爬取 需求：获取豆瓣电影中动态加载出更多电影详情数据 """ from selenium import webdriver from time import sleep bro = webdriver.PhantomJS(executable_path='/Users/bobo/Desktop/phantomjs-2.1.1-macosx/bin/phantomjs') url = 'https://movie.douban.com/typerank?type_name=%E5%96%9C%E5%89%A7&type=24&interval_id=100:90&action=' bro.get(url) sleep(1) #截屏 bro.save_screenshot('./1.png') #编写js代码：让页面中的滚轮向下滑动（底部） js = 'window.scrollTo(0,document.body.scrollHeight)' #如何让浏览器对象执行js代码 bro.execute_script(js) sleep(1) #截屏 bro.save_screenshot('./2.png') bro.execute_script(js) bro.save_screenshot('./3.png') #获取加载数据后的页面:page_sourse获取浏览器当前的页面数据 page_text = bro.page_source print(page_text) bro.quit() ################################################## from selenium import webdriver from selenium.webdriver import ActionChains from selenium.webdriver.common.by import By #按照什么方式查找，By.ID,By.CSS_SELECTOR from selenium.webdriver.common.keys import Keys #键盘按键操作 from selenium.webdriver.support import expected_conditions as EC from selenium.webdriver.support.wait import WebDriverWait #等待页面加载某些元素 browser=webdriver.Chrome() try: browser.get('https://www.baidu.com') input_tag=browser.find_element_by_id('kw') input_tag.send_keys('美女') #python2中输入中文错误，字符串前加个u input_tag.send_keys(Keys.ENTER) #输入回车 wait=WebDriverWait(browser,10) wait.until(EC.presence_of_element_located((By.ID,'content_left'))) #等到id为content_left的元素加载完毕,最多等10秒 print(browser.page_source) print(browser.current_url) print(browser.get_cookies()) finally: browser.close()
""" 浏览器创建 Selenium支持非常多的浏览器，如Chrome、Firefox、Edge等，还有Android、BlackBerry等手机端的浏览器。另外，也支持无界面浏览器PhantomJS。 from selenium import webdriver browser = webdriver.Chrome() browser = webdriver.Firefox() browser = webdriver.Edge() browser = webdriver.PhantomJS() browser = webdriver.Safari() 元素定位 webdriver 提供了一系列的元素定位方法，常用的有以下几种： find_element_by_id() find_element_by_name() find_element_by_class_name() find_element_by_tag_name() find_element_by_link_text() find_element_by_partial_link_text() find_element_by_xpath() find_element_by_css_selector() 注意 1、find_element_by_xxx找的是第一个符合条件的标签，find_elements_by_xxx找的是所有符合条件的标签。 2、根据ID、CSS选择器和XPath获取，它们返回的结果完全一致。 3、另外，Selenium还提供了通用方法find_element()，它需要传入两个参数：查找方式By和值。实际上，它就是find_element_by_id() 这种方法的通用函数版本，比如find_element_by_id(id)就等价于find_element(By.ID, id)，二者得到的结果完全一致。 节点交互 Selenium可以驱动浏览器来执行一些操作，也就是说可以让浏览器模拟执行一些动作。比较常见的用法有：输入文字时用send_keys()方法， 清空文字时用clear()方法，点击按钮时用click()方法。示例如下： from selenium import webdriver import time browser = webdriver.Chrome() browser.get('https://www.taobao.com') input = browser.find_element_by_id('q') input.send_keys('MAC') time.sleep(1) input.clear() input.send_keys('IPhone') button = browser.find_element_by_class_name('btn-search') button.click() browser.quit() 动作链 在上面的实例中，一些交互动作都是针对某个节点执行的。比如，对于输入框，我们就调用它的输入文字和清空文字方法；对于按钮，就调用它的点击方法。 其实，还有另外一些操作，它们没有特定的执行对象，比如鼠标拖曳、键盘按键等，这些动作用另一种方式来执行，那就是动作链。 比如，现在实现一个节点的拖曳操作，将某个节点从一处拖曳到另外一处，可以这样实现： from selenium import webdriver from selenium.webdriver import ActionChains import time browser = webdriver.Chrome() url = 'http://www.runoob.com/try/try.php?filename=jqueryui-api-droppable' browser.get(url) browser.switch_to.frame('iframeResult') source = browser.find_element_by_css_selector('#draggable') target = browser.find_element_by_css_selector('#droppable') actions = ActionChains(browser) # actions.drag_and_drop(source, target) # actions.perform() #执行动作链 actions.click_and_hold(source) time.sleep(3) for i in range(5): actions.move_by_offset(xoffset=17,yoffset=0).perform() time.sleep(0.5) actions.release() 执行JavaScript 对于某些操作，Selenium API并没有提供。比如，下拉进度条，它可以直接模拟运行JavaScript，此时使用execute_script()方法即可实现，代码如下： from selenium import webdriver browser = webdriver.Chrome() browser.get('https://www.jd.com/') browser.execute_script('window.scrollTo(0, document.body.scrollHeight)') browser.execute_script('alert("123")') 获取页面源码数据 通过page_source属性可以获取网页的源代码，接着就可以使用解析库（如正则表达式、Beautiful Soup、pyquery等）来提取信息了。 前进和后退 #模拟浏览器的前进后退 import time from selenium import webdriver browser=webdriver.Chrome() browser.get('https://www.baidu.com') browser.get('https://www.taobao.com') browser.get('http://www.sina.com.cn/') browser.back() time.sleep(10) browser.forward() browser.close() Cookie处理 使用Selenium，还可以方便地对Cookies进行操作，例如获取、添加、删除Cookies等。示例如下： from selenium import webdriver browser = webdriver.Chrome() browser.get('https://www.zhihu.com/explore') print(browser.get_cookies()) browser.add_cookie({'name': 'name', 'domain': 'www.zhihu.com', 'value': 'germey'}) print(browser.get_cookies()) browser.delete_all_cookies() print(browser.get_cookies()) 异常处理 from selenium import webdriver from selenium.common.exceptions import TimeoutException,NoSuchElementException,NoSuchFrameException try: browser=webdriver.Chrome() browser.get('http://www.runoob.com/try/try.php?filename=jqueryui-api-droppable') browser.switch_to.frame('iframssseResult') except TimeoutException as e: print(e) except NoSuchFrameException as e: print(e) finally: browser.close() phantomJS PhantomJS是一款无界面的浏览器，其自动化操作流程和上述操作谷歌浏览器是一致的。由于是无界面的，为了能够展示自动化操作流程， PhantomJS为用户提供了一个截屏的功能，使用save_screenshot函数实现。 from selenium import webdriver import time # phantomjs路径 path = r'PhantomJS驱动路径' browser = webdriver.PhantomJS(path) # 打开百度 url = 'http://www.baidu.com/' browser.get(url) time.sleep(3) browser.save_screenshot(r'phantomjs\baidu.png') # 查找input输入框 my_input = browser.find_element_by_id('kw') # 往框里面写文字 my_input.send_keys('美女') time.sleep(3) #截屏 browser.save_screenshot(r'phantomjs\meinv.png') # 查找搜索按钮 button = browser.find_elements_by_class_name('s_btn')[0] button.click() time.sleep(3) browser.save_screenshot(r'phantomjs\show.png') time.sleep(3) browser.quit() 谷歌无头浏览器 由于PhantomJs最近已经停止了更新和维护，所以推荐大家可以使用谷歌的无头浏览器，是一款无界面的谷歌浏览器。 from selenium import webdriver from selenium.webdriver.chrome.options import Options import time # 创建一个参数对象，用来控制chrome以无界面模式打开 chrome_options = Options() chrome_options.add_argument('--headless') chrome_options.add_argument('--disable-gpu') # 驱动路径 path = r'C:\Users\ZBLi\Desktop\1801\day05\ziliao\chromedriver.exe' # 创建浏览器对象 browser = webdriver.Chrome(executable_path=path, chrome_options=chrome_options) # 上网 url = 'http://www.baidu.com/' browser.get(url) time.sleep(3) browser.save_screenshot('baidu.png') browser.quit() 登录qq空间，爬取数据 import requests from selenium import webdriver from lxml import etree import time driver = webdriver.Chrome(executable_path='/Users/bobo/Desktop/chromedriver') driver.get('https://qzone.qq.com/') #在web 应用中经常会遇到frame 嵌套页面的应用，使用WebDriver 每次只能在一个页面上识别元素，对于frame 嵌套内的页面上的元素， 直接定位是定位是定位不到的。这个时候就需要通过switch_to_frame()方法将当前定位的主体切换了frame 里。 driver.switch_to.frame('login_frame') driver.find_element_by_id('switcher_plogin').click() #driver.find_element_by_id('u').clear() driver.find_element_by_id('u').send_keys('328410948') #这里填写你的QQ号 #driver.find_element_by_id('p').clear() driver.find_element_by_id('p').send_keys('xxxxxx') #这里填写你的QQ密码 driver.find_element_by_id('login_button').click() time.sleep(2) driver.execute_script('window.scrollTo(0,document.body.scrollHeight)') time.sleep(2) driver.execute_script('window.scrollTo(0,document.body.scrollHeight)') time.sleep(2) driver.execute_script('window.scrollTo(0,document.body.scrollHeight)') time.sleep(2) page_text = driver.page_source tree = etree.HTML(page_text) #执行解析操作 li_list = tree.xpath('//ul[@id="feed_friend_list"]/li') for li in li_list: text_list = li.xpath('.//div[@class="f-info"]//text()|.//div[@class="f-info qz_info_cut"]//text()') text = ''.join(text_list) print(text+'\n\n\n') driver.close() 尽可能多的爬取豆瓣网中的电影信息 from selenium import webdriver from time import sleep import time if __name__ == '__main__': url = 'https://movie.douban.com/typerank?type_name=%E6%81%90%E6%80%96&type=20&interval_id=100:90&action=' # 发起请求前，可以让url表示的页面动态加载出更多的数据 path = r'C:\Users\Administrator\Desktop\爬虫授课\day05\ziliao\phantomjs-2.1.1-windows\bin\phantomjs.exe' # 创建无界面的浏览器对象 bro = webdriver.PhantomJS(path) # 发起url请求 bro.get(url) time.sleep(3) # 截图 bro.save_screenshot('1.png') # 执行js代码（让滚动条向下偏移n个像素（作用：动态加载了更多的电影信息）） js = 'window.scrollTo(0,document.body.scrollHeight)' bro.execute_script(js) # 该函数可以执行一组字符串形式的js代码 time.sleep(2) bro.execute_script(js) # 该函数可以执行一组字符串形式的js代码 time.sleep(2) bro.save_screenshot('2.png') time.sleep(2) # 使用爬虫程序爬去当前url中的内容 html_source = bro.page_source # 该属性可以获取当前浏览器的当前页的源码（html） with open('./source.html', 'w', encoding='utf-8') as fp: fp.write(html_source) bro.quit() selenium规避被检测识别 现在不少大网站有对selenium采取了监测机制。比如正常情况下我们用浏览器访问淘宝等网站的 window.navigator.webdriver的值为 undefined。而使用selenium访问则该值为true。那么如何解决这个问题呢？ 只需要设置Chromedriver的启动参数即可解决问题。在启动Chromedriver之前，为Chrome开启实验性功能参数excludeSwitches， 它的值为['enable-automation']，完整代码如下： from selenium.webdriver import Chrome from selenium.webdriver import ChromeOptions option = ChromeOptions() option.add_experimental_option('excludeSwitches', ['enable-automation']) driver = Chrome(options=option) """ ###############选择器#########基本用法 #官网链接：http://selenium-python.readthedocs.io/locating-elements.html from selenium import webdriver from selenium.webdriver import ActionChains from selenium.webdriver.common.by import By #按照什么方式查找，By.ID,By.CSS_SELECTOR from selenium.webdriver.common.keys import Keys #键盘按键操作 from selenium.webdriver.support import expected_conditions as EC from selenium.webdriver.support.wait import WebDriverWait #等待页面加载某些元素 import time driver=webdriver.Chrome() driver.get('https://www.baidu.com') wait=WebDriverWait(driver,10) try: #===============所有方法=================== # 1、find_element_by_id # 2、find_element_by_link_text # 3、find_element_by_partial_link_text # 4、find_element_by_tag_name # 5、find_element_by_class_name # 6、find_element_by_name # 7、find_element_by_css_selector # 8、find_element_by_xpath # 强调： # 1、上述均可以改写成find_element(By.ID,'kw')的形式 # 2、find_elements_by_xxx的形式是查找到多个元素，结果为列表 #===============示范用法=================== # 1、find_element_by_id print(driver.find_element_by_id('kw')) # 2、find_element_by_link_text # login=driver.find_element_by_link_text('登录') # login.click() # 3、find_element_by_partial_link_text login=driver.find_elements_by_partial_link_text('录')[0] login.click() # 4、find_element_by_tag_name print(driver.find_element_by_tag_name('a')) # 5、find_element_by_class_name button=wait.until(EC.element_to_be_clickable((By.CLASS_NAME,'tang-pass-footerBarULogin'))) button.click() # 6、find_element_by_name input_user=wait.until(EC.presence_of_element_located((By.NAME,'userName'))) input_pwd=wait.until(EC.presence_of_element_located((By.NAME,'password'))) commit=wait.until(EC.element_to_be_clickable((By.ID,'TANGRAM__PSP_10__submit'))) input_user.send_keys('18611453110') input_pwd.send_keys('xxxxxx') commit.click() # 7、find_element_by_css_selector driver.find_element_by_css_selector('#kw') # 8、find_element_by_xpath time.sleep(5) finally: driver.close() ###############选择器#########xpath # 官网链接：http://selenium-python.readthedocs.io/locating-elements.html from selenium import webdriver from selenium.webdriver import ActionChains from selenium.webdriver.common.by import By # 按照什么方式查找，By.ID,By.CSS_SELECTOR from selenium.webdriver.common.keys import Keys # 键盘按键操作 from selenium.webdriver.support import expected_conditions as EC from selenium.webdriver.support.wait import WebDriverWait # 等待页面加载某些元素 import time driver = webdriver.PhantomJS() driver.get('https://doc.scrapy.org/en/latest/_static/selectors-sample1.html') # wait=WebDriverWait(driver,3) driver.implicitly_wait(3) # 使用隐式等待 try: # find_element_by_xpath # //与/ # driver.find_element_by_xpath('//body/a') # 开头的//代表从整篇文档中寻找,body之后的/代表body的儿子，这一行找不到就会报错了 driver.find_element_by_xpath('//body//a') # 开头的//代表从整篇文档中寻找,body之后的//代表body的子子孙孙 driver.find_element_by_css_selector('body a') # 取第n个 res1 = driver.find_elements_by_xpath('//body//a[1]') # 取第一个a标签 print(res1[0].text) # 按照属性查找,下述三者查找效果一样 res1 = driver.find_element_by_xpath('//a[5]') res2 = driver.find_element_by_xpath('//a[@href="image5.html"]') res3 = driver.find_element_by_xpath('//a[contains(@href,"image5")]') # 模糊查找 print('==>', res1.text) print('==>', res2.text) print('==>', res3.text) # 其他 res1 = driver.find_element_by_xpath('/html/body/div/a') print(res1.text) res2 = driver.find_element_by_xpath('//a[img/@src="image3_thumb.jpg"]') # 找到子标签img的src属性为image3_thumb.jpg的a标签 print(res2.tag_name, res2.text) res3 = driver.find_element_by_xpath( "//input[@name='continue'][@type='button']") # 查看属性name为continue且属性type为button的input标签 res4 = driver.find_element_by_xpath("//*[@name='continue'][@type='button']") # 查看属性name为continue且属性type为button的所有标签 time.sleep(5) finally: driver.close() ###############选择器#########获取标签属性 from selenium import webdriver from selenium.webdriver import ActionChains from selenium.webdriver.common.by import By #按照什么方式查找，By.ID,By.CSS_SELECTOR from selenium.webdriver.common.keys import Keys #键盘按键操作 from selenium.webdriver.support import expected_conditions as EC from selenium.webdriver.support.wait import WebDriverWait #等待页面加载某些元素 browser=webdriver.Chrome() browser.get('https://www.amazon.cn/') wait=WebDriverWait(browser,10) wait.until(EC.presence_of_element_located((By.ID,'cc-lm-tcgShowImgContainer'))) tag=browser.find_element(By.CSS_SELECTOR,'#cc-lm-tcgShowImgContainer img') #获取标签属性， print(tag.get_attribute('src')) #获取标签ID，位置，名称，大小（了解） print(tag.id) print(tag.location) print(tag.tag_name) print(tag.size) browser.close() ##################等待元素被加载################## """ #1、selenium只是模拟浏览器的行为，而浏览器解析页面是需要时间的（执行css，js），一些元素可能需要过一段时间才能加载出来，为了保证能查找到元素，必须等待 #2、等待的方式分两种： 隐式等待：在browser.get（'xxx'）前就设置，针对所有元素有效 显式等待：在browser.get（'xxx'）之后设置，只针对某个元素有效 """ #隐式等待 from selenium import webdriver from selenium.webdriver import ActionChains from selenium.webdriver.common.by import By #按照什么方式查找，By.ID,By.CSS_SELECTOR from selenium.webdriver.common.keys import Keys #键盘按键操作 from selenium.webdriver.support import expected_conditions as EC from selenium.webdriver.support.wait import WebDriverWait #等待页面加载某些元素 browser=webdriver.Chrome() #隐式等待:在查找所有元素时，如果尚未被加载，则等10秒 browser.implicitly_wait(10) browser.get('https://www.baidu.com') input_tag=browser.find_element_by_id('kw') input_tag.send_keys('美女') input_tag.send_keys(Keys.ENTER) contents=browser.find_element_by_id('content_left') #没有等待环节而直接查找，找不到则会报错 print(contents) browser.close() #显式等待 from selenium import webdriver from selenium.webdriver import ActionChains from selenium.webdriver.common.by import By #按照什么方式查找，By.ID,By.CSS_SELECTOR from selenium.webdriver.common.keys import Keys #键盘按键操作 from selenium.webdriver.support import expected_conditions as EC from selenium.webdriver.support.wait import WebDriverWait #等待页面加载某些元素 browser=webdriver.Chrome() browser.get('https://www.baidu.com') input_tag=browser.find_element_by_id('kw') input_tag.send_keys('美女') input_tag.send_keys(Keys.ENTER) #显式等待：显式地等待某个元素被加载 wait=WebDriverWait(browser,10) wait.until(EC.presence_of_element_located((By.ID,'content_left'))) contents=browser.find_element(By.CSS_SELECTOR,'#content_left') print(contents) browser.close()
from selenium import webdriver from selenium.webdriver import ActionChains from selenium.webdriver.common.by import By #按照什么方式查找，By.ID,By.CSS_SELECTOR from selenium.webdriver.common.keys import Keys #键盘按键操作 from selenium.webdriver.support import expected_conditions as EC from selenium.webdriver.support.wait import WebDriverWait #等待页面加载某些元素 ############################################################点击，清空 browser=webdriver.Chrome() browser.get('https://www.amazon.cn/') wait=WebDriverWait(browser,10) input_tag=wait.until(EC.presence_of_element_located((By.ID,'twotabsearchtextbox'))) input_tag.send_keys('iphone 8') button=browser.find_element_by_css_selector('#nav-search > form > div.nav-right > div > input') button.click() import time time.sleep(3) input_tag=browser.find_element_by_id('twotabsearchtextbox') input_tag.clear() #清空输入框 input_tag.send_keys('iphone7plus') button=browser.find_element_by_css_selector('#nav-search > form > div.nav-right > div > input') button.click() browser.close() ###########################################################Action Chains driver = webdriver.Chrome() driver.get('http://www.runoob.com/try/try.php?filename=jqueryui-api-droppable') wait=WebDriverWait(driver,3) # driver.implicitly_wait(3) # 使用隐式等待 try: driver.switch_to.frame('iframeResult') ##切换到iframeResult sourse=driver.find_element_by_id('draggable') target=driver.find_element_by_id('droppable') #方式一：基于同一个动作链串行执行 # actions=ActionChains(driver) #拿到动作链对象 # actions.drag_and_drop(sourse,target) #把动作放到动作链中，准备串行执行 # actions.perform() #方式二：不同的动作链，每次移动的位移都不同 ActionChains(driver).click_and_hold(sourse).perform() distance=target.location['x']-sourse.location['x'] track=0 while track < distance: ActionChains(driver).move_by_offset(xoffset=2,yoffset=0).perform() track+=2 ActionChains(driver).release().perform() time.sleep(10) finally: driver.close() ###########################################################自己写JS try: browser=webdriver.Chrome() browser.get('https://www.baidu.com') browser.execute_script('alert("hello world")') #打印警告 finally: browser.close() ###########################################################frame的切换 try: browser=webdriver.Chrome() browser.get('http://www.runoob.com/try/try.php?filename=jqueryui-api-droppable') browser.switch_to.frame('iframeResult') #切换到id为iframeResult的frame tag1=browser.find_element_by_id('droppable') print(tag1) # tag2=browser.find_element_by_id('textareaCode') #报错，在子frame里无法查看到父frame的元素 browser.switch_to.parent_frame() #切回父frame,就可以查找到了 tag2=browser.find_element_by_id('textareaCode') print(tag2) finally: browser.close() ###########################################################模拟浏览器的前进后退 browser=webdriver.Chrome() browser.get('https://www.baidu.com') browser.get('https://www.taobao.com') browser.get('http://www.sina.com.cn/') browser.back() time.sleep(10) browser.forward() browser.close() ###########################################################cookies browser=webdriver.Chrome() browser.get('https://www.zhihu.com/explore') print(browser.get_cookies()) browser.add_cookie({'k1':'xxx','k2':'yyy'}) print(browser.get_cookies()) # browser.delete_all_cookies() ###########################################################切换选项卡 #选项卡管理：切换选项卡，有js的方式windows.open,有windows快捷键：ctrl+t等，最通用的就是js的方式 import time from selenium import webdriver browser=webdriver.Chrome() browser.get('https://www.baidu.com') browser.execute_script('window.open()') print(browser.window_handles) #获取所有的选项卡 browser.switch_to_window(browser.window_handles[1]) browser.get('https://www.taobao.com') time.sleep(10) browser.switch_to_window(browser.window_handles[0]) browser.get('https://www.sina.com.cn') browser.close() ###########################################################异常处理 from selenium import webdriver from selenium.common.exceptions import TimeoutException,NoSuchElementException,NoSuchFrameException try: browser=webdriver.Chrome() browser.get('http://www.runoob.com/try/try.php?filename=jqueryui-api-droppable') browser.switch_to.frame('iframssseResult') except TimeoutException as e: print(e) except NoSuchFrameException as e: print(e) finally: browser.close()
#注意：网站都策略都是在不断变化的，精髓在于学习流程。下述代码生效与2017-11-7，不能保证永久有效 from selenium import webdriver from selenium.webdriver import ActionChains from selenium.webdriver.common.by import By from selenium.webdriver.common.keys import Keys from selenium.webdriver.support import expected_conditions as EC from selenium.webdriver.support.wait import WebDriverWait browser=webdriver.Chrome() try: browser.get('http://mail.163.com/') wait=WebDriverWait(browser,5) frame=wait.until(EC.presence_of_element_located((By.ID,'x-URS-iframe'))) browser.switch_to.frame(frame) wait.until(EC.presence_of_element_located((By.CSS_SELECTOR,'.m-container'))) inp_user=browser.find_element_by_name('email') inp_pwd=browser.find_element_by_name('password') button=browser.find_element_by_id('dologin') inp_user.send_keys('18611453110') inp_pwd.send_keys('xxxx') button.click() #如果遇到验证码，可以把下面一小段打开注释 # import time # time.sleep(10) # button = browser.find_element_by_id('dologin') # button.click() wait.until(EC.presence_of_element_located((By.ID,'dvNavTop'))) write_msg=browser.find_elements_by_css_selector('#dvNavTop li')[1] #获取第二个li标签就是“写信”了 write_msg.click() wait.until(EC.presence_of_element_located((By.CLASS_NAME,'tH0'))) recv_man=browser.find_element_by_class_name('nui-editableAddr-ipt') title=browser.find_element_by_css_selector('.dG0 .nui-ipt-input') recv_man.send_keys('378533872@qq.com') title.send_keys('圣旨') print(title.tag_name) frame=wait.until(EC.presence_of_element_located((By.CLASS_NAME,'APP-editor-iframe'))) browser.switch_to.frame(frame) body=browser.find_element(By.CSS_SELECTOR,'body') body.send_keys('egon很帅，可以加工资了') browser.switch_to.parent_frame() #切回他爹 send_button=browser.find_element_by_class_name('nui-toolbar-item') send_button.click() #可以睡时间久一点别让浏览器关掉，看看发送成功没有 import time time.sleep(10000) except Exception as e: print(e) finally: browser.close()
from selenium import webdriver from selenium.webdriver import ActionChains from selenium.webdriver.common.by import By #按照什么方式查找，By.ID,By.CSS_SELECTOR from selenium.webdriver.common.keys import Keys #键盘按键操作 from selenium.webdriver.support import expected_conditions as EC from selenium.webdriver.support.wait import WebDriverWait #等待页面加载某些元素 import time def get_goods(driver): try: goods=driver.find_elements_by_class_name('gl-item') for good in goods: detail_url=good.find_element_by_tag_name('a').get_attribute('href') p_name=good.find_element_by_css_selector('.p-name em').text.replace('\n','') price=good.find_element_by_css_selector('.p-price i').text p_commit=good.find_element_by_css_selector('.p-commit a').text msg = ''' 商品 : %s 链接 : %s 价钱 ：%s 评论 ：%s ''' % (p_name,detail_url,price,p_commit) print(msg,end='\n\n') button=driver.find_element_by_partial_link_text('下一页') button.click() time.sleep(1) get_goods(driver) except Exception: pass def spider(url,keyword): driver = webdriver.Chrome() driver.get(url) driver.implicitly_wait(3) # 使用隐式等待 try: input_tag=driver.find_element_by_id('key') input_tag.send_keys(keyword) input_tag.send_keys(Keys.ENTER) get_goods(driver) finally: driver.close() if __name__ == '__main__': spider('https://www.jd.com/',keyword='iPhone8手机')
验证码处理
- 简单的校验码Tesserocr就可以搞定
- 极验滑动认证 极验官网：http://www.geetest.com/
""" 云打码平台（打码兔）处理验证码的实现流程： - 1.对携带验证码的页面数据进行抓取 - 2.可以将页面数据中验证码进行解析，验证码图片下载到本地 - 3.可以将验证码图片提交给三方平台进行识别，返回验证码图片上的数据值 - 云打码平台： - 1.在官网中进行注册（普通用户和开发者用户） - 2.登录开发者用户： - 1.实例代码的下载（开发文档-》调用实例及最新的DLL-》PythonHTTP实例下载） - 2.创建一个软件：我的软件-》添加新的软件 -3.使用示例代码中的源码文件中的代码进行修改，让其识别验证码图片中的数据值 """ import http.client, mimetypes, urllib, json, time, requests class YDMHttp: apiurl = 'http://api.yundama.com/api.php' username = '' password = '' appid = '' appkey = '' def __init__(self, username, password, appid, appkey): self.username = username self.password = password self.appid = str(appid) self.appkey = appkey def request(self, fields, files=[]): response = self.post_url(self.apiurl, fields, files) response = json.loads(response) return response def balance(self): data = {'method': 'balance', 'username': self.username, 'password': self.password, 'appid': self.appid, 'appkey': self.appkey} response = self.request(data) if (response): if (response['ret'] and response['ret'] < 0): return response['ret'] else: return response['balance'] else: return -9001 def login(self): data = {'method': 'login', 'username': self.username, 'password': self.password, 'appid': self.appid, 'appkey': self.appkey} response = self.request(data) if (response): if (response['ret'] and response['ret'] < 0): return response['ret'] else: return response['uid'] else: return -9001 def upload(self, filename, codetype, timeout): data = {'method': 'upload', 'username': self.username, 'password': self.password, 'appid': self.appid, 'appkey': self.appkey, 'codetype': str(codetype), 'timeout': str(timeout)} file = {'file': filename} response = self.request(data, file) if (response): if (response['ret'] and response['ret'] < 0): return response['ret'] else: return response['cid'] else: return -9001 def result(self, cid): data = {'method': 'result', 'username': self.username, 'password': self.password, 'appid': self.appid, 'appkey': self.appkey, 'cid': str(cid)} response = self.request(data) return response and response['text'] or '' def decode(self, filename, codetype, timeout): cid = self.upload(filename, codetype, timeout) if (cid > 0): for i in range(0, timeout): result = self.result(cid) if (result != ''): return cid, result else: time.sleep(1) return -3003, '' else: return cid, '' def report(self, cid): data = {'method': 'report', 'username': self.username, 'password': self.password, 'appid': self.appid, 'appkey': self.appkey, 'cid': str(cid), 'flag': '0'} response = self.request(data) if (response): return response['ret'] else: return -9001 def post_url(self, url, fields, files=[]): for key in files: files[key] = open(files[key], 'rb'); res = requests.post(url, files=files, data=fields) return res.text # 该函数就调用了打码平台的相关的接口对指定的验证码图片进行识别，返回图片上的数据值 def getCode(codeImg): # 云打码平台普通用户的用户名 username = 'bobo328410948' # 云打码平台普通用户的密码 password = 'bobo328410948' # 软件ＩＤ，开发者分成必要参数。登录开发者后台【我的软件】获得！ appid = 6003 # 软件密钥，开发者分成必要参数。登录开发者后台【我的软件】获得！ appkey = '1f4b564483ae5c907a1d34f8e2f2776c' # 验证码图片文件 filename = codeImg # 验证码类型，# 例：1004表示4位字母数字，不同类型收费不同。请准确填写，否则影响识别率。在此查询所有类型 http://www.yundama.com/price.html codetype = 3000 # 超时时间，秒 timeout = 20 # 检查 if (username == 'username'): print('请设置好相关参数再测试') else: # 初始化 yundama = YDMHttp(username, password, appid, appkey) # 登陆云打码 uid = yundama.login(); print('uid: %s' % uid) # 查询余额 balance = yundama.balance(); print('balance: %s' % balance) # 开始识别，图片路径，验证码类型ID，超时时间（秒），识别结果 cid, result = yundama.decode(filename, codetype, timeout); print('cid: %s, result: %s' % (cid, result)) return result ## import requests from lxml import etree import json import time import re #1.对携带验证码的页面数据进行抓取 url = 'https://www.douban.com/accounts/login?source=movie' headers = { 'User-Agent': 'Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.77 Mobile Safari/537.36' } page_text = requests.get(url=url,headers=headers).text #2.可以将页面数据中验证码进行解析，验证码图片下载到本地 tree = etree.HTML(page_text) codeImg_url = tree.xpath('//*[@id="captcha_image"]/@src')[0] #获取了验证码图片对应的二进制数据值 code_img = requests.get(url=codeImg_url,headers=headers).content #获取capture_id '<img id="captcha_image" src="https://www.douban.com/misc/captcha?id=AdC4WXGyiRuVJrP9q15mqIrt:en&size=s" alt="captcha" class="captcha_image">' c_id = re.findall('<img id="captcha_image".*?id=(.*?)&.*?>',page_text,re.S)[0] with open('./code.png','wb') as fp: fp.write(code_img) #获得了验证码图片上面的数据值 codeText = getCode('./code.png') print(codeText) #进行登录操作 post = 'https://accounts.douban.com/login' data = { "source": "movie", "redir": "https://movie.douban.com/", "form_email": "15027900535", "form_password": "bobo@15027900535", "captcha-solution":codeText, "captcha-id":c_id, "login": "登录", } print(c_id) login_text = requests.post(url=post,data=data,headers=headers).text with open('./login.html','w',encoding='utf-8') as fp: fp.write(login_text)
#步骤一:点击按钮，弹出没有缺口的图片 #步骤二：获取步骤一的图片 #步骤三：点击滑动按钮，弹出带缺口的图片 #步骤四：获取带缺口的图片 #步骤五：对比两张图片的所有RBG像素点，得到不一样像素点的x值，即要移动的距离 #步骤六：模拟人的行为习惯（先匀加速拖动后匀减速拖动），把需要拖动的总距离分成一段一段小的轨迹 #步骤七：按照轨迹拖动，完全验证 #步骤八：完成登录 #安装：selenium+chrome/phantomjs #安装：Pillow Pillow:基于PIL，处理python 3.x的图形图像库.因为PIL只能处理到python 2.x，而这个模块能处理Python3.x，目前用它做图形的很多. http://www.cnblogs.com/apexchu/p/4231041.html C:\Users\Administrator>pip3 install pillow C:\Users\Administrator>python3 Python 3.6.1 (v3.6.1:69c0db5, Mar 21 2017, 18:41:36) [MSC v.1900 64 bit (AMD64)] on win32 Type "help", "copyright", "credits" or "license" for more information. >>> from PIL import Image
from selenium import webdriver from selenium.webdriver import ActionChains from selenium.webdriver.common.by import By from selenium.webdriver.common.keys import Keys from selenium.webdriver.support import expected_conditions as EC from selenium.webdriver.support.wait import WebDriverWait from PIL import Image import time def get_snap(): ''' 对整个网页截图，保存成图片，然后用PIL.Image拿到图片对象 :return: 图片对象 ''' driver.save_screenshot('snap.png') page_snap_obj=Image.open('snap.png') return page_snap_obj def get_image(): ''' 从网页的网站截图中，截取验证码图片 :return: 验证码图片 ''' img=wait.until(EC.presence_of_element_located((By.CLASS_NAME,'geetest_canvas_img'))) time.sleep(2) #保证图片刷新出来 localtion=img.location size=img.size top=localtion['y'] bottom=localtion['y']+size['height'] left=localtion['x'] right=localtion['x']+size['width'] page_snap_obj=get_snap() crop_imag_obj=page_snap_obj.crop((left,top,right,bottom)) return crop_imag_obj def get_distance(image1,image2): ''' 拿到滑动验证码需要移动的距离 :param image1:没有缺口的图片对象 :param image2:带缺口的图片对象 :return:需要移动的距离 ''' threshold=60 left=57 for i in range(left,image1.size[0]): for j in range(image1.size[1]): rgb1=image1.load()[i,j] rgb2=image2.load()[i,j] res1=abs(rgb1[0]-rgb2[0]) res2=abs(rgb1[1]-rgb2[1]) res3=abs(rgb1[2]-rgb2[2]) if not (res1 < threshold and res2 < threshold and res3 < threshold): return i-7 #经过测试，误差为大概为7 return i-7 #经过测试，误差为大概为7 def get_tracks(distance): ''' 拿到移动轨迹，模仿人的滑动行为，先匀加速后匀减速 匀变速运动基本公式： ①v=v0+at ②s=v0t+½at² ③v²-v0²=2as :param distance: 需要移动的距离 :return: 存放每0.3秒移动的距离 ''' #初速度 v=0 #单位时间为0.2s来统计轨迹，轨迹即0.2内的位移 t=0.3 #位移/轨迹列表，列表内的一个元素代表0.2s的位移 tracks=[] #当前的位移 current=0 #到达mid值开始减速 mid=distance*4/5 while current < distance: if current < mid: # 加速度越小，单位时间的位移越小,模拟的轨迹就越多越详细 a= 2 else: a=-3 #初速度 v0=v #0.2秒时间内的位移 s=v0*t+0.5*a*(t**2) #当前的位置 current+=s #添加到轨迹列表 tracks.append(round(s)) #速度已经达到v,该速度作为下次的初速度 v=v0+a*t return tracks try: driver=webdriver.Chrome() driver.get('https://account.geetest.com/login') wait=WebDriverWait(driver,10) #步骤一：先点击按钮，弹出没有缺口的图片 button=wait.until(EC.presence_of_element_located((By.CLASS_NAME,'geetest_radar_tip'))) button.click() #步骤二：拿到没有缺口的图片 image1=get_image() #步骤三：点击拖动按钮，弹出有缺口的图片 button=wait.until(EC.presence_of_element_located((By.CLASS_NAME,'geetest_slider_button'))) button.click() #步骤四：拿到有缺口的图片 image2=get_image() # print(image1,image1.size) # print(image2,image2.size) #步骤五：对比两张图片的所有RBG像素点，得到不一样像素点的x值，即要移动的距离 distance=get_distance(image1,image2) #步骤六：模拟人的行为习惯（先匀加速拖动后匀减速拖动），把需要拖动的总距离分成一段一段小的轨迹 tracks=get_tracks(distance) print(tracks) print(image1.size) print(distance,sum(tracks)) #步骤七：按照轨迹拖动，完全验证 button=wait.until(EC.presence_of_element_located((By.CLASS_NAME,'geetest_slider_button'))) ActionChains(driver).click_and_hold(button).perform() for track in tracks: ActionChains(driver).move_by_offset(xoffset=track,yoffset=0).perform() else: ActionChains(driver).move_by_offset(xoffset=3,yoffset=0).perform() #先移过一点 ActionChains(driver).move_by_offset(xoffset=-3,yoffset=0).perform() #再退回来，是不是更像人了 time.sleep(0.5) #0.5秒后释放鼠标 ActionChains(driver).release().perform() #步骤八：完成登录 input_email=driver.find_element_by_id('email') input_password=driver.find_element_by_id('password') button=wait.until(EC.element_to_be_clickable((By.CLASS_NAME,'login-btn'))) input_email.send_keys('18611453110@163.com') input_password.send_keys('linhaifeng123') # button.send_keys(Keys.ENTER) button.click() import time time.sleep(200) finally: driver.close()
from selenium import webdriver from selenium.webdriver import ActionChains from selenium.webdriver.common.by import By from selenium.webdriver.common.keys import Keys from selenium.webdriver.support import expected_conditions as EC from selenium.webdriver.support.wait import WebDriverWait from PIL import Image import time def get_snap(): driver.save_screenshot('full_snap.png') page_snap_obj=Image.open('full_snap.png') return page_snap_obj def get_image(): img=driver.find_element_by_class_name('geetest_canvas_img') time.sleep(2) location=img.location size=img.size left=location['x'] top=location['y'] right=left+size['width'] bottom=top+size['height'] page_snap_obj=get_snap() image_obj=page_snap_obj.crop((left,top,right,bottom)) # image_obj.show() return image_obj def get_distance(image1,image2): start=57 threhold=60 for i in range(start,image1.size[0]): for j in range(image1.size[1]): rgb1=image1.load()[i,j] rgb2=image2.load()[i,j] res1=abs(rgb1[0]-rgb2[0]) res2=abs(rgb1[1]-rgb2[1]) res3=abs(rgb1[2]-rgb2[2]) # print(res1,res2,res3) if not (res1 < threhold and res2 < threhold and res3 < threhold): return i-7 return i-7 def get_tracks(distance): distance+=20 #先滑过一点，最后再反着滑动回来 v=0 t=0.2 forward_tracks=[] current=0 mid=distance*3/5 while current < distance: if current < mid: a=2 else: a=-3 s=v*t+0.5*a*(t**2) v=v+a*t current+=s forward_tracks.append(round(s)) #反着滑动到准确位置 back_tracks=[-3,-3,-2,-2,-2,-2,-2,-1,-1,-1] #总共等于-20 return {'forward_tracks':forward_tracks,'back_tracks':back_tracks} try: # 1、输入账号密码回车 driver = webdriver.Chrome() driver.implicitly_wait(3) driver.get('https://passport.cnblogs.com/user/signin') username = driver.find_element_by_id('input1') pwd = driver.find_element_by_id('input2') signin = driver.find_element_by_id('signin') username.send_keys('linhaifeng') pwd.send_keys('xxxxx') signin.click() # 2、点击按钮，得到没有缺口的图片 button = driver.find_element_by_class_name('geetest_radar_tip') button.click() # 3、获取没有缺口的图片 image1 = get_image() # 4、点击滑动按钮，得到有缺口的图片 button = driver.find_element_by_class_name('geetest_slider_button') button.click() # 5、获取有缺口的图片 image2 = get_image() # 6、对比两种图片的像素点，找出位移 distance = get_distance(image1, image2) # 7、模拟人的行为习惯，根据总位移得到行为轨迹 tracks = get_tracks(distance) print(tracks) # 8、按照行动轨迹先正向滑动，后反滑动 button = driver.find_element_by_class_name('geetest_slider_button') ActionChains(driver).click_and_hold(button).perform() # 正常人类总是自信满满地开始正向滑动，自信地表现是疯狂加速 for track in tracks['forward_tracks']: ActionChains(driver).move_by_offset(xoffset=track, yoffset=0).perform() # 结果傻逼了，正常的人类停顿了一下，回过神来发现，卧槽，滑过了,然后开始反向滑动 time.sleep(0.5) for back_track in tracks['back_tracks']: ActionChains(driver).move_by_offset(xoffset=back_track, yoffset=0).perform() # 小范围震荡一下，进一步迷惑极验后台，这一步可以极大地提高成功率 ActionChains(driver).move_by_offset(xoffset=-3, yoffset=0).perform() ActionChains(driver).move_by_offset(xoffset=3, yoffset=0).perform() # 成功后，骚包人类总喜欢默默地欣赏一下自己拼图的成果，然后恋恋不舍地松开那只脏手 time.sleep(0.5) ActionChains(driver).release().perform() time.sleep(10) # 睡时间长一点，确定登录成功 finally: driver.close()
from selenium import webdriver from selenium.webdriver import ActionChains from selenium.webdriver.common.by import By from selenium.webdriver.common.keys import Keys from selenium.webdriver.support import expected_conditions as EC from selenium.webdriver.support.wait import WebDriverWait from PIL import Image import time def get_snap(driver): driver.save_screenshot('full_snap.png') page_snap_obj=Image.open('full_snap.png') return page_snap_obj def get_image(driver): img=driver.find_element_by_class_name('geetest_canvas_img') time.sleep(2) location=img.location size=img.size left=location['x'] top=location['y'] right=left+size['width'] bottom=top+size['height'] page_snap_obj=get_snap(driver) image_obj=page_snap_obj.crop((left,top,right,bottom)) # image_obj.show() return image_obj def get_distance(image1,image2): start=57 threhold=60 for i in range(start,image1.size[0]): for j in range(image1.size[1]): rgb1=image1.load()[i,j] rgb2=image2.load()[i,j] res1=abs(rgb1[0]-rgb2[0]) res2=abs(rgb1[1]-rgb2[1]) res3=abs(rgb1[2]-rgb2[2]) # print(res1,res2,res3) if not (res1 < threhold and res2 < threhold and res3 < threhold): return i-7 return i-7 def get_tracks(distance): distance+=20 #先滑过一点，最后再反着滑动回来 v=0 t=0.2 forward_tracks=[] current=0 mid=distance*3/5 while current < distance: if current < mid: a=2 else: a=-3 s=v*t+0.5*a*(t**2) v=v+a*t current+=s forward_tracks.append(round(s)) #反着滑动到准确位置 back_tracks=[-3,-3,-2,-2,-2,-2,-2,-1,-1,-1] #总共等于-20 return {'forward_tracks':forward_tracks,'back_tracks':back_tracks} def crack(driver): #破解滑动认证 # 1、点击按钮，得到没有缺口的图片 button = driver.find_element_by_class_name('geetest_radar_tip') button.click() # 2、获取没有缺口的图片 image1 = get_image(driver) # 3、点击滑动按钮，得到有缺口的图片 button = driver.find_element_by_class_name('geetest_slider_button') button.click() # 4、获取有缺口的图片 image2 = get_image(driver) # 5、对比两种图片的像素点，找出位移 distance = get_distance(image1, image2) # 6、模拟人的行为习惯，根据总位移得到行为轨迹 tracks = get_tracks(distance) print(tracks) # 7、按照行动轨迹先正向滑动，后反滑动 button = driver.find_element_by_class_name('geetest_slider_button') ActionChains(driver).click_and_hold(button).perform() # 正常人类总是自信满满地开始正向滑动，自信地表现是疯狂加速 for track in tracks['forward_tracks']: ActionChains(driver).move_by_offset(xoffset=track, yoffset=0).perform() # 结果傻逼了，正常的人类停顿了一下，回过神来发现，卧槽，滑过了,然后开始反向滑动 time.sleep(0.5) for back_track in tracks['back_tracks']: ActionChains(driver).move_by_offset(xoffset=back_track, yoffset=0).perform() # 小范围震荡一下，进一步迷惑极验后台，这一步可以极大地提高成功率 ActionChains(driver).move_by_offset(xoffset=-3, yoffset=0).perform() ActionChains(driver).move_by_offset(xoffset=3, yoffset=0).perform() # 成功后，骚包人类总喜欢默默地欣赏一下自己拼图的成果，然后恋恋不舍地松开那只脏手 time.sleep(0.5) ActionChains(driver).release().perform() def login_cnblogs(username,password): driver = webdriver.Chrome() try: # 1、输入账号密码回车 driver.implicitly_wait(3) driver.get('https://passport.cnblogs.com/user/signin') input_username = driver.find_element_by_id('input1') input_pwd = driver.find_element_by_id('input2') signin = driver.find_element_by_id('signin') input_username.send_keys(username) input_pwd.send_keys(password) signin.click() # 2、破解滑动认证 crack(driver) time.sleep(10) # 睡时间长一点，确定登录成功 finally: driver.close() if __name__ == '__main__': login_cnblogs(username='linhaifeng',password='xxxx')