Python實現提高運行速度的技巧分享

更新時間：2023年06月13日 08:53:07 作者：0思必得0

這篇文章主要為大家詳細介紹了Python實現提高運行速度的相關技巧，文中的示例代碼講解詳細，具有一定的參考價值，感興趣的小伙伴可以跟隨小編一起了解一下

提高Python運行速度(大方向)

現在我們已經知曉如何計算Python代碼的運行時間了，接下來就是要想辦法提高Python運行速度。一般要提高Python代碼的運行速度遵循以下幾點：

1.嘗試通過多線程運行

多線程（multithreading），是指從軟件或者硬件上實現多個線程并發(fā)執(zhí)行的技術。具有多線程能力的計算機因有硬件支持而能夠在同一時間執(zhí)行多于一個線程，進而提升整體處理性能。

在一個程序中，這些獨立運行的程序片段叫作“線程”（Thread），利用它編程的概念就叫作“多線程處理”。利用多線程技術可以顯著提高某些特定的代碼運行速度。

現在一般普通的計算機硬件都支持多線程技術，如果一個程序任務可以分解成多線程形式，那么運行速度將會得到極大的提升。
在以后的教程中將會介紹這種技術。

2.優(yōu)化循環(huán)處理

循環(huán)處理是編寫代碼時經常遇到的情況，由于大循環(huán)一般會運行上成千上萬次以上，于是在循環(huán)結構中，每一個小小的代碼片段進行優(yōu)化處理后都將會大大提高代碼的運行速度。

后面將會詳細介紹一些比較實用且常見的優(yōu)化小技巧。

3.使用內置模塊、函數和數據類型

Python內置的模塊和函數是在安裝Python時已經定義和安裝好的，不僅導入方便，而且運行速度要比個人編寫的代碼快很多。

速度對比_內置模塊

from math import factorial
from time import time
from timeit import timeit
def slow(n=100):
    if n == 0 or n == 1:
        return 1
    else:
        return n * slow(n - 1)
def fast():
factorial(100)
b1 = time()
timeit(slow, number=10_0000)
e1 = time()
print(f'函數 slow 運行 10 萬次的時間為：{e1 - b1}')
b2 = time()
timeit(fast, number=10_0000)
e2 = time()
print(f'函數 fast 運行 10 萬次的時間為：{e2 - b2}')

函數 slow 運行 10 萬次的時間為：1.9230999946594238
函數 fast 運行 10 萬次的時間為：0.1594223976135254

速度對比_內置函數

from mdTools import ftDecTimeIt  # 小編自己編寫的一個計時裝飾器
@ftDecTimeIt(100_0000)
def slow():
    new_list = []
    word_list = ["i", "am", "a", "bad", "boy"]
    for word in word_list:
        new_list.append(word.capitalize())
@ftDecTimeIt(100_0000)
def fast():
    word_list = ["i", "am", "a", "bad", "boy"]
new_list = list(map(str.capitalize, word_list))
slow()
fast()

函數 slow 運行 1000000 次的總耗時為：0.9304 秒
函數 fast 運行 1000000 次的總耗時為：0.8292 秒

速度對比_內置方法

from mdTools import ftDecTimeIt
@ftDecTimeIt(100_0000)
def slow():
    new_list = ""
    word_list = ["i", "am", "a", "bad", "boy"]
    for word in word_list:
        new_list += word.capitalize()
@ftDecTimeIt(100_0000)
def fast():
    word_list = ["i", "am", "a", "bad", "boy"]
new_list = ''.join(word_list)
slow()
fast()

函數 slow 運行 1000000 次的總耗時為：1.0097 秒
函數 fast 運行 1000000 次的總耗時為：0.2878 秒

4.使用較新的Python版本

Python版本是在不停迭代更新的，每次更新都會包含優(yōu)化內容，這其中不但會優(yōu)化內置函數、內置方法、更新模塊，增加新的語法、模塊等，還會優(yōu)化運行速度，截止目前，最新的Python11某些方便運行速度相較于舊版本更是提升30%左右。

5.使用lru_cache緩存數據

當你可以把需要計算出來的數據保存下來的時候，千萬不要重復的去計算它。如果你有一個經常需要使用的函數，而且返回的是可預測的結果，最好是能將其緩存到內存中。后續(xù)的函數調用如果是一樣的，將立即返回結果。

Python本地庫functools中的裝飾器：@functools.lru_cache，它就能夠緩存函數最近的調用，當緩存的值在特定時間內保持不變的時候這個非常好用，比如遞歸調用問題。

速度對比_緩存數據

from functools import lru_cache
from time import time
from timeit import timeit
def slow(n=10):
    if n == 1:
        return 1
    if n == 2:
        return 2
    else:
        return slow(n-2) + slow(n-1)
@lru_cache()
def fast(n=10):
    if n == 1:
        return 1
    if n == 2:
        return 2
    else:
        return slow(n - 2) + slow(n - 1)
b1 = time()
timeit(slow, number=10_0000)
e1 = time()
print(f'函數 slow 運行 10 萬次的時間為：{e1 - b1}')
b2 = time()
timeit(fast, number=10_0000)
e2 = time()
print(f'函數 fast 運行 10 萬次的時間為：{e2 - b2}')

函數 slow 運行 10 萬次的時間為：1.344538927078247
函數 fast 運行 10 萬次的時間為：0.007016420364379883

6.使用專門的第三方庫

們都知道，專業(yè)的人做專業(yè)的事，因為他們往往比一般人更了解，也更有經驗，處理起來也更加得心應手。同樣的，在Python編程中，如果有專門的庫，那么處理起來也事半功倍，而且效率也高。

速度對比_numba庫

numba中提供了jit裝飾器，它可以將其裝飾的函數JIT編譯成機器碼函數，并返回一個可在Python中調用機器碼的包裝對象。

from mdTools import ftDecTimeIt
from numba import jit
@ftDecTimeIt(1)
def slow(x=1, y=1_0000_0000):
    s = 0
    for i in range(x, y):
        s += i
return s
@ftDecTimeIt(1)
@jit
def fast(x=1, y=1_0000_0000):
    s = 0
    for i in range(x, y):
        s += i
return s
slow()
fast()

函數 slow 運行 1 次的總耗時為：5.2450 秒
函數 fast 運行 1 次的總耗時為：0.2750 秒

速度對比_numpy庫

果你要處理非常龐大的數據，并且希望能高效的對它們進行計算，那么numpy庫是一個非常好的選擇。numpy在一些關鍵代碼上使用了C來代替，比原生Python更快處理數組，也能更高效的存儲數據。

使用numpy也能更方便也更快的創(chuàng)建出大數據。讓我們來看下面的例子：

from mdTools import ftDecTimeIt
import numpy as np
array = np.random.random(1_0000_0000)
@ftDecTimeIt(1)
def slow():
sum(array)
@ftDecTimeIt(1)
def fast():
np.sum(array)
slow()
fast()