STY: Underscores for long numbers

Author: MomIsBestFriend

pandas/_libs/testing.pyx

@@ -66,7 +66,8 @@ cpdef assert_almost_equal(a, b,
                           check_less_precise=False,
                           bint check_dtype=True,
                           obj=None, lobj=None, robj=None):
-    """Check that left and right objects are almost equal.
+    """
+    Check that left and right objects are almost equal.
 
     Parameters
     ----------
@@ -89,7 +90,6 @@ cpdef assert_almost_equal(a, b,
         Specify right object name being compared, internally used to show
         appropriate assertion message
     """
-
     cdef:
         int decimal
         double diff = 0.0
@@ -127,9 +127,9 @@ cpdef assert_almost_equal(a, b,
             # classes can't be the same, to raise error
             assert_class_equal(a, b, obj=obj)
 
-        assert has_length(a) and has_length(b), (
-            f"Can't compare objects without length, one or both is invalid: "
-            f"({a}, {b})")
+        assert has_length(a) and has_length(b), ("Can't compare objects without "
+                                                 "length, one or both is invalid: "
+                                                 f"({a}, {b})")
 
         if a_is_ndarray and b_is_ndarray:
             na, nb = a.size, b.size
@@ -157,7 +157,7 @@ cpdef assert_almost_equal(a, b,
             else:
                 r = None
 
-            raise_assert_detail(obj, f'{obj} length are different', na, nb, r)
+            raise_assert_detail(obj, f"{obj} length are different", na, nb, r)
 
         for i in xrange(len(a)):
             try:
@@ -169,8 +169,8 @@ cpdef assert_almost_equal(a, b,
 
         if is_unequal:
             from pandas.util.testing import raise_assert_detail
-            msg = (f'{obj} values are different '
-                   f'({np.round(diff * 100.0 / na, 5)} %)')
+            msg = (f"{obj} values are different "
+                   f"({np.round(diff * 100.0 / na, 5)} %)")
             raise_assert_detail(obj, msg, lobj, robj)
 
         return True

pandas/core/algorithms.py

@@ -391,16 +391,15 @@ def isin(comps, values) -> np.ndarray:
     ndarray[bool]
         Same length as `comps`.
     """
-
     if not is_list_like(comps):
         raise TypeError(
-            "only list-like objects are allowed to be passed"
-            f" to isin(), you passed a [{type(comps).__name__}]"
+            "only list-like objects are allowed to be passed "
+            f"to isin(), you passed a [{type(comps).__name__}]"
         )
     if not is_list_like(values):
         raise TypeError(
-            "only list-like objects are allowed to be passed"
-            f" to isin(), you passed a [{type(values).__name__}]"
+            "only list-like objects are allowed to be passed "
+            f"to isin(), you passed a [{type(values).__name__}]"
         )
 
     if not isinstance(values, (ABCIndex, ABCSeries, np.ndarray)):
@@ -421,7 +420,7 @@ def isin(comps, values) -> np.ndarray:
 
     # GH16012
     # Ensure np.in1d doesn't get object types or it *may* throw an exception
-    if len(comps) > 1000000 and not is_object_dtype(comps):
+    if len(comps) > 1_000_000 and not is_object_dtype(comps):
         f = np.in1d
     elif is_integer_dtype(comps):
         try:
@@ -833,8 +832,8 @@ def mode(values, dropna: bool = True) -> ABCSeries:
     result = f(values, dropna=dropna)
     try:
         result = np.sort(result)
-    except TypeError as e:
-        warn(f"Unable to sort modes: {e}")
+    except TypeError as err:
+        warn(f"Unable to sort modes: {err}")
 
     result = _reconstruct_data(result, original.dtype, original)
     return Series(result)
@@ -1019,7 +1018,8 @@ def quantile(x, q, interpolation_method="fraction"):
     values = np.sort(x)
 
     def _interpolate(a, b, fraction):
-        """Returns the point at the given fraction between a and b, where
+        """
+        Returns the point at the given fraction between a and b, where
         'fraction' must be between 0 and 1.
         """
         return a + (b - a) * fraction
@@ -1192,7 +1192,8 @@ def compute(self, method):
                 )
 
         def get_indexer(current_indexer, other_indexer):
-            """Helper function to concat `current_indexer` and `other_indexer`
+            """
+            Helper function to concat `current_indexer` and `other_indexer`
             depending on `method`
             """
             if method == "nsmallest":
@@ -1660,7 +1661,7 @@ def take_nd(
 
 def take_2d_multi(arr, indexer, fill_value=np.nan):
     """
-    Specialized Cython take which sets NaN values in one pass
+    Specialized Cython take which sets NaN values in one pass.
     """
     # This is only called from one place in DataFrame._reindex_multi,
     #  so we know indexer is well-behaved.
@@ -1988,8 +1989,8 @@ def sort_mixed(values):
 
     if not is_list_like(codes):
         raise TypeError(
-            "Only list-like objects or None are allowed to be"
-            "passed to safe_sort as codes"
+            "Only list-like objects or None are allowed to "
+            "be passed to safe_sort as codes"
         )
     codes = ensure_platform_int(np.asarray(codes))
 

pandas/core/arrays/categorical.py

@@ -299,7 +299,7 @@ class Categorical(ExtensionArray, PandasObject):
 
     # For comparisons, so that numpy uses our implementation if the compare
     # ops, which raise
-    __array_priority__ = 1000
+    __array_priority__ = 1_000
     _dtype = CategoricalDtype(ordered=False)
     # tolist is not actually deprecated, just suppressed in the __dir__
     _deprecations = PandasObject._deprecations | frozenset(["tolist", "itemsize"])
@@ -494,14 +494,13 @@ def astype(self, dtype: Dtype, copy: bool = True) -> ArrayLike:
         if is_extension_array_dtype(dtype):
             return array(self, dtype=dtype, copy=copy)  # type: ignore # GH 28770
         if is_integer_dtype(dtype) and self.isna().any():
-            msg = "Cannot convert float NaN to integer"
-            raise ValueError(msg)
+            raise ValueError("Cannot convert float NaN to integer")
         return np.array(self, dtype=dtype, copy=copy)
 
     @cache_readonly
     def size(self) -> int:
         """
-        return the len of myself
+        Return the len of myself.
         """
         return self._codes.size
 

pandas/core/arrays/timedeltas.py

@@ -157,7 +157,7 @@ class TimedeltaArray(dtl.DatetimeLikeArrayMixin, dtl.TimelikeOps):
 
     _typ = "timedeltaarray"
     _scalar_type = Timedelta
-    __array_priority__ = 1000
+    __array_priority__ = 1_000
     # define my properties & methods for delegation
     _other_ops: List[str] = []
     _bool_ops: List[str] = []

pandas/core/base.py

@@ -618,7 +618,7 @@ class IndexOpsMixin:
     """
 
     # ndarray compatibility
-    __array_priority__ = 1000
+    __array_priority__ = 1_000
     _deprecations: FrozenSet[str] = frozenset(
         ["tolist", "item"]  # tolist is not deprecated, just suppressed in the __dir__
     )

pandas/core/computation/align.py

@@ -35,7 +35,9 @@ def _zip_axes_from_type(typ, new_axes):
 
 
 def _any_pandas_objects(terms) -> bool:
-    """Check a sequence of terms for instances of PandasObject."""
+    """
+    Check a sequence of terms for instances of PandasObject.
+    """
     return any(isinstance(term.value, PandasObject) for term in terms)
 
 
@@ -98,7 +100,7 @@ def _align_core(terms):
                 reindexer_size = len(reindexer)
 
                 ordm = np.log10(max(1, abs(reindexer_size - term_axis_size)))
-                if ordm >= 1 and reindexer_size >= 10000:
+                if ordm >= 1 and reindexer_size >= 10_000:
                     w = (
                         f"Alignment difference on axis {axis} is larger "
                         f"than an order of magnitude on term {repr(terms[i].name)}, "
@@ -116,7 +118,9 @@ def _align_core(terms):
 
 
 def align_terms(terms):
-    """Align a set of terms"""
+    """
+    Align a set of terms.
+    """
     try:
         # flatten the parse tree (a nested list, really)
         terms = list(com.flatten(terms))

pandas/core/computation/common.py

@@ -9,15 +9,19 @@
 
 
 def _ensure_decoded(s):
-    """ if we have bytes, decode them to unicode """
+    """
+    If we have bytes, decode them to unicode.
+    """
     if isinstance(s, (np.bytes_, bytes)):
         s = s.decode(get_option("display.encoding"))
     return s
 
 
 def result_type_many(*arrays_and_dtypes):
-    """ wrapper around numpy.result_type which overcomes the NPY_MAXARGS (32)
-    argument limit """
+    """
+    Wrapper around numpy.result_type which overcomes the NPY_MAXARGS (32)
+    argument limit.
+    """
     try:
         return np.result_type(*arrays_and_dtypes)
     except ValueError:
@@ -26,8 +30,10 @@ def result_type_many(*arrays_and_dtypes):
 
 
 def _remove_spaces_column_name(name):
-    """Check if name contains any spaces, if it contains any spaces
-    the spaces will be removed and an underscore suffix is added."""
+    """
+    Check if name contains any spaces, if it contains any spaces
+    the spaces will be removed and an underscore suffix is added.
+    """
     if not isinstance(name, str) or " " not in name:
         return name
 

pandas/core/computation/ops.py

@@ -506,8 +506,8 @@ def __init__(self, lhs, rhs, **kwargs):
 
         if not isnumeric(lhs.return_type) or not isnumeric(rhs.return_type):
             raise TypeError(
-                f"unsupported operand type(s) for {self.op}:"
-                f" '{lhs.return_type}' and '{rhs.return_type}'"
+                f"unsupported operand type(s) for {self.op}: "
+                f"'{lhs.return_type}' and '{rhs.return_type}'"
             )
 
         # do not upcast float32s to float64 un-necessarily