Thay thế cho câu lệnh switch trong Python?

Tôi muốn viết một hàm trong Python trả về các giá trị cố định khác nhau dựa trên giá trị của một chỉ mục đầu vào.

Trong các ngôn ngữ khác tôi sẽ sử dụng một câu lệnh switchhoặc case, nhưng Python dường như không có switchcâu lệnh nào. Các giải pháp Python được đề xuất trong kịch bản này là gì?

Bạn có thể sử dụng một từ điển:

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

Nếu bạn muốn mặc định, bạn có thể sử dụng get(key[, default])phương pháp từ điển :

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

Tôi luôn thích làm theo cách này

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

Từ đây

Ngoài các phương thức từ điển (mà tôi thực sự thích, BTW), bạn cũng có thể sử dụng if- elif- elseđể có được switch/ case/ defaultchức năng:

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

Điều này tất nhiên không giống với chuyển đổi / trường hợp - bạn không thể dễ dàng bỏ qua breakcâu lệnh, nhưng bạn có thể có một bài kiểm tra phức tạp hơn. Định dạng của nó đẹp hơn một loạt các ifs lồng nhau , mặc dù về mặt chức năng đó là những gì nó gần hơn.

Công thức Python yêu thích của tôi cho switch / case là:

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

Ngắn gọn và đơn giản cho các kịch bản đơn giản.

So sánh với hơn 11 dòng mã C:

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

Bạn thậm chí có thể gán nhiều biến bằng cách sử dụng bộ dữ liệu:

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))

Sử dụng:

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

Các xét nghiệm:

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

Yêu thích của tôi là một công thức thực sự tốt đẹp . Bạn sẽ thực sự thích nó. Đây là cái gần nhất tôi từng thấy với các báo cáo trường hợp chuyển đổi thực tế, đặc biệt là trong các tính năng.

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

Đây là một ví dụ:

# 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

Có một mô hình mà tôi đã học được từ mã 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'

Bạn có thể sử dụng nó bất cứ lúc nào bạn cần gửi mã thông báo và thực thi đoạn mã mở rộng. Trong một máy trạng thái, bạn sẽ có state_các phương thức và gửi đi self.state. Công tắc này có thể được mở rộng một cách sạch sẽ bằng cách kế thừa từ lớp cơ sở và xác định các do_phương thức của riêng bạn . Thường thì bạn sẽ không códo_ các phương thức trong lớp cơ sở.

Chỉnh sửa: chính xác là nó được sử dụng như thế nào

Trong trường hợp của SMTP, bạn sẽ nhận được HELOtừ dây. Mã liên quan (từ twisted/mail/smtp.py, được sửa đổi cho trường hợp của chúng tôi) trông như thế này

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

Bạn sẽ nhận được ' HELO foo.bar.com '(hoặc bạn có thể nhận được 'QUIT'hoặc 'RCPT TO: foo'). Đây là tokenized vào partsnhư ['HELO', 'foo.bar.com']. Tên tra cứu phương thức thực tế được lấy từparts[0] .

(Phương thức ban đầu cũng được gọi state_COMMAND, bởi vì nó sử dụng cùng một mẫu để triển khai một máy trạng thái, nghĩa là getattr(self, 'state_' + self.mode))

Giả sử bạn không muốn trả về một giá trị mà muốn sử dụng các phương thức thay đổi thứ gì đó trên một đối tượng. Sử dụng phương pháp được nêu ở đây sẽ là:

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

Điều xảy ra ở đây là python đánh giá tất cả các phương thức trong từ điển. Vì vậy, ngay cả khi giá trị của bạn là 'a', đối tượng sẽ được tăng lên và giảm theo x.

Giải pháp:

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

result = func(*args)

Vì vậy, bạn nhận được một danh sách có chứa một hàm và các đối số của nó. Bằng cách này, chỉ con trỏ hàm và danh sách đối số được trả về, không được đánh giá. 'kết quả' sau đó đánh giá cuộc gọi hàm trả về.

Tôi sẽ thả hai xu của tôi ở đây. Lý do không có câu lệnh case / switch trong Python là vì Python tuân theo nguyên tắc 'Chỉ có một cách đúng để làm điều gì đó'. Vì vậy, rõ ràng bạn có thể đưa ra nhiều cách khác nhau để tái tạo chức năng chuyển đổi / trường hợp, nhưng cách Pythonic để thực hiện điều này là cấu trúc if / elif. I E

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

