පයිතන්හි ස්විච් ප්‍රකාශය සඳහා ආදේශන?

ආදාන දර්ශකයක වටිනාකම මත පදනම්ව විවිධ ස්ථාවර අගයන් ලබා දෙන ශ්‍රිතයක් පයිතන් හි ලිවීමට මට අවශ්‍යය.

වෙනත් භාෂාවලින් මම ප්‍රකාශයක් switchහෝ caseප්‍රකාශයක් භාවිතා කරමි , නමුත් පයිතන්ට switchප්‍රකාශයක් ඇති බවක් නොපෙනේ . මෙම තත්වය තුළ නිර්දේශිත පයිතන් විසඳුම් මොනවාද?

ඔබට ශබ්ද කෝෂයක් භාවිතා කළ හැකිය:

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

ඔබට පෙරනිමි අවශ්‍ය නම් ඔබට ශබ්ද කෝෂ get(key[, default])ක්‍රමය භාවිතා කළ හැකිය :

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

මම හැම විටම කැමතියි මේ ආකාරයට එය කිරීමට

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

මෙතැන් සිට

ශබ්ද කෝෂ ක්‍රමවලට අමතරව (මම ඇත්තටම කැමති, BTW), ඔබට ද if- elif- elseලබා ගැනීමට භාවිතා කළ හැකිය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

මෙය ඇත්ත වශයෙන්ම මාරුවීමට / නඩුවට සමාන නොවේ - breakප්‍රකාශය අතහැර දැමීම තරම් පහසුවෙන් ඔබට වැටිය නොහැක , නමුත් ඔබට වඩාත් සංකීර්ණ පරීක්ෂණයක් කළ හැකිය. එහි හැඩතල ගැන්වීම කැදැලි මාලාවකට වඩා හොඳයි if, ක්‍රියාකාරීව වුවද එය එයට සමීප වේ.

ස්විචය / නඩුව සඳහා මගේ ප්‍රියතම පයිතන් වට්ටෝරුව:

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

සරල අවස්ථා සඳහා කෙටි හා සරල.

සී කේතයේ පේළි 11+ සමඟ සසඳන්න:

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

ටුපල් භාවිතා කිරීමෙන් ඔබට බහු විචල්‍යයන් පවා පැවරිය හැකිය:

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

භාවිතය:

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

පරීක්ෂණ:

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

මගේ ප්‍රියතම එක ඇත්තෙන්ම හොඳ වට්ටෝරුවකි . ඔබ ඇත්තටම එයට කැමති වනු ඇත. තථ්‍ය ස්විච් සිද්ධි ප්‍රකාශයන්ට, විශේෂයෙන් විශේෂාංග වලට මා දුටු ආසන්නතම අවස්ථාව එයයි.

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

මෙන්න උදාහරණයක්:

# 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 කේතයෙන් මම ඉගෙන ගත් රටාවක් තිබේ.

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'

ඔබට ටෝකනයකින් යැවීමට සහ දිගු කේත කැබැල්ලක් ක්‍රියාත්මක කිරීමට අවශ්‍ය ඕනෑම වේලාවක එය භාවිතා කළ හැකිය. රාජ්ය යන්ත්රයක ඔබට state_ක්රම තිබේ, සහ යැවීම self.state. මූලික පන්තියෙන් උරුම වීමෙන් සහ ඔබේම do_ක්‍රම නිර්වචනය කිරීමෙන් මෙම ස්විචය පිරිසිදු ලෙස දිගු කළ හැකිය . බොහෝ විට ඔබට do_මූලික පන්තියේ ක්‍රම පවා නොතිබෙනු ඇත .

සංස්කරණය කරන්න: එය හරියටම භාවිතා කරන්නේ කෙසේද?

SMTP නම් ඔබට කම්බියෙන් ලැබෙනු HELOඇත. අදාළ කේතය (සිට twisted/mail/smtp.py, අපගේ නඩුව සඳහා වෙනස් කරන ලදි) මේ වගේ ය

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

ඔබට ලැබෙනු ඇත ' HELO foo.bar.com '(නැතහොත් ඔබට ලැබෙනු ඇත 'QUIT'හෝ 'RCPT TO: foo'). මෙය ටෝකනය කර partsඇත ['HELO', 'foo.bar.com']. සත්‍ය ක්‍රමවේදය බැලීමේ නම ලබාගෙන ඇත parts[0].

