5

Had a basic question after reading the Cython documentation on classes, but I thought to get it clear. Here is a sample code from the Cython documentation: 

cdef class Rectangle:
    cdef int x0, y0
    cdef int x1, y1
    def __init__(self, int x0, int y0, int x1, int y1):
        self.x0 = x0; self.y0 = y0; self.x1 = x1; self.y1 = y1
    cpdef int area(self):
        cdef int area
        area = (self.x1 - self.x0) * (self.y1 - self.y0)
        if area < 0:
            area = -area
        return area

Why is the __init__ preceded by def and not cdef or cpdef?

I realize that there is a __cinit__ function, but shouldn't making cpdef __init__ make the __init__ code faster?

Or, are we supposed to put the code, that we need to make very fast, in the __cinit__ section and the code, which we can afford to run slower, in the __init__ section?

uday
  • 6,453
  • 13
  • 56
  • 94
  • `__init__` and `__cinit__` are the constructors of your object. In a well designed program you usually do not have any time critical calculations in a constructor. Also `__cinit__` and `__init__` are not equivalent. If you have to initialize `c` parts of your objects (e.g. a `malloc`) then this happens in `__cinit__` and normal python initialization happens in `__init__` – cel Jul 27 '15 at 11:14
  • i understand this (and this is in the documentation too). what i wanted to ask is that why codes use `def __init__` instead of say `cpdef __init__` – uday Jul 27 '15 at 11:49
  • I am not sure if `cpdef __init__` even works. apart from that - I don't see a reason for doing that. Why would you prefer `cpdef`? – cel Jul 27 '15 at 11:52

1 Answers1

1

cpdef does not affect the speed of the code inside the function. It only creates a version of the function that can be called directly from C/Cython (without having to go through the Python call mechanism). The "inside" of the function is compiled in both cases and runs at exactly the same speed. See Definition of def, cdef and cpdef in cython for a full discussion.

Most Cython special functions (those with names of the form __xxx__) are restricted to being defined as def functions. Essentially because they serve a special purpose to the Python interpreter and Cython won't be able to use the C shortcut version. __init__ is no exception - it's part of the normal Python construction mechanism and so it only make senses to call it as a Python method.

__cinit__ is a slightly odd case - it can only be invoked by the Cython (implicitly) and cannot be called by the user. It therefore isn't really either a normal def, cdef or cpdef method. It's therefore just a matter of language design what keyword is used to define it (whatever you chose, it'd always be called in the same way anyway). In terms of what arguments it accepts it behaves like a def function though since it can handle *args and **kwds but only types that can be directly converted from Python objects (i.e. not C pointers).

If you can to make an alternate cdef (or cpdef) staticmethod constructor to be called directly from Cython you can. This is discussed in the documentation.

DavidW
  • 29,336
  • 6
  • 55
  • 86