Seleksi Kondisi #

Pengertian #

Seleksi kondisi di Python adalah cara untuk membuat keputusan dalam kode program berdasarkan kondisi tertentu. Seleksi kondisi memungkinkan eksekusi kode yang berbeda tergantung pada apakah kondisi tersebut benar (True) atau salah (False). Python mendukung beberapa bentuk seleksi kondisi, termasuk pernyataan if, elif, dan else.

Struktur #

1. Pernyataan if: Mengevaluasi suatu kondisi dan mengeksekusi blok kode jika kondisi tersebut benar.
2. Pernyataan elif (else if): Mengevaluasi kondisi lain jika kondisi sebelumnya salah.
3. Pernyataan else: Mengeksekusi blok kode jika semua kondisi sebelumnya salah.

Penggunaan #

if #

x = 10
if x > 5:
    print("x lebih besar dari 5")

Dalam contoh di atas, pesan “x lebih besar dari 5” akan dicetak karena kondisi x > 5 adalah benar.

if dan else #

x = 3
if x > 5:
    print("x lebih besar dari 5")
else:
    print("x tidak lebih besar dari 5")

Dalam contoh di atas, pesan “x tidak lebih besar dari 5” akan dicetak karena kondisi x > 5 adalah salah.

if, elif, dan else #

x = 5
if x > 5:
    print("x lebih besar dari 5")
elif x == 5:
    print("x sama dengan 5")
else:
    print("x kurang dari 5")

Dalam contoh di atas, pesan “x sama dengan 5” akan dicetak karena kondisi x == 5 adalah benar.

Bersarang #

Anda dapat membuat seleksi kondisi di dalam seleksi kondisi lain.

x = 10
y = 20
if x > 5:
    if y > 15:
        print("x lebih besar dari 5 dan y lebih besar dari 15")
    else:
        print("x lebih besar dari 5 tetapi y tidak lebih besar dari 15")
else:
    print("x tidak lebih besar dari 5")

Dalam contoh di atas, pesan “x lebih besar dari 5 dan y lebih besar dari 15” akan dicetak karena kedua kondisi adalah benar.

Logika Kompleks #

Anda dapat menggunakan operator logika seperti and, or, dan not untuk membuat kondisi yang lebih kompleks.

x = 10
y = 20
if x > 5 and y > 15:
    print("x lebih besar dari 5 dan y lebih besar dari 15")
elif x > 5 or y > 15:
    print("Salah satu dari x lebih besar dari 5 atau y lebih besar dari 15")
else:
    print("x tidak lebih besar dari 5 dan y tidak lebih besar dari 15")

Dalam contoh di atas, pesan “x lebih besar dari 5 dan y lebih besar dari 15” akan dicetak karena kedua kondisi dalam and adalah benar.

Fungsi #

Seleksi kondisi sering digunakan dalam fungsi untuk mengontrol alur program berdasarkan parameter yang diberikan.

def cek_angka(angka):
    if angka > 0:
        return "Positif"
    elif angka < 0:
        return "Negatif"
    else:
        return "Nol"

print(cek_angka(10))  # Output: Positif
print(cek_angka(-5))  # Output: Negatif
print(cek_angka(0))   # Output: Nol

Input Pengguna #

Seleksi kondisi dapat digunakan untuk membuat keputusan berdasarkan input dari pengguna.

umur = int(input("Masukkan umur Anda: "))
if umur < 18:
    print("Anda masih di bawah umur.")
elif umur >= 18 and umur <= 65:
    print("Anda seorang dewasa.")
else:
    print("Anda seorang lansia.")

Dalam contoh di atas, program akan mencetak pesan yang sesuai berdasarkan umur yang dimasukkan oleh pengguna.

Ternary Operator #

Python juga mendukung operator ternary untuk seleksi kondisi sederhana dalam satu baris.

x = 10
status = "Positif" if x > 0 else "Negatif atau Nol"
print(status)  # Output: Positif

