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?
6 Answers
>>>a = [1,2,3,4,5,6]
>>>print (len(a))
6For 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
3The 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.
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 shapegiven 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; e.g. [[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))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)
1Here 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)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:
shapes.count(shape) != len(shapes) is a neat trick to determine if all the shapes up to a given level are identical, taken from .
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)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.
