题目背景：有一批须要处置惩罚的文件，关于每个文件，都须要挪用同一个函数举行处置惩罚，相称耗时。
有无加快的要领呢？当然有啦，比方说你将这些文件分红若干批，每个批次都挪用本身写的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频仍写入文件怎样提速的细致内容，更多请关注ki4网别的相干文章！
