引言

“Python太慢了。”這種觀點在編程語言的討論中頻頻出現(xiàn)，常常使人忽視Python的眾多優(yōu)點。

但事實真的如此嗎？與普遍看法相反，如果你掌握了Python式的編程技巧，Python其實可以像冠軍選手一樣快速奔跑。

在表面之下，精通Python的開發(fā)者們掌握著一系列微妙而強大的技巧，這些技巧能顯著提升他們代碼的性能，遠超常規(guī)水平。這些不僅僅是技巧，它們甚至改變了游戲規(guī)則。

今天，我們將揭示九種變革性的策略，這些策略可以徹底改變你對Python編程的看法。這些策略乍看之下或許很簡單，但它們具有強大的效力，能以你從未想象的方式提升效率。準(zhǔn)備好給你的Python技能加速了嗎？讓我們深入了解并開始優(yōu)化吧！

1.join 或 +：更快的字符串連接

如果你的程序中經(jīng)常進行字符串操作，那么字符串連接可能會成為你的 Python 程序的瓶頸。

基本上，在 Python 中有兩種字符串連接的方法：

• 使用join()函數(shù)將一系列字符串合并為一個
• 使用+或+=符號逐一將每個字符串添加到一個中

那么哪種方法更快？廢話少說，下面我們使用3種不同的方式連接相同的字符串：

str_list = ['Facts', 'speak', 'louder', 'than', 'words!']

# 使用 + 號
def concat_plus(strings):
    result = ''
    for word in strings:
        result += word + ' '
    return result

# 使用 join() 方法
def concat_join(strings):
    return ' '.join(strings)

# 直接連接
def concat_directly():
    return 'Facts' + 'speak' + 'louder' + 'than' + 'words!'

根據(jù)您那作為男士or女士神奇的第六感（????），悄悄告訴我您認(rèn)為哪個函數(shù)速度最快，哪個最慢？實際結(jié)果可能會讓您感到驚訝哦??????：

import timeit

print(f'The plus symbol: {timeit.timeit(concat_plus, number=10000)}')
print(f'The join function: {timeit.timeit(concat_join, number=10000)}')
print(f'The direct concatenation: {timeit.timeit(concat_directly, number=10000)}')

圖片

如上所示，對于字符串連接，join() 方法比通過循環(huán)逐個添加字符串要快。

原因很簡單。一方面，在Python中，字符串是不可變數(shù)據(jù)，每個 += 操作都會伴隨新字符串變量的創(chuàng)建和舊字符串的復(fù)制，這會額外消耗更多的計算資源。另一方面，.join() 方法專門針對連接列表字符串進行了優(yōu)化。它預(yù)先計算生成字符串的大小，然后一次性為其分配存儲空間。因此，它避免了循環(huán)中的 += 操作帶來的開銷，因此更快。

然而，在我們的測試中，最快的函數(shù)是直接連接字符串字面量。其高速度歸結(jié)于：

• Python 解釋器可以在編譯時優(yōu)化字符串字面值的連接，將它們轉(zhuǎn)換為單個字符串字面值。這里沒有涉及到循環(huán)迭代或函數(shù)調(diào)用，因此操作效率非常高。
• 由于在編譯時已知所有字符串，Python 可以非?？焖俚貓?zhí)行此操作，比在循環(huán)中運行時連接甚至優(yōu)化過的 .join() 方法都要快得多。

總之，如果您需要連接字符串列表，請選擇 join() 而不是 +=。如果您想直接連接字符串，只需使用 + 即可。

2.更快的列表創(chuàng)建：選擇“[]”而非“l(fā)ist()”

創(chuàng)建列表并不困難。兩種常見的方法是：

• 使用 list() 函數(shù)
• 直接使用 []：

import timeit

print('The List Creation:')
print(f"[]: {timeit.timeit('[]', number=10 ** 7)}")
print(f'The list function: {timeit.timeit(list, number=10 ** 7)}')

圖片

正如結(jié)果所示，直接使用 [] 比執(zhí)行 list() 函數(shù)要快差不多2倍。這是因為 [] 是一種字面語法，而 list() 是一個構(gòu)造函數(shù)調(diào)用。毫無疑問，調(diào)用函數(shù)需要額外的時間。相同的邏輯，在創(chuàng)建字典時，我們也應(yīng)該利用 {} 而不是 dict()。

3.更快的成員檢查：用 Set 而不用 List

成員檢查操作的性能在很大程度上取決于底層數(shù)據(jù)結(jié)構(gòu)，一起來看看下面這個例子：

