code: def plot_parametric(*args, show=True, **kwargs):
      """
      Plots a 2D parametric curve.
  
      Parameters
      ==========
  
      args
          Common specifications are:
  
          - Plotting a single parametric curve with a range
              ``plot_parametric((expr_x, expr_y), range)``
          - Plotting multiple parametric curves with the same range
              ``plot_parametric((expr_x, expr_y), ..., range)``
          - Plotting multiple parametric curves with different ranges
              ``plot_parametric((expr_x, expr_y, range), ...)``
  
          ``expr_x`` is the expression representing $x$ component of the
          parametric function.
  
          ``expr_y`` is the expression representing $y$ component of the
          parametric function.
  
          ``range`` is a 3-tuple denoting the parameter symbol, start and
          stop. For example, ``(u, 0, 5)``.
  
          If the range is not specified, then a default range of (-10, 10)
          is used.
  
          However, if the arguments are specified as
          ``(expr_x, expr_y, range), ...``, you must specify the ranges
          for each expressions manually.
  
          Default range may change in the future if a more advanced
          algorithm is implemented.
  
      adaptive : bool, optional
          Specifies whether to use the adaptive sampling or not.
  
          The default value is set to ``True``. Set adaptive to ``False``
          and specify ``n`` if uniform sampling is required.
  
      depth :  int, optional
          The recursion depth of the adaptive algorithm. A depth of
          value $n$ samples a maximum of $2^n$ points.
  
      n : int, optional
          Used when the ``adaptive`` flag is set to ``False``. Specifies the
          number of the points used for the uniform sampling.
          This keyword argument replaces ``nb_of_points``, which should be
          considered deprecated.
  
      line_color : string, or float, or function, optional
          Specifies the color for the plot.
          See ``Plot`` to see how to set color for the plots.
          Note that by setting ``line_color``, it would be applied simultaneously
          to all the series.
  
      label : str, optional
          The label of the expression in the plot. It will be used when
          called with ``legend``. Default is the name of the expression.
          e.g. ``sin(x)``
  
      xlabel : str, optional
          Label for the x-axis.
  
      ylabel : str, optional
          Label for the y-axis.
  
      xscale : 'linear' or 'log', optional
          Sets the scaling of the x-axis.
  
      yscale : 'linear' or 'log', optional
          Sets the scaling of the y-axis.
  
      axis_center : (float, float), optional
          Tuple of two floats denoting the coordinates of the center or
          {'center', 'auto'}
  
      xlim : (float, float), optional
          Denotes the x-axis limits, ``(min, max)```.
  
      ylim : (float, float), optional
          Denotes the y-axis limits, ``(min, max)```.
  
      size : (float, float), optional
          A tuple in the form (width, height) in inches to specify the size of
          the overall figure. The default value is set to ``None``, meaning
          the size will be set by the default backend.
  
      Examples
      ========
  
      .. plot::
         :context: reset
         :format: doctest
         :include-source: True
  
         >>> from sympy import plot_parametric, symbols, cos, sin
         >>> u = symbols('u')
  
      A parametric plot with a single expression:
  
      .. plot::
         :context: close-figs
         :format: doctest
         :include-source: True
  
         >>> plot_parametric((cos(u), sin(u)), (u, -5, 5))
         Plot object containing:
         [0]: parametric cartesian line: (cos(u), sin(u)) for u over (-5.0, 5.0)
  
      A parametric plot with multiple expressions with the same range:
  
      .. plot::
         :context: close-figs
         :format: doctest
         :include-source: True
  
         >>> plot_parametric((cos(u), sin(u)), (u, cos(u)), (u, -10, 10))
         Plot object containing:
         [0]: parametric cartesian line: (cos(u), sin(u)) for u over (-10.0, 10.0)
         [1]: parametric cartesian line: (u, cos(u)) for u over (-10.0, 10.0)
  
      A parametric plot with multiple expressions with different ranges
      for each curve:
  
      .. plot::
         :context: close-figs
         :format: doctest
         :include-source: True
  
         >>> plot_parametric((cos(u), sin(u), (u, -5, 5)),
         ...     (cos(u), u, (u, -5, 5)))
         Plot object containing:
         [0]: parametric cartesian line: (cos(u), sin(u)) for u over (-5.0, 5.0)
         [1]: parametric cartesian line: (cos(u), u) for u over (-5.0, 5.0)
  
      Notes
      =====
  
      The plotting uses an adaptive algorithm which samples recursively to
      accurately plot the curve. The adaptive algorithm uses a random point
      near the midpoint of two points that has to be further sampled.
      Hence, repeating the same plot command can give slightly different
      results because of the random sampling.
  
      If there are multiple plots, then the same optional arguments are
      applied to all the plots drawn in the same canvas. If you want to
      set these options separately, you can index the returned ``Plot``
      object and set it.
  
      For example, when you specify ``line_color`` once, it would be
      applied simultaneously to both series.
  
      .. plot::
         :context: close-figs
         :format: doctest
         :include-source: True
  
          >>> from sympy import pi
          >>> expr1 = (u, cos(2*pi*u)/2 + 1/2)
          >>> expr2 = (u, sin(2*pi*u)/2 + 1/2)
          >>> p = plot_parametric(expr1, expr2, (u, 0, 1), line_color='blue')
  
      If you want to specify the line color for the specific series, you
      should index each item and apply the property manually.
  
      .. plot::
         :context: close-figs
         :format: doctest
         :include-source: True
  
          >>> p[0].line_color = 'red'
          >>> p.show()
  
      See Also
      ========
  
      Plot, Parametric2DLineSeries
      """
      args = _plot_sympify(args)
      plot_expr = _check_arguments(args, 2, 1, **kwargs)
  
      labels = kwargs.pop("label", [])
      rendering_kw = kwargs.pop("rendering_kw", None)
      series = _create_series(
          Parametric2DLineSeries, plot_expr, **kwargs
      )
      _set_labels(series, labels, rendering_kw)
  
      plots = plot_factory(*series, **kwargs)
      if show:
          plots.show()
      return plots
  
imports: from sympy.concrete.summations import Sum
  from sympy.core.containers import Tuple
  from sympy.core.expr import Expr
  from sympy.core.function import Function, AppliedUndef
  from sympy.core.symbol import Dummy, Symbol, Wild
  from sympy.external import import_module
  from sympy.functions import sign
  from sympy.plotting.backends.base_backend import Plot
  from sympy.plotting.backends.matplotlibbackend import MatplotlibBackend
  from sympy.plotting.backends.textbackend import TextBackend
  from sympy.plotting.series import LineOver1DRangeSeries, Parametric2DLineSeries, Parametric3DLineSeries, ParametricSurfaceSeries, SurfaceOver2DRangeSeries, ContourSeries
  from sympy.plotting.utils import _check_arguments, _plot_sympify
  from sympy.tensor.indexed import Indexed
  from sympy.plotting.plotgrid import PlotGrid
  from sympy.plotting.series import BaseSeries
  from sympy.plotting.series import Line2DBaseSeries
  from sympy.plotting.series import Line3DBaseSeries
  from sympy.plotting.series import SurfaceBaseSeries
  from sympy.plotting.series import List2DSeries
  from sympy.plotting.series import GenericDataSeries
  from sympy.plotting.series import centers_of_faces
  from sympy.plotting.series import centers_of_segments
  from sympy.plotting.series import flat
  from sympy.plotting.backends.base_backend import unset_show
  from sympy.plotting.backends.matplotlibbackend import _matplotlib_list
  from sympy.plotting.textplot import textplot
label_desc: Use image node_id 7 for calling a global function with example usage: plot_parametric() and returns: plots