diff --git a/src/sage/coding/binary_code.pyx b/src/sage/coding/binary_code.pyx
index 83dbefdfaf3..1b8b1d17ae1 100644
--- a/src/sage/coding/binary_code.pyx
+++ b/src/sage/coding/binary_code.pyx
@@ -617,7 +617,7 @@ cdef codeword *expand_to_ortho_basis(BinaryCode B, int n) noexcept:
         i = k
         word = <codeword>1 << k
         k += 1
-    else: # NOTE THIS WILL NEVER HAPPEN AS CURRENTLY SET UP!
+    else:  # NOTE THIS WILL NEVER HAPPEN AS CURRENTLY SET UP!
         temp = (<codeword>1 << k) - 1
         i = k
         word = <codeword>1 << k
@@ -813,7 +813,7 @@ cdef class BinaryCode:
                     combination ^= (1 << j)
                     word ^= self_basis[j]
 
-        else: # isinstance(arg1, BinaryCode)
+        else:  # isinstance(arg1, BinaryCode)
             other_basis = other.basis
             for i from 0 <= i < nrows-1:
                 self_basis[i] = other_basis[i]
@@ -2423,9 +2423,12 @@ cdef class PartitionStack:
         cdef int *self_wd_lvls = self.wd_lvls
         cdef int *self_wd_ents = self.wd_ents
         while True:
-            if CG.is_one(self_wd_ents[wd_ptr], col): i += 1
-            if self_wd_lvls[wd_ptr] > k: wd_ptr += 1
-            else: break
+            if CG.is_one(self_wd_ents[wd_ptr], col):
+                i += 1
+            if self_wd_lvls[wd_ptr] > k:
+                wd_ptr += 1
+            else:
+                break
         return i
 
     def _wd_degree(self, C, wd, col_ptr, k):
@@ -3347,15 +3350,17 @@ cdef class BinaryCodeClassifier:
                 if qzb > 0: zb__Lambda_rho[k] = Lambda[k]
                 state = 3
 
-            elif state == 3: # attempt to rule out automorphisms while moving down the tree
+            elif state == 3:  # attempt to rule out automorphisms while moving down the tree
                 # if k > hzf, then we know that nu currently does not look like zeta, the first
                 # terminal node encountered, thus there is no automorphism to discover. If qzb < 0,
                 # i.e. Lambda[k] < zb[k], then the indicator is not maximal, and we can't reach a
                 # canonical leaf. If neither of these is the case, then proceed to state 4.
-                if hzf__h_zeta <= k or qzb >= 0: state = 4
-                else: state = 6
+                if hzf__h_zeta <= k or qzb >= 0:
+                    state = 4
+                else:
+                    state = 6
 
-            elif state == 4: # at this point we have -not- ruled out the presence of automorphisms
+            elif state == 4:  # at this point we have -not- ruled out the presence of automorphisms
                 if nu.is_discrete(k):
                     state = 7
                     continue  # we have a terminal node, so process it
@@ -3365,17 +3370,18 @@ cdef class BinaryCodeClassifier:
                 # equal to its minimum element
                 v[k] = nu.new_first_smallest_nontrivial(k, W, self.Phi_size * k)
                 if not nu.sat_225(k): hh = k + 1
-                e[k] = 0 # see state 12 and 17
-                state = 2 # continue down the tree
+                e[k] = 0  # see state 12 and 17
+                state = 2  # continue down the tree
 
-            elif state == 5: # same as state 3, but in the case where we haven't yet defined zeta
-                             # i.e. this is our first time down the tree. Once we get to the bottom,
-                             # we will have zeta = nu = rho, so we do:
+            elif state == 5:
+                # same as state 3, but in the case where we haven't yet defined zeta
+                # i.e. this is our first time down the tree. Once we get to the bottom,
+                # we will have zeta = nu = rho, so we do:
                 zf__Lambda_zeta[k] = Lambda[k]
                 zb__Lambda_rho[k] = Lambda[k]
                 state = 4
 
-            elif state == 6: # at this stage, there is no reason to continue downward, so backtrack
+            elif state == 6:  # at this stage, there is no reason to continue downward, so backtrack
                 j = k
 
                 # return to the longest ancestor nu[i] of nu that could have a