import timeit

target_dataset = range(1000000)
search_element = 1314
target_list = list(target_dataset)
target_set = set(target_dataset)

def list_membership_test():
    return search_element in target_list

def set_membership_test():
    return search_element in target_set

print(f'The list membership test: {timeit.timeit(list_membership_test, number=1000)}')
print(f'The set membership test: {timeit.timeit(set_membership_test, number=1000)}')

圖片

結(jié)果顯示，在集合中進行成員檢查比在列表中快得多。我還發(fā)現(xiàn)一個問題，那就是搜索的元素越靠前則耗時越短，如果搜索一個不存在的元素則耗時最長。上面我們搜索的目標(biāo)元素是1314，如果我們搜索一個不存在的元素1314520，則明顯耗時更多：

圖片

因為搜索一個不存在的元素必須遍歷完整個列表或集合。By the way，從這個例子可以看出要做到一生一世（1314）很容易，因為每個人生來便有，但是要做到一生一世我愛你（1314520）卻并不簡單，因為需要付出更多的代價。哈哈??????，開個玩笑，扯遠了，權(quán)當(dāng)是給您枯燥的閱讀帶來一點小樂趣！

回到主題，為什么成員檢查用集合比列表更快呢？

• 在Python列表中，成員檢查（element in list）是通過迭代每個元素直到找到所需元素或達到列表末尾來執(zhí)行的。因此，這個操作的時間復(fù)雜度為O(n)。
• 在Python中，集合用哈希表實現(xiàn)。在檢查成員關(guān)系（element in set）時，Python使用哈希機制，其時間復(fù)雜度平均為O(1)。

這里的要點是在編寫程序時仔細考慮底層數(shù)據(jù)結(jié)構(gòu)。利用正確的數(shù)據(jù)結(jié)構(gòu)可以顯著加快我們的代碼速度。

4.更快的數(shù)據(jù)生成：用推導(dǎo)式而不用 for 循環(huán)

Python 中有四種推導(dǎo)式：列表、字典、集合和生成器。它們不僅提供更簡潔的語法來創(chuàng)建相關(guān)的數(shù)據(jù)結(jié)構(gòu)，而且比使用 for 循環(huán)的性能更好。因為它們使用 C 語言實現(xiàn)的，性能進行了優(yōu)化。

一起看看下面這個生成1-10000的立方示例：

import timeit

def generate_cubes_for_loop():
    cubes = []
    for i in range(10000):
        cubes.append(i * i * i)
    return cubes

def generate_cubes_comprehension():
    return [i * i * i for i in range(10000)]

print(f'For loop: {timeit.timeit(generate_cubes_for_loop, number=10000)}')
print(f'Comprehension: {timeit.timeit(generate_cubes_comprehension, number=10000)}')

上述代碼只是列表推導(dǎo)式和 for 循環(huán)之間的簡單速度比較。正如如結(jié)果所示，列表推導(dǎo)式更快。

5.更快的循環(huán)：優(yōu)先用局部變量

在Python中，訪問局部變量比訪問全局變量或?qū)ο髮傩砸?。這里用一個簡單例子來證明這一點：

import timeit

class Test:
    def __init__(self):
        self.value = 0
        
obj = Test()

def access_global_variable():
    for _ in range(1000):
        obj.value += 1
        
def access_local_variable():
    value = obj.value
    for _ in range(1000):
        value += 1
        
print(f'Access global variable: {timeit.timeit(access_global_variable, number=1000)}')
print(f'Access local variable: {timeit.timeit(access_local_variable, number=1000)}')

這就是 Python 的工作原理。直觀地說，當(dāng)函數(shù)編譯時，其中的局部變量是已知的，但其他外部變量則需要時間來檢索。

這只是一個很小的改良，但有時候我們?nèi)笨梢岳盟鼇韮?yōu)化我們的代碼，特別是在處理大數(shù)據(jù)集時。

6.更快的執(zhí)行：優(yōu)先使用內(nèi)置模塊和庫

當(dāng)工程師們說 Python 時，默認(rèn)是指 CPython。因為 CPython 是 Python 語言的默認(rèn)和最廣泛使用的實現(xiàn)。

考慮到大多數(shù)內(nèi)置模塊和庫都是用更快速和更底層的語言 C 編寫的，我們應(yīng)該盡可能利用這些內(nèi)置工具并避免重復(fù)發(fā)明輪子。

import timeit
import random
from collections import Counter

