python频繁写入文件怎么提速-Python教程

成绩布景：有一批需求解决的文件，关于每个文件，都需求挪用同一个函数进行解决，相称耗时。

有无减速的方法呢？当然有啦，比方说你将这些文件分红若干批，每个批次都挪用本人写的python剧本进行解决，这样同时运转若干个python顺序也能够进行减速。

有无更简略的办法呢？比方说，我一个运转的一个顺序外面，同时候为多个线程，而后进行解决？

大略思绪:将这些个文件门路的list，分红若干个，至于分红几何，要看本人cpu外围有几何，比方你的cpu有32核的，实践上就能够减速32倍。

代码以下：

# -*-coding:utf-8-*-
import numpy as np
from glob import glob
import math
import os
import torch
from tqdm import tqdm
import multiprocessing
label_path = '/home/ying/data/shiyongjie/distortion_datasets/new_distortion_dataset/train/label.txt'
file_path = '/home/ying/data/shiyongjie/distortion_datasets/new_distortion_dataset/train/distortion_image'
save_path = '/home/ying/data/shiyongjie/distortion_datasets/new_distortion_dataset/train/flow_field'
r_d_max = 128
image_index = 0
txt_file = open(label_path)
file_list = txt_file.readlines()
txt_file.close()
file_label = {}
for i in file_list:
    i = i.split()
    file_label[i[0]] = i[1]
r_d_max = 128
eps = 1e-32
H = 256
W = 256
def generate_flow_field(image_list):
    for image_file_path in ((image_list)):
        pixel_flow = np.zeros(shape=tuple([256, 256, 2]))  # 依照pytorch中的grid来写
        image_file_name = os.path.basename(image_file_path)
        # print(image_file_name)
        k = float(file_label[image_file_name])*(-1)*1e-7
        # print(k)
        r_u_max = r_d_max/(1+k*r_d_max**2)  # 较量争论出畸变校对之后的对角线的实践长度
        scale = r_u_max/128  # 将这个长度紧缩到256的尺寸，会有一个scale，实际上这里写128*sqrt(2)可能会愈加直观
        for i_u in range(256):
            for j_u in range(256):
                x_u = float(i_u - 128)
                y_u = float(128 - j_u)
                theta = math.atan2(y_u, x_u)
                r = math.sqrt(x_u ** 2 + y_u ** 2)
                r = r * scale  # 实际上失去的r，即不resize到256×256的图象尺寸size，而且带入公式中
                r_d = (1.0 - math.sqrt(1 - 4.0 * k * r ** 2)) / (2 * k * r + eps)  # 对应正在原图（畸变图）中的r
                x_d = int(round(r_d * math.cos(theta)))
                y_d = int(round(r_d * math.sin(theta)))
                i_d = int(x_d + W / 2.0)
                j_d = int(H / 2.0 - y_d)
                if i_d < W and i_d >= 0 and j_d < H and j_d >= 0:  # 只有求的的畸变点正在原图中的时分才进行赋值
                    value1 = (i_d - 128.0)/128.0
                    value2 = (j_d - 128.0)/128.0
                    pixel_flow[j_u, i_u, 0] = value1  # mesh中存储的是对应的r的比值，正在进行畸变校对的时分，给定一张这样的图，进行找像素便可
                    pixel_flow[j_u, i_u, 1] = value2
# 保留成array格局
        saved_image_file_path = os.path.join(save_path, image_file_name.split('.')[0] + '.npy')
        pixel_flow = pixel_flow.astype('f2')  # 将数据的格局转换成float16类型， 节流空间
        # print(saved_image_file_path)
        # print(pixel_flow)
        np.save(saved_image_file_path, pixel_flow)
    return
if __name__ == '__main__':
    file_list = glob(file_path + '/*.JPEG')
    m = 32
    n = int(math.ceil(len(file_list) / float(m)))  # 向上取整
    result = []
    pool = multiprocessing.Pool(processes=m)  # 32过程
    for i in range(0, len(file_list), n):
        result.append(pool.apply_async(generate_flow_field, (file_list[i: i+n],)))
    pool.close()
    pool.join()

正在下面的代码中，函数

generate_flow_field(image_list)

需求传入一个list，而后关于这个list进行操作，之后对操作的后果进行保留

以是，只要要将你需求解决的多个文件，切分红只管即便等巨细的list，而后再对每个list，开一个线程进行解决便可

下面的主函数：

if __name__ == '__main__':
    file_list = glob(file_path + '/*.JPEG')  # 将文件夹下一切的JPEG文件列成一个list
    m = 32  # 假定CPU有32个外围
    n = int(math.ceil(len(file_list) / float(m)))  # 每个外围需求解决的list的数量
    result = []
    pool = multiprocessing.Pool(processes=m)  # 开32线程的线程池
    for i in range(0, len(file_list), n):
        result.append(pool.apply_async(generate_flow_field, (file_list[i: i+n],)))  # 对每个list都用下面咱们界说的函数进行解决
    pool.close()  # 解决完结之后，封闭线程池
    pool.join()

次要是这样的两行代码，一行是

pool = multiprocessing.Pool(processes=m)  # 开32线程的线程池

用来开拓线程池

另一行是

result.append(pool.apply_async(generate_flow_field, (file_list[i: i+n],)))  # 对每个list都用下面咱们界说的函数进行解决

关于线程池，用apply_async()同时跑generate_flow_field这个函数，传入的参数是：file_list[i: i+n]

实际上apply_async()这个函数的作用是一切的线程同时跑，速率是比拟快的。

更多Python相干技巧文章，请拜访Python教程栏目进行学习！

以上就是python频仍写入文件怎样提速的具体内容，更多请存眷资源魔其它相干文章！