Penggantian untuk pernyataan switch dalam Python?

Saya ingin menulis fungsi dengan Python yang mengembalikan nilai tetap berbeda berdasarkan nilai indeks input.

Dalam bahasa lain saya akan menggunakan pernyataan switchatau case, tetapi Python tampaknya tidak memiliki switchpernyataan. Apa solusi Python yang disarankan dalam skenario ini?

Anda bisa menggunakan kamus:

def f(x):
    return {
        'a': 1,
        'b': 2,
    }[x]

Jika Anda ingin default, Anda bisa menggunakan get(key[, default])metode kamus :

def f(x):
    return {
        'a': 1,
        'b': 2
    }.get(x, 9)    # 9 is default if x not found

Saya selalu suka melakukannya dengan cara ini

result = {
  'a': lambda x: x * 5,
  'b': lambda x: x + 7,
  'c': lambda x: x - 2
}[value](x)

Dari sini

Selain metode kamus (yang sangat saya sukai, BTW), Anda juga dapat menggunakan if- elif- elseuntuk mendapatkan fungsi switch/ case/ default:

if x == 'a':
    # Do the thing
elif x == 'b':
    # Do the other thing
if x in 'bc':
    # Fall-through by not using elif, but now the default case includes case 'a'!
elif x in 'xyz':
    # Do yet another thing
else:
    # Do the default

Ini tentu saja tidak identik dengan beralih / kasing - Anda tidak dapat terjatuh semudah meninggalkan breakpernyataan, tetapi Anda dapat memiliki tes yang lebih rumit. Pemformatannya lebih bagus daripada serangkaian nested ifs, meskipun secara fungsional itulah yang lebih dekat dengannya.

Resep Python favorit saya untuk sakelar / kasing adalah:

choices = {'a': 1, 'b': 2}
result = choices.get(key, 'default')

Singkat dan sederhana untuk skenario sederhana.

Bandingkan dengan 11+ baris kode C:

// C Language version of a simple 'switch/case'.
switch( key ) 
{
    case 'a' :
        result = 1;
        break;
    case 'b' :
        result = 2;
        break;
    default :
        result = -1;
}

Anda bahkan dapat menetapkan beberapa variabel dengan menggunakan tuple:

choices = {'a': (1, 2, 3), 'b': (4, 5, 6)}
(result1, result2, result3) = choices.get(key, ('default1', 'default2', 'default3'))

class switch(object):
    value = None
    def __new__(class_, value):
        class_.value = value
        return True

def case(*args):
    return any((arg == switch.value for arg in args))

Pemakaian:

while switch(n):
    if case(0):
        print "You typed zero."
        break
    if case(1, 4, 9):
        print "n is a perfect square."
        break
    if case(2):
        print "n is an even number."
    if case(2, 3, 5, 7):
        print "n is a prime number."
        break
    if case(6, 8):
        print "n is an even number."
        break
    print "Only single-digit numbers are allowed."
    break

Tes:

n = 2
#Result:
#n is an even number.
#n is a prime number.
n = 11
#Result:
#Only single-digit numbers are allowed.

Resep favorit saya adalah resep yang sangat enak . Anda akan sangat menyukainya. Ini yang paling dekat yang pernah saya lihat dengan pernyataan kasus sakelar aktual, terutama di fitur.

class switch(object):
    def __init__(self, value):
        self.value = value
        self.fall = False

    def __iter__(self):
        """Return the match method once, then stop"""
        yield self.match
        raise StopIteration

    def match(self, *args):
        """Indicate whether or not to enter a case suite"""
        if self.fall or not args:
            return True
        elif self.value in args: # changed for v1.5, see below
            self.fall = True
            return True
        else:
            return False

Ini sebuah contoh:

# The following example is pretty much the exact use-case of a dictionary,
# but is included for its simplicity. Note that you can include statements
# in each suite.
v = 'ten'
for case in switch(v):
    if case('one'):
        print 1
        break
    if case('two'):
        print 2
        break
    if case('ten'):
        print 10
        break
    if case('eleven'):
        print 11
        break
    if case(): # default, could also just omit condition or 'if True'
        print "something else!"
        # No need to break here, it'll stop anyway

# break is used here to look as much like the real thing as possible, but
# elif is generally just as good and more concise.

