1 基础

  1. index -> 数据库
  2. type -> 表
  3. document -> 行
  4. field -> 列
  5. -------------------------------------------------------------------
  6. 字段属性
  7. type
  8. 	String
  9. 		text -> 可分词,不能聚合
  10. 		keyword -> 可聚合,不能分词
  11. 	数值类型
  12. 		long.integer.short.byte.double.float.half_float.scaled_float
  14. index
  15. 	true -> 会被索引,默认true
  16. 	false -> 不会被索引,如设置图片
  17. -------------------------------------------------------------------
  18. 创建数据库 a1 分片5 副本1
  19. PUT a1
  20. {
  21.   "settings": {
  22.     "number_of_shards": 5,
  23.     "number_of_replicas": 1
  24.   }
  25. }
  27. 查看数据库 a1
  28. GET a1
  30. 查看所有数据库
  31. GET *
  33. 删除数据库 a1
  34. DELETE a1

2 基础

  1. //在 a1 数据库中建表 student
  2. //建立字段 name(类型text 指定分词) age(类型integer)
  3. PUT a1/_mapping/student
  4. {
  5.   "properties": {
  6.     "name": {
  7.       "type": "text",
  8.       "analyzer": "ik_max_word"
  9.     },
  10.     "age": {
  11.       "type": "integer"
  12.     }
  13.   }
  14. }
  16. 查看 a1 数据库中建立的表解构
  17. GET a1/_mapping
  19. 往表中添加数据
  20. POST a1/student
  21. {
  22.   "name":"小米手机",
  23.   "age":11
  24. }
  26. 查看 a1 数据库的全部数据
  27. _source -> 查询到的数据
  28. _id -> 文档的唯一标识
  29. GET a1/_search
  30. {
  31.     "query":{
  32.         "match_all": {}
  33.     }
  34. }
  36. 自定义 _id 为2 的数据
  37. POST a1/student/2
  38. {
  39.   "name":"大米手机",
  40.   "age":22
  41. }
  43. 如果添加字段 address 不存在就会自动创建
  44. POST a1/student/3
  45. {
  46.   "name":"小米电视4K",
  47.   "age":33,
  48.   "address":"安徽阜阳晶宫大酒店101"
  49. }
  51. 修改数据如果对应 id 存在则删除之前的再添加 不存在则添加
  52. PUT a1/student/4
  53. {
  54.   "name":"小米电脑",
  55.   "age":44
  56. }
  58. 删除id=4的文档
  59. DELETE a1/student/4

3 基本查询

  1. 基本查询
  3. match_all
  4. 查询数据库 a1 所有数据
  5. GET a1/_search
  6. {
  7.   "query": {
  8. 	"match_all": {}
  9.   }
  10. }
  11. ---
  12. {
  13.   "took": 4,//查询耗时4毫秒
  14.   "timed_out": false,//没有超时
  15.   "_shards": {//分片
  16. 	"total": 5,//一共5个
  17. 	"successful": 5,//成功5个
  18. 	"skipped": 0,//跳过0个
  19. 	"failed": 0//失败0个
  20.   },
  21.   "hits": {//查询到的数据
  22. 	"total": 3,//查询总条数
  23. 	"max_score": 1,//最大得分1
  24. 	"hits": [//查询到的数据所有文档
  25. 	  {//一个文档
  26. 		"_index": "a1",//数据库
  27. 		"_type": "student",//表
  28. 		"_id": "2",//注解 每个文档的唯一标识
  29. 		"_score": 1,//得分是1 满分是最大得分
  30. 		"_source": {//查询到的数据 包括 字段 字段值 -> k:v
  31. 		  "name": "大米手机",
  32. 		  "age": 22
  33. 		}
  34. 	  },
  35. 	  {
  36. 		"_index": "a1",
  37. 		"_type": "student",
  38. 		"_id": "CA2Yqm0Bmr19jrNQ7nRL",
  39. 		"_score": 1,
  40. 		"_source": {
  41. 		  "name": "小米手机",
  42. 		  "age": 11
  43. 		}
  44. 	  },
  45. 	  {
  46. 		"_index": "a1",
  47. 		"_type": "student",
  48. 		"_id": "3",
  49. 		"_score": 1,
  50. 		"_source": {
  51. 		  "name": "小米电视4K",
  52. 		  "age": 33,
  53. 		  "address": "安徽阜阳小米酒店101"
  54. 		}
  55. 	  }
  56. 	]
  57.   }
  58. }
  59. ---
  60. match
  61. 查询 name=小米电视
  62. 因为使用了分词,默认是or 所以可匹配 -> 小米 or 电视
  63. GET a1/_search
  64. {
  65.   "query": {
  66.     "match": {
  67.       "name": "小米电视"
  68.     }
  69.   }
  70. }
  72. 查询分词,指定and可匹配 -> 小米 and 电视
  73. GET a1/_search
  74. {
  75.   "query": {
  76.     "match": {
  77.       "name": {
  78.         "query": "小米电视",
  79.         "operator": "and"
  80.       }
  81.     }
  82.   }
  83. }
  85. 可以指定分词的个数,
  86. 1 -> 匹配任意一个词
  87. 2 -> 匹配任意两个词
  88. 3 -> 因为超过了分词量,所以匹配不到
  89. GET a1/_search
  90. {
  91.   "query": {
  92.     "match": {
  93.       "name": {
  94.         "query": "小米电视",
  95.         "minimum_should_match": 1
  96.       }
  97.     }
  98.   }
  99. }
  101. 3x0.66=1.98,因为1.98<2 所以匹配任意一个
  102. GET a1/_search
  103. {
  104.   "query": {
  105.     "match": {
  106.       "name": {
  107.         "query": "小米智能电视",
  108.         "minimum_should_match": "66%"
  109.       }
  110.     }
  111.   }
  112. }
  114. 3x0.67=2.01,因为2.01>2 所以匹配任意两个
  115. GET a1/_search
  116. {
  117.   "query": {
  118.     "match": {
  119.       "name": {
  120.         "query": "小米智能电视",
  121.         "minimum_should_match": "67%"
  122.       }
  123.     }
  124.   }
  125. }
  127. 查询 name 或 address 含有"小米"这个词
  128. GET a1/_search
  129. {
  130.   "query": {
  131.     "multi_match": {
  132.       "query": "小米",
  133.       "fields": ["name","address"]
  134.     }
  135.   }
  136. }
  138. 精准匹配 age=11
  139. GET a1/_search
  140. {
  141.   "query": {
  142.     "term": {
  143.       "age": {
  144.         "value": 11
  145.       }
  146.     }
  147.   }
  148. }
  150. 多条精准匹配 age in [11,22,77]
  151. GET a1/_search
  152. {
  153.   "query": {
  154.     "terms": {
  155.       "age": [11,22,77]
  156.     }
  157.   }
  158. }

