python运行慢怎么解决(python运行慢的原因)

pythonprocess多核更慢

可能出现 Python 进程在多核处理器上运行更慢的情况，这可能是因为在使用多核时会存在一些额外的开销，例如进程之间的通信、数历渗哗据复制等。在单核处理器上运行的情况下，这些额外的开销被隐藏了。此外，如果某些任务的执行时间比较短，Python 在启动多个进程时也需要考虑到进程之间切换时的开销。

为了获得更好的性能并使用多核处理器，可以尝试以下解决方案：

1. 使用并行处理库，例如 multiprocessing 和 concurrent.futures，可以轻松地开启多个进程同时处理任务。这可以显着提高 Python 进程在多核处理器上的运行速度。

2. 使用 NumPy、pandas 等科学计算库可以发挥多核处理器的优势，因为它们已经实现了各种并行化算法。

3. 尽可能避免使用全局锁肢行，应该使用线程局部数据，这将使得多线程应用程序能够在多核处理器上运行。

4. 尽可能减少进程之间的数据通信，此外，尽量减少数据复制操作。

5. 通过设置进程池，使用进程池可以将所有进程预先建立，这可以显著减少开销，特别是在短时间内运行许多进程的情况下。喊喊

提升Python运行速度的5个小技巧

pre{overflow-x: auto}

Python 是世界上使用最广泛的编程语言之一。它是一种解释型高级通用编程语言，具有广泛的用途，几乎可以将其用于所有事物。其以简单的语法、优雅的代码和丰富的第三方库而闻名。python除了有很多优点外，但在速度上还有一个非常大的缺点。

虽然Python代码运行缓慢，但可以通过下面分享的5个小技巧提升Python运行速度！

首先，定义一个计时函数timeshow，通过简单的装饰，可以打印指定函数的运行时间。

这个函数在下面的例子中会被多次使用。

def?timeshow(func): ????from?time?import?time ????def?newfunc(*arg,?**kw): ????????t1?=?time() ?誉竖斗???????res?=?func(*arg,?**kw) ????????t2?=?time() ????????print(f"{func.__name__:?10}?:?{t2-t1:.6f}?sec") ????????return?res ????return?newfunc @timeshow def?test_it(): ????print("hello?pytip") test_it() 1. 选择合适的数据结构

使用正确的数据结构对python脚本的运行时间有显着影响。Python 有四种内置的数据结构：

列表 : List

元组 : Tuple

集合 : Set

字典 : Dictionary

但是，大多数开发人员在所有情况下都使用列表。这是不正确的做法，应纤凳该根据任务使用合适数据结构。

运行下面的代码，可以看到元组执行简单检索操作的速度比列表快。其中dis模块反汇编了一个函数的字节码，这有利于查看列表和元组之间的区别。

import?dis def?a(): ????data?=?[1,?2,?庆磨3,?4,?5,6,7,8,9,10] ????x?=data[5] ????return?x def?b(): ????data?=?(1,?2,?3,?4,?5,6,7,8,9,10) ????x?=data[5] ????return?x print("-----:使用列表的机器码:------") dis.dis(a) print("-----:使用元组的机器码:------") dis.dis(b)

运行输出:

-----:使用列表的机器码:------

3 0 LOAD_CONST 1 (1)

2 LOAD_CONST 2 (2)

4 LOAD_CONST 3 (3)

6 LOAD_CONST 4 (4)

8 LOAD_CONST 5 (5)

10 LOAD_CONST 6 (6)

12 LOAD_CONST 7 (7)

14 LOAD_CONST 8 (8)

16 LOAD_CONST 9 (9)

18 LOAD_CONST 10 (10)

20 BUILD_LIST 10

22 STORE_FAST 0 (data)

4 24 LOAD_FAST 0 (data)

26 LOAD_CONST 5 (5)

28 BINARY_SUBSCR

30 STORE_FAST 1 (x)

5 32 LOAD_FAST 1 (x)

34 RETURN_VALUE

-----:使用元组的机器码:------

7 0 LOAD_CONST 1 ((1, 2, 3, 4, 5, 6, 7, 8, 9, 10))

2 STORE_FAST 0 (data)

8 4 LOAD_FAST 0 (data)

6 LOAD_CONST 2 (5)

8 BINARY_SUBSCR

10 STORE_FAST 1 (x)

9 12 LOAD_FAST 1 (x)

