Cabaran: Alternatif untuk melaksanakan gelung dalam Python

Sudah agak lama saya mula menerokai ciri bahasa yang menakjubkan dalam Python. Pada mulanya, saya memberi cabaran kepada diri saya sendiri dengan matlamat membenarkan saya mempraktikkan lebih banyak ciri bahasa Python daripada pengalaman pengaturcaraan dengan bahasa pengaturcaraan lain. Ini menjadikan perkara lebih dan lebih menarik! Kod menjadi lebih dan lebih ringkas, dan kod kelihatan lebih berstruktur dan piawai. Saya akan menerangkan manfaat ini di bawah.

Untuk gelung biasanya digunakan dalam senario penggunaan berikut:

• Untuk mengekstrak beberapa maklumat dalam urutan.
• Janakan satu urutan daripada yang lain.
• Menulis untuk sudah menjadi kebiasaan.

Nasib baik, Python sudah mempunyai banyak alatan untuk membantu anda melakukan ini, anda hanya perlu mengalihkan fikiran anda dan memikirkannya dari perspektif yang berbeza.

Apakah faedah yang anda perolehi dengan mengelak daripada menulis untuk gelung:

• Kurang jumlah kod
• Kebolehbacaan kod yang lebih baik
• Kurang lekukan (masih menghasilkan sense for Python)

Mari kita lihat struktur kod berikut:

# 1
with ...:
 for ...:
 if ...:
 try:
 except:
 else:

Dalam contoh ini, kita berurusan dengan kod bersarang berbilang peringkat, yang sukar dibaca. Contoh ini menggunakan berbilang peringkat kod bersarang. Apa yang saya temui dalam kod ini ialah penggunaan lekukan secara sembarangan untuk mencampurkan logik pengurusan (dengan, cuba-kecuali) dan logik perniagaan (untuk, jika). Jika anda mematuhi konvensyen hanya menggunakan lekukan untuk logik pentadbiran, maka logik perniagaan teras harus dikeluarkan dengan segera.

• "Struktur rata lebih baik daripada struktur bersarang" - The Zen of Python

Alat sedia ada yang boleh digunakan untuk menggantikan gelung

1. Senaraikan Kefahaman / Ungkapan penjana

Mari lihat contoh mudah. Jika anda ingin menukar satu tatasusunan kepada tatasusunan yang lain:

result = []
for item in item_list:
 new_item = do_something_with(item)
 result.append(item)

Jika anda suka MapReduce, anda juga boleh menggunakan peta, atau Senarai Pemahaman dalam Python:

hasil = [do_something_with(item) untuk item dalam item_list]

Begitu juga, jika anda hanya ingin mengulangi elemen

dalam tatasusunan, anda juga boleh menggunakan Ungkapan Penjana kod yang sama.

result = (do_something_with(item) for item in item_list)

2. Fungsi

Jika anda ingin memetakan tatasusunan ke tatasusunan lain, panggil sahaja fungsi peta untuk menyelesaikan masalah ini dengan cara pengaturcaraan yang lebih maju dan praktikal.

doubled_list = map(lambda x: x * 2, old_list)

Jika anda ingin mengurangkan jujukan kepada satu, gunakan reduce

from functools import reduce
summation = reduce(lambda x, y: x + y, numbers)

Selain itu, banyak fungsi terbina dalam Python menggunakan iterables:

>>> a = list(range(10))
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> all(a)
False
>>> any(a)
True
>>> max(a)
9
>>> min(a)
0
>>> list(filter(bool, a))
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> set(a)
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
>>> dict(zip(a,a))
{0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9}
>>> sorted(a, reverse=True)
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
>>> str(a)
'[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]'
>>> sum(a)
45

3 atau Penjana

Dua kaedah di atas adalah baik untuk mengendalikan logik yang lebih mudah. Bagaimana pula dengan logik yang lebih kompleks? Sebagai pengaturcara, kami menulis fungsi untuk mengasingkan perniagaan yang kompleks. Idea yang sama berlaku di sini. Jika anda menulis seperti ini:

results = []
for item in item_list:
 # setups
 # condition
 # processing
 # calculation
 results.append(result)

Jelas sekali anda menambah terlalu banyak tanggungjawab pada blok kod. Sebaliknya, saya cadangkan anda lakukan:

def process_item(item):
 # setups
 # condition
 # processing
 # calculation
 return result
results = [process_item(item) for item in item_list]

Apakah yang berlaku jika anda menukar kepada fungsi bersarang?

results = []
for i in range(10):
 for j in range(i):
 results.append((i, j))

Tukar kepada Pemahaman Senarai untuk mencapai sesuatu seperti ini:

results = [(i, j)
for i in range(10)
for j in range(i)]

Jika anda kod Blok perlu merekodkan beberapa keadaan dalaman

# finding the max prior to the current item
a = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
results = []
current_max = 0
for i in a:
 current_max = max(i, current_max)
 results.append(current_max)
# results = [3, 4, 6, 6, 6, 9, 9, 9, 9, 9]

Kami menggunakan penjana untuk mencapai ini:

def max_generator(numbers):
 current_max = 0
 for i in numbers:
 current_max = max(i, current_max)
 yield current_max
a = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
results = list(max_generator(a))

• Pembaca mungkin bertanya "Tunggu! Anda menggunakan gelung for dalam penjana, itu menipu. ! dalam kebanyakan senario. Anda boleh menggantikan gelung asal anda Sebagai contoh, contoh terakhir boleh ditulis semula sebagai:

from itertools import accumulate
a = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
resutls = list(accumulate(a, max))

Selain itu, jika anda ingin mengulangi urutan gabungan, anda perlu menggunakan product() , pilih atur(), kombinasi(). >

Kesimpulan

Dalam kebanyakan kes, anda tidak perlu menulis untuk gelung

Anda harus mengelak daripada menulis untuk gelung, yang mana akan menjadikan kod lebih mudah dibaca

Atas ialah kandungan terperinci Cabaran: Alternatif untuk melaksanakan gelung dalam Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!