将相同的列表元素放在一起

Question

Is this an alright way to bring equal elements together (make them appear consecutively in the list)?

>>> a = [2, 7, 1, 8, 2, 8, 1, 8, 2, 8]
>>> for x in reversed(a):
        a.remove(x)
        a.append(x)

>>> a
[8, 8, 8, 8, 2, 2, 2, 1, 1, 7]

Edit: List where it allegedly doesn't work (see comments):

>>> a = [2, 7, 1, 1, 8, 2, 8, 1, 8, 2, 8]
>>> for x in reversed(a):
        a.remove(x)
        a.append(x)

>>> a
[8, 8, 8, 8, 2, 2, 2, 1, 1, 1, 7]

Answer 1

Just use list.sort :

a = [2, 7, 1, 8, 2, 8, 1, 8, 2, 8]
a.sort()
print(a)

Output:

[1, 1, 2, 2, 2, 7, 8, 8, 8, 8]

If u want it in descending order, then pass reverse = True to list.sort :

a = [2, 7, 1, 8, 2, 8, 1, 8, 2, 8]
a.sort(reverse = True)
print(a)

Output:

[8, 8, 8, 8, 7, 2, 2, 2, 1, 1]

Answer 2

Another solution, giving no guarantee on the order of the output, but that is O(n) instead O(n*log(n)) for the solution using sort: count the values, and create a new list with the corresponding counts for each value:

from collections import Counter

a = [2, 7, 1, 8, 2, 8, 1, 8, 2, 8]

counts = Counter(a)
out = []
for value, count in counts.items():
    out.extend([value]*count)
    
print(out)
# [2, 2, 2, 7, 1, 1, 8, 8, 8, 8]

---

As suggested by @Manuel, there is a Counter method that I had never noticed, Counter.elements() :

Return an iterator over elements repeating each as many times as its count. Elements are returned in the order first encountered

So, to get an output in original order, and in O(n), the code would be simply:

from collections import Counter

a = [2, 7, 1, 8, 2, 8, 1, 8, 2, 8]

out = list(Counter(a).elements())

print(out)
# [2, 2, 2, 7, 1, 1, 8, 8, 8, 8]

Answer 3

Why/how it works, and about this possibly being an undefined implementation detail:

The iterator starts at the end :

                             iterator
                                ↓
a = [2, 7, 1, 8, 2, 8, 1, 8, 2, 8]
x = undefined

Then the for loop asks the iterator for an item. After getting the last 8, the iterator decreases its index into the list and returns the 8 ( code ), which the for loop stores in x . So now we have:

                             ↓
a = [2, 7, 1, 8, 2, 8, 1, 8, 2, 8]
x = 8

Then a.remove(x) removes the first 8, which shifts all later items to the left:

                             ↓
a = [2, 7, 1, 2, 8, 1, 8, 2, 8]
x = 8

And a.append(x) appends it at the end:

                             ↓
a = [2, 7, 1, 2, 8, 1, 8, 2, 8, 8]
x = 8

Then the for loop gets the next item from the iterator, which is the same 8 as before, only at the lower index:

                          ↓
a = [2, 7, 1, 2, 8, 1, 8, 2, 8, 8]
x = 8 (same one again)

The remove again removes the first 8 (which was originally the second 8):

                          ↓
a = [2, 7, 1, 2, 1, 8, 2, 8, 8]

And it gets appended:

                          ↓
a = [2, 7, 1, 2, 1, 8, 2, 8, 8, 8]

The next round moves the originally third 8 to the end:

                       ↓
a = [2, 7, 1, 2, 1, 2, 8, 8, 8, 8]

And then finally the originally fourth 8 (which we've been finding over and over again) moves as well:

                    ↓
a = [2, 7, 1, 2, 1, 2, 8, 8, 8, 8]

The same then happens to the 2's, 1's and the 7, so we end up with:

a = [8, 8, 8, 8, 2, 2, 2, 1, 1, 7]

JBernardo commented that it "could be undefined behavior on a different python implementation" . I guess it could be, but I'd blame that implementation. The Python reference documentation notes (although about the forward iterator):

There is a subtlety when the sequence is being modified by the loop (this can only occur for mutable sequences, eg lists). An internal counter is used to keep track of which item is used next, and this is incremented on each iteration. When this counter has reached the length of the sequence the loop terminates. This means that if the suite deletes the current (or a previous) item from the sequence, the next item will be skipped (since it gets the index of the current item which has already been treated). Likewise, if the suite inserts an item in the sequence before the current item, the current item will be treated again the next time through the loop.

And that's not marked as a CPython implementation detail, which the Python documentation does at plenty of other places: 261 results for googling site:docs.python.org/3/ "CPython implementation detail"