Comment puis-je obtenir le nombre total d'éléments dans mon arbitrairement imbriquée liste de listes?

J'ai une liste affectée à la variable my_list. La valeur de my_list est [[1,2,3],[3,5,[2,3]], [[3,2],[5,[4]]]]. J'ai besoin de trouver la longueur de my_list, mais len(my_list) ne renvoie 3. Je le veux de retour 11. Est-il de fonctions Python qui permettra de rétablir la pleine longueur de my_list listes imbriquées et tous.

Exemple:

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

Output
11

Je voudrais, si cela a fonctionné pour pas seulement des nombres, mais des chaînes aussi.

Il devrait être une règle. Combien de "imbriquées" nous sommes talkin?
Donc, c'est votre liste? Ne peut pas être changer avec un autre listes imbriquées?
Voulez-vous que cela fonctionne avec des listes imbriquées qui peuvent contenir des chaînes, ou de faire les listes contiennent uniquement des chiffres?
Votre question est un peu trompeur, "trouver la longueur de toutes les listes imbriquées?"
Voici une belle fonction pour aplatir arbitraire des listes imbriquées: stackoverflow.com/a/2158532/4014959 . L'utiliser pour aplatir votre liste imbriquée, alors vous avez juste besoin de la len() de la liste aplatie.

OriginalL'auteur michaelpri | 2015-01-04

16

Cette fonction compte la longueur d'une liste, le comptage d'autre objet que la liste de longueur 1, et recursing sur les éléments de la liste pour trouver le aplatie longueur, et fonctionne avec n'importe quel degré d'imbrication les interprètes de pile maximum de profondeur.
```
def recursive_len(item):
    if type(item) == list:
        return sum(recursive_len(subitem) for subitem in item)
    else:
        return 1
```
Remarque: en fonction de la façon dont il sera utilisé, il peut être préférable de vérifier si l'élément est itératif plutôt que de vérifier si elle a le type list, afin de juger correctement de la taille de n-uplets, etc. Cependant, de vérifier si l'objet est itératif aura pour effet de bord de comptage de chaque caractère dans une chaîne, plutôt que de donner la longueur de la chaîne 1, qui peut être indésirable.

Vous devez modifier que if type(item) == list or type(item) == tuple or type(item)==dict etc.
if isinstance(item, collections.Iterable) and not isinstance(item,basestring):
Vous pouvez également passer d'un n-uplet de issinstance if isinstance(item, (list,tuple))

OriginalL'auteur stonesam92
5

Comme alternative, vous pouvez utiliser aplatir avec len:
```
from compiler.ast import flatten

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

len(flatten(my_list))
11
```
PS. merci pour @thefourtheye de pointage, s'il vous plaît note:

Obsolète depuis la version 2.6: Le compilateur paquet a été supprimé en Python 3.

Des solutions Alternatives peuvent être trouvées ici: Python 3 remplacement déprécié compilateur.ast aplatir la fonction

compiler.ast.flatten est obsolète depuis longtemps de retour.
Je suis toujours sur Python 2, mais oui c'est un argument valable

OriginalL'auteur Anzel
4

hack solution, quelqu'un a dû le poster. Convertir liste de chaîne de caractères (quitter le levage lourd /récursivité à __str__ opérateur) puis de compter les virgules, ajouter 1.
```
>>> my_list = [[1,2,3],[3,5,[2,3]], [[3,2],[5,[4]]]]
>>> str(my_list).count(",")+1
11
```
(pour les entiers & flotteurs, bien sûr échoue avec des cordes, car ils peuvent contenir des virgules)

EDIT: ce hack ne tient pas compte de vide listes: nous avons pour supprimer [] éléments:
```
>>> my_list = [[1,2,3],[3,5,[2,3]], [[3,2],[5,[4],[]]]]  # added empty list at the end
>>> s = str(my_list)
>>> s.count(",")-s.count("[]")+1   # still 11
```
Attention cependant, il semble qu'il compte vide listes comme un élément afin de [] et [1] sont comptés.
c'est vrai. Pas très fiable, sauf si vous supprimez le comte de [] édité. thx

OriginalL'auteur Jean-François Fabre
2

Vous êtes essentiellement la recherche d'un moyen de calculer le nombre de feuilles dans un arbre.
```
 def is_leaf(tree):
        return type(tree) != list

def count_leaves(tree):
    if is_leaf(tree):
        return 1
    else:
        branch_counts = [count_leaves(b) for b in tree]
        return sum(branch_counts)
```
La count_leaves fonction compte le nombre de feuilles dans un arbre par récursive de calcul de la branch_counts des branches, puis en additionnant les résultats. Le cas de base, c'est quand l'arbre est une feuille, qui est un arbre avec 1 feuille de laurier. Le nombre de feuilles différente de la longueur de l'arbre, qui est le nombre de ses branches.

OriginalL'auteur Jobs

C'est une solution alternative, qui pourrait ne pas être si performant, puisqu'il remplit une nouvelle liste aplatie, qui est retourné à la fin:

def flatten_list(ls, flattened_list=[]):
    for elem in ls:
        if not isinstance(elem, list): 
            flattened_list.append(elem)
        else:
            flatten_list(elem, flattened_list)
    return flattened_list

flatten_list intuitivement aplatit la liste, et ensuite, vous pouvez calculer la longueur de la nouvelle retourné aplatie liste avec les len() fonction:

len(flatten_list(my_list))

OriginalL'auteur nbro

Voici mon oeuvre:

def nestedList(check):
    returnValue = 0
    for i in xrange(0, len(check)):
        if(isinstance(check[i], list)):
            returnValue += nestedList(check[i])
        else:
            returnValue += 1
    return returnValue

OriginalL'auteur ProgrammingIsAwsome

Vous devez vous connecter pour publier un commentaire.