ctypes.cast.

>>> import ctypes
>>> c_long_p = ctypes.POINTER(ctypes.c_long)
>>> some_long = ctypes.c_long(42)
>>> ctypes.addressof(some_long)
4300833936
>>> ctypes.cast(4300833936, c_long_p)
<__main__.LP_c_long object at 0x1005983b0>
>>> ctypes.cast(4300833936, c_long_p).contents
c_long(42)

Here's a utility function based on a (now-deleted) comment made by "Tiran" in a weblog discussion @Hophat Abc references in his own answer that will work in both Python 2 and 3.

Disclaimer: If you read the the linked discussion, you'll find that some folks think this is so unsafe that it should never be used (as likewise mentioned in some of the comments below). I don't agree with that assessment but feel I should at least mention that there's some debate about using it.

import _ctypes

def di(obj_id):
    """ Inverse of id() function. """
    return _ctypes.PyObj_FromPtr(obj_id)

if __name__ == '__main__':
    a = 42
    b = 'answer'
    print(di(id(a)))  # -> 42
    print(di(id(b)))  # -> answer

I don't know why we need to use 2 dereferencing stars instead of just writing (*arr+i) = value;

Since arr is a pointer to a pointer to an int, *arr+1 is a pointer to an int. You need a double pointer so that you could change the vale of the variable from inside a function call.

The general rule is if you need to change a variable of type sometype inside a function, you need to pass sometype* into the function, and use an additional asterisk inside to make assignments. Otherwise, changes that you make to parameter inside the function will remain local to the function. In this case, sometype is itself a pointer (i.e. int*) so in order to modify it inside allocateArray you need to pass int**.

Note: in C you do not need to cast malloc, so the second line of code can be rewritten like this:

*arr = malloc(size * sizeof(int));

1. Let's have a look at your Cython code

cdef double *c_arr3 = <double *>malloc(2*sizeof(double))
c_arr3[:] = [1.0, 2.0]

Here, the python list [1.0, 2.0] is only meant to initialise the block of memory on the heap your pointer c_arr3 points to. Therefore, there's no need to create a python list from a performance perspective. That's one of the reasons why Cython will roughly generate the following C code instead:

/* allocate the memory */
double* c_arr3 = (double*) malloc(2*sizeof(double));

/* create a C array (instead of a list) to initialize c_arr3 */
double tmp[2];
tmp[0] = 1.0;
tmp[1] = 2.0;

/* copy all values of tmp into c_arr3 */
memcpy(&c_arr3[0], &tmp[0], 2*sizeof(double));

The a[:] = expr is Cython's slicing syntax that is typically used for typed memoryviews and works pretty similar to numpy arrays. Thus, it's mainly used to copy values of the right-hand-side expr into a.

2. c_arr3[:]and c_arr4[:] are no double*. It's just syntactic sugar in Cython for copying values (see the above C code), which also means that it can be used to initialize blocks of memory. However, at the time of writing, initialization via c_arr3[:] = expr only works for simple right-hand side literals like python lists.

3. Yes, you could use a typed memoryview instead of raw pointers:

cdef double[::1] c_mv = <double[:2]>malloc(2*sizeof(double))

# set all values to 1.0
c_mv[:] = 1.0

# initialize it with the values of np_arr
# note that you don't need to convert np_arr to a list
c_mv[:] = np_arr[:]

# don't forget to free the memory!
free(&c_mv[0])