# Operator Python: aritmetika, pembagian // dan %, perbandingan, and/or/not dan python round

URL: https://skillaria.top/id/guides/python/operator-python-round

Operator / di Python selalu menghasilkan float, // membagi bulat dengan pembulatan ke bawah, % adalah sisa bagi, dan ** adalah pangkat. Fungsi round(x, n) membulatkan ke n angka desimal secara banker's rounding: round(2.5) hasilnya 2, round(3.5) hasilnya 4; pembulatan ke atas dan ke bawah ke bilangan bulat dilakukan oleh math.ceil dan math.floor, nilai mutlak oleh abs.

Operator Python adalah simbol yang mengubah nilai menjadi nilai baru: `+` menjumlahkan, `//` membagi bulat, `and` menggabungkan kondisi. Di bawah ini daftar lengkap operator beserta contohnya, perbedaan `/` dan `//`, logika `and`, `or`, `not`, serta fungsi pembulatan: python round, `math.ceil`, `math.floor`, dan `abs`. Semua contoh bisa langsung dicoba di REPL.

## Daftar operator Python

Operator dikelompokkan menurut fungsinya. Tidak perlu menghafal seluruh tabel: di kode sehari-hari yang paling sering muncul adalah aritmetika, perbandingan, dan penghubung logika.

| Kelompok | Operator | Contoh |
| --- | --- | --- |

| Aritmetika | `+ - * / // % **` | `7 // 2` → 3 |

| Perbandingan | `== != < > <= >=` | `3 < 5` → True |

| Logika | `and or not` | `not True` → False |

| Identitas | `is`, `is not` | `x is None` |

| Keanggotaan | `in`, `not in` | `"kopi" in "kopi susu"` → True |

| Penugasan | `= += -= *= /= //= %= **=` | `total += 250` |

| Walrus | `:=` | `if (n := len(s)) > 10:` |

| Bitwise | `& | ^ ~ << >>` | `5 & 3` → 1 |

## Operator aritmetika

Penjumlahan, pengurangan, dan perkalian bekerja seperti di sekolah. Jika salah satu operand adalah `float`, hasilnya juga `float`: `2 + 1.0` menghasilkan `3.0`. Bilangan bulat di Python tidak mengalami overflow — `2 ** 100` dihitung dengan tepat, berapa pun jumlah digitnya.

```
>>> 250 + 120
370
>>> 12.5 * 3
37.5
>>> 2 ** 10
1024
>>> 2 ** 0.5
1.4142135623730951
```

### Pangkat di Python: operator **

Pangkat ditulis dengan dua tanda bintang, bukan `^`: di Python `^` adalah XOR bitwise, sehingga `2 ^ 3` menghasilkan 1, bukan 8. Pangkat pecahan menghasilkan akar: `9 ** 0.5` sama dengan `3.0`. Ada juga fungsi `pow(x, y)` — hasilnya sama, dengan tambahan argumen ketiga untuk sisa bagi: `pow(2, 10, 1000)` menghasilkan 24.

Perhatikan prioritas: `**` dikerjakan sebelum minus unary, sehingga `-2 ** 2` sama dengan `-4`. Untuk mengkuadratkan bilangan negatif, tulis kurung: `(-2) ** 2`.

## Pembagian di Python: /, // dan %

Di Python ada dua jenis pembagian, dan inilah sumber kejutan terbesar bagi pemula. Pembagian biasa `/` selalu menghasilkan `float`, bahkan jika hasilnya bulat. Pembagian bulat `//` membuang bagian desimal, sedangkan `%` menghasilkan sisa bagi.

```
>>> 7 / 2
3.5
>>> 8 / 2
4.0
>>> 7 // 2
3
>>> 7 % 2
1
```

### Pembagian bulat // dan sisa bagi %: praktik

Pasangan `//` dan `%` menjawab pertanyaan «berapa utuh dan berapa sisanya». Di kursus, pelacak pengeluaran menyimpan uang dalam satuan terkecil agar tidak kehilangan ketelitian, lalu memisahkan jumlahnya menjadi rupiah dan sen:

```
cents = 125050            # simpan uang dalam sen
whole = cents // 100      # 1250 — bagian utuh
rest = cents % 100        # 50 — sisa
print(whole, rest)        # 1250 50

print(40 // 7, "minggu dan", 40 % 7, "hari")   # 5 minggu dan 5 hari
```

