How can I get a list shape without using numpy?

Question

a1=[1,2,3,4,5,6]  
b1=[[1,2,3], [4,5,6]]

If using np.shape list a1 will return (6,) and b1 will return (2, 3) .

If Numpy is forbidden, how can I get the shape of list a1 ?

I am mainly confused about how can I let the python program know a1 is only one dimension. Is there any good method?

Answer 1

>>>a = [1,2,3,4,5,6]
>>>print (len(a))
6

For one dimensional lists, the above method can be used. len(list_name) returns number of elements in the list.

>>>a = [[1,2,3],[4,5,6]]
>>>nrow = len(a)
>>>ncol = len(a[0])
>>>nrow
2
>>>ncol
3

The above gives the dimension of the list. len(a) returns number of rows. len(a[0]) returns number of rows in a[0] which is the number of columns.

Here's a link to original answer.

Answer 2

this is a recursive attempt at solving your problem. it will only work if all the lists on the same depth have the same length. otherwise it will raise a ValueError :

from collections.abc import Sequence


def get_shape(lst, shape=()):
    """
    returns the shape of nested lists similarly to numpy's shape.

    :param lst: the nested list
    :param shape: the shape up to the current recursion depth
    :return: the shape including the current depth
            (finally this will be the full depth)
    """

    if not isinstance(lst, Sequence):
        # base case
        return shape

    # peek ahead and assure all lists in the next depth
    # have the same length
    if isinstance(lst[0], Sequence):
        l = len(lst[0])
        if not all(len(item) == l for item in lst):
            msg = 'not all lists have the same length'
            raise ValueError(msg)

    shape += (len(lst), )
    
    # recurse
    shape = get_shape(lst[0], shape)

    return shape

given your input (and the inputs from the comments) these are the results:

a1=[1,2,3,4,5,6]
b1=[[1,2,3],[4,5,6]]

print(get_shape(a1))  # (6,)
print(get_shape(b1))  # (2, 3)
print(get_shape([[0,1], [2,3,4]]))  # raises ValueError
print(get_shape([[[1,2],[3,4]],[[5,6],[7,8]]]))  # (2, 2, 2)

not sure if the last result is what you wanted.

---

UPDATE

as pointed out in the comments by mkl the code above will not catch all the cases where the shape of the nested list is inconsistent; eg [[0, 1], [2, [3, 4]]] will not raise an error.

this is a shot at checking whether or not the shape is consistent (there might be a more efficient way to do this...)

from collections.abc import Sequence, Iterator
from itertools import tee, chain

def is_shape_consistent(lst: Iterator):
    """
    check if all the elements of a nested list have the same
    shape.

    first check the 'top level' of the given lst, then flatten
    it by one level and recursively check that.

    :param lst:
    :return:
    """

    lst0, lst1 = tee(lst, 2)

    try:
        item0 = next(lst0)
    except StopIteration:
        return True
    is_seq = isinstance(item0, Sequence)

    if not all(is_seq == isinstance(item, Sequence) for item in lst0):
        return False

    if not is_seq:
        return True

    return is_shape_consistent(chain(*lst1))

which could be used this way:

lst0 = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
lst1 = [[0, 1, 2], [3, [4, 5]], [7, [8, 9]]]

assert is_shape_consistent(iter(lst0))
assert not is_shape_consistent(iter(lst1))

Answer 3

Here is a great example from "Ten Essays on Fizz Buzz" book by Joel Grus by using recursion.

from typing import List, Tuple, Union


def shape(ndarray: Union[List, float]) -> Tuple[int, ...]:
    if isinstance(ndarray, list):
        # More dimensions, so make a recursive call
        outermost_size = len(ndarray)
        row_shape = shape(ndarray[0])
        return (outermost_size, *row_shape)
    else:
        # No more dimensions, so we're done
        return ()

Example:

