In Python, how to multiply each element in a multidimensional list by a number?

I have a multidimensional list of floats (or ints, I think it doesn't matter in our case), say, a list named lst = [[1,2],[1,1],[4,5]]. The dimension of the list is not specified: it doesn't have to be 2. lst could also be a 3-dimensional list, which is something like [[[1,2],[1,1],[4,5]],[[1,2],[1,1],[4,5]]]. I want to multiply each number in lst by a given number, say, 2.

If lst is one-dimensional, one way to do this is to define lst2 = [i*2 for i in lst]. However, this doesn't work for a high dimensional list. One could also use loops to do this element by element, but since the dimension of lst is not specified, the number of loops needed is unknown.

Does anyone have some idea how to do this neatly?

You can use recursion for the task, e.g.:

lst = [[[1, 2], [1, 1], [4, 5]], [[1, 2], [1, 1], [4, 5]]]

def multiply(obj, number):
    if isinstance(obj, list):
        return [multiply(v, number) for v in obj]
    else:
        return obj * number

new_lst = multiply(lst, 2)
print(new_lst)

Prints:

[[[2, 4], [2, 2], [8, 10]], [[2, 4], [2, 2], [8, 10]]]

If you want something more generally useful, you could make this util that works with any function:

def nested_map(func, obj):
    if not isinstance(obj, list):
        return func(obj)
    return [nested_map(func, x) for x in obj]


nested_map(lambda n: 2*n, lst)
# [[[2, 4], [2, 2], [8, 10]], [[2, 4], [2, 2], [8, 10]]]

You could write a general function to make this work between nested lists of any dimensions:

def broadcast(a,b,oper):
    match = isinstance(a,list),isinstance(b,list)
    if match == (False,False): return oper(a,b)
    if match == (True,False):  return [broadcast(i,b,oper) for i in a]
    if match == (False,True):  return [broadcast(a,i,oper) for i in b]
    a = a + a[-1:]*(len(b)-len(a))
    b = b + b[-1:]*(len(a)-len(b))
    return [broadcast(i,j,oper) for i,j in zip(a,b)]

outputs:

A = [ [1,2,3],
      [4,5,6],
      [7,8,9] ]
B = [ [10,20,30] ]
C = [100,200,300]

mult = lambda a,b: a*b
add  = lambda a,b: a+b

print(*broadcast(A,10,mult),sep="\n")
[10, 20, 30]
[40, 50, 60]
[70, 80, 90]

print(*broadcast(A,B,add),sep="\n")
[11, 22, 33]
[14, 25, 36]
[17, 28, 39]

print(*broadcast(A,C,add),sep="\n")
[101, 102, 103]
[204, 205, 206]
[307, 308, 309]

print(*broadcast(B,C,add),sep="\n")
[110, 120, 130]
[210, 220, 230]
[310, 320, 330]