@@ -3396,9 +3402,10 @@ cdef class BinaryCodeClassifier:
                     else:
                         k = hh-1
                 # TODO: is the following line necessary?
-                if k == -1: k = 0
+                if k == -1:
+                    k = 0
 
-                if hb > k:# update hb since we are backtracking
+                if hb > k:  # update hb since we are backtracking
                     hb = k
                 # if j == hh, then all nodes lower than our current position are equivalent, so bail out
                 if j == hh:
@@ -3465,7 +3472,7 @@ cdef class BinaryCodeClassifier:
 
                 state = 10
 
-            elif state == 9: # nu is a better guess at the canonical label than rho
+            elif state == 9:  # nu is a better guess at the canonical label than rho
                 rho = PartitionStack(nu)
                 k_rho = k
                 qzb = 0
@@ -3475,7 +3482,7 @@ cdef class BinaryCodeClassifier:
                 zb__Lambda_rho[k+1] = -1
                 state = 6
 
-            elif state == 10: # we have an automorphism to process
+            elif state == 10:  # we have an automorphism to process
                 # increment l
                 if l < self.L-1: l += 1
                 # store information about the automorphism to Omega and Phi
@@ -3496,8 +3503,8 @@ cdef class BinaryCodeClassifier:
                         Omega[ii] ^= (1<<j)  # so cancel
                         j = col_gamma[j]     # cellmates
                     i += 1
-                    while i < ncols and not Omega[ii]&(1<<i): # find minimal element
-                        i += 1                                # of next cell
+                    while i < ncols and not Omega[ii]&(1<<i):  # find minimal element
+                        i += 1                                 # of next cell
                 i = 0
                 jj = self.radix
                 while i < nwords:
diff --git a/src/sage/libs/mpmath/ext_impl.pyx b/src/sage/libs/mpmath/ext_impl.pyx
index 8996d6296cf..477b6a09b09 100644
--- a/src/sage/libs/mpmath/ext_impl.pyx
+++ b/src/sage/libs/mpmath/ext_impl.pyx
@@ -1183,10 +1183,14 @@ cdef MPF_exp(MPF *y, MPF *x, MPopts opts):
     cdef mpz_t t, u
     cdef tuple w
     if x.special:
-        if x.special == S_ZERO: MPF_set_si(y, 1)
-        elif x.special == S_NINF: MPF_set_zero(y)
-        elif x.special == S_INF: MPF_set_inf(y)
-        else: MPF_set_nan(y)
+        if x.special == S_ZERO:
+            MPF_set_si(y, 1)
+        elif x.special == S_NINF:
+            MPF_set_zero(y)
+        elif x.special == S_INF:
+            MPF_set_inf(y)
+        else:
+            MPF_set_nan(y)
         return
     wp = opts.prec + 14
     sign = mpz_sgn(x.man) < 0
diff --git a/src/sage/libs/mpmath/utils.pyx b/src/sage/libs/mpmath/utils.pyx
index 5f681852c68..47061a6bfa4 100644
--- a/src/sage/libs/mpmath/utils.pyx
+++ b/src/sage/libs/mpmath/utils.pyx
@@ -134,11 +134,15 @@ cpdef normalize(long sign, Integer man, exp, long bc, long prec, str rnd):
         elif rnd == 'd':
             mpz_fdiv_q_2exp(res.value, man.value, shift)
         elif rnd == 'f':
-            if sign: mpz_cdiv_q_2exp(res.value, man.value, shift)
-            else:    mpz_fdiv_q_2exp(res.value, man.value, shift)
+            if sign:
+                mpz_cdiv_q_2exp(res.value, man.value, shift)
+            else:
+                mpz_fdiv_q_2exp(res.value, man.value, shift)
         elif rnd == 'c':
-            if sign: mpz_fdiv_q_2exp(res.value, man.value, shift)
-            else:    mpz_cdiv_q_2exp(res.value, man.value, shift)
+            if sign:
+                mpz_fdiv_q_2exp(res.value, man.value, shift)
+            else:
+                mpz_cdiv_q_2exp(res.value, man.value, shift)
         elif rnd == 'u':
             mpz_cdiv_q_2exp(res.value, man.value, shift)
         exp += shift
