Python类内部访问类属性的优雅方式探讨

Great question! Let’s break down the two approaches you’ve outlined, since PEP8 doesn’t lay out a strict one-size-fits-all rule here— the right choice depends on your intent and use case.

First, let’s restate your example for clarity:

class MyClass(object):
    BAR = 1
    def foo(self):
        # Way A:
        print(self.BAR)
        # Way B:
        print(MyClass.BAR)

Both methods work, but here’s when to pick each:

• Way A: Using self.BAR

  • This is the more flexible, object-oriented approach. If you ever create a subclass that overrides BAR, using self will automatically use the subclass’s value instead of the parent class’s original. For example:

    class MySubclass(MyClass):
        BAR = 2
    
    obj = MySubclass()
    obj.foo()  # Prints 2 (via self.BAR) and 1 (via MyClass.BAR)
    

  • It also keeps your code maintainable: if you rename MyClass later, you won’t have to update every hardcoded reference to MyClass.BAR inside methods.
  • It feels intuitive because you’re accessing an attribute through the instance, which aligns with how most instance-level operations work.

• Way B: Using MyClass.BAR

  • Use this when you specifically want to reference the parent class’s attribute, ignoring any subclass overrides. It makes your intent crystal clear to other developers: "I need exactly the value defined in MyClass, not anything from a child class."
  • It also explicitly signals that BAR is a class-level (static) attribute, which can help readers quickly understand the attribute’s scope.

Quick Rule of Thumb #

• Choose self.BAR if you want your method to adapt to subclass changes and avoid hardcoding class names.
• Choose MyClass.BAR if you need to enforce using the parent class’s exact value and make your intent unambiguous.

PEP8 stays quiet on this because it’s context-dependent—both are valid, and the best call hinges on what you’re trying to achieve with the attribute access.

内容的提问来源于stack exchange，提问作者Ofek .T.