(මුල් ක්‍රමය ද හැඳින්වේ state_COMMAND, මන්ද එය රාජ්‍ය යන්ත්‍රයක් ක්‍රියාත්මක කිරීම සඳහා එකම රටාව භාවිතා කරන බැවිනි, එනම් getattr(self, 'state_' + self.mode))

ඔබට වටිනාකමක් ලබා දීමට අවශ්‍ය නැති බව කියමු, නමුත් වස්තුවක් මත යමක් වෙනස් කරන ක්‍රම භාවිතා කිරීමට අවශ්‍යය. මෙහි දක්වා ඇති ප්‍රවේශය භාවිතා කිරීම:

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

මෙහි සිදුවන්නේ පයිතන් ශබ්ද කෝෂයේ ඇති සියලුම ක්‍රම ඇගයීමයි. ඒ නිසා ඔබේ වටිනාකම 'a' පවා, වස්තුව නිලධාරිෙයකු වනු ඇත හා x මගින් අඩු වේ.

විසඳුමක්:

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

result = func(*args)

එබැවින් ඔබට ශ්‍රිතයක් සහ එහි තර්ක අඩංගු ලැයිස්තුවක් ලැබේ. මේ ආකාරයෙන්, ශ්‍රිත දර්ශකය සහ තර්ක ලැයිස්තුව පමණක් ආපසු ලැබෙනු ඇත, ඇගයීමට ලක් නොකෙරේ . 'ප්‍රති result ලය' ඉන්පසු ආපසු එන ශ්‍රිත ඇමතුම ඇගයීමට ලක් කරයි.

මම මගේ ශත දෙක මෙතනට දාන්නම්. පයිතන්හි නඩුවක් / ස්විච් ප්‍රකාශයක් නොතිබීමට හේතුව පයිතන් 'යමක් කිරීමට ඇත්තේ එකම නිවැරදි ක්‍රමයයි' යන මූලධර්මය අනුගමනය කිරීමයි. එබැවින් පැහැදිලිවම ඔබට ස්විච් / කේස් ක්‍රියාකාරිත්වය ප්‍රතිනිර්මාණය කිරීමේ විවිධ ක්‍රම ඉදිරිපත් කළ හැකිය, නමුත් මෙය සාක්ෂාත් කර ගැනීමේ පයිතොනික් ක්‍රමය නම් / එලිෆ් ඉදිකිරීම් වේ. එනම්

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

මට දැනුනේ PEP 8 මෙහි අනුමැතිය ලැබිය යුතු බවයි. පයිතන් පිළිබඳ සුන්දර දේවලින් එකක් වන්නේ එහි සරල බව සහ අලංකාරයයි. එය බොහෝ දුරට ව්‍යුත්පන්න වී ඇත්තේ PEP 8 හි සඳහන් කර ඇති මූලධර්මයන්ගෙන් වන අතර, “යමක් කිරීමට ඇත්තේ එකම නිවැරදි මාර්ගයයි”

"ඩික්ට් ස්විච්" අදහස මත පුළුල් කිරීම. ඔබගේ ස්විචය සඳහා පෙරනිමි අගයක් භාවිතා කිරීමට ඔබට අවශ්‍ය නම්:

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

කාර්යයන් ක්‍රියාත්මක කිරීමට විසඳුම:

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

එහිදී foo1 (), foo2 (), foo3 () සහ පෙරනිමි () යනු ශ්‍රිත වේ

ඔබට සංකීර්ණ සිද්ධි වාරණයක් තිබේ නම්, ශ්‍රිත ශබ්ද කෝෂ බැලීමේ වගුවක් භාවිතා කිරීම ගැන සලකා බැලිය හැකිය ...

ඔබේ නිදොස්කරණයට පිවිසීම සහ ශබ්දකෝෂය එක් එක් ශ්‍රිතය දෙස බලන ආකාරය බැලීම හොඳ අදහසක් වීමට පෙර ඔබ මෙය කර නොමැති නම්.

සටහන: කිසිවිටෙකත් නෑ "()" මෙම නඩුව තුළ / ශබ්ද කෝෂය බැලීම භාවිතා හෝ ශබ්ද කෝෂය / නඩුව වාරණ නිර්මාණය ලෙස එය ඔබගේ එක් එක් කාර්ය කියනු ඇත. මෙය මතක තබා ගන්න ඔබට අවශ්‍ය වන්නේ එක් එක් ශ්‍රිතය ඇමතීමට අවශ්‍ය වන්නේ එක් වරක් හැෂ් ස්ටයිල් බැලීමක් භාවිතා කරමිනි.

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

