Dalam artikel ini, kami akan membincangkan beberapa kegunaan biasa bagi gelung dan pemahaman dalam Python, cara menganalisis gelung sedia ada dan cara mengubahnya menjadi ungkapan yang setara dalam Elixir, menggunakan fungsi dalam modul Enum dan kefahaman.

Kami akan menumpukan pada:

• mengubah koleksi data melalui fungsi (peta)
• menapis nilai ke dalam atau keluar daripada koleksi (penapis)
• menghasilkan nilai atau struktur agregat tunggal, seperti purata (kurangkan atau lipatan)

Kami akan menamatkan dengan contoh asas yang menggabungkan ketiga-tiga!

Ular sawa

Untuk gelung

Dalam Python, untuk gelung biasanya menampilkan pemprosesan berjalin - langkah digabungkan bersama ke dalam klausa atau badan yang sama. Berikut ialah contoh yang menduakan dua nombor genap yang pertama:

result = 0
for num in [1, 2, 3, 4, 5]:
    if num % 2 == 0:
        result += num ** 2
print(result)  # Output: 20

Satu cabaran badan bersilang ini ialah:

1. kenal pasti setiap langkah, dan…
2. tentukan jenis langkah itu.

Memecahkan setiap langkah membolehkan anda memahami transformasi yang berlaku, menghapuskan mana-mana yang tidak perlu dan menulis semula langkah tersebut ke dalam binaan bahasa lain atau fungsi peringkat lebih tinggi.

Menganotasi fungsi di atas menghasilkan:

result = 0
for num in [1, 2, 3, 4, 5]:
    ## Filter
    if num % 2 == 0:
        ## Reduce (result += ) and Map (num ** 2)
        result += num ** 2
print(result)  # Output: 20

Langkah-langkahnya

Akibatnya - susunan langkahnya ialah:

1. Tapis "keluar" nombor ganjil/"dalam" nombor genap
2. Peta nombor (cth. 2) ke nombor segi empat samanya (cth. 4)
3. Kurangkan kepada jumlah nombor genap kuasa dua

Kefahaman

Pemahaman dalam Python ialah cara mudah untuk memetakan dan menapis koleksi seperti senarai dan kamus. Mereka tidak menawarkan cara untuk mengurangkan hasil, tetapi kita boleh menggunakan fungsi terbina dalam seperti jumlah untuk mengubah perkara di atas untuk memproses hasil pemahaman:

result = sum(num ** 2 for num in [1, 2, 3, 4, 5] if num % 2 == 0)
print(result)  # Output: 20

Dengan pemahaman, ungkapan membahagikan langkah peta (nombor ** 2) dan penapis (jika nombor % 2 == 0) dengan jelas. jumlah ialah langkah kurangkan di sini.

Memang mudah untuk menyelak ungkapan pemahaman dalam Python ini dan ia meletakkan had atas yang berguna pada kerumitan pemahaman.

Dengan latar belakang ini, dan pemahaman yang lebih baik tentang struktur dan had binaan pemprosesan Python, mari teruskan menulis semula kod Python di atas menggunakan pemahaman Elixir dan saluran paip Enum!

Pemetaan: Enum.map dan penjana

Bagaimanakah kita boleh menulis langkah kepada nombor kuasa dua? Dalam Elixir, ia mudah!

Menggunakan Enum.map:

result = 0
for num in [1, 2, 3, 4, 5]:
    if num % 2 == 0:
        result += num ** 2
print(result)  # Output: 20

dan menggunakan pemahaman (untuk):

result = 0
for num in [1, 2, 3, 4, 5]:
    ## Filter
    if num % 2 == 0:
        ## Reduce (result += ) and Map (num ** 2)
        result += num ** 2
print(result)  # Output: 20

<- mewakili ungkapan penjana, menjana nilai untuk digunakan dalam kandungan for expression, selepas melakukan:

Penapisan: Enum.penapis dan penapis

Mudah dilakukan dengan Enum.filter (atau Enum.reject):

result = sum(num ** 2 for num in [1, 2, 3, 4, 5] if num % 2 == 0)
print(result)  # Output: 20

Kami ingin menapis nombor ganjil sebelum ia diduakan, jadi kami meletakkannya di tempat yang betul dalam perancangan - sebelum Enum.map.

Dengan menggunakan pemahaman, kita boleh menambah ungkapan kedua pada kepala pemahaman, penapis, iaitu ujian boolean:

Enum.map([1, 2, 3, 4, 5], & &1 ** 2)

Ungkapan rem(n, 2) == 0 kemudian membuang mana-mana unsur yang mengembalikan palsu (atau nihil), meninggalkan [2, 4] sebagai nombor yang sebenarnya dihantar ke badan (do: n ** 2) daripada kefahaman.

Kurangkan -> Enum.kurangkan dan kurangkan:

Menggunakan Enum.reduce/2, kita boleh menukar senarai nombor kuasa dua kepada jumlahnya dengan menambah pada penumpuk. Elemen pertama digunakan sebagai nilai awal penumpuk jika kita tidak menentukan nilai awal untuk penumpuk (Enum.reduce/3), dan itu berguna di sini:

for n <- [1, 2, 3, 4, 5], do: n ** 2

Dengan kefahaman, kami mempunyai lebih banyak kuasa daripada Python yang setara. Kita boleh menambah langkah mengurangkan dengan menambahkan klausa lain pada kepala:

[1, 2, 3, 4, 5]
|> Enum.filter(& rem(&1, 2) == 0)
|> Enum.map(& &1 ** 2)

membuat dua perubahan di sini:

1. menambah klausa pengurangan: 0 pada kepala, untuk menentukan bahawa kami akan mengumpul nilai yang nilai awalnya ialah 0
2. menukar untuk badan untuk menangkap nilai acc (penumpuk) yang boleh kita tambahkan nilai kuasa dua semasa.

Fungsi terbina dalam: Enum.sum

Sebagai peraturan umum, kita harus menyatakan data yang ingin kita ubah dengan cara tahap tertinggi yang mungkin. Adalah berguna untuk menganggap Enum.reduce sebagai transformasi fungsi tahap paling rendah, kerana semua pemprosesan data lain boleh ditulis semula dari seginya.

Modul Enum mengandungi banyak fungsi peringkat lebih tinggi, biasanya melibatkan pengurangan senarai nilai kepada satu nilai agregat, seperti jumlah, maksimum atau minimum. Dalam kes ini, kami mahukan jumlah elemen.

Untuk saluran paip Enum, ini adalah mudah:

for n <- [1, 2, 3, 4, 5], rem(n, 2) == 0, do: n ** 2

Tiada cara untuk mewakili fungsi agregat peringkat tinggi ini dalam pemahaman, jadi kami boleh menyalurkan output pemahaman ke dalam panggilan Enum.sum seperti itu, sama seperti yang kami lakukan dalam Python:

[1, 2, 3, 4, 5]
|> Enum.filter(& rem(&1, 2) == 0)
|> Enum.map(& &1 ** 2)
|> Enum.reduce(& &1 + &2)

Mencampurkan bentuk yang berbeza secara amnya harus dielakkan, terutamanya jika transformasi adalah mudah, kerana ia mengakibatkan beban mental yang kurang untuk pembaca - pengurangan: borang di atas sebenarnya lebih jelas untuk dibaca walaupun pada tahap yang lebih rendah.

Ekspresi Elixir mana yang lebih baik?

Untuk meringkaskan, kami telah menghasilkan dua bentuk yang boleh dianggap sebagai idiomatik. Untuk saluran paip Enum:

result = 0
for num in [1, 2, 3, 4, 5]:
    if num % 2 == 0:
        result += num ** 2
print(result)  # Output: 20

dan kefahaman:

result = 0
for num in [1, 2, 3, 4, 5]:
    ## Filter
    if num % 2 == 0:
        ## Reduce (result += ) and Map (num ** 2)
        result += num ** 2
print(result)  # Output: 20

Kod yang mudah dibaca hendaklah mudah untuk diimbas, tanpa kesamaran atau tersandung pada ekspresi. Saya rasa kedua-dua borang memenuhi kriteria itu, sebagai:

1. mereka mengikut satu bentuk konsisten - sama ada saluran paip Enum atau pemahaman
2. setiap ungkapan sepadan dengan satu langkah pemprosesan
3. ia boleh dibaca dari atas ke bawah atau dari kiri ke kanan tanpa gangguan

Kesimpulan

Menulis transformasi ini boleh dilakukan dalam beberapa cara berbeza dalam Elixir, dan asas kod mudah untuk mengubah gaya, terutamanya apabila kod ditukar dan pemprosesan menjadi lebih rumit dari semasa ke semasa.

PureType boleh memecahkan dan menganalisis saluran paip dan pemahaman Enum untuk mewakilinya dalam bentuk yang paling jelas dan paling idiomatik, mempelajari pilihan anda dan meningkatkan kebolehbacaan dan kejelasan kod anda untuk orang lain dalam pasukan. Cubalah hari ini!

Atas ialah kandungan terperinci Untuk gelung dan pemahaman dalam Elixir - mengubah kod imperatif. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!