Python性能優(yōu)化的20條建議

http://segmentfault.com/a/1190000000666603

優(yōu)化算法時(shí)間復(fù)雜度

算法的時(shí)間復(fù)雜度對(duì)程序的執(zhí)行效率影響最大，在Python中可以通過(guò)選擇合適的數(shù)據(jù)結(jié)構(gòu)來(lái)優(yōu)化時(shí)間復(fù)雜度，如list和set查找某一個(gè)元素的時(shí)間復(fù)雜度分別是O(n)和O(1)。不同的場(chǎng)景有不同的優(yōu)化方式，總得來(lái)說(shuō)，一般有分治，分支界限，貪心，動(dòng)態(tài)規(guī)劃等思想。

減少冗余數(shù)據(jù)

如用上三角或下三角的方式去保存一個(gè)大的對(duì)稱矩陣。在0元素占大多數(shù)的矩陣?yán)锸褂孟∈杈仃嚤硎尽?/p>

合理使用copy與deepcopy

對(duì)于dict和list等數(shù)據(jù)結(jié)構(gòu)的對(duì)象，直接賦值使用的是引用的方式。而有些情況下需要復(fù)制整個(gè)對(duì)象，這時(shí)可以使用copy包里的copy和deepcopy，這兩個(gè)函數(shù)的不同之處在于后者是遞歸復(fù)制的。效率也不一樣：（以下程序在ipython中運(yùn)行）

import copy a = range(100000) %timeit -n 10 copy.copy(a) # 運(yùn)行10次 copy.copy(a) %timeit -n 10 copy.deepcopy(a) 10 loops, best of 3: 1.55 ms per loop 10 loops, best of 3: 151 ms per loop

timeit后面的-n表示運(yùn)行的次數(shù)，后兩行對(duì)應(yīng)的是兩個(gè)timeit的輸出，下同。由此可見(jiàn)后者慢一個(gè)數(shù)量級(jí)。

使用dict或set查找元素

python dict和set都是使用hash表來(lái)實(shí)現(xiàn)(類似c++11標(biāo)準(zhǔn)庫(kù)中unordered_map)，查找元素的時(shí)間復(fù)雜度是O(1)

a = range(1000) s = set(a) d = dict((i,1) for i in a) %timeit -n 10000 100 in d %timeit -n 10000 100 in s 10000 loops, best of 3: 43.5 ns per loop 10000 loops, best of 3: 49.6 ns per loop

dict的效率略高(占用的空間也多一些)。

合理使用生成器（generator）和yield

%timeit -n 100 a = (i for i in range(100000)) %timeit -n 100 b = [i for i in range(100000)] 100 loops, best of 3: 1.54 ms per loop 100 loops, best of 3: 4.56 ms per loop

使用()得到的是一個(gè)generator對(duì)象，所需要的內(nèi)存空間與列表的大小無(wú)關(guān)，所以效率會(huì)高一些。在具體應(yīng)用上，比如set(i for i in range(100000))會(huì)比set([i for i in range(100000)])快。

但是對(duì)于需要循環(huán)遍歷的情況：

%timeit -n 10 for x in (i for i in range(100000)): pass %timeit -n 10 for x in [i for i in range(100000)]: pass 10 loops, best of 3: 6.51 ms per loop 10 loops, best of 3: 5.54 ms per loop

后者的效率反而更高，但是如果循環(huán)里有break,用generator的好處是顯而易見(jiàn)的。yield也是用于創(chuàng)建generator：

def yield_func(ls): for i in ls: yield i+1 def not_yield_func(ls): return [i+1 for i in ls] ls = range(1000000) %timeit -n 10 for i in yield_func(ls):pass %timeit -n 10 for i in not_yield_func(ls):pass 10 loops, best of 3: 63.8 ms per loop 10 loops, best of 3: 62.9 ms per loop

對(duì)于內(nèi)存不是非常大的list，可以直接返回一個(gè)list，但是可讀性yield更佳(人個(gè)喜好)。

python2.x內(nèi)置generator功能的有xrange函數(shù)、itertools包等。

優(yōu)化循環(huán)

循環(huán)之外能做的事不要放在循環(huán)內(nèi)，比如下面的優(yōu)化可以快一倍：

