CLN: replace variations of "..." + str(...) with f-strings

This was done by hand.

Author: akx

pandas/_testing/__init__.py

@@ -569,7 +569,7 @@ def makeCustomIndex(
 
     if names is True:
         # build default names
-        names = [prefix + str(i) for i in range(nlevels)]
+        names = [f"{prefix}{i}" for i in range(nlevels)]
     if names is False:
         # pass None to index constructor for no name
         names = None

pandas/core/dtypes/dtypes.py

@@ -1134,7 +1134,7 @@ def __new__(cls, subtype=None, closed: str_type | None = None):
             )
             raise TypeError(msg)
 
-        key = str(subtype) + str(closed)
+        key = f"{subtype}{closed}"
         try:
             return cls._cache_dtypes[key]
         except KeyError:

pandas/core/interchange/buffer.py

@@ -64,14 +64,9 @@ def __dlpack_device__(self) -> tuple[DlpackDeviceType, int | None]:
         return (DlpackDeviceType.CPU, None)
 
     def __repr__(self) -> str:
-        return (
-            "PandasBuffer("
-            + str(
-                {
-                    "bufsize": self.bufsize,
-                    "ptr": self.ptr,
-                    "device": self.__dlpack_device__()[0].name,
-                }
-            )
-            + ")"
-        )
+        spec = {
+            "bufsize": self.bufsize,
+            "ptr": self.ptr,
+            "device": self.__dlpack_device__()[0].name,
+        }
+        return f"PandasBuffer({spec})"

pandas/core/ops/docstrings.py

@@ -99,9 +99,7 @@ def make_flex_doc(op_name: str, typ: str) -> str:
 f    1.0
 dtype: float64"""
 
-_add_example_SERIES = (
-    _common_examples_algebra_SERIES
-    + """
+_add_example_SERIES = f"""{_common_examples_algebra_SERIES}
 >>> a.add(b, fill_value=0)
 a    2.0
 b    1.0
@@ -110,11 +108,8 @@ def make_flex_doc(op_name: str, typ: str) -> str:
 e    NaN
 dtype: float64
 """
-)
 
-_sub_example_SERIES = (
-    _common_examples_algebra_SERIES
-    + """
+_sub_example_SERIES = f"""{_common_examples_algebra_SERIES}
 >>> a.subtract(b, fill_value=0)
 a    0.0
 b    1.0
@@ -123,11 +118,8 @@ def make_flex_doc(op_name: str, typ: str) -> str:
 e    NaN
 dtype: float64
 """
-)
 
-_mul_example_SERIES = (
-    _common_examples_algebra_SERIES
-    + """
+_mul_example_SERIES = f"""{_common_examples_algebra_SERIES}
 >>> a.multiply(b, fill_value=0)
 a    1.0
 b    0.0
@@ -136,11 +128,8 @@ def make_flex_doc(op_name: str, typ: str) -> str:
 e    NaN
 dtype: float64
 """
-)
 
-_div_example_SERIES = (
-    _common_examples_algebra_SERIES
-    + """
+_div_example_SERIES = f"""{_common_examples_algebra_SERIES}
 >>> a.divide(b, fill_value=0)
 a    1.0
 b    inf
@@ -149,11 +138,8 @@ def make_flex_doc(op_name: str, typ: str) -> str:
 e    NaN
 dtype: float64
 """
-)
 
-_floordiv_example_SERIES = (
-    _common_examples_algebra_SERIES
-    + """
+_floordiv_example_SERIES = f"""{_common_examples_algebra_SERIES}
 >>> a.floordiv(b, fill_value=0)
 a    1.0
 b    NaN
@@ -162,11 +148,8 @@ def make_flex_doc(op_name: str, typ: str) -> str:
 e    NaN
 dtype: float64
 """
-)
 
-_divmod_example_SERIES = (
-    _common_examples_algebra_SERIES
-    + """
+_divmod_example_SERIES = f"""{_common_examples_algebra_SERIES}
 >>> a.divmod(b, fill_value=0)
 (a    1.0
  b    NaN
@@ -181,11 +164,8 @@ def make_flex_doc(op_name: str, typ: str) -> str:
  e    NaN
  dtype: float64)
 """
-)
 
-_mod_example_SERIES = (
-    _common_examples_algebra_SERIES
-    + """
+_mod_example_SERIES = f"""{_common_examples_algebra_SERIES}
 >>> a.mod(b, fill_value=0)
 a    0.0
 b    NaN
@@ -194,10 +174,7 @@ def make_flex_doc(op_name: str, typ: str) -> str:
 e    NaN
 dtype: float64
 """
-)
-_pow_example_SERIES = (
-    _common_examples_algebra_SERIES
-    + """
+_pow_example_SERIES = f"""{_common_examples_algebra_SERIES}
 >>> a.pow(b, fill_value=0)
 a    1.0
 b    1.0
@@ -206,11 +183,8 @@ def make_flex_doc(op_name: str, typ: str) -> str:
 e    NaN
 dtype: float64
 """
-)
 
-_ne_example_SERIES = (
-    _common_examples_algebra_SERIES
-    + """
+_ne_example_SERIES = f"""{_common_examples_algebra_SERIES}
 >>> a.ne(b, fill_value=0)
 a    False
 b     True
@@ -219,11 +193,8 @@ def make_flex_doc(op_name: str, typ: str) -> str:
 e     True
 dtype: bool
 """
-)
 
