diff options
| -rw-r--r-- | Doc/whatsnew/2.6.rst | 47 | ||||
| -rw-r--r-- | Lib/struct.py | 111 |
2 files changed, 46 insertions, 112 deletions
diff --git a/Doc/whatsnew/2.6.rst b/Doc/whatsnew/2.6.rst index 7bd9cbd..54be1e1 100644 --- a/Doc/whatsnew/2.6.rst +++ b/Doc/whatsnew/2.6.rst @@ -483,6 +483,32 @@ PEP 3119: Abstract Base Classes XXX +How to identify a file object? + +ABCs are a collection of classes describing various interfaces. +Classes can derive from an ABC to indicate they support that ABC's +interface. Concrete classes should obey the semantics specified by +an ABC, but Python can't check this; it's up to the implementor. + +A metaclass lets you declare that an existing class or type +derives from a particular ABC. You can even + +class AppendableSequence: + __metaclass__ = ABCMeta + +AppendableSequence.register(list) +assert issubclass(list, AppendableSequence) +assert isinstance([], AppendableSequence) + +@abstractmethod decorator -- you can't instantiate classes w/ +an abstract method. + +@abstractproperty decorator +@abstractproperty +def readonly(self): + return self._x + + .. seealso:: :pep:`3119` - Introducing Abstract Base Classes @@ -554,12 +580,22 @@ Here are all of the changes that Python 2.6 makes to the core Python language. * More floating-point features were also added. The :func:`float` function will now turn the strings ``+nan`` and ``-nan`` into the corresponding - IEEE 754 Not a Number values, and ``+inf`` and ``-inf`` into + IEEE 754 Not A Number values, and ``+inf`` and ``-inf`` into positive or negative infinity. This works on any platform with IEEE 754 semantics. (Contributed by Christian Heimes.) .. Patch 1635. + Other functions in the :mod:`math` module, :func:`isinf` and + :func:`isnan`, return true if their floating-point argument is + infinite or Not A Number. + .. Patch 1640 + The ``math.copysign(x, y)`` function + copies the sign bit of an IEEE 754 number, returning the absolute + value of *x* combined with the sign bit of *y*. For example, + ``math.copysign(1, -0.0)`` returns -1.0. (Contributed by Christian + Heimes.) + * Changes to the :class:`Exception` interface as dictated by :pep:`352` continue to be made. For 2.6, the :attr:`message` attribute is being deprecated in favor of the @@ -612,6 +648,10 @@ Here are all of the changes that Python 2.6 makes to the core Python language. Optimizations ------------- +* All of the functions in the :mod:`struct` module have been rewritten in + C, thanks to work at the Need For Speed sprint. + (Contributed by Raymond Hettinger.) + * Internally, a bit is now set in type objects to indicate some of the standard built-in types. This speeds up checking if an object is a subclass of one of these types. (Contributed by Neal Norwitz.) @@ -1074,12 +1114,13 @@ Changes to Python's build process and to the C API include: .. Issue 1635 -* Some macros were renamed. :cmacro:`Py_Size()` became :cmacro:`Py_SIZE()`, +* Some macros were renamed to make it clearer that they are macros, + not functions. :cmacro:`Py_Size()` became :cmacro:`Py_SIZE()`, :cmacro:`Py_Type()` became :cmacro:`Py_TYPE()`, and :cmacro:`Py_Refcnt()` became :cmacro:`Py_REFCNT()`. Macros for backward compatibility are still available for Python 2.6. - .. Issue 1629: XXX why was this done? + .. Issue 1629 .. ====================================================================== diff --git a/Lib/struct.py b/Lib/struct.py index 45f6729..3784c05 100644 --- a/Lib/struct.py +++ b/Lib/struct.py @@ -1,109 +1,2 @@ -""" -Functions to convert between Python values and C structs. -Python strings are used to hold the data representing the C struct -and also as format strings to describe the layout of data in the C struct. - -The optional first format char indicates byte order, size and alignment: - @: native order, size & alignment (default) - =: native order, std. size & alignment - <: little-endian, std. size & alignment - >: big-endian, std. size & alignment - !: same as > - -The remaining chars indicate types of args and must match exactly; -these can be preceded by a decimal repeat count: - x: pad byte (no data); c:char; b:signed byte; B:unsigned byte; - h:short; H:unsigned short; i:int; I:unsigned int; - l:long; L:unsigned long; f:float; d:double. -Special cases (preceding decimal count indicates length): - s:string (array of char); p: pascal string (with count byte). -Special case (only available in native format): - P:an integer type that is wide enough to hold a pointer. -Special case (not in native mode unless 'long long' in platform C): - q:long long; Q:unsigned long long -Whitespace between formats is ignored. - -The variable struct.error is an exception raised on errors. -""" - -__version__ = '3.0' - - -from _struct import Struct as _Struct, error - -class Struct(_Struct): - def __init__(self, fmt): - if isinstance(fmt, str): - fmt = bytes(fmt, 'ascii') - elif isinstance(fmt, buffer): - fmt = bytes(fmt) - _Struct.__init__(self, fmt) - -_MAXCACHE = 100 -_cache = {} - -def _compile(fmt): - # Internal: compile struct pattern - if len(_cache) >= _MAXCACHE: - _cache.clear() - s = Struct(fmt) - _cache[fmt] = s - return s - -def calcsize(fmt): - """ - Return size of C struct described by format string fmt. - See struct.__doc__ for more on format strings. - """ - try: - o = _cache[fmt] - except KeyError: - o = _compile(fmt) - return o.size - -def pack(fmt, *args): - """ - Return string containing values v1, v2, ... packed according to fmt. - See struct.__doc__ for more on format strings. - """ - try: - o = _cache[fmt] - except KeyError: - o = _compile(fmt) - return bytes(o.pack(*args)) - -def pack_into(fmt, buf, offset, *args): - """ - Pack the values v1, v2, ... according to fmt, write - the packed bytes into the writable buffer buf starting at offset. - See struct.__doc__ for more on format strings. - """ - try: - o = _cache[fmt] - except KeyError: - o = _compile(fmt) - o.pack_into(buf, offset, *args) - -def unpack(fmt, s): - """ - Unpack the string, containing packed C structure data, according - to fmt. Requires len(string)==calcsize(fmt). - See struct.__doc__ for more on format strings. - """ - try: - o = _cache[fmt] - except KeyError: - o = _compile(fmt) - return o.unpack(s) - -def unpack_from(fmt, buf, offset=0): - """ - Unpack the buffer, containing packed C structure data, according to - fmt starting at offset. Requires len(buffer[offset:]) >= calcsize(fmt). - See struct.__doc__ for more on format strings. - """ - try: - o = _cache[fmt] - except KeyError: - o = _compile(fmt) - return o.unpack_from(buf, offset) +from _struct import * +from _struct import _clearcache |