对于循环，如何在循环外使用循环变量

Question

LR = int(raw_input()) 
RPL = []
c1 = []
c2 = []
L1a = [8, 9, 14, 13, 12]
L2a =[9, 12, 14, 10, 8]
OM = [9, 10]
L3a = [26]
L1b = [27, 32, 26]
L2b = [30, 27, 32, 28, 31]
L3b = [31, 30, 26]

def I():
    for i in L1b:
        for j in L2b:
            for k in L3b:
                n = i * j * k
                c1.append(n)
    for i in OM:
        for j in L1a:
            for k in L2a:
                n = i * j * k
                c2.append(n)
def II():
    for i in c1:
        for j in c2:
            x = (i / j) * LR
            RPL.append(x)

In my program I need for loop variables i,j,k from 'I' function to print them in my 'II' function to show what combination was used to create x. I tried with two dimensional arrays but it didnt work well. So is there any easy option to work this out?

Answer 1

The following script I think does what you are trying to do:

import operator, itertools

LR = int(raw_input())

L1a = [8, 9, 14, 13, 12]
L2a = [9, 12, 14, 10, 8]
L3a = [26]
L1b = [27, 32, 26]
L2b = [30, 27, 32, 28, 31]
L3b = [31, 30, 26]
OM = [9, 10]

c1 = [(reduce(operator.mul, p), p) for p in itertools.product(L1b, L2b, L3b)]
c2 = [(reduce(operator.mul, p), p) for p in itertools.product(OM, L1a, L2a)]

RPL = [(((p[0][0]) / p[1][0]) * LR, p[0][1], p[1][1])  for p in itertools.product(c1, c2)]

print RPL

This displays the following type of results of an LR of 10 :

[(380, (27, 30, 31), (9, 8, 9)), (290, (27, 30, 31), (9, 8, 12)), (240, (27, 30, 31), (9, 8, 14)), ... etc

Each permutation is stored as a tuple with the result of the multiplication. This is then used when calculating your RPL value.

You could also format RPL as follows, to show which permutations made each result:

for rpl, p1, p2 in RPL:
    print "%8d  %15s  %15s" % (rpl, str(p1), str(p2))

Giving output in the form:

 380     (27, 30, 31)        (9, 8, 9)
 290     (27, 30, 31)       (9, 8, 12)
 240     (27, 30, 31)       (9, 8, 14)
 340     (27, 30, 31)       (9, 8, 10)
 430     (27, 30, 31)        (9, 8, 8)
 340     (27, 30, 31)        (9, 9, 9)

The script uses the Python itertools module. This provides a product function which has the same effect of having multiple nested for loops. The result of each iteration gives your values for i , j and k , but as a tuple, eg (27, 30, 31) .

The reduce command can be used to multiply all of the numbers in the list that was returned, by applying the same function to each entry. As you can't write reduce( * , p) , you can use Python's operator module to provide a function name version for * , ie operator.mul .

The result of this gets wrapped in () to make a tuple with two parts, the first is the result of the multiplications and the second part is the permutation that produced it. eg (25110, (27, 30, 31)) .

c1 is a list holding all of these value. This is called a list comprehension. It is equivalent to a for loop with c1.append() inside.

Once c1 and c2 have been created (I suggest you try and print their values to see what they look like), the script then uses a similar method to calculate all of the RPL values. Each iteration gives p which would look like:

((25110, (27, 30, 31)), (648, (9, 8, 9)))

This is a tuple with two entries (25110, (27, 30, 31)) and (648, (9, 8, 9)) . Python can access each value using indexes. So to get the 25110 you would use p[0][0] for the first tuple, first part. Or p[0][1] to get (27, 30, 31) .

The solution script could be converted to not use list comprehensions as follows:

c1 = []

for p in itertools.product(L1b, L2b, L3b):
    multiply_all = reduce(operator.mul, p)
    c1.append((multiply_all, p))

c2 = []

for p in itertools.product(OM, L1a, L2a):
    multiply_all = reduce(operator.mul, p)
    c2.append((multiply_all, p))

RPL = []

for p in itertools.product(c1, c2):
    calculation = (p[0][0] / p[1][0]) * LR
    RPL.append((calculation, p[0][1], p[1][1]))

Answer 2

If you want i, j and k, store them instead of their product. Instead of c1.append(n) , use c1.append((i, j, k)) .

Then, in II would look like this:

for (i1, j1, k1) in c1:
    for (i2, j2, k2) in c2:
        i = i1 * j1 * k1
        j = i2 * j2 * k2

        x = (i / j) * LR
        RPL.append(x)

A thing you should consider is that you can return two lists from I instead of having two global lists. Global variables that are modified are usually a Bad Thing.

Answer 3

You can't use loop variables outside the loop. Never. Even if language allows that - it is totally confusing and a sign of a bad code structure.

Regarding your question - there are a number of ways to do that. The least involving would be to use a tuple instead of a number in last iteration of I (do you have a better names for them?).

def I():
    # snip
    n = i * j * k
    c2.append((i, j, k, n))  # double braces is important

def II():
    # snip
    for c1_loop_var in c1:  # note loop variable name changed
        for i, j, k, n in c2:
            x = (c1_loop_var / n) * LR
            # and whatever you need to do with i,j,k

As a side note, the snippet you provided does not contain a single variable with a good name, so it's totally not clear to anyone. If you're going to be the only user of this code - up to you, but I would try giving them more sensible names - it's a good practice anyway.