来自一个集合的列表理解，其元素是由两个元组组成的元组

Question

I have a huge list of tuples each containing another two tuples like eg

lst = [((0,2,1), (2,1,3)), ((3,2,1), (0,1,1)), ...]

Many of the elements of this list are not acceptable under certain criteria and I am trying to create a new list composed by those elements satisfying those conditions. Among others, I would like to remove those elements whose left (resp. right) tuple contains a zero but the right (resp. left) tuple has no zero in the same position. Also those elements whose left tuple contains two consecutive non zero numbers (in a given range) and the number located in the right tuple in the same position than the one where the repetition appears is not a 1. To do this, I have tried:

acceptable_lst = [elem for elem in lst for j in range(3) if not ((elem[0][j] == 0 and
                  elem[1][j] != 0) or (j < 2 and elem[0][j] != 0 and elem[0][j] == elem[0][j+1]
                  and elem[1][j+1] != 1)]

When I apply this code to eg

lst = [((3,2,2), (1,2,3)),
       ((0,1,3), (2,2,3)),
       ((1,1,2), (3,3,3)),
       ((0,2,2), (3,3,3)),
       ((2,2,1), (3,1,3))]

I would like to get:

acceptable_lst = [((2,2,1), (3,1,3))]

Why? The first element in lst has a rep of 2 in the left tuple, the second 2 in the third position, but the third element in the right tuple is not a 1. The second element has a zero in the first position of the left tuple and a non zero in the same position of the right tuple, so on... Only the last element in lst satisfies the above conditions.

However what I get is

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

which indicates that my code is completely wrong. How can I implement what I need?

Answer 1

Check the validity in a function

def valid(elemLeft, elemRight):
    lastItem = None
    for i in range(3):
        if elemLeft[i] == 0 and elemRight[i] != 0:
            return False

        if lastItem != None:
            if elemLeft[i] == lastItem and elemRight[i] != 1:
                return False

        lastItem = elemLeft[i]
    
    return True

lst = [((3,2,2),(1,2,3)), ((0,1,3),(2,2,3)), ((1,1,2),(3,3,3)), ((0,2,2),(3,3,3)), ((2,2,1),(3,1,3))]
acceptable_lst = [elem for elem in lst if valid(elem[0],elem[1])]
print(acceptable_lst)

Answer 2

You are doing two for loops in your list comprehension.

[ elem for elem in lst for j in range(3) if condition ]

is equivalent to:

out_list = []
for elem in lst:
    for j in range(3):
        if condition:
            out_list.append(elem)

If you have to use list comprehension for this task, you could modify it:

import numpy as np

acceptable_lst = [elem for elem in lst 
                  if not (np.any([(elem[0][j] == 0 and elem[1][j] != 0) for j in range(3)])) 
                    and not np.any([(j < 2 and elem[0][j] != 0 and elem[0][j] == elem[0][j+1] and elem[1][j+1] != 1) for j in range(3)])]