我不知道你说的“手动”是什么意思。你可以选择一个colourmap并很容易地制作一个颜色数组：

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.cm as cm

x = np.arange(10)
ys = [i+x+(i*x)**2 for i in range(10)]

colors = cm.rainbow(np.linspace(0, 1, len(ys)))
for y, c in zip(ys, colors):
    plt.scatter(x, y, color=c)

或者你可以使用itertools.cycle制作你自己的颜色循环器，指定你想要循环的颜色，使用next得到你想要的颜色。例如，使用3种颜色：

import itertools

colors = itertools.cycle(["r", "b", "g"])
for y in ys:
    plt.scatter(x, y, color=next(colors))

想一想，也许不使用zip和第一个更干净：

colors = iter(cm.rainbow(np.linspace(0, 1, len(ys))))
for y in ys:
    plt.scatter(x, y, color=next(colors))

在matplotlib中，用不同颜色的点绘制图的正常方法是传递一个颜色列表作为参数。
例如：

import matplotlib.pyplot
matplotlib.pyplot.scatter([1,2,3],[4,5,6],color=['red','green','blue'])

当你有一个列表的列表，你想他们每个列表的颜色。我认为最优雅的方法是@DSM建议的，只需执行一个循环，多次调用分散。
但是，如果出于某种原因，你想只调用一次，你可以制作一个大的颜色列表，带有列表理解和一点地板划分：

import matplotlib
import numpy as np

X = [1,2,3,4]
Ys = np.array([[4,8,12,16],
      [1,4,9,16],
      [17, 10, 13, 18],
      [9, 10, 18, 11],
      [4, 15, 17, 6],
      [7, 10, 8, 7],
      [9, 0, 10, 11],
      [14, 1, 15, 5],
      [8, 15, 9, 14],
       [20, 7, 1, 5]])
nCols = len(X)  
nRows = Ys.shape[0]

colors = matplotlib.cm.rainbow(np.linspace(0, 1, len(Ys)))

