一、爬虫之requests
a、介绍：使用requests可以模拟浏览器的请求，比起之前用到的urllib，requests模块的api更加便捷（本质就是封装了urllib3）
b、注意：requests发送请求是将网页内容下载来以后，并不会执行js代码，这需要我们自己分析目标站点然后发起新的requests请求
c、安装：pip3 install requests
d、各种请求方式，常用的是requests.get()和requets.post()
二、基于get请求
a、基本请求
import requests response=requests.get(‘http://dig.chouti.com/‘) print(response.text)
b、带参数get请求-----》》params
c、带参数get请求-----》》headers
#通常我们在发送请求时都需要带上请求头，请求头是将自身伪装成浏览器的关键，常见的有用的请求头如下 Host Referer #大型网站通常都会根据该参数判断请求的来源 User-Agent #客户端 Cookie #Cookie信息虽然包含在请求头里，但requests模块有单独的参数来处理他，headers={}内就不要放它了
d、带参数get请求-----》》cookies
三、基于post请求
a、介绍
#GET请求 HTTP默认的请求方法就是GET * 没有请求体 * 数据必须在1K之内！ * GET请求数据会暴露在浏览器的地址栏中 GET请求常用的操作： 1. 在浏览器的地址栏中直接给出URL，那么就一定是GET请求 2. 点击页面上的超链接也一定是GET请求 3. 提交表单时，表单默认使用GET请求，但可以设置为POST #POST请求 (1). 数据不会出现在地址栏中 (2). 数据的大小没有上限 (3). 有请求体 (4). 请求体中如果存在中文，会使用URL编码！ #！！！requests.post()用法与requests.get()完全一致，特殊的是requests.post()有一个data参数，用来存放请求体数据 复制代码
b、发送POST的请求，模拟浏览器的登录行为
四、响应Response
a、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
b、编码问题
#编码问题 import requests response=requests.get(‘http://www.autohome.com/news‘) # response.encoding=‘gbk‘ #汽车之家网站返回的页面内容为gb2312编码的，而requests的默认编码为ISO-8859-1，如果不设置成gbk则中文乱码 print(response.text)
c、获取二进制
#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)
d、解析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
a、介绍
selenium最初是一个自动化测试工具,而爬虫中使用它主要是为了解决requests无法直接执行javascript代码的问题 selenium本质是通过驱动浏览器，完全模拟浏览器的操作，比如跳转、输入、点击、下拉等，来拿到网页渲染之后的结果，可支持多种浏览器 from selenium import webdriver browser=webdriver.Chrome() browser=webdriver.Firefox() browser=webdriver.PhantomJS() browser=webdriver.Safari() browser=webdriver.Edge()
b、安装
#安装：selenium+chromedriver pip3 install selenium 下载chromdriver.exe放到python安装路径的scripts目录中即可，注意最新版本是2.29，并非2.9 国内镜像网站地址：http://npm.taobao.org/mirrors/chromedriver/2.29/ 最新的版本去官网找:https://sites.google.com/a/chromium.org/chromedriver/downloads
#注意： selenium3默认支持的webdriver是Firfox，而Firefox需要安装geckodriver 下载链接：https://github.com/mozilla/geckodriver/releases
六、选择器
a、基本使用
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(‘[email protected]‘) 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()
b、xpath
c、获取标签属性
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()
七、等待元素加载
a、selenium只是模拟浏览器的行为，而浏览器解析页面是需要时间的（执行css，js），一些元素可能需要过一段时间才能加载出来，为了保证能查找到元素，必须等待
b、等待的方式分两种：
隐式等待：在browser.get（‘xxx‘）前就设置，针对所有元素有效
显式等待：在browser.get（‘xxx‘）之后设置，只针对某个元素有效
八、爬虫之解析库----re,beautifulsoup、pyquery
a、介绍
Beautiful Soup 是一个可以从html或XML文件中提取数据的Python库.它能够通过你喜欢的转换器实现惯用的文档导航,查找,
修改文档的方式.Beautiful Soup会帮你节省数小时甚至数天的工作时间.你可能在寻找 Beautiful Soup3 的文档,Beautiful Soup 3
目前已经停止开发,官网推荐在现在的项目中使用Beautiful Soup 4, 移植到BS4
b、安装
安装：Beautifulsoup4
pip3 install beautifulsoup4
安装解释器：
Beautiful Soup支持Python标准库中的HTML解析器,还支持一些第三方的解析器,其中一个是 lxml .根据操作系统不同,可以选择下列方法来安装lxml:
九、遍历文档数
#遍历文档树：即直接通过标签名字选择，特点是选择速度快，但如果存在多个相同的标签则只返回第一个 #1、用法 #2、获取标签的名称 #3、获取标签的属性 #4、获取标签的内容 #5、嵌套选择 #6、子节点、子孙节点 #7、父节点、祖先节点 #8、兄弟节点
#遍历文档树：即直接通过标签名字选择，特点是选择速度快，但如果存在多个相同的标签则只返回第一个 html_doc = """ <html><head><title>The Dormouse‘s story</title></head> <body> <p id="my p" class="title"><b id="bbb" class="boldest">The Dormouse‘s story</b></p> <p class="story">Once upon a time there were three little sisters; and their names were <a href="http://example.com/elsie" class="sister" id="link1">Elsie</a>, <a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and <a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>; and they lived at the bottom of a well.</p> <p class="story">...</p> """ #1、用法 from bs4 import BeautifulSoup soup=BeautifulSoup(html_doc,‘lxml‘) # soup=BeautifulSoup(open(‘a.html‘),‘lxml‘) print(soup.p) #存在多个相同的标签则只返回第一个 print(soup.a) #存在多个相同的标签则只返回第一个 #2、获取标签的名称 print(soup.p.name) #3、获取标签的属性 print(soup.p.attrs) #4、获取标签的内容 print(soup.p.string) # p下的文本只有一个时，取到，否则为None print(soup.p.strings) #拿到一个生成器对象, 取到p下所有的文本内容 print(soup.p.text) #取到p下所有的文本内容 for line in soup.stripped_strings: #去掉空白 print(line) ‘‘‘ 如果tag包含了多个子节点,tag就无法确定 .string 方法应该调用哪个子节点的内容, .string 的输出结果是 None，如果只有一个子节点那么就输出该子节点的文本，比如下面的这种结构，soup.p.string 返回为None,但soup.p.strings就可以找到所有文本 <p id=‘list-1‘> 哈哈哈哈 <a class=‘sss‘> <span> <h1>aaaa</h1> </span> </a> <b>bbbbb</b> </p> ‘‘‘ #5、嵌套选择 print(soup.head.title.string) print(soup.body.a.string) #6、子节点、子孙节点 print(soup.p.contents) #p下所有子节点 print(soup.p.children) #得到一个迭代器,包含p下所有子节点 for i,child in enumerate(soup.p.children): print(i,child) print(soup.p.descendants) #获取子孙节点,p下所有的标签都会选择出来 for i,child in enumerate(soup.p.descendants): print(i,child) #7、父节点、祖先节点 print(soup.a.parent) #获取a标签的父节点 print(soup.a.parents) #找到a标签所有的祖先节点，父亲的父亲，父亲的父亲的父亲... #8、兄弟节点 print(‘=====>‘) print(soup.a.next_sibling) #下一个兄弟 print(soup.a.previous_sibling) #上一个兄弟 print(list(soup.a.next_siblings)) #下面的兄弟们=>生成器对象 print(soup.a.previous_siblings) #上面的兄弟们=>生成器对象 用法
十、搜索文档数
a、五种过滤器
#1、五种过滤器: 字符串、正则表达式、列表、True、方法 #1.1、字符串：即标签名 print(soup.find_all(‘b‘)) #1.2、正则表达式 import re print(soup.find_all(re.compile(‘^b‘))) #找出b开头的标签，结果有body和b标签 #1.3、列表：如果传入列表参数,Beautiful Soup会将与列表中任一元素匹配的内容返回.下面代码找到文档中所有<a>标签和<b>标签: print(soup.find_all([‘a‘,‘b‘])) #1.4、True：可以匹配任何值,下面代码查找到所有的tag,但是不会返回字符串节点 print(soup.find_all(True)) for tag in soup.find_all(True): print(tag.name) #1.5、方法:如果没有合适过滤器,那么还可以定义一个方法,方法只接受一个元素参数 ,如果这个方法返回 True 表示当前元素匹配并且被找到,如果不是则反回 False def has_class_but_no_id(tag): return tag.has_attr(‘class‘) and not tag.has_attr(‘id‘)
b、find_all
#2、find_all( name , attrs , recursive , text , **kwargs ) #2.1、name: 搜索name参数的值可以使任一类型的 过滤器 ,字符窜,正则表达式,列表,方法或是 True . print(soup.find_all(name=re.compile(‘^t‘))) #2.2、keyword: key=value的形式，value可以是过滤器：字符串 , 正则表达式 , 列表, True . print(soup.find_all(id=re.compile(‘my‘))) print(soup.find_all(href=re.compile(‘lacie‘),id=re.compile(‘\\d‘))) #注意类要用class_ print(soup.find_all(id=True)) #查找有id属性的标签 # 有些tag属性在搜索不能使用,比如HTML5中的 data-* 属性: data_soup = BeautifulSoup(‘<div data-foo="value">foo!</div>‘,‘lxml‘) # data_soup.find_all(data-foo="value") #报错：SyntaxError: keyword can‘t be an expression # 但是可以通过 find_all() 方法的 attrs 参数定义一个字典参数来搜索包含特殊属性的tag: print(data_soup.find_all(attrs={"data-foo": "value"})) # [<div data-foo="value">foo!</div>] #2.3、按照类名查找，注意关键字是class_，class_=value,value可以是五种选择器之一 print(soup.find_all(‘a‘,class_=‘sister‘)) #查找类为sister的a标签 print(soup.find_all(‘a‘,class_=‘sister ssss‘)) #查找类为sister和sss的a标签，顺序错误也匹配不成功 print(soup.find_all(class_=re.compile(‘^sis‘))) #查找类为sister的所有标签 #2.4、attrs print(soup.find_all(‘p‘,attrs={‘class‘:‘story‘})) #2.5、text: 值可以是：字符，列表，True，正则 print(soup.find_all(text=‘Elsie‘)) print(soup.find_all(‘a‘,text=‘Elsie‘)) #2.6、limit参数:如果文档树很大那么搜索会很慢.如果我们不需要全部结果,可以使用 limit 参数限制返回结果的数量.效果与SQL中的limit关键字类似,当搜索到的结果数量达到 limit 的限制时,就停止搜索返回结果 print(soup.find_all(‘a‘,limit=2)) #2.7、recursive:调用tag的 find_all() 方法时,Beautiful Soup会检索当前tag的所有子孙节点,如果只想搜索tag的直接子节点,可以使用参数 recursive=False . print(soup.html.find_all(‘a‘)) print(soup.html.find_all(‘a‘,recursive=False)) ‘‘‘ 像调用 find_all() 一样调用tag find_all() 几乎是Beautiful Soup中最常用的搜索方法,所以我们定义了它的简写方法. BeautifulSoup 对象和 tag 对象可以被当作一个方法来使用,这个方法的执行结果与调用这个对象的 find_all() 方法相同,下面两行代码是等价的: soup.find_all("a") soup("a") 这两行代码也是等价的: soup.title.find_all(text=True) soup.title(text=True) ‘‘‘
c、find
#3、find( name , attrs , recursive , text , **kwargs ) find_all() 方法将返回文档中符合条件的所有tag,尽管有时候我们只想得到一个结果.比如文档中只有一个<body>标签,那么使用 find_all() 方法来查找<body>标签就不太合适, 使用 find_all 方法并设置 limit=1 参数不如直接使用 find() 方法.下面两行代码是等价的: soup.find_all(‘title‘, limit=1) # [<title>The Dormouse‘s story</title>] soup.find(‘title‘) # <title>The Dormouse‘s story</title> 唯一的区别是 find_all() 方法的返回结果是值包含一个元素的列表,而 find() 方法直接返回结果. find_all() 方法没有找到目标是返回空列表, find() 方法找不到目标时,返回 None . print(soup.find("nosuchtag")) # None soup.head.title 是 tag的名字 方法的简写.这个简写的原理就是多次调用当前tag的 find() 方法: soup.head.title # <title>The Dormouse‘s story</title> soup.find("head").find("title") # <title>The Dormouse‘s story</title>
d、css选择器
#1、CSS选择器 print(soup.p.select(‘.sister‘)) print(soup.select(‘.sister span‘)) print(soup.select(‘#link1‘)) print(soup.select(‘#link1 span‘)) print(soup.select(‘#list-2 .element.xxx‘)) print(soup.select(‘#list-2‘)[0].select(‘.element‘)) #可以一直select,但其实没必要,一条select就可以了 # 2、获取属性 print(soup.select(‘#list-2 h1‘)[0].attrs) # 3、获取内容 print(soup.select(‘#list-2 h1‘)[0].get_text())
十一、爬虫之MongoDB
a、简介
MongoDB是一款强大、灵活、且易于扩展的通用型数据库
b、易用性
MongoDB是一个面向文档（document-oriented）的数据库，而不是关系型数据库。
不采用关系型主要是为了获得更好得扩展性。当然还有一些其他好处，与关系数据库相比，面向文档的数据库不再有“行“（row）的概念取而代之的是更为灵活的“文档”（document）模型。
通过在文档中嵌入文档和数组，面向文档的方法能够仅使用一条记录来表现复杂的层级关系，这与现代的面向对象语言的开发者对数据的看法一致。
另外，不再有预定义模式（predefined schema）：文档的键（key）和值（value）不再是固定的类型和大小。由于没有固定的模式，
根据需要添加或删除字段变得更容易了。通常由于开发者能够进行快速迭代，所以开发进程得以加快。而且，实验更容易进行。开发者能尝试大量的数据模型，从中选一个最好的。
c、易扩展性
应用程序数据集的大小正在以不可思议的速度增长。随着可用带宽的增长和存储器价格的下降，即使是一个小规模的应用程序，需要存储的数据量也可能大的惊人，甚至超出
了很多数据库的处理能力。过去非常罕见的T级数据，现在已经是司空见惯了。
由于需要存储的数据量不断增长，开发者面临一个问题：应该如何扩展数据库，分为纵向扩展和横向扩展，纵向扩展是最省力的做法，但缺点是大型机一般都非常贵，而且
当数据量达到机器的物理极限时，花再多的钱也买不到更强的机器了，此时选择横向扩展更为合适，但横向扩展带来的另外一个问题就是需要管理的机器太多。
MongoDB的设计采用横向扩展。面向文档的数据模型使它能很容易地在多台服务器之间进行数据分割。MongoDB能够自动处理跨集群的数据和负载，自动重新分配文档，以及将
用户的请求路由到正确的机器上。这样，开发者能够集中精力编写应用程序，而不需要考虑如何扩展的问题。如果一个集群需要更大的容量，只需要向集群添加新服务器，
MongoDB就会自动将现有的数据向新服务器传送
d、丰富的功能
MongoDB作为一款通用型数据库，除了能够创建、读取、更新和删除数据之外，还提供了一系列不断扩展的独特功能 #1、索引 支持通用二级索引，允许多种快速查询，且提供唯一索引、复合索引、地理空间索引、全文索引 #2、聚合 支持聚合管道，用户能通过简单的片段创建复杂的集合，并通过数据库自动优化 #3、特殊的集合类型 支持存在时间有限的集合，适用于那些将在某个时刻过期的数据，如会话session。类似地，MongoDB也支持固定大小的集合，用于保存近期数据，如日志 #4、文件存储 支持一种非常易用的协议，用于存储大文件和文件元数据。MongoDB并不具备一些在关系型数据库中很普遍的功能，如链接join和复杂的多行事务。省略 这些的功能是处于架构上的考虑，或者说为了得到更好的扩展性，因为在分布式系统中这两个功能难以高效地实
e、卓越的性能
MongoDB的一个主要目标是提供卓越的性能，这很大程度上决定了MongoDB的设计。MongoDB把尽可能多的内存用作缓存cache，视图为每次查询自动选择正确的索引。
总之各方面的设计都旨在保持它的高性能
虽然MongoDB非常强大并试图保留关系型数据库的很多特性，但它并不追求具备关系型数据库的所有功能。只要有可能，数据库服务器就会将处理逻辑交给客户端。
这种精简方式的设计是MongoDB能够实现如此高性能的原因之一
十二、MongoDB基础
a、文档是MongoDB的核心概念。文档就是键值对的一个有序集{‘msg‘:‘hello‘,‘foo‘:3}。类似于python中的有序字典
需要注意的是： #1、文档中的键/值对是有序的。 #2、文档中的值不仅可以是在双引号里面的字符串，还可以是其他几种数据类型（甚至可以是整个嵌入的文档)。 #3、MongoDB区分类型和大小写。 #4、MongoDB的文档不能有重复的键。 #5、文档中的值可以是多种不同的数据类型，也可以是一个完整的内嵌文档。文档的键是字符串。除了少数例外情况，键可以使用任意UTF-8字符。 文档键命名规范： #1、键不能含有\\0 (空字符)。这个字符用来表示键的结尾。 #2、.和$有特别的意义，只有在特定环境下才能使用。 #3、以下划线"_"开头的键是保留的(不是严格要求的)。
b、集合就是一组文档。如果将MongoDB中的一个文档比喻为关系型数据的一行，那么一个集合就是相当于一张表
#1、集合存在于数据库中，通常情况下为了方便管理，不同格式和类型的数据应该插入到不同的集合，但其实集合没有固定的结构，这意味着我们完全可以把不同格式和类型的数据统统插入一个集合中。 #2、组织子集合的方式就是使用“.”，分隔不同命名空间的子集合。 比如一个具有博客功能的应用可能包含两个集合，分别是blog.posts和blog.authors，这是为了使组织结构更清晰，这里的blog集合（这个集合甚至不需要存在）跟它的两个子集合没有任何关系。 在MongoDB中，使用子集合来组织数据非常高效，值得推荐 #3、当第一个文档插入时，集合就会被创建。合法的集合名： 集合名不能是空字符串""。 集合名不能含有\\0字符（空字符)，这个字符表示集合名的结尾。 集合名不能以"system."开头，这是为系统集合保留的前缀。 用户创建的集合名字不能含有保留字符。有些驱动程序的确支持在集合名里面包含，这是因为某些系统生成的集合中包含该字符。除非你要访问这种系统创建的集合，否则千万不要在名字里出现$。
c、数据库：在MongoDB中，多个文档组成集合，多个集合可以组成数据库
数据库也通过名字来标识。数据库名可以是满足以下条件的任意UTF-8字符串： #1、不能是空字符串（"")。 #2、不得含有‘ ‘（空格)、.、$、/、\\和\\0 (空字符)。 #3、应全部小写。 #4、最多64字节。 有一些数据库名是保留的，可以直接访问这些有特殊作用的数据库。 #1、admin： 从身份认证的角度讲，这是“root”数据库，如果将一个用户添加到admin数据库，这个用户将自动获得所有数据库的权限。
再者，一些特定的服务器端命令也只能从admin数据库运行，如列出所有数据库或关闭服务器 #2、local: 这个数据库永远都不可以复制，且一台服务器上的所有本地集合都可以存储在这个数据库中 #3、config: MongoDB用于分片设置时，分片信息会存储在config数据库中
d、强调：把数据库名添加到集合名前，得到集合的完全限定名，即命名空间
例如：
如果要使用cms数据库中的blog.posts集合，这个集合的命名空间就是
cmd.blog.posts。命名空间的长度不得超过121个字节，且在实际使用中应该小于100个字节
十三、CRUD操作
a、数据库操作
#1、增 use config #如果数据库不存在，则创建数据库，否则切换到指定数据库。 #2、查 show dbs #查看所有 可以看到，我们刚创建的数据库config并不在数据库的列表中， 要显示它，我们需要向config数据库插入一些数据。 db.table1.insert({‘a‘:1}) #3、删 use config #先切换到要删的库下 db.dropDatabase() #删除当前库
b、集合操作
#1、增 当第一个文档插入时，集合就会被创建 > use database1 switched to db database1 > db.table1.insert({‘a‘:1}) WriteResult({ "nInserted" : 1 }) > db.table2.insert({‘b‘:2}) WriteResult({ "nInserted" : 1 }) #2、查 > show tables table1 table2 #3、删 > db.table1.drop() true > show tables table2
d、文档操作
增：
查：
# SQL：=,!=,>,<,>=,<= # MongoDB：{key:value}代表什么等于什么,"$ne","$gt","$lt","gte","lte",其中"$ne"能用于所有数据类型 #1、select * from db1.user where name = "alex"; db.user.find({‘name‘:‘alex‘}) #2、select * from db1.user where name != "alex"; db.user.find({‘name‘:{"$ne":‘alex‘}}) #3、select * from db1.user where id > 2; db.user.find({‘_id‘:{‘$gt‘:2}}) #4、select * from db1.user where id < 3; db.user.find({‘_id‘:{‘$lt‘:3}}) #5、select * from db1.user where id >= 2; db.user.find({"_id":{"$gte":2,}}) #6、select * from db1.user where id <= 2; db.user.find({"_id":{"$lte":2}})
# SQL：and，or，not # MongoDB：字典中逗号分隔的多个条件是and关系，"$or"的条件放到[]内,"$not" #1、select * from db1.user where id >= 2 and id < 4; db.user.find({‘_id‘:{"$gte":2,"$lt":4}}) #2、select * from db1.user where id >= 2 and age < 40; db.user.find({"_id":{"$gte":2},"age":{"$lt":40}}) #3、select * from db1.user where id >= 5 or name = "alex"; db.user.find({ "$or":[ {‘_id‘:{"$gte":5}}, {"name":"alex"} ] }) #4、select * from db1.user where id % 2=1; db.user.find({‘_id‘:{"$mod":[2,1]}}) #5、上题，取反 db.user.find({‘_id‘:{"$not":{"$mod":[2,1]}}})
# SQL：in，not in # MongoDB："$in","$nin" #1、select * from db1.user where age in (20,30,31); db.user.find({"age":{"$in":[20,30,31]}}) #2、select * from db1.user where name not in (‘alex‘,‘yuanhao‘); db.user.find({"name":{"$nin":[‘alex‘,‘yuanhao‘]}}
# SQL: regexp 正则 # MongoDB: /正则表达/i #1、select * from db1.user where name regexp ‘^j.*?(g|n)$‘; db.user.find({‘name‘:/^j.*?(g|n)$/i})
#1、查看有dancing爱好的人 db.user.find({‘hobbies‘:‘dancing‘}) #2、查看既有dancing爱好又有tea爱好的人 db.user.find({ ‘hobbies‘:{ "$all":[‘dancing‘,‘tea‘] } }) #3、查看第4个爱好为tea的人 db.user.find({"hobbies.3":‘tea‘}) #4、查看所有人最后两个爱好 db.user.find({},{‘hobbies‘:{"$slice":-2},"age":0,"_id":0,"name":0,"addr":0}) #5、查看所有人的第2个到第3个爱好 db.user.find({},{‘hobbies‘:{"$slice":[1,2]},"age":0,"_id":0,"name":0,"addr":0}) > db.blog.find().pretty() { "_id" : 1, "name" : "alex意外死亡的真相", "comments" : [ { "name" : "egon", "content" : "alex是谁？？？", "thumb" : 200 }, { "name" : "wxx", "content" : "我去，真的假的", "thumb" : 300 }, { "name" : "yxx", "content" : "吃喝嫖赌抽，欠下两个亿", "thumb" : 40 }, { "name" : "egon", "content" : "xxx", "thumb" : 0 } ] } db.blog.find({},{‘comments‘:{"$slice":-2}}).pretty() #查询最后两个 db.blog.find({},{‘comments‘:{"$slice":[1,2]}}).pretty() #查询1到2
# 排序:--1代表升序，-1代表降序 db.user.find().sort({"name":1,}) db.user.find().sort({"age":-1,‘_id‘:1})
# 分页:--limit代表取多少个document，skip代表跳过前多少个document。 db.user.find().sort({‘age‘:1}).limit(1).skip(2)
# 获取数量 db.user.count({‘age‘:{"$gt":30}}) --或者 db.user.find({‘age‘:{"$gt":30}}).count()
#1、{‘key‘:null} 匹配key的值为null或者没有这个key db.t2.insert({‘a‘:10,‘b‘:111}) db.t2.insert({‘a‘:20}) db.t2.insert({‘b‘:null}) > db.t2.find({"b":null}) { "_id" : ObjectId("5a5cc2a7c1b4645aad959e5a"), "a" : 20 } { "_id" : ObjectId("5a5cc2a8c1b4645aad959e5b"), "b" : null } #2、查找所有 db.user.find() #等同于db.user.find({}) db.user.find().pretty() #3、查找一个，与find用法一致，只是只取匹配成功的第一个 db.user.findOne({"_id":{"$gt":3}})
改：
update() 方法用于更新已存在的文档。语法格式如下： db.collection.update( <query>, <update>, { upsert: <boolean>, multi: <boolean>, writeConcern: <document> } ) 参数说明：对比update db1.t1 set name=‘EGON‘,sex=‘Male‘ where name=‘egon‘ and age=18; query : 相当于where条件。 update : update的对象和一些更新的操作符（如$,$inc...等，相当于set后面的 upsert : 可选，默认为false，代表如果不存在update的记录不更新也不插入，设置为true代表插入。 multi : 可选，默认为false，代表只更新找到的第一条记录，设为true,代表更新找到的全部记录。 writeConcern :可选，抛出异常的级别。 更新操作是不可分割的：若两个更新同时发送，先到达服务器的先执行，然后执行另外一个，不会破坏文档。
#注意：除非是删除，否则_id是始终不会变的 #1、覆盖式: db.user.update({‘age‘:20},{"name":"Wxx","hobbies_count":3}) 是用{"_id":2,"name":"Wxx","hobbies_count":3}覆盖原来的记录 #2、一种最简单的更新就是用一个新的文档完全替换匹配的文档。这适用于大规模式迁移的情况。例如 var obj=db.user.findOne({"_id":2}) obj.username=obj.name+‘SB‘ obj.hobbies_count++ delete obj.age db.user.update({"_id":2},obj)
#设置：$set 通常文档只会有一部分需要更新。可以使用原子性的更新修改器，指定对文档中的某些字段进行更新。 更新修改器是种特殊的键，用来指定复杂的更新操作，比如修改、增加后者删除 #1、update db1.user set name="WXX" where id = 2 db.user.update({‘_id‘:2},{"$set":{"name":"WXX",}}) #2、没有匹配成功则新增一条{"upsert":true} db.user.update({‘_id‘:6},{"$set":{"name":"egon","age":18}},{"upsert":true}) #3、默认只改匹配成功的第一条,{"multi":改多条} db.user.update({‘_id‘:{"$gt":4}},{"$set":{"age":28}}) db.user.update({‘_id‘:{"$gt":4}},{"$set":{"age":38}},{"multi":true}) #4、修改内嵌文档，把名字为alex的人所在的地址国家改成Japan db.user.update({‘name‘:"alex"},{"$set":{"addr.country":"Japan"}}) #5、把名字为alex的人的地2个爱好改成piao db.user.update({‘name‘:"alex"},{"$set":{"hobbies.1":"piao"}}) #6、删除alex的爱好,$unset db.user.update({‘name‘:"alex"},{"$unset":{"hobbies":""}})
往数组内添加元素:$push #1、为名字为yuanhao的人添加一个爱好read db.user.update({"name":"yuanhao"},{"$push":{"hobbies":"read"}}) #2、为名字为yuanhao的人一次添加多个爱好tea，dancing db.user.update({"name":"yuanhao"},{"$push":{ "hobbies":{"$each":["tea","dancing"]} }}) 按照位置且只能从开头或结尾删除元素：$pop #3、{"$pop":{"key":1}} 从数组末尾删除一个元素 db.user.update({"name":"yuanhao"},{"$pop":{ "hobbies":1} }) #4、{"$pop":{"key":-1}} 从头部删除 db.user.update({"name":"yuanhao"},{"$pop":{ "hobbies":-1} }) #5、按照条件删除元素,："$pull" 把符合条件的统统删掉，而$pop只能从两端删 db.user.update({‘addr.country‘:"China"},{"$pull":{ "hobbies":"read"} }, { "multi":true } )
删：
#1、删除多个中的第一个 db.user.deleteOne({ ‘age‘: 8 }) #2、删除国家为China的全部 db.user.deleteMany( {‘addr.country‘: ‘China‘} ) #3、删除全部 db.user.deleteMany({})
e、聚合
如果你有数据存储在MongoDB中，你想做的可能就不仅仅是将数据提取出来那么简单了；你可能希望对数据进行分析并加以利用。MongoDB提供了以下聚合工具： #1、聚合框架 #2、MapReduce(详见MongoDB权威指南) #3、几个简单聚合命令：count、distinct和group。(详见MongoDB权威指南) #聚合框架： 可以使用多个构件创建一个管道，上一个构件的结果传给下一个构件。 这些构件包括（括号内为构件对应的操作符）：筛选($match)、投射($project)、分组($group)、排序($sort)、限制($limit)、跳过($skip) 不同的管道操作符可以任意组合，重复使用
十四、爬虫性能
a、背景知识
爬虫的本质就是一个socket客户端与服务端的通信过程，如果我们有多个url待爬取，只用一个线程且采用串行的方式执行，
那只能等待爬取一个结束后才能继续下一个，效率会非常低。需要强调的是：对于单线程下串行N个任务，并不完全等同于低效，
如果这N个任务都是纯计算的任务，那么该线程对cpu的利用率仍然会很高，之所以单线程下串行多个爬虫任务低效，
是因为爬虫任务是明显的IO密集型程序。
b、同步、异步、回调机制
c、同步调用：即提交一个任务后就在原地等待任务结束，等到拿到任务的结果后再继续下一行代码，效率低下
十五、高性能
上述无论哪种解决方案其实没有解决一个性能相关的问题：IO阻塞，无论是多进程还是多线程，在遇到IO阻塞时都会被操作系统强行剥夺走CPU的执行权限，
程序的执行效率因此就降低了下来。
解决这一问题的关键在于，我们自己从应用程序级别检测IO阻塞然后切换到我们自己程序的其他任务执行，这样把我们程序的IO降到最低，
我们的程序处于就绪态就会增多，以此来迷惑操作系统，操作系统便以为我们的程序是IO比较少的程序，从而会尽可能多的分配CPU给我们，这样也就达到了提升程序执行效率的目的
a、在python3.3之后新增了asyncio模块，可以帮我们检测IO（只能是网络IO），实现应用程序级别的切换
b、但asyncio模块只能发tcp级别的请求，不能发http协议，因此，在我们需要发送http请求的时候，需要我们自定义http报头
c、自定义http报头多少有点麻烦，于是有了aiohttp模块，专门帮我们封装http报头，然后我们还需要用asyncio检测IO实现切换
d、此外，还可以将requests.get函数传给asyncio，就能够被检测了
e、还有之前在协程时介绍的gevent模块
f、封装了gevent+requests模块的grequests模块
g、twisted：是一个网络框架，其中一个功能是发送异步请求，检测IO并自动切换
十六、scrapy
a、介绍
Scrapy一个开源和协作的框架，其最初是为了页面抓取 (更确切来说, 网络抓取 )所设计的，使用它可以以快速、简单、可扩展的方式从网站中提取所需的数据。
但目前Scrapy的用途十分广泛，可用于如数据挖掘、监测和自动化测试等领域，也可以应用在获取API所返回的数据(例如 Amazon Associates Web Services ) 或者通用的网络爬虫。
Scrapy 是基于twisted框架开发而来，twisted是一个流行的事件驱动的python网络框架。因此Scrapy使用了一种非阻塞（又名异步）的代码来实现并发
b、安装
#Windows平台 1、pip3 install wheel #安装后，便支持通过wheel文件安装软件，wheel文件官网：https://www.lfd.uci.edu/~gohlke/pythonlibs 3、pip3 install lxml 4、pip3 install pyopenssl 5、下载并安装pywin32：https://sourceforge.net/projects/pywin32/files/pywin32/ 6、下载twisted的wheel文件：http://www.lfd.uci.edu/~gohlke/pythonlibs/#twisted 7、执行pip3 install 下载目录\\Twisted-17.9.0-cp36-cp36m-win_amd64.whl 8、pip3 install scrapy #Linux平台 1、pip3 install scrapy
c、命令行工具
#1 查看帮助 scrapy -h scrapy <command> -h #2 有两种命令：其中Project-only必须切到项目文件夹下才能执行，而Global的命令则不需要 Global commands: startproject #创建项目 genspider #创建爬虫程序 settings #如果是在项目目录下，则得到的是该项目的配置 runspider #运行一个独立的python文件，不必创建项目 shell #scrapy shell url地址 在交互式调试，如选择器规则正确与否 fetch #独立于程单纯地爬取一个页面，可以拿到请求头 view #下载完毕后直接弹出浏览器，以此可以分辨出哪些数据是ajax请求 version #scrapy version 查看scrapy的版本，scrapy version -v查看scrapy依赖库的版本 Project-only commands: crawl #运行爬虫，必须创建项目才行，确保配置文件中ROBOTSTXT_OBEY = False check #检测项目中有无语法错误 list #列出项目中所包含的爬虫名 edit #编辑器，一般不用 parse #scrapy parse url地址 --callback 回调函数 #以此可以验证我们的回调函数是否正确 bench #scrapy bentch压力测试 #3 官网链接 https://docs.scrapy.org/en/latest/topics/commands.html
d、文件说明：
- scrapy.cfg 项目的主配置信息，用来部署scrapy时使用，爬虫相关的配置信息在settings.py文件中。
- items.py 设置数据存储模板，用于结构化数据，如：Django的Model
- pipelines 数据处理行为，如：一般结构化的数据持久化
- settings.py 配置文件，如：递归的层数、并发数，延迟下载等。强调:配置文件的选项必须大写否则视为无效，正确写法USER_AGENT=‘xxxx‘
- spiders 爬虫目录，如：创建文件，编写爬虫规则
十七、Spiders
a、介绍
#1、Spiders是由一系列类（定义了一个网址或一组网址将被爬取）组成，具体包括如何执行爬取任务并且如何从页面中提取结构化的数据。 #2、换句话说，Spiders是你为了一个特定的网址或一组网址自定义爬取和解析页面行为的地方
b、Spiders会循环做如下事情
#1、生成初始的Requests来爬取第一个URLS，并且标识一个回调函数 第一个请求定义在start_requests()方法内默认从start_urls列表中获得url地址来生成Request请求，默认的回调函数是parse方法。回调函数在下载完成返回response时自动触发 #2、在回调函数中，解析response并且返回值 返回值可以4种： 包含解析数据的字典 Item对象 新的Request对象（新的Requests也需要指定一个回调函数） 或者是可迭代对象（包含Items或Request） #3、在回调函数中解析页面内容 通常使用Scrapy自带的Selectors，但很明显你也可以使用Beutifulsoup，lxml或其他你爱用啥用啥。 #4、最后，针对返回的Items对象将会被持久化到数据库 通过Item Pipeline组件存到数据库：https://docs.scrapy.org/en/latest/topics/item-pipeline.html#topics-item-pipeline） 或者导出到不同的文件（通过Feed exports：https://docs.scrapy.org/en/latest/topics/feed-exports.html#topics-feed-exports） 复制代码
e、Spiders总共提供了五种类
#1、scrapy.spiders.Spider #scrapy.Spider等同于scrapy.spiders.Spider #2、scrapy.spiders.CrawlSpider #3、scrapy.spiders.XMLFeedSpider #4、scrapy.spiders.CSVFeedSpider #5、scrapy.spiders.SitemapSpider
f、导入使用
g、class scrapy.spiders.spider
这是最简单的spider类，任何其他的spider类都需要继承它（包含你自己定义的）。
该类不提供任何特殊的功能，它仅提供了一个默认的start_requests方法默认从start_urls中读取url地址发送requests请求，并且默认parse作为回调函数
十八、Selectors
#1 //与/ #2 text #3、extract与extract_first:从selector对象中解出内容 #4、属性：xpath的属性加前缀@ #4、嵌套查找 #5、设置默认值 #4、按照属性查找 #5、按照属性模糊查找 #6、正则表达式 #7、xpath相对路径 #8、带变量的xpath