diff --git a/src/sage/libs/singular/singular.pyx b/src/sage/libs/singular/singular.pyx
index d4ed0e3b064..5acef85c3e6 100644
--- a/src/sage/libs/singular/singular.pyx
+++ b/src/sage/libs/singular/singular.pyx
@@ -96,16 +96,18 @@ cdef Rational si2sa_QQ(number *n, number **nn, ring *_ring):
 
     mpq_init(_z)
 
-    ##  Immediate integers handles carry the tag 'SR_INT', i.e. the last bit is 1.
-    ##  This distinguishes immediate integers from other handles which point to
-    ##  structures aligned on 4 byte boundaries and therefore have last bit zero.
-    ##  (The second bit is reserved as tag to allow extensions of this scheme.)
-    ##  Using immediates as pointers and dereferencing them gives address errors.
+    # Immediate integers handles carry the tag 'SR_INT', i.e. the last bit is 1.
+    # This distinguishes immediate integers from other handles which point to
+    # structures aligned on 4 byte boundaries and therefore have last bit zero.
+    # (The second bit is reserved as tag to allow extensions of this scheme.)
+    # Using immediates as pointers and dereferencing them gives address errors.
     nom = nlGetNumerator(n, _ring.cf)
     mpz_init(nom_z)
 
-    if (SR_HDL(nom) & SR_INT): mpz_set_si(nom_z, SR_TO_INT(nom))
-    else: mpz_set(nom_z,nom.z)
+    if SR_HDL(nom) & SR_INT:
+        mpz_set_si(nom_z, SR_TO_INT(nom))
+    else:
+        mpz_set(nom_z,nom.z)
 
     mpq_set_num(_z,nom_z)
     nlDelete(&nom,_ring.cf)
@@ -114,8 +116,10 @@ cdef Rational si2sa_QQ(number *n, number **nn, ring *_ring):
     denom = nlGetDenom(n, _ring.cf)
     mpz_init(denom_z)
 
-    if (SR_HDL(denom) & SR_INT): mpz_set_si(denom_z, SR_TO_INT(denom))
-    else: mpz_set(denom_z,denom.z)
+    if SR_HDL(denom) & SR_INT:
+        mpz_set_si(denom_z, SR_TO_INT(denom))
+    else:
+        mpz_set(denom_z,denom.z)
 
     mpq_set_den(_z, denom_z)
     nlDelete(&denom,_ring.cf)
diff --git a/src/sage/numerical/backends/glpk_backend.pyx b/src/sage/numerical/backends/glpk_backend.pyx
index c70ac0bb0e0..750c72d9766 100644
--- a/src/sage/numerical/backends/glpk_backend.pyx
+++ b/src/sage/numerical/backends/glpk_backend.pyx
@@ -2134,18 +2134,23 @@ cdef class GLPKBackend(GenericBackend):
             value = solver_parameter_values[value]
 
         if name == timelimit_intopt:
-            if value is None: return self.iocp.tm_lim
-            else: self.iocp.tm_lim = value
+            if value is None:
+                return self.iocp.tm_lim
+            else:
+                self.iocp.tm_lim = value
 
         if name == timelimit_seconds:
-            if value is None: return self.iocp.tm_lim / 1000.0
+            if value is None:
+                return self.iocp.tm_lim / 1000.0
             else:
                 self.iocp.tm_lim = value * 1000.0
                 self.smcp.tm_lim = value * 1000.0
 
         elif name == timelimit_simplex:
-            if value is None: return self.smcp.tm_lim
-            else: self.smcp.tm_lim = value
+            if value is None:
+                return self.smcp.tm_lim
+            else:
+                self.smcp.tm_lim = value
 
         elif name == simplex_or_intopt:
             if value is None:
@@ -2155,155 +2160,227 @@ cdef class GLPKBackend(GenericBackend):
             self.simplex_or_intopt = value
 
         elif name == msg_lev_simplex:
-            if value is None: return self.smcp.msg_lev
-            else: self.smcp.msg_lev = value
+            if value is None:
+                return self.smcp.msg_lev
+            else:
+                self.smcp.msg_lev = value
 
         elif name == msg_lev_intopt:
-            if value is None: return self.iocp.msg_lev
-            else: self.iocp.msg_lev = value
+            if value is None:
+                return self.iocp.msg_lev
+            else:
+                self.iocp.msg_lev = value
 
         elif name == br_tech:
