Python多处理输出结果

给出一个要处理的数据列表和一个64核CPU（加上500 GB RAM）。 该列表应该对字符串进行排序，并将数据存储在一个包含数百万条记录的结果集中，该结果集运行正常，多处理只需几秒钟。 但我还需要以某种方式将结果存储在txt、csv输出或数据库中。到目前为止，我还没有找到一个可行的解决方案，因为在第一部分（过程）之后，insert方法要么在尝试MySQL池时出错，要么在给出txt输出时花费了非常长的时间。 到目前为止，我尝试了：简单的txt输出，打印成txt文件，使用csv、pandas和numpy libs。似乎没有什么能加快速度。任何帮助都将不胜感激！ 我现在的代码：

import os
import re
import datetime
import time
import csv

import mysql.connector as connector
from mysql.connector.pooling import MySQLConnectionPool

import mysql

import numpy as np
from tqdm import tqdm
from time import sleep
import multiprocessing as mp

import numpy

pool = MySQLConnectionPool( pool_name="sql_pool",
                            pool_size=32,
                            pool_reset_session=True,
                            host="localhost",
                            port="3306",
                            user="homestead",
                            password="secret",
                            database="homestead")

# # sql connection
db = mysql.connector.connect(
  host="localhost",
  port="3306",
  user="homestead",
  password="secret",
  database="homestead"
)

sql_cursor = db.cursor()
delete_statement = "DELETE FROM statistics"
sql_cursor.execute(delete_statement)

db.commit()

sql_statement = "INSERT INTO statistics (name, cnt) VALUES (%s, %s)"

list = []
domains = mp.Manager().list()
unique_list = mp.Manager().list()
invalid_emails = mp.Manager().list()
result = mp.Manager().list()
regex_email = '^(\w|\.|\_|\-)+[@](\w|\_|\-|\.)+[.]\w{2,3}$'

# check email validity
def check(list, email):
    if(re.search(regex_email, email)):
        domains.append(email.lower().split('@')[1])
        return True
    else:
        invalid_emails.append(email)
        return False
#end of check email validity

# execution time converter
def convertTime(seconds):
    seconds = seconds % (24 * 3600)
    hour = seconds // 3600
    seconds %= 3600
    minutes = seconds // 60
    seconds %= 60

    if(hour == 0):
        if(minutes == 0):
            return "{0} sec".format(seconds)
        else:
            return "{0}min {1}sec".format(minutes, seconds)
    else:
        return "{0}hr {1}min {2}sec".format(hour, minutes, seconds)
# execution time converter end

#process
def process(list):
    for item in tqdm(list):
        if(check(list, item)):
            item = item.lower().split('@')[1]
            if item not in unique_list:
                unique_list.append(item)
# end of process

def insert(list):
    global sql_statement

    # Add to db
    con = pool.get_connection()
    cur = con.cursor()

    print("PID %d: using connection %s" % (os.getpid(), con))
    #cur.executemany(sql_statement, sorted(map(set_result, list)))
    for item in list:

        cur.execute(sql_statement, (item, domains.count(item)))
    con.commit()
    cur.close()
    con.close()

# def insert_into_database(list):
    #sql_cursor.execute(sql_statement, (unique_list, 1), multi=True)

    # sql_cursor.executemany(sql_statement, sorted(map(set_result, list)))
    # db.commit()

# statistics
def statistics(list):
    for item in tqdm(list):
        if(domains.count(item) > 0):
            result.append([domains.count(item), item])
# end of statistics

params = sys.argv
filename = ''
process_count = -1
for i, item in enumerate(params):
    if(item.endswith('.txt')):
        filename = item
    if(item == '--top'):
        process_count = int(params[i+1])


def set_result(item):
    return item, domains.count(item)