def counter_custom(lst):
    frequency = {}
    for item in lst:
        if item in frequency:
            frequency[item] += 1
        else:
            frequency[item] = 1
    return frequency

def counter_builtin(lst):
    return Counter(lst)

target_dataset = [random.randint(0, 100) for _ in range(1000)]
print(f'Counter custom: {timeit.timeit(lambda: counter_custom(target_dataset), number=100)}')
print(f'Counter builtin: {timeit.timeit(lambda: counter_custom(target_dataset), number=100)}')

這里比較了在列表中計算元素頻率的兩種方法。正如我們所看到的，利用 collections 模塊中的內(nèi)置 Counter 比自己編寫 for 循環(huán)更快，更整潔，更好（但有時候自定義的性能又會比內(nèi)置模塊更好，尚不知道原因）。

7.更快的函數(shù)調(diào)用：利用緩存裝飾器

緩存是一種常用的技術(shù)，用于避免重復(fù)計算并加快程序的運行速度。幸運的是，在大多數(shù)情況下，我們不需要編寫自己的緩存處理代碼，因為Python提供了一個用于此目的的開箱即用的裝飾器 — @functools.cache。

例如，以下代碼將執(zhí)行兩個斐波那契數(shù)生成函數(shù)，一個帶有緩存裝飾器，而另一個沒有：

import timeit
from functools import cache

def fibonacci_norm(n):
    if n <= 1:
        return n
    return fibonacci_norm(n - 1) + fibonacci_norm(n - 2)

@cache
def fibonacci_cached(n):
    if n <= 1:
        return n
    return fibonacci_cached(n - 1) + fibonacci_cached(n - 2)

print(f'fibonacci normal: {timeit.timeit(lambda: fibonacci_norm(30), number=1)}')
print(f'fibonacci cached: {timeit.timeit(lambda: fibonacci_cached(30), number=1)}')

結(jié)果顯示 cache 裝飾器版本比普通版本的速度快得多。

普通的斐波那契函數(shù)效率低下，因為在獲取 fibonacci(30) 的結(jié)果過程中，它多次重新計算相同的斐波那契數(shù)。

緩存版本明顯更快，因為它緩存了先前計算的結(jié)果。因此，每個斐波那契數(shù)它只計算一次，并且使用相同參數(shù)進行的后續(xù)調(diào)用都從緩存中獲取。

僅僅添加一個內(nèi)置裝飾器就可以帶來如此大的性能提升，這就是 Pythonic 的意義所在。??

8.更快的無限循環(huán): 優(yōu)先選擇“while 1”而不是“while True”

要創(chuàng)建一個無限循環(huán)，我們可以使用 while True 或 while 1 。它們的性能差異通常是可以忽略的。但有趣的是 while 1 稍微更快。這源于 1 是字面值，而 True 是 Python 全局范圍內(nèi)需要查找的全局名稱，因此需要微小的額外開銷。

我們也通過一個簡單的示例比較這兩種方式的性能:

import timeit

def infinite_loop_with_true():
    result = 0
    while True:
        if result >= 10000:
            break
        result += 1
        
def infinite_loop_with_one():
    result = 0
    while 1:
        if result >= 10000:
            break
        result += 1
        
print(f'Infinite loop with true: {timeit.timeit(infinite_loop_with_true, number=10000)}')
print(f'Infinite loop with one: {timeit.timeit(infinite_loop_with_one, number=10000)}')

正如我們所看到的，while 1 確實略快。但是，現(xiàn)代 Python 解釋器（如CPython）經(jīng)過高度優(yōu)化，這樣的差異通常微不足道。因此，我們無需在意這種微不足道的差異。另外，從代碼可讀性角度來說，其實 while True 的可讀性比 while 1 更強。

9.更快的腳本啟動：智能導(dǎo)入Python模塊

通常情況下，我們都習(xí)慣在Python 腳本頂部導(dǎo)入所有模塊。事實上，有些時候不必這樣做。此外，如果模塊太大，則按需導(dǎo)入可能會是一個更好的主意。比如，在用到模塊的函數(shù)內(nèi)部導(dǎo)入：

def target_function():
    import specific_module
    # rest of the function

如上面的代碼所示，specific_module 在函數(shù)內(nèi)部執(zhí)行導(dǎo)入操作。這是“惰性加載”的思想，在函數(shù)調(diào)用時才導(dǎo)入指定模塊。

這種方法的好處是，如果在腳本執(zhí)行期間從未調(diào)用 target_function，則永遠不會加載 specific_module，從而節(jié)省資源并減少腳本的啟動時間。