14 RETURN_VALUE

看下列表的机器码，冗长而多余！

2. 善用强大的内置函数和第三方库

如果你正在使用python并且仍在自己编写一些通用函数(比如加法、减法)，那么是在侮辱python。 Python有大量的库和内置函数来帮助你不用编写这些函数。 如果研究下，那么你会惊奇地发现几乎90%的问题已经有第三方包或内置函数来解决。

可以通过访问官方文档查看所有内置函数。你也可以在wiki python上找到更多使用内置函数的场景。

比如，现在我们想合并列表中的所有单词为一个句子，比较法自己编写和调用库函数的区别:

#???正常人能想到的方法 @timeshow def?f1(list): ????s?="" ????for?substring?in?list: ????????s?+=?substring ????return?s #???pythonic?的方法 @timeshow def?f2(list): ????s?=?"".join(list) ????return?s l?=?["I",?"Love",?"Python"]?*?1000?#?为了看到差异，我们把这个列表放大了 f1(l) f2(l)

运行输出:

f1 : 0.000227 sec

f2 : 0.000031 sec

3. 少用循环

用 列表推导式 代替循环

用 迭代器 代替循环

用 filter() 代替循环

减少循环次数，精确控制，不浪费CPU

##?返回n以内的可以被7整除的所有数字。 #???正常人能想到的方法: @timeshow def?f_loop(n):? ????L=[] ????for?i?in?range(n): ????????if?i?%?7?==0: ????????????L.append(i) ????return?L #????列表推导式 @timeshow def?f_list(n): ????L?=?[i?for?i?in?range(n)?if?i?%?7?==?0] ????return?L #????迭代器 @timeshow def?f_iter(n): ????L?=?(i?for?i?in?range(n)?if?i?%?7?==?0) ????return?L #???过滤器? @timeshow def?f_filter(n): ????L?=?filter(lambda?x:?x?%?7?==?0,?range(n)) ????return?L #???精确控制循环次数? @timeshow def?f_mind(n): ????L?=?(i*7?for?i?in?range(n//7)) ????return?L n?=?1_000_000 f_loop(n) f_list(n) f_iter(n) f_filter(n) f_mind(n)

输出为:

f_loop : 0.083017 sec

f_list : 0.056110 sec

f_iter : 0.000015 sec

f_filter : 0.000003 sec

f_mind : 0.000002 sec

谁快谁慢，一眼便知！

filter 配合 lambda 大法就是屌！！！

4. 避免循环重复计算

如果你有一个迭代器，必须用它的元素做一些耗时计算，比如匹配正则表达式。你应该将正则表达式模式定义在循环之外，因为最好只编译一次模式，而不是在循环的每次迭代中一次又一次地编译它。

只要有可能，就应该尝试在循环外进行尽可能多的运算，比如将函数计算分配给局部变量，然后在函数中使用它。

#???应改避免的方式： @timeshow def?f_more(s): ????import?re ????for?i?in?s: ????????m?=?re.search(r'a*[a-z]?c',?i) #???更好的方式： @timeshow def?f_less(s): ????import?re ????regex?=?re.compile(r'a*[a-z]?c') ????for?i?in?s: ????????m?=?regex.search(i) s?=?["abctestabc"]?*?1_000 f_more(s) f_less(s)

输出为:

f_more : 0.001068 sec

f_less : 0.000365 sec

5. 少用内存、少用全局变量

内存占用是指程序运行时使用的内存量。为了让Python代码运行得更快，应该减少程序的内存使用量，即尽量减少变量或对象的数量。

Python 访问局部变量比全局变量更有效。在有必要之前，应该始终尝试忽略声明全局变量。一个在程序中定义过的全局变量会一直存在，直到整个程序编译完成，所以它一直占据着内存空间。另一方面，局部变量访问更快，且函数完成后即可回收。因此，使用多个局部变量比使用全局变量会更好。

#???应该避免的方式： message?=?"Line1\n" message?+=?"Line2\n" message?+=?"Line3\n" #???更好的方式： l?=?["Line1","Line2","Line3"] message?=?'\n'.join(l) #???应该避免的方式： x?=?5 y?=?6? def?add(): ????return?x+y add() #???更好的方式： def?add(): ????x?=?5 ????y?=?6 ????return?x+y add()

总结

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注的更多内容!

python 处理大数据程序运行的越来越慢的问题

