¿Cómo encontrar elementos duplicados en una matriz usando for loop en Python?

Tengo una lista con elementos duplicados:

list_a=[1,2,3,5,6,7,5,2] tmp=[] for i in list_a: if tmp.__contains__(i): print i else: tmp.append(i) 

He usado el código anterior para encontrar los elementos duplicados en la list_a . No quiero eliminar los elementos de la lista.

Pero quiero usar para bucle aquí. Normalmente C / C ++ usamos así, supongo:

  for (int i=0;i<=list_a.length;i++) for (int j=i+1;j<=list_a.length;j++) if (list_a[i]==list_a[j]) print list_a[i] 

¿Cómo usamos así en Python?

 for i in list_a: for j in list_a[1:]: .... 

Probé el código anterior. Pero se equivoca de solución No sé cómo boost el valor para j .

Solo para información, en Python 2.7+, podemos usar Counter

 import collections x=[1, 2, 3, 5, 6, 7, 5, 2] >>> x [1, 2, 3, 5, 6, 7, 5, 2] >>> y=collections.Counter(x) >>> y Counter({2: 2, 5: 2, 1: 1, 3: 1, 6: 1, 7: 1}) 

Lista única

 >>> list(y) [1, 2, 3, 5, 6, 7] 

Artículos encontrados más de 1 vez

 >>> [i for i in y if y[i]>1] [2, 5] 

Artículos encontrados solo una vez

 >>> [i for i in y if y[i]==1] [1, 3, 6, 7] 

Use el operador in lugar de llamar __contains__ directamente.

Lo que tienes casi funciona (pero es O (n ** 2)):

 for i in xrange(len(list_a)): for j in xrange(i + 1, len(list_a)): if list_a[i] == list_a[j]: print "duplicate:", list_a[i] 

Pero es mucho más fácil usar un conjunto (aproximadamente O (n) debido a la tabla hash):

 seen = set() for n in list_a: if n in seen: print "duplicate:", n else: seen.add(n) 

O un dictado, si desea rastrear ubicaciones de duplicados (también O (n)):

 import collections items = collections.defaultdict(list) for i, item in enumerate(list_a): items[item].append(i) for item, locs in items.iteritems(): if len(locs) > 1: print "duplicates of", item, "at", locs 

O incluso simplemente detectar un duplicado en algún lugar (también O (n)):

 if len(set(list_a)) != len(list_a): print "duplicate" 

Siempre se podría utilizar una lista de comprensión:

 dups = [x for x in list_a if list_a.count(x) > 1] 

Antes de Python 2.3, use dict ():

 >>> lst = [1, 2, 3, 5, 6, 7, 5, 2] >>> stats = {} >>> for x in lst : # count occurrences of each letter: ... stats[x] = stats.get(x, 0) + 1 >>> print stats {1: 1, 2: 2, 3: 1, 5: 2, 6: 1, 7: 1} # filter letters appearing more than once: >>> duplicates = [dup for (dup, i) in stats.items() if i > 1] >>> print duplicates 

Así que una función:

 def getDuplicates(iterable): """ Take an iterable and return a generator yielding its duplicate items. Items must be hashable. eg : >>> sorted(list(getDuplicates([1, 2, 3, 5, 6, 7, 5, 2]))) [2, 5] """ stats = {} for x in iterable : stats[x] = stats.get(x, 0) + 1 return (dup for (dup, i) in stats.items() if i > 1) 

Con Python 2.3 viene set (), e incluso está integrado después de que:

 def getDuplicates(iterable): """ Take an iterable and return a generator yielding its duplicate items. Items must be hashable. eg : >>> sorted(list(getDuplicates([1, 2, 3, 5, 6, 7, 5, 2]))) [2, 5] """ try: # try using built-in set found = set() except NameError: # fallback on the sets module from sets import Set found = Set() for x in iterable: if x in found : # set is a collection that can't contain duplicate yield x found.add(x) # duplicate won't be added anyway 

