how many bytes in an int

[Reid Nichol]

Hello,
I was wondering if I could control how many bytes are in an int and
the byte order. In C/C++ I can use int32 but how do I do this in
python? How can I control byte order?

[Grant Edwards]

On 2004-08-09, Reid Nichol <rn*********@ya hoo.com> wrote:

I was wondering if I could control how many bytes are in an int and
the byte order. In C/C++ I can use int32 but how do I do this in
python? How can I control byte order?

I suspect you want to use the "struct" module -- but it's a
guess, since you haven't really said what it is you're trying
to accomplish.

--
Grant Edwards grante Yow! My polyvinyl cowboy
at wallet was made in Hong
visi.com Kong by Montgomery Clift!

[Martin v. Löwis]

Reid Nichol wrote:

I was wondering if I could control how many bytes are in an int and
the byte order. In C/C++ I can use int32 but how do I do this in
python? How can I control byte order?

You can't. Python uses as many bytes as are necessary to represent
the number (larger numbers - more bytes). Why do you want to control
the number of bytes?

Regards,
Martin

[Reid Nichol]

Grant Edwards wrote:

On 2004-08-09, Reid Nichol <rn*********@ya hoo.com> wrote:

I was wondering if I could control how many bytes are in an int and
the byte order. In C/C++ I can use int32 but how do I do this in
python? How can I control byte order?

I suspect you want to use the "struct" module -- but it's a
guess, since you haven't really said what it is you're trying
to accomplish.

I'm thinking of writing a movie file encoder (probably avi). So, I need
to output DWORD (lookup revealed its a 4-byte int) to a binary file.
Therefore I need to know whether this can be done in python or not,
which will tell me whether I'll try to do it or not.

But, since the 64-bit archecture is out, short, long, etc may change
there meanings quite soon. From what I've read in the struct module
docs I can only tell it that it's a short, long, etc. but not whether
it's exactly a 4-byte int. Is there a way to do this?

[Grant Edwards]

On 2004-08-09, Reid Nichol <rn*********@ya hoo.com> wrote:

I suspect you want to use the "struct" module -- but it's a
guess, since you haven't really said what it is you're trying
to accomplish.

I'm thinking of writing a movie file encoder (probably avi).
So, I need to output DWORD (lookup revealed its a 4-byte int)
to a binary file. Therefore I need to know whether this can
be done in python or not, which will tell me whether I'll try
to do it or not.

But, since the 64-bit archecture is out, short, long, etc may
change there meanings quite soon. From what I've read in the
struct module docs I can only tell it that it's a short, long,
etc. but not whether it's exactly a 4-byte int. Is there a
way to do this?

The struct module is the only thing I know about. If you're
worried about the "C" types in the struct module changing
underneat you, you could do a pure Python implimentation of
"python-int" to/from DWORD. It's utterly trivial and shouldn't
take more than one or two lines of code.

--
Grant Edwards grante Yow! LOOK!!! I'm WALKING
at in my SLEEP again!!
visi.com

[Grant Edwards]

On 2004-08-09, Grant Edwards <gr****@visi.co m> wrote:

The struct module is the only thing I know about. If you're
worried about the "C" types in the struct module changing
underneat you, you could do a pure Python implimentation of
"python-int" to/from DWORD. It's utterly trivial and shouldn't
take more than one or two lines of code.

def toLittleEndianD WORD(i):
return ''.join(map(chr ,[x&0xff for x in [i,i>>8,i>>16,i> >24]]))

def fromLittleEndia nDWORD(s):
return ord(s[0]) + (ord(s[1])<<8) + (ord(s[2])<<16) + (ord(s[3])<<24)

--
Grant Edwards grante Yow! Well, O.K. I'll
at compromise with my
visi.com principles because of
EXISTENTIAL DESPAIR!

[Martin v. Löwis]

Reid Nichol wrote:

I'm thinking of writing a movie file encoder (probably avi). So, I need
to output DWORD (lookup revealed its a 4-byte int) to a binary file.
Therefore I need to know whether this can be done in python or not,
which will tell me whether I'll try to do it or not.
You looked up DWORD somewhat incorrectly. It is a four byte int in
memory, but on disk, it is a little-endian byte string of four bytes.

