Encontrar la lista más larga en una lista de listas en Python

Tengo que encontrar la lista más larga de listas en Python.

Por ejemplo:

longest([1,2,3]) devuelve 3

longest([[[1,2,3]]]) también devuelve 3 (la lista interna es 3)

longest([[], [3,[4,5],[2,3,4,5,3,3], [7], 5, [1,2,3], [3,4]], [1,2,3,4,5]]) devuelve 7 (lista [3,[4,5],[2,3,4,5,3,3], [7], 5, [1,2,3], [3,4]] contiene 7 elementos)

Ahora mismo tengo este código, pero no funciona con los dos primeros ejemplos.

 def longest(list1): longest_list = max(len(elem) for elem in list1) return longest_list 

Tal vez la recursión ayude? ¡Gracias!

Aquí hay una solución recursiva para cualquier lista de profundidad:

 def longest(l): if(not isinstance(l, list)): return(0) return(max([len(l),] + [len(subl) for subl in l if isinstance(subl, list)] + [longest(subl) for subl in l])) 

Versión de Python 3.3:

 def lengths(x): if isinstance(x,list): yield len(x) for y in x: yield from lengths(y) 

uso:

 >>> l = [[], [3,[4,5],[2,3,4,5,3,3], [7], 5, [1,2,3], [3,4]], [1,2,3,4,5]] >>> max(lengths(l)) 7 

En Python 2.6+ no tienes el yield from statement (se introdujo en Python 3.3), así que tienes que cambiar el código ligeramente:

 def lengths(x): if isinstance(x,list): yield len(x) for y in x: for z in lengths(y): yield z 

De hecho, la recursión puede resolver esto.

 def longest(lst): if type(lst) is not list: return 0 max = len(lst) for i in lst: max_i = longest(i) if max_i > max: max = max_i return max 

Puedes hacer esto con recursión:

 def longest(list1) : l = 0 if type(list1) is list : l = len(list1) if l > 0 : l = max(l,max(longest(elem) for elem in list1)) return l 

(demostración en línea) .

El código primero comprueba si esta is list que estamos tratando. Si es así, primero tomamos el len de la lista. A continuación realizamos una llamada recursiva sobre sus elementos. Y calcula el máximo longest de los elementos. Si el máximo es mayor que la longitud misma. Devolvemos ese máximo, de lo contrario devolvemos la longitud.

Debido a que el valor longest de una lista no es cero, la recursión se detendrá y tenemos una respuesta para los elementos individuales que se utilizarán en el paso inductivo.

Otra función recursiva usando el mapa:

 def longest(a): return max(len(a), *map(longest, a)) if isinstance(a, list) and a else 0 

 In [2]: longest([1,2,3]) Out[2]: 3 In [3]: longest([[[1,2,3]]]) Out[3]: 3 In [4]: longest([[], [3,[4,5],[2,3,4,5,3,3], [7], 5, [1,2,3], [3,4]], [1,2,3,4,5]]) Out[4]: 7 

e iterativamente:

 def longest(a): mx = 0 stack = [a[:]] while stack: cur = stack.pop() if isinstance(cur, list): mx = max(mx, len(cur)) stack += cur return mx 

 In [6]: longest([1,2,3]) Out[6]: 3 In [7]: longest([[[1,2,3]]]) Out[7]: 3 In [8]: longest([[], [3,[4,5],[2,3,4,5,3,3], [7], 5, [1,2,3], [3,4]], [1,2,3,4,5]]) Out[8]: 7 

Estas simples líneas me funcionan, mi lista es una anidada (lista de listas)

 #define the function# def find_max_list(list): list_len = [len(i) for i in list] print(max(list_len)) #print output# find_max_list(your_list) 

Usando la biblioteca de herramientas , esto se puede lograr de la siguiente manera:

 from toolz.curried import count def longest(your_list): return max(map(count, your_list)) 

Una advertencia: esto no funciona si your_list contiene no iterables.