Question

我一直在努力为以下应用程序找到面向对象编程的好模式。

假设您有一个需要修改的对象 - 也许，该对象是一个房子，其房产价格将被修改/添加。此修改基于属性dimension_x和dimension_y。但是为了设定价格，我们需要比较来自具有dimension_x和dimension_y的其他类（在本例中为Houses）的实例。

class Houses(object):
  def __init__(self, dimension_x=None, dimension_y=None):
    self.dimension_x = dimension_x
    self.dimension_y = dimension_y

class City(object):
  def __init__(self, houses_without_price=None):
    self.houses_without_price = houses_without_price
    self.houses = []
  def set_dimensions(self, house1_without_price, house2_with_price):
      # calculate dimension_x, dimension_y and set these properties 
      # in an instance of Houses
  def set_price(self, house1):
     # based on dimension_x and dimension_y from our instance of Houses, 
     # add a price to the instances of self.houses_without_price

所以基本上我们的类Houses只是dimension_x和dimension_y的存储。显然，我可以使用字典代替。但是，houses_without_price和字典之间的交互往往过于复杂。例如：

d = [{'object': house_without_price_1, 'dimension_x': 20, 'dimension_y': 34}, 
{'object': house_without_price_2, 'dimension_x': 43, 'dimension_y': 55}...]

然后计算价格属性。

处理对象之间这种交互的最佳方法是什么？

Answer 1

创建一个经理类。

包含所有众议院类的东西，我们说一个列表。

然后你可以在管理器类中包含一个函数，如：

def CompareDimensions(self):
    dims = [list(instance.GetDimensions()) for instance in self.house_list]
    dims = numpy.array(dims)
    # .... futher processing on matrix

假设您的house类有一个名为GetDimensions的函数，它返回一个（dim_x，dim_y）元组，您可以轻松构建一个矩阵来比较这些值。

使用经理还可以让您永远不必直接处理每个房屋类，但您可以从经理那里抽象出流程。比如创建一个名为PushNewHouse的经理函数（self，dim_x，dim_y）

更详细的解释：

import numpy # Assuming you have numpy available

class Houses(object):
    def __init__(self, dimension_x=None, dimension_y=None):
        self.dimension_x = dimension_x
        self.dimension_y = dimension_y
    def GetDimensions(self):
        return (self.dimension_x,self.dimension_y)

class HouseManager(object):
    def __init__(self):
        self.house_list = []
    def PushNewHouse(self,dim_x,dim_y):
        self.house_list.append(House(dim_x,dim_y))
    def CompareDimensions(self):
        dims = [list(instance.GetDimensions()) for instance in self.house_list]
        dims = numpy.array(dims)
        # .... futher processing on matrix

Answer 2

我不知道python，但在C＃中它看起来像这样：

public class House(){
    public double X { get; set; }
    public double Y { get; set; }
    public double Area(){
       return X*Y;
    }
    public double Value { get; set; }
}

不确定如何在python中定义字典，但基本上在C＃中就像伪代码一样，你想要

Dictionary<double, List<House>> HousesWithValue = new Dictionary<int, List<House>>();

我对该过程的原始理解是，您将拥有一系列已知值的房屋，这些房屋将被添加到字典中。你有一个没有价值的新房子。因此，当您将其添加到城市时，首先，根据区域检查字典，然后从该列表中，您可以从房屋值中获得平均价格。

但如果没有房子有价格，那么你基本上只是寻找的是一种方法来排序那些拥有你有价值的房产的房屋。

//道歉，如果这不是正确的python，我对它并不熟悉。

house_tuples = [
    ('house1', 20, 30, 600),
    ('house2', 30, 40, 1200),
    ('house3', 30, 30, 900),
]
>>> sorted(house_tuples, key=lambda house: house[3])   # sort by area or something

然后，您可以根据区域或其他内容对列表进行排序。即使您不了解绝对值，这也可以为您提供“相对”价格的图片。因此，如果在排序之后，事实证明house3是第二个，那么它将具有中间值或其他值。

面向对象编程中对象的交互

2 个答案: