code: def __init__(
      self,
      args,
      expr,
      print_lambda=False,
      use_evalf=False,
      float_wrap_evalf=False,
      complex_wrap_evalf=False,
      use_np=False,
      use_python_math=False,
      use_python_cmath=False,
      use_interval=False,
  ):
      self.print_lambda = print_lambda
      self.use_evalf = use_evalf
      self.float_wrap_evalf = float_wrap_evalf
      self.complex_wrap_evalf = complex_wrap_evalf
      self.use_np = use_np
      self.use_python_math = use_python_math
      self.use_python_cmath = use_python_cmath
      self.use_interval = use_interval
  
      # Constructing the argument string
      # - check
      if not all(isinstance(a, Symbol) for a in args):
          raise ValueError("The arguments must be Symbols.")
      # - use numbered symbols
      syms = numbered_symbols(exclude=expr.free_symbols)
      newargs = [next(syms) for _ in args]
      expr = expr.xreplace(dict(zip(args, newargs)))
      argstr = ", ".join([str(a) for a in newargs])
      del syms, newargs, args
  
      # Constructing the translation dictionaries and making the translation
      self.dict_str = self.get_dict_str()
      self.dict_fun = self.get_dict_fun()
      exprstr = str(expr)
      newexpr = self.tree2str_translate(self.str2tree(exprstr))
  
      # Constructing the namespaces
      namespace = {}
      namespace.update(self.sympy_atoms_namespace(expr))
      namespace.update(self.sympy_expression_namespace(expr))
      # XXX Workaround
      # Ugly workaround because Pow(a,Half) prints as sqrt(a)
      # and sympy_expression_namespace can not catch it.
      from sympy.functions.elementary.miscellaneous import sqrt
  
      namespace.update({"sqrt": sqrt})
      namespace.update({"Eq": lambda x, y: x == y})
      namespace.update({"Ne": lambda x, y: x != y})
      # End workaround.
      if use_python_math:
          namespace.update({"math": __import__("math")})
      if use_python_cmath:
          namespace.update({"cmath": __import__("cmath")})
      if use_np:
          try:
              namespace.update({"np": __import__("numpy")})
          except ImportError:
              raise ImportError(
                  "experimental_lambdify failed to import numpy."
              )
      if use_interval:
          namespace.update(
              {
                  "imath": __import__(
                      "sympy.plotting.intervalmath",
                      fromlist=["intervalmath"],
                  )
              }
          )
          namespace.update({"math": __import__("math")})
  
      # Construct the lambda
      if self.print_lambda:
          print(newexpr)
      eval_str = "lambda %s : ( %s )" % (argstr, newexpr)
      self.eval_str = eval_str
      exec("MYNEWLAMBDA = %s" % eval_str, namespace)
      self.lambda_func = namespace["MYNEWLAMBDA"]
  
imports: import re
  from sympy.core.numbers import I, NumberSymbol, oo, zoo
  from sympy.core.symbol import Symbol
  from sympy.utilities.iterables import numbered_symbols
  from sympy.external import import_module
  import warnings
label_desc: Use image node_id 1 to create a new Lambdifier object  with example: obj = Lambdifier(args, expr, print_lambda, use_evalf, float_wrap_evalf, complex_wrap_evalf, use_np, use_python_math, use_python_cmath, use_interval)