code: def epath(path, expr=None, func=None, args=None, kwargs=None):
      r"""
      Manipulate parts of an expression selected by a path.
  
      Explanation
      ===========
  
      This function allows to manipulate large nested expressions in single
      line of code, utilizing techniques to those applied in XML processing
      standards (e.g. XPath).
  
      If ``func`` is ``None``, :func:`epath` retrieves elements selected by
      the ``path``. Otherwise it applies ``func`` to each matching element.
  
      Note that it is more efficient to create an EPath object and use the select
      and apply methods of that object, since this will compile the path string
      only once.  This function should only be used as a convenient shortcut for
      interactive use.
  
      This is the supported syntax:
  
      * select all: ``/*``
            Equivalent of ``for arg in args:``.
      * select slice: ``/[0]`` or ``/[1:5]`` or ``/[1:5:2]``
            Supports standard Python's slice syntax.
      * select by type: ``/list`` or ``/list|tuple``
            Emulates ``isinstance()``.
      * select by attribute: ``/__iter__?``
            Emulates ``hasattr()``.
  
      Parameters
      ==========
  
      path : str | EPath
          A path as a string or a compiled EPath.
      expr : Basic | iterable
          An expression or a container of expressions.
      func : callable (optional)
          A callable that will be applied to matching parts.
      args : tuple (optional)
          Additional positional arguments to ``func``.
      kwargs : dict (optional)
          Additional keyword arguments to ``func``.
  
      Examples
      ========
  
      >>> from sympy.simplify.epathtools import epath
      >>> from sympy import sin, cos, E
      >>> from sympy.abc import x, y, z, t
  
      >>> path = "/*/[0]/Symbol"
      >>> expr = [((x, 1), 2), ((3, y), z)]
  
      >>> epath(path, expr)
      [x, y]
      >>> epath(path, expr, lambda expr: expr**2)
      [((x**2, 1), 2), ((3, y**2), z)]
  
      >>> path = "/*/*/Symbol"
      >>> expr = t + sin(x + 1) + cos(x + y + E)
  
      >>> epath(path, expr)
      [x, x, y]
      >>> epath(path, expr, lambda expr: 2*expr)
      t + sin(2*x + 1) + cos(2*x + 2*y + E)
  
      """
      _epath = EPath(path)
  
      if expr is None:
          return _epath
      if func is None:
          return _epath.select(expr)
      else:
          return _epath.apply(expr, func, args, kwargs)
  
file_path: sympy/sympy/simplify/epathtools.py
imports: from sympy.core import Basic
label_desc: Use image node_id 1 for calling a global function with example usage: epath(path, expr, func, args, kwargs) and returns: _epath, _epath, _epath