Python:爬虫技术

常见就是搜索引擎，无差别的搜集数据、存储、提取关键字、构建索引库，给用户提供搜索接口。

• 爬取一般流程
  1. 初始化一批URL,将这些URL放到带爬队列
  2. 从队列取出这些URL，通过DNS解析IP，对IP对应的站点下载HTML页面，保存到本地服务器中，爬取完的URL放到已爬取队列。
  3. 分析这些网页内容，找出网页里面的其他关心的URL链接，继续执行第2步，直到爬取条件结束。
• 搜索引擎如何获取一个网站的URL
  1. 新网站主动提交给搜索引擎
  2. 通过其他网站页面中设置的外链接
  3. 搜索引擎和DNS服务商合作，获取最新收录的网站

• 有针对性的编写特定领域数据的爬取程序，针对 某些类别数据采集的爬虫，是面向主题的爬虫

urllib是标准库，它一个工具包模块，包含下面模块来处理url: * urllib.request 用于打开和读写url * urllib.error 包含了由urllib.request引起的异常 * urllib.parse 用于解析url * urllib.robotparser 分析robots.txt文件

Python2中提供了urllib和urllib2。urllib提供较为底层的接口，urllib2对urllib进行了进一步封装。Python3中将urllib合并到了urllib2中，并更名为标准库urllib包。

定义了在基本和摘要式身份验证、重定向、cookies等应用中打开Url(主要是HTTP)的函数和类。

• urlopen方法

  1. urlopen(url,data=None)
     • url是链接地址字符串，或请求类的实例
     • data提交的数据，如果data为Non发起的*GET*请求，否则发起*POST*请求。见=urllib.request.Request#get_method=返回http.client.HTTPResponse类的相遇对象，这是一个类文件对象。

  from urllib.request import urlopen
  
  # 打开一个url返回一个相应对象，类文件对象
  # 下面链接访问后会有跳转
  responses = urlopen("http://www.bing.com") #默认GET方法
  print(responses.closed)
  with responses:
      print(1, type(responses)) # http.client.HTTPResponse类文件对象
      print(2,responses.status,responses.reason) #状态
      print(3,responses.geturl()) #返回真正的URL
      print(4,responses.info()) #headers
      print(5,responses.read()[:50]) #读取返回的内容
  
  print(responses.closed)
  

  

  1. 上例，通过urllib.request.urlopen方法，发起一个HTTP的GET请求，WEB服务器返回了网页内容。响应的数据被封装到类文件对象中，可以通过read方法、readline方法、readlines方法获取数据，status和reason属性表示返回的状态码，info方法返回头信息，等等。
