trying to get rid of some .iteritems

Author: fchapoton

src/sage/algebras/hecke_algebras/cubic_hecke_algebra.py

@@ -578,7 +578,7 @@ def formal_markov_trace(self, extended=False, field_embedding=False):
             mtcf = [M.from_vector(cf.to_vector()) for cf in mtcf]
 
         R = M.base_ring()
-        return M.linear_combination((mtcf[i], R(val)) for i, val in vs.iteritems())
+        return M.linear_combination((mtcf[i], R(val)) for i, val in vs.items())
 
 
 class CubicHeckeAlgebra(CombinatorialFreeModule):

src/sage/algebras/lie_algebras/bgg_dual_module.py

@@ -746,10 +746,10 @@ def _construct_next_level(self):
                 mat = matrix(R, [[b[s] for s in supp] for b in wt_basis])
                 mat.echelonize()
                 for i, k in enumerate(self._weight_space_bases[mu]):
-                    data = {supp[ind]: R(c) for ind, c in mat[i].iteritems() if c}
+                    data = {supp[ind]: R(c) for ind, c in mat[i].items() if c}
                     self._basis[k] = ambient.element_class(ambient, data)
                 i = mat.nrows() - 1
-                data = {supp[ind]: R(c) for ind, c in mat[i].iteritems() if c}
+                data = {supp[ind]: R(c) for ind, c in mat[i].items() if c}
                 if data:
                     next_level[key] = ambient.element_class(ambient, data)
                     self._basis[key] = next_level[key]

src/sage/algebras/lie_algebras/center_uea.py

@@ -309,7 +309,7 @@ def _construct_next_degree(self):
                 continue
             M = matrix(R, [[v[s] for v in ad] for s in supp])
             ker = M.right_kernel_matrix()