Tôi chỉ cảm thấy PEP 8 xứng đáng nhận được một cái gật đầu ở đây. Một trong những điều hay về Python là sự đơn giản và thanh lịch của nó. Điều đó phần lớn xuất phát từ các nguyên tắc được đặt trong PEP 8 của chúng tôi, bao gồm "Chỉ có một cách đúng để làm điều gì đó"

mở rộng trên ý tưởng "dict as switch". nếu bạn muốn sử dụng một giá trị mặc định cho công tắc của mình:

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

Nếu bạn có một khối trường hợp phức tạp, bạn có thể xem xét sử dụng bảng tra cứu từ điển chức năng ...

Nếu bạn chưa làm điều này trước khi bạn nên bước vào trình gỡ lỗi của mình và xem chính xác cách từ điển tìm kiếm từng chức năng.

LƯU Ý: Đỗ không sử dụng "()" trong trường hợp / tra cứu từ điển hoặc nó sẽ gọi mỗi người trong số các chức năng của bạn như là khối từ điển / trường hợp được tạo ra. Hãy nhớ điều này bởi vì bạn chỉ muốn gọi mỗi hàm một lần bằng cách sử dụng tra cứu kiểu băm.

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()

Nếu bạn đang tìm kiếm câu lệnh phụ, dưới dạng "switch", tôi đã xây dựng một mô-đun python mở rộng Python. Nó được gọi là ESPY là "Cấu trúc nâng cao cho Python" và nó có sẵn cho cả Python 2.x và Python 3.x.

Ví dụ, trong trường hợp này, một câu lệnh chuyển đổi có thể được thực hiện theo đoạn mã sau:

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

có thể được sử dụng như thế này:

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

Vì vậy, espy dịch nó trong Python là:

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

Tôi thấy rằng một cấu trúc chuyển đổi phổ biến:

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

có thể được biểu thị bằng Python như sau:

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

hoặc được định dạng một cách rõ ràng hơn:

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

Thay vì là một tuyên bố, phiên bản python là một biểu thức, đánh giá một giá trị.

Hầu hết các câu trả lời ở đây đều khá cũ và đặc biệt là những câu được chấp nhận, vì vậy nó có vẻ đáng để cập nhật.

Đầu tiên, Câu hỏi thường gặp về Python chính thức bao gồm điều này và khuyến nghị elifchuỗi cho các trường hợp đơn giản và cho các trường hợp dictlớn hơn hoặc phức tạp hơn. Nó cũng gợi ý một bộvisit_ phương thức (một kiểu được sử dụng bởi nhiều khung máy chủ) cho một số trường hợp:

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

Câu hỏi thường gặp cũng đề cập đến PEP 275 , được viết để có được quyết định chính thức một lần và tất cả về việc thêm các câu lệnh chuyển đổi kiểu C. Nhưng PEP đó thực sự đã được hoãn lại với Python 3 và nó chỉ bị từ chối chính thức dưới dạng một đề xuất riêng, PEP 3103 . Tất nhiên, câu trả lời là không có phần mềm nhưng hai PEP có liên kết đến thông tin bổ sung nếu bạn quan tâm đến lý do hoặc lịch sử.

Một điều xuất hiện nhiều lần (và có thể thấy trong PEP 275, mặc dù nó đã bị cắt ra như một đề xuất thực tế) là nếu bạn thực sự bận tâm khi có 8 dòng mã để xử lý 4 trường hợp, so với 6 trường hợp các dòng bạn có trong C hoặc Bash, bạn luôn có thể viết này:

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

Điều này không được PEP 8 khuyến khích chính xác, nhưng nó có thể đọc được và không quá khác thường.

Trong hơn một thập kỷ kể từ khi PEP 3103 bị từ chối, vấn đề về các tuyên bố trường hợp kiểu C, hoặc thậm chí phiên bản mạnh hơn một chút trong Go, đã bị coi là đã chết; Bất cứ khi nào bất cứ ai đưa ra ý tưởng về python hoặc -dev, họ đều đề cập đến quyết định cũ.

