Python 迭代数组并将其应用于函数

在python中，我使用函数“q”对p中的每一列（即4,4数组）进行迭代。 比如：

P = np.array([[1, 0, 0, 1], [0, 1, 0, 0], [0, 0, 0.5, 0], [0, 0, 0.5, 0]])


def q(q_u):
    q = np.array(
        [
            [np.dot(0, 2, q_u)],
            [np.zeros((4, 1), dtype=int)],
            [np.zeros((2, 1), dtype=int)],
        ],
        dtype=object,
    )

    return q


np.apply_along_axis(q, axis=0, arr=P)

我得到一个（3,1,4）数组，将q函数应用于p数组。这是正确的。但是如何保存并在以后调用4（3,1）个数组到一个dictional中，以便在以后将其应用到另一个需要（3,1）个数组的函数printR中呢

printR（60，res，q）

---

应该将4个数组添加到字典中，以便使用PrintR进行迭代，还是有其他方法？

使用

转置

，

zip

创建字典

要创建4个

（1,3）

，只需将它们传递给dict即可

arr = np.apply_along_axis(q, axis=0, arr=P)

d = dict(zip(range(arr.size), arr.T))

Out[259]:
{0: array([[0, array([[0],
        [0],
        [0],
        [0]]),
         array([[0],
        [0]])]], dtype=object), 1: array([[0, array([[0],
        [0],
        [0],
        [0]]),
         array([[0],
        [0]])]], dtype=object), 2: array([[0, array([[0],
        [0],
        [0],
        [0]]),
         array([[0],
        [0]])]], dtype=object), 3: array([[0, array([[0],
        [0],
        [0],
        [0]]),
         array([[0],
        [0]])]], dtype=object)}

In [260]: d[0].shape
Out[260]: (1, 3)

---

要创建4个

（3,1）

，请使用dict comprehension

d = {k: v.T for k, v in zip(range(arr.size), arr.T)}

Out[269]:
{0: array([[0],
        [array([[0],
        [0],
        [0],
        [0]])],
        [array([[0],
        [0]])]], dtype=object), 1: array([[0],
        [array([[0],
        [0],
        [0],
        [0]])],
        [array([[0],
        [0]])]], dtype=object), 2: array([[0],
        [array([[0],
        [0],
        [0],
        [0]])],
        [array([[0],
        [0]])]], dtype=object), 3: array([[0],
        [array([[0],
        [0],
        [0],
        [0]])],
        [array([[0],
        [0]])]], dtype=object)}

In [270]: d[0].shape
Out[270]: (3, 1)

---

注意：我有意使用

arr.size

让zip仅根据

arr.T

的长度修剪元组，使用

transpose

，

zip

创建字典

要创建4个

（1,3）

，只需将它们传递给dict即可

arr = np.apply_along_axis(q, axis=0, arr=P)

d = dict(zip(range(arr.size), arr.T))

Out[259]:
{0: array([[0, array([[0],
        [0],
        [0],
        [0]]),
         array([[0],
        [0]])]], dtype=object), 1: array([[0, array([[0],
        [0],
        [0],
        [0]]),
         array([[0],
        [0]])]], dtype=object), 2: array([[0, array([[0],
        [0],
        [0],
        [0]]),
         array([[0],
        [0]])]], dtype=object), 3: array([[0, array([[0],
        [0],
        [0],
        [0]]),
         array([[0],
        [0]])]], dtype=object)}

In [260]: d[0].shape
Out[260]: (1, 3)

---

要创建4个

（3,1）

，请使用dict comprehension

d = {k: v.T for k, v in zip(range(arr.size), arr.T)}

Out[269]:
{0: array([[0],
        [array([[0],
        [0],
        [0],
        [0]])],
        [array([[0],
        [0]])]], dtype=object), 1: array([[0],
        [array([[0],
        [0],
        [0],
        [0]])],
        [array([[0],
        [0]])]], dtype=object), 2: array([[0],
        [array([[0],
        [0],
        [0],
        [0]])],
        [array([[0],
        [0]])]], dtype=object), 3: array([[0],
        [array([[0],
        [0],
        [0],
        [0]])],
        [array([[0],
        [0]])]], dtype=object)}

In [270]: d[0].shape
Out[270]: (3, 1)

---

注意：我故意使用

arr.size

让zip仅根据

arr.T

的长度来修剪元组，以更正令人费解的

点

        [np.dot(0.2, q_u)], 

生成另一个问题中的

ost

我仍然想知道你为什么坚持使用

apply\u沿_轴

。它没有任何速度优势。比较这些时间安排：

In [36]: timeit np.apply_along_axis(q, axis=0, arr=P)                                          
141 µs ± 112 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [37]: timeit np.stack([q(P[:,i]) for i in range(P.shape[1])], axis=2)                       
72.1 µs ± 500 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [38]: timeit [q(P[:,i]) for i in range(P.shape[1])]                                         
53 µs ± 42.2 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

dot（0.2，q_）

行只做

0.2*q_

，应用于

p

的可以是

0.2*p

或

0.2*p.T

让我们更改

q

