笔记合集爬虫基础系列临近结束课件直接合一起方便自己寻找有空再整理

最新推荐文章于 2020-10-28 17:46:39 发布

原创最新推荐文章于 2020-10-28 17:46:39 发布 · 1.4k 阅读

5 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

爬虫

python3

python基础系列

这是一份详细的Python爬虫基础系列笔记，涵盖了从day01到day13的学习内容，包括数据抓取、主从配置、Scrapy框架的使用、增量爬虫等。讲解了如何启动主从配置，使用Scrapy创建项目、设置请求头、提取网页数据，并介绍了Redis、MongoDB的相关知识。

day01

一、爬虫的定义：程序或者脚本---》自动的爬取万维网的数据的程序或者脚本。
二、爬虫可以解决的问题：
	（1）解决冷启动问题。
	（2）搜索引擎的根基。---通用爬虫。
	（3）帮助机器学习建立知识图谱。
	（4）制作各种比价软件。
三、爬虫工程师的进阶之路：
	初级爬虫工程师
		1.web 前端的知识： HTML、CSS、JavaSc1ipt、 DOM、 DHTML 、Ajax、jQuery、json 等；
		2、正则表达式， 能提取正常一般网页中想要的信息，比如某些特殊的文字， 链接信息， 知道什么是懒惰， 什么是贪婪型的正则；
		3、会使用 XPath 等获取一些DOM 结构中的节点信息；
		4、知道什么是深度优先， 广度优先的抓取算法， 及实践中的使用规则；
		5、能分析简单网站的结构， 会使用urllib或requests 库进行简单的数据抓取。
	中级爬虫工程师：
		1、了解什么事HASH，会简单地使用MD5，SHA1等算法对数据进行HASH一遍存储
		2、熟悉HTTP，HTTPS协议的基础知识，了解GET，POST方法，了解HTTP头中的信息，包括返回状态码，编码，user-agent，cookie，session等
		3、能设置user-agent进行数据爬取，设置代理等
		4、知道什么事Request，什么事response，会使用Fiddler等工具抓取及分析简单地网络数据包；对于动态爬虫，要学会分析ajax请求，模拟制造post数据包请求，抓取客户端session等信息，对于一些简单的网站，能够通过模拟数据包进行自动登录。
		5、对于一些难搞定的网站学会使用phantomjs+selenium抓取一些动态网页信息
		6、并发下载，通过并行下载加速数据爬取；多线程的使用。
	高级爬虫工程师：
		1、能够使用Tesseract，百度AI，HOG+SVM，CNN等库进行验证码识别。
		2、能使用数据挖掘技术，分类算法等避免死链。
		3、会使用常用的数据库进行数据存储，查询。比如mongoDB，redis；学习如何通过缓存避免重复下载的问题。
		4、能够使用机器学习的技术动态调整爬虫的爬取策略，从而避免被禁IP封禁等。
		5、能使用一些开源框架scrapy，scrapy-redis等分布式爬虫，能部署掌控分布式爬虫进行大规模数据爬取。
		
四、搜索引擎
	1、什么是搜索引擎：
		搜索引擎通过特定算法，从互联网上获取网页信息，将其保存到本地，为用户提供检索服务的一种程序。

	2、搜索引擎的组成：搜索引擎主要是是由通用爬虫组成的。
		（1）通用爬虫：将互联网上的网页信息【整体】爬取下来的爬虫程序。
		（2）搜索引擎的工作步骤：
			1、抓取网页
			2、数据存储
			3、预处理
				提取文字
				中文分词
				消除噪音
				。。。
			4、设置网站排名（访问量），为用户提供检索服务。
		（3）为什么搜索引擎可以爬取所有的网页？---搜索引擎的通用是如何来爬取所有网页的。
			一个网页就是一个url，这个问题其实在问，【url的获取来源】。
			url的获取来源：
				1、新网站会主动提交网址给搜索引擎。
				2、网页中的一些外链，这些url全部都会加入到通用爬虫的爬取队列。
				3、搜索引擎和dns解析服务商合作，如果有新网站注册，搜索引擎就可拿到网址。
	3、通用爬虫的缺陷：
		（1）通用爬虫是爬取整个网页，但是网页中90%的内容基本是没用。
		（2）不能满足不同行业，不同人员的不同需求。
		（3）只能获取文字，不能获取音频，视频，文档等信息。
		（4）只能通过关键字查询，无法通过语义查询。
	4、聚焦爬虫：在实施网页抓取的过程中，【会对内容进行筛选】，尽量保证只抓取与【需求相关】的信息的爬虫程序。	
五、robots协议：
	定义：网络爬虫排除标准
	作用：告诉搜索引擎那些可以爬那些不能爬。
六、http协议
	1、什么是http协议：
		是一种规范——————>约束发布和接受html的规范。
	2、http和https。
		http：超文本传输协议。
		https:安全版的http协议。---ssl---
			对称加密---密钥
			非对称---私钥+公钥
			数字签证---
	3、https：443
	   http：80
	   Upgrade-Insecure-Requests: 1：可以将http升级成https请求。
	4、http的特点：
		（1）应用层协议。
		（2）无连接：http每次发送请求和响应的过程都是独立。
			在http 1.0以后，有请求头：connection：keep-alive：客户端和服务建立长连接。
			
		（3）无状态：http协议不记录状态。
			cookie和session做到请求状态的记录。
			cookie是在客户端保存，session是在服务器保存。
	5、url：统一资源定位符。
		（1）主要作用：用来定位互联网上的任意资源的位置。
		（2）为什么url可以定位任意资源？
			组成：https://www.baidu.com/index.html?username=123&password=abc#top
				scheme：协议---https
				netloc:网络地址：ip:port---www.baidu.com
					通过ip定位电脑，通过port定位应用。
					192.168.92.10:
						代理ip：ip：port
				path：资源路径。---index.html
				query：请求参数：---？后面的内容username=123&password=abc
				fragment：锚点----top
			
			原因：url包含netloc可以定位电脑，path定位资源，这样就可以找到任意在互联网上的信息。
		（3）特殊符号：
			？：后面就是请求参数
			&:连接请求参数
			#:锚点----如果url中有锚点，在爬虫程序中尽量去除。
	6、 http的工作过程：
		 （1）地址解析：
			将url的所有组成部分分别解析出来。
		 （2）封装http请求数据包。
			将第一步解析出来的信息进行装包。---http数据包。
		 （3）封装tcp数据包，通过三次握手建立tcp。
		 （4）客户端发送请求
		 （5）服务发送响应
		 （6）关闭tcp连接。
	7、当我们在浏览器输入一个url，浏览器加载出这个页面，中间做了哪些事？
		（1）客户端解析url，封装数据包，建立连接，发送请求。
		（2）服务器返回url对应资源文件给客户端，比如：index.html。
		（3）客户端检查index.html是否有静态资源（引用外部文件），比如js，css，图片。有的话再分别发送请求，来获取这些静态资源。
		（4）客户端获取所有静态资源，通过html语法，完全将index.html页面显示出来。
	8、	http的请求方法：
		get请求：get（获取）-->获取服务器的指定资源--->涉及到筛选一些信息--->请求参数：主要拼接在url中。--->不安全（别人可以通过url获取信息）--->请求参数的大小受限。
		post请求：post（邮递）--->向服务器传递数据--->请求数据是放在请求实体中的--->安全--->大小不受限。
	9、客户端请求
		（1）组成：请求行、请求头、空行、请求数据（实体）
		
			请求头：请求方法；host地址，http协议版本。
		（2）请求头：
				user-agent：客户端标识。
				accept：允许传入的文件类型。
					Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3
				Referer：标识产生请求的网页来自于哪个网页。
						防盗链
				cookie：cookie信息。---现在很多网站，必须封装cookie才给数据。
			post请求重要的请求头：		
				content-type:post请求的数据类型
				content-length:post请求数据的长度。
				
			ajax请求必须封装的头：
				x-requested-with:xmlhttprequest
				
	10、服务器响应：
		（1）组成：状态行、响应头、空行、响应正文。
		（2）响应头：
			Content-Type：text/html;charset=UTF-8
		
		（3）状态码（面试常考）：
			1XX:表示服务器成功接收部分请求，还需要发剩余请求才能处理整个过程。（处理了一半）
			2XX:表示服务器成功接收请求并处理完整个过程。（成功）
				200成功
			3XX:为了完成请求，客户端需要进一步细化请求。
				302：重定向
				304：使用缓存资源
			4XX：客户端请求错误。（url写错了）
				404:服务器无法找到请求内容。
				403:服务器拒绝访问，权限不够。
			5XX:服务器错误。
				502：服务器错误
				500：请求未完成，服务器遇到不可知问题。
-----------------------------------------------------------------------
1.笔记
2.
	用【递归】的方法实现斐波那契数列。
	
	1,1,2,3,5,8,13.。。。
	用【递归】的方法获取一个list的最大值和最小值，return（最大值，最小值）

day02

1、斐波那契数列：
	def F(n):
		if n==1 or n==2:
			return 1
		return F(n-1)+F(n-2)
		
