Question: I am having a lot of confusion using the `sys.getsizeof` function in python. All I want to find out is that for say a floating point value, is the system using 4 or 8 bytes (i.e. single or double precision in C terms).

I do the following:

```
import sys

x = 0.0
sys.getsizeof(x)  # Returns 24

type(x) # returns float

sys.getsizeof(float)  # Returns 400.

```

How can I simply find out the how many bytes are actually used for the floating point representation. I know it should be 8 bytes but how can I verify this (something like the `sizeof` operator in C++)

Answer: 
Running

```
sys.getsizeof(float)

```

does not return the size of any individual float, it returns the size of the `float` *class*. That class contains a lot more data than just any single float, so the returned size will also be much bigger.

If you just want to know the size of a single float, the easiest way is to simply instantiate some arbitrary float. For example:

```
sys.getsizeof(float())

```

Note that

```
float()

```

simply returns `0.0`, so this is actually equivalent to:

```
sys.getsizeof(0.0)

```

This returns `24` bytes in your case (and probably for most other people as well). In the case of CPython (the most common Python implementation), every `float` object will contain a reference counter and a pointer to the type (a pointer to the `float` class), which will each be 8 bytes for 64bit CPython or 4 bytes each for 32bit CPython. The remaining bytes (`24 - 8 - 8 = 8` in your case which is very likely to be 64bit CPython) will be the bytes used for the actual float value itself. 

This is not guaranteed to work out the same way for other Python implementations though. The [language reference](https://docs.python.org/3/reference/datamodel.html#objects-values-and-types) says:

> 
> These represent machine-level double precision floating point numbers. You are at the mercy of the underlying machine architecture (and C or Java implementation) for the accepted range and handling of overflow. Python does not support single-precision floating point numbers; the savings in processor and memory usage that are usually the reason for using these are dwarfed by the overhead of using objects in Python, so there is no reason to complicate the language with two kinds of floating point numbers.
> 
> 
> 

and I'm not aware of any runtime methods to accurately tell you the number of bytes used. However, note that the quote above from the language reference does say that Python only supports double precision floats, so in most cases (depending on how critical it is for you to always be 100% right) it should be comparable to double precision in C.
From [the docs](https://docs.python.org/3/library/sys.html#sys.getsizeof):

> 
> getsizeof() calls the object’s **sizeof** method and adds an additional garbage collector overhead if the object is managed by the garbage collector.
> 
> 
> 

`sys.getsizeof` is not about the byte size as in C.

For `int` there is [`bit_length()`](https://docs.python.org/3/library/stdtypes.html#int.bit_length).