查找列表的笛卡尔积，根据条件过滤掉元素

Question

I recently came across this notation

a = [1,2,3,4]
b = [2,4,6]

c = [(x,y,z) for x in a for y in b for z in a]

First I don't know how to search for the notation in creating c , is there a name for this type of structure?

Also, I'm confident that c can be updated to not allow x to equal z . Please can you help me with this?

I've tried various things on the lines of

c = [(x,y,z) for x in a for y in b for z in a for x != z]

but so far I can't find anything that works, or is even valid syntax.

What I'm trying to accomplish is to find every combination of (a,b,a) where a can only be used once in each line so the result would be

[(1, 2, 2),
 (1, 2, 3),
 (1, 2, 4),
 (1, 4, 2),
 (1, 4, 3),
 (1, 4, 4),
 (1, 6, 2),
 (1, 6, 3),
 (1, 6, 4),
 (2, 2, 1),
 (2, 2, 3),
 (2, 2, 4),
 (2, 4, 1),
 (2, 4, 3),
 (2, 4, 4),
 (2, 6, 1),
 (2, 6, 3),
 (2, 6, 4),
 (3, 2, 1),
 (3, 2, 2),
 (3, 2, 4),
 (3, 4, 1),
 (3, 4, 2),
 (3, 4, 4),
 (3, 6, 1),
 (3, 6, 2),
 (3, 6, 4),
 (4, 2, 1),
 (4, 2, 2),
 (4, 2, 3),
 (4, 4, 1),
 (4, 4, 2),
 (4, 4, 3),
 (4, 6, 1),
 (4, 6, 2),
 (4, 6, 3)]

Thanks

Answer 1

It is known as list comprehension and you can use logical if within it to filter the results in the returned list as:

>>> a = [1,2,3,4]
>>> b = [2,4,6]
#     if condition to skip results where `x` equals `z` v
>>> c = [(x,y,z) for x in a for y in b for z in a if x != z]
>>> c   
[(1, 2, 2), (1, 2, 3), (1, 2, 4), (1, 4, 2), (1, 4, 3), (1, 4, 4), (1, 6, 2), (1, 6, 3), (1, 6, 4), (2, 2, 1), (2, 2, 3), (2, 2, 4), (2, 4, 1), (2, 4, 3), (2, 4, 4), (2, 6, 1), (2, 6, 3), (2, 6, 4), (3, 2, 1), (3, 2, 2), (3, 2, 4), (3, 4, 1), (3, 4, 2), (3, 4, 4), (3, 6, 1), (3, 6, 2), (3, 6, 4), (4, 2, 1), (4, 2, 2), (4, 2, 3), (4, 4, 1), (4, 4, 2), (4, 4, 3), (4, 6, 1), (4, 6, 2), (4, 6, 3)]

Instead of using nested list comprehension , you may get the same behavior using itertools.product as well:

>>> from itertools import product

>>> [(x,y,z) for x, y, z in product(a, b, a) if x !=z]
[(1, 2, 2), (1, 2, 3), (1, 2, 4), (1, 4, 2), (1, 4, 3), (1, 4, 4), (1, 6, 2), (1, 6, 3), (1, 6, 4), (2, 2, 1), (2, 2, 3), (2, 2, 4), (2, 4, 1), (2, 4, 3), (2, 4, 4), (2, 6, 1), (2, 6, 3), (2, 6, 4), (3, 2, 1), (3, 2, 2), (3, 2, 4), (3, 4, 1), (3, 4, 2), (3, 4, 4), (3, 6, 1), (3, 6, 2), (3, 6, 4), (4, 2, 1), (4, 2, 2), (4, 2, 3), (4, 4, 1), (4, 4, 2), (4, 4, 3), (4, 6, 1), (4, 6, 2), (4, 6, 3)]

Answer 2

this is list comprehension and the correct syntax for the filtering condition is this:

c = [(x,y,z) for x in a for y in b for z in a if x != z]

List comprehensions

Answer 3

The syntax being used to create c is called a list comprehension . Almost your exact case is the fourth code example in those docs:

A list comprehension consists of brackets containing an expression followed by a for clause, then zero or more for or if clauses. The result will be a new list resulting from evaluating the expression in the context of the for and if clauses which follow it. For example, this listcomp combines the elements of two lists if they are not equal:

>>>[(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]

[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

All you need to do is change your last for to an if :

c = [(x,y,z) for x in a for y in b for z in a if x != z]

Answer 4

Just for the sake of variety, I would like to add the following solution that is based on itertools.product and circumvents the if check.

from itertools import product
a = [1,2,3,4]
b = [2,4,6]

c = []
for i, item in enumerate(a):
    c.extend((item, x, y) for x, y in product(b, a[:i] + a[i+1:]))
print(c)

producing:

[(1, 2, 2), (1, 2, 3), (1, 2, 4), (1, 4, 2), (1, 4, 3), (1, 4, 4), (1, 6, 2), (1, 6, 3), (1, 6, 4), (2, 2, 1), (2, 2, 3), (2, 2, 4), (2, 4, 1), (2, 4, 3), (2, 4, 4), (2, 6, 1), (2, 6, 3), (2, 6, 4), (3, 2, 1), (3, 2, 2), (3, 2, 4), (3, 4, 1), (3, 4, 2), (3, 4, 4), (3, 6, 1), (3, 6, 2), (3, 6, 4), (4, 2, 1), (4, 2, 2), (4, 2, 3), (4, 4, 1), (4, 4, 2), (4, 4, 3), (4, 6, 1), (4, 6, 2), (4, 6, 3)]

---

I did some timings too to compare the different approaches using:

from timeit import timeit

setup = '''

from itertools import product


def list_comp(a, b):
    return [(x,y,z) for x in a for y in b for z in a if x != z]


def itertools_listComp(a, b):
    return [(x,y,z) for x, y, z in product(a, b, a) if x !=z]


def itertools_forLoop(a, b):
    c = []
    for i, item in enumerate(a):
        c.extend((item, x, y) for x, y in product(b, a[:i] + a[i + 1:]))
    return c

a = [1, 2, 3, 4]
b = [2, 4, 6]
'''

print('list_comp:', timeit(stmt="list_comp(a, b)", setup=setup, number=1000))
print('itertools_forLoop:', timeit(stmt="itertools_forLoop(a, b)", setup=setup, number=1000))
print('itertools_listComp:', timeit(stmt="itertools_listComp(a, b)", setup=setup, number=1000))

and the results are:

list_comp:          0.0050
itertools_listComp: 0.0056
itertools_forLoop:  0.0086

So it seems that the plain list comprehension is the fastest. This behavior persists with bigger a lists too.