Match-Case #

match-case adalah fitur baru yang diperkenalkan di Python 3.10 sebagai bagian dari PEP 634. Ini adalah implementasi dari “Structural Pattern Matching” yang memungkinkan penulisan kode yang lebih bersih dan lebih ekspresif untuk berbagai kasus kondisional, mirip dengan switch-case di beberapa bahasa pemrograman lain. match-case memungkinkan Anda untuk mencocokkan pola kompleks dalam data.

Struktur #

match variabel:
    case pola1:
        # Blok kode untuk pola1
    case pola2:
        # Blok kode untuk pola2
    case _:
        # Blok kode untuk default

Penggunaan #

Pencocokan Nilai #

def describe_number(x):
    match x:
        case 0:
            return "Nol"
        case 1:
            return "Satu"
        case _:
            return "Angka lain"

print(describe_number(0))  # Output: Nol
print(describe_number(1))  # Output: Satu
print(describe_number(42))  # Output: Angka lain

Pencocokan Struktur Data #

def describe_point(point):
    match point:
        case (0, 0):
            return "Titik asal"
        case (0, y):
            return f"Sumbu y pada {y}"
        case (x, 0):
            return f"Sumbu x pada {x}"
        case (x, y):
            return f"Titik pada ({x}, {y})"
        case _:
            return "Bukan titik dalam 2D"

print(describe_point((0, 0)))  # Output: Titik asal
print(describe_point((0, 5)))  # Output: Sumbu y pada 5
print(describe_point((3, 0)))  # Output: Sumbu x pada 3
print(describe_point((3, 4)))  # Output: Titik pada (3, 4)
print(describe_point((3, 4, 5)))  # Output: Bukan titik dalam 2D

Pencocokan Kondisi Tambahan #

def describe_number(x):
    match x:
        case x if x < 0:
            return "Negatif"
        case x if x == 0:
            return "Nol"
        case x if x > 0:
            return "Positif"

print(describe_number(-1))  # Output: Negatif
print(describe_number(0))   # Output: Nol
print(describe_number(1))   # Output: Positif

Pencocokan Dictionary #

def describe_person(person):
    match person:
        case {"name": name, "age": age} if age < 18:
            return f"{name} adalah anak-anak."
        case {"name": name, "age": age} if age >= 18:
            return f"{name} adalah orang dewasa."
        case _:
            return "Tidak dikenal"

person1 = {"name": "Alice", "age": 17}
person2 = {"name": "Bob", "age": 22}

print(describe_person(person1))  # Output: Alice adalah anak-anak.
print(describe_person(person2))  # Output: Bob adalah orang dewasa.

Penjelasan Lanjutan #

• Wildcard Pattern (_): Digunakan untuk mencocokkan semua nilai yang tidak cocok dengan pola lain. Ini mirip dengan default dalam switch-case.
• Literal Pattern: Mencocokkan nilai literal seperti angka atau string.
• Sequence Pattern: Mencocokkan elemen dalam urutan seperti tuple atau list.
• Mapping Pattern: Mencocokkan kunci dan nilai dalam dictionary.
• Class Pattern: Mencocokkan objek berdasarkan kelas dan atributnya.

Keuntungan #

1. Kebersihan dan Keterbacaan: Kode lebih mudah dibaca dan dipahami.
2. Ekspresifitas: Dapat mencocokkan pola kompleks dan struktur data dalam satu blok kode.
3. Fleksibilitas: Dapat digunakan untuk mencocokkan berbagai jenis pola dalam data.

Dengan memahami dan menggunakan match-case, Anda dapat menulis kode yang lebih bersih, lebih ekspresif, dan lebih mudah dipelihara dalam Python.

Kesimpulan #

Dengan memahami seleksi kondisi di Python, Anda dapat mengontrol alur eksekusi program Anda dengan lebih baik, membuatnya lebih fleksibel dan responsif terhadap berbagai situasi.