gh-40685: cython-lint cleanup in modules folder
    
fixing minor details, as suggested by cython-lint

also converting a few loops to use `range`

### 📝 Checklist

- [x] The title is concise and informative.
- [x] The description explains in detail what this PR is about.
    
URL: #40685
Reported by: Frédéric Chapoton
Reviewer(s): Frédéric Chapoton, Michael Orlitzky

Author: Release Manager

src/sage/modules/finite_submodule_iter.pxd

@@ -1,7 +1,7 @@
 from sage.structure.element cimport ModuleElement
 
 cdef class FiniteZZsubmodule_iterator:
-    #### Global Data
+    # Global Data
     cdef FiniteZZsubmodule_iterator _other_ZZ
     cdef ModuleElement _basis
     cdef ModuleElement _cw

src/sage/modules/finite_submodule_iter.pyx

@@ -57,14 +57,14 @@ will result in improved running times::
     True
 """
 
-#*****************************************************************************
+# ***************************************************************************
 #       Copyright (C) 2012 Thomas Feulner <[email protected]>
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
 #  as published by the Free Software Foundation; either version 2 of
 #  the License, or (at your option) any later version.
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
 
 cdef class FiniteZZsubmodule_iterator:
     r"""

src/sage/modules/free_module_element.pyx

@@ -953,7 +953,7 @@ def random_vector(ring, degree=None, *args, **kwds):
     if ring not in Rings():
         raise TypeError("elements of a vector, or module element, must come from a ring, not %s" % ring)
     if not hasattr(ring, "random_element"):
-        raise AttributeError("cannot create a random vector since there is no random_element() method for %s" % ring )
+        raise AttributeError("cannot create a random vector since there is no random_element() method for %s" % ring)
     sparse = kwds.pop('sparse', False)
     entries = [ring.random_element(*args, **kwds) for _ in range(degree)]
     return vector(ring, degree, entries, sparse)
@@ -1290,16 +1290,15 @@ cdef class FreeModuleElement(Vector):   # abstract base class
         # on the elements, which is sometimes much prettier than
         # the coerced=False we would get otherwise.
         if self.is_sparse_c():
-            items = [(n, sib(e, 2))
-                     for n,e in self.dict().items()]
+            items = [(n, sib(e, 2)) for n, e in self.dict().items()]
             items.sort()
             if len(self):
                 # we may need to add an extra element on the end to
                 # set the size.  (There doesn't seem to be a better way
                 # to do it.)
-                if len(items) == 0 or len(self)-1 > items[-1][0]:
+                if not items or len(self)-1 > items[-1][0]:
                     items.append((len(self)-1, sib.int(0)))
-            items_dict = sib.dict([(sib.int(n), e) for n,e in items])
+            items_dict = sib.dict([(sib.int(n), e) for n, e in items])
 
             return sib.name('vector')(self.base_ring(), items_dict)
         else:
@@ -1508,7 +1507,7 @@ cdef class FreeModuleElement(Vector):   # abstract base class
         """
         from sage.matrix.args import MatrixArgs
         ma = MatrixArgs(self._parent._base, 1, self.degree(),
-                list(self), sparse=self.is_sparse())
+                        list(self), sparse=self.is_sparse())
         return ma.matrix()
 
     def column(self):
@@ -1580,7 +1579,7 @@ cdef class FreeModuleElement(Vector):   # abstract base class
         """
         from sage.matrix.args import MatrixArgs
         ma = MatrixArgs(self._parent._base, self.degree(), 1,
-                [(x,) for x in self], sparse=self.is_sparse())
+                        [(x,) for x in self], sparse=self.is_sparse())
         return ma.matrix()
 
     def __copy__(self):
@@ -1622,7 +1621,7 @@ cdef class FreeModuleElement(Vector):   # abstract base class
             sage: v.subs(a=b, b=d)
             (b, d, d, e)
         """
-        return self.parent()([ a.subs(in_dict, **kwds) for a in self.list() ])
+        return self.parent()([a.subs(in_dict, **kwds) for a in self.list()])
 
     def change_ring(self, R):
         """
@@ -2481,7 +2480,9 @@ cdef class FreeModuleElement(Vector):   # abstract base class
                 from sage.plot.plot3d.shapes2 import line3d, point3d
 
                 if plot_type == 'arrow':
-                    return line3d([start, [(u+v) for u,v in zip(coords, start)]], arrow_head=True, **kwds)
+                    return line3d([start,
+                                   [(u+v) for u, v in zip(coords, start)]],
+                                  arrow_head=True, **kwds)
                 else:
                     return point3d(coords, **kwds)
             elif dimension < 3:
@@ -2492,7 +2493,8 @@ cdef class FreeModuleElement(Vector):   # abstract base class
 
                 from sage.plot.all import arrow, point
                 if plot_type == 'arrow':
-                    return arrow(start, [(u+v) for u,v in zip(coords, start)], **kwds)
+                    return arrow(start,
+                                 [(u+v) for u, v in zip(coords, start)], **kwds)
                 else:
                     return point(coords, **kwds)
             else:
@@ -2504,7 +2506,7 @@ cdef class FreeModuleElement(Vector):   # abstract base class
             raise NotImplementedError("plot_type was unrecognized")
 
     def plot_step(self, xmin=0, xmax=1, eps=None, res=None,
-             connect=True, **kwds):
+                  connect=True, **kwds):
         r"""
         INPUT:
 
@@ -2542,9 +2544,9 @@ cdef class FreeModuleElement(Vector):   # abstract base class
             y = float(self[i])
             if x > xmax:
                 break
-            v.append((x,y))
+            v.append((x, y))
             x += eps
-            v.append((x,y))
+            v.append((x, y))
         from sage.plot.all import line, points
         if connect:
             return line(v, **kwds)
@@ -2885,9 +2887,9 @@ cdef class FreeModuleElement(Vector):   # abstract base class
             MS = MatrixSpace(R, rank, rank, sparse=self.is_sparse())
             s = self.list(copy=False)
             return MS([
-                [ zero, -s[2],  s[1]],
-                [ s[2],  zero, -s[0]],
-                [-s[1],  s[0],  zero]])
+                [zero, -s[2], s[1]],
+                [s[2], zero, -s[0]],
+                [-s[1], s[0], zero]])
         elif rank == 7:
             MS = MatrixSpace(R, rank, rank, sparse=self.is_sparse())
             s = self.list(copy=False)
@@ -4031,16 +4033,16 @@ cdef class FreeModuleElement(Vector):   # abstract base class
             zero_res = 0
             if len(self.dict(copy=False)) < self._degree:
                 # OK, we have some zero entries.
-                zero_res = phi(self.base_ring()(0))
+                zero_res = phi(self.base_ring().zero())
                 if not zero_res.is_zero():
                     # And phi maps 0 to a nonzero value.
                     v = [zero_res] * self._degree
-                    for i,z in self.dict(copy=False).items():
+                    for i, z in self.dict(copy=False).items():
                         v[i] = phi(z)
 
             if v is None:
                 # phi maps 0 to 0 (or else we don't have any zeroes at all)
-                v = dict([(i,phi(z)) for i,z in self.dict(copy=False).items()])
+                v = {i: phi(z) for i, z in self.dict(copy=False).items()}
                 # add a zero at the last position, if it is not already set.
                 # This will help the constructor to determine the right degree.
                 v.setdefault(self._degree-1, zero_res)
@@ -4189,14 +4191,14 @@ cdef class FreeModuleElement(Vector):   # abstract base class
         # return self.apply_map(lambda x: x.nintegral(*args, **kwds) for x in self)
 
         if self.is_sparse():
-            v = [(i,z.nintegral(*args, **kwds)) for i,z in self.dict(copy=False).items()]
-            answers = dict([(i,a[0]) for i,a in v])
-            v=dict(v)
+            v = {i: z.nintegral(*args, **kwds)
+                 for i, z in self.dict(copy=False).items()}
+            answers = {i: a[0] for i, a in v.items()}
         else:
             v = [z.nintegral(*args, **kwds) for z in self.list()]
             answers = [a[0] for a in v]
 
-        return (vector(answers,sparse=self.is_sparse()), v)
+        return (vector(answers, sparse=self.is_sparse()), v)
 
     nintegrate = nintegral
 
@@ -5518,4 +5520,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.iteritems()}, sparse=True)

src/sage/modules/module.pyx

@@ -49,7 +49,7 @@ A minimal example of a module::
     sage: TestSuite(M).run()
 """
 
-#*****************************************************************************
+# ***************************************************************************
 #       Copyright (C) 2005 William Stein <[email protected]>
 #                     2014 Julian Rueth <[email protected]>
 #
