使用扩展在Python中创建新类型

Question

I've read the documentation and coded up my own example based on their Noddy example:

https://docs.python.org/3.4/extending/newtypes.html

This is a bit of a departure from using Py_BuildValue() to build arbitrary objects dynamically. It appears that the underlying assumption is that there's a C structure backing every object instance you want to create.

Is this really the only (best?) way to create new objects in Python? I was hoping to create a new object and declare members/types similar to how you would create tuples, lists, and dictionaries etc. It seems like it should be possible to declare a new type, declare members and their types, and then plug values in field-by-field w/o all this.

I can't even use the structure defined by the existing API of what I'm gluing because Python objects require the compulsory PyObject_HEAD field. I have to define a new C structure, copy the relevant elements that were handed back to me from the API call. It just seems like a level of memory management on the C side that should be unnecessary.

Answer 1

Sure, there's another way to create types in Python. Perhaps you've seen it?

class Foo():
    def __init__(self):
        ....

I'm being a little glib, of course. But when exposing a C interface to Python, it's often a good idea to have a Python script doing much of the interfacing; after all, it's quicker to write Python code than CPython binding code. And if what you have is basically an opaque handle type and a set of C functions which create/operate on those handles, you can simply expose those functions as free functions, and use them from your Python-side binding code. (You might even be able to do it without writing a single line of CPython binding code, using ctypes .)

Answer 2

So, rather than creating a new type, I was reading up on manipulating tuples in piecewise fashion and there's a section on struct sequences. This is sort of what I was originally envisioning:

https://docs.python.org/3.4/c-api/tuple.html

It doesn't have all the power that a new type provides, but for communicating struct-like objects back to the caller with named attributes, this seems like a pretty easy way to go.

I'm curious what you folks think about this...