# Empty suites are considered syntax errors, so intentional fall-throughs
# should contain 'pass'
c = 'z'
for case in switch(c):
    if case('a'): pass # only necessary if the rest of the suite is empty
    if case('b'): pass
    # ...
    if case('y'): pass
    if case('z'):
        print "c is lowercase!"
        break
    if case('A'): pass
    # ...
    if case('Z'):
        print "c is uppercase!"
        break
    if case(): # default
        print "I dunno what c was!"

# As suggested by Pierre Quentel, you can even expand upon the
# functionality of the classic 'case' statement by matching multiple
# cases in a single shot. This greatly benefits operations such as the
# uppercase/lowercase example above:
import string
c = 'A'
for case in switch(c):
    if case(*string.lowercase): # note the * for unpacking as arguments
        print "c is lowercase!"
        break
    if case(*string.uppercase):
        print "c is uppercase!"
        break
    if case('!', '?', '.'): # normal argument passing style also applies
        print "c is a sentence terminator!"
        break
    if case(): # default
        print "I dunno what c was!"

class Switch:
    def __init__(self, value):
        self.value = value

    def __enter__(self):
        return self

    def __exit__(self, type, value, traceback):
        return False # Allows a traceback to occur

    def __call__(self, *values):
        return self.value in values


from datetime import datetime

with Switch(datetime.today().weekday()) as case:
    if case(0):
        # Basic usage of switch
        print("I hate mondays so much.")
        # Note there is no break needed here
    elif case(1,2):
        # This switch also supports multiple conditions (in one line)
        print("When is the weekend going to be here?")
    elif case(3,4):
        print("The weekend is near.")
    else:
        # Default would occur here
        print("Let's go have fun!") # Didn't use case for example purposes

Ada pola yang saya pelajari dari kode Twisted Python.

class SMTP:
    def lookupMethod(self, command):
        return getattr(self, 'do_' + command.upper(), None)
    def do_HELO(self, rest):
        return 'Howdy ' + rest
    def do_QUIT(self, rest):
        return 'Bye'

SMTP().lookupMethod('HELO')('foo.bar.com') # => 'Howdy foo.bar.com'
SMTP().lookupMethod('QUIT')('') # => 'Bye'

Anda dapat menggunakannya kapan saja Anda perlu mengirim token dan mengeksekusi sepotong kode yang diperluas. Di mesin negara Anda akan memiliki state_metode, dan pengiriman self.state. Switch ini dapat diperluas dengan mewarisi dari kelas dasar dan mendefinisikan do_metode Anda sendiri . Sering kali Anda bahkan tidak akan memiliki do_metode di kelas dasar.

Sunting: bagaimana tepatnya itu digunakan

Dalam hal SMTP, Anda akan menerima HELOdari kawat. Kode yang relevan (dari twisted/mail/smtp.py, dimodifikasi untuk kasus kami) terlihat seperti ini

class SMTP:
    # ...

    def do_UNKNOWN(self, rest):
        raise NotImplementedError, 'received unknown command'

    def state_COMMAND(self, line):
        line = line.strip()
        parts = line.split(None, 1)
        if parts:
            method = self.lookupMethod(parts[0]) or self.do_UNKNOWN
            if len(parts) == 2:
                return method(parts[1])
            else:
                return method('')
        else:
            raise SyntaxError, 'bad syntax'

SMTP().state_COMMAND('   HELO   foo.bar.com  ') # => Howdy foo.bar.com

Anda akan menerima ' HELO foo.bar.com '(atau Anda mungkin mendapatkan 'QUIT'atau 'RCPT TO: foo'). Ini tokenized menjadi partssebagai ['HELO', 'foo.bar.com']. Nama pencarian metode yang sebenarnya diambil dari parts[0].

(Metode asli juga disebut state_COMMAND, karena menggunakan pola yang sama untuk mengimplementasikan mesin negara, yaitu getattr(self, 'state_' + self.mode))

Katakanlah Anda tidak ingin hanya mengembalikan nilai, tetapi ingin menggunakan metode yang mengubah sesuatu pada suatu objek. Menggunakan pendekatan yang dinyatakan di sini adalah:

result = {
  'a': obj.increment(x),
  'b': obj.decrement(x)
}.get(value, obj.default(x))

