Simplify the named tuple template by using the new string format syntax.

Lib/collections/__init__.py

@@ -290,46 +290,46 @@ def namedtuple(typename, field_names, verbose=False, rename=False):
     # Create and fill-in the class template
     numfields = len(field_names)
     argtxt = repr(field_names).replace("'", "")[1:-1]   # tuple repr without parens or quotes
-    reprtxt = ', '.join('%s=%%r' % name for name in field_names)
-    template = '''class %(typename)s(tuple):
-        '%(typename)s(%(argtxt)s)'
+    reprtxt = ', '.join('{}=%r'.format(name) for name in field_names)
+    template = '''class {typename}(tuple):
+        '{typename}({argtxt})'
 
         __slots__ = ()
         
-        _fields = %(field_names)r
+        _fields = {field_names!r}
         
-        def __new__(_cls, %(argtxt)s):
-            'Create new instance of %(typename)s(%(argtxt)s)'
-            return _tuple.__new__(_cls, (%(argtxt)s))
+        def __new__(_cls, {argtxt}):
+            'Create new instance of {typename}({argtxt})'
+            return _tuple.__new__(_cls, ({argtxt}))
         
         @classmethod
         def _make(cls, iterable, new=tuple.__new__, len=len):
-            'Make a new %(typename)s object from a sequence or iterable'
+            'Make a new {typename} object from a sequence or iterable'
             result = new(cls, iterable)
-            if len(result) != %(numfields)d:
-                raise TypeError('Expected %(numfields)d arguments, got %%d' %% len(result))
+            if len(result) != {numfields:d}:
+                raise TypeError('Expected {numfields:d} arguments, got %d' % len(result))
             return result
         
         def __repr__(self):
             'Return a nicely formatted representation string'
-            return self.__class__.__name__ + '(%(reprtxt)s)' %% self
+            return self.__class__.__name__ + '({reprtxt})' % self
         
         def _asdict(self):
             'Return a new OrderedDict which maps field names to their values'
             return OrderedDict(zip(self._fields, self))
         
         def _replace(_self, **kwds):
-            'Return a new %(typename)s object replacing specified fields with new values'
-            result = _self._make(map(kwds.pop, %(field_names)r, _self))
+            'Return a new {typename} object replacing specified fields with new values'
+            result = _self._make(map(kwds.pop, {field_names!r}, _self))
             if kwds:
-                raise ValueError('Got unexpected field names: %%r' %% kwds.keys())
+                raise ValueError('Got unexpected field names: %r' % kwds.keys())
             return result
         
         def __getnewargs__(self):
             'Return self as a plain tuple.  Used by copy and pickle.'
             return tuple(self)
 
-        ''' % locals()
+'''.format(**locals())
     for i, name in enumerate(field_names):
         template += "        %s = _property(_itemgetter(%d), doc='Alias for field number %d')\n" % (name, i, i)
     if verbose: