Cara Menggunakan Switch di Python: Panduan Lengkap dengan Contoh dan Alternatif

Depan » pemrograman » Cara Menggunakan Switch di Python: Panduan Lengkap dengan Contoh dan Alternatif

Pernahkah Anda bertanya-tanya bagaimana cara menangani beberapa kondisi dalam Python dengan mudah dan efisien? Ketika Anda pernah bekerja dengan bahasa seperti C, Java atau JavaScript, Anda pasti pernah menggunakan yang terkenal sakelar sakelar untuk memilih di antara beberapa opsi berdasarkan nilai variabel. Namun, dalam Python, mekanisme klasik ini tidak ada... hingga baru-baru ini. Tentu saja, sementara pengembang harus mencari alternatif selama bertahun-tahun, bahasa tersebut kini menawarkan solusi yang modern dan canggih.

Artikel ini adalah panduan utama Anda untuk memahami cara menggunakan padanan switch di Python., temukan alternatif paling tangguh di versi lama, jelaskan mengapa tidak disertakan di tahap awal, dan pelajari cara menulis kode yang lebih bersih dan mudah dibaca, apa pun versi yang Anda gunakan. Bersiaplah untuk mempelajari semua trik, contoh, dan perbedaan utama dalam mengimplementasikan beberapa kondisional dalam ekosistem Python.

Apakah switch ada di Python? Sejarah dan alasan ketidakhadirannya

Switch-case, yang hadir dalam banyak bahasa, tidak pernah hadir secara resmi di Python hingga versi 3.10. Alasan utamanya bersifat filosofis: para pencipta Python selalu berkomitmen pada kesederhanaan dan keterbacaan. Mereka percaya bahwa memperkenalkan sintaksis switch baru dapat memperumit banyak hal, sehingga jika-elif-lain cukup untuk mengisi kesenjangan tersebut. Lebih jauh, tidak pernah ada konsensus mengenai sintaksis yang ideal. Bahkan, beberapa usulan resmi (PEP 275, PEP 3103) ditolak karena kurangnya kesepakatan dan karena banyak yang percaya bahwa alternatif yang ada sudah cukup jelas dan kuat.

Selama bertahun-tahun, komunitas telah mengompensasi ketiadaan saklar dengan menggunakan rangkaian kondisi dan kamus. Tak perlu dikatakan lagi, topik ini memicu perdebatan, tetapi jauh dari kerugian yang tak teratasi, pendekatan-pendekatan ini terbukti fleksibel dan sangat adaptif. Namun, seiring dengan meningkatnya kompleksitas proyek, kebutuhan akan solusi yang lebih elegan pun semakin meningkat.

Apa itu switch case dan apa kegunaannya?

El sakelar sakelar Ini adalah struktur kontrol yang digunakan dalam banyak bahasa pemrograman untuk mengeksekusi berbagai blok kode berdasarkan nilai variabel atau ekspresi. Dengan kata lain, struktur ini memungkinkan Anda memilih satu opsi dari sekian banyak opsi yang tersedia dengan cara yang bersih dan lugas, sehingga menghindari rangkaian kondisional yang tak berujung.

Contoh penggunaan yang umum adalah: menampilkan nama hari dalam seminggu berdasarkan angka, memberikan nilai, memilih operasi berdasarkan masukan pengguna, dll. Dalam bahasa seperti C atau Java, sintaksnya sederhana:

switch(valor) {
    case 1:
        // acción
        break;
    case 2:
        // otra acción
        break;
    default:
        // acción por defecto
}

Dalam Python, struktur klasik ini belum ada hingga saat ini, jadi pengembang harus kreatif untuk mencapai hasil yang sama.

Kedatangan switch dalam Python: pernyataan match-case (sejak Python 3.10)

Dengan dirilisnya versi 3.10, Python menggabungkan fitur yang telah lama ditunggu-tunggu: pernyataan kasus pertandingan. Meskipun sintaksnya mengingatkan pada switch-case tradisional, sebenarnya jauh lebih kuat, karena memperkenalkan pencocokan pola (pencocokan pola), memungkinkan untuk membandingkan tidak hanya nilai sederhana, tetapi juga struktur kompleks, tupel, kelas, daftar, kamus, dll.

