在Python中向后迭代字典

Question

I have a long dictionary of elements and I want to remove any dictionary entries that only has a list with only 1 element. For example

    wordDict={'aardvark':['animal','shell'], 'bat':['animal', 'wings'], 
              'computer':['technology'], 'donut':['food','sweet']}

I want to remove the 'computer' entry because the list in it only has one element. I started by iterating through the wordDict and putting each entry in the dictionary in a separate list so that it looks like this

    wordList=[['animal','shell'],['animal','wings'],['technology'],['food','sweet']]

and then iterating through that list backwards, checking if the length of each element in the list is greater than 1. Backwards because going forwards causes the index to change as I delete.

So in wordList, ['technology'] gets removed and this is what is left

    wordList=[['animal','shell'],['animal','wings'],['food','sweet']]

The problem is that as wordDict becomes substantially large (100k+ words), it takes a long time to put the wordDict into a list then iterate through that list and I want to make it more efficient.

I was thinking about iterating through the dictionary backwards, checking if each entry has more than one word and then removing the dictionary entry if it doesn't. At the end, what needs to be returned is a list, not a dictionary so the index doesn't matter in the end, I only used them for sorting purposes.

Is there a way to do this?

Answer 1

You can drop the elements you don't want and create a new dictionary, with dictionary comprehension, like this

>>> {word: items for word, items in wordDict.items() if len(items) > 1}
{'aardvark': ['animal', 'shell'],
 'bat': ['animal', 'wings'],
 'donut': ['food', 'sweet']}

You are iterating through the wordDict dictionary and checking if the length of the items is greater than 1. If it is, then include it in the new dictionary being constructed, otherwise don't include it.

Answer 2

The first option is as thefourtheye suggested try rebuild the dictionary accordingly and letting the only elements which has a list with more than one element:-

new_dict = {key:value for key,value in d.iteritems() if len(value) > 1} 

And the second option is iterate the dictionary and remove the items accordingly but it will not that much efficient as the first option.

Answer 3

If you only needs the list in the end you can do:

wordList = list(filter(lambda x: len(x) > 1, wordDict.values()))

It's not necessary to create a temporary dictionary...

Edit: An alternative (actually clearer and faster than the above) is

wordList = list(value for value in wordDict.values() if len(value) > 1)

---

Bonus: if you wan't to filter empty values, you can just do:

wordList = list(filter(bool, wordDict.values()))

Edit: the alternative here too (it's a little bit strange, but is right):

wordList = list(value for value in wordDict.values() if value)

The logical value of empty lists (and dicts, etc) is False .

Answer 4

I think it's faster to keep track of elements with length = 1. When inserting an element to dictionary with length = 1 or performing an operation on an element that makes the length = 1, put key of that element in a list like "singles". Then, when you want, remove all elements with length = 1 using keys in "singles". It eliminates the need to traverse all element of dictionary.

For example, when inserting to dictionary:

def insert(wordDict, key, element, singles):
    wordDict[key] = element
    if len(element) == 1:
        singles.append(key)

And, when doing an operation of an element that possibly changes its length:

def some_operation(key, element, singles):
    # Do something.
    if len(element) == 1:
        singles.append(key)

At the end, when you want to perform your deletion of all elements with length = 1:

def delete_singles(wordDict, singles):
    for k in singles:
        wordDict.pop(k)

Now, just do all inserts and modifications with these functions and use delete_single() to do the deletion. I hope it works fast!

Answer 5

One may modify the length of list as one iterates because it is possible to do it sensibly, by iterating backwards. But as you noticed, it is also slow (O(nk), where k in the number of items delected.

One may not change the keys of a dict while iterating because that could cause a rebuilding of the internal hash array that is the basis of the iteration. One must instead make a separate collection of keys to iterate through.

wordDict={'aardvark':['animal','shell'], 'bat':['animal', 'wings'], 
              'computer':['technology'], 'donut':['food','sweet']}

for key in list(wordDict.keys()):
    if len(wordDict[key]) <= 1:
        del wordDict[key]

print(wordDict)

prints

{'aardvark': ['animal', 'shell'], 'bat': ['animal', 'wings'], 'donut': ['food', 'sweet']}