-            if value is None: return self.iocp.br_tech
-            else: self.iocp.br_tech = value
+            if value is None:
+                return self.iocp.br_tech
+            else:
+                self.iocp.br_tech = value
 
         elif name == bt_tech:
-            if value is None: return self.iocp.bt_tech
-            else: self.iocp.bt_tech = value
+            if value is None:
+                return self.iocp.bt_tech
+            else:
+                self.iocp.bt_tech = value
 
         elif name == pp_tech:
-            if value is None: return self.iocp.pp_tech
-            else: self.iocp.pp_tech = value
+            if value is None:
+                return self.iocp.pp_tech
+            else:
+                self.iocp.pp_tech = value
 
         elif name == fp_heur:
-            if value is None: return self.iocp.fp_heur
+            if value is None:
+                return self.iocp.fp_heur
             else:
-                if value: value = GLP_ON
-                else: value = GLP_OFF
+                if value:
+                    value = GLP_ON
+                else:
+                    value = GLP_OFF
                 self.iocp.fp_heur = value
 
         elif name == gmi_cuts:
-            if value is None: return self.iocp.gmi_cuts
+            if value is None:
+                return self.iocp.gmi_cuts
             else:
-                if value: value = GLP_ON
-                else: value = GLP_OFF
+                if value:
+                    value = GLP_ON
+                else:
+                    value = GLP_OFF
                 self.iocp.gmi_cuts = value
 
         elif name == mir_cuts:
-            if value is None: return self.iocp.mir_cuts
+            if value is None:
+                return self.iocp.mir_cuts
             else:
-                if value: value = GLP_ON
-                else: value = GLP_OFF
+                if value:
+                    value = GLP_ON
+                else:
+                    value = GLP_OFF
                 self.iocp.mir_cuts = value
 
         elif name == cov_cuts:
-            if value is None: return self.iocp.cov_cuts
+            if value is None:
+                return self.iocp.cov_cuts
             else:
-                if value: value = GLP_ON
-                else: value = GLP_OFF
+                if value:
+                    value = GLP_ON
+                else:
+                    value = GLP_OFF
                 self.iocp.cov_cuts = value
 
         elif name == clq_cuts:
-            if value is None: return self.iocp.clq_cuts
+            if value is None:
+                return self.iocp.clq_cuts
             else:
-                if value: value = GLP_ON
-                else: value = GLP_OFF
+                if value:
+                    value = GLP_ON
+                else:
+                    value = GLP_OFF
                 self.iocp.clq_cuts = value
 
         elif name == tol_int:
-            if value is None: return self.iocp.tol_int
-            else: self.iocp.tol_int = value
+            if value is None:
+                return self.iocp.tol_int
+            else:
+                self.iocp.tol_int = value
 
         elif name == tol_obj:
-            if value is None: return self.iocp.tol_obj
-            else: self.iocp.tol_obj = value
+            if value is None:
+                return self.iocp.tol_obj
+            else:
+                self.iocp.tol_obj = value
 
         elif name == mip_gap:
-            if value is None: return self.iocp.mip_gap
-            else: self.iocp.mip_gap = value
+            if value is None:
+                return self.iocp.mip_gap
+            else:
+                self.iocp.mip_gap = value
 
         elif name == tm_lim_intopt:
-            if value is None: return self.iocp.tm_lim
-            else: self.iocp.tm_lim = value
+            if value is None:
+                return self.iocp.tm_lim
+            else:
+                self.iocp.tm_lim = value
 
         elif name == out_frq_intopt:
-            if value is None: return self.iocp.out_frq
-            else: self.iocp.out_frq = value
+            if value is None:
+                return self.iocp.out_frq
+            else:
+                self.iocp.out_frq = value
 
         elif name == out_dly_intopt:
-            if value is None: return self.iocp.out_dly
-            else: self.iocp.out_dly = value
+            if value is None:
+                return self.iocp.out_dly
+            else:
+                self.iocp.out_dly = value
 
         elif name == presolve_intopt:
-            if value is None: return self.iocp.presolve
+            if value is None:
+                return self.iocp.presolve
             else:
-                if value: value = GLP_ON
-                else: value = GLP_OFF
+                if value:
+                    value = GLP_ON
+                else:
+                    value = GLP_OFF
                 self.iocp.presolve = value
 
         elif name == binarize:
