web-dev-qa-db-fra.com

Trouver la liste la plus longue dans une liste de listes en Python

Il me faut la plus longue liste de listes en Python.

Par exemple:

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

longest([[[1,2,3]]]) renvoie également 3 (la liste intérieure est 3)

longest([[], [3,[4,5],[2,3,4,5,3,3], [7], 5, [1,2,3], [3,4]], [1,2,3,4,5]]) renvoie 7 (la liste [3,[4,5],[2,3,4,5,3,3], [7], 5, [1,2,3], [3,4]] contient 7 éléments)

En ce moment, j'ai ce code, mais il ne fait pas l'affaire avec les deux premiers exemples.

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

Peut-être que la récursivité aidera? Merci!

pythonlist
16
Liis Krevald

Voici une solution récursive pour toute liste de profondeur:

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]))
2
cr1msonB1ade

Version Python 3.3:

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

usage:

>>> 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

Dans Python 2.6+, vous n'avez pas l'instruction yield from (qui a été introduite dans Python 3.3), vous devez donc modifier légèrement le code:

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

En effet, la récursivité peut résoudre ce problème.

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
1
wvdz

Vous pouvez le faire avec la récursivité:

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

(démo en ligne) .

Le code vérifie d’abord si ce is list nous traitons. Si tel est le cas, prenons d’abord la len de la liste. Ensuite, nous effectuons un appel récursif sur ses éléments. Et calculer la valeur maximale longest des éléments. Si le maximum est supérieur à la longueur elle-même. Nous renvoyons ce maximum, sinon nous renvoyons la longueur.

Comme la valeur longest d'une non-liste est égale à zéro, la récursivité s'arrête et nous avons une réponse pour les éléments simples à utiliser dans l'étape inductive.

1
Willem Van Onsem

Ces quelques lignes simples fonctionnent pour moi, ma liste est imbriquée (liste de listes)

#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)
0
FeiLiao

Une autre fonction récursive utilisant map:

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

et itérativement:

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
0
DTing

En utilisant la bibliothèque toolz , vous pouvez le faire comme ceci: 

from toolz.curried import count

def longest(your_list): 
    return max(map(count, your_list))

Une mise en garde: cela ne fonctionne pas si your_list contient des non-itérables. 

0
Mathias Wedeken