查找列表中有多少个列表具有相同的元素

Question

我是Python的新手，所以遇到了一些麻烦。 我在一个列表中有几个字符串列表。

list=[  [['AA','A0'],['AB','A0']],
        [['AA','B0'],['AB','A0']],
        [['A0','00'],['00','A0'], [['00','BB'],['AB','A0'],['AA','A0']] ]
     ]

我必须找到多少个具有相同元素的列表。 例如，对于上面的列表，元素['AB','A0']的正确结果是3，因为它是连接大部分元素的元素。

我写了一些代码...但是不好...它适用于列表中的两个列表，但不适用于更多...。请帮助！ 这是我的代码...上面的清单...

for t in range(0,len(list)-1):
     pattern=[]
     flag=True
     pattern.append(list[t])
     count=1
     rest=list[t+1:]
     for p in pattern:
         for j in p:
            if flag==False:
               break
            pair= j
            for i in rest:
                 for y in i:
                    if pair==y:
                        count=count+1
                          break                   
            if brojac==len(list):
                flag=False
                    break             

Answer 1

由于您的数据结构相当复杂，因此您可能需要构建一个递归函数，该函数可以自我调用（ http://en.wikipedia.org/wiki/Recursion_(computer_science） ）。

此功能非常简单。 您遍历原始列表的所有项目。 如果当前项目等于要搜索的值，则将找到的对象数增加1。如果该项目本身是列表，则将遍历该子列表并在该子列表中找到所有匹配项（通过在子列表而不是原始列表上调用相同的函数）。 然后，您可以通过子列表中的计数来增加找到的对象的总数。 我希望我的解释是清楚的。

alist=[[['AA','A0'],['AB','A0']],[['AA','B0'],['AB','A0']],[['A0','00'],['00','A0'],[['00','BB'],['AB','A0'],['AA','A0']]]]

def count_in_list(val, arr):
    val_is_list = isinstance(val, list)
    ct = 0
    for item in arr:
        item_is_list = isinstance(item, list)
        if item == val or (val_is_list and item_is_list and sorted(item) == sorted(val)):
            ct += 1
        if item_is_list :
            ct += count_in_list(val, item)
    return ct

print count_in_list(['AB', 'A0'], alist)

Answer 2

这是一种迭代方法，也可以使用python3来工作，该方法将获取所有子列表的计数：

from collections import defaultdict

d = defaultdict(int)

def counter(lst,  d):
    it = iter(lst)
    nxt = next(it)
    while nxt:
        if isinstance(nxt, list):
            if nxt and isinstance(nxt[0], str):
                d[tuple(nxt)] += 1
                rev = tuple(reversed(nxt))
                if rev in d:
                    d[rev] += 1
            else:
                 lst += nxt
        nxt = next(it,"")
    return d


print((counter(lst, d)['AB', 'A0'])
3

它仅适用于像您的输入这样的数据，列表旁边的字符串嵌套会破坏代码。

要获得单个子列表计数更容易：

def counter(lst,  ele):
    it = iter(lst)
    nxt = next(it)
    count = 0
    while nxt:
        if isinstance(nxt, list):
            if ele in (nxt, nxt[::-1]):
                count += 1
        else:
            lst += nxt
        nxt = next(it, "")
    return count

print(counter(lst, ['AB', 'A0']))
3

Answer 3

糟糕-这可能不是很好的代码，但是这就是我要尝试解决的方式。 请不要伤害我;-)

第一，

我将问题分成三个较小的部分：

1. 摆脱多个嵌套列表，
2. 计算内部列表中所有值对的出现，并
3. 从计数结果中提取最常出现的值对。

1。

我仍然会使用嵌套列表，但是深度只有两层。 要遍历的外部列表及其内部的所有两个值列表。 您可以在此处找到有关如何清除嵌套列表的大量信息。 因为我只是一个初学者，所以我无法从所有非常详细的信息中受益匪浅-但如果向下滚动，您会发现一个与我相似的示例。 这就是我的理解，这就是我的能力。

请注意，这是一个递归函数。 正如您在评论中提到的那样，您认为这不容易理解：我认为您是对的。 我将尝试以某种方式进行解释：

我不知道嵌套深度在您的列表中是否一致。 而且我不想自己提取值，因为您想使用列表。 因此，此函数遍历外部列表。 对于每个元素，它都会检查它是否是一个列表。 如果没有，则什么也不会发生。 如果它是一个列表，则将查看该列表中的第一个元素。 它将再次检查它是否为列表。

如果当前列表中的第一个元素是另一个列表，则将再次调用该函数-递归-但这一次从当前内部列表开始。 重复此操作，直到函数找到一个列表，该列表在第一个位置上包含一个不是列表的元素。

在您的示例中，它将遍历完整的列表列表，直到找到您的第一个字符串值。 然后，它获取包含该值的列表-并将其放在另一个列表中，然后返回该列表。

