# Pemboleh Ubah dalam Python 🐍

Hai semua, kembali lagi dalam Python dalam Bahasa Melayu!🤩 

Hari ini saya akan terangkan sedikit salah satu asas mengenai bahasa pengaturcaraan Python iaitu Pemboleh Ubah (PU) atau dalam bahasa Inggerisnya,*Variable*. 

Secara amnya, PU adalah sebuah nama yang menyimpan nilai yang mempunyai banyak bentuk, sama ada nombor (*interger*) atau tetangsi (*string*).

Mari lihat contoh mudah kod PU. 

```
 x = 3
```
Dalam kod di atas, PU-x telah menyimpan sebuah nilai iaitu nombor 3. Bagi menyimpan tetangsi pula, PU ditulis seperti berikut

```
nama = "Hai, nama saya Ammar."
```
String adalah sebuah *item* yang ditulis dengan pembuka dan penutup kata. PU-nama menyimpan sebuah nilai tetangsi iaitu ```"Hai, nama saya Ammar."``` 

Bagi menghasilkan *output* kod, anda harus menggunakan arahan ```print()``` kepada PU tadi. 
```
print(x)
print(y)

```
```
Output:
3
Hai, nama saya Ammar.

```
Sekarang, anda sudah faham apa yang dimaksudkan dengan Pemboleh Ubah. Mari kita pergi ke bentuk evolusi PU yang mempunyai empat jenis iaitu:

• Tuple
• List
• Dictionary 
• Set 

### 1. Tuple

*Tuple* adalah sebuah PU yang ditulis menggunakan **braket lengkung** -- (  ) -- untuk menyimpan pelagai informasi sama ada berbentuk nombor, tetangsi dan sebagainya.

*Tuple* tidak boleh digubah menggunakan arahan Python, melainkan anda sendiri memadam informasi tersebut daripada *tuple*. Ia juga berada dalam keadaan tersusun walaupun tidak dilabel dengan apa-apa.

Contoh *tuple*:

```
air_minuman = ("Sirap", "Teh Ais", "Milo", "Kopi-O")
print(air_minuman)
```
```
Output:
("Sirap", "Teh Ais", "Milo", "Kopi-O")
```

Di dalam PU-air_minuman, pelbagai jenis minuman disimpan di dalamnya. Biasanya *Tuple* digunakan pada awal pembelajaran Python kerana konsepnya yang mudah untuk menyimpan pelbagai nilai; dan tidak mempunyai ada-apa metod untuk mengubahnya. 

Tetapi, semakin lama anda mempelajari Python, anda akan lebih kerap menggunakan satu bentuk lagi iaitu, *List*.

### 2. List

*List* adalah sebuah bentuk PU yang menggunakan **braket petak** -- [ ] -- untuk menyimpan data informasi. 

Data akan disimpan dalam dilabel menggunakan label **indeks** (bermula dari 0) yang bertujuan untuk memudahkan pengaturcara bagi merujuknya kembali. Analogi yang mudah adalah seperti adik beradik yang dilabel menggunakan gelaran anak pertama, anak kedua, anak ketiga dan seterusnya. 


![family-gb9f97bb93_1920.jpg](https://cdn.hashnode.com/res/hashnode/image/upload/v1636555296039/WUVOKEY9n.jpeg)

> Contoh keluarga dengan adik beradik 3 orang.

Contoh kod *list*;

```
nom = [1, 2, 3, 4,5]

```
```
menu_burger = ["daging", "ayam", "special", "double", "kahwin"]
```
```
mix = [1, "nasi", 2, "ayam", "sayur", 45]
```
Anda dapat lihat di atas terdapat 3 jenis *list* yang menyimpan nilai dalam bentuk nombor dan tetangsi. Anda  boleh mencampurkan keduanya di dalam satu *list*.

Anda telah lihat kesemua jenis *list* yang anda boleh tulis. Dan seperti yang telah saya perkatakan tadi, *list* menggunakan **indeks** bagi melabel setiap *item* yang berada di dalamnya. 

Anda boleh menyeru setiap data menggunakan label indeks seperti kod dibawah.

```
menu_burger = ["daging", "ayam", "special", "double", "kahwin"]

print(menu_burger[0])
print(menu_burger[1])
print(menu_burger[2])

```
```
Output:
daging
ayam 
special
```
Jika kita rujuk kepada *list* ```menu_burger``` di atas, anda dapat lihat, ```daging``` dilabel dengan indeks [0], ```ayam``` dilabel dengan indeks [1], dan ```special``` dilabel dengan indeks [2]. Dengan cara ini, anda boleh mengakses mana-mana kandungan di dalam *list* menggunakan nombor yang telah ditetapkan. 

Penyimpanan maklumat ini juga dikenali sebagai *array*. 

### 3. Dictionary 

*Dictionary* adalah sebuah bentuk PU yang menggunakan **kurungan keriting** -- { } -- bagi membentuknya. *Dictionary* menggunakan konsep pasangan **kunci-nilai** (*key-value*) yang mana kunci digunakan sebagai label kepada nilai. 
```
nama_dict = {"kunci" : "nilai"}
```

Mari lihat contoh dibawah;

```
dict_kereta = { "nama" : "Kancil", "jenama" : "Produa", "buatan" : "Malaysia"}

print(dict_kereta)
```
```
Output:
{ "nama":"Kancil", "jenama":"Produa", "buatan":"Malaysia"}
```
Jika tadi pada *list* anda boleh menyeru nilai menggunakan nilai [indeks], dalam *dictionary* pula anda boleh menyeru **kunci** kepada nilai tersebut. 

Lihat kod dibawah;

```
print(dict_kereta["jenama"]
```
```
Output:
Produa
```

Dengan menggunakan *dictionary* cara penulisan data anda lebih bebas pada aspek pelabelan nilai kerana anda boleh menentukan sendiri apakah **kunci** yang anda inginkan. Namun, jika label tidak penting untuk data anda, anda boleh menggunakan *list* sebagai alternatif.

Ciri *Dictionary* adalah ia boleh diubah menggunakan arahan Python dan tidak membenarkan nilai yang sama ditulis berulang. 


### 4. Set 

*Set* pula mempunyai struktur seperti *dictionary* tetapi tidak mempunyai kunci. Fungsinya pula sama seperti *tuple* iaitu menyimpan pelbagai data di dalam PU, tetapi ianya tidak berada dalam keadaan tersusun seperti *tuple*.

Contoh *set*;

```
buah = { "pisang", "manggis", "cempedak"}

print(buah)
```
```
{"cempedak", "pisang", "manggis"}
```
Disebabkan *set* mempunyai ciri tidak tersusun, maka *output* yang terhasil adalah rawak dan tidak mengikut yang asal.

Penggunaan *set* adalah jarang dalam pengaturcaraan kerana kurang memberi kelebihan kepada pengaturcara. Jika anda menjumpai kod yang mampu memanfaatkan bentuk *set* sila komen dibawah! 😁

### Kesimpulan

Pemboleh ubah adalah asas yang penting untuk difahami di dalam pengaturcaraan. Ia diguna meluas lagi-lagi untuk menyimpan sebuah kod yang besar sekaligus mewakili kod-kod tersebut. 

Memahami *tuple*, *list*, *dictionary* dan *set* juga satu kemestian kerana ia digunakan untuk tujuan berbeza dengan kegunaan yang tersendiri. 

Setakat itu sahaya daripada saya. 

Teruskan belajar dan menjelajah dunia pengaturcaraan. Selamat berkoding! 👩‍💻