问题
So, I have a series of actions to perform, based on 4 conditional variables - lets say x,y,z & t. Each of these variables have a possible True or False value. So, that is a total of 16 possible permutations. And I need to perform a different action for each permutation.
What is the best way to do this rather than making a huge if-else construct.
Lets see a simplified example. This is how my code would look if I try to contain all the different permutations into a large if-else construct.
if (x == True):
if (y == True):
if (z == True):
if (t == True):
print ("Case 1")
else:
print ("Case 2")
else:
if (t == True):
print ("Case 3")
else:
print ("Case 4")
else:
if (z == True):
if (t == True):
print ("Case 5")
else:
print ("Case 6")
else:
if (t == True):
print ("Case 7")
else:
print ("Case 8")
else:
if (y == True):
if (z == True):
if (t == True):
print ("Case 9")
else:
print ("Case 10")
else:
if (t == True):
print ("Case 11")
else:
print ("Case 12")
else:
if (z == True):
if (t == True):
print ("Case 13")
else:
print ("Case 14")
else:
if (t == True):
print ("Case 15")
else:
print ("Case 16")
Is there any way to simplify this? Obviously, my objective for each case is more complicated than just printing "Case 1".
回答1:
You can use a map of cases to results:
cases = { (True, True, True, True): "Case 1",
(True, True, True, False): "Case 2",
(True, True, False, True): "Case 3",
(True, True, False, False):"Case 4",
(True, False, True, True): "Case 5",
(True, False, True, False):"Case 6",
(True, False, False, True): "Case 7",
(True, False, False, False):"Case 8",
(False, True, True, True): "Case 9",
(False, True, True, False):"Case 10",
(False, True, False, True): "Case 11",
(False, True, False, False):"Case 12",
(False, False, True, True): "Case 13",
(False, False, True, False):"Case 14",
(False, False, False, True): "Case 15",
(False, False, False, False):"Case 16"}
print(cases[(x,y,z,t])
If you want to do something else/different for each case, you could add a function to that map.
cases = { (True, True, True, True): foo_func,
(True, True, True, False): bar_func,
...}
result = cases[(x,y,x,t)](*args)
You can also use one of the masking solutions to make the code shorter, or if you have too many cases to write out, but for smaller sets of cases, this explicit representation will be clearer and easier to maintain.
回答2:
you could get your case number directly from binary manipulation of your booleans:
case = (x^1) << 3 | (y^1) << 2 | (z^1) << 1 | (t^1) + 1
print(f'Case {case}')
if you look at John Kugelman's answer you see that x, y, z, t are just the 'bits' of your case number (where True=0 and False=1)... so i construct an int setting those bits (and then add 1 because you start counting at 1).
if the numbering is arbitrary you can simplify that down to x << 3 | y << 2 | z << 1 | t and take it from there.
this is easily extensible to a larger number of boolean variables.
then to do something based on the case number i suggest you create a dictionary containing the case as key and the function or data or whatever as value. something like:
case_functions = {1: func_1, 2: func_2, ...}
res = case_functions(case)(some argument)
回答3:
You could shove all the values into a tuple and use 16 tuple comparisons.
if (x, y, z, t) == (True, True, True, True): print("Case 1")
elif (x, y, z, t) == (True, True, True, False): print("Case 2")
elif (x, y, z, t) == (True, True, False, True): print("Case 3")
elif (x, y, z, t) == (True, True, False, False): print("Case 4")
elif (x, y, z, t) == (True, False, True, True): print("Case 5")
elif (x, y, z, t) == (True, False, True, False): print("Case 6")
elif (x, y, z, t) == (True, False, False, True): print("Case 7")
elif (x, y, z, t) == (True, False, False, False): print("Case 8")
elif (x, y, z, t) == (False, True, True, True): print("Case 9")
elif (x, y, z, t) == (False, True, True, False): print("Case 10")
elif (x, y, z, t) == (False, True, False, True): print("Case 11")
elif (x, y, z, t) == (False, True, False, False): print("Case 12")
elif (x, y, z, t) == (False, False, True, True): print("Case 13")
elif (x, y, z, t) == (False, False, True, False): print("Case 14")
elif (x, y, z, t) == (False, False, False, True): print("Case 15")
elif (x, y, z, t) == (False, False, False, False): print("Case 16")
This could be converted into a dict lookup or use clever binary packing tricks, but the advantages here are (a) it's straightforward and readable; (b) there's no need for lambdas or functions; and (c) you can put anything into the 16 cases.
回答4:
This is a flexible solution that offers scalability and a certain level of simplicity.
Firstly, you'll need to create the methods that will run per output. These are the "complicated" versions of your print("case X") statements
#Define your method outcomes here...
#Note that this follows a binary layout starting with
# a + b + c + d = false
def action1(): #binary 0 (a'b'c'd')
print("case 1")
def action2(): #binary 1 (a'b'c'd)
print("case 2")
def action3(): #binary 2 (a'b'cd')
print("case 3")
def action4(): #binary 3 (a'b'cd)
print("case 4")
def action5(): #binary 4 (a'bc'd')
print("case 5") #etc...
def action6():
print("case 6")
def action7():
print("case 7")
def action8():
print("case 8")
def action9():
print("case 9")
def action10():
print("case 10")
def action11():
print("case 11")
def action12():
print("case 12")
def action13():
print("case 13")
def action14():
print("case 14")
def action15():
print("case 15")
def action16():
print("case 16")
def actionDefault():
print("Error!")
Then, you can easily reference these specific action methods later by creating a method name list and then creating a method to reference the method list when called.
import itertools #Generates all permutations
import sys #Allows us to get the current module
#Returns the index of the actionList we should execute
def evaluateActionIndex(varList):
allcombinations = itertools.product([False, True], repeat=len(varList))
i = 0
for subset in allcombinations: #for each of the possible combinations...
if list(subset) == varList: #Check to see if we want to execute this index.
return i
i = i + 1 #Increment the target index
return -1 #Execute default method (-1 index)
def performAction(index):
actionList = [action1.__name__, action2.__name__, action3.__name__, action4.__name__,
action5.__name__, action6.__name__, action7.__name__, action8.__name__,
action9.__name__, action10.__name__, action11.__name__, action12.__name__,
action13.__name__, action14.__name__, action15.__name__, action16.__name__,
actionDefault.__name__]
method = getattr(sys.modules[__name__], actionList[index]) #Get method by name
method() #Execute Method
We can perform some action by using:
#Mock up some control inputs
a = False
b = True
c = False
d = False
controlVariables = [a, b, c, d] #All Your Control Variables
#Execute control sequence
performAction(evaluateActionIndex(controlVariables))
I've tested this and it works effectively. You can add as many control variables as you need to the controlVariables list.
回答5:
That's genious. Bits! Very clean.
I was searching for a solution to this for a long time.
Here's a javascript version:
//assuming you have your variables in an array
let q = evaluatedQuery = ["wd:Q82955", "wd:Q212238", "", "wd:Q116"]
//lenght of the binary string
let possibleCases = evaluatedQuery.length
let binaryCase = ""
for (let i = 0; i < possibleCases; i++) {
// this "!!" makes a value truthy or falsy,
// and converts that to an integer "!!q[i] ^ 0"
binaryCase = `${binaryCase}${!!q[i] ^ 0}`
}
//this finds out which of (q*q = 16) cases its gonna be
let parsedBinaryCase = parseInt(binaryCase, 2) + 1
//this converts it to an array for easy handling
let binaryCaseArr = binaryCase.split("")
//this filers out falsy values by taking falsy values index
let boundQueryElements = evaluatedQuery.filter((el, i) => {
return !binaryCaseArr[i] != !!el ^ 0
})
console.log(binaryCase) //output: 1101
console.log(parsedBinaryCase) //output: 14
console.log(boundQueryElements) //output: ['wd:Q82955','wd:Q212238','wd:Q116']
//and this is a clean way to handle those 16 cases
//in this example it would go to case 14
switch (parsedBinaryCase) {
case 1:
break
case 2:
break
case 3:
break
case 4:
break
case 5:
break
case 6:
break
case 7:
break
case 8:
break
case 9:
break
case 10:
break
case 11:
break
case 12:
break
case 13:
break
case 14:
// for (let el in boundQueryElements) {
// }
break
case 15:
break
case 16:
break
default:
}
It, like, 'flattens' the tree structure.
回答6:
Just use the binary-ness of True and False values:
x = True
y = True
z = True
t = True
total = bin(x + 2 * y + 4 * z + 8 * t)
print(total)
print(int(total, 2))
Outputs:
0b1111
15
Whereas
x = False
y = True
z = False
t = True
total = bin(x + 2 * y + 4 * z + 8 * t)
print(total)
print(int(total, 2))
Yields:
0b1010
10
Now you can easily use the int(total, 2) value to determine which case you are dealing with
So you could convert your code to a single level of indents:
case = int(total, 2)
if case == 0:
print('case 0')
elif case == 1:
print('case 1')
elif case == 2:
print('case 2')
...
回答7:
When there are this many cases I usually prefer writing helper functions that make the code easier to maintain, e.g.:
def compare(xyzt, binaryval):
boolval = tuple(digit == '1' for digit in binaryval)
return all(a == b for a, b in zip(xyzt, boolval))
then your if statement can be written as:
xyzt = (x, y, z, t)
if compare(xyzt, '1111'): ...
elif compare(xyzt, '1110'): ...
elif compare(xyzt, '1100'): ...
etc.
which makes it much easier to verify that you've considered all the cases.
回答8:
I think this is a nice place for a registry of handlers. This won't give you the shortest code, but I think it gives you code that is easier to read and more maintainable, which is one interpretation of "simpler". I'd do something like this:
registry.py
handlers = dict()
def register(x, y, z, t):
if (x, y, z, t) in handlers:
raise ValueError("Handler already registered for {}/{}/{}/{}".format(
x, y, z, t))
def insert(f):
handlers[(x, y, z, t)] = f
return insert
def handle(x, y, z, t):
if (x, y, z, t) not in handlers:
raise KeyError("No handler registered for {}/{}/{}/{}".format(
x, y, z, t))
return handlers[(x, y, z, t)]()
handlers.py
from delegation import register, handle
@register(x=True, y=True, z=False, t=True)
def some_descriptive_name():
print("hi!")
@register(x=True, y=False, z=True, t=False)
def another_good_name():
print("Yes hello.")
# etc.
main.py
from handlers import handle
x, y, z, t = True, False, False, True
handle(x, y, z, t)
This lets you see exactly the conditions under which each handler will be activated. Separating your handlers into their own functions makes for cleaner testing as well. I've added a check to make sure you're not trying to handle the same conditions more than once and an error message for if a set of conditions isn't handled. It'd be easy to add a check to make sure that all cases are handled, too.
If your actions need to make use of variables (besides the four conditionals) you can do that as well; just change the signature and return value of handle like so:
def handle(x, y, z, t, *args, **kwargs):
...
return handlers[(x, y, z, t)](*args, **kwargs)
and, of course, add arguments to the handlers.
回答9:
Extending on @Reedinationer's answer:
# your functions
def f0(): print('case 1')
def f1(): print('case 2')
def f2(): print('case 3')
#.
#.
def f15(): print('case 16')
list_of_functions = [f0, f1, f2] # assuming there are 16 functions in total
x = False
y = False
z = False
t = False
total = bin(x + 2 * y + 4 * z + 8 * t)
index = int(total, 2)
list_of_functions[index]() # will print('case 1')
Tested on python 2.7 and 3.7
来源：https://stackoverflow.com/questions/55422804/best-way-to-combine-a-permutation-of-conditional-statements