Con Python 2.7 y superior, tiene el módulo de collections que proporciona la misma función que el dictado , y podemos hacerlo más corto (y más rápido, probablemente sea C bajo el capó) que la solución 1:

 import collections def getDuplicates(iterable): """ Take an iterable and return a generator yielding its duplicate items. Items must be hashable. eg : >>> sorted(list(getDuplicates([1, 2, 3, 5, 6, 7, 5, 2]))) [2, 5] """ return (dup for (dup, i) in collections.counter(iterable).items() if i > 1) 

Me quedo con la solución 2.

 def get_duplicates(arr): dup_arr = arr[:] for i in set(arr): dup_arr.remove(i) return list(set(dup_arr)) print get_duplicates([1,2,3,5,6,7,5,2]) [2, 5] print get_duplicates([1,2,1,3,4,5,4,4,6,7,8,2]) [1, 2, 4] 

Si está buscando un mapeo uno a uno entre sus bucles nesteds y Python, esto es lo que desea:

 n = len(list_a) for i in range(n): for j in range(i+1, n): if list_a[i] == list_a[j]: print list_a[i] 

El código de arriba no es “Pythonic”. Lo haría algo como esto:

 seen = set() for i in list_a: if i in seen: print i else: seen.add(i) 

Además, no use __contains__ , sino que use in (como anteriormente).

Lo siguiente requiere que los elementos de su lista sean hashable (no solo implementando __eq__ ). Me parece más pythonic usar un valor predeterminado (y tienes el número de repeticiones de forma gratuita):

 colecciones de importación
 l = [1, 2, 4, 1, 3, 3]
 d = collections.defaultdict (int)
 para x en l:
    d [x] + = 1
 imprima [k para k, v en d.iteritems () si v> 1]
 # impresiones [1, 3]

Usando solo itertools, y funciona bien en Python 2.5

 from itertools import groupby list_a = sorted([1, 2, 3, 5, 6, 7, 5, 2]) result = dict([(r, len(list(grp))) for r, grp in groupby(list_a)]) 

Resultado:

 {1: 1, 2: 2, 3: 1, 5: 2, 6: 1, 7: 1} 

Parece que tienes una lista ( list_a ) que puede incluir duplicados, que preferirías mantener como está, y construir una lista de-duplicados tmp basada en list_a. En Python 2.7, puedes lograr esto con una línea:

tmp = list(set(list_a))

La comparación de las longitudes de tmp y list_a en este punto debería aclarar si efectivamente hubo elementos duplicados en list_a . Esto puede ayudar a simplificar las cosas si desea ingresar al bucle para un procesamiento adicional.

Usted podría simplemente “traducir” línea por línea.

c ++

 for (int i=0;i<=list_a.length;i++) for (int j=i+1;j<=list_a.length;j++) if (list_a[i]==list_a[j]) print list_a[i] 

Pitón

 for i in range(0, len(list_a)): for j in range(i + 1, len(list_a)) if list_a[i] == list_a[j]: print list_a[i] 

c ++ para el bucle:

 for(int x = start; x < end; ++x) 

Equivalente de Python:

 for x in range(start, end): 

Sólo rápido y sucio,

 list_a=[1,2,3,5,6,7,5,2] holding_list=[] for x in list_a: if x in holding_list: pass else: holding_list.append(x) print holding_list 

Salida [1, 2, 3, 5, 6, 7]

Utilizando numpy:

 import numpy as np count,value = np.histogram(list_a,bins=np.hstack((np.unique(list_a),np.inf))) print 'duplicate value(s) in list_a: ' + ', '.join([str(v) for v in value[count>1]]) 

En el caso de Python3 y si dos listas

 def removedup(List1,List2): List1_copy = List1[:] for i in List1_copy: if i in List2: List1.remove(i) List1 = [4,5,6,7] List2 = [6,7,8,9] removedup(List1,List2) print (List1) 

Por supuesto, no he hecho pruebas, pero creo que va a ser difícil vencer a los pandas en velocidad:

  pd.DataFrame(list_a, columns=["x"]).groupby('x').size().to_dict() 

Un poco más de implementación en Pythonic (no la más, por supuesto), pero en el espíritu de su código C podría ser:

 for i, elem in enumerate(seq): if elem in seq[i+1:]: print elem 

Edición: sí, imprime los elementos más de una vez si hay más de 2 repeticiones, pero eso es lo que hace también el pseudo código C de la operación.