@jason-neal thank you for the report.

As far as I understand, the difference between case A plt.scatter(0, 1, c=0.5) and case B plt.scatter([0], [1], c=0.5) is triggered in the following block of Axes.scatter (starting here):

        # After this block, c_array will be None unless
        # c is an array for mapping.  The potential ambiguity
        # with a sequence of 3 or 4 numbers is resolved in
        # favor of mapping, not rgb or rgba.
        if c_none or co is not None:
            c_array = None
        else:  # <- from the not shown instructions above, c_none is False
            try:
                c_array = np.asanyarray(c, dtype=float)
                if c_array.shape in xy_shape:  # <- True for case *A* => everything will be fine
                    c = np.ma.ravel(c_array)
                else:  # <- in case *B* c_array.shape == (), while xy_shape == ((1,), (1,))
                    # Wrong size; it must not be intended for mapping.
                    c_array = None
            except ValueError:
                # Failed to make a floating-point array; c must be color specs.
                c_array = None

        if c_array is None:  # <- True in case *B*
            try:
                # must be acceptable as PathCollection facecolors
                colors = mcolors.to_rgba_array(c)  # <- BOOM!
            except ValueError:
                # c not acceptable as PathCollection facecolor
                msg = ("c of shape {0} not acceptable as a color sequence "
                       "for x with size {1}, y with size {2}")
                raise ValueError(msg.format(c.shape, x.size, y.size))
        else:
            colors = None  # use cmap, norm after collection is created

Funnily, something like plt.scatter([0], 1, c=0.5) does not raise an exception. @tacaswell (or any other core dev actually using scatter), is it the expected behavior? It seems a bit unconsistent to me to raise an error for plt.scatter([0], [1], c=0.5) but not for plt.scatter([0], 1, c=0.5) or plt.scatter(0, 1, c=0.5), but I would glad to have a second opinion.

(Too bad I had a possible fix before noticing that behavior 😢)
For the record, my possible fix was something along the lines of @jason-neal 's suggestion:

---
 lib/matplotlib/axes/_axes.py | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/lib/matplotlib/axes/_axes.py b/lib/matplotlib/axes/_axes.py
index df2ccd55e..2137f6805 100644
--- a/lib/matplotlib/axes/_axes.py
+++ b/lib/matplotlib/axes/_axes.py
@@ -4228,11 +4228,19 @@ linewidth=2, markersize=12)
             try:
                 # must be acceptable as PathCollection facecolors
                 colors = mcolors.to_rgba_array(c)
-            except ValueError:
+            except (ValueError, TypeError) as e:
                 # c not acceptable as PathCollection facecolor
-                raise ValueError("c of shape {} not acceptable as a color "
-                                 "sequence for x with size {}, y with size {}"
-                                 .format(c.shape, x.size, y.size))
+                try:
+                    msg = ("c of shape {} not acceptable as a color "
+                           "sequence for x with size {}, y with size {}"
+                           .format(c.shape, x.size, y.size))
+                except AttributeError:
+                    # More verbose version that avoids `.shape`. Avoid `.size`
+                    # as well to handle cases as `plt.scatter(0, 1, c=[0.5])`.
+                    msg = ("c = {} is not of acceptable shape for color "
+                           "mapping with x with shape {}, y with shape {}"
+                           .format(c, *xy_shape))
+                raise type(e)(msg)
         else:
             colors = None  # use cmap, norm after collection is created
 
-- 
2.14.3

Reading more carefully the docstring of plt.scatter:

x, y : array_like, shape (n, )
    Input data
[...]
c : color, sequence, or sequence of color, optional, default: 'b'
    `c` can be a single color format string, or a sequence of color
    specifications of length `N`, or a sequence of `N` numbers to be
    mapped to colors using the `cmap` and `norm` specified via kwargs
    (see below). Note that `c` should not be a single numeric RGB or
    RGBA sequence because that is indistinguishable from an array of
    values to be colormapped.  `c` can be a 2-D array in which the
    rows are RGB or RGBA, however, including the case of a single
    row to specify the same color for all points.

my understanding is that we are not supporting any of the following cases, among which some are actually not raising an error:

• plt.scatter(0, 1, c=0.5) -> no exception
• plt.scatter([0], [1], c=0.5)
• plt.scatter(0, 1, c=[0.5])
• plt.scatter([0], 1, c=0.5) -> no exception
• plt.scatter([0], 1, c=[0.5]) -> no exception
• etc.

although for each case at least one of the parameter is not an “array-like”, contrary to what is asked in the docstring.

PS: one can also note the inconsistent case between n and N in the docstring above \o/.

With the recent updates to scatter e.g. #11383 the examples given above now produce error messages.

• plt.scatter(0, 1, c=0.5) -> IndexError: tuple index out of range
• plt.scatter([0], [1], c=0.5) -> IndexError: tuple index out of range
• plt.scatter(0, 1, c=[0.5]) -> ValueError: 'c' argument has 1 elements, which is not acceptable for use with 'x' with size 1, 'y' with size 1.
• plt.scatter([0], 1, c=0.5) -> IndexError: tuple index out of range

The last example still works.

• plt.scatter([0], 1, c=[0.5]) -> no exception / Works

If this is supposed to work like this then this issue can probably be closed.

leaving this comment here in hopes it may be useful to others who come across it:

A solution that works for passing both arrays and scalars is:

plt.scatter(np.reshape(x,-1), np.reshape(y,-1), c=np.reshape(c,-1))

I was updating code that had x and y formed by indexing arrays, but if you passed a length-1 index, it would return a scalar, not a length-1 array. This would result in the error

"ValueError: 'c' argument has 1 elements, which is not acceptable for use with 'x' with size 1, 'y' with size 1."

and I found the np.reshape approach to be the cleanest way to upgrade from matplotlib==2.2.3 and handle a variety of use-cases.

We definitely need more tests to make sure not to break the scatter API twice within two successive versions again.

Closing; mostly superseded by #12735.

@jason-neal for the code below
#Pass data to a matrix
x = dataFrame.as_matrix(columns = ['Size','# of Bedrooms'])
y = dataFrame.as_matrix(columns = ['Price'])

#Plot data, the color represents the
sc = scatter(x[:,0],x[:,1], c = y, s= 50)
cb = colorbar(sc)
cb.ax.set_ylabel('House Price $')
xlabel('Size m^2')
ylabel('# of Bedrooms')

#Make global variables that will be use often
global m,n
m = x.shape[1]
n = x.shape[1]+1

#make initial theta as an array of 1D
inTheta = zeros(n)

#it gives
ValueError: 'c' argument has 47 elements, which is not acceptable for use with 'x' with size 47, 'y' with size 47.
please help me with this thank you

It will be fixed 3.2