7. Boolean dan Kondisi

Di bab-bab sebelumnya, Anda telah belajar cara bekerja dengan angka, string, dan operasi data dasar. Sekarang kita siap menjelajahi bagaimana Python membuat keputusan—kemampuan mendasar yang memungkinkan program merespons secara berbeda berdasarkan berbagai kondisi. Inti dari pengambilan keputusan di Python adalah nilai Boolean dan kondisi.

Pikirkan tentang keputusan sehari-hari: "Jika sedang hujan, saya akan membawa payung." "Jika suhu di atas 30°C, saya akan menyalakan AC." Keputusan-keputusan ini didasarkan pada kondisi yang bernilai true atau false. Python menggunakan prinsip yang sama: ia mengevaluasi kondisi untuk menentukan apakah kondisi tersebut true atau false, lalu bertindak sesuai hasilnya.

Di bab ini, kita akan mengeksplorasi nilai Boolean, mempelajari cara membuat kondisi menggunakan operator perbandingan, memahami konsep "truthiness" di Python, dan menemukan teknik-teknik kuat untuk membangun ekspresi logis yang kompleks. Di akhir bab ini, Anda akan menguasai blok bangunan yang dibutuhkan untuk pernyataan if dan loop yang akan Anda pelajari di bab-bab berikutnya.

7.1) Nilai Boolean True dan False

Python memiliki tipe data khusus bernama bool (singkatan dari Boolean) yang merepresentasikan nilai kebenaran. Tipe ini hanya memiliki dua kemungkinan nilai: True dan False. Perhatikan bahwa nilai-nilai ini diawali huruf besar—ini penting di Python. Menulis true atau false (huruf kecil) akan menyebabkan error karena Python tidak akan mengenalinya.

python

# boolean_basics.py
# Membuat variabel Boolean
is_sunny = True
is_raining = False
 
print(is_sunny)    # Output: True
print(is_raining)  # Output: False
 
print(type(True))   # Output: <class 'bool'>
print(type(False))  # Output: <class 'bool'>

Nilai Boolean sangat mendasar karena mereka merepresentasikan hasil dari setiap pertanyaan ya/tidak yang mungkin diajukan program Anda: Apakah angka ini lebih besar dari 10? Apakah string ini berisi huruf 'a'? Apakah pengguna sudah login? Setiap kondisi di Python pada akhirnya dievaluasi menjadi True atau False.

7.1.1) Boolean dalam Variabel dan Ekspresi

Anda dapat menyimpan nilai Boolean dalam variabel sama seperti Anda menyimpan angka atau string. Ini berguna ketika Anda ingin melacak status sesuatu di dalam program:

python

# boolean_variables.py
# Menggunakan variabel Boolean untuk melacak status
is_logged_in = False
has_permission = True
is_valid_email = True
 
print("User logged in:", is_logged_in)        # Output: User logged in: False
print("Has permission:", has_permission)      # Output: Has permission: True
print("Valid email:", is_valid_email)         # Output: Valid email: True
 
# Variabel Boolean dapat diubah nilainya
is_logged_in = True
print("User logged in:", is_logged_in)        # Output: User logged in: True

Variabel Boolean sering dinamai dengan awalan seperti is_, has_, atau can_ untuk memperjelas tujuannya. Konvensi penamaan ini membantu Anda dan orang lain yang membaca kode untuk segera memahami bahwa variabel tersebut menyimpan nilai true/false.

7.2) Operator Perbandingan dan Kondisi Dasar

Walaupun Anda dapat membuat nilai Boolean secara langsung dengan True dan False, sebagian besar nilai Boolean dalam program Anda akan berasal dari perbandingan—menguji hubungan antara nilai-nilai. Python menyediakan beberapa operator perbandingan yang membandingkan dua nilai dan menghasilkan nilai Boolean.

7.2.1) Enam Operator Perbandingan

Python memiliki enam operator perbandingan utama:

