J'ai une liste avec des éléments en double:
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)
J'ai utilisé le code ci-dessus pour trouver les éléments en double dans le list_a
. Je ne veux pas supprimer les éléments de la liste.
Mais je veux utiliser pour la boucle ici . Normalement, nous utilisons le C/C++ comme ceci:
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]
comment on utilise comme ça en Python?
for i in list_a:
for j in list_a[1:]:
....
J'ai essayé le code ci-dessus. Mais la solution se trompe. Je ne sais pas comment augmenter la valeur de j
.
Juste pour information, en python 2.7+, nous pouvons utiliser 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})
Liste unique
>>> list(y)
[1, 2, 3, 5, 6, 7]
Articles trouvés plus d'une fois
>>> [i for i in y if y[i]>1]
[2, 5]
Articles trouvés une seule fois
>>> [i for i in y if y[i]==1]
[1, 3, 6, 7]
Utilisez l'opérateur in
au lieu d'appeler directement __contains__
.
Ce que vous avez presque fonctionne (mais est 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]
Mais il est beaucoup plus facile d’utiliser un ensemble (à peu près O(n) en raison de la table de hachage):
seen = set()
for n in list_a:
if n in seen:
print "duplicate:", n
else:
seen.add(n)
Ou un dict, si vous voulez suivre les emplacements des doublons (également 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
Ou même simplement détecter un duplicata quelque part (aussi O (n)):
if len(set(list_a)) != len(list_a):
print "duplicate"
Vous pouvez toujours utiliser une compréhension de liste:
dups = [x for x in list_a if list_a.count(x) > 1]
Avant Python 2.3, utilisez 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
Donc une fonction:
def getDuplicates(iterable):
"""
Take an iterable and return a generator yielding its duplicate items.
Items must be hashable.
e.g :
>>> 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)
Avec Python 2.3 vient set (), et il est même intégré après que:
def getDuplicates(iterable):
"""
Take an iterable and return a generator yielding its duplicate items.
Items must be hashable.
e.g :
>>> 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
Avec Python 2.7 et les versions ultérieures, vous avez le modulecollections
qui remplit la même fonction que celui de dict , et nous pouvons le rendre plus court (et plus rapide, c probablement sous le capot) que la solution 1:
import collections
def getDuplicates(iterable):
"""
Take an iterable and return a generator yielding its duplicate items.
Items must be hashable.
e.g :
>>> 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)
Je resterais avec la solution 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 vous recherchez un mappage personnalisé entre vos boucles imbriquées et Python, voici ce que vous souhaitez:
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]
Le code ci-dessus n'est pas "Pythonic". Je le ferais quelque chose comme ça:
seen = set()
for i in list_a:
if i in seen:
print i
else:
seen.add(i)
De même, n'utilisez pas __contains__
, utilisez plutôt in
(comme ci-dessus).
Utiliser uniquement itertools et fonctionne bien sur 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)])
Résultat:
{1: 1, 2: 2, 3: 1, 5: 2, 6: 1, 7: 1}
Ce qui suit nécessite que les éléments de votre liste soient hashable (pas seulement en implémentant __eq__
) . Je trouve plus Pythonic d'utiliser un defaultdict (et vous avez le nombre de répétitions gratuitement):
importer des collections l = [1, 2, 4, 1, 3, 3] d = collections.defaultdict (int) pour x dans l: d [x] + = 1 print [k pour k, v dans d.iteritems () si v> 1] # imprime [1, 3]
En utilisant 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]])
Certes, je n'ai pas fait de tests, mais je suppose qu'il sera difficile de battre les pandas en vitesse:
pd.DataFrame(list_a, columns=["x"]).groupby('x').size().to_dict()
Juste rapide et sale,
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
Vous pouvez simplement "traduire" ligne par ligne.
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]
Python
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 ++ pour la boucle:
for(int x = start; x < end; ++x)
Équivalent Python:
for x in range(start, end):
En cas de Python3 et si vous deux listes
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)