2、
	def max_min(L,start,end):
		
		if end-start <=1:
			return (max(L[start],L[end]),min(L[start],L[end]))
		max1,min1 = max_min(L,start,(start+end)//2)
		max2,min2 = max_min(L,(start+end)//2+1,end)
		
		return (max(max1,max2),min(min1,min2))
		
==================================================================================
第二讲requests模块
文档：从 pythoneer 到 pythonista 的100个模...
链接：http://note.youdao.com/noteshare?id=2b95bb3651c21af80ca1936f8ecb1e0f&sub=635CA99241664308947C4F3BC1B5DDBF

1、使用步骤：
		#1.导包
		import requests
		#2、确定基础url
		base_url = 'https://www.baidu.com'
		#3、发送请求，获取响应
		response = requests.get(base_url)
		#4、处理响应内容
		
2、requests.get()---get请求方法参数详解
			
	（1）requests.get(
				url=请求url，
				headers =请求头字典，
				params = 请求参数字典。
				timeout = 超时时长，
			)---->response对象
	（2）response对象的属性：
		服务器响应包含：状态行（协议，状态码）、响应头，空行，响应正文
		（1）响应正文：
			字符串格式：response.text
			bytes类型：response.content
		（2）状态码：response.status_code
		
		（3）响应头：response.headers(字典)
				response.headers['cookie']
				
		（4）响应正文的编码：response.encoding
			response.text获取到的字符串类型的响应正文，其实是通过下面的步骤获取的：
				response.text = response.content.decode(response.encoding)
	
		（5）乱码问题的解决办法：
			产生的原因：编码和解码的编码格式不一致造成的。
				str.encode('编码')---将字符串按指定编码解码成bytes类型
				bytes.decode('编码')---将bytes类型按指定编码编码成字符串。
			a、response.content.decode('页面正确的编码格式')
				 <meta http-equiv="content-type" content="text/html;charset=utf-8">
			b、找到正确的编码，设置到response.encoding中
				response.encoding = 正确的编码
				response.text--->正确的页面内容。
	（3）get请求项目总结：
		a、没有请求参数的情况下，只需要确定url和headers字典。
		b、get请求是有请求参数。
			在chrome浏览器中，下面找query_string_params,将里面的参数封装到params字典中。
		c、分页主要是查看每页中，请求参数页码字段的变化，找到变化规律，用for循环就可以做到分页。
					
3、post请求：
		requests.post(
			url=请求url，
			headers = 请求头字典，
			data=请求数据字典
			timeout=超时时长
		
		)---response对象
		post请求一般返回数据都是json数据。
		#解析json数据的方法：
		（1）response.json()--->json字符串所对应的python的list或者dict
		（2）用json模块。
			json.loads(json_str)---->json_data(python的list或者dict)
			json.dumps(json_data)--->json_str
		
		post请求能否成功，关键看请求参数。
		如何查找是哪个请求参数在影响数据获取？--->通过对比，找到变化的参数。
		变化参数如何找到参数的生成方式，就是解决这个ajax请求数据获取的途径。
		寻找的办法有以下几种：
			（1）写死在页面。
			（2）写在js中。
			（3）请求参数是在之前的一条ajax请求的数据里面提前获取好的。
4、代理使用方法	。
	（1）代理基本原理：
		代理形象的说，他是网络信息中转站。实际上就是在本机和服务器之间架了一座桥。
					
	（2）代理的作用：
		a、突破自身ip访问限制，可以访问一些平时访问不到网站。
		b、访问一些单位或者团体的资源。
		c、提高访问速度。代理的服务器主要作用就是中转，所以一般代理服务里面都是用内存来进行数据存储的。
		d、隐藏ip。
	（3）代理的分类：
		1、按照协议进行划分：
			FTP代理服务器---21,2121
			HTTP代理服务器---80,8080
			SSL/TLS代理：主要用访问加密网站。端口：443
			telnet代理 ：主要用telnet远程控制，端口一般为23
		2、按照匿名程度：
			高度匿名代理：数据包会原封不动转化，在服务段看来，就好像一个普通用户在访问，做到完全隐藏ip。
			普通匿名代理：数据包会做一些改动，服务器有可能找到原ip。
			透明代理：不但改动数据，还会告诉服务，是谁访问的。
			间谍代理：指组织或者个人用于记录用户传输数据，然后进行研究，监控等目的的代理。	
	（4）在requests模块中如何设置代理？
		proxies = {
			'代理服务器的类型':'代理ip'
		}
		response = requests.get(proxies = proxies)
		代理服务器的类型:http,https,ftp
		代理ip:http://ip:port
作业:
1.股吧信息爬取：
	url:http://guba.eastmoney.com/
	要求:
		1、爬取10页内容，保存到guba文件夹下
2、金山词霸：http://www.iciba.com/
做到和有道相似想过。

day03

一、cookie和session
	1、什么是cookie？
		cookie是指网站为了鉴别用户身份，进行会话跟踪而存储在客户端本地的数据。
	2、什么是session？
		本来的含义是指有始有终的一些列动作，而在web中，session对象用来在服务器存储特定用户会话所需要的属性及信息。
	3、cookie和session产生的原因：
		cookie和session他们不属于http协议范围，由于http协议是无法保持状态，但实际情况，我们有需压保持一些信息，作为下次请求的条件，所有就产生了cookie和session。
	4、cookie的原理：
		由服务器产生，当浏览器第一次登录，发送请求到服务器，服务器返回数据，同时生成一个cookie返回给客户端，客户端将这个cookie保存下来。
		当浏览器再次访问，浏览器就会自动带上cookie信息，这样服务器就能通过cookie判断是哪个用户在操作。
		
		cookie的缺陷：
			1、不安全--保存在客户端。
			2、cookie本身最大支持4096（4kb）---存储大小受限。
	5、session的工作原理。
		正是因为cookie的缺陷，所有产生了另外一种保持状态的方法---session。
		服务器存储session，基于http协议的无状态特征，所以服务器就不知道这个访问者是谁。为了解决这个问题，cookie就起到了桥的作用。cookie在使用的过程中，将一个叫做sessionid的字段放到cookie中，将来服务器可以通过这个id字段来查找到底是那个用户的session。
		
		session的生命周期：当用户第一次登陆时创建（生命开始），到session有效期结束（30min）。
		
	6、当我们浏览器关闭，session是否就失效了？
		不失效，原因，session失效使用生命周期决定的。
	7、cookie组成：
		name：cookie名称，一旦创建，不可更改。
		value：该cookie的值
		domain：者cookie可以访问网站域名。
		maxage:cookie的失效时间。负数是永不失效。
		path：这个使用路径
		http字段：cookie的httponly，若次属性为true，则只有http头中会带此cookie。
		secrue:该cookie是否仅被使用安全传输协议。
		size:cookie的大小
		
	8、会话cookie和持久cookie。
		持久化：将内存中的数据存储到硬盘（文件中，数据库）上的过程。
		序列化：将对象保存到硬盘上。
		
		会话cookie：保存在内存中cookie，浏览器关闭，cookie失效。
		持久cookie：保存在硬盘上的cookie。
	9、用requests实现登陆：
	（1）只需要将【登陆后的】cookie字段封装在请求头中。
	（2）使用requests的session对象登陆
		session对象可以记录登陆状态。
		使用步骤：
		#session：记录登陆状态
		se = requests.Session()
		data = {
			'email':'13016031459',
			'password':'12345678',
		}
		#此时se对象就保存了登陆信息
		se.post(base_url,data = data,headers = headers)
		------------------------------------------
		index_url = 'http://www.renren.com/971682585/profile'
		#用se对象来进行个人首页的访问，就可以了
		response = se.get(index_url,headers=headers)
		if '鸣人' in response.text:
			print('登陆成功！')
		else:
			print('登陆失败！')
===================================================================================
第三讲 正则表达式

一、数据的分类
	1、结构化数据
		特点：数据以行为单位，每一个数据表示一个实体。每一行数据的属性都是一样的。
		举例：关系型数据库中的表就是结构化数据。
		处理方法：sql
	2、半结构化数据
		特点：结构化数据的另一种形式。他并不符合关系型数据的特点，不能用关系型模型来描述。但是这种数据包含相关标记，有用来分割语义元素以及字段进行分层的描述。
		因此也被称为自描述结构。
		举例：xml，html，json，非关系型数据库存储的数据。
		处理方法：正则，xpath，jsonpath，css选择器。
	3、非结构化数据：
		特点：没有固定结构的数据。
		举例：文档、图片、音频、视频。
		处理方法：常常用二进制形式来做整体保存。
	
二、json数据
	1、json是什么语言的内容？
		json是js语言中用来用【字符串格式】来保存对象和数组的一种数据结构。
		json数据本质上是字符串。
	2、js种数组和对象：
		js的数组：var array  = ['aaa','bb','cc']----和python列表对应
		js的对象：var obj = {name：'zhangsan',age:10}---和python字典对应。
			name = obj.name
	3、json数据的解析方法：
		json模块：
		对json字符串的操作“：
			json.loads(json_str)--->python的list或者dict
			json.dumps(python的list或者dict) --->json_str
		------
		对json文件的操作：
			json.load(fp)--->从json文件中读出json数据，返回一个python的list或者dict
			json.dump(python的list或者dict，fp)---》python的list或者dict保存到fp所对应的的文件中。
	
	4、json的意义：
		json作为数据格式进行传输，具有较高的效率
		json不像xml那样具有严格的闭合标签，所以json作为数据传输的时候，他的数据有效占比（有效数据和总数据的比）比xml高很多。
		在相同流量下，json比xml作为数据传输，传输的数据更多。
三、正则表达式
	1、元字符
		（1）匹配边界：
			^ ----行首
			$-----行尾
		（2）重复次数
			？----0次或1次
			*----->=0
			+---- >=1
			{n,}--->=n
			{n,m}--->=n,<=m
			{n}----n次
		（3）各种字符的表示
			[]----匹配括号中一个字符，单字符
			[abc]--匹配a或者b或者c
			[a-z0-9A-Z]
			\d---数字
			\w---数字字母下划线
			\s---空白字符：换行符、制表符、空格
			\b---单词边界
			.----除换行符以外的任意字符。
		abb??
	2、re模块的使用。
		python中re模块是用来做正则处理的。
	（1）re模块的使用步骤：
		#1导包
		import re
		#2将正则表达式编译成一个pattern对象
		pattern = re.complie(
					r'正则表达式',
					'匹配模式'
					)
		r表示元字符。
		#3、用pattern对象来使用相应的方法来匹配内容。
	
	（2）pattern对象的方法：
		1.match方法：默认从头开始，只匹配一次，返回一个match对象。
		pattern.match(
			'匹配的目标字符串'，
			start,匹配开始的位置--缺省，start = 0
			end，匹配结束的位置--缺省,end = -1
		)--->match对象
		
		match对象的属性：
			match.group()---获取匹配内容。
			match.span()--匹配的范围
			match.start()---开始位置
			match.end()---结束位置
				这些方法都可以带一个参数0，但是不能写1,1来表示取分组。
				match.group(0)---获取匹配内容。
				match.span(0)--匹配的范围
				match.start(0)---开始位置
				match.end(0)---结束位置
				match.groups()--将所有分组的内容，按顺序放到一个元组中返回
		2、search方法：从任意位置开始匹配，只匹配一次，返回一个match对象
			pattern.search(
				'匹配的目标字符串'，
				start,匹配开始的位置--缺省，start = 0
				end，匹配结束的位置--缺省,end = -1
			)--->match对象
		
		3、findall方法：全文匹配，匹配多次，将每次匹配到的结果放到list中返回。
			pattern.findall(
				'匹配的目标字符串'，
				start,匹配开始的位置--缺省，start = 0
				end，匹配结束的位置--缺省,end = -1
			)--->list	
			
			
		4、finditer方法：全文匹配，匹配多次，返回一个迭代器。
			pattern.finditer(
				'匹配的目标字符串'，
				start,匹配开始的位置--缺省，start = 0
				end，匹配结束的位置--缺省,end = -1
			)--->list	
			finditer主要用匹配内容比较多的情况下。
	
	
		5、split：切分，按照正则所表示内容进行切分字符串，返回切分后的每个子串
			pattern.split(
				'要切分的字符串'，
				'切分字数'，默认是全部分。
			)--->list
		6、sub方法：用指定字符串，替换正则表达所匹配到的内容。
			pattern.sub(
				repl,#替换成什么
				content,替换什么
				count,替换次数，默认替换所有
			)--->替换后的字符串。
			
			repl替换内容可以使函数：
				函数要求：
					1.函数必须有参数，参数就是正则匹配目标字符串所得到的每个match对象。
					2、这个函数必须要有返回值，返回值必须是字符串，这个字符串将来就作为替换的内容。
			
			#zhangsan:3000,lisi:4000
			#涨工资每个人涨1000
			content = 'zhangsan:3000,lisi:4000'
			p = re.compile(r'\d+')
			result = p.sub(add,)
	
		7、分组
			分组在正则表达式中使用（）来表示的，一个括号就是一个分组。
			分组的作用：
			（1）筛选特定内容
			（2）可以在同一个表达式中应用前面的分组：
				\1引用第一分组
			（3）findall配合分组
				import re

				content = '<html><h1>正则表达式</h1></html>'
				p = re.compile(r'<(html)><(h1)>(.*)</\2></\1>')
				# print(p.search(content).group())
				print(p.findall(content))#[('html', 'h1', '正则表达式')]
		8、贪婪非贪婪模式
			（1）贪婪和非贪婪的却别在于匹配内容的多少。贪婪是尽可能多，非贪婪尽可能的少
			（2）贪婪使用*来控制匹配次数的。正则默认是贪婪。默认是取数量控制符的最大值。【】
			（3）非贪婪使用?来控制的。
			（4）在表示数量控制元字符后面加一个？，此时就表示这个数量控制符取最小值，也就是非贪婪。
		
		9.匹配模式：
			re.S ----.可以匹配换行符
			re.I----忽略大小写。
	
		10、万能正则匹配表达式：.*?(尽可能少匹配任意内容)配合re.S



作业：
	1、非负整数  
		[99,100,-100,-1,90]
	2、匹配正整数
	3、非正整数
	4、qq邮箱：
		qq号5位---14
	5、匹配11位电话号码
		1 3-9
	6、匹配日期：
		2019-12-19
	7、长度为8-10的用户密码：
		开头字母：必须大写，每一位可以是数字，字母，_
猫眼其他字段做出来。
股吧：
	1、字段
		阅读
		评论
		标题
		作者
		更新时间
		详情页
	2.10页内容保存到json文件。

day04

第四讲 xpath
一、什么xml？
	1、定义：可扩展标记性语言
	2、特点：xml的是具有自描述结构的半结构化数据。
	3、作用：xml主要设计宗旨是用来传输数据的。他还可以作为配置文件。
二、xml和html的区别？
	1、语法要求不同：xml的语法要求更严格。
		（1）html不区分大小写的，xml区分。
		（2）html有时可以省却尾标签。xml不能省略任何标签，严格按照嵌套首位结构。
		（3）只有xml中有自闭标签(没有内容的标签,只有属性。)<a class='abc'/>
		（4）在html中属性名可以不带属性值。xml必须带属性值。
		（5）在xml中属性必须用引号括起来，html中可以不加引号。
	2、作用不同：
		html主要设计用来显示数据以及更好的显示数据。
		xml主要设计宗旨就是用传输数据。
	3、标记不同：xml没有固定标记，html的标记都是固定的，不能自定义。
三、xpath
	1、什么是xpath？
		xpath是一种筛选html或者xml页面元素的【语法】。
	2、xml和html的一些名词：
		元素、标签、属性、内容
	3、xml的两种解析方法：
		dom和sax。
	4、xpath语法：
		（1）选取节点：
			nodename --- 选取此标签及其所有子标签。
			/----从根节点开始选取。
			// ----从任意节点开始，不考虑他们的位置。
				//book---不管book位置，在xml中取出所有的book标签。
			.----当前节点开始找
			..----从父节点
			@ ---选取属性
			text()---选取内容
		（2）谓语：起限定的作用，限定他前面的内容。
			[]写在谁的后面，就限定谁，一般用于限定元素或者标签。
			//book[@class='abc']
			常见的谓语：
				[@class]   ----选取有class
				[@class='abc'] ---选取class属性为abc的节点。
				[contains(@href,'baidu')] ---选取href属性包含baidu的标签
			
				[1] ---选取第一个
				[last()]---选取最后一个
				[last()-1]---选取倒数第二
				[position()>2]---跳过前两个。
				book[price>30]
		（3）通配符
			*  ---匹配任意节点
			@* ---匹配任意属性
		（4）选取若干路径
			|  ---左边和右边的xpath选的内容都要---and
	5、lxml模块----python处理xml和html的模块。
	（1）解析字符串类型xml。
			from lxml import etree
			
			text='''
				html页面内容
			'''
			tree = etree.HTML(text)---返回值就是一个element对象
			#element对象有xpath方法，可以通过xpath表达式来筛选内容。
			#选取class属性为item-1的li下面的a标签的内容
			a_contents = tree.xpath('//li[@class="item-1"]/a/text()')
				
			将element对象变成字符串的方法
			# html_str = etree.tostring(tree,pretty_print=True).decode('utf-8')
			# print(type(html_str))
			
			#elment对象xpath放来筛选，返回值都是一个list。
			#xpath表达式最后一个是一个元素（标签），list中都是elment元素
			#xpath表达式最后一个是属性，list都是属性字符串
			#xpath表达式最后一个是内容，list都是内容字符串
	（2）解析xml或者html文件：
			from lxml import etree
			#parse方法是按照xml的方式来解析，如果语法出问题，就会报错。
			html = etree.parse('demo.html')
			# print(html)#_ElementTree
			li_texts = html.xpath('//li/a/text()')
			print(li_texts)
作业：
	药网数据爬取：
	url:https://www.111.com.cn/categories/953710-a0-b0-c31-d0-e0-f0-g0-h0-i0-j2.html
	要求：抓取50页
		字段：单价，描述，评论数量，详情页链接，（功能主治 ，有效期 ，用法用量）
	（1）用xpath爬取数据。
	（2）将数据保存到excel中

day05

1、path环境变量的作用：
	为了让cmd找到各种命令exe工具，配path就找exe所在目录配置就可以了。
	C:\Anaconda3\Scripts---找pip.exe
	C:\Anaconda3----python.exe
	
多个版本，如何共存？
	python3.7
	anaconda
	放在前面的先被使用。
2.修改完path，要重启cmd

	where python 
	path
	
pip install redis
pip install aiohttp
pip install asyncio
------------------------------------------------------------------
第五讲：动态html
一、反爬策略：
	1、请求头：
		---user-agent
		---referer
		---cookie
	2、访问频率限制。
		---代理池
		---再用户访问高峰期进行爬取，冲散日志。12-13   7-10
		---设置等待时长。time.sleep(3)
	3、ajax异步请求，用接口获取数据。
	4、能一次性获取的数据，绝不发送第二次请求（获取数据的过程中尽量减少请求次数。）
		能在列表页获取的数据，绝不进详情页。
	5、页面内容是js代码。
		selenium+phantomjs的组合进行页面内容的获取。
二、html页面的技术
	
	1、js：
		页面在请求html的过程中，服务器返回html，同时还会请求js文件。
	2、jqery:js的库，方便js开发。
	3、ajax:web的异步请求技术
		同步请求，异步请求。
	
三、selenium和phantomjs
		1、什么是selenium？
			selenium一个web自动化测试工具。【但是它本身是不带浏览器】。这个工具其实就是作为一些外部工具驱动来使用的，可以控制一些外部应用来完成自动化测试。
		2、phantomjs：他其实就是一个内置无界面浏览器引擎。--无界面可以提高程序运行速度。
			因为phantomjs是一个浏览器引擎，所以他最大的功能就是执行页面的js代码。
			
		3.安装selenium和phantomjs？
			selenium安装：pip install selenium==2.48.0
			phantomjs安装：百度phantomjs镜像--->下载一个Windows版本的————>phantomjs-2.1.1-windows.zip  
			
			可视化的chrome浏览器插件：---chromedriver安装：
			下载：百度：chromedriver镜像
				（1）保证chrome是正版。
				（2）查看自己chrome的版本号：73.0.3683.86
				（3）找一个和自己版本号最接近的版本下载。
				
	
			将下载好的exe文件复制到：C:\Anaconda3\Scripts
	
	文档：selenuim常用方法总结.note
链接：http://note.youdao.com/noteshare?id=0142a95cf23fadbaea95809ccb5674b2&sub=02896A50836E4995997A821419D9A063

day06

一、selenium的三种等待：
	1、强制等待：不管页面是否加载出来，强制让进程等待。
		time.sleep(2)
	2、隐式等待：driver.implicitly_wait(20)
		设置20秒的最大等待时长，他等待的结束条件是：等待到浏览器全部加载完成完成为止，全部加载可以理解为，浏览器不在装圈圈。
		弊端：页面的加载其实不单单是页面html，重要还有一些页面静态资源，而静态资源的加载是最耗时。这些静态资源对我们爬取数据又没什么作用，所以隐式等待其实效率并不高。
	3、显示等待：满足一些内置的等待条件，这要这些条件满足，就等待结束。这些条件比如：特定页面元素加载出来。
	
		创建显示等待的步骤：
			from selenium.webdriver.support.wait import WebDriverWait
			from selenium.webdriver.support import expected_conditions as EC
			from selenium.webdriver.common.by import By
			
			1、创建wait对象：
				wait = WebDriverWait(
					driver = 作用的哪个驱动,
					20,最大等待时长
					0.5，每隔多少秒做页面扫描
				)
			2.在之前selenium使用步骤的等待位置：
				wait.until(EC.presence_of_element_located(
						locator = 定位器对象。
				))--->返回值是一个webelement对象（locator对象所定位的哪个webelement）
				定位器对象是一个元组。
				locator = （By.xpath,'xpath表达式'）
							By.ID
							By.CSS_SELECTOR
				
				
			文档：selenium的三种等待.note
链接：http://note.youdao.com/noteshare?id=8f6a0765e4017a4140a05485a9d80a48&sub=48D9761ED13A49EDAC64D180C8340613
==============================================================================
day06 多线程爬虫

	关注：程序运行速度---->主要是由cpu（大脑）来决定。
		  想要提高程序的运行速度----->提高cpu利用率。
		  
	提高cpu的利用率由两种途径：
	（1）让cpu不休息。cup每时每刻都在处理任务，这个任务可以理解为线程。这种情况就叫做多线程。
	（2）cpu都是分核。每个核就是一个小脑袋。可以理解一心多用。让每个核都作用起来，去干不同的事情，这种方法是就叫多进程。
	
一、程序、线程、进程？
	程序：一个应用就可以理解为一个程序。
	进程：程序运行资源分配的最小单位，一个程序可以有多个进程。
	线程：cup最小的调度单位，必须依赖进程存在。线程是没有独立资源的，所有的线程共享他所在进程的所有资源。
			
二、什么是多线程？
	程序中包含多个并行的线程来完成不同的任务。
三、python中的threading模块
	1、创建多线程的第一种方法：
		t = threading.Thread(
				target = 方法名，
				args = (,)--参数列表，元组
			)
		t.start()---启动线程
	2、查看线程的数量：threading.enumerate()
		enumerate(
				可迭代对象，
				i，----表示索引从i开始。
			)---python的内置函数：枚举可迭代对象，同时获取迭代对象的每个值和其索引。
		可迭代对象：有__iter__属性的对象。
		迭代器：有__iter___和__next__属性的对象。
		这两个如何转化：迭代器=iter(可迭代对象)
		可迭代对象都有：list，tuple，dict，str，bytesarray，set，fp
	3、创建第二种方法：	自定线程类。
		python的继承：
			（1）继承是通过在定义类的时候，类后面的（）中添加父类来实现的。
			（2）被继承的类称为父类，继承的类称为子类。
			（3）子类继承父类所有非私有的属性及方法。
			（4）如果子类重写父类的属性和方法，子类默认是优先拿自己的。
		用自定义线程的步骤：
		（1）继承threading.Thread
		（2）重写run方法：
		（3）实例化这个类，就相当于创建了一个线程。
			t = MyThread()
			t.start()---默认执行就是run方法里面的内容。
		（4）如果自定义线程要传参数，这时候必须要写init方法。必须在init中先调用父类的init（初始化父类。）
			调用父类的init方法有两种方法：
				super().__init__()
				threading.Tread.__init__(self)
	4、线程的名称：线程.name查看线程的名称。
		如果没有给线程自定义名称，默认线程的名称是：Thread-1,Thread-2,....
		自定义名称：  
		t = MyThread(name=str(i))
        t.start()
	5、线程的五种状态：
		线程的执行顺序是混乱：线程是cup调度的最小单位，线程的执行完全是由cpu调度所决定的。cpu如何来调度呢？是由线程状态决定。
	
		【图片】
	6、线程间公用数据的共享问题。
		多个线程多全局变量的更改，容易造成数据的混乱。
		解决办法：
			将线程对公有数据更改部分，用互斥锁锁起来，这两就可以解决这种问题。
			
			多线程避免多个线程同时处理公有变量。----解耦。
			import threading
			
			mutex = threading.Lock()#创建一个锁对象
			
			if mutex.acquire():#上锁。
				'''
				公有数据的处理代码
				'''
			mutex.release()#释放锁
			-----------------------------------
			mutex.acquire(True):默认情况就是True，线程到锁这里如果没有获取锁状态，就会被阻塞。
			mutex.acquire(False)：线程到锁这里如果没有获取锁状态，不会被阻塞。
			
		
四、多进程和多线程
	1、并发和并行
	
	
	
作业：
1、url：https://zu.fang.com/
思路：1、获取区域列表
	  2、进入区域列表，做分页
	  3、爬取的字段：
		标题
		位置
		租住方式
		规格
		大小
		朝向
		详情页链接
	4、将数据保存到excel
	5、提交两版本。一个简单py文件，oop（面向对象-class）
	6、用selenium来实现。

day07

一、mongo的配置
	1、新建文件夹：
		C:\MongoDB\Server\3.4\data\db
		C:\MongoDB\Server\3.4\data\logs
	2、配置环境变量：
		C:\MongoDB\Server\3.4\bin配置到path系统环境变量中。
	3、测试是否配置成功
		mongod --dbpath C:\MongoDB\Server\3.4\data\db
	4、配置服务：
		mongod --dbpath C:\MongoDB\Server\3.4\data\db --logpath C:\MongoDB\Server\3.4\data\logs\mongo.log --logappend --port 27017 --serviceName "MongoDB" --install
二、客户端和服务端命令
	服务器命令使用开启服务器，开启服务器才可以存储数据，查找数据。
	客户端用连接服务器，做crud操作。
	
	服务器命令：mongod
		--dbpath ---数据库存储数据文件的路径
		--port  端口，将来服务器在这个端口上绑定。
	客户端命令：mongo
		--port 端口号：指定连接哪个端口服务器。
	
	任务：在cmd中开启两个个mongo服务器,端口在27018，27019，用客户端分别连接他们。
	--host  ---》-h
	开启27018，打开一个cmd输入：
		mongod --dbpath C:\MongoDB\Server\3.4\data\db --port 27018 
	开启27019：重新打开cmd，输入：
		新建db文件夹：C:\MongoDB\Server\3.4\data\db2
		mongod --dbpath C:\MongoDB\Server\3.4\data\db2 --port 27019 
		
	开启客户端
		连接27018：
			mongo --port 27018
		连接27019：
			mongo --port 27019

作业：
	1，笔趣阁小说下载
		url:http://www.xbiquge.la/xuanhuanxiaoshuo/
		思路：进入首页，获取小说列表，进入小说，获取章节列表，在章节页面下载内容
		
		字段：
			小说名称
			章节名称
			章节内容
		保存：
			1.一本小说一个txt文件
			2.每本小说都是全的。
		进阶：
			1.用多线程---保证章节目录是有序的。

day08

一、MongoDB简介
SQL术语/概念
MongoDB术语/概念
解释/说明
database
database
数据库
table
collection
数据库表/集合
row
document
数据记录行/文档
column
field
数据字段/域
index
index
索引
table joins
表连接， MongoDB不支持
primary key
primary key
主键， MongoDB自动将_id字段设置为主键
1、mongodb 文档数据库,存储的是文档(Bson->json的二进制化).
    {name:'zhangsan',age:'9'}
2、MongoDB特点:内部执行引擎为JS解释器, 把文档存储成bson结构,在查询时,转换为JS对象,并可以通过熟悉的js语法来操作.
2、mongo和传统型数据库相比,最大的不同:
传统型数据库: 结构化数据, 定好了表结构后,每一行的内容,必是符合表结构的,就是说--列的个数,类型都一样.
mongo文档型数据库: 集合中存储的每篇文档,都可以有自己独特的结构(json对象都可以有自己独特的属性和值)
mongo数据库的collection不用提前创建（可以隐式创建。）。关系型数据库的表必须提前创建
3、mongodb数据库bin目录下的文件意义

在这里插入图片描述

bsondump.exe ：导出bsondump结构
mongo.exe：客户端---开启一个客户端，连接指定服务，crud
mongod.exe：服务端--开启一个mongo服务器
mongodump.exe：整体数据库导出（备份工具）
mongoexport.exe：导出易识别的json文档
mongofiles.exe：GridFS工具，内建的分布式文件系统
mongoimport.exe：数据导入程序
mongorestore.exe：数据恢复工具
mongos.exe：路由器（分片时使用）
mongostat.exe：监视程序

4、mongo入门命令
show dbs  查看当前的数据库
 use databaseName 选库
show collections 查看当前库下的collection，show tables
如何创建库?
    Mongodb的库是隐式创建,你可以use 一个不存在的库，然后在该库下创建collection,即可创建库
use dbname ---ues一个不存在的库
db.createCollection(‘collectionName’) ---在该库下面创建集合，就可以创建一个数据库
    即可创建一个集合。
其实在MongoDB中，collection也是可以隐身创建的
db.collectionName.insert(document)
如何删除数据库和集合？
db.collectionName.drop()//删除集合
db.dropDatabase()//删除数据库

二、MongoDB基础增删改查操作
1、增：insert方法
首先要明确一点，MongoDB存储的时文档，文档其实就是json格式的对象。
语法：
db.collectionName.insert(document)
增加单篇文档：
db.collectionName.insert({title:’nice day’})
增加单个文档,并指定_id
db.collectionName.insert({_id:8,age:78,name:’lisi’})
增加多个文档
db.collectionName.insert(
[
{time:'friday',study:'mongodb'},
{_id:9,gender:'male',name:'QQ'}
]
)
2、删除：remove
语法:
 db.collection.remove(查询表达式, 选项)
选项是指  {justOne:true/false},是否只删一行, 默认为false
注意：
1: 查询表达式依然是个json对象 {age:20}
2: 查询表达式匹配的行,将被删掉.
3: 如果不写查询表达式,collections中的所有文档将被删掉
例1:删除stu表中 sn属性值为’001’的文档
 db.stu.remove({sn:’001’})
例2: 删除stu表中gender属性为m的文档,只删除1行.
db.stu.remove({gender:’m’,true});

3、更新：update
语法: db.collection.update(查询表达式,新值,选项)

改谁? --- 查询表达式
改成什么样? -- 新值 或 赋值表达式
操作选项 ----- 可选参数
例:
db.news.update({name:'QQ'},{name:'MSN'});
是指选中news表中,name值为QQ的文档,并把其文档值改为{name:’MSN’},结果: 文档中的其他列也不见了,改后只有_id和name列了，即--新文档直接替换了旧文档,而不是修改
如果是想修改文档的某列,可以用$set关键字：
db.collectionName.update(query,{$set:{name:’QQ’}})
修改时的赋值表达式
$set 修改某列的值
$unset 删除某个列
$rename 重命名某个列
$inc 增长某个列
Option的作用:{upsert:true/false,multi:true/false}
Upsert---是指没有匹配的行,则直接插入该行.
例:
db.stu.update({name:'wuyong'},{$set:{name:'junshiwuyong'}},{upsert:true});
如果有name=’wuyong’的文档,将被修改，如果没有,将添加此新文档
db.news.update({_id:99},{x:123,y:234},{upsert:true});
没有_id=99的文档被修改,因此直接插入该文档
multi: 是指修改多行(即使查询表达式命中多行,默认也只改1行,如果想改多行,可以用此选项)
db.news.update({age:21},{$set:{age:22}},{multi:true});
    则把news中所有age=21的文档,都修改
4、查: find
语法: db.collection.find(查询表达式,查询的列);
db.collections.find(表达式,{列1:1,列2:1});
    在查询的列参数中，1表示显示，0表示不显示
例1:db.stu.find()
    查询所有文档 所有内容
例2: db.stu.find({},{gendre:1})
    查询所有文档,的gender属性 (_id属性默认总是查出来)
例3: db.stu.find({},{gender:1, _id:0})
    查询所有文档的gender属性,且不查询_id属性
例4: db.stu.find({gender:’male’},{name:1,_id:0});
    查询所有gender属性值为male的文档中的name属性
    2. MongoDB AND 条件
    MongoDB 的 find() 方法可以传入多个键(key)，每个键(key)以逗号隔开，及常规 SQL 的 AND 条件。类似于 WHERE 语句：WHERE by='优就业' AND title='MongoDB 教程。
    语法格式如下：
db.col.find({key1:value1， key2:value2}).pretty()
    3、常用方法：
limit():
db.COLLECTION_NAME.find().limit(NUMBER)
skip()
db.COLLECTION_NAME.find().limit(NUMBER).skip(NUMBER)
sort()
db.COLLECTION_NAME.find().sort({KEY:1})
count()
 db.mycol.count()
5、查询表达式:
最简单的查询表达式
    {filed:value} ,是指查询field列的值为value的文档
$lt小于
db.stu.find({age:{$lt:10}},{name:1,age:1})
$lte小于等于
$gt 大于
$gte大于等于
$ne --- != 查询表达式
{field:{$nq:value}} ---作用：查filed列的值 不等于 value 的文档
db.goods.find({cat_id:{$nq:3}},{cat_id:1,goods_id:1,goods_name:1,_id:0})
//查询cat_id不等3的数据
$nin --> not in
db.stu.find({age:{$nin:[1,16]}})
$all：指数组所有单元匹配，就是指我指定的内容都要有，通过一个list来指定
db.stu.insert({name:'xt',age:99,hobby:['aa','bb']})
db.stu.find({hobby:{$all:['aa','bb']}},{name:1,age:1,_id:0})
$exists
        语法: {field:{$exists:1}}
        作用: 查询出含有field字段的文档
 db.stu.find({hobby:{$exists:1}})
$nor
{$nor:[条件1,条件2]} 是指  所有条件都不满足的文档为真返回
$and
        {$and:[条件1,条件2]} 是指  所有条件都满足，就为真
$or
        {$or:[条件1,条件2]} 是指  条件1和条件2有一个满足，就为真
基础查询 where的练习

练习文档

对应的mysql数据: $sql = 'select goods_id,cat_id,goods_name,goods_number,click_count,shop_price,add_time from ecs_goods';

mongodb数组:
[{"goods_id":1,"cat_id":4,"goods_name":"KD876","goods_number":1,"click_count":7,"shop_price":1388.00,"add_time":1240902890},{"goods_id":4,"cat_id":8,"goods_name":"\u8bfa\u57fa\u4e9aN85\u539f\u88c5\u5145\u7535\u5668","goods_number":17,"click_count":0,"shop_price":58.00,"add_time":1241422402},{"goods_id":3,"cat_id":8,"goods_name":"\u8bfa\u57fa\u4e9a\u539f\u88c55800\u8033\u673a","goods_number":24,"click_count":3,"shop_price":68.00,"add_time":1241422082},{"goods_id":5,"cat_id":11,"goods_name":"\u7d22\u7231\u539f\u88c5M2\u5361\u8bfb\u5361\u5668","goods_number":8,"click_count":3,"shop_price":20.00,"add_time":1241422518},{"goods_id":6,"cat_id":11,"goods_name":"\u80dc\u521bKINGMAX\u5185\u5b58\u5361","goods_number":15,"click_count":0,"shop_price":42.00,"add_time":1241422573},{"goods_id":7,"cat_id":8,"goods_name":"\u8bfa\u57fa\u4e9aN85\u539f\u88c5\u7acb\u4f53\u58f0\u8033\u673aHS-82","goods_number":20,"click_count":0,"shop_price":100.00,"add_time":1241422785},{"goods_id":8,"cat_id":3,"goods_name":"\u98de\u5229\u6d669@9v","goods_number":1,"click_count":9,"shop_price":399.00,"add_time":1241425512},{"goods_id":9,"cat_id":3,"goods_name":"\u8bfa\u57fa\u4e9aE66","goods_number":4,"click_count":20,"shop_price":2298.00,"add_time":1241511871},{"goods_id":10,"cat_id":3,"goods_name":"\u7d22\u7231C702c","goods_number":7,"click_count":11,"shop_price":1328.00,"add_time":1241965622},{"goods_id":11,"cat_id":3,"goods_name":"\u7d22\u7231C702c","goods_number":1,"click_count":0,"shop_price":1300.00,"add_time":1241966951},{"goods_id":12,"cat_id":3,"goods_name":"\u6469\u6258\u7f57\u62c9A810","goods_number":8,"click_count":13,"shop_price":983.00,"add_time":1245297652}]

[{"goods_id":13,"cat_id":3,"goods_name":"\u8bfa\u57fa\u4e9a5320 XpressMusic","goods_number":8,"click_count":13,"shop_price":1311.00,"add_time":1241967762},{"goods_id":14,"cat_id":4,"goods_name":"\u8bfa\u57fa\u4e9a5800XM","goods_number":1,"click_count":6,"shop_price":2625.00,"add_time":1241968492},{"goods_id":15,"cat_id":3,"goods_name":"\u6469\u6258\u7f57\u62c9A810","goods_number":3,"click_count":8,"shop_price":788.00,"add_time":1241968703},{"goods_id":16,"cat_id":2,"goods_name":"\u6052\u57fa\u4f1f\u4e1aG101","goods_number":0,"click_count":3,"shop_price":823.33,"add_time":1241968949},{"goods_id":17,"cat_id":3,"goods_name":"\u590f\u65b0N7","goods_number":1,"click_count":2,"shop_price":2300.00,"add_time":1241969394},{"goods_id":18,"cat_id":4,"goods_name":"\u590f\u65b0T5","goods_number":1,"click_count":0,"shop_price":2878.00,"add_time":1241969533},{"goods_id":19,"cat_id":3,"goods_name":"\u4e09\u661fSGH-F258","goods_number":12,"click_count":7,"shop_price":858.00,"add_time":1241970139},{"goods_id":20,"cat_id":3,"goods_name":"\u4e09\u661fBC01","goods_number":12,"click_count":14,"shop_price":280.00,"add_time":1241970417},{"goods_id":21,"cat_id":3,"goods_name":"\u91d1\u7acb A30","goods_number":40,"click_count":4,"shop_price":2000.00,"add_time":1241970634},{"goods_id":22,"cat_id":3,"goods_name":"\u591a\u666e\u8fbeTouch HD","goods_number":1,"click_count":15,"shop_price":5999.00,"add_time":1241971076}]

[{"goods_id":23,"cat_id":5,"goods_name":"\u8bfa\u57fa\u4e9aN96","goods_number":8,"click_count":17,"shop_price":3700.00,"add_time":1241971488},{"goods_id":24,"cat_id":3,"goods_name":"P806","goods_number":100,"click_count":35,"shop_price":2000.00,"add_time":1241971981},{"goods_id":25,"cat_id":13,"goods_name":"\u5c0f\u7075\u901a\/\u56fa\u8bdd50\u5143\u5145\u503c\u5361","goods_number":2,"click_count":0,"shop_price":48.00,"add_time":1241972709},{"goods_id":26,"cat_id":13,"goods_name":"\u5c0f\u7075\u901a\/\u56fa\u8bdd20\u5143\u5145\u503c\u5361","goods_number":2,"click_count":0,"shop_price":19.00,"add_time":1241972789},{"goods_id":27,"cat_id":15,"goods_name":"\u8054\u901a100\u5143\u5145\u503c\u5361","goods_number":2,"click_count":0,"shop_price":95.00,"add_time":1241972894},{"goods_id":28,"cat_id":15,"goods_name":"\u8054\u901a50\u5143\u5145\u503c\u5361","goods_number":0,"click_count":0,"shop_price":45.00,"add_time":1241972976},{"goods_id":29,"cat_id":14,"goods_name":"\u79fb\u52a8100\u5143\u5145\u503c\u5361","goods_number":0,"click_count":0,"shop_price":90.00,"add_time":1241973022},{"goods_id":30,"cat_id":14,"goods_name":"\u79fb\u52a820\u5143\u5145\u503c\u5361","goods_number":9,"click_count":1,"shop_price":18.00,"add_time":1241973114},{"goods_id":31,"cat_id":3,"goods_name":"\u6469\u6258\u7f57\u62c9E8 ","goods_number":1,"click_count":5,"shop_price":1337.00,"add_time":1242110412},{"goods_id":32,"cat_id":3,"goods_name":"\u8bfa\u57fa\u4e9aN85","goods_number":4,"click_count":9,"shop_price":3010.00,"add_time":1242110760}]



cageory表 ,对应的mysql数据: select cat_id,cat_name from ecs_category;

[{"cat_id":1,"cat_name":"\u624b\u673a\u7c7b\u578b"},{"cat_id":2,"cat_name":"CDMA\u624b\u673a"},{"cat_id":3,"cat_name":"GSM\u624b\u673a"},{"cat_id":4,"cat_name":"3G\u624b\u673a"},{"cat_id":5,"cat_name":"\u53cc\u6a21\u624b\u673a"},{"cat_id":6,"cat_name":"\u624b\u673a\u914d\u4ef6"},{"cat_id":7,"cat_name":"\u5145\u7535\u5668"},{"cat_id":8,"cat_name":"\u8033\u673a"},{"cat_id":9,"cat_name":"\u7535\u6c60"},{"cat_id":11,"cat_name":"\u8bfb\u5361\u5668\u548c\u5185\u5b58\u5361"},{"cat_id":12,"cat_name":"\u5145\u503c\u5361"},{"cat_id":13,"cat_name":"\u5c0f\u7075\u901a\/\u56fa\u8bdd\u5145\u503c\u5361"},{"cat_id":14,"cat_name":"\u79fb\u52a8\u624b\u673a\u5145\u503c\u5361"},{"cat_id":15,"cat_name":"\u8054\u901a\u624b\u673a\u5145\u503c\u5361"}]

练习题目

//主键为32的商品
 db.goods.find({goods_id:32});
//不属第3栏目的所有商品($ne)
 db.goods.find({cat_id:{$ne:3}},{goods_id:1,cat_id:1,goods_name:1});

//本店价格高于3000元的商品{$gt}
 db.goods.find({shop_price:{$gt:3000}},{goods_name:1,shop_price:1});

//本店价格低于或等于100元的商品($lte)
 db.goods.find({shop_price:{$lte:100}},{goods_name:1,shop_price:1});

//取出第4栏目或第11栏目的商品($in)
 db.goods.find({cat_id:{$in:[4,11]}},{goods_name:1,shop_price:1});


//取出100<=价格<=500的商品($and)
db.goods.find({$and:[{price:{$gt:100},{$price:{$lt:500}}}]);


//取出不属于第3栏目且不属于第11栏目的商品($and $nin和$nor分别实现)
 db.goods.find({$and:[{cat_id:{$ne:3}},{cat_id:{$ne:11}}]}
 ,{goods_name:1,cat_id:1})
 db.goods.find({cat_id:{$nin:[3,11]}},{goods_name:1,cat_id:1});
 db.goods.find({$nor:[{cat_id:3},{cat_id:11}]},{goods_name:1,cat_id:1});


//取出价格大于100且小于300,或者大于4000且小于5000的商品()
db.goods.find({
$or:[ 
      {
        $and:[
            {shop_price:{$gt:100}},
            {shop_price:{$lt:300}}
             ]
       },
       {
        $and:[
            {shop_price:{$gt:4000}},
            {shop_price:{$lt:5000}}
             ]
        }
    ]},{goods_name:1,shop_price:1});



//取出goods_id%5 == 1, 即,1,6,11,..这样的商品
db.goods.find({goods_id:{$mod:[5,1]}});


//取出有age属性的文档
db.stu.find({age:{$exists:1}});
含有age属性的文档将会被查出
6、MongoDB 聚合(db.col.aggregate())
    MongoDB中聚合(aggregate)主要用于处理数据(诸如统计平均值，求和等)，并返回计算后的数据结果。有点类似sql语句中的 count(*)。
    语法：
db.COLLECTION_NAME.aggregate(
[
    {管道1},
    {管道2},
    {管道3}，
    ...
]
)
MongoDB的聚合管道将MongoDB文档在一个管道处理完毕后将结果传递给下一个管道处理,管道操作是可以重复的。
聚合框架中常用的几个管道操作：
$project：修改输入文档的结构。可以用来重命名、增加或删除域，也可以用于创建计算结果以及嵌套文档。
$match：用于过滤数据，只输出符合条件的文档。$match使用MongoDB的标准查询操作。
$limit：用来限制MongoDB聚合管道返回的文档数。
$skip：在聚合管道中跳过指定数量的文档，并返回余下的文档。
$group：将集合中的文档分组，可用于统计结果。
$sort：将输入文档排序后输出。
group中的一下操作表达式：

表达式
描述
$sum
计算总和。
$avg
计算平均值
$min
获取集合中所有文档对应值得最小值。
$max
获取集合中所有文档对应值得最大值。
$first
根据资源文档的排序获取第一个文档数据。
$last
根据资源文档的排序获取最后一个文档数据
聚合操作练习：
1.查询每个栏目下的商品数量 
db.collection.aggregate(); [{$group:{_id:"$cat_id",total:{$sum:1}}}]  
2.查询goods下有多少条商品
db.goods.aggregate([{$group:{_id:null,total:{$sum:1}}}])
3.查询每个栏目下价格大于50元的商品个数 
db.goods.aggregate([{$match:{shop_price:{$gt:50}}}, {$group:{_id:"$cat_id",total:{$sum:1}}}])
4.查询每个栏目下的库存量 
db.goods.aggregate([{$group:{_id:"$cat_id" , total:{$sum:"$goods_number"}}}])
5.查询每个栏目下 价格大于50元的商品个数 #并筛选出"满足条件的商品个数" 大于等于3的栏目
（1）价格大于50：
    {$match:{shop_price:{$gt:50}}}
（2）要想查出个数大于3的栏目，必须先对cat_id进行分组：
{$group:{_id:"$cat_id",total:{$sum:1}}}
（3）最后用match来去除大于3个的栏目
{$match:{total:{$gte:3}}}
6.查询每个栏目下的库存量,并按库存量排序 
思路：
（1）按栏目的库存量分组（2）排序
{$group:{_id:"$cat_id" , total:{$sum:"$goods_number"}}}
 {$sort:{total:1}}
db.goods.aggregate([{$group:{_id:"$cat_id" , total:{$sum:"$goods_number"}}}, {$sort:{total:1}}])
1是正序，-1是逆序
7.查询每个栏目的商品平均价格,并按平均价格由高到低排序
db.goods.aggregate([{$group:{_id:"$cat_id",avg:{$avg:"$shop_price"}}},{$sort:{avg:-1}}]) 

三、游标操作
前面给大家讲过，MongoDB在底层上时用js来实现的，所以我们可以通过以下代码，在数据库中插入1000条数据。
for (var i=0;i<1000;i++){
db.bar.insert({_id:i+1,title:'hello world'+i,content:'aaa'+i})
}
    我们可以看出，上面就是js的for循环代码。所以在MongoDB中可以将js代码和我们的数据库做操作指令一起配合来使用。
如果数据库中很多数据，比如刚刚插入的1000条，我们执行以下命令：
db.bar.find()
     他会将所有的数据都查询出来给我们，此时我们考虑是否能让我们在查询的时候，像python中生成器那样，每次给我们返回一个数据。其实在MongoDB中也有类似生成器这样的东东，他叫游标
1、游标是什么？
	mongo的游标相当于python中的迭代器。通过将查询结构定义给一个变量，这个变量就是游标。通过这个游标，我们可以每次获取一个数据。
2、游标的声明：
var curor_name = db.bar.find()
3、游标的操作：
curor.hasNext()//判断游标是否已经取到尽头，|true表示没有到尽头。
curor.next()//取出游标的下一个单元
例如：
var mycusor = db.bar.find().limit(5)
print(mycusor.next())//会显示是一个bson格式的数据
printjson(mycusor.next())
我们可以写一个while循环来打印游标结果：
while(mycusor.hasNext()){
		printjson(mycusor.next())
}
游标还有一个toArray()方法，方便我们可以看到所有行
print(mycusor.toArray())//看到所有行
	print(mycusor.toArray()[2])//看到第二行
注意不要使用toArray（），原因是会把所有的行立即以对象的形式放在内存中，可以再取出少数几行时，使用此功能。
4、cursor.forEach(回调函数)
    
var gettile = function(obj){print(obj.goods_name)}
var cursor = db.goods.find()
cursor.forEach(gettile)

5、游标在分页中的应用
一般的，我们假设每页N行，当前是page页，就需要跳过（page-1）*N，再取N行，在mysql中，用limit，offset,N来实现，在MongoDB中，用skip(),limit()函数来实现。
var mycusor = db.bar.find().skip(90).limit(10)//跳过90条，取10条。

 var mycursor = db.bar.find().skip(9995);
则是查询结果中,跳过前9995行

查询第901页,每页10条
则是 var mytcursor = db.bar.find().skip(9000).limit(10);

四、索引创建
索引提高查询速度,降低写入速度,[权衡常用的查询字段,不必在太多列上建索引]
在mongodb中,索引可以按字段升序/降序来创建,便于排序
默认是用btree来组织索引文件,2.4版本以后,也允许建立hash索引

    常用命令：
	(1)查看当前索引状态：db.collection.getIndexes()
	(2)创建普通单列索引：db.collection.ensureIndex({field:1/-1})//1为正序，-1为逆序
	(3)删除单个索引：db.collection.dropIndex({field:1/-1})
	(4)删除所有索引：db.collection.dropIndexes()
        _id所在的列的索引不能删除。
	(5)创建多列索引：db.collection.ensureIndex({field1:1/-1，field2:1/-1})
	多列索引的使用范围更广，因为一般情况下，我们都是通过多个字段来进行查询数据的，这时候单列索引其实用不到。
	两个列一起建立索引其实就是将两个列绑定到一起，来创建索引

      （6）子文档索引： 
	子文档查询：
	1.插入两条带子文档的数据
db.shop. insert({name: 'N0kia' , SPC: {weight: 120 , area: ' taiwan ' } } ) ;
db.shop. insert({name: 'sanxing ' , SPC ：{weight: 100 , area: 'hanguo'} } ) ;
	2.查询出产地在台湾的手机
db.shop.find({'spc.area':'taiwan'})
	给子文档加索引：
db.shop.ensureIndex({'spc.area':1})//子文档就点就可以了
	(7)	唯一索引：{unique:true}
db.collection.ensureIndex({field:1/-1},{unique:true})
	唯一索引的列不能重复插入
    
     （8）hash索引：
db.collection.ensureIndex({field:'hashed'})

五、MongoDB数据的导入导出
1、通用选项：
导入/导出可以操作的是本地的mongodb服务器,也可以是远程的.
所以,都有如下通用选项:
--host host   主机
--port port    端口
-u username 用户名
-p passwd   密码
2、mongoexport 导出json格式的文件
-d  库名
-c  表名
-f  field1,field2...列名
-q  查询条件
-o  导出的文件名
--type csv  导出csv格式(便于和传统数据库交换数据)
例1：
mongoexport -d test -c news -o test.json
例2: 只导出goods_id,goods_name列
mongoexport -d test -c goods -f goods_id,goods_name -o goods.json
例3: 只导出价格低于1000元的行
mongoexport -d test -c goods -f goods_id,goods_name,shop_price -q ‘{shop_price:{$lt:200}}’ -o goods.json
注: _id列总是导出
当初csv文件的时候，需要指定导出哪些列。
mongoexport -d shop -c goods -o goods.csv --type csv -f goods_id,cat_id,goods_name,shop_price
3、Mongoimport 导入
-d 待导入的数据库
-c 待导入的表(不存在会自己创建)
--file 备份文件路径
例1: 导入json
mongoimport -d test -c goods --file ./goodsall.json
例2: 导入csv
mongoimport -d test -c goods --type csv -f goods_id,goods_name --file ./goodsall.csv
4、mongodump 导出二进制bson结构的数据及其索引信息
-d  库名
-c  表名
mongodum -d test  [-c 表名]  默认是导出到mongo下的dump目录
规律:
导出的文件放在以database命名的目录下
每个表导出2个文件,分别是bson结构的数据文件, json的索引信息
如果不声明表名, 导出所有的表
5、mongorestore 导入二进制文件
mongorestore -d shop -c goods --dir ./dump/shop/goods.bson

二进制备份,不仅可以备份数据,还可以备份索引,备份数据比较小.速度比较快。

六、replaction复制集
       一般情况下，我们通常在机器上安装了一个数据库，这是我们的数据都是存在这个数据库中的，如果有一天，因为一些不可控因素导致数据库宕机或者数据库的文件丢失，此时损失就很大了。针对于这种问题，我们希望有一个数据库集，在我们其中一个数据库进行插入的时候，其他数据库也能插入数据，这样其中一台服务器宕机了，也能够使我们的数据正常存取。
在MongoDB中，是通过replaction复制集来实现此功能的。
在Windows下实现复制集的方法：

创建复制集之前，把所有的mongo服务器都关掉
1、创建三个存储数据库的文件夹，用来保存数据文件

在这里插入图片描述

2、打开三个cmd窗口，分别启动三个mongodb
mongod --dbpath C:\MongoDB\Server\3.4\data\m1 --logpath C:\MongoDB\Server\3.4\data\logs\mongo1.log --port 27017 --replSet rs
mongod --dbpath C:\MongoDB\Server\3.4\data\m2 --logpath C:\MongoDB\Server\3.4\data\logs\mongo2.log --port 27018 --replSet rs
mongod --dbpath C:\MongoDB\Server\3.4\data\m3 --logpath C:\MongoDB\Server\3.4\data\logs\mongo3.log --port 27019 --replSet rs

其中的--replSet就表示创建的数据集的名称，必须指定相同的名称才可以。
3、配置
var rsconf = {
	_id:'rs',
	members:[
			{_id:0,host:'127.0.0.1:27017'},
			{_id:1,host:'127.0.0.1:27018'},
			{_id:2,host:'127.0.0.1:27019'}
			]
}

这时候我们可以打印rsconf来看一下
printjson(rsconf)
接下来需要将配置初始化
rs.initiate(rsconf)
现在我们看到，现在登录客户端已经不是哪台机器，而是rs复制集

在这里插入图片描述

我们在主机上插入一条数据，再从机上必须输入rs.slaveOk()之后才能被允许查看数据
5、删除复制集
rs.remove('127.0.0.1:27019')
删除节点后，如果想再添加，必须重新配置才可以。
var rsconf = {
	_id:'rs',
	members:[
			{_id:0,host:'127.0.0.1:27017'},
			{_id:1,host:'127.0.0.1:27018'},
			{_id:2,host:'127.0.0.1:27019'}
			]
	}
	在输入：rs.reconfig(rsconf)
在输入rs.status(),可以看到数据集现在又是三个了。

day09

一、Redis基础知识
redis的客户端和服务端命令：
redis-server :服务器命令
    启动一个redis的命令是：redis-server redis.windows.conf
redis-cli:客户端命令
    启动一个客户端的redis命令：redis-cli  -p 6379  
一个redis.windows.conf配置就是一个redis服务器。需要启动多个服务器时，只需要修改一下这个配置文件redis.windows.conf的名称，更改端口号，再用redis-server就可以启动。
要求：启动一个端口号在6380上的redis服务器。
    1.创建配置文件如下：

在这里插入图片描述

3、用如下命令启动

1、redis和memcached相比,的独特之处:
redis可以持久化数据到硬盘，memcached只能做缓存。
        redis可以用来做存储(storge),也就是redis可以将数据持久化到硬盘。 而memccached是用来做缓存(cache)  这个特点主要因为其有”持久化”的功能.
redis相比于memcached，其支持的数据类型更多。
        存储的数据有”结构”,对于memcached来说,存储的数据,只有1种类型--”字符串”,  而redis则可以存储字符串,链表,哈希结构,集合,有序集合.
2、redis的优点
读写速度快. 数据存放在内存中,数据结构类似于HashMap，HashMap的优势就是查找和操作的时间复杂度都是O(1)
支持丰富的数据类型,string,hash,list,set,sorted
支持简单事务,watch
丰富的特性:可以用于缓存,消息队列,按key设置过期时间,到期后自动删除
支持数据持久化(将内存数据持久化到磁盘),支持AOF和RDB两种持久化方式,从而进行数据恢复操作,可以有效地防止数据丢失
支持主从(master-slave)复制来实现数据备份,主机会自动将数据同步到从机

2、Redis目录下的重要文件的意义：
redis-benchmark 性能测试工具
redis-check-aof 日志文件检测工(比如断电造成日志损坏,可以检测并修复)
redis-check-dump 快照文件检测工具,效果类上
redis-cli 客户端
redis-server 服务端
redis.windows.conf redis配置文件，在启动redis服务器的时候，必须要指定配置文件，那么相当于于一个配置文件就是一个redis数据库服务器。
redis服务器启动命令：
redis-server redis.windows.conf
3、redis基础命令：
keys * //返回键(key)
keys list* //返回名以list开头的所有键(key)
exists list1 //判断键名为list1的是否存在 存在返回1， 不存在返回0
del list1 //删除一个键(名为list1)
expire list1 10 //设置键名为list1的过期时间为10秒后
ttl list1 //查看键名为list1的过期时间，若为-1表示已过期 或 永不过期
move age 1 //将键名age的转移到1数据库中。
select 1 //表示进入到1数据库中，默认在0数据库
persist age //移除age的过期时间。
flushdb:删除所有的数据 清除当前所在库的所有数据
flushall 清空所有数据
二、redis数据类型
（一）String字符串
set
get
mset
mget
setnx
msetnx
incr
decr
incrby
decrby
setrange
getrange

set方法：设置key对应的值为string类型的value，如果该key已经存在，则覆盖key对应的value值。所以在redis中key只能有一个。
127.0.0.1:6379> set name lijie
get:根据key获取value值
127.0.0.1:6379> get name
Setnx：设置一个不存的字符串，返回0 表示设置失败，已存在。返回1 表示设置新值成功，nx是not exist的意思。
127.0.0.1:6379> setnx name zs
(integer) 0
127.0.0.1:6379> setnx age 20
(integer) 1
setex：设置字符串，同时设置有效期。ex---expire(有效期)
127.0.0.1:6379> setex color 10 red
OK
立即查询
127.0.0.1:6379> get color"red"
10秒后查询
127.0.0.1:6379> get color
(nil)
Setrange：替换字符串。
setrange 替换什么 从哪里开始（0） 替换成什么

127.0.0.1:6379> set email jalja@sina.com
OK
127.0.0.1:6379> get email
"jalja@sina.com"
127.0.0.1:6379> setrange email 6 163.com
(integer) 14
127.0.0.1:6379> get email
"jalja@163.comm"
Mset：一次设置多个key-value，返回OK表示全部设置成功，返回0表示全部失败。如果存在则替换。m--multi
127.0.0.1:6379> mset name1 zs name2 ls
OK
127.0.0.1:6379> get name1
"zs"
127.0.0.1:6379> get name2
"ls"
msetnx：一次设置多个不存在的key-value，返回1表示全部设置成功，返回0表示全部失败。
127.0.0.1:6379> msetnx name3 kk name4 mm name2 LL
(integer) 0
127.0.0.1:6379> get name3
(nil)
127.0.0.1:6379> get name4
(nil)
getset：获取原值，并设置新值
127.0.0.1:6379> getset name4 UU
(nil)
127.0.0.1:6379> get name4
"UU"
127.0.0.1:6379> getset name4 RR
"UU"
getrange：获取key对应value的子字符串
127.0.0.1:6379> get email
"jalja@163.comm"
127.0.0.1:6379> getrange email 0 4
"jalja"
mget：一次获取多个key对应的value值，不存在返回nil
127.0.0.1:6379> mget name1 name2 name3 name4 name5
1) "zs"
2) "ls"
3) (nil)
4) "RR"
5) (nil)
incr：对key对应的value做加1操作，并返回新值
127.0.0.1:6379> get age
"20"
127.0.0.1:6379> incr age
(integer) 21
incrby:与incr类似，加指定值，key不存在的时候会设置key，并认为该key原来的value=0
127.0.0.1:6379> get age
"21"
127.0.0.1:6379> incrby age 9
(integer) 30
127.0.0.1:6379> incrby age -5
(integer) 25
127.0.0.1:6379> incrby height 10
(integer) 10
decr：对key对应的value做减1操作
127.0.0.1:6379> get height
"10"
127.0.0.1:6379> decr height
(integer) 9
127.0.0.1:6379> decr height
(integer) 8
decrby：对key对应的value减去指定的值
127.0.0.1:6379> get height
"8"
127.0.0.1:6379> decrby height 3
(integer) 5
127.0.0.1:6379> decrby height -3
(integer) 8
append：对key对应的vlaue字符串追加，返回新字符串的长度
127.0.0.1:6379> get name1
"zs"
127.0.0.1:6379> append name1 ML
(integer) 4
127.0.0.1:6379> get name1
"zsML"
strlen：获取key对应value的长度
127.0.0.1:6379> get name1
"zsML"
127.0.0.1:6379> strlen name1
(integer) 4
（二）Hash类型
     Redis hash 是一个string类型的filed和value的映射表、它的添加、删除操作都是O(1)（平均操作）。Hash特别适合存储对象。相较于对象的每个字段存成单个string类型。将一个对象存储在hash类型中会占用更少的内存，并且可以更方便存取整个对象。
