Open In App

Using Pointers in Python using ctypes

Last Updated : 09 Jan, 2023
Like Article

In this article, we are going to learn about using pointers in Python using ctypes module.

We will see how we can use Pointers in Python programming language using the ctypes module. Some basic operations like storing addresses, pointing to a different variable using pointers, etc. will be demonstrated here. Developers who have used C or C++ might be familiar with the Pointers concept and knows that even though it sometimes becomes hard to grasp but it is very useful. 

What is a Pointer?

A pointer is a special type of variable which stores the memory address of another variable. They can’t store normal values like integers or float or Strings, they can only store Addresses and we can use that address location to print the value which has been stored in that address. Pointers don’t store any value, it only stores address.

Also, if we want to store the address of an Integer variable then our pointer should also be of type integer, for float the pointer must be of type float. We can’t store the address of a String into an Integer pointer.

In languages like C/C++ pointers are heavily used, to get the value to which the pointer is pointing we Dereference that pointer variable i.e while printing it we put the certain format specifier and then use an asterisk (*) with that variable to get the value it was pointing. To get the address we simply print that using the unsigned specifier (%u) as addresses must be unsigned (positive values).

Creating a variable to store a value using the ctypes module

In this we are going to create a pointer value_1 using ctypes module and then printing its type and value.


import ctypes as ct
# value_1 variable stores an integer
# of type Ctypes (not a regular integer)
value_1 = ct.c_int(10)
# printing the type of value_1
# printing the value which value_1 stores

Output: In the above code when we are printing “value_1” it is printing c_long(10) instead of c_int(10) it is so because the size of c_long() and c_int() are same so whenever we are try to print c_int() type it prints c_long(). After that we are printing its value.


Using float and double type:


# Importing ctypes module
import ctypes as ct
# creating a ctypes float variable
float_value = ct.c_float(15.25)
# creating a ctypes double variable
double_value = ct.c_double(85.69845)
# printing what float_value and double_value variable holds
# printing the values stored inside float_value and double_value variable


c_float(15.25) c_double(85.69845)
15.25 85.69845

Pointing to a different variable

Now it is time to do what pointers are used to do i.e pointing to an address/memory location. Also, we will verify that the pointer variable ptr which refers to pointer value_1 printing the same address or not.


