title: edit python variables in matplotlibs interactive mode
body: <p>I am actually working on a small data-editor to smooth some measurements. Therefore I want to use matplotlib in interactive mode, following this example:
  <a href="http://matplotlib.org/examples/event_handling/poly_editor.html" rel="nofollow noreferrer">Poly_editor example from matplotlib...</a></p>
  
  <pre><code>"""
  This is an example to show how to build cross-GUI applications using
  matplotlib event handling to interact with objects on the canvas
  
  """
  import numpy as np
  from matplotlib.lines import Line2D
  from matplotlib.artist import Artist
  from matplotlib.mlab import dist_point_to_segment
  
  
  class PolygonInteractor(object):
      """
      An polygon editor.
  
      Key-bindings
  
        't' toggle vertex markers on and off.  When vertex markers are on,
            you can move them, delete them
  
        'd' delete the vertex under point
  
        'i' insert a vertex at point.  You must be within epsilon of the
            line connecting two existing vertices
  
      """
  
      showverts = True
      epsilon = 5  # max pixel distance to count as a vertex hit
  
      def __init__(self, ax, poly):
          if poly.figure is None:
              raise RuntimeError('You must first add the polygon to a figure         or canvas before defining the interactor')
          self.ax = ax
          canvas = poly.figure.canvas
          self.poly = poly
  
          x, y = zip(*self.poly.xy)
          self.line = Line2D(x, y, marker='o', markerfacecolor='r', animated=True)
          self.ax.add_line(self.line)
          #self._update_line(poly)
  
          cid = self.poly.add_callback(self.poly_changed)
          self._ind = None  # the active vert
  
          canvas.mpl_connect('draw_event', self.draw_callback)
          canvas.mpl_connect('button_press_event', self.button_press_callback)
          canvas.mpl_connect('key_press_event', self.key_press_callback)
          canvas.mpl_connect('button_release_event', self.button_release_callback)
          canvas.mpl_connect('motion_notify_event', self.motion_notify_callback)
          self.canvas = canvas
  
      def draw_callback(self, event):
          self.background = self.canvas.copy_from_bbox(self.ax.bbox)
          self.ax.draw_artist(self.poly)
          self.ax.draw_artist(self.line)
          self.canvas.blit(self.ax.bbox)
  
      def poly_changed(self, poly):
          'this method is called whenever the polygon object is called'
          # only copy the artist props to the line (except visibility)
          vis = self.line.get_visible()
          Artist.update_from(self.line, poly)
          self.line.set_visible(vis)  # don't use the poly visibility state
  
      def get_ind_under_point(self, event):
          'get the index of the vertex under point if within epsilon tolerance'
  
          # display coords
          xy = np.asarray(self.poly.xy)
          xyt = self.poly.get_transform().transform(xy)
          xt, yt = xyt[:, 0], xyt[:, 1]
          d = np.sqrt((xt - event.x)**2 + (yt - event.y)**2)
          indseq = np.nonzero(np.equal(d, np.amin(d)))[0]
          ind = indseq[0]
  
          if d[ind] &gt;= self.epsilon:
              ind = None
  
          return ind
  
      def button_press_callback(self, event):
          'whenever a mouse button is pressed'
          if not self.showverts:
              return
          if event.inaxes is None:
              return
          if event.button != 1:
              return
          self._ind = self.get_ind_under_point(event)
  
      def button_release_callback(self, event):
          'whenever a mouse button is released'
          if not self.showverts:
              return
          if event.button != 1:
              return
          self._ind = None
  
      def key_press_callback(self, event):
          'whenever a key is pressed'
          if not event.inaxes:
              return
          if event.key == 't':
              self.showverts = not self.showverts
              self.line.set_visible(self.showverts)
              if not self.showverts:
                  self._ind = None
          elif event.key == 'd':
              ind = self.get_ind_under_point(event)
              if ind is not None:
                  self.poly.xy = [tup for i, tup in enumerate(self.poly.xy) if i != ind]
                  self.line.set_data(zip(*self.poly.xy))
          elif event.key == 'i':
              xys = self.poly.get_transform().transform(self.poly.xy)
              p = event.x, event.y  # display coords
              for i in range(len(xys) - 1):
                  s0 = xys[i]
                  s1 = xys[i + 1]
                  d = dist_point_to_segment(p, s0, s1)
                  if d &lt;= self.epsilon:
                      self.poly.xy = np.array(
                          list(self.poly.xy[:i]) +
                          [(event.xdata, event.ydata)] +
                          list(self.poly.xy[i:]))
                      self.line.set_data(zip(*self.poly.xy))
                      break
  
          self.canvas.draw()
  
      def motion_notify_callback(self, event):
          'on mouse movement'
          if not self.showverts:
              return
          if self._ind is None:
              return
          if event.inaxes is None:
              return
          if event.button != 1:
              return
          x, y = event.xdata, event.ydata
  
          self.poly.xy[self._ind] = x, y
          if self._ind == 0:
              self.poly.xy[-1] = x, y
          elif self._ind == len(self.poly.xy) - 1:
              self.poly.xy[0] = x, y
          self.line.set_data(zip(*self.poly.xy))
  
          self.canvas.restore_region(self.background)
          self.ax.draw_artist(self.poly)
          self.ax.draw_artist(self.line)
          self.canvas.blit(self.ax.bbox)
  
  
  if __name__ == '__main__':
      import matplotlib.pyplot as plt
      from matplotlib.patches import Polygon
  
      theta = np.arange(0, 2*np.pi, 0.1)
      r = 1.5
  
      xs = r*np.cos(theta)
      ys = r*np.sin(theta)
  
      poly = Polygon(list(zip(xs, ys)), animated=True)
  
      fig, ax = plt.subplots()
      ax.add_patch(poly)
      p = PolygonInteractor(ax, poly)
  
      #ax.add_line(p.line)
      ax.set_title('Click and drag a point to move it')
      ax.set_xlim((-2, 2))
      ax.set_ylim((-2, 2))
      plt.show()
  </code></pre>
  
  <p>For simplicity let's say, I now want to edit the shown polygon by hand and after closing the window, the new <code>x</code> and <code>y</code> values of the vertices should be stored for further computations.</p>
  
  <p>My Problem now is, that code after the <code>plt.show()</code> is immediately executed. The <code>plt.show(blocked=True)</code> does not work with the interactive mode.
  The <code>plt.show()</code> could even be excluded from the code and it still works, since the plotting seems to be done all in the <code>PolygonInteractor</code> class...</p>
  
  <p>Does anybody have a suggestion how to "really" edit the data in the plot?</p>