docstr: Applies all the axis settings before the axis or figure is returned.
  Only plots with zorder 0 get to apply their settings.
  
  When the number of the frame is supplied as n, this method looks
  up and computes the appropriate title, axis labels and axis bounds.
code: def _finalize_axis(
      self,
      key,
      element=None,
      title=None,
      dimensions=None,
      ranges=None,
      xticks=None,
      yticks=None,
      zticks=None,
      xlabel=None,
      ylabel=None,
      zlabel=None,
  ):
      """
      Applies all the axis settings before the axis or figure is returned.
      Only plots with zorder 0 get to apply their settings.
  
      When the number of the frame is supplied as n, this method looks
      up and computes the appropriate title, axis labels and axis bounds.
      """
      if element is None:
          element = self._get_frame(key)
      self.current_frame = element
      if not dimensions and element and not self.subplots:
          el = element.traverse(lambda x: x, [Element])
          if el:
              el = el[0]
              dimensions = (
                  el.nodes.dimensions()
                  if isinstance(el, Graph)
                  else el.dimensions()
              )
      axis = self.handles["axis"]
  
      subplots = list(self.subplots.values()) if self.subplots else []
      if self.zorder == 0 and key is not None:
          if self.bgcolor:
              if mpl_version <= Version("1.5.9"):
                  axis.set_axis_bgcolor(self.bgcolor)
              else:
                  axis.set_facecolor(self.bgcolor)
  
          # Apply title
          title = self._format_title(key)
          if self.show_title and title is not None:
              fontsize = self._fontsize("title")
              if "title" in self.handles:
                  self.handles["title"].set_text(title)
              else:
                  self.handles["title"] = axis.set_title(
                      title, **fontsize
                  )
  
          # Apply subplot label
          self._subplot_label(axis)
  
          # Apply axis options if axes are enabled
          if element is not None and not any(
              not sp._has_axes for sp in [self] + subplots
          ):
              # Set axis labels
              if dimensions:
                  self._set_labels(
                      axis, dimensions, xlabel, ylabel, zlabel
                  )
              else:
                  if self.xlabel is not None:
                      axis.set_xlabel(self.xlabel)
                  if self.ylabel is not None:
                      axis.set_ylabel(self.ylabel)
                  if self.zlabel is not None and hasattr(
                      axis, "set_zlabel"
                  ):
                      axis.set_zlabel(self.zlabel)
  
              if not subplots:
                  legend = axis.get_legend()
                  if legend:
                      legend.set_visible(self.show_legend)
                      self.handles["bbox_extra_artists"] += [legend]
                  axis.xaxis.grid(self.show_grid)
                  axis.yaxis.grid(self.show_grid)
  
              # Apply log axes
              if self.logx:
                  axis.set_xscale("log")
              if self.logy:
                  axis.set_yscale("log")
  
              if not (
                  isinstance(self.projection, str)
                  and self.projection == "3d"
              ):
                  self._set_axis_position(axis, "x", self.xaxis)
                  self._set_axis_position(axis, "y", self.yaxis)
  
              # Apply ticks
              if self.apply_ticks:
                  self._finalize_ticks(
                      axis, dimensions, xticks, yticks, zticks
                  )
  
              # Set axes limits
              self._set_axis_limits(axis, element, subplots, ranges)
  
          # Apply aspects
          if (
              self.aspect is not None
              and self.projection != "polar"
              and not self.adjoined
          ):
              self._set_aspect(axis, self.aspect)
  
      if not subplots and not self.drawn:
          self._finalize_artist(element)
  
      self._execute_hooks(element)
      return super()._finalize_axis(key)
  
imports: import copy
  import math
  import warnings
  from types import FunctionType
  import matplotlib.colors
  import numpy
  import param
  from matplotlib import ticker
  from matplotlib.dates import date2num
  from matplotlib.image import AxesImage
  from packaging.version import Version
  from ...core import CompositeOverlay, Dataset, DynamicMap, Element, Element3D, NdOverlay, util
  from ...core.options import Keywords, abbreviated_exception
  from ...element import Graph, Path
  from ...streams import Stream
  from ...util.transform import dim
  from ..plot import GenericElementPlot, GenericOverlayPlot
  from ..util import color_intervals, dim_range_key, process_cmap
  from .plot import MPLPlot, mpl_rc_context
  from .util import EqHistNormalize, mpl_version, validate, wrap_formatter
label_desc: Use image node_id 2 for calling the ElementPlot obj's underlying member method code with example usage: obj._finalize_axis(key, element, title, dimensions, ranges, xticks, yticks, zticks, xlabel, ylabel, zlabel) and returns: super