format replaced with f-strings

Author: lucassa3

pandas/core/groupby/generic.py

@@ -303,8 +303,7 @@ def _aggregate_multiple_funcs(self, arg, _level):
             obj = self
             if name in results:
                 raise SpecificationError(
-                    "Function names must be unique, found multiple named "
-                    "{name}".format(name=name)
+                    f"Function names must be unique, found multiple named {name}"
                 )
 
             # reset the cache so that we
@@ -396,8 +395,8 @@ def transform(self, func, *args, **kwargs):
 
         if isinstance(func, str):
             if not (func in base.transform_kernel_whitelist):
-                msg = "'{func}' is not a valid function name for transform(name)"
-                raise ValueError(msg.format(func=func))
+                msg = f"'{func}' is not a valid function name for transform(name)"
+                raise ValueError(msg)
             if func in base.cythonized_kernels:
                 # cythonized transform or canned "agg+broadcast"
                 return getattr(self, func)(*args, **kwargs)
@@ -527,7 +526,7 @@ def nunique(self, dropna: bool = True) -> Series:
         try:
             sorter = np.lexsort((val, ids))
         except TypeError:  # catches object dtypes
-            msg = "val.dtype must be object, got {}".format(val.dtype)
+            msg = f"val.dtype must be object, got {val.dtype}"
             assert val.dtype == object, msg
             val, _ = algorithms.factorize(val, sort=False)
             sorter = np.lexsort((val, ids))
@@ -1335,8 +1334,8 @@ def transform(self, func, *args, **kwargs):
 
         if isinstance(func, str):
             if not (func in base.transform_kernel_whitelist):
-                msg = "'{func}' is not a valid function name for transform(name)"
-                raise ValueError(msg.format(func=func))
+                msg = f"'{func}' is not a valid function name for transform(name)"
+                raise ValueError(msg)
             if func in base.cythonized_kernels:
                 # cythonized transformation or canned "reduction+broadcast"
                 return getattr(self, func)(*args, **kwargs)
@@ -1499,8 +1498,8 @@ def filter(self, func, dropna=True, *args, **kwargs):
             else:
                 # non scalars aren't allowed
                 raise TypeError(
-                    "filter function returned a {typ}, "
-                    "but expected a scalar bool".format(typ=type(res).__name__)
+                    f"filter function returned a {type(res).__name__}, "
+                    "but expected a scalar bool"
                 )
 
         return self._apply_filter(indices, dropna)
@@ -1862,7 +1861,7 @@ def _managle_lambda_list(aggfuncs: Sequence[Any]) -> Sequence[Any]:
     for aggfunc in aggfuncs:
         if com.get_callable_name(aggfunc) == "<lambda>":
             aggfunc = partial(aggfunc)
-            aggfunc.__name__ = "<lambda_{}>".format(i)
+            aggfunc.__name__ = f"<lambda_{i}>"
             i += 1
         mangled_aggfuncs.append(aggfunc)
 

pandas/core/groupby/groupby.py

