使用python生成大量数据写入es数据库并查询操作（聚合）

已于 2022-09-11 12:30:21 修改
阅读量2.9k 收藏 8
点赞数 2
分类专栏： ElasticSearch 文章标签： elasticsearch 聚类
于 2022-09-11 00:14:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44799217/article/details/126794236
版权

模拟学生成绩信息写入es数据库，包括姓名、性别、科目、成绩。

示例代码1：  【一次性写入10000*1000条数据】  【本人亲测耗时5100秒】

from elasticsearch import Elasticsearch
from elasticsearch import helpers
import random
import time

es = Elasticsearch(hosts='http://127.0.0.1:9200')
# print(es)

names = ['刘一', '陈二', '张三', '李四', '王五', '赵六', '孙七', '周八', '吴九', '郑十']
sexs = ['男', '女']
subjects = ['语文', '数学', '英语', '生物', '地理']
grades = [85, 77, 96, 74, 85, 69, 84, 59, 67, 69, 86, 96, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86]
datas = []

start = time.time()
# 开始批量写入es数据库
# 批量写入数据
for j in range(1000):
    print(j)
    action = [
        {
            "_index": "grade",
            "_type": "doc",
            "_id": i,
            "_source": {
                "id": i,
                "name": random.choice(names),
                "sex": random.choice(sexs),
                "subject": random.choice(subjects),
                "grade": random.choice(grades)
            }
        } for i in range(10000 * j, 10000 * j + 10000)
    ]
    helpers.bulk(es, action)
end = time.time()
print('花费时间：', end - start)

elasticsearch-head中显示：

示例代码2：    【一次性写入10000*5000条数据】  【本人亲测耗时23000秒】

from elasticsearch import Elasticsearch
from elasticsearch import helpers
import random
import time

es = Elasticsearch(hosts='http://127.0.0.1:9200')
# print(es)

names = ['刘一', '陈二', '张三', '李四', '王五', '赵六', '孙七', '周八', '吴九', '郑十']
sexs = ['男', '女']
subjects = ['语文', '数学', '英语', '生物', '地理']
grades = [85, 77, 96, 74, 85, 69, 84, 59, 67, 69, 86, 96, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86]
datas = []

start = time.time()
# 开始批量写入es数据库
# 批量写入数据
for j in range(5000):
    print(j)
    action = [
        {
            "_index": "grade3",
            "_type": "doc",
            "_id": i,
            "_source": {
                "id": i,
                "name": random.choice(names),
                "sex": random.choice(sexs),
                "subject": random.choice(subjects),
                "grade": random.choice(grades)
            }
        } for i in range(10000 * j, 10000 * j + 10000)
    ]
    helpers.bulk(es, action)
end = time.time()
print('花费时间：', end - start)

 示例代码3：  【一次性写入10000*9205条数据】  【耗时过长】

from elasticsearch import Elasticsearch
from elasticsearch import helpers
import random
import time

es = Elasticsearch(hosts='http://127.0.0.1:9200')

names = ['刘一', '陈二', '张三', '李四', '王五', '赵六', '孙七', '周八', '吴九', '郑十']
sexs = ['男', '女']
subjects = ['语文', '数学', '英语', '生物', '地理']
grades = [85, 77, 96, 74, 85, 69, 84, 59, 67, 69, 86, 96, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86]
datas = []

start = time.time()
# 开始批量写入es数据库
# 批量写入数据
for j in range(9205):
    print(j)
    action = [
        {
            "_index": "grade2",
            "_type": "doc",
            "_id": i,
            "_source": {
                "id": i,
                "name": random.choice(names),
                "sex": random.choice(sexs),
                "subject": random.choice(subjects),
                "grade": random.choice(grades)
            }
        } for i in range(10000*j, 10000*j+10000)
    ]
    helpers.bulk(es, action)
end = time.time()
print('花费时间：', end - start)

查询数据并计算各种方式的成绩总分。

