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

Question

I have been struggling trying to find a nice pattern in objected oriented programming for the following application.

Suppose you have an object that needs to be modified - maybe, the object is a house and its property price will be modified/added. This modification is based on properties dimension_x and dimension_y . But in order to set a price, we need to compare instances from other class (in this case, Houses) that have dimension_x and dimension_y .

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

So basically our class Houses is just a storage for dimension_x and dimension_y. Obviously, I could use a dictionary instead. However, the interaction between the houses_without_price and a dictionary tends to be overcomplicated. For example:

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

and then calculate the price property.

What is the best way to deal with this kind of interaction between objects?

Answer 1

Create a manager Class.

Something that will contain all the House Classes, in let's say a list.

Then you can include a function in the manager class like:

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

Assuming your house class has a function called GetDimensions, which returns a tuple of (dim_x,dim_y), you can easily build a matrix to compare these values.

Using a manager will also give you the ability to never having to directly deal with each individual house class, but you can abstract the processes from the manager. Such as creating a manager function called PushNewHouse(self,dim_x,dim_y)

A more detailed explaination:

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

I don't know python, but in C# it would look something like this:

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

Not sure how you define a dictionary in python, but basically in C# like pseudocode, you want

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

My original understanding of the process was that you would have a whole collection of houses with known values that get added to the dictionary. You have a new house that has no value. So when you add it to the city, first, check the dictionary based on the area, and from that list, you can get the average price from the house values.

But if none of the houses have a price, what you are basically just looking for is a way to SORT the houses that have properties that you do have values for.

// my apologies if this isn't correct python, I'm not that familiar with it.

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

Then you can sort the list based on area or something. This could give you a picture of the "relative" price even if you have no knowledge of absolutes. So if after sorting, it turns out that house3 is second, then it will have a value in the middle or whatever.