4 结果过滤

  1. 结果过滤
  3. 查询字段只显示 name age
  4. 并且查询 age in [11,22,77]
  5. GET a1/_search
  6. {
  7.   "_source": ["name","age"],
  8.   "query": {
  9.     "terms": {
  10.       "age": [11,22,77]
  11.     }
  12.   }
  13. }
  15. 查询所有 只显示"address"字段,没有此字段的显示空
  16. GET a1/_search
  17. {
  18.   "_source": {
  19.     "includes": ["address"]
  20.   }
  21. }
  23. 查询所有只除了"address"字段,其他全显示
  24. GET a1/_search
  25. {
  26.   "_source": {
  27.     "excludes": ["address"]
  28.   }
  29. }

5 高级查询

  1. 高级查询
  3. 与 must[{1},{2}] 满足所有
  4. 查询"name"分词有"小米"并且"age"等于11或者22
  5. GET a1/_search
  6. {
  7.   "query": {
  8.     "bool": {
  9.       "must": [
  10.         {
  11.           "match": {
  12.             "name": "小米"
  13.           }
  14.         },
  15.         {
  16.           "terms": {
  17.             "age": [11,22]
  18.           }
  19.         }
  20.       ]
  21.     }
  22.   }
  23. }
  25. 非 must_not[{1},{2}] 不满足所有
  26. 查询"name"分词没有"小米并且"age"不等于11或者22
  27. GET a1/_search
  28. {
  29.   "query": {
  30.     "bool": {
  31.       "must_not": [
  32.         {
  33.           "match": {
  34.             "name": "小米"
  35.           }
  36.         },
  37.         {
  38.           "terms": {
  39.             "age": [11,22]
  40.           }
  41.         }
  42.       ]
  43.     }
  44.   }
  45. }
  47. 或 should[{1},{2}] 满足任意一个
  48. GET a1/_search
  49. {
  50.   "query": {
  51.     "bool": {
  52.       "should": [
  53.         {
  54.           "match": {
  55.             "name": "小米"
  56.           }
  57.         },
  58.         {
  59.           "terms": {
  60.             "age": [11,22]
  61.           }
  62.         }
  63.       ]
  64.     }
  65.   }
  66. }
  68. >  >=  <  <=
  69. lt lte gt gte
  70. 查询 10<=age<30
  71. GET a1/_search
  72. {
  73.   "query": {
  74.     "range": {
  75.       "age": {
  76.         "gte": 10,
  77.         "lt": 30
  78.       }
  79.     }
  80.   }
  81. }

6 过滤

  1. 过滤
  3. 查询"name"=小米并且10<=age<=20
  4. GET a1/_search
  5. {
  6.   "query": {
  7.     "bool": {
  8.       "must": [
  9.         {
  10.           "match": {
  11.             "name": "小米"
  12.           }
  13.         }
  14.       ],
  15.       "filter": {
  16.         "range": {
  17.           "age": {
  18.             "gte": 10,
  19.             "lte": 20
  20.           }
  21.         }
  22.       }
  23.     }
  24.   }
  25. }
  27. 排序
  29. 查询"name"=小米并按照年龄降序
  30. GET a1/_search
  31. {
  32.   "query": {
  33.     "match": {
  34.       "name": "小米"
  35.     }
  36.   },
  37.   "sort": [
  38.     {
  39.       "age": {
  40.         "order": "desc"
  41.       }
  42.     }
  43.   ]
  44. }

