format

Author: Michael Vincent Mannino

pandas/plotting/_matplotlib/core.py

@@ -10,7 +10,6 @@
     Iterator,
     Sequence,
 )
-from random import shuffle
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -22,6 +21,10 @@
 
 import matplotlib as mpl
 import numpy as np
+from seaborn._base import (
+    HueMapping,
+    VectorPlotter,
+)
 
 from pandas._libs import lib
 from pandas.errors import AbstractMethodError
@@ -1340,27 +1343,47 @@ def _make_plot(self, fig: Figure) -> None:
         norm, cmap = self._get_norm_and_cmap(c_values, color_by_categorical)
         cb = self._get_colorbar(c_values, c_is_column)
 
-        # if a list of non color strings is passed in as c, generate a list
-        # colored by uniqueness of the strings, such same strings get same color
-        create_colors = not self._are_valid_colors(c_values)
-        if create_colors:
-            custom_color_mapping, c_values = self._uniquely_color_strs(c_values)
-            cb = False  # no colorbar; opt for legend
-
         if self.legend:
             label = self.label
         else:
             label = None
-        scatter = ax.scatter(
-            data[x].values,
-            data[y].values,
-            c=c_values,
-            label=label,
-            cmap=cmap,
-            norm=norm,
-            s=self.s,
-            **self.kwds,
-        )
+
+        # if a list of non color strings is passed in as c, color points
+        # by uniqueness of the strings, such same strings get same color
+        create_colors = not self._are_valid_colors(c_values)
+
+        # Plot as normal
+        if not create_colors:
+            scatter = ax.scatter(
+                data[x].values,
+                data[y].values,
+                c=c_values,
+                label=label,
+                cmap=cmap,
+                norm=norm,
+                s=self.s,
+                **self.kwds,
+            )
+        # Have to custom color
+        else:
+            scatter = ax.scatter(
+                data[x].values,
+                data[y].values,
+                label=label,
+                cmap=cmap,
+                norm=norm,
+                s=self.s,
+                **self.kwds,
+            )
+
+            # set colors via Seaborn as it contains all the logic for handling color
+            # decision all nicely packaged
+            scatter.set_facecolor(
+                HueMapping(
+                    VectorPlotter(data=data, variables={"x": x, "y": y, "hue": c})
+                )(c_values)
+            )
+
         if cb:
             cbar_label = c if c_is_column else ""
             cbar = self._plot_colorbar(ax, fig=fig, label=cbar_label)
@@ -1377,15 +1400,6 @@ def _make_plot(self, fig: Figure) -> None:
                 label,  # type: ignore[arg-type]
             )
 
-        # build legend for labeling custom colors
-        if create_colors:
-            ax.legend(
-                handles=[
-                    mpl.patches.Circle((0, 0), facecolor=color, label=string)
-                    for string, color in custom_color_mapping.items()
-                ]
-            )
-
         errors_x = self._get_errorbars(label=x, index=0, yerr=False)
         errors_y = self._get_errorbars(label=y, index=0, xerr=False)
         if len(errors_x) > 0 or len(errors_y) > 0:
@@ -1409,38 +1423,20 @@ def _get_c_values(self, color, color_by_categorical: bool, c_is_column: bool):
             c_values = c
         return c_values
 
-    def _are_valid_colors(self, c_values: np.ndarray | list):
+    def _are_valid_colors(self, c_values: np.ndarray):
         # check if c_values contains strings and if these strings are valid mpl colors.
         # no need to check numerics as these (and mpl colors) will be validated for us
         # in .Axes.scatter._parse_scatter_color_args(...)
+        unique = np.unique(c_values)
         try:
-            if len(c_values) and all(isinstance(c, str) for c in c_values):
-                mpl.colors.to_rgba_array(c_values)
+            if len(c_values) and all(isinstance(c, str) for c in unique):
+                mpl.colors.to_rgba_array(unique)
 
             return True
 
         except (TypeError, ValueError) as _:
             return False
 