-            if value is None: return self.iocp.binarize
+            if value is None:
+                return self.iocp.binarize
             else:
-                if value: value = GLP_ON
-                else: value = GLP_OFF
+                if value:
+                    value = GLP_ON
+                else:
+                    value = GLP_OFF
                 self.iocp.binarize = value
 
         elif name == msg_lev_simplex:
-            if value is None: return self.smcp.msg_lev
-            else: self.smcp.msg_lev = value
+            if value is None:
+                return self.smcp.msg_lev
+            else:
+                self.smcp.msg_lev = value
 
         elif name == meth:
-            if value is None: return self.smcp.meth
-            else: self.smcp.meth = value
+            if value is None:
+                return self.smcp.meth
+            else:
+                self.smcp.meth = value
 
         elif name == pricing:
-            if value is None: return self.smcp.pricing
-            else: self.smcp.pricing = value
+            if value is None:
+                return self.smcp.pricing
+            else:
+                self.smcp.pricing = value
 
         elif name == r_test:
-            if value is None: return self.smcp.r_test
-            else: self.smcp.r_test = value
+            if value is None:
+                return self.smcp.r_test
+            else:
+                self.smcp.r_test = value
 
         elif name == tol_bnd:
-            if value is None: return self.smcp.tol_bnd
-            else: self.smcp.tol_bnd = value
+            if value is None:
+                return self.smcp.tol_bnd
+            else:
+                self.smcp.tol_bnd = value
 
         elif name == tol_dj:
-            if value is None: return self.smcp.tol_dj
-            else: self.smcp.tol_dj = value
+            if value is None:
+                return self.smcp.tol_dj
+            else:
+                self.smcp.tol_dj = value
 
         elif name == tol_piv:
-            if value is None: return self.smcp.tol_piv
-            else: self.smcp.tol_piv = value
+            if value is None:
+                return self.smcp.tol_piv
+            else:
+                self.smcp.tol_piv = value
 
         elif name == obj_ll:
-            if value is None: return self.smcp.obj_ll
-            else: self.smcp.obj_ll = value
+            if value is None:
+                return self.smcp.obj_ll
+            else:
+                self.smcp.obj_ll = value
 
         elif name == obj_ul:
-            if value is None: return self.smcp.obj_ul
-            else: self.smcp.obj_ul = value
+            if value is None:
+                return self.smcp.obj_ul
+            else:
+                self.smcp.obj_ul = value
 
         elif name == it_lim:
-            if value is None: return self.smcp.it_lim
-            else: self.smcp.it_lim = value
+            if value is None:
+                return self.smcp.it_lim
+            else:
+                self.smcp.it_lim = value
 
         elif name == tm_lim_simplex:
-            if value is None: return self.smcp.tm_lim
-            else: self.smcp.tm_lim = value
+            if value is None:
+                return self.smcp.tm_lim
+            else:
+                self.smcp.tm_lim = value
 
         elif name == out_frq_simplex:
-            if value is None: return self.smcp.out_frq
-            else: self.smcp.out_frq = value
+            if value is None:
+                return self.smcp.out_frq
+            else:
+                self.smcp.out_frq = value
 
         elif name == out_dly_simplex:
-            if value is None: return self.smcp.out_dly
-            else: self.smcp.out_dly = value
+            if value is None:
+                return self.smcp.out_dly
+            else:
+                self.smcp.out_dly = value
 
         elif name == presolve_simplex:
-            if value is None: return self.smcp.presolve
+            if value is None:
+                return self.smcp.presolve
             else:
-                if value: value = GLP_ON
-                else: value = GLP_OFF
+                if value:
+                    value = GLP_ON
+                else:
+                    value = GLP_OFF
                 self.smcp.presolve = value
         else:
             raise ValueError("This parameter is not available.")
diff --git a/src/sage/rings/finite_rings/element_base.pyx b/src/sage/rings/finite_rings/element_base.pyx
index 6ac8470d4c9..5da0dfded3f 100644
--- a/src/sage/rings/finite_rings/element_base.pyx
+++ b/src/sage/rings/finite_rings/element_base.pyx
@@ -87,14 +87,13 @@ cdef class FiniteRingElement(CommutativeRingElement):
         gcd = n.gcd(q-1)
         if self.is_one():
             if gcd == 1:
