How to use the future.builtins.zip function in future

def fasta(self, sequences, names=None):
        """
        Create a file and write `sequences` to it in FASTA format. Filename is
        returned.
        """
        names = names or ('sequence_%d' % i for i in itertools.count(1))
        filename = self.empty()

        with open(filename, 'w') as f:
            f.write('\n'.join('>' + '\n'.join(entry) for entry in
                              zip(names, sequences)) + '\n')

        return filename

self.canvas.blit(self.modelax.bbox)
                    self._ivert = None
            elif self._ipoly is not None:
                self.polygons[self._ipoly].remove()
                self.lines[self._ipoly].remove()
                self.polygons.pop(self._ipoly)
                self.lines.pop(self._ipoly)
                self.densities.pop(self._ipoly)
                self._ipoly = None
                self.canvas.draw()
                self._update_data()
                self._update_data_plot()
        elif event.key == 'n':
            self._ivert = None
            self._ipoly = None
            for line, poly in zip(self.lines, self.polygons):
                poly.set_animated(False)
                line.set_animated(False)
                line.set_color([0, 0, 0, 0])
            self.canvas.draw()
            self.background = self.canvas.copy_from_bbox(self.modelax.bbox)
            self._drawing = True
            self._xy = []
            self._drawing_plot = Line2D([], [], **self.line_args)
            self._drawing_plot.set_animated(True)
            self.modelax.add_line(self._drawing_plot)
            self.dataax.set_title(' | '.join([
                'left click: set vertice', 'right click: finish',
                'esc: cancel']))
            self.canvas.draw()
        elif event.key == 'escape':
            self._drawing = False

def search_fields_to_dict(fields):
    """
    In ``SearchableQuerySet`` and ``SearchableManager``, search fields
    can either be a sequence, or a dict of fields mapped to weights.
    This function converts sequences to a dict mapped to even weights,
    so that we're consistently dealing with a dict of fields mapped to
    weights, eg: ("title", "content") -> {"title": 1, "content": 1}
    """
    if not fields:
        return {}
    try:
        int(list(dict(fields).values())[0])
    except (TypeError, ValueError):
        fields = dict(zip(fields, [1] * len(fields)))
    return fields

# Used to set the ylims for the data axes.
        if data is None:
            self.dmin, self.dmax = 0, 0
        else:
            self.dmin, self.dmax = data.min(), data.max()
        self.predicted = kwargs.get('predicted', numpy.zeros_like(x))
        self.error = kwargs.get('error', 0)
        self.cmap = kwargs.get('cmap', pyplot.cm.RdBu_r)
        self.line_args = dict(
            linewidth=2, linestyle='-', color='k', marker='o',
            markerfacecolor='k', markersize=5, animated=False, alpha=0.6)
        self.polygons = []
        self.lines = []
        self.densities = kwargs.get('densities', [])
        vertices = kwargs.get('vertices', [])
        for xy, dens in zip(vertices, self.densities):
            poly, line = self._make_polygon(xy, dens)
            self.polygons.append(poly)
            self.lines.append(line)

cl = [0]
    fi = [0]

    all_times = set(cl_age) | set(fi_age)
    cl_count = 0
    fi_count = 0

    for time in sorted(all_times):
      cl_count += cl_hist.get(time, 0)
      fi_count += fi_hist.get(time, 0)

      times.append(time)
      cl.append(cl_count)
      fi.append(fi_count)

    return (list(zip(times, cl)), list(zip(times, fi)))

def _apply(function, types, values):
    try:
        t_len, d_len = len(types), len(values)
    except TypeError:
        pass
    else:
        if t_len > d_len:
            raise ValueError('Too few values.')
        elif t_len < d_len:
            raise ValueError('Too many values.')
    return [function(t, v) for t, v in zip(types, values)]

def replace_header(self, _name, _value):
        """Replace a header.

        Replace the first matching header found in the message, retaining
        header order and case.  If no matching header was found, a KeyError is
        raised.
        """
        _name = _name.lower()
        for i, (k, v) in zip(range(len(self._headers)), self._headers):
            if k.lower() == _name:
                self._headers[i] = self.policy.header_store_parse(k, _value)
                break
        else:
            raise KeyError(_name)

def rgb_list_to_colordict(rgb_list):
    colors_by_channel = list(zip(*rgb_list))
    channels = ('red', 'green', 'blue', 'alpha')
    return dict((color, value)
                for color, value in zip(channels, colors_by_channel))

def _button_release_callback(self, event):
        """
        Reset place markers on mouse button release
        """
        if event.inaxes != self.modelax:
            return
        if event.button != 1:
            return
        if self._ivert is None and self._ipoly is None:
            return
        self.background = None
        for line, poly in zip(self.lines, self.polygons):
            poly.set_animated(False)
            line.set_animated(False)
        self.canvas.draw()
        self._ivert = None
        # self._ipoly is only released when clicking outside
        # the polygons
        self._lastevent = None
        self._update_data()
        self._update_data_plot()