[split] Creating a variable as a function

[DPaul]

For the "select...case" enthousiasts we have now 1 direct solution
and 2 workarounds, that should satisfy 90% of the needs.
Of course if you need a mix of the 3 , you'll need to be creative.

Great help, appreciate it,
Paul

[buran]

note that these are jut sample implementations, e.g. in certain cases bisect module can be useful and allow for different implementation, see Other examples section.

[jefsummers]

You can create an array of functions and call the selected one based on a calculation, but if you are looking at 50 different functions to select from I would suspect there is a better approach.

[ndc85430]

Also, if you want to dispatch to a function based on type of argument, there's singledispatch in the functools module: https://docs.python.org/3/library/functo...ledispatch

[DPaul]

After having tested the proposed solutions, i have to curb my
"90%" enthousiasm a little.

All solutions work if you provide an argument that has been "foreseen",
like in a menu system.

But all select...case constructs end with the "case else.." , the alternative for the non-explicitely mentioned values.
I don't see any other solution then a try...except clause, with the risk of not being able to differentiate
between a genuine "bug" or an unexpected value.

All this puzzels me, and there must be some site when you can recommend "improvements" to python.
I'm interested in the historical records, to see if some form of select case has been proposed, and why it's absent.
Maybe it's in the "pipeline" :-)
Paul

---

"PEP" is what i was looking for, but i did not get any wiser.
Anyway:

There seems to be a solution for the "switch case" or "select case" construction that provides a
"case else" or a "default:
https://data-flair.training/blogs/python-switch-case/

Does not take away that you always find "partial" solutions, and not a generic python solution,
so you can mix single, multiple and range arguments;

I immediately add that single and multiple arguments, such as posts #3 and #8 are possible
because you can use #8 with just 1 value in the tuple. Looks a bit strange, but it works.

Paul

[bowlofred]

It is in fact in the pipeline for consideration. The currently open version is PEP 622.

Rejected proposals from the past include PEP 3103 and PEP 275.

[DPaul]

It is in fact in the pipeline for consideration. The currently open version is PEP 622.

Rejected proposals from the past include PEP 3103 and PEP 275.

Thanks for the info!

Wow, just a few weeks ago !

Output:
This general idea has been floating around for a pretty long time, and many back and forth decisions were made.

Looks like a lot of work !
I keep thinking of my signature buddy, "Better is the enemy of good".

Paul

[snippsat]

One more,just using some pre-made code for a rage dict.
Then use it in a way i like do switch case stuff in Python,so i think a reasonable clean and readable solution.

from range_key_dict import RangeKeyDict

def low():
    return 'Low range'

def med():
    return 'Medium range'

def high():
    return 'High range'

def switch_case(number):
    r_dict =  RangeKeyDict({
        (0, 332): low(),
        (333, 665): med(),
        (666, 1000): high(),
    })
    return r_dict.get(number, f'<{number}> Not in any range')

number = int(input("Enter a number between 1 and 1000: "))
print(switch_case(number))

Output:
Enter a number between 1 and 1000: 50
Low range

Enter a number between 1 and 1000: 700
High range

Enter a number between 1 and 1000: 5000
<5000> Not in any range

[DPaul]

With thanks to all the contributers, i made an overview of
some alternatives for a switch or select case construction.
This includes the "case else" or "default" option.
Note that alt 1 is in fact a simple case of alt 2.
Note that alternative 3 requires a pip install.

#the functions
def AAA():
    return 'AAA'

def BBB():
    return 'BBB'

def ELSE():
    return 'UNKNOWN'
# ---------------------------
#(1)single key dict with default
def switcher1(k):
    myDict = {100:AAA(),200:BBB()}
    return myDict.get(k, ELSE())

print(switcher1(200))
print(switcher1(502))
# -----------------------------
#(2)tuple with (optional) multiple keys and default
def switcher2(k):   
    myDict2 = {('a'):AAA(), ('x', 'y', 'z'):BBB()}
    myDict2 = {key:value for item, value in myDict2.items() for key in item}
    return myDict2.get(k, ELSE())

print(switcher2('z'))
print(switcher2('M'))
# --------------------------------
#(3) range dict with default
from range_key_dict import RangeKeyDict
 
def switcher3(k):
    myDict3 =  RangeKeyDict({(0,100): AAA(),(101,200): BBB()})
    return myDict3.get(k, ELSE())

print(switcher3(152))
print(switcher3(5210))

Can somebody write to PEP622 that they can save the time & effort.

Paul

[buran]

I am afraid you don't understand the concept completly.
you must not execute all functions, when adding them to dict. note the difference between adding function as value in dict and adding the return value of the function. same for the default value/function
you want to return a function, not the result of it (which may well be None). @snippsat example may be misleading in that respect