Entfernen Werte in Wörterbuch mit einer Liste von Wörtern python

Question

Lassen Sie uns sagen, ich habe eine Liste von Wörtern

nottastyfruits = ['grape', 'orange', 'durian', 'pear'] 

fruitGroup = {'001': ['grape','apple', 'jackfruit', 'orange', 'Longan'], 
       '002': ['apple', 'watermelon', 'pear']} 

ich durch alle Schlüssel im Wörterbuch gehen und die Worte aus nottastyfruits Liste entfernen.

Mein aktueller Code ist

finalfruits = {} 
for key, value in fruitGroup.items(): 
    fruits = [] 
    for fruit in value: 
     if fruit not in nottastyfruits: 
      fruits.append(fruit) 
    finalfruits[key] = (fruits) 

Dies dauert so lange laufen zu lassen, wenn Sie einen großen Daten Text wie große Text Vorverarbeitung haben. Gibt es dafür einen effizienteren und schnelleren Weg?

Vielen Dank für Ihre Zeit

Answer 1

es flach machen durch ein Wörterbuch Verständnis mit wird den Overhead der for Schleife entfernen.

machen nottastyfruits ein Satz wird Lookup Zeit verringern:

nottastyfruits = set(nottastyfruits) 
finalfruits = {k: [f for f in v if f not in nottastyfruits] for k, v in fruitGroup.items()} 

Answer 2

Sie sollten eine set aus Ihrem fruitlist machen die Lookups Speedup, dann ein Wörterbuch Verständnis verwenden:

nottastyfruits = set(['grape', 'orange', 'durian', 'pear']) 

fruitGroup = {'001': ['grape','apple', 'jackfruit', 'orange', 'Longan'], 
      '002': ['apple', 'watermelon', 'pear']} 

print {k: [i for i in v if i not in nottastyfruits] for k, v in fruitGroup.iteritems()} 

>>> {'002': ['apple', 'watermelon'], '001': ['apple', 'jackfruit', 'Longan']} 

Answer 3

Eine niedrig hängenden Früchte, wenn man so will, ist nottastyfruits ein set zu machen. Außerdem können Sie mithilfe von Comprehensions etwas Leistung ausgleichen.

In [1]: fruitGroup = {'001': ['grape','apple', 'jackfruit', 'orange', 'Longan'], 
    ...:    '002': ['apple', 'watermelon', 'pear'] 
    ...:    } 

In [2]: nottastyfruit = {'grape', 'orange', 'durian', 'pear'} 

In [3]: finalfruits = {k:[f for f in v if f not in nottastyfruit] for k,v in fruitGroup.items()} 

In [4]: finalfruits 
Out[4]: {'001': ['apple', 'jackfruit', 'Longan'], '002': ['apple', 'watermelon']} 

Answer 4

Da sowohl nottastyfruits und Listen im Wörterbuch flachen Listen sind, können Sie Gruppen verwenden, um die Differenz zwischen den beiden zu bekommen.

nottastyfruits = set(['orange', 'pear', 'grape', 'durian']) 
fruitGroup = {'001': ['grape','apple', 'jackfruit', 'orange', 'Longan'], '002': ['apple', 'watermelon', 'pear'] } 

for key, value in fruitGroup.iteritems(): 
    fruitGroup[key] = list(set(value).difference(nottastyfruits)) 

print fruitGroup # Prints "{'002': ['watermelon', 'apple'], '001': ['jackfruit', 'apple', 'Longan']}" 

Answer 5

Unten finden Sie eine Benchmark Differents vorgeschlagenen Lösungen sowie eine Lösung auf dem filter() Funktion basiert:

from timeit import timeit 


nottastyfruits = ['grape', 'orange', 'durian', 'pear'] 

fruitGroup = {'001': ['grape','apple', 'jackfruit', 'orange', 'Longan'], 
       '002': ['apple', 'watermelon', 'pear']} 


