Python'daki switch deyiminin değiştirilmesi?

Bir girdi dizininin değerine göre farklı sabit değerler döndüren bir işlev Python yazmak istiyorum.

Diğer dillerde bir switchveya casedeyimi kullanırım, ancak Python'un bir switchifadesi yok gibi görünüyor . Bu senaryoda önerilen Python çözümleri nelerdir?

Bir sözlük kullanabilirsiniz:

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

Varsayılanları isterseniz sözlük get(key[, default])yöntemini kullanabilirsiniz :

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

Bunu hep böyle yapmayı sevdim

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

Buradan

(Gerçekten BTW gibi), ayrıca kullanabilirsiniz Sözlük yöntemlere ek olarak if- elif- elseelde etmek switch/ case/ defaultişlevsellik:

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

Bu elbette geçiş / durumla aynı değildir - breakifadeyi bırakmak kadar kolay düşemezsiniz, ancak daha karmaşık bir test yapabilirsiniz. ifİşlevsel olarak daha yakın olmasına rağmen, biçimlendirmesi bir dizi iç içe s'den daha iyidir .

Switch / case için en sevdiğim Python tarifi:

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

Kısa ve basit senaryolar için basit.

11+ C kodu satırıyla karşılaştırın:

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

Tüpleri kullanarak birden çok değişken bile atayabilirsiniz:

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

Kullanımı:

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

Testler:

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

En sevdiğim, gerçekten güzel bir tarif . Gerçekten hoşuna gidecek. Özellikle özelliklerde, gerçek anahtar durum ifadelerine en yakın gördüğüm.

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

İşte bir örnek:

# 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

Twisted Python kodundan öğrendiğim bir model var.

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'

Bir jetona göndermeniz ve genişletilmiş bir kod parçası yürütmeniz gerektiğinde bunu kullanabilirsiniz. Durum makinesinde state_yöntemleriniz olur ve gönderilir self.state. Bu anahtar, temel sınıftan devralınarak ve kendi do_yöntemlerinizi tanımlayarak temiz bir şekilde genişletilebilir . Çoğu zaman do_temel sınıfta yönteminiz bile olmaz .

Düzenleme: tam olarak nasıl kullanılır

SMTP durumunda HELOtelden alacaksınız . İlgili kod ( twisted/mail/smtp.pybizim durumumuz için değiştirildi) şu şekilde görünüyor

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

Sen alacaksınız ' HELO foo.bar.com '(veya alabilirsiniz 'QUIT'ya 'RCPT TO: foo'). Bu içine simgeleþtirilmiþ edilir partsolarak ['HELO', 'foo.bar.com']. Gerçek yöntem arama adı alınır parts[0].

(Orijinal yöntem de denir state_COMMAND, çünkü bir durum makinesini uygulamak için aynı modeli kullanır, yani getattr(self, 'state_' + self.mode))

Diyelim ki sadece bir değer döndürmek istemiyorsunuz, aynı zamanda bir nesnede bir şeyi değiştiren yöntemleri kullanmak istiyorsunuz. Burada belirtilen yaklaşımı kullanmak:

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

Burada olan şey, python'un sözlükteki tüm yöntemleri değerlendirmesidir. Bu nedenle, değeriniz 'a' olsa bile, nesne x ile artırılır ve azaltılır.

Çözüm:

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

result = func(*args)

Böylece bir işlev ve argümanlarını içeren bir liste alırsınız. Bu şekilde, yalnızca işlev işaretçisi ve argüman listesi geri verilmesinde, değil değerlendirdi. 'sonuç' sonra döndürülen işlev çağrısını değerlendirir.

İki sentimi buraya bırakacağım. Python'da bir vaka / anahtar ifadesinin olmamasının nedeni, Python'un 'Bir şey yapmanın tek bir doğru yolu' ilkesini izlemesidir. Açıkçası, anahtar / vaka işlevselliğini yeniden yaratmanın çeşitli yollarını bulabilirdiniz, ancak bunu gerçekleştirmenin Pythonic yolu if / elif yapısıdır. yani

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

PEP 8'in burada başını hak ettiğini hissettim. Python ile ilgili güzel şeylerden biri sadeliği ve zarafeti. Bu büyük ölçüde PEP 8'de "Bir şeyi yapmanın tek bir doğru yolu var"

"anahtar olarak dikte" fikrini genişletiyor. anahtarınız için varsayılan bir değer kullanmak istiyorsanız:

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

Karmaşık bir vaka bloğunuz varsa, bir işlev sözlüğü arama tablosu kullanmayı düşünebilirsiniz ...

Bunu daha önce yapmadıysanız, hata ayıklayıcınıza adım atmak ve sözlüğün her işlevi nasıl aradığını görmek iyi bir fikirdir.

NOT: Do not "()" veya vaka / sözlük arama içeride o Sözlük / kutu bloğu oluşturulur olarak fonksiyonların her arayacak kullanın. Bunu unutmayın, çünkü her işlevi yalnızca bir kez karma stil araması kullanarak çağırmak istersiniz.

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