示例代码4：   【一次性获取所有的数据，在程序中分别计算所耗的时间】

from elasticsearch import Elasticsearch
import time


def search_data(es, size=10):
    query = {
        "query": {
            "match_all": {}
        }
    }
    res = es.search(index='grade', body=query, size=size)
    # print(res)
    return res


if __name__ == '__main__':
    start = time.time()
    es = Elasticsearch(hosts='http://192.168.1.1:9200')
    # print(es)
    size = 10000
    res = search_data(es, size)
    # print(type(res))
    # total = res['hits']['total']['value']
    # print(total)
    all_source = []
    for i in range(size):
        source = res['hits']['hits'][i]['_source']
        all_source.append(source)
        # print(source)

    # 统计查询出来的所有学生的所有课程的所有成绩的总成绩
    start1 = time.time()
    all_grade = 0
    for data in all_source:
        all_grade += int(data['grade'])
    print('所有学生总成绩之和：', all_grade)
    end1 = time.time()
    print("耗时：", end1 - start1)

    # 统计查询出来的每个学生的所有课程的所有成绩的总成绩
    start2 = time.time()
    names1 = []
    all_name_grade = {}
    for data in all_source:
        if data['name'] in names1:
            all_name_grade[data['name']] += data['grade']
        else:
            names1.append(data['name'])
            all_name_grade[data['name']] = data['grade']
    print(all_name_grade)
    end2 = time.time()
    print("耗时：", end2 - start2)

    # 统计查询出来的每个学生的每门课程的所有成绩的总成绩
    start3 = time.time()
    names2 = []
    subjects = []
    all_name_all_subject_grade = {}
    for data in all_source:
        if data['name'] in names2:
            if all_name_all_subject_grade[data['name']].get(data['subject']):
                all_name_all_subject_grade[data['name']][data['subject']] += data['grade']
            else:
                all_name_all_subject_grade[data['name']][data['subject']] = data['grade']
        else:
            names2.append(data['name'])
            all_name_all_subject_grade[data['name']] = {}
            all_name_all_subject_grade[data['name']][data['subject']] = data['grade']
    print(all_name_all_subject_grade)
    end3 = time.time()
    print("耗时：", end3 - start3)
    end = time.time()
    print('总耗时：', end - start)

运行结果：

在示例代码4中当把size由10000改为 2000000时，运行效果如下所示：

        在项目中一般不用上述代码4中所统计成绩的方法，面对大量的数据是比较耗时的，要使用es中的聚合查询。计算数据中所有成绩之和。

示例代码5：  【使用普通计算方法和聚类方法做对比验证】

from elasticsearch import Elasticsearch
import time


def search_data(es, size=10):
    query = {
        "query": {
            "match_all": {}
        }
    }
    res = es.search(index='grade', body=query, size=size)
    # print(res)
    return res


def search_data2(es, size=10):
    query = {
        "aggs": {
            "all_grade": {
                "terms": {
                    "field": "grade",
                    "size": 1000
                }
            }
        }
    }
    res = es.search(index='grade', body=query, size=size)
    # print(res)
    return res


if __name__ == '__main__':
    start = time.time()
    es = Elasticsearch(hosts='http://127.0.0.1:9200')
    size = 2000000
    res = search_data(es, size)
    all_source = []
    for i in range(size):
        source = res['hits']['hits'][i]['_source']
        all_source.append(source)
        # print(source)

    # 统计查询出来的所有学生的所有课程的所有成绩的总成绩
    start1 = time.time()
    all_grade = 0
    for data in all_source:
        all_grade += int(data['grade'])
    print('200万数据所有学生总成绩之和：', all_grade)
    end1 = time.time()
    print("耗时：", end1 - start1)

    end = time.time()
    print('200万数据总耗时：', end - start)

    # 聚合操作
    start_aggs = time.time()
    es = Elasticsearch(hosts='http://127.0.0.1:9200')
    # size = 2000000
    size = 0
    res = search_data2(es, size)
    # print(res)

    aggs = res['aggregations']['all_grade']['buckets']
    print(aggs)

    sum = 0
    for agg in aggs:
        sum += (agg['key'] * agg['doc_count'])

    print('1000万数据总成绩之和:', sum)
    end_aggs = time.time()
    print('1000万数据总耗时：', end_aggs - start_aggs)