1、hset：设置hash filed 为指定值，如果key不存在，则先创建。key存在则替换
127.0.0.1:6379> hset user:001 name zs
(integer) 1
127.0.0.1:6379> hget user:001 name
"zs"
#设置一个user：001 的用户的name为zs（可以将user:001看做一个表）
	2.hget：获取指定field字段的值
127.0.0.1:6379> hget user:001 name
(nil)
3、 hsetnx：设置hash filed 为指定值，如果key不存在，则先创建。如果存在则返回0表示设置失败。
127.0.0.1:6379> hsetnx user:001 name ML
(integer) 0
127.0.0.1:6379> hsetnx user:001 age 1
(integer) 1
3、hmset：同时设置hash的多个file
127.0.0.1:6379> hmset user:002 name MM age 20
OK
127.0.0.1:6379> hget user:002 name
"MM"
127.0.0.1:6379> hget user:002 age
"20"
4、hmget：获取全部指定的hash filed，必须指定获取的key的名称
127.0.0.1:6379> hmget user:002 name age
1) "MM"
2) "20"
5、hincrby：对hash filed加上指定的值
127.0.0.1:6379> hget user:002 age
"20"
127.0.0.1:6379> hincrby user:002 age 5
(integer) 25
127.0.0.1:6379> hincrby user:002 age -5
(integer) 20
6、hexists：测试指定的filed是否存在，返回1表示存在，返回0表示不存在
127.0.0.1:6379> hexists user:002 name
(integer) 1
127.0.0.1:6379> hexists user:002 age
(integer) 1
127.0.0.1:6379> hexists user:002 height
(integer) 0
7、hlen：返回指定hash的field的数量
127.0.0.1:6379> hlen user:002
(integer) 2
8、hdel 删除指定hash 的filed字段，返回1表示删除成功0:表示删除失败
127.0.0.1:6379> hget  user:002 age
"20"
127.0.0.1:6379> hdel user:002 age
(integer) 1
127.0.0.1:6379> hdel user:002 age
(integer) 0
127.0.0.1:6379> hget user:002 age
(nil)
9、hkeys：返回hash 的所有filed
127.0.0.1:6379> hkeys user:001
1) "name"
2) "age"
127.0.0.1:6379> hkeys user:002
1) "name"
10、hvals：返回hash的所有value
127.0.0.1:6379> hvals user:001
1) "zs"
2) "1"
127.0.0.1:6379> hvals user:002
1) "MM"
 