# main
if(filename):
    try:
        start_time = time.time()
        now = datetime.datetime.now()
        dirname = "email_stats_{0}".format(now.strftime("%Y%m%d_%H%M%S"))
        os.mkdir(dirname)

        list = open(filename).read().split()

        if(process_count == -1):
            process_count = len(list)

        if(process_count > 0):
            list = list[:process_count]

        #chunking list
        n = int(len(list) /  mp.cpu_count())
        chunks = [list[i:i + n] for i in range(0, len(list), n)]

        processes = []
        print('Processing list on {0} cores...'.format(mp.cpu_count()))
        for chunk in chunks:
            p = mp.Process(target=process, args=[chunk])
            p.start()
            processes.append(p)

        for p in processes:
            p.join()

        # insert(unique_list)

        ## step 2 - write sql

        ##  Clearing out db before new data insert
        con = pool.get_connection()
        cur = con.cursor()

        delete_statement = "DELETE FROM statistics"
        cur.execute(delete_statement)

        u_processes = []

        #Maximum pool size for sql is 32, so maximum chunk number should be that too.
        if(mp.cpu_count() < 32):
            n2 = int(len(unique_list) /  mp.cpu_count())
        else:
            n2 = int(len(unique_list) /  32)

        u_chunks = [unique_list[i:i + n2] for i in range(0, len(unique_list), n2)]
        for u_chunk in u_chunks:
            p = mp.Process(target=insert, args=[u_chunk])
            p.start()
            u_processes.append(p)

        for p in u_processes:
            p.join()

        for p in u_processes:
            p.close()

        # sql_cursor.executemany(sql_statement, sorted(map(set_result, unique_list)))
        # db.commit()
        # for item in tqdm(unique_list):
        #     sql_val = (item, domains.count(item))
        #     sql_cursor.execute(sql_statement, sql_val)
        #
        #     db.commit()

        ## numpy.savetxt('saved.txt', sorted(map(set_result, unique_list)), fmt='%s')


        # with(mp.Pool(mp.cpu_count(), initializer = db) as Pool:
        #     Pool.map_async(insert_into_database(),set(unique_list))
        #     Pool.close()
        #     Pool.join()

        print('Creating statistics for {0} individual domains...'.format(len(unique_list)))

        # unique_list = set(unique_list)
        # with open("{0}/result.txt".format(dirname), "w+") as f:
        #     csv.writer(f).writerows(sorted(map(set_result, unique_list), reverse=True))

        print('Writing final statistics...')
        print('OK.')
        f = open("{0}/stat.txt".format(dirname),"w+")
        f.write("Number of processed emails: {0}\r\n".format(process_count))
        f.write("Number of valid emails: {0}\r\n".format(len(list) - len(invalid_emails)))
        f.write("Number of invalid emails: {0}\r\n".format(len(invalid_emails)))
        f.write("Execution time: {0}".format(convertTime(int(time.time() - start_time))))
        f.close()

    except FileNotFoundError:
        print('File not found, path or file broken.')
else:
    print('Wrong file format, should be a txt file.')
# main

