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

我是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             

---

由于您的数据结构相当复杂，您可能需要构建一个递归函数，即调用自身（）的函数

这个函数相当简单。您可以遍历原始列表中的所有项。如果当前项等于要搜索的值，则将找到的对象数增加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)

---

希望这样的东西就是你想要的。这有点牵强，可能表明递归更好。但既然你不想这样，这里有一些代码可以工作。我并不擅长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;

这可能不是很好和简单的代码，但这就是我试图解决这个问题的方法。请不要伤害我；-）

首先，

我将把这个问题分成三个小问题：

摆脱多个嵌套列表

计算内部列表和中所有值对的出现次数

从计数结果中提取最常出现的值对

1.

我仍然使用嵌套列表，但只有两层深度。一个外部列表，用于迭代，以及其中的所有两个值列表。您可以找到大量关于如何摆脱嵌套列表的信息。由于我只是一个初学者，我无法从所有这些非常详细的信息中获得太多信息——但是如果你向下滚动，你会发现一个类似于我的示例。这就是我的理解，这就是我能做的

请注意，它是一个递归函数。正如你在评论中提到的，你认为这不容易理解：我认为你是对的。我会设法解释一下：

我不知道你的列表中的嵌套深度是否一致。我不想超越这些值本身，因为你想处理列表。所以这个函数在外部列表中循环。对于每个元素，它检查它是否是一个列表。如果没有，什么也不会发生。如果它是一个列表，它将查看该列表中的第一个元素。它会再次检查它是否是列表

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

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

哦，孩子，这听起来真的很疯狂-告诉我这是否澄清了什么…：-D

“哟，老兄，我喜欢列表，所以我把一个列表放在一个列表中…”

不管怎样-调用该函数，您会发现您的列表重新排列了一点：

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

塔达阿！：-）

如果你真的有这样一个只有九个元素的列表，并且你不需要经常计算值，那么就手工计算吧。通过读取数值和用手指计数。这会容易得多；-）

否则，给你

或…

---

…等待某位大师出现，并给出一个我以前从未见过的超快速、优雅的单行python命令，该命令也会这样做；-）

这是一种迭代方法，也可以使用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

---

这是我能合理地做到的最简单的事情：

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（）

generate生成一系列表示列表中每个项目的排序元组。

计数器

对象统计每个项的出现次数，其

方法返回最常用项的值和计数

你说过递归太难了，但我不同意你的看法：它是解决这个问题的最简单的方法。你越早爱上递归，你就会越快乐。：-）
 请不要使用
列表
作为变量名，它是一个内置类型。它与
['AB'，'A0']
匹配
['A0'，'AB']
？是的，它是…它与…@user2923389相同
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)