（三）List类型 
       List是一个链表结构，主要功能是push、pop，获取一个范围的所有值等等，操作中key理解为链表的名字。Redis的list类型其实就是一个每个子元素都是string类型的双向链表。我们可以通过push、pop操作链表的头部或者链表尾部添加元素，这样list既可以作为栈，又可以作为队列。
1、lpush：在key对应list的头部添加字符串元素，返回list中元素的个数
127.0.0.1:6379> lpush list1 "hello"
(integer) 1
127.0.0.1:6379> lpush list1 "word"
(integer) 2
2、lrange：获取list中的元素，
127.0.0.1:6379> lrange list1 0 -1（0：第一个，-1：最后一个）
1) "word"
2) "hello"
3、rpush：在key对应的list尾部添加元素
127.0.0.1:6379> rpush list2 10
(integer) 1
127.0.0.1:6379> rpush list2 11
(integer) 2
127.0.0.1:6379> lrange list2 0 -1
1) "10"
2) "11"
4、linsert：在key对应list的特定位置前或后添加字符串
127.0.0.1:6379> lrange list2 0 -1
1) "10"
2) "11"
127.0.0.1:6379> linsert list2 before 11 10.5
(integer) 3
127.0.0.1:6379> linsert list2 after 11 11.5
127.0.0.1:6379> lrange list2 0 -1
1) "10"
2) "10.5"
3) "11"
4)"11.5"
5、lset：更改list中指定下标的元素，返回ok表示设置成功
127.0.0.1:6379> lrange list2 0 -1
1) "10"
2) "10.5"
3) "11"
127.0.0.1:6379> lset list2 1 10.00
OK
127.0.0.1:6379> lrange list2 0 -1
1) "10"
2) "10.00"
3) "11"
6、lrem：从key对应list中删除n个和value相同的元素（n<0 从尾部删除，n=0 全部删除,n>0从头部删除。）
127.0.0.1:6379> lrange list 0 -1
1) "two"
2) "one"
3) "one"
127.0.0.1:6379> lrem list 1 one
(integer) 1
127.0.0.1:6379> lrange list 0 -1
1) "two"
2) "one"
7、ltrim：保留list中指定范围的数据，其他的都不要了
127.0.0.1:6379> lrange list2 0 -1
1) "10"
2) "10.00"
3) "11"
4) "12"
127.0.0.1:6379> ltrim list2 1 2
OK
127.0.0.1:6379> lrange list2 0 -1
1) "10.00"
2) "11"
8、lpop：从list的头部删除元素，并返回该元素
127.0.0.1:6379> lrange list 0 -1
1) "two"
2) "one"
127.0.0.1:6379> lpop list
"two"
127.0.0.1:6379> lrange list 0 -1
1) "one"
 9、rpop：从list尾部删除元素，并返回该元素