a = range(10000) size_a = len(a) %timeit -n 1000 for i in a: k = len(a) %timeit -n 1000 for i in a: k = size_a 1000 loops, best of 3: 569 μs per loop 1000 loops, best of 3: 256 μs per loop

優(yōu)化包含多個(gè)判斷表達(dá)式的順序

對(duì)于and，應(yīng)該把滿足條件少的放在前面，對(duì)于or，把滿足條件多的放在前面。如：

a = range(2000) %timeit -n 100 [i for i in a if 10 < i < 20 or 1000 < i < 2000] %timeit -n 100 [i for i in a if 1000 < i < 2000 or 100 < i < 20] %timeit -n 100 [i for i in a if i % 2 == 0 and i > 1900] %timeit -n 100 [i for i in a if i > 1900 and i % 2 == 0] 100 loops, best of 3: 287 μs per loop 100 loops, best of 3: 214 μs per loop 100 loops, best of 3: 128 μs per loop 100 loops, best of 3: 56.1 μs per loop

使用join合并迭代器中的字符串

In [1]: %%timeit...: s = ''...: for i in a: ...: s += i ...: 10000 loops, best of 3: 59.8 μs per loop In [2]: %%timeit s = ''.join(a) ...: 100000 loops, best of 3: 11.8 μs per loop

join對(duì)于累加的方式，有大約5倍的提升。

選擇合適的格式化字符方式

s1, s2 = 'ax', 'bx' %timeit -n 100000 'abc%s%s' % (s1, s2) %timeit -n 100000 'abc{0}{1}'.format(s1, s2) %timeit -n 100000 'abc' + s1 + s2 100000 loops, best of 3: 183 ns per loop 100000 loops, best of 3: 169 ns per loop 100000 loops, best of 3: 103 ns per loop

三種情況中，%的方式是最慢的，但是三者的差距并不大（都非常快）。(個(gè)人覺(jué)得%的可讀性最好)

不借助中間變量交換兩個(gè)變量的值

In [3]: %%timeit -n 10000a,b=1,2....: c=a;a=b;b=c;....: 10000 loops, best of 3: 172 ns per loop In [4]: %%timeit -n 10000 a,b=1,2 a,b=b,a ....: 10000 loops, best of 3: 86 ns per loop

使用a,b=b,a而不是c=a;a=b;b=c;來(lái)交換a,b的值，可以快1倍以上。

使用if is

a = range(10000) %timeit -n 100 [i for i in a if i == True] %timeit -n 100 [i for i in a if i is True] 100 loops, best of 3: 531 μs per loop 100 loops, best of 3: 362 μs per loop

使用?if is True?比?if == True?將近快一倍。

使用級(jí)聯(lián)比較x < y < z

x, y, z = 1,2,3 %timeit -n 1000000 if x < y < z:pass %timeit -n 1000000 if x < y and y < z:pass 1000000 loops, best of 3: 101 ns per loop 1000000 loops, best of 3: 121 ns per loop

x < y < z效率略高，而且可讀性更好。

while 1?比?while True?更快

def while_1(): n = 100000 while 1: n -= 1 if n <= 0: break def while_true(): n = 100000 while True: n -= 1 if n <= 0: break m, n = 1000000, 1000000 %timeit -n 100 while_1() %timeit -n 100 while_true() 100 loops, best of 3: 3.69 ms per loop 100 loops, best of 3: 5.61 ms per loop

while 1 比 while true快很多，原因是在python2.x中，True是一個(gè)全局變量，而非關(guān)鍵字。

使用**而不是pow

%timeit -n 10000 c = pow(2,20) %timeit -n 10000 c = 2**20 10000 loops, best of 3: 284 ns per loop 10000 loops, best of 3: 16.9 ns per loop

**就是快10倍以上！

使用 cProfile, cStringIO 和 cPickle等用c實(shí)現(xiàn)相同功能（分別對(duì)應(yīng)profile, StringIO, pickle）的包

import cPickle import pickle a = range(10000) %timeit -n 100 x = cPickle.dumps(a) %timeit -n 100 x = pickle.dumps(a) 100 loops, best of 3: 1.58 ms per loop 100 loops, best of 3: 17 ms per loop

由c實(shí)現(xiàn)的包，速度快10倍以上！

使用最佳的反序列化方式

下面比較了eval, cPickle, json方式三種對(duì)相應(yīng)字符串反序列化的效率：

