提升Python的執行效率的技巧有哪些

今天小編給大家分享一下提升Python的執行效率的技巧有哪些的相關知識點，內容詳細，邏輯清晰，相信大部分人都還太了解這方面的知識，所以分享這篇文章給大家參考一下，希望大家閱讀完這篇文章后有所收獲，下面我們一起來了解一下吧。

開始之前小伙伴先可以開發一個統計函數運行時間的python裝飾器用于后面我們對各個python技巧使用后的時間統計。

# 導入時間提取的time模塊
from time import time

import dis


def compute_time(func_):
    '''
    計算函數的運行時間
    '''

    def func_time(*arg, **kw):
        t1 = time()
        result = func_(*arg, **kw)
        t2 = time()
        print(f"{func_.__name__: >10} : {t2 - t1:.6f} 秒")
        return result

    return func_time

上述的compute_time時間計算函數我們開發好了，可以開發一個hello_world函數測試一下使用是否正常。

@compute_time
def hello_world():
    print("hello_world!")


hello_world()

# hello_world!
# hello_world : 0.000000 秒

通過hello_world函數的測試，證明我們的時間裝飾器compute_time能夠正常統計出函數所運行的時間。

接下來，我們開始正式的介紹下面的五種方式來提高python的運行速度并提供時間運行的結果。

1、合理使用標準或非標準庫

在開發過程中絕對不能小看python的標準或非標準庫，說實話我們自己有時候寫的同樣的業務代碼塊確實是沒有大佬們完美。

比如下面這個業務我們需要將一個python列表中的值轉換成字符串，首先看看下面的代碼塊的寫法。

# 初始化一個list列表
list_ = ['a', 'b', 'c'] * 10000


@compute_time
def func_1(list_=None):
    '''
    列表元素轉字符串函數
    '''
    str_ = ''
    for s in list_:
        str_ = str_ + s
    return str_


func_1(list_)


# func_1 : 0.001999 秒

通過上面的func_1函數的執行情況使用自己寫的傳統的方式來轉換步驟比較繁雜，并且花費了0.001999 秒的時間。

@compute_time
def func_2(list_=None):
    '''
    列表元素轉字符串
    '''
    return ''.join(list_)


func_2(list_)

# func_2 : 0.000000 秒

相比func_1函數的運行時間，func_2運行的時間幾乎可以忽略不計，六位數的小數根本看不出來變化。

2、減少循環的使用

從平常開發的過程中其實已經發現，使用列表推導式、迭代式等的可序列化數據處理方式要比for循環更加的便捷、高效。

下面我們同樣可以通過一個例子來說明問題，比如我們需要挑選出一個list列表中可以被2整除的數。

# 初始化循環次數n
n = 100000


@compute_time
def func_3(n=None):
    list_ = []
    for m in range(n):
        if m % 2 == 0:
            list_.append(m)
    return list_


@compute_time
def func_4(n=None):
    return [m for m in range(n) if m % 2 == 0]


func_3(n)

func_4(n)

# func_3 : 0.004986 秒
# func_4 : 0.003014 秒

通過func_3函數、func_4函數的比較，首先func_4的方式比func_3精簡了許多。

并且時間上func_4使用列表推導式的方式比普通的for循環運行速度上快了1/4的時間。

3、注意重復代碼運行

關于代碼的重復運行這個在我們通常的開發方式中都能體會到，也就是本可以作為公共代碼塊運行一次就可以。

可以卻將能夠公共使用的代碼塊加入到了循環當中，這樣只會影響代碼塊的執行效率。

比如我們需要使用python的re模塊去搜索字符串中的某一些元素，下面通過兩種方式來比較時間結果。

# 導入正則表達式匹配模塊
import re


@compute_time
def func_5(str_=None):
    for s in str_:
        result = re.search(r'a*[a-z]?c', s)


@compute_time
def func_6(str_=None):
    repx = re.compile(r'a*[a-z]?c')
    for s in str_:
        result = repx.search(s)


func_5('abcdefg1234oks' * 1000)

func_6('abcdefg1234oks' * 1000)

# func_5 : 0.006999 秒
# func_6 : 0.002000 秒

對比func_5和func_6的業務實現方式，我們將re模塊的compile正則匹配對象直接放到for循環的外層，運行時間直接就減少了3倍不止。