10、rpoplpush：从第一个list的尾部删除元素，并添加到第二个list的头部
127.0.0.1:6379> lrange list 0 -1
1) "one"
127.0.0.1:6379> lrange list1 0 -1
1) "word"
2) "hello"
127.0.0.1:6379> rpoplpush list1 list
"hello"
127.0.0.1:6379> lrange list 0 -1
1) "hello"
2) "one"
127.0.0.1:6379> lrange list1 0 -1
1) "word"
11、lindex 返回名称为key的list中index位置的元素<===>list[index]
127.0.0.1:6379> lrange list 0 -1
1) "hello"
2) "one"
127.0.0.1:6379> lindex list 1
"one"
12、llen：返回指定key对应list的长度<====> len(list)
127.0.0.1:6379> lrange list 0 -1
1) "hello"
2) "one"
127.0.0.1:6379> llen list
(integer) 2
（三）Sets类型
   Set是一个string类型的无序集合，不允许重复。Set是通过hash table实现的。添加、删除、查找的复杂度都是0（1）。对集合我们可以取并集、交集、差集。
1、 sadd：向key对应的set集合中添加元素，返回1表示添加成功，返回0 表示失败
127.0.0.1:6379> sadd myset1 one
(integer) 1
127.0.0.1:6379> sadd myset1 two
(integer) 1
2、 Smembers：查看set集合中的元素
127.0.0.1:6379> smembers myset1
1) "two"
2) "one"
3、srem：删除key对应set集合中的元素，返回1表示删除成功 0表示失败
127.0.0.1:6379> srem myset1 two
(integer) 1
4、spop：随机删除set中的一个元素并返回该元素
127.0.0.1:6379> smembers myset1
1) "three"
2) "one"
3) "four"
127.0.0.1:6379> spop myset1
"four"
127.0.0.1:6379> smembers myset1
1) "three"
2) "one"
5、sdiff：返回给定set集合的差集 （以在前的set集合为标准）
127.0.0.1:6379> smembers myset1
1) "three"
2) "one"
127.0.0.1:6379> smembers myset2
1) "two"
2) "one"
127.0.0.1:6379> sdiff myset1 myset2
1) "three"
127.0.0.1:6379> sdiff myset2 myset1
1) "two"
6、sdiffstore：返回所有给定set集合的差集，并将差集添加到另外一个集合中
127.0.0.1:6379> smembers myset1
1) "three"
2) "one"
127.0.0.1:6379> smembers myset2
1) "two"
2) "one"
127.0.0.1:6379> sdiffstore myset3 =myset1 -myset2
(integer) 1
127.0.0.1:6379> smembers myset3
1) "three"
7、sinter：返回所有给定集合的交集
127.0.0.1:6379> smembers myset1
1) "three"
2) "one"
127.0.0.1:6379> smembers myset2
1) "two"
2) "one"
127.0.0.1:6379> sinter myset1 myset2
1) "one"
8、sinterstore：返回所有给定集合key的交集，并将结果存为另一个key
127.0.0.1:6379> smembers myset1
1) "three"
2) "one"
127.0.0.1:6379> smembers myset2
1) "two"
2) "one"
127.0.0.1:6379> sinterstore myset4 =myset1  myset2
(integer) 1 
9、sunion 返回所有给定集合的并集
127.0.0.1:6379> smembers myset1
1) "three"
2) "one"
127.0.0.1:6379> smembers myset2
1) "two"
2) "one"
127.0.0.1:6379> sunion myset1 myset2
1) "three"
2) "two"
3) "one"
10、sunionstore 返回所有给定集合的并集，并将结果存入另一个集合
127.0.0.1:6379> smembers myset1
1) "three"
2) "one"
127.0.0.1:6379> smembers myset2
1) "two"
2) "one"
127.0.0.1:6379> sunionstore myset5  myset1 myset2
(integer) 3
11、smove：从第一个集合中移除元素并将该元素添加到另一个集合中。
127.0.0.1:6379> smembers myset1
1) "three"
2) "one"
127.0.0.1:6379> smembers myset5
1) "three"
2) "two"
3) "one"
127.0.0.1:6379> smove myset5 myset1 two
(integer) 1
127.0.0.1:6379> smembers myset5
1) "three"
2) "one"
127.0.0.1:6379> smembers myset1
1) "three"
2) "two"
3) "one"
12、Scard：返回set集合中元素的个数 llen(list) strlen (str) hlen(hash) 
127.0.0.1:6379> smembers myset1
1) "three"
2) "two"
3) "one"
127.0.0.1:6379> scard myset1
(integer) 3
13、sismember：测试member元素是否是名称为key的set集合 返回1：表示是 0：不是
127.0.0.1:6379> smembers myset1
1) "three"
2) "two"
3) "one"
127.0.0.1:6379> sismember myset1 tree
(integer) 0
127.0.0.1:6379> sismember myset1 three
(integer) 1
14、srandmember：随机返回set集合中的一个元素，但不删除该元素
127.0.0.1:6379> smembers myset1
1) "three"
2) "two"
3) "one"
127.0.0.1:6379>  srandmember myset1
"one"
 