import json import cPickle a = range(10000) s1 = str(a) s2 = cPickle.dumps(a) s3 = json.dumps(a) %timeit -n 100 x = eval(s1) %timeit -n 100 x = cPickle.loads(s2) %timeit -n 100 x = json.loads(s3) 100 loops, best of 3: 16.8 ms per loop 100 loops, best of 3: 2.02 ms per loop 100 loops, best of 3: 798 μs per loop

可見(jiàn)json比cPickle快近3倍，比eval快20多倍。

使用C擴(kuò)展(Extension)

目前主要有CPython(python最常見(jiàn)的實(shí)現(xiàn)的方式)原生API, ctypes,Cython，cffi三種方式，它們的作用是使得Python程序可以調(diào)用由C編譯成的動(dòng)態(tài)鏈接庫(kù)，其特點(diǎn)分別是：

CPython原生API: 通過(guò)引入Python.h頭文件，對(duì)應(yīng)的C程序中可以直接使用Python的數(shù)據(jù)結(jié)構(gòu)。實(shí)現(xiàn)過(guò)程相對(duì)繁瑣，但是有比較大的適用范圍。

ctypes: 通常用于封裝(wrap)C程序，讓純Python程序調(diào)用動(dòng)態(tài)鏈接庫(kù)（Windows中的dll或Unix中的so文件）中的函數(shù)。如果想要在python中使用已經(jīng)有C類庫(kù)，使用ctypes是很好的選擇，有一些基準(zhǔn)測(cè)試下，python2+ctypes是性能最好的方式。

Cython: Cython是CPython的超集，用于簡(jiǎn)化編寫C擴(kuò)展的過(guò)程。Cython的優(yōu)點(diǎn)是語(yǔ)法簡(jiǎn)潔，可以很好地兼容numpy等包含大量C擴(kuò)展的庫(kù)。Cython的使得場(chǎng)景一般是針對(duì)項(xiàng)目中某個(gè)算法或過(guò)程的優(yōu)化。在某些測(cè)試中，可以有幾百倍的性能提升。

cffi: cffi的就是ctypes在pypy（詳見(jiàn)下文）中的實(shí)現(xiàn)，同進(jìn)也兼容CPython。cffi提供了在python使用C類庫(kù)的方式，可以直接在python代碼中編寫C代碼，同時(shí)支持鏈接到已有的C類庫(kù)。

使用這些優(yōu)化方式一般是針對(duì)已有項(xiàng)目性能瓶頸模塊的優(yōu)化，可以在少量改動(dòng)原有項(xiàng)目的情況下大幅度地提高整個(gè)程序的運(yùn)行效率。

并行編程

因?yàn)镚IL的存在，Python很難充分利用多核CPU的優(yōu)勢(shì)。但是，可以通過(guò)內(nèi)置的模塊multiprocessing實(shí)現(xiàn)下面幾種并行模式：

多進(jìn)程：對(duì)于CPU密集型的程序，可以使用multiprocessing的Process,Pool等封裝好的類，通過(guò)多進(jìn)程的方式實(shí)現(xiàn)并行計(jì)算。但是因?yàn)檫M(jìn)程中的通信成本比較大，對(duì)于進(jìn)程之間需要大量數(shù)據(jù)交互的程序效率未必有大的提高。

多線程：對(duì)于IO密集型的程序，multiprocessing.dummy模塊使用multiprocessing的接口封裝threading，使得多線程編程也變得非常輕松(比如可以使用Pool的map接口，簡(jiǎn)潔高效)。

分布式：multiprocessing中的Managers類提供了可以在不同進(jìn)程之共享數(shù)據(jù)的方式，可以在此基礎(chǔ)上開(kāi)發(fā)出分布式的程序。

不同的業(yè)務(wù)場(chǎng)景可以選擇其中的一種或幾種的組合實(shí)現(xiàn)程序性能的優(yōu)化。

終級(jí)大殺器：PyPy

PyPy是用RPython(CPython的子集)實(shí)現(xiàn)的Python，根據(jù)官網(wǎng)的基準(zhǔn)測(cè)試數(shù)據(jù)，它比CPython實(shí)現(xiàn)的Python要快6倍以上。快的原因是使用了Just-in-Time(JIT)編譯器，即動(dòng)態(tài)編譯器，與靜態(tài)編譯器(如gcc,javac等)不同，它是利用程序運(yùn)行的過(guò)程的數(shù)據(jù)進(jìn)行優(yōu)化。由于歷史原因，目前pypy中還保留著GIL，不過(guò)正在進(jìn)行的STM項(xiàng)目試圖將PyPy變成沒(méi)有GIL的Python。