cs = [colors[i//len(X)] for i in range(len(Ys)*len(X))] #could be done with numpy's repmat
Xs=X*nRows #use list multiplication for repetition
matplotlib.pyplot.scatter(Xs,Ys.flatten(),color=cs)

cs = [array([ 0.5,  0. ,  1. ,  1. ]),
 array([ 0.5,  0. ,  1. ,  1. ]),
 array([ 0.5,  0. ,  1. ,  1. ]),
 array([ 0.5,  0. ,  1. ,  1. ]),
 array([ 0.28039216,  0.33815827,  0.98516223,  1.        ]),
 array([ 0.28039216,  0.33815827,  0.98516223,  1.        ]),
 array([ 0.28039216,  0.33815827,  0.98516223,  1.        ]),
 array([ 0.28039216,  0.33815827,  0.98516223,  1.        ]),
 ...
 array([  1.00000000e+00,   1.22464680e-16,   6.12323400e-17,
          1.00000000e+00]),
 array([  1.00000000e+00,   1.22464680e-16,   6.12323400e-17,
          1.00000000e+00]),
 array([  1.00000000e+00,   1.22464680e-16,   6.12323400e-17,
          1.00000000e+00]),
 array([  1.00000000e+00,   1.22464680e-16,   6.12323400e-17,
          1.00000000e+00])]

一个简单的修复

如果您只有一种类型的集合（例如没有误差线的散点图），您也可以在绘制它们之后更改颜色，这有时更容易执行。

import matplotlib.pyplot as plt
from random import randint
import numpy as np

#Let's generate some random X, Y data X = [ [frst group],[second group] ...]
X = [ [randint(0,50) for i in range(0,5)] for i in range(0,24)]
Y = [ [randint(0,50) for i in range(0,5)] for i in range(0,24)]
labels = range(1,len(X)+1)

fig = plt.figure()
ax = fig.add_subplot(111)
for x,y,lab in zip(X,Y,labels):
        ax.scatter(x,y,label=lab)

你只需要一段代码：

#Now this is actually the code that you need, an easy fix your colors just cut and paste not you need ax.
colormap = plt.cm.gist_ncar #nipy_spectral, Set1,Paired  
colorst = [colormap(i) for i in np.linspace(0, 0.9,len(ax.collections))]       
for t,j1 in enumerate(ax.collections):
    j1.set_color(colorst[t])

ax.legend(fontsize='small')

即使在同一子图中有许多不同的散点图，输出也会显示不同的颜色。

你可以像这样使用plot()函数：

import matplotlib.pyplot as plt

import numpy as np

x = np.arange(10)
ys = [i+x+(i*x)**2 for i in range(10)]
plt.figure()
for y in ys:
    plt.plot(x, y, 'o')
plt.show()

在2013年1月和matplotlib 1.3.1（2013年8月）之前，这个问题有点棘手，这是您可以在matpplotlib网站上找到的最古老的稳定版本。但在那之后就很琐碎了。
因为当前版本的matplotlib.pylab.scatter支持赋值：颜色名称字符串的数组，具有颜色Map的浮点数的数组，RGB或RGBA的数组。
这个答案献给@Oxinabox在2015年修正2013版自己的无尽激情。
你有两个选择使用分散命令与多种颜色在一个单一的调用。
1.作为pylab.scatter命令支持使用RGBA阵列做任何你想要的颜色;
1.早在2013年初，就没有办法这样做，因为命令仅支持整个散射点集合的单色。当我在做我的10000行项目时，我想出了一个通用的解决方案来绕过它。所以它很俗气，但我可以做任何形状，颜色，大小和透明。这个技巧也可以应用于绘制路径集合，线集合....
代码的灵感也来自于pyplot.scatter的源代码，我只是复制了scatter所做的事情，而没有触发它绘制。
命令pyplot.scatter返回一个PatchCollection对象，在文件“matplotlib/collections.py“中，一个私有变量_facecolors在Collection类和一个方法set_facecolors。
所以每当你有一个散点绘制你可以这样做：

# rgbaArr is a N*4 array of float numbers you know what I mean
# X is a N*2 array of coordinates
# axx is the axes object that current draw, you get it from
# axx = fig.gca()

# also import these, to recreate the within env of scatter command 
import matplotlib.markers as mmarkers
import matplotlib.transforms as mtransforms
from matplotlib.collections import PatchCollection
import matplotlib.markers as mmarkers
import matplotlib.patches as mpatches

# define this function
# m is a string of scatter marker, it could be 'o', 's' etc..
# s is the size of the point, use 1.0
# dpi, get it from axx.figure.dpi
def addPatch_point(m, s, dpi):
    marker_obj = mmarkers.MarkerStyle(m)
    path = marker_obj.get_path()
    trans = mtransforms.Affine2D().scale(np.sqrt(s*5)*dpi/72.0)
    ptch = mpatches.PathPatch(path, fill = True, transform = trans)
    return ptch

patches = []
# markerArr is an array of maker string, ['o', 's'. 'o'...]
# sizeArr is an array of size float, [1.0, 1.0. 0.5...]

for m, s in zip(markerArr, sizeArr):
    patches.append(addPatch_point(m, s, axx.figure.dpi))

pclt = PatchCollection(
                patches,
                offsets = zip(X[:,0], X[:,1]),
                transOffset = axx.transData)

pclt.set_transform(mtransforms.IdentityTransform())
pclt.set_edgecolors('none') # it's up to you
pclt._facecolors = rgbaArr

# in the end, when you decide to draw
axx.add_collection(pclt)
# and call axx's parent to draw_idle()

对于大型数据集和有限数量的颜色，一个更快的解决方案是使用Pandas和groupby函数：

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import time

# a generic set of data with associated colors
nsamples=1000
x=np.random.uniform(0,10,nsamples)
y=np.random.uniform(0,10,nsamples)
colors={0:'r',1:'g',2:'b',3:'k'}
c=[colors[i] for i in np.round(np.random.uniform(0,3,nsamples),0)]

plt.close('all')

# "Fast" Scatter plotting
starttime=time.time()
# 1) make a dataframe
df=pd.DataFrame()
df['x']=x
df['y']=y
df['c']=c
plt.figure()
# 2) group the dataframe by color and loop
for g,b in df.groupby(by='c'):
    plt.scatter(b['x'],b['y'],color=g)
print('Fast execution time:', time.time()-starttime)

# "Slow" Scatter plotting
starttime=time.time()
plt.figure()
# 2) group the dataframe by color and loop
for i in range(len(x)):
    plt.scatter(x[i],y[i],color=c[i])
print('Slow execution time:', time.time()-starttime)

plt.show()

这对我很有效：
对于每个系列，使用随机rgb颜色发生器

c = color[np.random.random_sample(), np.random.random_sample(), np.random.random_sample()]

您还可以创建一个颜色列表，其中包括散点图中所需的所有颜色，并将其作为内部参数，如：

colors = ["red", "blue", "green"]
plt.scatter(X, Y, color = colors)