1

我想从均匀分布中绘制公司类型 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：从这里开始，我被卡住了。我必须调用距离方法来计算两种公司类型（即自我和其他）之间的每一个距离，并将它们保存到一个列表中。任何帮助，将不胜感激。

问题 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)
   ...

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

4

3 回答 3

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产生输入迭代的笛卡尔积。

于 2013-10-28T20:11:26.073 回答
1

我不确定我是否理解。

您的代码似乎还不错，这样的性能改进空间不大，那么无论如何，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)

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

编辑： 要获取每个 type_1 的每个 type_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])
于 2013-10-28T20:12:40.320 回答
1

我不太确定你想要完成什么......这是一个生成器的例子，它有点像你想要的，对吧？5×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是什么意思？你被困在哪里了？你想要完成什么？

于 2013-10-28T21:01:10.573 回答