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/'
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 = adlines()
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 * s(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 = il(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 = il(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线程的线程池
writelines()方法将什么写入文件⽤来开辟线程池
另外⼀⾏是
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的open的写⼊⽅式有：
write(str)：将str写⼊⽂件
writelines(sequence of strings)：写多⾏到⽂件，参数为可迭代对象
f = open('', 'w') #⾸先先创建⼀个⽂件对象，打开⽅式为w
f.writelines('123456') #⽤readlines()⽅法写⼊⽂件
运⾏上⾯结果之后，可以看到⽂件有123456内容，这⾥需要注意的是，mode为‘w'模式(写模式)，再来看下⾯代码：
f = open('', 'w') #⾸先先创建⼀个⽂件对象，打开⽅式为w
f.writelines(123456) #⽤readlines()⽅法写⼊⽂件
运⾏上⾯代码之后会报⼀个TypeError，这是因为writelines传⼊的参数并不是⼀个可迭代的对象。
以上就是关于python频繁写⼊⽂件怎么提速的相关知识点以及扩展内容，感谢⼤家的阅读。

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。