Operator	Arti	Contoh	Hasil
`==`	Sama dengan	`5 == 5`	`True`
`!=`	Tidak sama dengan	`5 != 3`	`True`
`<`	Kurang dari	`3 < 5`	`True`
`>`	Lebih besar dari	`5 > 3`	`True`
`<=`	Kurang dari atau sama dengan	`5 <= 5`	`True`
`>=`	Lebih besar dari atau sama dengan	`5 >= 3`	`True`

Mari kita lihat operator-operator ini dalam aksi:

python

# comparison_operators.py
# Membandingkan angka
x = 10
y = 20
 
print(x == y)   # Output: False
print(x != y)   # Output: True
print(x < y)    # Output: True
print(x > y)    # Output: False
print(x <= y)   # Output: True
print(x >= y)   # Output: False
 
# Perbandingan dengan nilai yang sama
a = 15
b = 15
 
print(a == b)   # Output: True
print(a <= b)   # Output: True
print(a >= b)   # Output: True

7.2.2) Membandingkan Angka dan String

Operator perbandingan bekerja dengan banyak tipe nilai, bukan hanya integer:

python

# comparing_types.py
# Membandingkan angka floating-point
temperature = 23.5
print(temperature > 20.0)   # Output: True
print(temperature == 23.5)  # Output: True
 
# Membandingkan string (urutan alfabetis/leksikografis)
name1 = "Alice"
name2 = "Bob"
print(name1 < name2)   # Output: True
print(name1 == name2)  # Output: False
 
# Perbandingan string peka huruf besar-kecil
word1 = "Python"
word2 = "python"
print(word1 == word2)  # Output: False
 
# Membandingkan panjang string menggunakan len()
print(len(name1) == len(name2))  # Output: False

Saat membandingkan string, Python menggunakan urutan leksikografis, yang pada dasarnya adalah urutan alfabet berdasarkan nilai karakter Unicode. Huruf besar muncul sebelum huruf kecil dalam urutan ini, itulah mengapa "Python" dan "python" tidak sama.

7.2.3) Menyimpan Hasil Perbandingan

Hasil dari setiap perbandingan adalah nilai Boolean, artinya Anda dapat menyimpannya dalam variabel:

python

# storing_comparisons.py
# Menyimpan hasil perbandingan untuk digunakan nanti
age = 25
is_adult = age >= 18
is_senior = age >= 65
is_teenager = 13 <= age <= 19  # Kita akan mempelajari perbandingan berantai sebentar lagi
 
print("Is adult:", is_adult)        # Output: Is adult: True
print("Is senior:", is_senior)      # Output: Is senior: False
print("Is teenager:", is_teenager)  # Output: Is teenager: False
 
# Menggunakan hasil perbandingan yang disimpan dalam perhitungan atau ekspresi lain
price = 100
discount_eligible = price > 50
print("Discount eligible:", discount_eligible)  # Output: Discount eligible: True

Menyimpan hasil perbandingan dalam variabel yang dinamai secara deskriptif membuat kode Anda lebih mudah dibaca. Alih-alih berulang kali menulis age >= 18 di seluruh program, Anda dapat menggunakan variabel is_adult, yang dengan jelas mengomunikasikan apa yang sedang Anda cek.

7.3) Boolean dari Perbandingan, Ekspresi, dan Fungsi bool()

Kita telah melihat bahwa perbandingan menghasilkan nilai Boolean. Namun ada cara lain untuk mendapatkan nilai Boolean di Python, termasuk menggunakan fungsi bool() untuk mengonversi tipe lain menjadi Boolean.

7.3.1) Fungsi bool()

Fungsi bool() mengonversi nilai apa pun ke padanan Boolean-nya. Ini berguna ketika Anda ingin secara eksplisit memeriksa apakah suatu nilai akan dianggap true atau false dalam konteks Boolean:

python

