Le comptage de la profondeur ou le niveau le plus profond, une liste imbriquée va à

Un ont un réel problème (et un mal de tête) avec une mission...

Je suis dans un cours d'introduction à la programmation de la classe, et je dois écrire une fonction qui, étant donné une liste, sera de retour le "maximum" de profondeur, il va à la...
Par exemple: [1,2,3] retourne 1, [1,[2,3]] sera de retour le 2...

J'ai écrit ce morceau de code (c'est le meilleur que j'ai pu obtenir T_T)

def flat(l):
    count=0
    for item in l:
        if isinstance(item,list):
            count+= flat(item)
    return count+1

Cependant, Il est évident qu'elle se complique pas fonctionner comme il se doit, parce que si il y a des listes qui ne comptent pas pour le maximum de profondeur, il soulève encore le compteur...

Par exemple: lorsque j'utilise la fonction avec [1,2,[3,4],5,[6],7] il doit retourner 2, mais il renvoie 3...

Des idées ou de l'aide serait grandement appréciée ^^ merci beaucoup!! J'ai été strugling avec ce depuis des semaines...

  • Je pense que le mot que vous voulez, c'est la "profondeur", pas de "profondeur".
  • Comme une note de côté: découvrez la PEP-8. Ça va être bon pour former les habitudes tout de suite. Pour commencer, utilisez L pour une liste, pas l (qui ressemble à 1).
  • Merci ^^ mon mal, je suppose que c'est assez clair que l'anglais n'est pas ma langue première 🙂
  • C'est vraiment intéressant ^^ merci! Je ne savais pas que l'existence même d'un...
  • +1 pour la prise clair que ce sont les devoirs et ensuite de poser la question de manière appropriée. La question est à la fois intéressant, et montre ce qui a été tenté jusqu'à présent.
InformationsquelleAutor dhcarmona | 2011-05-18
  1. 5

    En largeur d'abord, sans la récursivité, et il travaille également avec d'autres types de séquences:

    from collections import Sequence
from itertools import chain, count

def depth(seq):
    for level in count():
        if not seq:
            return level
        seq = list(chain.from_iterable(s for s in seq if isinstance(s, Sequence)))

    La même idée, mais avec beaucoup moins de consommation de mémoire:

    from collections import Sequence
from itertools import chain, count