7 聚合

  1. 聚合
  3. select count(color)//指标 -> 对桶计算
  4. from table
  5. group by color//桶 -> 满足条件的文档集合
  7. 1.通过国家划分文档（桶）
  8. 2.然后通过性别划分每个国家（桶）
  9. 3.然后通过年龄区间划分每种性别（桶）
  10. 4.最后，为每个年龄区间计算平均薪酬（指标）
  11. 所有的这些都在一个请求内完成并且只遍历一次数据！
  13. PUT /cars
  14. {
  15.   "settings": {
  16.     "number_of_shards": 1,
  17.     "number_of_replicas": 0
  18.   },
  19.   "mappings": {
  20.     "transactions": {
  21.       "properties": {
  22.         "color": {
  23.           "type": "keyword"
  24.         },
  25.         "make": {
  26.           "type": "keyword"
  27.         }
  28.       }
  29.     }
  30.   }
  31. }
  33. 执行这一条 先执行上一条
  34. POST /cars/transactions/_bulk
  35. { "index": {}}
  36. { "price" : 10000, "color" : "red", "make" : "honda", "sold" : "2014-10-28" }
  37. { "index": {}}
  38. { "price" : 20000, "color" : "red", "make" : "honda", "sold" : "2014-11-05" }
  39. { "index": {}}
  40. { "price" : 30000, "color" : "green", "make" : "ford", "sold" : "2014-05-18" }
  41. { "index": {}}
  42. { "price" : 15000, "color" : "blue", "make" : "toyota", "sold" : "2014-07-02" }
  43. { "index": {}}
  44. { "price" : 12000, "color" : "green", "make" : "toyota", "sold" : "2014-08-19" }
  45. { "index": {}}
  46. { "price" : 20000, "color" : "red", "make" : "honda", "sold" : "2014-11-05" }
  47. { "index": {}}
  48. { "price" : 80000, "color" : "red", "make" : "bmw", "sold" : "2014-01-01" }
  49. { "index": {}}
  50. { "price" : 25000, "color" : "blue", "make" : "ford", "sold" : "2014-02-12" }
  52. ---1 -> 尝试聚合 terms
  53. 按照"color"聚合 聚合名称为"popular_colors"
  54. GET /cars/_search
  55. {
  56.     "size" : 0,
  57.     "aggs" : {
  58.         "popular_colors" : {
  59.             "terms" : {"field" : "color"}
  60.         }
  61.     }
  62. }
  64. 聚合结果 -> 红色汽车卖的最好
  65. hits 结果为空,因为我们设置size:0
  66. aggregations 聚合结果
  67. popular_colors 聚合名称
  68. buckets 桶的集合
  69. 	key 这个桶对应"color"的值
  70. 	doc_count 这个桶中文档数量
  72. {
  73.   "took": 3,
  74.   "timed_out": false,
  75.   "_shards": {
  76.     "total": 1,
  77.     "successful": 1,
  78.     "skipped": 0,
  79.     "failed": 0
  80.   },
  81.   "hits": {
  82.     "total": 8,//查询到全部8条
  83.     "max_score": 0,
  84.     "hits": []//显示0条 设置了 size=0
  85.   },
  86.   "aggregations": {
  87.     "popular_colors": {
  88.       "doc_count_error_upper_bound": 0,
  89.       "sum_other_doc_count": 0,
  90.       "buckets": [
  91.         {
  92.           "key": "red",
  93.           "doc_count": 4
  94.         },
  95.         {
  96.           "key": "blue",
  97.           "doc_count": 2
  98.         },
  99.         {
  100.           "key": "green",
  101.           "doc_count": 2
  102.         }
  103.       ]
  104.     }
  105.   }
  106. }
  108. ---2 -> 添加度量指标 avg
  109. 对聚合后的桶再进行度量算平均值
  110. GET cars/_search
  111. {
  112.   "size": 0,
  113.   "aggs": {
  114.     "popular_colors": {
  115.       "terms": {"field": "color"},
  116.       "aggs": {
  117.         "avg_price": {
  118.           "avg": {"field": "price"}
  119.         }
  120.       }
  121.     }
  122.   }
  123. }
  124. 聚合结果 -> 红色汽车平均价格最贵
  125. ...
  126.   "aggregations": {
  127.     "popular_colors": {
  128.       "doc_count_error_upper_bound": 0,
  129.       "sum_other_doc_count": 0,
  130.       "buckets": [
  131.         {
  132.           "key": "red",
  133.           "doc_count": 4,
  134.           "avg_price": {
  135.             "value": 32500
  136.           }
  137.         },
  138.         {
  139.           "key": "blue",
  140.           "doc_count": 2,
  141.           "avg_price": {
  142.             "value": 20000
  143.           }
  144.         },
  145.         {
  146.           "key": "green",
  147.           "doc_count": 2,
  148.           "avg_price": {
  149.             "value": 21000
  150.           }
  151.         }
  152.       ]
  153.     }
  154.   }
  155. ...
  156. ---3 -> 嵌套桶 terms avg terms
  157. 对聚合的结果再次进行聚合,桶嵌套桶
  158. GET /cars/_search
  159. {
  160.     "size" : 0,
  161.     "aggs" : {
  162.         "popular_colors" : {
  163.             "terms" : {"field" : "color"},
  164.             "aggs":{
  165.                 "avg_price": {
  166.                    "avg": {"field": "price"}
  167.                 },
  168.                 "maker":{
  169.                     "terms":{"field":"make"}
  170.                 }
  171.             }
  172.         }
  173.     }
  174. }
  176. 聚合结果 -> 每种颜色的各个车型卖出去多少量
  177. + 原来的color桶和avg计算我们不变
  178. + maker：在嵌套的aggs下新添一个桶，叫做maker
  179. + terms：桶的划分类型依然是词条
  180. + filed：这里根据make字段进行划分
  181. ...
  182.   "aggregations": {
  183.     "popular_colors": {
  184.       "doc_count_error_upper_bound": 0,
  185.       "sum_other_doc_count": 0,
  186.       "buckets": [
  187.         {
  188.           "key": "red",
  189.           "doc_count": 4,
  190.           "maker": {
  191.             "doc_count_error_upper_bound": 0,
  192.             "sum_other_doc_count": 0,
  193.             "buckets": [
  194.               {
  195.                 "key": "honda",
  196.                 "doc_count": 3
  197.               },
  198.               {
  199.                 "key": "bmw",
  200.                 "doc_count": 1
  201.               }
  202.             ]
  203.           },
  204.           "avg_price": {
  205.             "value": 32500
  206.           }
  207.         },
  208.         {
  209.           "key": "blue",
  210.           ...
  211.         },
  212.         {
  213.           "key": "green",
  214.           ...
  215.         }
  216.       ]
  217.     }
  218.   }
  219. ...
  221. ---4 -> 最后的修改 terms avg min max terms terms
  222. 1>
  223. 	一共有多少种颜色
  224. 	每种颜色卖多少辆车
  225. 	每种颜色平均价格是多少
  226. 2>
  227. 	每种颜色都是什么车
  228. 	每种车有多少辆
  229. 3>
  230. 	每种车价格是多少
  231. GET /cars/_search
  232. {
  233.     "size" : 0,
  234.     "aggs" : {
  235.         "popular_colors" : {
  236.             "terms" : {  "field" : "color"},
  237.             "aggs":{
  238.                 "avg_price": {
  239.                    "avg": { "field": "price" }
  240.                 },
  241.                 "min_price":{
  242.                   "min": {"field": "price"}
  243.                 },
  244.                 "max_price":{
  245.                   "max": {"field": "price"}
  246.                 },
  247.                 "maker":{
  248.                     "terms":{"field":"make"},
  249.                     "aggs": {
  250.                       "a_price": {
  251.                         "terms": {"field": "price" }
  252.                       }
  253.                     }
  254.                 }
  255.             }
  256.         }
  257.     }
  258. }
  260. 聚合结果
  261. 	其中红色汽车4辆
  262. 	红色最贵80000 最便宜10000
  263. 	其中3辆honda本田 1辆bmw
  264. 	其中本田20000 卖2辆 本田10000卖1辆 宝马bmw80000 卖一辆
  265. ...
  266.   "aggregations": {
  267.     "popular_colors": {
  268.       "doc_count_error_upper_bound": 0,
  269.       "sum_other_doc_count": 0,
  270.       "buckets": [
  271.         {
  272.           "key": "red",
  273.           "doc_count": 4,
  274.           "max_price": {
  275.             "value": 80000
  276.           },
  277.           "min_price": {
  278.             "value": 10000
  279.           },
  280.           "maker": {
  281.             "doc_count_error_upper_bound": 0,
  282.             "sum_other_doc_count": 0,
  283.             "buckets": [
  284.               {
  285.                 "key": "honda",
  286.                 "doc_count": 3,
  287.                 "a_price": {
  288.                   "doc_count_error_upper_bound": 0,
  289.                   "sum_other_doc_count": 0,
  290.                   "buckets": [
  291.                     {
  292.                       "key": 20000,
  293.                       "doc_count": 2
  294.                     },
  295.                     {
  296.                       "key": 10000,
  297.                       "doc_count": 1
  298.                     }
  299.                   ]
  300.                 }
  301.               },
  302.               {
  303.                 "key": "bmw",
  304.                 "doc_count": 1,
  305.                 "a_price": {
  306.                   "doc_count_error_upper_bound": 0,
  307.                   "sum_other_doc_count": 0,
  308.                   "buckets": [
  309.                     {
  310.                       "key": 80000,
  311.                       "doc_count": 1
  312.                     }
  313.                   ]
  314.                 }
  315.               }
  316.             ]
  317.           },
  318.           "avg_price": {
  319.             "value": 32500
  320.           }
  321.         },
  322.         {
  323.           "key": "blue",
  324.           ...
  325.         },
  326.         {
  327.           "key": "green",
  328.           ...
  329.         }
  330.       ]
  331.     }
  332.   }
  333. ...
  335. ---5 -> 条形图 histogram interval
  336. 聚合名称"a_price"
  337. 根据字段"price"进行5000一次分割
  338. 从最小到最大,例如
  339. [-1,1,4999,5000,5001,10000,10001] -> 
  341. [-5000,0) -> -1
  342. [0,5000) -> 1 4999
  343. [5000,10000) -> 5000 5001
  344. [10000,15000) -> 10000 10001
  346. key=0 [0,5000)
  347. key=5000 [5000,10000)
  348. GET /cars/_search
  349. {
  350.   "size":0,
  351.   "aggs":{
  352.     "a_price":{
  353.       "histogram": {
  354.         "field": "price",
  355.         "interval": 5000
  356.       }
  357.     }
  358.   }
  359. }
  361. 聚合结果
  362. ...
  363.   "aggregations": {
  364.     "a_price": {
  365.       "buckets": [
  366.         {
  367.           "key": 10000,
  368.           "doc_count": 2
  369.         },
  370.         {
  371.           "key": 15000,
  372.           "doc_count": 1
  373.         },
  374.         {
  375.           "key": 20000,
  376.           "doc_count": 2
  377.         },
  378.         {
  379.           "key": 25000,
  380.           "doc_count": 1
  381.         },
  382.         {
  383.           "key": 30000,
  384.           "doc_count": 1
  385.         },
  386.         {
  387.           "key": 35000,
  388.           "doc_count": 0
  389.         },
  390.         {
  391.           "key": 40000,
  392.           "doc_count": 0
  393.         },
  394.         {
  395.           "key": 45000,
  396.           "doc_count": 0
  397.         },
  398.         {
  399.           "key": 50000,
  400.           "doc_count": 0
  401.         },
  402.         {
  403.           "key": 55000,
  404.           "doc_count": 0
  405.         },
  406.         {
  407.           "key": 60000,
  408.           "doc_count": 0
  409.         },
  410.         {
  411.           "key": 65000,
  412.           "doc_count": 0
  413.         },
  414.         {
  415.           "key": 70000,
  416.           "doc_count": 0
  417.         },
  418.         {
  419.           "key": 75000,
  420.           "doc_count": 0
  421.         },
  422.         {
  423.           "key": 80000,
  424.           "doc_count": 1
  425.         }
  426.       ]
  427.     }
  428.   }
  429. ...
  430. ---6 -> 条形图 histogram interval min_doc_count
  431. 最少有一条记录
  432. GET /cars/_search
  433. {
  434.   "size":0,
  435.   "aggs":{
  436.     "a_price":{
  437.       "histogram": {
  438.         "field": "price",
  439.         "interval": 5000,
  440.         "min_doc_count": 1
  441.       }
  442.     }
  443.   }
  444. }
  446. 聚合结果
  447. ...
  448.   "aggregations": {
  449.     "a_price": {
  450.       "buckets": [
  451.         {
  452.           "key": 10000,
  453.           "doc_count": 2
  454.         },
  455.         {
  456.           "key": 15000,
  457.           "doc_count": 1
  458.         },
  459.         {
  460.           "key": 20000,
  461.           "doc_count": 2
  462.         },
  463.         {
  464.           "key": 25000,
  465.           "doc_count": 1
  466.         },
  467.         {
  468.           "key": 30000,
  469.           "doc_count": 1
  470.         },
  471.         {
  472.           "key": 80000,
  473.           "doc_count": 1
  474.         }
  475.       ]
  476.     }
  477.   }
  478. ...
  480. ---7 -> 按时间统计 date_histogram interval format min_doc_count
  481. 按月分割 至少匹配一条
  482. GET /cars/transactions/_search
  483. {
  484.    "size" : 0,
  485.    "aggs": {
  486.       "sales": {
  487.          "date_histogram": {
  488.             "field": "sold",
  489.             "interval": "month",
  490.             "format": "yyyy-MM-dd",
  491.             "min_doc_count": 1
  492.          }
  493.       }
  494.    }
  495. }
  496. 聚合结果
  497. ...
  498.   "aggregations": {
  499.     "sales": {
  500.       "buckets": [
  501.         {
  502.           "key_as_string": "2014-01-01",
  503.           "key": 1388534400000,
  504.           "doc_count": 1
  505.         },
  506.         {
  507.           "key_as_string": "2014-02-01",
  508.           "key": 1391212800000,
  509.           "doc_count": 1
  510.         },
  511.         {
  512.           "key_as_string": "2014-05-01",
  513.           "key": 1398902400000,
  514.           "doc_count": 1
  515.         },
  516.         {
  517.           "key_as_string": "2014-07-01",
  518.           "key": 1404172800000,
  519.           "doc_count": 1
  520.         },
  521.         {
  522.           "key_as_string": "2014-08-01",
  523.           "key": 1406851200000,
  524.           "doc_count": 1
  525.         },
  526.         {
  527.           "key_as_string": "2014-10-01",
  528.           "key": 1412121600000,
  529.           "doc_count": 1
  530.         },
  531.         {
  532.           "key_as_string": "2014-11-01",
  533.           "key": 1414800000000,
  534.           "doc_count": 2
  535.         }
  536.       ]
  537.     }
  538.   }
  539. ...
  540. ---8 -> 返回空桶 date_histogram interval format min_doc_count extended_bounds min max
  541. 按月分割查询整年的数据 查询一共12条 用于做统计图之类的
  542. 如果数据只到11月 则不会显示12月,就需要加extended_bounds用来限制整年
  543. GET /cars/transactions/_search
  544. {
  545.    "size" : 0,
  546.    "aggs": {
  547.       "sales": {
  548.          "date_histogram": {
  549.             "field": "sold",
  550.             "interval": "month",
  551.             "format": "yyyy-MM-dd",
  552.             "min_doc_count" : 0,
  553.             "extended_bounds" : {
  554.                 "min" : "2014-01-01",
  555.                 "max" : "2014-12-31"
  556.             }
  557.          }
  558.       }
  559.    }
  560. }
  561. 聚合结果
  562. ...
  563.   "aggregations": {
  564.     "sales": {
  565.       "buckets": [
  566.         {
  567.           "key_as_string": "2014-01-01",
  568.           "key": 1388534400000,
  569.           "doc_count": 1
  570.         },
  571.         {
  572.           "key_as_string": "2014-02-01",
  573.           "key": 1391212800000,
  574.           "doc_count": 1
  575.         },
  576.         {
  577.           "key_as_string": "2014-03-01",
  578.           "key": 1393632000000,
  579.           "doc_count": 0
  580.         },
  581.         {
  582.           "key_as_string": "2014-04-01",
  583.           "key": 1396310400000,
  584.           "doc_count": 0
  585.         },
  586.         {
  587.           "key_as_string": "2014-05-01",
  588.           "key": 1398902400000,
  589.           "doc_count": 1
  590.         },
  591.         {
  592.           "key_as_string": "2014-06-01",
  593.           "key": 1401580800000,
  594.           "doc_count": 0
  595.         },
  596.         {
  597.           "key_as_string": "2014-07-01",
  598.           "key": 1404172800000,
  599.           "doc_count": 1
  600.         },
  601.         {
  602.           "key_as_string": "2014-08-01",
  603.           "key": 1406851200000,
  604.           "doc_count": 1
  605.         },
  606.         {
  607.           "key_as_string": "2014-09-01",
  608.           "key": 1409529600000,
  609.           "doc_count": 0
  610.         },
  611.         {
  612.           "key_as_string": "2014-10-01",
  613.           "key": 1412121600000,
  614.           "doc_count": 1
  615.         },
  616.         {
  617.           "key_as_string": "2014-11-01",
  618.           "key": 1414800000000,
  619.           "doc_count": 2
  620.         },
  621.         {
  622.           "key_as_string": "2014-12-01",
  623.           "key": 1417392000000,
  624.           "doc_count": 0
  625.         }
  626.       ]
  627.     }
  628.   }
  629. ...
  630. ---9 -> 时间统计 扩展案例 date_histogram interval format min_doc_count extended_bounds min max terms sum
  631. 按照季度进行划分全年 分为4个季度
  632. 每个季度卖了多少钱
  633. 每个季度每种车卖了多少辆 每种车卖多少钱
  634. GET /cars/transactions/_search
  635. {
  636.    "size" : 0,
  637.    "aggs": {
  638.       "sales": {
  639.          "date_histogram": {
  640.             "field": "sold",
  641.             "interval": "quarter",
  642.             "format": "yyyy-MM-dd",
  643.             "min_doc_count" : 0,
  644.             "extended_bounds" : {
  645.                 "min" : "2014-01-01",
  646.                 "max" : "2014-12-31"
  647.             }
  648.          },
  649.          "aggs": {
  650.             "per_make_sum": {
  651.                "terms": {"field": "make"},
  652.                "aggs": {
  653.                   "sum_price": {"sum": { "field": "price" }}
  654.                }
  655.             },
  656.             "total_sum": {"sum": { "field": "price" }}
  657.          }
  658.       }
  659.    }
  660. }
  662. 聚合结果
  663. 第一季度[2014-01-01,2014-04-01) 共卖了2辆车 卖了105000
  664. 其中1辆bmw宝马 80000 1辆ford福特 25000
  665. ...
  666.   "aggregations": {
  667.     "sales": {
  668.       "buckets": [
  669.         {
  670.           "key_as_string": "2014-01-01",
  671.           "key": 1388534400000,
  672.           "doc_count": 2,
  673.           "per_make_sum": {
  674.             "doc_count_error_upper_bound": 0,
  675.             "sum_other_doc_count": 0,
  676.             "buckets": [
  677.               {
  678.                 "key": "bmw",
  679.                 "doc_count": 1,
  680.                 "sum_price": {
  681.                   "value": 80000
  682.                 }
  683.               },
  684.               {
  685.                 "key": "ford",
  686.                 "doc_count": 1,
  687.                 "sum_price": {
  688.                   "value": 25000
  689.                 }
  690.               }
  691.             ]
  692.           },
  693.           "total_sum": {
  694.             "value": 105000
  695.           }
  696.         },
  697.         {
  698.           "key_as_string": "2014-04-01",
  699. 		  ...
  700.         },
  701.         {
  702.           "key_as_string": "2014-07-01",
  703.           ...
  704.         },
  705.         {
  706.           "key_as_string": "2014-10-01",
  707.           ...
  708.         }
  709.       ]
  710.     }
  711.   }
  712. ...
  713. ---10 -> stats 包括 count min max avg sum
  714. GET cars/_search
  715. {
  716.   "size": 0,
  717.   "aggs": {
  718.     "price": {
  719.       "stats": {"field": "price"}
  720.     }
  721.   }
  722. }
  723. 聚合结果
  724. ...
  725.   "aggregations": {
  726.     "price": {
  727.       "count": 8,
  728.       "min": 10000,
  729.       "max": 80000,
  730.       "avg": 26500,
  731.       "sum": 212000
  732.     }
  733.   }
  734. ...

