python
diff --git a/‎Demo/tix/grid.py‎
Lines changed: 2 additions & 2 deletions b/‎Demo/tix/grid.py‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎Doc/lib/libdbhash.tex‎
Lines changed: 1 addition & 1 deletion b/‎Doc/lib/libdbhash.tex‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎Doc/lib/libfuncs.tex‎
Lines changed: 8 additions & 26 deletions b/‎Doc/lib/libfuncs.tex‎
Lines changed: 8 additions & 26 deletions
diff --git a/‎Doc/lib/libitertools.tex‎
Lines changed: 4 additions & 4 deletions b/‎Doc/lib/libitertools.tex‎
Lines changed: 4 additions & 4 deletions
diff --git a/‎Doc/lib/librandom.tex‎
Lines changed: 2 additions & 2 deletions b/‎Doc/lib/librandom.tex‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎Doc/lib/libstdtypes.tex‎
Lines changed: 9 additions & 9 deletions b/‎Doc/lib/libstdtypes.tex‎
Lines changed: 9 additions & 9 deletions
diff --git a/‎Doc/lib/libtimeit.tex‎
Lines changed: 1 addition & 1 deletion b/‎Doc/lib/libtimeit.tex‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎Doc/tut/tut.tex‎
Lines changed: 4 additions & 4 deletions b/‎Doc/tut/tut.tex‎
Lines changed: 4 additions & 4 deletions
diff --git a/‎Doc/whatsnew/Makefile‎
Lines changed: 0 additions & 3 deletions b/‎Doc/whatsnew/Makefile‎
Lines changed: 0 additions & 3 deletions
@@ -18,8 +18,8 @@ def editnotify(self, x, y):
 g = MyGrid(r, name="a_grid",
 selectunit="cell")
 g.pack(fill=tk.BOTH)
-for x in xrange(5):
-    for y in xrange(5):
+for x in range(5):
+    for y in range(5):
         g.set(x,y,text=str((x,y)))
 
 c = tk.Button(r, text="Close", command=r.destroy)
 
@@ -72,7 +72,7 @@ \subsection{Database Objects \label{dbhash-objects}}
 
 \begin{verbatim}
 print db.first()
-for i in xrange(1, len(db)):
+for i in range(1, len(db)):
     print db.next()
 \end{verbatim}
 \end{methoddesc}
 
@@ -868,7 +868,7 @@ \section{Built-in Functions \label{built-in-funcs}}
 \end{funcdesc}
 
 \begin{funcdesc}{range}{\optional{start,} stop\optional{, step}}
-  This is a versatile function to create lists containing arithmetic
+  This is a versatile function to create sequences containing arithmetic
   progressions.  It is most often used in \keyword{for} loops.  The
   arguments must be plain integers.  If the \var{step} argument is
   omitted, it defaults to \code{1}.  If the \var{start} argument is
@@ -882,19 +882,19 @@ \section{Built-in Functions \label{built-in-funcs}}
   \exception{ValueError} is raised).  Example:
 
 \begin{verbatim}
->>> range(10)
+>>> list(range(10))
 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
->>> range(1, 11)
+>>> list(range(1, 11))
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
->>> range(0, 30, 5)
+>>> list(range(0, 30, 5))
 [0, 5, 10, 15, 20, 25]
->>> range(0, 10, 3)
+>>> list(range(0, 10, 3))
 [0, 3, 6, 9]
->>> range(0, -10, -1)
+>>> list(range(0, -10, -1))
 [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
->>> range(0)
+>>> list(range(0))
 []
->>> range(1, 0)
+>>> list(range(1, 0))
 []
 \end{verbatim}
 \end{funcdesc}
@@ -1230,24 +1230,6 @@ \section{Built-in Functions \label{built-in-funcs}}
     other scopes (such as modules) can be.  This may change.}
 \end{funcdesc}
 
-\begin{funcdesc}{xrange}{\optional{start,} stop\optional{, step}}
-  This function is very similar to \function{range()}, but returns an
-  ``xrange object'' instead of a list.  This is an opaque sequence
-  type which yields the same values as the corresponding list, without
-  actually storing them all simultaneously.  The advantage of
-  \function{xrange()} over \function{range()} is minimal (since
-  \function{xrange()} still has to create the values when asked for
-  them) except when a very large range is used on a memory-starved
-  machine or when all of the range's elements are never used (such as
-  when the loop is usually terminated with \keyword{break}).
-
-  \note{\function{xrange()} is intended to be simple and fast.
-        Implementations may impose restrictions to achieve this.
-        The C implementation of Python restricts all arguments to
-        native C longs ("short" Python integers), and also requires
-        that the number of elements fit in a native C long.}
-\end{funcdesc}
-
 \begin{funcdesc}{zip}{\optional{iterable, \moreargs}}
   This function returns a list of tuples, where the \var{i}-th tuple contains
   the \var{i}-th element from each of the argument sequences or iterables.
 
@@ -161,7 +161,7 @@ \subsection{Itertool functions \label{itertools-functions}}
                 key = lambda x: x
             self.keyfunc = key
             self.it = iter(iterable)
-            self.tgtkey = self.currkey = self.currvalue = xrange(0)
+            self.tgtkey = self.currkey = self.currvalue = []
         def __iter__(self):
             return self
         def __next__(self):
@@ -252,7 +252,7 @@ \subsection{Itertool functions \label{itertools-functions}}
   \begin{verbatim}
      def islice(iterable, *args):
          s = slice(*args)