# bool_function.py
# Mengonversi angka ke Boolean
print(bool(1))       # Output: True
print(bool(42))      # Output: True
print(bool(-5))      # Output: True
print(bool(0))       # Output: False
print(bool(0.0))     # Output: False
 
# Mengonversi string ke Boolean
print(bool("Hello"))     # Output: True
print(bool("False"))     # Output: True
print(bool(""))          # Output: False
 
# Mengonversi None ke Boolean
print(bool(None))    # Output: False

Fungsi bool() mengikuti aturan tertentu untuk konversi, yang akan kita jelajahi lebih detail di bagian berikutnya tentang truthiness dan falsiness. Untuk saat ini, perhatikan bahwa sebagian besar nilai dikonversi menjadi True, tetapi nilai-nilai khusus seperti 0, 0.0, string kosong (""), dan None dikonversi menjadi False.

7.4) Truthiness dan Falsiness dalam Kondisi

Salah satu fitur terkuat Python adalah konsep truthiness dan falsiness. Di Python, setiap nilai—bukan hanya True dan False—memiliki interpretasi Boolean bawaan. Artinya Anda dapat menggunakan nilai apa pun di tempat yang mengharapkan Boolean, dan Python akan memperlakukannya sebagai true atau false.

7.4.1) Nilai Falsy: Apa Saja yang Dianggap False

Di Python, nilai-nilai berikut dianggap falsy (berperilaku seperti False dalam konteks Boolean):

Nilai Boolean False itu sendiri
Nilai khusus None
Nol numerik dalam bentuk apa pun: 0, 0.0, 0j (nol kompleks)
Sekuens kosong: "" (string kosong), [] (list kosong), () (tuple kosong)
Mapping kosong: {} (dictionary kosong)
Set kosong: set()

Mari kita verifikasi ini dengan fungsi bool():

python

# falsy_values.py
# Semua nilai ini adalah falsy
print("Boolean False:", bool(False))     # Output: Boolean False: False
print("None:", bool(None))               # Output: None: False
print("Zero integer:", bool(0))          # Output: Zero integer: False
print("Zero float:", bool(0.0))          # Output: Zero float: False
print("Empty string:", bool(""))         # Output: Empty string: False
print("Empty list:", bool([]))           # Output: Empty list: False
print("Empty tuple:", bool(()))          # Output: Empty tuple: False
print("Empty dict:", bool({}))           # Output: Empty dict: False

7.4.2) Nilai Truthy: Segala Sesuatu Selain Itu

Setiap nilai lain di Python dianggap truthy (berperilaku seperti True dalam konteks Boolean). Ini termasuk:

Nilai Boolean True itu sendiri
Angka non-nol (positif atau negatif)
String, list, tuple, dictionary, atau set yang tidak kosong
Sebagian besar objek yang Anda buat

python

# truthy_values.py
# Semua nilai ini adalah truthy
print("Boolean True:", bool(True))           # Output: Boolean True: True
print("Positive integer:", bool(42))         # Output: Positive integer: True
print("Negative integer:", bool(-1))         # Output: Negative integer: True
print("Non-zero float:", bool(3.14))         # Output: Non-zero float: True
print("Non-empty string:", bool("Hello"))    # Output: Non-empty string: True
print("String 'False':", bool("False"))      # Output: String 'False': True
print("String '0':", bool("0"))              # Output: String '0': True
print("Non-empty list:", bool([1, 2, 3]))    # Output: Non-empty list: True
print("Non-empty tuple:", bool((1,)))        # Output: Non-empty tuple: True
print("Non-empty dict:", bool({"a": 1}))     # Output: Non-empty dict: True

Catatan penting: String "False" adalah truthy karena ia adalah string yang tidak kosong. String "0" juga truthy karena alasan yang sama. Hanya nilai Boolean False dan nilai numerik 0 yang bersifat falsy.

7.4.3) Mengapa Truthiness Penting

