Python (3.4) List comprehensions - How do you control the flow of execution

Question

This is an example that mirrors the code I am currently working on:

def find_match():

    num=[[2, 3, 5, 7, 8, 10, 12], [12, 1, 3, 5, 6, 8, 10], [11, 12, 2, 4, 5, 7, 9]]
    name= ['Type One','Type Two','Type Three']

    match = [[[name[ri], name[ci][5:], list(sorted(set (rv) & set(cv)))]
    for ci,cv in enumerate (num) if rv != cv] for ri,rv in enumerate(num)]

    return match

>>> match=find_match()
[[[3, 5, 8, 10, 12], [2, 5, 7, 12]], [[3, 5, 8, 10, 12], [5, 12]], [[2, 5, 7, 12], [5, 12]]]

Once again, this just serves as an example, so I am aware that the function is in no way generalizable, the actual function takes one nested lists as it's arg, which is in turn created via another function.

This locates matches between each sub-list compared to all the other sub-lists

What I wish to do now do is to append a name for each match within the new list of matching pairs, here's my desired output

[['Type One', ['Two', [3, 5, 8, 10, 12]], ['Three', [2, 5, 7, 12]]], ['Type Two', ['One', [3, 5,   
8, 10, 12]], ['Three', [5, 12]]], ['Type Three', ['One', [2, 5, 7, 12]], ['Two', [5, 12]]]]

You see, producing the string name, such as 'One', and printing the pattern, would happen on the same line of execution within a nested for loop, where the title for a cohort of matches, such as 'Type One' would be executed within the outer loop.

This is my desired output using nested for loops:

matches=[]
match=[]

for ri,rv in enumerate(num):
    match.append(name[ri])
    for ci,cv in enumerate(num):
        if rv!= cv:
            match.append([name[ci][5:],sorted((list(set(cv) & set (rv))))])

     matches.append(match)
     match=[]

return matches

This allows me to access a section of the list via the index, such as:

>>> match=find_match()
>>> match[0]
['Type One', ['Two', [3, 5, 8, 10, 12]], 'Type One', ['Three', [2, 5, 7, 12]]]
>>> match[0][0]
'Type One'
>>> match[0][1]
['Two', [3, 5, 8, 10, 12]]
>>> match[0][2]
'Type One'

With a LC, it only returns a list of values, but in such a way that it behaves like a nested for loop where all the statements are executed within the final loop:

for ri,rv in enumerate(num):
    for ci,cv in enumerate(num):
        if rv!= cv:
            match.append(name[ri])
            match.append([name[ci][5:],sorted((list(set(cv) & set (rv))))]) 

This is the same as this LC:

match = [[[name[ri], name[ci][5:], list(sorted(set (rv) & set(cv)))]
for ci,cv in enumerate (num) if rv != cv] for ri,rv in enumerate(num)]

Both of these produce:

[[['Type One', 'Two', [3, 5, 8, 10, 12]], ['Type One', 'Three', [2, 5, 7, 12]]], [['Type Two',     
'One', [3, 5, 8, 10, 12]], ['Type Two', 'Three', [5, 12]]], [['Type Three', 'One', [2, 5, 7,    
12]], ['Type Three', 'Two', [5, 12]]]]

So, am wondering if there is a way to control the flow of execution within a LC, so that the statements are within their respective scopes, rather than executing all of the statements at once. If there is that would be incredible, it would make the creation of nested loops so easy, with much less code, and formatting it would be practically effortless.

Thanks for taking the time to read my question, any help would be very much appreciated

Answer 1

num = [[2, 3, 5, 7, 8, 10, 12], [12, 1, 3, 5, 6, 8, 10], [11, 12, 2, 4, 5, 7, 9]]
name = ['Type One','Type Two','Type Three']

[[name[ci]] 
 + [[name[ri][5:]] 
    + [sorted(set(cv) & set (rv))]   
    for ri,rv in enumerate(num) if rv!=cv] 
 for ci,cv in enumerate(num)]

yields

[['Type One', ['Two', [3, 5, 8, 10, 12]], ['Three', [2, 5, 7, 12]]],
 ['Type Two', ['One', [3, 5, 8, 10, 12]], ['Three', [5, 12]]],
 ['Type Three', ['One', [2, 5, 7, 12]], ['Two', [5, 12]]]]