Python Language
अन्य भाषाओं से कथन स्विच करने के विकल्प

टिप्पणियों

भाषा जो प्रदान करती है उसका उपयोग करें: यदि / अन्यथा निर्माण।

ठीक है, यदि आप एक switch / case निर्माण चाहते हैं, तो जाने के लिए सबसे सरल तरीका अच्छा पुराना उपयोग करना है if / else निर्माण:

def switch(value):
    if value == 1:
        return "one"
    if value == 2:
        return "two"
    if value == 42:
        return "the answer to the question about life, the universe and everything"
    raise Exception("No case found!")

यह बेमानी लग सकता है, और हमेशा सुंदर नहीं, लेकिन यह अब तक का सबसे कुशल तरीका है, और यह काम करता है:

>>> switch(1)
one
>>> switch(2)
two
>>> switch(3)
…
Exception: No case found!
>>> switch(42)
the answer to the question about life the universe and everything

एक कार्य का उपयोग करें

कार्यों का एक शब्दकोश बनाने के लिए जाने का एक और सीधा तरीका है:

switch = {
    1: lambda: 'one',
    2: lambda: 'two',
    42: lambda: 'the answer of life the universe and everything',
}

तब आप एक डिफ़ॉल्ट फ़ंक्शन जोड़ते हैं:

def default_case():
    raise Exception('No case found!')

और आप इसे प्राप्त करने और चलाने के लिए फ़ंक्शन को प्राप्त करने के लिए शब्दकोश की विधि का उपयोग करते हैं। यदि मान डिक्शनरी में मौजूद नहीं है, तो default_case चलाया जाता है।

>>> switch.get(1, default_case)()
one
>>> switch.get(2, default_case)()
two
>>> switch.get(3, default_case)()
…
Exception: No case found!
>>> switch.get(42, default_case)()
the answer of life the universe and everything

आप कुछ सिंटैक्टिक शुगर भी बना सकते हैं ताकि स्विच अच्छा दिखे:

def run_switch(value):
    return switch.get(value, default_case)()

>>> run_switch(1)
one

वर्ग आत्मनिरीक्षण का उपयोग करें

आप स्विच / केस संरचना की नकल करने के लिए एक वर्ग का उपयोग कर सकते हैं। निम्नलिखित "केस" भाग को हल करने के लिए एक वर्ग के आत्मनिरीक्षण का उपयोग कर getattr() फ़ंक्शन का उपयोग करता है जो एक स्ट्रिंग को एक उदाहरण पर एक बाध्य विधि में हल करता है)।

फिर उस __call__ विधि को __call__ मेथड को ओवरलोड करने के लिए __call__ किया जाता है () ऑपरेटर।

class SwitchBase:
    def switch(self, case):
        m = getattr(self, 'case_{}'.format(case), None)
        if not m:
            return self.default
        return m

    __call__ = switch

फिर इसे अच्छे लगने के लिए, हम SwitchBase क्लास को हटा देते हैं (लेकिन यह एक कक्षा में किया जा सकता है), और वहाँ हम सभी case को विधियों के रूप में परिभाषित करते हैं:

class CustomSwitcher:
    def case_1(self):
        return 'one'

    def case_2(self):
        return 'two'

    def case_42(self):
        return 'the answer of life, the universe and everything!'

    def default(self):
        raise Exception('Not a case!')

तो फिर हम अंत में इसका इस्तेमाल कर सकते हैं:

>>> switch = CustomSwitcher()
>>> print(switch(1))
one
>>> print(switch(2))
two
>>> print(switch(3))
…
Exception: Not a case!
>>> print(switch(42))
the answer of life, the universe and everything!

एक संदर्भ प्रबंधक का उपयोग करना

एक और तरीका, जो बहुत पठनीय और सुरुचिपूर्ण है, लेकिन अगर / अन्य संरचना की तुलना में बहुत कम कुशल है, तो निम्नानुसार एक वर्ग का निर्माण करना है, जो कि तुलना करने के लिए मूल्य को पढ़ेगा और संग्रहीत करेगा, संदर्भ के भीतर एक कॉल करने योग्य के रूप में उजागर करता है। अगर यह संग्रहीत मूल्य से मेल खाता है तो यह सच होगा:

class Switch:
    def __init__(self, value): 
        self._val = value
    def __enter__(self):
        return self
    def __exit__(self, type, value, traceback):
        return False # Allows traceback to occur
    def __call__(self, cond, *mconds): 
        return self._val in (cond,)+mconds

फिर मामलों को परिभाषित करना वास्तविक switch / case निर्माण के लिए लगभग एक मैच है (नीचे एक फ़ंक्शन के भीतर उजागर, जिससे इसे दिखाना आसान हो):

def run_switch(value):
    with Switch(value) as case:
        if case(1):
            return 'one'
        if case(2):
            return 'two'
        if case(3):
            return 'the answer to the question about life, the universe and everything'
        # default
        raise Exception('Not a case!')

तो निष्पादन होगा:

>>> run_switch(1)
one
>>> run_switch(2)
two
>>> run_switch(3)
…
Exception: Not a case!
>>> run_switch(42)
the answer to the question about life, the universe and everything

नोटा नेने :

• इस समाधान को pypi पर उपलब्ध स्विच मॉड्यूल के रूप में पेश किया जा रहा है।