可调用类的不可调用子类(Non-callable subclass of a callable class)

 
 
 是否有机会创建用户定义类型的对象，导致重用现有对象？ 
 
 
 只有在明确设计用户定义类型的情况下才会发生这种情况。 用__new__()或一些元类。 
 
 
 
 我想知道我是否可以验证我的任何班级是否会出现这种行为。 
 
 
 使用源代码，卢克。 
 
 当涉及到int ，小的整数是预分配的，并且这些预分配的整数用于创建用整数计算的任何位置。 当MyInt(1) is MyInt(1)时，你不能得到这个工作，因为你在那里有没有整数。 然而： 
 
>>> MyInt(1) + MyInt(1) is 2
True
 
 这当然是因为MyInt（1）+ MyInt（1）不返回MyInt。 它返回一个int，因为这就是整数的__add__返回的值（这也是对预分配整数的检查发生的地方）。 如果有的话，这只是表明子类int通常不是特别有用。 :-) 
 
 
 
 这是否意味着语言为不覆盖新的用户定义类提供“不同的对象保证”，还是仅仅是一个任意的实现行为？ 
 
 
 它不保证它，因为没有必要这样做。 默认行为是创建一个新的对象。 如果你不希望发生这种情况，你必须重写它。 有保证是没有道理的。 

 
 
Is there any chance that the creation of an object of a user-defined type results in a reuse of an existing object?
 
 
This will happen if, and only if, the user-defined type is explicitly designed to do that. With __new__() or some metaclass.
 
 
 
I'd like to know how I can verify for any class I work with whether it might exhibit such a behavior.
 
 
Use the source, Luke.
 
When it comes to int, small integers are pre-allocated, and these pre-allocated integers are used wherever you create of calculate with integers. You can't get this working when you do MyInt(1) is MyInt(1), because what you have there are not integers. However:
 
>>> MyInt(1) + MyInt(1) is 2
True
 
This is because of course MyInt(1) + MyInt(1) does not return a MyInt. It returns an int, because that's what the __add__ of an integer returns (and that's where the check for pre-allocated integers occur as well). This if anything just shows that subclassing int in general isn't particularly useful. :-)
 
 
 
Does this mean the language provides "distinct object guarantee" for user-defined classes that don't override new, or is it just an arbitrary implementation behavior?
 
 
It doesn't guarantee it, because there is no need to do so. The default behavior is to create a new object. You have to override it if you don't want that to happen. Having a guarantee makes no sense.