Python 我使用随机生成的有序对的numpy数组，我需要确定有序对是否是不同类型的三角形

本周我开始使用numpy，对此我感到非常困惑。看起来与普通python函数非常不同

对于形状为1000X6的数组，是否有办法在数组中逐行检查，例如，一个等边三角形。我有6列，因此每行有三元组，每个点有2个整数

import numpy as np
pnts = np.random.randint(0,50,(1000, 6))

我还认为最好创建3个如下所示的阵列：

import numpy as np
A = np.random.random((10,2))
B = np.random.random((10,2))
C = np.random.random((10,2))

创建有序对，然后使用算法查找三角形

有没有更好的方法来创建一个表示1000个有序对的三元组的数组，以及如何在该数组中找到三角形，例如等边三角形

我现在做了一些改变。我为x坐标和y坐标制作了两个数组

x = np.random.randint(0,10,(3,1000))
y = np.random.randint(0,10,(3,1000))

增加问题

我有一些算法，可以得到每个匹配的x和y坐标，它们可以找到每个三角形的边长和角度。我会发布，但代码太多了。现在我有了一些函数，它们使用角度和边长来求一个不等角线，等边线，右等参线和非右等参线

我的问题现在更与索引相关。我将再次使用等边三角形作为示例，因为这是我们一直在使用的

E = np.column_stack((ACXY,ABXY,CBXY))
ES = np.logical_and(E[:,0] == E[:,1], E[:,1] == E[:,2])

我要找到等边三角形

- ACXY = the distance from point A to C
- ABXY = the distance from point A to B
- CBXY = the distance from point C to B

我希望能够获取所有等边三角形的坐标三元组，对它们进行索引，并将它们放入一个名为E_Tri的新数组中。我不认为我需要创建布尔值的函数。我想如果：否则：陈述也许是更好的方式

这也可能有帮助，我将显示

E=np.column\u堆栈（（ACXY，ABXY，CBXY））

帮助理解（E）的数组

E将是那样的。希望这会有意义，如果没有请让我知道

也许像这样的事情，即使这不起作用，只是增加了问题

E = np.column_stack((ACXY,ABXY,CBXY))
equilateral = [] 
def E_Tri(E):
    if E[:,0] == E[:,1] and E[:,1] == E[:,2]:
        equilateral.append(E_Tri)
    else:
        return E

---

您已经很好地描述了如何存储数据，但没有描述算法是什么。例如，如果我们想回答“这组三个（x，y）点P1..P3是等边三角形吗”的问题，我们可以这样表述：

dist(P1,P2) == dist(P2,P3) == dist(P3,P1)

其中

dist（P1，P2）

使用毕达哥拉斯定理：

sqrt((P1.x - P2.x)**2 + (P1.y - P2.y)**2)

但是请注意，

sqrt（）

是不必要的，因为我们所关心的是三条腿的长度是否相等（如果相等，那么它们的平方也将相等）

在NumPy中，我们希望以一种可并行化的方式完成所有事情。因此，如果您有一个代表1000个三角形的1000x6数组，则需要一次对1000个元素执行所有操作。如果数组名为A，且其列为：

P1.x, P1.y, P2.x, P2.y, P3.x, P3.y

那么第一个操作是：

A[0] - A[2] # P1.x - P2.x
A[1] - A[3] # P1.y - P2.y
A[2] - A[4]
A[3] - A[5]
A[4] - A[0]
A[5] - A[1]

可以更简洁地写：

R = A - np.roll(A, -2, axis=0) # 1000x6 array of all differences

完成后，您可以一次对所有1000x6结果进行平方运算，得到一个1000x6数组R，从中我们添加x和y对以获得距离的平方：

R[0] + R[1] # (P1.x - P2.x)**2 + (P1.y - P2.y)**2
R[2] + R[3]
R[4] + R[5]

也就是说：

S = R[0::2] + R[1::2] # three column-wise additions at once

这为我们提供了1000x3平方距离数组S。现在我们只需检查每一行的列是否都相等：

np.logical_and(S[0] == S[1], S[1] == S[2])

这给出了1000x1布尔向量，它告诉我们每一行是否为等边三角形

请注意，我们从未以迭代的方式逐行进行。这是因为在NumPy中执行此操作要比执行列操作慢得多

请注意，我在编写上述内容时，假设数组的形状实际上是

（61000）

，我说的是

1000x6

。这是为了方便记法（

A[0]

而不是

A[：，0]

），还因为在对列进行操作时效率更高，因为NumPy默认使用行主顺序。如果需要，您可以

np.transpose（）

输入数据

因此，最终只是：

A = pnts.T
R = np.square(A - np.roll(A, -2, axis=0))
S = R[0::2] + R[1::2] # 1000x3 squares of distances
np.logical_and(S[0] == S[1], S[1] == S[2]) # 1000 True/False results

---

良好的解释；但如果A有形状（1000，3，2）@eelcoogendoorn:Fair够了；我只是决定坚持OP指定的形状，但一开始的

reformate（）

不会有任何影响。我将把它作为练习留给读者！谢谢你的帮助！我之所以有6个数字，是因为它们是有序对。我想为不同类型的三角形（如等边三角形、直角三角形、不等边三角形、e.t.c.）创建有序对数组，然后用（vstack）将这些数组堆叠在一起。如果我确实从（10000，3，2）形状开始，那么（np.roll）和（points.repeat）创建一个新的有序对数组会更容易吗？还有谁能解释numpy中的（独特）功能吗？至于x6还是x3x2更简单，请自己尝试并决定。至于

np.unique（）

，请阅读文档——它基本上会丢弃数组中的重复元素。如果您需要查看我用于获取（ACXY、ABXY、CBXY）的算法，请告诉我，我将尝试清理它们，并将其以可读性和不太冗长的方式发布。

A = pnts.T
R = np.square(A - np.roll(A, -2, axis=0))
S = R[0::2] + R[1::2] # 1000x3 squares of distances
np.logical_and(S[0] == S[1], S[1] == S[2]) # 1000 True/False results