运行结果：

计算数据中每个同学的各科总成绩之和。 

示例代码6：  【子聚合】【先分组，再计算】

from elasticsearch import Elasticsearch
import time


def search_data(es, size=10):
    query = {
        "query": {
            "match_all": {}
        }
    }
    res = es.search(index='grade', body=query, size=size)
    # print(res)
    return res


def search_data2(es):
    query = {
        "size": 0,
        "aggs": {
            "all_names": {
                "terms": {
                    "field": "name.keyword",
                    "size": 10
                },
                "aggs": {
                    "total_grade": {
                        "sum": {
                            "field": "grade"
                        }
                    }
                }
            }
        }
    }
    res = es.search(index='grade', body=query)
    # print(res)
    return res


if __name__ == '__main__':
    start = time.time()
    es = Elasticsearch(hosts='http://127.0.0.1:9200')
    size = 2000000
    res = search_data(es, size)
    all_source = []
    for i in range(size):
        source = res['hits']['hits'][i]['_source']
        all_source.append(source)
        # print(source)

    # 统计查询出来的每个学生的所有课程的所有成绩的总成绩
    start2 = time.time()
    names1 = []
    all_name_grade = {}
    for data in all_source:
        if data['name'] in names1:
            all_name_grade[data['name']] += data['grade']
        else:
            names1.append(data['name'])
            all_name_grade[data['name']] = data['grade']
    print(all_name_grade)
    end2 = time.time()
    print("200万数据耗时：", end2 - start2)

    end = time.time()
    print('200万数据总耗时：', end - start)

    # 聚合操作
    start_aggs = time.time()
    es = Elasticsearch(hosts='http://127.0.0.1:9200')
    res = search_data2(es)
    # print(res)

    aggs = res['aggregations']['all_names']['buckets']
    # print(aggs)
    dic = {}
    for agg in aggs:
        dic[agg['key']] = agg['total_grade']['value']

    print('1000万数据:', dic)
    end_aggs = time.time()
    print('1000万数据总耗时：', end_aggs - start_aggs)

运行结果：

计算数据中每个同学的每科成绩之和。 

示例代码7：

from elasticsearch import Elasticsearch
import time


def search_data(es, size=10):
    query = {
        "query": {
            "match_all": {}
        }
    }
    res = es.search(index='grade', body=query, size=size)
    # print(res)
    return res