导入操作系统
进口稀土
导入日期时间
导入时间
导入csv
将mysql.connector作为连接器导入
从mysql.connector.pooling导入MySQLConnectionPool
导入mysql
将numpy作为np导入
从TQM导入TQM
从时间上导入睡眠
将多处理作为mp导入
进口numpy
pool=MySQLConnectionPool（pool\u name=“sql\u pool”，
池大小=32，
池重置会话=真，
host=“localhost”，
port=“3306”，
user=“宅地”，
password=“secret”，
数据库=“宅地”）
##sql连接
db=mysql.connector.connect(
host=“localhost”，
port=“3306”，
user=“宅地”，
password=“secret”，
数据库=“宅地”
)
sql_cursor=db.cursor（）
delete_statement=“从统计数据中删除”
sql\u cursor.execute（delete\u语句）
db.commit（）
sql_statement=“插入统计（名称、cnt）值（%s，%s）”
列表=[]
domains=mp.Manager（）.list（）
唯一列表=mp.Manager（）.list（）
无效的\u电子邮件=mp.Manager（）.list（）
结果=mp.Manager（）.list（）
regex|u email='^（\w| \.\u124; \-）+[@]（\ w| \.\u124; \-）+[.]\ w{2,3}$'
#检查电子邮件有效性
def检查（列表、电子邮件）：
如果（重新搜索（regex_电子邮件，电子邮件））：
domains.append（email.lower（）.split（'@'）[1]）
返回真值
其他：
无效的\u电子邮件。追加（电子邮件）
返回错误
#检查电子邮件有效性结束
#执行时间转换器
def转换时间（秒）：
秒=秒%（24*3600）
小时=秒//3600
秒%=3600
分=秒//60
秒%=60
如果（小时==0）：
如果（分钟==0）：
返回“{0}秒”。格式（秒）
其他：
返回“{0}min{1}sec”。格式（分钟，秒）
其他：
返回“{0}hr{1}min{2}sec”。格式（小时、分钟、秒）
#执行时间转换器结束
#过程
def流程（列表）：
对于TQM（列表）中的项目：
如果（检查（列表、项目））：
item=item.lower（）.split（'@'）[1]
如果项目不在唯一列表中：
唯一\u列表。追加（项）
#进程结束
def插入（列表）：
全局sql\u语句
#添加到数据库
con=pool.get_connection（）
cur=con.cursor（）
打印（“PID%d:使用连接%s”%（os.getpid（），con））
#cur.executemany（sql_语句，排序（映射（set_结果，列表）））
对于列表中的项目：
cur.execute（sql_语句，（item，domains.count（item）））
con.commit（）
当前关闭（）
con.close（）
#def将_插入_数据库（列表）：
#sql\u cursor.execute（sql\u语句，（unique\u list，1），multi=True）
#sql\u cursor.executemany（sql\u语句，排序（映射（set\u结果，列表）））
#db.commit（）
#统计数字
def统计信息（列表）：
对于TQM（列表）中的项目：
如果（域计数（项）>0）：
result.append（[domains.count（项），项]）
#统计结束
params=sys.argv
文件名=“”
进程计数=-1
对于i，枚举中的项（参数）：
如果（item.endswith（'.txt'））：
filename=项目
如果（项目=='--top'）：
进程计数=int（参数[i+1]）
def设置结果（项目）：
返回项，域。计数（项）
#主要
如果（文件名）：
尝试：
开始时间=time.time（）
now=datetime.datetime.now（）
dirname=“email_stats_{0}”。格式（now.strftime（“%Y%m%d_%H%m%S”））
os.mkdir（dirname）
列表=打开（文件名）.read（）.split（）
如果（进程计数==-1）：
进程计数=len（列表）
如果（进程计数>0）：
列表=列表[：进程\计数]
#分块列表
n=int（len（list）/mp.cpu\u count（））
chunks=[list[i:i+n]表示范围内的i（0，len（list），n）]
进程=[]
打印（{0}核上的处理列表…）。格式（mp.cpu\u count（））
对于块中的块：
p=mp.Process（target=Process，args=[chunk]）
p、 开始（）
进程。追加（p）
对于流程中的p：
p、 加入
#插入（唯一列表）
##步骤2-编写sql
##在插入新数据之前清除数据库
con=pool.get_connection（）
cur=con.cursor（）
delete_statement=“从统计数据中删除”
cur.execute（delete_语句）
u_进程=[]
#sql的最大池大小是32，所以最大块数也应该是32。
如果（mp.cpu_count（）<32）：
n2=int（len（唯一列表）/mp.cpu\u计数（）
其他：
n2=int（len（唯一列表）/32）
u_chunks=[唯一_列表[i:i+n2]表示范围内的i（0，len（唯一_列表），n2）]
对于u_块中的u_块：
p=mp.Process（target=insert，args=[u\u chunk]）
p、 开始（）
u_进程。追加（p）
对于u__过程中的p：
p、 加入
对于u__过程中的p：
p、 关闭（）
#sql\u cursor.executemany（sql\u语句，排序（映射（集合结果，唯一列表）））
#db.commit（）
#对于TQM（唯一列表）中的项目：
#sql_val=（项，域。计数（项））
#sql\u cursor.execute（sql\u语句，sql\u val）
#
#db.commit（）
##numpy.savetxt（'saved.txt'，已排序（映射（设置结果，唯一列表）），fmt='%s'）
#使用（mp.Pool（mp.cpu\u count（），初始值设定项=db）作为池：
7.3949973583221436 [0, 1, 2, 3, 4] [99995, 99996, 99997, 99998, 99999]
0.007997751235961914 [0, 1, 2, 3, 4] [99995, 99996, 99997, 99998, 99999]