（四）Sorted set （zset）类型
    Sorted set是set的一个升级版，他在set的基础上增加了一个顺序属性，这一属性在添加元素的时候可以指定，每次指定后，zset会自动重新按新的值挑战顺序。可以理解为有两列的mysql表，一列存value，一列存顺序。操作key理解为zset的名字
1、zadd：向有序集合zset中添加元素并指定顺序，如果该元素已存在就更新元素顺序。
127.0.0.1:6379> zadd myzset1 1 one
(integer) 1
127.0.0.1:6379> zadd myzset1 2 two
(integer) 1
2、zrange：从zset集合中取元素 [withscores] 输出元素顺序号
127.0.0.1:6379> zadd myzset1 1 one
(integer) 1
127.0.0.1:6379> zadd myzset1 2 two
(integer) 1
127.0.0.1:6379> zrange myzset1 0 -1 withscores
1) "one"
2) "1"
3) "two"
4) "2"
    3、zrem：删除zset集合中指定的元素
127.0.0.1:6379> zrange myzset1 0 -1 withscores
1) "one"
2) "1"
3) "two"
4) "2"
127.0.0.1:6379> zrem myzset1 two
(integer) 1
127.0.0.1:6379> zrange myzset1 0 -1 withscores
1) "one"
2) "1"
4、zincrby：若zset中已经存在元素member、则该元素的score增加incrment否则向该集合中添加该元素，其score的值为increment
例：改变myset1中one元素的顺序值
127.0.0.1:6379> zrange myzset1 0 -1 withscores
1) "one"
2) "1"
127.0.0.1:6379> zincrby myzset1 2 one
"3"
127.0.0.1:6379> zrange myzset1 0 -1 withscores
1) "one"
2) "3"
5、zrank：正序方式，获取指定元素的索引下标
127.0.0.1:6379> zrange myzset1 0 -1 withscores
1) "one"
2) "3"
3) "four"
4) "4"
5) "five"
6) "5"
127.0.0.1:6379> zrank myzset1 four
(integer) 1
5、zrevrank：逆序的方式获取指定元素的索引下标，rev--reverse
127.0.0.1:6379> zrange myzset1 0 -1 withscores
1) "one"
2) "3"
3) "four"
4) "4"
5) "five"
6) "5"
127.0.0.1:6379> zrevrank myzset1 four
(integer) 1
127.0.0.1:6379> zrevrank myzset1 five
(integer) 0
6、zrevrange：从zset集合中倒叙（score倒叙）获取元素
127.0.0.1:6379> zrange myzset1 0 -1 withscores
1) "one"
2) "3"
3) "four"
4) "4"
5) "five"
6) "5"
127.0.0.1:6379> zrevrange myzset1 0 -1 withscores
1) "five"
2) "5"
3) "four"
4) "4"
5) "one"
6) "3"
8、zrangebyscore：从zset集合中根据score顺序获取元素
127.0.0.1:6379> zrange myzset1 0 -1 withscores
1) "one"
2) "3"
3) "four"
4) "4"
5) "five"
6) "5"
127.0.0.1:6379> zrangebyscore  myzset1 4 5 withscores
1) "four"
2) "4"
3) "five"
4) "5"
9、zcount：返回集合中score在给定区间的数量
127.0.0.1:6379> zrange myzset1 0 -1 withscores
1) "one"
2) "3"
3) "four"
4) "4"
5) "five"
6) "5"
127.0.0.1:6379> zcount myzset1 3 4
(integer) 2
10：zcard：返回zset集合中所有元素个数
127.0.0.1:6379> zrange myzset1 0 -1 withscores
1) "one"
2) "3"
3) "four"
4) "4"
5) "five"
6) "5"
127.0.0.1:6379> zcard myzset1
(integer) 3
12、zremrangebyrank：删除集合中排名（下标）在给定区间的元素
127.0.0.1:6379> zrange myzset1 0 -1 withscores
1) "one"
2) "3"
3) "four"
4) "4"
5) "five"
6) "5"
127.0.0.1:6379> zremrangebyrank myzset1 1 2
(integer) 2
127.0.0.1:6379> zrange myzset1 0 -1 withscores
1) "one"
2) "3"
12、zremrangebyscore：：删除集合中顺序（score值）在给定区间的元素
127.0.0.1:6379> zrange myzset1 0 -1 withscores
1) "one"
2) "3"
3) "four"
4) "4"
5) "five"
6) "5"
127.0.0.1:6379> zremrangebyscore myzset1 3 4
(integer) 2
127.0.0.1:6379> zrange myzset1 0 -1 withscores
1) "five"
2) "5"
 rank是指下标索引：他是从0开始的