Kedua hasil sekaligus diberikan oleh fungsi bawaan `divmod`: `divmod(125050, 100)` menghasilkan tuple `(1250, 50)`. Sisa bagi juga berguna untuk mengecek bilangan genap: `n % 2 == 0` bernilai benar untuk bilangan genap.

### Bilangan negatif: // membulatkan ke bawah

Operator `//` tidak sekadar membuang pecahan, melainkan membulatkan ke bawah, menuju minus tak hingga. Untuk bilangan positif tidak ada bedanya, tetapi untuk bilangan negatif berbeda. Tanda sisa bagi `%` di Python mengikuti tanda pembaginya, sehingga selalu berlaku `a == (a // b) * b + a % b`.

```
>>> -7 // 2
-4
>>> -7 % 2
1
>>> int(-7 / 2)     # membuang pecahan, bukan membulatkan ke bawah
-3
```

### Pembagian dengan nol: error apa yang muncul

Pembagian dengan nol oleh ketiga operator tersebut memunculkan exception `ZeroDivisionError`. Ini berlaku untuk bilangan bulat maupun pecahan. Error bisa ditangkap dengan `try/except`, atau diperiksa lebih dulu dengan mengecek pembaginya.

```
>>> 10 / 0
Traceback (most recent call last):
  ...
ZeroDivisionError: division by zero
>>> count = 0
>>> avg = 1500 / count if count else 0
>>> avg
0
```

## Operator perbandingan

Perbandingan menghasilkan `True` atau `False`. Kesamaan diperiksa dengan dua tanda `==`, sedangkan satu `=` adalah penugasan. String dibandingkan karakter demi karakter berdasarkan kode karakternya, sehingga `"B" < "a"` benar: huruf kapital berada sebelum huruf kecil.

```
>>> 250 == 250.0
True
>>> 3 != 4
True
>>> 1 < 5 > 0.1 + 0.2 == 0.3
False
```

Rantai perbandingan seperti `0 <= x < 100` adalah fitur praktis Python: tidak perlu menulis `and`. Baris terakhir mengingatkan tentang ketidaktepatan bilangan pecahan: `0.1 + 0.2` menghasilkan `0.30000000000000004`. Bandingkan bilangan pecahan dengan `math.isclose(a, b)`, dan simpan uang dalam sen atau dengan `Decimal`.

## Operator logika and, or, not

Operator logika di Python ditulis sebagai kata, bukan simbol `&&` dan `||` seperti di bahasa lain. `and` benar jika kedua sisinya benar, `or` benar jika salah satunya benar, dan `not` membalik nilai.

| a | b | a and b | a or b | not a |
| --- | --- | --- | --- | --- |

| True | True | True | True | False |

| True | False | False | True | False |

| False | True | False | True | True |

| False | False | False | False | True |

Prioritas: pertama `not`, lalu `and`, lalu `or`. Ekspresi `True or False and False` bernilai `True`, karena `and` dikerjakan lebih dulu. Pada kondisi yang rumit, gunakan kurung — lebih jelas bagi Anda maupun rekan kerja.

### Apa sebenarnya yang dikembalikan and dan or

`and` dan `or` tidak selalu mengembalikan `True` atau `False`, melainkan salah satu operand. `or` mengembalikan nilai benar pertama (atau yang terakhir jika tidak ada yang benar), `and` mengembalikan nilai salah pertama (atau yang terakhir). Nilai yang dianggap salah adalah `0`, `0.0`, string kosong, koleksi kosong, `None`, dan `False`.

```
>>> name = ""
>>> name or "Tamu"
'Tamu'
>>> 5 and 0
0
>>> not ""
True
```

Evaluasinya malas: jika hasil sudah pasti dari sisi kiri, sisi kanan tidak dihitung. Karena itu `count and total / count` tidak akan gagal dengan pembagian nol saat `count == 0`. Operator `not`, berbeda dengan dua lainnya, selalu mengembalikan `bool`.

## Operator is dan in

`==` membandingkan nilai, sedangkan `is` memeriksa apakah dua nama menunjuk ke objek yang sama. Dua keranjang kosong yang berbeda itu sama, tetapi bukan satu objek. Satu-satunya tempat `is` dipakai terus-menerus adalah pemeriksaan `None`: `if x is None`.

```
>>> a = [250, 120]
>>> b = [250, 120]
>>> a == b, a is b
(True, False)
>>> c = a
>>> c is a
True
```

Jangan membandingkan angka dan string dengan `is`: kadang hasilnya tampak benar karena cache objek internal, tetapi itu bergantung pada implementasi, dan Python memberi `SyntaxWarning` untuk konstruksi seperti `x is 5`.

