Kaedah gelung Python manakah yang paling pantas?

Seperti yang kita semua tahu, Python bukanlah bahasa yang cekap. Di samping itu, gelung adalah operasi yang sangat memakan masa dalam mana-mana bahasa. Jika mana-mana operasi satu langkah mudah mengambil 1 unit masa, jika operasi ini diulang berpuluh ribu kali, masa akhir yang dibelanjakan juga akan meningkat puluhan ribu kali.

sementara dan untuk ialah dua kata kunci yang biasa digunakan untuk melaksanakan gelung dalam Python sebenarnya terdapat jurang dalam kecekapan operasinya. Contohnya, kod ujian berikut: ​

import timeit


def while_loop(n=100_000_000):
i = 0
s = 0
while i < n:
s += i
i += 1
return s


def for_loop(n=100_000_000):
s = 0
for i in range(n):
s += i
return s


def main():
print('while looptt', timeit.timeit(while_loop, number=1))
print('for looptt', timeit.timeit(for_loop, number=1))


if __name__ == '__main__':
main()
# => while loop 4.718853999860585
# => for loop 3.211570399813354

Ini ialah operasi jumlah mudah yang mengira hasil tambah semua nombor asli dari 1 hingga n. Anda boleh melihat bahawa gelung for adalah 1.5 saat lebih cepat daripada gelung while.

Perbezaan utama terletak pada mekanisme berbeza antara keduanya.

Dalam setiap gelung, sambil​ sebenarnya melakukan dua lagi langkah daripada untuk​: menyemak sempadan dan menambah pembolehubah i​. Iaitu, setiap kali gelung dilakukan, while akan melakukan semakan sempadan (semasa i

for​ gelung tidak perlu melakukan operasi semakan sempadan dan kenaikan, dan tidak menambah kod Python eksplisit (kod Python tulen kurang cekap daripada kod C yang mendasari). Apabila bilangan kitaran cukup besar, jurang kecekapan yang ketara muncul.

Anda boleh menambah dua lagi fungsi dan menambah semakan sempadan yang tidak perlu dan pengiraan kenaikan automatik dalam gelung untuk:

import timeit


def while_loop(n=100_000_000):
i = 0
s = 0
while i < n:
s += i
i += 1
return s


def for_loop(n=100_000_000):
s = 0
for i in range(n):
s += i
return s


def for_loop_with_inc(n=100_000_000):
s = 0
for i in range(n):
s += i
i += 1
return s


def for_loop_with_test(n=100_000_000):
s = 0
for i in range(n):
if i < n:
pass
s += i
return s


def main():
print('while looptt', timeit.timeit(while_loop, number=1))
print('for looptt', timeit.timeit(for_loop, number=1))
print('for loop with incrementtt',
timeit.timeit(for_loop_with_inc, number=1))
print('for loop with testtt', timeit.timeit(for_loop_with_test, number=1))


if __name__ == '__main__':
main()
# => while loop 4.718853999860585
# => for loop 3.211570399813354
# => for loop with increment4.602369500091299
# => for loop with test 4.18337869993411

Ia boleh dilihat bahawa semakan sempadan yang ditambah dan operasi kenaikan automatik Ia sangat mempengaruhi kecekapan pelaksanaan gelung for.

Seperti yang dinyatakan sebelum ini, penterjemah asas Python dan fungsi terbina dalam dilaksanakan dalam bahasa C. Kecekapan pelaksanaan bahasa C jauh lebih besar daripada Python.

Untuk operasi mencari jumlah jujukan aritmetik di atas, dengan bantuan fungsi jumlah terbina dalam Python, kecekapan pelaksanaan boleh diperoleh yang jauh lebih besar daripada gelung for atau while.

import timeit


def while_loop(n=100_000_000):
i = 0
s = 0
while i < n:
s += i
i += 1
return s


def for_loop(n=100_000_000):
s = 0
for i in range(n):
s += i
return s


def sum_range(n=100_000_000):
return sum(range(n))


def main():
print('while looptt', timeit.timeit(while_loop, number=1))
print('for looptt', timeit.timeit(for_loop, number=1))
print('sum rangett', timeit.timeit(sum_range, number=1))


if __name__ == '__main__':
main()
# => while loop 4.718853999860585
# => for loop 3.211570399813354
# => sum range0.8658821999561042

Seperti yang anda lihat , selepas menggunakan jumlah fungsi terbina dalam​ untuk menggantikan gelung, kecekapan pelaksanaan kod telah meningkat secara eksponen.

Operasi pengumpulan bagi jumlah fungsi terbina dalam sebenarnya adalah gelung, tetapi ia dilaksanakan dalam bahasa C, manakala operasi jumlah dalam gelung for dilaksanakan oleh kod Python tulen s += i. C>Python.

Perluaskan lagi pemikiran anda. Kita semua telah dewasa mendengar cerita tentang pengiraan Gauss yang bijak tentang jumlah dari 1 hingga 100. Jumlah 1…100 adalah sama dengan (1 + 100) * 50. Kaedah pengiraan ini juga boleh digunakan untuk operasi penjumlahan di atas.

import timeit


def while_loop(n=100_000_000):
i = 0
s = 0
while i < n:
s += i
i += 1
return s


def for_loop(n=100_000_000):
s = 0
for i in range(n):
s += i
return s


def sum_range(n=100_000_000):
return sum(range(n))


def math_sum(n=100_000_000):
return (n * (n - 1)) // 2


def main():
print('while looptt', timeit.timeit(while_loop, number=1))
print('for looptt', timeit.timeit(for_loop, number=1))
print('sum rangett', timeit.timeit(sum_range, number=1))
print('math sumtt', timeit.timeit(math_sum, number=1))


if __name__ == '__main__':
main()
# => while loop 4.718853999860585
# => for loop 3.211570399813354
# => sum range0.8658821999561042
# => math sum 2.400018274784088e-06

Masa pelaksanaan akhir jumlah matematik ialah kira-kira 2.4e-6, yang dipendekkan berjuta-juta kali. Idea di sini ialah kerana kecekapan gelung adalah rendah, sekeping kod perlu dilaksanakan ratusan juta kali.

Cuma, jangan gelung dan gunakan formula matematik untuk menjadikan ratusan juta operasi gelung menjadi satu langkah sahaja. Kecekapan secara semula jadi telah dipertingkatkan berbanding sebelum ini.

Kesimpulan akhir (sedikit Riddler):

Cara terpantas untuk melaksanakan gelung - - - bukan untuk menggelung

Untuk Python, ia adalah sebaik mungkin Gunakan binaan -in berfungsi untuk meminimumkan kod Python tulen dalam gelung.

Atas ialah kandungan terperinci Kaedah gelung Python manakah yang paling pantas?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!