So you *do* need the struct module, because only that will give you
byte strings (of course, Grant's formula also works)
But, since the 64-bit archecture is out, short, long, etc may change
there meanings quite soon. From what I've read in the struct module
docs I can only tell it that it's a short, long, etc. but not whether
it's exactly a 4-byte int. Is there a way to do this?

As Grant says: use the struct module. Use struct.calcsize to find out
how large an int is. If the size is too large, try a short. If the size
is too small, try a long. If no type matches, take the next larger type,
and drop the extra bytes.

However, it does not actually need to be that difficult: "int" is 32-bit
on all current systems, including all 64-bit systems (only long is
64-bits on some 64-bit systems).

Regards,
Martin

[Robin Becker]

Grant Edwards wrote:

On 2004-08-09, Grant Edwards <gr****@visi.co m> wrote:

The struct module is the only thing I know about. If you're
worried about the "C" types in the struct module changing
underneat you, you could do a pure Python implimentation of
"python-int" to/from DWORD. It's utterly trivial and shouldn't
take more than one or two lines of code.

def toLittleEndianD WORD(i):
return ''.join(map(chr ,[x&0xff for x in [i,i>>8,i>>16,i> >24]]))

def fromLittleEndia nDWORD(s):
return ord(s[0]) + (ord(s[1])<<8) + (ord(s[2])<<16) + (ord(s[3])<<24)

this simple code will give warnings in 2.3, I think struct is really needed.

toLittleEndianD WORD(-1) '\xff\xff\xff\x ff' fromLittleEndia nDWORD(toLittle EndianDWORD(-1)) __main__:2: FutureWarning: x<<y losing bits or changing sign will return
a long in Python 2.4 and up
-1

--
Robin Becker

[Grant Edwards]

On 2004-08-09, Robin Becker <ro***@SPAMREMO VEjessikat.fsne t.co.uk> wrote:

Grant Edwards wrote:

On 2004-08-09, Grant Edwards <gr****@visi.co m> wrote:

The struct module is the only thing I know about. If you're
worried about the "C" types in the struct module changing
underneat you, you could do a pure Python implimentation of
"python-int" to/from DWORD. It's utterly trivial and shouldn't
take more than one or two lines of code.

def toLittleEndianD WORD(i):
return ''.join(map(chr ,[x&0xff for x in [i,i>>8,i>>16,i> >24]]))

def fromLittleEndia nDWORD(s):
return ord(s[0]) + (ord(s[1])<<8) + (ord(s[2])<<16) + (ord(s[3])<<24)

this simple code will give warnings in 2.3,

I think struct is really needed.

Like the man said, "struct" doesn't convert to-from integers of
specified byte lengths. All it has are the C types "int"
"long" "long long", etc. There is no portable way using struct
to request a 4-byte integer.

toLittleEndianD WORD(-1) '\xff\xff\xff\x ff' fromLittleEndia nDWORD(toLittle EndianDWORD(-1))

__main__:2: FutureWarning: x<<y losing bits or changing sign will return
a long in Python 2.4 and up
-1

Hopefully that can be fixed? Python integer objects seem to
get more difficult to work with every year. ;) A few weeks
back, somebody posted code for fixed length Python integer
objects.

--
Grant Edwards grante Yow! YOU PICKED KARL
at MALDEN'S NOSE!!
visi.com

[Grant Edwards]

On 2004-08-09, Grant Edwards <gr****@visi.co m> wrote:

I think struct is really needed.

Like the man said, "struct" doesn't convert to-from integers
of specified byte lengths. All it has are the C types "int"
"long" "long long", etc. There is no portable way using
struct to request a 4-byte integer.

I like the "calcsize" suggestion for "portablizi ng" the struct
method. Once at program startup you figure out what struct
formats you need for various lengths and Bob's your uncle.

--
Grant Edwards grante Yow! FIRST, I'm covering
at you with OLIVE OIL and
visi.com PRUNE WHIP!!