gh-40026: just a few pep8 details
    
nothing serious, but a little cleanup

### 📝 Checklist

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

Author: Release Manager

src/sage/groups/matrix_gps/binary_dihedral.py

@@ -82,7 +82,7 @@ def __init__(self, n):
 
         MS = MatrixSpace(R, 2)
         zero = R.zero()
-        gens = [ MS([zeta, zero, zero, ~zeta]), MS([zero, i, i, zero]) ]
+        gens = [MS([zeta, zero, zero, ~zeta]), MS([zero, i, i, zero])]
 
         from sage.libs.gap.libgap import libgap
         gap_gens = [libgap(matrix_gen) for matrix_gen in gens]

src/sage/rings/polynomial/multi_polynomial_sequence.py

@@ -314,11 +314,12 @@ def PolynomialSequence(arg1, arg2=None, immutable=False, cr=False, cr_str=None):
     except ImportError:
         BooleanMonomialMonoid = ()
 
-    def is_ring(r): return (isinstance(r, (MPolynomialRing_base,
-                                           BooleanMonomialMonoid,
-                                           InfinitePolynomialRing_sparse))
-                            or (isinstance(r, QuotientRing_nc)
-                                and isinstance(r.cover_ring(), MPolynomialRing_base)))
+    def is_ring(r):
+        return (isinstance(r, (MPolynomialRing_base,
+                               BooleanMonomialMonoid,
+                               InfinitePolynomialRing_sparse))
+                or (isinstance(r, QuotientRing_nc)
+                    and isinstance(r.cover_ring(), MPolynomialRing_base)))
 
     if is_ring(arg1):
         ring, gens = arg1, arg2
@@ -1101,7 +1102,7 @@ def macaulay_matrix(self, degree,
             # order the rows with TOP
             else:
                 R_monomials_useful = []
-                for i in range(degree,target_degree-self.minimal_degree()+1):
+                for i in range(degree, target_degree-self.minimal_degree()+1):
                     R_monomials_useful += R_monomials_of_degree[i]
                 R_monomials_useful.sort()
                 for mon in R_monomials_useful:
@@ -1461,6 +1462,7 @@ def maximal_degree(self):
             return max(f.degree() for f in self)
         except ValueError:
             return -1  # empty sequence
+
     def minimal_degree(self):
         """
         Return the minimal degree of any polynomial in this sequence.
@@ -1777,7 +1779,8 @@ def eliminate_linear_variables(self, maxlength=Infinity, skip=None, return_reduc
         else:
             # slower, more flexible solution
             if skip is None:
-                def skip(lm, tail): return False
+                def skip(lm, tail):
+                    return False
 
             while True:
                 linear = []
@@ -1997,7 +2000,9 @@ def solve(self, algorithm='polybori', n=1,
         eliminated_variables = {f.lex_lead() for f in reductors}
         leftover_variables = {x.lm() for x in R_origin.gens()} - solved_variables - eliminated_variables
 
-        def key_convert(x): return R_origin(x).lm()
+        def key_convert(x):
+            return R_origin(x).lm()
+
         if leftover_variables != set():
             partial_solutions = solutions
             solutions = []

src/sage/schemes/generic/algebraic_scheme.py

@@ -1358,7 +1358,7 @@ def Jacobian(self):
         d = self.codimension()
         minors = self.Jacobian_matrix().minors(d)
         I = self.defining_ideal()
-        minors = tuple([ I.reduce(m) for m in minors ])
+        minors = tuple([I.reduce(m) for m in minors])
         return I.ring().ideal(I.gens() + minors)
 
     def reduce(self):

src/sage/schemes/generic/divisor.py

@@ -69,8 +69,8 @@ def CurvePointToIdeal(C, P):
     R = A.coordinate_ring()
     n = A.ngens()
     x = A.gens()
-    polys = [ ]
-    m = n-1
+    polys = []
+    m = n - 1
     while m > 0 and P[m] == 0:
         m += -1
     if isinstance(A, ProjectiveSpace_ring):

src/sage/schemes/plane_conics/con_field.py

@@ -70,8 +70,8 @@ def __init__(self, A, f):
             Projective Conic Curve over Rational Field defined by x^2 + y^2 + z^2
         """
         super().__init__(A, f)
-        self._coefficients = [f[(2,0,0)], f[(1,1,0)], f[(1,0,1)],
-                                f[(0,2,0)], f[(0,1,1)], f[(0,0,2)]]
+        self._coefficients = [f[(2, 0, 0)], f[(1, 1, 0)], f[(1, 0, 1)],
+                              f[(0, 2, 0)], f[(0, 1, 1)], f[(0, 0, 2)]]
         self._parametrization = None
         self._diagonal_matrix = None
 
@@ -116,13 +116,13 @@ def base_extend(self, S):
                 return self
             if not S.has_coerce_map_from(B):
                 raise ValueError("No natural map from the base ring of self "
-                                  "(= %s) to S (= %s)" % (self, S))
+                                 "(= %s) to S (= %s)" % (self, S))
             from .constructor import Conic
             con = Conic([S(c) for c in self.coefficients()],
                         self.variable_names())
             if self._rational_point is not None:
                 pt = [S(c) for c in Sequence(self._rational_point)]
-                if not pt == [0,0,0]:
+                if not pt == [0, 0, 0]:
                     # The following line stores the point in the cache
                     # if (and only if) there is no point in the cache.
                     pt = con.point(pt)
