请注意：我考虑过的属性，但我不认为他们是一个清洁的解决方案

块引用>

但他们。通过使用属性，你有你想要的类签名，而能够使用的属性作为属性本身

 高清_get_id（个体经营）：
   回报self._id高清_set_id（个体经营，newid的）：
   self._id = NEWID
 

很可能类似于你现在所拥有的。为了安抚你的团队，你只需要添加以下内容：

  ID =财产（_get_id，_set_id）
 

您也可以使用属性作为装饰：

  @property
DEF ID（个体经营）：
    回报self._id@ id.setter
DEF ID（个体经营，newid的）：
    self._id = NEWID
 

，并使其只读，只留下了 set_id /的 id.setter 位。

I realize that in most cases, it's preferred in Python to just access attributes directly, since there's no real concept of encapsulation like there is in Java and the like. However, I'm wondering if there aren't any exceptions, particularly with abstract classes that have disparate implementations.

Let's say I'm writing a bunch of abstract classes (because I am) and that they represent things having to do with version control systems like repositories and revisions (because they do). Something like an SvnRevision and an HgRevision and a GitRevision are very closely semantically linked, and I want them to be able to do the same things (so that I can have code elsewhere that acts on any kind of Repository object, and is agnostic of the subclass), which is why I want them to inherit from an abstract class. However, their implementations vary considerably.

So far, the subclasses that have been implemented share a lot of attribute names, and in a lot of code outside of the classes themselves, direct attribute access is used. For example, every subclass of Revision has an author attribute, and a date attribute, and so on. However, the attributes aren't described anywhere in the abstract class. This seems to me like a very fragile design.

If someone wants to write another implementation of the Revision class, I feel like they should be able to do so just by looking at the abstract class. However, an implementation of the class that satisfies all of the abstract methods will almost certainly fail, because the author won't know that they need attributes called 'author' and 'date' and so on, so code that tries to access Revision.author will throw an exception. Probably not hard to find the source of the problem, but irritating nonetheless, and it just feels like an inelegant design.

My solution was to write accessor methods for the abstract classes (get_id, get_author, etc.). I thought this was actually a pretty clean solution, since it eliminates arbitrary restrictions on how attributes are named and stored, and just makes clear what data the object needs to be able to access. Any class that implements all of the methods of the abstract class will work... that feels right.

Anyways, the team I'm working with hates this solution (seemingly for the reason that accessors are unpythonic, which I can't really argue with). So... what's the alternative? Documentation? Or is the problem I'm imagining a non-issue?

Note: I've considered properties, but I don't think they're a cleaner solution.

Note: I've considered properties, but I don't think they're a cleaner solution.

But they are. By using properties, you'll have the class signature you want, while being able to use the property as an attribute itself.

def _get_id(self):
   return self._id

def _set_id(self, newid):
   self._id = newid

Is likely similar to what you have now. To placate your team, you'd just need to add the following:

id = property(_get_id, _set_id)

You could also use property as a decorator:

@property
def id(self):
    return self._id

@id.setter
def id(self, newid):
    self._id = newid

And to make it readonly, just leave out set_id/the id.setter bit.