32

割り当てに実際の問題（および頭痛）があります...

私は入門的なプログラミングクラスにいます。リストを指定すると、「最大」の深さを返す関数を作成する必要があります。例：[1,2,3]は1、[を返します。 1、[2,3]]は2を返します。

私はこのコードを書きました（T_Tを入手できる最高のものです）

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

ただし、最大の深さを考慮しないリストがある場合でも、カウンターが上がるため、明らかに正常に機能しません...

例：[1,2、[3,4]、5、[6]、7]で関数を使用すると、2が返されますが、3が返されます...

どんなアイデアや助けも大歓迎です^^どうもありがとう!! 私はこれで何週間も苦労しています...

4

14 に答える 14

36

これが関数を書く1つの方法です

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

私はあなたが欠けている考えは使用することだと思いますmax()

于 2011-05-18T02:10:19.970 に答える
16

まず、要件を少し言い換えてみましょう。

リストの深さは、そのサブリストの最大の深さより1つ多くなります。

これで、これをコードに直接変換できます。

def depth(l):
    if isinstance(l, list):
        return 1 + max(depth(item) for item in l)
    else:
        return 0
于 2011-05-18T02:12:30.780 に答える
7

再帰で簡単

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
于 2011-05-18T02:10:44.490 に答える
6

幅優先、再帰なし、他のシーケンスタイプでも機能します。

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

同じ考えですが、メモリ消費量がはるかに少なくなります。

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
于 2011-05-18T05:23:03.803 に答える
2

Pythonの1行でそれをしました:)

楽しい

def f(g,count=0): return count if not isinstance(g,list) else max([f(x,count+1) for x in g])
于 2011-05-18T02:21:56.750 に答える
2

虐待的な方法：あなたのリストが呼ばれていると言う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))])

これにより、リストが開始ブラケットと終了ブラケットのリストに変換され、対応する終了ブラケットが発生する前に発生する最大数の開始ブラケットが検出されます。

于 2011-05-18T02:44:23.990 に答える
2

追加のモジュールを必要とせず、深さに関係なく同じ速度を持つ方法：

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

基本的に、これは、を使用してリストを文字列に変換しますrepr()。(次に、「 」または「 」に等しいこの文字列内のすべての文字について[、変数を増やしますcount。閉じ括弧の場合は減少しcountます。count次に、到達した最大値を返します。

于 2014-05-07T17:37:17.543 に答える
1

すべての反復可能（デフォルトで文字列が無効になっている）のハンマーの答えを拡張しました：

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
于 2016-02-29T11:16:39.217 に答える
1

Numpyでは、データ構造をに変換して、numpy arrayそのライブラリ関数を使用できます。arr.shapeレイヤーごとの長さを与えるのでlen()、構造の形状と深さを取得できます。

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ドキュメント：https ：//docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.shape.html

于 2019-07-09T09:04:04.160 に答える
1

クイックフィックスをお探しの場合

def getDepth(matrix):
    try:
        len(matrix)
        return getDepth(matrix[0]) + 1
    except:
        return 0
于 2020-06-23T02:18:04.493 に答える
0

空のリストも処理できるように、言われたことへの短い追加：

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
于 2015-09-21T16:31:44.387 に答える
0

@Johnのソリューションは優れていますが、、、またはさらにネストされたリストなどの空のリストの場合に対処するには、次のようなことを行う必要があります[]。[[]]

depth = lambda L: isinstance(L, list) and (max(map(depth, L)) + 1) if str(L) else 1
于 2016-09-27T11:31:39.140 に答える
0

Pythonのみを使用して再帰的に実行することもできます。

def depth(L,d):
    max = d
    for i in range(len(L)):
        if type(L[i])==list :
            a = depth(L[i],d+1)
            if a>max :
                 max = a
    return(max)

この関数は再帰的であり、リストの深さを数えてリストの最大深度に到達し、戻ったときに、ネストされたすべてのリストの中で登録されている最大の深度のみを保持します。

于 2020-08-09T15:06:59.877 に答える
0

元のかなりエレガントなソリューションに固執し、 maxを使用して機能させましょう。他のソリューションの多くはラムダ式を使用するか、外部ライブラリを必要とします。これは「純粋な」Pythonを使用し、シンプルに保ちます。

def depth(lst):
    d = 0
    for item in lst:
        if isinstance(item, list):
            d = max(depth(item), d)
    return d + 1

ボーナス：このソリューションは空のリストをカウントし、文字列をトラバースするトラップを回避します（空のリストをカウントする場合）。

于 2022-01-02T04:22:11.913 に答える