Memahami truthiness itu penting karena ini adalah konsep mendasar di Python yang akan sering Anda temui. Di Bab 8, Anda akan mempelajari pernyataan if yang membuat keputusan berdasarkan kondisi. Pernyataan-pernyataan ini dapat menggunakan nilai apa pun, bukan hanya perbandingan Boolean eksplisit, karena Python secara otomatis mengevaluasi truthiness dari nilai-nilai tersebut.

Truthiness memungkinkan Anda menulis kode ringkas yang memeriksa apakah koleksi berisi item, apakah string memiliki isi, atau apakah nilai opsional tersedia. Berikut sekilas bagaimana truthiness akan berguna (kita akan mempelajari sintaks lengkap pernyataan if di Bab 8):

python

# truthiness_preview.py
# Mendemonstrasikan truthiness dengan bool()
# (Di Bab 8, kita akan menggunakan ini langsung dalam pernyataan if)
 
# Memeriksa apakah sebuah string punya isi
user_input = ""
has_content = bool(user_input)
print("User entered something:", has_content)  # Output: User entered something: False
 
user_input = "Alice"
has_content = bool(user_input)
print("User entered something:", has_content)  # Output: User entered something: True
 
# Memeriksa apakah sebuah list punya item
shopping_list = []
has_items = bool(shopping_list)
print("Shopping list has items:", has_items)  # Output: Shopping list has items: False
 
shopping_list = ["milk", "eggs", "bread"]
has_items = bool(shopping_list)
print("Shopping list has items:", has_items)  # Output: Shopping list has items: True
 
# Memeriksa apakah sebuah nilai ada (bukan None)
optional_value = None
value_exists = bool(optional_value)
print("Value exists:", value_exists)  # Output: Value exists: False

Memahami truthiness membuat kode Anda lebih "Pythonic"—mengikuti konvensi dan idiom Python. Saat Anda melihat pemrogram Python yang berpengalaman memeriksa kondisi tanpa perbandingan eksplisit, mereka memanfaatkan truthiness untuk menulis kode yang lebih bersih dan mudah dibaca.

7.5) Perbandingan Berantai dan Jebakan Umum Boolean

Python menawarkan fitur kuat bernama perbandingan berantai (chained comparisons) yang membuat kondisi tertentu lebih mudah dibaca dan lebih mirip notasi matematika. Namun, fitur ini dan aspek-aspek lain dari logika Boolean juga dapat menyebabkan kesalahan-kesalahan umum.

7.5.1) Perbandingan Berantai

Dalam matematika, Anda mungkin menulis "10 < x < 20" untuk menyatakan bahwa x berada di antara 10 dan 20. Python memungkinkan Anda menulis dengan cara yang persis sama:

python

# chained_comparisons.py
# Memeriksa apakah sebuah nilai berada dalam suatu rentang
x = 15
 
# Cara matematika (perbandingan berantai)
in_range = 10 < x < 20
print("x is between 10 and 20:", in_range)  # Output: x is between 10 and 20: True
 
# Ini setara dengan menggabungkan dua perbandingan
# (Kita akan mempelajari 'and' di Bab 9)
in_range = (10 < x) and (x < 20)
print("x is between 10 and 20:", in_range)  # Output: x is between 10 and 20: True
 
# Menguji dengan nilai di luar rentang
y = 25
in_range = 10 < y < 20
print("y is between 10 and 20:", in_range)  # Output: y is between 10 and 20: False
 
# Menguji dengan nilai batas
z = 10
in_range = 10 < z < 20
print("z is between 10 and 20:", in_range)  # Output: z is between 10 and 20: False
 
# Menyertakan batas dengan <= dan >=
in_range_inclusive = 10 <= z <= 20
print("z is between 10 and 20 (inclusive):", in_range_inclusive)  # Output: z is between 10 and 20 (inclusive): True

Perbandingan berantai bekerja dengan mengevaluasi setiap pasangan item yang berdekatan. Ekspresi 10 < x < 20 dievaluasi sebagai (10 < x) and (x < 20). Semua perbandingan harus bernilai true agar keseluruhan rantai bernilai true.

