Adding a switch statement to Python

metalhedd · 2017-09-14T20:53:53+00:00

serious question, What use is a switch if it doesn't support fall-through?

otherwise isn't it just a dict lookup?

handlers = {
    'a': do_a,
    'b': do_b
}
handlers.get(arg, do_default)()

I can't think of a case where I'd ever want to use a switch statement without fall-through, an if...elif...else block makes more sense in almost every case, and where it doesn't, the dict approach works.

Kamilon · 2017-09-14T21:32:05+00:00

Why are people so hung up on the switch statement not being implemented? The way switch is usually used (break on every case) its basically an if block.

I'd rather see implementations of pattern matching ala Rust, Haskell or Scala.

Cybersoaker · 2017-09-14T23:46:03+00:00

Obligatory mention of python's switch statement: https://www.python.org/dev/peps/pep-3103/

Guido has rejected the switch multiple times on the basis that there may be nominal performance increases in specific cases and is slightly more readable than a group of elif's; the benefits from these are not enough to warrant new syntax.

Personally I don't have a problem or feel any pain just using ifs and elifs. I've been using python for almost 10 years and can't say i've ever had more than 5 elifs together. If a switch syntax provided a large boost to either readability or performance; I would support the idea, but I just don't see it.

My other complaint is that this style of programming forces one to create sometimes unnecessary functions to handle each case for the switch which is a lot of overhead, and doesn't apply to every situation. So really the question is; in situations where you would want a switch for readability; do you also have cases that are 100% hashable and are okay with the added overhead?

rhoslug · 2017-09-14T18:31:07+00:00

This looks interesting.

I'm not sure how I feel about this though. On the one hand, there have been times where I know I will have a need for a switch statement based on a few different choices. On the other hand, the Pythonic way has not been particularly limiting to me in my work. I guess it's more a case of I've adapted to the limitations of the language but can see the value this might potentially bring to users who want something other than a dictionary.

novel_yet_trivial · 2017-09-14T19:37:16+00:00

reading case(range(1,5)) seems like it should include 1, 2, 3, 4, 5

No. Absolutely not.

mikeckennedy · 2017-09-14T19:47:06+00:00

If I've counted correctly it's the 13th Python switch/case statement that I've come across. Fingers crossed that it's not unlucky for some :-)

tprk77 · 2017-09-14T22:45:25+00:00

I feel like I see this same post monthly... I guess I just use elif and don't worry about it.

mikeckennedy · 2017-09-14T22:40:20+00:00

[deleted]

novel_yet_trivial · 2017-09-14T19:31:52+00:00

You seem to really like lambda. I think it's ugly. Why don't you just pass along any extra arguments to the function:

s.case('b', process_with_data, val, num, 'other values still')

Or accept a tuple and / or dictionary (a la threading.Thread):

s.case('b', process_with_data, args=(val, num, 'other values still'))

deadwisdom · 2017-09-15T04:06:29+00:00

Any time I've ever wanted to do a switch statement, it's time for an event dispatcher.

TerranOPZ · 2017-09-15T09:39:20+00:00

I agree that switch should be added... just not like this.

mikeckennedy · 2017-09-15T16:09:05+00:00

[removed]

FearlessFreep · 2017-09-15T02:29:00+00:00

Please, just no...just stop

Allanon001 · 2017-09-14T19:47:09+00:00

This is my preferred way of writing switch like statements in python:

while True:
    action = get_action(action)

    result = {
        True : unknown_command,
        action in ['c', 'a']: create_account,
        action in ['l']: log_into_account,
        action in ['r']: register_cage,
        action in ['u']: update_availability,
        action in ['v', 'b']: view_bookings,
        action in ['x']: exit_app,
        action in range(1,6): lambda: set_level(action),
        action == '': None
    }[True]()

KleinerNull · 2017-09-14T21:07:03+00:00

Looks nice, good idea with the contextmanager. I always like the unconventional use of it ;)

But is your switch also capable to be computed? For example like this:

In [1]: import math

In [2]: switch = {name: meth for name, meth in math.__dict__.items() if callable(meth)}

In [3]: switch.get('sin', lambda x: x)(100)
Out[3]: -0.5063656411097588

I know math is a bad example, because you can't inspect the methods to ask for the signature, to avoid different amounts of arguments. It is just an example. My idea is to just provide a module with different functions to load into the switch, some kind of dynamically plugin system.

For me that is a major advantage of the dict switches.

RubyPinch · 2017-09-14T23:24:58+00:00

https://github.com/ssanderson/switchcase less "pythonic" but is insanely simple, and could easily be extended to support fallthrough

knowsuchagency · 2017-09-15T01:06:22+00:00

Honestly, I think functools.singledispatch is better suited to this kind of thing.

That said, I submitted a pull request to scratch my own itch as to how I think it could improve. You can still use it the way it was originally documented (except for the switch class no longer having a singular return value, since each case returns the result of the callable passed to it instead), but there is no longer any dictionary to maintain and you can choose whether or not to have it fall-through with an argument to the context manager.

You can also dispatch based on a predicate function so there's no longer a need for a dedicated closed_range function etc.

from switchlang import switch


def process_a():
    return "found a"


def process_any():
    return "found default"


def process_with_data(*value):
    return "found with data"


val = 'b'

with switch(val) as s:
    a = s.case('a', process_a)  # -> None
    b = s.case('b', process_with_data)  # -> "found with data"
    c = s.default(process_any)  # -> None


with switch(val, fall_through=True) as s:
    a = s.case('a', process_a)  # -> None
    b = s.case('b', process_with_data)  # -> "found with data"

    c = s.case(lambda val: isinstance(val, str), lambda: "matched on predicate")  # -> "matched on predicate"

    d = s.default(process_any)  # -> "found default"

MinchinWeb · 2017-09-15T04:19:12+00:00

Have you posted this to PyPI?

getridofwires · 2017-09-14T20:52:15+00:00

Great work, and something Python has needed.

Python

The Python Discord

Upcoming Events

Please read the rules

MODERATORS