score是指分数。

day10

一、Redis事物及乐观锁
1、Redis支持简单的事务
2、Redis与 mysql事务的对比
Mysql
Redis
开启
start transaction
muitl
语句
普通sql
普通命令
失败
rollback 回滚
discard 取消
成功
commit
exec
redis的事务，在用multi开启之后，之后输入的所有命令，其实都是将其添加到一个执行队列中，当使用exec这个命令时，这个队列中的命令就会按顺序执行，使用discard这个命令式，这个队列就会被清空。
注: rollback与discard 作用：
 discard和rollback都可以做到回滚。但是dicard其实就是将开启事物后的队列里面的命令清空。rollback是真正的回滚，就是回到开启事务之前的状态。
3、在mutil后面的语句中, 语句出错可能有2种情况：
（1）语法就有问题,此时，在输入命令时，就会报错。
（2）语法本身没错,但适用对象有问题. 比如 zadd 操作list对象，这个命令也会被加入队列。exec之后，出错的那个命令之前的命令是会被执行的

在这里插入图片描述

相当于只要事务的所有命令中出现任何语法错误，在exec时都会回滚，所有命令都不会执行。

4、乐观锁
思考:我正在买票，Ticket = 1, money =100，而票只有1张, 如果在我multi之后,和exec之前, 票被别人买了---即ticket变成0了。我该如何观察这种情景,并不再提交。
悲观的想法:
世界充满危险,肯定有人和我抢, 给 ticket上锁, 只有我能操作. [悲观锁]
乐观的想法:
没有那么人和我抢,因此,我只需要注意,有没有人更改ticket的值就可以了 [乐观锁]
Redis的事务中,启用的是乐观锁,只负责监测key没有被改动
具体的命令----  watch命令
redis 127.0.0.1:6379> watch ticket
OK
redis 127.0.0.1:6379> multi
OK
redis 127.0.0.1:6379> decr ticket
QUEUED
redis 127.0.0.1:6379> decrby money 100
QUEUED
redis 127.0.0.1:6379> exec
(nil)   // 返回nil,说明监视的ticket已经改变了,事务就取消了.
redis 127.0.0.1:6379> get ticket
"0"
redis 127.0.0.1:6379> get money
"200"
步骤：
创建ticket和money 字符串，分别是1和100
打开两个客户端：一个客户端执行上述代码，另一个客户端在exec之前，更改一下ticket的值。

watch key1 key2  ... keyN
作用:监听key1 key2..keyN有没有变化,如果有变, 则事务取消
unwatch
作用: 取消所有watch监听
二、消息订阅
    Redis 发布订阅(pub/sub)是一种消息通信模式：发送者(pub)发送消息，订阅者(sub)接收消息。
    Redis 客户端可以订阅任意数量的频道。
    下图展示了频道 channel1 ， 以及订阅这个频道的三个客户端 —— client2 、 client5 和 client1 之间的关系：

在这里插入图片描述

当有新消息通过 PUBLISH 命令发送给频道 channel1 时，这个消息就会被发送给订阅它的三个客户端。

使用办法:
订阅端: Subscribe 频道名称
发布端: publish 频道名称 发布内容
客户端例子:
redis 127.0.0.1:6379> subscribe news
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "news"
3) (integer) 1
1) "message"
2) "news"
3) "good good study"
1) "message"
2) "news"
3) "day day up"
 
服务端例子:
redis 127.0.0.1:6379> publish news 'good good study'
(integer) 1
redis 127.0.0.1:6379> publish news 'day day up'
(integer) 1
消息的意义:建立客户端之间的通信
    client1 :处理计算的第一步
    client2:处理计算的第二步
    client3：处理计算的最后一步
        client1--->将计算结果当成一个消息发送client2