Apa yang terjadi di sini adalah python mengevaluasi semua metode dalam kamus. Jadi, bahkan jika nilai Anda adalah 'a', objek akan bertambah dan dikurangi dengan x.

Larutan:

func, args = {
  'a' : (obj.increment, (x,)),
  'b' : (obj.decrement, (x,)),
}.get(value, (obj.default, (x,)))

result = func(*args)

Jadi, Anda mendapatkan daftar yang berisi fungsi dan argumennya. Dengan cara ini, hanya pointer fungsi dan daftar argumen yang dikembalikan, tidak dievaluasi. 'result' kemudian mengevaluasi pemanggilan fungsi yang dikembalikan.

Saya hanya akan menurunkan dua sen saya di sini. Alasan tidak ada pernyataan case / switch dalam Python adalah karena Python mengikuti prinsip 'Hanya ada satu cara yang tepat untuk melakukan sesuatu'. Jadi jelas Anda bisa membuat berbagai cara untuk menciptakan fungsi switch / case, tetapi cara Pythonic untuk mencapai ini adalah if / elif construct. yaitu

if something:
    return "first thing"
elif somethingelse:
    return "second thing"
elif yetanotherthing:
    return "third thing"
else:
    return "default thing"

Saya hanya merasa PEP 8 layak mendapat anggukan di sini. Salah satu hal indah tentang Python adalah kesederhanaan dan keanggunannya. Itu sebagian besar berasal dari prinsip-prinsip yang tercantum dalam PEP 8, termasuk "Hanya ada satu cara yang tepat untuk melakukan sesuatu"

memperluas gagasan "dict as switch". jika Anda ingin menggunakan nilai default untuk sakelar Anda:

def f(x):
    try:
        return {
            'a': 1,
            'b': 2,
        }[x]
    except KeyError:
        return 'default'

Jika Anda memiliki blok kasus yang rumit, Anda dapat mempertimbangkan menggunakan tabel pencarian kamus fungsi ...

Jika Anda belum melakukan ini sebelumnya, ide yang bagus untuk masuk ke debugger dan lihat bagaimana kamus melihat setiap fungsi.

CATATAN: Do tidak menggunakan "()" dalam kasus / kamus lookup atau akan memanggil masing-masing fungsi Anda sebagai blok kamus / kasus dibuat. Ingat ini karena Anda hanya ingin memanggil setiap fungsi sekali menggunakan pencarian gaya hash.

def first_case():
    print "first"

def second_case():
    print "second"

def third_case():
    print "third"

mycase = {
'first': first_case, #do not use ()
'second': second_case, #do not use ()
'third': third_case #do not use ()
}
myfunc = mycase['first']
myfunc()

Jika Anda mencari pernyataan ekstra, sebagai "switch", saya membangun modul python yang memperluas Python. Ini disebut ESPY sebagai "Enhanced Structure for Python" dan tersedia untuk Python 2.x dan Python 3.x.

Misalnya, dalam hal ini, pernyataan switch dapat dilakukan dengan kode berikut:

macro switch(arg1):
    while True:
        cont=False
        val=%arg1%
        socket case(arg2):
            if val==%arg2% or cont:
                cont=True
                socket
        socket else:
            socket
        break

yang bisa digunakan seperti ini:

a=3
switch(a):
    case(0):
        print("Zero")
    case(1):
        print("Smaller than 2"):
        break
    else:
        print ("greater than 1")

jadi tanyalah menerjemahkannya dengan Python sebagai:

a=3
while True:
    cont=False
    if a==0 or cont:
        cont=True
        print ("Zero")
    if a==1 or cont:
        cont=True
        print ("Smaller than 2")
        break
    print ("greater than 1")
    break

Saya menemukan bahwa struktur saklar umum:

switch ...parameter...
case p1: v1; break;
case p2: v2; break;
default: v3;

dapat diekspresikan dalam Python sebagai berikut:

(lambda x: v1 if p1(x) else v2 if p2(x) else v3)

atau diformat dengan cara yang lebih jelas:

(lambda x:
     v1 if p1(x) else
     v2 if p2(x) else
     v3)

Alih-alih menjadi pernyataan, versi python adalah ekspresi, yang mengevaluasi nilai.