මෙහි ඇති පිළිතුරු බොහොමයක් පැරණි ඒවා වන අතර විශේෂයෙන් පිළිගත් ඒවා බැවින් එය යාවත්කාලීන කිරීම වටී.

පළමුව, නිල පයිතන් නිති අසන ප්‍රශ්න මෙය ආවරණය elifකරන අතර සරල අවස්ථා සඳහා දාමය සහ dictවිශාල හෝ වඩා සංකීර්ණ අවස්ථා සඳහා දාමය නිර්දේශ කරයි . visit_සමහර අවස්ථා සඳහා ක්‍රම මාලාවක් (බොහෝ සේවාදායක රාමු භාවිතා කරන විලාසිතාවක්) ද එය යෝජනා කරයි :

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

නිතර අසනු ලබන ප්‍රශ්නවල PEP 275 ගැන සඳහන් වන අතර එය සී-ස්ටයිල් ස්විච් ප්‍රකාශ එකතු කිරීම පිළිබඳ නිල සහ එක් වරක් තීරණය ලබා ගැනීම සඳහා ලියා ඇත. නමුත් එම PEP සැබවින්ම පයිතන් 3 වෙත කල් දැමූ අතර එය නිල වශයෙන් ප්‍රතික්ෂේප කරනු ලැබුවේ වෙනම යෝජනාවක් වන PEP 3103 ලෙස පමණි . පිළිතුර ඇත්ත වශයෙන්ම නැත - නමුත් ඔබ හේතු හෝ ඉතිහාසය ගැන උනන්දුවක් දක්වන්නේ නම් PEPs දෙකට අමතර තොරතුරු සඳහා සබැඳි ඇත.

කිහිප වතාවක්ම පැමිණි එක් දෙයක් (සහ එය PEP 275 හි දැකිය හැකිය, එය සත්‍ය නිර්දේශයක් ලෙස කපා හැර තිබුනද), ඔබට නඩු 4 ක් හැසිරවීමට කේත පේළි 8 ක් තිබීම ගැන කරදර වන්නේ නම්, එදිරිව 6 ඔබට සී හෝ බෑෂ් හි ඇති රේඛා, ඔබට මෙය සැමවිටම ලිවිය හැකිය:

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

මෙය PEP 8 විසින් හරියටම ධෛර්යමත් නොකෙරේ, නමුත් එය කියවිය හැකි අතර එය ඒකාකාරී නොවේ.

PEP 3103 ප්‍රතික්ෂේප වී දශකයකට වැඩි කාලයක් තිස්සේ, C- විලාසිතාවේ සිද්ධි ප්‍රකාශ නිකුත් කිරීම හෝ Go හි තරමක් ප්‍රබල අනුවාදය පවා මිය ගොස් ඇතැයි සැලකේ; කවුරුහරි එය පයිතන් අදහස් හෝ -දෙව් මත ගෙන එන විට, ඔවුන් පැරණි තීරණයට යොමු කරනු ලැබේ.

කෙසේ වෙතත්, සෑම වසර කිහිපයකට වරක් පූර්ණ එම්එල්-රටා රටා ගැලපීම පිළිබඳ අදහස පැන නගී, විශේෂයෙන් ස්විෆ්ට් සහ රස්ට් වැනි භාෂාවන් එය භාවිතා කර ඇති හෙයින්. ගැටළුව වන්නේ වීජීය දත්ත වර්ග නොමැතිව රටා ගැලපීමෙන් වැඩි ප්‍රයෝජනයක් ලබා ගැනීම දුෂ්කර වීමයි. ගයිඩෝ මෙම අදහසට අනුකම්පා කර ඇති අතර, කිසිවෙකු පයිතන්ට හොඳින් ගැලපෙන යෝජනාවක් ඉදිරිපත් කර නැත. (ඔබට මගේ 2014 ස්ට්රෝමන් කියවිය හැකිය උදාහරණයක් සඳහා.) මෙම සමඟ වෙනස් විය හැකි dataclass3.7 හා වඩාත් බලවත් සඳහා යම් යම් කඩින් කඩ යෝජනා enumමුදලක් වර්ග හැසිරවීමට, හෝ (ප්රකාශය-දේශීය සබඳතා විවිධ වර්ගවල විවිධ යෝජනා වැනි සමග පී.ඊ.පී. 3150 , හෝ -අයිඩියස් හි දැනට සාකච්ඡා කෙරෙන යෝජනා මාලාවක්). නමුත් මෙතෙක් එය එසේ වී නැත.

