Contents [show]
Dalam proses pembelajaran ke program, selalunya perlu mencipta program yang tidak begitu mudah untuk diaplikasikan dalam kehidupan sebenar. Lagipun, dari semasa ke semasa anda perlu mengikut arahan hanya dalam keadaan tertentu. Untuk dapat melaksanakan ini dalam program, semua bahasa mempunyai pernyataan kawalan. Dengan bantuan mereka, anda boleh mengawal aliran pelaksanaan kod, mencipta gelung atau melakukan tindakan tertentu hanya apabila keadaan tertentu adalah benar.
Hari ini kita akan bercakap tentang pernyataan if, yang menyemak keadaan semasa untuk keadaan tertentu, dan berdasarkan maklumat ini, membuat keputusan tentang tindakan selanjutnya.
Jenis Pernyataan Kawalan
Secara umum, jika bukan satu-satunya pernyataan yang mengawal aliran program. Serta dia sendiri boleh menjadi komponen rangkaian pengendali yang lebih besar.
Terdapat juga gelung dan pernyataan yang mengawal proses pelaksanaannya. Hari ini kita hanya akan bercakap tentang pengendali bersyarat dan rantai di mana ia boleh mengambil bahagian.
Dalam pengaturcaraan, terdapat perkara seperti percabangan. Ia adalah tepat ini yang bermaksud urutan perintah yang dilaksanakan hanya jika syarat tertentu adalah benar. Kriteria itu sendiri mungkin berbeza:
- Kesamaan pembolehubah kepada nilai tertentu.
- Melakukan tindakan tertentu.
- Keadaan permohonan (runtuh atau tidak).
Spektrum boleh menjadi lebih besar. Pernyataan bersyarat datang dalam beberapa jenis:
- Dengan satu cawangan. Iaitu, pemeriksaan tunggal dilakukan, akibatnya tindakan tertentu dilakukan.
- Dengan dua atau lebih cawangan. Jika kriteria 1 adalah benar, maka semak kriteria 2. Jika ia benar, maka semak 3. Maka, lakukan seberapa banyak semakan yang diperlukan.
- Dengan beberapa syarat. Semuanya mudah di sini. Jurubahasa menyemak beberapa syarat atau salah satu daripadanya.
jika kenyataan
Struktur pernyataan if adalah serupa dalam semua bahasa. Walau bagaimanapun, dalam Python, sintaksnya agak berbeza daripada yang lain:
jika syarat:
<ungkapan input 1>
<ungkapan input 2>
<не входящее выражение>
Pertama, pengendali itu sendiri diisytiharkan, selepas itu keadaan di mana ia mula berfungsi ditulis. Keadaan boleh sama ada benar atau salah.
Ini diikuti dengan blok dengan arahan. Jika ia segera mengikut kriteria yang perlu dipenuhi, maka urutan arahan yang sepadan dipanggil blok if. Anda boleh menggunakan sebarang bilangan arahan di dalamnya.
Perhatian! Lekukan dalam arahan all if block mestilah sama saiz. Sempadan blok ditentukan oleh inden.
Menurut dokumentasi bahasa, lekukan ialah 4 ruang.
Bagaimanakah pengendali ini berfungsi? Apabila jurubahasa melihat perkataan if, ia segera menyemak ungkapan itu terhadap kriteria yang ditentukan pengguna. Jika ini berlaku, maka dia mula mencari arahan dan mengikutinya. Jika tidak, semua arahan daripada blok ini dilangkau.
Jika pernyataan selepas keadaan tidak diinden, ia tidak dianggap sebagai blok if. Dalam keadaan kita, baris ini adalah
Berikut ialah coretan kod untuk contoh cara pengendali ini berfungsi.
nombor = int(input(“Masukkan nombor: “))
jika nombor > 10:
print("Nombor lebih besar daripada 10")
Program ini menggesa pengguna untuk nombor dan menyemak sama ada ia lebih besar daripada 10. Jika ya, ia mengembalikan maklumat yang sesuai. Sebagai contoh, jika pengguna memasukkan nombor 5, maka program itu hanya akan tamat, dan itu sahaja.
Tetapi jika anda menentukan nombor 100, maka jurubahasa akan memahami bahawa ia lebih daripada sepuluh, dan melaporkannya.
Perhatian! Dalam kes kami, jika syarat itu palsu, program berhenti, kerana tiada arahan diberikan selepas arahan.
Terdapat hanya satu arahan dalam kod di atas. Tetapi terdapat banyak lagi daripada mereka. Satu-satunya keperluan adalah untuk inden.
Sekarang mari kita analisa urutan arahan ini.
nombor = int(input(“Tulis nombor: “))
jika nombor > 10:
cetak("baris pertama")
cetak("baris kedua")
cetak("baris ketiga")
print("Barisan yang dilaksanakan, tanpa mengira nombor yang dimasukkan")
print("Tamatkan permohonan")
Cuba teka apakah output jika anda memasukkan nilai 2, 5, 10, 15, 50.
Seperti yang anda lihat, jika nombor yang dimasukkan oleh pengguna adalah lebih daripada sepuluh, maka tiga baris adalah output + satu dengan teks "Jalankan setiap kali ..." dan satu "Tamat", dan jika kurang daripada sepuluh, maka hanya satu, dengan teks yang berbeza. Hanya baris 3,4,5 akan dilaksanakan jika benar. Walau bagaimanapun, dua baris terakhir akan ditulis tidak kira nombor yang ditentukan oleh pengguna.
Jika anda menggunakan pernyataan secara langsung dalam konsol, hasilnya akan berbeza. Jurubahasa segera menghidupkan mod berbilang baris jika, selepas menentukan kriteria pengesahan, tekan Enter.
Katakan kita telah menulis urutan arahan berikut.
>>>
>>> n = 100
>>> jika n > 10:
...
Selepas itu, kita akan melihat bahawa >>> telah digantikan dengan elipsis. Ini bermakna mod input berbilang talian didayakan. Dengan kata mudah, jika anda menekan Enter, anda akan dipindahkan ke input peringkat kedua arahan.
Dan untuk keluar dari blok ini, anda perlu menambah satu lagi pembinaan pada blok itu if.
>>>
>>> n = 100
>>> jika n > 10:
… cetak(«nv 10»)
...
Jika syarat tidak benar, program tamat. Ini adalah masalah, kerana pengguna mungkin menganggap program sedemikian telah ditutup kerana kegagalan. Oleh itu, adalah perlu untuk memberi maklum balas kepada pengguna. Untuk ini, pautan digunakan jika tidak.
operator ekspresi jika tidak
Operator ini membenarkan anda melaksanakan pautan: jika ungkapan itu sepadan dengan peraturan tertentu, lakukan tindakan ini, dan jika tidak, maka yang lain. Iaitu, ia membolehkan anda membahagikan aliran program kepada dua jalan. Sintaks adalah intuitif:
jika syarat:
# jika blok
kenyataan 1
kenyataan 2
dan sebagainya
lain:
# blok lain
kenyataan 3
kenyataan 4
dan sebagainya:
Mari terangkan cara pengendali ini berfungsi. Pertama, pernyataan standard dilaksanakan dalam benang yew, menyemak sama ada ia sepadan keadaan "betul atau salah". Tindakan selanjutnya bergantung pada keputusan semakan. Jika benar, arahan yang berada dalam urutan arahan berikutan keadaan dilaksanakan secara langsung. yew, jika ia palsu, maka lagi.
Dengan cara ini anda boleh menangani ralat. Sebagai contoh, pengguna perlu memasukkan jejari. Jelas sekali, ia hanya boleh menjadi nombor dengan tanda tambah atau ia adalah nilai nol. Jika kurang daripada 0, maka anda perlu mengeluarkan mesej yang meminta anda memasukkan nombor positif.
Berikut ialah kod yang melaksanakan tugas ini. Tetapi ada satu kesilapan di sini. Cuba teka yang mana satu.
jejari = int(input(“Masukkan jejari: “))
jika jejari >= 0:
print(“Lilitan = “, 2 * 3.14 * jejari)
print(“Luas = “, 3.14 * jejari ** 2)
lain:
print(“Sila masukkan nombor positif”)
Ralat ketidakpadanan lekukan. Jika dan Lain mesti ditempatkan tanpa mereka atau dengan bilangan yang sama (bergantung kepada sama ada ia bersarang atau tidak).
Mari berikan satu lagi kes penggunaan (di mana semuanya akan betul dengan penjajaran operator) – elemen aplikasi yang menyemak kata laluan.
kata laluan = input("Masukkan kata laluan:")
jika kata laluan == «sshh»:
print("Selamat Datang")
lain:
print("Akses ditolak")
Arahan ini melangkau orang itu lebih jauh jika kata laluan adalah sshh. Jika ada kombinasi huruf dan nombor lain, maka ia memaparkan mesej "Akses ditolak".
pernyataan-ungkapan if-elif-else
Hanya jika beberapa syarat tidak benar, pernyataan yang ada dalam blok dilaksanakan. lagi. Ungkapan ini berfungsi seperti ini.
jika syarat_1:
# jika blok
kenyataan
kenyataan
lebih banyak kenyataan
keadaan elif_2:
# blok elif pertama
kenyataan
kenyataan
lebih banyak kenyataan
keadaan elif_3:
# blok elif kedua
kenyataan
kenyataan
lebih banyak kenyataan
...
lagi
kenyataan
kenyataan
lebih banyak kenyataan
Anda boleh menentukan sebarang bilangan syarat tambahan.
Kenyataan bersarang
Cara lain untuk melaksanakan berbilang syarat adalah dengan memasukkan semakan syarat tambahan dalam blok if.
operator if di dalam blok keadaan lain
gre_score = int(input("Masukkan had kredit semasa anda"))
per_grad = int(input(“Masukkan penilaian kredit anda: “))
jika per_grad > 70:
# luar jika blok
jika gre_score > 150:
# dalaman jika blok
print("Tahniah, anda telah menerima pinjaman")
lain:
print("Maaf, anda tidak layak untuk pinjaman")
Program ini melakukan semakan penarafan kredit. Jika kurang daripada 70, program melaporkan bahawa pengguna tidak layak untuk kredit. Jika lebih besar, semakan kedua dilakukan untuk melihat sama ada had kredit semasa melebihi 150. Jika ya, maka mesej dipaparkan bahawa pinjaman telah dikeluarkan.
Jika kedua-dua nilai adalah palsu, maka mesej dipaparkan bahawa pengguna tidak mempunyai kemungkinan untuk mendapatkan pinjaman.
Sekarang mari kita mengolah semula program itu sedikit.
gre_score = int(input("Masukkan had semasa:"))
per_grad = int(input(“Masukkan skor kredit: “))
jika per_grad > 70:
jika gre_score > 150:
print("Tahniah, anda telah menerima pinjaman")
lain:
print("Had kredit anda adalah rendah")
lain:
print("Maaf, anda tidak layak mendapat kredit")
Kod itu sendiri sangat serupa, tetapi bersarang if juga menyediakan algoritma sekiranya keadaan daripadanya ternyata palsu. Iaitu, had pada kad tidak mencukupi, tetapi sejarah kredit adalah baik, mesej "Anda mempunyai penarafan kredit rendah" dipaparkan.
pernyataan if-else dalam keadaan lagi
Mari kita buat satu lagi program yang menentukan gred pelajar berdasarkan markah ujian.
skor = int(input(“Masukkan skor anda: “))
jika markah >= 90:
print("Hebat! Gred anda ialah A")
lain:
jika markah >= 80:
print("Hebat! Gred anda ialah B")
lain:
jika markah >= 70:
print("Baik! Gred anda ialah C")
lain:
jika markah >= 60:
print(“Gred anda ialah D. Ia berbaloi untuk mengulangi bahan tersebut.”)
lain:
print("Anda gagal dalam peperiksaan")
Permohonan terlebih dahulu menyemak untuk melihat sama ada skor lebih besar daripada atau sama dengan 90. Jika ya, maka ia mengembalikan gred A. Jika syarat ini palsu, maka semakan seterusnya dilakukan. Kami melihat bahawa algoritma adalah hampir sama pada pandangan pertama. Jadi daripada menyemak dalam lagi lebih baik menggunakan gabungan if-elif-else.
Jadi pengendali if melaksanakan fungsi yang sangat penting - ia memastikan bahawa kepingan kod tertentu dilaksanakan hanya jika ada keperluan untuknya. Adalah mustahil untuk membayangkan pengaturcaraan tanpa itu, kerana walaupun algoritma yang paling mudah memerlukan garpu seperti "jika anda pergi ke kiri, anda akan menemuinya, dan jika anda pergi ke kanan, maka anda perlu melakukan ini dan itu."