three_d = [
    [[0, 0, 0], [1, 1, 1], [2, 2, 2]],
    [[0, 0, 0], [1, 1, 1], [2, 2, 2]],
    [[0, 0, 0], [1, 1, 1], [2, 2, 2]],
    [[0, 0, 0], [1, 1, 1], [2, 2, 2]],
    [[0, 0, 0], [1, 1, 1], [2, 2, 2]],
]

result = shape(three_d)
print(result)
>>> (5, 3, 3)

Answer 4

The question clearly states 'without using numpy'. However, if anybody reached here looking for a solution without any condition, consider below. This solution will work for a balanced list.

b1=[[1,2,3], [4,5,6]]
np.asarray(b1).shape

(2, 3)

Answer 5

Depending on the level of thoroughness required, I would recommend using tail recursion. Build up the shape from the innermost to the outermost list. That will allow you to check that all the sizes match up at every depth and index.

def shape(lst):
    def ishape(lst):
        shapes = [ishape(x) if isinstance(x, list) else [] for x in lst]
        shape = shapes[0]
        if shapes.count(shape) != len(shapes):
            raise ValueError('Ragged list')
        shape.append(len(lst))
        return shape
    return tuple(reversed(ishape(lst)))

Here is a demo on IDEOne: https://ideone.com/HJRwlC

shapes.count(shape) != len(shapes) is a neat trick to determine if all the shapes up to a given level are identical, taken from https://stackoverflow.com/a/3844948/2988730 .

If your only goal is to determine whether the list is one dimensional or not, just run a single all on the outermost list:

is_1d = all(not isinstance(x, list) for x in lst)

OR

is_1d = not any(isinstance(x, list) for x in lst)

Answer 6

Following function keeps track of first item of each dimension of a list. It doesn't matter how many dimensions it has.

def list_shape(input):
    
shape = []
    a = len(input)
    shape.append(a)
    b = input[0]

    while a > 0:
        try:

            a = len(b)
            shape.append(a)
            b = b[0]

        except:
            break
        
    return shape

list1 = [[[123], [231]], [[345], [231]]]

print(list_shape(list1))

Output:

[2, 2, 1]

Note: Only works for symmetrical lists and numeral data within the list.

Answer 7

My proposal for the problem is the following relative complex code which delivers the maximum shape in form of a tuple. The method can be feeded by any kind of nested iterable object that contains a __len__ method. I use the itertools.zip_longest() method to calculate the shape.

import itertools

def get_max_shape(value):
    if hasattr(value, '__len__'):
        s0 = len(value)
        if s0 == 0:
            return ()
        s1 = 0
        sub_shape = []
        # via zip_longest we iterate over the longest sub_list item
        for v2 in itertools.zip_longest(*(v if hasattr(v, '__len__') else tuple() for v in value), fillvalue=0):
            s1 += 1  # calc the length of second dimension
            for v3 in v2:
                sub_shape_new = get_max_shape(v3)  # recursive measurement of lower dimensions
                # compare new shapes with old shapes (find max)
                for i, new in enumerate(sub_shape_new):
                    if i >= len(sub_shape):
                        # new items
                        sub_shape.extend(sub_shape_new[i:])
                    else:
                        # is max?
                        if sub_shape[i] < new:
                            sub_shape[i] = new
        if len(sub_shape):
            return (s0, s1) + tuple(sub_shape)
        elif s1:
            return (s0, s1)
        else:
            return (s0,)
    else:
        return ()

The execution delivers:

>>> print(get_max_shape([])
()
>>> print(get_max_shape([1, 2, 3])
(3,)
>>> print(get_max_shape([1, 2, [2, 3]]))
(3,2)
 >>> print(get_max_shape([[[2, 3, 4, 5], 1, 2], [3, [2, 3, 4], 5, 6]]))
(2, 4, 4)
>>> print(get_max_shape([[[2, 3, 4, [4, [5, 6]]], 1, 2], [3, [2, [3, 4, 5, 6, 7], 4], 5, 6]]))
(2, 4, 4, 5, 2)

The code might be improved but in general I think it works and it does not iterate over all items to get the dimensions it uses the length() method if possible.