8 聚合

  1. 	GET /cars/transactions/_search
  2. 	{
  3. 		"size" : 0,
  4. 		"aggs" : {
  5. 			"colors" : {
  6. 				"terms" : {"field" : "color"}
  7. 			}
  8. 		}
  9. 	}
  10. 上等价于下
  11. 	GET /cars/transactions/_search
  12. 	{
  13. 		"size" : 0,
  14. 		"query" : {
  15. 			"match_all" : {}
  16. 		},
  17. 		"aggs" : {
  18. 			"colors" : {
  19. 				"terms" : {"field" : "color"}
  20. 			}
  21. 		}
  22. 	}
  24. ---1 -> 范围限定的聚合 query match aggs avg
  25. 对查询的结果进行聚合
  26. GET cars/_search
  27. {
  28.   "size": 0,
  29.   "query": {
  30.     "match": {"make": "ford"}
  31.   },
  32.   "aggs": {
  33.     "avg_1": {
  34.       "avg": {"field": "price"}
  35.     }
  36.   }
  37. }
  38. 聚合结果
  39. ...
  40.   "aggregations": {
  41.     "avg_1": {
  42.       "value": 27500//对查询到的结果进行求平均值
  43.     }
  44.   }
  45. ...
  46. ---2 -> 范围限定的聚合 query match aggs avg global aggs avg
  47. 对查询的结果进行聚合 并对全部数据也进行聚合
  48. GET cars/_search
  49. {
  50.   "size": 0,
  51.   "query": {
  52.     "match": {"make": "ford"}
  53.   },
  54.   "aggs": {
  55.     "avg_1": {//对查询的结果进行聚合
  56.       "avg": {"field": "price"}
  57.     },
  58.     "all":{//聚合桶名称
  59.       "global": {},
  60.        "aggs": {
  61.         "avg_2": {//对全部数据求平均值的桶
  62.           "avg": {"field": "price"}
  63.         }
  64.       }
  65.     }
  66.   }
  67. }
  68. 聚合结果
  69. ...
  70.   "aggregations": {
  71.     "all": {
  72.       "doc_count": 8,
  73.       "avg_2": {
  74.         "value": 26500
  75.       }
  76.     },
  77.     "avg_1": {
  78.       "value": 27500
  79.     }
  80.   }
  81. ...
  82. ---3 -> 过滤 query constant_score filter range aggs avg
  83. 使用"constant_score"的"filter"进行过滤,再对过滤的结果进行聚合
  84. GET /cars/transactions/_search
  85. {
  86.     "size" : 0,
  87.     "query" : {
  88.         "constant_score": {
  89.             "filter": {
  90.                 "range": {
  91.                     "price": {"gte": 30000}
  92.                 }
  93.             }
  94.         }
  95.     },
  96.     "aggs" : {
  97.         "single_avg_price": {
  98.             "avg" : { "field" : "price" }
  99.         }
  100.     }
  101. }
  102. 聚合结果
  103. ...
  104.   "aggregations": {
  105.     "single_avg_price": {
  106.       "value": 55000
  107.     }
  108.   }
  109. ...
  110. ---4 -> 过滤桶 query match aggs filter range aggs avg
  111. 对查询结果进行过滤(现在时间的前一个月)再进行计算平均值
  112. GET /cars/transactions/_search
  113. {
  114.    "size" : 0,
  115.    "query":{
  116.       "match": {"make": "ford"}
  117.    },
  118.    "aggs":{
  119.       "recent_sales": {
  120.          "filter": {
  121.             "range": {"sold": {"from": "now-1M"}}
  122.          },
  123.          "aggs": {
  124.             "average_price":{"avg": {"field": "price"}}
  125.          }
  126.       }
  127.    }
  128. }
  129. 聚合结果
  130. ...
  131.   "aggregations": {
  132.     "recent_sales": {
  133.       "meta": {},
  134.       "doc_count": 0,
  135.       "average_price": {
  136.         "value": null
  137.       }
  138.     }
  139.   }
  140. ...
  141. ---5 -> 后过滤器 query match post_filter term aggs terms
  142. "post_filter"只影响搜索结果"hits",不影响聚合结果"aggregations"
  143. GET /cars/transactions/_search
  144. {
  145.     "size" : 0,
  146.     "query": {
  147.         "match": {"make": "ford"}
  148.     },
  149.     "post_filter": {
  150.         "term" : {"color" : "green"}
  151.     },
  152.     "aggs" : {
  153.         "all_colors": {
  154.             "terms" : { "field" : "color" }
  155.         }
  156.     }
  157. }
  158. 聚合结果
  159. ...
  160.   "hits": {
  161.     "total": 1,//只有一条
  162.     "max_score": 0,
  163.     "hits": []
  164.   },
  165.   "aggregations": {
  166.     "all_colors": {
  167.       "doc_count_error_upper_bound": 0,
  168.       "sum_other_doc_count": 0,
  169.       "buckets": [
  170.         {
  171.           "key": "blue",
  172.           "doc_count": 1
  173.         },
  174.         {
  175.           "key": "green",
  176.           "doc_count": 1
  177.         }
  178.       ]
  179.     }
  180.   }
  181. ...
  182. ---6 -> 内置排序 aggs terms order _count _term
  183. 桶默认按照"doc_count"降序
  184. 我们可以使用内置"order"排序
  185. _count
  186. 	按"doc_count"大小排序。对 terms 、 histogram 、 date_histogram 有效。
  187. _term
  188. 	按照"key"字母顺序排序。只在 terms 内使用。
  189. _key
  190. 	按每个桶的键值数值排序（理论上与 _term 类似）。 只在 histogram 和 date_histogram 内使用。
  191. GET cars/_search
  192. {
  193.   "size": 0,
  194.   "aggs": {
  195.     "colors": {
  196.       "terms": {
  197.         "field": "color",
  198.         "order": {
  199.           "_count": "asc"
  200.         }
  201.       }
  202.     }
  203.   }
  204. }
  205. 聚合结果
  206. ...
  207.   "aggregations": {
  208.     "colors": {
  209.       "doc_count_error_upper_bound": 0,
  210.       "sum_other_doc_count": 0,
  211.       "buckets": [
  212.         {
  213.           "key": "blue",
  214.           "doc_count": 2
  215.         },
  216.         {
  217.           "key": "green",
  218.           "doc_count": 2
  219.         },
  220.         {
  221.           "key": "red",
  222.           "doc_count": 4
  223.         }
  224.       ]
  225.     }
  226.   }
  227. ...
  228. ---7 -> 按度量排序 aggs terms order aggs avg
  229. 按照计算的平均价格的桶名称进行平均价格升序
  230. GET /cars/transactions/_search
  231. {
  232.     "size" : 0,
  233.     "aggs" : {
  234.         "makes" : {
  235.             "terms" : {
  236.               "field" : "make",
  237.               "order": {"avg_price" : "asc" }
  238.             },
  239.             "aggs": {
  240.                 "avg_price": {"avg": {"field": "price"}}
  241.             }
  242.         }
  243.     }
  244. }
  245. 聚合结果
  246. ...
  247.   "aggregations": {
  248.     "makes": {
  249.       "doc_count_error_upper_bound": 0,
  250.       "sum_other_doc_count": 0,
  251.       "buckets": [
  252.         {
  253.           "key": "toyota",
  254.           "doc_count": 2,
  255.           "avg_price": {
  256.             "value": 13500
  257.           }
  258.         },
  259.         {
  260.           "key": "honda",
  261.           "doc_count": 3,
  262.           "avg_price": {
  263.             "value": 16666.666666666668
  264.           }
  265.         },
  266.         {
  267.           "key": "ford",
  268.           "doc_count": 2,
  269.           "avg_price": {
  270.             "value": 27500
  271.           }
  272.         },
  273.         {
  274.           "key": "bmw",
  275.           "doc_count": 1,
  276.           "avg_price": {
  277.             "value": 80000
  278.           }
  279.         }
  280.       ]
  281.     }
  282.   }
  283. ...
  284. ---8 -> 按度量排序 aggs terms order aggs extended_stats
  285. 按照扩展统计的方差进行升序
  286. GET /cars/transactions/_search
  287. {
  288.     "size" : 0,
  289.     "aggs" : {
  290.         "colors" : {
  291.             "terms" : {
  292.               "field" : "color",
  293.               "order": {"stats.variance" : "asc" }
  294.             },
  295.             "aggs": {
  296.                 "stats": {"extended_stats": {"field": "price"}}
  297.             }
  298.         }
  299.     }
  300. }
  301. 聚合结果
  302. ...
  303.   "aggregations": {
  304.     "colors": {
  305.       "doc_count_error_upper_bound": 0,
  306.       "sum_other_doc_count": 0,
  307.       "buckets": [
  308.         {
  309.           "key": "blue",
  310.           "doc_count": 2,
  311.           "stats": {
  312.             "count": 2,
  313.             "min": 15000,
  314.             "max": 25000,
  315.             "avg": 20000,
  316.             "sum": 40000,
  317.             "sum_of_squares": 850000000,
  318.             "variance": 25000000,
  319.             "std_deviation": 5000,
  320.             "std_deviation_bounds": {
  321.               "upper": 30000,
  322.               "lower": 10000
  323.             }
  324.           }
  325.         },
  326.         {
  327.           "key": "green",
  328.           ...
  329.         },
  330.         {
  331.           "key": "red",
  332.           ...
  333.         }
  334.       ]
  335.     }
  336.   }
  337. ...
  338. ---9 -> 基于"深度"度量排序 aggs histogram interval order aggs filter terms aggs extended_stats
  339. a2>a3.variance 表示"a2"中的"a3"的"variance"属性
  340. 按照价格两万一次分割,过滤了只取"red","green"一共6个文档,并且根据分割块进行价格计算扩展统计,
  341. 根据分割每一块的扩展统计的方差来升序排列,并且排除分割内至少数量为1
  342. 这里"a1"//单值桶 "a2"//多值桶 "a3"//度量指标
  343. GET cars/_search
  344. {
  345.   "size": 0,
  346.   "aggs": {
  347.     "a1": {
  348.       "histogram": {
  349.         "field": "price",
  350.         "interval": 20000,
  351.         "min_doc_count": 1,
  352.         "order": {"a2>a3.variance": "asc"}
  353.       },
  354.     "aggs": {
  355.       "a2": {
  356.         "filter": {
  357.           "terms": {"color": ["red","green"]}
  358.         },
  359.       "aggs": {
  360.         "a3": {
  361.           "extended_stats": {"field": "price"}
  362.         }
  363.       }
  364.       }
  365.     }
  366.     }
  367.   }
  368. }
  369. 聚合结果
  370. ...
  371.   "aggregations": {
  372.     "a1": {//多值桶
  373.       "buckets": [
  374.         {
  375.           "key": 80000,//[80000,100000)有1条
  376.           "doc_count": 1,
  377.           "a2": {//单值桶
  378.             "doc_count": 1,//[80000,100000) 并且属于["red","green"]有1条
  379.             "a3": {
  380.               "count": 1,
  381.               "min": 80000,
  382.               "max": 80000,
  383.               "avg": 80000,
  384.               "sum": 80000,
  385.               "sum_of_squares": 6400000000,
  386.               "variance": 0,//属于["red","green"]1条的方差
  387.               "std_deviation": 0,
  388.               "std_deviation_bounds": {
  389.                 "upper": 80000,
  390.                 "lower": 80000
  391.               }
  392.             }
  393.           }
  394.         },
  395.         {
  396.           "key": 0,//[0,20000)有3条
  397.           "doc_count": 3,
  398.           "a2": {
  399.             "doc_count": 2,//[0,20000) 并且属于["red","green"]有2条
  400.             "a3": {
  401.              ...
  402.               "variance": 1000000,//属于["red","green"]2条的方差
  403.              ...
  404.             }
  405.           }
  406.         },
  407.         {
  408.           "key": 20000,//[20000,40000)有4条
  409.           "doc_count": 4,
  410.           "a2": {
  411.             "doc_count": 3,//[20000,40000) 并且属于["red","green"]有3条
  412.             "a3": {
  413.              ...
  414.               "variance": 22222222.22222225,//属于["red","green"]3条的方差
  415.              ...
  416.             }
  417.           }
  418.         }
  419.       ]
  420.     }
  421.   }
  422. ...
  423. ---10 -> 统计去重后的数量 aggs cardinality
  424. GET /cars/transactions/_search
  425. {
  426.     "size" : 0,
  427.     "aggs" : {
  428.         "distinct_colors" : {
  429.             "cardinality" : {"field" : "color"}
  430.         }
  431.     }
  432. }
  433. 聚合结果
  434. ...
  435.   "aggregations": {
  436.     "distinct_colors": {
  437.       "value": 3
  438.     }
  439.   }
  440. ...
  441. ---11 -> 统计去重后的数量 aggs date_histogram interval min_doc_count aggs cardinality
  442. 按日期每个月分割一次,至少一条才显示,每个月根据颜色都去重
  443. GET /cars/transactions/_search
  444. {
  445.   "size" : 0,
  446.   "aggs" : {
  447.       "months" : {
  448.         "date_histogram": {
  449.           "field": "sold",
  450.           "interval": "month",
  451.           "min_doc_count": 1
  452.         },
  453.         "aggs": {
  454.           "distinct_colors" : {
  455.               "cardinality" : {"field" : "color"}
  456.           }
  457.         }
  458.       }
  459.   }
  460. }
  461. 聚合结果
  462. ...
  463.   "aggregations": {
  464.     "months": {
  465.       "buckets": [
  466.         ...
  467.         {
  468.           "key_as_string": "2014-08-01T00:00:00.000Z",
  469.           "key": 1406851200000,
  470.           "doc_count": 1,
  471.           "distinct_colors": {
  472.             "value": 1
  473.           }
  474.         },
  475.         {
  476.           "key_as_string": "2014-10-01T00:00:00.000Z",
  477.           "key": 1412121600000,
  478.           "doc_count": 1,
  479.           "distinct_colors": {
  480.             "value": 1
  481.           }
  482.         },
  483.         {
  484.           "key_as_string": "2014-11-01T00:00:00.000Z",
  485.           "key": 1414800000000,
  486.           "doc_count": 2,
  487.           "distinct_colors": {
  488.             "value": 1
  489.           }
  490.         }
  491.       ]
  492.     }
  493.   }
  494. ...
  495. ---12 -> 统计去重后的数量 aggs cardinality precision_threshold
  496. GET /cars/transactions/_search
  497. {
  498.     "size" : 0,
  499.     "aggs" : {
  500.         "distinct_colors" : {
  501.             "cardinality" : {
  502.               "field" : "color",
  503.               "precision_threshold" : 100 //指定精度,范围[0,40000]超过四万也会为四万
  504.             }
  505.         }
  506.     }
  507. }
  508. 聚合结果
  509. ...
  510.   "aggregations": {
  511.     "distinct_colors": {
  512.       "value": 3
  513.     }
  514.   }
  515. ...

