Python：删除列表中至少由同一列表中的一个其他字符串包含的字符串

Question

I would love to filter my list of strings the following way: I want to exclude strings , if there is at least one other string in the same list that is " in " it . Or to put this differently: I want to maintain strings, if there is no other string of the same list that is in it. Case Sensitivity should play a role here, if possible.

To make this more clear, please find below an example :

My "first" list that contains every string:

elements =["tree","TREE","treeforest","water","waterfall"]

After applying the solution, I would love to receive this list:

elements = ["tree","TREE","water"]

For example: tree is in treeforest . Thus, treeforest is excluded from my list. Same applies for water and waterfall . However, tree , TREE and water should be maintained, because there are no others strings, that are " in " them.

As I'd like to apply this to a " larger " list of strings, more efficient solutions are preferred.

Hope this is understandable. Thanks a lot in advance!! Any help is highly appreciated.

Answer 1

Quite optimized function with 2 loops, which saves a lot of loop iterations:

def filterlist(l):
    # keep track of elements, which will be deleted
    deletelist = [False for _ in l]

    for i, el in enumerate(l):
        # already in deletelist, jump right to the next el
        if deletelist[i]:
            continue

        for j, el2 in enumerate(l):
            # comparing item to itself or el2 already in deletelist?
            # jump to next el2
            if i == j or deletelist[j]:
                continue

            # the comparison everyone expects
            if el in el2:
                deletelist[j] = True

            # also, check the other way around
            # will save loop iterations later
            elif el2 in el:
                deletelist[i] = True
                break # causes jump to next el

    # create new list, keep elements that are not in deletelist
    return [el for i, el in enumerate(l) if not deletelist[i]]

Usually built-in functions are faster, so let's compare it to Ed Ward's solution:

# result of Ed Ward's solution using timeit:
100000 loops, best of 10: 5.38 usec per loop

# filterlist function with loops using timeit:
100000 loops, best of 10: 4.42 usec per loop

Interesting, but to get a really representative result, you should run timeit with a larger element list.

Answer 2

from copy import deepcopy

def remove_composite_words(e,elements):
  temp = [x for x in elements if e in x]
  temp = set(temp)
  elements = list(set(elements).difference(temp))
  return e,sorted(elements, key=len)

def keep_shortest_root(elements):
  elements = deepcopy(elements)
  elements = list(set(elements))
  elements = sorted(elements, key=len)
  if len(elements[0]) ==0:
    elements = elements[1:]

  results = []
  e = elements[0]
  while elements:
    e,elements = remove_composite_words(e,elements)
    results.append(e)
    if elements:
      e = elements[0]

  return results
  
elements =["tree","TREE","treeforest","water","waterfall",'forestTREE','tree']

keep_shortest_root(elements)  

This should return

['tree', 'TREE', 'water']

How it works:

The function remove_composite_words() tests if an element in contained in any other element in the list and save only those that match. Then it remove the matching elements from the initial list.

So if you have element 'a' and list ['a','aa','b','c'] the function will return 'a' and the list ['b','c'] .

keep_shortest_root() applies remove_composite_words() to the initial list and then to the transformed list (output from remove_composite_words() ) until there are no more words left.

Note that keep_shortest_root() first gets the unique words from the input list and then sorts them by length. This combined with the fact that remove_composite_words() removed the matched words from initial list make the algorithm run faster since the number of comparisons drops with the number of iterations.

Answer 3

Found a bit of a simpler solution to the one already provided, thought I might chip in

 def Remove_Subset(List):
    ListCopy=List
    for Element1 in List:
        for Element2 in List:
            if (Element1 in Element2) and (Element1!= Element2):
                ListCopy.remove(Element2)
    return(ListCopy)
elements =["treeforest","tree","TREE","treeforest","water","waterfall","tree"]
print(Remove_Subset(elements))


>>> ['tree', 'TREE', 'water']

Answer 4

This is an explanation of the answer I gave in my comment

---

I used this code:

new_elements = list(filter(lambda item: not any(elem in item for elem in elements if elem != item), elements))

which yields:

['tree', 'TREE', 'water']

---

I don't know how much you know about Python generator expressions, and filter , so I'll try to explain anyway.

filter is a Python built-in function, which takes a function to use on each item in the supplied iterable (eg list, etc). In our case, the function is this:

lambda item: not any(elem in item for elem in elements if elem != item)

This function takes an item from the the list ( item ), and then iterates over every element in the list ( for elem in elements ), and for each element ( elem ) checks if this element is in our string ( item ). Note that it skips to the next element if elem != item , because we don't want to compare it with itself.

The function any simply keeps iterating until either the expression returned is True , or it reaches the end. If there were any matches, any returns True , but to tell filter to drop this item, we need to return False , so we invert the output from any .

We also pass to filter our list ( elements ), and convert the result from filter to another list .

---

Note: the bonus of using any instead of iterating over every item for every other item is that in the case of finding a match, we don't have to iterate over the entire list: any returns at that point. In theory, this could be faster than two nested for-loops without a break statement.