Anda dapat merangkai lebih dari dua perbandingan:

python

# multiple_chains.py
# Merangkai beberapa perbandingan
a = 5
b = 10
c = 15
d = 20
 
# Memeriksa apakah nilai-nilai dalam urutan naik
ascending = a < b < c < d
print("Values are in ascending order:", ascending)  # Output: Values are in ascending order: True

Berikut representasi visual bagaimana perbandingan berantai bekerja:

7.5.2) Jebakan Umum: Assignment vs Comparison

Salah satu kesalahan paling umum yang dilakukan pemula adalah menggunakan assignment (=) ketika sebenarnya yang dimaksud adalah comparison (==):

python

# assignment_vs_comparison_pitfall.py
x = 10
 
# Ini adalah assignment, bukan comparison
# Ini memberikan nilai 20 ke x, bukan membandingkan x dengan 20
# x = 20  # Ini akan mengubah x menjadi 20
 
# Ini adalah comparison
result = (x == 20)  # Ini memeriksa apakah x sama dengan 20
print("x equals 20:", result)  # Output: x equals 20: False
print("x is now:", x)  # Output: x is now: 10
 
# Di Bab 8, Anda akan belajar bahwa menggunakan = dalam kondisi menyebabkan error
# if x = 20:  # SyntaxError: invalid syntax
#     print("This won't work")
 
# Perbandingan yang benar
# Di Bab 8, Anda akan menulis: if x == 10:
result = x == 10
print("x equals 10:", result)  # Output: x equals 10: True

Python membantu mencegah kesalahan ini dalam pernyataan if (yang akan Anda pelajari di Bab 8) dengan menimbulkan SyntaxError jika Anda menggunakan assignment alih-alih comparison. Namun, dalam konteks lain, menggunakan = saat Anda bermaksud == dapat membuat bug halus yang sulit ditemukan.

7.5.3) Jebakan Umum: Perbandingan Floating-Point

Saat membandingkan angka floating-point, Anda perlu menyadari masalah presisi:

python

# floating_point_comparison.py
# Aritmetika floating-point dapat memiliki masalah presisi
result = 0.1 + 0.2
print("0.1 + 0.2 =", result)  # Output: 0.1 + 0.2 = 0.30000000000000004
 
# Perbandingan langsung mungkin tidak bekerja seperti yang diharapkan
is_equal = (result == 0.3)
print("Result equals 0.3:", is_equal)  # Output: Result equals 0.3: False
 
# Nilai sebenarnya sangat dekat tetapi tidak persis 0.3
print("Difference:", result - 0.3)  # Output: Difference: 5.551115123125783e-17
 
# Untuk perbandingan floating-point, gunakan toleransi kecil
tolerance = 0.0001
is_close = abs(result - 0.3) < tolerance
print("Result is close to 0.3:", is_close)  # Output: Result is close to 0.3: True
 
# Python 3.5+ menyediakan math.isclose() untuk ini
# Kita akan mempelajari tentang mengimpor module di Bab 23
# import math
# is_close = math.isclose(result, 0.3)

Masalah ini muncul karena komputer menyimpan angka floating-point dalam biner, dan beberapa angka desimal (seperti 0.1) tidak dapat direpresentasikan secara tepat dalam biner. Saat Anda melakukan aritmetika dengan angka-angka ini, kesalahan pembulatan kecil terakumulasi. Untuk sebagian besar tujuan praktis, kesalahan ini dapat diabaikan, tetapi mereka dapat menyebabkan perbandingan kesetaraan langsung gagal secara tak terduga.

7.6) Boolean sebagai Integer (1 dan 0) dan Mengapa Anda Harus Menghindari Aritmetika

Ini fakta yang mengejutkan: di Python, True dan False sebenarnya adalah kasus khusus dari integer. True setara dengan 1, dan False setara dengan 0. Ini adalah artefak historis dari desain Python, tetapi memiliki beberapa implikasi menarik. Memahami hubungan ini membantu Anda menghindari kebingungan, tetapi Anda sebaiknya jarang menggunakannya secara langsung dalam kode.