-    def _uniquely_color_strs(
-        self, c_values: np.ndarray | list
-    ) -> tuple[dict, np.ndarray]:
-        # well, almost uniquely color them (up to 949)
-        unique = np.unique(c_values)
-
-        # for up to 7, lets keep colors consistent
-        if len(unique) <= 7:
-            possible_colors = list(mpl.colors.BASE_COLORS.values())  # Hex
-        # explore better ways to handle this case
-        else:
-            possible_colors = list(mpl.colors.XKCD_COLORS.values())  # Hex
-            shuffle(possible_colors)
-
-        colors = [possible_colors[i % len(possible_colors)] for i in range(len(unique))]
-        color_mapping = dict(zip(unique, colors))
-
-        return color_mapping, np.array(list(map(color_mapping.get, c_values)))
-
     def _get_norm_and_cmap(self, c_values, color_by_categorical: bool):
         c = self.c
         if self.colormap is not None:

pandas/tests/plotting/frame/test_frame_color.py

@@ -217,22 +217,46 @@ def test_scatter_with_c_column_name_with_colors(self, cmap):
                 ax = df.plot.scatter(x=0, y=1, cmap=cmap, c="species")
         else:
             ax = df.plot.scatter(x=0, y=1, c="species", cmap=cmap)
+
+        assert len(np.unique(ax.collections[0].get_facecolor(), axis=0)) == 3  # r/g/b
         assert ax.collections[0].colorbar is None
 
     def test_scatter_with_c_column_name_without_colors(self):
+        # Given
+        colors = ["NY", "MD", "MA", "CA"]
+        color_count = 4  # 4 unique colors
+
+        # When
         df = DataFrame(
             {
                 "dataX": range(100),
                 "dataY": range(100),
-                "state": ["NY", "MD", "MA", "CA"] * 25,
+                "color": (colors[i % len(colors)] for i in range(100)),
             }
         )
-        df.plot.scatter("dataX", "dataY", c="state")
 
-        with tm.assert_produces_warning(None):
-            ax = df.plot.scatter(x=0, y=1, c="state")
+        # Then
+        ax = df.plot.scatter("dataX", "dataY", c="color")
+        assert len(np.unique(ax.collections[0].get_facecolor(), axis=0)) == color_count
+
+        # Given
+        colors = ["r", "g", "not-a-color"]
+        color_count = 3
+        # Also, since not all are mpl-colors, points matching 'r' or 'g'
+        # are not necessarily red or green
+
+        # When
+        df = DataFrame(
+            {
+                "dataX": range(100),
+                "dataY": range(100),
+                "color": (colors[i % len(colors)] for i in range(100)),
+            }
+        )
 
-        assert len(np.unique(ax.collections[0].get_facecolor())) == 4  # 4 states
+        # Then
+        ax = df.plot.scatter("dataX", "dataY", c="color")
+        assert len(np.unique(ax.collections[0].get_facecolor(), axis=0)) == color_count
 
     def test_scatter_colors(self):
         df = DataFrame({"a": [1, 2, 3], "b": [1, 2, 3], "c": [1, 2, 3]})
@@ -244,7 +268,8 @@ def test_scatter_colors_not_raising_warnings(self):
         # provided via 'c'. Parameters 'cmap' will be ignored
         df = DataFrame({"x": [1, 2, 3], "y": [1, 2, 3]})
         with tm.assert_produces_warning(None):
-            df.plot.scatter(x="x", y="y", c="b")
+            ax = df.plot.scatter(x="x", y="y", c="b")
+            assert len(np.unique(ax.collections[0].get_facecolor(), axis=0)) == 1  # b
 
     def test_scatter_colors_default(self):
         df = DataFrame({"a": [1, 2, 3], "b": [1, 2, 3], "c": [1, 2, 3]})