gh-40725: some fixes for ruff SIM warnings
    
mainly about using `.get()`

### 📝 Checklist

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

Author: Release Manager

src/sage/algebras/lie_algebras/representation.py

@@ -628,7 +628,7 @@ def __init__(self, L, minimal=False):
 
             def as_exp(s):
                 sm = s._monomial
-                return tuple([sm[i] if i in sm else 0 for i in I])
+                return tuple([sm.get(i, 0) for i in I])
 
             def test_ideal(m, X):
                 elt = self._pbw.element_class(self._pbw, {monoid(list(zip(I, m))): one})
@@ -706,13 +706,13 @@ def _project(self, elt):
         if self._minimal:
             for m, c in elt._monomial_coefficients.items():
                 mm = m._monomial
-                vec = tuple([mm[i] if i in mm else 0 for i in I])
+                vec = tuple([mm.get(i, 0) for i in I])
                 if vec in self._indices:
                     ret[self._indices(vec)] = c
         else:
             for m, c in elt._monomial_coefficients.items():
                 mm = m._monomial
-                vec = [mm[i] if i in mm else 0 for i in I]
+                vec = [mm.get(i, 0) for i in I]
                 if sum(e * d for e, d in zip(vec, self._degrees)) <= self._step:
                     ret[self._indices(vec)] = c
         return self.element_class(self, ret)

src/sage/combinat/designs/orthogonal_arrays_build_recursive.py