@@ -556,9 +556,7 @@ def __getattr__(self, attr):
             return self[attr]
 
         raise AttributeError(
-            "'{typ}' object has no attribute '{attr}'".format(
-                typ=type(self).__name__, attr=attr
-            )
+            f"'{type(self).__name__}' object has no attribute '{attr}'"
         )
 
     @Substitution(
@@ -1751,7 +1749,7 @@ def nth(self, n: Union[int, List[int]], dropna: Optional[str] = None) -> DataFra
             raise ValueError(
                 "For a DataFrame groupby, dropna must be "
                 "either None, 'any' or 'all', "
-                "(was passed {dropna}).".format(dropna=dropna)
+                f"(was passed {dropna})."
             )
 
         # old behaviour, but with all and any support for DataFrames.
@@ -2488,7 +2486,7 @@ def get_groupby(
 
         klass = DataFrameGroupBy
     else:
-        raise TypeError("invalid type: {obj}".format(obj=obj))
+        raise TypeError(f"invalid type: {obj}")
 
     return klass(
         obj=obj,

pandas/core/groupby/grouper.py

@@ -174,7 +174,7 @@ def _set_grouper(self, obj: FrameOrSeries, sort: bool = False):
             else:
                 if key not in obj._info_axis:
                     raise KeyError(
-                        "The grouper name {key} is not found".format(key=key)
+                        f"The grouper name {key} is not found"
                     )
                 ax = Index(obj[key], name=key)
 
@@ -192,7 +192,7 @@ def _set_grouper(self, obj: FrameOrSeries, sort: bool = False):
                 else:
                     if level not in (0, ax.name):
                         raise ValueError(
-                            "The level {level} is not valid".format(level=level)
+                            f"The level {level} is not valid"
                         )
 
         # possibly sort
@@ -212,13 +212,13 @@ def groups(self):
 
     def __repr__(self) -> str:
         attrs_list = (
-            "{name}={val!r}".format(name=attr_name, val=getattr(self, attr_name))
+            f"{attr_name}={getattr(self, attr_name)!r}"
             for attr_name in self._attributes
             if getattr(self, attr_name) is not None
         )
         attrs = ", ".join(attrs_list)
         cls_name = self.__class__.__name__
-        return "{cls}({attrs})".format(cls=cls_name, attrs=attrs)
+        return f"{cls_name}({attrs})"
 
 
 class Grouping:
@@ -281,7 +281,7 @@ def __init__(
             if not isinstance(level, int):
                 if level not in index.names:
                     raise AssertionError(
-                        "Level {level} not in index".format(level=level)
+                        f"Level {level} not in index"
                     )
                 level = index.names.index(level)
 
@@ -350,17 +350,15 @@ def __init__(
             ):
                 if getattr(self.grouper, "ndim", 1) != 1:
                     t = self.name or str(type(self.grouper))
-                    raise ValueError("Grouper for '{t}' not 1-dimensional".format(t=t))
+                    raise ValueError(f"Grouper for '{t}' not 1-dimensional")
                 self.grouper = self.index.map(self.grouper)
                 if not (
                     hasattr(self.grouper, "__len__")
                     and len(self.grouper) == len(self.index)
                 ):
                     errmsg = (
                         "Grouper result violates len(labels) == "
-                        "len(data)\nresult: {grper}".format(
-                            grper=pprint_thing(self.grouper)
-                        )
+                        f"len(data)\nresult: {pprint_thing(self.grouper)}"
                     )
                     self.grouper = None  # Try for sanity
                     raise AssertionError(errmsg)
@@ -375,7 +373,7 @@ def __init__(
                 self.grouper = self.grouper.astype("timedelta64[ns]")
 
     def __repr__(self) -> str:
-        return "Grouping({name})".format(name=self.name)
+        return f"Grouping({self.name})"
 
     def __iter__(self):
         return iter(self.indices)
@@ -501,9 +499,7 @@ def get_grouper(
             if isinstance(level, str):
                 if obj.index.name != level:
                     raise ValueError(
-                        "level name {level} is not the name of the index".format(
-                            level=level
-                        )
+                        f"level name {level} is not the name of the index"
                     )
             elif level > 0 or level < -1:
                 raise ValueError("level > 0 or level < -1 only valid with MultiIndex")
@@ -636,12 +632,8 @@ def is_in_obj(gpr) -> bool:
 
         if is_categorical_dtype(gpr) and len(gpr) != obj.shape[axis]:
             raise ValueError(
-                (
-                    "Length of grouper ({len_gpr}) and axis ({len_axis})"
-                    " must be same length".format(
-                        len_gpr=len(gpr), len_axis=obj.shape[axis]
-                    )
-                )
+                f"Length of grouper ({len(gpr)}) and axis ({obj.shape[axis]})"
+                " must be same length"
             )
 
         # create the Grouping

pandas/core/groupby/ops.py

@@ -446,17 +446,17 @@ def _cython_operation(
         # are not setup for dim transforming
         if is_categorical_dtype(values) or is_sparse(values):
             raise NotImplementedError(
-                "{dtype} dtype not supported".format(dtype=values.dtype)
+                f"{values.dtype} dtype not supported"
             )
         elif is_datetime64_any_dtype(values):
             if how in ["add", "prod", "cumsum", "cumprod"]:
                 raise NotImplementedError(
-                    "datetime64 type does not support {how} operations".format(how=how)
+                    f"datetime64 type does not support {how} operations"
                 )
         elif is_timedelta64_dtype(values):
             if how in ["prod", "cumprod"]:
                 raise NotImplementedError(
-                    "timedelta64 type does not support {how} operations".format(how=how)
+                    f"timedelta64 type does not support {how} operations"
                 )
 
         if is_datetime64tz_dtype(values.dtype):
@@ -509,9 +509,7 @@ def _cython_operation(
             out_dtype = "float"
         else:
             if is_numeric:
-                out_dtype = "{kind}{itemsize}".format(
-                    kind=values.dtype.kind, itemsize=values.dtype.itemsize
-                )
+                out_dtype = f"{values.dtype.kind}{values.dtype.itemsize}"
             else:
                 out_dtype = "object"