code: def pole_zero_plot(
      system,
      pole_color="blue",
      pole_markersize=10,
      zero_color="orange",
      zero_markersize=7,
      grid=True,
      show_axes=True,
      show=True,
      **kwargs,
  ):
      r"""
      Returns the Pole-Zero plot (also known as PZ Plot or PZ Map) of a system.
  
      A Pole-Zero plot is a graphical representation of a system's poles and
      zeros. It is plotted on a complex plane, with circular markers representing
      the system's zeros and 'x' shaped markers representing the system's poles.
  
      Parameters
      ==========
  
      system : SISOLinearTimeInvariant type systems
          The system for which the pole-zero plot is to be computed.
      pole_color : str, tuple, optional
          The color of the pole points on the plot. Default color
          is blue. The color can be provided as a matplotlib color string,
          or a 3-tuple of floats each in the 0-1 range.
      pole_markersize : Number, optional
          The size of the markers used to mark the poles in the plot.
          Default pole markersize is 10.
      zero_color : str, tuple, optional
          The color of the zero points on the plot. Default color
          is orange. The color can be provided as a matplotlib color string,
          or a 3-tuple of floats each in the 0-1 range.
      zero_markersize : Number, optional
          The size of the markers used to mark the zeros in the plot.
          Default zero markersize is 7.
      grid : boolean, optional
          If ``True``, the plot will have a grid. Defaults to True.
      show_axes : boolean, optional
          If ``True``, the coordinate axes will be shown. Defaults to False.
      show : boolean, optional
          If ``True``, the plot will be displayed otherwise
          the equivalent matplotlib ``plot`` object will be returned.
          Defaults to True.
  
      Examples
      ========
  
      .. plot::
          :context: close-figs
          :format: doctest
          :include-source: True
  
          >>> from sympy.abc import s
          >>> from sympy.physics.control.lti import TransferFunction
          >>> from sympy.physics.control.control_plots import pole_zero_plot
          >>> tf1 = TransferFunction(s**2 + 1, s**4 + 4*s**3 + 6*s**2 + 5*s + 2, s)
          >>> pole_zero_plot(tf1)   # doctest: +SKIP
  
      See Also
      ========
  
      pole_zero_numerical_data
  
      References
      ==========
  
      .. [1] https://en.wikipedia.org/wiki/Pole%E2%80%93zero_plot
  
      """
      zeros, poles = pole_zero_numerical_data(system)
  
      zero_real = np.real(zeros)
      zero_imag = np.imag(zeros)
  
      pole_real = np.real(poles)
      pole_imag = np.imag(poles)
  
      plt.plot(
          pole_real,
          pole_imag,
          "x",
          mfc="none",
          markersize=pole_markersize,
          color=pole_color,
      )
      plt.plot(
          zero_real,
          zero_imag,
          "o",
          markersize=zero_markersize,
          color=zero_color,
      )
      plt.xlabel("Real Axis")
      plt.ylabel("Imaginary Axis")
      plt.title(f"Poles and Zeros of ${latex(system)}$", pad=20)
  
      if grid:
          plt.grid()
      if show_axes:
          plt.axhline(0, color="black")
          plt.axvline(0, color="black")
      if show:
          plt.show()
          return
  
      return plt
  
imports: from sympy.core.numbers import I, pi
  from sympy.functions.elementary.exponential import exp, log
  from sympy.polys.partfrac import apart
  from sympy.core.symbol import Dummy
  from sympy.external import import_module
  from sympy.functions import arg, Abs
  from sympy.integrals.laplace import _fast_inverse_laplace
  from sympy.physics.control.lti import SISOLinearTimeInvariant
  from sympy.plotting.series import LineOver1DRangeSeries
  from sympy.polys.polytools import Poly
  from sympy.printing.latex import latex
label_desc: Use image node_id 3 for calling a global function with example usage: pole_zero_plot(system, pole_color, pole_markersize, zero_color, zero_markersize, grid, show_axes, show) and returns: plt