如果python程序中含有C擴(kuò)展(非cffi的方式)，JIT的優(yōu)化效果會(huì)大打折扣，甚至比CPython慢（比Numpy）。所以在PyPy中最好用純Python或使用cffi擴(kuò)展。

隨著STM，Numpy等項(xiàng)目的完善，相信PyPy將會(huì)替代CPython。

使用性能分析工具

除了上面在ipython使用到的timeit模塊，還有cProfile。cProfile的使用方式也非常簡(jiǎn)單：?python -m cProfile filename.py，filename.py?是要運(yùn)行程序的文件名，可以在標(biāo)準(zhǔn)輸出中看到每一個(gè)函數(shù)被調(diào)用的次數(shù)和運(yùn)行的時(shí)間，從而找到程序的性能瓶頸，然后可以有針對(duì)性地優(yōu)化。

參考

[1]?http://www.ibm.com/developerworks/cn/linux/l-cn-python-optim/

[2]?http://maxburstein.com/blog/speeding-up-your-python-code/

=========================

?

http://code.oneapm.com/python/2015/05/18/python-performance-tips/

原文地址：https://blog.newrelic.com/2015/01/21/python-performance-tips/

Python是一門優(yōu)秀的語(yǔ)言，它能讓你在短時(shí)間內(nèi)通過(guò)極少量代碼就能完成許多操作。不僅如此，它還輕松支持多任務(wù)處理，比如多進(jìn)程。

不喜歡Python的人經(jīng)常會(huì)吐嘈Python運(yùn)行太慢。但是，事實(shí)并非如此。嘗試以下六個(gè)竅門，來(lái)為你的Python應(yīng)用提速。

竅門一：關(guān)鍵代碼使用外部功能包

Python簡(jiǎn)化了許多編程任務(wù)，但是對(duì)于一些時(shí)間敏感的任務(wù)，它的表現(xiàn)經(jīng)常不盡人意。使用C/C++或機(jī)器語(yǔ)言的外部功能包處理時(shí)間敏感任務(wù)，可以有效提高應(yīng)用的運(yùn)行效率。這些功能包往往依附于特定的平臺(tái)，因此你要根據(jù)自己所用的平臺(tái)選擇合適的功能包。簡(jiǎn)而言之，這個(gè)竅門要你犧牲應(yīng)用的可移植性以換取只有通過(guò)對(duì)底層主機(jī)的直接編程才能獲得的運(yùn)行效率。以下是一些你可以選擇用來(lái)提升效率的功能包：

• Cython
• Pylnlne
• PyPy
• Pyrex

這些功能包的用處各有不同。比如說(shuō)，使用C語(yǔ)言的數(shù)據(jù)類型，可以使涉及內(nèi)存操作的任務(wù)更高效或者更直觀。Pyrex就能幫助Python延展出這樣的功能。Pylnline能使你在Python應(yīng)用中直接使用C代碼。內(nèi)聯(lián)代碼是獨(dú)立編譯的，但是它把所有編譯文件都保存在某處，并能充分利用C語(yǔ)言提供的高效率。

竅門二：在排序時(shí)使用鍵

Python含有許多古老的排序規(guī)則，這些規(guī)則在你創(chuàng)建定制的排序方法時(shí)會(huì)占用很多時(shí)間，而這些排序方法運(yùn)行時(shí)也會(huì)拖延程序?qū)嶋H的運(yùn)行速度。最佳的排序方法其實(shí)是盡可能多地使用鍵和內(nèi)置的sort()方法。譬如，拿下面的代碼來(lái)說(shuō)：

import operatorsomelist = [(1, 5, 8), (6, 2, 4), (9, 7, 5)] somelist.sort(key=operator.itemgetter(0)) somelist #Output = [(1, 5, 8), (6, 2, 4), (9, 7, 5)] somelist.sort(key=operator.itemgetter(1)) somelist #Output = [(6, 2, 4), (1, 5, 8), (9, 7, 5)] somelist.sort(key=operator.itemgetter(2)) somelist #Output = [(6, 2, 4), (9, 7, 5), (1, 5, 8)],