三、Redis持久化配置	
    redis启动之后，就从硬盘上将所有数据读出来，加载到内存中。
    持久化：将内存中的数据保存到硬盘上。
    序列化：就对象保存到硬盘上。
redis是一个内存数据库，他最大的特点就是可以将内存的上的数据持久化的硬盘。这是为了保证数据在系统重启或者电脑电源关闭，数据不会被丢失。
当redis启动的启动的时候，他会将硬盘的数据，全部加载到内存，在内存上运行。

    redis持久化是通过两种方式来完成的：
RDB快照
日志
（一）RDB快照
Rdb快照的配置选项：
save 900 1 // 900内,有1条写入,则产生快照
save 300 1000 // 如果300秒内有1000次写入,则产生快照
save 60 10000 // 如果60秒内有10000次写入,则产生快照
    (这3个选项都屏蔽,则rdb禁用)
和持久化相关的redis配置：
stop-writes-on-bgsave-error yes // 后台备份进程出错时,主进程停不停止写入?
rdbcompression yes // 导出的rdb文件是否压缩
Rdbchecksum yes // 导入rbd恢复时数据时,要不要检验rdb的完整性
dbfilename dump.rdb //导出来的rdb文件名
dir ./ //rdb的放置路径
（二）aof日志
    Aof 的配置：
appendonly no # 是否打开 aof日志功能
appendfsync always # 每1个命令,都立即同步到aof. 安全,速度慢
appendfsync everysec # 折衷方案,每秒写1次
appendfsync no # 写入工作交给操作系统,由操作系统判断缓冲区大小,统一写入到 aof. 同步频率低,速度快。
no-appendfsync-on-rewrite yes: # 正在导出rdb快照的过程中,要不要停止同步aof
auto-aof-rewrite-percentage 100 #aof文件大小比起上次重写时的大小,增长率100%时,重写
auto-aof-rewrite-min-size 64mb #aof文件,至少超过64M时,重写
两种持久化机制的比较：
RDB持久化
AOF持久化
全量备份,一次保存整个数据库
增量备份,一次保存一个修改数据库的命令
保存的间隔较长
保存的间隔默认一秒
数据还原速度快
数据还原速度一般
更适合数据备份,默认开启
更适合用来保存数据,和一般SQL持久化方式一样,默认关闭
启动优先级 : 低
启动优先级 : 高
体积 : 小
体积 : 大
恢复速度 : 快
恢复速度 : 慢
数据安全性 : 丢数据
数据安全性 : 根据策略决定
（三）redis持久化相关的问题
1、在dump rdb过程中,aof如果停止同步,会不会丢失数据?
答: 不会,所有的操作缓存在内存的队列里, dump完成后,统一操作.

2、aof重写是指什么?
答: aof重写是指把内存中的数据,逆化成命令,写入到.aof日志里。题。以解决 aof日志过大的问。
 
3、如果rdb文件,和aof文件都存在,优先用谁来恢复数据?
答: 在这种情况下,当redis重启的时候会优先载入AOF文件来恢复原始的数据,因为在通常情况下AOF文件保存的数据集要比RDB文件完整。
 
4、 2种是否可以同时用?
答: 可以,而且推荐这么做
 
5、恢复时rdb和aof哪个恢复的快
答: rdb快,因为其是数据的内存映射,直接载入到内存,而aof是命令,需要逐条执行
四、Redis主从复制（集群）
1、集群的作用：
主从备份----防止主机宕机
读写分离----分担master 的任务
任务分离----如从服分别分担备份工作与计算工作
集群布局1：

在这里插入图片描述
集群布局2：
第二种方案有一个好处：master宕机后，可以直接切换到slave1
2、主从通信过程：

步骤：
1，salve会自动的发送一个同步的指令并连接master。
2，master收到同步指令后，会dumprdb（内存镜像），并传送给slave，slave拿到整块的内存镜像塞到自己的内存中。
3，如果在dumprdb的过程中，master中还有新的操作命令对其操作，那么这些命令将会缓存到aof日志中，dump结束后就统一发送给slave。
4，此后，如果master再改变，就由一个叫：replicationFeedSlaves的进程去维护之间数据的同步。

3、主从配置



    
    主服务器：
rdb禁用
#save 900 1
#save 300 10
#save 60 1000
aof打开
appendonly yes
    从服务器：
设置端口
port 6380
有一台启用rdb
两台都禁用aof
设置slave-of
slaveof localhost 6379
    
redis-server redis.windows.conf --maxheap 200m
redis-server redis.windows6380.conf --maxheap 200m
redis-server redis.windows6381.conf --maxheap 200m
    
    启动客户端：
redis-cli 
redis-cli -p 6380
redis-cli -p 6381
配置如下：
1、服务关闭
2、复制两个配置文件，名字如下：

在这里插入图片描述

3、该端口号

4、主机配置更改：
禁用rdb

打开aof

在这里插入图片描述

5、配置从机
6380—启用rdb
两台都禁用aof
两台都要配置

day11 scrapy

创建项目 Scrapy startproject [项目名]

在这里插入图片描述

将创建好的项目拖到pycharm中，目录结构如下：

在这里插入图片描述

2、创建spiders，爬虫文件。

3、打开spider文件。将待爬取的url放到start_urls中。

Spider文件的主要内容如下：

4、更改settings.py中的配置。
（1）Scrapy默认是遵守robots，将rotbos协议改为False

（2）设置下载的请求头。

5、在parse方法中，验证response中是否有数据。

6、在item.py中定义要爬取的字段。

7、在parse方法中实现数据提取逻辑。
Response有xpath方法
[Selector对象]= Response.xpath(‘xpath表达式’)
从selector对象汇总提取字符串的方法有两个：
Extract()----从一个列表中提取每个selector对象的内容
Extract_first()—提取出列表中获取第一个selector对象的内容。
提取样板：

8、可以通过命令直接将爬取的保存到对应文件中。
首先：

保存到json文件：

保存到csv文件
Scrapy crawl guba_spider -o guba.csv
Last、启动scrapy项目
Scrapy crawl spider文件的name属性
如果不想查看配置信息，增加一个–nolog参数

day11


1、客户端启动和服务端开启命令：
	mongod 服务端
		--dbpath
		--port
		--logpath
	mongo 客户端
		--port
		--host
2、基础命令：
	show dbs
	show collections
	show tables
	
	如何创建库？
		1、use 数据库名
		2、添加一条数据	
			db.collectionName.insert({文档})
			db.createCollection(name)
	删除数据库：db.dropDatabase()
	删除集合：db.collectionName.drop()
	
3、CRUD
	（1）insert---插入
		db.collectionName.insert({文档})
		插入多条文档：
		db.collectionName.insert([{文档1},{文档2},{文档3},....])
	 (2)查找--find
		db.collectionName.find({查询表达式},{field1:1/0}) --1显示，0不显示
		
		查询表达式：
			=    {key:value}
			<     $lt
			>    $gt
			<=   $lte
			>=   $gte
			!=   $ne
			
			{$nin:{age:[1,2,3]}}  查询不在数组中的数据
			{$in:{age:[12,13,14]}   查询在数组中的数据
			{$all:{hobby：['a','b','c']}}  满足数组中的所有内容的条件
			{$mod:{age:[5,1]} 
			
			{$and:[{},{},{}]}
			{$or:[{},{},{}]}
			{$nor:[{},{},{}]}
	(3)聚合
		db.collectionName.aggregate([{管道1},{管道2},{管道3}])
		{$match:{查询表达式}}
		{$group:{_id:'$field',avg/sum/max/min:{$avg/$sum/$max/$min:1/'$field'}}}
	(4)游标
		将查询结果赋值给一个变量，这个标量就是游标，游标就相当于python中迭代器，我们可以从中一个一个取出查询结果。
		
		var cursor = db.collectionName.find()
		cursor.hasNext()---是否有下一个（如果游标到结尾，才为false）
		cursor.next()---获取下一个。
		
		cursor.forEach(回调函数)
				作用：回调函数接收游标中每一个查询结果，并做批量操作。
	（5）hash
		（1）什么是hash。
			Hash ：散列，通过关于键值(key)的函数，将数据映射到内存存储中一个位置来访问。这个过程叫做Hash
		（2）特点：
			正向快速
			逆向困难
			输入敏感
			冲突避免
		（3）作用：
			给数据打指纹---指纹就是唯一标识--->去除重复
			密码存储
		（4）什么叫hash碰撞？
		 (5)字符串加密和文件加密？
			
			
第10天作业
1、作业
	将下面的项目改装到scrapy框架中：
		笔趣阁项目
		
2、爬取瓜子二手车车辆信息
	
	url :https://www.guazi.com/bj/buy/
	要求
		1.先获取区域列表，然后在区域列表下获取每一页的车辆信息
		2、爬取字段：
			列表页字段：
				名称
				价格
				里程数
				详情页链接
			
			详情页字段：
				排量
				上牌时间
				产商
				驱动方式
				发动机型号
		3、完成3个版本的代码
			（1）简单py文件
			（2）类
			（3）多线程
			选做：用scrapy实现
		4、数据保存到mongodb中。

day12 增量爬虫

一、增量爬虫
	1、定义：通过更改爬取策略，使得爬取到数据库的数据增量式增长的一种爬虫程序。
	2、策略：
		（1）在发送请求之前判断这个URL是不是之前爬取过；
				用redis去重
		（2）在解析内容后判断这部分内容是不是之前爬取过 
				用redis去重
				def response_seen(response.text)
		（3）写入存储介质时判断内容是不是已经在介质中存在分析
				用update方法
		这三个策略的本质---->判重。
	3、判重的方法：
		1、python中的set来判重吗？
		  缺点：
			set的add操作没有返回值，无法找到到底add成功了没有。
			set是运行内存上的，当前程序一旦关闭，这个set就会请求，下载启动爬虫，set又会重新创建，无法记录上次爬取的内容。
		2、用文件保存：
			非常麻烦
			list_ = ['abcdef','abcdefg','abcdef']
			fp_w = open('demo.txt','a+',encoding='utf-8')
			for l in list_:
				fp_w.write(l+'\n')
			fp_r = open('demo.txt','r')
			a = [x for x in fp_r]
			if 'abcdefg\n' in a:
				print('yes')
		3、redis中的set---效果最好
			步骤：
			(1)写一个获取数据hash指纹的方法
				def get_md5():
					pass
			(2)在redis中用set来添加数据，
				sadd s1 name ---->成功返回1，不成功返回0
				def url_seen(url):
					re = redis.Redis()
					result = re.sadd('set的名称'，get_md5(url))
					return 0==result
				
				
二、scrapy-redis分布式
	1、什么分布式？
		分布式数据库：将数据库部署在多台计算机上，多台计算机组成一个系统，这个系统就是分布式数据库。	
		分布式出现的原因：原来有单台电脑完成的任务已经无法达到我们想要性能要求了，所以就想到是否可以用多台电脑，通过扩展硬件的方式来提高性能。	
	2、scrapy-redis的分布式原理。
			见图
	3、scrapy-redis安装
		pip install scrapy-redis
	4、scrapy分布式项目部署。
		（1）主要配置如下：
		#配置scrapy-redis调度器
		SCHEDULER = "scrapy_redis.scheduler.Scheduler"
		#配置url去重
		DUPEFILTER_CLASS = "scrapy_redis.dupefilter.RFPDupeFilter"
		#配置优先级队列
		SCHEDULER_QUEUE_CLASS = 'scrapy_redis.queue.PriorityQueue'
		
		ITEM_PIPELINES = {
		#如果配置redispipelines，就会将item数据保存到redis中。
		'scrapy_redis.pipelines.RedisPipeline': 300
		}
		#主机名
		REDIS_HOST = 'localhost'
		##端口号
		REDIS_PORT = 6379
		 （2）部署流程：
		 1、导入from scrapy_redis import spiders包
				spiders继承spiders.RedisSpider
		 2、start_urls注释掉，设置redis_key = 'picture_caixi:start_urls'
			redis-key就表示将来scrapy启动，会去这个key所指定的redis的list中取任务url。
		3、添加配置：
			这三条主机和从机都要添加
				#配置scrapy-redis调度器
				SCHEDULER = "scrapy_redis.scheduler.Scheduler"
				#配置url去重
				DUPEFILTER_CLASS = "scrapy_redis.dupefilter.RFPDupeFilter"
				#配置优先级队列
				SCHEDULER_QUEUE_CLASS = 'scrapy_redis.queue.PriorityQueue'
				##端口号
				REDIS_PORT = 6379
				MONGO_DATABASE = 'caixi'
				
			主机：
				#主机名
				REDIS_HOST = 'localhost'
				MONGO_URI = 'localhost'
			从机里面：	10.10.92.157
				REDIS_HOST = '目标主机的ip'
				MONGO_URI = '目标主机的ip'
				
		在启动scrapy-redis分布式项目之前，一定要远程连接一个主机的mongo和redis