Ekstra deyim arıyorsanız "switch" olarak Python'u genişleten bir python modülü oluşturdum. ESPY'ye "Python için Gelişmiş Yapı" denir ve hem Python 2.x hem de Python 3.x için kullanılabilir.

Örneğin, bu durumda, aşağıdaki kodla bir switch ifadesi gerçekleştirilebilir:

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

şu şekilde kullanılabilir:

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

bu yüzden espy Python'da şöyle tercüme eder:

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

Ortak bir anahtar yapısı buldum:

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

Python ile şu şekilde ifade edilebilir:

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

veya daha net bir şekilde biçimlendirilmiş:

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

Bir deyim olmak yerine, python sürümü bir değeri değerlendiren bir ifadedir.

Buradaki cevapların çoğu oldukça eski ve özellikle kabul edilenler, bu yüzden güncellenmeye değer görünüyor.

İlk olarak, resmi Python SSS bu konuyu kapsar ve elifbasit vakalar için ve dictdaha büyük veya daha karmaşık vakalar için zinciri önerir . Ayrıca visit_, bazı durumlarda bir dizi yöntem (birçok sunucu çerçevesi tarafından kullanılan bir stil) önerir :

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

SSS ayrıca C-tarzı anahtar ifadeleri ekleme konusunda resmi bir kez ve hep birlikte karar almak için yazılan PEP 275'ten de bahsetmektedir . Ancak bu PEP aslında Python 3'e ertelendi ve sadece resmi olarak ayrı bir teklif olarak reddedildi, PEP 3103 . Yanıt elbette hayırdı, ancak nedenlerle veya geçmişle ilgileniyorsanız iki PEP'in ek bilgilere bağlantıları vardır.

Birden fazla kez ortaya çıkan bir şey (ve gerçek bir öneri olarak kesilmiş olsa da PEP 275'te görülebilir), 4 vakayı işlemek için 8 satır kodla gerçekten rahatsız olursanız, C veya Bash'taki satırlara her zaman şunu yazabilirsiniz:

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

Bu PEP 8 tarafından tam olarak teşvik edilmez, ancak okunabilir ve çok tekdüze değil.

PEP 3103'ün reddedilmesinden bu yana geçen on yıldan fazla bir süredir, C-tarzı vaka ifadeleri, hatta Go'daki biraz daha güçlü bir sürümün ölü olduğu düşünülüyordu; ne zaman birisi python-fikirleri ya da -dev'i ortaya koyarsa, eski karara yönlendirilirler.

Bununla birlikte, tam ML tarzı desen eşleştirme fikri, özellikle Swift ve Rust gibi diller onu benimsediğinden, birkaç yılda bir ortaya çıkar. Sorun, cebirsel veri türleri olmadan desen eşleşmesinden çok fazla faydalanmanın zor olmasıdır. Guido bu fikre sempati duysa da, hiç kimse Python'a çok iyi uyan bir teklif bulamadı. ( Bir örnek için 2014 strawman'ımı okuyabilirsiniz .) Bu, 3.7'dedataclass ve enumtoplam türlerini işlemek için daha güçlü bir şekilde bazı düzensiz tekliflerle veya farklı türde yerel bildirimler için ( PEP 3150 veya şu anda tartışılan teklifler kümesi -ideler). Ama şimdiye kadar olmadı.

Ayrıca, temelde elifnormal ifadeden tek gönderim tür anahtarlamaya kadar her şeyin bir karması olan Perl 6 tarzı eşleştirme için öneriler de vardır .

Fonksiyonları çalıştırmak için çözüm:

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

burada foo1 (), foo2 (), foo3 () ve default () işlevlerdir

Google aramada hiçbir yerde aradığım basit cevabı bulamadım. Ama yine de anladım. Gerçekten çok basit. Göndermeye karar verdim ve belki de başkasının kafasında birkaç çizik olmasını önleyin. Anahtar basitçe "içeri" ve tuples. RANDOM düşmesi de dahil olmak üzere düşme ile switch deyimi davranışı.

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)

sağlar:

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.

Kullandığım çözümler:

Burada yayınlanan ve okunması nispeten kolay olan ve varsayılanları destekleyen 2 çözümün bir kombinasyonu.

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

nerede

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

"lambda x: x - 2"dikte bakar ve kullanırx=23

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

bunu dikte bulamaz ve varsayılanı "lambda x: x - 22"ile kullanır 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

Mark Bies'in cevabını beğendim

Yana xdeğişken zorunluluk iki kez kullanılan, ben parametresiz lambda fonksiyonları modifiye.

Koşmak zorundayım 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'

Düzenleme: Ben Nonesözlük ile birlikte türü kullanabileceğini fark ettim . Bu taklit olurduswitch ; case else

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

Kısa ve okunması kolay, varsayılan bir değere sahiptir ve hem koşullarda hem de dönüş değerlerinde ifadeleri destekler.

Ancak, sözlüğü olan çözümden daha az verimlidir. Örneğin, Python varsayılan değeri döndürmeden önce tüm koşulları taramak zorundadır.

gönderilen bir sözlük kullanabilirsiniz:

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

Çıktı:

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