7.6.1) Boolean Adalah Integer

Anda dapat memverifikasi bahwa Boolean adalah integer dengan memeriksa tipenya dan melakukan operasi integer:

python

# booleans_as_integers.py
# Boolean adalah subtipe dari integer
print(isinstance(True, int))   # Output: True
print(isinstance(False, int))  # Output: True
 
# True sama dengan 1, False sama dengan 0
print(True == 1)    # Output: True
print(False == 0)   # Output: True
print(True == 2)    # Output: False
 
# Anda dapat menggunakan Boolean dalam aritmetika (tapi sebaiknya tidak!)
result = True + True
print("True + True =", result)  # Output: True + True = 2
 
result = True + False
print("True + False =", result)  # Output: True + False = 1
 
result = False * 100
print("False * 100 =", result)  # Output: False * 100 = 0
 
# Boolean dapat digunakan sebagai indeks list
items = ["first", "second", "third"]
print(items[False])  # Output: first
print(items[True])   # Output: second

Fungsi isinstance() memeriksa apakah sebuah nilai merupakan instance dari suatu tipe. Saat kita memeriksa isinstance(True, int), Python mengembalikan True karena tipe bool adalah subclass dari tipe int.

7.6.2) Mengapa Anda Harus Menghindari Aritmetika Boolean

Meskipun Python mengizinkan Anda menggunakan Boolean dalam aritmetika, Anda sebaiknya menghindarinya. Menggunakan Boolean sebagai angka membuat kode Anda membingungkan dan lebih sulit dipahami. Hubungan antara Boolean dan integer sebagian besar adalah detail historis yang perlu Anda ketahui, tetapi jarang digunakan secara langsung.

Berikut alasan mengapa aritmetika Boolean bermasalah:

python

# boolean_arithmetic_problems.py
# Contoh kode yang membingungkan
count = 0
has_error = True
has_warning = False
 
# Ini bekerja tetapi membingungkan
total = count + has_error + has_warning
print("Total:", total)  # Output: Total: 1
 
# Apa artinya ini? Tidak jelas!
# Pendekatan yang lebih baik: buat eksplisit
# Kita akan mempelajari ekspresi if-else di Bab 10.
error_count = 1 if has_error else 0
warning_count = 1 if has_warning else 0
total = count + error_count + warning_count
print("Total:", total)  # Output: Total: 1

Satu-satunya pengecualian umum untuk aturan ini adalah saat menghitung nilai True dalam sebuah koleksi:

python

# counting_trues.py
# Menghitung berapa banyak kondisi yang bernilai true
conditions = [True, False, True, True, False]
 
# Ini dapat diterima karena maksudnya jelas
true_count = sum(conditions)
print("Number of true conditions:", true_count)  # Output: Number of true conditions: 3
 
# Ini bekerja karena sum() menjumlahkan nilai-nilai
# True diperlakukan sebagai 1, False sebagai 0
# Jadi sum([True, False, True, True, False]) = 1 + 0 + 1 + 1 + 0 = 3

Dalam kasus ini, menggunakan sum() pada list Boolean adalah idiom Python yang umum dan banyak dipahami. Maksudnya—menghitung berapa banyak kondisi yang bernilai true—jelas dari konteks.

7.6.3) Boolean dalam Konversi Tipe

Karena Boolean adalah integer, mengonversinya ke integer secara eksplisit itu berlebihan:

python

# boolean_conversion.py
# Mengonversi Boolean ke integer (tidak perlu)
value = True
int_value = int(value)
print("Integer value:", int_value)  # Output: Integer value: 1
print("Are they equal?", value == int_value)  # Output: Are they equal? True
 
# Tetapi mengonversi integer ke Boolean itu berguna
number = 0
bool_value = bool(number)
print("Boolean value:", bool_value)  # Output: Boolean value: False
 
