Преобразование списка в набор изменяет порядок элементов

В последнее время я заметил , что когда я Конвертирование listв setпорядок элементов изменяются и сортируются по характеру.

Рассмотрим этот пример:

x=[1,2,20,6,210]
print x 
# [1, 2, 20, 6, 210] # the order is same as initial order

set(x)
# set([1, 2, 20, 210, 6]) # in the set(x) output order is sorted

Мои вопросы -

1. Почему это происходит?
2. Как я могу выполнять операции с настройками (особенно с настройкой разницы), не теряя первоначального порядка?

1. A set- это неупорядоченная структура данных, поэтому она не сохраняет порядок вставки.

2. Это зависит от ваших требований. Если у вас есть обычный список, и вы хотите удалить некоторый набор элементов, сохраняя порядок списка, вы можете сделать это с пониманием списка:

   >>> a = [1, 2, 20, 6, 210]
   >>> b = set([6, 20, 1])
   >>> [x for x in a if x not in b]
   [2, 210]

   Если вам нужна структура данных, которая поддерживает как быстрые тесты членства, так и сохранение порядка вставки , вы можете использовать ключи словаря Python, который, начиная с Python 3.7, гарантированно сохраняет порядок вставки:

   >>> a = dict.fromkeys([1, 2, 20, 6, 210])
   >>> b = dict.fromkeys([6, 20, 1])
   >>> dict.fromkeys(x for x in a if x not in b)
   {2: None, 210: None}

   bздесь действительно не нужно заказывать - вы также можете использовать set. Обратите внимание, что a.keys() - b.keys()возвращает установленную разницу как a set, поэтому порядок вставки не сохраняется.

   В старых версиях Python collections.OrderedDictвместо этого можно использовать :

   >>> a = collections.OrderedDict.fromkeys([1, 2, 20, 6, 210])
   >>> b = collections.OrderedDict.fromkeys([6, 20, 1])
   >>> collections.OrderedDict.fromkeys(x for x in a if x not in b)
   OrderedDict([(2, None), (210, None)])

В Python 3.6 set()теперь должен сохраняться порядок, но есть другое решение для Python 2 и 3:

>>> x = [1, 2, 20, 6, 210]
>>> sorted(set(x), key=x.index)
[1, 2, 20, 6, 210]

Отвечая на ваш первый вопрос, набор - это структура данных, оптимизированная для операций с наборами. Как и математический набор, он не обеспечивает и не поддерживает какой-либо конкретный порядок элементов. Абстрактная концепция набора не обеспечивает порядок, поэтому реализация не требуется. Когда вы создаете набор из списка, Python имеет право изменять порядок элементов для нужд внутренней реализации, которую он использует для набора, который может эффективно выполнять операции над наборами.

удалить дубликаты и сохранить порядок с помощью функции ниже

def unique(sequence):
    seen = set()
    return [x for x in sequence if not (x in seen or seen.add(x))]

проверьте эту ссылку

В математике есть множества и упорядоченные множества (oset).

• set : неупорядоченный контейнер уникальных элементов (Реализовано)
• oset : упорядоченный контейнер уникальных элементов (NotImplemented)

В Python напрямую реализованы только наборы. Мы можем эмулировать oset с помощью обычных клавиш dict ( 3.7+ ).

Дано

a = [1, 2, 20, 6, 210, 2, 1]
b = {2, 6}

Код

oset = dict.fromkeys(a).keys()
# dict_keys([1, 2, 20, 6, 210])

Демо

Реплики удаляются, порядок вставки сохраняется.

list(oset)
# [1, 2, 20, 6, 210]

Операции, подобные множеству, над клавишами dict.

oset - b
# {1, 20, 210}

oset | b
# {1, 2, 5, 6, 20, 210}

oset & b
# {2, 6}

oset ^ b
# {1, 5, 20, 210}

подробности

Примечание: неупорядоченная структура не препятствует упорядоченным элементам. Напротив, поддержание порядка не гарантируется. Пример:

assert {1, 2, 3} == {2, 3, 1}                    # sets (order is ignored)

