# Penyata Bersyarat - Semua yang Anda Harus Tahu

# Pengenalan

Hai, kembali lagi dalam Python dalam Melayu! Hari ini tajuk yang kita akan bincangkan adalah tajuk yang seringkali ada dalam asas pengaturcaraan iaitu, penyata *if-else*. 

Apa itu penyata bersyarat atau juga dikenali sebagai penyata *if-else*? 🤔

> Penyata bersyarat adalah sebuah metod penulisan pengaturcaraan dimana pengaturcara dapat menetapkan syarat-syarat tertentu sebelum kod dapat dilaksanakan. 

Bagi menerangkan secara analogi, cuba anda bayangkan anda pergi ke pasaraya. Anda mahu membeli ikan untuk makan malam. Tetapi ikan yang anda inginkan mempunyai ciri-ciri tertentu seperti, tak terlalu besar, tak terlalu kecil, harga pada antara RM10 dan RM20, dan bukan daripada keluarga ikan tertentu.

 ![Hello](https://cdn.pixabay.com/photo/2014/10/08/21/52/fish-480830_960_720.jpg)

Begitu juga dengan pengaturcaraan. Anda boleh menetapkan "syarat ciri-ciri ikan" yang anda inginkan menggunakan penyata bersyarat. Mari kita lihat bagaimana penyata bersyarat digunakan di dalam Python.

```
saiz_ikan = 20

if saiz_ikan == 20:
    print("Beli ikan ini.")

elif saiz_ikan < 20:
    print("Ikan terlalu kecil.")

else:
    print("Ikan terlalu besar.")

```
# Komponen Penyata Bersyarat 
### 👉 if

Untuk menggunakan penyata bersyarat, gunakan  ```if``` pada awal kod. 

Kemudian disusuli dengan syarat yang anda ingin kenakan, misalnya dalam kod diatas, syaratnya saiz ikan adalah 20. Kemudian di akhir penyata, letakkan kolon ```:``` atau titik dua bertindih. 

`if <syarat> <:>`

Selesai menulis penyata, pergi ke barisan seterusnya untuk menulis perintah yang akan dilaksanakan jika syarat ditepati. Perintah tersebut haruslah diperenggankan (*indented*). Perenggan digunapakai bagi memberitahu bahawa kod ini akan dilaksanakan jika penyata tersebut menepati syarat.

```
if <syarat>:
      <buat sesuatu>
```

Dalam kod diatas, jika saiz ikan adalah 20, maka apa yang program akan lakukan adalah mengeluarkan *output* ```"Beli ikan ini." ``` di dalam konsol.

### 👉 elif

Untuk syarat kedua dan seterusnya, gunakan ```elif``` . Sama juga seperti ```if```, letakkan syarat dan perintah yang ingin dilaksanakan jika menepati syarat tersebut. 


```
elif <syarat seterusnya>:
      <buat sesuatu>
```

Perintah dibawah penyata bersyarat hanya akan dilaksanakan jika dan hanya jika syarat tersebut adalah ```True```. Jika syarat tersebut adalah ```False```, program akan membaca syarat yang seterusnya dan menyemak syarat tersebut, sehinggalah program menemukan syarat yang ```True```.

### 👉 else

Selain daripada ```if``` dan ```elif```, anda juga boleh menggunakan ```else``` yang mana secara mudahnya difahami sebagai - **selain daripada syarat diatas**. ```else``` akan dilaksanakan jika syarat-syarat sebelumnya adalah `False`. 

Daripada kod diatas, ```else``` merujuk kepada syarat selain daripada saiz ikan **bersamaan** dengan 20 dan saiz ikan **lebih kecil** daripada 20; maka makna ```else``` disini merujuk kepada saiz ikan **lebih besar** daripda 20. 

Begitulah asas dalam menggunakan penyata bersyarat di dalam pengaturcaraan. Mari kita beralih kepada peringkat seterusnya iaitu - menggabungkan syarat dalam penyata bersyarat.

# Menggabungkan syarat

Dengan menggunakan penyata bersyarat, anda boleh menggabungkan beberapa syarat sekaligus menggunakan kata kunci Operator Boolean ```or``` dan ```and```.

### 1. Operator ```or``` 

```or``` dapat menggabungkan beberapa syarat dan mempunyai ciri dimana 
> Jika salah satu daripada syarat itu adalah ```True```, maka keseluruhan penyata tersebut akan dikira sebagai ```True```. 

```
[True✅] or [True✅] --->  [True✅] - kod dijalankan
[True✅] or [False❌] --->  [True✅] - kod dijalankan
[False❌] or [True✅]  --->  [True✅] - kod dijalankan
[False❌] or [False❌] --->  [False❌] - kod tidak dijalankan

```

Contoh kod:

```
saiz_ikan = 20
warna_ikan = "merah"

if saiz_ikan == 20 or warna_ikan == "hijau":
    print("Beli ikan ini.")

elif saiz_ikan < 20:
    print("Ikan terlalu kecil.")

else:
    print("Ikan terlalu besar.")
```
```
Output:

Beli ikan ini.
```
> `saiz_ikan` -> `True✅` + `warna_ikan` -> `False❌` ==> `True✅`

Dalam penyata syarat yang pertama, walaupun `warna_ikan` adalah ```False```, tetapi disebakan `saiz_ikan` adalah ```True```, makan keseluruhan penyata tersebut dianggap sebagai ```True```, dan menghasilkan *output* ```Beli ikan ini.```.

### 2. Operator ```and```

```and``` dapat menggabungkan beberapa syarat dan mempunyai ciri dimana 
> Jika salah satu daripada syarat itu adalah ```False```, maka keseluruhan penyata tersebut akan dikira sebagai ```False```. Untuk mendapatkan ```True```, kesemua syarat haruslah ```True``` barulah keseleruhan penyata dianggap sebagai ```True```.

```

[True✅] and [True✅] --->  [True✅] - kod dijalankan
[True✅] and [False❌] --->  [False❌] - kod tidak dijalankan
[False❌] and [True✅] --->  [False❌] - kod tidak dijalankan
[False❌] and [False❌] --->  [False❌] - kod tidak dijalankan

``` 
Contoh kod:

```
saiz_ikan = 20
warna_ikan = "merah"

if saiz_ikan == 20 and warna_ikan == "hijau":
    print("Beli ikan ini.")

else:
    print("Ikan yang anda inginkan tiada dijual")
```
```
Output:

Ikan yang anda inginkan tiada dijual.
```
> `saiz_ikan` -> `True✅` + `warna_ikan` -> `False❌` ==> `False❌`

Jika dilihat didalam kod, walaupun syarat ```saiz_ikan``` adalah ```True```, tetapi disebakan ```warna_ikan``` adalah ```False```, maka keseluruhan penyata dianggap sebagai ```False``` dan kod seterusnya tidak dilaksanakan. Kod yang dilaksanakan adalah daripada penyata ```else``` kerana penyata yang sebelumnya adalah ```False``` maka ```else``` akan mewakili ```True```. 

## Penyata bersyarat tersarang (*nested*)

Penyata bersyarat tersarang secara mudahnya adalah penyata bersyarat di dalam penyata bersyarat. Mari lihat contoh untuk lebih memahami. 

```
saiz_ikan = 20
warna_ikan = "merah"

if saiz_ikan == 20 or warna_ikan == "hijau":
    harga_ikan = int(input("Masukkan harga ikan:"))
    if harga_ikan < 15:
         print("Beli ikan ini.")

elif saiz_ikan < 20:
    print("Ikan terlalu kecil.")

else:
    print("Ikan terlalu besar.")
```

Dalam penyata pertama, saya telah menambah satu lagi penyata bersyarat di dalam penyata bersyarat pertama. Penyata itu mengatakan bahawa jika *input* harga_ikan yang pengguna masukkan adalah lebih rendah daripada 15, barulah *output* ```Beli ikan ini.``` akan terpapar dalam konsol.

Maka disini, adalah tidak mustahil untuk anda meletakkan syarat di dalam syarat untuk kegunaan tertentu. Anda juga boleh memasukkan penyata bersyarat di dalam ```elif``` dan ```else``` sepertimana ```if```.

# Penyata bersyarat tanpa syarat

Walaupun kelihatan aneh, tahukah anda, anda juga boleh menulis sebuah penyata bersyarat tanpa meletakkan syarat?

Mari lihat contoh dibawah.

```
num = 1

if num:
     print("Hello dunia!")
```
```
Output:

Hello dunia!
```

Apa yang berlaku disini? Mengapa program menganggap penyata ini ```True``` dan mengeluarkan *output* walapun tiada syarat yang diletakkan padanya?

Apakah maksud ```if num:```? Penyata ini bermaksud;

>Jika `num` tidak bersamaan dengan nilai sifar atau `None`, maka penyata bersyarat adalah `True` dan juga sebaliknya jika `num` bersamaan dengan sifar atau `None`, maka penyata dianggap sebagai `False`. 

atau boleh juga difahami dengan,

> `if num:` = `if num != 0:` = `if num != None:` 

> `True` --> `num` ada nilai

> `False` --> `num` tiada nilai

Maka, ```if num:``` dalam hal ini adalah ```True``` kerana nilai di dalamnya bukan **sifar, 0** atau ```None```.

Mari lihat kes pemboleh ubah jika nilainya adalah sifar atau `None`.

```
num = None

if num:
    print("Tidak akan dioutput kerana False")

else:
    print("Akan dioutput")
```
```
Output:

Akan dioutput.
```
Melalui kod diatas, output ```Akan dioutput``` terhasil dalam konsol, kerana penyata pertama adalah ```False``` dan kod di dalamnya tidak akan dilaksanakan. Penyata pertama ```False``` kerana pemboleh ubah `num` tidak mempunyai nilai di dalamnya. 

Cara penulisan kod ini selalunya dipakai bagi tujuan menyemak kandungan di dalam sebuah pemboleh ubah atau *list* sama ada mempunyai kandungan ataupun tidak. Dan jika anda kreatif, ada pelbagai lagi kegunaan yang boleh digunakan yang boleh dihasilkan daripadanya.

# Ungkapan Bersyarat (*Conditional Expression*)

Dalam penyata bersyarat, terdapat juga satu lagi cara penulisan Python yang agak berbeza yang dipanggil sebagai **Ungkapan Bersyarat**. 

> Cara penulisan ini adalah dengan menulis kesemua komponen penyata bersyarat di dalama satu barisan (tanpa menggunakan perenggan seperti kebiasaan)

Contoh cara penulisan kod;

```
val = 2

print (val) if  val == 3  else print("val less than 3")  if val > 3 else print("val bigger than 3")

```
Tetapi harus diingat bahawa dalam **Zen of Python** (boleh cuba `import this` untuk lihat Zen yang lain), terdapat satu konsep yang dinamakan *Redibility count*, yang membawa makna kod haruslah **mudah dibaca**. 

Klik untuk baca lebih lanjut:
https://en.wikipedia.org/wiki/Zen_of_Python#:~:text=The%20Zen%20of%20Python%20is,Python%20mailing%20list%20in%201999.

Maka, jika kita ingin menulis ungkapan bersyarat, pendekkan ungkapan seperti berikut,


```
val = 2

print (val) if  val == 3  else print("less than 3")  

if val > 3:
   print("bigger than 3")

```
Kini, kod lebih teratur dan mudah difahami. 😘

# Kesimpulan 

Penyata bersyarat adalah sebuah konsep yang ada dalam mana-mana bahasa pengaturcaraan sekalipun. Dengan memanfaatkan ia, kod akan menjadi lebih dinamik dan mampu mencipta kegunaan tertentu mengikut kehendak pengguna. 

Sampai disini sahaja Python dalam Melayu kali ini. Jika ada sebarang komen, pembetulan atau cadangan, boleh tulis di ruangan komen dibawah. Jika artikel ini bermanfaat, silakan berkongsi dimana-mana sahaja yang anda suka! 🥰

Sampai jumpa, adios! 👋