Pencocokan huruf pada Python ditulis seperti ini:

def ejemplo_switch(x):
    match x:
        case 1:
            return "uno"
        case 2:
            return "dos"
        case _:
            return "desconocido"

Garis bawah (_) bertindak sebagai wildcard dan setara dengan kegagalan Dalam bahasa lain, dieksekusi saat tidak ada pola sebelumnya yang cocok.

Mengapa begitu dahsyat? Karena Anda dapat menerima pola yang kompleks, menangkap variabel, membuka tupel atau objek, dan bahkan menggunakan penjaga untuk menambahkan kondisi tambahan setelah kasus:

match dato:
    case (a, b) if a > b:
        print("El primer elemento es mayor que el segundo")
    case (a, b):
        print(f"Valores: {a}, {b}")

Selain itu, dalam Python 3.10 dan di atasnya, struktur ini meningkatkan keterbacaan, kemudahan pemeliharaan, dan skalabilitas kode Anda, terutama saat menangani banyak kasus.

Alternatif untuk beralih ke Python untuk versi yang lebih lama

Sebelum kedatangan kotak korek api, pengembang menemukan alternatif yang sama validnya. Dua yang paling umum adalah penggunaan rantai if-elif-else dan pemetaan menggunakan kamusMari kita lihat lebih dekat:

1. Menggunakan if-elif-else

Solusi yang paling langsung dan mudah dipahami adalah dengan merangkai kondisi menggunakan if, elif, dan else. Dengan cara ini, Anda dapat mencakup semua kemungkinan nilai untuk suatu variabel dan mengeksekusi blok kode yang sesuai. Misalnya, untuk menampilkan hari dalam seminggu berdasarkan angka:

dia = 4
if dia == 1:
    print('lunes')
elif dia == 2:
    print('martes')
elif dia == 3:
    print('miércoles')
elif dia == 4:
    print('jueves')
elif dia == 5:
    print('viernes')
elif dia == 6:
    print('sábado')
elif dia == 7:
    print('domingo')
else:
    print('error')

Keuntungan dari pendekatan ini:

• Kode yang sederhana dan mudah dibaca.
• Anda tidak memerlukan struktur khusus lainnya; ini Python murni.
• Jenis perbandingan apa pun dapat digunakan, bukan hanya kesetaraan.

Kerugian dari tangga if-elif-else:

• Kecenderungan terhadap kode yang berulang. Anda harus mengulang variabel dalam setiap perbandingan, yang menghasilkan banyak teks yang tidak perlu jika Anda memiliki banyak kasus.
• Kurang efisien jika terdapat banyak kondisi. Jika kasusnya sudah selesai, semua kasus sebelumnya dievaluasi sebelum tiba.
• Kesulitan menambahkan atau menghapus kasus secara dinamis.

2. Menggunakan kamus untuk mensimulasikan switch-case

Cara yang sangat Pythonic untuk mensimulasikan peralihan adalah dengan menggunakan kamus. Idenya sederhana: Anda mengaitkan setiap nilai yang mungkin (kunci) dengan fungsi atau tindakan (nilai) yang sesuai. Kemudian, Anda mencari kamus untuk mendapatkan fungsi tersebut dan menjalankannya:

def lunes():
    print('lunes')
def martes():
    print('martes')
def error():
    print('error')

switch_semana = {
    1: lunes,
    2: martes,
    # ... otros días ...
}
dia = 8
switch_semana.get(dia, error)()

Keuntungan metode ini:

• Kode yang ringkas dan mudah diperluas.
• Akses sangat cepat ke fungsi yang tepat. Kamus menggunakan hashing, jadi pencarian hampir seketika.
• Memungkinkan Anda menetapkan fungsi yang sama ke beberapa tombol (misalnya, ke kasus kelompok).
• Saklar dapat dimodifikasi pada waktu proses.

Kekurangan:

• Hal ini memerlukan pendefinisian sebelumnya semua fungsi terkait, yang mungkin rumit untuk tindakan sederhana.
• Ia hanya memperbolehkan perbandingan untuk kesetaraan (tidak berlaku untuk interval, rentang, dan lain-lain).
• Ini tidak ditujukan untuk kasus dengan logika kondisional yang lebih kompleks dalam setiap pilihan.

