""" Test cases for DataFrame.plot """ import re import numpy as np import pytest import pandas as pd from pandas import DataFrame import pandas._testing as tm from pandas.tests.plotting.common import ( _check_colors, _check_plot_works, _unpack_cycler, ) from pandas.util.version import Version mpl = pytest.importorskip("matplotlib") plt = pytest.importorskip("matplotlib.pyplot") cm = pytest.importorskip("matplotlib.cm") def _check_colors_box(bp, box_c, whiskers_c, medians_c, caps_c="k", fliers_c=None): if fliers_c is None: fliers_c = "k" _check_colors(bp["boxes"], linecolors=[box_c] * len(bp["boxes"])) _check_colors(bp["whiskers"], linecolors=[whiskers_c] * len(bp["whiskers"])) _check_colors(bp["medians"], linecolors=[medians_c] * len(bp["medians"])) _check_colors(bp["fliers"], linecolors=[fliers_c] * len(bp["fliers"])) _check_colors(bp["caps"], linecolors=[caps_c] * len(bp["caps"])) class TestDataFrameColor: @pytest.mark.parametrize( "color", ["C0", "C1", "C2", "C3", "C4", "C5", "C6", "C7", "C8", "C9"] ) def test_mpl2_color_cycle_str(self, color): # GH 15516 df = DataFrame( np.random.default_rng(2).standard_normal((10, 3)), columns=["a", "b", "c"] ) _check_plot_works(df.plot, color=color) def test_color_single_series_list(self): # GH 3486 df = DataFrame({"A": [1, 2, 3]}) _check_plot_works(df.plot, color=["red"]) @pytest.mark.parametrize("color", [(1, 0, 0), (1, 0, 0, 0.5)]) def test_rgb_tuple_color(self, color): # GH 16695 df = DataFrame({"x": [1, 2], "y": [3, 4]}) _check_plot_works(df.plot, x="x", y="y", color=color) def test_color_empty_string(self): df = DataFrame(np.random.default_rng(2).standard_normal((10, 2))) with pytest.raises(ValueError, match="Invalid color argument:"): df.plot(color="") def test_color_and_style_arguments(self): df = DataFrame({"x": [1, 2], "y": [3, 4]}) # passing both 'color' and 'style' arguments should be allowed # if there is no color symbol in the style strings: ax = df.plot(color=["red", "black"], style=["-", "--"]) # check that the linestyles are correctly set: linestyle = [line.get_linestyle() for line in ax.lines] assert linestyle == ["-", "--"] # check that the colors are correctly set: color = [line.get_color() for line in ax.lines] assert color == ["red", "black"] # passing both 'color' and 'style' arguments should not be allowed # if there is a color symbol in the style strings: msg = ( "Cannot pass 'style' string with a color symbol and 'color' keyword " "argument. Please use one or the other or pass 'style' without a color " "symbol" ) with pytest.raises(ValueError, match=msg): df.plot(color=["red", "black"], style=["k-", "r--"]) @pytest.mark.parametrize( "color, expected", [ ("green", ["green"] * 4), (["yellow", "red", "green", "blue"], ["yellow", "red", "green", "blue"]), ], ) def test_color_and_marker(self, color, expected): # GH 21003 df = DataFrame(np.random.default_rng(2).random((7, 4))) ax = df.plot(color=color, style="d--") # check colors result = [i.get_color() for i in ax.lines] assert result == expected # check markers and linestyles assert all(i.get_linestyle() == "--" for i in ax.lines) assert all(i.get_marker() == "d" for i in ax.lines) def test_bar_colors(self): default_colors = _unpack_cycler(plt.rcParams) df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) ax = df.plot.bar() _check_colors(ax.patches[::5], facecolors=default_colors[:5]) def test_bar_colors_custom(self): custom_colors = "rgcby" df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) ax = df.plot.bar(color=custom_colors) _check_colors(ax.patches[::5], facecolors=custom_colors) @pytest.mark.parametrize("colormap", ["jet", cm.jet]) def test_bar_colors_cmap(self, colormap): df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) ax = df.plot.bar(colormap=colormap) rgba_colors = [cm.jet(n) for n in np.linspace(0, 1, 5)] _check_colors(ax.patches[::5], facecolors=rgba_colors) def test_bar_colors_single_col(self): df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) ax = df.loc[:, [0]].plot.bar(color="DodgerBlue") _check_colors([ax.patches[0]], facecolors=["DodgerBlue"]) def test_bar_colors_green(self): df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) ax = df.plot(kind="bar", color="green") _check_colors(ax.patches[::5], facecolors=["green"] * 5) def test_bar_user_colors(self): df = DataFrame( {"A": range(4), "B": range(1, 5), "color": ["red", "blue", "blue", "red"]} ) # This should *only* work when `y` is specified, else # we use one color per column ax = df.plot.bar(y="A", color=df["color"]) result = [p.get_facecolor() for p in ax.patches] expected = [ (1.0, 0.0, 0.0, 1.0), (0.0, 0.0, 1.0, 1.0), (0.0, 0.0, 1.0, 1.0), (1.0, 0.0, 0.0, 1.0), ] assert result == expected def test_if_scatterplot_colorbar_affects_xaxis_visibility(self): # addressing issue #10611, to ensure colobar does not # interfere with x-axis label and ticklabels with # ipython inline backend. random_array = np.random.default_rng(2).random((10, 3)) df = DataFrame(random_array, columns=["A label", "B label", "C label"]) ax1 = df.plot.scatter(x="A label", y="B label") ax2 = df.plot.scatter(x="A label", y="B label", c="C label") vis1 = [vis.get_visible() for vis in ax1.xaxis.get_minorticklabels()] vis2 = [vis.get_visible() for vis in ax2.xaxis.get_minorticklabels()] assert vis1 == vis2 vis1 = [vis.get_visible() for vis in ax1.xaxis.get_majorticklabels()] vis2 = [vis.get_visible() for vis in ax2.xaxis.get_majorticklabels()] assert vis1 == vis2 assert ( ax1.xaxis.get_label().get_visible() == ax2.xaxis.get_label().get_visible() ) def test_if_hexbin_xaxis_label_is_visible(self): # addressing issue #10678, to ensure colobar does not # interfere with x-axis label and ticklabels with # ipython inline backend. random_array = np.random.default_rng(2).random((10, 3)) df = DataFrame(random_array, columns=["A label", "B label", "C label"]) ax = df.plot.hexbin("A label", "B label", gridsize=12) assert all(vis.get_visible() for vis in ax.xaxis.get_minorticklabels()) assert all(vis.get_visible() for vis in ax.xaxis.get_majorticklabels()) assert ax.xaxis.get_label().get_visible() def test_if_scatterplot_colorbars_are_next_to_parent_axes(self): random_array = np.random.default_rng(2).random((10, 3)) df = DataFrame(random_array, columns=["A label", "B label", "C label"]) fig, axes = plt.subplots(1, 2) df.plot.scatter("A label", "B label", c="C label", ax=axes[0]) df.plot.scatter("A label", "B label", c="C label", ax=axes[1]) plt.tight_layout() points = np.array([ax.get_position().get_points() for ax in fig.axes]) axes_x_coords = points[:, :, 0] parent_distance = axes_x_coords[1, :] - axes_x_coords[0, :] colorbar_distance = axes_x_coords[3, :] - axes_x_coords[2, :] assert np.isclose(parent_distance, colorbar_distance, atol=1e-7).all() @pytest.mark.parametrize("cmap", [None, "Greys"]) def test_scatter_with_c_column_name_with_colors(self, cmap): # https://github.com/pandas-dev/pandas/issues/34316 df = DataFrame( [[5.1, 3.5], [4.9, 3.0], [7.0, 3.2], [6.4, 3.2], [5.9, 3.0]], columns=["length", "width"], ) df["species"] = ["r", "r", "g", "g", "b"] if cmap is not None: with tm.assert_produces_warning(UserWarning, check_stacklevel=False): 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 ax.collections[0].colorbar is None def test_scatter_colors(self): df = DataFrame({"a": [1, 2, 3], "b": [1, 2, 3], "c": [1, 2, 3]}) with pytest.raises(TypeError, match="Specify exactly one of `c` and `color`"): df.plot.scatter(x="a", y="b", c="c", color="green") def test_scatter_colors_not_raising_warnings(self): # GH-53908. Do not raise UserWarning: No data for colormapping # 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") def test_scatter_colors_default(self): df = DataFrame({"a": [1, 2, 3], "b": [1, 2, 3], "c": [1, 2, 3]}) default_colors = _unpack_cycler(mpl.pyplot.rcParams) ax = df.plot.scatter(x="a", y="b", c="c") tm.assert_numpy_array_equal( ax.collections[0].get_facecolor()[0], np.array(mpl.colors.ColorConverter.to_rgba(default_colors[0])), ) def test_scatter_colors_white(self): df = DataFrame({"a": [1, 2, 3], "b": [1, 2, 3], "c": [1, 2, 3]}) ax = df.plot.scatter(x="a", y="b", color="white") tm.assert_numpy_array_equal( ax.collections[0].get_facecolor()[0], np.array([1, 1, 1, 1], dtype=np.float64), ) def test_scatter_colorbar_different_cmap(self): # GH 33389 df = DataFrame({"x": [1, 2, 3], "y": [1, 3, 2], "c": [1, 2, 3]}) df["x2"] = df["x"] + 1 _, ax = plt.subplots() df.plot("x", "y", c="c", kind="scatter", cmap="cividis", ax=ax) df.plot("x2", "y", c="c", kind="scatter", cmap="magma", ax=ax) assert ax.collections[0].cmap.name == "cividis" assert ax.collections[1].cmap.name == "magma" def test_line_colors(self): custom_colors = "rgcby" df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) ax = df.plot(color=custom_colors) _check_colors(ax.get_lines(), linecolors=custom_colors) plt.close("all") ax2 = df.plot(color=custom_colors) lines2 = ax2.get_lines() for l1, l2 in zip(ax.get_lines(), lines2): assert l1.get_color() == l2.get_color() @pytest.mark.parametrize("colormap", ["jet", cm.jet]) def test_line_colors_cmap(self, colormap): df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) ax = df.plot(colormap=colormap) rgba_colors = [cm.jet(n) for n in np.linspace(0, 1, len(df))] _check_colors(ax.get_lines(), linecolors=rgba_colors) def test_line_colors_single_col(self): df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) # make color a list if plotting one column frame # handles cases like df.plot(color='DodgerBlue') ax = df.loc[:, [0]].plot(color="DodgerBlue") _check_colors(ax.lines, linecolors=["DodgerBlue"]) def test_line_colors_single_color(self): df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) ax = df.plot(color="red") _check_colors(ax.get_lines(), linecolors=["red"] * 5) def test_line_colors_hex(self): # GH 10299 df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) custom_colors = ["#FF0000", "#0000FF", "#FFFF00", "#000000", "#FFFFFF"] ax = df.plot(color=custom_colors) _check_colors(ax.get_lines(), linecolors=custom_colors) def test_dont_modify_colors(self): colors = ["r", "g", "b"] DataFrame(np.random.default_rng(2).random((10, 2))).plot(color=colors) assert len(colors) == 3 def test_line_colors_and_styles_subplots(self): # GH 9894 default_colors = _unpack_cycler(mpl.pyplot.rcParams) df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) axes = df.plot(subplots=True) for ax, c in zip(axes, list(default_colors)): _check_colors(ax.get_lines(), linecolors=[c]) @pytest.mark.parametrize("color", ["k", "green"]) def test_line_colors_and_styles_subplots_single_color_str(self, color): df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) axes = df.plot(subplots=True, color=color) for ax in axes: _check_colors(ax.get_lines(), linecolors=[color]) @pytest.mark.parametrize("color", ["rgcby", list("rgcby")]) def test_line_colors_and_styles_subplots_custom_colors(self, color): # GH 9894 df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) axes = df.plot(color=color, subplots=True) for ax, c in zip(axes, list(color)): _check_colors(ax.get_lines(), linecolors=[c]) def test_line_colors_and_styles_subplots_colormap_hex(self): # GH 9894 df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) # GH 10299 custom_colors = ["#FF0000", "#0000FF", "#FFFF00", "#000000", "#FFFFFF"] axes = df.plot(color=custom_colors, subplots=True) for ax, c in zip(axes, list(custom_colors)): _check_colors(ax.get_lines(), linecolors=[c]) @pytest.mark.parametrize("cmap", ["jet", cm.jet]) def test_line_colors_and_styles_subplots_colormap_subplot(self, cmap): # GH 9894 df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) rgba_colors = [cm.jet(n) for n in np.linspace(0, 1, len(df))] axes = df.plot(colormap=cmap, subplots=True) for ax, c in zip(axes, rgba_colors): _check_colors(ax.get_lines(), linecolors=[c]) def test_line_colors_and_styles_subplots_single_col(self): # GH 9894 df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) # make color a list if plotting one column frame # handles cases like df.plot(color='DodgerBlue') axes = df.loc[:, [0]].plot(color="DodgerBlue", subplots=True) _check_colors(axes[0].lines, linecolors=["DodgerBlue"]) def test_line_colors_and_styles_subplots_single_char(self): # GH 9894 df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) # single character style axes = df.plot(style="r", subplots=True) for ax in axes: _check_colors(ax.get_lines(), linecolors=["r"]) def test_line_colors_and_styles_subplots_list_styles(self): # GH 9894 df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) # list of styles styles = list("rgcby") axes = df.plot(style=styles, subplots=True) for ax, c in zip(axes, styles): _check_colors(ax.get_lines(), linecolors=[c]) def test_area_colors(self): from matplotlib.collections import PolyCollection custom_colors = "rgcby" df = DataFrame(np.random.default_rng(2).random((5, 5))) ax = df.plot.area(color=custom_colors) _check_colors(ax.get_lines(), linecolors=custom_colors) poly = [o for o in ax.get_children() if isinstance(o, PolyCollection)] _check_colors(poly, facecolors=custom_colors) handles, _ = ax.get_legend_handles_labels() _check_colors(handles, facecolors=custom_colors) for h in handles: assert h.get_alpha() is None def test_area_colors_poly(self): from matplotlib import cm from matplotlib.collections import PolyCollection df = DataFrame(np.random.default_rng(2).random((5, 5))) ax = df.plot.area(colormap="jet") jet_colors = [cm.jet(n) for n in np.linspace(0, 1, len(df))] _check_colors(ax.get_lines(), linecolors=jet_colors) poly = [o for o in ax.get_children() if isinstance(o, PolyCollection)] _check_colors(poly, facecolors=jet_colors) handles, _ = ax.get_legend_handles_labels() _check_colors(handles, facecolors=jet_colors) for h in handles: assert h.get_alpha() is None def test_area_colors_stacked_false(self): from matplotlib import cm from matplotlib.collections import PolyCollection df = DataFrame(np.random.default_rng(2).random((5, 5))) jet_colors = [cm.jet(n) for n in np.linspace(0, 1, len(df))] # When stacked=False, alpha is set to 0.5 ax = df.plot.area(colormap=cm.jet, stacked=False) _check_colors(ax.get_lines(), linecolors=jet_colors) poly = [o for o in ax.get_children() if isinstance(o, PolyCollection)] jet_with_alpha = [(c[0], c[1], c[2], 0.5) for c in jet_colors] _check_colors(poly, facecolors=jet_with_alpha) handles, _ = ax.get_legend_handles_labels() linecolors = jet_with_alpha _check_colors(handles[: len(jet_colors)], linecolors=linecolors) for h in handles: assert h.get_alpha() == 0.5 def test_hist_colors(self): default_colors = _unpack_cycler(mpl.pyplot.rcParams) df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) ax = df.plot.hist() _check_colors(ax.patches[::10], facecolors=default_colors[:5]) def test_hist_colors_single_custom(self): df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) custom_colors = "rgcby" ax = df.plot.hist(color=custom_colors) _check_colors(ax.patches[::10], facecolors=custom_colors) @pytest.mark.parametrize("colormap", ["jet", cm.jet]) def test_hist_colors_cmap(self, colormap): df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) ax = df.plot.hist(colormap=colormap) rgba_colors = [cm.jet(n) for n in np.linspace(0, 1, 5)] _check_colors(ax.patches[::10], facecolors=rgba_colors) def test_hist_colors_single_col(self): df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) ax = df.loc[:, [0]].plot.hist(color="DodgerBlue") _check_colors([ax.patches[0]], facecolors=["DodgerBlue"]) def test_hist_colors_single_color(self): df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) ax = df.plot(kind="hist", color="green") _check_colors(ax.patches[::10], facecolors=["green"] * 5) def test_kde_colors(self): pytest.importorskip("scipy") custom_colors = "rgcby" df = DataFrame(np.random.default_rng(2).random((5, 5))) ax = df.plot.kde(color=custom_colors) _check_colors(ax.get_lines(), linecolors=custom_colors) @pytest.mark.parametrize("colormap", ["jet", cm.jet]) def test_kde_colors_cmap(self, colormap): pytest.importorskip("scipy") df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) ax = df.plot.kde(colormap=colormap) rgba_colors = [cm.jet(n) for n in np.linspace(0, 1, len(df))] _check_colors(ax.get_lines(), linecolors=rgba_colors) def test_kde_colors_and_styles_subplots(self): pytest.importorskip("scipy") default_colors = _unpack_cycler(mpl.pyplot.rcParams) df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) axes = df.plot(kind="kde", subplots=True) for ax, c in zip(axes, list(default_colors)): _check_colors(ax.get_lines(), linecolors=[c]) @pytest.mark.parametrize("colormap", ["k", "red"]) def test_kde_colors_and_styles_subplots_single_col_str(self, colormap): pytest.importorskip("scipy") df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) axes = df.plot(kind="kde", color=colormap, subplots=True) for ax in axes: _check_colors(ax.get_lines(), linecolors=[colormap]) def test_kde_colors_and_styles_subplots_custom_color(self): pytest.importorskip("scipy") df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) custom_colors = "rgcby" axes = df.plot(kind="kde", color=custom_colors, subplots=True) for ax, c in zip(axes, list(custom_colors)): _check_colors(ax.get_lines(), linecolors=[c]) @pytest.mark.parametrize("colormap", ["jet", cm.jet]) def test_kde_colors_and_styles_subplots_cmap(self, colormap): pytest.importorskip("scipy") df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) rgba_colors = [cm.jet(n) for n in np.linspace(0, 1, len(df))] axes = df.plot(kind="kde", colormap=colormap, subplots=True) for ax, c in zip(axes, rgba_colors): _check_colors(ax.get_lines(), linecolors=[c]) def test_kde_colors_and_styles_subplots_single_col(self): pytest.importorskip("scipy") df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) # make color a list if plotting one column frame # handles cases like df.plot(color='DodgerBlue') axes = df.loc[:, [0]].plot(kind="kde", color="DodgerBlue", subplots=True) _check_colors(axes[0].lines, linecolors=["DodgerBlue"]) def test_kde_colors_and_styles_subplots_single_char(self): pytest.importorskip("scipy") df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) # list of styles # single character style axes = df.plot(kind="kde", style="r", subplots=True) for ax in axes: _check_colors(ax.get_lines(), linecolors=["r"]) def test_kde_colors_and_styles_subplots_list(self): pytest.importorskip("scipy") df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) # list of styles styles = list("rgcby") axes = df.plot(kind="kde", style=styles, subplots=True) for ax, c in zip(axes, styles): _check_colors(ax.get_lines(), linecolors=[c]) def test_boxplot_colors(self): default_colors = _unpack_cycler(mpl.pyplot.rcParams) df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) bp = df.plot.box(return_type="dict") _check_colors_box( bp, default_colors[0], default_colors[0], default_colors[2], default_colors[0], ) def test_boxplot_colors_dict_colors(self): df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) dict_colors = { "boxes": "#572923", "whiskers": "#982042", "medians": "#804823", "caps": "#123456", } bp = df.plot.box(color=dict_colors, sym="r+", return_type="dict") _check_colors_box( bp, dict_colors["boxes"], dict_colors["whiskers"], dict_colors["medians"], dict_colors["caps"], "r", ) def test_boxplot_colors_default_color(self): default_colors = _unpack_cycler(mpl.pyplot.rcParams) df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) # partial colors dict_colors = {"whiskers": "c", "medians": "m"} bp = df.plot.box(color=dict_colors, return_type="dict") _check_colors_box(bp, default_colors[0], "c", "m", default_colors[0]) @pytest.mark.parametrize("colormap", ["jet", cm.jet]) def test_boxplot_colors_cmap(self, colormap): df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) bp = df.plot.box(colormap=colormap, return_type="dict") jet_colors = [cm.jet(n) for n in np.linspace(0, 1, 3)] _check_colors_box( bp, jet_colors[0], jet_colors[0], jet_colors[2], jet_colors[0] ) def test_boxplot_colors_single(self): df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) # string color is applied to all artists except fliers bp = df.plot.box(color="DodgerBlue", return_type="dict") _check_colors_box(bp, "DodgerBlue", "DodgerBlue", "DodgerBlue", "DodgerBlue") def test_boxplot_colors_tuple(self): df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) # tuple is also applied to all artists except fliers bp = df.plot.box(color=(0, 1, 0), sym="#123456", return_type="dict") _check_colors_box(bp, (0, 1, 0), (0, 1, 0), (0, 1, 0), (0, 1, 0), "#123456") def test_boxplot_colors_invalid(self): df = DataFrame(np.random.default_rng(2).standard_normal((5, 5))) msg = re.escape( "color dict contains invalid key 'xxxx'. The key must be either " "['boxes', 'whiskers', 'medians', 'caps']" ) with pytest.raises(ValueError, match=msg): # Color contains invalid key results in ValueError df.plot.box(color={"boxes": "red", "xxxx": "blue"}) def test_default_color_cycle(self): import cycler colors = list("rgbk") plt.rcParams["axes.prop_cycle"] = cycler.cycler("color", colors) df = DataFrame(np.random.default_rng(2).standard_normal((5, 3))) ax = df.plot() expected = _unpack_cycler(plt.rcParams)[:3] _check_colors(ax.get_lines(), linecolors=expected) def test_no_color_bar(self): df = DataFrame( { "A": np.random.default_rng(2).uniform(size=20), "B": np.random.default_rng(2).uniform(size=20), "C": np.arange(20) + np.random.default_rng(2).uniform(size=20), } ) ax = df.plot.hexbin(x="A", y="B", colorbar=None) assert ax.collections[0].colorbar is None def test_mixing_cmap_and_colormap_raises(self): df = DataFrame( { "A": np.random.default_rng(2).uniform(size=20), "B": np.random.default_rng(2).uniform(size=20), "C": np.arange(20) + np.random.default_rng(2).uniform(size=20), } ) msg = "Only specify one of `cmap` and `colormap`" with pytest.raises(TypeError, match=msg): df.plot.hexbin(x="A", y="B", cmap="YlGn", colormap="BuGn") def test_passed_bar_colors(self): color_tuples = [(0.9, 0, 0, 1), (0, 0.9, 0, 1), (0, 0, 0.9, 1)] colormap = mpl.colors.ListedColormap(color_tuples) barplot = DataFrame([[1, 2, 3]]).plot(kind="bar", cmap=colormap) assert color_tuples == [c.get_facecolor() for c in barplot.patches] def test_rcParams_bar_colors(self): color_tuples = [(0.9, 0, 0, 1), (0, 0.9, 0, 1), (0, 0, 0.9, 1)] with mpl.rc_context(rc={"axes.prop_cycle": mpl.cycler("color", color_tuples)}): barplot = DataFrame([[1, 2, 3]]).plot(kind="bar") assert color_tuples == [c.get_facecolor() for c in barplot.patches] def test_colors_of_columns_with_same_name(self): # ISSUE 11136 -> https://github.com/pandas-dev/pandas/issues/11136 # Creating a DataFrame with duplicate column labels and testing colors of them. df = DataFrame({"b": [0, 1, 0], "a": [1, 2, 3]}) df1 = DataFrame({"a": [2, 4, 6]}) df_concat = pd.concat([df, df1], axis=1) result = df_concat.plot() legend = result.get_legend() if Version(mpl.__version__) < Version("3.7"): handles = legend.legendHandles else: handles = legend.legend_handles for legend, line in zip(handles, result.lines): assert legend.get_color() == line.get_color() def test_invalid_colormap(self): df = DataFrame( np.random.default_rng(2).standard_normal((3, 2)), columns=["A", "B"] ) msg = "(is not a valid value)|(is not a known colormap)" with pytest.raises((ValueError, KeyError), match=msg): df.plot(colormap="invalid_colormap") def test_dataframe_none_color(self): # GH51953 df = DataFrame([[1, 2, 3]]) ax = df.plot(color=None) expected = _unpack_cycler(mpl.pyplot.rcParams)[:3] _check_colors(ax.get_lines(), linecolors=expected)