The non-ordered sorting is slightly faster, since it doesn't store the order of the items. You can clearly tell which one is faster, but I'll explain anyways. Remd is non-ordered sorting, while oremd is ordered sorting. Return self._class_, (OrderedDict(self),) Return '%s(%r)' % (self._class_._name_, OrderedDict(self)) 'Counter that remembers the order elements are first encountered' Now, here are the functions: from collections import OrderedDict, CounterĬlass OrderedCounter(Counter, OrderedDict): Another solution which keeps the order of the items, using a subclass of both OrderedDict and Counter which is named 'OrderedCounter'. I suggest you override this, and changing it to use the hash of an equivalent mutable type (like using hash(tuple(my_list)) if my_list is a list). However, this hash function uses identity for unhashable objects, meaning two equal objects that are both unhashable won't work. Unhashable objects will be treated as if they are hashable.
This should be enough to allow unhashable items in our solution. To allow unhashable keys in Counter, I made a Container class, which will try to get the object's default hash function, but if it fails, it will try its identity function. However, that solution is also limited to hashable keys. There's only one other solution which even has Counter in it.
Most of these answers only remove duplicate items which are hashable, but this question doesn't imply it doesn't just need hashable items, meaning I'll offer some solutions which don't require hashable items.Ĭollections.Counter is a powerful tool in the standard library which could be perfect for this. In this answer, there will be two sections: Two unique solutions, and a graph of speed for specific solutions. list objects), then you will have to use a slow approach in which you will basically have to compare every item with every other item in a nested loop. If you have to deal with items that are not hashable (e.g. This usually means that they have to be immutable. Check out this question for more details and alternative ways to preserve the order when removing duplicates.įinally note that both the set as well as the OrderedDict/ dict solutions require your items to be hashable. If you don’t actually need to preserve the order, you’re often better off using a set, especially because it gives you a lot more operations to work with.
Note that this may have some overhead of creating a dictionary first, and then creating a list from it. Starting with Python 3.7, the built-in dictionary is guaranteed to maintain the insertion order as well, so you can also use that directly if you are on Python 3.7 or later (or CPython 3.6): > list(omkeys(t)) A very common solution for this is to rely on OrderedDict to keep the order of keys during insertion: > from collections import OrderedDict If order is important to you, then you will have to use a different mechanism. When converting a set back to a list, an arbitrary order is created. As mentioned above, sets themselves are unordered collections, so the order is lost. The following example should cover whatever you are trying to do: > t = Īs you can see from the example result, the original order is not maintained. If you later need a real list again, you can similarly pass the set to the list() function. To create a set from any iterable, you can simply pass it to the built-in set() function. Sets are unordered collections of distinct objects. The common approach to get a unique collection of items is to use a set.
0 kommentar(er)
