Question: How can I find out the number of Bytes a certain integer number takes up to store?

E.g. for

* hexadecimal `\x00` - `\xff` (or decimal `0` - `255` = binary `0000 0000` - `1111 1111`) I'm looking to get 1 (Byte),
* hexadecimal `\x100` - `\xffff` (or decimal `256` - `65535` = binary `0000 0001 0000 0000` - `1111 1111 1111 1111`) would give me 2 (Bytes)

and so on.

Any clue for hexadecimal or decimal format as the input?

Answer: 
Unless you're dealing with an `array.array` or a `numpy.array` - the size always has object overhead. And since Python deals with BigInts naturally, it's really, really hard to tell...

```
>>> i = 5
>>> import sys
>>> sys.getsizeof(i)
24

```

So on a 64bit platform it requires 24 bytes to store what could be stored in 3 bits.

However, if you did,

```
>>> s = '\x05'
>>> sys.getsizeof(s)
38

```

So no, not really - you've got the memory-overhead of the definition of the `object` rather than raw storage...

If you then take:

```
>>> a = array.array('i', [3])
>>> a
array('i', [3])
>>> sys.getsizeof(a)
60L
>>> a = array.array('i', [3, 4, 5])
>>> sys.getsizeof(a)
68L

```

Then you get what would be called normal byte boundaries, etc.. etc... etc...

If you just want what "purely" should be stored - minus object overhead, then from 2.(6|7) you can use `some_int.bit_length()` (otherwise just bitshift it as other answers have shown) and then work from there
By using a simple biwise operation to move all the used bits over 1 byte each time you can see how many bytes are needed to store a number.

It's probably worth noting that while this method is very generic, it will not work on negative numbers and only looks at the binary of the variable without taking into account what it is stored in.

```
a = 256
i = 0

while(a > 0):
    a = a >> 8;
    i += 1;

print (i)

```

The program behaves as follows:

a is `0000 0001 0000 0000` in binary
each run of the loop will shift this to the left by 8:

```
loop 1:
0000 0001 >> 0000 0000
0000 0001 > 0 (1 > 0)

loop 2:

0000 0000 >> 0000 0001
0000 0000 > 0 (0 > 0)

END 0 is not > 0

```

so there are 2 bytes needed to store the number.