我在 Python中有一个包含字符串的列表：

["foo/bar","foo/bar/baz","foo/bar/qux"]

我试图将该列表中未包含在任何其他更长元素中的最小元素分开.在这种情况下,我想返回一个列表[“foo / bar / baz”,“foo / bar / qux”],因为它们不包含在任何更长的元素中.我不想要“foo / bar”,因为它包含在“foo / bar / baz”和“foo / bar / qux”中.我一直在尝试嵌套for和if语句,但我似乎无法做到正确.任何人都能指出我正确的方向吗？

假设你真的在寻找叶子目录(即“包含在”真的意思是“前缀为”,斜杠是特殊的),这里有一个简单的算法：

def leaf_dirs(dirlist):
    """Given a list of directories,find leaf directories"""
    parents = {}
    for path in dirlist:
        parts = path.split('/')
        if parts[0] == '':
            raise ValueError("can't handle rooted directory %s" % path)
        parent = '/'.join(parts[:-1])
        parents[parent] = True
    return [path for path in dirlist if path not in parents]

基本上,所有“父目录”名称都放入字典中,然后我们过滤掉这些名称.在“foo / bar / baz”和“foo / bar / quux”的情况下,父路径(foo / bar)输入两次,但我们并不在意.

编辑：修复omri Barel注意到的点,而不仅仅是使用[： – 1]部分：

while parts:
            parts.pop() # strip last path component
            parent = '/'.join(parts)
            parents[parent] = True

这将剥离最后一个组件并进入父组件. (我故意在这里输入空字符串,这样做有点简单.)

假设我们有以下列表：

sequence = ['2','4','1','2','3','4']
#indices     0    1    2    3    4    5    6    7    8    9    10

接下来,我们有以下列表：

key_list = ['2','4']

现在,我想从序列中提取所有可能的子列表,这些子列表保留了密钥列表的顺序,即其索引.

让我举例说明.因此,对于序列,保留key_list顺序的所有可能的索引子列表是：

[0,3,5]
[0,7]
[0,9]
[0,10]

[0,6,8,10]

[3,7]
[3,9]
[3,10]

[6,9]
[6,10]

有什么建议？

编辑：我正在使用一个大数据集,我必须为文件的每一行执行此操作,所以我正在寻找一种非常优化的方法来做到这一点,通过避免蛮力方法(制作所有可能的序列组合)

附：我不知道问题的标题是否合适,如果您有更好的标题,请随时更改.

它可能需要一些优化,也许比列表列表更好的结构,以避免我现在正在做的愚蠢的复制和插入,但我认为这应该在最糟糕的复杂性len(序列)^ 2(不确定)关于复杂性).

sequence = ['2','4']
key_list = ['2','4']

sub_lists = []
final_sub_lists = set()
len_key_list = len(key_list)

for index,value in enumerate(sequence):
    for sub_list in sub_lists:
        len_sub_list = len(sub_list)
        # Test if current value can continue the current sub list
        if len_sub_list < len_key_list and key_list[len_sub_list] == value:
            if len_sub_list == len_key_list - 1:
                # We have found a complete sub list
                final_sub_lists.add(tuple(sub_list + [index]))
            else:
                # We copy the current sub list to be sure not miss any sub lists
                # like for instance (6,9) and (6,10).
                sub_lists.insert(0,sub_list[:])
                sub_list.append(index)
    if key_list[0] == value:
        # Start a new sub list
        sub_lists.append([index])

print sorted(final_sub_lists)

说明：sub_lists是包含到目前为止匹配的索引的列表列表.当sub_list匹配key_list的所有值时,它将附加到set final_sub_lists.

它没有经过全面测试,所以请随意纠正或指出优化！

我正在使用 Python并考虑以下问题：给出一个列表,例如[1,-2,4,5,3]多次包含0的整数,我希望有这些0和每一个的索引是它出现在列表中的次数,直到出现不同的元素或列表结束.

给定l = [1,0],函数将返回((1,1),(3,2),(7,1)).结果是一个元组列表.元组的第一个元素是给定元素的索引(在列表中),第二个元素是在不同元素出现或列表结束之前重复的次数.

天真地,我会写这样的东西：

def myfun(l,x):
    if x not in l:
        print("The given element is not in list.")
    else:
        j = 0
        n = len(l)
        r = list()
        while j <= (n-2):
            count = 0
            if l[j] == x:
                while l[j + count] == x and j <= (n-1):
                    count +=1
                r.append((j,count))
                j += count
            else:
                j += 1
        if l[-1] == x:
            r.append((n-1,1))
        return r

但我想知道是否会有更好的(更短的？)方式做同样的事情.

不是最漂亮的,但是单行：

>>> import itertools
>>> l=[1,0]
>>> [(k[0][0],len(k)) for k in [list(j) for i,j in itertools.groupby(enumerate(l),lambda x: x[1]) if i==0]]
[(1,1)]

首先,itertools.groupby(enumerate(l),lambda x：x [1])将按枚举(l)的第二项分组,但保留项的索引.

然后[list(j)for i,lambda x：x [1])if if == 0]将仅保留0值.

最后,需要最后一个列表理解因为list(j)使用了itertools对象.