最近编写并运行了一个处理1500万个数据的程序，本来最初每秒可以处理150个左右的数据，预计大概15个小时的时间就可以处理完，晚上的时候就开始运行，本以为等到第二天中午就可以得到结果呢，，，

可是，等我第二天的时候一看，什么？？？还没处理完，当前的数据处理速度变成了一秒5个左右，然后还需要等待300个小时。

然后就查了一下这个问题，原来同样也有很多人在处理培察蔽大数据的时候遇到了这个问题，大多数的文章分析的原因都是说由于GC（垃圾回收）造成的性能下降。

Python的垃圾回收机制的工作原理为每个对象维护一个引用计数，每次内存对象的创建与销毁都必须修改引用计数，从而在大量的对象创建时，需要大量的执行修改引用计数操作，对于程序执行过程中，额外的性能开销是令人可怕的。回收的触发时机有两种可能，一是用户主动调用gc.collect(),二是对象数量超过阈值。

所以正是GC拖慢了程序的性能，所以我们可以考虑在处理的时候禁止垃圾回收。

通过这样的改进之后速度确度会有很大的提升。但是又有也会另外的一个问题，内存溢出，由于运行的过程中生成大量的对象，一次使用后就没有了引用，由于关闭了垃圾回收机制，一直存在内存中得不到清理，然后程序的内存使用量越来越大。解决的方法就是定期打开gc.enable()再关配州闭或者主动调用gc.collect(),这样就可以了。

通过上述的改进后程序确实了很多，可是我的程序还是运行的越来越慢，我都怀疑人生了，然后分别测试了各个步骤所花费的时间才知道了原因，我使用了pandas创建一个DataFrame,然后每次迭代得到的结果都添加新的数据到DataFrame中，随着里边的数据越来越多，添加的速度也就越来越慢了，严重的拖累的运行速度。这里的解决方法有两个：

1 分段保存结果，间隔一段时间就保存一次结果，最后再将多次的结果合并。

2 换一个数据存储方法，我是直接使用了python的没和字典进行保存结果，它随着数据的增多添加的速度也会变慢，但是差别不是很大，在可接受的范围内，可以使用；或者再加上方法1，分段进行保存再合并也是可以的。

python运行速度慢怎么办

yxhtest7772017-07-18

关注

?分享

??697??????2

python运行速度慢怎么办？6个Python性能优化技巧

?

Python是一门非常酷的语言，因为很少的Python代码可以在短时间内做很多事情，并且，Python很容易就能支持多任务卜谈和多重处理。

Python的批评者声称Python性能低效、执行缓慢，但实际上并非如型凳碰此：尝试以下6个小技巧，可以加快Python应用程序。

关键代码可以依赖于扩展包

Python使许多编程任务变得简单，但是对于很关键的任务并不总是提供最好的性能。使用C、C++或者机器语言扩展包来执行关键任务能极大改善性能。这些包是依赖于平台的，也就是说，你必须使用特定的、与你使用的平台相关的包。简而言之,该解决方案提供了一些应用程序的可移植性,以换取性能,您可以获得只有通过直接向底层主机编程。

下面这些扩展包你可以考虑添加到你的个人扩展库中：

Cython

PyInlne

PyPy

Pyrex

这些包有不同的作用和执行方式。例如，Pyrex 让Python处理一些内存任务变得简单高效；PyInline可以直接让你在Python应用程序中使用C代码，虽然内联代码被单独编译，但是如果你能高效的利用C代码，它可以在同一个地方处理每一件事情。

使用关键字排序

有很多古老的Python代码在执行时将花费额外的时间去创建一个自定义的排序函数。最好的排序方式是使用关键字和默认的sort()方法。

优化循环

每一种编程语言都强调循环语句的优化，Python也是一样的。尽管你可以依赖于丰富的技术让循环运粗樱行的更快，然而，开发者经常忽略的一个方法是避免在循环内部使用点拼接字符串。

使用新版本

任何一个在线上搜索Python资料的人都会发现无数关于Python版本迁移的信息。通常，Python每一个版本都针对之前的一个版本做了优化和改进，以让Python运行的更快。限制因素是你喜欢的函数库是否也针对Python的新版本做了改进。

当你使用了新的函数库，获得了Python的新版本，你需要保证代码依然能够运行，检查应用，修正差异。然后，如果你仅仅是