Python-Encuentra los mismos valores en una lista y agrupa una nueva lista

duplicates append

Question

Estoy atascado al resolver esto y me pregunto si alguien podría señalarme en la dirección correcta ...

De esta lista:

N = [1,2,2,3,3,3,4,4,4,4,5,5,5,5,5]

Estoy tratando de crear:

L = [[1],[2,2],[3,3,3],[4,4,4,4],[5,5,5,5,5]]

Cualquier valor que se encuentre que es el mismo se agrupa en su propia lista secundaria. Aquí está mi intento hasta ahora, ¿estoy pensando que debería usar un bucle while?

global n

n = [1,2,2,3,3,3,4,4,4,4,5,5,5,5,5] #Sorted list
l = [] #Empty list to append values to

def compare(val):
   """ This function receives index values
   from the n list (n[0] etc) """

   global valin
   valin = val

   global count
   count = 0

    for i in xrange(len(n)):
        if valin == n[count]: # If the input value i.e. n[x] == n[iteration]
            temp = valin, n[count]
             l.append(temp) #append the values to a new list
             count +=1
        else:
          count +=1


for x in xrange (len(n)):
    compare(n[x]) #pass the n[x] to compare function

Answer 1

Alguien menciona para N=[1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 1] obtendrá [[1], [2, 2], [3, 3, 3], [4, 4, 4, 4], [5, 5, 5, 5, 5], [1]]

En otras palabras, cuando los números de la lista no están en orden o es una lista de desorden, no está disponible.

Así que tengo mejor respuesta para resolver este problema.

from collections import Counter

N = [1,2,2,3,3,3,4,4,4,4,5,5,5,5,5]
C = Counter(N)

print [ [k,]*v for k,v in C.items()]

Answer 2

Estás supercomplicando esto.

Lo que desea hacer es: para cada valor, si es el mismo que el último valor, simplemente agréguelo a la lista de los últimos valores; de lo contrario, crea una nueva lista. Puedes traducir ese inglés directamente a Python:

new_list = []
for value in old_list:
    if new_list and new_list[-1][0] == value:
        new_list[-1].append(value)
    else:
        new_list.append([value])

Incluso hay formas más simples de hacerlo si está dispuesto a ser un poco más abstracto, por ejemplo, mediante el uso de las funciones de agrupación en itertools . Pero esto debería ser fácil de entender.

Si realmente necesita hacer esto con un bucle while, puede convertir cualquier bucle for en un bucle while como este:

for value in iterable:
    do_stuff(value)

iterator = iter(iterable)
while True:
    try:
        value = next(iterator)
    except StopIteration:
        break
    do_stuff(value)

O, si sabe que lo iterable es una secuencia, puede usar un bucle while más simple:

index = 0
while index < len(sequence):
    value = sequence[index]
    do_stuff(value)
    index += 1

Pero ambos hacen que su código sea menos legible, menos pitónico, más complicado, menos eficiente, más fácil de equivocarse, etc.

Answer 3

Mantener la calma y usar itertools.groupby :

from itertools import groupby

N = [1,2,2,3,3,3,4,4,4,4,5,5,5,5,5]

print([list(j) for i, j in groupby(N)])

Salida:

[[1], [2, 2], [3, 3, 3], [4, 4, 4, 4], [5, 5, 5, 5, 5]]

Nota al margen: Evite el uso de la variable global cuando no lo necesite .

Answer 4

Otra solución ligeramente diferente que no depende de itertools:

#!/usr/bin/env python

def group(items):
    """
    groups a sorted list of integers into sublists based on the integer key
    """
    if len(items) == 0:
        return []

    grouped_items = []
    prev_item, rest_items = items[0], items[1:]

    subgroup = [prev_item]
    for item in rest_items:
        if item != prev_item:
            grouped_items.append(subgroup)
            subgroup = []
        subgroup.append(item)
        prev_item = item

    grouped_items.append(subgroup)
    return grouped_items

print group([1,2,2,3,3,3,4,4,4,4,5,5,5,5,5])
# [[1], [2, 2], [3, 3, 3], [4, 4, 4, 4], [5, 5, 5, 5, 5]]

Answer 5

Puede usar itertools.groupby junto con una lista de comprensión

>>> l =  [1,2,2,3,3,3,4,4,4,4,5,5,5,5,5]
>>> [list(v) for k,v in itertools.groupby(l)]
[[1], [2, 2], [3, 3, 3], [4, 4, 4, 4], [5, 5, 5, 5, 5]]

Esto se puede asignar a la variable L como en

L = [list(v) for k,v in itertools.groupby(l)]

Answer 6

Puedes hacerlo usando numpy también:

import numpy as np

N = np.array([1,2,2,3,3,3,4,4,4,4,5,5,5,5,5])
counter = np.arange(1, np.alen(N))
L = np.split(N, counter[N[1:]!=N[:-1]])

La ventaja de este método es que cuando tiene otra lista relacionada con N y desea dividirla de la misma manera.