Optimize code and avoiding if statements in python

Question

I have a code with several if statements that check some variables combination ranges. My code is the following:

cnt1, cnt2, cnt3, cnt4, cnt5, cnt6, cnt7, cnt8, cnt9, \
 cnt10, cnt11, cnt12 = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
var1_1, var1_2, var1_3 var2_1, var2_2, var2_3, var3_1, var3_2, var3_3, var4_1, var4_2, var4_3, \
var5_1, var5_3, var5_3, var6_1, var6_2, var6_3, var7_1, var7_2, var7_3, var8_1, var8_2, var8_3 \
var9_1, var9_2, var9_3, var10_1, var10_2, var10_3, var11_1, var11_2, var11_3, var12_1, var12_2, \
var12_3 = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
if case == 1:
 cnt1 = cnt1 + 1
 if common_edge < 0.33:
 var1_1 = var1_1 + common_var
 elif 0.33<= common_edge < 0.66:
 var1_2 = var1_2 + common_var
 elif common_edge>= 0.66:
 var1_3 = var1_3 + common_var
elif case == 2:
 cnt2 = cnt2 + 1
 if common_edge < 0.33:
 var2_1 = var2_1 + common_var
 elif 0.33<= common_edge < 0.66:
 var2_2 = var2_2 + common_var
 elif common_edge>= 0.66:
 var2_3 = var2_3 + common_var
elif case == 3:
 cnt3 = cnt3 + 1
 if common_edge < 0.33:
 var3_1 = var3_1 + common_var
 elif 0.33<= common_edge < 0.66:
 var3_2 = var3_2 + common_var
 elif common_edge>= 0.66:
 var3_3 = var3_3 + common_var
elif case == 4:
 cnt4 = cnt4 + 1
 if common_edge < 0.33:
 var4_1 = var4_1 + common_var
 elif 0.33<= common_edge < 0.66:
 var4_2 = var4_2 + common_var
 elif common_edge>= 0.66:
 var4_3 = var4_3 + common_var
elif case == 5:
 cnt5 = cnt5 + 1
 if common_edge < 0.33:
 var5_1 = var5_1 + common_var
 elif 0.33<= common_edge < 0.66:
 var5_2 = var5_2 + common_var
 elif common_edge>= 0.66:
 var5_3 = var5_3 + common_var
elif case == 6:
 cnt6 = cnt6 + 1
 if common_edge < 0.33:
 var6_1 = var6_1 + common_var
 elif 0.33<= common_edge < 0.66:
 var6_2 = var6_2 + common_var
 elif common_edge>= 0.66:
 var6_3 = var6_3 + common_var
elif case == 7:
 cnt7 = cnt7 + 1
 if common_edge < 0.33:
 var7_1 = var7_1 + common_var
 elif 0.33<= common_edge < 0.66:
 var7_2 = var7_2 + common_var
 elif common_edge>= 0.66:
 var7_3 = var7_3 + common_var
elif case == 8:
 cnt8 = cnt8 + 1
 if common_edge < 0.33:
 var8_1 = var8_1 + common_var
 elif 0.33<= common_edge < 0.66:
 var8_2 = var8_2 + common_var
 elif common_edge>= 0.66:
 var8_3 = var8_3 + common_var
elif case == 9:
 cnt9 = cnt9 + 1
 if common_edge < 0.33:
 var9_1 = var9_1 + common_var
 elif 0.33<= common_edge < 0.66:
 var9_2 = var9_2 + common_var
 elif common_edge>= 0.66:
 var9_3 = var9_3 + common_var
elif case == 10:
 cnt10 = cnt10 + 1
 if common_edge < 0.33:
 var10_1 = var10_1 + common_var
 elif 0.33<= common_edge < 0.66:
 var10_2 = var10_2 + common_var
 elif common_edge>= 0.66:
 var10_3 = var10_3 + common_var
elif case == 11:
 cnt11 = cnt11 + 1
 if common_edge < 0.33:
 var11_1 = var1_11 + common_var
 elif 0.33<= common_edge < 0.66:
 var11_2 = var11_2 + common_var
 elif common_edge>= 0.66:
 var11_3 = var11_3 + common_var
elif case == 12:
 cnt12 = cnt12 + 1
 if common_edge < 0.33:
 var12_1 = var12_1 + common_var
 elif 0.33<= common_edge < 0.66:
 var12_2 = var12_2 + common_var
 elif common_edge>= 0.66:
 var12_3 = var12_3 + common_var

How can I optimize that code and do not use so many if statements. Is there a smooth way to avoid the if-else?

• Jongware: If your code works without any errors, a better place to ask would be Code Review.
• jpp: In its current form, this post isn't great anywhere. What I suggest is you create a function with all your logic and benchmark it via timeit. Then provide the constraints of your problem, e.g. can you use NumPy?
• John Coleman: Why cnt1, cnt2 etc. rather than a single variable cnt for the tuple (with similar remarks for your other variables)? There is seldom a good reason to explicitly name each entry in a data structure.
• Jose Ramon: @jpp yes I can use numpy.

Answer 1

cnt = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
var = [
 [0, 0, 0], 
 [0, 0, 0],
 [0, 0, 0],
 [0, 0, 0],
 [0, 0, 0],
 [0, 0, 0],
 [0, 0, 0],
 [0, 0, 0],
 [0, 0, 0],
 [0, 0, 0],
 [0, 0, 0],
 [0, 0, 0],
 [0, 0, 0],
]
element = case - 1
cnt[element] = cnt[element] + 1
if common_edge < 0.33:
 var[element][0] = var[element][0] + common_var
elif 0.33 <= common_edge < 0.66:
 var[element][1] = var[element][1] + common_var
elif common_edge >= 0.66:
 var[element][2] = var[element][2] + common_var

• Konrad Rudolph: You can further simplify this by changing the definitions to cnt = [0] * 12 and var = [[0, 0, 0]] * 12 (this also fixes a counting bug in your code).
• Sergey Pugach: @KonradRudolph No. In your solution all 13 lists will be linked to one list object and when any is changed all 12 will change too.
• Konrad Rudolph: Good point. You can get around this by copying the items: var = list(map(list, [[0, 0, 0]] * 12)).
• Jose Ramon: I think with that solution i am changing all the var array in the same way. I add debugger after one step and I figure out that all 12 sub arrays of var where the same.
• Konrad Rudolph: @JoseRamon Read the subsequent comments.

Answer 2

You can try it:

cnt = {item: 0 for item in range(12)}
var = {item: [0, 0, 0] for item in range(12)}
def you_function(case, cnt, common_edge, var, common_var):
 cnt[case] += 1
 if common_edge < 0.333:
 var[case][0] += common_var
 elif 0.33 <= common_edge < 0.66:
 var[case][1] += common_var
 elif common_edge >= 0.66:
 var[case][2] += common_var
 return cnt, var

• Konrad Rudolph: Why are you using dicts instead of lists?
• Ihor Voronin: Because: Lookups in lists are O(n), lookups in dictionaries are amortized O(1), with regard to the number of items in the data structure. If you don't need to associate values, use sets. And I think in this task author work with often work with this data so dict can be applied here.
• Konrad Rudolph: No, that’s incorrect. Index lookup in Python lists is O(1) (not amortised, always), and with a much smaller constant factor than in dicts.