-         it = iter(xrange(s.start or 0, s.stop or sys.maxint, s.step or 1))
+         it = iter(range(s.start or 0, s.stop or sys.maxint, s.step or 1))
          nexti = next(it)
          for i, element in enumerate(iterable):
              if i == nexti:
@@ -342,7 +342,7 @@ \subsection{Itertool functions \label{itertools-functions}}
              while True:
                  yield object
          else:
-             for i in xrange(times):
+             for i in range(times):
                  yield object
   \end{verbatim}
 \end{funcdesc}
@@ -425,7 +425,7 @@ \subsection{Examples \label{itertools-example}}
 Check 1202 is for $823.14
 
 >>> import operator
->>> for cube in imap(operator.pow, xrange(1,5), repeat(3)):
+>>> for cube in imap(operator.pow, range(1,5), repeat(3)):
 ...    print cube
 ...
 1
 
@@ -163,9 +163,9 @@ \section{\module{random} ---
   population contains repeats, then each occurrence is a possible
   selection in the sample.
 
-  To choose a sample from a range of integers, use an \function{xrange()}
+  To choose a sample from a range of integers, use an \function{range()}
   object as an argument.  This is especially fast and space efficient for
-  sampling from a large population:  \code{sample(xrange(10000000), 60)}.
+  sampling from a large population:  \code{sample(range(10000000), 60)}.
 \end{funcdesc}
 
 
 
@@ -403,11 +403,11 @@ \section{Iterator Types \label{typeiter}}
 
 \section{Sequence Types ---
 	    \class{str}, \class{unicode}, \class{list},
-	    \class{tuple}, \class{buffer}, \class{xrange}
+	    \class{tuple}, \class{buffer}, \class{range}
 	    \label{typesseq}}
 
 There are six sequence types: strings, Unicode strings, lists,
-tuples, buffers, and xrange objects.
+tuples, buffers, and range objects.
 
 String literals are written in single or double quotes:
 \code{'xyzzy'}, \code{"frobozz"}.  See chapter 2 of the
@@ -433,11 +433,11 @@ \section{Sequence Types ---
 \obindex{buffer}
 
 Xrange objects are similar to buffers in that there is no specific
-syntax to create them, but they are created using the \function{xrange()}
-function.\bifuncindex{xrange}  They don't support slicing,
+syntax to create them, but they are created using the \function{range()}
+function.\bifuncindex{range}  They don't support slicing,
 concatenation or repetition, and using \code{in}, \code{not in},
 \function{min()} or \function{max()} on them is inefficient.
-\obindex{xrange}
+\obindex{range}
 
 Most sequence types support the following operations.  The \samp{in} and
 \samp{not in} operations have the same priorities as the comparison
@@ -1069,11 +1069,11 @@ \subsection{String Formatting Operations \label{typesseq-strings}}
 \refmodule{re}.\refstmodindex{re}
 
 
-\subsection{XRange Type \label{typesseq-xrange}}
+\subsection{XRange Type \label{typesseq-range}}
 
-The \class{xrange}\obindex{xrange} type is an immutable sequence which
-is commonly used for looping.  The advantage of the \class{xrange}
-type is that an \class{xrange} object will always take the same amount
+The \class{range}\obindex{range} type is an immutable sequence which
+is commonly used for looping.  The advantage of the \class{range}
+type is that an \class{range} object will always take the same amount
 of memory, no matter the size of the range it represents.  There are
 no consistent performance advantages.
 
 
@@ -98,7 +98,7 @@ \section{\module{timeit} ---
 measured.  If so, GC can be re-enabled as the first statement in the
 \var{setup} string.  For example:
 \begin{verbatim}
-    timeit.Timer('for i in xrange(10): oct(i)', 'gc.enable()').timeit()
+    timeit.Timer('for i in range(10): oct(i)', 'gc.enable()').timeit()
 \end{verbatim}
 \end{notice}
 \end{methoddesc}
 
@@ -147,9 +147,9 @@ \section{\module{types} ---
 The type of open file objects such as \code{sys.stdout}.
 \end{datadesc}
 
-\begin{datadesc}{XRangeType}
+\begin{datadesc}{RangeType}
 The type of range objects returned by
-\function{xrange()}\bifuncindex{xrange}.
+\function{range()}\bifuncindex{range}.
 \end{datadesc}
 
 \begin{datadesc}{SliceType}
 
@@ -2260,7 +2260,7 @@ \section{Looping Techniques \label{loopidioms}}
 function.
 
 \begin{verbatim}
->>> for i in reversed(xrange(1,10,2)):
+>>> for i in reversed(range(1,10,2)):
 ...     print i
 ...
 9
@@ -2700,12 +2700,12 @@ \section{The \function{dir()} Function \label{dir}}
  'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod',
  'enumerate', 'eval', 'exec', 'execfile', 'exit', 'file', 'filter', 'float',
  'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex',
- 'id', 'int', 'isinstance', 'issubclass', 'iter',
+ 'id', 'input', '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',
  'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super',
- 'tuple', 'type', 'unichr', 'unicode', 'vars', 'xrange', 'zip']
+ 'tuple', 'type', 'unichr', 'unicode', 'vars', 'zip']
 \end{verbatim}
 
 
@@ -4762,7 +4762,7 @@ \section{Mathematics\label{mathematics}}
 >>> import random
 >>> random.choice(['apple', 'pear', 'banana'])
 'apple'
->>> random.sample(xrange(100), 10)   # sampling without replacement
+>>> random.sample(range(100), 10)   # sampling without replacement
 [30, 83, 16, 4, 8, 81, 41, 50, 18, 33]
 >>> random.random()    # random float
 0.17970987693706186