Python: supprime les doublons de la liste s'ils sont exactement les mêmes, y compris l'ordre des éléments

Ce que vous avez besoin est unique permutations plutôt que de combinaisons:

y = list(set(itertools.permutations(x,3)))

Qui est, (1,2,2) et (2,1,2) sera considéré comme de la même combinaison et un seul d'entre eux sera retourné. Ils sont, cependant, les différentes permutations. Utilisation set() de supprimer les doublons.

Ensuite, si vous voulez trier les éléments au sein de chaque n-uplet et ont également l'ensemble de la liste triée, vous pouvez le faire:

y = [tuple(sorted(q)) for q in y]
y.sort()

Ce sera probablement faire ce que vous voulez, mais c'est vaste overkill. C'est un faible niveau de prototype pour un générateur qui peut être ajouté à itertools un jour. Il est de faible niveau pour faciliter la re-mise en œuvre dans C. Où N est la longueur de l'objet iterable d'entrée, il exige le pire des cas de l'espace O(N) et ne à la plupart des N*(N-1)//2 élément comparaisons, quel que soit le nombre d'anagrammes sont générés. Ces deux sont optimales 😉

Utilisation comme suit:

>>> x = [1,1,1,2,2,2,3,3,3,4,4,5]
>>> for t in anagrams(x, 3):
...     print(t)
(1, 1, 1)
(1, 1, 2)
(1, 1, 3)
(1, 1, 4)
(1, 1, 5)
(1, 2, 1)
...

Il n'y aura pas de doublons dans la sortie. Remarque: c'est Python 3 code. Il a besoin de quelques modifications pour s'exécuter sous Python 2.

import operator
class ENode:
def __init__(self, initial_index=None):
self.indices = [initial_index]
self.current = 0
self.prev = self.next = self
def index(self):
"Return current index."
return self.indices[self.current]
def unlink(self):
"Remove self from list."
self.prev.next = self.next
self.next.prev = self.prev
def insert_after(self, x):
"Insert node x after self."
x.prev = self
x.next = self.next
self.next.prev = x
self.next = x
def advance(self):
"""Advance the current index.
If we're already at the end, remove self from list.
.restore() undoes everything .advance() did."""
assert self.current < len(self.indices)
self.current += 1
if self.current == len(self.indices):
self.unlink()
def restore(self):
"Undo what .advance() did."
assert self.current <= len(self.indices)
if self.current == len(self.indices):
self.prev.insert_after(self)
self.current -= 1
def build_equivalence_classes(items, equal):
ehead = ENode()
for i, elt in enumerate(items):
e = ehead.next
while e is not ehead:
if equal(elt, items[e.indices[0]]):
# Add (index of) elt to this equivalence class.
e.indices.append(i)
break
e = e.next
else:
# elt not equal to anything seen so far:  append
# new equivalence class.
e = ENode(i)
ehead.prev.insert_after(e)
return ehead
def anagrams(iterable, count=None, equal=operator.__eq__):
def perm(i):
if i:
e = ehead.next
assert e is not ehead
while e is not ehead:
result[count - i] = e.index()
e.advance()
yield from perm(i-1)
e.restore()
e = e.next
else:
yield tuple(items[j] for j in result)
items = tuple(iterable)
if count is None:
count = len(items)
if count > len(items):
return
ehead = build_equivalence_classes(items, equal)
result = [None] * count
yield from perm(count)

À l'aide d'un ensemble doit probablement travailler. Un jeu est en fait un conteneur qui ne contient pas d'éléments dupliqués.

Python comprend également un type de données pour ensembles. Un jeu est un non ordonnée
collection sans les éléments en double. Utilisations de base inclut l'adhésion
d'essais et d'éliminer les doublons. Définir des objets également en charge
des opérations mathématiques comme union, intersection, différence, et
symétrique différence.

import itertools
x = [1,1,1,2,2,2,3,3,3,4,4,5]
y = set()
for x in itertools.combinations(x,3):
y.add(x)
print(y)