-                if all: return [self]
-                else: return self
-            else:
-                nthroot = K.zeta(gcd)
-                return [nthroot**a for a in range(gcd)] if all else nthroot
+                return [self] if all else self
+            nthroot = K.zeta(gcd)
+            return [nthroot**a for a in range(gcd)] if all else nthroot
         if gcd == q-1:
-            if all: return []
-            else: raise ValueError("no nth root")
+            if all:
+                return []
+            raise ValueError("no nth root")
         gcd, alpha, _ = n.xgcd(q-1)  # gcd = alpha*n + beta*(q-1), so 1/n = alpha/gcd (mod q-1)
         if gcd == 1:
             return [self**alpha] if all else self**alpha
@@ -102,8 +101,9 @@ cdef class FiniteRingElement(CommutativeRingElement):
         n = gcd
         q1overn = (q-1)//n
         if self**q1overn != 1:
-            if all: return []
-            else: raise ValueError("no nth root")
+            if all:
+                return []
+            raise ValueError("no nth root")
         self = self**alpha
         if cunningham:
             from sage.rings.factorint import factor_cunningham
@@ -133,12 +133,11 @@ cdef class FiniteRingElement(CommutativeRingElement):
             if all:
                 nthroot = K.zeta(n)
                 L = [self]
-                for i in range(1,n):
+                for i in range(1, n):
                     self *= nthroot
                     L.append(self)
                 return L
-            else:
-                return self
+            return self
         else:
             raise ValueError("unknown algorithm")
 
@@ -240,10 +239,11 @@ cdef class FinitePolyExtElement(FiniteRingElement):
             from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
             R = PolynomialRing(self.parent().prime_subfield(), var)
             return R(self.__pari__().minpoly('x').lift())
-        elif algorithm == 'matrix':
+
+        if algorithm == 'matrix':
             return self.matrix().minpoly(var)
-        else:
-            raise ValueError("unknown algorithm '%s'" % algorithm)
+
+        raise ValueError("unknown algorithm '%s'" % algorithm)
 
     # We have two names for the same method
     # for compatibility with sage.matrix
@@ -502,8 +502,7 @@ cdef class FinitePolyExtElement(FiniteRingElement):
         """
         if self.parent().degree()>1:
             return self.polynomial()._latex_()
-        else:
-            return str(self)
+        return str(self)
 
     def __pari__(self, var=None):
         r"""
@@ -623,10 +622,11 @@ cdef class FinitePolyExtElement(FiniteRingElement):
             from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
             R = PolynomialRing(self.parent().prime_subfield(), var)
             return R(self.__pari__().charpoly('x').lift())
-        elif algorithm == 'matrix':
+
+        if algorithm == 'matrix':
             return self.matrix().charpoly(var)
-        else:
-            raise ValueError("unknown algorithm '%s'" % algorithm)
+
+        raise ValueError("unknown algorithm '%s'" % algorithm)
 
     def norm(self):
         """
@@ -656,10 +656,7 @@ cdef class FinitePolyExtElement(FiniteRingElement):
         """
         f = self.charpoly('x')
         n = f[0]
-        if f.degree() % 2:
-            return -n
-        else:
-            return n
+        return -n if f.degree() % 2 else n
 
     def trace(self):
         """
@@ -921,20 +918,22 @@ cdef class FinitePolyExtElement(FiniteRingElement):
         """
         if self.is_zero():
             if n <= 0:
-                if all: return []
-                else: raise ValueError
-            if all: return [self]
-            else: return self
+                if all:
+                    return []
+                raise ValueError
+            return [self] if all else self
         if n < 0:
             self = ~self
             n = -n
         elif n == 0:
             if self == 1:
-                if all: return [a for a in self.parent().list() if a != 0]
-                else: return self
+                if all:
+                    return [a for a in self.parent().list() if a != 0]
+                return self
             else:
-                if all: return []
-                else: raise ValueError
+                if all:
+                    return []
+                raise ValueError
         if extend:
             raise NotImplementedError
         n = Integer(n)