import ctypes as ct
# storing a ctypes long value
value_1 = ct.c_long(10)
# using pointer() method we are pointing to the 
# value_1 variable and storing it in ptr
ptr = ct.pointer(value_1)
print("Contents of value_1 : " ,
print("Real value stored in value_1 : ",
print("Address of value_1 : ",
# If we want to print the contents of a pointer
# type variable then need to use .contents
# otherwise only writing the variable is enough like above
print("Contents of ptr variable : ",
# To print the value stored in the address 
# pointed by that pointer variable
# we need to use .value after .contents
print("The value at which ptr points at : ",
# Printing the address of the value to 
# which the ptr variable points at
print("Address of that value which is \
pointed and stored in ptr : ",id(ptr.contents.value))

Explanation: After importing and storing a value in value_1 variable we are using a variable named ptr (resembles pointer) and using the pointer method of the ctypes module to point to that value_1. Now to print what the ptr variable holds we have to use another method named contents which will print the content of the variable that ptr points at (similar to using & in C/C++), not the value of ptr. To print the value of ptr we have to use another method called values after contents this will print the value to which the ptr variable points (similar to using * in C/C++).


Contents of value_1 :  c_long(10)
Real value stored in value_1 :  10
Address of value_1 :  139741265425760
Contents of ptr variable :  c_long(10)
The value at which ptr points at :  10
Address of that value which is pointed and stored in ptr :  139741265425760

In the output, we can see that the id of the last print statement and the third print statement are the same, which means that ptr is pointing the to same memory location.

Changing the value of the variable which the pointer points at using the Pointer

In this, we are first creating a variable value_1 which stores the value 10 which is of ctype long, then using the ptr variable we are pointing to that variable. Now we are printing the value stored in value_1 variable, then we are changing the value of value_1 variable using the ptr variable. Then if we print the value of value_1 variable again, we will see the value stored inside it has changed.


import ctypes as ct
value_1 = ct.c_long(10)
# Creating a pointer which points at a 
# variable which stores c_long type value
ptr = ct.pointer(value_1)
# Printing to see what the void pointer currently holds
print("Value before Changing : " ,
# storing a value in ptr variable
ptr.contents.value = 25
# If we print the value_1 variable it will 
# now store the updated value
print("Value after Changing : ",


Value before Changing :  10
Value after Changing :  25

Void Pointers

As the name suggests void pointer is a type of Pointer that has no specific data type associated with it. It can be typecasted into any type and can hold data of any type. Since in Python the concept of pointers is not properly available or used we can’t properly create a Void Pointer, as the POINTER function requires one argument i.e the data type. But we can create a Void pointer of a certain data type and then don’t point it to any memory address. We are just typecasting it like C/C++ early.

Void Pointers using ctypes

We can also create some void pointers of a specific type that doesn’t hold any address while creating. 


import ctypes as ct
# Creating a variable ptr2 which will act as a void pointer
# We will not point it to any other memory location
ptr2 = ct.POINTER(ct.c_int)
# Trying to print a void pointer


<class '__main__.LP_c_int'>

As we can see that if we try to print this void pointer as it doesn’t point to any value it just points to the type it can store i.e long (ctypes by default converts int to long). Notice one thing here we have used POINTER() instead of pointer that’s because the pointer() function creates a new pointer instance, pointing to an object. In contrast, POINTER() is a factory function that creates and returns a new ctypes pointer type. Pointer types are cached and reused internally, the parameter which we will pass in POINTER() must be of ctypes.

Making the void pointer point to an address

Now we will make the void pointer point to a variable of the same type which has been passed as its argument.


import ctypes as ct
value_1 = ct.c_int(10)
# Creating a void Pointer ptr2
ptr2 = ct.POINTER(ct.c_int)
# Trying to print the contents of the void 
# pointer before pointing it to any variable
print("Contents of Void Pointer : ",
# Now pointing the ptr2 variable to the value_1
# variable which is a ctype c_int
ptr2.contents = value_1
# Now again printing the contents of the ptr2 variable
print("Contents of void pointer after \
pointing it to a variable : ",ptr2.contents)
# Printing the value stored in the Void Pointer
print("Value stored by Void Pointer : ",

Explanation: Hereafter the creation of Void Pointer, we are pointing that ptr2 variable to a ctype c_int variable value_1. Now if we print the contents of the ptr2 variable we will see that it contains c_long(10). Now if we try to print the value stored in the address to which the ex-void pointer points we will get 10 as output. 


Contents of Void Pointer :  <attribute 'contents' of '_ctypes._Pointer' objects>
Contents of void pointer after pointing it to a variable :  c_int(10)
Value stored by Void Pointer :  10

If we don’t point to a memory location but try to print the value of a void pointer we will get an error like below.


import ctypes as ct
value_1 = ct.c_int(10)
ptr = ct.pointer(value_1)
# Creating a void pointer
ptr2 = ct.POINTER(ct.c_int)
# Trying to print the value of a void pointer
# This returns an error


Traceback (most recent call last):
  File "", line 12, in <module>
AttributeError: 'getset_descriptor' object has no attribute 'value'

Null Pointer

A null pointer is also a type of Pointer that doesn’t point to any memory location. The difference between a Null pointer and Void Pointer is that we can’t typecast a Null Pointer to any other data type like Void Pointer.

Null Pointer using ctypes module:

We can also create a Null Pointer using the ctypes module if we create a POINTER type variable without any argument it creates a NULL Pointer.


import ctypes as ct
# Creating a Null Pointer of type c_long
null_ptr = ct.POINTER(ct.c_long)()
# Printing the null pointer

Here we are creating a Null Pointer of type c_long by providing a blank () after the POINTER() method which indicates it is a Null Pointer. Now if we try to print it we will get a Hexadecimal Memory address like below.


<__main__.LP_c_long object at 0x7f5df5740200>

How to check if it is a Null Pointer

We can check the Null Pointer by using the bool() function, the Boolean value of a Null Pointer is always False,


# Importing ctypes module
import ctypes as ct
# Declare a void pointer
void_ptr = ct.POINTER(ct.c_int)
# Printing the boolean value of void pointer
print("Boolean Value of Void Pointer",
# Declare a null pointer
null_ptr = ct.POINTER(ct.c_int)()
# Printing the boolean value of null pointer
print("Boolean Value of Null Pointer",

Explanation: Here we are checking if really we were able to successfully make a Null Pointer. bool() function of Python can be used for this Purpose, the boolean value of the Null Pointer will always be 0 i.e False, which will indicate that we have created a Null Pointer successfully.


Boolean Value of Void Pointer True
Boolean Value of Null Pointer False

Similar Reads

Python | Opaque Pointers in C extension modules
Let's discuss an extension module that needs to handle a pointer to a C data structure, without exposing any internal details of the structure to Python. Opaque data structures can be easily handled by wrapping them inside capsule objects as shown in the code snippet below. Code #1 : typedef struct Point { double x, y; } Point; extern double distan
2 min read
Move all zeroes to end of array using Two-Pointers
Given an array of random numbers, Push all the zero’s of the given array to the end of the array. For example, if the given arrays is {1, 0, 2, 6, 0, 4}, it should be changed to {1, 2, 6, 4, 0, 0}. The order of all other elements should be the same.Examples: Input: arr[]={8, 9, 0, 1, 2, 0, 3} Output: arr[]={8, 9, 1, 2, 3, 0, 0} Explanation: Swap {0
6 min read
Python3 Program for Two Pointers Technique
Two pointers is really an easy and effective technique which is typically used for searching pairs in a sorted array.Given a sorted array A (sorted in ascending order), having N integers, find if there exists any pair of elements (A[i], A[j]) such that their sum is equal to X. Let’s see the naive solution. C/C++ Code # Naive solution to find if the
3 min read
Python program to build flashcard using class in Python
In this article, we will see how to build a flashcard using class in python. A flashcard is a card having information on both sides, which can be used as an aid in memoization. Flashcards usually have a question on one side and an answer on the other. Particularly in this article, we are going to create flashcards that will be having a word and its
2 min read
Python | Visualizing O(n) using Python
Introduction Algorithm complexity can be a difficult concept to grasp, even presented with compelling mathematical arguments. This article presents a tiny Python program that shows the relative complexity of several typical functions. It can be easily adapted to other functions. Complexity. Why it matters? Computational complexity is a venerable su
3 min read
Python - Read blob object in python using wand library
BLOB stands for Binary Large OBject. A blob is a data type that can store binary data. This is different than most other data types used in databases, such as integers, floating point numbers, characters, and strings, which store letters and numbers. BLOB is a large complex collection of binary data which is stored in Database. Basically BLOB is us
2 min read
Creating and updating PowerPoint Presentations in Python using python - pptx
python-pptx is library used to create/edit a PowerPoint (.pptx) files. This won't work on MS office 2003 and previous versions. We can add shapes, paragraphs, texts and slides and much more thing using this library. Installation: Open the command prompt on your system and write given below command: pip install python-pptx Let's see some of its usag
4 min read
Python | Convert LaTeX Matrices into SymPy Matrices using Python
A matrix is a rectangular two-dimensional array of data like numbers, characters, symbols, etc. which we can store in row and column format. We can perform operations on elements by using an index (i,j) where 'i' and 'j' stand for an index of row and column respectively. In the Python programming language, we can represent them in many formats like
5 min read
Python Image Editor Using Python
You can create a simple image editor using Python by using libraries like Pillow(PIL) which will provide a wide range of image-processing capabilities. In this article, we will learn How to create a simple image editor that can perform various operations like opening an image, resizing it, blurring the image, flipping and rotating the image, and so
13 min read
Using Python Environment Variables with Python Dotenv
Python dotenv is a powerful tool that makes it easy to handle environment variables in Python applications from start to finish. It lets you easily load configuration settings from a special file (usually named .env) instead of hardcoding them. This makes your code more secure, easier to manage, and better organized. In this article, we'll see over
3 min read
Practice Tags :