- Patch 1433928:

gvanrossum · gvanrossum · commit 1968ad32cd7f · 2006-02-25T22:38:04.000Z
- The copy module now "copies" function objects (as atomic objects).
  - dict.__getitem__ now looks for a __missing__ hook before raising
    KeyError.
  - Added a new type, defaultdict, to the collections module.
    This uses the new __missing__ hook behavior added to dict (see above).
diff --git a/Doc/lib/libcollections.tex b/Doc/lib/libcollections.tex
@@ -8,9 +8,10 @@ \section{\module{collections} ---
 \versionadded{2.4}
 
 
-This module implements high-performance container datatypes.  Currently, the
-only datatype is a deque.  Future additions may include B-trees
-and Fibonacci heaps.
+This module implements high-performance container datatypes.  Currently,
+there are two datatypes, deque and defaultdict.
+Future additions may include B-trees and Fibonacci heaps.
+\versionchanged[Added defaultdict]{2.5}
 
 \begin{funcdesc}{deque}{\optional{iterable}}
   Returns a new deque objected initialized left-to-right (using
@@ -211,3 +212,46 @@ \subsection{Recipes \label{deque-recipes}}
 [[[['a', 'b'], ['c', 'd']], [['e', 'f'], ['g', 'h']]]]
 
 \end{verbatim}
+
+
+
+\begin{funcdesc}{defaultdict}{\optional{default_factory\optional{, ...}}}
+  Returns a new dictionary-like object.  \class{defaultdict} is a subclass
+  of the builtin \class{dict} class.  It overrides one method and adds one
+  writable instance variable.  The remaining functionality is the same as
+  for the \class{dict} class and is not documented here.
+
+  The first argument provides the initial value for the
+  \member{default_factory} attribute; it defaults to \code{None}.
+  All remaining arguments are treated the same as if they were
+  passed to the \class{dict} constructor, including keyword arguments.
+
+ \versionadded{2.5}
+\end{funcdesc}
+
+\class{defaultdict} objects support the following method in addition to
+the standard \class{dict} operations:
+
+\begin{methoddesc}{__missing__}{key}
+  If the \member{default_factory} attribute is \code{None}, this raises
+  an \exception{KeyError} exception with the \var{key} as argument.
+
+  If \member{default_factory} is not \code{None}, it is called without
+  arguments to provide a default value for the given \var{key}, this
+  value is inserted in the dictionary for the \var{key}, and returned.
+
+  If calling \member{default_factory} raises an exception this exception
+  is propagated unchanged.
+
+  This method is called by the \method{__getitem__} method of the
+  \class{dict} class when the requested key is not found; whatever it
+  returns or raises is then returned or raised by \method{__getitem__}.
+\end{methoddesc}
+
+\class{defaultdict} objects support the following instance variable:
+
+\begin{datadesc}{default_factory}
+  This attribute is used by the \method{__missing__} method; it is initialized
+  from the first argument to the constructor, if present, or to \code{None}, 
+  if absent.
+\end{datadesc}
diff --git a/Doc/lib/libcopy.tex b/Doc/lib/libcopy.tex
@@ -67,9 +67,12 @@ \section{\module{copy} ---
 
 \end{itemize}
 
-This version does not copy types like module, class, function, method,
+This module does not copy types like module, method,
 stack trace, stack frame, file, socket, window, array, or any similar
-types.
+types.  It does ``copy'' functions and classes (shallow and deeply),
+by returning the original object unchanged; this is compatible with
+the way these are treated by the \module{pickle} module.
+\versionchanged[Added copying functions]{2.5}
 
 Classes can use the same interfaces to control copying that they use
 to control pickling.  See the description of module
diff --git a/Doc/lib/libstdtypes.tex b/Doc/lib/libstdtypes.tex
@@ -1350,7 +1350,7 @@ \subsection{Mapping Types --- \class{dict} \label{typesmapping}}
 
 \begin{tableiii}{c|l|c}{code}{Operation}{Result}{Notes}
   \lineiii{len(\var{a})}{the number of items in \var{a}}{}
-  \lineiii{\var{a}[\var{k}]}{the item of \var{a} with key \var{k}}{(1)}
+  \lineiii{\var{a}[\var{k}]}{the item of \var{a} with key \var{k}}{(1), (10)}
   \lineiii{\var{a}[\var{k}] = \var{v}}
           {set \code{\var{a}[\var{k}]} to \var{v}}
           {}
@@ -1454,6 +1454,17 @@ \subsection{Mapping Types --- \class{dict} \label{typesmapping}}
 \versionchanged[Allowed the argument to be an iterable of key/value
                 pairs and allowed keyword arguments]{2.4}
 
+\item[(10)] If a subclass of dict defines a method \method{__missing__},
+if the key \var{k} is not present, the \var{a}[\var{k}] operation calls
+that method with the key \var{k} as argument.  The \var{a}[\var{k}]
+operation then returns or raises whatever is returned or raised by the
+\function{__missing__}(\var{k}) call if the key is not present.
+No other operations or methods invoke \method{__missing__}().
+If \method{__missing__} is not defined, \exception{KeyError} is raised.
+\method{__missing__} must be a method; it cannot be an instance variable.
+For an example, see \module{collections}.\class{defaultdict}.
+\versionadded{2.5}
+
 \end{description}
 
 \subsection{File Objects
diff --git a/Lib/UserDict.py b/Lib/UserDict.py
@@ -14,7 +14,12 @@ def __cmp__(self, dict):
         else:
             return cmp(self.data, dict)
     def __len__(self): return len(self.data)
-    def __getitem__(self, key): return self.data[key]
+    def __getitem__(self, key):
+        if key in self.data:
+            return self.data[key]
+        if hasattr(self.__class__, "__missing__"):
+            return self.__class__.__missing__(self, key)
+        raise KeyError(key)
     def __setitem__(self, key, item): self.data[key] = item
     def __delitem__(self, key): del self.data[key]
     def clear(self): self.data.clear()
diff --git a/Lib/copy.py b/Lib/copy.py
@@ -101,7 +101,8 @@ def _copy_immutable(x):
     return x
 for t in (type(None), int, long, float, bool, str, tuple,
           frozenset, type, xrange, types.ClassType,
-          types.BuiltinFunctionType):
+          types.BuiltinFunctionType,
+	  types.FunctionType):
     d[t] = _copy_immutable
 for name in ("ComplexType", "UnicodeType", "CodeType"):
     t = getattr(types, name, None)
@@ -217,6 +218,7 @@ def _deepcopy_atomic(x, memo):
 d[xrange] = _deepcopy_atomic
 d[types.ClassType] = _deepcopy_atomic
 d[types.BuiltinFunctionType] = _deepcopy_atomic
+d[types.FunctionType] = _deepcopy_atomic
 
 def _deepcopy_list(x, memo):
     y = []
diff --git a/Lib/test/test_copy.py b/Lib/test/test_copy.py
@@ -568,6 +568,22 @@ def __getstate__(self):
                 raise ValueError, "ain't got no stickin' state"
         self.assertRaises(ValueError, copy.copy, EvilState())
 
+    def test_copy_function(self):
+        self.assertEqual(copy.copy(global_foo), global_foo)
+        def foo(x, y): return x+y
+        self.assertEqual(copy.copy(foo), foo)
+        bar = lambda: None
+        self.assertEqual(copy.copy(bar), bar)
+
+    def test_deepcopy_function(self):
+        self.assertEqual(copy.deepcopy(global_foo), global_foo)
+        def foo(x, y): return x+y
+        self.assertEqual(copy.deepcopy(foo), foo)
+        bar = lambda: None
+        self.assertEqual(copy.deepcopy(bar), bar)
+
+def global_foo(x, y): return x+y
+
 def test_main():
     test_support.run_unittest(TestCopy)
 
diff --git a/Lib/test/test_defaultdict.py b/Lib/test/test_defaultdict.py
@@ -0,0 +1,135 @@
+"""Unit tests for collections.defaultdict."""
+
+import os
+import copy
+import tempfile
+import unittest
+
+from collections import defaultdict
+
+def foobar():
+    return list
+
+class TestDefaultDict(unittest.TestCase):
+
+    def test_basic(self):
+        d1 = defaultdict()
+        self.assertEqual(d1.default_factory, None)
+        d1.default_factory = list
+        d1[12].append(42)
+        self.assertEqual(d1, {12: [42]})
+        d1[12].append(24)
+        self.assertEqual(d1, {12: [42, 24]})
+        d1[13]
+        d1[14]
+        self.assertEqual(d1, {12: [42, 24], 13: [], 14: []})
+        self.assert_(d1[12] is not d1[13] is not d1[14])
+        d2 = defaultdict(list, foo=1, bar=2)
+        self.assertEqual(d2.default_factory, list)
+        self.assertEqual(d2, {"foo": 1, "bar": 2})
+        self.assertEqual(d2["foo"], 1)
+        self.assertEqual(d2["bar"], 2)
+        self.assertEqual(d2[42], [])
+        self.assert_("foo" in d2)
+        self.assert_("foo" in d2.keys())
+        self.assert_("bar" in d2)
+        self.assert_("bar" in d2.keys())
+        self.assert_(42 in d2)
+        self.assert_(42 in d2.keys())
+        self.assert_(12 not in d2)
+        self.assert_(12 not in d2.keys())
+        d2.default_factory = None
+        self.assertEqual(d2.default_factory, None)
+        try:
+            d2[15]
+        except KeyError, err:
+            self.assertEqual(err.args, (15,))
+        else:
+            self.fail("d2[15] didn't raise KeyError")
+
+    def test_missing(self):
+        d1 = defaultdict()
+        self.assertRaises(KeyError, d1.__missing__, 42)
+        d1.default_factory = list
+        self.assertEqual(d1.__missing__(42), [])
+
+    def test_repr(self):
+        d1 = defaultdict()
+        self.assertEqual(d1.default_factory, None)
+        self.assertEqual(repr(d1), "defaultdict(None, {})")
+        d1[11] = 41
+        self.assertEqual(repr(d1), "defaultdict(None, {11: 41})")
+        d2 = defaultdict(0)
+        self.assertEqual(d2.default_factory, 0)
+        d2[12] = 42
+        self.assertEqual(repr(d2), "defaultdict(0, {12: 42})")
+        def foo(): return 43
+        d3 = defaultdict(foo)
+        self.assert_(d3.default_factory is foo)
+        d3[13]
+        self.assertEqual(repr(d3), "defaultdict(%s, {13: 43})" % repr(foo))
+
+    def test_print(self):
+        d1 = defaultdict()
+        def foo(): return 42
+        d2 = defaultdict(foo, {1: 2})
+        # NOTE: We can't use tempfile.[Named]TemporaryFile since this
+        # code must exercise the tp_print C code, which only gets
+        # invoked for *real* files.
+        tfn = tempfile.mktemp()
+        try:
+            f = open(tfn, "w+")
+            try:
+                print >>f, d1
+                print >>f, d2
+                f.seek(0)
+                self.assertEqual(f.readline(), repr(d1) + "\n")
+                self.assertEqual(f.readline(), repr(d2) + "\n")
+            finally:
+                f.close()
+        finally:
+            os.remove(tfn)
+
+    def test_copy(self):
+        d1 = defaultdict()
+        d2 = d1.copy()
+        self.assertEqual(type(d2), defaultdict)
+        self.assertEqual(d2.default_factory, None)
+        self.assertEqual(d2, {})
+        d1.default_factory = list
+        d3 = d1.copy()
+        self.assertEqual(type(d3), defaultdict)
+        self.assertEqual(d3.default_factory, list)
+        self.assertEqual(d3, {})
+        d1[42]
+        d4 = d1.copy()
+        self.assertEqual(type(d4), defaultdict)
+        self.assertEqual(d4.default_factory, list)
+        self.assertEqual(d4, {42: []})
+        d4[12]
+        self.assertEqual(d4, {42: [], 12: []})
+
+    def test_shallow_copy(self):
+        d1 = defaultdict(foobar, {1: 1})
+        d2 = copy.copy(d1)
+        self.assertEqual(d2.default_factory, foobar)
+        self.assertEqual(d2, d1)
+        d1.default_factory = list
+        d2 = copy.copy(d1)
+        self.assertEqual(d2.default_factory, list)
+        self.assertEqual(d2, d1)
+
+    def test_deep_copy(self):
+        d1 = defaultdict(foobar, {1: [1]})
+        d2 = copy.deepcopy(d1)
+        self.assertEqual(d2.default_factory, foobar)
+        self.assertEqual(d2, d1)
+        self.assert_(d1[1] is not d2[1])
+        d1.default_factory = list
+        d2 = copy.deepcopy(d1)
+        self.assertEqual(d2.default_factory, list)
+        self.assertEqual(d2, d1)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_dict.py b/Lib/test/test_dict.py
@@ -395,6 +395,56 @@ def __eq__(self, other):
         else:
             self.fail("< didn't raise Exc")
 
+    def test_missing(self):
+        # Make sure dict doesn't have a __missing__ method
+        self.assertEqual(hasattr(dict, "__missing__"), False)
+        self.assertEqual(hasattr({}, "__missing__"), False)
+        # Test several cases:
+        # (D) subclass defines __missing__ method returning a value
+        # (E) subclass defines __missing__ method raising RuntimeError
+        # (F) subclass sets __missing__ instance variable (no effect)
+        # (G) subclass doesn't define __missing__ at a all
+        class D(dict):
+            def __missing__(self, key):
+                return 42
+        d = D({1: 2, 3: 4})
+        self.assertEqual(d[1], 2)
+        self.assertEqual(d[3], 4)
+        self.assert_(2 not in d)
+        self.assert_(2 not in d.keys())
+        self.assertEqual(d[2], 42)
+        class E(dict):
+            def __missing__(self, key):
+                raise RuntimeError(key)
+        e = E()
+        try:
+            e[42]
+        except RuntimeError, err:
+            self.assertEqual(err.args, (42,))
+        else:
+            self.fail_("e[42] didn't raise RuntimeError")
+        class F(dict):
+            def __init__(self):
+                # An instance variable __missing__ should have no effect
+                self.__missing__ = lambda key: None
+        f = F()
+        try:
+            f[42]
+        except KeyError, err:
+            self.assertEqual(err.args, (42,))
+        else:
+            self.fail_("f[42] didn't raise KeyError")
+        class G(dict):
+            pass
+        g = G()
+        try:
+            g[42]
+        except KeyError, err:
+            self.assertEqual(err.args, (42,))
+        else:
+            self.fail_("g[42] didn't raise KeyError")
+
+
 import mapping_tests
 
 class GeneralMappingTests(mapping_tests.BasicTestMappingProtocol):
diff --git a/Lib/test/test_userdict.py b/Lib/test/test_userdict.py
diff --git a/Misc/NEWS b/Misc/NEWS
diff --git a/Modules/collectionsmodule.c b/Modules/collectionsmodule.c
diff --git a/Objects/dictobject.c b/Objects/dictobject.c
