如何在Python中为列表分配序号的唯一值？

Question

Suppose I have a list

A = ['A', 'A', 'A', 'B', 'B', 'C']

How to turn it to

B = [0, 0, 0, 1, 1, 2]

?

I wrote this way

C = {t[1]:t[0] for t in enumerate(list(set(A)))}
B = [C[e] for e in A]

and it gave

[1, 1, 1, 2, 2, 0]

ie the order appeared random and also the entire code looks complex.

Is there any simpler way?

Answer 1

You can try something nasty (albeit much more understandable than your current code) like:

>>> B = [ord(x) - 65 for x in A]
>>> B
[0, 0, 0, 1, 1, 2]

If A is a big list, consider letting B be a generator, like so:

B = (ord(x) - 65 for x in A)

Answer 2

a = ['A', 'A', 'A', 'B', 'B', 'C']
x = sorted(set(a))
b = [x.index(y) for y in a]
print(b)
[0, 0, 0, 1, 1, 2]

Answer 3

Do you want the order to be determined by the alphabetical order of the unique element, or the order in which they first appear in the original list? For instance, should ['C', 'A', 'A', 'A', 'B', 'B', 'C'] turn into [2,0,0,0,1,1,2], or [0,1,1,1,2,2,0]? If the former:

uniques = list(set(A))
uniques.sort()
uniques_dict = {uniques[i]:i for i in range(len(uniques))}
B = [uniques_dict[a] for a in A]

for the latter:

uniques_dict = {}
ordinal = 0
for a in A:
  if not (a in uniques_dict.keys):
     uniques_dict[a] = ordinal
     ordinal = ordinal+1
B = [uniques_dict[a] for a in A]

Answer 4

Seems constructing a dictionary/mapping is the key, using it will just be variations on a theme. Even constructing the dictionary will be variations on a theme - whether it is better/worse/simple/complicated is in the eyes of the reader.

>>> import itertools
>>> ordinatates = itertools.count(0)
>>> a = ['a', 'b', 'c', 'a', 'a', 'c', 'c']
>>> unique = sorted(set(a))
>>> d = {thing:ordinal for thing, ordinal in zip(unique, ordinates)}

Apply it

>>> list(map(d.get, a))
[0, 1, 2, 0, 0, 2, 2]
>>>

It will throw a KeyException if there are items in a that are not in d .

similar, same caveat:

>>> import operator
>>> a = ['a','b','c', 'a', 'a', 'c','c']
>>> m = map(operator.itemgetter, a)
>>> [get(d) for get in m]
[0, 1, 2, 0, 0, 2, 2]
>>>

Similar without the caveat

class Foo(dict):
    def __call__(self, item):
        '''Returns self[item] or None.'''
        try:
            return self[item]
        except KeyError as e:
            # print or log something descriptive - print(repr(e))
            return None

>>> ordinates = itertools.count(0)
>>> a = ['a','b','c', 'a', 'a', 'c','c']
>>> unique = sorted(set(a))
>>> d = Foo((thing,ordinal) for thing, ordinal in zip(unique, ordinates))
>>> result = list(map(d, a))
>>> result
[0, 1, 2, 0, 0, 2, 2]
>>>

---

All that assumed you wanted the ordinal positions of the sorted items - as your example list was conveniently pre -sorted. If you were looking for the position in the list where a unique thing first occurred, construct the mapping like this:

import itertools
ordinal = itertools.count()
b = ['c','b','c', 'a', 'a', 'c','c']
d = {}
for thing in b:
    if thing in d:
        continue
    d[thing] = next(ordinal)

Application

>>> list(map(d.get, b))
[0, 1, 0, 2, 2, 0, 0]
>>>

@Abdou alluded to this in his comment but you conveniently didn't answer.

If you have a one-liner fetish that can be written as

d = {}
d.update((thing,d[thing] if thing in d else next(ordinal)) for thing in b)

Answer 5

I will assume that: 1. you don't rely on elements being letters; 2. you want to index them on the base on the first appearence in the list A .

>>> A = ['A', 'A', 'A', 'B', 'B', 'C']
>>> seen=set()
>>> C={x:len(seen)-1 for x in A if not (x in seen or seen.add(x))}
>>> C
{'B': 1, 'C': 2, 'A': 0}
>>> list(map(C.get, A))
[0, 0, 0, 1, 1, 2]

The second line defines a set, seen , which will store the elements of A we have already seen in the list comprehension of the next line.

The third line defines the dictioanry that will map unique elements to their indices. It's a little tricky (although not so unusual).

We iterate through the values of A .

• Case 1: the value x is in seen, thus x in seen or ... is True , the second part is not evaluated, and not(...) returns False : x is ignored.

• Case 2: the value x is not in seen, thus x in seen is False and the second part is evaluated. Remind that seen.add will always return None , which is equivalent to False in this context. x in seen or seen.add(x) is False , but x has been added to seen . And not(...) returns True : x is mapped to the len of seen , which is incremented by one for each new element.

The sixth line simply maps the newly defined dictionary to the values of A .