Что большая часть pythonic пути состоит в том, чтобы гарантировать, что все элементы списка отличаются?

The most popular answers are O(N) (good!-) but, as @Paul and @Mark point out, they require the list's items to be hashable. Both @Paul and @Mark's proposed approaches for unhashable items are general but take O(N squared) -- i.e., a lot.

If your list's items are not hashable but are comparable, you can do better... here's an approach that always work as fast as feasible given the nature of the list's items.

import itertools

def allunique(L):
  # first try sets -- fastest, if all items are hashable
  try:
    return len(L) == len(set(L))
  except TypeError:
    pass
  # next, try sort -- second fastest, if items are comparable
  try:
    L1 = sorted(L)
  except TypeError:
    pass
  else:
    return all(len(list(g))==1 for k, g in itertools.groupby(L1))
  # fall back to the slowest but most general approach
  return all(v not in L[i+1:] for i, L in enumerate(L))

This is O(N) where feasible (all items hashable), O(N log N) as the most frequent fallback (some items unhashable, but all comparable), O(N squared) where inevitable (some items unhashable, e.g. dicts, and some non-comparable, e.g. complex numbers).

Inspiration for this code comes from an old recipe by the great Tim Peters, which differed by actually producing a list of unique items (and also was so far ago that set was not around -- it had to use a dict...!-), but basically faced identical issues.

Как насчет этого:

if len(x) != len(set(x)):
    raise Exception("throw to caller")

Предполагается, что элементы в x хешируемы.

Надеюсь, все элементы в вашей последовательности неизменяемы - в противном случае вы не сможете вызвать set на последовательность.

>>> set( ([1,2], [3,4]) )
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

Если у вас есть изменяемые элементы, вы не сможете их хэшировать, и вам придется многократно проверять список:

def isUnique(lst):
    for i,v in enumerate(lst):
        if v in lst[i+1:]:
            return False
    return True

>>> isUnique( ([1,2], [3,4]) )
True
>>> isUnique( ([1,2], [3,4], [1,2]) )
False

Я бы использовал это:

mylist = [1,2,3,4]
is_unique = all(mylist.count(x) == 1 for x in mylist)

Вы можете обработать список, чтобы создать заведомо уникальную копию:

def make_unique(seq): 
    t = type(seq) 
    seen = set()
    return t(c for c in seq if not (c in seen or seen.add(c)))

Или, если элементы seq не хешируются:

def unique1(seq):
    t = type(seq) 
    seen = [] 
    return t(c for c in seq if not (c in seen or seen.append(c)))

И это сохранит элементы в порядке (без дубликатов, конечно).

По мере создания списка вы можете проверить, существует ли уже значение, например:

if x in y:
     raise Exception("Value %s already in y" % x)
else:
     y.append(x)

Преимущество этого состоит в том, что будет сообщено о конфликтующей переменной.