以省略尺寸1的尺寸，从而使显示更加紧凑：

In [49]: def q1(q_u): 
    ...:     q = np.array( 
    ...:         [ 
    ...:             np.dot(0.2, q_u), 
    ...:             np.zeros((4,), dtype=int), 
    ...:             np.zeros((2,), dtype=int), 
    ...:         ], 
    ...:         dtype=object, 
    ...:     ) 
    ...:     return q 
    ...:                                                                                       
In [50]: np.apply_along_axis(q1, axis=0, arr=P)                                                
Out[50]: 
array([[array([0.2, 0. , 0. , 0. ]), array([0. , 0.2, 0. , 0. ]),
        array([0. , 0. , 0.1, 0.1]), array([0.2, 0. , 0. , 0. ])],
       [array([0, 0, 0, 0]), array([0, 0, 0, 0]), array([0, 0, 0, 0]),
        array([0, 0, 0, 0])],
       [array([0, 0]), array([0, 0]), array([0, 0]), array([0, 0])]],
      dtype=object)
In [51]: _.shape                                                                               
Out[51]: (3, 4)

我们可以生成相同的数字，排列方式略有不同：

In [52]: [0.2 * P.T, np.zeros((4,4),int), np.zeros((4,2),int)]                                 
Out[52]: 
[array([[0.2, 0. , 0. , 0. ],
        [0. , 0.2, 0. , 0. ],
        [0. , 0. , 0.1, 0.1],
        [0.2, 0. , 0. , 0. ]]), 
 array([[0, 0, 0, 0],
        [0, 0, 0, 0],
        [0, 0, 0, 0],
        [0, 0, 0, 0]]), 
 array([[0, 0],
        [0, 0],
        [0, 0],
        [0, 0]])]

您正在制作3个二维数组，每个数组的

p

每列有一行

我在[38]中计时的列表理解生成4个大小（3，）的数组，即

p

的每列一个数组<“代码>沿轴应用”会使其模糊，将它们连接到最后一个维度上（就像轴为2的我的

堆栈那样）

列表理解不仅速度快，而且还能保持
q
输出“完整”，使其更容易传递到另一个函数。
将困惑的
点更正为

        [np.dot(0.2, q_u)], 

生成另一个问题中的
ost

我仍然想知道你为什么坚持使用
apply\u沿_轴
。它没有任何速度优势。比较这些时间安排：

In [36]: timeit np.apply_along_axis(q, axis=0, arr=P)                                          
141 µs ± 112 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [37]: timeit np.stack([q(P[:,i]) for i in range(P.shape[1])], axis=2)                       
72.1 µs ± 500 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [38]: timeit [q(P[:,i]) for i in range(P.shape[1])]                                         
53 µs ± 42.2 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

dot（0.2，q_）
行只做
0.2*q_
，应用于
p
的可以是
0.2*p
或
0.2*p.T

让我们更改
q
以省略尺寸1的尺寸，从而使显示更加紧凑：

In [49]: def q1(q_u): 
    ...:     q = np.array( 
    ...:         [ 
    ...:             np.dot(0.2, q_u), 
    ...:             np.zeros((4,), dtype=int), 
    ...:             np.zeros((2,), dtype=int), 
    ...:         ], 
    ...:         dtype=object, 
    ...:     ) 
    ...:     return q 
    ...:                                                                                       
In [50]: np.apply_along_axis(q1, axis=0, arr=P)                                                
Out[50]: 
array([[array([0.2, 0. , 0. , 0. ]), array([0. , 0.2, 0. , 0. ]),
        array([0. , 0. , 0.1, 0.1]), array([0.2, 0. , 0. , 0. ])],
       [array([0, 0, 0, 0]), array([0, 0, 0, 0]), array([0, 0, 0, 0]),
        array([0, 0, 0, 0])],
       [array([0, 0]), array([0, 0]), array([0, 0]), array([0, 0])]],
      dtype=object)
In [51]: _.shape                                                                               
Out[51]: (3, 4)

我们可以生成相同的数字，排列方式略有不同：

In [52]: [0.2 * P.T, np.zeros((4,4),int), np.zeros((4,2),int)]                                 
Out[52]: 
[array([[0.2, 0. , 0. , 0. ],
        [0. , 0.2, 0. , 0. ],
        [0. , 0. , 0.1, 0.1],
        [0.2, 0. , 0. , 0. ]]), 
 array([[0, 0, 0, 0],
        [0, 0, 0, 0],
        [0, 0, 0, 0],
        [0, 0, 0, 0]]), 
 array([[0, 0],
        [0, 0],
        [0, 0],
        [0, 0]])]

您正在制作3个二维数组，每个数组的
p
每列有一行

我在[38]中计时的列表理解生成4个大小（3，）的数组，即
p
的每列一个数组<“代码>沿轴应用”
会使其模糊，将它们连接到最后一个维度上（就像轴为2的我的
堆栈那样）

列表理解不仅速度快，而且还能保持
q
输出的“完整性”，使其更容易传递到另一个函数。
np.dot（0，2，q_）
-这应该是做什么的？
np.dot（0，2，q_）
-这应该是做什么的？