#
2.2 Type Methods

This section aims to give a quick fly-by on the various type methods you can implement and what they do.

Here is the definition of `PyTypeObject`, with some fields only used in debug builds omitted:

      typedef struct _typeobject {
          PyObject_VAR_HEAD
          char *tp_name; /* For printing */
          int tp_basicsize, tp_itemsize; /* For allocation */

          /* Methods to implement standard operations */

          destructor tp_dealloc;
          printfunc tp_print;
          getattrfunc tp_getattr;
          setattrfunc tp_setattr;
          cmpfunc tp_compare;
          reprfunc tp_repr;

          /* Method suites for standard classes */

          PyNumberMethods *tp_as_number;
          PySequenceMethods *tp_as_sequence;
          PyMappingMethods *tp_as_mapping;

          /* More standard operations (here for binary compatibility) */

          hashfunc tp_hash;
          ternaryfunc tp_call;
          reprfunc tp_str;
          getattrofunc tp_getattro;
          setattrofunc tp_setattro;

          /* Functions to access object as input/output buffer */
          PyBufferProcs *tp_as_buffer;

          /* Flags to define presence of optional/expanded features */
          long tp_flags;

          char *tp_doc; /* Documentation string */

          /* Assigned meaning in release 2.0 */
          /* call function for all accessible objects */
          traverseproc tp_traverse;

          /* delete references to contained objects */
          inquiry tp_clear;

          /* Assigned meaning in release 2.1 */
          /* rich comparisons */
          richcmpfunc tp_richcompare;

          /* weak reference enabler */
          long tp_weaklistoffset;

          /* Added in release 2.2 */
          /* Iterators */
          getiterfunc tp_iter;
          iternextfunc tp_iternext;

          /* Attribute descriptor and subclassing stuff */
          struct PyMethodDef *tp_methods;
          struct memberlist *tp_members;
          struct getsetlist *tp_getset;
          struct _typeobject *tp_base;
          PyObject *tp_dict;
          descrgetfunc tp_descr_get;
          descrsetfunc tp_descr_set;
          long tp_dictoffset;
          initproc tp_init;
          allocfunc tp_alloc;
          newfunc tp_new;
          destructor tp_free; /* Low-level free-memory routine */
          PyObject *tp_bases;
          PyObject *tp_mro; /* method resolution order */
          PyObject *tp_defined;

      } PyTypeObject;

Now that's a lot of methods. Don't worry too much though - if you have a type you want to define, the chances are very good that you will only implement a handful of these.

As you probably expect by now, we're going to go over this and give more information about the various handlers. We won't go in the order they are defined in the structure, because there is a lot of historical baggage that impacts the ordering of the fields; be sure your type initializaion keeps the fields in the right order! It's often easiest to find an example that includes all the fields you need (even if they're initialized to `0`) and then change the values to suit your new type.

          char *tp_name; /* For printing */

The name of the type - as mentioned in the last section, this will appear in various places, almost entirely for diagnostic purposes. Try to choose something that will be helpful in such a situation!

          int tp_basicsize, tp_itemsize; /* For allocation */

These fields tell the runtime how much memory to allocate when new objects of this typed are created. Python has some builtin support for variable length structures (think: strings, lists) which is where the `tp_itemsize` field comes in. This will be dealt with later.

          char *tp_doc;

Here you can put a string (or its address) that you want returned when the Python script references `obj.__doc__` to retrieve the docstring.

Now we come to the basic type methods--the ones most extension types will implement.

Subsections

- 2.2.1 Finalization and De-allocation
- 2.2.2 Object Representation
- 2.2.3 Attribute Management Functions
- 2.2.4 Object Comparison
- 2.2.5 Abstract Protocol Support
- 2.2.6 More Suggestions