පර්ල් 6 විලාසිතාවේ ගැලපීම සඳහා ඉඳහිට යෝජනා ද ඇත, එය මූලික වශයෙන් රීජෙක්ස් elifසිට තනි පිටත් කිරීමේ වර්ග මාරුව දක්වා සියල්ලේ මිෂ්මාෂ් ය .

ඔබ "ස්විචය" ලෙස අමතර ප්‍රකාශයක් සොයන්නේ නම්, මම පයිතන් දිගු කරන පයිතන් මොඩියුලයක් සාදන ලදී. එය හැඳින්වේ ESPY "පයිතන් සඳහා වැඩි දියුණු කළ ව්‍යුහය" ලෙස අතර එය පයිතන් 2.x සහ පයිතන් 3.x යන දෙකටම ලබා ගත හැකිය.

උදාහරණයක් ලෙස, මෙම අවස්ථාවේදී, පහත දැක්වෙන කේතය මඟින් ස්විච් ප්‍රකාශයක් කළ හැකිය:

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

එය මේ ආකාරයෙන් භාවිතා කළ හැකිය:

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

එබැවින් එස්පී විසින් එය පයිතන් භාෂාවෙන් පරිවර්තනය කරයි:

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

පොදු ස්විච් ව්‍යුහයක් බව මට පෙනී ගියේය:

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

පහත පරිදි පයිතන්හි ප්‍රකාශ කළ හැකිය:

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

හෝ පැහැදිලි ආකාරයකින් සංයුති කර ඇත:

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

ප්‍රකාශයක් වෙනුවට පයිතන් අනුවාදය ප්‍රකාශනයක් වන අතර එය අගයක් තක්සේරු කරයි.

ගූගල් සෙවුමේ කොතැනකවත් මා සොයන සරල පිළිතුර මට හමු නොවීය. නමුත් මම එය කෙසේ හෝ හදුනා ගතිමි. එය ඇත්තෙන්ම තරමක් සරල ය. එය පළ කිරීමට තීරණය කළ අතර, වෙනත් කෙනෙකුගේ හිසෙහි සීරීම් කිහිපයක් වළක්වා ගත හැකිය. යතුර සරලව "in" සහ tuples වේ. RANDOM fall-through ඇතුළුව වැටීම හරහා මාරුවීමේ ප්‍රකාශන හැසිරීම මෙන්න.

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)

සපයයි:

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.

මම භාවිතා කරන විසඳුම්:

මෙහි පළ කර ඇති විසඳුම් 2 ක එකතුවක් වන අතර එය කියවීමට පහසු වන අතර පෙරනිමි සඳහා සහාය වේ.

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

කොහෙද

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

"lambda x: x - 2"ආ ict ාව දෙස බලා එය භාවිතා කරයිx=23

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

මෙම dict තුළ සොයා හා පෙරනිමි භාවිතා කරන්නේ නැත "lambda x: x - 22"සමග 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

මම කැමතියි මාක් බීස්ගේ පිළිතුරට

සිට xවිචල්‍යය දෙවරක් භාවිතා කළ යුතු , මම ලැම්බඩා ශ්‍රිත පරාමිති රහිත ලෙස වෙනස් කළෙමි.

මට දුවන්න වෙනවා 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'

සංස්කරණය කරන්න:None ශබ්ද කෝෂ සමඟ ටයිප් භාවිතා කළ හැකි බව මම දුටුවෙමි . එබැවින් මෙය අනුකරණය කරනු ඇතswitch ; case else

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

කෙටි හා කියවීමට පහසු, පෙරනිමි අගයක් ඇති අතර කොන්දේසි සහ ප්‍රතිලාභ අගයන් දෙකෙහිම ප්‍රකාශන සඳහා සහය දක්වයි.

කෙසේ වෙතත්, එය ශබ්ද කෝෂයක් සමඟ ඇති විසඳුමට වඩා අඩු කාර්යක්ෂම වේ. උදාහරණයක් ලෙස, පෙරනිමි අගය ලබා දීමට පෙර පයිතන්ට සියලු කොන්දේසි පරිලෝකනය කළ යුතුය.