是因為在循環中直接使用search匹配正則對象，會在循環中不斷地創建正則匹配對象，這樣就
增加了for循環的處理負擔，導致速度變慢。

4、減少全局變量使用

在說明這一點的時候，我們要明白全局變量在程序運行的過程中是一直存在的不會消失。

全局變量太多就會導致運行期間占用的內存太大，相比全局變量使用局部變量就會變得更加的高效。

下面我們通過兩種方式的使用實例，來對比全局變量和局部變量的運行時間。

mes_1 = 'ss1'

mes_2 = 'ss2'

mes_3 = 'ss3'


@compute_time
def func_7():
    result = mes_1 + mes_2 + mes_3
    return result


@compute_time
def func_8():
    me_1 = 'ss1'
    me_2 = 'ss2'
    me_3 = 'ss3'
    result = me_1 + me_2 + me_3
    return result


func_7()

func_8()


# func_7 : 0.000997 秒
# func_8 : 0.000000 秒

上面我們做了一個普通的加法計算已經說明了問題，func_8函數使用局部變量的方式確實速度更快。

5、使用合理的數據結構

在大多數的python開發過程中，想必很多人都是為了方便更多的時候使用的是list列表的方式來處理數據。

Python 有四種內置的數據結構：列表、元組、集合、字典，在合適的業務場景中使用合適的數據結構來處理數據同樣能提高計算的執行效率。

比如：下面我們將從一個list列表和tuple元組來提取對應索引位置上面的值。

@compute_time
def func_9():
    data = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
    print(data[3])


@compute_time
def func_10():
    data = ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h')
    print(data[3])

func_9()

func_10()

# func_9 : 0.000000 秒
# func_10 : 0.000000 秒

通過執行func_9和func_10函數，我們發現時間上兩者的差距不大，起碼在六位小數之內是分辨不出結果的。

print('func_9匯編產生的機器碼：')
dis.dis(func_9)

print('func_10匯編產生的機器碼：')
dis.dis(func_10)

最后，我們分別查看了func_9和func_10的匯編機器碼，發現明顯list列表處理產生的機器碼更多。

# func_9匯編產生的機器碼：
#  30           0 LOAD_GLOBAL              0 (time)
#               2 CALL_FUNCTION            0
#               4 STORE_FAST               2 (t1)
#
#  31           6 LOAD_DEREF               0 (func_)
#               8 LOAD_FAST                0 (arg)
#              10 LOAD_FAST                1 (kw)
#              12 CALL_FUNCTION_EX         1
#              14 STORE_FAST               3 (result)
#
#  32          16 LOAD_GLOBAL              0 (time)
#              18 CALL_FUNCTION            0
#              20 STORE_FAST               4 (t2)
#
#  33          22 LOAD_GLOBAL              1 (print)
#              24 LOAD_DEREF               0 (func_)
#              26 LOAD_ATTR                2 (__name__)
#              28 LOAD_CONST               1 (' >10')
#              30 FORMAT_VALUE             4 (with format)
#              32 LOAD_CONST               2 (' : ')
#              34 LOAD_FAST                4 (t2)
#              36 LOAD_FAST                2 (t1)
#              38 BINARY_SUBTRACT
#              40 LOAD_CONST               3 ('.6f')
#              42 FORMAT_VALUE             4 (with format)
#              44 LOAD_CONST               4 (' 秒')
#              46 BUILD_STRING             4
#              48 CALL_FUNCTION            1
#              50 POP_TOP
#
#  34          52 LOAD_FAST                3 (result)
#              54 RETURN_VALUE
# func_10匯編產生的機器碼：
#  30           0 LOAD_GLOBAL              0 (time)
#               2 CALL_FUNCTION            0
#               4 STORE_FAST               2 (t1)
#
#  31           6 LOAD_DEREF               0 (func_)
#               8 LOAD_FAST                0 (arg)
#              10 LOAD_FAST                1 (kw)
#              12 CALL_FUNCTION_EX         1
#              14 STORE_FAST               3 (result)

以上就是“提升Python的執行效率的技巧有哪些”這篇文章的所有內容，感謝各位的閱讀！相信大家閱讀完這篇文章都有很大的收獲，小編每天都會為大家更新不同的知識，如果還想學習更多的知識，請關注億速云行業資訊頻道。