[Python-Dev] Subclassing varying length types (What's a PyStructSequence ?)
Mon, 10 Dec 2001 00:22:15 -0500
> Have you tried disabling all free list and using pymalloc
> instead ?
No, but I haven't tried anything -- it's a 2.3 issue.
> If this pays off, I agree, we should get rid off all of them.
When I do try it <wink>, it will be slower but more memory-efficient (both
data and code) than the type-specific free lists, and faster and much more
memory-efficient than using malloc().
> I would consider moving from 8-bit strings to Unicode an
> improvement in flexibility.
Sure. Moving from one malloc to two is orthogonal.
> It also results in better algroithms (== simpler, less error-prone,
> etc. in this case).
Unclear what "it" means; assuming it means using two mallocs instead of one
for a Unicode string object, the 8-bit string algorithms haven't been a
particular source of bugs. People mutating strings at the C level has been.
> As I said, it's a tradeoff flexibility vs. memory consumption.
> Whether it pays off depends on your application environment. It
> certainly does for companies like Micron and pays off stock-wise
> for a lot of people... uhm, getting off-topic here :-)
I've got nothing against Unicode (apart from the larger issue that the whole
world would obviously be a lot better off if they switched to American
>> Subclassing seems easy enough to me from the Python level; I
>> don't have time to revisit C-level subclasssing here (and I don't
>> know that it's hackish there either, but do think it's in need of
> It is beautifully easy for non-varying-length types. Unfortunately,
> it happens that some of the basic types which would be attractive
> for subclassing are varying length types (such as string and
It's easy to subclass from str and tuple in Python -- even to add your own
> In my case, I'm looking for away to subclass strings, but I haven't
> yet found an elegant solution to the problem of adding extra
> data to the instances.
It's easy if you're willing to use a dict:
def __new__(cls, strguts, n):
self = str.__new__(cls, strguts)
self.n = n
s = STR('abc', 42)
print s # abc
print s.n # 42
__slots__ doesn't work here, though.
I admit I personally don't see much attraction to subclassing from str and
tuple, apart from adding additional *methods*. I suppose someone could code
up two-malloc variants ...