def search_data2(es):
    query = {
        "size": 0,
        "aggs": {
            "all_names": {
                "terms": {
                    "field": "name.keyword",
                    "size": 10
                },
                "aggs": {
                    "all_subjects": {
                        "terms": {
                            "field": "subject.keyword",
                            "size": 5
                        },
                        "aggs": {
                            "total_grade": {
                                "sum": {
                                    "field": "grade"
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    res = es.search(index='grade', body=query)
    # print(res)
    return res


if __name__ == '__main__':
    start = time.time()
    es = Elasticsearch(hosts='http://127.0.0.1:9200')
    size = 2000000
    res = search_data(es, size)
    all_source = []
    for i in range(size):
        source = res['hits']['hits'][i]['_source']
        all_source.append(source)
        # print(source)

    # 统计查询出来的每个学生的每门课程的所有成绩的总成绩
    start3 = time.time()
    names2 = []
    subjects = []
    all_name_all_subject_grade = {}
    for data in all_source:
        if data['name'] in names2:
            if all_name_all_subject_grade[data['name']].get(data['subject']):
                all_name_all_subject_grade[data['name']][data['subject']] += data['grade']
            else:
                all_name_all_subject_grade[data['name']][data['subject']] = data['grade']
        else:
            names2.append(data['name'])
            all_name_all_subject_grade[data['name']] = {}
            all_name_all_subject_grade[data['name']][data['subject']] = data['grade']
    print('200万数据:', all_name_all_subject_grade)
    end3 = time.time()
    print("耗时：", end3 - start3)
    end = time.time()
    print('200万数据总耗时：', end - start)

    # 聚合操作
    start_aggs = time.time()
    es = Elasticsearch(hosts='http://127.0.0.1:9200')
    res = search_data2(es)
    # print(res)

    aggs = res['aggregations']['all_names']['buckets']
    # print(aggs)

    dic = {}
    for agg in aggs:
        dic[agg['key']] = {}
        for sub in agg['all_subjects']['buckets']:
            dic[agg['key']][sub['key']] = sub['total_grade']['value']
    print('1000万数据:', dic)
    end_aggs = time.time()
    print('1000万数据总耗时：', end_aggs - start_aggs)

运行结果：

        在上面查询计算示例代码中，当使用含有1000万数据的索引grade时，普通方法查询计算是比较耗时的，使用聚合查询能够大大节约大量时间。当面对9205万数据的索引grade2时，这时使用普通计算方法所消耗的时间太大了，在线上开发环境中是不可用的，所以必须使用聚合方法来计算。

示例代码8：

from elasticsearch import Elasticsearch
import time


def search_data(es):
    query = {
        "size": 0,
        "aggs": {
            "all_names": {
                "terms": {
                    "field": "name.keyword",
                    "size": 10
                },
                "aggs": {
                    "all_subjects": {
                        "terms": {
                            "field": "subject.keyword",
                            "size": 5
                        },
                        "aggs": {
                            "total_grade": {
                                "sum": {
                                    "field": "grade"
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    res = es.search(index='grade2', body=query)
    # print(res)
    return res


if __name__ == '__main__':
    # 聚合操作
    start_aggs = time.time()
    es = Elasticsearch(hosts='http://127.0.0.1:9200')
    res = search_data(es)
    # print(res)

    aggs = res['aggregations']['all_names']['buckets']
    # print(aggs)

    dic = {}
    for agg in aggs:
        dic[agg['key']] = {}
        for sub in agg['all_subjects']['buckets']:
            dic[agg['key']][sub['key']] = sub['total_grade']['value']
    print('9205万数据:', dic)
    end_aggs = time.time()
    print('9205万数据总耗时：', end_aggs - start_aggs)

运行结果：

注意：写查询语句时建议使用kibana去写，然后复制查询语句到代码中，kibana会提示查询语句。

IT之一小佬
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python写数据进es中
MrZhangTS的博客
12-08 896
es = Elasticsearch(['http://es地址1:9200', 'es地址2:9200', 'es地址3:9200'])index_name = "xxxx" + formatted_date # 替换成你的索引名。1、自定义inde为：xxxx，data_to_insert也可以自定义函数。addresses_Total="数据1"addresses_idle="数据1"addresses_use="数据1"subnet_name="数据1"# 要es写入的数据。
python操作es数据
a18852867035的博客
03-23 7855
不知不觉进入职场已经大半年了，有些收获，同时又感觉自己的渺小，感觉自己还需要学习很多。最近项目中需要利用Python读写es数据，试了网上的一些方法，有的方法已经过期了，有的报错，花了一段时间才成功搞定。现在将这些方法记录下来，方便自己也方便其它读者。 1）首先安装相应es的包； pip install elasticsearch 2)读取ES数据； from elasticsearch impo...
es 大批量写入提高性能的策略
花&败
08-15 9603
1、用bulk批量写入 你如果要往es里面灌入数据的话，那么根据你的业务场景来，如果你的业务场景可以支持让你将一批数据聚合起来，一次性写入es，那么就尽量采用bulk的方式，每次批量写个几百条这样子。 bulk批量写入的性能比你一条一条写入大量的document的性能要好很多。但是如果要知道一个bulk请求最佳的大小，需要对单个es node的单个shard做压测。先bulk写入100个document，然后200个，400个，以此类推，每次都将bulk size加倍一次。如果bulk写入性能开始变平
如何用python代码，操作es数据库
最新发布
斯特凡今天也很帅的博客
04-11 178
【代码】如何用python代码，操作es数据库。
python 写入es,Python 批量写入 Elasticsearch 脚本
weixin_30458701的博客
03-25 904
Elasticsearch 官方和社区提供了各种各样的客户端库，在之前的博客中，我陆陆续续提到和演示过 Perl 的，Javascript 的，Ruby 的。上周写了一版 Python 的，考虑到好像很难找到现成的示例，如何用 python 批量写数据进 Elasticsearch，今天一并贴上来。#!/usr/bin/env pypy#coding:utf-8import reimport sy...
python elasticsearch 批量写入测试
大数据挖掘SparkExpert的博客
11-06 2817
elasticsearch 是一个高效的近实时的数据库。最近要重新进行老版本的ES 数据迁移到新版本。由于以前都是采用java来进行连接的，不过这回为了方便，找了个python 连接包来进行处理。   本博客主要测试python　elasticsearch　进行批量写入的测试 步骤一：安装python的elasticsearch包 用：pip install elasticsearch ...
python向es写入大量数据_使用Python-elasticsearch-bulk批量快速向elasticsearch插入数据_李谦的博客-CSDN博客...
weixin_42302142的博客
03-02 3139
from elasticsearch import Elasticsearchfrom elasticsearch import helpersimport pymysqlimport time# 连接ESes = Elasticsearch(['127.0.0.1'],port=9200# 连接MySQLprint("Connect to mysql...")mysql_db = "test"m...
Python将json文件写入ES数据库的方法
01-01
1、安装Elasticsearch数据库 PS：在此之前需首先安装Java SE环境 下载elasticsearch-6.5.2版本，进入/elasticsearch-6.5.2/bin目录，双击执行elasticsearch.bat 打开浏览器输入http://localhost:9200 显示以下内容则...
学习python之编写简单简单连接数据库并执行查询操作
12-23
python 连接数据库操作, 方法如下: 在本机的mysql 数据库中有一个名为yao的库，其中有一个名为user的表，表中的内容如图 下面，则是python连接数据库的方法，及查找出表中的内容，代码如下： #! /usr/bin/python #...
Python爬取数据并写入MySQL数据库的实例
12-25
首先我们来爬取 .../usr/bin/env python # coding=utf-8 import requests from bs4 import BeautifulSoup import MySQLdb print('连接到mysql服务器...') db = MySQLdb.connect("localhost",
Python对ElasticSearch获取数据及操作
12-26
使用Python对ElasticSearch获取数据及操作，供大家参考，具体内容如下 Version Python ：2.7 ElasticSearch：6.3 代码： #!/usr/bin/env python # -*- coding: utf-8 -*- """ @Time : 2018/7/4 @Author : ...
python批量导入数据进Elasticsearch的实例
09-20
今天小编就为大家分享一篇python批量导入数据进Elasticsearch的实例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
elasticsearch进行批量插入的时候总是少数据
01-07
一、问题 现有a表和b表，两张mysql数据库的表，需要把两张表的数据取共同字段，合并并导入es中，其中a表共有数据1000条，b表共有数据1200条，a表和b表的主键id都是从1开始递增的，结果导入的时候显示成功导入2200条数据，而实际查询的时候却只显示b表1200条数据。 二 、分析 现在导致数据被删除的情况应该是a表和b表的主键id重复，es默认mysql中的 id 为主键 并且document 的_id 和id保持一致， 导致a表中的数据被删除掉了（替换掉了） 三、解决方案 新建一个字段保存数据库的id 主键数据， 查询的时候使用uuid作为id的数据 注意 es2.0以后就不支持修
4. python-es-8.3.3-bulk批量操作
我的博客
08-19 839
python-es-histogram
Android设计模式-6-策略模式
o118abcdef的博客
01-05 242
1.定义： 定义一系列的算法，并将每一个算法封装起来，而且使他们可以相互替换，让算法独立于使用它的客户而独立变化。 2.应用场景： 多个类只区别在表现行为不同，可以在运行时动态选择具体要执行的行为。 需要在不同情况下使用不同的策略(算法)，或者策略还可能在未来用其它方式来实现。 对客户隐藏具体策略(算法)的实现细节，彼此完全独立。 3. 优缺点 优点： 1.策略类之间可以自由切换，由于策略类都实现同一个接口，所以使它们之间可以自由切换。 2.易于扩展，增加一个新的策略只需要添加一个具体的策
python 写入es_基础篇ES基础数据操作
weixin_39641236的博客
11-30 1408
Elasticsearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。Elasticsearch是用Java语言开发的，并作为Apache许可条款下的开放源码发布，是一种流行的企业级搜索引擎。Elasticsearch用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。curl操作：会比较麻烦，先使用这种方...
es批量导入大量数据
qq_42977353的博客
08-03 1万+
问题1：通过restAPI导入数据在数据量非常小的情况下也可以使用，一次性导入100万条数据，这个可能要很长时间，想要在短时间内导入大量数据。 https://www.elastic.co/guide/cn/elasticsearch/guide/current/bulk.html#bulk 这篇文章简单介绍了批量导入数据的操作 我的改进 1、首先生成导入的数据文件，文件是json的格式，最后一定要多一行回车 {"index":{"_index":"test2","_type":"_doc"}} {"nam
使用python，批量导入数据到elasticsearch中
热门推荐
三月一号君
10-28 1万+
使用python，批量导入数据到elasticsearch中 使用python官方模块，批量将文件中的数据导入到elasticsearch中。 1、文件内容 文件以{url:content}组成且以“\t”隔开，例子如下： http://www.avsforum.com/forum/39-networking-media-servers-content-streaming/1624586-
Python3往Elasticsearch批量插入数据
Infinity的博客
08-03 6501
废话不多说，直接上代码 # -*- coding: utf-8 -*- from elasticsearch import Elasticsearch import os #指定一个文件夹 path = r'C:\Users\Administrator\Desktop\files' es = Elasticsearch() doc = [] i = 1 #获取文件夹下所有文件的绝对路径和文...
python scrapy爬虫数据并写入数据库
09-17
Python Scrapy是一种优秀的开源网络爬虫框架，可以用于从网页中爬取数据。借助其强大的功能，我们可以轻松地将爬取到的数据写入数据库。 首先，我们需要创建一个Scrapy项目并配置好爬虫。在项目中，我们可以定义Item类来表示我们需要提取的数据字段。通过编写爬虫规则，我们可以指定要爬取的网页、需要提取的数据字段以及数据的处理方式。 在编写完爬虫规则后，Scrapy会自动将爬取到的数据封装成Item对象。我们可以在爬虫的回调函数中对这些Item对象进行处理，例如将数据写入数据库。 为了将数据写入数据库，我们可以使用Python的数据库操作库，如MySQLdb或者pymysql。首先，我们需要连接到数据库，并创建一个数据库连接对象。然后，我们可以将爬取到的数据逐条插入到数据库中。 插入数据的具体步骤如下： 1. 导入数据库操作库 2. 连接到数据库 3. 创建游标对象 4. 遍历爬取到的数据 5. 构造插入语句 6. 执行插入操作 7. 提交事务 8. 关闭游标和数据库连接 通过以上步骤，我们可以将爬取到的数据成功写入数据库。 值得注意的是，在爬取大量数据时，为了提高性能和效率，我们可以使用异步IO库，如aiomysql或aiopg，来实现异步插入操作。 总而言之，Python Scrapy可以轻松实现数据的网页爬取，并通过数据库操作库将数据写入数据库。这样，我们可以方便地对爬取到的数据进行存储和管理。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值