Perbedaan antara if-elif-else dan switch (atau match-case)

Cara kerja internal rantai if-elif-else berbeda dengan cara kerja sakelar. Dalam if-elif-else, kondisi dievaluasi satu per satu, dari atas ke bawah, hingga kondisi pertama bernilai benar. Oleh karena itu, jika nilai yang dicari berada di awal, eksekusinya akan cepat; jika berada di akhir, eksekusinya akan lebih lama.

Sakelar tradisional (dan kamus sebagai alternatif dalam Python) malah sering menggunakan tabel pencarian, sehingga akses lebih seragam, terlepas dari berapa banyak contoh yang ada atau posisinya. kotak korek api dan kamus, waktu aksesnya jauh lebih homogen.

Kapan harus memilih setiap alternatif?

Tidak ada solusi universal tunggal; alat terbaik bergantung pada masalah spesifik.

• Untuk sejumlah kecil kondisi atau logika kompleks di setiap cabang, if-elif-else adalah pilihan yang paling mudah. Memungkinkan perbandingan apa pun dan sangat fleksibel.
• Bila Anda memiliki banyak kasus dan masing-masing kasus hanya melakukan tindakan tertentu, andalkan kamus. Kodenya lebih bersih, lebih terukur, dan lebih mudah dipelihara.
• Jika Anda menggunakan Python 3.10 atau lebih tinggi, kotak korek api Ini adalah pilihan terbaik untuk kejelasan dan kekuatan. Memungkinkan Anda menggabungkan keanggunan sakelar dengan kekuatan pencocokan pola pada struktur yang kompleks.

Selalu pikirkan keterbacaan, kinerja, dan pemeliharaan kode Anda.

Contoh praktis penggunaan switch di Python dan alternatifnya

Mari kita lihat beberapa contoh penerapan masing-masing alternatif ini, dari yang paling sederhana hingga paling rumit:

Contoh 1: Hitung nilai berdasarkan skor

# Usando if-elif-else
puntuacion = 85
if puntuacion >= 90:
    print('Sobresaliente')
elif puntuacion >= 80:
    print('Notable')
elif puntuacion >= 70:
    print('Bien')
else:
    print('Insuficiente')

Kasus ini sempurna untuk menggunakan kondisi, karena Anda bekerja dengan interval, bukan nilai tetap.

Contoh 2: Menampilkan hari dalam seminggu berdasarkan angka (dengan kamus)

# Definición de funciones para cada día
def lunes():
    print('lunes')
def martes():
    print('martes')
def miercoles():
    print('miércoles')
def jueves():
    print('jueves')
def viernes():
    print('viernes')
def sabado():
    print('sábado')
def domingo():
    print('domingo')
def error():
    print('error')
switch_semana = {
    1: lunes,
    2: martes,
    3: miercoles,
    4: jueves,
    5: viernes,
    6: sabado,
    7: domingo
}
dia = 8
switch_semana.get(dia, error)()

Contoh 3: Menggunakan match-case untuk memilih operasi aritmatika

operacion = 'suma'
a = 10
b = 5
match operacion:
    case 'suma':
        print(a + b)
    case 'resta':
        print(a - b)
    case 'multiplicacion':
        print(a * b)
    case 'division':
        print(a / b)
    case _:
        print('Operación no válida')

Seperti yang Anda lihat, sintaksnya sederhana dan sangat jelas. Garis bawah menunjukkan huruf besar-kecil default.

Contoh lanjutan: pencocokan pola dengan match-case

Kekuatan hebat dari match-case adalah kemampuannya untuk bekerja dengan pola yang rumit. Misalnya, Anda dapat mengurai tupel, daftar, kamus, objek, dan lain-lain.

punto = (3, 5)
match punto:
    case (0, 0):
        print('Origen')
    case (0, y):
        print(f'Eje Y en {y}')
    case (x, 0):
        print(f'Eje X en {x}')
    case (x, y):
        print(f'Coordenadas X={x}, Y={y}')

Anda bahkan dapat menggunakan klausa if (penjaga) untuk menambahkan kondisi tambahan pada setiap kasus.