Tuy nhiên, ý tưởng về việc khớp mẫu theo kiểu ML đầy đủ xuất hiện cứ sau vài năm, đặc biệt là khi các ngôn ngữ như Swift và Rust đã áp dụng nó. Vấn đề là thật khó để sử dụng nhiều từ khớp mẫu mà không có các kiểu dữ liệu đại số. Trong khi Guido tỏ ra thông cảm với ý tưởng này, không ai đưa ra một đề xuất phù hợp với Python lắm. (Bạn có thể đọc 2014 strawman của tôi cho một ví dụ.) Điều này có thể thay đổi theo dataclasstrong 3,7 và một số đề xuất lẻ tẻ cho một mạnh hơn enumđể xử lý các loại Tóm lại, hoặc với các đề xuất khác nhau cho các loại khác nhau của các ràng buộc tuyên bố địa phương (như PEP 3150 , hoặc tập hợp các đề xuất hiện đang được thảo luận trên -ideas). Nhưng cho đến nay, nó đã không.

Thỉnh thoảng cũng có những đề xuất cho kết hợp kiểu Perl 6, về cơ bản là một sự nhầm lẫn của tất cả mọi thứ, từ elifregex đến chuyển đổi loại một lần gửi.

Giải pháp để chạy các chức năng:

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

trong đó foo1 (), foo2 (), foo3 () và default () là các hàm

Tôi đã không tìm thấy câu trả lời đơn giản mà tôi đang tìm kiếm ở bất cứ đâu trên tìm kiếm của Google. Nhưng dù sao thì tôi cũng đã hiểu ra rồi. Nó thực sự khá đơn giản. Quyết định đăng nó, và có thể ngăn một vài vết trầy xước trên đầu người khác. Chìa khóa chỉ đơn giản là "trong" và bộ dữ liệu. Dưới đây là hành vi câu lệnh chuyển đổi với thông qua, bao gồm cả thông qua 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)

Cung cấp:

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.

Các giải pháp tôi sử dụng:

Một sự kết hợp của 2 trong số các giải pháp được đăng ở đây, tương đối dễ đọc và hỗ trợ mặc định.

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

Ở đâu

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

tra cứu "lambda x: x - 2"trong dict và sử dụng nó vớix=23

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

không tìm thấy nó trong dict và sử dụng mặc định "lambda x: x - 22"với 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

tôi thích câu trả lời của Mark Bies

Kể từ khi x biến phải sử dụng hai lần, tôi đã sửa đổi các hàm lambda thành không tham số.

Tôi phải chạy với 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'

Chỉnh sửa: Tôi nhận thấy rằng tôi có thể sử dụng Noneloại với từ điển. Vì vậy, điều này sẽ thi đuaswitch ; case else

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

Ngắn gọn và dễ đọc, có giá trị mặc định và hỗ trợ các biểu thức trong cả hai điều kiện và giá trị trả về.

Tuy nhiên, nó kém hiệu quả hơn so với giải pháp với một từ điển. Ví dụ, Python phải quét qua tất cả các điều kiện trước khi trả về giá trị mặc định.

bạn có thể sử dụng một lệnh được gửi đi:

#!/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()

Đầu ra:

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

Đơn giản, không thử nghiệm; mỗi điều kiện được đánh giá độc lập: không có thông qua, nhưng tất cả các trường hợp được đánh giá (mặc dù biểu thức để bật chỉ được đánh giá một lần), trừ khi có tuyên bố ngắt. Ví dụ,

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. ')

in Was 1. Was 1 or 2. Was something. ^{(Chết tiệt! Tại sao tôi không thể có khoảng trắng theo sau trong các khối mã nội tuyến?)} nếu expressionđánh giá 1, Was 2.nếu expressionđánh giá 2hoặc Was something.nếu expressionđánh giá với thứ khác.

Xác định:

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

cho phép bạn sử dụng cú pháp khá đơn giản, với các trường hợp được gói vào bản đồ:

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

Tôi tiếp tục cố gắng xác định lại công tắc theo cách cho phép tôi thoát khỏi "lambda:", nhưng đã từ bỏ. Tinh chỉnh định nghĩa:

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

Cho phép tôi ánh xạ nhiều trường hợp vào cùng một mã và cung cấp tùy chọn mặc định:

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")
    })

Mỗi trường hợp sao chép phải có trong từ điển riêng của mình; switch () hợp nhất các từ điển trước khi tra cứu giá trị. Nó vẫn xấu hơn tôi muốn, nhưng nó có hiệu quả cơ bản là sử dụng tra cứu băm trên biểu thức, thay vì lặp qua tất cả các phím.