def fruit_filter_original(fruit_groups, not_tasty_fruits): 
    final_fruits = {} 
    for key, value in fruit_groups.items(): 
     fruits = [] 
     for fruit in value: 
      if fruit not in not_tasty_fruits: 
       fruits.append(fruit) 
     final_fruits[key] = (fruits) 
    return final_fruits 


def fruit_filter_comprehension(fruit_groups, not_tasty_fruits): 
    return {group: [fruit for fruit in fruits 
         if fruit not in not_tasty_fruits] 
      for group, fruits in fruit_groups.items()} 


def fruit_filter_set_comprehension(fruit_groups, not_tasty_fruits): 
    not_tasty_fruits = set(not_tasty_fruits) 
    return {group: [fruit for fruit in fruits 
         if fruit not in not_tasty_fruits] 
      for group, fruits in fruit_groups.items()} 


def fruit_filter_set(fruit_groups, not_tasty_fruits): 
    return {group: list(set(fruits).difference(not_tasty_fruits)) 
      for group, fruits in fruit_groups.items()} 


def fruit_filter_filter(fruit_groups, not_tasty_fruits): 
    return {group: filter(lambda fruit: fruit not in not_tasty_fruits, fruits) 
      for group, fruits in fruit_groups.items()} 


print(fruit_filter_original(fruitGroup, nottastyfruits)) 
print(fruit_filter_comprehension(fruitGroup, nottastyfruits)) 
print(fruit_filter_set_comprehension(fruitGroup, nottastyfruits)) 
print(fruit_filter_set(fruitGroup, nottastyfruits)) 
print(fruit_filter_filter(fruitGroup, nottastyfruits)) 


print(timeit("fruit_filter_original(fruitGroup, nottastyfruits)", number=100000, 
     setup="from __main__ import fruit_filter_original, fruitGroup, nottastyfruits")) 
print(timeit("fruit_filter_comprehension(fruitGroup, nottastyfruits)", number=100000, 
     setup="from __main__ import fruit_filter_comprehension, fruitGroup, nottastyfruits")) 
print(timeit("fruit_filter_set_comprehension(fruitGroup, nottastyfruits)", number=100000, 
     setup="from __main__ import fruit_filter_set_comprehension, fruitGroup, nottastyfruits")) 
print(timeit("fruit_filter_set(fruitGroup, nottastyfruits)", number=100000, 
     setup="from __main__ import fruit_filter_set, fruitGroup, nottastyfruits")) 
print(timeit("fruit_filter_filter(fruitGroup, nottastyfruits)", number=100000, 
     setup="from __main__ import fruit_filter_filter, fruitGroup, nottastyfruits")) 

Wir können sehen, dass alle Lösungen in der Bezeichnung der Leistung nicht gleich sind:

{'001': ['apple', 'jackfruit', 'Longan'], '002': ['apple', 'watermelon']} 
{'001': ['apple', 'jackfruit', 'Longan'], '002': ['apple', 'watermelon']} 
{'001': ['apple', 'jackfruit', 'Longan'], '002': ['apple', 'watermelon']} 
{'001': ['jackfruit', 'apple', 'Longan'], '002': ['watermelon', 'apple']} 
{'001': ['apple', 'jackfruit', 'Longan'], '002': ['apple', 'watermelon']} 
2.57386991159 # fruit_filter_original 
2.36822144247 # fruit_filter_comprehension 
2.46125930873 # fruit_filter_set_comprehension 
4.09036626702 # fruit_filter_set 
3.76554637862 # fruit_filter_filter 

Die Verständnis basierte Lösung ist die bessere, aber es ist keine sehr signifikante Verbesserung (mit den gegebenen Daten mindestens) im Vergleich zu dem ursprünglichen Code. Die Set-Verständnis-Lösung ist auch eine kleine Verbesserung. Die Lösungen basieren auf Filterfunktion und Differenz gesetzt sind recht langsam ...

Fazit: Wenn Sie Leistung suchen, die Lösungen von Moses Koledoye und juanpa.arrivillaga scheinen besser zu sein. Diese Ergebnisse können jedoch bei größeren Daten abweichen, daher könnte es eine gute Idee sein, den Test mit echten Daten durchzuführen.