Python：使用OOP和访问方法（self、other）

我想从均匀分布中为公司类型0和1绘制位置，并使用Python中的OOP概念计算这两种类型之间的距离

class Firm_loc:

    def __init__(self,type):
        self.type = type
        self.random_location()

    def random_location(self):
        self.location = uniform(0,1), uniform(0,1)

    def distance(self,other):
        xx = (self.location[0] - other.location[0])**2
        yy = (self.location[1] - other.location[1])**2
        return sqrt(xx+yy)

firms = [Firm_loc('Firm_type_0') for i in range(5)]
firms.extend=[Firm_loc('Firm_type_1') for i in range(5)]

问题1：从这里开始，我被困住了。我必须调用distance方法来计算两个公司类型（即self和other）之间的每个距离，并将它们保存到列表中。任何帮助都将不胜感激

问题2：是否还有比上述代码更简短、更有效的代码

问题3：我尝试在OOP中使用“自我和其他”的概念，因为这两种类型的计算是成对的。按照传统的程序方法，代码将如何重写

编辑：

感谢您的回答，但对于距离，我必须有5x5=25个距离，如下所示：

Firm_type_0    Firm_type_1    Distance
   f0_0            f0_1       D(f0_0, f0_1)
   f0_0            f1_1       D(f0_0, f1_1)
   f0_0            f2_1       D(f0_0, f2_1)
   f0_0            f3_1       D(f0_0, f3_1)
   ...

---

我认为这两个答案不会产生这样的距离。

我认为您应该将不同的类型存储到不同的列表中。然后迭代这些列表的乘积，计算成对的距离

import itertools
firms = [Firm_loc('Firm_type_0') for i in range(5)]
other_firms = [Firm_loc('Firm_type_1') for i in range(5)]
distances = [i.distance(j) for i, j in itertools.product(firms, other_firms)]

---

product

生成输入可比项的笛卡尔积。

我不确定我是否理解

您的代码似乎还不错，在类似的方面没有太多的性能改进空间，那么python在数学方面也不是很好

如果你想计算公司对之间的距离，你需要一个对列表

firms_a = [Firm_loc('Firm_type_0') for i in range(5)]
firms_b = [Firm_loc('Firm_type_1') for i in range(5)]
all_firms = firms_a + firms_b
firm_distances = [firm_a.distance(firm_b) for firm_a, firm_b in zip(firms_a, firms_b)]
# firm_distance[0] is firms_a[0] distance to firms_b[0] and so on

您在这里使用的“OOP”只是非常基本的语法糖。程序方法可以做到这一点：

Firm_loc.distance(firm_a, firm_b)

这与：

firm_a.distance(firm_b)

在开始处理继承之前，您更有可能使用语法糖进行结构编程，而不是面向对象编程

编辑： 要获取每个类型_1的每个类型_0之间的距离，请执行以下操作：

firms_a = [Firm_loc('Firm_type_0') for i in range(5)]
firms_b = [Firm_loc('Firm_type_1') for i in range(5)]
all_firms = firms_a + firms_b
firm_distances = {
    firm_a:{
        firm_b:firm_a.distance(firm_b) for firm_b in firms_b
    }
    for firm_a in firms_a
}
# Getting the distance of two firms, always A then B
firm_a, firm_b = firms_a[2], firms_b[1]
print(firm_distances[firm_a][firm_b])

# Iterating through distances from a firm A
for firm_b, firm_distance in firm_distances[firm_a].items():
    print(firm_distance)

# Iterating through distances from a firm B
for firm_a in firm_distances:
    print(firm_distances[firm_a][firm_b])

---

我不太清楚你想完成什么。。。这里有一个关于发电机的例子，它有点像你想要的，对吗？5 x 5

firms_a = (Firm_loc('Firm_type_0') for i in range(5))
distances = [[firm.distance(i) for i in (Firm_loc('Firm_type_1') for j in range(5))] for firm in firms_a]

关于OOP问题，我认为OdraEncoded提供了很好的答案。您可以将其放入类方法中，例如：

class FirmLoc:
    @classmethod
    def distance(cls, first, second):
        #body of your distance function 
    ...

---

你说的问题1是什么意思？你被困在哪里？你想完成什么？

你可能是指

公司。扩展（[Firm_loc（'Firm_type_1'）范围内的i（5）]

。否则，您将覆盖

列表

的

扩展

方法。您应该查看，特别是

pdist

或

cdist

。不过，这将要求您将数据存储在numpy数组中。谢谢，但代码似乎不产生25个距离。哦，对不起，错过了这个。谢谢，但代码似乎不产生25个距离。@BillTP那么您需要每个类型_0和类型_1之间的距离。忘了你需要字典的清单吧。谢谢。我只想计算25个距离。您的代码会产生令人满意的结果。