def depth(seq):
    seq = iter(seq)
    try:
        for level in count():
            seq = chain([next(seq)], seq)
            seq = chain.from_iterable(s for s in seq if isinstance(s, Sequence))
    except StopIteration:
        return level
    • cela permettra de rompre sur une séquence avec des chaînes. par exemple, depth(["a"]) va casser
    • simplement étendre le troisième de la dernière ligne comme seq = chain.from_iterable(s for s in seq if isinstance(s, Sequence) and not isinstance(s, str)) et il travaillera également avec des éléments de chaîne
    InformationsquelleAutor pillmuncher
  2. 27

    Ici est une façon d'écrire la fonction

    depth = lambda L: isinstance(L, list) and max(map(depth, L))+1

    Je pense que l'idée vous manque, c'est d'utiliser max()

    • Merci ^^ j'aime la façon dont vous les gars seront en mesure de simplifier chaque fonction à l'aide de lambda ^^ j'espère pouvoir le faire un jour.
    • Cela rompt sur vide listes, juste pour info
    InformationsquelleAutor John La Rooy
  3. 12

    Nous allons tout d'abord reformuler vos exigences légèrement.

    La profondeur d'une liste est un de plus que la profondeur maximale de ses sous-listes.

    Maintenant, cela peut être traduits directement à code:

    def depth(l):
    if isinstance(l, list):
        return 1 + max(depth(item) for item in l)
    else:
        return 0
    • Je vous remercie beaucoup! Yep, j'ai oublié de le max() fonction...
    • Le code doit être corrigée pour vider la liste des éléments qui provoquent le générateur pour créer une séquence vide pour max arg ce qui entraîne une erreur.
    InformationsquelleAutor hammar
  4. 5

    facile avec la récursivité

    def flat(l):
    depths = []
    for item in l:
        if isinstance(item, list):
            depths.append(flat(item))
    if len(depths) > 0:
        return 1 + max(depths)
    return 1
    • Merci! C'est une grande et très undestandable pour moi ^^
    InformationsquelleAutor Eduardo
  5. 2

    Il l'a fait en une ligne de python 🙂

    profiter de

    def f(g,count=0): return count if not isinstance(g,list) else max([f(x,count+1) for x in g])
    InformationsquelleAutor systemizer
  6. 2

    Abusif de:
    Dire que votre liste est appelée mylist

    mybrackets = map(lambda x: 1 if x=='[' else -1, [x for x in str(mylist) if x=='[' or x==']'])
    maxdepth = max([sum(mybrackets[:i+1]) for i in range(len(mybrackets))])

    Cela transforme votre liste à une liste d'ouverture et de fermeture crochets, puis trouve le plus grand nombre de l'ouverture des crochets qui se produisent avant que le correspondant crochet de fermeture se produit.

    InformationsquelleAutor sans
  7. 2

    Une manière qui n'a pas besoin de modules supplémentaires et a la même vitesse, peu importe à quelle profondeur:

    def depth(nested):
    instring = False
    count = 0
    depthlist = []
    for char in repr(nested):
        if char == '"' or char == "'":
            instring = not instring
        elif not instring and ( char == "[" or char == ")" ):
            count += 1
        elif not instring and ( char == "]" or char == ")" ):
            count -= 1
        depthlist.append(count)
    return(max(depthlist))

    Fondamentalement, ce que cela fait, c'est de convertir la liste d'une chaîne à l'aide de repr(). Ensuite, pour chaque personnage dans cette chaîne égale à "(" ou "[" il augmente la variable count. pour la fermeture crochets, elle diminue count. Ensuite, il retourne la valeur maximale que count a atteint.

    InformationsquelleAutor user3315473
  8. 1

    J'ai étendu la hammar réponse pour chaque objet iterable (chaînes désactivée par défaut):

    def depth(arg, exclude=None):
    if exclude is None:
        exclude = (str, )

    if isinstance(arg, tuple(exclude)):
        return 0

    try:
        if next(iter(arg)) is arg:  # avoid infinite loops
            return 1
    except TypeError:
        return 0

    try:
        depths_in = map(lambda x: depth(x, exclude), arg.values())
    except AttributeError:
        try:
            depths_in = map(lambda x: depth(x, exclude), arg)
        except TypeError:
            return 0

    try:
        depth_in = max(depths_in)
    except ValueError:
        depth_in = 0

    return 1 + depth_in
    • C'est la meilleure réponse ici
    InformationsquelleAutor Marco Sulla
  9. 0

    Un court plus de ce qui a été dit pour qu'il puisse gérer vide listes de trop:

    def list_depth(list_of_lists):
    if isinstance(list_of_lists, list):
        if(len(list_of_lists) == 0):
            depth = 1
        else:
            depth = 1 + max([list_depth(l) for l in list_of_lists])
    else:
        depth = 0
    return depth
    InformationsquelleAutor David
  10. 0

    @Jean solution est excellente, mais à l'adresse de la liste vide des cas, comme [], [[]], vous devrez peut-être faire quelque chose comme ceci

    depth = lambda L: isinstance(L, list) and (max(map(depth, L)) + 1) if L else 1

    InformationsquelleAutor onerhao
  11. 0

    Dans Numpy, vous pouvez convertir la structure de données pour un numpy array et d'utiliser ses fonctions de bibliothèque. arr.shape donne la longueur de la couche, de sorte que nous pouvons len() la forme et obtenir la profondeur de la structure:

    import numpy as np

def f( lists )
  arr = np.array( lists )
  return len(arr.shape)

f( [[[1,2],[3,4]],[[3,4],[5,6]]] ) # results in 3
f( [[1,2],[3,4]] ) # results in 2
f( [1,2] )  # results in 1
f( [] )  # results in 1

    Numpy docs pour la forme: https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.shape.html

    InformationsquelleAutor pds