Sebagian besar jawaban di sini sudah cukup lama, dan terutama yang diterima, jadi sepertinya layak diperbarui.

Pertama, FAQ Python resmi membahas hal ini, dan merekomendasikan elifrantai untuk kasus sederhana dan dictuntuk kasus yang lebih besar atau lebih kompleks. Ini juga menyarankan serangkaian visit_metode (gaya yang digunakan oleh banyak kerangka kerja server) untuk beberapa kasus:

def dispatch(self, value):
    method_name = 'visit_' + str(value)
    method = getattr(self, method_name)
    method()

FAQ juga menyebutkan PEP 275 , yang ditulis untuk mendapatkan keputusan resmi sekali-untuk-semua tentang penambahan pernyataan beralih gaya-C. Tetapi PEP itu sebenarnya ditangguhkan ke Python 3, dan hanya secara resmi ditolak sebagai proposal terpisah, PEP 3103 . Jawabannya tentu saja tidak — tetapi kedua PEP memiliki tautan ke informasi tambahan jika Anda tertarik pada alasan atau sejarahnya.

Satu hal yang muncul beberapa kali (dan dapat dilihat dalam PEP 275, meskipun itu dipotong sebagai rekomendasi sebenarnya) adalah bahwa jika Anda benar-benar terganggu dengan memiliki 8 baris kode untuk menangani 4 kasus, vs. 6 baris yang Anda miliki di C atau Bash, Anda selalu dapat menulis ini:

if x == 1: print('first')
elif x == 2: print('second')
elif x == 3: print('third')
else: print('did not place')

Ini tidak sepenuhnya didorong oleh PEP 8, tetapi itu dapat dibaca dan tidak terlalu tidak otomatis.

Selama lebih dari satu dekade sejak PEP 3103 ditolak, masalah pernyataan kasus C-style, atau bahkan versi yang sedikit lebih kuat di Go, telah dianggap mati; setiap kali ada yang membawanya pada python-ideas atau -dev, mereka dirujuk ke keputusan lama.

Namun, gagasan pencocokan pola gaya ML penuh muncul setiap beberapa tahun, terutama karena bahasa seperti Swift dan Rust telah mengadopsinya. Masalahnya adalah sulit untuk menggunakan banyak dari pencocokan pola tanpa tipe data aljabar. Sementara Guido bersimpati pada ide tersebut, tidak ada yang datang dengan proposal yang cocok dengan Python. (Anda dapat membaca strawman 2014 saya sebagai contoh.) Ini bisa berubah dengan dataclassdi 3.7 dan beberapa proposal sporadis untuk yang lebih kuat enumuntuk menangani jenis penjumlahan, atau dengan berbagai proposal untuk berbagai jenis ikatan lokal-pernyataan (seperti PEP 3150 , atau set proposal yang saat ini sedang dibahas di -ideas). Tapi sejauh ini, belum.

Ada juga kadang-kadang proposal untuk pencocokan gaya 6-Perl, yang pada dasarnya merupakan mishmash dari segalanya mulai dari elifregex ke jenis-pengiriman tunggal-switching.

Solusi untuk menjalankan fungsi:

result = {
    'case1':     foo1, 
    'case2':     foo2,
    'case3':     foo3,
    'default':   default,
}.get(option)()

di mana foo1 (), foo2 (), foo3 () dan default () adalah fungsi

Saya tidak menemukan jawaban sederhana yang saya cari di mana saja di pencarian Google. Tapi toh aku yang menemukannya. Ini sangat sederhana. Memutuskan untuk mempostingnya, dan mungkin mencegah goresan di kepala orang lain lebih sedikit. Kuncinya hanyalah "dalam" dan tupel. Berikut adalah perilaku pernyataan switch dengan fall-through, termasuk fall-through RANDOM.

l = ['Dog', 'Cat', 'Bird', 'Bigfoot',
     'Dragonfly', 'Snake', 'Bat', 'Loch Ness Monster']

for x in l:
    if x in ('Dog', 'Cat'):
        x += " has four legs"
    elif x in ('Bat', 'Bird', 'Dragonfly'):
        x += " has wings."
    elif x in ('Snake',):
        x += " has a forked tongue."
    else:
        x += " is a big mystery by default."
    print(x)