diff --git a/src/sage/rings/finite_rings/integer_mod.pyx b/src/sage/rings/finite_rings/integer_mod.pyx
index 19525b40937..9a3abc6f963 100644
--- a/src/sage/rings/finite_rings/integer_mod.pyx
+++ b/src/sage/rings/finite_rings/integer_mod.pyx
@@ -1505,17 +1505,18 @@ cdef class IntegerMod_abstract(FiniteRingElement):
         n = Integer(n)
         if n == 0:
             if self == 1:
-                if all: return [K(a) for a in range(1,K.order())]
-                else: return self
+                if all:
+                    return [K(a) for a in range(1, K.order())]
+                return self
             else:
-                if all: return []
-                else: raise ValueError
+                if all:
+                    return []
+                raise ValueError
         F = K.factored_order()
         if len(F) == 0:
             if all:
                 return [self]
-            else:
-                return self
+            return self
         if len(F) != 1:
             if all:
                 # we should probably do a first pass to see if there are any solutions so that we don't get giant intermediate lists and waste time...
@@ -1533,33 +1534,31 @@ cdef class IntegerMod_abstract(FiniteRingElement):
         p, k = F[0]
         if self.is_zero():
             if n < 0:
-                if all: return []
-                else: raise ValueError
+                if all:
+                    return []
+                raise ValueError
             if all:
                 if k == 1:
                     return [self]
-                else:
-                    minval = max(1, (k/n).ceil())
-                    return [K(a*p**minval) for a in range(p**(k-minval))]
-            else:
-                return self
+                minval = max(1, (k/n).ceil())
+                return [K(a*p**minval) for a in range(p**(k-minval))]
+            return self
         if n < 0:
             try:
                 self = ~self
             except ZeroDivisionError:
-                if all: return []
-                else: raise ValueError
+                if all:
+                    return []
+                raise ValueError
             n = -n
         if p == 2 and k == 1:
-            if all: return [self]
-            else: return self
+            return [self] if all else self
         if k > 1:
             pval, upart = self.lift().val_unit(p)
             if not n.divides(pval):
                 if all:
                     return []