-            vecs = [self._reduce(UEA.linear_combination((vecs[i], c) for i, c in kv.iteritems()))
+            vecs = [self._reduce(UEA.linear_combination((vecs[i], c) for i, c in kv.items()))
                     for kv in ker.rows()]
 
         # Lastly, update the appropriate data

src/sage/algebras/lie_algebras/verma_module.py

@@ -1490,7 +1490,8 @@ def singular_vector(self):
                             continue
                         M = matrix(pbw.base_ring(), [[v[s] for v in image] for s in supp])
                         ker = M.right_kernel_matrix()
-                        basis = [C.linear_combination((basis[j], c) for j, c in kv.iteritems())
+                        basis = [C.linear_combination((basis[j], c)
+                                                      for j, c in kv.items())
                                  for kv in ker.rows()]
 
                     assert len(basis) == 1

src/sage/categories/finite_dimensional_lie_algebras_with_basis.py

@@ -1788,7 +1788,7 @@ def compute_diff(k):
                                 vec = elt.to_vector()
                             else:
                                 vec = Lmod.coordinate_vector(elt.to_vector())
-                            for key, coeff in vec.iteritems():
+                            for key, coeff in vec.items():
                                 if not coeff:
                                     continue
                                 s, A = sgn(key, Z)

src/sage/modules/free_module_element.pyx

@@ -693,7 +693,7 @@ def prepare(v, R, degree=None):
     if isinstance(v, dict):
         # convert to a list
         X = [0]*degree
-        for key, value in v.iteritems():
+        for key, value in v.items():
             X[key] = value
         v = X
     # convert to a Sequence over common ring
@@ -1711,18 +1711,9 @@ cdef class FreeModuleElement(Vector):   # abstract base class
             <...generator object at ...>
             sage: list(v.items())                                                       # needs sage.symbolic
             [(0, 1), (1, 2/3), (2, pi)]
-
-        TESTS:
-
-        Using iteritems as an alias::
-
-            sage: list(v.iteritems())                                                   # needs sage.symbolic
-            [(0, 1), (1, 2/3), (2, pi)]
         """
         cdef dict d = self.dict(copy=False)
-        yield from d.iteritems()
-
-    iteritems = items
+        yield from d.items()
 
     def __abs__(self):
         """
@@ -3305,10 +3296,8 @@ cdef class FreeModuleElement(Vector):   # abstract base class
         V = self.parent()
         R = self.base_ring()
         if self.is_sparse():
-            # this could be a dictionary comprehension in Python 3
-            entries = {}
-            for index, entry in self.iteritems():
-                entries[index] = entry.conjugate()
+            entries = {index: entry.conjugate()
+                       for index, entry in self.items()}
         else:
             entries = [entry.conjugate() for entry in self]
         return V(vector(R, self._degree, entries))
@@ -5021,7 +5010,7 @@ cdef class FreeModuleElement_generic_sparse(FreeModuleElement):
                 e = entries_dict
                 entries_dict = {}
                 try:
-                    for k, x in (<dict> e).iteritems():
+                    for k, x in (<dict> e).items():
                         x = coefficient_ring(x)
                         if x:
                             entries_dict[k] = x
@@ -5042,7 +5031,7 @@ cdef class FreeModuleElement_generic_sparse(FreeModuleElement):
             (2, 4/3, 2*pi)
         """
         cdef dict v = dict((<FreeModuleElement_generic_sparse>right)._entries)
-        for i, a in left._entries.iteritems():
+        for i, a in left._entries.items():
             if i in v:
                 sum = (<Element>a)._add_(<Element> v[i])
                 if sum:
@@ -5062,7 +5051,7 @@ cdef class FreeModuleElement_generic_sparse(FreeModuleElement):
             (0, 0, 0)
         """
         cdef dict v = dict(left._entries)   # dict to make a copy
-        for i, a in (<FreeModuleElement_generic_sparse>right)._entries.iteritems():
+        for i, a in (<FreeModuleElement_generic_sparse>right)._entries.items():
             if i in v:
                 diff = (<Element> v[i])._sub_(<Element>a)
                 if diff:
@@ -5083,7 +5072,7 @@ cdef class FreeModuleElement_generic_sparse(FreeModuleElement):
         """
         cdef dict v = {}
         if right:
-            for i, a in self._entries.iteritems():
+            for i, a in self._entries.items():
                 prod = (<Element>a)._mul_(right)
                 if prod:
                     v[i] = prod
@@ -5099,7 +5088,7 @@ cdef class FreeModuleElement_generic_sparse(FreeModuleElement):
         """
         cdef dict v = {}
         if left:
-            for i, a in self._entries.iteritems():
+            for i, a in self._entries.items():
                 prod = left._mul_(a)
                 if prod:
                     v[i] = prod
@@ -5152,7 +5141,7 @@ cdef class FreeModuleElement_generic_sparse(FreeModuleElement):
         z = left.base_ring().zero()
         if left.base_ring() is not right.base_ring():
             z *= right.base_ring().zero()
-        for i, a in left._entries.iteritems():
+        for i, a in left._entries.items():
             if i in e:
                 z += a * e[i]
         return z
@@ -5168,7 +5157,7 @@ cdef class FreeModuleElement_generic_sparse(FreeModuleElement):
         # Component wise vector * vector multiplication.
         cdef dict e = (<FreeModuleElement_generic_sparse>right)._entries
         cdef dict v = {}
-        for i, a in left._entries.iteritems():
+        for i, a in left._entries.items():
             if i in e:
                 prod = (<Element>a)._mul_(<Element> e[i])
                 if prod:
@@ -5199,8 +5188,8 @@ cdef class FreeModuleElement_generic_sparse(FreeModuleElement):
             sage: a < b
             True
         """
-        a = sorted((<FreeModuleElement_generic_sparse>left)._entries.iteritems())
-        b = sorted((<FreeModuleElement_generic_sparse>right)._entries.iteritems())
+        a = sorted((<FreeModuleElement_generic_sparse>left)._entries.items())
+        b = sorted((<FreeModuleElement_generic_sparse>right)._entries.items())
 
         return richcmp([(-x, y) for x, y in a], [(-x, y) for x, y in b], op)
 
@@ -5220,12 +5209,10 @@ cdef class FreeModuleElement_generic_sparse(FreeModuleElement):
 
         Using iteritems as an alias::
 
-            sage: list(v.iteritems())                                                   # needs sage.symbolic
+            sage: list(v.items())                                                   # needs sage.symbolic
             [(0, 1), (1, 2/3), (2, pi)]
         """
-        return iter(self._entries.iteritems())
-
-    iteritems = items
+        return iter(self._entries.items())
 
     def __reduce__(self):
         """
@@ -5291,7 +5278,7 @@ cdef class FreeModuleElement_generic_sparse(FreeModuleElement):
             # Loop over the old dict and convert old index n to new
             # index k in slice
             newentries = {}
-            for n, x in self._entries.iteritems():
+            for n, x in self._entries.items():
                 if min <= n <= max and n % step == mod:
                     k = (n - start) // step
                     newentries[k] = x
@@ -5388,7 +5375,7 @@ cdef class FreeModuleElement_generic_sparse(FreeModuleElement):
             d = d.denominator()
         except AttributeError:
             return d
-        for y in self._entries.itervalues():
+        for y in self._entries.values():
             d = d.lcm(y.denominator())
         return d
 
@@ -5447,7 +5434,7 @@ cdef class FreeModuleElement_generic_sparse(FreeModuleElement):
         """
         z = self._parent.coordinate_ring().zero()
         cdef list v = [z] * self._degree
-        for i, a in self._entries.iteritems():
+        for i, a in self._entries.items():
             v[i] = a
         return v
 
@@ -5516,4 +5503,4 @@ cdef class FreeModuleElement_generic_sparse(FreeModuleElement):
         if prec is None:
             prec = digits_to_bits(digits)
         return vector({k: v.numerical_approx(prec, algorithm=algorithm)
-                       for k, v in self._entries.iteritems()}, sparse=True)
+                       for k, v in self._entries.items()}, sparse=True)

src/sage/modules/with_basis/subquotient.py

@@ -648,7 +648,7 @@ def __and__(self, other):
         UV = U & V  # the intersection
         A = self._ambient
         supp = self._support_order
-        return A.submodule([A.element_class(A, {supp[i]: c for i, c in vec.iteritems()})
+        return A.submodule([A.element_class(A, {supp[i]: c for i, c in vec.items()})
                             for vec in UV.basis()])
 
     intersection = __and__