Tôi nghĩ cách tốt nhất là sử dụng các thành ngữ ngôn ngữ python để giữ cho mã của bạn có thể kiểm tra được . Như đã trình bày trong các câu trả lời trước, tôi sử dụng từ điển để tận dụng các cấu trúc và ngôn ngữ python và giữ mã "trường hợp" được phân lập trong các phương thức khác nhau. Bên dưới có một lớp, nhưng bạn có thể sử dụng trực tiếp một mô-đun, toàn cầu và các chức năng. Lớp này có các phương thức có thể được kiểm tra với sự cô lập . Tùy thuộc vào nhu cầu của bạn, bạn cũng có thể chơi với các phương thức và thuộc tính tĩnh.

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)

Có thể tận dụng phương thức này bằng cách sử dụng các lớp làm khóa của "__choice_table". Bằng cách này, bạn có thể tránh lạm dụng isinstance và giữ tất cả sạch sẽ và có thể kiểm tra.

Giả sử bạn phải xử lý rất nhiều tin nhắn hoặc gói từ mạng hoặc MQ của bạn. Mỗi gói có cấu trúc riêng và mã quản lý của nó (theo cách chung). Với đoạn mã trên, có thể làm một cái gì đó như thế này:

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)

Vì vậy, độ phức tạp không được lan truyền trong dòng mã nhưng nó được biểu hiện trong cấu trúc mã .

Mở rộng câu trả lời của Greg Hewgill - Chúng tôi có thể gói gọn giải pháp từ điển bằng cách sử dụng trang trí:

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

Điều này sau đó có thể được sử dụng với @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

Tin tốt là điều này đã được thực hiện trong NeoPySwitch -module. Đơn giản chỉ cần cài đặt bằng pip:

pip install NeoPySwitch

Một giải pháp tôi có xu hướng sử dụng cũng sử dụng từ điển là:

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)()

Điều này có lợi thế là nó không cố gắng đánh giá các chức năng mọi lúc và bạn chỉ cần đảm bảo rằng chức năng bên ngoài có được tất cả thông tin mà các chức năng bên trong cần.

Cho đến nay đã có rất nhiều câu trả lời cho biết: "chúng tôi không có công tắc trong Python, hãy làm theo cách này". Tuy nhiên, tôi muốn chỉ ra rằng chính câu lệnh chuyển đổi là một cấu trúc dễ bị lạm dụng có thể và nên tránh trong hầu hết các trường hợp vì chúng thúc đẩy lập trình lười biếng. Trường hợp tại điểm:

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

Bây giờ, bạn có thể làm điều này với một câu lệnh chuyển đổi (nếu Python cung cấp một) nhưng bạn sẽ lãng phí thời gian của mình vì có những phương pháp làm tốt điều này. Hoặc có thể, bạn có một cái gì đó ít rõ ràng hơn:

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

Tuy nhiên, loại hoạt động này có thể và nên được xử lý bằng từ điển vì nó sẽ nhanh hơn, ít phức tạp hơn, ít bị lỗi hơn và gọn hơn.

Và phần lớn "trường hợp sử dụng" cho các câu lệnh chuyển đổi sẽ thuộc một trong hai trường hợp này; chỉ có rất ít lý do để sử dụng một lý do nếu bạn nghĩ kỹ về vấn đề của mình.

Vì vậy, thay vì hỏi "làm thế nào để tôi chuyển đổi trong Python?", Có lẽ chúng ta nên hỏi, "tại sao tôi muốn chuyển đổi trong Python?" bởi vì đó thường là câu hỏi thú vị hơn và thường sẽ phơi bày những lỗ hổng trong thiết kế của bất cứ thứ gì bạn đang xây dựng.

Bây giờ, điều đó không có nghĩa là các công tắc cũng không bao giờ được sử dụng. Các máy trạng thái, từ vựng, trình phân tích cú pháp và automata đều sử dụng chúng ở một mức độ nào đó và nói chung, khi bạn bắt đầu từ một đầu vào đối xứng và đi đến một đầu ra không đối xứng, chúng có thể hữu ích; bạn chỉ cần đảm bảo rằng bạn không sử dụng công tắc như một cái búa vì bạn thấy một loạt các đinh trong mã của bạn.