python编程优化_python 性能优化方法小结

最新推荐文章于 2024-09-04 15:20:01 发布

weixin_39969568

最新推荐文章于 2024-09-04 15:20:01 发布

阅读量186

点赞数

文章标签： python编程优化

本文链接：https://blog.csdn.net/weixin_39969568/article/details/113987289

版权

python 性能优化方法小结

来源：中文源码网浏览：次日期：2018年9月2日

【下载文档: python 性能优化方法小结.txt 】

(友情提示:右键点上行txt文档名->目标另存为)

python 性能优化方法小结提高性能有如下方法

1、Cython,用于合并python和c语言静态编译泛型

2、IPython.parallel，用于在本地或者集群上并行执行代码

3、numexpr，用于快速数值运算

4、multiprocessing,python内建的并行处理模块

5、Numba，用于为cpu动态编译python代码

6、NumbaPro，用于为多核cpu和gpu动态编译python代码

为了验证相同算法在上面不同实现上的的性能差异，我们先定义一个测试性能的函数

def perf_comp_data(func_list, data_list, rep=3, number=1):

'''Function to compare the performance of different functions.

Parameters

func_list : list

list with function names as strings data_list : list

list with data set names as strings rep : int

number of repetitions of the whole comparison

number : int

number ofexecutions for every function

'''

from timeit import repeat

res_list = {}

for name in enumerate(func_list):

stmt = name[1] + '(' + data_list[name[0]] + ')'

setup = "from __main__ import " + name[1] + ','+ data_list[name[0]]

results = repeat(stmt=stmt, setup=setup, repeat=rep, number=number)

res_list[name[1]] = sum(results) / rep

res_sort = sorted(res_list.items(), key = lambda item : item[1])

for item in res_sort:

rel = item[1] / res_sort[0][1]

print ('function: ' + item[0] + ', av. time sec: %9.5f, ' % item[1] + 'relative: %6.1f' % rel)

定义执行的算法如下

from math import *

def f(x):

return abs(cos(x)) ** 0.5 + sin(2 + 3 * x)对应的数学公式是生成数据如下

i=500000

a_py = range(i)第一个实现f1是在内部循环执行f函数，然后将每次的计算结果添加到列表中，实现如下

def f1(a):

res = []

for x in a:

res.append(f(x))

return res当然实现这种方案的方法不止一种，可以使用迭代器或eval函数,我自己加入了使用生成器和map方法的测试，发现结果有明显差距，不知道是否科学：

迭代器实现

def f2(a):

return [f(x) for x in a]eval实现

def f3(a):

ex = 'abs(cos(x)) **0.5+ sin(2 + 3 * x)'

return [eval(ex) for x in a] 生成器实现

def f7(a):

return (f(x) for x in a)map实现

def f8(a):

return map(f, a)接下来是使用numpy的narray结构的几种实现

import numpy as np

a_np = np.arange(i) def f4(a):

return (np.abs(np.cos(a)) ** 0.5 + np.sin(2 + 3 * a))import numexpr as nedef f5(a):

ex = 'abs(cos(a)) ** 0.5 + sin( 2 + 3 * a)'

ne.set_num_threads(1)

return ne.evaluate(ex)def f6(a):

ex = 'abs(cos(a)) ** 0.5 + sin(2 + 3 * a)'

ne.set_num_threads(2)

return ne.evaluate(ex)

上面的f5和f6只是使用的处理器个数不同，可以根据自己电脑cpu的数目进行修改，也不是越大越好

下面进行测试

func_list = ['f1', 'f2', 'f3', 'f4', 'f5', 'f6', 'f7', 'f8']

data_list = ['a_py', 'a_py', 'a_py', 'a_np', 'a_np', 'a_np', 'a_py', 'a_py']

perf_comp_data(func_list, data_list)测试结果如下

function: f8, av. time sec: 0.00000, relative: 1.0

function: f7, av. time sec: 0.00001, relative: 1.7

function: f6, av. time sec: 0.03787, relative: 11982.7

function: f5, av. time sec: 0.05838, relative: 18472.4

function: f4, av. time sec: 0.09711, relative: 30726.8

function: f2, av. time sec: 0.82343, relative: 260537.0

function: f1, av. time sec: 0.92557, relative: 292855.2

function: f3, av. time sec: 32.80889, relative: 10380938.6发现f8的时间最短，调大一下时间精度再测一次

function: f8, av. time sec: 0.000002483, relative: 1.0

function: f7, av. time sec: 0.000004741, relative: 1.9

function: f5, av. time sec: 0.028068110, relative: 11303.0

function: f6, av. time sec: 0.031389788, relative: 12640.6

function: f4, av. time sec: 0.053619114, relative: 21592.4

function: f1, av. time sec: 0.852619225, relative: 343348.7

function: f2, av. time sec: 1.009691877, relative: 406601.7

function: f3, av. time sec: 26.035869787, relative: 10484613.6发现使用map的性能最高，生成器次之，其他方法的性能就差的很远了。但是使用narray数据的在一个数量级，使用python的list数据又在一个数量级。生成器的原理是并没有生成一个完整的列表，而是在内部维护一个next函数，通过一边循环迭代一遍生成下个元素的方法的实现的，所以他既不用在执行时遍历整个循环，也不用分配整个空间，它花费的时间和空间跟列表的大小是没有关系的，map与之类似，而其他实现都是跟列表大小有关系的。

内存布局

numpy的ndarray构造函数形式为

np.zeros(shape, dtype=float, order='C')

np.array(object, dtype=None, copy=True, order=None, subok=False, ndmin=0)

shape或object定义了数组的大小或是引用了另一个一个数组

dtype用于定于元素的数据类型，可以是int8，int32，float8，float64等等

order定义了元素在内存中的存储顺序，c表示行优先，F表示列优先

下面来比较一下内存布局在数组很大时的差异，先构造同样的的基于C和基于F的数组，代码如下：

x = np.random.standard_normal(( 3, 1500000))

c = np.array(x, order='C')

f = np.array(x, order='F') 下面来测试性能

%timeit c.sum(axis=0)