Help on class Scatter3d in module plotly.graph_objs.graph_objs:
class Scatter3d(PlotlyTrace)
| A dictionary-like object for representing a 3D scatter trace in plotly.
|
| Quick method reference:
|
| Scatter3d.update(changes)
| Scatter3d.strip_style()
| Scatter3d.get_data()
| Scatter3d.to_graph_objs()
| Scatter3d.validate()
| Scatter3d.to_string()
| Scatter3d.force_clean()
|
| Valid keys:
|
| x [required=True] (value=list or 1d numpy array of numbers, strings,
| datetimes or list of lists or 2d numpy array of numbers) (streamable):
| Sets the x coordinates of the points of this 3D scatter trace. If
| 'x' is linked to a list or 1d numpy array of strings, then the x
| coordinates are integers, 0, 1, 2, 3, ..., labeled on the x-axis by
| the list or 1d numpy array of strings linked to 'x'.
|
| y [required=True] (value=list or 1d numpy array of numbers, strings,
| datetimes or list of lists or 2d numpy array of numbers) (streamable):
| Sets the y coordinates of the points of this 3D scatter trace. If
| 'y' is linked to a list or 1d numpy array of strings, then the y
| coordinates are integers, 0, 1, 2, 3, ..., labeled on the y-axis by
| the list or 1d numpy array of strings linked to 'y'.
|
| z [required=True] (value=list or 1d numpy array of numbers, strings,
| datetimes or list of lists or 2d numpy array of numbers) (streamable):
| Sets the z coordinates of the points of this scatter trace. If 'z'
| is linked to a list or 1d numpy array of strings, then the z
| coordinates are integers, 0, 1, 2, 3, ..., labeled on the z-axis by
| the list or 1d numpy array of strings linked to 'z'.
|
| mode [required=False] (value='lines' | 'markers' | 'text' |
| 'lines+markers' | 'lines+text' | 'markers+text' | 'lines+markers+text'):
| Plotting mode for this 3D scatter trace. If the mode includes 'text'
| then the 'text' will appear at the (x,y) points, otherwise it will
| appear on hover.
|
| name [required=False] (value=a string):
| The label associated with this trace. This name will appear in the
| column header in the online spreadsheet.
|
| text [required=False] (value=list or 1d numpy array of strings)
| (streamable):
| The text elements associated with each (x,y,z) pair in this 3D
| scatter trace. If the scatter 'mode' does not include 'text' then
| elements linked to 'text' will appear on hover only. In contrast, if
| 'text' is included in 'mode', the elements in 'text' will be
| rendered on the plot at the locations specified in part by their
| corresponding (x,y,z) coordinate pair and the 'textposition' key.
|
| error_z [required=False] (value=ErrorZ object | dictionary-like object)
| (streamable):
| Links a dictionary-like object describing the z-axis error bars that
| can be drawn from the (x,y,z) coordinates of this 3D scatter trace.
|
| For more, run `help(plotly.graph_objs.ErrorZ)`
|
| error_y [required=False] (value=ErrorY object | dictionary-like object)
| (streamable):
| Links a dictionary-like object describing the y-axis error bars that
| can be drawn from the (x,y,z) coordinates of this 3D scatter trace.
|
| For more, run `help(plotly.graph_objs.ErrorY)`
|
| error_x [required=False] (value=ErrorX object | dictionary-like object)
| (streamable):
| Links a dictionary-like object describing the x-axis error bars that
| can be drawn from the (x,y,z) coordinates of this 3D scatter trace.
|
| For more, run `help(plotly.graph_objs.ErrorX)`
|
| marker [required=False] (value=Marker object | dictionary-like object)
| (streamable):
| Links a dictionary-like object containing marker style parameters
| for this 3D scatter trace. Has an effect only if 'mode' contains
| 'markers'.
|
| For more, run `help(plotly.graph_objs.Marker)`
|
| line [required=False] (value=Line object | dictionary-like object)
| (streamable):
| Links a dictionary-like object containing line parameters for this
| 3D scatter trace. Has an effect only if 'mode' contains 'lines'.
|
| For more, run `help(plotly.graph_objs.Line)`
|
| textposition [required=False] (value='top left' | 'top' (or 'top
| center')| 'top right' | 'left' (or 'middle left') | '' (or 'middle
| center') | 'right' (or 'middle right') | 'bottom left' | 'bottom' (or
| 'bottom center') | 'bottom right'):
| Sets the position of the text elements in the 'text' key with
| respect to the data points. By default, the text elements are
| plotted directly at the (x,y,z) coordinates.
|
| scene [required=False] (value='scene1' | 'scene2' | 'scene3' | etc.):
| This key determines the scene on which this trace will be plotted
| in.
|
| stream [required=False] (value=Stream object | dictionary-like object):
| Links a dictionary-like object that initializes this trace as a
| writable-stream, for use with the streaming API.
|
| For more, run `help(plotly.graph_objs.Stream)`
|
| visible [required=False] (value=a boolean: True | False):
| Toggles whether or not this object will be visible on the rendered
| figure.
|
| type [required=False] (value='scatter3d'):
| Plotly identifier for this data's trace type.
|
| Method resolution order:
| Scatter3d
| PlotlyTrace
| PlotlyDict
| __builtin__.dict
| __builtin__.object
|
| Methods inherited from PlotlyTrace:
|
| __init__(self, *args, **kwargs)
|
| to_string(self, level=0, indent=4, eol='\n', pretty=True, max_chars=80)
| Returns a formatted string showing graph_obj constructors.
|
| Example:
|
| print(obj.to_string())
|
| Keyword arguments:
| level (default = 0) -- set number of indentations to start with
| indent (default = 4) -- set indentation amount
| eol (default = '\n') -- set end of line character(s)
| pretty (default = True) -- curtail long list output with a '...'
| max_chars (default = 80) -- set max characters per line
|
| ----------------------------------------------------------------------
| Methods inherited from PlotlyDict:
|
| __setitem__(self, key, value)
|
| force_clean(self, caller=True)
| Attempts to convert to graph_objs and call force_clean() on values.
|
| Calling force_clean() on a PlotlyDict will ensure that the object is
| valid and may be sent to plotly. This process will also remove any
| entries that end up with a length == 0.
|
| Careful! This will delete any invalid entries *silently*.
|
| get_data(self)
| Returns the JSON for the plot with non-data elements stripped.
|
| get_ordered(self, caller=True)
|
| strip_style(self)
| 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.
|
| This process first attempts to convert nested collections from dicts
| or lists to subclasses of PlotlyList/PlotlyDict. This process forces
| a validation, which may throw exceptions.
|
| Then, each of these objects call `strip_style` on themselves and so
| on, recursively until the entire structure has been validated and
| stripped.
|
| to_graph_objs(self, caller=True)
| Walk obj, convert dicts and lists to plotly graph objs.
|
| For each key in the object, if it corresponds to a special key that
| should be associated with a graph object, the ordinary dict or list
| will be reinitialized as a special PlotlyDict or PlotlyList of the
| appropriate `kind`.
|
| 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.
|
| validate(self, caller=True)
| Recursively check the validity of the keys in a PlotlyDict.
|
| The valid keys constitute the entries in each object
| dictionary in graph_objs_meta.json
|
| The validation process first requires that all nested collections be
| converted to the appropriate subclass of PlotlyDict/PlotlyList. Then,
| each of these objects call `validate` and so on, recursively,
| until the entire object has been validated.
|
| ----------------------------------------------------------------------
| 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 __builtin__.dict:
|
| __cmp__(...)
| x.__cmp__(y) <==> cmp(x,y)
|
| __contains__(...)
| D.__contains__(k) -> True if D has a key k, else False
|
| __delitem__(...)
| x.__delitem__(y) <==> del x[y]
|
| __eq__(...)
| x.__eq__(y) <==> x==y
|
| __ge__(...)
| x.__ge__(y) <==> x>=y
|
| __getattribute__(...)
| x.__getattribute__('name') <==> x.name
|
| __getitem__(...)
| x.__getitem__(y) <==> x[y]
|
| __gt__(...)
| x.__gt__(y) <==> x>y
|
| __iter__(...)
| x.__iter__() <==> iter(x)
|
| __le__(...)
| x.__le__(y) <==> x<=y
|
| __len__(...)
| x.__len__() <==> len(x)
|
| __lt__(...)
| x.__lt__(y) <==> x<y
|
| __ne__(...)
| x.__ne__(y) <==> x!=y
|
| __repr__(...)
| x.__repr__() <==> repr(x)
|
| __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(...)
| dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
| v defaults to None.
|
| get(...)
| D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None.
|
| has_key(...)
| D.has_key(k) -> True if D has a key k, else False
|
| items(...)
| D.items() -> list of D's (key, value) pairs, as 2-tuples
|
| iteritems(...)
| D.iteritems() -> an iterator over the (key, value) items of D
|
| iterkeys(...)
| D.iterkeys() -> an iterator over the keys of D
|
| itervalues(...)
| D.itervalues() -> an iterator over the values of D
|
| keys(...)
| D.keys() -> list of 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() -> list of D's values
|
| viewitems(...)
| D.viewitems() -> a set-like object providing a view on D's items
|
| viewkeys(...)
| D.viewkeys() -> a set-like object providing a view on D's keys
|
| viewvalues(...)
| D.viewvalues() -> an object providing a view on D's values
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from __builtin__.dict:
|
| __hash__ = None
|
| __new__ = <built-in method __new__ of type object>
| T.__new__(S, ...) -> a new object with type S, a subtype of T