-_eq_example_SERIES = (
-    _common_examples_algebra_SERIES
-    + """
+_eq_example_SERIES = f"""{_common_examples_algebra_SERIES}
 >>> a.eq(b, fill_value=0)
 a     True
 b    False
@@ -232,11 +203,8 @@ def make_flex_doc(op_name: str, typ: str) -> str:
 e    False
 dtype: bool
 """
-)
 
-_lt_example_SERIES = (
-    _common_examples_comparison_SERIES
-    + """
+_lt_example_SERIES = f"""{_common_examples_comparison_SERIES}
 >>> a.lt(b, fill_value=0)
 a    False
 b    False
@@ -246,11 +214,8 @@ def make_flex_doc(op_name: str, typ: str) -> str:
 f     True
 dtype: bool
 """
-)
 
-_le_example_SERIES = (
-    _common_examples_comparison_SERIES
-    + """
+_le_example_SERIES = f"""{_common_examples_comparison_SERIES}
 >>> a.le(b, fill_value=0)
 a    False
 b     True
@@ -260,11 +225,8 @@ def make_flex_doc(op_name: str, typ: str) -> str:
 f     True
 dtype: bool
 """
-)
 
-_gt_example_SERIES = (
-    _common_examples_comparison_SERIES
-    + """
+_gt_example_SERIES = f"""{_common_examples_comparison_SERIES}
 >>> a.gt(b, fill_value=0)
 a     True
 b    False
@@ -274,11 +236,8 @@ def make_flex_doc(op_name: str, typ: str) -> str:
 f    False
 dtype: bool
 """
-)
 