Operator `in` memeriksa keanggotaan: substring dalam string, elemen dalam list, kunci dalam dictionary. `not in` adalah kebalikannya.

```
>>> "kopi" in "kopi susu"
True
>>> "makanan" in {"makanan": 450, "taksi": 300}
True
>>> 5 not in [1, 2, 3]
True
```

## Operator penugasan dan operator walrus :=

Operator gabungan `+=`, `-=`, `*=`, `//=`, dan lainnya adalah singkatan: `total += 250` berarti `total = total + 250`. Python tidak punya `++` dan `--`: menulis `x++` menghasilkan error sintaksis.

Operator walrus `:=` (dinamai karena menyerupai mata dan gading walrus) memberikan nilai langsung di dalam ekspresi. Ini berguna ketika nilai perlu diperiksa sekaligus dipakai:

```
items = ["kopi", "taksi", "makan siang", "bioskop"]
if (n := len(items)) > 3:
    print(f"Terlalu banyak pengeluaran: {n}")

while (line := input("Jumlah: ")) != "":
    print(int(line) * 2)
```

Tanpa walrus, `len` harus dipanggil dua kali atau penugasannya ditulis di baris terpisah. Jangan berlebihan memakainya: jika baris menjadi sulit dibaca, penugasan biasa lebih baik.

## Pembulatan di Python: round, ceil, floor

Untuk pembulatan, Python menyediakan fungsi bawaan `round` dan fungsi dari modul `math`. Keduanya memecahkan masalah yang berbeda, dan sering tertukar.

| Fungsi | Apa yang dilakukan | 2.5 | -2.5 | 2.7 |
| --- | --- | --- | --- | --- |

| `round(x)` | ke yang terdekat, separuh ke angka genap | 2 | -2 | 3 |

| `math.floor(x)` | ke bawah, menuju minus tak hingga | 2 | -3 | 2 |

| `math.ceil(x)` | ke atas, menuju plus tak hingga | 3 | -2 | 3 |

| `math.trunc(x)`, `int(x)` | membuang pecahan, menuju nol | 2 | -2 | 2 |

### Fungsi round di Python dan pembulatan banker

Fungsi `round(x, n)` membulatkan sampai `n` angka di belakang koma; tanpa argumen kedua, hasilnya bilangan bulat `int`. Jebakan utamanya: python round membulatkan secara «banker's rounding» — separuh ke angka genap terdekat. Karena itu `round(2.5)` menghasilkan 2, dan `round(3.5)` menghasilkan 4. Dengan cara ini kesalahan pembulatan tidak menumpuk ke satu arah pada perhitungan besar.

```
>>> round(2.5), round(3.5)
(2, 4)
>>> round(3.14159, 2)
3.14
>>> round(1250, -2)     # ke ratusan
1200
>>> round(2.675, 2)     # bukan 2.68: dalam biner nilainya 2.67499...
2.67
```

Jika Anda membutuhkan pembulatan «separuh ke atas» yang biasa dipakai di struk, gunakan `Decimal` dengan mode `ROUND_HALF_UP`. Berikan angkanya sebagai string agar tidak ikut membawa galat `float`:

```
>>> from decimal import Decimal, ROUND_HALF_UP
>>> Decimal("2.5").quantize(Decimal("1"), ROUND_HALF_UP)
Decimal('3')
>>> Decimal("2.675").quantize(Decimal("0.01"), ROUND_HALF_UP)
Decimal('2.68')
```

Ada satu aturan lagi dari kursus: bulatkan hanya saat menampilkan. Untuk cetakan yang rapi tidak perlu `round` — cukup f-string: `f"{amount:.2f}"` menampilkan dua angka di belakang koma, sementara nilainya tetap tepat.

### math.ceil dan math.floor: pembulatan ke atas dan ke bawah

`math.ceil` dibutuhkan ketika «kurang» tidak boleh terjadi: berapa bus yang harus dipesan, berapa halaman yang dibutuhkan. `math.floor` dipakai saat hanya satuan penuh yang dihitung. Kedua fungsi mengembalikan `int`.

```
import math

guests = 47
seats = 20
print(math.ceil(guests / seats))   # 3 bus
print(math.floor(9.99))            # 9
print(-(-guests // seats))         # 3 — ceil tanpa math, dengan trik //
```

