In http://docs.python.org/dev/library/struct.html,

it says
"Native byte order is big-endian or little-endian, depending on the host 
system. For example, Motorola and Sun processors are big-endian; Intel 
and DEC processors are little-endian."

This is a gross over-generalization at best.  Off the top of my head, 
current Linux kernels run the Intel Itanium in big-endian mode. (Though, 
I don't recall if there's a non-privileged instruction to flip 
endianness, system headers and system calls are defined in big-endian 
order, which is what's most relevant to the struct module.)  Sun SPARC 
v9 is bi-endian. Intel Itanium and XScale processors are bi-endian.  Dec 
Alphas are bi-endian.  (Though, I'm only aware of Cray using Alphas in 
big-endian mode.)

The quoted paragraph should name specific processors which are single-
endian (Intel Core 2, Sun SPARC v8) and/or provide a Wikipedia 
reference, rather than making incorrect statements.

Intel Itanium machines running Linux are probably the most common 
systems where this statement's inaccuracy is likely to cause confusion 
among developers.

Something like "Motorola and Sun processors are usually big-endian;
Intel and DEC processors are usually little-endian" (or "most
of"/"several") might be enough.

Maybe it's better to avoid the platform-specific statements altogether, 
and just point out the existence of sys.byteorder for those who want to 
check the endianness of the system they're currently working on.

Or maybe just mention that the x86 and AMD64 (aka x86-64) architectures 
are little-endian;  I'd guess that this covers a good proportion of the 
processors that people are currently running Python on.  People using more 
exotic architectures probably already know their endianness.

Good suggestions, Mark! We should do both, I think. I didn't know about
sys.byteorder before your message ;-) Thanks for education!

How about this:

"Native byte order is big-endian or little-endian, depending on the host 
system. For example, Intel x86 and AMD64 (x86-64) are little-endian;
Motorola 68000 and PowerPC G5 are big-endian; some are even bi-endian
(switchable endianess) - ARM and DEC Alpha. Use sys.byteorder to check
the endianess of your system."

Sorry for any spelling and styling mistakes...

Little style:

"Native byte order is big-endian or little-endian, depending on the host 
system. For example, Intel x86 and AMD64 (x86-64) are little-endian;
Motorola 68000 and PowerPC G5 are big-endian; ARM and DEC Alpha feature
switchable endianness (bi-endian). Use sys.byteorder to check the
endianess of your system."

Hey all,

I (a person who just wandered by) think that Alexey Shamrin's suggested text is great.

For that reason, I have turned it into a unified diff created by 'svn diff'.

I hope that would help move this bug along!

I'm attaching that patch against trunk right now.

I'm attaching (basically) the same patch, this time against the py3k branch.

I'm open to improvements to the text. If the text is okay, please just ship these!

Sincerely,

A dude sitting in an open space at PyCon.

Committed to trunk as rev.78308, and to 3.x as rev. 78309.

Thanks to Alexey for the text, and Asheesh for making a patch!