print()

for x in range(10):
    if x in (0, 1):
        x = "Values 0 and 1 caught here."
    elif x in (2,):
        x = "Value 2 caught here."
    elif x in (3, 7, 8):
        x = "Values 3, 7, 8 caught here."
    elif x in (4, 6):
        x = "Values 4 and 6 caught here"
    else:
        x = "Values 5 and 9 caught in default."
    print(x)

Menyediakan:

Dog has four legs
Cat has four legs
Bird has wings.
Bigfoot is a big mystery by default.
Dragonfly has wings.
Snake has a forked tongue.
Bat has wings.
Loch Ness Monster is a big mystery by default.

Values 0 and 1 caught here.
Values 0 and 1 caught here.
Value 2 caught here.
Values 3, 7, 8 caught here.
Values 4 and 6 caught here
Values 5 and 9 caught in default.
Values 4 and 6 caught here
Values 3, 7, 8 caught here.
Values 3, 7, 8 caught here.
Values 5 and 9 caught in default.

Solusi yang saya gunakan:

Kombinasi 2 solusi yang diposting di sini, yang relatif mudah dibaca dan mendukung default.

result = {
  'a': lambda x: x * 5,
  'b': lambda x: x + 7,
  'c': lambda x: x - 2
}.get(whatToUse, lambda x: x - 22)(value)

dimana

.get('c', lambda x: x - 22)(23)

melihat "lambda x: x - 2"dict dan menggunakannya denganx=23

.get('xxx', lambda x: x - 22)(44)

tidak menemukannya di dict dan menggunakan default "lambda x: x - 22"dengan x=44.

# simple case alternative

some_value = 5.0

# this while loop block simulates a case block

# case
while True:

    # case 1
    if some_value > 5:
        print ('Greater than five')
        break

    # case 2
    if some_value == 5:
        print ('Equal to five')
        break

    # else case 3
    print ( 'Must be less than 5')
    break

def f(x):
    dictionary = {'a':1, 'b':2, 'c':3}
    return dictionary.get(x,'Not Found') 
##Returns the value for the letter x;returns 'Not Found' if x isn't a key in the dictionary

aku suka jawaban Mark Bies

Sejak x variabel harus digunakan dua kali, saya memodifikasi fungsi lambda menjadi parameterless.

Saya harus menjalankannya results[value](value)

In [2]: result = {
    ...:   'a': lambda x: 'A',
    ...:   'b': lambda x: 'B',
    ...:   'c': lambda x: 'C'
    ...: }
    ...: result['a']('a')
    ...: 
Out[2]: 'A'

In [3]: result = {
    ...:   'a': lambda : 'A',
    ...:   'b': lambda : 'B',
    ...:   'c': lambda : 'C',
    ...:   None: lambda : 'Nothing else matters'

    ...: }
    ...: result['a']()
    ...: 
Out[3]: 'A'

Sunting: Saya perhatikan bahwa saya dapat menggunakan Nonejenis dengan kamus. Jadi ini akan ditiruswitch ; case else

def f(x):
     return 1 if x == 'a' else\
            2 if x in 'bcd' else\
            0 #default

Singkat dan mudah dibaca, memiliki nilai default dan mendukung ekspresi di kedua kondisi dan mengembalikan nilai.

Namun, ini kurang efisien daripada solusi dengan kamus. Misalnya, Python harus memindai semua kondisi sebelum mengembalikan nilai default.

Anda dapat menggunakan dict yang dikirim:

#!/usr/bin/env python


def case1():
    print("This is case 1")

def case2():
    print("This is case 2")

def case3():
    print("This is case 3")


token_dict = {
    "case1" : case1,
    "case2" : case2,
    "case3" : case3,
}


def main():
    cases = ("case1", "case3", "case2", "case1")
    for case in cases:
        token_dict[case]()


if __name__ == '__main__':
    main()

Keluaran:

This is case 1
This is case 3
This is case 2
This is case 1

Sederhana, tidak diuji; setiap kondisi dievaluasi secara independen: tidak ada jatuh, tetapi semua kasus dievaluasi (meskipun ekspresi untuk menghidupkan hanya dievaluasi sekali), kecuali ada pernyataan istirahat. Sebagai contoh,

