Определить, имеют ли 2 списка одинаковые элементы независимо от порядка?

Исходя из вашего примера:

x = ['a', 'b']
y = ['b', 'a']

что элементы списков не будут повторяться (они уникальны), а также могут быть хешируемыми (какими являются строки и другие определенные неизменяемые объекты python), наиболее прямой и эффективный с точки зрения вычислений ответ использует встроенные множества Python (которые семантически подобны математическим наборы, о которых вы, возможно, узнали в школе).

set(x) == set(y) # prefer this if elements are hashable

В случае если элементы являются хэшируемыми, но не уникальными, collections.Counterсемантически также работает как мультимножество, но это намного медленнее :

from collections import Counter
Counter(x) == Counter(y)

Предпочитаю использовать sorted:

sorted(x) == sorted(y) 

если элементы можно заказать. Это объясняет неуникальные или неопределяемые обстоятельства, но это может быть намного медленнее, чем использование наборов.

Эмпирический Эксперимент

Эмпирический эксперимент делает вывод , что следует предпочесть set, то sorted. Выберите только Counterесли вам нужны другие вещи, такие как подсчет или дальнейшее использование в качестве мультимножества.

Первая настройка:

import timeit
import random
from collections import Counter

data = [str(random.randint(0, 100000)) for i in xrange(100)]
data2 = data[:]     # copy the list into a new one

def sets_equal(): 
    return set(data) == set(data2)

def counters_equal(): 
    return Counter(data) == Counter(data2)

def sorted_lists_equal(): 
    return sorted(data) == sorted(data2)

И тестирование:

>>> min(timeit.repeat(sets_equal))
13.976069927215576
>>> min(timeit.repeat(counters_equal))
73.17287588119507
>>> min(timeit.repeat(sorted_lists_equal))
36.177085876464844

Итак, мы видим, что сравнение наборов - самое быстрое решение, а сравнение отсортированных списков - второе по быстродействию.

Это, кажется, работает, хотя возможно громоздко для больших списков.

>>> A = [0, 1]
>>> B = [1, 0]
>>> C = [0, 2]
>>> not sum([not i in A for i in B])
True
>>> not sum([not i in A for i in C])
False
>>> 

Однако, если каждый список должен содержать все элементы другого, приведенный выше код является проблематичным.

>>> A = [0, 1, 2]
>>> not sum([not i in A for i in B])
True

Проблема возникает, когда len(A) != len(B)и, в этом примере len(A) > len(B),. Чтобы избежать этого, вы можете добавить еще одно утверждение.

>>> not sum([not i in A for i in B]) if len(A) == len(B) else False
False

Еще одна вещь, я сравнил свое решение с timeit.repeat при тех же условиях, которые использовал Аарон Холл в своем посте. Как и предполагалось, результаты разочаровывают. Мой метод последний. set(x) == set(y)это.

>>> def foocomprehend(): return not sum([not i in data for i in data2])
>>> min(timeit.repeat('fooset()', 'from __main__ import fooset, foocount, foocomprehend'))
25.2893661496
>>> min(timeit.repeat('foosort()', 'from __main__ import fooset, foocount, foocomprehend'))
94.3974742993
>>> min(timeit.repeat('foocomprehend()', 'from __main__ import fooset, foocount, foocomprehend'))
187.224562545

Как упомянуто в комментариях выше, общий случай - боль. Это довольно легко, если все элементы можно хэшировать или все элементы можно сортировать. Однако недавно мне пришлось попытаться раскрыть общий случай. Вот мое решение. После публикации я понял, что это дубликат вышеупомянутого решения, которое я пропустил при первом проходе. В любом случае, если вы используете слайсы, а не list.remove (), вы можете сравнить неизменяемые последовательности.

def sequences_contain_same_items(a, b):
    for item in a:
        try:
            i = b.index(item)
        except ValueError:
            return False
        b = b[:i] + b[i+1:]
    return not b