哦，男孩，这听起来真是太疯狂了-告诉我是否可以澄清任何事情... :-D

“哟，我想你喜欢清单，所以我把清单放在清单里……”

def get_inner_lists(some_list):
    inner_lists = []
    for item in some_list:
        if hasattr(item, '__iter__') and not isinstance(item, basestring):
            if hasattr(item[0], '__iter__') and not isinstance(item[0], basestring):
                inner_lists.extend(get_inner_lists(item))
            else:
                inner_lists.append(item)                            
    return inner_lists

无论如何-调用该函数，您会发现列表重新排列了一下：

>>> foo = [[['AA','A0'],['AB','A0']],[['AA','B0'],['AB','A0']],[['A0','00'],['00','A0'],[['00','BB'],['AB','A0'],['AA','A0']]]]
>>> print get_inner_lists(foo)

[['AA', 'A0'], ['AB', 'A0'], ['AA', 'B0'], ['AB', 'A0'], ['A0', '00'], ['00', 'A0'], ['00', 'BB'], ['AB', 'A0'], ['AA', 'A0']]

2。

现在，我将遍历该列表并使用其值构建一个字符串。 这仅适用于两个值的列表，但是正如您在示例中所显示的那样。 在迭代时，我将建立一个字典，将字符串作为键，将出现的值作为值。 这使得添加新值和增加现有值的计数器非常容易：

def count_list_values(some_list):
    result = {}
    for item in some_list:
        str = item[0]+'-'+item[1]
        if not str in result.keys():
            result[str] = 1
        else:
            result[str] += 1    
    return result

在那里，所有计数都已完成。 我不知道是否需要它，但是副作用是所有值和所有情况都出现了：

>>> print count_list_values(get_inner_lists(foo))

{'00-A0': 1, '00-BB': 1, 'A0-00': 1, 'AB-A0': 3, 'AA-A0': 2, 'AA-B0': 1}

3。

但是您想要清晰的结果，因此让我们循环浏览该字典，列出所有键和所有值，找到最大值-并返回相应的键。 用分隔符（ - ）构建两个值的字符串后，很容易将其拆分并再次列出该列表：

def get_max_dict_value(some_dict):
    all_keys = []
    all_values = []
    for key, val in some_dict.items():
        all_keys.append(key)
        all_values.append(val)
    return all_keys[all_values.index(max(all_values))].split('-')

如果定义了这三个小功能，然后将它们组合使用，那么您将获得：

>>> print get_max_dict_value(count_list_values(get_inner_lists(foo)))

['AB', 'A0']

塔达！ :-)

如果您确实有这样的列表，其中仅包含9个元素，并且您不需要经常计算值-则手动进行。 通过读取值并用手指计数。 这样会容易得多；-)

否则，你去！

要么...

...您等到某个Guru出现并给您一个我从未见过的超快速，优雅的单行python命令时，它将执行相同的操作;-)

Answer 4

这很简单，我可以合理地做到：

from collections import Counter

lst = [  [['AA','A0'],['AB','A0']],
        [['AA','B0'],['AB','A0']],
        [['A0','00'],['00','A0'], [['00','BB'],['AB','A0'],['AA','A0']] ]
     ]


def is_leaf(element):
    return (isinstance(element, list) and
            len(element) == 2 and
            isinstance(element[0], basestring)
            and isinstance(element[1], basestring))


def traverse(iterable):
    for element in iterable:
        if is_leaf(element):
            yield tuple(sorted(element))
        else:
            for value in traverse(element):
                yield value

value, count = Counter(traverse(lst)).most_common(1)[0]
print 'Value {!r} is present {} times'.format(value, count)

traverse()生成产生一系列已排序的元组，它们表示列表中的每个项目。 Counter对象对每个对象的出现次数进行计数，其.most_common(1)方法返回最常见项目的值和计数。

您已经说过递归太困难了，但是我希望有所不同：这是解决此问题的最简单方法。 您越早喜欢递归，就会越快乐。 :-)

Answer 5

希望这样的东西就是您想要的。 这有点脆弱，建议递归更好。 但是由于您不希望这样，所以这里有一些代码可能会起作用。 我不太擅长python，但希望它能胜任：

def Compare(List):
    #Assuming that the list input is a simple list like ["A1","B0"]
    myList =[[['AA','A0'],['AB','A0']],[['AA','B0'],['AB','A0']],[['A0','00'],['00','A0'],[['00','BB'],['AB','A0'],['AA','A0']]]]

#Create a counter that will count if the elements are the same
myCounter = 0;
for innerList1 in myList:        
    for innerList2 in innerList1
        for innerList3 in innerList2
            for element in innerList3
                for myListElements in myList
                    if (myListElements == element)
                        myCounter = myCounter + 1;

                        #I am putting the break here so that it counts how many lists have the
                        #same elements, not how many elements are the same in the lists
                        break;

return myCounter;