Python Language
Alternatieven om instructie van andere talen te schakelen

Opmerkingen

Gebruik wat de taal biedt: de if / else-constructie.

Nou, als je een switch / case constructie wilt, is de meest eenvoudige manier om te gaan de goede oude if / else constructie gebruiken:

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

het ziet er misschien overbodig uit en is niet altijd mooi, maar dat is verreweg de meest efficiënte manier om te gaan en het doet zijn werk:

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

Gebruik een dict van functies

Een andere eenvoudige manier om te gaan is om een woordenboek met functies te maken:

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

dan voeg je een standaardfunctie toe:

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

en u gebruikt de methode get van het woordenboek om de functie te krijgen die de waarde heeft om te controleren en uit te voeren. Als waarde niet bestaat in woordenboek, wordt default_case uitgevoerd.

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

je kunt ook wat syntactische suiker maken, zodat de schakelaar er mooier uitziet:

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

>>> run_switch(1)
one

Gebruik klasse-introspectie

U kunt een klasse gebruiken om de structuur van de schakelaar / behuizing na te bootsen. Het volgende gebruikt introspectie van een klasse (met behulp van de functie getattr() waarmee een string wordt omgezet in een gebonden methode voor een instantie) om het gedeelte "case" op te lossen.

Vervolgens wordt die introspectiemethode gebruikt voor de methode __call__ om de operator () te overbelasten.

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

    __call__ = switch

Om het er mooier uit te laten zien, subclasseren we de SwitchBase klasse (maar het kan in één klasse worden gedaan), en daar definiëren we alle case als methoden:

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

dus dan kunnen we het eindelijk gebruiken:

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

Een contextmanager gebruiken

Een andere manier, die zeer leesbaar en elegant is, maar veel minder efficiënt dan een if / else-structuur, is om een klasse als volgt te bouwen, die de waarde om mee te vergelijken zal lezen en opslaan, zich binnen de context blootlegt als een afroepbare die retourneert true als deze overeenkomt met de opgeslagen waarde:

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

dan is het definiëren van de cases bijna een match met de echte switch / case constructie (belicht binnen een functie hieronder, om het gemakkelijker te maken om te pronken):

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

Dus de uitvoering zou zijn:

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

Nota Bene :

• Deze oplossing wordt aangeboden als de schakelmodule die beschikbaar is op pypi .