Perbedaan kinerja antara if-elif-else, kamus, dan match-case

Dalam kebanyakan kasus, perbedaan kinerja dapat diabaikan untuk skrip normal. Namun, ketika ada banyak alternatif, kamus dan pencocokan kasus dapat lebih efisien, karena mengurangi jumlah perbandingan. Namun, faktor yang paling penting biasanya adalah keterbacaan dan pemeliharaan kode, alih-alih optimasi mikro yang jarang membuat perbedaan dalam proyek nyata.

Gunakan teknik yang membuat kode lebih jelas dan menghindari kesalahan.

Solusi kreatif: kelas dan manajer konteks untuk meniru sakelar

Beberapa pengembang telah membuat kelas khusus yang memungkinkan meniru perilaku sakelar klasik, termasuk opsi lanjutan seperti menambahkan istirahat untuk mengendalikan eksekusi kasus berikutnya, mengelompokkan kasus, menyesuaikan perbandingan, atau mengaktifkan mode ketat untuk memastikan hanya satu cabang yang dieksekusi.

Misalnya, manajer konteks khusus dapat diimplementasikan untuk menggunakan sintaksis yang sangat mirip dengan bahasa lain:

class switch:
    def __init__(self, variable, comparator=None, strict=False):
        self.variable = variable
        self.matched = False
        self.matching = False
        if comparator:
            self.comparator = comparator
        else:
            self.comparator = lambda x, y: x == y
        self.strict = strict
    def __enter__(self):
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        pass
    def case(self, expr, break_=False):
        if self.strict:
            if self.matched:
                return False
            if self.matching or self.comparator(self.variable, expr):
                if not break_:
                    self.matching = True
                else:
                    self.matched = True
                    self.matching = False
                return True
            else:
                return False
        else:
            if self.matching or self.comparator(self.variable, expr):
                if not break_:
                    self.matching = True
                else:
                    self.matched = True
                    self.matching = False
                return True
            else:
                return False
    def default(self):
        return not self.matched and not self.matching

Penggunaan kelas ini memungkinkan sintaksis seperti ini:

dia = 4
with switch(dia) as s:
    if s.case(1, True): print('lunes')
    if s.case(2, True): print('martes')
    if s.case(3, True): print('miércoles')
    if s.case(4, True): print('jueves')
    if s.case(5, True): print('viernes')
    if s.case(6, True): print('sábado')
    if s.case(7, True): print('domingo')
    if s.default(): print('error')

Keuntungan dari solusi ini? Bahasa ini memiliki sintaksis yang sangat familiar bagi mereka yang berasal dari bahasa lain dan memungkinkan penyesuaian tingkat lanjut, seperti menggunakan fungsi perbandingan apa pun, mengelompokkan kasus, menjalankan beberapa cabang atau hanya satu, dll. Kelemahannya adalah biasanya lebih lambat dan memerlukan impor atau pendefinisian kelas khusus.

Menggunakan fungsi lambda untuk menyederhanakan tindakan pada kamus

Seringkali Anda tidak perlu mendefinisikan fungsi terpisah untuk setiap tindakan; Anda dapat menggunakan fungsi anonim (lambda). Hal ini terutama praktis ketika tindakan yang akan dilakukan sederhana:

switch_operaciones = {
    'sumar': lambda a, b: a + b,
    'restar': lambda a, b: a - b,
    'multiplicar': lambda a, b: a * b
}
operacion = 'sumar'
resultado = switch_operaciones.get(operacion, lambda a, b: None)(5, 3)
print(resultado)

Ini membuat kode menjadi padat dan mudah diperluas tanpa kehilangan kejelasan.

Kasus Penggunaan Lanjutan: Pencocokan Pola di Match-Case

Kalimat kotak korek api Python 3.10 jauh melampaui peniruan switch-case klasik. Kekuatannya yang sebenarnya terletak pada pencocokan pola strukturalMisalnya, Anda dapat membedakan berbagai struktur data, kelas khusus, menguraikan objek, dan menangkap sub-elemen dengan mudah.

Contoh dengan daftar dan tupel:

datos = 
match datos:
    case :
        print('Lista con 1, 2, 3')
    case :
        print('Lista que empieza con 1')
    case _:
        print('Otra lista')

