Python class 和方法 - 访问和更改属性的最佳实践？

Question

TLDR: What's best practice for accessing and altering attributes of a class instance?

Let's say we have a class to generate an object that is intended to hold data about a product (eg maybe a product master dataset).

class StoreProduct(object):

    def __init__(self,ProductID,ProductPrice,ProductDescription):
        self.ProductID = ProductID
        self.ProductPrice = ProductPrice
        self.ProductDescription = ProductDescription


    def ChangeProductPrice(self, newProductPrice):
        self.ProductPrice = newProductPrice

And we have another class we may be able to use to access those instances generated by StoreProduct(), with methods for making adjustments / changes.

class ChangeProductData(object):

    def __init__(self):
        pass
    @staticmethod
    def ChangeProductObjectPrice(newProductPrice,ProductObject):

        ProductObject.ProductPrice = newProductPrice

So we generate an instance named Product1:

Product1 = StoreProduct(
    ProductID="Product1",
    ProductPrice=4,
    ProductDescription="A nice lamp"
)

What's best practice coding for reading and/or altering class instances?

If I wanted to alter an attribute in Product 1 (in this case the price) is something like this acceptable in general, or is it bad code?

Method 1

ChangeProductData().ChangeProductObjectPrice(8,Product1)

Or is this the preferred way to do it?

Method 2

Product1.ChangeProductPrice(2)

When might there be exceptions?

While the above are simplified situations, what I've currently read seems to indicate that Method 2 might be better practice. However, wouldn't Method 1 provide greater flexibility in future (eg if you need to change how a method works, or add new methods).

I have also been reading into getattr() and setattr(), but people seem to be mixed on whether its better than using dot (eg Product1.ProductPrice to get the price).

Answer 1

Definitely method 2. As @user2357112 mentions, method 1 doesn't make sense. As you rightly pointed out, this is a simple scenario and the pythonic way would be use property

class StoreProduct(object):  # minor: please notice the PEP styling
    def __init__(self, product_price):
        self._price = produce_price
        # other attributes, omitted for brevity

    @property
    def product_price(self):  # pythonic getter
        return self._price

    @product_price.setter
    def product_price(self, new_price):  # python setter
        # you could do any custom validation before setting
        self._price = new_price

Coming to the question of

I'm specifically tackling the issue of whether accessing and altering an class' attribute with another class is a big no-no.

• Accessing: Accessing is okay here. In fact many design patterns that rely on composition heavily do this. eg, adapter , strategy , decorator , command etc patterns

• Altering: You want the class owning the attribute to be in charge of "altering". Foreign classes should only request to alter .

PS This is treading a bit along the lines of CQRS(Command Query Responsibility Segregation) pattern