@@ -62,8 +62,8 @@ A minimal example of a module::
 #
 #  The full text of the GPL is available at:
 #
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
 
 cdef class Module(Parent):
     """

src/sage/modules/vector_complex_double_dense.pyx

@@ -31,15 +31,15 @@ AUTHORS:
        Vector_double_dense class
 """
 
-#*****************************************************************************
+# ***************************************************************************
 #       Copyright (C) 2008 Jason Grout <[email protected]>
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 2 of the License, or
 # (at your option) any later version.
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
 
 from sage.rings.complex_double import CDF
 

src/sage/modules/vector_double_dense.pyx

@@ -33,7 +33,7 @@ AUTHORS:
 - William Stein
 """
 
-#*****************************************************************************
+# ***************************************************************************
 #       Copyright (C) 2006-2010 William Stein <[email protected]>
 #       Copyright (C) 2009      Alexandru Ghitza
 #       Copyright (C) 2020      Antonio Rojas
@@ -48,7 +48,7 @@ AUTHORS:
 # the Free Software Foundation, either version 2 of the License, or
 # (at your option) any later version.
 #                  https://www.gnu.org/licenses/
-#*****************************************************************************
+# ***************************************************************************
 
 cimport numpy
 import numpy

src/sage/modules/vector_integer_sparse.pxd

@@ -8,9 +8,9 @@ from sage.libs.gmp.types cimport mpz_t
 
 cdef struct mpz_vector:
     mpz_t *entries      # array of nonzero entries
-    Py_ssize_t   *positions    # positions of those nonzero entries, starting at 0
-    Py_ssize_t    degree       # the degree of this sparse vector
-    Py_ssize_t    num_nonzero  # the number of nonzero entries of this vector.
+    Py_ssize_t *positions   # positions of those nonzero entries, starting at 0
+    Py_ssize_t degree       # the degree of this sparse vector
+    Py_ssize_t num_nonzero  # the number of nonzero entries of this vector.
 
 cdef int allocate_mpz_vector(mpz_vector* v, Py_ssize_t num_nonzero) except -1
 cdef int mpz_vector_init(mpz_vector* v, Py_ssize_t degree, Py_ssize_t num_nonzero) except -1

src/sage/modules/vector_integer_sparse.pyx

@@ -163,10 +163,10 @@ cdef object mpz_vector_to_list(mpz_vector* v):
     cdef Integer a
     cdef Py_ssize_t i
     X = []
-    for i from 0 <= i < v.num_nonzero:
+    for i in range(v.num_nonzero):
         a = Integer()
         a.set_from_mpz(v.entries[i])
-        X.append( (v.positions[i], a) )
+        X.append((v.positions[i], a))
     return X
 
 
@@ -318,7 +318,7 @@ cdef int add_mpz_vector_init(mpz_vector* sum,
             mpz_set(z.entries[k], v.entries[i])
             i = i + 1
             k = k + 1
-        elif v.positions[i] > w.positions[j]: # copy entry from w in
+        elif v.positions[i] > w.positions[j]:  # copy entry from w in
             if do_multiply:
                 # This means: tmp = multiple*w.entries[j]
                 mpz_mul(tmp, multiple, w.entries[j])
@@ -343,7 +343,7 @@ cdef int add_mpz_vector_init(mpz_vector* sum,
                 k = k + 1     # only increment if sum is nonzero!
             i = i + 1
             j = j + 1
-        #end if
+        # end if
     # end while
     for i from k <= i < z.num_nonzero:
         mpz_clear(z.entries[i])
@@ -357,7 +357,7 @@ cdef int mpz_vector_scale(mpz_vector* v, mpz_t scalar) except -1:
         mpz_vector_init(v, v.degree, 0)
         return 0
     cdef Py_ssize_t i
-    for i from 0 <= i < v.num_nonzero:
+    for i in range(v.num_nonzero):
         # v.entries[i] = scalar * v.entries[i]
         mpz_mul(v.entries[i], v.entries[i], scalar)
     return 0

src/sage/modules/vector_modn_sparse.pyx

@@ -264,7 +264,7 @@ cdef int add_c_vector_modint_init(c_vector_modint* sum, c_vector_modint* v,
             z.entries[k] = v.entries[i]
             i = i + 1
             k = k + 1
-        elif v.positions[i] > w.positions[j]: # copy entry from w in
+        elif v.positions[i] > w.positions[j]:  # copy entry from w in
             s = (multiple * w.entries[j]) % v.p
             if s != 0:
                 z.positions[k] = w.positions[j]