for case in [expression]:
    if case == 1:
        print(end='Was 1. ')

    if case == 2:
        print(end='Was 2. ')
        break

    if case in (1, 2):
        print(end='Was 1 or 2. ')

    print(end='Was something. ')

cetakan Was 1. Was 1 or 2. Was something. ^{(Sial! Mengapa saya tidak dapat memiliki spasi spasi di blok kode sebaris?)} jika expressiondievaluasi 1, Was 2.jika expressiondievaluasi 2, atau Was something.jika expressiondievaluasi ke yang lain.

Mendefinisikan:

def switch1(value, options):
  if value in options:
    options[value]()

memungkinkan Anda untuk menggunakan sintaks yang cukup mudah, dengan case yang dibundel ke dalam peta:

def sample1(x):
  local = 'betty'
  switch1(x, {
    'a': lambda: print("hello"),
    'b': lambda: (
      print("goodbye," + local),
      print("!")),
    })

Saya terus mencoba mendefinisikan ulang saklar dengan cara yang akan membiarkan saya menyingkirkan "lambda:", tetapi menyerah. Tweak definisi:

def switch(value, *maps):
  options = {}
  for m in maps:
    options.update(m)
  if value in options:
    options[value]()
  elif None in options:
    options[None]()

Mengizinkan saya memetakan banyak kasing ke kode yang sama, dan untuk menyediakan opsi default:

def sample(x):
  switch(x, {
    _: lambda: print("other") 
    for _ in 'cdef'
    }, {
    'a': lambda: print("hello"),
    'b': lambda: (
      print("goodbye,"),
      print("!")),
    None: lambda: print("I dunno")
    })

Setiap case yang direplikasi harus dalam kamusnya sendiri; switch () mengkonsolidasikan kamus sebelum mencari nilainya. Ini masih lebih jelek daripada yang saya inginkan, tetapi memiliki efisiensi dasar menggunakan pencarian hash pada ekspresi, daripada loop melalui semua kunci.

Saya pikir cara terbaik adalah dengan menggunakan idiom bahasa python untuk menjaga kode Anda dapat diuji . Seperti yang ditunjukkan dalam jawaban sebelumnya, saya menggunakan kamus untuk memanfaatkan struktur dan bahasa python dan menjaga kode "case" tetap terisolasi dalam metode yang berbeda. Di bawah ini ada kelas, tetapi Anda dapat menggunakan modul, global, dan fungsi secara langsung. Kelas memiliki metode yang dapat diuji dengan isolasi . Bergantung pada kebutuhan Anda, Anda dapat bermain dengan metode dan atribut statis juga.

class ChoiceManager:

    def __init__(self):
        self.__choice_table = \
        {
            "CHOICE1" : self.my_func1,
            "CHOICE2" : self.my_func2,
        }

    def my_func1(self, data):
        pass

    def my_func2(self, data):
        pass

    def process(self, case, data):
        return self.__choice_table[case](data)

ChoiceManager().process("CHOICE1", my_data)

Dimungkinkan untuk mengambil keuntungan dari metode ini menggunakan juga kelas sebagai kunci "__choice_table". Dengan cara ini Anda dapat menghindari penyalahgunaan konten dan menjaga semua tetap bersih dan dapat diuji.

Andaikan Anda harus memroses banyak pesan atau paket dari internet atau MQ Anda. Setiap paket memiliki struktur dan kode manajemennya sendiri (dengan cara yang umum). Dengan kode di atas dimungkinkan untuk melakukan sesuatu seperti ini:

class PacketManager:

    def __init__(self):
        self.__choice_table = \
        {
            ControlMessage : self.my_func1,
            DiagnosticMessage : self.my_func2,
        }

    def my_func1(self, data):
        # process the control message here
        pass

    def my_func2(self, data):
        # process the diagnostic message here
        pass

    def process(self, pkt):
        return self.__choice_table[pkt.__class__](pkt)

pkt = GetMyPacketFromNet()
PacketManager().process(pkt)


# isolated test or isolated usage example
def test_control_packet():
    p = ControlMessage()
    PacketManager().my_func1(p)

Jadi kompleksitas tidak menyebar dalam aliran kode tetapi ini diberikan dalam struktur kode .

