Apakah teknik untuk meningkatkan kecekapan pelaksanaan Python?

Sebelum bermula, anda boleh membangunkan penghias ular sawa yang mengira masa berjalan fungsi, yang akan digunakan kemudian untuk statistik masa selepas kami menggunakan pelbagai teknik ular sawa.

# 导入时间提取的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

Kami telah membangunkan fungsi pengiraan masa pengiraan di atas Kami boleh membangunkan fungsi hello_world untuk menguji sama ada ia digunakan secara normal.

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


hello_world()

# hello_world!
# hello_world : 0.000000 秒

Melalui ujian fungsi hello_world, terbukti bahawa penghias masa kita mengira_masa biasanya boleh mengira masa berjalan fungsi tersebut.

Seterusnya, kami mula memperkenalkan secara rasmi lima cara berikut untuk meningkatkan kelajuan larian python dan memberikan hasil larian masa.

1. Penggunaan perpustakaan standard atau bukan standard yang munasabah

Semasa proses pembangunan, anda tidak boleh memandang rendah perpustakaan standard atau bukan standard python Sejujurnya, kami kadangkala menulis perniagaan yang sama kod menyekat diri kita Memang benar bahawa tidak ada kesempurnaan seperti orang besar.

Sebagai contoh, dalam perniagaan berikut, kita perlu menukar nilai dalam senarai ular sawa kepada rentetan Pertama, lihat bagaimana blok kod berikut ditulis.

# 初始化一个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 秒

Menggunakan kaedah tradisional yang ditulis oleh saya sendiri untuk menukar langkah-langkah melalui pelaksanaan fungsi func_1 di atas adalah rumit dan mengambil masa 0.001999 saat.

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


func_2(list_)

# func_2 : 0.000000 秒

Berbanding dengan masa berjalan fungsi func_1, masa berjalan func_2 hampir boleh diabaikan, dan perpuluhan enam digit tidak dapat melihat perubahan sama sekali.

2. Kurangkan penggunaan gelung

Daripada proses pembangunan biasa, kami sebenarnya telah mendapati bahawa kaedah pemprosesan data boleh bersiri menggunakan terbitan senarai, lelaran, dll. adalah lebih mudah daripada untuk gelung , cekap .

Di bawah ini kita juga boleh menggunakan contoh untuk menggambarkan masalah Sebagai contoh, kita perlu memilih nombor dalam senarai yang boleh dibahagikan dengan 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 秒

Melalui perbandingan fungsi func_3 dan fungsi func_4, pertama sekali, kaedah func_4 jauh lebih mudah daripada func_3.

Dan dari segi masa, func_4 menggunakan terbitan senarai untuk menjalankan 1/4 lebih pantas daripada gelung biasa.

3 Beri perhatian kepada kod berulang yang dijalankan

Berkenaan menjalankan kod berulang, kita semua boleh mengalami ini dalam kaedah pembangunan biasa kita, iaitu, ia boleh dijalankan sekali sebagai kod awam blok.

Anda boleh menambah blok kod yang boleh digunakan secara terbuka ke dalam gelung, yang hanya akan menjejaskan kecekapan pelaksanaan blok kod.

Sebagai contoh, kita perlu menggunakan modul semula python untuk mencari elemen tertentu dalam rentetan Berikut ialah dua cara untuk membandingkan hasil masa.

# 导入正则表达式匹配模块
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 秒

Membandingkan kaedah pelaksanaan perniagaan func_5 dan func_6, kami meletakkan objek pemadanan biasa kompilasi modul semula terus ke lapisan luar gelung for, dan masa berjalan dikurangkan secara langsung lebih daripada 3 kali ganda .

adalah kerana menggunakan carian untuk memadankan objek biasa secara terus dalam gelung akan terus mencipta objek padanan biasa dalam gelung, yang
meningkatkan beban pemprosesan gelung for dan menyebabkan kelajuan menjadi perlahan.

4. Kurangkan penggunaan pembolehubah global

Apabila menerangkan perkara ini, kita mesti faham bahawa pembolehubah global sentiasa wujud dan tidak akan hilang semasa program dijalankan.

Terlalu banyak pembolehubah global akan menyebabkan terlalu banyak memori akan diduduki semasa operasi Ia akan menjadi lebih cekap untuk menggunakan pembolehubah tempatan berbanding dengan pembolehubah global.

Di bawah ini kami menggunakan contoh dua kaedah untuk membandingkan masa berjalan pembolehubah global dan pembolehubah tempatan.

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 秒

Kami telah melakukan pengiraan penambahan biasa di atas untuk menggambarkan masalah Cara fungsi func_8 menggunakan pembolehubah tempatan sememangnya lebih pantas.

5 Gunakan struktur data yang munasabah

Dalam kebanyakan proses pembangunan Python, ramai orang mesti menggunakan senarai untuk memproses data untuk kemudahan.

Python mempunyai empat struktur data terbina dalam: senarai, tupel, set dan kamus Menggunakan struktur data yang sesuai untuk memproses data dalam senario perniagaan yang sesuai juga boleh meningkatkan kecekapan pelaksanaan pengiraan.

Contohnya: di bawah kami akan mengekstrak nilai pada kedudukan indeks yang sepadan daripada senarai senarai dan tuple 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 秒

Dengan melaksanakan fungsi func_9 dan func_10, kami mendapati bahawa perbezaan masa antara keduanya tidaklah besar, sekurang-kurangnya hasilnya tidak dapat dibezakan dalam enam tempat perpuluhan.

print('func_9汇编产生的机器码：')
dis.dis(func_9)

print('func_10汇编产生的机器码：')
dis.dis(func_10)

Akhir sekali, kami melihat pada kod mesin pemasangan masing-masing func_9 dan func_10, dan mendapati bahawa pemprosesan senarai jelas menghasilkan lebih banyak kod mesin.

Atas ialah kandungan terperinci Apakah teknik untuk meningkatkan kecekapan pelaksanaan Python?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!