Fix issue-61209: Updated unique() behavior

Author: sahermuhamed1

Diff for: pandas/core/base.py

@@ -16,6 +16,8 @@
 )
 
 import numpy as np
+from typing import Any
+from pandas._typing import ArrayLike
 
 from pandas._libs import lib
 from pandas._typing import (
@@ -1096,13 +1098,28 @@ def value_counts(
             dropna=dropna,
         )
 
-    def unique(self):
+    def unique(self, dropna: bool = True) -> ArrayLike:
+        """
+        Return unique values in the object.
+        
+        Parameters
+        ----------
+        dropna : bool, default True
+            If True, exclude NA/null values.
+            
+        Returns
+        -------
+        ndarray or ExtensionArray
+        """
         values = self._values
         if not isinstance(values, np.ndarray):
-            # i.e. ExtensionArray
+            # For ExtensionArray
             result = values.unique()
         else:
             result = algorithms.unique1d(values)
+        
+        if dropna:
+            result = result[~isna(result)]
         return result
 
     @final

Diff for: pandas/core/series.py

@@ -2084,72 +2084,30 @@ def mode(self, dropna: bool = True) -> Series:
             dtype=self.dtype,
         ).__finalize__(self, method="mode")
 
-    def unique(self) -> ArrayLike:
+    def unique(self, dropna: bool = True) -> ArrayLike:
         """
         Return unique values of Series object.
-
-        Uniques are returned in order of appearance. Hash table-based unique,
-        therefore does NOT sort.
-
+        
+        Parameters
+        ----------
+        dropna : bool, default True
+            If True, exclude NA/null values.
+            
         Returns
         -------
         ndarray or ExtensionArray
-            The unique values returned as a NumPy array. See Notes.
-
-        See Also
-        --------
-        Series.drop_duplicates : Return Series with duplicate values removed.
-        unique : Top-level unique method for any 1-d array-like object.
-        Index.unique : Return Index with unique values from an Index object.
-
-        Notes
-        -----
-        Returns the unique values as a NumPy array. In case of an
-        extension-array backed Series, a new
-        :class:`~api.extensions.ExtensionArray` of that type with just
-        the unique values is returned. This includes
-
-            * Categorical
-            * Period
-            * Datetime with Timezone
-            * Datetime without Timezone
-            * Timedelta
-            * Interval
-            * Sparse
-            * IntegerNA
-
-        See Examples section.
-
+            The unique values returned as a NumPy array or ExtensionArray.
+            
         Examples
         --------
-        >>> pd.Series([2, 1, 3, 3], name="A").unique()
-        array([2, 1, 3])
-
-        >>> pd.Series([pd.Timestamp("2016-01-01") for _ in range(3)]).unique()
-        <DatetimeArray>
-        ['2016-01-01 00:00:00']
-        Length: 1, dtype: datetime64[s]
-
-        >>> pd.Series(
-        ...     [pd.Timestamp("2016-01-01", tz="US/Eastern") for _ in range(3)]
-        ... ).unique()
-        <DatetimeArray>
-        ['2016-01-01 00:00:00-05:00']
-        Length: 1, dtype: datetime64[s, US/Eastern]
-
-        An Categorical will return categories in the order of
-        appearance and with the same dtype.
-
-        >>> pd.Series(pd.Categorical(list("baabc"))).unique()
-        ['b', 'a', 'c']
-        Categories (3, object): ['a', 'b', 'c']
-        >>> pd.Series(
-        ...     pd.Categorical(list("baabc"), categories=list("abc"), ordered=True)
-        ... ).unique()
-        ['b', 'a', 'c']
-        Categories (3, object): ['a' < 'b' < 'c']
+        >>> s = pd.Series([1, 2, 2, pd.NA])
+        >>> s.unique()
+        array([1, 2])
+        
+        >>> s.unique(dropna=False)
+        array([1, 2, <NA>], dtype=object)
         """
-        return super().unique()
+        return super().unique(dropna=dropna)
 
     @overload
     def drop_duplicates(

Diff for: pandas/tests/series/test_arithmetic.py

@@ -958,3 +958,41 @@ def test_rmod_consistent_large_series():
     expected = Series([1] * 10001)
 
     tm.assert_series_equal(result, expected)
+
+from pandas._testing import assert_numpy_array_equal, assert_extension_array_equal
+
+# Test Case 1: Basic numeric unique with NA (dropna=False) 
+def test_unique_numeric_dropna_false():
+    s = pd.Series([1, 2, 2, pd.NA, 3, pd.NA])
+    result = s.unique(dropna=False)
+    expected = np.array([1, 2, pd.NA, 3], dtype=object)
+    assert_numpy_array_equal(result, expected)
+
+# Test Case 2: Empty Series
+def test_unique_empty_series():
+    s = pd.Series([], dtype='float64')
+    result = s.unique()
+    expected = np.array([], dtype='float64')
+    assert_numpy_array_equal(result, expected)
+
+# Test Case 3: Categorical data
+def test_unique_categorical():
+    s = pd.Series(pd.Categorical(['a', 'b', 'a', pd.NA]))
+    result = s.unique(dropna=False)
+    expected = pd.Categorical(['a', 'b', pd.NA])
+    assert_extension_array_equal(result, expected)
+
+
+# Test Case 4: NA values
+def test_unique_with_nas_simple():
+    s = pd.Series([1, 2, 2, pd.NA, 3, pd.NA], dtype='Int64')
+    
+    # Current behavior (returns ExtensionArray)
+    result = s.unique()
+    expected = pd.array([1, 2, 3], dtype='Int64')
+    tm.assert_extension_array_equal(result, expected)
+    
+    # With dropna=False
+    result_with_na = s.unique(dropna=False)
+    expected_with_na = pd.array([1, 2, pd.NA, 3], dtype='Int64')
+    tm.assert_extension_array_equal(result_with_na, expected_with_na)