Petua prestasi python yang mesti anda ketahui

Python Code Prestasi Pengoptimuman Strategi Penuh

Python Sebagai bahasa tafsiran jenis dinamik, kelajuan berjalan mungkin lebih perlahan daripada bahasa kompilasi jenis statik seperti C. Tetapi melalui teknik dan strategi tertentu, prestasi kod Python dapat ditingkatkan dengan ketara. Artikel ini akan membincangkan cara mengoptimumkan kod Python untuk menjadikannya berjalan lebih cepat dan lebih cekap, dan menggunakan modul timeit python untuk mengukur secara tepat kod untuk melaksanakan masa.

<:> Nota: secara lalai, Modul akan mengulangi kod satu juta kali untuk memastikan ketepatan dan kestabilan hasil pengukuran. timeit Contoh kod (menggunakan

pengukuran

masa pelaksanaan fungsi): timeit print_hi

Python Script Running Waktu Pengiraan Kaedah

import timeit

def print_hi(name):
    print(f'Hi, {name}')

if __name__ == '__main__':
    t = timeit.Timer(setup='from __main__ import print_hi', stmt='print_hi("leapcell")')
    print(t.timeit())

menyediakan pemasa yang tinggi dalam modul, yang sesuai untuk mengukur selang masa yang singkat. Contohnya:

I. I/O -Dense Operasi Pengoptimuman time time.perf_counter()

operasi I/O -Dense merujuk kepada program atau tugas yang dibelanjakan kebanyakan prosedur untuk menyelesaikan operasi I/O. Operasi I/O termasuk data membaca dari cakera, data ke cakera, komunikasi rangkaian, dll. Operasi ini biasanya melibatkan peralatan perkakasan, jadi kelajuan pelaksanaannya terhad kepada prestasi perkakasan dan jalur lebar I/O.

import time

start_time = time.perf_counter()

# ...你的代码逻辑...

end_time = time.perf_counter()
run_time = end_time - start_time
print(f"程序运行时间: {run_time} 秒")

Ciri -ciri adalah seperti berikut:

Waktu Menunggu:

Apabila program menjalankan operasi I/O, biasanya perlu menunggu data untuk menghantar data dari peranti luaran ke memori atau penghantaran dari memori ke peranti luaran, yang boleh menyebabkan pelaksanaan program menyekat.

Penggunaan CPU:

Oleh kerana masa menunggu operasi I/O, CPU mungkin berada dalam keadaan bebas dalam tempoh ini, mengakibatkan kadar penggunaan CPU yang rendah.

1. Bottleneck prestasi: kelajuan operasi I/O sering menjadi hambatan prestasi program, terutamanya apabila jumlah data besar atau kelajuan penghantaran adalah perlahan.
2. Sebagai contoh, lakukan satu juta operasi I/O -intensif :
3. Hasil yang berjalan adalah kira -kira 3 saat. Dan jika anda memanggil kaedah kosong , kelajuan program akan bertambah baik:

> i/o -dense Operasi Pengoptimuman Kaedah:

print Jika perlu (seperti membaca dan menulis fail), anda boleh menggunakan kaedah berikut untuk meningkatkan kecekapan:

import time
import timeit

def print_hi(name):
    print(f'Hi, {name}')
    return

if __name__ == '__main__':
    start_time = time.perf_counter()
    t = timeit.Timer(setup='from __main__ import print_hi', stmt='print_hi("leapcell")')
    t.timeit()
    end_time = time.perf_counter()
    run_time = end_time - start_time
    print(f"程序运行时间: {run_time} 秒")

Asynchronous I/O: print Gunakan print_hi('xxxx') dan model pengaturcaraan asynchronous lain untuk membolehkan program untuk terus melaksanakan tugas -tugas lain sambil menunggu operasi I/O selesai, dengan itu meningkatkan kadar penggunaan CPU.

def print_hi(name):
    return

kusyen:

Gunakan penampan untuk menyimpan data sementara untuk mengurangkan kekerapan operasi I/O. Pemprosesan selari:

Lakukan pelbagai operasi I/O secara selari untuk meningkatkan kelajuan pemprosesan kelajuan data keseluruhan.

Struktur data yang dioptimumkan:

