argument).
\end{funcdesc}
-\begin{funcdesc}{intern}{string}
- Enter \var{string} in the table of ``interned'' strings and return
- the interned string -- which is \var{string} itself or a copy.
- Interning strings is useful to gain a little performance on
- dictionary lookup -- if the keys in a dictionary are interned, and
- the lookup key is interned, the key comparisons (after hashing) can
- be done by a pointer compare instead of a string compare. Normally,
- the names used in Python programs are automatically interned, and
- the dictionaries used to hold module, class or instance attributes
- have interned keys. \versionchanged[Interned strings are not
- immortal (like they used to be in Python 2.2 and before);
- you must keep a reference to the return value of \function{intern()}
- around to benefit from it]{2.3}
-\end{funcdesc}
\versionadded{1.5.2}
\end{datadesc}
+\begin{funcdesc}{intern}{string}
+ Enter \var{string} in the table of ``interned'' strings and return
+ the interned string -- which is \var{string} itself or a copy.
+ Interning strings is useful to gain a little performance on
+ dictionary lookup -- if the keys in a dictionary are interned, and
+ the lookup key is interned, the key comparisons (after hashing) can
+ be done by a pointer compare instead of a string compare. Normally,
+ the names used in Python programs are automatically interned, and
+ the dictionaries used to hold module, class or instance attributes
+ have interned keys. \versionchanged[Interned strings are not
+ immortal (like they used to be in Python 2.2 and before);
+ you must keep a reference to the return value of \function{intern()}
+ around to benefit from it]{2.3}
+\end{funcdesc}
+
\begin{datadesc}{last_type}
\dataline{last_value}
\dataline{last_traceback}
'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod',
'enumerate', 'eval', 'exec', 'execfile', 'exit', 'file', 'filter', 'float',
'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex',
- 'id', 'int', 'intern', 'isinstance', 'issubclass', 'iter',
+ 'id', 'int', 'isinstance', 'issubclass', 'iter',
'len', 'license', 'list', 'locals', 'long', 'map', 'max', 'min',
'object', 'oct', 'open', 'ord', 'pow', 'property', 'quit', 'range',
'reload', 'repr', 'reversed', 'round', 'set',
Interning strings (ob_sstate) tries to ensure that only one string
object with a given value exists, so equality tests can be one pointer
comparison. This is generally restricted to strings that "look like"
- Python identifiers, although the intern() builtin can be used to force
+ Python identifiers, although the sys.intern() function can be used to force
interning of any string.
Together, these sped the interpreter by up to 20%. */
self.assertEqual(int(Foo4()), 42L)
self.assertRaises(TypeError, int, Foo5())
- def test_intern(self):
- self.assertRaises(TypeError, intern)
- s = "never interned before"
- self.assert_(intern(s) is s)
- s2 = s.swapcase().swapcase()
- self.assert_(intern(s2) is s)
-
- # Subclasses of string can't be interned, because they
- # provide too much opportunity for insane things to happen.
- # We don't want them in the interned dict and if they aren't
- # actually interned, we don't want to create the appearance
- # that they are by allowing intern() to succeeed.
- class S(str):
- def __hash__(self):
- return 123
-
- self.assertRaises(TypeError, intern, S("abc"))
-
- # It's still safe to pass these strings to routines that
- # call intern internally, e.g. PyObject_SetAttr().
- s = S("abc")
- setattr(s, s, s)
- self.assertEqual(getattr(s, s), s)
-
def test_iter(self):
self.assertRaises(TypeError, iter)
self.assertRaises(TypeError, iter, 42, 42)
# the test runs under regrtest.
self.assert_(sys.__stdout__.encoding == sys.__stderr__.encoding)
+ def test_intern(self):
+ self.assertRaises(TypeError, sys.intern)
+ s = "never interned before"
+ self.assert_(sys.intern(s) is s)
+ s2 = s.swapcase().swapcase()
+ self.assert_(sys.intern(s2) is s)
+
+ # Subclasses of string can't be interned, because they
+ # provide too much opportunity for insane things to happen.
+ # We don't want them in the interned dict and if they aren't
+ # actually interned, we don't want to create the appearance
+ # that they are by allowing intern() to succeeed.
+ class S(str):
+ def __hash__(self):
+ return 123
+
+ self.assertRaises(TypeError, sys.intern, S("abc"))
+
+ # It's still safe to pass these strings to routines that
+ # call intern internally, e.g. PyObject_SetAttr().
+ s = S("abc")
+ setattr(s, s, s)
+ self.assertEqual(getattr(s, s), s)
+
+
def test_main():
test.test_support.run_unittest(SysModuleTest)
TO DO
-----
-- See PEP 3000.
+- See PEP 3000, 3100.
- Test merging certain changes from the 2.5 HEAD code.
Core and Builtins
-----------------
-- Renamed nb_nonzero to nb_bool and __nonzero__ to __bool__
+- Moved intern() to sys.intern().
+
+- exec is now a function.
+
+- Renamed nb_nonzero to nb_bool and __nonzero__ to __bool__.
- Classic classes are a thing of the past. All classes are new style.
- zip returns an iterator
- Additions:
- set literals
+ set literals, ellipsis literal
Extension Modules
"delattr" "dict" "dir" "divmod"
"enumerate" "eval" "execfile" "exit" "file"
"filter" "float" "getattr" "globals" "hasattr"
- "hash" "hex" "id" "int" "intern"
+ "hash" "hex" "id" "int"
"isinstance" "issubclass" "iter" "len" "license"
"list" "locals" "long" "map" "max" "min" "object"
"oct" "open" "ord" "pow" "property" "range"
Return the hexadecimal representation of an integer or long integer.");
-static PyObject *
-builtin_intern(PyObject *self, PyObject *args)
-{
- PyObject *s;
- if (!PyArg_ParseTuple(args, "S:intern", &s))
- return NULL;
- if (!PyString_CheckExact(s)) {
- PyErr_SetString(PyExc_TypeError,
- "can't intern subclass of string");
- return NULL;
- }
- Py_INCREF(s);
- PyString_InternInPlace(&s);
- return s;
-}
-
-PyDoc_STRVAR(intern_doc,
-"intern(string) -> string\n\
-\n\
-``Intern'' the given string. This enters the string in the (global)\n\
-table of interned strings whose purpose is to speed up dictionary lookups.\n\
-Return the string itself or the previously interned string object with the\n\
-same value.");
-
-
static PyObject *
builtin_iter(PyObject *self, PyObject *args)
{
{"hash", builtin_hash, METH_O, hash_doc},
{"hex", builtin_hex, METH_O, hex_doc},
{"id", builtin_id, METH_O, id_doc},
- {"intern", builtin_intern, METH_VARARGS, intern_doc},
{"isinstance", builtin_isinstance, METH_VARARGS, isinstance_doc},
{"issubclass", builtin_issubclass, METH_VARARGS, issubclass_doc},
{"iter", builtin_iter, METH_VARARGS, iter_doc},
#endif
+
+static PyObject *
+sys_intern(PyObject *self, PyObject *args)
+{
+ PyObject *s;
+ if (!PyArg_ParseTuple(args, "S:intern", &s))
+ return NULL;
+ if (!PyString_CheckExact(s)) {
+ PyErr_SetString(PyExc_TypeError,
+ "can't intern subclass of string");
+ return NULL;
+ }
+ Py_INCREF(s);
+ PyString_InternInPlace(&s);
+ return s;
+}
+
+PyDoc_STRVAR(intern_doc,
+"intern(string) -> string\n\
+\n\
+``Intern'' the given string. This enters the string in the (global)\n\
+table of interned strings whose purpose is to speed up dictionary lookups.\n\
+Return the string itself or the previously interned string object with the\n\
+same value.");
+
+
/*
* Cached interned string objects used for calling the profile and
* trace functions. Initialized by trace_init().
{"getwindowsversion", (PyCFunction)sys_getwindowsversion, METH_NOARGS,
getwindowsversion_doc},
#endif /* MS_WINDOWS */
+ {"intern", sys_intern, METH_VARARGS, intern_doc},
#ifdef USE_MALLOPT
{"mdebug", sys_mdebug, METH_VARARGS},
#endif
from pybench import Test
from string import join
+import sys
class ConcatStrings(Test):
def test(self):
# Make sure the strings *are* interned
- s = intern(join(map(str,range(10))))
+ s = sys.intern(join(map(str,range(10))))
t = s
for i in xrange(self.rounds):
def calibrate(self):
- s = intern(join(map(str,range(10))))
+ s = sys.intern(join(map(str,range(10))))
t = s
for i in xrange(self.rounds):
list = warnings.get(filename)
if list is None:
warnings[filename] = list = []
- list.append((int(lineno), intern(what)))
+ list.append((int(lineno), sys.intern(what)))
f.close()
return warnings
projects / python / commitdiff