• User-Agent问题

  1. 上例代码非常精简，即可以获得网站的响应数据。但目前urlopen方法通过url字符串和data发起HTTP的请求。如果想修改HTTP头，例如useragent,就的借助其他方式。

     • 原码中构造的useragen如下：

     `=python # urllib.request.OpenerDirector class OpenerDirector: def init__(self): client_version = "Python-urllib/%s" % __version self.addheaders = [('User-agent', client_version)]=

     • 当前显示为Python-urlib/3.7
     • 有些网站是反爬虫的，所以要把爬虫伪装成浏览器。顺便打开一个浏览器，复制李立群的UA值，用来伪装。
• Request类
  Request(url,data=None,headers={})
  初始化方法，构造一个请求对象。可添加一个header的字典。data参数决定是GET还是POST请求。
  =obj.add_header(key,val)=为header增加一个键值对。

from urllib.request import Request,urlopen
import random

# 打开一个url返回一个Request请求对象
# url = "https://movie.douban.com/" #注意尾部的斜杠一定要有
url = "http://www.bing.com/"

ua_list = [
    "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/57.0.2987.133 Safari/537.36", # chrome
    "Mozilla/5.0 (Windows; U; Windows NT 6.1; zh-CN) AppleWebKit/537.36 (KHTML, like Gecko) Version/5.0.1 Safari/537.36", # safafi
    "Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:50.0) Gecko/20100101 Firefox/50.0", # Firefox
    "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0)" # IE
]

ua = random.choice(ua_list)
request = Request(url)
request.add_header("User-Agent",ua)
print(type(request))

response = urlopen(request,timeout=20) #request对象或者url都可以
print(type(response))

with response:
    print(1,response.status,response.getcode(),response.reason) #状态，getcode本质上就是返回status
    print(2,response.geturl()) #返回数据的url。如果重定向，这个url和原始url不一样
    # 例如：原始url是http://www.bing.com/,返回http://cn.bing.com/
    print(3,response.info()) #返回响应头headers
    print(4,response.read()[:50]) #读取返回的内容

print(5,request.get_header("User-agent"))
print(6,request.headers)
print(7,"user-agent".capitalize())

该模块可以完成对url的编解码

1. parse.urlencode({key:value}) #对查询字符串进行编码

from urllib import parse

u = parse.urlencode({
    "url":"http://www.xdd.com/python",
    "p_url":"http://www.xdd.com/python?id=1&name=张三"
})
print(u)

# 运行结果
url=http%3A%2F%2Fwww.xdd.com%2Fpython&p_url=http%3A%2F%2Fwww.xdd.com%2Fpython%3Fid%3D1%26name%3D%E5%BC%A0%E4%B8%89

从运行结果来看冒号、斜杠、&、等号、问号等符号全部被编码了，%之后实际上是单字节十六进制表示的值。
一般来说url中的地址部分，一般不需要使用中文路径，但是参数部分，不管GET还是POST方法，提交的数据中， 可能有斜杆、等号、问号等符号，这样这些字符表示数据，不表示元字符。如果直接发给服务器端，就会导致接收 方无法判断谁是元字符，谁是数据了。为了安全，一般会将数据部分的字符做url编码，这样就不会有歧义了。 后来可以传送中文，同样会做编码，一般先按照字符集的encoding要求转换成字节序列，每一个字节对应的十六 进制字符串前加上百分号即可。

from urllib import parse

u = parse.urlencode({"wd":"中"}) #编码查询字符串
url= "https://www.baidu.com/s?{}".format(u)
print(url)

print("中".encode("utf-8")) # b'xe4\xb8\xad'
print(parse.unquote(u)) #解码
print(parse.unquote(url))

• 链接=必应=搜索引擎官网，获取一个搜索的URL=http://cn.bing.com/search?q=%E7%A5%9E%E6%8E%A2%E7%8B%84%E4%BB%81%E6%9D%B0=

from urllib.request import urlopen,Request
from urllib.parse import urlencode

data = urlencode({"q":"神探狄仁杰"})
base_url = "http://cn.bing.com/search"
url = "{}?{}".format(base_url,data)
safafi = "Mozilla/5.0 (Windows; U; Windows NT 6.1; zh-CN) AppleWebKit/537.36 (KHTML, like Gecko) Version/5.0.1 Safari/537.36" # safafi

request = Request(url,headers={"User-agent":safafi})
repost = urlopen(request)
with repost:
    with open("d:/abc.html","wb") as f:
        f.write(repost.read())
print("ok")

• http://httpbin.org/测试网站

from urllib.request import Request,urlopen
from urllib.parse import urlencode
import simplejson

request = Request("http://httpbin.org/post")
request.add_header("User-agent","Mozilla/5.0 (Windows; U; Windows NT 6.1; zh-CN) AppleWebKit/537.36 (KHTML, like Gecko) Version/5.0.1 Safari/537.36")
data = urlencode({"name":"张三,@=/&","age":"6"})
print(data)

res = urlopen(request,data.encode()) #POST方法，Form提价数据，如果Data的值不是None就使用Post方法，否则Get方法
with res:
    j = res.read().decode() #json
    print(j)
    print("===============================")
    print(simplejson.loads(j))

• 查看“豆瓣电影”,中的热门电影，通过分析，我们知道这部分内容，是通过AJAX从后台拿到的JSON数据。
• 访问URL是=https://movie.douban.com/j/search_subjects?type=movie&tag=%E7%83%AD%E9%97%A8&page_limit=50&page_start=0=
  1. =%E7%83%AD%E9%97%A8=是utf-8编码的中文”热门”
  2. tag 标签”热门”，表示热门电影
  3. type 数据类型，movie是电影
  4. page_limit表示返回数据的总数
  5. page_start 表示数据偏移
• 服务器返回json数据如下：(轮播组件，共50条数据)

from urllib.request import Request,urlopen
from urllib.parse import urlencode

base_url = "https://movie.douban.com/j/search_subjects"
data = urlencode({
    "tag":"热门",
    "type":"movie",
    "page_limit":10,
    "page_start":10
})
request = Request(base_url)

# POST方法
repost = urlopen(request,data=data.encode())
with repost:
    print(repost._method)
    print(repost.read().decode()[:100])

# GET方法
with urlopen("{}?{}".format(base_url,data)) as res:
    print(res._method)
    print(res.read().decode()[:100])

• 在XPath中，有七种类型的节点：*元素、属性、文本、命名空间、处理指令、注释以及文档(根)节点。*
  1. =/=根节点
  2. =<bookstore>=元素节点
  3. =<author>Corets,Eva</author>=元素节点。
  4. id"bk104"=是属性节点，id是元素节点book的属性
• 节点之间的嵌套形成*父子(parent,children)关系*。
• 具有统一个父结点的不同节点是*兄弟(sibling)关系*。
• 节点选择

• 谓语(Predicates)
• 谓语用来查找某个特定的节点或者包含某个指定的值的节点。
• *谓语被嵌在方括号中*。
• 谓语就是查询的条件。
• 即在路径选择时，在中括号内指定查询条件。
• XPath轴(Axes)
• 轴的意思是相对于当前结点的节点集

• 步Step
• 步的语法=轴名称：节点测试[谓语]=

• XPATH示例
• 以斜杠开始的称为绝对路径，表示从根开始。
• 不以斜杠开始的称为相对路径，一般都是依照当前节点来计算。当前节点在上下文环境中，当前节点很可能已经补是根节点了。
• 一般为了方便，往往xml如果层次很深，都会使用=//=来查找节点。

• 函数总结

• 在文档树中找到关心的内容才是日常的工资，也就是说如何遍历树中的节点。使用上面的test.html来测试
• 使用Tag
  • soup.div可以找到从根节点开始查找第一个div节点,返回一个Tag对象
  • soup.div.p说明从根节点开始找到第一个div后返回一个Tag对象，这个Tag对象下继续找第一个p，找到返回Tag对象
  • soup.p返回了文字“字典”，而不是文字“bottom”说明遍历时*深度优先*，返回也是Tag对象
• 遍历直接子节点
  • Tag.contents #将对象的所有类型直接子节点以列表方式输出
  • Tag.children #返回子节点的迭代器
    • Tag.children #等价于Tag.contents

• 遍历所有子孙节点

  • Tag.descendants ​#返回节点的所有类型子孙节点，可以看出迭代次序是深度优先

  from bs4 import BeautifulSoup
  from bs4.element import Tag
  
  with open("d://xdd.html",encoding="utf-8") as f:
      soup = BeautifulSoup(f,"lxml")
      print(soup.p.string)
      print(soup.div.contents) #直接子标签列表
      print("- "*30)
  
      for i in soup.div.children: #直接子标签可迭代对象
          print(i.name)
      print("- "*30)
      print(list(map(
          lambda x:x.name if x.name else x,
          soup.div.descendants #所有子孙
      )))
  

  
  

• 遍历字符串

  • 在前面的例子中，soup.div.string返回None，是因为string要求soup.div只能有一个NavigableString类型子节点，也就是这样=<div>only string</div>=。
  • Tag.string #获取Tag下的string对象，如果多余1个结点返回None
  • Tag.strings #返回迭代器，带多余的空白字符。所有的string对象
  • Tag.stripped_strings #返回，会去除多余空白字符

  from bs4 import BeautifulSoup
  from bs4.element import Tag
  
  with open("d://xdd.html",encoding="utf-8") as f:
      soup = BeautifulSoup(f,"lxml")
      print(soup.div.string) #返回None，因为多余1个子节点
      print("- "*30)
      print("".join(soup.div.strings).strip()) #返回迭代器，带多余的空白字符
      print("- "*30)
      print("".join(soup.div.stripped_strings)) #返回迭代器，去除多余空白字符
  

  

• 遍历祖先节点

  • BeautifulSoup.parent ​#获取根节点的父结点，必定返回None,根节点没有父结点
  • Tag.parent #获取第一个Tag的父结点
  • Tag.parent.parent.get("id") #获取第一个tag的父结点的父结点的id属性
  • Tag.parents #获取Tag节点的所有父结点，由近及远

  from bs4 import BeautifulSoup
  from bs4.element import Tag
  
  with open("d://xdd.html",encoding="utf-8") as f:
      soup = BeautifulSoup(f,"lxml")
      print(type(soup))
      print(soup.parent)
      print(soup.div.parent.name) #body ,第一个div的父节点
      print(soup.p.parent.parent.get("id")) #取id属性， main
      print("- "*30)
      print(list(map(lambda x:x.name,soup.p.parents))) #父迭代器，由近及远
  

  
  

• 遍历兄弟节点

  • Tag.next_sibling ​#第一个Tag元素的下一个(下面)兄弟节点，注意：可能是一个文本节点
  • Tag.previous_sibling ​#第一个Tag元素之前的兄弟节点(上面)，注意：可能是一个文本节点
  • Tag.next_siblings #获取Tag元素的下面的所有兄弟节点

  from bs4 import BeautifulSoup
  from bs4.element import Tag
  
  with open("d://xdd.html",encoding="utf-8") as f:
      soup = BeautifulSoup(f,"lxml")
      print(type(soup),type(soup.p))
      print("{} [{}]".format(1,soup.p.next_sibling.encode()))
      print("{} [{}]".format(2,soup.p.previous_sibling.encode()))
      print(soup.p.previous_sibling.next_sibling) #等价于soup.p
      print(soup.p.next_sibling.previous_sibling)  # 等价于soup.p
      print(soup.p)
      print(list(soup.p.next_siblings))
  

  
  

• 遍历其他元素

  • Tag.next_element ​#是下一个可被解析的对象(字符串或tag),和下一个兄弟节点next_sibling不一样
  • Tag.next_elements #返回所有下一个可被解析的对象，是个可迭代对象。

  from bs4 import BeautifulSoup
  
  with open("d://xdd.html",encoding="utf-8") as f:
      soup = BeautifulSoup(f,"lxml")
      print(type(soup),type(soup.p))
      print(soup.p.next_element) #返回"字典"2个字
      print(soup.p.next_element.next_element.encode())
      print(soup.p.next_element.next_element.next_element)
      print(list(soup.p.next_elements))
  
      print("- "*30)
      #对比差异
      print(list(soup.p.next_elements))
      print(list(soup.p.next_siblings))
  

  

• find系有很多分发，请执行查询帮助https://www.crummy.com/software/BeautifulSoup/bs4/doc.zh/#id25
• =find_all(name=None,attrs={},recursive=True,text=None,limit=None,**kwargs)=#立即返回一个列表
• name参数:官方称为*fiter过滤器*，这个参数可以是一下
  1. *字符串*：一个标签名称的字符串，会按照这个字符串全长匹配标签名 =print(soup.find_all('p'))=#返回文档中所有p标签

  2. 正则表达式对象:按照”正则表达式对象”的模式匹配标签名

     import re
     print(soup.find_all(re.compile("^h\d"))) #标签名以h开头后接数字
     

  3. *列表*：或关系查找列表中的每个字符串

     print(soup.find_all(["p","h1","h3"])) #或关系，找出列表所有的标签
     print(soup.find_all(re.compile(r"^p|h|\d$"))) #使用正则表达式完成
     

  4. True或None,则find_all返回全部非字符串节点、非注释节点，就是Tag标签类型

     from bs4 import BeautifulSoup
     
     with open("d://xdd.html",encoding="utf-8") as f:
         soup = BeautifulSoup(f,"lxml")
         print(list(map(lambda x: x.name, soup.find_all(True))))
         print(list(map(lambda x: x.name, soup.find_all(None))))
         print(list(map(lambda x: x.name, soup.find_all())))
     

     

     from bs4 import BeautifulSoup
     from bs4.element import Tag
     
     with open("d://xdd.html",encoding="utf-8") as f:
         soup = BeautifulSoup(f,"lxml")
         values = [True,None,False]
         for value in values:
             all = soup.find_all(value)
             print(type(all[0]))
             print(len(all))
     
         print("- "*30)
         count = 0
         for i,t in enumerate(soup.descendants): #遍历所有类型的子孙节点
             print(i,type(t),t.name)
             if isinstance(t,Tag): #只对Tag类型计数
                 count += 1
         print(count)
     # 数目一致，所以返回的是Tag类型的节点，源码中确实返回的Tag类型
     

     
     

  5. 函数

     • 如果使用以上过滤器还不能提取想要的节点，可以使用函数，此函数仅只能*接收一个参数*。
     • 如果这个函数返回True,表示当前节点配置；返回False则是不匹配。
     • 示例：找出所有class属性且有多个值的节点(测试html中符合这个条件只有h3标签)

     from bs4 import BeautifulSoup
     from bs4.element import Tag
     
     def many_classes(tag:Tag):
         # print(type(tag))
         # print(type(tag.attrs))
         return len(tag.attrs.get("class",[])) > 1
     
     with open("d://xdd.html",encoding="utf-8") as f:
         soup = BeautifulSoup(f,"lxml")
         print(soup.find_all(many_classes))
     

     
     

• keyword传参

  1. 使用关键字传参，如果参数名不是find系函数已定义的位置参数名，参数会被kwargs收集并被*当做标签的属性*来搜索。
  2. 属性的传参可以是字符串、正则表达式对象、True、列表。

  from bs4 import BeautifulSoup
  import re
  
  with open("d://xdd.html",encoding="utf-8") as f:
      soup = BeautifulSoup(f,"lxml")
      print(soup.find_all(id="first")) #id为first的所有结点列表
      print(1,"- "*30)
      print(soup.find_all(id=re.compile("\w+"))) #相当于找有di的所有节点
      print(2,"- " * 30)
      print(soup.find_all(id=True)) #所有有id的节点
  
      print(3,"- " * 30)
      print(list(map(lambda x:x["id"],soup.find_all(id=True))))
      print(4,"- " * 30)
      print(soup.find_all(id=["first",re.compile(r"^sec")])) #指定id的名称列表
      print(5,"- " * 30)
      print(soup.find_all(id=True,src=True)) #相当于条件and,既有id又有src属性的节点列表
  

  

• css的class的特殊处理

  1. class是Python关键字，所以使用=class_=。class是多值属性，可以匹配其中任意一个，也可以完全匹配。

  print(soup.find_all(class_="content"))
  print(soup.find_all(class_="title")) #可以使用任意一个css类
  print(soup.find_all(class_="highlight")) #可以使用任意一个css类
  print(soup.find_all(class_="highlight title")) #顺序错了，找不到
  print(soup.find_all(class_="title highlight")) #顺序一致，找到。就是字符串完全匹配
  

• attrs参数

  • attrs接收一个字典，字典的key为属性名，value可以是字符串、正则表达式对象、True、列表。可以多个属性

  print(soup.find_all(attrs={"class":"title"}))
  print(soup.find_all(attrs={"class":"highlight"}))
  print(soup.find_all(attrs={"class":"title highlight"}))
  print(soup.find_all(attrs={"id":True}))
  print(soup.find_all(attrs={"id":re.compile(r"\d$")}))
  print(list(map(lambda x:x.name,soup.find_all(attrs={"id":True,"src":True}))))
  

• text参数

  • 可以通过text参数搜索文档中的字符串内容，接受字符串、正则表达式对象、True、列表

  from bs4 import BeautifulSoup
  import re
  
  with open("d://xdd.html",encoding="utf-8") as f:
      soup = BeautifulSoup(f,"lxml")
      print(list(map(lambda x:(type(x),x),soup.find_all(text=re.compile("\w+"))))) #返回文本类节点
      print("- "*30)
      print(list(map(lambda x:(type(x),x),soup.find_all(text=re.compile("[a-z]+")))))
      print("- "*30)
      print(soup.find_all(re.compile(r"^(h|p)"),text=re.compile("[a-z]+"))) #相当于过滤Tag对象，并看它的string是否符合text参数要求，返回Tag对象
  

  
  

• *limit参数*：显示返回结果的数量

  print(soup.find_all(id=True,limit=3)) #返回列表中有3个结果
  

• recursive参数
  • 默认是递归搜索所有子孙节点，如果不需要请设置为False

• 简化写法

  1. find_all()是非常常用的方法，可以简化省略掉

  from bs4 import BeautifulSoup
  import re
  
  with open("d://xdd.html",encoding="utf-8") as f:
      soup = BeautifulSoup(f,"lxml")
      print(soup("img")) #所有img标签对象的列表，等价于soup.find_all("img")
      print(soup.img) #深度优先第一个img
  
      print(soup.a.find_all(text=True)) #返回文本
      print(soup.a(text=True)) #返回文本，和上面等价
      print(soup("a",text=True)) #返回a标签对象
  
      print(soup.find_all("img",attrs={"id":"bg1"}))
      print(soup("img",attrs={"id":"bg1"})) #find_all的省略
      print(soup("img",attrs={"id":re.compile("1")}))
  

  

• find方法

  1. find(name,attrs,recursive,text,**kwargs)
     • 参数几乎和find_all一样。
     • 找到了，find_all返回一个列表，而find返回一个单值，元素对象。
     • 找不到，find_all返回一个空列表，而find返回一个None。

  from bs4 import BeautifulSoup
  
  with open("d://xdd.html",encoding="utf-8") as f:
      soup = BeautifulSoup(f,"lxml")
      print(soup.find("img",attrs={"id":"bg1"}).attrs.get("src","xdd"))
      print(soup.find("img",attrs={"id":"bg1"}).get("src")) #简化了attrs
      print(soup.find("img",attrs={"id":"bg1"})["src"])
  

  

• 和JQuery一样，可以使用CSS选择器来 查找节点
• 使用soup.select()方法，select方法支持大部分CSS选择器，返回列表。
• CSS中，标签名直接使用，类名前加=.=点号,id名前加=#=井号。
• BeautifulSoup.select("css选择器")

from bs4 import BeautifulSoup

with open("d://xdd.html",encoding="utf-8") as f:
    soup = BeautifulSoup(f,"lxml")
    #元素选择器
    print(1,soup.select("p")) #所有的p标签

    #类选择器
    print(2,soup.select(".title"))

    #使用了伪类
    #直接子标签是p的同类型的所有p标签中的第二个
    #(同类型)同标签名p的第2个，伪类只实现了nth-of-type，且要求是数字
    print(3,soup.select("div.content >p:nth-of-type(2)"))

    # id选择器
    print(4,soup.select("p#second"))
    print(5,soup.select("#bg1"))

    #后代选择器
    print(6,soup.select("div p")) # div下逐层找p
    print(7,soup.select("div div p")) #div下逐层找div下逐层找p

    #子选择器，直接后代
    print(8,soup.select("div > p")) #div下直接子标签的p，有2个

    #相邻兄弟选择器
    print(9, soup.select("div p:nth-of-type(1) + [src]")) #返回[]
    print(9, soup.select("div p:nth-of-type(1) + p"))  # 返回p标签
    print(9, soup.select("div > p:nth-of-type(2) + input"))  # 返回input Tag
    print(9, soup.select("div > p:nth-of-type(2) + [type]"))  # 同上

    #普通兄弟选择器
    print(10, soup.select("div p:nth-of-type(1) ~ [src]")) #返回2个img

    #属性选择器
    print(11,soup.select("[src]")) #有属性src
    print(12,soup.select("[src='/']")) #属性src等于/
    print(13,soup.select("[src='http://www.xdd.com/']")) #完全匹配
    print(14,soup.select("[src^='http://www']")) #以http://www开头
    print(15,soup.select("[src$='com/']")) #以com/结尾
    print(16,soup.select("img[src*='xdd']")) #包含xdd
    print(17,soup.select("img[src*='.com']")) #包含.com
    print(18,soup.select("[class='title highlight']")) #完全匹配calss等于'title highlight'
    print(19,soup.select("[class~=title]")) #多值属性中有一个title

• 获取文本内容
• 搜索节点的目的往往是为了提取该节点的文本内容，一般不需要HTML标记，只需要文字

from bs4 import BeautifulSoup

with open("d://xdd.html",encoding="utf-8") as f:
    soup = BeautifulSoup(f,"lxml")
    # 元素选择器
    ele = soup.select("div") #所有的div标签
    print(type(ele))
    print(ele[0].string) #内容仅仅只能是文本类型，否则返回None
    print(list(ele[0].strings)) #迭代保留空白字符
    print(list(ele[0].stripped_strings)) #迭代不保留空白字符

    print("- "*30)
    print(ele[0])
    print("- " * 30)

    print(list(ele[0].text))#本质上就是get_text(),保留空白字符的strings
    print(list(ele[0].get_text())) #迭代并join，保留空白字符，strip默认为False
    print(list(ele[0].get_text(strip=True))) #迭代并join，不保留空白字符

• bs4.element.Tag#string源码

class Tag(PageElement):
@property
    def string(self):
        if len(self.contents) != 1:
            return None
        child = self.contents[0]
        if isinstance(child, NavigableString):
            return child
        return child.string

    @string.setter
    def string(self, string):
        self.clear()
        self.append(string.__class__(string))

    def _all_strings(self, strip=False, types=(NavigableString, CData)):
        for descendant in self.descendants:
            if (
                (types is None and not isinstance(descendant, NavigableString))
                or
                (types is not None and type(descendant) not in types)):
                continue
            if strip:
                descendant = descendant.strip()
                if len(descendant) == 0:
                    continue
            yield descendant

    strings = property(_all_strings)

    @property
    def stripped_strings(self):
        for string in self._all_strings(True):
            yield string

    def get_text(self, separator="", strip=False,
                 types=(NavigableString, CData)):
        return separator.join([s for s in self._all_strings(
                    strip, types=types)])
    getText = get_text
    text = property(get_text)

• 使用系统环境变量，如果没有使用rabbitmq-env.conf中定义环境变量，否则使用缺省值

RABBITMQ_NODE_IP_ADDRESS the empty string, meaning that it should bind to all network interfaces.  
RABBITMQ_NODE_PORT 5672  
RABBITMQ_DIST_PORT RABBITMQ_NODE_PORT + 20000  #内部节点和客户端工具通信用  
RABBITMQ_CONFIG_FILE 配置文件路径默认为/etc/rabbitmq/rabbitmq  

环境变量文件，可以不配置

• rabbitmq.config配置文件
• 3.7支持新旧两种配置文件格式

• erlang配置文件格式，为了兼容继续采用

  

• sysctl格式，如果不需要兼容，RabbitMQ鼓励使用。 (这个文件也可以不配置)

列出所有可用插件

rabbitmq-plugins list

• 启动WEB管理插件，会依赖启用其他几个插件。

[root@xdd rabbitmq]$ rabbitmq-plugins enable rabbitmq_management

systemctl start rabbitmq-server

• 启动中，可能出现下面的错误
  1. Error when reading /var/lib/rabbitmq/.erlang.cookie:eacces=这就是这个文件的权限问题，修改属组、属组为rabbitmq即可 =chown rabbitmq.rabbitmq /var/lib/rabbitmq/.erlang.cookie
• 服务启动成功

[root@xdd ~]# ss -tanl | grep 5672
LISTEN     0      128          *:25672                    *:*
LISTEN     0      128          *:15672                    *:*
LISTEN     0      128         :::5672                    :::*
[root@xdd ~]#

• 开始登陆WEB界面,=http://192.168.61.108(rabbitmq所在主机的ip):15672=
  
• 使用guest/guest只能本地登陆，远程登录会报错
• rabbitmqctl命令
  • rabbitmqctl [-n <node>] [-1][-q] <command> [<command options>]
  • General options:
    1. -n node
    2. -q,–quiet
    3. -t,–timeout timeout
    4. -l longnames
  • Commands:
    1. add_user <username> <password> 添加用户
    2. list_user 列出用户
    3. delete_user username 删除用户
    4. change_password <username> <password> 修改用户名，密码
    5. set_user_tags <username> <tag> [...] 设置用户tag
    6. list_user_permissions 列出用户权限
• 添加用户：=rabbitmqctl add_user username password=
  
• 删除用户：=rabbitmqctl delete_user username=
• 更改密码：=rabbitmqctl change_password username newpassword=
• 设置权限Tags，其实就是分配组：=rabbitmqctl set_user_tags username tag=
• 设置xdd用户为管理员tag后登陆

# rabbitmqctl add_user gdy gdy  #添加xdd用户
# rabbitmqctl list_users #查看所有用户
# rabbitmqctl set_user_tags gdy administrator #设置xdd用户为管理员用户

• tag的意义如下：
  1. administrator可以管理用户、权限、虚拟主机。
• 基本信息(web管理端口15672，协议端口5672)
  
• 虚拟主机
  1. 缺省虚拟主机，默认只能是guest用户在本机链接，下图新建的用户gdy默认无法访问任何虚拟主机

• 参考官网https://www.rabbitmq.com/getstarted.html

• 名词解释

1. 系统间解耦
2. 解决生产者、消费者速度匹配
3. 由于稍微上规模的项目都会分层、分模块开发，模块间或系统间尽量不要直接耦合，需要开放公共接口提供给别的模块或系统调用，而调用可能触发并发问题，为了缓冲和解耦，往往采用中间件技术。
4. RabbitMQ只是消息中间件中的一种应用程序，也是较常用的中间件服务。