Skip to content

Instantly share code, notes, and snippets.

@tomron
Created Oct 22, 2021
Embed
What would you like to do?
Other pie - creat a pie chart with the top `n-1` values as separate sectors and other sector for the remaining values
"""
`plotly.express` is a terse, consistent, high-level wrapper around `plotly.graph_objects`
for rapid data exploration and figure generation. Learn more at https://plotly.express/
"""
from __future__ import absolute_import
from plotly import optional_imports
pd = optional_imports.get_module("pandas")
if pd is None:
raise ImportError(
"""\
Plotly express requires pandas to be installed."""
)
from ._imshow import imshow
from ._chart_types import ( # noqa: F401
scatter,
scatter_3d,
scatter_polar,
scatter_ternary,
scatter_mapbox,
scatter_geo,
line,
line_3d,
line_polar,
line_ternary,
line_mapbox,
line_geo,
area,
bar,
timeline,
bar_polar,
violin,
box,
strip,
histogram,
ecdf,
scatter_matrix,
parallel_coordinates,
parallel_categories,
choropleth,
density_contour,
density_heatmap,
pie,
other_pie,
sunburst,
treemap,
icicle,
funnel,
funnel_area,
choropleth_mapbox,
density_mapbox,
)
from ._core import ( # noqa: F401
set_mapbox_access_token,
defaults,
get_trendline_results,
NO_COLOR,
)
from ._special_inputs import IdentityMap, Constant, Range # noqa: F401
from . import data, colors, trendline_functions # noqa: F401
__all__ = [
"scatter",
"scatter_3d",
"scatter_polar",
"scatter_ternary",
"scatter_mapbox",
"scatter_geo",
"scatter_matrix",
"density_contour",
"density_heatmap",
"density_mapbox",
"line",
"line_3d",
"line_polar",
"line_ternary",
"line_mapbox",
"line_geo",
"parallel_coordinates",
"parallel_categories",
"area",
"bar",
"timeline",
"bar_polar",
"violin",
"box",
"strip",
"histogram",
"ecdf",
"choropleth",
"choropleth_mapbox",
"pie",
"other_pie",
"sunburst",
"treemap",
"icicle",
"funnel",
"funnel_area",
"imshow",
"data",
"colors",
"trendline_functions",
"set_mapbox_access_token",
"get_trendline_results",
"IdentityMap",
"Constant",
"Range",
"NO_COLOR",
]
from ._core import make_figure
from ._doc import make_docstring
import plotly.graph_objs as go
_wide_mode_xy_append = [
"Either `x` or `y` can optionally be a list of column references or array_likes, ",
"in which case the data will be treated as if it were 'wide' rather than 'long'.",
]
_cartesian_append_dict = dict(x=_wide_mode_xy_append, y=_wide_mode_xy_append)
def scatter(
data_frame=None,
x=None,
y=None,
color=None,
symbol=None,
size=None,
hover_name=None,
hover_data=None,
custom_data=None,
text=None,
facet_row=None,
facet_col=None,
facet_col_wrap=0,
facet_row_spacing=None,
facet_col_spacing=None,
error_x=None,
error_x_minus=None,
error_y=None,
error_y_minus=None,
animation_frame=None,
animation_group=None,
category_orders=None,
labels=None,
orientation=None,
color_discrete_sequence=None,
color_discrete_map=None,
color_continuous_scale=None,
range_color=None,
color_continuous_midpoint=None,
symbol_sequence=None,
symbol_map=None,
opacity=None,
size_max=None,
marginal_x=None,
marginal_y=None,
trendline=None,
trendline_options=None,
trendline_color_override=None,
trendline_scope="trace",
log_x=False,
log_y=False,
range_x=None,
range_y=None,
render_mode="auto",
title=None,
template=None,
width=None,
height=None,
):
"""
In a scatter plot, each row of `data_frame` is represented by a symbol
mark in 2D space.
"""
return make_figure(args=locals(), constructor=go.Scatter)
scatter.__doc__ = make_docstring(scatter, append_dict=_cartesian_append_dict)
def density_contour(
data_frame=None,
x=None,
y=None,
z=None,
color=None,
facet_row=None,
facet_col=None,
facet_col_wrap=0,
facet_row_spacing=None,
facet_col_spacing=None,
hover_name=None,
hover_data=None,
animation_frame=None,
animation_group=None,
category_orders=None,
labels=None,
orientation=None,
color_discrete_sequence=None,
color_discrete_map=None,
marginal_x=None,
marginal_y=None,
trendline=None,
trendline_options=None,
trendline_color_override=None,
trendline_scope="trace",
log_x=False,
log_y=False,
range_x=None,
range_y=None,
histfunc=None,
histnorm=None,
nbinsx=None,
nbinsy=None,
title=None,
template=None,
width=None,
height=None,
):
"""
In a density contour plot, rows of `data_frame` are grouped together
into contour marks to visualize the 2D distribution of an aggregate
function `histfunc` (e.g. the count or sum) of the value `z`.
"""
return make_figure(
args=locals(),
constructor=go.Histogram2dContour,
trace_patch=dict(
contours=dict(coloring="none"),
histfunc=histfunc,
histnorm=histnorm,
nbinsx=nbinsx,
nbinsy=nbinsy,
xbingroup="x",
ybingroup="y",
),
)
density_contour.__doc__ = make_docstring(
density_contour,
append_dict=dict(
x=_wide_mode_xy_append,
y=_wide_mode_xy_append,
z=[
"For `density_heatmap` and `density_contour` these values are used as the inputs to `histfunc`.",
],
histfunc=["The arguments to this function are the values of `z`."],
),
)
def density_heatmap(
data_frame=None,
x=None,
y=None,
z=None,
facet_row=None,
facet_col=None,
facet_col_wrap=0,
facet_row_spacing=None,
facet_col_spacing=None,
hover_name=None,
hover_data=None,
animation_frame=None,
animation_group=None,
category_orders=None,
labels=None,
orientation=None,
color_continuous_scale=None,
range_color=None,
color_continuous_midpoint=None,
marginal_x=None,
marginal_y=None,
opacity=None,
log_x=False,
log_y=False,
range_x=None,
range_y=None,
histfunc=None,
histnorm=None,
nbinsx=None,
nbinsy=None,
title=None,
template=None,
width=None,
height=None,
):
"""
In a density heatmap, rows of `data_frame` are grouped together into
colored rectangular tiles to visualize the 2D distribution of an
aggregate function `histfunc` (e.g. the count or sum) of the value `z`.
"""
return make_figure(
args=locals(),
constructor=go.Histogram2d,
trace_patch=dict(
histfunc=histfunc,
histnorm=histnorm,
nbinsx=nbinsx,
nbinsy=nbinsy,
xbingroup="x",
ybingroup="y",
),
)
density_heatmap.__doc__ = make_docstring(
density_heatmap,
append_dict=dict(
x=_wide_mode_xy_append,
y=_wide_mode_xy_append,
z=[
"For `density_heatmap` and `density_contour` these values are used as the inputs to `histfunc`.",
],
histfunc=["The arguments to this function are the values of `z`.",],
),
)
def line(
data_frame=None,
x=None,
y=None,
line_group=None,
color=None,
line_dash=None,
symbol=None,
hover_name=None,
hover_data=None,
custom_data=None,
text=None,
facet_row=None,
facet_col=None,
facet_col_wrap=0,
facet_row_spacing=None,
facet_col_spacing=None,
error_x=None,
error_x_minus=None,
error_y=None,
error_y_minus=None,
animation_frame=None,
animation_group=None,
category_orders=None,
labels=None,
orientation=None,
color_discrete_sequence=None,
color_discrete_map=None,
line_dash_sequence=None,
line_dash_map=None,
symbol_sequence=None,
symbol_map=None,
markers=False,
log_x=False,
log_y=False,
range_x=None,
range_y=None,
line_shape=None,
render_mode="auto",
title=None,
template=None,
width=None,
height=None,
):
"""
In a 2D line plot, each row of `data_frame` is represented as vertex of
a polyline mark in 2D space.
"""
return make_figure(args=locals(), constructor=go.Scatter)
line.__doc__ = make_docstring(line, append_dict=_cartesian_append_dict)
def area(
data_frame=None,
x=None,
y=None,
line_group=None,
color=None,
symbol=None,
hover_name=None,
hover_data=None,
custom_data=None,
text=None,
facet_row=None,
facet_col=None,
facet_col_wrap=0,
facet_row_spacing=None,
facet_col_spacing=None,
animation_frame=None,
animation_group=None,
category_orders=None,
labels=None,
color_discrete_sequence=None,
color_discrete_map=None,
symbol_sequence=None,
symbol_map=None,
markers=False,
orientation=None,
groupnorm=None,
log_x=False,
log_y=False,
range_x=None,
range_y=None,
line_shape=None,
title=None,
template=None,
width=None,
height=None,
):
"""
In a stacked area plot, each row of `data_frame` is represented as
vertex of a polyline mark in 2D space. The area between successive
polylines is filled.
"""
return make_figure(
args=locals(),
constructor=go.Scatter,
trace_patch=dict(stackgroup=1, mode="lines", groupnorm=groupnorm),
)
area.__doc__ = make_docstring(area, append_dict=_cartesian_append_dict)
def bar(
data_frame=None,
x=None,
y=None,
color=None,
pattern_shape=None,
facet_row=None,
facet_col=None,
facet_col_wrap=0,
facet_row_spacing=None,
facet_col_spacing=None,
hover_name=None,
hover_data=None,
custom_data=None,
text=None,
base=None,
error_x=None,
error_x_minus=None,
error_y=None,
error_y_minus=None,
animation_frame=None,
animation_group=None,
category_orders=None,
labels=None,
color_discrete_sequence=None,
color_discrete_map=None,
color_continuous_scale=None,
pattern_shape_sequence=None,
pattern_shape_map=None,
range_color=None,
color_continuous_midpoint=None,
opacity=None,
orientation=None,
barmode="relative",
log_x=False,
log_y=False,
range_x=None,
range_y=None,
title=None,
template=None,
width=None,
height=None,
):
"""
In a bar plot, each row of `data_frame` is represented as a rectangular
mark.
"""
return make_figure(
args=locals(),
constructor=go.Bar,
trace_patch=dict(textposition="auto"),
layout_patch=dict(barmode=barmode),
)
bar.__doc__ = make_docstring(bar, append_dict=_cartesian_append_dict)
def timeline(
data_frame=None,
x_start=None,
x_end=None,
y=None,
color=None,
facet_row=None,
facet_col=None,
facet_col_wrap=0,
facet_row_spacing=None,
facet_col_spacing=None,
hover_name=None,
hover_data=None,
custom_data=None,
text=None,
animation_frame=None,
animation_group=None,
category_orders=None,
labels=None,
color_discrete_sequence=None,
color_discrete_map=None,
color_continuous_scale=None,
range_color=None,
color_continuous_midpoint=None,
opacity=None,
range_x=None,
range_y=None,
title=None,
template=None,
width=None,
height=None,
):
"""
In a timeline plot, each row of `data_frame` is represented as a rectangular
mark on an x axis of type `date`, spanning from `x_start` to `x_end`.
"""
return make_figure(
args=locals(),
constructor="timeline",
trace_patch=dict(textposition="auto", orientation="h"),
layout_patch=dict(barmode="overlay"),
)
timeline.__doc__ = make_docstring(timeline)
def histogram(
data_frame=None,
x=None,
y=None,
color=None,
pattern_shape=None,
facet_row=None,
facet_col=None,
facet_col_wrap=0,
facet_row_spacing=None,
facet_col_spacing=None,
hover_name=None,
hover_data=None,
animation_frame=None,
animation_group=None,
category_orders=None,
labels=None,
color_discrete_sequence=None,
color_discrete_map=None,
pattern_shape_sequence=None,
pattern_shape_map=None,
marginal=None,
opacity=None,
orientation=None,
barmode="relative",
barnorm=None,
histnorm=None,
log_x=False,
log_y=False,
range_x=None,
range_y=None,
histfunc=None,
cumulative=None,
nbins=None,
title=None,
template=None,
width=None,
height=None,
):
"""
In a histogram, rows of `data_frame` are grouped together into a
rectangular mark to visualize the 1D distribution of an aggregate
function `histfunc` (e.g. the count or sum) of the value `y` (or `x` if
`orientation` is `'h'`).
"""
return make_figure(
args=locals(),
constructor=go.Histogram,
trace_patch=dict(
histnorm=histnorm, histfunc=histfunc, cumulative=dict(enabled=cumulative),
),
layout_patch=dict(barmode=barmode, barnorm=barnorm),
)
histogram.__doc__ = make_docstring(
histogram,
append_dict=dict(
x=["If `orientation` is `'h'`, these values are used as inputs to `histfunc`."]
+ _wide_mode_xy_append,
y=["If `orientation` is `'v'`, these values are used as inputs to `histfunc`."]
+ _wide_mode_xy_append,
histfunc=[
"The arguments to this function are the values of `y`(`x`) if `orientation` is `'v'`(`'h'`).",
],
),
)
def ecdf(
data_frame=None,
x=None,
y=None,
color=None,
text=None,
line_dash=None,
symbol=None,
facet_row=None,
facet_col=None,
facet_col_wrap=0,
facet_row_spacing=None,
facet_col_spacing=None,
hover_name=None,
hover_data=None,
animation_frame=None,
animation_group=None,
markers=False,
lines=True,
category_orders=None,
labels=None,
color_discrete_sequence=None,
color_discrete_map=None,
line_dash_sequence=None,
line_dash_map=None,
symbol_sequence=None,
symbol_map=None,
marginal=None,
opacity=None,
orientation=None,
ecdfnorm="probability",
ecdfmode="standard",
render_mode="auto",
log_x=False,
log_y=False,
range_x=None,
range_y=None,
title=None,
template=None,
width=None,
height=None,
):
"""
In a Empirical Cumulative Distribution Function (ECDF) plot, rows of `data_frame`
are sorted by the value `x` (or `y` if `orientation` is `'h'`) and their cumulative
count (or the cumulative sum of `y` if supplied and `orientation` is `h`) is drawn
as a line.
"""
return make_figure(args=locals(), constructor=go.Scatter)
ecdf.__doc__ = make_docstring(
ecdf,
append_dict=dict(
x=[
"If `orientation` is `'h'`, the cumulative sum of this argument is plotted rather than the cumulative count."
]
+ _wide_mode_xy_append,
y=[
"If `orientation` is `'v'`, the cumulative sum of this argument is plotted rather than the cumulative count."
]
+ _wide_mode_xy_append,
),
)
def violin(
data_frame=None,
x=None,
y=None,
color=None,
facet_row=None,
facet_col=None,
facet_col_wrap=0,
facet_row_spacing=None,
facet_col_spacing=None,
hover_name=None,
hover_data=None,
custom_data=None,
animation_frame=None,
animation_group=None,
category_orders=None,
labels=None,
color_discrete_sequence=None,
color_discrete_map=None,
orientation=None,
violinmode=None,
log_x=False,
log_y=False,
range_x=None,
range_y=None,
points=None,
box=False,
title=None,
template=None,
width=None,
height=None,
):
"""
In a violin plot, rows of `data_frame` are grouped together into a
curved mark to visualize their distribution.
"""
return make_figure(
args=locals(),
constructor=go.Violin,
trace_patch=dict(
points=points, box=dict(visible=box), scalegroup=True, x0=" ", y0=" ",
),
layout_patch=dict(violinmode=violinmode),
)
violin.__doc__ = make_docstring(violin, append_dict=_cartesian_append_dict)
def box(
data_frame=None,
x=None,
y=None,
color=None,
facet_row=None,
facet_col=None,
facet_col_wrap=0,
facet_row_spacing=None,
facet_col_spacing=None,
hover_name=None,
hover_data=None,
custom_data=None,
animation_frame=None,
animation_group=None,
category_orders=None,
labels=None,
color_discrete_sequence=None,
color_discrete_map=None,
orientation=None,
boxmode=None,
log_x=False,
log_y=False,
range_x=None,
range_y=None,
points=None,
notched=False,
title=None,
template=None,
width=None,
height=None,
):
"""
In a box plot, rows of `data_frame` are grouped together into a
box-and-whisker mark to visualize their distribution.
Each box spans from quartile 1 (Q1) to quartile 3 (Q3). The second
quartile (Q2) is marked by a line inside the box. By default, the
whiskers correspond to the box' edges +/- 1.5 times the interquartile
range (IQR: Q3-Q1), see "points" for other options.
"""
return make_figure(
args=locals(),
constructor=go.Box,
trace_patch=dict(boxpoints=points, notched=notched, x0=" ", y0=" "),
layout_patch=dict(boxmode=boxmode),
)
box.__doc__ = make_docstring(box, append_dict=_cartesian_append_dict)
def strip(
data_frame=None,
x=None,
y=None,
color=None,
facet_row=None,
facet_col=None,
facet_col_wrap=0,
facet_row_spacing=None,
facet_col_spacing=None,
hover_name=None,
hover_data=None,
custom_data=None,
animation_frame=None,
animation_group=None,
category_orders=None,
labels=None,
color_discrete_sequence=None,
color_discrete_map=None,
orientation=None,
stripmode=None,
log_x=False,
log_y=False,
range_x=None,
range_y=None,
title=None,
template=None,
width=None,
height=None,
):
"""
In a strip plot each row of `data_frame` is represented as a jittered
mark within categories.
"""
return make_figure(
args=locals(),
constructor=go.Box,
trace_patch=dict(
boxpoints="all",
pointpos=0,
hoveron="points",
fillcolor="rgba(255,255,255,0)",
line={"color": "rgba(255,255,255,0)"},
x0=" ",
y0=" ",
),
layout_patch=dict(boxmode=stripmode),
)
strip.__doc__ = make_docstring(strip, append_dict=_cartesian_append_dict)
def scatter_3d(
data_frame=None,
x=None,
y=None,
z=None,
color=None,
symbol=None,
size=None,
text=None,
hover_name=None,
hover_data=None,
custom_data=None,
error_x=None,
error_x_minus=None,
error_y=None,
error_y_minus=None,
error_z=None,
error_z_minus=None,
animation_frame=None,
animation_group=None,
category_orders=None,
labels=None,
size_max=None,
color_discrete_sequence=None,
color_discrete_map=None,
color_continuous_scale=None,
range_color=None,
color_continuous_midpoint=None,
symbol_sequence=None,
symbol_map=None,
opacity=None,
log_x=False,
log_y=False,
log_z=False,
range_x=None,
range_y=None,
range_z=None,
title=None,
template=None,
width=None,
height=None,
):
"""
In a 3D scatter plot, each row of `data_frame` is represented by a
symbol mark in 3D space.
"""
return make_figure(args=locals(), constructor=go.Scatter3d)
scatter_3d.__doc__ = make_docstring(scatter_3d)
def line_3d(
data_frame=None,
x=None,
y=None,
z=None,
color=None,
line_dash=None,
text=None,
line_group=None,
symbol=None,
hover_name=None,
hover_data=None,
custom_data=None,
error_x=None,
error_x_minus=None,
error_y=None,
error_y_minus=None,
error_z=None,
error_z_minus=None,
animation_frame=None,
animation_group=None,
category_orders=None,
labels=None,
color_discrete_sequence=None,
color_discrete_map=None,
line_dash_sequence=None,
line_dash_map=None,
symbol_sequence=None,
symbol_map=None,
markers=False,
log_x=False,
log_y=False,
log_z=False,
range_x=None,
range_y=None,
range_z=None,
title=None,
template=None,
width=None,
height=None,
):
"""
In a 3D line plot, each row of `data_frame` is represented as vertex of
a polyline mark in 3D space.
"""
return make_figure(args=locals(), constructor=go.Scatter3d)
line_3d.__doc__ = make_docstring(line_3d)
def scatter_ternary(
data_frame=None,
a=None,
b=None,
c=None,
color=None,
symbol=None,
size=None,
text=None,
hover_name=None,
hover_data=None,
custom_data=None,
animation_frame=None,
animation_group=None,
category_orders=None,
labels=None,
color_discrete_sequence=None,
color_discrete_map=None,
color_continuous_scale=None,
range_color=None,
color_continuous_midpoint=None,
symbol_sequence=None,
symbol_map=None,
opacity=None,
size_max=None,
title=None,
template=None,
width=None,
height=None,
):
"""
In a ternary scatter plot, each row of `data_frame` is represented by a
symbol mark in ternary coordinates.
"""
return make_figure(args=locals(), constructor=go.Scatterternary)
scatter_ternary.__doc__ = make_docstring(scatter_ternary)
def line_ternary(
data_frame=None,
a=None,
b=None,
c=None,
color=None,
line_dash=None,
line_group=None,
symbol=None,
hover_name=None,
hover_data=None,
custom_data=None,
text=None,
animation_frame=None,
animation_group=None,
category_orders=None,
labels=None,
color_discrete_sequence=None,
color_discrete_map=None,
line_dash_sequence=None,
line_dash_map=None,
symbol_sequence=None,
symbol_map=None,
markers=False,
line_shape=None,
title=None,
template=None,
width=None,
height=None,
):
"""
In a ternary line plot, each row of `data_frame` is represented as
vertex of a polyline mark in ternary coordinates.
"""
return make_figure(args=locals(), constructor=go.Scatterternary)
line_ternary.__doc__ = make_docstring(line_ternary)
def scatter_polar(
data_frame=None,
r=None,
theta=None,
color=None,
symbol=None,
size=None,
hover_name=None,
hover_data=None,
custom_data=None,
text=None,
animation_frame=None,
animation_group=None,
category_orders=None,
labels=None,
color_discrete_sequence=None,
color_discrete_map=None,
color_continuous_scale=None,
range_color=None,
color_continuous_midpoint=None,
symbol_sequence=None,
symbol_map=None,
opacity=None,
direction="clockwise",
start_angle=90,
size_max=None,
range_r=None,
range_theta=None,
log_r=False,
render_mode="auto",
title=None,
template=None,
width=None,
height=None,
):
"""
In a polar scatter plot, each row of `data_frame` is represented by a
symbol mark in polar coordinates.
"""
return make_figure(args=locals(), constructor=go.Scatterpolar)
scatter_polar.__doc__ = make_docstring(scatter_polar)
def line_polar(
data_frame=None,
r=None,
theta=None,
color=None,
line_dash=None,
hover_name=None,
hover_data=None,
custom_data=None,
line_group=None,
text=None,
symbol=None,
animation_frame=None,
animation_group=None,
category_orders=None,
labels=None,
color_discrete_sequence=None,
color_discrete_map=None,
line_dash_sequence=None,
line_dash_map=None,
symbol_sequence=None,
symbol_map=None,
markers=False,
direction="clockwise",
start_angle=90,
line_close=False,
line_shape=None,
render_mode="auto",
range_r=None,
range_theta=None,
log_r=False,
title=None,
template=None,
width=None,
height=None,
):
"""
In a polar line plot, each row of `data_frame` is represented as vertex
of a polyline mark in polar coordinates.
"""
return make_figure(args=locals(), constructor=go.Scatterpolar)
line_polar.__doc__ = make_docstring(line_polar)
def bar_polar(
data_frame=None,
r=None,
theta=None,
color=None,
pattern_shape=None,
hover_name=None,
hover_data=None,
custom_data=None,
base=None,
animation_frame=None,
animation_group=None,
category_orders=None,
labels=None,
color_discrete_sequence=None,
color_discrete_map=None,
color_continuous_scale=None,
pattern_shape_sequence=None,
pattern_shape_map=None,
range_color=None,
color_continuous_midpoint=None,
barnorm=None,
barmode="relative",
direction="clockwise",
start_angle=90,
range_r=None,
range_theta=None,
log_r=False,
title=None,
template=None,
width=None,
height=None,
):
"""
In a polar bar plot, each row of `data_frame` is represented as a wedge
mark in polar coordinates.
"""
return make_figure(
args=locals(),
constructor=go.Barpolar,
layout_patch=dict(barnorm=barnorm, barmode=barmode),
)
bar_polar.__doc__ = make_docstring(bar_polar)
def choropleth(
data_frame=None,
lat=None,
lon=None,
locations=None,
locationmode=None,
geojson=None,
featureidkey=None,
color=None,
facet_row=None,
facet_col=None,
facet_col_wrap=0,
facet_row_spacing=None,
facet_col_spacing=None,
hover_name=None,
hover_data=None,
custom_data=None,
animation_frame=None,
animation_group=None,
category_orders=None,
labels=None,
color_discrete_sequence=None,
color_discrete_map=None,
color_continuous_scale=None,
range_color=None,
color_continuous_midpoint=None,
projection=None,
scope=None,
center=None,
fitbounds=None,
basemap_visible=None,
title=None,
template=None,
width=None,
height=None,
):
"""
In a choropleth map, each row of `data_frame` is represented by a
colored region mark on a map.
"""
return make_figure(
args=locals(),
constructor=go.Choropleth,
trace_patch=dict(locationmode=locationmode),
)
choropleth.__doc__ = make_docstring(choropleth)
def scatter_geo(
data_frame=None,
lat=None,
lon=None,
locations=None,
locationmode=None,
geojson=None,
featureidkey=None,
color=None,
text=None,
symbol=None,
facet_row=None,
facet_col=None,
facet_col_wrap=0,
facet_row_spacing=None,
facet_col_spacing=None,
hover_name=None,
hover_data=None,
custom_data=None,
size=None,
animation_frame=None,
animation_group=None,
category_orders=None,
labels=None,
color_discrete_sequence=None,
color_discrete_map=None,
color_continuous_scale=None,
range_color=None,
color_continuous_midpoint=None,
symbol_sequence=None,
symbol_map=None,
opacity=None,
size_max=None,
projection=None,
scope=None,
center=None,
fitbounds=None,
basemap_visible=None,
title=None,
template=None,
width=None,
height=None,
):
"""
In a geographic scatter plot, each row of `data_frame` is represented
by a symbol mark on a map.
"""
return make_figure(
args=locals(),
constructor=go.Scattergeo,
trace_patch=dict(locationmode=locationmode),
)
scatter_geo.__doc__ = make_docstring(scatter_geo)
def line_geo(
data_frame=None,
lat=None,
lon=None,
locations=None,
locationmode=None,
geojson=None,
featureidkey=None,
color=None,
line_dash=None,
text=None,
facet_row=None,
facet_col=None,
facet_col_wrap=0,
facet_row_spacing=None,
facet_col_spacing=None,
hover_name=None,
hover_data=None,
custom_data=None,
line_group=None,
symbol=None,
animation_frame=None,
animation_group=None,
category_orders=None,
labels=None,
color_discrete_sequence=None,
color_discrete_map=None,
line_dash_sequence=None,
line_dash_map=None,
symbol_sequence=None,
symbol_map=None,
markers=False,
projection=None,
scope=None,
center=None,
fitbounds=None,
basemap_visible=None,
title=None,
template=None,
width=None,
height=None,
):
"""
In a geographic line plot, each row of `data_frame` is represented as
vertex of a polyline mark on a map.
"""
return make_figure(
args=locals(),
constructor=go.Scattergeo,
trace_patch=dict(locationmode=locationmode),
)
line_geo.__doc__ = make_docstring(line_geo)
def scatter_mapbox(
data_frame=None,
lat=None,
lon=None,
color=None,
text=None,
hover_name=None,
hover_data=None,
custom_data=None,
size=None,
animation_frame=None,
animation_group=None,
category_orders=None,
labels=None,
color_discrete_sequence=None,
color_discrete_map=None,
color_continuous_scale=None,
range_color=None,
color_continuous_midpoint=None,
opacity=None,
size_max=None,
zoom=8,
center=None,
mapbox_style=None,
title=None,
template=None,
width=None,
height=None,
):
"""
In a Mapbox scatter plot, each row of `data_frame` is represented by a
symbol mark on a Mapbox map.
"""
return make_figure(args=locals(), constructor=go.Scattermapbox)
scatter_mapbox.__doc__ = make_docstring(scatter_mapbox)
def choropleth_mapbox(
data_frame=None,
geojson=None,
featureidkey=None,
locations=None,
color=None,
hover_name=None,
hover_data=None,
custom_data=None,
animation_frame=None,
animation_group=None,
category_orders=None,
labels=None,
color_discrete_sequence=None,
color_discrete_map=None,
color_continuous_scale=None,
range_color=None,
color_continuous_midpoint=None,
opacity=None,
zoom=8,
center=None,
mapbox_style=None,
title=None,
template=None,
width=None,
height=None,
):
"""
In a Mapbox choropleth map, each row of `data_frame` is represented by a
colored region on a Mapbox map.
"""
return make_figure(args=locals(), constructor=go.Choroplethmapbox)
choropleth_mapbox.__doc__ = make_docstring(choropleth_mapbox)
def density_mapbox(
data_frame=None,
lat=None,
lon=None,
z=None,
hover_name=None,
hover_data=None,
custom_data=None,
animation_frame=None,
animation_group=None,
category_orders=None,
labels=None,
color_continuous_scale=None,
range_color=None,
color_continuous_midpoint=None,
opacity=None,
zoom=8,
center=None,
mapbox_style=None,
radius=None,
title=None,
template=None,
width=None,
height=None,
):
"""
In a Mapbox density map, each row of `data_frame` contributes to the intensity of
the color of the region around the corresponding point on the map
"""
return make_figure(
args=locals(), constructor=go.Densitymapbox, trace_patch=dict(radius=radius)
)
density_mapbox.__doc__ = make_docstring(density_mapbox)
def line_mapbox(
data_frame=None,
lat=None,
lon=None,
color=None,
text=None,
hover_name=None,
hover_data=None,
custom_data=None,
line_group=None,
animation_frame=None,
animation_group=None,
category_orders=None,
labels=None,
color_discrete_sequence=None,
color_discrete_map=None,
zoom=8,
center=None,
mapbox_style=None,
title=None,
template=None,
width=None,
height=None,
):
"""
In a Mapbox line plot, each row of `data_frame` is represented as
vertex of a polyline mark on a Mapbox map.
"""
return make_figure(args=locals(), constructor=go.Scattermapbox)
line_mapbox.__doc__ = make_docstring(line_mapbox)
def scatter_matrix(
data_frame=None,
dimensions=None,
color=None,
symbol=None,
size=None,
hover_name=None,
hover_data=None,
custom_data=None,
category_orders=None,
labels=None,
color_discrete_sequence=None,
color_discrete_map=None,
color_continuous_scale=None,
range_color=None,
color_continuous_midpoint=None,
symbol_sequence=None,
symbol_map=None,
opacity=None,
size_max=None,
title=None,
template=None,
width=None,
height=None,
):
"""
In a scatter plot matrix (or SPLOM), each row of `data_frame` is
represented by a multiple symbol marks, one in each cell of a grid of
2D scatter plots, which plot each pair of `dimensions` against each
other.
"""
return make_figure(
args=locals(), constructor=go.Splom, layout_patch=dict(dragmode="select")
)
scatter_matrix.__doc__ = make_docstring(scatter_matrix)
def parallel_coordinates(
data_frame=None,
dimensions=None,
color=None,
labels=None,
color_continuous_scale=None,
range_color=None,
color_continuous_midpoint=None,
title=None,
template=None,
width=None,
height=None,
):
"""
In a parallel coordinates plot, each row of `data_frame` is represented
by a polyline mark which traverses a set of parallel axes, one for each
of the `dimensions`.
"""
return make_figure(args=locals(), constructor=go.Parcoords)
parallel_coordinates.__doc__ = make_docstring(parallel_coordinates)
def parallel_categories(
data_frame=None,
dimensions=None,
color=None,
labels=None,
color_continuous_scale=None,
range_color=None,
color_continuous_midpoint=None,
title=None,
template=None,
width=None,
height=None,
dimensions_max_cardinality=50,
):
"""
In a parallel categories (or parallel sets) plot, each row of
`data_frame` is grouped with other rows that share the same values of
`dimensions` and then plotted as a polyline mark through a set of
parallel axes, one for each of the `dimensions`.
"""
return make_figure(args=locals(), constructor=go.Parcats)
parallel_categories.__doc__ = make_docstring(parallel_categories)
def pie(
data_frame=None,
names=None,
values=None,
color=None,
color_discrete_sequence=None,
color_discrete_map=None,
hover_name=None,
hover_data=None,
custom_data=None,
labels=None,
title=None,
template=None,
width=None,
height=None,
opacity=None,
hole=None,
):
"""
In a pie plot, each row of `data_frame` is represented as a sector of a
pie.
"""
if color_discrete_sequence is not None:
layout_patch = {"piecolorway": color_discrete_sequence}
else:
layout_patch = {}
return make_figure(
args=locals(),
constructor=go.Pie,
trace_patch=dict(showlegend=(names is not None), hole=hole),
layout_patch=layout_patch,
)
pie.__doc__ = make_docstring(
pie,
override_dict=dict(
hole=[
"float",
"Sets the fraction of the radius to cut out of the pie."
"Use this to make a donut chart.",
],
),
)
def other_pie(
data_frame=None,
names=None,
values=None,
color=None,
color_discrete_sequence=None,
color_discrete_map=None,
hover_name=None,
hover_data=None,
custom_data=None,
labels=None,
title=None,
template=None,
width=None,
height=None,
opacity=None,
hole=None,
n=None,
other_label=None
):
"""
In a other pie plot, if `n` is None less than 1 each row of `data_frame` represented as a sector of a
pie. Otherwise the `n-1` with the heighest valuess top `n-1` are represented as a sector of a pie and
additional sector with label `other_label` of size sum of values in all other rows represents that
remaining rows.
"""
if color_discrete_sequence is not None:
layout_patch = {"piecolorway": color_discrete_sequence}
else:
layout_patch = {}
if isinstance(n, int) and n > 1 and len(data_frame) > n:
data_frame = data_frame.sort_values(values, ascending=False)[[names, values]]
head_data_frame = data_frame.head(n-1)
tail_value = data_frame.tail(len(data_frame)-(n-1))[values].sum()
data_frame = head_data_frame.append({names: other_label, values: tail_value}, ignore_index=True)
return make_figure(
args=locals(),
constructor=go.Pie,
trace_patch=dict(showlegend=(names is not None), hole=hole),
layout_patch=layout_patch,
)
def sunburst(
data_frame=None,
names=None,
values=None,
parents=None,
path=None,
ids=None,
color=None,
color_continuous_scale=None,
range_color=None,
color_continuous_midpoint=None,
color_discrete_sequence=None,
color_discrete_map=None,
hover_name=None,
hover_data=None,
custom_data=None,
labels=None,
title=None,
template=None,
width=None,
height=None,
branchvalues=None,
maxdepth=None,
):
"""
A sunburst plot represents hierarchial data as sectors laid out over
several levels of concentric rings.
"""
if color_discrete_sequence is not None:
layout_patch = {"sunburstcolorway": color_discrete_sequence}
else:
layout_patch = {}
if path is not None and (ids is not None or parents is not None):
raise ValueError(
"Either `path` should be provided, or `ids` and `parents`."
"These parameters are mutually exclusive and cannot be passed together."
)
if path is not None and branchvalues is None:
branchvalues = "total"
return make_figure(
args=locals(),
constructor=go.Sunburst,
trace_patch=dict(branchvalues=branchvalues, maxdepth=maxdepth),
layout_patch=layout_patch,
)
sunburst.__doc__ = make_docstring(sunburst)
def treemap(
data_frame=None,
names=None,
values=None,
parents=None,
ids=None,
path=None,
color=None,
color_continuous_scale=None,
range_color=None,
color_continuous_midpoint=None,
color_discrete_sequence=None,
color_discrete_map=None,
hover_name=None,
hover_data=None,
custom_data=None,
labels=None,
title=None,
template=None,
width=None,
height=None,
branchvalues=None,
maxdepth=None,
):
"""
A treemap plot represents hierarchial data as nested rectangular
sectors.
"""
if color_discrete_sequence is not None:
layout_patch = {"treemapcolorway": color_discrete_sequence}
else:
layout_patch = {}
if path is not None and (ids is not None or parents is not None):
raise ValueError(
"Either `path` should be provided, or `ids` and `parents`."
"These parameters are mutually exclusive and cannot be passed together."
)
if path is not None and branchvalues is None:
branchvalues = "total"
return make_figure(
args=locals(),
constructor=go.Treemap,
trace_patch=dict(branchvalues=branchvalues, maxdepth=maxdepth),
layout_patch=layout_patch,
)
treemap.__doc__ = make_docstring(treemap)
def icicle(
data_frame=None,
names=None,
values=None,
parents=None,
path=None,
ids=None,
color=None,
color_continuous_scale=None,
range_color=None,
color_continuous_midpoint=None,
color_discrete_sequence=None,
color_discrete_map=None,
hover_name=None,
hover_data=None,
custom_data=None,
labels=None,
title=None,
template=None,
width=None,
height=None,
branchvalues=None,
maxdepth=None,
):
"""
An icicle plot represents hierarchial data with adjoined rectangular
sectors that all cascade from root down to leaf in one direction.
"""
if color_discrete_sequence is not None:
layout_patch = {"iciclecolorway": color_discrete_sequence}
else:
layout_patch = {}
if path is not None and (ids is not None or parents is not None):
raise ValueError(
"Either `path` should be provided, or `ids` and `parents`."
"These parameters are mutually exclusive and cannot be passed together."
)
if path is not None and branchvalues is None:
branchvalues = "total"
return make_figure(
args=locals(),
constructor=go.Icicle,
trace_patch=dict(branchvalues=branchvalues, maxdepth=maxdepth),
layout_patch=layout_patch,
)
icicle.__doc__ = make_docstring(icicle)
def funnel(
data_frame=None,
x=None,
y=None,
color=None,
facet_row=None,
facet_col=None,
facet_col_wrap=0,
facet_row_spacing=None,
facet_col_spacing=None,
hover_name=None,
hover_data=None,
custom_data=None,
text=None,
animation_frame=None,
animation_group=None,
category_orders=None,
labels=None,
color_discrete_sequence=None,
color_discrete_map=None,
opacity=None,
orientation=None,
log_x=False,
log_y=False,
range_x=None,
range_y=None,
title=None,
template=None,
width=None,
height=None,
):
"""
In a funnel plot, each row of `data_frame` is represented as a
rectangular sector of a funnel.
"""
return make_figure(args=locals(), constructor=go.Funnel)
funnel.__doc__ = make_docstring(funnel, append_dict=_cartesian_append_dict)
def funnel_area(
data_frame=None,
names=None,
values=None,
color=None,
color_discrete_sequence=None,
color_discrete_map=None,
hover_name=None,
hover_data=None,
custom_data=None,
labels=None,
title=None,
template=None,
width=None,
height=None,
opacity=None,
):
"""
In a funnel area plot, each row of `data_frame` is represented as a
trapezoidal sector of a funnel.
"""
if color_discrete_sequence is not None:
layout_patch = {"funnelareacolorway": color_discrete_sequence}
else:
layout_patch = {}
return make_figure(
args=locals(),
constructor=go.Funnelarea,
trace_patch=dict(showlegend=(names is not None)),
layout_patch=layout_patch,
)
funnel_area.__doc__ = make_docstring(funnel_area)
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment