Mengapa meminta maaf lebih mudah daripada mendapatkan izin dengan Python?

LBYL, pendekatan balasan terhadap EAFP tidak ada hubungannya dengan pernyataan, itu hanya berarti Anda menambahkan tanda centang sebelum mencoba untuk mengakses sesuatu yang mungkin tidak ada di sana.

Alasan mengapa Python adalah EAFP adalah karena tidak seperti bahasa lain (misalnya Java) - dalam Python, menangkap pengecualian adalah operasi yang relatif murah, dan itulah mengapa Anda dianjurkan untuk menggunakannya.

Contoh untuk EAFP:

try:
    snake = zoo['snake']
except KeyError as e:
    print "There's no snake in the zoo"
    snake = None

Contoh untuk LBYL:

if 'snake' in zoo:
    snake = zoo['snake']
else:
    snake = None

Anda mencampurkan dua hal di sini: Pernyataan dan logika berbasis EAFP.

Pernyataan digunakan untuk memvalidasi kontrak fungsi, yaitu kondisi sebelum dan sesudahnya dan terkadang juga invariannya. Mereka memastikan bahwa suatu fungsi akan digunakan sebagaimana mestinya. Ini bukan untuk aliran kode, karena mereka benar-benar mengganggu eksekusi jika terjadi kesalahan. Contoh umum adalah pemeriksaan argumen None dalam pemanggilan fungsi.

Di Python, Anda biasanya menghindari penggunaan pernyataan terlalu banyak. Secara umum, Anda harus mengharapkan pengguna kode Anda untuk menggunakannya dengan benar. Misalnya, jika Anda mendokumentasikan suatu fungsi untuk mengambil argumen yang bukan None, maka tidak perlu ada pernyataan yang memvalidasi argumen tersebut. Sebaliknya, berharap saja ada nilainya. Jika ada kesalahan karena nilai Tidak Ada, maka kesalahan tersebut akan tetap muncul, sehingga pengguna mengetahui bahwa mereka melakukan kesalahan. Namun Anda tidak harus memeriksa semuanya setiap saat.

Sekarang, EAFP adalah sesuatu yang berbeda. Ini digunakan dalam aliran kontrol, atau lebih tepatnya, ini menghindari aliran kontrol tambahan demi mengharapkan segala sesuatunya benar dan menangkap pengecualian jika ternyata tidak benar. Contoh umum yang menunjukkan perbedaannya adalah akses kunci dalam kamus:

# LBYL
if key in dic:
    print(dic[key])
else:
    handleError()

# EAFP
try:
    print(dic[key])
except KeyError:
    handleError()

Sekarang ini terlihat sangat mirip, meskipun Anda harus ingat bahwa solusi LBYL memeriksa kamus dua kali. Seperti semua kode yang menangkap pengecualian, Anda hanya boleh melakukannya jika tidak adanya kunci adalah kasus luar biasa. Jadi jika biasanya kunci yang diberikan dikecualikan untuk ada di kamus, maka itu adalah EAFP dan Anda sebaiknya mengaksesnya secara langsung. Jika Anda tidak mengharapkan kuncinya ada di kamus, Anda mungkin harus memeriksa keberadaannya terlebih dahulu (meskipun pengecualian lebih murah di Python, pengecualian tersebut tetap tidak gratis, jadi simpanlah untuk kasus luar biasa).

Manfaat EAFP di sini juga adalah bahwa lebih dalam logika perpustakaan atau aplikasi Anda, di mana key berasal dari atas, Anda dapat berasumsi bahwa kunci yang valid telah diteruskan di sini. Jadi Anda tidak perlu menangkap pengecualian di sini tetapi biarkan saja pengecualian tersebut muncul ke titik yang lebih tinggi dalam kode Anda sehingga Anda dapat menangani kesalahan tersebut. Hal ini memungkinkan Anda untuk memiliki fungsi tingkat rendah yang sepenuhnya bebas dari pemeriksaan semacam ini.

Pertanyaan yang bagus! Ada sedikit pertanyaan di StackOverflow yang menanyakan tentang "filosofi di balik prinsip".

Mengenai definisi EAFP dalam glosarium Python, saya bahkan akan melangkah lebih jauh dan mengatakan bahwa penyebutan "pengecualian cache jika asumsi terbukti salah" agak menyesatkan dalam konteks ini. Karena jujur ​​saja, cuplikan kode ke-2 berikut TIDAK terlihat lebih "bersih dan cepat" (istilah yang digunakan dalam definisi di atas). Pantas saja OP menanyakan pertanyaan ini.

# LBYL
if key in dic:
    print(dic[key])
else:
    handleError()

# EAFP
try:
    print(dic[key])
except KeyError:
    handleError()

Menurut saya, momen sebenarnya ketika EAFP bersinar adalah Anda TIDAK menulis try ... except ... sama sekali, setidaknya tidak di sebagian besar basis kode dasar Anda. Karena, aturan pertama penanganan pengecualian: jangan lakukan penanganan pengecualian. Dengan mengingat hal tersebut, sekarang, mari kita tulis ulang cuplikan ke-2 menjadi ini:

# Real EAFP
print(dic[key])

Sekarang, bukankah pendekatan EAFP yang sebenarnya bersih dan cepat?

Saya akan memperluas jawaban dari @RayLuo.

Masalahnya dengan LBYL, sebenarnya tidak berfungsi secara umum. Kecuali Anda memiliki aplikasi single-thread, selalu ada kemungkinan kondisi balapan:

# LBYL
if key in dic:
    # RACE CONDITION
    print(dic[key])
else:
    handleError()

# EAFP
try:
    print(dic[key])
except KeyError:
    handleError()

Kunci dapat ditambahkan ke dikt antara tanda centang if dan dan print. Hal ini kedengarannya tidak mungkin terjadi dalam kasus khusus ini. Namun kemungkinannya lebih besar jika pemeriksaan yang Anda lakukan bertentangan dengan DB, API, atau sumber data eksternal apa pun yang dapat berubah secara asinkron dengan data aplikasi Anda.

Artinya cara yang tepat untuk mengimplementasikan LBYL adalah:

if key in dic:
    try:
        print(dic[key])
    except KeyError:
        handleError()
else:
    handleError()

Perhatikan klausa try / except sama persis dengan pendekatan EAFP.

Karena Anda harus menangani pengecualian gaya EAFP bahkan saat menggunakan pendekatan LBYL, Anda sebaiknya menggunakan pendekatan EAFP terlebih dahulu.

Satu-satunya keadaan di mana saya akan menggunakan pemeriksaan if adalah jika tindakan berikutnya (print dalam kasus ini) sangat mahal/memakan waktu untuk memulai. Itu jarang terjadi dan bukan alasan untuk menggunakan tanda centang if setiap saat.

Intinya: LBYL tidak berfungsi dalam kasus umum, tetapi EAFP bisa. Pengembang yang baik fokus pada pola solusi umum yang dapat mereka gunakan dengan percaya diri dalam berbagai masalah. Belajar menggunakan EAFP secara konsisten.