Update: there is now a dedicated documentation page for this, including swatches at https://plotly.com/python/builtin-colorscales/

This file contains most of what you’re looking for.

So probably from plotly._plotly_utils.colors import PLOTLY_SCALES will allow you to do colorscales = PLOTLY_SCALES.keys() although this is meant to be an internal object.

I should add that there are other color scales that Plotly will recognize by name but those aren’t available as a neat import like this as they are in other modules like plotly.express.colors.sequential or plotly.express.colors.cyclical etc.

Plotly does not appear to have such a method, so I wrote one:

import plotly.colors

def get_continuous_color(colorscale, intermed):
    """
    Plotly continuous colorscales assign colors to the range [0, 1]. This function computes the intermediate
    color for any value in that range.

    Plotly doesn't make the colorscales directly accessible in a common format.
    Some are ready to use:
    
        colorscale = plotly.colors.PLOTLY_SCALES["Greens"]

    Others are just swatches that need to be constructed into a colorscale:

        viridis_colors, scale = plotly.colors.convert_colors_to_same_type(plotly.colors.sequential.Viridis)
        colorscale = plotly.colors.make_colorscale(viridis_colors, scale=scale)

    :param colorscale: A plotly continuous colorscale defined with RGB string colors.
    :param intermed: value in the range [0, 1]
    :return: color in rgb string format
    :rtype: str
    """
    if len(colorscale) < 1:
        raise ValueError("colorscale must have at least one color")

    if intermed <= 0 or len(colorscale) == 1:
        return colorscale[0][1]
    if intermed >= 1:
        return colorscale[-1][1]

    for cutoff, color in colorscale:
        if intermed > cutoff:
            low_cutoff, low_color = cutoff, color
        else:
            high_cutoff, high_color = cutoff, color
            break

    # noinspection PyUnboundLocalVariable
    return plotly.colors.find_intermediate_color(
        lowcolor=low_color, highcolor=high_color,
        intermed=((intermed - low_cutoff) / (high_cutoff - low_cutoff)),
        colortype="rgb")

The challenge is that the built-in Plotly colorscales are not consistently exposed. Some are defined as a colorscale already, others as just a list of color swatches that must be converted to a color scale first.

The Viridis colorscale is defined with hex values, which the Plotly color manipulation methods don't like, so it's easiest to construct it from swatches like this:

viridis_colors, _ = plotly.colors.convert_colors_to_same_type(plotly.colors.sequential.Viridis)
colorscale = plotly.colors.make_colorscale(viridis_colors)

get_continuous_color(colorscale, intermed=0.25)
# rgb(58.75, 80.75, 138.25)

Here is an implementation for a custom colorscale based on the viridis colour scale R users will be familiar with.

var x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
var y = vector_normalise(x);

var trace1 = {
  x: x,
  y: x,
  mode: 'markers',
  marker: {
    colorscale: [
      [0.000, "rgb(68, 1, 84)"],
      [0.111, "rgb(72, 40, 120)"],
      [0.222, "rgb(62, 74, 137)"],
      [0.333, "rgb(49, 104, 142)"],
      [0.444, "rgb(38, 130, 142)"],
      [0.556, "rgb(31, 158, 137)"],
      [0.667, "rgb(53, 183, 121)"],
      [0.778, "rgb(109, 205, 89)"],
      [0.889, "rgb(180, 222, 44)"],
      [1.000, "rgb(253, 231, 37)"]
    ],
    color: y,
    size: 20,
  },
};

Plotly.newPlot('myDiv', [trace1], {});

Below is my normalisation function, I have left it verbose to help with understanding. The input vec could be overwritten and returned to reduce local variables if desired.

function vector_normalise(vec) {
  var vmin = Math.min(...vec);
  var vmax = Math.max(...vec);
  // calculate the delta to save time with big arrays
  var vdelta = vmax - vmin;
  // create an empty array to return
  var vec_ret = [];
  // push doesn't seem to like inline functions
  var vnorm;
  // iterate over the array/vector
  vec.forEach(value => {
    vnorm = (value - vmin) / vdelta;
    vec_ret.push(vnorm);
  })
  return vec_ret
}

Edit: Turns out Viridis is one of the existing available palettes... 😉

Plotly uses the same colors as in d3's scale.category10() function. After 10 colors the whole color scheme starts again from 0.

The colors codes can be found in KDD's answer. The snippet below gives the d3 colors and takes the Plotly colors dynamically from a plot, i.e. even if the Plotly changes the color codes will be correct.

var d3colors = Plotly.d3.scale.category10();
var color_div = document.getElementById('colors');
var data = [];

for (var i = 0; i < 11; i += 1) {
  data.push({
    x: [i],
    y: [i + 1],
    name: i + ": Color: " + d3colors(i),
    type: 'bar'
  });
}
Plotly.plot('colors', data);

var node;
var textnode;
for (var i = 0; i < 10; i += 1) {
  var color = d3colors(i);
  node = document.createElement("div");
  node.style.color = color;
  var text = "D3: " + color;
  textnode = document.createTextNode(text);
  node.appendChild(textnode);
  node.appendChild(document.createElement("br"));
  var rgb = Plotly.d3.selectAll('.point').selectAll('path')[i][0].style.fill;
  color = Plotly.d3.rgb(rgb).toString()
  var text = "Plotly: " + color + " ; " + rgb;
  textnode = document.createTextNode(text);
  node.appendChild(textnode);
  color_div.appendChild(node); 
}

<script src="https://cdn.plot.ly/plotly-latest.min.js"></script>
<div id="colors"></div>