-_ge_example_SERIES = (
-    _common_examples_comparison_SERIES
-    + """
+_ge_example_SERIES = f"""{_common_examples_comparison_SERIES}
 >>> a.ge(b, fill_value=0)
 a     True
 b     True
@@ -288,7 +247,6 @@ def make_flex_doc(op_name: str, typ: str) -> str:
 f    False
 dtype: bool
 """
-)
 
 _returns_series = """Series\n    The result of the operation."""
 

pandas/io/formats/style.py

@@ -2625,7 +2625,7 @@ def set_table_styles(
 
             table_styles = [
                 {
-                    "selector": str(s["selector"]) + idf + str(idx),
+                    "selector": f"{s['selector']}{idf}{idx}",
                     "props": maybe_convert_css_to_tuples(s["props"]),
                 }
                 for key, styles in table_styles.items()

pandas/io/sql.py

@@ -1350,7 +1350,7 @@ def get_engine(engine: str) -> BaseEngine:
             try:
                 return engine_class()
             except ImportError as err:
-                error_msgs += "\n - " + str(err)
+                error_msgs += f"\n - {err}"
 
         raise ImportError(
             "Unable to find a usable engine; "
@@ -1911,7 +1911,7 @@ def _create_table_setup(self):
         escape = _get_valid_sqlite_name
 
         create_tbl_stmts = [
-            escape(cname) + " " + ctype for cname, ctype, _ in column_names_and_types
+            f"{escape(cname)} {ctype}" for cname, ctype, _ in column_names_and_types
         ]
 
         if self.keys is not None and len(self.keys):
@@ -1924,30 +1924,22 @@ def _create_table_setup(self):
                 f"CONSTRAINT {self.name}_pk PRIMARY KEY ({cnames_br})"
             )
         if self.schema:
-            schema_name = self.schema + "."
+            schema_name = f"{self.schema}."
         else:
             schema_name = ""
+        create_tbl_stmts_str = ",\n  ".join(create_tbl_stmts)
         create_stmts = [
-            "CREATE TABLE "
-            + schema_name
-            + escape(self.name)
-            + " (\n"
-            + ",\n  ".join(create_tbl_stmts)
-            + "\n)"
+            f"CREATE TABLE {schema_name}{escape(self.name)} "
+            f"(\n{create_tbl_stmts_str}\n)"
         ]
 
         ix_cols = [cname for cname, _, is_index in column_names_and_types if is_index]
         if len(ix_cols):
             cnames = "_".join(ix_cols)
             cnames_br = ",".join([escape(c) for c in ix_cols])
+            ix_name = f"ix_{self.name}_{cnames}"
             create_stmts.append(
-                "CREATE INDEX "
-                + escape("ix_" + self.name + "_" + cnames)
-                + "ON "
-                + escape(self.name)
-                + " ("
-                + cnames_br
-                + ")"
+                f"CREATE INDEX {escape(ix_name)} ON {escape(self.name)} ({cnames_br})"
             )
 
         return create_stmts

pandas/io/stata.py

@@ -864,7 +864,7 @@ class StataMissingValue:
         # Conversion to long to avoid hash issues on 32 bit platforms #8968
         MISSING_VALUES[b] = "."
         for i in range(1, 27):
-            MISSING_VALUES[i + b] = "." + chr(96 + i)
+            MISSING_VALUES[i + b] = f".{chr(96 + i)}"
 
     float32_base: bytes = b"\x00\x00\x00\x7f"
     increment: int = struct.unpack("<i", b"\x00\x08\x00\x00")[0]
@@ -973,7 +973,7 @@ def __init__(self) -> None:
         # with a label, but the underlying variable is -127 to 100
         # we're going to drop the label and cast to int
         self.DTYPE_MAP = dict(
-            list(zip(range(1, 245), [np.dtype("a" + str(i)) for i in range(1, 245)]))
+            list(zip(range(1, 245), [np.dtype(f"a{i}") for i in range(1, 245)]))
             + [
                 (251, np.dtype(np.int8)),
                 (252, np.dtype(np.int16)),
@@ -1502,9 +1502,9 @@ def _setup_dtype(self) -> np.dtype:
         for i, typ in enumerate(self.typlist):
             if typ in self.NUMPY_TYPE_MAP:
                 typ = cast(str, typ)  # only strs in NUMPY_TYPE_MAP
-                dtypes.append(("s" + str(i), self.byteorder + self.NUMPY_TYPE_MAP[typ]))
+                dtypes.append((f"s{i}", self.byteorder + self.NUMPY_TYPE_MAP[typ]))
             else:
-                dtypes.append(("s" + str(i), "S" + str(typ)))
+                dtypes.append((f"s{i}", f"S{typ}"))
         self._dtype = np.dtype(dtypes)
 
         return self._dtype
@@ -2092,7 +2092,7 @@ def _maybe_convert_to_int_keys(convert_dates: dict, varlist: list[Hashable]) ->
     new_dict = {}
     for key in convert_dates:
         if not convert_dates[key].startswith("%"):  # make sure proper fmts
-            convert_dates[key] = "%" + convert_dates[key]
+            convert_dates[key] = f"%{convert_dates[key]}"
         if key in varlist:
             new_dict.update({varlist.index(key): convert_dates[key]})
         else:
@@ -2170,7 +2170,7 @@ def _dtype_to_default_stata_fmt(
                 return "%9s"
             else:
                 raise ValueError(excessive_string_length_error.format(column.name))
-        return "%" + str(max(itemsize, 1)) + "s"
+        return f"%{max(itemsize, 1)}s"
     elif dtype == np.float64:
         return "%10.0g"
     elif dtype == np.float32:
@@ -2476,19 +2476,19 @@ def _check_column_names(self, data: DataFrame) -> DataFrame:
 
             # Variable name must not be a reserved word
             if name in self.RESERVED_WORDS:
-                name = "_" + name
+                name = f"_{name}"
 
             # Variable name may not start with a number
             if "0" <= name[0] <= "9":
-                name = "_" + name
+                name = f"_{name}"
 
             name = name[: min(len(name), 32)]
 
             if not name == orig_name:
                 # check for duplicates
                 while columns.count(name) > 0:
                     # prepend ascending number to avoid duplicates
-                    name = "_" + str(duplicate_var_id) + name
+                    name = f"_{duplicate_var_id}{name}"
                     name = name[: min(len(name), 32)]
                     duplicate_var_id += 1
                 converted_names[orig_name] = name
@@ -3249,7 +3249,7 @@ def _tag(val: str | bytes, tag: str) -> bytes:
         """Surround val with <tag></tag>"""
         if isinstance(val, str):
             val = bytes(val, "utf-8")
-        return bytes("<" + tag + ">", "utf-8") + val + bytes("</" + tag + ">", "utf-8")
+        return bytes(f"<{tag}>", "utf-8") + val + bytes(f"</{tag}>", "utf-8")
 
     def _update_map(self, tag: str) -> None:
         """Update map location for tag with file position"""