-                else:
-                    raise ValueError("no nth root")
+                raise ValueError("no nth root")
             if pval > 0:
                 if all:
                     return [K(a.lift()*p**(pval // n) + p**(k - (pval - pval//n)) * b) for a in mod(upart, p**(k-pval)).nth_root(n, all=True, algorithm=algorithm) for b in range(p**(pval - pval//n))]
@@ -1571,27 +1570,30 @@ cdef class IntegerMod_abstract(FiniteRingElement):
                 sign = [1]
                 if self % 4 == 3:
                     if n % 2 == 0:
-                        if all: return []
-                        else: raise ValueError("no nth root")
+                        if all:
+                            return []
+                        raise ValueError("no nth root")
                     else:
                         sign = [-1]
                         self = -self
                 elif n % 2 == 0:
                     if k > 2 and self % 8 == 5:
-                        if all: return []
-                        else: raise ValueError("no nth root")
+                        if all:
+                            return []
+                        raise ValueError("no nth root")
                     sign = [1, -1]
                 if k == 2:
-                    if all: return [K(s) for s in sign[:2]]
-                    else: return K(sign[0])
-                if all: modp = [mod(self,8)]
-                else: modp = mod(self,8)
+                    if all:
+                        return [K(s) for s in sign[:2]]
+                    return K(sign[0])
+                modp = [mod(self, 8)] if all else mod(self, 8)
             else:
                 sign = [1]
                 modp = self % p
                 self = self / K(R.teichmuller(modp))
                 modp = modp.nth_root(n, all=all, algorithm=algorithm)
-            # now self is congruent to 1 mod 4 or 1 mod p (for odd p), so the power series for p-adic log converges.
+            # now self is congruent to 1 mod 4 or 1 mod p (for odd p),
+            # so the power series for p-adic log converges.
             # Hensel lifting is probably better, but this is easier at the moment.
             plog = R(self).log()
             nval = n.valuation(p)
@@ -1599,11 +1601,11 @@ cdef class IntegerMod_abstract(FiniteRingElement):
                 if self == 1:
                     if all:
                         return [s*K(p*a+m.lift()) for a in range(p**(k-(2 if p==2 else 1))) for m in modp for s in sign]
-                    else:
-                        return K(modp.lift())
+                    return K(modp.lift())
                 else:
-                    if all: return []
-                    else: raise ValueError("no nth root")
+                    if all:
+                        return []
+                    raise ValueError("no nth root")
             if all:
                 ans = [plog // n + p**(k - nval) * i for i in range(p**nval)]
                 ans = [s*K(R.teichmuller(m) * a.exp()) for a in ans for m in modp for s in sign]
@@ -3193,10 +3195,12 @@ cdef int_fast32_t mod_pow_int(int_fast32_t base, int_fast32_t exp, int_fast32_t
         if exp == 4: return (prod * prod) % n
 
     pow2 = base
-    if exp % 2: prod = base
-    else: prod = 1
+    if exp % 2:
+        prod = base
+    else:
+        prod = 1
     exp = exp >> 1
-    while(exp != 0):
+    while exp != 0:
         pow2 = pow2 * pow2
         if pow2 >= INTEGER_MOD_INT32_LIMIT: pow2 = pow2 % n
         if exp % 2:
@@ -3855,10 +3859,12 @@ cdef int_fast64_t mod_pow_int64(int_fast64_t base, int_fast64_t exp, int_fast64_
         if exp == 4: return (prod * prod) % n
 
     pow2 = base
-    if exp % 2: prod = base
-    else: prod = 1
+    if exp % 2:
+        prod = base
+    else:
+        prod = 1
     exp = exp >> 1
-    while(exp != 0):
+    while exp != 0:
         pow2 = pow2 * pow2
         if pow2 >= INTEGER_MOD_INT64_LIMIT: pow2 = pow2 % n
         if exp % 2:
diff --git a/src/sage/rings/polynomial/polynomial_element.pyx b/src/sage/rings/polynomial/polynomial_element.pyx
index 4d2e607b37d..aac651235f7 100644
--- a/src/sage/rings/polynomial/polynomial_element.pyx
+++ b/src/sage/rings/polynomial/polynomial_element.pyx
@@ -1175,8 +1175,7 @@ cdef class Polynomial(CommutativePolynomial):
         cdef Py_ssize_t d = self.degree()
         if 0 <= i <= d:
             return self.get_unsafe(i)
-        else:
-            return self._parent._base.zero()
+        return self._parent._base.zero()
 
     cdef get_unsafe(self, Py_ssize_t i):
         """
@@ -1822,13 +1821,14 @@ cdef class Polynomial(CommutativePolynomial):
         cdef Polynomial _right = right
         if self.is_term():
             return _right._mul_term(self, term_on_right=False)
-        elif _right.is_term():
+
+        if _right.is_term():
             return self._mul_term(_right, term_on_right=True)
 
-        elif self._parent.is_exact():
+        if self._parent.is_exact():
             return self._mul_karatsuba(right)
-        else:
-            return self._mul_generic(right)
+
+        return self._mul_generic(right)
 
     cpdef Polynomial _mul_trunc_(self, Polynomial right, long n):
         r"""
@@ -6809,13 +6809,17 @@ cdef class Polynomial(CommutativePolynomial):
 
         e = self.exponents()
         c = self.coefficients()
-        if len(e) == 0: return []
+        if len(e) == 0:
+            return []
         if len(e) == 1:
-            if e[0] == 0: return []
-            else:         return [(infinity.infinity, e[0])]
+            if e[0] == 0:
+                return []
+            return [(infinity.infinity, e[0])]
 
-        if e[0] == 0: slopes = []
-        else:         slopes = [(infinity.infinity, e[0])]
+        if e[0] == 0:
+            slopes = []
+        else:
+            slopes = [(infinity.infinity, e[0])]
 
         points = [(e[0], c[0].valuation(p)), (e[1], c[1].valuation(p))]
         slopes.append((-(c[1].valuation(p)-c[0].valuation(p))/(e[1] - e[0]), e[1]-e[0]))
@@ -6826,8 +6830,8 @@ cdef class Polynomial(CommutativePolynomial):
                 slopes = slopes[:-1]
                 points = points[:-1]
                 s = -(v-points[-1][1])/(e[i]-points[-1][0])
-            slopes.append((s,e[i]-points[-1][0]))
-            points.append((e[i],v))
+            slopes.append((s, e[i]-points[-1][0]))
+            points.append((e[i], v))
 
         return slopes