包含某些元组的元组的元组索引列表

Question

I have a list list1 of 3 sublists of tuples like

[[(['A', 'B', 'A'], ['B', 'O', 'A']),
  (['A', 'B', 'A'], ['B', 'A', 'O']),
  (['A', 'B', 'O'], ['B', 'O', 'A']),
  (['A', 'B', 'O'], ['B', 'A', 'O']),
  (['A', 'B', 'A'], ['B', 'O', 'A']),
  (['A', 'B', 'A'], ['B', 'A', 'O'])],
 [(['A', 'B', 'A'], ['B', 'A', 'A']),
  (['A', 'B', 'O'], ['B', 'A', 'A']),
  (['A', 'B', 'A'], ['B', 'A', 'A'])],
 [['A', 'B', 'A'], ['A', 'B', 'O']],
 [['A', 'B', 'B']],
 [['B', 'A', 'A']]]

Assume list2 = ['A', 'B', 'A']. My goal is to obtain a list of indices of any pairs of tuples (or a singleton set of tuple) in list1 that contain the tuple list2 . I tried to use the enumerate function as follows but the result is not correct

print([i for i, j in enumerate(bigset) if ['A', 'B', 'A'] in j[0] or 
       ['A', 'B', 'A'] == j[0] or [['A', 'B', 'A']] in j[0]])

Can anyone please help me with this problem? I'm quite stuck due to the mismatch in the different sizes of tuples of tuples appearing in list1 .

Another question I have is: I want to find the total number of 3-element lists in list1 . So if I do it by hand, the answer is 22 . But how to do it in code? I guess we need to use two for loops?

Expected Output For list1 above with the given list2 , we would get the list of indices containing list2 is [0,1,5,6,7,9,10] .

Answer 1

Would it work for your implementation if we sort out your list1 into a more friendly format first? If so, you could do that in a pretty simple way:

Go through each element of list1, if the element is itself a big list of tuples, then we want to unpack further. If the element is a tuple (so the first element of that tuple is a list), or it is itself one of your 3-element lists, then we just want to append that as it is.

nice_list = []
for i in list1:
    if type(i[0]) == str or type(i[0]) == list:
        # i.e. i is one of your 3-element lists, or a tuple of lists
        nice_list.append(i)
    else:
        #If i is still a big list of other tuples, we want to unpack further
        for j in i:
            nice_list.append(j)

Then you could search for the indices much easier:

for i, idx in zip(nice_list, range(len(nice_list))): 
    if ['A', 'B', 'A'] in i: 
        print(idx) #Or append them to a list, whatever you wanted to do

For a not-particularly-elegant solution to your question about finding how many 3-element lists there are, yes you could use a for loop:

no_of_lists = 0
for n in nice_list:
    if type(n) == tuple:
        no_of_lists += len(n)
    elif type(n) == list and type(n[0]) == list:
        # if it is a list of lists
        no_of_lists += len(n)
    elif type(n) == list and type(n[0]) == str:
        #if it is a 3-element list
        no_of_lists_lists += 1
print('Number of 3-element lists contained:', no_of_lists)

Edit: to answer the question you asked in the comments about how the for n in nice_list part works, this just iterates through each element of the list. To explore this, try writing some code to print out nice_list[0] , nice_list[1] etc, or a for loop which prints out each n so you can see what that looks like. For example, you could do:

for n in nice_list:
    print(n)

to understand how that's working.

Answer 2

Slightly unconventional approach, due to unknown depth, and/or lack of known array flattening operation - I would try with regex:

import re

def getPos(el, arr):
    el=re.escape(str(el))
    el=f"(\({el})|({el}\))"
    i=0
    for s in re.finditer(r"\([^\)]+\)", str(arr)):
        if(re.match(el,s.group(0))):
            yield i
        i+=1

Which yields:

>>> print(list(getPos(list2, list1)))

[0, 1, 4, 5, 6, 8, 9]

(Which I believe is the actual result you want).

Answer 3

Ok, so here you go

This use recursion because we don't know the depth of your list1 SO the index will be counted like this :

0,1
2,3,4,
6,7
8,
9,10,11,12

etc... (The same order you have by writing it in 1 row)

Here the result will be :

[0, 2, 8, 10, 12, 16, 18]

Now the code

def foo(l,ref):
    global s
    global indexes
    for items in l:  #if it's an element of 3 letters
        if len(items)== 3 and len(items[0])==1:
            if items == ref: 
                indexes.append(s) #save his index if it match the ref
            s+= 1  #next index
        else: #We need to go deeper
            foo(items,ref)
    return(s)
          
        
list1 = [[(['A', 'B', 'A'], ['B', 'O', 'A']),
  (['A', 'B', 'A'], ['B', 'A', 'O']),
  (['A', 'B', 'O'], ['B', 'O', 'A']),
  (['A', 'B', 'O'], ['B', 'A', 'O']),
  (['A', 'B', 'A'], ['B', 'O', 'A']),
  (['A', 'B', 'A'], ['B', 'A', 'O'])],
 [(['A', 'B', 'A'], ['B', 'A', 'A']),
  (['A', 'B', 'O'], ['B', 'A', 'A']),
  (['A', 'B', 'A'], ['B', 'A', 'A'])],
 [['A', 'B', 'A'], ['A', 'B', 'O']],
 [['A', 'B', 'B']],
 [['B', 'A', 'A']]]

list2 = ['A', 'B', 'A']
indexes = []
s=0
count= foo(list1,list2)
print(indexes)

s is the index we are working on count is the total amount of element (22). Indexes is the list of index you want.

This work even if you make a list3 = [list1,list1,[list1,[list1],list1]] , you may want to try it.

Best luck to end your script now.