Contoh dengan objek (dengan asumsi kelas Point):

class Punto:
    def __init__(self, x, y):
        self.x = x
        self.y = y
p = Punto(2, 3)
match p:
    case Punto(x=0, y=0):
        print('Origen')
    case Punto(x, y):
        print(f'Coordenadas: {x} {y}')

Mekanisme ini memungkinkan Anda menulis kode yang sangat ekspresif yang beradaptasi dengan struktur kompleks tanpa kehilangan keterbacaan.

Aspek yang perlu dipertimbangkan saat melakukan migrasi kode: kompatibilitas dan praktik terbaik

Tidak semua proyek mampu menggunakan match-case sekarang juga. Jika Anda bekerja di lingkungan dengan versi Python yang lebih lama (misalnya, 3.8 atau 3.9), Anda harus memilih kamus. Saat Anda dapat meningkatkan ke versi 3.10 atau yang lebih baru, manfaatkan kekuatan dan kejelasan pencocokan pola, terutama dalam proyek yang membutuhkan logika pemilihan ganda.

Ingat:

• Pilih opsi yang menawarkan keterbacaan, fleksibilitas, dan kemudahan pemeliharaan terbaik.
• Dalam masalah yang sangat sederhana (beberapa kasus), if-elif-else biasanya cukup dan lebih langsung.
• Untuk tabel pilihan besar, gunakan kamus dan fungsi.
• Untuk struktur yang kompleks atau untuk memanfaatkan Python modern sepenuhnya, pilih match-case.

Trik kecil: Anda dapat mengonversi fungsi yang ada untuk menerima kamus tindakan, membuat transisi antar pendekatan menjadi lebih mudah.

Tips optimasi dan desain untuk kode Python yang lebih bersih

Jangan membuat kesalahan dalam mendesain rantai kondisi yang tak berujung hanya untuk meniru peralihan klasik. Pikirkan setiap kasus spesifik dan nilai struktur kontrol mana yang memberikan nilai tambah paling besar pada konteks program Anda. Ingatlah bahwa Python menghargai kejelasan, jadi hindari kode yang terlalu rumit jika Anda dapat mencapai hasil yang sama dengan lebih mudah.

Tips penting: Saat menggunakan kamus, gunakan fungsi get() untuk menghindari kesalahan jika kunci tidak ada dan dengan demikian dapat menentukan kasus default secara elegan.

Perbandingan dengan bahasa lain dan pemikiran akhir

Dalam beberapa bahasa, seperti C, C++, atau Java, switch hanya memungkinkan untuk membandingkan nilai-nilai sederhana (bilangan bulat, string) dan memberikan sedikit nilai untuk struktur yang kompleks. Python melangkah lebih jauh: pertama, ia menawarkan alternatif yang serbaguna (if-elif-else, kamus), dan sekarang ia membuka pintu ke logika tingkat lanjut tanpa usaha ekstra. Kuncinya adalah memanfaatkan keunggulan setiap versi dan tidak memaksakan diri untuk meniru sintaksis lain jika masalahnya memerlukan solusi yang berbeda.

Jika Anda baru mulai belajar Python atau baru belajar bahasa pemrograman lain, jangan frustrasi jika tidak menemukan kata kunci "switch" di manual. Pertimbangkan semua kemungkinan yang tersedia dan pilih yang paling sesuai dengan konteks dan kebutuhan Anda.

Mengelola beberapa alternatif dalam Python tidak pernah semudah atau lebih canggih dari ini. Sekarang Anda memahami alasan di balik ketidakhadiran (dan kedatangan berikutnya) switch, cara mensimulasikannya secara efektif dalam versi apa pun, dan cara mendapatkan hasil maksimal dari pernyataan match-case yang baru. Apakah Anda harus memilih di antara setengah lusin opsi, memanipulasi struktur yang rumit, mengikuti praktik terbaik, atau mengkhawatirkan kinerja, Anda memiliki alternatif yang tangguh, elegan, dan fleksibel. Apakah kode Anda untuk skrip cepat atau aplikasi yang rumit, Python memberi Anda alat untuk menuliskannya dengan jelas, cepat, dan mudah.