Modul `math` punya fungsi berguna lain: `math.sqrt` (akar), `math.isclose` (perbandingan pecahan), `math.pi`, `math.gcd`. Di Python 3.15 muncul submodul `math.integer` (PEP 791) untuk matematika bilangan bulat: di dalamnya ada `comb`, `factorial`, `gcd`, `isqrt`, `lcm`, `perm`, sedangkan `math.gcd` dan yang lain tetap berfungsi.

## Fungsi abs: nilai mutlak

`abs(x)` mengembalikan nilai mutlak — jarak dari nol tanpa tanda. Tidak perlu impor, fungsinya bawaan. Berlaku untuk bilangan bulat, pecahan, bahkan kompleks: untuk `3+4j` hasilnya panjang vektornya, yaitu `5.0`.

```
>>> abs(-250)
250
>>> abs(-12.5)
12.5
>>> budget, spent = 5000, 5320
>>> abs(budget - spent)    # seberapa jauh meleset
320
```

Penggunaan tipikalnya adalah selisih tanpa memperhatikan arah, dan perbandingan dengan toleransi: `abs(a - b) < 0.001`. Untuk pecahan, `math.isclose` lebih andal karena memperhitungkan skala bilangan.

## Prioritas operator

Ketika ada beberapa operator dalam satu ekspresi, Python mengerjakannya menurut prioritas — dari yang tertinggi ke yang terendah:

1. `**`
2. unary `-x`, `+x`, `~x`
3. `* / // %`
4. `+ -`
5. pergeseran dan operasi bitwise
6. perbandingan, `in`, `is`
7. `not`
8. `and`
9. `or`
10. `:=`

Jadi `2 + 3 * 4` sama dengan 14, sedangkan `(2 + 3) * 4` sama dengan 20. Jika ragu, tulis kurung: kurung berlebih tidak merugikan, tetapi kesalahan prioritas sulit dicari.

## Kesalahan umum dengan operator

| Kesalahan | Yang terjadi | Cara yang benar |
| --- | --- | --- |

| `if x = 5:` | SyntaxError: ini penugasan | `if x == 5:` |

| `2 ^ 3` sebagai pangkat | XOR bitwise, hasilnya 1 | `2 ** 3` |

| mengharapkan bilangan bulat dari `8 / 2` | mendapat `4.0` | `8 // 2` |

| `x == 1 or 2` | selalu benar: `or 2` | `x in (1, 2)` |

| mengharapkan 3 dari `round(2.5)` | banker's rounding menghasilkan 2 | `Decimal` dengan `ROUND_HALF_UP` |

| `"5" + 5` | TypeError | `int("5") + 5` |

## Kesimpulan

Ingat hal utamanya: `/` selalu menghasilkan float, `//` membulatkan ke bawah, `%` menghasilkan sisa bagi dengan tanda pembagi, dan pangkat adalah `**`. Operator logika `and`, `or`, `not` ditulis sebagai kata dan dievaluasi secara malas, sedangkan `is` diperlukan untuk pemeriksaan `None`. Fungsi python round membulatkan ke angka genap, untuk pembulatan ke atas dan ke bawah ada `math.ceil` dan `math.floor`, dan nilai mutlak diberikan oleh `abs`. Di kursus, operator ini dipraktikkan pada pelacak pengeluaran, tempat uang disimpan dalam satuan sen.

## FAQ

**Bagaimana membulatkan angka di Python sampai dua angka di belakang koma?**

Gunakan round(x, 2). Jika hanya ingin menampilkannya dengan rapi, pakai f-string f"{x:.2f}", yang tidak mengubah nilai aslinya.

**Mengapa round(0.5) di Python menghasilkan 0?**

Karena round membulatkan separuh ke angka genap terdekat, dan 0 adalah genap; demikian pula round(1.5) dan round(2.5) menghasilkan 2.

**Bagaimana mendapatkan bagian bulat dari pembagian di Python?**

Dengan operator //: 17 // 5 menghasilkan 3. Untuk bilangan negatif operator ini membulatkan ke bawah, sehingga -17 // 5 menghasilkan -4; jika ingin membuang pecahan menuju nol, gunakan int(-17 / 5).

**Apakah Python punya operator ternary?**

Ya, berupa ekspresi kondisional: nilai_jika_benar if kondisi else nilai_jika_salah, misalnya "genap" if n % 2 == 0 else "ganjil".

**Apa beda & dan and di Python?**

and adalah operator logika dengan evaluasi malas, sedangkan & adalah AND bitwise untuk angka dan irisan untuk himpunan; dalam kondisi if gunakan and.


---
Source: Skillaria.Top (https://skillaria.top)