Блог

У меня есть список list1 из 3 подсписков кортежей, таких как

 [[(['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']. моя цель — получить список индексов любых пар кортежей (или одноэлементного набора кортежей), в list1 которых содержится кортеж list2 . Я попытался использовать enumerate функцию следующим образом, но результат неверен

 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]])
  

Может кто-нибудь, пожалуйста, помочь мне с этой проблемой? Я довольно сильно застрял из-за несоответствия разных размеров кортежей кортежей, появляющихся в list1 .

Еще один вопрос, который у меня есть: я хочу найти общее количество списков из 3 элементов в list1 . Итак, если я сделаю это вручную, ответ будет 22 . Но как это сделать в коде? Я думаю, нам нужно использовать два for цикла?

Ожидаемый результат Для list1 приведенного выше list2 мы получили бы список индексов, содержащих list2 is [0,1,5,6,7,9,10] .

Хорошо, итак, поехали

Это использует рекурсию, потому что мы не знаем глубину вашего list1 ПОЭТОМУ индекс будет подсчитываться следующим образом :

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

и т.д… (Тот же порядок, который вы имеете, записав его в 1 строку)

Здесь результатом будет :

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

Теперь код

 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 это индекс, над которым мы работаем
count — общее количество элемента (22).
Indexes это список индексов, который вы хотите.

Это работает, даже если вы создаете list3 = [list1,list1,[list1,[list1],list1]] , вы можете попробовать это.

Желаю удачи в завершении вашего сценария сейчас.

Будет ли это работать для вашей реализации, если мы сначала отсортируем ваш list1 в более удобный формат? Если это так, вы могли бы сделать это довольно простым способом:

Пройдите по каждому элементу list1, если элемент сам по себе является большим списком кортежей, то мы хотим распаковать дальше. Если элемент является кортежем (то есть первым элементом этого кортежа является список), или он сам является одним из ваших списков из 3 элементов, тогда мы просто хотим добавить это как есть.

 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)
  

Тогда вы могли бы искать индексы намного проще:

 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
  

Для не особенно элегантного решения вашего вопроса о том, сколько существует списков из 3 элементов, да, вы могли бы использовать цикл for:

 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)
  

Редактировать: чтобы ответить на вопрос, который вы задали в комментариях о том, как работает for n in nice_list часть, это просто перебирает каждый элемент списка. Чтобы изучить это, попробуйте написать некоторый код для вывода на печать nice_list[0] , nice_list[1] и т.д. Или цикл for, который выводит каждый из них n , чтобы вы могли увидеть, как это выглядит. Например, вы могли бы сделать:

 for n in nice_list:
    print(n)
  

чтобы понять, как это работает.

Немного нетрадиционный подход из-за неизвестной глубины и / или отсутствия известной операции выравнивания массива — я бы попробовал с регулярным выражением:

 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
  

Что дает:

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

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

(Я считаю, что это фактический результат, который вы хотите).