@@ -743,10 +743,10 @@ def thwart_lemma_3_5(k, n, m, a, b, c, d=0, complement=False, explain_constructi
     last_sets_dict = [{v:i for i,v in enumerate(s)} for s in last_sets]
 
     # Truncating the OA
-    for i,D in enumerate(last_sets_dict):
+    for i, D in enumerate(last_sets_dict):
         kk = len(OA[0])-3+i
         for R in OA:
-            R[kk] = D[R[kk]] if R[kk] in D else None
+            R[kk] = D.get(R[kk], None)
 
     if d:
         for R in OA:

src/sage/combinat/diagram_algebras.py

@@ -1328,9 +1328,8 @@ def __contains__(self, obj):
                 return False
         if obj.base_diagram():
             tst = sorted(flatten(obj.base_diagram()))
-            if len(tst) % 2 or tst != list(range(-len(tst)//2,0)) + list(range(1,len(tst)//2+1)):
-                return False
-            return True
+            ell = len(tst)
+            return not ell % 2 and tst == list(range(-ell // 2, 0)) + list(range(1, ell // 2 + 1))
         return self.order == 0
 
     def _element_constructor_(self, d):

src/sage/combinat/sine_gordon.py

@@ -472,41 +472,21 @@ def plot(self, **kwds):
         else:
             radius = ceil(self.r() / (2 * pi))
         points_opts = {}
-        if 'points_color' in kwds:
-            points_opts['color'] = kwds['points_color']
-        else:
-            points_opts['color'] = 'black'
-        if 'points_size' in kwds:
-            points_opts['size'] = kwds['points_size']
-        else:
-            points_opts['size'] = 7
+        points_opts['color'] = kwds.get('points_color', 'black')
+        points_opts['size'] = kwds.get('points_size', 7)
         triangulation_opts = {}
-        if 'triangulation_color' in kwds:
-            triangulation_opts['color'] = kwds['triangulation_color']
-        else:
-            triangulation_opts['color'] = 'black'
-        if 'triangulation_thickness' in kwds:
-            triangulation_opts['thickness'] = kwds['triangulation_thickness']
-        else:
-            triangulation_opts['thickness'] = 0.5
+        triangulation_opts['color'] = kwds.get('triangulation_color', 'black')
+        triangulation_opts['thickness'] = kwds.get('triangulation_thickness',
+                                                   0.5)
         shading_opts = {}
-        if 'shading_color' in kwds:
-            shading_opts['color'] = kwds['shading_color']
-        else:
-            shading_opts['color'] = 'lightgray'
+        shading_opts['color'] = kwds.get('shading_color', 'lightgray')
         reflections_opts = {}
-        if 'reflections_color' in kwds:
-            reflections_opts['color'] = kwds['reflections_color']
-        else:
-            reflections_opts['color'] = 'blue'
-        if 'reflections_thickness' in kwds:
-            reflections_opts['thickness'] = kwds['reflections_thickness']
-        else:
-            reflections_opts['thickness'] = 1
+        reflections_opts['color'] = kwds.get('reflections_color', 'blue')
+        reflections_opts['thickness'] = kwds.get('reflections_thickness', 1)
         # Helper functions
 
         def triangle(x):
-            (a, b) = sorted(x[:2])
+            a, b = sorted(x[:2])
             for p in self.vertices():
                 if (p, a) in self.triangulation() or (a, p) in self.triangulation():
                     if (p, b) in self.triangulation() or (b, p) in self.triangulation():
@@ -522,7 +502,7 @@ def plot_arc(radius, p, q, **opts):
             if p - q in [1, -1]:
                 def f(t):
                     return (radius * cos(t), radius * sin(t))
-                (p, q) = sorted([p, q])
+                p, q = sorted([p, q])
                 angle_p = vertex_to_angle(p)
                 angle_q = vertex_to_angle(q)
                 return parametric_plot(f(t), (t, angle_q, angle_p), **opts)
@@ -533,7 +513,7 @@ def f(t):
                     angle_p += 2 * pi
                 internal_angle = angle_p - angle_q
                 if internal_angle > pi:
-                    (angle_p, angle_q) = (angle_q + 2 * pi, angle_p)
+                    angle_p, angle_q = (angle_q + 2 * pi, angle_p)
                     internal_angle = angle_p - angle_q
                 angle_center = (angle_p + angle_q) / 2
                 hypotenuse = radius / cos(internal_angle / 2)
@@ -607,8 +587,8 @@ def vertex_to_angle(v):
         P += line([(0, 1.1 * radius), (0, -1.1 * radius)],
                   zorder=len(P), **reflections_opts)
         axis_angle = vertex_to_angle(-0.5 * (self.rk() + (1, 1))[1])
-        (a, b) = (1.1 * radius * cos(axis_angle),
-                  1.1 * radius * sin(axis_angle))
+        a, b = (1.1 * radius * cos(axis_angle),
+                1.1 * radius * sin(axis_angle))
         P += line([(a, b), (-a, -b)], zorder=len(P), **reflections_opts)
         # Wrap up
         P.set_aspect_ratio(1)

src/sage/databases/sql_db.py

@@ -335,10 +335,9 @@ def _create_print_table(cur, col_titles, **kwds):
             pcol_map.append(kwds['plot_cols'][col])
             pcol_index.append(col_titles.index(col))
 
-    max_field_size = kwds['max_field_size'] if 'max_field_size' in kwds \
-                    else 20
+    max_field_size = kwds.get('max_field_size', 20)
     id_col_index = col_titles.index(kwds['id_col']) if 'id_col' in kwds \
-                   else None
+        else None
 
     if 'relabel_cols' in kwds:
         relabel_cols = kwds['relabel_cols']

src/sage/functions/bessel.py

@@ -1224,10 +1224,7 @@ def Bessel(*args, **kwds):
         raise ValueError("inconsistent types given")
     # record the function type
     if _type is None:
-        if 'typ' in kwds:
-            _type = kwds['typ']
-        else:
-            _type = 'J'
+        _type = kwds.get('typ', 'J')
     if _type not in ['I', 'J', 'K', 'Y']:
         raise ValueError("type must be one of I, J, K, Y")
 

src/sage/homology/chain_complex.py

@@ -1486,10 +1486,7 @@ def torsion_list(self, max_prime, min_prime=2):
                     temp_diff[i] = mod_p_betti.get(i, 0) - torsion_free[i]
                 for i in temp_diff:
                     if temp_diff[i] > 0:
-                        if i+D in diff_dict:
-                            lower = diff_dict[i+D]
-                        else:
-                            lower = 0
+                        lower = diff_dict.get(i + D, 0)
                         current = temp_diff[i]
                         if current > lower:
                             diff_dict[i] = current - lower

src/sage/homology/graded_resolution.py

@@ -262,14 +262,12 @@ def betti(self, i, a=None):
         else:
             degrees = [a]
 
-        betti = {}
-        for s in degrees:
-            betti[s] = len([d for d in shifts if d == s])
+        betti = {s: len([d for d in shifts if d == s]) for s in degrees}
 
         if a is None:
             return betti
         else:
-            return betti[a] if a in betti else 0
+            return betti.get(a, 0)
 
     def K_polynomial(self, names=None):
         r"""

src/sage/manifolds/chart.py

@@ -913,10 +913,7 @@ def valid_coordinates(self, *coordinates, **kwds):
         """
         if len(coordinates) != self.domain()._dim:
             return False
-        if 'parameters' in kwds:
-            parameters = kwds['parameters']
-        else:
-            parameters = None
+        parameters = kwds.get('parameters', None)
         # Check of restrictions:
         if self._restrictions:
             substitutions = dict(zip(self._xx, coordinates))
@@ -2556,14 +2553,8 @@ def valid_coordinates(self, *coordinates, **kwds):
         n = len(coordinates)
         if n != self._manifold._dim:
             return False
-        if 'tolerance' in kwds:
-            tolerance = kwds['tolerance']
-        else:
-            tolerance = 0
-        if 'parameters' in kwds:
-            parameters = kwds['parameters']
-        else:
-            parameters = None
+        tolerance = kwds.get('tolerance', 0)
+        parameters = kwds.get('parameters', None)
         # Check of the coordinate ranges:
         for x, bounds in zip(coordinates, self._bounds):
             xmin = bounds[0][0] - tolerance

src/sage/plot/plot3d/list_plot3d.py

@@ -618,8 +618,8 @@ def g(x, y):
         return G
 
     if interpolation_type == 'spline':
-        kx = kwds['kx'] if 'kx' in kwds else 3
-        ky = kwds['ky'] if 'ky' in kwds else 3
+        kx = kwds.get('kx', 3)
+        ky = kwds.get('ky', 3)
         if 'degree' in kwds:
             kx = kwds['degree']
             ky = kwds['degree']