Merge remote-tracking branch 'upstream/main'

Author: Dr-Irv

doc/source/user_guide/index.rst

@@ -17,6 +17,43 @@ For a high level summary of the pandas fundamentals, see :ref:`dsintro` and :ref
 Further information on any specific method can be obtained in the
 :ref:`api`.
 
+How to read these guides
+------------------------
+In these guides you will see input code inside code blocks such as:
+
+::
+
+    import pandas as pd
+    pd.DataFrame({'A': [1, 2, 3]})
+
+
+or:
+
+.. ipython:: python
+
+    import pandas as pd
+    pd.DataFrame({'A': [1, 2, 3]})
+
+The first block is a standard python input, while in the second the ``In [1]:`` indicates the input is inside a `notebook <https://jupyter.org>`__. In Jupyter Notebooks the last line is printed and plots are shown inline.
+
+For example:
+
+.. ipython:: python
+
+    a = 1
+    a
+is equivalent to:
+
+::
+
+    a = 1
+    print(a)
+
+
+
+Guides
+-------
+
 .. If you update this toctree, also update the manual toctree in the
    main index.rst.template
 

doc/source/user_guide/indexing.rst

@@ -89,7 +89,7 @@ Getting values from an object with multi-axes selection uses the following
 notation (using ``.loc`` as an example, but the following applies to ``.iloc`` as
 well). Any of the axes accessors may be the null slice ``:``. Axes left out of
 the specification are assumed to be ``:``, e.g. ``p.loc['a']`` is equivalent to
-``p.loc['a', :, :]``.
+``p.loc['a', :]``.
 
 .. csv-table::
     :header: "Object Type", "Indexers"

pandas/_libs/hashtable_func_helper.pxi.in

