docs: def default_sort_key(item, order=None):
      """Return a key that can be used for sorting.
  
      The key has the structure:
  
      (class_key, (len(args), args), exponent.sort_key(), coefficient)
  
      This key is supplied by the sort_key routine of Basic objects when
      ``item`` is a Basic object or an object (other than a string) that
      sympifies to a Basic object. Otherwise, this function produces the
      key.
  
      The ``order`` argument is passed along to the sort_key routine and is
      used to determine how the terms *within* an expression are ordered.
      (See examples below) ``order`` options are: 'lex', 'grlex', 'grevlex',
      and reversed values of the same (e.g. 'rev-lex'). The default order
      value is None (which translates to 'lex').
  
      Examples
      ========
  
      >>> from sympy import S, I, default_sort_key
      >>> from sympy.core.function import UndefinedFunction
      >>> from sympy.abc import x
  
      The following are equivalent ways of getting the key for an object:
  
      >>> x.sort_key() == default_sort_key(x)
      True
  
      Here are some examples of the key that is produced:
  
      >>> default_sort_key(UndefinedFunction('f'))
      ((0, 0, 'UndefinedFunction'), (1, ('f',)), ((1, 0, 'Number'),
          (0, ()), (), 1), 1)
      >>> default_sort_key('1')
      ((0, 0, 'str'), (1, ('1',)), ((1, 0, 'Number'), (0, ()), (), 1), 1)
      >>> default_sort_key(S.One)
      ((1, 0, 'Number'), (0, ()), (), 1)
      >>> default_sort_key(2)
      ((1, 0, 'Number'), (0, ()), (), 2)
  
  
      While sort_key is a method only defined for SymPy objects,
      default_sort_key will accept anything as an argument so it is
      more robust as a sorting key. For the following, using key=
      lambda i: i.sort_key() would fail because 2 doesn't have a sort_key
      method; that's why default_sort_key is used. Note, that it also
      handles sympification of non-string items likes ints:
  
      >>> a = [2, I, -I]
      >>> sorted(a, key=default_sort_key)
      [2, -I, I]
  
      The returned key can be used anywhere that a key can be specified for
      a function, e.g. sort, min, max, etc...:
  
      >>> a.sort(key=default_sort_key); a[0]
      2
      >>> min(a, key=default_sort_key)
      2
  
      Note
      ----
  
      The key returned is useful for getting items into a canonical order
      that will be the same across platforms. It is not directly useful for
      sorting lists of expressions:
  
      >>> a, b = x, 1/x
  
      Since ``a`` has only 1 term, its value of sort_key is unaffected by
      ``order``:
  
      >>> a.sort_key() == a.sort_key('rev-lex')
      True
  
      If ``a`` and ``b`` are combined then the key will differ because there
      are terms that can be ordered:
  
      >>> eq = a + b
      >>> eq.sort_key() == eq.sort_key('rev-lex')
      False
      >>> eq.as_ordered_terms()
      [x, 1/x]
      >>> eq.as_ordered_terms('rev-lex')
      [1/x, x]
  
      But since the keys for each of these terms are independent of ``order``'s
      value, they don't sort differently when they appear separately in a list:
  
      >>> sorted(eq.args, key=default_sort_key)
      [1/x, x]
      >>> sorted(eq.args, key=lambda i: default_sort_key(i, order='rev-lex'))
      [1/x, x]
  
      The order of terms obtained when using these keys is the order that would
      be obtained if those terms were *factors* in a product.
  
      See Also
      ========
  
      sympy.core.expr.as_ordered_factors, sympy.core.expr.as_ordered_terms
  
      """
  
      from sympy.core import S, Basic
      from sympy.core.sympify import sympify, SympifyError
      from sympy.core.compatibility import iterable
  
      if isinstance(item, Basic):
          return item.sort_key(order=order)
  
      if iterable(item, exclude=string_types):
          if isinstance(item, dict):
              args = item.items()
              unordered = True
          elif isinstance(item, set):
              args = item
              unordered = True
          else:
              # e.g. tuple, list
              args = list(item)
              unordered = False
  
          args = [default_sort_key(arg, order=order) for arg in args]
  
          if unordered:
              # e.g. dict, set
              args = sorted(args)
  
          cls_index, args = 10, (len(args), tuple(args))
      else:
          if not isinstance(item, string_types):
              try:
                  item = sympify(item)
              except SympifyError:
                  # e.g. lambda x: x
                  pass
              else:
                  if isinstance(item, Basic):
                      # e.g int -> Integer
                      return default_sort_key(item)
                  # e.g. UndefinedFunction
  
          # e.g. str
          cls_index, args = 0, (1, (str(item),))
  
      return (cls_index, 0, item.__class__.__name__
              ), args, S.One.sort_key(), S.One