Help on class Contour in module plotly.graph_objs.graph_objs:
class Contour(PlotlyDict)
| Valid attributes for 'contour' at path [] under parents ():
|
| ['autocontour', 'zmax', 'ysrc', 'colorbar', 'xaxis', 'hoverinfo',
| 'contours', 'yaxis', 'opacity', 'dx', 'colorscale', 'line', 'uid',
| 'xsrc', 'showlegend', 'legendgroup', 'dy', 'transpose', 'text', 'zauto',
| 'stream', 'zsrc', 'showscale', 'ncontours', 'ytype', 'y0', 'z', 'name',
| 'zmin', 'connectgaps', 'xtype', 'reversescale', 'y', 'x0', 'x',
| 'visible', 'textsrc', 'type', 'autocolorscale']
|
| Run `<contour-object>.help('attribute')` on any of the above.
| '<contour-object>' is the object at []
|
| Method resolution order:
| Contour
| PlotlyDict
| builtins.dict
| PlotlyBase
| builtins.object
|
| Methods inherited from PlotlyDict:
|
| __copy__(self)
|
| __deepcopy__(self, memodict={})
|
| __dir__(self)
| Dynamically return the existing and possible attributes.
|
| __getattr__(self, key)
| Python only calls this when key is missing!
|
| __getitem__(self, key)
| Calls __missing__ when key is not found. May mutate object.
|
| __init__(self, *args, **kwargs)
|
| __missing__(self, key)
| Mimics defaultdict. This is called from __getitem__ when key DNE.
|
| __setattr__(self, key, value)
| Maps __setattr__ onto __setitem__
|
| __setitem__(self, key, value, _raise=True)
| Validates/Converts values which should be Graph Objects.
|
| force_clean(self, **kwargs)
| Recursively remove empty/None values.
|
| get_data(self, flatten=False)
| Returns the JSON for the plot with non-data elements stripped.
|
| get_ordered(self, **kwargs)
| Return a predictable, OrderedDict version of self.
|
| help(self, attribute=None, return_help=False)
| Print help string for this object or an attribute of this object.
|
| :param (str) attribute: A valid attribute string for this object.
| :param (bool) return_help: Return help_string instead of printing it?
| :return: (None|str)
|
| strip_style(self)
| Recursively strip style from the current representation.
|
| All PlotlyDicts and PlotlyLists are guaranteed to survive the
| stripping process, though they made be left empty. This is allowable.
|
| Keys that will be stripped in this process are tagged with
| `'type': 'style'` in graph_objs_meta.json. Note that a key tagged as
| style, but with an array as a value may still be considered data.
|
| to_string(self, level=0, indent=4, eol='\n', pretty=True, max_chars=80)
| Returns a formatted string showing graph_obj constructors.
|
| :param (int) level: The number of indentations to start with.
| :param (int) indent: The indentation amount.
| :param (str) eol: The end of line character(s).
| :param (bool) pretty: Curtail long list output with a '..' ?
| :param (int) max_chars: The max characters per line.
|
| Example:
|
| print(obj.to_string())
|
| update(self, dict1=None, **dict2)
| Update current dict with dict1 and then dict2.
|
| This recursively updates the structure of the original dictionary-like
| object with the new entries in the second and third objects. This
| allows users to update with large, nested structures.
|
| Note, because the dict2 packs up all the keyword arguments, you can
| specify the changes as a list of keyword agruments.
|
| Examples:
| # update with dict
| obj = Layout(title='my title', xaxis=XAxis(range=[0,1], domain=[0,1]))
| update_dict = dict(title='new title', xaxis=dict(domain=[0,.8]))
| obj.update(update_dict)
| obj
| {'title': 'new title', 'xaxis': {'range': [0,1], 'domain': [0,.8]}}
|
| # update with list of keyword arguments
| obj = Layout(title='my title', xaxis=XAxis(range=[0,1], domain=[0,1]))
| obj.update(title='new title', xaxis=dict(domain=[0,.8]))
| obj
| {'title': 'new title', 'xaxis': {'range': [0,1], 'domain': [0,.8]}}
|
| This 'fully' supports duck-typing in that the call signature is
| identical, however this differs slightly from the normal update
| method provided by Python's dictionaries.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from PlotlyDict:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.dict:
|
| __contains__(self, key, /)
| True if D has a key k, else False.
|
| __delitem__(self, key, /)
| Delete self[key].
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __gt__(self, value, /)
| Return self>value.
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| __repr__(self, /)
| Return repr(self).
|
| __sizeof__(...)
| D.__sizeof__() -> size of D in memory, in bytes
|
| clear(...)
| D.clear() -> None. Remove all items from D.
|
| copy(...)
| D.copy() -> a shallow copy of D
|
| fromkeys(iterable, value=None, /) from builtins.type
| Returns a new dict with keys from iterable and values equal to value.
|
| get(...)
| D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None.
|
| items(...)
| D.items() -> a set-like object providing a view on D's items
|
| keys(...)
| D.keys() -> a set-like object providing a view on D's keys
|
| pop(...)
| D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
| If key is not found, d is returned if given, otherwise KeyError is raised
|
| popitem(...)
| D.popitem() -> (k, v), remove and return some (key, value) pair as a
| 2-tuple; but raise KeyError if D is empty.
|
| setdefault(...)
| D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
|
| values(...)
| D.values() -> an object providing a view on D's values
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from builtins.dict:
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Methods inherited from PlotlyBase:
|
| to_graph_objs(self, **kwargs)
| Everything is cast into graph_objs. Here for backwards compat.
|
| validate(self)
| Everything is *always* validated now. keep for backwards compat.