ඔබට යවන ලද නියෝගයක් භාවිතා කළ හැකිය:

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

ප්‍රතිදානය:

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

සරල, පරීක්ෂා කර නැත; සෑම කොන්දේසියක්ම ස්වාධීනව ඇගයීමට ලක් කරනු ලැබේ: බිඳවැටීමක් නොමැත, නමුත් සියලු අවස්ථා ඇගයීමට ලක් කෙරේ (මාරුවීමේ ප්‍රකාශනය ඇගයීමට ලක් කරනු ලබන්නේ එක් වරක් පමණි), විවේක ප්‍රකාශයක් නොමැති නම්. උදාහරණයක් වශයෙන්,

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

පිටපත් Was 1. Was 1 or 2. Was something. ^{(Dammit! ඇයි මම පේළිගත කේතයන් තුළ whitespace අවර ඇත නොහැකි?)} නම් expressionඇගයීමට කිරීමට 1, Was 2.නම් expressionකිරීමට ඇගයීමට 2හෝ Was something.නම් expressionවෙන දෙයක් කිරීමට ඇගයීමට.

නිර්වචනය:

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

සිතියමකට සම්බන්ධ කර ඇති අවස්ථා සමඟ තරමක් සරල වාක්‍ය ඛණ්ඩයක් භාවිතා කිරීමට ඔබට ඉඩ සලසයි:

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

මම "ලැම්බඩා:" ඉවත් කිරීමට ඉඩ සලසන අයුරින් ස්විචය නැවත අර්ථ දැක්වීමට උත්සාහ කළ නමුත් එය අත්හැරියෙමි. අර්ථ දැක්වීම වෙනස් කිරීම:

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

එකම කේතයකට අවස්ථා කිහිපයක් සිතියම් ගත කිරීමට සහ පෙරනිමි විකල්පයක් සැපයීමට මට ඉඩ දී ඇත:

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

ප්‍රතිවර්තනය කරන ලද සෑම නඩුවක්ම එහි ශබ්ද කෝෂයේ තිබිය යුතුය; ස්විචය () අගය බැලීමට පෙර ශබ්ද කෝෂ ඒකාබද්ධ කරයි. එය මා කැමති ප්‍රමාණයට වඩා තවමත් කැතයි, නමුත් එයට සියලු යතුරු හරහා ලූපයක් වෙනුවට ප්‍රකාශනය මත හැෂ් බැලීමක් භාවිතා කිරීමේ මූලික කාර්යක්ෂමතාව ඇත.

මම හිතන්නේ හොඳම ක්‍රමය ඔබේ කේතය පරීක්ෂා කර බැලීමට පයිතන් භාෂා මෝඩයන් භාවිතා කිරීමයි . පෙර පිළිතුරු වල පෙන්වා ඇති පරිදි, මම පයිතන් ව්‍යුහයන්ගෙන් සහ භාෂාවෙන් ප්‍රයෝජන ගැනීමට ශබ්ද කෝෂ භාවිතා කරන අතර "කේස්" කේතය විවිධ ක්‍රම වලින් හුදකලා කර තබමි. පහළින් පංතියක් ඇත, නමුත් ඔබට කෙලින්ම මොඩියුලයක්, ග්ලෝබල් සහ කාර්යයන් භාවිතා කළ හැකිය. පන්තියට හුදකලාව පරීක්ෂා කළ හැකි ක්‍රම තිබේ . ඔබගේ අවශ්‍යතා මත පදනම්ව, ඔබට ස්ථිතික ක්‍රම සහ ගුණාංග සමඟ සෙල්ලම් කළ හැකිය.

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" හි යතුරු ලෙස පන්ති ද භාවිතා කරමින් මෙම ක්‍රමයේ වාසිය ලබා ගත හැකිය . මේ ආකාරයෙන් ඔබට අනිසි අපයෝජනයන් වළක්වා ගත හැකි අතර සියල්ල පිරිසිදුව හා පරීක්‍ෂා කළ හැකිය.

ඔබට ජාලයෙන් හෝ ඔබේ MQ වෙතින් පණිවිඩ හෝ පැකට් ගොඩක් සැකසිය යුතු යැයි සිතමු. සෑම පැකට්ටුවකටම තමන්ගේම ව්‍යුහයක් සහ කළමනාකරණ කේතයක් ඇත (සාමාන්‍ය ආකාරයෙන්). ඉහත කේතය සමඟ මෙවැනි දෙයක් කළ හැකිය:

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)