在每段例子里，list都是根據(jù)你選擇的用作關(guān)鍵參數(shù)的索引進(jìn)行排序的。這個(gè)方法不僅對(duì)數(shù)值類型有效，還同樣適用于字符串類型。

竅門三：針對(duì)循環(huán)的優(yōu)化

每一種編程語(yǔ)言都強(qiáng)調(diào)最優(yōu)化的循環(huán)方案。當(dāng)使用Python時(shí)，你可以借助豐富的技巧讓循環(huán)程序跑得更快。然而，開(kāi)發(fā)者們經(jīng)常遺忘的一個(gè)技巧是：盡量避免在循環(huán)中訪問(wèn)變量的屬性。譬如，拿下面的代碼來(lái)說(shuō)：

lowerlist = ['this', 'is', 'lowercase'] upper = str.upper upperlist = [] append = upperlist.append for word in lowerlist: append(upper(word)) print(upperlist) #Output = ['THIS', 'IS', 'LOWERCASE']

每次你調(diào)用str.upper, Python都會(huì)計(jì)算這個(gè)式子的值。然而，如果你把這個(gè)求值賦值給一個(gè)變量，那么求值的結(jié)果就能提前知道，Python程序就能運(yùn)行得更快。因此，關(guān)鍵就是盡可能減小Python在循環(huán)中的工作量。因?yàn)镻ython解釋執(zhí)行的特性，在上面的例子中會(huì)大大減慢它的速度。

（注意：優(yōu)化循環(huán)的方法還有很多，這只是其中之一。比如，很多程序員會(huì)認(rèn)為，列表推導(dǎo)式是提高循環(huán)速度的最佳方法。關(guān)鍵在于，優(yōu)化循環(huán)方案是提高應(yīng)用程序運(yùn)行速度的上佳選擇。）

竅門四：使用較新的Python版本

如果你在網(wǎng)上搜索Python，你會(huì)發(fā)現(xiàn)數(shù)不盡的信息都是關(guān)于如何升級(jí)Python版本。通常，每個(gè)版本的Python都會(huì)包含優(yōu)化內(nèi)容，使其運(yùn)行速度優(yōu)于之前的版本。但是，限制因素在于，你最喜歡的函數(shù)庫(kù)有沒(méi)有同步更新支持新的Python版本。與其爭(zhēng)論函數(shù)庫(kù)是否應(yīng)該更新，關(guān)鍵在于新的Python版本是否足夠高效來(lái)支持這一更新。

你要保證自己的代碼在新版本里還能運(yùn)行。你需要使用新的函數(shù)庫(kù)才能體驗(yàn)新的Python版本，然后你需要在做出關(guān)鍵性的改動(dòng)時(shí)檢查自己的應(yīng)用。只有當(dāng)你完成必要的修正之后，你才能體會(huì)新版本的不同。

然而，如果你只是確保自己的應(yīng)用在新版本中可以運(yùn)行，你很可能會(huì)錯(cuò)過(guò)新版本提供的新特性。一旦你決定更新，請(qǐng)分析你的應(yīng)用在新版本下的表現(xiàn)，并檢查可能出問(wèn)題的部分，然后優(yōu)先針對(duì)這些部分應(yīng)用新版本的特性。只有這樣，用戶才能在更新之初就覺(jué)察到應(yīng)用性能的改觀。

竅門五：嘗試多種編碼方法

每次創(chuàng)建應(yīng)用時(shí)都使用同一種編碼方法幾乎無(wú)一例外會(huì)導(dǎo)致應(yīng)用的運(yùn)行效率不盡人意。可以在程序分析時(shí)嘗試一些試驗(yàn)性的辦法。譬如說(shuō)，在處理字典中的數(shù)據(jù)項(xiàng)時(shí)，你既可以使用安全的方法，先確保數(shù)據(jù)項(xiàng)已經(jīng)存在再進(jìn)行更新，也可以直接對(duì)數(shù)據(jù)項(xiàng)進(jìn)行更新，把不存在的數(shù)據(jù)項(xiàng)作為特例分開(kāi)處理。請(qǐng)看下面第一段代碼：

n = 16myDict = {} for i in range(0, n): char = 'abcd'[i%4] if char not in myDict: myDict[char] = 0 myDict[char] += 1 print(myDict)

