{a copy of \var{a}'s list of (\var{key}, \var{value}) pairs}
{(3)}
\lineiii{\var{a}.keys()}{a copy of \var{a}'s list of keys}{(3)}
- \lineiii{\var{a}.update(\var{b})}
- {\code{for \var{k} in \var{b}.keys(): \var{a}[\var{k}] = \var{b}[\var{k}]}}
- {}
+ \lineiii{\var{a}.update(\optional{\var{b}})}
+ {updates (and overwrites) key/value pairs from \var{b}}
+ {(9)}
\lineiii{\var{a}.fromkeys(\var{seq}\optional{, \var{value}})}
{Creates a new dictionary with keys from \var{seq} and values set to \var{value}}
{(7)}
value is given and the key is not found. \versionadded{2.3}
\end{description}
+\item[(9)] \function{update()} accepts either another mapping object
+or an iterable of key/value pairs (as a tuple or other iterable of
+length two). If keyword arguments are specified, the mapping is
+then is updated with those key/value pairs:
+\samp{d.update(red=1, blue=2)}.
+\versionchanged[Allowed the argument to be an iterable of key/value
+ pairs and allowed keyword arguments]{2.4}
\subsection{File Objects
\label{bltin-file-objects}}
\begin{itemize}
+\item The \method{dict.update()} method now accepts the same
+argument forms as the \class{dict} constructor. This includes any
+mapping, any iterable of key/value pairs, and/or keyword arguments.
+
\item The string methods, \method{ljust()}, \method{rjust()}, and
\method{center()} now take an optional argument for specifying a
fill character other than a space.
def __init__(self, dict=None, **kwargs):
self.data = {}
if dict is not None:
- if not hasattr(dict,'keys'):
- dict = type({})(dict) # make mapping from a sequence
self.update(dict)
if len(kwargs):
self.update(kwargs)
def itervalues(self): return self.data.itervalues()
def values(self): return self.data.values()
def has_key(self, key): return self.data.has_key(key)
- def update(self, dict):
- if isinstance(dict, UserDict):
+ def update(self, dict=None, **kwargs):
+ if dict is None:
+ pass
+ elif isinstance(dict, UserDict):
self.data.update(dict.data)
- elif isinstance(dict, type(self.data)):
+ elif isinstance(dict, type({})) or not hasattr(dict, 'items'):
self.data.update(dict)
else:
for k, v in dict.items():
self[k] = v
+ if len(kwargs):
+ self.data.update(kwargs)
def get(self, key, failobj=None):
if not self.has_key(key):
return failobj
raise KeyError, 'container is empty'
del self[k]
return (k, v)
- def update(self, other):
+ def update(self, other=None, **kwargs):
# Make progressively weaker assumptions about "other"
- if hasattr(other, 'iteritems'): # iteritems saves memory and lookups
+ if other is None:
+ pass
+ elif hasattr(other, 'iteritems'): # iteritems saves memory and lookups
for k, v in other.iteritems():
self[k] = v
- elif hasattr(other, '__iter__'): # iter saves memory
- for k in other:
- self[k] = other[k]
- else:
+ elif hasattr(other, 'keys'):
for k in other.keys():
self[k] = other[k]
+ else:
+ for k, v in other:
+ self[k] = v
+ if kwargs:
+ self.update(kwargs)
def get(self, key, default=None):
try:
return self[key]
return key.upper() in self.data
def get(self, key, failobj=None):
return self.data.get(key.upper(), failobj)
- def update(self, dict):
- for k, v in dict.items():
- self[k] = v
def copy(self):
return dict(self)
def __setitem__(self, key, item):
putenv(key, item)
self.data[key] = item
- def update(self, dict):
- for k, v in dict.items():
- self[k] = v
try:
unsetenv
except NameError:
self.assertRaises(TypeError, {}.keys, x=2, y=2)
def test_oldargs1_0(self):
- self.assertRaises(TypeError, {}.update)
+ self.assertRaises(TypeError, [].count)
def test_oldargs1_1(self):
- {}.update({})
+ [].count(1)
def test_oldargs1_2(self):
- self.assertRaises(TypeError, {}.update, {}, 1)
+ self.assertRaises(TypeError, [].count, 1, 2)
def test_oldargs1_0_ext(self):
try:
- {}.update(*())
+ [].count(*())
except TypeError:
pass
else:
raise RuntimeError
def test_oldargs1_1_ext(self):
- {}.update(*({},))
+ [].count(*(1,))
def test_oldargs1_2_ext(self):
try:
- {}.update(*({}, 2))
+ [].count(*(1, 2))
except TypeError:
pass
else:
raise RuntimeError
def test_oldargs1_0_kw(self):
- self.assertRaises(TypeError, {}.update, x=2)
+ self.assertRaises(TypeError, [].count, x=2)
def test_oldargs1_1_kw(self):
- self.assertRaises(TypeError, {}.update, {}, x=2)
+ self.assertRaises(TypeError, [].count, {}, x=2)
def test_oldargs1_2_kw(self):
- self.assertRaises(TypeError, {}.update, x=2, y=2)
+ self.assertRaises(TypeError, [].count, x=2, y=2)
def test_main():
if d != {1:1, 2:2, 3:3}: raise TestFailed, 'dict update'
d.clear()
try: d.update(None)
-except AttributeError: pass
+except (TypeError, AttributeError): pass
else: raise TestFailed, 'dict.update(None), AttributeError expected'
class SimpleUserDict:
def __init__(self):
#update
p.update(self.reference)
self.assertEqual(dict(p), self.reference)
+ items = p.items()
+ p = self._empty_mapping()
+ p.update(items)
+ self.assertEqual(dict(p), self.reference)
d = self._full_mapping(self.reference)
- #setdefaullt
+ #setdefault
key, value = d.iteritems().next()
knownkey, knownvalue = self.other.iteritems().next()
self.assertEqual(d.setdefault(key, knownvalue), value)
else:
return wr()
- def update(self, dict):
+ def update(self, dict=None, **kwargs):
d = self.data
- for key, o in dict.items():
- d[key] = ref(o, self.__makeremove(key))
+ if dict is not None:
+ if not hasattr(dict, "items"):
+ dict = type({})(dict)
+ for key, o in dict.items():
+ d[key] = ref(o, self.__makeremove(key))
+ if len(kwargs):
+ self.update(kwargs)
def values(self):
L = []
def setdefault(self, key, default):
return self.data.setdefault(ref(key, self._remove),default)
- def update(self, dict):
+ def update(self, dict=None, **kwargs):
d = self.data
- for key, value in dict.items():
- d[ref(key, self._remove)] = value
+ if dict is not None:
+ if not hasattr(dict, "items"):
+ dict = type({})(dict)
+ for key, value in dict.items():
+ d[ref(key, self._remove)] = value
+ if len(kwargs):
+ self.update(kwargs)
class BaseIter:
Juan David Ibáñez Palomar
Tony Ingraldi
John Interrante
+Bob Ippolito
Ben Jackson
Paul Jackson
David Jacobs
the overallocation is no more than three elements -- this improves space
utilization for applications that have large numbers of small lists.
+- The dict.update() method now accepts all the same argument forms
+ as the dict() constructor. This now includes item lists and/or
+ keyword arguments.
+
- Support for arbitrary objects supporting the read-only buffer
interface as the co_code field of code objects (something that was
only possible to create from C code) has been removed.
return NULL;
}
+static int
+dict_update_common(PyObject *self, PyObject *args, PyObject *kwds, char *methname)
+{
+ PyObject *arg = NULL;
+ int result = 0;
+
+ if (!PyArg_UnpackTuple(args, methname, 0, 1, &arg))
+ result = -1;
+
+ else if (arg != NULL) {
+ if (PyObject_HasAttrString(arg, "keys"))
+ result = PyDict_Merge(self, arg, 1);
+ else
+ result = PyDict_MergeFromSeq2(self, arg, 1);
+ }
+ if (result == 0 && kwds != NULL)
+ result = PyDict_Merge(self, kwds, 1);
+ return result;
+}
+
static PyObject *
-dict_update(PyObject *mp, PyObject *other)
+dict_update(PyObject *self, PyObject *args, PyObject *kwds)
{
- if (PyDict_Update(mp, other) < 0)
+ if (dict_update_common(self, args, kwds, "update") == -1)
return NULL;
Py_INCREF(Py_None);
return Py_None;
items__doc__},
{"values", (PyCFunction)dict_values, METH_NOARGS,
values__doc__},
- {"update", (PyCFunction)dict_update, METH_O,
+ {"update", (PyCFunction)dict_update, METH_VARARGS | METH_KEYWORDS,
update__doc__},
{"fromkeys", (PyCFunction)dict_fromkeys, METH_VARARGS | METH_CLASS,
fromkeys__doc__},
static int
dict_init(PyObject *self, PyObject *args, PyObject *kwds)
{
- PyObject *arg = NULL;
- int result = 0;
-
- if (!PyArg_UnpackTuple(args, "dict", 0, 1, &arg))
- result = -1;
-
- else if (arg != NULL) {
- if (PyObject_HasAttrString(arg, "keys"))
- result = PyDict_Merge(self, arg, 1);
- else
- result = PyDict_MergeFromSeq2(self, arg, 1);
- }
- if (result == 0 && kwds != NULL)
- result = PyDict_Merge(self, kwds, 1);
- return result;
+ return dict_update_common(self, args, kwds, "dict");
}
static long
projects / python / commitdiff