python循环套,避免嵌套for循环python

I have a function which takes in expressions and replaces the variables with all the permutations of the values that I am using as inputs. This is my code that I have tested and works, however after looking through SO, people have said that nested for loops are a bad idea however I am unsure as to how to make this more efficient. Could somebody help? Thanks.

def replaceVar(expression):

eval_list = list()

a = [1, 8, 12, 13]

b = [1, 2, 3, 4]

c = [5, 9, 2, 7]

for i in expression:

first_eval = [i.replace("a", str(j)) for j in a]

tmp = list()

for k in first_eval:

snd_eval = [k.replace("b", str(l)) for l in b]

tmp2 = list()

for m in snd_eval:

trd_eval = [m.replace("c", str(n)) for n in c]

tmp2.append(trd_eval)

tmp.append(tmp2)

eval_list.append(tmp)

print(eval_list)

return eval_list

print(replaceVar(['b-16+(c-(a+11))', 'a-(c-5)+a-b-10']))

解决方案

Foreword

Nested loops are not a bad thing per se. They are only bad, if there are used for problems, for which better algorithm have been found (better and bad in terms of efficiency regarding the input size). Sorting of a list of integers for example is such a problem.

Analyzing the Problem

The size

In your case above you have three lists, all of size 4. This makes 4 * 4 * 4 = 64 possible combinations of them, if a comes always before b and b before c. So you need at least 64 iterations!

Your approach

In your approach we have 4 iterations for each possible value of a, 4 iterations for each possible value of b and the same for c. So we have 4 * 4 * 4 = 64 iterations in total. So in fact your solution is quite good!

As there is no faster way of listening all combinations, your way is also the best one.

The style

Regarding the style one can say that you can improve your code by better variable names and combining some of the for loops. E.g. like that:

def replaceVar(expressions):

"""

Takes a list of expressions and returns a list of expressions with

evaluated variables.

"""

evaluatedExpressions = list()

valuesOfA = [1, 8, 12, 13]

valuesOfB = [1, 2, 3, 4]

valuesOfC = [5, 9, 2, 7]

for expression in expressions:

for valueOfA in valuesOfA:

for valueOfB in valuesOfB:

for valueOfC in valuesOfC:

newExpression = expression.\

replace('a', str(valueOfA)).\

replace('b', str(valueOfB)).\

replace('c', str(valueOfC))

evaluatedExpressions.append(newExpression)

print(evaluatedExpressions)

return evaluatedExpressions

print(replaceVar(['b-16+(c-(a+11))', 'a-(c-5)+a-b-10']))

Notice however that the amount of iterations remain the same!

Itertools

As Kevin noticed, you could also use itertools to generate the cartesian product. Internally it will do the same as what you did with the combined for loops:

import itertools

def replaceVar(expressions):

"""

Takes a list of expressions and returns a list of expressions with

evaluated variables.

"""

evaluatedExpressions = list()

valuesOfA = [1, 8, 12, 13]

valuesOfB = [1, 2, 3, 4]

valuesOfC = [5, 9, 2, 7]

for expression in expressions:

for values in itertools.product(valuesOfA, valuesOfB, valuesOfC):

valueOfA = values[0]

valueOfB = values[1]

valueOfC = values[2]

newExpression = expression.\

replace('a', str(valueOfA)).\

replace('b', str(valueOfB)).\

replace('c', str(valueOfC))

evaluatedExpressions.append(newExpression)

print(evaluatedExpressions)

return evaluatedExpressions

print(replaceVar(['b-16+(c-(a+11))', 'a-(c-5)+a-b-10']))