Basit, test edilmedi; her koşul bağımsız olarak değerlendirilir: düşüş olmaz, ancak bir kesme ifadesi olmadığı sürece tüm durumlar değerlendirilir (açılma ifadesi yalnızca bir kez değerlendirilir). Örneğin,

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

baskılar Was 1. Was 1 or 2. Was something. ^{(Dammit! Neden? inline kod bloklar halinde sonlarındaki boşluk olamaz)} eğer expressionüzere değerlendirir 1, Was 2.eğer expressiondeğerlendirir için 2veya Was something.eğer expressiondeğerlendirir başka bir şeye.

tanımlanması:

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

durumları bir harita halinde paketlenmiş olarak oldukça basit bir sözdizimi kullanmanıza olanak tanır:

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

Anahtarı "lambda:" 'dan kurtulmama izin verecek şekilde yeniden tanımlamaya çalıştım ama vazgeçtim. Tanımı değiştirmek:

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

Birden fazla örneği aynı koda eşlememe ve varsayılan bir seçenek sunmama izin verdi:

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

Her çoğaltılmış durumun kendi sözlüğünde olması gerekir; switch (), değeri aramadan önce sözlükleri birleştirir. Hala istediğimden daha çirkin, ama tüm anahtarlar arasında bir döngü yerine ifadede karma bir arama kullanmanın temel verimliliğine sahip.

En iyi yolu kod test edilebilir tutmak için python dil deyimlerini kullanmak olduğunu düşünüyorum . Önceki yanıtlarda gösterildiği gibi , python yapılarından ve dilinden yararlanmak ve "case" kodunu farklı yöntemlerle izole tutmak için sözlükler kullanıyorum . Aşağıda bir sınıf var, ancak doğrudan bir modül, globaller ve fonksiyonlar kullanabilirsiniz. Sınıfta izolasyon ile test edilebilecek yöntemler vardır . İhtiyaçlarınıza bağlı olarak, statik yöntemler ve niteliklerle de oynayabilirsiniz.

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)

"__Choice_table" anahtarları olarak sınıflar kullanarak da bu yöntemden yararlanmak mümkündür . Bu şekilde isinstance kötüye kullanımını önleyebilir ve tüm temiz ve test edilebilir tutabilirsiniz.

İnternetten veya MQ'nuzdan çok fazla mesaj veya paket işlemeniz gerektiğini varsayalım. Her paketin kendi yapısı ve yönetim kodu vardır (genel bir şekilde). Yukarıdaki kod ile böyle bir şey yapmak mümkündür:

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)

Dolayısıyla karmaşıklık kod akışında yayılmaz ancak kod yapısında oluşturulur .

Üzerine Genişleyen Greg Hewgill cevabı - Bir dekoratör kullanarak Sözlük-çözüm sarabiliriz:

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

Bu daha sonra @case-decorator ile kullanılabilir

@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

İyi haber şu ki, bu zaten NeoPySwitch modülünde yapılmış . Sadece pip kullanarak kurun:

pip install NeoPySwitch

Sözlükleri de kullanan, kullanma eğiliminde olduğum bir çözüm:

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

Bunun avantajı, her seferinde fonksiyonları değerlendirmeye çalışmadığıdır ve sadece dış fonksiyonun iç fonksiyonların ihtiyaç duyduğu tüm bilgileri almasını sağlamanız gerekir.

Şimdiye kadar, "Python'da bir anahtarımız yok, bu şekilde yap" diyen çok sayıda cevap vardı. Ancak, switch ifadesinin kendisinin, tembel programlamayı teşvik ettikleri için çoğu durumda kaçınılması gereken ve kaçınılması gereken kolayca kötüye kullanılan bir yapı olduğunu belirtmek isterim. Konuşma konusu olan mesele:

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

Şimdi, olabilir bir switch deyimi ile bunu (Python bir teklif varsa) ama bu sadece para cezası yapmak yöntem vardır çünkü vaktini boşa olurdu. Ya da belki daha az belirgin bir şeyiniz vardır:

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

Bununla birlikte, bu tür bir işlem daha hızlı, daha az karmaşık, hataya daha az eğilimli ve daha kompakt olacağı için bir sözlükle ele alınabilir ve ele alınmalıdır.

Ve anahtar ifadeleri için "kullanım senaryolarının" büyük çoğunluğu bu iki durumdan birine girecektir; sorununuzu iyice düşündüyseniz, bunu kullanmanız için çok az neden vardır.

Yani, "Python'a nasıl geçebilirim?" Sorusunu sormak yerine, belki de "Python'a neden geçmek istiyorum?" Diye sormalıyız. çünkü bu genellikle daha ilginç bir sorudur ve inşa ettiğiniz şeyin tasarımındaki kusurları ortaya çıkarır.

Şimdi, bu anahtarların asla kullanılmaması gerektiği anlamına gelmez. Durum makineleri, sözlükler, ayrıştırıcılar ve otomatalar bunları bir dereceye kadar kullanırlar ve genel olarak simetrik bir girdiden başlayıp asimetrik bir çıktıya gittiğinizde yararlı olabilirler; kodunuzda bir sürü çivi gördüğünüz için anahtarı çekiç olarak kullanmadığınızdan emin olmanız gerekir.