繁体   English   中英

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

Find how many lists in list have the same element

提示:本站收集StackOverFlow近2千万问答,支持中英文搜索,鼠标放在语句上弹窗显示对应的参考中文或英文, 本站还提供   中文繁体   英文版本   中英对照 版本,有任何建议请联系yoyou2525@163.com。

我是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             
5 个回复

由于您的数据结构相当复杂,因此您可能需要构建一个递归函数,该函数可以自我调用( 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)

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

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

第一,

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

  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命令时,它将执行相同的操作;-)

这很简单,我可以合理地做到:

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)方法返回最常见项目的值和计数。

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

希望这样的东西就是您想要的。 这有点脆弱,建议递归更好。 但是由于您不希望这样,所以这里有一些代码可能会起作用。 我不太擅长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 如何计算一个列表中有多少个元素相同?

我需要执行以下任务: 我有一个物品清单。 每个项目还具有一个包含字符串的列表,例如“ gkejgueieriug ” 现在,我需要运行throw the list并检查每个项目列表中有多少个项目也在当前元素中 这是一个小的伪代码: 因为数据非常大,所以我 ...

2013-05-24 08:56:41 4 76   java
2 方案列表中有多少个元素

我需要编写一个函数,使用方案语言计算列表上有多少个元素。 例如 (howMany 'a)返回0 (howMany '(ab))返回1 (howMany '(a (bc)))返回2 我怎样才能做到这一点? 我不想要一个有效的代码,只是一个想法。 因此,也许您应该考虑删 ...

3 Java检查两个列表中有多少个元素相同

假设我有一个清单 然后另一个清单 现在,我要检查allElements包含来自randomElements 3个或更多元素。 如果只有2个或更少,那么我不希望它触发。 (上面的示例应该返回true)我将如何处理? 我可以使用allElements.deleteAll(ran ...

2019-10-07 20:38:18 4 49   java
4 查找大量列表具有相同元素的列表

我有一个列表字典(我也可以将它们组合起来) s *是字符串。 我想确定哪些键具有等效列表。 我了解如何对两个列表(==)或集合(交集)进行成对比较,但是我需要收集所有具有匹配列表的键。 例如: 有任何有效的方法可以在Python中执行此操作吗? ...

5 查找列表中有多少个嵌套字典键

我需要查找字典中有多少次出现键“ p”。 密钥嵌套在字典中,列表如下: 我尝试了这个: 但它只返回各个字符串。 我尝试将那些添加到列表中没有成功。 我还考虑制作一个for循环,只计算有多少,但这似乎是一个笨拙的方法。 我应该如何:1.一起创建所有字符串的列表,以便删除最后 ...

7 列表中有多少个单词

例如dic ['aet'] = ['ate','eat','eta']和dic ['pol'] = ['lop','pol'] 如果我输入一个单词的长度:3,我希望它打印出最长的字典值,其中单词的长度为3加上字典中的值。 我该怎么做? 我要从上面输出:['ate','eat' ...

2017-10-28 00:21:54 1 56   python
10 查找边缘列表中有多少个重复连接[python]

给定边列表,例如, 我需要查找列表中有多少个重复连接。 在此示例中:连接按顺序发生 则[2,3]已连接,因此我们将dup加1 那么[5,6]已经连接好了,所以我们再次将dup加1 返回dup = 2 最后一步是我的方法[12,10]了,因为它会将[12 ...

暂无
暂无

声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.

 
粤ICP备18138465号  © 2020-2021 STACKOOM.COM