number = 42
bool_value = bool(number)
print("Boolean value:", bool_value)  # Output: Boolean value: True

Mengonversi Boolean ke integer dengan int() tidak perlu karena Boolean sudah berperilaku sebagai integer. Namun, mengonversi integer (atau tipe lain) ke Boolean dengan bool() itu berguna ketika Anda ingin secara eksplisit memeriksa truthiness.

7.6.4) Alasan Historis

Alasan Boolean adalah integer di Python bersifat historis. Versi awal Python (sebelum versi 2.3) tidak memiliki tipe Boolean terpisah. Pemrogram menggunakan 1 untuk true dan 0 untuk false. Ketika tipe bool ditambahkan, tipe ini dibuat sebagai subclass dari int untuk mempertahankan kompatibilitas dengan kode yang sudah ada.

Saat ini, Anda sebaiknya memikirkan True dan False sebagai nilai Boolean terlebih dahulu dan terutama. Hubungannya dengan 1 dan 0 adalah detail implementasi yang jarang perlu Anda pikirkan, kecuali ketika Anda menjumpainya di tempat-tempat yang tak terduga.

7.7) Menggunakan in dan not in dalam Kondisi

Operator in dan not in menguji keanggotaan—apakah suatu nilai ada di dalam sebuah koleksi. Operator-operator ini sangat berguna untuk membuat kondisi yang mudah dibaca, terutama saat bekerja dengan string, list, dan koleksi lainnya.

7.7.1) Menguji Keanggotaan dalam String

Operator in memeriksa apakah satu string muncul di dalam string lain:

python

# string_membership.py
# Memeriksa apakah sebuah substring ada di dalam string
text = "Python programming is fun"
 
# Menggunakan 'in' untuk memeriksa substring
has_python = "Python" in text
print("Contains 'Python':", has_python)  # Output: Contains 'Python': True
 
has_java = "Java" in text
print("Contains 'Java':", has_java)  # Output: Contains 'Java': False
 
# Pencocokan peka huruf besar-kecil
has_python_lower = "python" in text
print("Contains 'python':", has_python_lower)  # Output: Contains 'python': False
 
# Menggunakan 'not in' untuk memeriksa ketiadaan
has_no_java = "Java" not in text
print("Does not contain 'Java':", has_no_java)  # Output: Does not contain 'Java': True

Operator in melakukan pencarian yang peka huruf besar-kecil. Jika Anda membutuhkan pencarian yang tidak peka huruf besar-kecil, Anda dapat mengonversi kedua string ke huruf dengan bentuk yang sama:

python

# case_insensitive_search.py
text = "Python Programming"
 
# Pencarian peka huruf besar-kecil (tidak cocok)
result = "python" in text
print("Contains 'python':", result)  # Output: Contains 'python': False
 
# Pencarian tidak peka huruf besar-kecil (konversi keduanya ke huruf kecil)
result = "python" in text.lower()
print("Contains 'python' (case-insensitive):", result)  # Output: Contains 'python' (case-insensitive): True
 
# String asli tidak berubah
print("Original text:", text)  # Output: Original text: Python Programming

7.7.2) Menguji Keanggotaan dalam List

Operator in juga bekerja dengan list (yang akan kita pelajari secara detail di Bab 14):

python

# list_membership.py
# Memeriksa apakah sebuah nilai ada di dalam list
numbers = [1, 2, 3, 4, 5]
 
has_three = 3 in numbers
print("List contains 3:", has_three)  # Output: List contains 3: True
 
has_ten = 10 in numbers
print("List contains 10:", has_ten)  # Output: List contains 10: False
 
# Menggunakan 'not in'
missing_ten = 10 not in numbers
print("List does not contain 10:", missing_ten)  # Output: List does not contain 10: True
 
