如何将2D numpy数组的2D numpy数组重组为浮点数的4D数组？

Question

I have an issue currently where I have a numpy array of shape (60,60) where each point is itself a numpy array of shape (11,11). This is causing problems for me, because each point of the (60,60) array is an object and not a float:

    P_arr.shape
    (60,60)
    P_arr[i,j].shape
    (11,11)
    P_arr[i,j][k,l]
    1.0

For matrix operations that I need to carry out later on, I need to access each float value of the array in a particular order. I need a new array to have a shape of (11,11,60,60), with each point being a float. Ideally, I would like to reach this point:

    New_P_arr[k,l,i,j]
    1.0

Is there any way to extract the float values out of the interior 2D arrays to reshape it into the desired form? I need a solution that is faster than looping, because this will scale up quite a bit in the future. I have tried flattening, vstack, concatenate, etc. The issue with flattening, for example, is this:

    New_P_arr = np.concatenate(P_arr)
    New_P_arr.shape
    (3600,)
    New_P_arr[i].shape
    (11,11)

So, flattening the array (or the other operations) will not allow me to access all the values within a single square bracket index. My initial thought was to flatten the array in order to reshape it, but because the points are objects and not floats that won't work either.

EDIT: Here is how I generated P_arr. I need to solve the associated Legendre function for a selection of 11 l and 11 m values over a grid of theta values with the shape (60,60). Scipy has a package, lpmn, which computes the associated Legendre polynomials as well as their derivatives (which I don't need), but it isn't vectorized. It returns an (11,11) array at a given theta value for each l and m up to the value I input (from 0-10, that's where the 11 comes from). This is the code:

    import numpy as np
    from scipy.special import lpmn
    lmax = 10
    mmax = lmax
    theta = np.arange(0, 180., 3)
    theta = theta*np.pi/180.
    phi = theta
    ph, th = np.meshgrid(theta, phi)
    cos_th = np.cos(th)
    th is a (60,60) array of theta values from 0-pi in equal steps    

    @np.vectorize
    def asscP(m, l, cos_theta):
        return lpmn(m, l, cos_theta)[0]

    asscP = np.vectorize(asscP, excluded={0,1}, otypes=[np.ndarray])
    P_arr = asscP(mmax, lmax, cos_th)

Answer 1

• you can first stack inner level then outer level.

>>>new_P_arr = np.stack([np.stack(p) for x in P_arr])
>>>new_P_arr.shape
(60,60,11,11)

Answer 2

As you are concerned with performance, you probably should review your data generation code. Two points to consider:

1. As per the docs np.vectorize does not make your code faster, it is just a convenience function and will loop over your elements.
2. Your cos_th array has the same values so the expensive call to lpmn is made 60x more often than necessary.

Based on this, I suggest you use python loops and numpy slice assignments as follows:

import numpy as np
from scipy.special import lpmn
lmax = 10
mmax = lmax
theta = np.arange(0, 180., 3)
theta = theta*np.pi/180.
cos_theta = np.cos(theta)
P_arr = np.zeros(shape=(len(theta), len(theta), mmax+1, lmax+1))
for e, ct in enumerate(cos_theta):
    P_arr[0,e,:] = lpmn(mmax, lmax, ct)[0]
    for i in range(1, len(theta)):
        P_arr[i,e,:] = P_arr[e,0,:] # copy data 60x
P_arr = P_arr.swapaxes(0,2)
P_arr = P_arr.swapaxes(1,3)
P_arr.shape