python - tuplas - Contando la profundidad o el nivel más profundo al que va una lista anidada

llenar una lista en python

Question

A tiene un problema real (y un dolor de cabeza) con una tarea ...

Estoy en una clase de programación introductoria, y tengo que escribir una función que, dada una lista, devolverá la profundidad "máxima" a la que ... Por ejemplo: [1,2,3] devolverá 1, [ 1, [2,3]] devolverá 2 ...

He escrito este código (es lo mejor que pude obtener T_T)

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

Sin embargo, obviamente no funciona como debería, porque si hay listas que no cuentan para la profundidad máxima, aún aumenta el contador ...

Por ejemplo: cuando uso la función con [1,2, [3,4], 5, [6], 7] debería devolver 2, pero devuelve 3 ...

Cualquier idea o ayuda sería muy apreciada ^^ muchas gracias !! He estado luchando con esto por semanas ...

Answer 1

Amplitud primero, sin recursión, y también funciona con otros tipos de secuencia:

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 misma idea, pero con mucho menos consumo de memoria:

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

Answer 2

Aquí hay una forma de escribir la función.

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

Creo que la idea que te estás perdiendo es usar max()

Answer 3

La solución de @ John es excelente, pero para abordar los casos de listas vacías, como [] , [[]] , es posible que deba hacer algo como esto

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

Answer 4

Lo hice en una línea de python :)

disfrutar

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

Answer 5

Manera abusiva: Di que tu lista se llama 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))])

Esto convierte su lista en una lista de corchetes de apertura y cierre, y luego encuentra el mayor número de corchetes de apertura que se producen antes de que se produzca el corchete de cierre correspondiente.

Answer 6

Primero reformulemos un poco sus requisitos.

La profundidad de una lista es uno más que la profundidad máxima de sus sub-listas.

Ahora, esto se puede traducir directamente al código:

def depth(l):
    if isinstance(l, list):
        return 1 + max(depth(item) for item in l)
    else:
        return 0

Answer 7

Una breve adición a lo que se ha dicho para que pueda manejar listas vacías también:

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

Answer 8

Una forma que no necesita módulos adicionales y tiene la misma velocidad, independientemente de la profundidad:

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

Básicamente, lo que esto hace es convertir la lista en una cadena usando repr() . Luego, para cada carácter en esta cadena igual a "(" o "[" aumenta el count variable. Para los corchetes de cierre disminuye el count . Luego devuelve el máximo que el count ha alcanzado.

Answer 9

fácil con recursión

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

Answer 10

Extendí la respuesta de Hammar para cada iterable (cadenas deshabilitadas por defecto):

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