Memperluas jawaban Greg Hewgill - Kita dapat merangkum solusi kamus menggunakan dekorator:

def case(callable):
    """switch-case decorator"""
    class case_class(object):
        def __init__(self, *args, **kwargs):
            self.args = args
            self.kwargs = kwargs

        def do_call(self):
            return callable(*self.args, **self.kwargs)

return case_class

def switch(key, cases, default=None):
    """switch-statement"""
    ret = None
    try:
        ret = case[key].do_call()
    except KeyError:
        if default:
            ret = default.do_call()
    finally:
        return ret

Ini kemudian dapat digunakan dengan @case-decorator

@case
def case_1(arg1):
    print 'case_1: ', arg1

@case
def case_2(arg1, arg2):
    print 'case_2'
    return arg1, arg2

@case
def default_case(arg1, arg2, arg3):
    print 'default_case: ', arg1, arg2, arg3

ret = switch(somearg, {
    1: case_1('somestring'),
    2: case_2(13, 42)
}, default_case(123, 'astring', 3.14))

print ret

Kabar baiknya adalah bahwa ini sudah dilakukan di NeoPySwitch -module. Cukup instal menggunakan pip:

pip install NeoPySwitch

Solusi yang cenderung saya gunakan yang juga menggunakan kamus adalah:

def decision_time( key, *args, **kwargs):
    def action1()
        """This function is a closure - and has access to all the arguments"""
        pass
    def action2()
        """This function is a closure - and has access to all the arguments"""
        pass
    def action3()
        """This function is a closure - and has access to all the arguments"""
        pass

   return {1:action1, 2:action2, 3:action3}.get(key,default)()

Ini memiliki keuntungan karena tidak mencoba untuk mengevaluasi fungsi setiap waktu, dan Anda hanya perlu memastikan bahwa fungsi luar mendapatkan semua informasi yang dibutuhkan fungsi dalam.

Ada banyak jawaban sejauh ini yang mengatakan, "kami tidak memiliki saklar di Python, lakukan dengan cara ini". Namun, saya ingin menunjukkan bahwa pernyataan switch itu sendiri adalah konstruksi yang mudah disalahgunakan yang dapat dan harus dihindari dalam kebanyakan kasus karena mereka mempromosikan pemrograman malas. Inti masalah:

def ToUpper(lcChar):
    if (lcChar == 'a' or lcChar == 'A'):
        return 'A'
    elif (lcChar == 'b' or lcChar == 'B'):
        return 'B'
    ...
    elif (lcChar == 'z' or lcChar == 'Z'):
        return 'Z'
    else:
        return None        # or something

Sekarang, Anda bisa melakukan ini dengan pernyataan switch (jika Python menawarkan satu) tetapi Anda akan membuang-buang waktu karena ada metode yang melakukan ini dengan baik. Atau mungkin, Anda memiliki sesuatu yang kurang jelas:

def ConvertToReason(code):
    if (code == 200):
        return 'Okay'
    elif (code == 400):
        return 'Bad Request'
    elif (code == 404):
        return 'Not Found'
    else:
        return None

Namun, operasi semacam ini dapat dan harus ditangani dengan kamus karena akan lebih cepat, lebih kompleks, lebih rentan terhadap kesalahan dan lebih kompak.

Dan sebagian besar "kasus penggunaan" untuk pernyataan beralih akan jatuh ke dalam salah satu dari dua kasus ini; hanya ada sedikit alasan untuk menggunakannya jika Anda sudah memikirkan masalah Anda secara menyeluruh.

Jadi, daripada bertanya "bagaimana cara beralih di Python?", Mungkin kita harus bertanya, "mengapa saya ingin beralih di Python?" karena itu seringkali pertanyaan yang lebih menarik dan akan sering memaparkan kekurangan dalam desain apa pun yang sedang Anda bangun.

Sekarang, itu bukan untuk mengatakan bahwa switch tidak boleh digunakan juga. Mesin negara, lexer, parser, dan automata semuanya menggunakannya sampai tingkat tertentu dan, secara umum, ketika Anda mulai dari input simetris dan pergi ke output asimetris mereka dapat berguna; Anda hanya perlu memastikan bahwa Anda tidak menggunakan sakelar sebagai palu karena Anda melihat banyak paku dalam kode Anda.