@@ -17,7 +17,7 @@ dtypes = [('Complex128', 'complex128', 'complex128',
           ('UInt32', 'uint32', 'uint32', 'uint32_t', ''),
           ('UInt16', 'uint16', 'uint16', 'uint16_t', ''),
           ('UInt8', 'uint8', 'uint8', 'uint8_t', ''),
-          ('Object', 'object', 'pymap', 'object', ''),
+          ('Object', 'object', 'pymap', 'object', '<PyObject*>'),
           ('Int64', 'int64', 'int64', 'int64_t', ''),
           ('Int32', 'int32', 'int32', 'int32_t', ''),
           ('Int16', 'int16', 'int16', 'int16_t', ''),
@@ -61,11 +61,11 @@ cdef value_count_{{dtype}}(const {{dtype}}_t[:] values, bint dropna):
     for i in range(n):
         val = values[i]
         if not dropna or not checknull(val):
-            k = kh_get_{{ttype}}(table, <PyObject*>val)
+            k = kh_get_{{ttype}}(table, {{to_c_type}}val)
             if k != table.n_buckets:
                 table.vals[k] += 1
             else:
-                k = kh_put_{{ttype}}(table, <PyObject*>val, &ret)
+                k = kh_put_{{ttype}}(table, {{to_c_type}}val, &ret)
                 table.vals[k] = 1
                 result_keys.append(val)
     {{else}}
@@ -110,6 +110,8 @@ cdef duplicated_{{dtype}}(const {{dtype}}_t[:] values, object keep='first'):
         int ret = 0
         {{if dtype != 'object'}}
         {{c_type}} value
+        {{else}}
+        PyObject* value
         {{endif}}
         Py_ssize_t i, n = len(values)
         khiter_t k
@@ -123,44 +125,33 @@ cdef duplicated_{{dtype}}(const {{dtype}}_t[:] values, object keep='first'):
 
     if keep == 'last':
         {{if dtype == 'object'}}
-        for i in range(n - 1, -1, -1):
-            # equivalent: range(n)[::-1], which cython doesn't like in nogil
-            kh_put_{{ttype}}(table, <PyObject*>values[i], &ret)
-            out[i] = ret == 0
+        if True:
         {{else}}
         with nogil:
+        {{endif}}
             for i in range(n - 1, -1, -1):
                 # equivalent: range(n)[::-1], which cython doesn't like in nogil
                 value = {{to_c_type}}(values[i])
                 kh_put_{{ttype}}(table, value, &ret)
                 out[i] = ret == 0
-        {{endif}}
+
     elif keep == 'first':
         {{if dtype == 'object'}}
-        for i in range(n):
-            kh_put_{{ttype}}(table, <PyObject*>values[i], &ret)
-            out[i] = ret == 0
+        if True:
         {{else}}
         with nogil:
+        {{endif}}
             for i in range(n):
                 value = {{to_c_type}}(values[i])
                 kh_put_{{ttype}}(table, value, &ret)
                 out[i] = ret == 0
-        {{endif}}
+
     else:
         {{if dtype == 'object'}}
-        for i in range(n):
-            value = values[i]
-            k = kh_get_{{ttype}}(table, <PyObject*>value)
-            if k != table.n_buckets:
-                out[table.vals[k]] = 1
-                out[i] = 1
-            else:
-                k = kh_put_{{ttype}}(table, <PyObject*>value, &ret)
-                table.vals[k] = i
-                out[i] = 0
+        if True:
         {{else}}
         with nogil:
+        {{endif}}
             for i in range(n):
                 value = {{to_c_type}}(values[i])
                 k = kh_get_{{ttype}}(table, value)
@@ -171,7 +162,7 @@ cdef duplicated_{{dtype}}(const {{dtype}}_t[:] values, object keep='first'):
                     k = kh_put_{{ttype}}(table, value, &ret)
                     table.vals[k] = i
                     out[i] = 0
-        {{endif}}
+
     kh_destroy_{{ttype}}(table)
     return out
 
@@ -206,39 +197,41 @@ cdef ismember_{{dtype}}(const {{dtype}}_t[:] arr, const {{dtype}}_t[:] values):
         khiter_t k
         int ret = 0
         ndarray[uint8_t] result
+
+        {{if dtype == "object"}}
+        PyObject* val
+        {{else}}
         {{c_type}} val
+        {{endif}}
+
         kh_{{ttype}}_t *table = kh_init_{{ttype}}()
 
     # construct the table
     n = len(values)
     kh_resize_{{ttype}}(table, n)
 
     {{if dtype == 'object'}}
-    for i in range(n):
-        kh_put_{{ttype}}(table, <PyObject*>values[i], &ret)
+    if True:
     {{else}}
     with nogil:
+    {{endif}}
         for i in range(n):
             val = {{to_c_type}}(values[i])
             kh_put_{{ttype}}(table, val, &ret)
-    {{endif}}
 
     # test membership
     n = len(arr)
     result = np.empty(n, dtype=np.uint8)
 
     {{if dtype == 'object'}}
-    for i in range(n):
-        val = arr[i]
-        k = kh_get_{{ttype}}(table, <PyObject*>val)
-        result[i] = (k != table.n_buckets)
+    if True:
     {{else}}
     with nogil:
+    {{endif}}
         for i in range(n):
             val = {{to_c_type}}(arr[i])
             k = kh_get_{{ttype}}(table, val)
             result[i] = (k != table.n_buckets)
-    {{endif}}
 
     kh_destroy_{{ttype}}(table)
     return result.view(np.bool_)

pandas/tests/arrays/numpy_/__init__.py

@@ -0,0 +1,30 @@
+import numpy as np
+
+from pandas.core.dtypes.common import is_scalar
+
+import pandas as pd
+import pandas._testing as tm
+
+
+class TestSearchsorted:
+    def test_searchsorted_numeric_dtypes_scalar(self, any_real_numpy_dtype):
+        arr = pd.array([1, 3, 90], dtype=any_real_numpy_dtype)
+        result = arr.searchsorted(30)
+        assert is_scalar(result)
+        assert result == 2
+
+        result = arr.searchsorted([30])
+        expected = np.array([2], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_searchsorted_numeric_dtypes_vector(self, any_real_numpy_dtype):
+        arr = pd.array([1, 3, 90], dtype=any_real_numpy_dtype)
+        result = arr.searchsorted([2, 30])
+        expected = np.array([1, 2], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_searchsorted_sorter(self, any_real_numpy_dtype):
+        arr = pd.array([3, 1, 2], dtype=any_real_numpy_dtype)
+        result = arr.searchsorted([0, 3], sorter=np.argsort(arr))
+        expected = np.array([0, 2], dtype=np.intp)
+        tm.assert_numpy_array_equal(result, expected)

pandas/tests/arrays/numpy_/test_indexing.py

@@ -0,0 +1,16 @@
+from pandas.core.dtypes.common import is_scalar
+
+import pandas as pd
+
+
+class TestSearchsorted:
+    def test_searchsorted(self, string_dtype):
+        arr = pd.array(["a", "b", "c"], dtype=string_dtype)
+
+        result = arr.searchsorted("a", side="left")
+        assert is_scalar(result)
+        assert result == 0
+
+        result = arr.searchsorted("a", side="right")
+        assert is_scalar(result)
+        assert result == 1

pandas/tests/arrays/test_numpy.py renamed to pandas/tests/arrays/numpy_/test_numpy.py

@@ -10,7 +10,6 @@
 import pandas as pd
 import pandas._testing as tm
 from pandas.api.extensions import register_extension_dtype
-from pandas.api.types import is_scalar
 from pandas.arrays import (
     BooleanArray,
     DatetimeArray,
@@ -391,61 +390,3 @@ def test_array_not_registered(registry_without_decimal):
     result = pd.array(data, dtype=DecimalDtype)
     expected = DecimalArray._from_sequence(data)
     tm.assert_equal(result, expected)
-
-
-class TestArrayAnalytics:
-    def test_searchsorted(self, string_dtype):
-        arr = pd.array(["a", "b", "c"], dtype=string_dtype)
-
-        result = arr.searchsorted("a", side="left")
-        assert is_scalar(result)
-        assert result == 0
-
-        result = arr.searchsorted("a", side="right")
-        assert is_scalar(result)
-        assert result == 1
-
-    def test_searchsorted_numeric_dtypes_scalar(self, any_real_numpy_dtype):
-        arr = pd.array([1, 3, 90], dtype=any_real_numpy_dtype)
-        result = arr.searchsorted(30)
-        assert is_scalar(result)
-        assert result == 2
-
-        result = arr.searchsorted([30])
-        expected = np.array([2], dtype=np.intp)
-        tm.assert_numpy_array_equal(result, expected)
-
-    def test_searchsorted_numeric_dtypes_vector(self, any_real_numpy_dtype):
-        arr = pd.array([1, 3, 90], dtype=any_real_numpy_dtype)
-        result = arr.searchsorted([2, 30])
-        expected = np.array([1, 2], dtype=np.intp)
-        tm.assert_numpy_array_equal(result, expected)
-
-    @pytest.mark.parametrize(
-        "arr, val",
-        [
-            [
-                pd.date_range("20120101", periods=10, freq="2D"),
-                pd.Timestamp("20120102"),
-            ],
-            [
-                pd.date_range("20120101", periods=10, freq="2D", tz="Asia/Hong_Kong"),
-                pd.Timestamp("20120102", tz="Asia/Hong_Kong"),
-            ],
-            [
-                pd.timedelta_range(start="1 day", end="10 days", periods=10),
-                pd.Timedelta("2 days"),
-            ],
-        ],
-    )
-    def test_search_sorted_datetime64_scalar(self, arr, val):
-        arr = pd.array(arr)
-        result = arr.searchsorted(val)
-        assert is_scalar(result)
-        assert result == 1
-
-    def test_searchsorted_sorter(self, any_real_numpy_dtype):
-        arr = pd.array([3, 1, 2], dtype=any_real_numpy_dtype)
-        result = arr.searchsorted([0, 3], sorter=np.argsort(arr))
-        expected = np.array([0, 2], dtype=np.intp)
-        tm.assert_numpy_array_equal(result, expected)