assert [1, 2, 3] != [2, 3, 1]                    # lists (order is guaranteed)

Можно с удовольствием обнаружить, что список и мультимножество (mset) - это еще две увлекательные математические структуры данных:

• список : упорядоченный контейнер элементов, который разрешает репликацию (реализовано)
• mset : неупорядоченный контейнер элементов, разрешающий репликацию (NotImplemented) *

Резюме

Container | Ordered | Unique | Implemented
----------|---------|--------|------------
set       |    n    |    y   |     y
oset      |    y    |    y   |     n
list      |    y    |    n   |     y
mset      |    n    |    n   |     n*  

^{* Мультимножество может быть косвенно эмулировано с collections.Counter()помощью dict-подобного отображения кратностей (счетчиков).}

Как указано в других ответах, наборы - это структуры данных (и математические концепции), которые не сохраняют порядок элементов -

Однако, используя комбинацию наборов и словарей, вы можете добиться того, чего захотите - попробуйте использовать эти фрагменты:

# save the element order in a dict:
x_dict = dict(x,y for y, x in enumerate(my_list) )
x_set = set(my_list)
#perform desired set operations
...
#retrieve ordered list from the set:
new_list = [None] * len(new_set)
for element in new_set:
   new_list[x_dict[element]] = element

Основываясь на ответе Свена, я обнаружил, что с помощью collections.OrderedDict, как так, помог мне выполнить то, что вы хотите, плюс разрешил мне добавить больше элементов в dict:

import collections

x=[1,2,20,6,210]
z=collections.OrderedDict.fromkeys(x)
z
OrderedDict([(1, None), (2, None), (20, None), (6, None), (210, None)])

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

z['nextitem']=None

И вы можете выполнить операцию вроде z.keys () над dict и получить набор:

z.keys()
[1, 2, 20, 6, 210]

Реализация вышеизложенной концепции наивысшего балла, которая возвращает его в список:

def SetOfListInOrder(incominglist):
    from collections import OrderedDict
    outtemp = OrderedDict()
    for item in incominglist:
        outtemp[item] = None
    return(list(outtemp))

Протестировано (кратко) на Python 3.6 и Python 2.7.

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

# initial lists on which you want to do set difference
>>> nums = [1,2,2,3,3,4,4,5]
>>> evens = [2,4,4,6]
>>> evens_set = set(evens)
>>> result = []
>>> for n in nums:
...   if not n in evens_set and not n in result:
...     result.append(n)
... 
>>> result
[1, 3, 5]

Его временная сложность не так хороша, но он аккуратный и легко читаемый.

Интересно, что люди всегда используют «проблему реального мира», чтобы пошутить над определением в теоретической науке.

Если в наборе есть порядок, сначала нужно разобраться со следующими проблемами. Если в вашем списке есть повторяющиеся элементы, в каком порядке вы должны превратить его в набор? В каком порядке мы объединяем два множества? Каков порядок, если мы пересекаем два множества с разным порядком на одних и тех же элементах?

Кроме того, set намного быстрее при поиске определенного ключа, что очень хорошо для работы с наборами (и поэтому вам нужен набор, а не список).

Если вам действительно важен индекс, просто сохраните его в виде списка. Если вы все еще хотите выполнить операцию набора для элементов во многих списках, самый простой способ - создать словарь для каждого списка с одинаковыми ключами в наборе вместе со значением списка, содержащим весь индекс ключа в исходном списке.

def indx_dic(l):
    dic = {}
    for i in range(len(l)):
        if l[i] in dic:
            dic.get(l[i]).append(i)
        else:
            dic[l[i]] = [i]
    return(dic)

a = [1,2,3,4,5,1,3,2]
set_a  = set(a)
dic_a = indx_dic(a)

print(dic_a)
# {1: [0, 5], 2: [1, 7], 3: [2, 6], 4: [3], 5: [4]}
print(set_a)
# {1, 2, 3, 4, 5}

Вот простой способ сделать это:

x=[1,2,20,6,210]
print sorted(set(x))