Gunakan Senarai Pemantauan untuk transformasi mudah untuk meningkatkan kejelasan dan kelajuan. 2. Cache operasi mahal seperti len () di gelung luar untuk mengelakkan panggilan berulang. 3. Menggunakan zip () dan menghitung () untuk mengurangkan pengindeksan dan meningkatkan kebolehbacaan. 4. Break awal atau penapis data di depan untuk meminimumkan pemprosesan yang tidak perlu. 5. Pertimbangkan struktur bersarang meratakan sekali jika mereka sering dilalui, memastikan kedalaman rekursi dan penggunaan memori tetap dapat diurus. Gelung bersarang yang cekap mengurangkan kelebihan, meningkatkan kebolehbacaan, dan mengoptimumkan prestasi dengan mengekalkan gelung dalaman bersandar dan memanfaatkan alat terbina dalam Python dengan berkesan.

Apabila bekerja dengan struktur data yang kompleks seperti senarai bersarang, kamus senarai, atau susunan pelbagai dimensi-bersarang for gelung sering tidak dapat dielakkan. Walau bagaimanapun, bersarang yang tidak cekap boleh menyebabkan kod kembung, perlahan, dan sukar dibaca. Kuncinya bukan untuk mengelakkan gelung bersarang sepenuhnya, tetapi untuk menulisnya dengan cekap dan sengaja .

Berikut adalah cara untuk membuat gelung bersarang yang bersih dan cekap apabila berurusan dengan data yang kompleks.

1. Logik meratakan apabila mungkin

Sebelum menulis pelbagai tahap bersarang, tanya: Bolehkah saya mempermudahkan struktur atau mengekstrak sebahagian logik?

Sebagai contoh, jika anda memproses senarai kamus di mana masing -masing mempunyai senarai item:

 data = [
    {"id": 1, "tags": ["a", "b"]},
    {"id": 2, "tags": ["c", "d", "e"]},
]

Bukannya bersarang tanpa tujuan:

 # Kurang cekap
hasil = []
Untuk item dalam data:
    untuk tag dalam item ["tags"]:
        results.append ((item ["id"], tag))

Ini baik -baik saja, tetapi jika anda melakukan ini dengan kerap, pertimbangkan untuk menggunakan pemahaman penjana atau senarai untuk kejelasan dan kelajuan:

 # Lebih cekap dan ringkas
hasil = [(item ["id"], tag) untuk item dalam data untuk tag dalam item ["tags"]]

Senarai pemantauan biasanya lebih cepat daripada gelung bersarang di Python tulen kerana mereka dioptimumkan secara dalaman.

? Petua : Gunakan pemantauan untuk transformasi mudah. Rizab gelung penuh untuk logik kompleks dengan keadaan atau kesan sampingan.

2. Elakkan operasi mahal berulang di dalam gelung dalaman

Perangkap prestasi biasa adalah menilai semula nilai-nilai dalam gelung dalaman yang boleh di-cache di luar.

 # Lambat: len () dipanggil berulang kali
untuk sublist dalam data_list:
    untuk saya dalam julat (len (sublist)):
        proses (sublist [i])

# Cepat: Panjang cache
untuk sublist dalam data_list:
    n = len (sublist)
    untuk saya dalam julat (n):
        proses (sublist [i])

Lebih baik? Melewati secara langsung melalui unsur -unsur:

 untuk sublist dalam data_list:
    untuk item dalam sublist:
        proses (item)

? Peraturan : Gerakkan perhitungan invarian (seperti len() , carian atribut, panggilan fungsi) ke skop paling luar.

3. Gunakan enumerate() dan zip() untuk mengurangkan bersarang

Kadang-kadang apa yang kelihatan seperti pekerjaan untuk dua gelung dapat dilakukan dengan lebih bersih dengan terbina dalam.

Sebagai contoh, membandingkan unsur -unsur di dua struktur bersarang:

 list_a = [[1, 2], [3, 4]]
list_b = [[5, 6], [7, 8]]

# Bukannya:
untuk i dalam julat (len (list_a)):
    untuk j dalam julat (len (list_a [i])):
        diff = list_a [i] [j] - list_b [i] [j]
        cetak (diff)

# Lebih suka:
untuk row_a, row_b dalam zip (list_a, list_b):
    untuk a, b dalam zip (row_a, row_b):
        cetak (a - b)

Bersih, lebih selamat (tiada kesilapan indeks), dan lebih mudah dibaca.

4. Break awal atau penapis di depan

Jika anda mencari atau menapis, jangan memproses segala -galanya yang tidak perlu.

 # Berhenti apabila dijumpai
dijumpai = palsu
untuk kumpulan dalam data:
    untuk item dalam kumpulan:
        jika item == sasaran:
            cetak ("dijumpai!")
            dijumpai = benar
            rehat
    Sekiranya dijumpai:
        rehat

Atau lebih baik, gunakan fungsi penolong untuk membuat pulangan awal lebih mudah:

 def find_in_nested (data, sasaran):
    untuk kumpulan dalam data:
        untuk item dalam kumpulan:
            jika item == sasaran:
                kembali benar
    kembali palsu

Juga, struktur luar pra-penapis jika boleh:

 # Langkau kumpulan kosong atau tidak relevan lebih awal
untuk kumpulan dalam data:
    Jika tidak kumpulan atau "tidak aktif" dalam kumpulan:
        Teruskan
    untuk item dalam kumpulan:
        proses (item)

5. Pertimbangkan struktur kompleks meratakan (berhati -hati)

Sekiranya anda berulang kali melintasi data yang sangat bersarang, pertimbangkan untuk meratakannya sekali -terutamanya jika strukturnya statik.

 def flatten (data):
    Untuk item dalam data:
        Jika isInstance (item, senarai):
            Hasil dari rata (item)
        lain:
            item hasil

# Kemudian:
untuk nilai di flatten (nested_data):
    proses (nilai)

Hanya berhati -hati: kedalaman rekursi dan penggunaan memori boleh menjadi masalah dengan struktur yang sangat mendalam.

Ringkasan: Amalan terbaik

• ? Gunakan senarai senarai/dict untuk lelaran bersarang sederhana.
• ? Cache panggilan mahal (seperti len() , akses atribut) di luar gelung dalaman.
• ? Lebih suka zip() , enumerate() , dan lelaran langsung ke atas indeks.
• ? Break awal atau penapis awal untuk mengelakkan kerja yang tidak perlu.
• ? Pertimbangkan data meratakan atau penstrukturan semula jika anda sering melayari.

Gelung bersarang yang cekap bukan tentang mengelakkan kedalaman -mereka tentang mengurangkan kelebihan, meningkatkan kebolehbacaan, dan menghormati aliran data .

Pada asasnya, pastikan gelung dalaman bersandar, dan biarkan gelung luar melakukan mengangkat berat apabila mungkin.

Atas ialah kandungan terperinci Kerajinan yang cekap bersarang untuk gelung untuk struktur data yang kompleks. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!