ctypes in python size with the `sys.getsizeof(Var)` method vs `ctypes.sizeof(Var)`

byte, ctypes, python, size, sys

Solution

If you want to know the details, you should take a look at `objects.h` (especially the comments at the top of the file). Your `ctypes.c_byte(1)` is a Python object:

>>> import sys
>>> import ctypes
>>> isinstance(ctypes.c_byte(1), object)
True

As noted by @Daniel, `sys.getsizeof` gets the size of that Python object. That Python object is larger than the corresponding object in C. Note the following from the `object.h` comments:

Objects are structures allocated on the heap. . . .
The actual memory allocated for an object
contains other data that can only be accessed after casting the pointer
to a pointer to a longer structure type.  This longer type must start
with the reference count and type fields; the macro PyObject_HEAD should be
used for this.

In other words, a macro `PyObject_HEAD` is attached to the start of every object. This increases the size of the Python object.

`ctypes.sizeof`, on the other hand, returns the actual size of the `C` data type that is within the Python object (using C's `sizeof` operator).

EDIT

In light of your goal that you mention in your comment to Daniel's post, it is possible to send one byte over a server in Python 3.x. Below is an example of how you would send a byte using Python's `socket` module to prove this point.

Here is the server, which you will run in one Python interpreter:

# Server
import socket

HOST = ''                      # All available interfaces
PORT = 50007                   # Same port as client
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((HOST, PORT))
s.listen(1)
conn, addr = s.accept()
print('Connected by', addr)
while True:
    data = conn.recv(1)        # receive data with bufsize 1; a larger bufsize will break this code
    if not data: break
    conn.sendall(data)
conn.close()

Here is the client, which you will run in another python interpreter:

# Client
import socket

HOST = '127.0.0.1'             # The remote host, but here using localhost
PORT = 50007                   # The port used by both the client and server
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST, PORT))
s.sendall(b'1')                # a bytes object
data = s.recv(1)               # Receive data from the socket with bufsize of 1
s.close()
print('Received', repr(data))  # confirm receipt

Problem

I have a question about variable size in python, I'm using the the Ctypes because i want a 1 byte number, but when I tried to check it's size in python (via `sys.getsize`) it said it was 80 byte but when i checked with the ctypes (via `ctypes.sizeof`) it said it was 1 byte only, can someone tell me what is the difference and why is there 2 different sizes? is it because python is using an object or wrapper? and when its sent to c it views the real size? ``` import sys import ctypes print("size in ctypes is : ",ctypes.sizeof(ctypes.c_byte(1))) print("size in sys is : ",sys.getsizeof(ctypes.c_byte(1))) ``` results in ``` size in ctypes is : 1 size in sys is : 80 ```

Original source