# Bekerja dengan string dalam list
fruits = ["apple", "banana", "cherry"]
has_banana = "banana" in fruits
print("List contains 'banana':", has_banana)  # Output: List contains 'banana': True
 
has_grape = "grape" in fruits
print("List contains 'grape':", has_grape)  # Output: List contains 'grape': False

7.7.3) Pengujian Keanggotaan dengan Range

Anda juga dapat menggunakan in dengan objek range (yang akan kita pelajari di Bab 12):

python

# range_membership.py
# Memeriksa apakah sebuah angka ada dalam range
age = 25
 
# Menggunakan 'in' dengan range
is_adult = age in range(18, 100)
print("Is adult:", is_adult)  # Output: Is adult: True
 
# Namun, operator perbandingan lebih efisien untuk rentang numerik
is_adult = 18 <= age < 100
print("Is adult:", is_adult)  # Output: Is adult: True
 
# 'in' dengan range berguna untuk sekuens tertentu
valid_ages = range(18, 66)  # Rentang usia kerja
is_working_age = age in valid_ages
print("Is working age:", is_working_age)  # Output: Is working age: True

7.7.4) Operator not in

Operator not in adalah kebalikan dari in—mengembalikan True jika nilai TIDAK ditemukan dalam koleksi:

python

# not_in_operator.py
# Menggunakan 'not in' untuk logika yang lebih jelas
allowed_users = ["alice", "bob", "charlie"]
current_user = "eve"
 
# Menggunakan 'not in' lebih mudah dibaca
is_unauthorized = current_user not in allowed_users
print("User is unauthorized:", is_unauthorized)  # Output: User is unauthorized: True
 
# Memeriksa field yang wajib tetapi belum ada
provided_fields = ["name", "email"]
 
# Mencari field yang hilang
missing_name = "name" not in provided_fields
missing_email = "email" not in provided_fields
missing_password = "password" not in provided_fields
 
print("Missing name:", missing_name)      # Output: Missing name: False
print("Missing email:", missing_email)    # Output: Missing email: False
print("Missing password:", missing_password)  # Output: Missing password: True

Operator in dan not in membuat kondisi Anda lebih mudah dibaca dan ekspresif. Alih-alih menulis perbandingan yang kompleks, Anda dapat langsung menyatakan "apakah nilai ini ada di koleksi ini?" yang sesuai dengan cara Anda memikirkan masalahnya.

Di bab ini, Anda telah mempelajari dasar-dasar nilai Boolean dan kondisi di Python. Anda sekarang memahami:

Nilai Boolean True dan False dan perannya dalam pengambilan keputusan
Operator perbandingan (==, !=, <, >, <=, >=) untuk membuat kondisi
Fungsi bool() untuk mengonversi nilai ke Boolean
Truthiness dan falsiness—bagaimana Python memperlakukan semua nilai sebagai true atau false
Perbandingan berantai untuk pengecekan rentang yang mudah dibaca
Jebakan umum yang perlu dihindari saat bekerja dengan Boolean
Hubungan antara Boolean dan integer (dan mengapa harus menghindari aritmetika Boolean)
Pengujian keanggotaan dengan operator in dan not in

Konsep-konsep ini membentuk fondasi untuk struktur alur kontrol yang akan Anda pelajari di bab-bab berikutnya. Di Bab 8, Anda akan menggunakan ekspresi Boolean dalam pernyataan if untuk membuat program merespons kondisi yang berbeda. Di Bab 9, Anda akan belajar menggabungkan beberapa kondisi menggunakan operator logika seperti and, or, dan not. Dan di Bab 10 dan 11, Anda akan menggunakan kondisi untuk mengontrol loop yang mengulang aksi.

Memahami Boolean dan kondisi sangat penting untuk menulis program yang dapat membuat keputusan, memvalidasi input, dan merespons berbagai situasi dengan tepat. Latihlah bekerja dengan konsep-konsep ini, dan Anda akan mendapati bahwa pengambilan keputusan di Python menjadi hal yang alami dan intuitif.