3145 lines
115 KiB
Python
3145 lines
115 KiB
Python
from plotly.basedatatypes import BaseTraceType as _BaseTraceType
|
||
import copy as _copy
|
||
|
||
|
||
class Histogram2d(_BaseTraceType):
|
||
|
||
# class properties
|
||
# --------------------
|
||
_parent_path_str = ""
|
||
_path_str = "histogram2d"
|
||
_valid_props = {
|
||
"autobinx",
|
||
"autobiny",
|
||
"autocolorscale",
|
||
"bingroup",
|
||
"coloraxis",
|
||
"colorbar",
|
||
"colorscale",
|
||
"customdata",
|
||
"customdatasrc",
|
||
"histfunc",
|
||
"histnorm",
|
||
"hoverinfo",
|
||
"hoverinfosrc",
|
||
"hoverlabel",
|
||
"hovertemplate",
|
||
"hovertemplatesrc",
|
||
"ids",
|
||
"idssrc",
|
||
"legend",
|
||
"legendgroup",
|
||
"legendgrouptitle",
|
||
"legendrank",
|
||
"legendwidth",
|
||
"marker",
|
||
"meta",
|
||
"metasrc",
|
||
"name",
|
||
"nbinsx",
|
||
"nbinsy",
|
||
"opacity",
|
||
"reversescale",
|
||
"showlegend",
|
||
"showscale",
|
||
"stream",
|
||
"textfont",
|
||
"texttemplate",
|
||
"type",
|
||
"uid",
|
||
"uirevision",
|
||
"visible",
|
||
"x",
|
||
"xaxis",
|
||
"xbingroup",
|
||
"xbins",
|
||
"xcalendar",
|
||
"xgap",
|
||
"xhoverformat",
|
||
"xsrc",
|
||
"y",
|
||
"yaxis",
|
||
"ybingroup",
|
||
"ybins",
|
||
"ycalendar",
|
||
"ygap",
|
||
"yhoverformat",
|
||
"ysrc",
|
||
"z",
|
||
"zauto",
|
||
"zhoverformat",
|
||
"zmax",
|
||
"zmid",
|
||
"zmin",
|
||
"zsmooth",
|
||
"zsrc",
|
||
}
|
||
|
||
# autobinx
|
||
# --------
|
||
@property
|
||
def autobinx(self):
|
||
"""
|
||
Obsolete: since v1.42 each bin attribute is auto-determined
|
||
separately and `autobinx` is not needed. However, we accept
|
||
`autobinx: true` or `false` and will update `xbins` accordingly
|
||
before deleting `autobinx` from the trace.
|
||
|
||
The 'autobinx' property must be specified as a bool
|
||
(either True, or False)
|
||
|
||
Returns
|
||
-------
|
||
bool
|
||
"""
|
||
return self["autobinx"]
|
||
|
||
@autobinx.setter
|
||
def autobinx(self, val):
|
||
self["autobinx"] = val
|
||
|
||
# autobiny
|
||
# --------
|
||
@property
|
||
def autobiny(self):
|
||
"""
|
||
Obsolete: since v1.42 each bin attribute is auto-determined
|
||
separately and `autobiny` is not needed. However, we accept
|
||
`autobiny: true` or `false` and will update `ybins` accordingly
|
||
before deleting `autobiny` from the trace.
|
||
|
||
The 'autobiny' property must be specified as a bool
|
||
(either True, or False)
|
||
|
||
Returns
|
||
-------
|
||
bool
|
||
"""
|
||
return self["autobiny"]
|
||
|
||
@autobiny.setter
|
||
def autobiny(self, val):
|
||
self["autobiny"] = val
|
||
|
||
# autocolorscale
|
||
# --------------
|
||
@property
|
||
def autocolorscale(self):
|
||
"""
|
||
Determines whether the colorscale is a default palette
|
||
(`autocolorscale: true`) or the palette determined by
|
||
`colorscale`. In case `colorscale` is unspecified or
|
||
`autocolorscale` is true, the default palette will be chosen
|
||
according to whether numbers in the `color` array are all
|
||
positive, all negative or mixed.
|
||
|
||
The 'autocolorscale' property must be specified as a bool
|
||
(either True, or False)
|
||
|
||
Returns
|
||
-------
|
||
bool
|
||
"""
|
||
return self["autocolorscale"]
|
||
|
||
@autocolorscale.setter
|
||
def autocolorscale(self, val):
|
||
self["autocolorscale"] = val
|
||
|
||
# bingroup
|
||
# --------
|
||
@property
|
||
def bingroup(self):
|
||
"""
|
||
Set the `xbingroup` and `ybingroup` default prefix For example,
|
||
setting a `bingroup` of 1 on two histogram2d traces will make
|
||
them their x-bins and y-bins match separately.
|
||
|
||
The 'bingroup' property is a string and must be specified as:
|
||
- A string
|
||
- A number that will be converted to a string
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["bingroup"]
|
||
|
||
@bingroup.setter
|
||
def bingroup(self, val):
|
||
self["bingroup"] = val
|
||
|
||
# coloraxis
|
||
# ---------
|
||
@property
|
||
def coloraxis(self):
|
||
"""
|
||
Sets a reference to a shared color axis. References to these
|
||
shared color axes are "coloraxis", "coloraxis2", "coloraxis3",
|
||
etc. Settings for these shared color axes are set in the
|
||
layout, under `layout.coloraxis`, `layout.coloraxis2`, etc.
|
||
Note that multiple color scales can be linked to the same color
|
||
axis.
|
||
|
||
The 'coloraxis' property is an identifier of a particular
|
||
subplot, of type 'coloraxis', that may be specified as the string 'coloraxis'
|
||
optionally followed by an integer >= 1
|
||
(e.g. 'coloraxis', 'coloraxis1', 'coloraxis2', 'coloraxis3', etc.)
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["coloraxis"]
|
||
|
||
@coloraxis.setter
|
||
def coloraxis(self, val):
|
||
self["coloraxis"] = val
|
||
|
||
# colorbar
|
||
# --------
|
||
@property
|
||
def colorbar(self):
|
||
"""
|
||
The 'colorbar' property is an instance of ColorBar
|
||
that may be specified as:
|
||
- An instance of :class:`plotly.graph_objs.histogram2d.ColorBar`
|
||
- A dict of string/value properties that will be passed
|
||
to the ColorBar constructor
|
||
|
||
Supported dict properties:
|
||
|
||
bgcolor
|
||
Sets the color of padded area.
|
||
bordercolor
|
||
Sets the axis line color.
|
||
borderwidth
|
||
Sets the width (in px) or the border enclosing
|
||
this color bar.
|
||
dtick
|
||
Sets the step in-between ticks on this axis.
|
||
Use with `tick0`. Must be a positive number, or
|
||
special strings available to "log" and "date"
|
||
axes. If the axis `type` is "log", then ticks
|
||
are set every 10^(n*dtick) where n is the tick
|
||
number. For example, to set a tick mark at 1,
|
||
10, 100, 1000, ... set dtick to 1. To set tick
|
||
marks at 1, 100, 10000, ... set dtick to 2. To
|
||
set tick marks at 1, 5, 25, 125, 625, 3125, ...
|
||
set dtick to log_10(5), or 0.69897000433. "log"
|
||
has several special values; "L<f>", where `f`
|
||
is a positive number, gives ticks linearly
|
||
spaced in value (but not position). For example
|
||
`tick0` = 0.1, `dtick` = "L0.5" will put ticks
|
||
at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10
|
||
plus small digits between, use "D1" (all
|
||
digits) or "D2" (only 2 and 5). `tick0` is
|
||
ignored for "D1" and "D2". If the axis `type`
|
||
is "date", then you must convert the time to
|
||
milliseconds. For example, to set the interval
|
||
between ticks to one day, set `dtick` to
|
||
86400000.0. "date" also has special values
|
||
"M<n>" gives ticks spaced by a number of
|
||
months. `n` must be a positive integer. To set
|
||
ticks on the 15th of every third month, set
|
||
`tick0` to "2000-01-15" and `dtick` to "M3". To
|
||
set ticks every 4 years, set `dtick` to "M48"
|
||
exponentformat
|
||
Determines a formatting rule for the tick
|
||
exponents. For example, consider the number
|
||
1,000,000,000. If "none", it appears as
|
||
1,000,000,000. If "e", 1e+9. If "E", 1E+9. If
|
||
"power", 1x10^9 (with 9 in a super script). If
|
||
"SI", 1G. If "B", 1B.
|
||
labelalias
|
||
Replacement text for specific tick or hover
|
||
labels. For example using {US: 'USA', CA:
|
||
'Canada'} changes US to USA and CA to Canada.
|
||
The labels we would have shown must match the
|
||
keys exactly, after adding any tickprefix or
|
||
ticksuffix. For negative numbers the minus sign
|
||
symbol used (U+2212) is wider than the regular
|
||
ascii dash. That means you need to use −1
|
||
instead of -1. labelalias can be used with any
|
||
axis type, and both keys (if needed) and values
|
||
(if desired) can include html-like tags or
|
||
MathJax.
|
||
len
|
||
Sets the length of the color bar This measure
|
||
excludes the padding of both ends. That is, the
|
||
color bar length is this length minus the
|
||
padding on both ends.
|
||
lenmode
|
||
Determines whether this color bar's length
|
||
(i.e. the measure in the color variation
|
||
direction) is set in units of plot "fraction"
|
||
or in *pixels. Use `len` to set the value.
|
||
minexponent
|
||
Hide SI prefix for 10^n if |n| is below this
|
||
number. This only has an effect when
|
||
`tickformat` is "SI" or "B".
|
||
nticks
|
||
Specifies the maximum number of ticks for the
|
||
particular axis. The actual number of ticks
|
||
will be chosen automatically to be less than or
|
||
equal to `nticks`. Has an effect only if
|
||
`tickmode` is set to "auto".
|
||
orientation
|
||
Sets the orientation of the colorbar.
|
||
outlinecolor
|
||
Sets the axis line color.
|
||
outlinewidth
|
||
Sets the width (in px) of the axis line.
|
||
separatethousands
|
||
If "true", even 4-digit integers are separated
|
||
showexponent
|
||
If "all", all exponents are shown besides their
|
||
significands. If "first", only the exponent of
|
||
the first tick is shown. If "last", only the
|
||
exponent of the last tick is shown. If "none",
|
||
no exponents appear.
|
||
showticklabels
|
||
Determines whether or not the tick labels are
|
||
drawn.
|
||
showtickprefix
|
||
If "all", all tick labels are displayed with a
|
||
prefix. If "first", only the first tick is
|
||
displayed with a prefix. If "last", only the
|
||
last tick is displayed with a suffix. If
|
||
"none", tick prefixes are hidden.
|
||
showticksuffix
|
||
Same as `showtickprefix` but for tick suffixes.
|
||
thickness
|
||
Sets the thickness of the color bar This
|
||
measure excludes the size of the padding, ticks
|
||
and labels.
|
||
thicknessmode
|
||
Determines whether this color bar's thickness
|
||
(i.e. the measure in the constant color
|
||
direction) is set in units of plot "fraction"
|
||
or in "pixels". Use `thickness` to set the
|
||
value.
|
||
tick0
|
||
Sets the placement of the first tick on this
|
||
axis. Use with `dtick`. If the axis `type` is
|
||
"log", then you must take the log of your
|
||
starting tick (e.g. to set the starting tick to
|
||
100, set the `tick0` to 2) except when
|
||
`dtick`=*L<f>* (see `dtick` for more info). If
|
||
the axis `type` is "date", it should be a date
|
||
string, like date data. If the axis `type` is
|
||
"category", it should be a number, using the
|
||
scale where each category is assigned a serial
|
||
number from zero in the order it appears.
|
||
tickangle
|
||
Sets the angle of the tick labels with respect
|
||
to the horizontal. For example, a `tickangle`
|
||
of -90 draws the tick labels vertically.
|
||
tickcolor
|
||
Sets the tick color.
|
||
tickfont
|
||
Sets the color bar's tick label font
|
||
tickformat
|
||
Sets the tick label formatting rule using d3
|
||
formatting mini-languages which are very
|
||
similar to those in Python. For numbers, see: h
|
||
ttps://github.com/d3/d3-format/tree/v1.4.5#d3-
|
||
format. And for dates see:
|
||
https://github.com/d3/d3-time-
|
||
format/tree/v2.2.3#locale_format. We add two
|
||
items to d3's date formatter: "%h" for half of
|
||
the year as a decimal number as well as "%{n}f"
|
||
for fractional seconds with n digits. For
|
||
example, *2016-10-13 09:15:23.456* with
|
||
tickformat "%H~%M~%S.%2f" would display
|
||
"09~15~23.46"
|
||
tickformatstops
|
||
A tuple of :class:`plotly.graph_objects.histogr
|
||
am2d.colorbar.Tickformatstop` instances or
|
||
dicts with compatible properties
|
||
tickformatstopdefaults
|
||
When used in a template (as layout.template.dat
|
||
a.histogram2d.colorbar.tickformatstopdefaults),
|
||
sets the default property values to use for
|
||
elements of
|
||
histogram2d.colorbar.tickformatstops
|
||
ticklabeloverflow
|
||
Determines how we handle tick labels that would
|
||
overflow either the graph div or the domain of
|
||
the axis. The default value for inside tick
|
||
labels is *hide past domain*. In other cases
|
||
the default is *hide past div*.
|
||
ticklabelposition
|
||
Determines where tick labels are drawn relative
|
||
to the ticks. Left and right options are used
|
||
when `orientation` is "h", top and bottom when
|
||
`orientation` is "v".
|
||
ticklabelstep
|
||
Sets the spacing between tick labels as
|
||
compared to the spacing between ticks. A value
|
||
of 1 (default) means each tick gets a label. A
|
||
value of 2 means shows every 2nd label. A
|
||
larger value n means only every nth tick is
|
||
labeled. `tick0` determines which labels are
|
||
shown. Not implemented for axes with `type`
|
||
"log" or "multicategory", or when `tickmode` is
|
||
"array".
|
||
ticklen
|
||
Sets the tick length (in px).
|
||
tickmode
|
||
Sets the tick mode for this axis. If "auto",
|
||
the number of ticks is set via `nticks`. If
|
||
"linear", the placement of the ticks is
|
||
determined by a starting position `tick0` and a
|
||
tick step `dtick` ("linear" is the default
|
||
value if `tick0` and `dtick` are provided). If
|
||
"array", the placement of the ticks is set via
|
||
`tickvals` and the tick text is `ticktext`.
|
||
("array" is the default value if `tickvals` is
|
||
provided).
|
||
tickprefix
|
||
Sets a tick label prefix.
|
||
ticks
|
||
Determines whether ticks are drawn or not. If
|
||
"", this axis' ticks are not drawn. If
|
||
"outside" ("inside"), this axis' are drawn
|
||
outside (inside) the axis lines.
|
||
ticksuffix
|
||
Sets a tick label suffix.
|
||
ticktext
|
||
Sets the text displayed at the ticks position
|
||
via `tickvals`. Only has an effect if
|
||
`tickmode` is set to "array". Used with
|
||
`tickvals`.
|
||
ticktextsrc
|
||
Sets the source reference on Chart Studio Cloud
|
||
for `ticktext`.
|
||
tickvals
|
||
Sets the values at which ticks on this axis
|
||
appear. Only has an effect if `tickmode` is set
|
||
to "array". Used with `ticktext`.
|
||
tickvalssrc
|
||
Sets the source reference on Chart Studio Cloud
|
||
for `tickvals`.
|
||
tickwidth
|
||
Sets the tick width (in px).
|
||
title
|
||
:class:`plotly.graph_objects.histogram2d.colorb
|
||
ar.Title` instance or dict with compatible
|
||
properties
|
||
titlefont
|
||
Deprecated: Please use
|
||
histogram2d.colorbar.title.font instead. Sets
|
||
this color bar's title font. Note that the
|
||
title's font used to be set by the now
|
||
deprecated `titlefont` attribute.
|
||
titleside
|
||
Deprecated: Please use
|
||
histogram2d.colorbar.title.side instead.
|
||
Determines the location of color bar's title
|
||
with respect to the color bar. Defaults to
|
||
"top" when `orientation` if "v" and defaults
|
||
to "right" when `orientation` if "h". Note that
|
||
the title's location used to be set by the now
|
||
deprecated `titleside` attribute.
|
||
x
|
||
Sets the x position with respect to `xref` of
|
||
the color bar (in plot fraction). When `xref`
|
||
is "paper", defaults to 1.02 when `orientation`
|
||
is "v" and 0.5 when `orientation` is "h". When
|
||
`xref` is "container", defaults to 1 when
|
||
`orientation` is "v" and 0.5 when `orientation`
|
||
is "h". Must be between 0 and 1 if `xref` is
|
||
"container" and between "-2" and 3 if `xref` is
|
||
"paper".
|
||
xanchor
|
||
Sets this color bar's horizontal position
|
||
anchor. This anchor binds the `x` position to
|
||
the "left", "center" or "right" of the color
|
||
bar. Defaults to "left" when `orientation` is
|
||
"v" and "center" when `orientation` is "h".
|
||
xpad
|
||
Sets the amount of padding (in px) along the x
|
||
direction.
|
||
xref
|
||
Sets the container `x` refers to. "container"
|
||
spans the entire `width` of the plot. "paper"
|
||
refers to the width of the plotting area only.
|
||
y
|
||
Sets the y position with respect to `yref` of
|
||
the color bar (in plot fraction). When `yref`
|
||
is "paper", defaults to 0.5 when `orientation`
|
||
is "v" and 1.02 when `orientation` is "h". When
|
||
`yref` is "container", defaults to 0.5 when
|
||
`orientation` is "v" and 1 when `orientation`
|
||
is "h". Must be between 0 and 1 if `yref` is
|
||
"container" and between "-2" and 3 if `yref` is
|
||
"paper".
|
||
yanchor
|
||
Sets this color bar's vertical position anchor
|
||
This anchor binds the `y` position to the
|
||
"top", "middle" or "bottom" of the color bar.
|
||
Defaults to "middle" when `orientation` is "v"
|
||
and "bottom" when `orientation` is "h".
|
||
ypad
|
||
Sets the amount of padding (in px) along the y
|
||
direction.
|
||
yref
|
||
Sets the container `y` refers to. "container"
|
||
spans the entire `height` of the plot. "paper"
|
||
refers to the height of the plotting area only.
|
||
|
||
Returns
|
||
-------
|
||
plotly.graph_objs.histogram2d.ColorBar
|
||
"""
|
||
return self["colorbar"]
|
||
|
||
@colorbar.setter
|
||
def colorbar(self, val):
|
||
self["colorbar"] = val
|
||
|
||
# colorscale
|
||
# ----------
|
||
@property
|
||
def colorscale(self):
|
||
"""
|
||
Sets the colorscale. The colorscale must be an array containing
|
||
arrays mapping a normalized value to an rgb, rgba, hex, hsl,
|
||
hsv, or named color string. At minimum, a mapping for the
|
||
lowest (0) and highest (1) values are required. For example,
|
||
`[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the
|
||
bounds of the colorscale in color space, use `zmin` and `zmax`.
|
||
Alternatively, `colorscale` may be a palette name string of the
|
||
following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,
|
||
Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,
|
||
YlGnBu,YlOrRd.
|
||
|
||
The 'colorscale' property is a colorscale and may be
|
||
specified as:
|
||
- A list of colors that will be spaced evenly to create the colorscale.
|
||
Many predefined colorscale lists are included in the sequential, diverging,
|
||
and cyclical modules in the plotly.colors package.
|
||
- A list of 2-element lists where the first element is the
|
||
normalized color level value (starting at 0 and ending at 1),
|
||
and the second item is a valid color string.
|
||
(e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']])
|
||
- One of the following named colorscales:
|
||
['aggrnyl', 'agsunset', 'algae', 'amp', 'armyrose', 'balance',
|
||
'blackbody', 'bluered', 'blues', 'blugrn', 'bluyl', 'brbg',
|
||
'brwnyl', 'bugn', 'bupu', 'burg', 'burgyl', 'cividis', 'curl',
|
||
'darkmint', 'deep', 'delta', 'dense', 'earth', 'edge', 'electric',
|
||
'emrld', 'fall', 'geyser', 'gnbu', 'gray', 'greens', 'greys',
|
||
'haline', 'hot', 'hsv', 'ice', 'icefire', 'inferno', 'jet',
|
||
'magenta', 'magma', 'matter', 'mint', 'mrybm', 'mygbm', 'oranges',
|
||
'orrd', 'oryel', 'oxy', 'peach', 'phase', 'picnic', 'pinkyl',
|
||
'piyg', 'plasma', 'plotly3', 'portland', 'prgn', 'pubu', 'pubugn',
|
||
'puor', 'purd', 'purp', 'purples', 'purpor', 'rainbow', 'rdbu',
|
||
'rdgy', 'rdpu', 'rdylbu', 'rdylgn', 'redor', 'reds', 'solar',
|
||
'spectral', 'speed', 'sunset', 'sunsetdark', 'teal', 'tealgrn',
|
||
'tealrose', 'tempo', 'temps', 'thermal', 'tropic', 'turbid',
|
||
'turbo', 'twilight', 'viridis', 'ylgn', 'ylgnbu', 'ylorbr',
|
||
'ylorrd'].
|
||
Appending '_r' to a named colorscale reverses it.
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["colorscale"]
|
||
|
||
@colorscale.setter
|
||
def colorscale(self, val):
|
||
self["colorscale"] = val
|
||
|
||
# customdata
|
||
# ----------
|
||
@property
|
||
def customdata(self):
|
||
"""
|
||
Assigns extra data each datum. This may be useful when
|
||
listening to hover, click and selection events. Note that,
|
||
"scatter" traces also appends customdata items in the markers
|
||
DOM elements
|
||
|
||
The 'customdata' property is an array that may be specified as a tuple,
|
||
list, numpy array, or pandas Series
|
||
|
||
Returns
|
||
-------
|
||
numpy.ndarray
|
||
"""
|
||
return self["customdata"]
|
||
|
||
@customdata.setter
|
||
def customdata(self, val):
|
||
self["customdata"] = val
|
||
|
||
# customdatasrc
|
||
# -------------
|
||
@property
|
||
def customdatasrc(self):
|
||
"""
|
||
Sets the source reference on Chart Studio Cloud for
|
||
`customdata`.
|
||
|
||
The 'customdatasrc' property must be specified as a string or
|
||
as a plotly.grid_objs.Column object
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["customdatasrc"]
|
||
|
||
@customdatasrc.setter
|
||
def customdatasrc(self, val):
|
||
self["customdatasrc"] = val
|
||
|
||
# histfunc
|
||
# --------
|
||
@property
|
||
def histfunc(self):
|
||
"""
|
||
Specifies the binning function used for this histogram trace.
|
||
If "count", the histogram values are computed by counting the
|
||
number of values lying inside each bin. If "sum", "avg", "min",
|
||
"max", the histogram values are computed using the sum, the
|
||
average, the minimum or the maximum of the values lying inside
|
||
each bin respectively.
|
||
|
||
The 'histfunc' property is an enumeration that may be specified as:
|
||
- One of the following enumeration values:
|
||
['count', 'sum', 'avg', 'min', 'max']
|
||
|
||
Returns
|
||
-------
|
||
Any
|
||
"""
|
||
return self["histfunc"]
|
||
|
||
@histfunc.setter
|
||
def histfunc(self, val):
|
||
self["histfunc"] = val
|
||
|
||
# histnorm
|
||
# --------
|
||
@property
|
||
def histnorm(self):
|
||
"""
|
||
Specifies the type of normalization used for this histogram
|
||
trace. If "", the span of each bar corresponds to the number of
|
||
occurrences (i.e. the number of data points lying inside the
|
||
bins). If "percent" / "probability", the span of each bar
|
||
corresponds to the percentage / fraction of occurrences with
|
||
respect to the total number of sample points (here, the sum of
|
||
all bin HEIGHTS equals 100% / 1). If "density", the span of
|
||
each bar corresponds to the number of occurrences in a bin
|
||
divided by the size of the bin interval (here, the sum of all
|
||
bin AREAS equals the total number of sample points). If
|
||
*probability density*, the area of each bar corresponds to the
|
||
probability that an event will fall into the corresponding bin
|
||
(here, the sum of all bin AREAS equals 1).
|
||
|
||
The 'histnorm' property is an enumeration that may be specified as:
|
||
- One of the following enumeration values:
|
||
['', 'percent', 'probability', 'density', 'probability
|
||
density']
|
||
|
||
Returns
|
||
-------
|
||
Any
|
||
"""
|
||
return self["histnorm"]
|
||
|
||
@histnorm.setter
|
||
def histnorm(self, val):
|
||
self["histnorm"] = val
|
||
|
||
# hoverinfo
|
||
# ---------
|
||
@property
|
||
def hoverinfo(self):
|
||
"""
|
||
Determines which trace information appear on hover. If `none`
|
||
or `skip` are set, no information is displayed upon hovering.
|
||
But, if `none` is set, click and hover events are still fired.
|
||
|
||
The 'hoverinfo' property is a flaglist and may be specified
|
||
as a string containing:
|
||
- Any combination of ['x', 'y', 'z', 'text', 'name'] joined with '+' characters
|
||
(e.g. 'x+y')
|
||
OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip')
|
||
- A list or array of the above
|
||
|
||
Returns
|
||
-------
|
||
Any|numpy.ndarray
|
||
"""
|
||
return self["hoverinfo"]
|
||
|
||
@hoverinfo.setter
|
||
def hoverinfo(self, val):
|
||
self["hoverinfo"] = val
|
||
|
||
# hoverinfosrc
|
||
# ------------
|
||
@property
|
||
def hoverinfosrc(self):
|
||
"""
|
||
Sets the source reference on Chart Studio Cloud for
|
||
`hoverinfo`.
|
||
|
||
The 'hoverinfosrc' property must be specified as a string or
|
||
as a plotly.grid_objs.Column object
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["hoverinfosrc"]
|
||
|
||
@hoverinfosrc.setter
|
||
def hoverinfosrc(self, val):
|
||
self["hoverinfosrc"] = val
|
||
|
||
# hoverlabel
|
||
# ----------
|
||
@property
|
||
def hoverlabel(self):
|
||
"""
|
||
The 'hoverlabel' property is an instance of Hoverlabel
|
||
that may be specified as:
|
||
- An instance of :class:`plotly.graph_objs.histogram2d.Hoverlabel`
|
||
- A dict of string/value properties that will be passed
|
||
to the Hoverlabel constructor
|
||
|
||
Supported dict properties:
|
||
|
||
align
|
||
Sets the horizontal alignment of the text
|
||
content within hover label box. Has an effect
|
||
only if the hover label text spans more two or
|
||
more lines
|
||
alignsrc
|
||
Sets the source reference on Chart Studio Cloud
|
||
for `align`.
|
||
bgcolor
|
||
Sets the background color of the hover labels
|
||
for this trace
|
||
bgcolorsrc
|
||
Sets the source reference on Chart Studio Cloud
|
||
for `bgcolor`.
|
||
bordercolor
|
||
Sets the border color of the hover labels for
|
||
this trace.
|
||
bordercolorsrc
|
||
Sets the source reference on Chart Studio Cloud
|
||
for `bordercolor`.
|
||
font
|
||
Sets the font used in hover labels.
|
||
namelength
|
||
Sets the default length (in number of
|
||
characters) of the trace name in the hover
|
||
labels for all traces. -1 shows the whole name
|
||
regardless of length. 0-3 shows the first 0-3
|
||
characters, and an integer >3 will show the
|
||
whole name if it is less than that many
|
||
characters, but if it is longer, will truncate
|
||
to `namelength - 3` characters and add an
|
||
ellipsis.
|
||
namelengthsrc
|
||
Sets the source reference on Chart Studio Cloud
|
||
for `namelength`.
|
||
|
||
Returns
|
||
-------
|
||
plotly.graph_objs.histogram2d.Hoverlabel
|
||
"""
|
||
return self["hoverlabel"]
|
||
|
||
@hoverlabel.setter
|
||
def hoverlabel(self, val):
|
||
self["hoverlabel"] = val
|
||
|
||
# hovertemplate
|
||
# -------------
|
||
@property
|
||
def hovertemplate(self):
|
||
"""
|
||
Template string used for rendering the information that appear
|
||
on hover box. Note that this will override `hoverinfo`.
|
||
Variables are inserted using %{variable}, for example "y: %{y}"
|
||
as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When
|
||
showing info for several points, "xother" will be added to
|
||
those with different x positions from the first point. An
|
||
underscore before or after "(x|y)other" will add a space on
|
||
that side, only when this field is shown. Numbers are formatted
|
||
using d3-format's syntax %{variable:d3-format}, for example
|
||
"Price: %{y:$.2f}".
|
||
https://github.com/d3/d3-format/tree/v1.4.5#d3-format for
|
||
details on the formatting syntax. Dates are formatted using
|
||
d3-time-format's syntax %{variable|d3-time-format}, for example
|
||
"Day: %{2019-01-01|%A}". https://github.com/d3/d3-time-
|
||
format/tree/v2.2.3#locale_format for details on the date
|
||
formatting syntax. The variables available in `hovertemplate`
|
||
are the ones emitted as event data described at this link
|
||
https://plotly.com/javascript/plotlyjs-events/#event-data.
|
||
Additionally, every attributes that can be specified per-point
|
||
(the ones that are `arrayOk: true`) are available. Finally, the
|
||
template string has access to variable `z` Anything contained
|
||
in tag `<extra>` is displayed in the secondary box, for example
|
||
"<extra>{fullData.name}</extra>". To hide the secondary box
|
||
completely, use an empty tag `<extra></extra>`.
|
||
|
||
The 'hovertemplate' property is a string and must be specified as:
|
||
- A string
|
||
- A number that will be converted to a string
|
||
- A tuple, list, or one-dimensional numpy array of the above
|
||
|
||
Returns
|
||
-------
|
||
str|numpy.ndarray
|
||
"""
|
||
return self["hovertemplate"]
|
||
|
||
@hovertemplate.setter
|
||
def hovertemplate(self, val):
|
||
self["hovertemplate"] = val
|
||
|
||
# hovertemplatesrc
|
||
# ----------------
|
||
@property
|
||
def hovertemplatesrc(self):
|
||
"""
|
||
Sets the source reference on Chart Studio Cloud for
|
||
`hovertemplate`.
|
||
|
||
The 'hovertemplatesrc' property must be specified as a string or
|
||
as a plotly.grid_objs.Column object
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["hovertemplatesrc"]
|
||
|
||
@hovertemplatesrc.setter
|
||
def hovertemplatesrc(self, val):
|
||
self["hovertemplatesrc"] = val
|
||
|
||
# ids
|
||
# ---
|
||
@property
|
||
def ids(self):
|
||
"""
|
||
Assigns id labels to each datum. These ids for object constancy
|
||
of data points during animation. Should be an array of strings,
|
||
not numbers or any other type.
|
||
|
||
The 'ids' property is an array that may be specified as a tuple,
|
||
list, numpy array, or pandas Series
|
||
|
||
Returns
|
||
-------
|
||
numpy.ndarray
|
||
"""
|
||
return self["ids"]
|
||
|
||
@ids.setter
|
||
def ids(self, val):
|
||
self["ids"] = val
|
||
|
||
# idssrc
|
||
# ------
|
||
@property
|
||
def idssrc(self):
|
||
"""
|
||
Sets the source reference on Chart Studio Cloud for `ids`.
|
||
|
||
The 'idssrc' property must be specified as a string or
|
||
as a plotly.grid_objs.Column object
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["idssrc"]
|
||
|
||
@idssrc.setter
|
||
def idssrc(self, val):
|
||
self["idssrc"] = val
|
||
|
||
# legend
|
||
# ------
|
||
@property
|
||
def legend(self):
|
||
"""
|
||
Sets the reference to a legend to show this trace in.
|
||
References to these legends are "legend", "legend2", "legend3",
|
||
etc. Settings for these legends are set in the layout, under
|
||
`layout.legend`, `layout.legend2`, etc.
|
||
|
||
The 'legend' property is an identifier of a particular
|
||
subplot, of type 'legend', that may be specified as the string 'legend'
|
||
optionally followed by an integer >= 1
|
||
(e.g. 'legend', 'legend1', 'legend2', 'legend3', etc.)
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["legend"]
|
||
|
||
@legend.setter
|
||
def legend(self, val):
|
||
self["legend"] = val
|
||
|
||
# legendgroup
|
||
# -----------
|
||
@property
|
||
def legendgroup(self):
|
||
"""
|
||
Sets the legend group for this trace. Traces and shapes part of
|
||
the same legend group hide/show at the same time when toggling
|
||
legend items.
|
||
|
||
The 'legendgroup' property is a string and must be specified as:
|
||
- A string
|
||
- A number that will be converted to a string
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["legendgroup"]
|
||
|
||
@legendgroup.setter
|
||
def legendgroup(self, val):
|
||
self["legendgroup"] = val
|
||
|
||
# legendgrouptitle
|
||
# ----------------
|
||
@property
|
||
def legendgrouptitle(self):
|
||
"""
|
||
The 'legendgrouptitle' property is an instance of Legendgrouptitle
|
||
that may be specified as:
|
||
- An instance of :class:`plotly.graph_objs.histogram2d.Legendgrouptitle`
|
||
- A dict of string/value properties that will be passed
|
||
to the Legendgrouptitle constructor
|
||
|
||
Supported dict properties:
|
||
|
||
font
|
||
Sets this legend group's title font.
|
||
text
|
||
Sets the title of the legend group.
|
||
|
||
Returns
|
||
-------
|
||
plotly.graph_objs.histogram2d.Legendgrouptitle
|
||
"""
|
||
return self["legendgrouptitle"]
|
||
|
||
@legendgrouptitle.setter
|
||
def legendgrouptitle(self, val):
|
||
self["legendgrouptitle"] = val
|
||
|
||
# legendrank
|
||
# ----------
|
||
@property
|
||
def legendrank(self):
|
||
"""
|
||
Sets the legend rank for this trace. Items and groups with
|
||
smaller ranks are presented on top/left side while with
|
||
"reversed" `legend.traceorder` they are on bottom/right side.
|
||
The default legendrank is 1000, so that you can use ranks less
|
||
than 1000 to place certain items before all unranked items, and
|
||
ranks greater than 1000 to go after all unranked items. When
|
||
having unranked or equal rank items shapes would be displayed
|
||
after traces i.e. according to their order in data and layout.
|
||
|
||
The 'legendrank' property is a number and may be specified as:
|
||
- An int or float
|
||
|
||
Returns
|
||
-------
|
||
int|float
|
||
"""
|
||
return self["legendrank"]
|
||
|
||
@legendrank.setter
|
||
def legendrank(self, val):
|
||
self["legendrank"] = val
|
||
|
||
# legendwidth
|
||
# -----------
|
||
@property
|
||
def legendwidth(self):
|
||
"""
|
||
Sets the width (in px or fraction) of the legend for this
|
||
trace.
|
||
|
||
The 'legendwidth' property is a number and may be specified as:
|
||
- An int or float in the interval [0, inf]
|
||
|
||
Returns
|
||
-------
|
||
int|float
|
||
"""
|
||
return self["legendwidth"]
|
||
|
||
@legendwidth.setter
|
||
def legendwidth(self, val):
|
||
self["legendwidth"] = val
|
||
|
||
# marker
|
||
# ------
|
||
@property
|
||
def marker(self):
|
||
"""
|
||
The 'marker' property is an instance of Marker
|
||
that may be specified as:
|
||
- An instance of :class:`plotly.graph_objs.histogram2d.Marker`
|
||
- A dict of string/value properties that will be passed
|
||
to the Marker constructor
|
||
|
||
Supported dict properties:
|
||
|
||
color
|
||
Sets the aggregation data.
|
||
colorsrc
|
||
Sets the source reference on Chart Studio Cloud
|
||
for `color`.
|
||
|
||
Returns
|
||
-------
|
||
plotly.graph_objs.histogram2d.Marker
|
||
"""
|
||
return self["marker"]
|
||
|
||
@marker.setter
|
||
def marker(self, val):
|
||
self["marker"] = val
|
||
|
||
# meta
|
||
# ----
|
||
@property
|
||
def meta(self):
|
||
"""
|
||
Assigns extra meta information associated with this trace that
|
||
can be used in various text attributes. Attributes such as
|
||
trace `name`, graph, axis and colorbar `title.text`, annotation
|
||
`text` `rangeselector`, `updatemenues` and `sliders` `label`
|
||
text all support `meta`. To access the trace `meta` values in
|
||
an attribute in the same trace, simply use `%{meta[i]}` where
|
||
`i` is the index or key of the `meta` item in question. To
|
||
access trace `meta` in layout attributes, use
|
||
`%{data[n[.meta[i]}` where `i` is the index or key of the
|
||
`meta` and `n` is the trace index.
|
||
|
||
The 'meta' property accepts values of any type
|
||
|
||
Returns
|
||
-------
|
||
Any|numpy.ndarray
|
||
"""
|
||
return self["meta"]
|
||
|
||
@meta.setter
|
||
def meta(self, val):
|
||
self["meta"] = val
|
||
|
||
# metasrc
|
||
# -------
|
||
@property
|
||
def metasrc(self):
|
||
"""
|
||
Sets the source reference on Chart Studio Cloud for `meta`.
|
||
|
||
The 'metasrc' property must be specified as a string or
|
||
as a plotly.grid_objs.Column object
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["metasrc"]
|
||
|
||
@metasrc.setter
|
||
def metasrc(self, val):
|
||
self["metasrc"] = val
|
||
|
||
# name
|
||
# ----
|
||
@property
|
||
def name(self):
|
||
"""
|
||
Sets the trace name. The trace name appears as the legend item
|
||
and on hover.
|
||
|
||
The 'name' property is a string and must be specified as:
|
||
- A string
|
||
- A number that will be converted to a string
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["name"]
|
||
|
||
@name.setter
|
||
def name(self, val):
|
||
self["name"] = val
|
||
|
||
# nbinsx
|
||
# ------
|
||
@property
|
||
def nbinsx(self):
|
||
"""
|
||
Specifies the maximum number of desired bins. This value will
|
||
be used in an algorithm that will decide the optimal bin size
|
||
such that the histogram best visualizes the distribution of the
|
||
data. Ignored if `xbins.size` is provided.
|
||
|
||
The 'nbinsx' property is a integer and may be specified as:
|
||
- An int (or float that will be cast to an int)
|
||
in the interval [0, 9223372036854775807]
|
||
|
||
Returns
|
||
-------
|
||
int
|
||
"""
|
||
return self["nbinsx"]
|
||
|
||
@nbinsx.setter
|
||
def nbinsx(self, val):
|
||
self["nbinsx"] = val
|
||
|
||
# nbinsy
|
||
# ------
|
||
@property
|
||
def nbinsy(self):
|
||
"""
|
||
Specifies the maximum number of desired bins. This value will
|
||
be used in an algorithm that will decide the optimal bin size
|
||
such that the histogram best visualizes the distribution of the
|
||
data. Ignored if `ybins.size` is provided.
|
||
|
||
The 'nbinsy' property is a integer and may be specified as:
|
||
- An int (or float that will be cast to an int)
|
||
in the interval [0, 9223372036854775807]
|
||
|
||
Returns
|
||
-------
|
||
int
|
||
"""
|
||
return self["nbinsy"]
|
||
|
||
@nbinsy.setter
|
||
def nbinsy(self, val):
|
||
self["nbinsy"] = val
|
||
|
||
# opacity
|
||
# -------
|
||
@property
|
||
def opacity(self):
|
||
"""
|
||
Sets the opacity of the trace.
|
||
|
||
The 'opacity' property is a number and may be specified as:
|
||
- An int or float in the interval [0, 1]
|
||
|
||
Returns
|
||
-------
|
||
int|float
|
||
"""
|
||
return self["opacity"]
|
||
|
||
@opacity.setter
|
||
def opacity(self, val):
|
||
self["opacity"] = val
|
||
|
||
# reversescale
|
||
# ------------
|
||
@property
|
||
def reversescale(self):
|
||
"""
|
||
Reverses the color mapping if true. If true, `zmin` will
|
||
correspond to the last color in the array and `zmax` will
|
||
correspond to the first color.
|
||
|
||
The 'reversescale' property must be specified as a bool
|
||
(either True, or False)
|
||
|
||
Returns
|
||
-------
|
||
bool
|
||
"""
|
||
return self["reversescale"]
|
||
|
||
@reversescale.setter
|
||
def reversescale(self, val):
|
||
self["reversescale"] = val
|
||
|
||
# showlegend
|
||
# ----------
|
||
@property
|
||
def showlegend(self):
|
||
"""
|
||
Determines whether or not an item corresponding to this trace
|
||
is shown in the legend.
|
||
|
||
The 'showlegend' property must be specified as a bool
|
||
(either True, or False)
|
||
|
||
Returns
|
||
-------
|
||
bool
|
||
"""
|
||
return self["showlegend"]
|
||
|
||
@showlegend.setter
|
||
def showlegend(self, val):
|
||
self["showlegend"] = val
|
||
|
||
# showscale
|
||
# ---------
|
||
@property
|
||
def showscale(self):
|
||
"""
|
||
Determines whether or not a colorbar is displayed for this
|
||
trace.
|
||
|
||
The 'showscale' property must be specified as a bool
|
||
(either True, or False)
|
||
|
||
Returns
|
||
-------
|
||
bool
|
||
"""
|
||
return self["showscale"]
|
||
|
||
@showscale.setter
|
||
def showscale(self, val):
|
||
self["showscale"] = val
|
||
|
||
# stream
|
||
# ------
|
||
@property
|
||
def stream(self):
|
||
"""
|
||
The 'stream' property is an instance of Stream
|
||
that may be specified as:
|
||
- An instance of :class:`plotly.graph_objs.histogram2d.Stream`
|
||
- A dict of string/value properties that will be passed
|
||
to the Stream constructor
|
||
|
||
Supported dict properties:
|
||
|
||
maxpoints
|
||
Sets the maximum number of points to keep on
|
||
the plots from an incoming stream. If
|
||
`maxpoints` is set to 50, only the newest 50
|
||
points will be displayed on the plot.
|
||
token
|
||
The stream id number links a data trace on a
|
||
plot with a stream. See https://chart-
|
||
studio.plotly.com/settings for more details.
|
||
|
||
Returns
|
||
-------
|
||
plotly.graph_objs.histogram2d.Stream
|
||
"""
|
||
return self["stream"]
|
||
|
||
@stream.setter
|
||
def stream(self, val):
|
||
self["stream"] = val
|
||
|
||
# textfont
|
||
# --------
|
||
@property
|
||
def textfont(self):
|
||
"""
|
||
Sets the text font.
|
||
|
||
The 'textfont' property is an instance of Textfont
|
||
that may be specified as:
|
||
- An instance of :class:`plotly.graph_objs.histogram2d.Textfont`
|
||
- A dict of string/value properties that will be passed
|
||
to the Textfont constructor
|
||
|
||
Supported dict properties:
|
||
|
||
color
|
||
|
||
family
|
||
HTML font family - the typeface that will be
|
||
applied by the web browser. The web browser
|
||
will only be able to apply a font if it is
|
||
available on the system which it operates.
|
||
Provide multiple font families, separated by
|
||
commas, to indicate the preference in which to
|
||
apply fonts if they aren't available on the
|
||
system. The Chart Studio Cloud (at
|
||
https://chart-studio.plotly.com or on-premise)
|
||
generates images on a server, where only a
|
||
select number of fonts are installed and
|
||
supported. These include "Arial", "Balto",
|
||
"Courier New", "Droid Sans",, "Droid Serif",
|
||
"Droid Sans Mono", "Gravitas One", "Old
|
||
Standard TT", "Open Sans", "Overpass", "PT Sans
|
||
Narrow", "Raleway", "Times New Roman".
|
||
size
|
||
|
||
Returns
|
||
-------
|
||
plotly.graph_objs.histogram2d.Textfont
|
||
"""
|
||
return self["textfont"]
|
||
|
||
@textfont.setter
|
||
def textfont(self, val):
|
||
self["textfont"] = val
|
||
|
||
# texttemplate
|
||
# ------------
|
||
@property
|
||
def texttemplate(self):
|
||
"""
|
||
Template string used for rendering the information text that
|
||
appear on points. Note that this will override `textinfo`.
|
||
Variables are inserted using %{variable}, for example "y:
|
||
%{y}". Numbers are formatted using d3-format's syntax
|
||
%{variable:d3-format}, for example "Price: %{y:$.2f}".
|
||
https://github.com/d3/d3-format/tree/v1.4.5#d3-format for
|
||
details on the formatting syntax. Dates are formatted using
|
||
d3-time-format's syntax %{variable|d3-time-format}, for example
|
||
"Day: %{2019-01-01|%A}". https://github.com/d3/d3-time-
|
||
format/tree/v2.2.3#locale_format for details on the date
|
||
formatting syntax. Every attributes that can be specified per-
|
||
point (the ones that are `arrayOk: true`) are available.
|
||
Finally, the template string has access to variable `z`
|
||
|
||
The 'texttemplate' property is a string and must be specified as:
|
||
- A string
|
||
- A number that will be converted to a string
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["texttemplate"]
|
||
|
||
@texttemplate.setter
|
||
def texttemplate(self, val):
|
||
self["texttemplate"] = val
|
||
|
||
# uid
|
||
# ---
|
||
@property
|
||
def uid(self):
|
||
"""
|
||
Assign an id to this trace, Use this to provide object
|
||
constancy between traces during animations and transitions.
|
||
|
||
The 'uid' property is a string and must be specified as:
|
||
- A string
|
||
- A number that will be converted to a string
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["uid"]
|
||
|
||
@uid.setter
|
||
def uid(self, val):
|
||
self["uid"] = val
|
||
|
||
# uirevision
|
||
# ----------
|
||
@property
|
||
def uirevision(self):
|
||
"""
|
||
Controls persistence of some user-driven changes to the trace:
|
||
`constraintrange` in `parcoords` traces, as well as some
|
||
`editable: true` modifications such as `name` and
|
||
`colorbar.title`. Defaults to `layout.uirevision`. Note that
|
||
other user-driven trace attribute changes are controlled by
|
||
`layout` attributes: `trace.visible` is controlled by
|
||
`layout.legend.uirevision`, `selectedpoints` is controlled by
|
||
`layout.selectionrevision`, and `colorbar.(x|y)` (accessible
|
||
with `config: {editable: true}`) is controlled by
|
||
`layout.editrevision`. Trace changes are tracked by `uid`,
|
||
which only falls back on trace index if no `uid` is provided.
|
||
So if your app can add/remove traces before the end of the
|
||
`data` array, such that the same trace has a different index,
|
||
you can still preserve user-driven changes if you give each
|
||
trace a `uid` that stays with it as it moves.
|
||
|
||
The 'uirevision' property accepts values of any type
|
||
|
||
Returns
|
||
-------
|
||
Any
|
||
"""
|
||
return self["uirevision"]
|
||
|
||
@uirevision.setter
|
||
def uirevision(self, val):
|
||
self["uirevision"] = val
|
||
|
||
# visible
|
||
# -------
|
||
@property
|
||
def visible(self):
|
||
"""
|
||
Determines whether or not this trace is visible. If
|
||
"legendonly", the trace is not drawn, but can appear as a
|
||
legend item (provided that the legend itself is visible).
|
||
|
||
The 'visible' property is an enumeration that may be specified as:
|
||
- One of the following enumeration values:
|
||
[True, False, 'legendonly']
|
||
|
||
Returns
|
||
-------
|
||
Any
|
||
"""
|
||
return self["visible"]
|
||
|
||
@visible.setter
|
||
def visible(self, val):
|
||
self["visible"] = val
|
||
|
||
# x
|
||
# -
|
||
@property
|
||
def x(self):
|
||
"""
|
||
Sets the sample data to be binned on the x axis.
|
||
|
||
The 'x' property is an array that may be specified as a tuple,
|
||
list, numpy array, or pandas Series
|
||
|
||
Returns
|
||
-------
|
||
numpy.ndarray
|
||
"""
|
||
return self["x"]
|
||
|
||
@x.setter
|
||
def x(self, val):
|
||
self["x"] = val
|
||
|
||
# xaxis
|
||
# -----
|
||
@property
|
||
def xaxis(self):
|
||
"""
|
||
Sets a reference between this trace's x coordinates and a 2D
|
||
cartesian x axis. If "x" (the default value), the x coordinates
|
||
refer to `layout.xaxis`. If "x2", the x coordinates refer to
|
||
`layout.xaxis2`, and so on.
|
||
|
||
The 'xaxis' property is an identifier of a particular
|
||
subplot, of type 'x', that may be specified as the string 'x'
|
||
optionally followed by an integer >= 1
|
||
(e.g. 'x', 'x1', 'x2', 'x3', etc.)
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["xaxis"]
|
||
|
||
@xaxis.setter
|
||
def xaxis(self, val):
|
||
self["xaxis"] = val
|
||
|
||
# xbingroup
|
||
# ---------
|
||
@property
|
||
def xbingroup(self):
|
||
"""
|
||
Set a group of histogram traces which will have compatible
|
||
x-bin settings. Using `xbingroup`, histogram2d and
|
||
histogram2dcontour traces (on axes of the same axis type) can
|
||
have compatible x-bin settings. Note that the same `xbingroup`
|
||
value can be used to set (1D) histogram `bingroup`
|
||
|
||
The 'xbingroup' property is a string and must be specified as:
|
||
- A string
|
||
- A number that will be converted to a string
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["xbingroup"]
|
||
|
||
@xbingroup.setter
|
||
def xbingroup(self, val):
|
||
self["xbingroup"] = val
|
||
|
||
# xbins
|
||
# -----
|
||
@property
|
||
def xbins(self):
|
||
"""
|
||
The 'xbins' property is an instance of XBins
|
||
that may be specified as:
|
||
- An instance of :class:`plotly.graph_objs.histogram2d.XBins`
|
||
- A dict of string/value properties that will be passed
|
||
to the XBins constructor
|
||
|
||
Supported dict properties:
|
||
|
||
end
|
||
Sets the end value for the x axis bins. The
|
||
last bin may not end exactly at this value, we
|
||
increment the bin edge by `size` from `start`
|
||
until we reach or exceed `end`. Defaults to the
|
||
maximum data value. Like `start`, for dates use
|
||
a date string, and for category data `end` is
|
||
based on the category serial numbers.
|
||
size
|
||
Sets the size of each x axis bin. Default
|
||
behavior: If `nbinsx` is 0 or omitted, we
|
||
choose a nice round bin size such that the
|
||
number of bins is about the same as the typical
|
||
number of samples in each bin. If `nbinsx` is
|
||
provided, we choose a nice round bin size
|
||
giving no more than that many bins. For date
|
||
data, use milliseconds or "M<n>" for months, as
|
||
in `axis.dtick`. For category data, the number
|
||
of categories to bin together (always defaults
|
||
to 1).
|
||
start
|
||
Sets the starting value for the x axis bins.
|
||
Defaults to the minimum data value, shifted
|
||
down if necessary to make nice round values and
|
||
to remove ambiguous bin edges. For example, if
|
||
most of the data is integers we shift the bin
|
||
edges 0.5 down, so a `size` of 5 would have a
|
||
default `start` of -0.5, so it is clear that
|
||
0-4 are in the first bin, 5-9 in the second,
|
||
but continuous data gets a start of 0 and bins
|
||
[0,5), [5,10) etc. Dates behave similarly, and
|
||
`start` should be a date string. For category
|
||
data, `start` is based on the category serial
|
||
numbers, and defaults to -0.5.
|
||
|
||
Returns
|
||
-------
|
||
plotly.graph_objs.histogram2d.XBins
|
||
"""
|
||
return self["xbins"]
|
||
|
||
@xbins.setter
|
||
def xbins(self, val):
|
||
self["xbins"] = val
|
||
|
||
# xcalendar
|
||
# ---------
|
||
@property
|
||
def xcalendar(self):
|
||
"""
|
||
Sets the calendar system to use with `x` date data.
|
||
|
||
The 'xcalendar' property is an enumeration that may be specified as:
|
||
- One of the following enumeration values:
|
||
['chinese', 'coptic', 'discworld', 'ethiopian',
|
||
'gregorian', 'hebrew', 'islamic', 'jalali', 'julian',
|
||
'mayan', 'nanakshahi', 'nepali', 'persian', 'taiwan',
|
||
'thai', 'ummalqura']
|
||
|
||
Returns
|
||
-------
|
||
Any
|
||
"""
|
||
return self["xcalendar"]
|
||
|
||
@xcalendar.setter
|
||
def xcalendar(self, val):
|
||
self["xcalendar"] = val
|
||
|
||
# xgap
|
||
# ----
|
||
@property
|
||
def xgap(self):
|
||
"""
|
||
Sets the horizontal gap (in pixels) between bricks.
|
||
|
||
The 'xgap' property is a number and may be specified as:
|
||
- An int or float in the interval [0, inf]
|
||
|
||
Returns
|
||
-------
|
||
int|float
|
||
"""
|
||
return self["xgap"]
|
||
|
||
@xgap.setter
|
||
def xgap(self, val):
|
||
self["xgap"] = val
|
||
|
||
# xhoverformat
|
||
# ------------
|
||
@property
|
||
def xhoverformat(self):
|
||
"""
|
||
Sets the hover text formatting rulefor `x` using d3 formatting
|
||
mini-languages which are very similar to those in Python. For
|
||
numbers, see:
|
||
https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for
|
||
dates see: https://github.com/d3/d3-time-
|
||
format/tree/v2.2.3#locale_format. We add two items to d3's date
|
||
formatter: "%h" for half of the year as a decimal number as
|
||
well as "%{n}f" for fractional seconds with n digits. For
|
||
example, *2016-10-13 09:15:23.456* with tickformat
|
||
"%H~%M~%S.%2f" would display *09~15~23.46*By default the values
|
||
are formatted using `xaxis.hoverformat`.
|
||
|
||
The 'xhoverformat' property is a string and must be specified as:
|
||
- A string
|
||
- A number that will be converted to a string
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["xhoverformat"]
|
||
|
||
@xhoverformat.setter
|
||
def xhoverformat(self, val):
|
||
self["xhoverformat"] = val
|
||
|
||
# xsrc
|
||
# ----
|
||
@property
|
||
def xsrc(self):
|
||
"""
|
||
Sets the source reference on Chart Studio Cloud for `x`.
|
||
|
||
The 'xsrc' property must be specified as a string or
|
||
as a plotly.grid_objs.Column object
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["xsrc"]
|
||
|
||
@xsrc.setter
|
||
def xsrc(self, val):
|
||
self["xsrc"] = val
|
||
|
||
# y
|
||
# -
|
||
@property
|
||
def y(self):
|
||
"""
|
||
Sets the sample data to be binned on the y axis.
|
||
|
||
The 'y' property is an array that may be specified as a tuple,
|
||
list, numpy array, or pandas Series
|
||
|
||
Returns
|
||
-------
|
||
numpy.ndarray
|
||
"""
|
||
return self["y"]
|
||
|
||
@y.setter
|
||
def y(self, val):
|
||
self["y"] = val
|
||
|
||
# yaxis
|
||
# -----
|
||
@property
|
||
def yaxis(self):
|
||
"""
|
||
Sets a reference between this trace's y coordinates and a 2D
|
||
cartesian y axis. If "y" (the default value), the y coordinates
|
||
refer to `layout.yaxis`. If "y2", the y coordinates refer to
|
||
`layout.yaxis2`, and so on.
|
||
|
||
The 'yaxis' property is an identifier of a particular
|
||
subplot, of type 'y', that may be specified as the string 'y'
|
||
optionally followed by an integer >= 1
|
||
(e.g. 'y', 'y1', 'y2', 'y3', etc.)
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["yaxis"]
|
||
|
||
@yaxis.setter
|
||
def yaxis(self, val):
|
||
self["yaxis"] = val
|
||
|
||
# ybingroup
|
||
# ---------
|
||
@property
|
||
def ybingroup(self):
|
||
"""
|
||
Set a group of histogram traces which will have compatible
|
||
y-bin settings. Using `ybingroup`, histogram2d and
|
||
histogram2dcontour traces (on axes of the same axis type) can
|
||
have compatible y-bin settings. Note that the same `ybingroup`
|
||
value can be used to set (1D) histogram `bingroup`
|
||
|
||
The 'ybingroup' property is a string and must be specified as:
|
||
- A string
|
||
- A number that will be converted to a string
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["ybingroup"]
|
||
|
||
@ybingroup.setter
|
||
def ybingroup(self, val):
|
||
self["ybingroup"] = val
|
||
|
||
# ybins
|
||
# -----
|
||
@property
|
||
def ybins(self):
|
||
"""
|
||
The 'ybins' property is an instance of YBins
|
||
that may be specified as:
|
||
- An instance of :class:`plotly.graph_objs.histogram2d.YBins`
|
||
- A dict of string/value properties that will be passed
|
||
to the YBins constructor
|
||
|
||
Supported dict properties:
|
||
|
||
end
|
||
Sets the end value for the y axis bins. The
|
||
last bin may not end exactly at this value, we
|
||
increment the bin edge by `size` from `start`
|
||
until we reach or exceed `end`. Defaults to the
|
||
maximum data value. Like `start`, for dates use
|
||
a date string, and for category data `end` is
|
||
based on the category serial numbers.
|
||
size
|
||
Sets the size of each y axis bin. Default
|
||
behavior: If `nbinsy` is 0 or omitted, we
|
||
choose a nice round bin size such that the
|
||
number of bins is about the same as the typical
|
||
number of samples in each bin. If `nbinsy` is
|
||
provided, we choose a nice round bin size
|
||
giving no more than that many bins. For date
|
||
data, use milliseconds or "M<n>" for months, as
|
||
in `axis.dtick`. For category data, the number
|
||
of categories to bin together (always defaults
|
||
to 1).
|
||
start
|
||
Sets the starting value for the y axis bins.
|
||
Defaults to the minimum data value, shifted
|
||
down if necessary to make nice round values and
|
||
to remove ambiguous bin edges. For example, if
|
||
most of the data is integers we shift the bin
|
||
edges 0.5 down, so a `size` of 5 would have a
|
||
default `start` of -0.5, so it is clear that
|
||
0-4 are in the first bin, 5-9 in the second,
|
||
but continuous data gets a start of 0 and bins
|
||
[0,5), [5,10) etc. Dates behave similarly, and
|
||
`start` should be a date string. For category
|
||
data, `start` is based on the category serial
|
||
numbers, and defaults to -0.5.
|
||
|
||
Returns
|
||
-------
|
||
plotly.graph_objs.histogram2d.YBins
|
||
"""
|
||
return self["ybins"]
|
||
|
||
@ybins.setter
|
||
def ybins(self, val):
|
||
self["ybins"] = val
|
||
|
||
# ycalendar
|
||
# ---------
|
||
@property
|
||
def ycalendar(self):
|
||
"""
|
||
Sets the calendar system to use with `y` date data.
|
||
|
||
The 'ycalendar' property is an enumeration that may be specified as:
|
||
- One of the following enumeration values:
|
||
['chinese', 'coptic', 'discworld', 'ethiopian',
|
||
'gregorian', 'hebrew', 'islamic', 'jalali', 'julian',
|
||
'mayan', 'nanakshahi', 'nepali', 'persian', 'taiwan',
|
||
'thai', 'ummalqura']
|
||
|
||
Returns
|
||
-------
|
||
Any
|
||
"""
|
||
return self["ycalendar"]
|
||
|
||
@ycalendar.setter
|
||
def ycalendar(self, val):
|
||
self["ycalendar"] = val
|
||
|
||
# ygap
|
||
# ----
|
||
@property
|
||
def ygap(self):
|
||
"""
|
||
Sets the vertical gap (in pixels) between bricks.
|
||
|
||
The 'ygap' property is a number and may be specified as:
|
||
- An int or float in the interval [0, inf]
|
||
|
||
Returns
|
||
-------
|
||
int|float
|
||
"""
|
||
return self["ygap"]
|
||
|
||
@ygap.setter
|
||
def ygap(self, val):
|
||
self["ygap"] = val
|
||
|
||
# yhoverformat
|
||
# ------------
|
||
@property
|
||
def yhoverformat(self):
|
||
"""
|
||
Sets the hover text formatting rulefor `y` using d3 formatting
|
||
mini-languages which are very similar to those in Python. For
|
||
numbers, see:
|
||
https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for
|
||
dates see: https://github.com/d3/d3-time-
|
||
format/tree/v2.2.3#locale_format. We add two items to d3's date
|
||
formatter: "%h" for half of the year as a decimal number as
|
||
well as "%{n}f" for fractional seconds with n digits. For
|
||
example, *2016-10-13 09:15:23.456* with tickformat
|
||
"%H~%M~%S.%2f" would display *09~15~23.46*By default the values
|
||
are formatted using `yaxis.hoverformat`.
|
||
|
||
The 'yhoverformat' property is a string and must be specified as:
|
||
- A string
|
||
- A number that will be converted to a string
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["yhoverformat"]
|
||
|
||
@yhoverformat.setter
|
||
def yhoverformat(self, val):
|
||
self["yhoverformat"] = val
|
||
|
||
# ysrc
|
||
# ----
|
||
@property
|
||
def ysrc(self):
|
||
"""
|
||
Sets the source reference on Chart Studio Cloud for `y`.
|
||
|
||
The 'ysrc' property must be specified as a string or
|
||
as a plotly.grid_objs.Column object
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["ysrc"]
|
||
|
||
@ysrc.setter
|
||
def ysrc(self, val):
|
||
self["ysrc"] = val
|
||
|
||
# z
|
||
# -
|
||
@property
|
||
def z(self):
|
||
"""
|
||
Sets the aggregation data.
|
||
|
||
The 'z' property is an array that may be specified as a tuple,
|
||
list, numpy array, or pandas Series
|
||
|
||
Returns
|
||
-------
|
||
numpy.ndarray
|
||
"""
|
||
return self["z"]
|
||
|
||
@z.setter
|
||
def z(self, val):
|
||
self["z"] = val
|
||
|
||
# zauto
|
||
# -----
|
||
@property
|
||
def zauto(self):
|
||
"""
|
||
Determines whether or not the color domain is computed with
|
||
respect to the input data (here in `z`) or the bounds set in
|
||
`zmin` and `zmax` Defaults to `false` when `zmin` and `zmax`
|
||
are set by the user.
|
||
|
||
The 'zauto' property must be specified as a bool
|
||
(either True, or False)
|
||
|
||
Returns
|
||
-------
|
||
bool
|
||
"""
|
||
return self["zauto"]
|
||
|
||
@zauto.setter
|
||
def zauto(self, val):
|
||
self["zauto"] = val
|
||
|
||
# zhoverformat
|
||
# ------------
|
||
@property
|
||
def zhoverformat(self):
|
||
"""
|
||
Sets the hover text formatting rulefor `z` using d3 formatting
|
||
mini-languages which are very similar to those in Python. For
|
||
numbers, see:
|
||
https://github.com/d3/d3-format/tree/v1.4.5#d3-format.By
|
||
default the values are formatted using generic number format.
|
||
|
||
The 'zhoverformat' property is a string and must be specified as:
|
||
- A string
|
||
- A number that will be converted to a string
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["zhoverformat"]
|
||
|
||
@zhoverformat.setter
|
||
def zhoverformat(self, val):
|
||
self["zhoverformat"] = val
|
||
|
||
# zmax
|
||
# ----
|
||
@property
|
||
def zmax(self):
|
||
"""
|
||
Sets the upper bound of the color domain. Value should have the
|
||
same units as in `z` and if set, `zmin` must be set as well.
|
||
|
||
The 'zmax' property is a number and may be specified as:
|
||
- An int or float
|
||
|
||
Returns
|
||
-------
|
||
int|float
|
||
"""
|
||
return self["zmax"]
|
||
|
||
@zmax.setter
|
||
def zmax(self, val):
|
||
self["zmax"] = val
|
||
|
||
# zmid
|
||
# ----
|
||
@property
|
||
def zmid(self):
|
||
"""
|
||
Sets the mid-point of the color domain by scaling `zmin` and/or
|
||
`zmax` to be equidistant to this point. Value should have the
|
||
same units as in `z`. Has no effect when `zauto` is `false`.
|
||
|
||
The 'zmid' property is a number and may be specified as:
|
||
- An int or float
|
||
|
||
Returns
|
||
-------
|
||
int|float
|
||
"""
|
||
return self["zmid"]
|
||
|
||
@zmid.setter
|
||
def zmid(self, val):
|
||
self["zmid"] = val
|
||
|
||
# zmin
|
||
# ----
|
||
@property
|
||
def zmin(self):
|
||
"""
|
||
Sets the lower bound of the color domain. Value should have the
|
||
same units as in `z` and if set, `zmax` must be set as well.
|
||
|
||
The 'zmin' property is a number and may be specified as:
|
||
- An int or float
|
||
|
||
Returns
|
||
-------
|
||
int|float
|
||
"""
|
||
return self["zmin"]
|
||
|
||
@zmin.setter
|
||
def zmin(self, val):
|
||
self["zmin"] = val
|
||
|
||
# zsmooth
|
||
# -------
|
||
@property
|
||
def zsmooth(self):
|
||
"""
|
||
Picks a smoothing algorithm use to smooth `z` data.
|
||
|
||
The 'zsmooth' property is an enumeration that may be specified as:
|
||
- One of the following enumeration values:
|
||
['fast', 'best', False]
|
||
|
||
Returns
|
||
-------
|
||
Any
|
||
"""
|
||
return self["zsmooth"]
|
||
|
||
@zsmooth.setter
|
||
def zsmooth(self, val):
|
||
self["zsmooth"] = val
|
||
|
||
# zsrc
|
||
# ----
|
||
@property
|
||
def zsrc(self):
|
||
"""
|
||
Sets the source reference on Chart Studio Cloud for `z`.
|
||
|
||
The 'zsrc' property must be specified as a string or
|
||
as a plotly.grid_objs.Column object
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["zsrc"]
|
||
|
||
@zsrc.setter
|
||
def zsrc(self, val):
|
||
self["zsrc"] = val
|
||
|
||
# type
|
||
# ----
|
||
@property
|
||
def type(self):
|
||
return self._props["type"]
|
||
|
||
# Self properties description
|
||
# ---------------------------
|
||
@property
|
||
def _prop_descriptions(self):
|
||
return """\
|
||
autobinx
|
||
Obsolete: since v1.42 each bin attribute is auto-
|
||
determined separately and `autobinx` is not needed.
|
||
However, we accept `autobinx: true` or `false` and will
|
||
update `xbins` accordingly before deleting `autobinx`
|
||
from the trace.
|
||
autobiny
|
||
Obsolete: since v1.42 each bin attribute is auto-
|
||
determined separately and `autobiny` is not needed.
|
||
However, we accept `autobiny: true` or `false` and will
|
||
update `ybins` accordingly before deleting `autobiny`
|
||
from the trace.
|
||
autocolorscale
|
||
Determines whether the colorscale is a default palette
|
||
(`autocolorscale: true`) or the palette determined by
|
||
`colorscale`. In case `colorscale` is unspecified or
|
||
`autocolorscale` is true, the default palette will be
|
||
chosen according to whether numbers in the `color`
|
||
array are all positive, all negative or mixed.
|
||
bingroup
|
||
Set the `xbingroup` and `ybingroup` default prefix For
|
||
example, setting a `bingroup` of 1 on two histogram2d
|
||
traces will make them their x-bins and y-bins match
|
||
separately.
|
||
coloraxis
|
||
Sets a reference to a shared color axis. References to
|
||
these shared color axes are "coloraxis", "coloraxis2",
|
||
"coloraxis3", etc. Settings for these shared color axes
|
||
are set in the layout, under `layout.coloraxis`,
|
||
`layout.coloraxis2`, etc. Note that multiple color
|
||
scales can be linked to the same color axis.
|
||
colorbar
|
||
:class:`plotly.graph_objects.histogram2d.ColorBar`
|
||
instance or dict with compatible properties
|
||
colorscale
|
||
Sets the colorscale. The colorscale must be an array
|
||
containing arrays mapping a normalized value to an rgb,
|
||
rgba, hex, hsl, hsv, or named color string. At minimum,
|
||
a mapping for the lowest (0) and highest (1) values are
|
||
required. For example, `[[0, 'rgb(0,0,255)'], [1,
|
||
'rgb(255,0,0)']]`. To control the bounds of the
|
||
colorscale in color space, use `zmin` and `zmax`.
|
||
Alternatively, `colorscale` may be a palette name
|
||
string of the following list: Blackbody,Bluered,Blues,C
|
||
ividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portl
|
||
and,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.
|
||
customdata
|
||
Assigns extra data each datum. This may be useful when
|
||
listening to hover, click and selection events. Note
|
||
that, "scatter" traces also appends customdata items in
|
||
the markers DOM elements
|
||
customdatasrc
|
||
Sets the source reference on Chart Studio Cloud for
|
||
`customdata`.
|
||
histfunc
|
||
Specifies the binning function used for this histogram
|
||
trace. If "count", the histogram values are computed by
|
||
counting the number of values lying inside each bin. If
|
||
"sum", "avg", "min", "max", the histogram values are
|
||
computed using the sum, the average, the minimum or the
|
||
maximum of the values lying inside each bin
|
||
respectively.
|
||
histnorm
|
||
Specifies the type of normalization used for this
|
||
histogram trace. If "", the span of each bar
|
||
corresponds to the number of occurrences (i.e. the
|
||
number of data points lying inside the bins). If
|
||
"percent" / "probability", the span of each bar
|
||
corresponds to the percentage / fraction of occurrences
|
||
with respect to the total number of sample points
|
||
(here, the sum of all bin HEIGHTS equals 100% / 1). If
|
||
"density", the span of each bar corresponds to the
|
||
number of occurrences in a bin divided by the size of
|
||
the bin interval (here, the sum of all bin AREAS equals
|
||
the total number of sample points). If *probability
|
||
density*, the area of each bar corresponds to the
|
||
probability that an event will fall into the
|
||
corresponding bin (here, the sum of all bin AREAS
|
||
equals 1).
|
||
hoverinfo
|
||
Determines which trace information appear on hover. If
|
||
`none` or `skip` are set, no information is displayed
|
||
upon hovering. But, if `none` is set, click and hover
|
||
events are still fired.
|
||
hoverinfosrc
|
||
Sets the source reference on Chart Studio Cloud for
|
||
`hoverinfo`.
|
||
hoverlabel
|
||
:class:`plotly.graph_objects.histogram2d.Hoverlabel`
|
||
instance or dict with compatible properties
|
||
hovertemplate
|
||
Template string used for rendering the information that
|
||
appear on hover box. Note that this will override
|
||
`hoverinfo`. Variables are inserted using %{variable},
|
||
for example "y: %{y}" as well as %{xother}, {%_xother},
|
||
{%_xother_}, {%xother_}. When showing info for several
|
||
points, "xother" will be added to those with different
|
||
x positions from the first point. An underscore before
|
||
or after "(x|y)other" will add a space on that side,
|
||
only when this field is shown. Numbers are formatted
|
||
using d3-format's syntax %{variable:d3-format}, for
|
||
example "Price: %{y:$.2f}".
|
||
https://github.com/d3/d3-format/tree/v1.4.5#d3-format
|
||
for details on the formatting syntax. Dates are
|
||
formatted using d3-time-format's syntax
|
||
%{variable|d3-time-format}, for example "Day:
|
||
%{2019-01-01|%A}". https://github.com/d3/d3-time-
|
||
format/tree/v2.2.3#locale_format for details on the
|
||
date formatting syntax. The variables available in
|
||
`hovertemplate` are the ones emitted as event data
|
||
described at this link
|
||
https://plotly.com/javascript/plotlyjs-events/#event-
|
||
data. Additionally, every attributes that can be
|
||
specified per-point (the ones that are `arrayOk: true`)
|
||
are available. Finally, the template string has access
|
||
to variable `z` Anything contained in tag `<extra>` is
|
||
displayed in the secondary box, for example
|
||
"<extra>{fullData.name}</extra>". To hide the secondary
|
||
box completely, use an empty tag `<extra></extra>`.
|
||
hovertemplatesrc
|
||
Sets the source reference on Chart Studio Cloud for
|
||
`hovertemplate`.
|
||
ids
|
||
Assigns id labels to each datum. These ids for object
|
||
constancy of data points during animation. Should be an
|
||
array of strings, not numbers or any other type.
|
||
idssrc
|
||
Sets the source reference on Chart Studio Cloud for
|
||
`ids`.
|
||
legend
|
||
Sets the reference to a legend to show this trace in.
|
||
References to these legends are "legend", "legend2",
|
||
"legend3", etc. Settings for these legends are set in
|
||
the layout, under `layout.legend`, `layout.legend2`,
|
||
etc.
|
||
legendgroup
|
||
Sets the legend group for this trace. Traces and shapes
|
||
part of the same legend group hide/show at the same
|
||
time when toggling legend items.
|
||
legendgrouptitle
|
||
:class:`plotly.graph_objects.histogram2d.Legendgrouptit
|
||
le` instance or dict with compatible properties
|
||
legendrank
|
||
Sets the legend rank for this trace. Items and groups
|
||
with smaller ranks are presented on top/left side while
|
||
with "reversed" `legend.traceorder` they are on
|
||
bottom/right side. The default legendrank is 1000, so
|
||
that you can use ranks less than 1000 to place certain
|
||
items before all unranked items, and ranks greater than
|
||
1000 to go after all unranked items. When having
|
||
unranked or equal rank items shapes would be displayed
|
||
after traces i.e. according to their order in data and
|
||
layout.
|
||
legendwidth
|
||
Sets the width (in px or fraction) of the legend for
|
||
this trace.
|
||
marker
|
||
:class:`plotly.graph_objects.histogram2d.Marker`
|
||
instance or dict with compatible properties
|
||
meta
|
||
Assigns extra meta information associated with this
|
||
trace that can be used in various text attributes.
|
||
Attributes such as trace `name`, graph, axis and
|
||
colorbar `title.text`, annotation `text`
|
||
`rangeselector`, `updatemenues` and `sliders` `label`
|
||
text all support `meta`. To access the trace `meta`
|
||
values in an attribute in the same trace, simply use
|
||
`%{meta[i]}` where `i` is the index or key of the
|
||
`meta` item in question. To access trace `meta` in
|
||
layout attributes, use `%{data[n[.meta[i]}` where `i`
|
||
is the index or key of the `meta` and `n` is the trace
|
||
index.
|
||
metasrc
|
||
Sets the source reference on Chart Studio Cloud for
|
||
`meta`.
|
||
name
|
||
Sets the trace name. The trace name appears as the
|
||
legend item and on hover.
|
||
nbinsx
|
||
Specifies the maximum number of desired bins. This
|
||
value will be used in an algorithm that will decide the
|
||
optimal bin size such that the histogram best
|
||
visualizes the distribution of the data. Ignored if
|
||
`xbins.size` is provided.
|
||
nbinsy
|
||
Specifies the maximum number of desired bins. This
|
||
value will be used in an algorithm that will decide the
|
||
optimal bin size such that the histogram best
|
||
visualizes the distribution of the data. Ignored if
|
||
`ybins.size` is provided.
|
||
opacity
|
||
Sets the opacity of the trace.
|
||
reversescale
|
||
Reverses the color mapping if true. If true, `zmin`
|
||
will correspond to the last color in the array and
|
||
`zmax` will correspond to the first color.
|
||
showlegend
|
||
Determines whether or not an item corresponding to this
|
||
trace is shown in the legend.
|
||
showscale
|
||
Determines whether or not a colorbar is displayed for
|
||
this trace.
|
||
stream
|
||
:class:`plotly.graph_objects.histogram2d.Stream`
|
||
instance or dict with compatible properties
|
||
textfont
|
||
Sets the text font.
|
||
texttemplate
|
||
Template string used for rendering the information text
|
||
that appear on points. Note that this will override
|
||
`textinfo`. Variables are inserted using %{variable},
|
||
for example "y: %{y}". Numbers are formatted using
|
||
d3-format's syntax %{variable:d3-format}, for example
|
||
"Price: %{y:$.2f}".
|
||
https://github.com/d3/d3-format/tree/v1.4.5#d3-format
|
||
for details on the formatting syntax. Dates are
|
||
formatted using d3-time-format's syntax
|
||
%{variable|d3-time-format}, for example "Day:
|
||
%{2019-01-01|%A}". https://github.com/d3/d3-time-
|
||
format/tree/v2.2.3#locale_format for details on the
|
||
date formatting syntax. Every attributes that can be
|
||
specified per-point (the ones that are `arrayOk: true`)
|
||
are available. Finally, the template string has access
|
||
to variable `z`
|
||
uid
|
||
Assign an id to this trace, Use this to provide object
|
||
constancy between traces during animations and
|
||
transitions.
|
||
uirevision
|
||
Controls persistence of some user-driven changes to the
|
||
trace: `constraintrange` in `parcoords` traces, as well
|
||
as some `editable: true` modifications such as `name`
|
||
and `colorbar.title`. Defaults to `layout.uirevision`.
|
||
Note that other user-driven trace attribute changes are
|
||
controlled by `layout` attributes: `trace.visible` is
|
||
controlled by `layout.legend.uirevision`,
|
||
`selectedpoints` is controlled by
|
||
`layout.selectionrevision`, and `colorbar.(x|y)`
|
||
(accessible with `config: {editable: true}`) is
|
||
controlled by `layout.editrevision`. Trace changes are
|
||
tracked by `uid`, which only falls back on trace index
|
||
if no `uid` is provided. So if your app can add/remove
|
||
traces before the end of the `data` array, such that
|
||
the same trace has a different index, you can still
|
||
preserve user-driven changes if you give each trace a
|
||
`uid` that stays with it as it moves.
|
||
visible
|
||
Determines whether or not this trace is visible. If
|
||
"legendonly", the trace is not drawn, but can appear as
|
||
a legend item (provided that the legend itself is
|
||
visible).
|
||
x
|
||
Sets the sample data to be binned on the x axis.
|
||
xaxis
|
||
Sets a reference between this trace's x coordinates and
|
||
a 2D cartesian x axis. If "x" (the default value), the
|
||
x coordinates refer to `layout.xaxis`. If "x2", the x
|
||
coordinates refer to `layout.xaxis2`, and so on.
|
||
xbingroup
|
||
Set a group of histogram traces which will have
|
||
compatible x-bin settings. Using `xbingroup`,
|
||
histogram2d and histogram2dcontour traces (on axes of
|
||
the same axis type) can have compatible x-bin settings.
|
||
Note that the same `xbingroup` value can be used to set
|
||
(1D) histogram `bingroup`
|
||
xbins
|
||
:class:`plotly.graph_objects.histogram2d.XBins`
|
||
instance or dict with compatible properties
|
||
xcalendar
|
||
Sets the calendar system to use with `x` date data.
|
||
xgap
|
||
Sets the horizontal gap (in pixels) between bricks.
|
||
xhoverformat
|
||
Sets the hover text formatting rulefor `x` using d3
|
||
formatting mini-languages which are very similar to
|
||
those in Python. For numbers, see:
|
||
https://github.com/d3/d3-format/tree/v1.4.5#d3-format.
|
||
And for dates see: https://github.com/d3/d3-time-
|
||
format/tree/v2.2.3#locale_format. We add two items to
|
||
d3's date formatter: "%h" for half of the year as a
|
||
decimal number as well as "%{n}f" for fractional
|
||
seconds with n digits. For example, *2016-10-13
|
||
09:15:23.456* with tickformat "%H~%M~%S.%2f" would
|
||
display *09~15~23.46*By default the values are
|
||
formatted using `xaxis.hoverformat`.
|
||
xsrc
|
||
Sets the source reference on Chart Studio Cloud for
|
||
`x`.
|
||
y
|
||
Sets the sample data to be binned on the y axis.
|
||
yaxis
|
||
Sets a reference between this trace's y coordinates and
|
||
a 2D cartesian y axis. If "y" (the default value), the
|
||
y coordinates refer to `layout.yaxis`. If "y2", the y
|
||
coordinates refer to `layout.yaxis2`, and so on.
|
||
ybingroup
|
||
Set a group of histogram traces which will have
|
||
compatible y-bin settings. Using `ybingroup`,
|
||
histogram2d and histogram2dcontour traces (on axes of
|
||
the same axis type) can have compatible y-bin settings.
|
||
Note that the same `ybingroup` value can be used to set
|
||
(1D) histogram `bingroup`
|
||
ybins
|
||
:class:`plotly.graph_objects.histogram2d.YBins`
|
||
instance or dict with compatible properties
|
||
ycalendar
|
||
Sets the calendar system to use with `y` date data.
|
||
ygap
|
||
Sets the vertical gap (in pixels) between bricks.
|
||
yhoverformat
|
||
Sets the hover text formatting rulefor `y` using d3
|
||
formatting mini-languages which are very similar to
|
||
those in Python. For numbers, see:
|
||
https://github.com/d3/d3-format/tree/v1.4.5#d3-format.
|
||
And for dates see: https://github.com/d3/d3-time-
|
||
format/tree/v2.2.3#locale_format. We add two items to
|
||
d3's date formatter: "%h" for half of the year as a
|
||
decimal number as well as "%{n}f" for fractional
|
||
seconds with n digits. For example, *2016-10-13
|
||
09:15:23.456* with tickformat "%H~%M~%S.%2f" would
|
||
display *09~15~23.46*By default the values are
|
||
formatted using `yaxis.hoverformat`.
|
||
ysrc
|
||
Sets the source reference on Chart Studio Cloud for
|
||
`y`.
|
||
z
|
||
Sets the aggregation data.
|
||
zauto
|
||
Determines whether or not the color domain is computed
|
||
with respect to the input data (here in `z`) or the
|
||
bounds set in `zmin` and `zmax` Defaults to `false`
|
||
when `zmin` and `zmax` are set by the user.
|
||
zhoverformat
|
||
Sets the hover text formatting rulefor `z` using d3
|
||
formatting mini-languages which are very similar to
|
||
those in Python. For numbers, see: https://github.com/d
|
||
3/d3-format/tree/v1.4.5#d3-format.By default the values
|
||
are formatted using generic number format.
|
||
zmax
|
||
Sets the upper bound of the color domain. Value should
|
||
have the same units as in `z` and if set, `zmin` must
|
||
be set as well.
|
||
zmid
|
||
Sets the mid-point of the color domain by scaling
|
||
`zmin` and/or `zmax` to be equidistant to this point.
|
||
Value should have the same units as in `z`. Has no
|
||
effect when `zauto` is `false`.
|
||
zmin
|
||
Sets the lower bound of the color domain. Value should
|
||
have the same units as in `z` and if set, `zmax` must
|
||
be set as well.
|
||
zsmooth
|
||
Picks a smoothing algorithm use to smooth `z` data.
|
||
zsrc
|
||
Sets the source reference on Chart Studio Cloud for
|
||
`z`.
|
||
"""
|
||
|
||
def __init__(
|
||
self,
|
||
arg=None,
|
||
autobinx=None,
|
||
autobiny=None,
|
||
autocolorscale=None,
|
||
bingroup=None,
|
||
coloraxis=None,
|
||
colorbar=None,
|
||
colorscale=None,
|
||
customdata=None,
|
||
customdatasrc=None,
|
||
histfunc=None,
|
||
histnorm=None,
|
||
hoverinfo=None,
|
||
hoverinfosrc=None,
|
||
hoverlabel=None,
|
||
hovertemplate=None,
|
||
hovertemplatesrc=None,
|
||
ids=None,
|
||
idssrc=None,
|
||
legend=None,
|
||
legendgroup=None,
|
||
legendgrouptitle=None,
|
||
legendrank=None,
|
||
legendwidth=None,
|
||
marker=None,
|
||
meta=None,
|
||
metasrc=None,
|
||
name=None,
|
||
nbinsx=None,
|
||
nbinsy=None,
|
||
opacity=None,
|
||
reversescale=None,
|
||
showlegend=None,
|
||
showscale=None,
|
||
stream=None,
|
||
textfont=None,
|
||
texttemplate=None,
|
||
uid=None,
|
||
uirevision=None,
|
||
visible=None,
|
||
x=None,
|
||
xaxis=None,
|
||
xbingroup=None,
|
||
xbins=None,
|
||
xcalendar=None,
|
||
xgap=None,
|
||
xhoverformat=None,
|
||
xsrc=None,
|
||
y=None,
|
||
yaxis=None,
|
||
ybingroup=None,
|
||
ybins=None,
|
||
ycalendar=None,
|
||
ygap=None,
|
||
yhoverformat=None,
|
||
ysrc=None,
|
||
z=None,
|
||
zauto=None,
|
||
zhoverformat=None,
|
||
zmax=None,
|
||
zmid=None,
|
||
zmin=None,
|
||
zsmooth=None,
|
||
zsrc=None,
|
||
**kwargs,
|
||
):
|
||
"""
|
||
Construct a new Histogram2d object
|
||
|
||
The sample data from which statistics are computed is set in
|
||
`x` and `y` (where `x` and `y` represent marginal
|
||
distributions, binning is set in `xbins` and `ybins` in this
|
||
case) or `z` (where `z` represent the 2D distribution and
|
||
binning set, binning is set by `x` and `y` in this case). The
|
||
resulting distribution is visualized as a heatmap.
|
||
|
||
Parameters
|
||
----------
|
||
arg
|
||
dict of properties compatible with this constructor or
|
||
an instance of :class:`plotly.graph_objs.Histogram2d`
|
||
autobinx
|
||
Obsolete: since v1.42 each bin attribute is auto-
|
||
determined separately and `autobinx` is not needed.
|
||
However, we accept `autobinx: true` or `false` and will
|
||
update `xbins` accordingly before deleting `autobinx`
|
||
from the trace.
|
||
autobiny
|
||
Obsolete: since v1.42 each bin attribute is auto-
|
||
determined separately and `autobiny` is not needed.
|
||
However, we accept `autobiny: true` or `false` and will
|
||
update `ybins` accordingly before deleting `autobiny`
|
||
from the trace.
|
||
autocolorscale
|
||
Determines whether the colorscale is a default palette
|
||
(`autocolorscale: true`) or the palette determined by
|
||
`colorscale`. In case `colorscale` is unspecified or
|
||
`autocolorscale` is true, the default palette will be
|
||
chosen according to whether numbers in the `color`
|
||
array are all positive, all negative or mixed.
|
||
bingroup
|
||
Set the `xbingroup` and `ybingroup` default prefix For
|
||
example, setting a `bingroup` of 1 on two histogram2d
|
||
traces will make them their x-bins and y-bins match
|
||
separately.
|
||
coloraxis
|
||
Sets a reference to a shared color axis. References to
|
||
these shared color axes are "coloraxis", "coloraxis2",
|
||
"coloraxis3", etc. Settings for these shared color axes
|
||
are set in the layout, under `layout.coloraxis`,
|
||
`layout.coloraxis2`, etc. Note that multiple color
|
||
scales can be linked to the same color axis.
|
||
colorbar
|
||
:class:`plotly.graph_objects.histogram2d.ColorBar`
|
||
instance or dict with compatible properties
|
||
colorscale
|
||
Sets the colorscale. The colorscale must be an array
|
||
containing arrays mapping a normalized value to an rgb,
|
||
rgba, hex, hsl, hsv, or named color string. At minimum,
|
||
a mapping for the lowest (0) and highest (1) values are
|
||
required. For example, `[[0, 'rgb(0,0,255)'], [1,
|
||
'rgb(255,0,0)']]`. To control the bounds of the
|
||
colorscale in color space, use `zmin` and `zmax`.
|
||
Alternatively, `colorscale` may be a palette name
|
||
string of the following list: Blackbody,Bluered,Blues,C
|
||
ividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portl
|
||
and,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.
|
||
customdata
|
||
Assigns extra data each datum. This may be useful when
|
||
listening to hover, click and selection events. Note
|
||
that, "scatter" traces also appends customdata items in
|
||
the markers DOM elements
|
||
customdatasrc
|
||
Sets the source reference on Chart Studio Cloud for
|
||
`customdata`.
|
||
histfunc
|
||
Specifies the binning function used for this histogram
|
||
trace. If "count", the histogram values are computed by
|
||
counting the number of values lying inside each bin. If
|
||
"sum", "avg", "min", "max", the histogram values are
|
||
computed using the sum, the average, the minimum or the
|
||
maximum of the values lying inside each bin
|
||
respectively.
|
||
histnorm
|
||
Specifies the type of normalization used for this
|
||
histogram trace. If "", the span of each bar
|
||
corresponds to the number of occurrences (i.e. the
|
||
number of data points lying inside the bins). If
|
||
"percent" / "probability", the span of each bar
|
||
corresponds to the percentage / fraction of occurrences
|
||
with respect to the total number of sample points
|
||
(here, the sum of all bin HEIGHTS equals 100% / 1). If
|
||
"density", the span of each bar corresponds to the
|
||
number of occurrences in a bin divided by the size of
|
||
the bin interval (here, the sum of all bin AREAS equals
|
||
the total number of sample points). If *probability
|
||
density*, the area of each bar corresponds to the
|
||
probability that an event will fall into the
|
||
corresponding bin (here, the sum of all bin AREAS
|
||
equals 1).
|
||
hoverinfo
|
||
Determines which trace information appear on hover. If
|
||
`none` or `skip` are set, no information is displayed
|
||
upon hovering. But, if `none` is set, click and hover
|
||
events are still fired.
|
||
hoverinfosrc
|
||
Sets the source reference on Chart Studio Cloud for
|
||
`hoverinfo`.
|
||
hoverlabel
|
||
:class:`plotly.graph_objects.histogram2d.Hoverlabel`
|
||
instance or dict with compatible properties
|
||
hovertemplate
|
||
Template string used for rendering the information that
|
||
appear on hover box. Note that this will override
|
||
`hoverinfo`. Variables are inserted using %{variable},
|
||
for example "y: %{y}" as well as %{xother}, {%_xother},
|
||
{%_xother_}, {%xother_}. When showing info for several
|
||
points, "xother" will be added to those with different
|
||
x positions from the first point. An underscore before
|
||
or after "(x|y)other" will add a space on that side,
|
||
only when this field is shown. Numbers are formatted
|
||
using d3-format's syntax %{variable:d3-format}, for
|
||
example "Price: %{y:$.2f}".
|
||
https://github.com/d3/d3-format/tree/v1.4.5#d3-format
|
||
for details on the formatting syntax. Dates are
|
||
formatted using d3-time-format's syntax
|
||
%{variable|d3-time-format}, for example "Day:
|
||
%{2019-01-01|%A}". https://github.com/d3/d3-time-
|
||
format/tree/v2.2.3#locale_format for details on the
|
||
date formatting syntax. The variables available in
|
||
`hovertemplate` are the ones emitted as event data
|
||
described at this link
|
||
https://plotly.com/javascript/plotlyjs-events/#event-
|
||
data. Additionally, every attributes that can be
|
||
specified per-point (the ones that are `arrayOk: true`)
|
||
are available. Finally, the template string has access
|
||
to variable `z` Anything contained in tag `<extra>` is
|
||
displayed in the secondary box, for example
|
||
"<extra>{fullData.name}</extra>". To hide the secondary
|
||
box completely, use an empty tag `<extra></extra>`.
|
||
hovertemplatesrc
|
||
Sets the source reference on Chart Studio Cloud for
|
||
`hovertemplate`.
|
||
ids
|
||
Assigns id labels to each datum. These ids for object
|
||
constancy of data points during animation. Should be an
|
||
array of strings, not numbers or any other type.
|
||
idssrc
|
||
Sets the source reference on Chart Studio Cloud for
|
||
`ids`.
|
||
legend
|
||
Sets the reference to a legend to show this trace in.
|
||
References to these legends are "legend", "legend2",
|
||
"legend3", etc. Settings for these legends are set in
|
||
the layout, under `layout.legend`, `layout.legend2`,
|
||
etc.
|
||
legendgroup
|
||
Sets the legend group for this trace. Traces and shapes
|
||
part of the same legend group hide/show at the same
|
||
time when toggling legend items.
|
||
legendgrouptitle
|
||
:class:`plotly.graph_objects.histogram2d.Legendgrouptit
|
||
le` instance or dict with compatible properties
|
||
legendrank
|
||
Sets the legend rank for this trace. Items and groups
|
||
with smaller ranks are presented on top/left side while
|
||
with "reversed" `legend.traceorder` they are on
|
||
bottom/right side. The default legendrank is 1000, so
|
||
that you can use ranks less than 1000 to place certain
|
||
items before all unranked items, and ranks greater than
|
||
1000 to go after all unranked items. When having
|
||
unranked or equal rank items shapes would be displayed
|
||
after traces i.e. according to their order in data and
|
||
layout.
|
||
legendwidth
|
||
Sets the width (in px or fraction) of the legend for
|
||
this trace.
|
||
marker
|
||
:class:`plotly.graph_objects.histogram2d.Marker`
|
||
instance or dict with compatible properties
|
||
meta
|
||
Assigns extra meta information associated with this
|
||
trace that can be used in various text attributes.
|
||
Attributes such as trace `name`, graph, axis and
|
||
colorbar `title.text`, annotation `text`
|
||
`rangeselector`, `updatemenues` and `sliders` `label`
|
||
text all support `meta`. To access the trace `meta`
|
||
values in an attribute in the same trace, simply use
|
||
`%{meta[i]}` where `i` is the index or key of the
|
||
`meta` item in question. To access trace `meta` in
|
||
layout attributes, use `%{data[n[.meta[i]}` where `i`
|
||
is the index or key of the `meta` and `n` is the trace
|
||
index.
|
||
metasrc
|
||
Sets the source reference on Chart Studio Cloud for
|
||
`meta`.
|
||
name
|
||
Sets the trace name. The trace name appears as the
|
||
legend item and on hover.
|
||
nbinsx
|
||
Specifies the maximum number of desired bins. This
|
||
value will be used in an algorithm that will decide the
|
||
optimal bin size such that the histogram best
|
||
visualizes the distribution of the data. Ignored if
|
||
`xbins.size` is provided.
|
||
nbinsy
|
||
Specifies the maximum number of desired bins. This
|
||
value will be used in an algorithm that will decide the
|
||
optimal bin size such that the histogram best
|
||
visualizes the distribution of the data. Ignored if
|
||
`ybins.size` is provided.
|
||
opacity
|
||
Sets the opacity of the trace.
|
||
reversescale
|
||
Reverses the color mapping if true. If true, `zmin`
|
||
will correspond to the last color in the array and
|
||
`zmax` will correspond to the first color.
|
||
showlegend
|
||
Determines whether or not an item corresponding to this
|
||
trace is shown in the legend.
|
||
showscale
|
||
Determines whether or not a colorbar is displayed for
|
||
this trace.
|
||
stream
|
||
:class:`plotly.graph_objects.histogram2d.Stream`
|
||
instance or dict with compatible properties
|
||
textfont
|
||
Sets the text font.
|
||
texttemplate
|
||
Template string used for rendering the information text
|
||
that appear on points. Note that this will override
|
||
`textinfo`. Variables are inserted using %{variable},
|
||
for example "y: %{y}". Numbers are formatted using
|
||
d3-format's syntax %{variable:d3-format}, for example
|
||
"Price: %{y:$.2f}".
|
||
https://github.com/d3/d3-format/tree/v1.4.5#d3-format
|
||
for details on the formatting syntax. Dates are
|
||
formatted using d3-time-format's syntax
|
||
%{variable|d3-time-format}, for example "Day:
|
||
%{2019-01-01|%A}". https://github.com/d3/d3-time-
|
||
format/tree/v2.2.3#locale_format for details on the
|
||
date formatting syntax. Every attributes that can be
|
||
specified per-point (the ones that are `arrayOk: true`)
|
||
are available. Finally, the template string has access
|
||
to variable `z`
|
||
uid
|
||
Assign an id to this trace, Use this to provide object
|
||
constancy between traces during animations and
|
||
transitions.
|
||
uirevision
|
||
Controls persistence of some user-driven changes to the
|
||
trace: `constraintrange` in `parcoords` traces, as well
|
||
as some `editable: true` modifications such as `name`
|
||
and `colorbar.title`. Defaults to `layout.uirevision`.
|
||
Note that other user-driven trace attribute changes are
|
||
controlled by `layout` attributes: `trace.visible` is
|
||
controlled by `layout.legend.uirevision`,
|
||
`selectedpoints` is controlled by
|
||
`layout.selectionrevision`, and `colorbar.(x|y)`
|
||
(accessible with `config: {editable: true}`) is
|
||
controlled by `layout.editrevision`. Trace changes are
|
||
tracked by `uid`, which only falls back on trace index
|
||
if no `uid` is provided. So if your app can add/remove
|
||
traces before the end of the `data` array, such that
|
||
the same trace has a different index, you can still
|
||
preserve user-driven changes if you give each trace a
|
||
`uid` that stays with it as it moves.
|
||
visible
|
||
Determines whether or not this trace is visible. If
|
||
"legendonly", the trace is not drawn, but can appear as
|
||
a legend item (provided that the legend itself is
|
||
visible).
|
||
x
|
||
Sets the sample data to be binned on the x axis.
|
||
xaxis
|
||
Sets a reference between this trace's x coordinates and
|
||
a 2D cartesian x axis. If "x" (the default value), the
|
||
x coordinates refer to `layout.xaxis`. If "x2", the x
|
||
coordinates refer to `layout.xaxis2`, and so on.
|
||
xbingroup
|
||
Set a group of histogram traces which will have
|
||
compatible x-bin settings. Using `xbingroup`,
|
||
histogram2d and histogram2dcontour traces (on axes of
|
||
the same axis type) can have compatible x-bin settings.
|
||
Note that the same `xbingroup` value can be used to set
|
||
(1D) histogram `bingroup`
|
||
xbins
|
||
:class:`plotly.graph_objects.histogram2d.XBins`
|
||
instance or dict with compatible properties
|
||
xcalendar
|
||
Sets the calendar system to use with `x` date data.
|
||
xgap
|
||
Sets the horizontal gap (in pixels) between bricks.
|
||
xhoverformat
|
||
Sets the hover text formatting rulefor `x` using d3
|
||
formatting mini-languages which are very similar to
|
||
those in Python. For numbers, see:
|
||
https://github.com/d3/d3-format/tree/v1.4.5#d3-format.
|
||
And for dates see: https://github.com/d3/d3-time-
|
||
format/tree/v2.2.3#locale_format. We add two items to
|
||
d3's date formatter: "%h" for half of the year as a
|
||
decimal number as well as "%{n}f" for fractional
|
||
seconds with n digits. For example, *2016-10-13
|
||
09:15:23.456* with tickformat "%H~%M~%S.%2f" would
|
||
display *09~15~23.46*By default the values are
|
||
formatted using `xaxis.hoverformat`.
|
||
xsrc
|
||
Sets the source reference on Chart Studio Cloud for
|
||
`x`.
|
||
y
|
||
Sets the sample data to be binned on the y axis.
|
||
yaxis
|
||
Sets a reference between this trace's y coordinates and
|
||
a 2D cartesian y axis. If "y" (the default value), the
|
||
y coordinates refer to `layout.yaxis`. If "y2", the y
|
||
coordinates refer to `layout.yaxis2`, and so on.
|
||
ybingroup
|
||
Set a group of histogram traces which will have
|
||
compatible y-bin settings. Using `ybingroup`,
|
||
histogram2d and histogram2dcontour traces (on axes of
|
||
the same axis type) can have compatible y-bin settings.
|
||
Note that the same `ybingroup` value can be used to set
|
||
(1D) histogram `bingroup`
|
||
ybins
|
||
:class:`plotly.graph_objects.histogram2d.YBins`
|
||
instance or dict with compatible properties
|
||
ycalendar
|
||
Sets the calendar system to use with `y` date data.
|
||
ygap
|
||
Sets the vertical gap (in pixels) between bricks.
|
||
yhoverformat
|
||
Sets the hover text formatting rulefor `y` using d3
|
||
formatting mini-languages which are very similar to
|
||
those in Python. For numbers, see:
|
||
https://github.com/d3/d3-format/tree/v1.4.5#d3-format.
|
||
And for dates see: https://github.com/d3/d3-time-
|
||
format/tree/v2.2.3#locale_format. We add two items to
|
||
d3's date formatter: "%h" for half of the year as a
|
||
decimal number as well as "%{n}f" for fractional
|
||
seconds with n digits. For example, *2016-10-13
|
||
09:15:23.456* with tickformat "%H~%M~%S.%2f" would
|
||
display *09~15~23.46*By default the values are
|
||
formatted using `yaxis.hoverformat`.
|
||
ysrc
|
||
Sets the source reference on Chart Studio Cloud for
|
||
`y`.
|
||
z
|
||
Sets the aggregation data.
|
||
zauto
|
||
Determines whether or not the color domain is computed
|
||
with respect to the input data (here in `z`) or the
|
||
bounds set in `zmin` and `zmax` Defaults to `false`
|
||
when `zmin` and `zmax` are set by the user.
|
||
zhoverformat
|
||
Sets the hover text formatting rulefor `z` using d3
|
||
formatting mini-languages which are very similar to
|
||
those in Python. For numbers, see: https://github.com/d
|
||
3/d3-format/tree/v1.4.5#d3-format.By default the values
|
||
are formatted using generic number format.
|
||
zmax
|
||
Sets the upper bound of the color domain. Value should
|
||
have the same units as in `z` and if set, `zmin` must
|
||
be set as well.
|
||
zmid
|
||
Sets the mid-point of the color domain by scaling
|
||
`zmin` and/or `zmax` to be equidistant to this point.
|
||
Value should have the same units as in `z`. Has no
|
||
effect when `zauto` is `false`.
|
||
zmin
|
||
Sets the lower bound of the color domain. Value should
|
||
have the same units as in `z` and if set, `zmax` must
|
||
be set as well.
|
||
zsmooth
|
||
Picks a smoothing algorithm use to smooth `z` data.
|
||
zsrc
|
||
Sets the source reference on Chart Studio Cloud for
|
||
`z`.
|
||
|
||
Returns
|
||
-------
|
||
Histogram2d
|
||
"""
|
||
super(Histogram2d, self).__init__("histogram2d")
|
||
|
||
if "_parent" in kwargs:
|
||
self._parent = kwargs["_parent"]
|
||
return
|
||
|
||
# Validate arg
|
||
# ------------
|
||
if arg is None:
|
||
arg = {}
|
||
elif isinstance(arg, self.__class__):
|
||
arg = arg.to_plotly_json()
|
||
elif isinstance(arg, dict):
|
||
arg = _copy.copy(arg)
|
||
else:
|
||
raise ValueError(
|
||
"""\
|
||
The first argument to the plotly.graph_objs.Histogram2d
|
||
constructor must be a dict or
|
||
an instance of :class:`plotly.graph_objs.Histogram2d`"""
|
||
)
|
||
|
||
# Handle skip_invalid
|
||
# -------------------
|
||
self._skip_invalid = kwargs.pop("skip_invalid", False)
|
||
self._validate = kwargs.pop("_validate", True)
|
||
|
||
# Populate data dict with properties
|
||
# ----------------------------------
|
||
_v = arg.pop("autobinx", None)
|
||
_v = autobinx if autobinx is not None else _v
|
||
if _v is not None:
|
||
self["autobinx"] = _v
|
||
_v = arg.pop("autobiny", None)
|
||
_v = autobiny if autobiny is not None else _v
|
||
if _v is not None:
|
||
self["autobiny"] = _v
|
||
_v = arg.pop("autocolorscale", None)
|
||
_v = autocolorscale if autocolorscale is not None else _v
|
||
if _v is not None:
|
||
self["autocolorscale"] = _v
|
||
_v = arg.pop("bingroup", None)
|
||
_v = bingroup if bingroup is not None else _v
|
||
if _v is not None:
|
||
self["bingroup"] = _v
|
||
_v = arg.pop("coloraxis", None)
|
||
_v = coloraxis if coloraxis is not None else _v
|
||
if _v is not None:
|
||
self["coloraxis"] = _v
|
||
_v = arg.pop("colorbar", None)
|
||
_v = colorbar if colorbar is not None else _v
|
||
if _v is not None:
|
||
self["colorbar"] = _v
|
||
_v = arg.pop("colorscale", None)
|
||
_v = colorscale if colorscale is not None else _v
|
||
if _v is not None:
|
||
self["colorscale"] = _v
|
||
_v = arg.pop("customdata", None)
|
||
_v = customdata if customdata is not None else _v
|
||
if _v is not None:
|
||
self["customdata"] = _v
|
||
_v = arg.pop("customdatasrc", None)
|
||
_v = customdatasrc if customdatasrc is not None else _v
|
||
if _v is not None:
|
||
self["customdatasrc"] = _v
|
||
_v = arg.pop("histfunc", None)
|
||
_v = histfunc if histfunc is not None else _v
|
||
if _v is not None:
|
||
self["histfunc"] = _v
|
||
_v = arg.pop("histnorm", None)
|
||
_v = histnorm if histnorm is not None else _v
|
||
if _v is not None:
|
||
self["histnorm"] = _v
|
||
_v = arg.pop("hoverinfo", None)
|
||
_v = hoverinfo if hoverinfo is not None else _v
|
||
if _v is not None:
|
||
self["hoverinfo"] = _v
|
||
_v = arg.pop("hoverinfosrc", None)
|
||
_v = hoverinfosrc if hoverinfosrc is not None else _v
|
||
if _v is not None:
|
||
self["hoverinfosrc"] = _v
|
||
_v = arg.pop("hoverlabel", None)
|
||
_v = hoverlabel if hoverlabel is not None else _v
|
||
if _v is not None:
|
||
self["hoverlabel"] = _v
|
||
_v = arg.pop("hovertemplate", None)
|
||
_v = hovertemplate if hovertemplate is not None else _v
|
||
if _v is not None:
|
||
self["hovertemplate"] = _v
|
||
_v = arg.pop("hovertemplatesrc", None)
|
||
_v = hovertemplatesrc if hovertemplatesrc is not None else _v
|
||
if _v is not None:
|
||
self["hovertemplatesrc"] = _v
|
||
_v = arg.pop("ids", None)
|
||
_v = ids if ids is not None else _v
|
||
if _v is not None:
|
||
self["ids"] = _v
|
||
_v = arg.pop("idssrc", None)
|
||
_v = idssrc if idssrc is not None else _v
|
||
if _v is not None:
|
||
self["idssrc"] = _v
|
||
_v = arg.pop("legend", None)
|
||
_v = legend if legend is not None else _v
|
||
if _v is not None:
|
||
self["legend"] = _v
|
||
_v = arg.pop("legendgroup", None)
|
||
_v = legendgroup if legendgroup is not None else _v
|
||
if _v is not None:
|
||
self["legendgroup"] = _v
|
||
_v = arg.pop("legendgrouptitle", None)
|
||
_v = legendgrouptitle if legendgrouptitle is not None else _v
|
||
if _v is not None:
|
||
self["legendgrouptitle"] = _v
|
||
_v = arg.pop("legendrank", None)
|
||
_v = legendrank if legendrank is not None else _v
|
||
if _v is not None:
|
||
self["legendrank"] = _v
|
||
_v = arg.pop("legendwidth", None)
|
||
_v = legendwidth if legendwidth is not None else _v
|
||
if _v is not None:
|
||
self["legendwidth"] = _v
|
||
_v = arg.pop("marker", None)
|
||
_v = marker if marker is not None else _v
|
||
if _v is not None:
|
||
self["marker"] = _v
|
||
_v = arg.pop("meta", None)
|
||
_v = meta if meta is not None else _v
|
||
if _v is not None:
|
||
self["meta"] = _v
|
||
_v = arg.pop("metasrc", None)
|
||
_v = metasrc if metasrc is not None else _v
|
||
if _v is not None:
|
||
self["metasrc"] = _v
|
||
_v = arg.pop("name", None)
|
||
_v = name if name is not None else _v
|
||
if _v is not None:
|
||
self["name"] = _v
|
||
_v = arg.pop("nbinsx", None)
|
||
_v = nbinsx if nbinsx is not None else _v
|
||
if _v is not None:
|
||
self["nbinsx"] = _v
|
||
_v = arg.pop("nbinsy", None)
|
||
_v = nbinsy if nbinsy is not None else _v
|
||
if _v is not None:
|
||
self["nbinsy"] = _v
|
||
_v = arg.pop("opacity", None)
|
||
_v = opacity if opacity is not None else _v
|
||
if _v is not None:
|
||
self["opacity"] = _v
|
||
_v = arg.pop("reversescale", None)
|
||
_v = reversescale if reversescale is not None else _v
|
||
if _v is not None:
|
||
self["reversescale"] = _v
|
||
_v = arg.pop("showlegend", None)
|
||
_v = showlegend if showlegend is not None else _v
|
||
if _v is not None:
|
||
self["showlegend"] = _v
|
||
_v = arg.pop("showscale", None)
|
||
_v = showscale if showscale is not None else _v
|
||
if _v is not None:
|
||
self["showscale"] = _v
|
||
_v = arg.pop("stream", None)
|
||
_v = stream if stream is not None else _v
|
||
if _v is not None:
|
||
self["stream"] = _v
|
||
_v = arg.pop("textfont", None)
|
||
_v = textfont if textfont is not None else _v
|
||
if _v is not None:
|
||
self["textfont"] = _v
|
||
_v = arg.pop("texttemplate", None)
|
||
_v = texttemplate if texttemplate is not None else _v
|
||
if _v is not None:
|
||
self["texttemplate"] = _v
|
||
_v = arg.pop("uid", None)
|
||
_v = uid if uid is not None else _v
|
||
if _v is not None:
|
||
self["uid"] = _v
|
||
_v = arg.pop("uirevision", None)
|
||
_v = uirevision if uirevision is not None else _v
|
||
if _v is not None:
|
||
self["uirevision"] = _v
|
||
_v = arg.pop("visible", None)
|
||
_v = visible if visible is not None else _v
|
||
if _v is not None:
|
||
self["visible"] = _v
|
||
_v = arg.pop("x", None)
|
||
_v = x if x is not None else _v
|
||
if _v is not None:
|
||
self["x"] = _v
|
||
_v = arg.pop("xaxis", None)
|
||
_v = xaxis if xaxis is not None else _v
|
||
if _v is not None:
|
||
self["xaxis"] = _v
|
||
_v = arg.pop("xbingroup", None)
|
||
_v = xbingroup if xbingroup is not None else _v
|
||
if _v is not None:
|
||
self["xbingroup"] = _v
|
||
_v = arg.pop("xbins", None)
|
||
_v = xbins if xbins is not None else _v
|
||
if _v is not None:
|
||
self["xbins"] = _v
|
||
_v = arg.pop("xcalendar", None)
|
||
_v = xcalendar if xcalendar is not None else _v
|
||
if _v is not None:
|
||
self["xcalendar"] = _v
|
||
_v = arg.pop("xgap", None)
|
||
_v = xgap if xgap is not None else _v
|
||
if _v is not None:
|
||
self["xgap"] = _v
|
||
_v = arg.pop("xhoverformat", None)
|
||
_v = xhoverformat if xhoverformat is not None else _v
|
||
if _v is not None:
|
||
self["xhoverformat"] = _v
|
||
_v = arg.pop("xsrc", None)
|
||
_v = xsrc if xsrc is not None else _v
|
||
if _v is not None:
|
||
self["xsrc"] = _v
|
||
_v = arg.pop("y", None)
|
||
_v = y if y is not None else _v
|
||
if _v is not None:
|
||
self["y"] = _v
|
||
_v = arg.pop("yaxis", None)
|
||
_v = yaxis if yaxis is not None else _v
|
||
if _v is not None:
|
||
self["yaxis"] = _v
|
||
_v = arg.pop("ybingroup", None)
|
||
_v = ybingroup if ybingroup is not None else _v
|
||
if _v is not None:
|
||
self["ybingroup"] = _v
|
||
_v = arg.pop("ybins", None)
|
||
_v = ybins if ybins is not None else _v
|
||
if _v is not None:
|
||
self["ybins"] = _v
|
||
_v = arg.pop("ycalendar", None)
|
||
_v = ycalendar if ycalendar is not None else _v
|
||
if _v is not None:
|
||
self["ycalendar"] = _v
|
||
_v = arg.pop("ygap", None)
|
||
_v = ygap if ygap is not None else _v
|
||
if _v is not None:
|
||
self["ygap"] = _v
|
||
_v = arg.pop("yhoverformat", None)
|
||
_v = yhoverformat if yhoverformat is not None else _v
|
||
if _v is not None:
|
||
self["yhoverformat"] = _v
|
||
_v = arg.pop("ysrc", None)
|
||
_v = ysrc if ysrc is not None else _v
|
||
if _v is not None:
|
||
self["ysrc"] = _v
|
||
_v = arg.pop("z", None)
|
||
_v = z if z is not None else _v
|
||
if _v is not None:
|
||
self["z"] = _v
|
||
_v = arg.pop("zauto", None)
|
||
_v = zauto if zauto is not None else _v
|
||
if _v is not None:
|
||
self["zauto"] = _v
|
||
_v = arg.pop("zhoverformat", None)
|
||
_v = zhoverformat if zhoverformat is not None else _v
|
||
if _v is not None:
|
||
self["zhoverformat"] = _v
|
||
_v = arg.pop("zmax", None)
|
||
_v = zmax if zmax is not None else _v
|
||
if _v is not None:
|
||
self["zmax"] = _v
|
||
_v = arg.pop("zmid", None)
|
||
_v = zmid if zmid is not None else _v
|
||
if _v is not None:
|
||
self["zmid"] = _v
|
||
_v = arg.pop("zmin", None)
|
||
_v = zmin if zmin is not None else _v
|
||
if _v is not None:
|
||
self["zmin"] = _v
|
||
_v = arg.pop("zsmooth", None)
|
||
_v = zsmooth if zsmooth is not None else _v
|
||
if _v is not None:
|
||
self["zsmooth"] = _v
|
||
_v = arg.pop("zsrc", None)
|
||
_v = zsrc if zsrc is not None else _v
|
||
if _v is not None:
|
||
self["zsrc"] = _v
|
||
|
||
# Read-only literals
|
||
# ------------------
|
||
|
||
self._props["type"] = "histogram2d"
|
||
arg.pop("type", None)
|
||
|
||
# Process unknown kwargs
|
||
# ----------------------
|
||
self._process_kwargs(**dict(arg, **kwargs))
|
||
|
||
# Reset skip_invalid
|
||
# ------------------
|
||
self._skip_invalid = False
|