Elasticsearch没看文档之前,整理的一些知识的更多相关文章

  1. 用Word收集网页中的内容，用文档结构图整理

    如何用Word保存网页中的内容 网页中的内容,用什么保存好? 用笔记类软件是个不错的选择,还可以用 Word 保存,这样方便用“文档结构图”来整理网页. 如图:网页收集后用文档结构图进行整理. (图一 ...

  2. 看文档要看仔细，英语要加强啊... cocos2d-x 的 API 和 对应版本的 cocos2d-js 的 API 没有完全对应

    /** * Sets the X rotation (angle) of the node in degrees which performs a horizontal rotational skew ...

  3. Jeecg社区wiki在开放，最终能够在线看文档啦！！！

    Jeecg社区wiki在开放,最终能够在线看文档啦! .! 2014-12-18 scott JEECG jeecg开源社区wiki正式启动了.方便大家看文档 訪问地址是: http://osbaba ...

  4. python模块之httplib(在py3中功能进一步强大，请详看文档)

    # -*- coding: utf-8 -*-#python 27#xiaodeng#python模块之httplib(在py3中功能进一步强大,请详看文档) import httplib#是较为底层 ...

  5. Elasticsearch 7.x文档基本操作（CRUD）

    官方文档:https://www.elastic.co/guide/en/elasticsearch/reference/current/docs.html 1.添加文档 1.1.指定文档ID PUT ...

  6. elasticsearch 基础 —— 分布式文档存储原理

    路由一个文档到一个分片中 当索引一个文档的时候,文档会被存储到一个主分片中. Elasticsearch 如何知道一个文档应该存放到哪个分片中呢?当我们创建文档时,它如何决定这个文档应当被存储在分片  ...

  7. elasticsearch 官方监控文档 老版但很有用

    https://zhaoyanblog.com/page/1?s=elasticsearch 监控每个节点(jvm部分) 操作系统和进程部分 操作系统和进程部分的含义是很清楚的,这里不会描述的很详细. ...

  8. 关于Elasticsearch单个索引文档最大数量问题

    因为ElasticSearch是一个基于Lucene的搜索服务器.Lucene的索引有个难以克服的限制,导致Elasticsearch的单个分片存在最大文档数量限制,一个索引分片的最大文档数量是20亿 ...

  9. Niagara帮助文档资料整理

    1.任何软件额发布都会有说明文档,有的不会附具体实践的操作步骤,存在不懂得问题一般可以通过查看榜文文档解决问题 一些软件的帮助文档是一PDF格式存储在软件安装的目录下面,如Niagar workben ...

随机推荐

  1. js闭包解决多个点击事件

    <script> var severalObj=window.document.getElementsByName("button"); for(var i=0;i&l ...

  2. Leaflet - 自定义弹出框（popup）

    有两种方法,一种直接改 CSS,一种是通过继承拓展 popup. 方法一:改 CSS 下面是一个将原有样式清空的设置(可能清的不全,只是提供个思路) .l-popup { &--no-styl ...

  3. 【React自制全家桶】八、React动画以及react-transition-group动画库的使用

    React动画通常有三种方法实现从易到难为: 1.transition(CSS3自带) 2.animation(CSS3自带) 3.react-transition-group动画库(需要引入插件) ...

  4. SQL SERVER 数据库安装完毕之后如何修改数据库实例排序规则

    背景 最近我们在azure portal 上开了几台英文版的数据库服务器,因默认是开启就安装好对应的数据库,所以存在一个实例排序规则的问题,需把整个实例都调整成Chinese_PRC_CI_AS,避免 ...

  5. 提交SVN Working copy locked解决

    今天一大早提交SVN的时候,出现这个错误: 百度了一下原因:因为我强制在commit的时候退出了,导致svn项目文件被锁了,不能commit,不能update了 赶紧百度了一下解决办法: http:/ ...

  6. python网络编程(Socket、TCP、UDP)

    Socket 是网络编程的一个抽象概念,通常我们用一个Socket表示 "打开了一个网络链接",而打开一个Socket 需要知道目标计算机的IP 地址和端口号,再指定协议类型即可. ...

  7. WDM-波分复用

    波分复用WDM(Wavelength Division Multiplexing)是将两种或多种不同波长的光载波信号(携带各种信息)在发送端经复用器(亦称合波器,Multiplexer)汇合在一起,并 ...

  8. 使用torchvision下载数据集显示没有模板

    配置: Anaconda+Windows+py3.7 一:首先先卸载开始的torchvision:pip uninstall torchvision 二:找到官网:https://pypi.org/p ...

  9. AttributeError: module 'html.parser' has no attribute 'HTMLParseError'

    别人说这种错误大多是,因为beautifulsoup的版本兼容问题, 因为beautifulsoup的4.0以下版本和4.0版本与python3.5以上都不兼容, 网上的解决方案大多是:降python ...

  10. 【Python基础】lpthw - Exercise 46 项目骨架

    本节将会介绍如何构建一个项目骨架目录.骨架目录中会包含项目文件布局.自动测试代码.模块及安装脚本. 一.环境配置(win10) 1. 检查并确认自己只安装了一个python版本. cd ~ pytho ...