當(dāng)一開(kāi)始myDict為空時(shí)，這段代碼會(huì)跑得比較快。然而，通常情況下，myDict填滿了數(shù)據(jù)，至少填有大部分?jǐn)?shù)據(jù)，這時(shí)換另一種方法會(huì)更有效率。

n = 16myDict = {} for i in range(0, n): char = 'abcd'[i%4] try: myDict[char] += 1 except KeyError: myDict[char] = 1 print(myDict)

在兩種方法中輸出結(jié)果都是一樣的。區(qū)別在于輸出是如何獲得的。跳出常規(guī)的思維模式，創(chuàng)建新的編程技巧能使你的應(yīng)用更有效率。

竅門六：交叉編譯你的應(yīng)用

開(kāi)發(fā)者有時(shí)會(huì)忘記計(jì)算機(jī)其實(shí)并不理解用來(lái)創(chuàng)建現(xiàn)代應(yīng)用程序的編程語(yǔ)言。計(jì)算機(jī)理解的是機(jī)器語(yǔ)言。為了運(yùn)行你的應(yīng)用，你借助一個(gè)應(yīng)用將你所編的人類可讀的代碼轉(zhuǎn)換成機(jī)器可讀的代碼。有時(shí)，你用一種諸如Python這樣的語(yǔ)言編寫應(yīng)用，再以C++這樣的語(yǔ)言運(yùn)行你的應(yīng)用，這在運(yùn)行的角度來(lái)說(shuō)，是可行的。關(guān)鍵在于，你想你的應(yīng)用完成什么事情，而你的主機(jī)系統(tǒng)能提供什么樣的資源。

Nuitka是一款有趣的交叉編譯器，能將你的Python代碼轉(zhuǎn)化成C++代碼。這樣，你就可以在native模式下執(zhí)行自己的應(yīng)用，而無(wú)需依賴于解釋器程序。你會(huì)發(fā)現(xiàn)自己的應(yīng)用運(yùn)行效率有了較大的提高，但是這會(huì)因平臺(tái)和任務(wù)的差異而有所不同。

（注意：Nuitka現(xiàn)在還處在測(cè)試階段，所以在實(shí)際應(yīng)用中請(qǐng)多加注意。實(shí)際上，當(dāng)下最好還是把它用于實(shí)驗(yàn)。此外，關(guān)于交叉編譯是否為提高運(yùn)行效率的最佳方法還存在討論的空間。開(kāi)發(fā)者已經(jīng)使用交叉編譯多年，用來(lái)提高應(yīng)用的速度。記住，每一種解決辦法都有利有弊，在把它用于生產(chǎn)環(huán)境之前請(qǐng)仔細(xì)權(quán)衡。）

在使用交叉編譯器時(shí)，記得確保它支持你所用的Python版本。Nuitka支持Python2.6, 2.7, 3.2和3.3。為了讓解決方案生效，你需要一個(gè)Python解釋器和一個(gè)C++編譯器。Nuitka支持許多C++編譯器，其中包括Microsoft Visual Studio,MinGW?和?Clang/LLVM。

交叉編譯可能造成一些嚴(yán)重問(wèn)題。比如，在使用Nuitka時(shí)，你會(huì)發(fā)現(xiàn)即便是一個(gè)小程序也會(huì)消耗巨大的驅(qū)動(dòng)空間。因?yàn)镹uitka借助一系列的動(dòng)態(tài)鏈接庫(kù)（DDLs）來(lái)執(zhí)行Python的功能。因此，如果你用的是一個(gè)資源很有限的系統(tǒng)，這種方法或許不太可行。

結(jié)論

前文所述的六個(gè)竅門都能幫助你創(chuàng)建運(yùn)行更有效率的Python應(yīng)用。但是銀彈是不存在的。上述的這些竅門不一定每次都能奏效。在特定的Python的版本下，有的竅門或許比其他的表現(xiàn)更好，但這有時(shí)候甚至取決于平臺(tái)的差異。你需要總結(jié)分析你的應(yīng)用，找到它效率低下的部分，然后嘗試這些竅門，找到解決問(wèn)題的最佳方法。

轉(zhuǎn)載于:https://www.cnblogs.com/zhizhan/p/4883806.html

總結(jié)

以上是生活随笔為你收集整理的提高Python运行效率的六个窍门的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問(wèn)題。

如果覺(jué)得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。