python - 有效检查数组是否有锯齿

Question

我正在寻找一种有效的方法来检查数组是否是锯齿状的，其中“锯齿状”意味着数组中的一个元素与它在同一维度上的相邻元素具有不同的形状。

例如[[1, 2], [3, 4, 5]]或 [[1, 2], [3, 4], [5, 6], [[7], [8]]]
为方便起见，我使用列表语法，但参数可能是嵌套列表或嵌套的 numpy 数组。为了方便起见，我还显示了整数，最低级别的组件可以是任何东西(例如通用对象)。假设最低级别的对象本身不可迭代(例如 str 或 dict ，但对于可以处理这些问题的解决方案来说绝对是加分!)。

尝试:

递归地展平数组很容易，但我猜效率很低，然后可以将展平数组的长度与 numpy.size 进行比较。输入数组的。如果它们匹配，则它不是锯齿状的。

def really1d(arr):
    # Returns false if the given array is not 1D or is a jagged 1D array.
    if np.ndim(arr) != 1:
        return False
    if len(arr) == 0:
        return True
    if np.any(np.vectorize(np.ndim)(arr)):
        return False
    return True


def flatten(arr):
    # Convert the given array to 1D (even if jagged)
    if (not np.iterable(arr)) or really1d(arr):
        return arr
    return np.concatenate([flatten(aa) for aa in arr])


def isjagged(arr):
    if (np.size(arr) == len(flatten(arr))):
        return False
    return True

我很确定串联会复制所有数据，这完全是浪费。也许有一个 itertools或 numpy.flatiter实现相同目标的方法？最终，扁平数组仅用于查找其长度。

Answer 1

首先显示的是列表，而不是数组(稍后会详细介绍):

In [305]: alist1 = [[1, 2], [3, 4, 5]]                                                   
In [306]: alist2 = [[1, 2], [3, 4], [5, 6], [[7], [8]]]                                  

第一级的混合len是一个简单而明显的测试

In [307]: [len(i) for i in alist1]                                                       
Out[307]: [2, 3]

但这还不够第二个例子:

In [308]: [len(i) for i in alist2]                                                       
Out[308]: [2, 2, 2, 2]

从 list1 制作数组产生一维对象数据类型:

In [310]: np.array(alist1)                                                               
Out[310]: array([list([1, 2]), list([3, 4, 5])], dtype=object)

list2是 2d，但仍然是对象 dtype:

In [311]: np.array(alist2)                                                               
Out[311]: 
array([[1, 2],
       [3, 4],
       [5, 6],
       [list([7]), list([8])]], dtype=object)

np.array不是最有效的工具；在编译时，它必须至少评估嵌套列表到它发现差异的级别。

如果列表不参差不齐，则在任何级别，结果都是数字 dtype:

In [321]: alist3 = [[1, 2], [3, 4], [5, 6], [7, 8]]                                      
In [322]: np.array(alist3)                                                               
Out[322]: 
array([[1, 2],
       [3, 4],
       [5, 6],
       [7, 8]])

如果列表元素是数组，则可能会出现进一步的结果 - 广播错误。这是第一个维度匹配时的结果，但差异在较低级别。

总之，如果它已经是 numpy数组，然后 object是一个很好的指标，特别是如果您期待数字 dtype。如果最低级别的元素本身可能是对象(列表除外)，这将无济于事。在 list1和 list2在这种情况下，一些或所有最低级别的元素都是对象 - 列表。

如果是列表列表，则对 len 进行递归求值可能是要走的路。但只有时间测试才能证明这比 np.array(alist)要好.