entityMap|blocks|key|dck96|text|是的，这是可能的，如果你想完全依靠嵌套，你可以尝试一下。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|f4mg7|x+=+[[0,+1,+2,+3],+[4,+5,+6,+7],+[8,+9,+10,+11]]

result+=+[]
for+k+in+range(len(x)):
++++temp+=+[]
++++for+i+in+range(len(x)):
++++++++tempSum+=+0
++++++++for+j+in+range(len(x[0])):
++++++++++++tempSum+%2B=+x[k][j]*x[i][j]
++++++++temp.append(tempSum)
++++result.append(temp)

print(result)|code-block|syntax|javascript|d58eo|输出：|47t1n|[[14,+38,+62],+[38,+126,+214],+[62,+214,+366]]|5mebk|您可以使用numpy进行验证：|9liig|>>>+x+=+np.arange(12).reshape(3,4)
>>>+x@x.T

array([[+14,++38,++62],
+++++++[+38,+126,+214],
+++++++[+62,+214,+366]])|3ifvr^0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|Q|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|R|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|S|9|@]|A|@]|B|$]]|$2|J|4|K|6|E|8|T|9|@]|A|@]|B|$F|G]]|$2|L|4|M|6|7|8|U|9|@]|A|@]|B|$]]|$2|N|4|O|6|E|8|V|9|@]|A|@]|B|$F|G]]|$2|P|4|-4|6|7|8|W|9|@]|A|@]|B|$]]]]

Yes, it is possible, you can try this if you want to rely purely on nesting.

<pre><code>x = [[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]]

result = []
for k in range(len(x)):
 temp = []
 for i in range(len(x)):
 tempSum = 0
 for j in range(len(x[0])):
 tempSum += x[k][j]*x[i][j]
 temp.append(tempSum)
 result.append(temp)

print(result)
</code></pre>

Output:

<pre><code>[[14, 38, 62], [38, 126, 214], [62, 214, 366]]
</code></pre>

you can verify it with numpy:

<pre><code>&gt;&gt;&gt; x = np.arange(12).reshape(3,4)
&gt;&gt;&gt; x@x.T

array([[ 14, 38, 62],
 [ 38, 126, 214],
 [ 62, 214, 366]])
</code></pre>

entityMap|blocks|key|211hf|text|通过直接使用矩阵乘法定义和标准数字广播，这应该是很有可能的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3arvl|import+numpy+as+np

def+matrix_multiplication_nested_loop(A,+B):
++++res+=+np.zeros((A.shape[0],+B.shape[1]))

++++for+_x+in+range(A.shape[0]):
++++++++for+_y+in+range(B.shape[1]):
++++++++++++res[_x,+_y]+=+np.sum(A[_x,+:]+*+B[:,+_y])
++++return+res

A+=+np.array([[1,+2,+3,+4],+[5,+6,+7,+8],+[0,+1,+2,+1]])
B+=+np.array([[1,+5,+0],+[2,+6,+1],+[3,+7,+2],+[4,+8,+1]])+#+A.T|code-block|syntax|javascript|ab32h^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|I|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|J|9|@]|A|@]|B|$F|G]]|$2|H|4|-4|6|7|8|K|9|@]|A|@]|B|$]]]]

It should very well be possible, by direct usage of matrix multiplication definition and standard numpy broadcasting:

<pre><code>import numpy as np

def matrix_multiplication_nested_loop(A, B):
 res = np.zeros((A.shape[0], B.shape[1]))

 for _x in range(A.shape[0]):
 for _y in range(B.shape[1]):
 res[_x, _y] = np.sum(A[_x, :] * B[:, _y])
 return res

A = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [0, 1, 2, 1]])
B = np.array([[1, 5, 0], [2, 6, 1], [3, 7, 2], [4, 8, 1]]) # A.T
</code></pre>

entityMap|blocks|key|2qv84|text|试试这个。没有numpy，常规列表，可以转移到任何语言|type|unstyled|depth|inlineStyleRanges|entityRanges|data|9rn0n|for+i+in+range(len(A)):
++++for+j+in+range(len(A)):
++++++++#+R+must+be+initialized+above+with+the+proper+shape+(n+x+n)!
++++++++R[i][j]+=+0
++++++++for+k+in+range(len(A[0])):
++++++++++++R[i][j]+%2B=+A[i][k]+*+A[j][k]|code-block|syntax|javascript|s22v^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|I|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|J|9|@]|A|@]|B|$F|G]]|$2|H|4|-4|6|7|8|K|9|@]|A|@]|B|$]]]]

Try this. No numpy, regular list and transferable to any language

<pre><code>for i in range(len(A)):
 for j in range(len(A)):
 # R must be initialized above with the proper shape (n x n)!
 R[i][j] = 0
 for k in range(len(A[0])):
 R[i][j] += A[i][k] * A[j][k]
</code></pre>

entityMap|blocks|key|2l2vc|text|下面是一个使用列表理解和sum的解决方案|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1a6du|a+=+[[1,+2],+[3,+4],+[5,+6]]

result+=+[
++++[+sum(x*y+for+x,+y+in+zip(row1,+row2))+for+row2+in+a+]
++++for+row1+in+a
]

#+result+=+[[5,+11,+17],+[11,+25,+39],+[17,+39,+61]]|code-block|syntax|javascript|9v35b|它之所以有效，是因为A和Aᵀ的矩阵乘积中的每个元素都是A的行与Aᵀ的列的乘积，而Aᵀ的列正是A的行。|75iuf^0|C|3|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|O|9|@$A|P|B|Q|C|D]]|E|@]|F|$]]|$2|G|4|H|6|I|8|R|9|@]|E|@]|F|$J|K]]|$2|L|4|M|6|7|8|S|9|@]|E|@]|F|$]]|$2|N|4|-4|6|7|8|T|9|@]|E|@]|F|$]]]]

Here's a solution using list comprehensions and <code>sum</code>:

<pre class="lang-py prettyprint-override"><code>a = [[1, 2], [3, 4], [5, 6]]

result = [
 [ sum(x*y for x, y in zip(row1, row2)) for row2 in a ]
 for row1 in a
]

# result = [[5, 11, 17], [11, 25, 39], [17, 39, 61]]
</code></pre>

It works because each element in the matrix product of A and Aᵀ is the product of a row from A with a column from Aᵀ, and the columns of Aᵀ are just the rows of A.

Suppose A is a MxN matrix. I want to multiply A with its transpose. Is it possible to do it with pure nested loop (i.e., not using np.transpose)? When I try to loop through it, I don't know how to figure out the range issue since the shape of the result is different from A. 

Say A is 3x4. Then the result of A*(A^T) will be 3x3. Both of <code>i</code>, <code>j</code> in <code>result[i][j]</code> cannot be larger than 4. So how can I iterate by rows and columns?

Python how to multiply non square matrices?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

 假设A是一个MxN矩阵。我想用它的转置乘以A。是否有可能使用纯嵌套循环(即不使用np.transpose)？当我尝试遍历它时，我不知道如何解决范围问题，因为结果的形状与A不同。 假设A是3x4。那么A*(A^T)的结果将是3x3。result[i][j]中的i和j都不能大于4。那么如何按行和按列迭代？ 

问Python如何将非方阵相乘？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python如何将非方阵相乘？EN