__init__(self, filename=None, persist=None, debug=0)
(Constructor)

Create a Gnuplot object.

Create a 'Gnuplot' object.  By default, this starts a gnuplot
process and prepares to write commands to it.

Keyword arguments:

  'filename=<string>' -- if a filename is specified, the
      commands are instead written to that file (e.g., for
      later use using 'load').

  'persist=1' -- start gnuplot with the '-persist' option
      (which creates a new plot window for each plot command).
      (This option is not available on older versions of
      gnuplot.)

  'debug=1' -- echo the gnuplot commands to stderr as well as
      sending them to gnuplot.

__call__(self, s)
(Call operator)

Send a command string to gnuplot.

_add_to_queue(self, items)

Add a list of items to the itemlist (but don't plot them).

_clear_queue(self)

clear(self)

hardcopy(self, filename=None, terminal='postscript', **keyw)

Create a hardcopy of the current plot.

Create a postscript hardcopy of the current plot to the
default printer (if configured) or to the specified filename.

Note that gnuplot remembers the postscript suboptions across
terminal changes.  Therefore if you set, for example, color=1
for one hardcopy then the next hardcopy will also be color
unless you explicitly choose color=0.  Alternately you can
force all of the options to their defaults by setting
mode='default'.  I consider this to be a bug in gnuplot.

Keyword arguments:

  'filename=<string>' -- if a filename is specified, save the
      output in that file; otherwise print it immediately
      using the 'default_lpr' configuration option.

  'terminal=<string>' -- the type of gnuplot 'terminal' to use
      for the output (e.g., 'postscript', 'png', 'latex',
      etc).  At the moment only 'postscript' is implemented.

The rest of the keyword arguments depend on the terminal type.

Keyword arguments for 'postscript' terminal:

  'mode=<string>' -- set the postscript submode ('landscape',
      'portrait', 'eps', or 'default').  The default is
      to leave this option unspecified.

  'eps=<bool>' -- shorthand for 'mode="eps"'; asks gnuplot to
      generate encapsulated postscript.

  'enhanced=<bool>' -- if set (the default), then generate
      enhanced postscript, which allows extra features like
      font-switching, superscripts, and subscripts in axis
      labels.  (Some old gnuplot versions do not support
      enhanced postscript; if this is the case set
      gp.GnuplotOpts.prefer_enhanced_postscript=None.)

  'color=<bool>' -- if set, create a plot with color.  Default
      is to leave this option unchanged.

  'solid=<bool>' -- if set, force lines to be solid (i.e., not
      dashed).

  'duplexing=<string>' -- set duplexing option ('defaultplex',
      'simplex', or 'duplex').  Only request double-sided
      printing if your printer can handle it.  Actually this
      option is probably meaningless since hardcopy() can only
      print a single plot at a time.

  'fontname=<string>' -- set the default font to <string>,
      which must be a valid postscript font.  The default is
      to leave this option unspecified.

  'fontsize=<double>' -- set the default font size, in
      postscript points.

Note that this command will return immediately even though it
might take gnuplot a while to actually finish working.  Be
sure to pause briefly before issuing another command that
might cause the temporary files to be deleted.

interact(self)

Allow user to type arbitrary commands to gnuplot.

load(self, filename)

plot(self, *items, **keyw)

Draw a new plot.

Clear the current plot and create a new 2-d plot containing
the specified items.  Each arguments should be of the
following types:

'PlotItem' (e.g., 'Data', 'File', 'Func') -- This is the most
    flexible way to call plot because the PlotItems can
    contain suboptions.  Moreover, PlotItems can be saved to
    variables so that their lifetime is longer than one plot
    command; thus they can be replotted with minimal overhead.

'string' (e.g., 'sin(x)') -- The string is interpreted as
    'Func(string)' (a function that is computed by gnuplot).

Anything else -- The object, which should be convertible to an
    array, is passed to the 'Data' constructor, and thus
    plotted as data.  If the conversion fails, an exception is
    raised.

refresh(self)

Refresh the plot, using the current 'PlotItem's.

replot(self, *items, **keyw)

Replot the data, possibly adding new 'PlotItem's.

reset(self)

save(self, filename)

set(self, **keyw)

set_boolean(self, option, value)

set_label(self, option, s=None, offset=None, font=None)

Set or clear a label option, which can include an offset or font.

If offset is specified, it should be a tuple of two integers or floats.

set_range(self, option, value)

set_string(self, option, s=None)

splot(self, *items, **keyw)

Draw a new three-dimensional plot.

Clear the current plot and create a new 3-d plot containing
the specified items.  Arguments can be of the following types:

'PlotItem' (e.g., 'Data', 'File', 'Func', 'GridData' ) -- This
    is the most flexible way to call plot because the
    PlotItems can contain suboptions.  Moreover, PlotItems can
    be saved to variables so that their lifetime is longer
    than one plot command--thus they can be replotted with
    minimal overhead.

'string' (e.g., 'sin(x*y)') -- The string is interpreted as a
    'Func()' (a function that is computed by gnuplot).

Anything else -- The object is converted to a Data() item, and
    thus plotted as data.  Note that each data point should
    normally have at least three values associated with it
    (i.e., x, y, and z).  If the conversion fails, an
    exception is raised.

title(self, s=None, offset=None, font=None)

xlabel(self, s=None, offset=None, font=None)

ylabel(self, s=None, offset=None, font=None)