3224 lines
117 KiB
Python
3224 lines
117 KiB
Python
from plotly.basedatatypes import BaseTraceType as _BaseTraceType
|
|
import copy as _copy
|
|
|
|
|
|
class Histogram(_BaseTraceType):
|
|
|
|
# class properties
|
|
# --------------------
|
|
_parent_path_str = ""
|
|
_path_str = "histogram"
|
|
_valid_props = {
|
|
"alignmentgroup",
|
|
"autobinx",
|
|
"autobiny",
|
|
"bingroup",
|
|
"cliponaxis",
|
|
"constraintext",
|
|
"cumulative",
|
|
"customdata",
|
|
"customdatasrc",
|
|
"error_x",
|
|
"error_y",
|
|
"histfunc",
|
|
"histnorm",
|
|
"hoverinfo",
|
|
"hoverinfosrc",
|
|
"hoverlabel",
|
|
"hovertemplate",
|
|
"hovertemplatesrc",
|
|
"hovertext",
|
|
"hovertextsrc",
|
|
"ids",
|
|
"idssrc",
|
|
"insidetextanchor",
|
|
"insidetextfont",
|
|
"legend",
|
|
"legendgroup",
|
|
"legendgrouptitle",
|
|
"legendrank",
|
|
"legendwidth",
|
|
"marker",
|
|
"meta",
|
|
"metasrc",
|
|
"name",
|
|
"nbinsx",
|
|
"nbinsy",
|
|
"offsetgroup",
|
|
"opacity",
|
|
"orientation",
|
|
"outsidetextfont",
|
|
"selected",
|
|
"selectedpoints",
|
|
"showlegend",
|
|
"stream",
|
|
"text",
|
|
"textangle",
|
|
"textfont",
|
|
"textposition",
|
|
"textsrc",
|
|
"texttemplate",
|
|
"type",
|
|
"uid",
|
|
"uirevision",
|
|
"unselected",
|
|
"visible",
|
|
"x",
|
|
"xaxis",
|
|
"xbins",
|
|
"xcalendar",
|
|
"xhoverformat",
|
|
"xsrc",
|
|
"y",
|
|
"yaxis",
|
|
"ybins",
|
|
"ycalendar",
|
|
"yhoverformat",
|
|
"ysrc",
|
|
}
|
|
|
|
# alignmentgroup
|
|
# --------------
|
|
@property
|
|
def alignmentgroup(self):
|
|
"""
|
|
Set several traces linked to the same position axis or matching
|
|
axes to the same alignmentgroup. This controls whether bars
|
|
compute their positional range dependently or independently.
|
|
|
|
The 'alignmentgroup' property is a string and must be specified as:
|
|
- A string
|
|
- A number that will be converted to a string
|
|
|
|
Returns
|
|
-------
|
|
str
|
|
"""
|
|
return self["alignmentgroup"]
|
|
|
|
@alignmentgroup.setter
|
|
def alignmentgroup(self, val):
|
|
self["alignmentgroup"] = val
|
|
|
|
# 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
|
|
|
|
# bingroup
|
|
# --------
|
|
@property
|
|
def bingroup(self):
|
|
"""
|
|
Set a group of histogram traces which will have compatible bin
|
|
settings. Note that traces on the same subplot and with the
|
|
same "orientation" under `barmode` "stack", "relative" and
|
|
"group" are forced into the same bingroup, Using `bingroup`,
|
|
traces under `barmode` "overlay" and on different axes (of the
|
|
same axis type) can have compatible bin settings. Note that
|
|
histogram and histogram2d* trace can share the same `bingroup`
|
|
|
|
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
|
|
|
|
# cliponaxis
|
|
# ----------
|
|
@property
|
|
def cliponaxis(self):
|
|
"""
|
|
Determines whether the text nodes are clipped about the subplot
|
|
axes. To show the text nodes above axis lines and tick labels,
|
|
make sure to set `xaxis.layer` and `yaxis.layer` to *below
|
|
traces*.
|
|
|
|
The 'cliponaxis' property must be specified as a bool
|
|
(either True, or False)
|
|
|
|
Returns
|
|
-------
|
|
bool
|
|
"""
|
|
return self["cliponaxis"]
|
|
|
|
@cliponaxis.setter
|
|
def cliponaxis(self, val):
|
|
self["cliponaxis"] = val
|
|
|
|
# constraintext
|
|
# -------------
|
|
@property
|
|
def constraintext(self):
|
|
"""
|
|
Constrain the size of text inside or outside a bar to be no
|
|
larger than the bar itself.
|
|
|
|
The 'constraintext' property is an enumeration that may be specified as:
|
|
- One of the following enumeration values:
|
|
['inside', 'outside', 'both', 'none']
|
|
|
|
Returns
|
|
-------
|
|
Any
|
|
"""
|
|
return self["constraintext"]
|
|
|
|
@constraintext.setter
|
|
def constraintext(self, val):
|
|
self["constraintext"] = val
|
|
|
|
# cumulative
|
|
# ----------
|
|
@property
|
|
def cumulative(self):
|
|
"""
|
|
The 'cumulative' property is an instance of Cumulative
|
|
that may be specified as:
|
|
- An instance of :class:`plotly.graph_objs.histogram.Cumulative`
|
|
- A dict of string/value properties that will be passed
|
|
to the Cumulative constructor
|
|
|
|
Supported dict properties:
|
|
|
|
currentbin
|
|
Only applies if cumulative is enabled. Sets
|
|
whether the current bin is included, excluded,
|
|
or has half of its value included in the
|
|
current cumulative value. "include" is the
|
|
default for compatibility with various other
|
|
tools, however it introduces a half-bin bias to
|
|
the results. "exclude" makes the opposite half-
|
|
bin bias, and "half" removes it.
|
|
direction
|
|
Only applies if cumulative is enabled. If
|
|
"increasing" (default) we sum all prior bins,
|
|
so the result increases from left to right. If
|
|
"decreasing" we sum later bins so the result
|
|
decreases from left to right.
|
|
enabled
|
|
If true, display the cumulative distribution by
|
|
summing the binned values. Use the `direction`
|
|
and `centralbin` attributes to tune the
|
|
accumulation method. Note: in this mode, the
|
|
"density" `histnorm` settings behave the same
|
|
as their equivalents without "density": "" and
|
|
"density" both rise to the number of data
|
|
points, and "probability" and *probability
|
|
density* both rise to the number of sample
|
|
points.
|
|
|
|
Returns
|
|
-------
|
|
plotly.graph_objs.histogram.Cumulative
|
|
"""
|
|
return self["cumulative"]
|
|
|
|
@cumulative.setter
|
|
def cumulative(self, val):
|
|
self["cumulative"] = 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
|
|
|
|
# error_x
|
|
# -------
|
|
@property
|
|
def error_x(self):
|
|
"""
|
|
The 'error_x' property is an instance of ErrorX
|
|
that may be specified as:
|
|
- An instance of :class:`plotly.graph_objs.histogram.ErrorX`
|
|
- A dict of string/value properties that will be passed
|
|
to the ErrorX constructor
|
|
|
|
Supported dict properties:
|
|
|
|
array
|
|
Sets the data corresponding the length of each
|
|
error bar. Values are plotted relative to the
|
|
underlying data.
|
|
arrayminus
|
|
Sets the data corresponding the length of each
|
|
error bar in the bottom (left) direction for
|
|
vertical (horizontal) bars Values are plotted
|
|
relative to the underlying data.
|
|
arrayminussrc
|
|
Sets the source reference on Chart Studio Cloud
|
|
for `arrayminus`.
|
|
arraysrc
|
|
Sets the source reference on Chart Studio Cloud
|
|
for `array`.
|
|
color
|
|
Sets the stoke color of the error bars.
|
|
copy_ystyle
|
|
|
|
symmetric
|
|
Determines whether or not the error bars have
|
|
the same length in both direction (top/bottom
|
|
for vertical bars, left/right for horizontal
|
|
bars.
|
|
thickness
|
|
Sets the thickness (in px) of the error bars.
|
|
traceref
|
|
|
|
tracerefminus
|
|
|
|
type
|
|
Determines the rule used to generate the error
|
|
bars. If *constant`, the bar lengths are of a
|
|
constant value. Set this constant in `value`.
|
|
If "percent", the bar lengths correspond to a
|
|
percentage of underlying data. Set this
|
|
percentage in `value`. If "sqrt", the bar
|
|
lengths correspond to the square of the
|
|
underlying data. If "data", the bar lengths are
|
|
set with data set `array`.
|
|
value
|
|
Sets the value of either the percentage (if
|
|
`type` is set to "percent") or the constant (if
|
|
`type` is set to "constant") corresponding to
|
|
the lengths of the error bars.
|
|
valueminus
|
|
Sets the value of either the percentage (if
|
|
`type` is set to "percent") or the constant (if
|
|
`type` is set to "constant") corresponding to
|
|
the lengths of the error bars in the bottom
|
|
(left) direction for vertical (horizontal) bars
|
|
visible
|
|
Determines whether or not this set of error
|
|
bars is visible.
|
|
width
|
|
Sets the width (in px) of the cross-bar at both
|
|
ends of the error bars.
|
|
|
|
Returns
|
|
-------
|
|
plotly.graph_objs.histogram.ErrorX
|
|
"""
|
|
return self["error_x"]
|
|
|
|
@error_x.setter
|
|
def error_x(self, val):
|
|
self["error_x"] = val
|
|
|
|
# error_y
|
|
# -------
|
|
@property
|
|
def error_y(self):
|
|
"""
|
|
The 'error_y' property is an instance of ErrorY
|
|
that may be specified as:
|
|
- An instance of :class:`plotly.graph_objs.histogram.ErrorY`
|
|
- A dict of string/value properties that will be passed
|
|
to the ErrorY constructor
|
|
|
|
Supported dict properties:
|
|
|
|
array
|
|
Sets the data corresponding the length of each
|
|
error bar. Values are plotted relative to the
|
|
underlying data.
|
|
arrayminus
|
|
Sets the data corresponding the length of each
|
|
error bar in the bottom (left) direction for
|
|
vertical (horizontal) bars Values are plotted
|
|
relative to the underlying data.
|
|
arrayminussrc
|
|
Sets the source reference on Chart Studio Cloud
|
|
for `arrayminus`.
|
|
arraysrc
|
|
Sets the source reference on Chart Studio Cloud
|
|
for `array`.
|
|
color
|
|
Sets the stoke color of the error bars.
|
|
symmetric
|
|
Determines whether or not the error bars have
|
|
the same length in both direction (top/bottom
|
|
for vertical bars, left/right for horizontal
|
|
bars.
|
|
thickness
|
|
Sets the thickness (in px) of the error bars.
|
|
traceref
|
|
|
|
tracerefminus
|
|
|
|
type
|
|
Determines the rule used to generate the error
|
|
bars. If *constant`, the bar lengths are of a
|
|
constant value. Set this constant in `value`.
|
|
If "percent", the bar lengths correspond to a
|
|
percentage of underlying data. Set this
|
|
percentage in `value`. If "sqrt", the bar
|
|
lengths correspond to the square of the
|
|
underlying data. If "data", the bar lengths are
|
|
set with data set `array`.
|
|
value
|
|
Sets the value of either the percentage (if
|
|
`type` is set to "percent") or the constant (if
|
|
`type` is set to "constant") corresponding to
|
|
the lengths of the error bars.
|
|
valueminus
|
|
Sets the value of either the percentage (if
|
|
`type` is set to "percent") or the constant (if
|
|
`type` is set to "constant") corresponding to
|
|
the lengths of the error bars in the bottom
|
|
(left) direction for vertical (horizontal) bars
|
|
visible
|
|
Determines whether or not this set of error
|
|
bars is visible.
|
|
width
|
|
Sets the width (in px) of the cross-bar at both
|
|
ends of the error bars.
|
|
|
|
Returns
|
|
-------
|
|
plotly.graph_objs.histogram.ErrorY
|
|
"""
|
|
return self["error_y"]
|
|
|
|
@error_y.setter
|
|
def error_y(self, val):
|
|
self["error_y"] = 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.histogram.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.histogram.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 `binNumber` 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
|
|
|
|
# hovertext
|
|
# ---------
|
|
@property
|
|
def hovertext(self):
|
|
"""
|
|
Same as `text`.
|
|
|
|
The 'hovertext' 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["hovertext"]
|
|
|
|
@hovertext.setter
|
|
def hovertext(self, val):
|
|
self["hovertext"] = val
|
|
|
|
# hovertextsrc
|
|
# ------------
|
|
@property
|
|
def hovertextsrc(self):
|
|
"""
|
|
Sets the source reference on Chart Studio Cloud for
|
|
`hovertext`.
|
|
|
|
The 'hovertextsrc' property must be specified as a string or
|
|
as a plotly.grid_objs.Column object
|
|
|
|
Returns
|
|
-------
|
|
str
|
|
"""
|
|
return self["hovertextsrc"]
|
|
|
|
@hovertextsrc.setter
|
|
def hovertextsrc(self, val):
|
|
self["hovertextsrc"] = 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
|
|
|
|
# insidetextanchor
|
|
# ----------------
|
|
@property
|
|
def insidetextanchor(self):
|
|
"""
|
|
Determines if texts are kept at center or start/end points in
|
|
`textposition` "inside" mode.
|
|
|
|
The 'insidetextanchor' property is an enumeration that may be specified as:
|
|
- One of the following enumeration values:
|
|
['end', 'middle', 'start']
|
|
|
|
Returns
|
|
-------
|
|
Any
|
|
"""
|
|
return self["insidetextanchor"]
|
|
|
|
@insidetextanchor.setter
|
|
def insidetextanchor(self, val):
|
|
self["insidetextanchor"] = val
|
|
|
|
# insidetextfont
|
|
# --------------
|
|
@property
|
|
def insidetextfont(self):
|
|
"""
|
|
Sets the font used for `text` lying inside the bar.
|
|
|
|
The 'insidetextfont' property is an instance of Insidetextfont
|
|
that may be specified as:
|
|
- An instance of :class:`plotly.graph_objs.histogram.Insidetextfont`
|
|
- A dict of string/value properties that will be passed
|
|
to the Insidetextfont 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.histogram.Insidetextfont
|
|
"""
|
|
return self["insidetextfont"]
|
|
|
|
@insidetextfont.setter
|
|
def insidetextfont(self, val):
|
|
self["insidetextfont"] = 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.histogram.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.histogram.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.histogram.Marker`
|
|
- A dict of string/value properties that will be passed
|
|
to the Marker constructor
|
|
|
|
Supported dict properties:
|
|
|
|
autocolorscale
|
|
Determines whether the colorscale is a default
|
|
palette (`autocolorscale: true`) or the palette
|
|
determined by `marker.colorscale`. Has an
|
|
effect only if in `marker.color` is set to a
|
|
numerical array. 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.
|
|
cauto
|
|
Determines whether or not the color domain is
|
|
computed with respect to the input data (here
|
|
in `marker.color`) or the bounds set in
|
|
`marker.cmin` and `marker.cmax` Has an effect
|
|
only if in `marker.color` is set to a numerical
|
|
array. Defaults to `false` when `marker.cmin`
|
|
and `marker.cmax` are set by the user.
|
|
cmax
|
|
Sets the upper bound of the color domain. Has
|
|
an effect only if in `marker.color` is set to a
|
|
numerical array. Value should have the same
|
|
units as in `marker.color` and if set,
|
|
`marker.cmin` must be set as well.
|
|
cmid
|
|
Sets the mid-point of the color domain by
|
|
scaling `marker.cmin` and/or `marker.cmax` to
|
|
be equidistant to this point. Has an effect
|
|
only if in `marker.color` is set to a numerical
|
|
array. Value should have the same units as in
|
|
`marker.color`. Has no effect when
|
|
`marker.cauto` is `false`.
|
|
cmin
|
|
Sets the lower bound of the color domain. Has
|
|
an effect only if in `marker.color` is set to a
|
|
numerical array. Value should have the same
|
|
units as in `marker.color` and if set,
|
|
`marker.cmax` must be set as well.
|
|
color
|
|
Sets the marker color. It accepts either a
|
|
specific color or an array of numbers that are
|
|
mapped to the colorscale relative to the max
|
|
and min values of the array or relative to
|
|
`marker.cmin` and `marker.cmax` if set.
|
|
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.histogram.marker.C
|
|
olorBar` instance or dict with compatible
|
|
properties
|
|
colorscale
|
|
Sets the colorscale. Has an effect only if in
|
|
`marker.color` is set to a numerical array. 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 `marker.cmin` and
|
|
`marker.cmax`. 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,Rd
|
|
Bu,Reds,Viridis,YlGnBu,YlOrRd.
|
|
colorsrc
|
|
Sets the source reference on Chart Studio Cloud
|
|
for `color`.
|
|
line
|
|
:class:`plotly.graph_objects.histogram.marker.L
|
|
ine` instance or dict with compatible
|
|
properties
|
|
opacity
|
|
Sets the opacity of the bars.
|
|
opacitysrc
|
|
Sets the source reference on Chart Studio Cloud
|
|
for `opacity`.
|
|
pattern
|
|
Sets the pattern within the marker.
|
|
reversescale
|
|
Reverses the color mapping if true. Has an
|
|
effect only if in `marker.color` is set to a
|
|
numerical array. If true, `marker.cmin` will
|
|
correspond to the last color in the array and
|
|
`marker.cmax` will correspond to the first
|
|
color.
|
|
showscale
|
|
Determines whether or not a colorbar is
|
|
displayed for this trace. Has an effect only if
|
|
in `marker.color` is set to a numerical array.
|
|
|
|
Returns
|
|
-------
|
|
plotly.graph_objs.histogram.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
|
|
|
|
# offsetgroup
|
|
# -----------
|
|
@property
|
|
def offsetgroup(self):
|
|
"""
|
|
Set several traces linked to the same position axis or matching
|
|
axes to the same offsetgroup where bars of the same position
|
|
coordinate will line up.
|
|
|
|
The 'offsetgroup' property is a string and must be specified as:
|
|
- A string
|
|
- A number that will be converted to a string
|
|
|
|
Returns
|
|
-------
|
|
str
|
|
"""
|
|
return self["offsetgroup"]
|
|
|
|
@offsetgroup.setter
|
|
def offsetgroup(self, val):
|
|
self["offsetgroup"] = 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
|
|
|
|
# orientation
|
|
# -----------
|
|
@property
|
|
def orientation(self):
|
|
"""
|
|
Sets the orientation of the bars. With "v" ("h"), the value of
|
|
the each bar spans along the vertical (horizontal).
|
|
|
|
The 'orientation' property is an enumeration that may be specified as:
|
|
- One of the following enumeration values:
|
|
['v', 'h']
|
|
|
|
Returns
|
|
-------
|
|
Any
|
|
"""
|
|
return self["orientation"]
|
|
|
|
@orientation.setter
|
|
def orientation(self, val):
|
|
self["orientation"] = val
|
|
|
|
# outsidetextfont
|
|
# ---------------
|
|
@property
|
|
def outsidetextfont(self):
|
|
"""
|
|
Sets the font used for `text` lying outside the bar.
|
|
|
|
The 'outsidetextfont' property is an instance of Outsidetextfont
|
|
that may be specified as:
|
|
- An instance of :class:`plotly.graph_objs.histogram.Outsidetextfont`
|
|
- A dict of string/value properties that will be passed
|
|
to the Outsidetextfont 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.histogram.Outsidetextfont
|
|
"""
|
|
return self["outsidetextfont"]
|
|
|
|
@outsidetextfont.setter
|
|
def outsidetextfont(self, val):
|
|
self["outsidetextfont"] = val
|
|
|
|
# selected
|
|
# --------
|
|
@property
|
|
def selected(self):
|
|
"""
|
|
The 'selected' property is an instance of Selected
|
|
that may be specified as:
|
|
- An instance of :class:`plotly.graph_objs.histogram.Selected`
|
|
- A dict of string/value properties that will be passed
|
|
to the Selected constructor
|
|
|
|
Supported dict properties:
|
|
|
|
marker
|
|
:class:`plotly.graph_objects.histogram.selected
|
|
.Marker` instance or dict with compatible
|
|
properties
|
|
textfont
|
|
:class:`plotly.graph_objects.histogram.selected
|
|
.Textfont` instance or dict with compatible
|
|
properties
|
|
|
|
Returns
|
|
-------
|
|
plotly.graph_objs.histogram.Selected
|
|
"""
|
|
return self["selected"]
|
|
|
|
@selected.setter
|
|
def selected(self, val):
|
|
self["selected"] = val
|
|
|
|
# selectedpoints
|
|
# --------------
|
|
@property
|
|
def selectedpoints(self):
|
|
"""
|
|
Array containing integer indices of selected points. Has an
|
|
effect only for traces that support selections. Note that an
|
|
empty array means an empty selection where the `unselected` are
|
|
turned on for all points, whereas, any other non-array values
|
|
means no selection all where the `selected` and `unselected`
|
|
styles have no effect.
|
|
|
|
The 'selectedpoints' property accepts values of any type
|
|
|
|
Returns
|
|
-------
|
|
Any
|
|
"""
|
|
return self["selectedpoints"]
|
|
|
|
@selectedpoints.setter
|
|
def selectedpoints(self, val):
|
|
self["selectedpoints"] = 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
|
|
|
|
# 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.histogram.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.histogram.Stream
|
|
"""
|
|
return self["stream"]
|
|
|
|
@stream.setter
|
|
def stream(self, val):
|
|
self["stream"] = val
|
|
|
|
# text
|
|
# ----
|
|
@property
|
|
def text(self):
|
|
"""
|
|
Sets hover text elements associated with each bar. If a single
|
|
string, the same string appears over all bars. If an array of
|
|
string, the items are mapped in order to the this trace's
|
|
coordinates.
|
|
|
|
The 'text' 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["text"]
|
|
|
|
@text.setter
|
|
def text(self, val):
|
|
self["text"] = val
|
|
|
|
# textangle
|
|
# ---------
|
|
@property
|
|
def textangle(self):
|
|
"""
|
|
Sets the angle of the tick labels with respect to the bar. For
|
|
example, a `tickangle` of -90 draws the tick labels vertically.
|
|
With "auto" the texts may automatically be rotated to fit with
|
|
the maximum size in bars.
|
|
|
|
The 'textangle' property is a angle (in degrees) that may be
|
|
specified as a number between -180 and 180.
|
|
Numeric values outside this range are converted to the equivalent value
|
|
(e.g. 270 is converted to -90).
|
|
|
|
Returns
|
|
-------
|
|
int|float
|
|
"""
|
|
return self["textangle"]
|
|
|
|
@textangle.setter
|
|
def textangle(self, val):
|
|
self["textangle"] = 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.histogram.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.histogram.Textfont
|
|
"""
|
|
return self["textfont"]
|
|
|
|
@textfont.setter
|
|
def textfont(self, val):
|
|
self["textfont"] = val
|
|
|
|
# textposition
|
|
# ------------
|
|
@property
|
|
def textposition(self):
|
|
"""
|
|
Specifies the location of the `text`. "inside" positions `text`
|
|
inside, next to the bar end (rotated and scaled if needed).
|
|
"outside" positions `text` outside, next to the bar end (scaled
|
|
if needed), unless there is another bar stacked on this one,
|
|
then the text gets pushed inside. "auto" tries to position
|
|
`text` inside the bar, but if the bar is too small and no bar
|
|
is stacked on this one the text is moved outside. If "none", no
|
|
text appears.
|
|
|
|
The 'textposition' property is an enumeration that may be specified as:
|
|
- One of the following enumeration values:
|
|
['inside', 'outside', 'auto', 'none']
|
|
|
|
Returns
|
|
-------
|
|
Any
|
|
"""
|
|
return self["textposition"]
|
|
|
|
@textposition.setter
|
|
def textposition(self, val):
|
|
self["textposition"] = val
|
|
|
|
# textsrc
|
|
# -------
|
|
@property
|
|
def textsrc(self):
|
|
"""
|
|
Sets the source reference on Chart Studio Cloud for `text`.
|
|
|
|
The 'textsrc' property must be specified as a string or
|
|
as a plotly.grid_objs.Column object
|
|
|
|
Returns
|
|
-------
|
|
str
|
|
"""
|
|
return self["textsrc"]
|
|
|
|
@textsrc.setter
|
|
def textsrc(self, val):
|
|
self["textsrc"] = 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 variables `label`
|
|
and `value`.
|
|
|
|
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
|
|
|
|
# unselected
|
|
# ----------
|
|
@property
|
|
def unselected(self):
|
|
"""
|
|
The 'unselected' property is an instance of Unselected
|
|
that may be specified as:
|
|
- An instance of :class:`plotly.graph_objs.histogram.Unselected`
|
|
- A dict of string/value properties that will be passed
|
|
to the Unselected constructor
|
|
|
|
Supported dict properties:
|
|
|
|
marker
|
|
:class:`plotly.graph_objects.histogram.unselect
|
|
ed.Marker` instance or dict with compatible
|
|
properties
|
|
textfont
|
|
:class:`plotly.graph_objects.histogram.unselect
|
|
ed.Textfont` instance or dict with compatible
|
|
properties
|
|
|
|
Returns
|
|
-------
|
|
plotly.graph_objs.histogram.Unselected
|
|
"""
|
|
return self["unselected"]
|
|
|
|
@unselected.setter
|
|
def unselected(self, val):
|
|
self["unselected"] = 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
|
|
|
|
# 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.histogram.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). If multiple non-overlaying histograms
|
|
share a subplot, the first explicit `size` is
|
|
used and all others discarded. If no `size` is
|
|
provided,the sample data from all traces is
|
|
combined to determine `size` as described
|
|
above.
|
|
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. If multiple non-
|
|
overlaying histograms share a subplot, the
|
|
first explicit `start` is used exactly and all
|
|
others are shifted down (if necessary) to
|
|
differ from that one by an integer number of
|
|
bins.
|
|
|
|
Returns
|
|
-------
|
|
plotly.graph_objs.histogram.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
|
|
|
|
# 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
|
|
|
|
# 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.histogram.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). If multiple non-overlaying histograms
|
|
share a subplot, the first explicit `size` is
|
|
used and all others discarded. If no `size` is
|
|
provided,the sample data from all traces is
|
|
combined to determine `size` as described
|
|
above.
|
|
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. If multiple non-
|
|
overlaying histograms share a subplot, the
|
|
first explicit `start` is used exactly and all
|
|
others are shifted down (if necessary) to
|
|
differ from that one by an integer number of
|
|
bins.
|
|
|
|
Returns
|
|
-------
|
|
plotly.graph_objs.histogram.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
|
|
|
|
# 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
|
|
|
|
# type
|
|
# ----
|
|
@property
|
|
def type(self):
|
|
return self._props["type"]
|
|
|
|
# Self properties description
|
|
# ---------------------------
|
|
@property
|
|
def _prop_descriptions(self):
|
|
return """\
|
|
alignmentgroup
|
|
Set several traces linked to the same position axis or
|
|
matching axes to the same alignmentgroup. This controls
|
|
whether bars compute their positional range dependently
|
|
or independently.
|
|
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.
|
|
bingroup
|
|
Set a group of histogram traces which will have
|
|
compatible bin settings. Note that traces on the same
|
|
subplot and with the same "orientation" under `barmode`
|
|
"stack", "relative" and "group" are forced into the
|
|
same bingroup, Using `bingroup`, traces under `barmode`
|
|
"overlay" and on different axes (of the same axis type)
|
|
can have compatible bin settings. Note that histogram
|
|
and histogram2d* trace can share the same `bingroup`
|
|
cliponaxis
|
|
Determines whether the text nodes are clipped about the
|
|
subplot axes. To show the text nodes above axis lines
|
|
and tick labels, make sure to set `xaxis.layer` and
|
|
`yaxis.layer` to *below traces*.
|
|
constraintext
|
|
Constrain the size of text inside or outside a bar to
|
|
be no larger than the bar itself.
|
|
cumulative
|
|
:class:`plotly.graph_objects.histogram.Cumulative`
|
|
instance or dict with compatible properties
|
|
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`.
|
|
error_x
|
|
:class:`plotly.graph_objects.histogram.ErrorX` instance
|
|
or dict with compatible properties
|
|
error_y
|
|
:class:`plotly.graph_objects.histogram.ErrorY` instance
|
|
or dict with compatible properties
|
|
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.histogram.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 `binNumber` 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`.
|
|
hovertext
|
|
Same as `text`.
|
|
hovertextsrc
|
|
Sets the source reference on Chart Studio Cloud for
|
|
`hovertext`.
|
|
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`.
|
|
insidetextanchor
|
|
Determines if texts are kept at center or start/end
|
|
points in `textposition` "inside" mode.
|
|
insidetextfont
|
|
Sets the font used for `text` lying inside the bar.
|
|
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.histogram.Legendgrouptitle
|
|
` 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.histogram.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.
|
|
offsetgroup
|
|
Set several traces linked to the same position axis or
|
|
matching axes to the same offsetgroup where bars of the
|
|
same position coordinate will line up.
|
|
opacity
|
|
Sets the opacity of the trace.
|
|
orientation
|
|
Sets the orientation of the bars. With "v" ("h"), the
|
|
value of the each bar spans along the vertical
|
|
(horizontal).
|
|
outsidetextfont
|
|
Sets the font used for `text` lying outside the bar.
|
|
selected
|
|
:class:`plotly.graph_objects.histogram.Selected`
|
|
instance or dict with compatible properties
|
|
selectedpoints
|
|
Array containing integer indices of selected points.
|
|
Has an effect only for traces that support selections.
|
|
Note that an empty array means an empty selection where
|
|
the `unselected` are turned on for all points, whereas,
|
|
any other non-array values means no selection all where
|
|
the `selected` and `unselected` styles have no effect.
|
|
showlegend
|
|
Determines whether or not an item corresponding to this
|
|
trace is shown in the legend.
|
|
stream
|
|
:class:`plotly.graph_objects.histogram.Stream` instance
|
|
or dict with compatible properties
|
|
text
|
|
Sets hover text elements associated with each bar. If a
|
|
single string, the same string appears over all bars.
|
|
If an array of string, the items are mapped in order to
|
|
the this trace's coordinates.
|
|
textangle
|
|
Sets the angle of the tick labels with respect to the
|
|
bar. For example, a `tickangle` of -90 draws the tick
|
|
labels vertically. With "auto" the texts may
|
|
automatically be rotated to fit with the maximum size
|
|
in bars.
|
|
textfont
|
|
Sets the text font.
|
|
textposition
|
|
Specifies the location of the `text`. "inside"
|
|
positions `text` inside, next to the bar end (rotated
|
|
and scaled if needed). "outside" positions `text`
|
|
outside, next to the bar end (scaled if needed), unless
|
|
there is another bar stacked on this one, then the text
|
|
gets pushed inside. "auto" tries to position `text`
|
|
inside the bar, but if the bar is too small and no bar
|
|
is stacked on this one the text is moved outside. If
|
|
"none", no text appears.
|
|
textsrc
|
|
Sets the source reference on Chart Studio Cloud for
|
|
`text`.
|
|
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 variables `label` and `value`.
|
|
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.
|
|
unselected
|
|
:class:`plotly.graph_objects.histogram.Unselected`
|
|
instance or dict with compatible properties
|
|
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.
|
|
xbins
|
|
:class:`plotly.graph_objects.histogram.XBins` instance
|
|
or dict with compatible properties
|
|
xcalendar
|
|
Sets the calendar system to use with `x` date data.
|
|
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.
|
|
ybins
|
|
:class:`plotly.graph_objects.histogram.YBins` instance
|
|
or dict with compatible properties
|
|
ycalendar
|
|
Sets the calendar system to use with `y` date data.
|
|
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`.
|
|
"""
|
|
|
|
def __init__(
|
|
self,
|
|
arg=None,
|
|
alignmentgroup=None,
|
|
autobinx=None,
|
|
autobiny=None,
|
|
bingroup=None,
|
|
cliponaxis=None,
|
|
constraintext=None,
|
|
cumulative=None,
|
|
customdata=None,
|
|
customdatasrc=None,
|
|
error_x=None,
|
|
error_y=None,
|
|
histfunc=None,
|
|
histnorm=None,
|
|
hoverinfo=None,
|
|
hoverinfosrc=None,
|
|
hoverlabel=None,
|
|
hovertemplate=None,
|
|
hovertemplatesrc=None,
|
|
hovertext=None,
|
|
hovertextsrc=None,
|
|
ids=None,
|
|
idssrc=None,
|
|
insidetextanchor=None,
|
|
insidetextfont=None,
|
|
legend=None,
|
|
legendgroup=None,
|
|
legendgrouptitle=None,
|
|
legendrank=None,
|
|
legendwidth=None,
|
|
marker=None,
|
|
meta=None,
|
|
metasrc=None,
|
|
name=None,
|
|
nbinsx=None,
|
|
nbinsy=None,
|
|
offsetgroup=None,
|
|
opacity=None,
|
|
orientation=None,
|
|
outsidetextfont=None,
|
|
selected=None,
|
|
selectedpoints=None,
|
|
showlegend=None,
|
|
stream=None,
|
|
text=None,
|
|
textangle=None,
|
|
textfont=None,
|
|
textposition=None,
|
|
textsrc=None,
|
|
texttemplate=None,
|
|
uid=None,
|
|
uirevision=None,
|
|
unselected=None,
|
|
visible=None,
|
|
x=None,
|
|
xaxis=None,
|
|
xbins=None,
|
|
xcalendar=None,
|
|
xhoverformat=None,
|
|
xsrc=None,
|
|
y=None,
|
|
yaxis=None,
|
|
ybins=None,
|
|
ycalendar=None,
|
|
yhoverformat=None,
|
|
ysrc=None,
|
|
**kwargs,
|
|
):
|
|
"""
|
|
Construct a new Histogram object
|
|
|
|
The sample data from which statistics are computed is set in
|
|
`x` for vertically spanning histograms and in `y` for
|
|
horizontally spanning histograms. Binning options are set
|
|
`xbins` and `ybins` respectively if no aggregation data is
|
|
provided.
|
|
|
|
Parameters
|
|
----------
|
|
arg
|
|
dict of properties compatible with this constructor or
|
|
an instance of :class:`plotly.graph_objs.Histogram`
|
|
alignmentgroup
|
|
Set several traces linked to the same position axis or
|
|
matching axes to the same alignmentgroup. This controls
|
|
whether bars compute their positional range dependently
|
|
or independently.
|
|
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.
|
|
bingroup
|
|
Set a group of histogram traces which will have
|
|
compatible bin settings. Note that traces on the same
|
|
subplot and with the same "orientation" under `barmode`
|
|
"stack", "relative" and "group" are forced into the
|
|
same bingroup, Using `bingroup`, traces under `barmode`
|
|
"overlay" and on different axes (of the same axis type)
|
|
can have compatible bin settings. Note that histogram
|
|
and histogram2d* trace can share the same `bingroup`
|
|
cliponaxis
|
|
Determines whether the text nodes are clipped about the
|
|
subplot axes. To show the text nodes above axis lines
|
|
and tick labels, make sure to set `xaxis.layer` and
|
|
`yaxis.layer` to *below traces*.
|
|
constraintext
|
|
Constrain the size of text inside or outside a bar to
|
|
be no larger than the bar itself.
|
|
cumulative
|
|
:class:`plotly.graph_objects.histogram.Cumulative`
|
|
instance or dict with compatible properties
|
|
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`.
|
|
error_x
|
|
:class:`plotly.graph_objects.histogram.ErrorX` instance
|
|
or dict with compatible properties
|
|
error_y
|
|
:class:`plotly.graph_objects.histogram.ErrorY` instance
|
|
or dict with compatible properties
|
|
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.histogram.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 `binNumber` 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`.
|
|
hovertext
|
|
Same as `text`.
|
|
hovertextsrc
|
|
Sets the source reference on Chart Studio Cloud for
|
|
`hovertext`.
|
|
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`.
|
|
insidetextanchor
|
|
Determines if texts are kept at center or start/end
|
|
points in `textposition` "inside" mode.
|
|
insidetextfont
|
|
Sets the font used for `text` lying inside the bar.
|
|
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.histogram.Legendgrouptitle
|
|
` 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.histogram.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.
|
|
offsetgroup
|
|
Set several traces linked to the same position axis or
|
|
matching axes to the same offsetgroup where bars of the
|
|
same position coordinate will line up.
|
|
opacity
|
|
Sets the opacity of the trace.
|
|
orientation
|
|
Sets the orientation of the bars. With "v" ("h"), the
|
|
value of the each bar spans along the vertical
|
|
(horizontal).
|
|
outsidetextfont
|
|
Sets the font used for `text` lying outside the bar.
|
|
selected
|
|
:class:`plotly.graph_objects.histogram.Selected`
|
|
instance or dict with compatible properties
|
|
selectedpoints
|
|
Array containing integer indices of selected points.
|
|
Has an effect only for traces that support selections.
|
|
Note that an empty array means an empty selection where
|
|
the `unselected` are turned on for all points, whereas,
|
|
any other non-array values means no selection all where
|
|
the `selected` and `unselected` styles have no effect.
|
|
showlegend
|
|
Determines whether or not an item corresponding to this
|
|
trace is shown in the legend.
|
|
stream
|
|
:class:`plotly.graph_objects.histogram.Stream` instance
|
|
or dict with compatible properties
|
|
text
|
|
Sets hover text elements associated with each bar. If a
|
|
single string, the same string appears over all bars.
|
|
If an array of string, the items are mapped in order to
|
|
the this trace's coordinates.
|
|
textangle
|
|
Sets the angle of the tick labels with respect to the
|
|
bar. For example, a `tickangle` of -90 draws the tick
|
|
labels vertically. With "auto" the texts may
|
|
automatically be rotated to fit with the maximum size
|
|
in bars.
|
|
textfont
|
|
Sets the text font.
|
|
textposition
|
|
Specifies the location of the `text`. "inside"
|
|
positions `text` inside, next to the bar end (rotated
|
|
and scaled if needed). "outside" positions `text`
|
|
outside, next to the bar end (scaled if needed), unless
|
|
there is another bar stacked on this one, then the text
|
|
gets pushed inside. "auto" tries to position `text`
|
|
inside the bar, but if the bar is too small and no bar
|
|
is stacked on this one the text is moved outside. If
|
|
"none", no text appears.
|
|
textsrc
|
|
Sets the source reference on Chart Studio Cloud for
|
|
`text`.
|
|
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 variables `label` and `value`.
|
|
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.
|
|
unselected
|
|
:class:`plotly.graph_objects.histogram.Unselected`
|
|
instance or dict with compatible properties
|
|
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.
|
|
xbins
|
|
:class:`plotly.graph_objects.histogram.XBins` instance
|
|
or dict with compatible properties
|
|
xcalendar
|
|
Sets the calendar system to use with `x` date data.
|
|
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.
|
|
ybins
|
|
:class:`plotly.graph_objects.histogram.YBins` instance
|
|
or dict with compatible properties
|
|
ycalendar
|
|
Sets the calendar system to use with `y` date data.
|
|
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`.
|
|
|
|
Returns
|
|
-------
|
|
Histogram
|
|
"""
|
|
super(Histogram, self).__init__("histogram")
|
|
|
|
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.Histogram
|
|
constructor must be a dict or
|
|
an instance of :class:`plotly.graph_objs.Histogram`"""
|
|
)
|
|
|
|
# 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("alignmentgroup", None)
|
|
_v = alignmentgroup if alignmentgroup is not None else _v
|
|
if _v is not None:
|
|
self["alignmentgroup"] = _v
|
|
_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("bingroup", None)
|
|
_v = bingroup if bingroup is not None else _v
|
|
if _v is not None:
|
|
self["bingroup"] = _v
|
|
_v = arg.pop("cliponaxis", None)
|
|
_v = cliponaxis if cliponaxis is not None else _v
|
|
if _v is not None:
|
|
self["cliponaxis"] = _v
|
|
_v = arg.pop("constraintext", None)
|
|
_v = constraintext if constraintext is not None else _v
|
|
if _v is not None:
|
|
self["constraintext"] = _v
|
|
_v = arg.pop("cumulative", None)
|
|
_v = cumulative if cumulative is not None else _v
|
|
if _v is not None:
|
|
self["cumulative"] = _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("error_x", None)
|
|
_v = error_x if error_x is not None else _v
|
|
if _v is not None:
|
|
self["error_x"] = _v
|
|
_v = arg.pop("error_y", None)
|
|
_v = error_y if error_y is not None else _v
|
|
if _v is not None:
|
|
self["error_y"] = _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("hovertext", None)
|
|
_v = hovertext if hovertext is not None else _v
|
|
if _v is not None:
|
|
self["hovertext"] = _v
|
|
_v = arg.pop("hovertextsrc", None)
|
|
_v = hovertextsrc if hovertextsrc is not None else _v
|
|
if _v is not None:
|
|
self["hovertextsrc"] = _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("insidetextanchor", None)
|
|
_v = insidetextanchor if insidetextanchor is not None else _v
|
|
if _v is not None:
|
|
self["insidetextanchor"] = _v
|
|
_v = arg.pop("insidetextfont", None)
|
|
_v = insidetextfont if insidetextfont is not None else _v
|
|
if _v is not None:
|
|
self["insidetextfont"] = _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("offsetgroup", None)
|
|
_v = offsetgroup if offsetgroup is not None else _v
|
|
if _v is not None:
|
|
self["offsetgroup"] = _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("orientation", None)
|
|
_v = orientation if orientation is not None else _v
|
|
if _v is not None:
|
|
self["orientation"] = _v
|
|
_v = arg.pop("outsidetextfont", None)
|
|
_v = outsidetextfont if outsidetextfont is not None else _v
|
|
if _v is not None:
|
|
self["outsidetextfont"] = _v
|
|
_v = arg.pop("selected", None)
|
|
_v = selected if selected is not None else _v
|
|
if _v is not None:
|
|
self["selected"] = _v
|
|
_v = arg.pop("selectedpoints", None)
|
|
_v = selectedpoints if selectedpoints is not None else _v
|
|
if _v is not None:
|
|
self["selectedpoints"] = _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("stream", None)
|
|
_v = stream if stream is not None else _v
|
|
if _v is not None:
|
|
self["stream"] = _v
|
|
_v = arg.pop("text", None)
|
|
_v = text if text is not None else _v
|
|
if _v is not None:
|
|
self["text"] = _v
|
|
_v = arg.pop("textangle", None)
|
|
_v = textangle if textangle is not None else _v
|
|
if _v is not None:
|
|
self["textangle"] = _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("textposition", None)
|
|
_v = textposition if textposition is not None else _v
|
|
if _v is not None:
|
|
self["textposition"] = _v
|
|
_v = arg.pop("textsrc", None)
|
|
_v = textsrc if textsrc is not None else _v
|
|
if _v is not None:
|
|
self["textsrc"] = _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("unselected", None)
|
|
_v = unselected if unselected is not None else _v
|
|
if _v is not None:
|
|
self["unselected"] = _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("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("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("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("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
|
|
|
|
# Read-only literals
|
|
# ------------------
|
|
|
|
self._props["type"] = "histogram"
|
|
arg.pop("type", None)
|
|
|
|
# Process unknown kwargs
|
|
# ----------------------
|
|
self._process_kwargs(**dict(arg, **kwargs))
|
|
|
|
# Reset skip_invalid
|
|
# ------------------
|
|
self._skip_invalid = False
|