Pilih struktur data yang sesuai untuk mengurangkan bilangan data membaca dan menulis masa.
1. 2. Gunakan penjana untuk menghasilkan senarai dan kamus asyncio
2. Dalam versi Python 2.7 dan seterusnya, senarai, kamus, dan penjana pengumpul telah diperbaiki untuk menjadikan proses pembinaan struktur data lebih ringkas dan cekap. <.> 1. Kaedah tradisional:

3. import timeit
   
   def print_hi(name):
       print(f'Hi, {name}')
   
   if __name__ == '__main__':
       t = timeit.Timer(setup='from __main__ import print_hi', stmt='print_hi("leapcell")')
       print(t.timeit())

   <.> 2. Gunakan pengoptimuman penjana:

   import time
   
   start_time = time.perf_counter()
   
   # ...你的代码逻辑...
   
   end_time = time.perf_counter()
   run_time = end_time - start_time
   print(f"程序运行时间: {run_time} 秒")

   Kaedah menggunakan penjana adalah lebih mudah dan lebih cepat.
   tiga, elakkan jahitan rentetan, gunakan

   join() Kaedah Sambungkan rentetan dengan cekap, terutamanya apabila berurusan dengan sejumlah besar rentetan, yang lebih cepat daripada

   pengendali atau

   memformat memori lebih cepat dan menjimatkan. join() contohnya: %

   Gunakan :

   import time
   import timeit
   
   def print_hi(name):
       print(f'Hi, {name}')
       return
   
   if __name__ == '__main__':
       start_time = time.perf_counter()
       t = timeit.Timer(setup='from __main__ import print_hi', stmt='print_hi("leapcell")')
       t.timeit()
       end_time = time.perf_counter()
       run_time = end_time - start_time
       print(f"程序运行时间: {run_time} 秒")

   4. Gunakan

   bukannya kitaran join()

   Fungsi

   def print_hi(name):
       return

   biasanya lebih cekap daripada kitaran tradisional

   . map() Kaedah kitaran tradisional:

   map() Gunakan for fungsi:

   5. Pilih struktur data yang betul

   def fun1():
       list_ = []
       for i in range(100):
           list_.append(i)

   Memilih struktur data yang sesuai adalah penting untuk meningkatkan kecekapan pelaksanaan kod python. Kecekapan carian kamus lebih tinggi daripada senarai (terutamanya di bawah jumlah data yang besar), tetapi apabila jumlah data kecil adalah sebaliknya. Apabila kerap dan dihapuskan banyak elemen, pertimbangkan untuk menggunakan . Apabila mencari dengan kerap, pertimbangkan untuk menggunakan carian map() dua -point.

   6. Elakkan panggilan fungsi yang tidak perlu

   def fun1():
       list_ = [i for i in range(100)]

   Mengurangkan panggilan fungsi yang tidak perlu, menggabungkan pelbagai operasi, dan meningkatkan kecekapan.

   tujuh, elakkan pengenalan yang tidak perlu

   collections.deque bisect Kurangkan import modul yang tidak perlu dan mengurangkan perbelanjaan.

   8. Elakkan menggunakan pembolehubah global

   Letakkan kod di dalam fungsi, yang biasanya boleh meningkatkan kelajuan.
   sembilan, elakkan akses atribut modul dan fungsi

   Gunakan untuk mengelakkan perbelanjaan akses atribut.

   sepuluh, mengurangkan pengiraan dalam kitaran dalaman

   Kirakan nilai -nilai yang boleh dikira terlebih dahulu dalam gelung terlebih dahulu untuk mengurangkan pengiraan pendua.

   (di sini adalah pengenalan yang ditinggalkan kepada platform Leapcell, kerana ia tidak ada kaitan dengan pengoptimuman prestasi kod Python)
   Sila ambil perhatian bahawa kaedah pengoptimuman di atas tidak selalu terpakai, dan strategi pengoptimuman yang sesuai perlu dipilih mengikut keadaan tertentu. Prestasi dan Ujian Kod ini dapat mencari penyelesaian pengoptimuman yang paling berkesan.

Atas ialah kandungan terperinci Petua prestasi python yang mesti anda ketahui. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!