එබැවින් කේත ප්‍රවාහයේ සංකීර්ණත්වය ව්‍යාප්ත නොවන නමුත් එය කේත ව්‍යුහයෙන් විදහා දක්වයි .

ග්‍රෙග් හෙව්ගිල්ගේ පිළිතුර පුළුල් කිරීම - සැරසිලි කරුවෙකු භාවිතයෙන් අපට ශබ්ද කෝෂ විසඳුම සංයුක්ත කළ හැකිය:

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

මෙය පසුව @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

ශුභාරංචිය නම් මෙය දැනටමත් NeoPySwitch -module හි සිදු කර ඇති බවයි . පයිප්ප භාවිතයෙන් ස්ථාපනය කරන්න:

pip install NeoPySwitch

ශබ්ද කෝෂ භාවිතා කරන මා භාවිතා කිරීමට නැඹුරු වන විසඳුමක් නම්:

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

මෙය සෑම විටම කාර්යයන් ඇගයීමට උත්සාහ නොකිරීමේ වාසියක් ඇති අතර, අභ්‍යන්තර ශ්‍රිතයට අවශ්‍ය සියලු තොරතුරු බාහිර ශ්‍රිතයට ලැබෙන බවට ඔබ සහතික විය යුතුය.

"අපට පයිතන්හි ස්විචයක් නොමැත, එය මේ ආකාරයෙන් කරන්න" යනුවෙන් පවසා ඇති පිළිතුරු රාශියක් මේ වන විට තිබේ. කෙසේ වෙතත්, ස්විච් ප්‍රකාශය පහසුවෙන්ම අනිසි ලෙස භාවිතා කළ හැකි ඉදිකිරීමක් බව පෙන්වා දීමට මම කැමැත්තෙමි. කාරණය අනුව:

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

දැන්, ඔබ හැකි මාරු-ප්රකාශය සමග මෙය (Python එක් ඉදිරිපත් නම්) නමුත් මේ දැන් හොදින් කරන ක්රම තිබෙනවා නිසා ඔබ ඔබේ කාලය නාස්ති කළ කියලා. නැතහොත්, ඔබට අඩු පැහැදිළි යමක් තිබේ:

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

කෙසේ වෙතත්, මෙවැනි ක්‍රියාකාරිත්වයක් ශබ්දකෝෂයකින් හැසිරවිය හැකි අතර එය වේගවත්, අඩු සංකීර්ණ, දෝෂ වලට ගොදුරු වීමේ අවදානම අඩු හා වඩා සංයුක්ත වනු ඇත.

ස්විච් ප්‍රකාශ සඳහා “භාවිතා කිරීමේ අවස්ථා” වලින් බහුතරයක් මෙම අවස්ථා දෙකෙන් එකකට වැටෙනු ඇත; ඔබ ඔබේ ගැටලුව ගැන තරයේ සිතුවා නම් එකක් භාවිතා කිරීමට ඇත්තේ ඉතා අල්ප හේතුවකි.

ඉතින්, "මම පයිතන් වෙත මාරු වන්නේ කෙසේද?" යනුවෙන් අසනවාට වඩා, සමහර විට අප ඇසිය යුත්තේ, "මට පයිතන් තුළට මාරුවීමට අවශ්‍ය ඇයි?" මන්ද එය බොහෝ විට වඩාත් සිත්ගන්නාසුලු ප්‍රශ්නය වන අතර බොහෝ විට ඔබ ගොඩනඟන ඕනෑම දෙයක් සැලසුම් කිරීමේදී අඩුපාඩු හෙළි කරනු ඇත.

දැන්, ස්විචයන් කිසි විටෙකත් භාවිතා නොකළ යුතු යැයි නොකියයි. රාජ්‍ය යන්ත්‍ර, ලෙක්සර්, පාර්සර් සහ ඔටෝමැටා යන සියල්ලම ඒවා යම් ප්‍රමාණයකට භාවිතා කරන අතර, පොදුවේ ගත් කල, ඔබ සමමිතික ආදානයකින් ආරම්භ කර අසමමිතික නිමැවුමකට ගිය විට ඒවා ප්‍රයෝජනවත් වේ; ඔබේ කේතයේ නියපොතු පොකුරක් දකින නිසා ඔබ ස්විචය මිටියක් ලෙස භාවිතා නොකරන බවට වග බලා ගත යුතුය.