@@ -284,26 +284,26 @@ def diagonal_matrix(self):
         """
         A = self.symmetric_matrix()
         B = self.base_ring()
-        basis = [vector(B,{2:0,i:1}) for i in range(3)]
+        basis = [vector(B, {2: 0, i: 1}) for i in range(3)]
         for i in range(3):
             zerovalue = (basis[i]*A*basis[i].column() == 0)
             if zerovalue:
-                for j in range(i+1,3):
+                for j in range(i+1, 3):
                     if basis[j]*A*basis[j].column() != 0:
                         b = basis[i]
                         basis[i] = basis[j]
                         basis[j] = b
                         zerovalue = False
             if zerovalue:
-                for j in range(i+1,3):
+                for j in range(i+1, 3):
                     if basis[i]*A*basis[j].column() != 0:
                         basis[i] = basis[i]+basis[j]
                         zerovalue = False
             if not zerovalue:
                 l = (basis[i]*A*basis[i].column())
-                for j in range(i+1,3):
+                for j in range(i+1, 3):
                     basis[j] = basis[j] - \
-                               (basis[i]*A*basis[j].column())/l * basis[i]
+                        (basis[i]*A*basis[j].column())/l * basis[i]
         T = matrix(basis).transpose()
         return T.transpose()*A*T, T
 
@@ -537,24 +537,24 @@ def has_rational_point(self, point=False,
 
         if isinstance(B, sage.rings.abc.ComplexField):
             if point:
-                [_,_,_,d,e,f] = self._coefficients
+                _, _, _, d, e, f = self._coefficients
                 if d == 0:
-                    return True, self.point([0,1,0])
+                    return True, self.point([0, 1, 0])
                 return True, self.point([0, ((e**2-4*d*f).sqrt()-e)/(2*d), 1],
                                         check=False)
             return True
         if isinstance(B, sage.rings.abc.RealField):
             D, T = self.diagonal_matrix()
-            [a, b, c] = [D[0,0], D[1,1], D[2,2]]
+            a, b, c = [D[0, 0], D[1, 1], D[2, 2]]
             if a == 0:
-                ret = True, self.point(T*vector([1,0,0]), check=False)
+                ret = True, self.point(T*vector([1, 0, 0]), check=False)
             elif a*c <= 0:
-                ret = True, self.point(T*vector([(-c/a).sqrt(),0,1]),
+                ret = True, self.point(T*vector([(-c/a).sqrt(), 0, 1]),
                                        check=False)
             elif b == 0:
-                ret = True, self.point(T*vector([0,1,0]), check=False)
+                ret = True, self.point(T*vector([0, 1, 0]), check=False)
             elif b*c <= 0:
-                ret = True, self.point(T*vector([0,(-c/b).sqrt(),0,1]),
+                ret = True, self.point(T*vector([0, (-c/b).sqrt(), 0, 1]),
                                        check=False)
             else:
                 ret = False, None
@@ -617,16 +617,16 @@ def has_singular_point(self, point=False):
             return ret[0]
         B = self.base_ring()
         if B.characteristic() == 2:
-            [a,b,c,d,e,f] = self.coefficients()
+            a, b, c, d, e, f = self.coefficients()
             if b == 0 and c == 0 and e == 0:
                 for i in range(3):
                     if [a, d, f][i] == 0:
-                        return True, self.point(vector(B, {2:0, i:1}))
+                        return True, self.point(vector(B, {2: 0, i: 1}))
                 if hasattr(a/f, 'is_square') and hasattr(a/f, 'sqrt'):
                     if (a/f).is_square():
-                        return True, self.point([1,0,(a/f).sqrt()])
+                        return True, self.point([1, 0, (a/f).sqrt()])
                     if (d/f).is_square():
-                        return True, self.point([0,1,(d/f).sqrt()])
+                        return True, self.point([0, 1, (d/f).sqrt()])
                 raise NotImplementedError("Sorry, find singular point on conics not implemented over all fields of characteristic 2.")
             pt = [e, c, b]
             if self.defining_polynomial()(pt) == 0:
@@ -760,7 +760,7 @@ def is_smooth(self):
             True
         """
         if self.base_ring().characteristic() == 2:
-            [a,b,c,d,e,f] = self.coefficients()
+            a, b, c, d, e, f = self.coefficients()
             if b == 0 and c == 0 and e == 0:
                 return False
             return self.defining_polynomial()([e, c, b]) != 0
@@ -803,7 +803,7 @@ def _magma_init_(self, magma):
         kmn = magma(self.base_ring())._ref()
         coeffs = self.coefficients()
         magma_coeffs = [coeffs[i]._magma_init_(magma) for i in [0, 3, 5, 1, 4, 2]]
-        return 'Conic([%s|%s])' % (kmn,','.join(magma_coeffs))
+        return 'Conic([%s|%s])' % (kmn, ','.join(magma_coeffs))
 
     def matrix(self):
         r"""
@@ -1265,10 +1265,10 @@ def upper_triangular_matrix(self):
             x^2 + 2*x*y + y^2 + 3*x*z + z^2
         """
         from sage.matrix.constructor import matrix
-        [a,b,c,d,e,f] = self.coefficients()
-        return matrix([[ a, b, c ],
-                       [ 0, d, e ],
-                       [ 0, 0, f ]])
+        a, b, c, d, e, f = self.coefficients()
+        return matrix([[a, b, c],
+                       [0, d, e],
+                       [0, 0, f]])
 
     def variable_names(self):
         r"""