una - python quitar duplicados

encontrar duplicados en una lista de listas

Question

Estoy usando Python 2.7 y estoy tratando de quitar la duplicación de una lista de listas y combinar los valores de los duplicados.

En este momento tengo:

original_list = [[''a'', 1], [''b'', 1], [''a'', 1], [''b'', 1], [''b'', 2], [''c'', 2], [''b'', 3]]

Quiero hacer coincidir el primer elemento de cada lista anidada y luego agregar los valores del segundo elemento. Quiero terminar con esto (el orden de la lista final no importa):

ideal_output = [[''a'', 2], [''b'', 7], [''c'', 2]]

Hasta ahora tengo un código que me encontrará los valores duplicados en función del primer elemento de cada lista anidada:

for item in original_list:
matches = -1
for x in original_list:
if (item[0] == x[0]):
matches += 1
if matches >= 1:
if item[0] not in duplicates_list:
duplicates_list.append(item[0])

Desde aquí necesito buscar todos los elementos de la lista de duplicados que están en la lista original y sumar los valores, pero no estoy seguro de cuál es la mejor manera de hacerlo.

Answer 1

SOLUCIÓN

Usar collections.Counter . collections.Counter :

from collections import Counter
original_list = [[''a'', 1], [''b'', 1], [''a'', 1], [''b'', 1], [''b'', 2], [''c'', 2], [''b'', 3]]
result = Counter()
for k, v in original_list:
result.update({k:v})
map(list, result.items())
# [[''a'', 2], [''c'', 2], [''b'', 7]]

RECOMENDACIONES

Entonces, muchas respuestas, puntos de vista y votaciones ascendentes. Incluso obtuve mi primera Nice answer de la nada (en los últimos 2 días hice un montón de respuestas por valor de más investigación y esfuerzos). En vista de esto, decidí hacer al menos un rendimiento de soluciones de investigación y prueba con un simple script escrito desde cero. No incluya el código directamente en la respuesta por el tamaño.

Cada función lleva el nombre de su autor y se puede encontrar fácilmente en cuestión. La solución de itertools.groupby ahora es igual a una de Mark Reed y se evalúa en su forma original, thefourtheye2 establece para la solución basada en itertools.groupby .

Cada uno se probó varias veces (muestras), cada muestra a su vez invocó varias iteraciones de funciones. Evalué min, max y desviación estándar para muestras veces.

Aquí vamos, haciendo una prueba de sondeo por 10 veces.

testing: thefourtheye, kroolik2, void, kroolik, alko, reed, visser
10 samples
10 iterations each
author min avg max stddev
reed 0.00000 0.00000 0.00000 0.00000
visser 0.00000 0.00150 0.01500 0.00450
thefourtheye 0.00000 0.00160 0.01600 0.00480
thefourtheye2 0.00000 0.00310 0.01600 0.00620
alko 0.00000 0.00630 0.01600 0.00772
void 0.01500 0.01540 0.01600 0.00049
kroolik2 0.04700 0.06430 0.07800 0.00831
kroolik 0.32800 0.34380 0.37500 0.01716

Observe las dos filas inferiores: en este punto, las soluciones de kroolik se descalificaron, ya que con ellas se realizarán iteraciones razonables de muestras * durante horas. Aquí van las pruebas finales. Yo manualmente agregué el número de votos a favor de ouptut:

testing: thefourtheye, kroolik2, void, kroolik, alko, reed, visser
100 samples
1000 iterations each
author upvotes min avg max stddev
reed [20] 0.06200 0.08174 0.15600 0.01841
thefourtheye [5] 0.06200 0.09971 0.20300 0.01911
visser [6] 0.10900 0.12392 0.23500 0.02263
thefourtheye2 0.25000 0.29674 0.89000 0.07183
alko [11] 0.56200 0.62309 1.04700 0.08438
void [3] 1.50000 1.65480 2.39100 0.18721
kroolik [14] [DSQ]

Answer 2

Muchas buenas respuestas, pero todas usan bastante más código del que usaría para esto, así que aquí está mi opinión, por lo que vale:

totals = {}
for k,v in original_list:
totals[k] = totals.get(k,0) + v
# totals = {''a'': 2, ''c'': 2, ''b'': 7}

Una vez que tenga un dict como ese, a partir de cualquiera de estas respuestas, puede usar items para obtener una lista de tuplas:

totals.items()
# => [(''a'', 2), (''c'', 2), (''b'', 7)]

Y una list mapas a través de las tuplas para obtener una lista de listas:

map(list, totals.items())
# => [[''a'', 2], [''c'', 2], [''b'', 7]]

Y ordena si los quieres en orden:

sorted(map(list, totals.items()))
# => [[''a'', 2], [''b'', 7], [''c'', 2]]

Answer 3

Puede ser que puedas probar esto también,

>>> x = [[1,1],[2,2],[1,1],[2,2],[3,3],[4,4],[4,4]]
>>> z = []
>>> for i in x:
>>> if i not in z:
>>> z.append(i)
>>>
>>> z
[[1, 1], [2, 2], [3, 3], [4, 4]]

Answer 4

Puede usar collections.defaultdict :

original_list = [[''a'', 1], [''b'', 1], [''a'', 1], [''b'', 1], [''b'', 2], [''c'', 2], [''b'', 3]]
import collections
data = collections.defaultdict(list)
for item in original_list:
data[item[0]].append(item[1])
output = {key: sum(values) for key, values in data.items()}
print output
# gives: {''a'': 2, ''c'': 2, ''b'': 7}

Answer 5

Sé que es feo, pero me estaba divirtiendo al tratar de implementarlo en un trazador de líneas 1:

map(list, set(([(x[0], sum([i[1] for i in original_list if i[0]==x[0]])) for x in original_list])))

salida:

[[''a'', 2], [''b'', 7], [''c'', 2]]

Answer 6

Si la orden no importa, puede usar esto

original_list = [[''a'', 1], [''b'', 1], [''a'', 1], [''b'', 1], [''b'', 2], [''c'', 2], [''b'', 3]]
myDict = {}
for first, second in original_list:
myDict[first] = myDict.get(first, 0) + second
result = [[key, value] for key, value in myDict.items()]
print result

O puede usar groupby y el código se convierte en un oneliner

original_list = [[''a'', 1], [''b'', 1], [''a'', 1], [''b'', 1], [''b'', 2], [''c'', 2], [''b'', 3]]
from itertools import groupby
print [[key, sum(item[1] for item in list(group))]
for key, group in groupby(sorted(original_list), lambda x:x[0])]

Salida

[[''a'', 2], [''b'', 7], [''c'', 2]]

Answer 7

>>> from collections import Counter
>>> lst = [[''a'', 1], [''b'', 1], [''a'', 1], [''b'', 1], [''b'', 2], [''c'', 2], [''b'', 3]]
>>> c = Counter(x for x, c in lst for _ in xrange(c))
Counter({''b'': 7, ''a'': 2, ''c'': 2})
>>> map(list, c.iteritems())
[[''a'', 2], [''c'', 2], [''b'', 7]]

O alternativamente, sin repetir cada elemento (a, b) b veces (@hcwhsa):

>>> from collections import Counter
>>> lst = [[''a'', 1], [''b'', 1], [''a'', 1], [''b'', 1], [''b'', 2], [''c'', 2], [''b'', 3]]
>>> c = sum((Counter(**{k:v}) for k, v in lst), Counter())
Counter({''b'': 7, ''a'': 2, ''c'': 2})
>>> map(list, c.iteritems())
[[''a'', 2], [''c'', 2], [''b'', 7]]