code: def tabulate(
      tabular_data,
      headers=[],
      tablefmt="simple",
      floatfmt="g",
      numalign="decimal",
      stralign="left",
      missingval="",
  ):
      """Format a fixed width table for pretty printing.
  
      >>> print(tabulate([[1, 2.34], [-56, "8.999"], ["2", "10001"]]))
      ---  ---------
        1      2.34
      -56      8.999
        2  10001
      ---  ---------
  
      The first required argument (`tabular_data`) can be a
      list-of-lists (or another iterable of iterables), a list of named
      tuples, a dictionary of iterables, an iterable of dictionaries,
      a two-dimensional NumPy array, NumPy record array, or a Pandas'
      dataframe.
  
  
      Table headers
      -------------
  
      To print nice column headers, supply the second argument (`headers`):
  
        - `headers` can be an explicit list of column headers
        - if `headers="firstrow"`, then the first row of data is used
        - if `headers="keys"`, then dictionary keys or column indices are used
  
      Otherwise, a headerless table is produced.
  
      If the number of headers is less than the number of columns, they
      are supposed to be names of the last columns. This is consistent
      with the plain-text format of R and Pandas' dataframes.
  
      >>> print(tabulate([["sex","age"],["Alice","F",24],["Bob","M",19]],
      ...       headers="firstrow"))
             sex      age
      -----  -----  -----
      Alice  F         24
      Bob    M         19
  
  
      Column alignment
      ----------------
  
      `tabulate` tries to detect column types automatically, and aligns
      the values properly. By default, it aligns decimal points of the
      numbers (or flushes integer numbers to the right), and flushes
      everything else to the left. Possible column alignments
      (`numalign`, `stralign`) are: "right", "center", "left", "decimal"
      (only for `numalign`), and None (to disable alignment).
  
  
      Table formats
      -------------
  
      `floatfmt` is a format specification used for columns which
      contain numeric data with a decimal point.
  
      `None` values are replaced with a `missingval` string:
  
      >>> print(tabulate([["spam", 1, None],
      ...                 ["eggs", 42, 3.14],
      ...                 ["other", None, 2.7]], missingval="?"))
      -----  --  ----
      spam    1  ?
      eggs   42  3.14
      other   ?  2.7
      -----  --  ----
  
      Various plain-text table formats (`tablefmt`) are supported:
      'plain', 'simple', 'grid', 'pipe', 'orgtbl', 'rst', 'mediawiki',
      and 'latex'. Variable `tabulate_formats` contains the list of
      currently supported formats.
  
      "plain" format doesn't use any pseudographics to draw tables,
      it separates columns with a double space:
  
      >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],
      ...                 ["strings", "numbers"], "plain"))
      strings      numbers
      spam         41.9999
      eggs        451
  
      >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]], tablefmt="plain"))
      spam   41.9999
      eggs  451
  
      "simple" format is like Pandoc simple_tables:
  
      >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],
      ...                 ["strings", "numbers"], "simple"))
      strings      numbers
      ---------  ---------
      spam         41.9999
      eggs        451
  
      >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]], tablefmt="simple"))
      ----  --------
      spam   41.9999
      eggs  451
      ----  --------
  
      "grid" is similar to tables produced by Emacs table.el package or
      Pandoc grid_tables:
  
      >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],
      ...                ["strings", "numbers"], "grid"))
      +-----------+-----------+
      | strings   |   numbers |
      +===========+===========+
      | spam      |   41.9999 |
      +-----------+-----------+
      | eggs      |  451      |
      +-----------+-----------+
  
      >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]], tablefmt="grid"))
      +------+----------+
      | spam |  41.9999 |
      +------+----------+
      | eggs | 451      |
      +------+----------+
  
      "pipe" is like tables in PHP Markdown Extra extension or Pandoc
      pipe_tables:
  
      >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],
      ...                ["strings", "numbers"], "pipe"))
      | strings   |   numbers |
      |:----------|----------:|
      | spam      |   41.9999 |
      | eggs      |  451      |
  
      >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]], tablefmt="pipe"))
      |:-----|---------:|
      | spam |  41.9999 |
      | eggs | 451      |
  
      "orgtbl" is like tables in Emacs org-mode and orgtbl-mode. They
      are slightly different from "pipe" format by not using colons to
      define column alignment, and using a "+" sign to indicate line
      intersections:
  
      >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],
      ...                ["strings", "numbers"], "orgtbl"))
      | strings   |   numbers |
      |-----------+-----------|
      | spam      |   41.9999 |
      | eggs      |  451      |
  
  
      >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]], tablefmt="orgtbl"))
      | spam |  41.9999 |
      | eggs | 451      |
  
      "rst" is like a simple table format from reStructuredText; please
      note that reStructuredText accepts also "grid" tables:
  
      >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],
      ...                ["strings", "numbers"], "rst"))
      =========  =========
      strings      numbers
      =========  =========
      spam         41.9999
      eggs        451
      =========  =========
  
      >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]], tablefmt="rst"))
      ====  ========
      spam   41.9999
      eggs  451
      ====  ========
  
      "mediawiki" produces a table markup used in Wikipedia and on other
      MediaWiki-based sites:
  
      >>> print(tabulate([["strings", "numbers"], ["spam", 41.9999], ["eggs", "451.0"]],
      ...                headers="firstrow", tablefmt="mediawiki"))
      {| class="wikitable" style="text-align: left;"
      |+ <!-- caption -->
      |-
      ! strings   !! align="right"|   numbers
      |-
      | spam      || align="right"|   41.9999
      |-
      | eggs      || align="right"|  451
      |}
  
      "latex" produces a tabular environment of LaTeX document markup:
  
      >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]], tablefmt="latex"))
      \\begin{tabular}{lr}
      \\hline
       spam &  41.9999 \\\\
       eggs & 451      \\\\
      \\hline
      \\end{tabular}
  
      """
  
      list_of_lists, headers = _normalize_tabular_data(
          tabular_data, headers
      )
  
      # optimization: look for ANSI control codes once,
      # enable smart width functions only if a control code is found
      plain_text = "\n".join(
          ["\t".join(map(_text_type, headers))]
          + ["\t".join(map(_text_type, row)) for row in list_of_lists]
      )
      has_invisible = re.search(_invisible_codes, plain_text)
      if has_invisible:
          width_fn = _visible_width
      else:
          width_fn = len
  
      # format rows and columns, convert numeric values to strings
      cols = list(zip(*list_of_lists))
      coltypes = list(map(_column_type, cols))
      cols = [
          [_format(v, ct, floatfmt, missingval) for v in c]
          for c, ct in zip(cols, coltypes)
      ]
  
      # align columns
      aligns = [
          numalign if ct in [int, float] else stralign
          for ct in coltypes
      ]
      minwidths = (
          [width_fn(h) + 2 for h in headers]
          if headers
          else [0] * len(cols)
      )
      cols = [
          _align_column(c, a, minw, has_invisible)
          for c, a, minw in zip(cols, aligns, minwidths)
      ]
  
      if headers:
          # align headers and add headers
          minwidths = [
              max(minw, width_fn(c[0]))
              for minw, c in zip(minwidths, cols)
          ]
          headers = [
              _align_header(h, a, minw)
              for h, a, minw in zip(headers, aligns, minwidths)
          ]
          rows = list(zip(*cols))
      else:
          minwidths = [width_fn(c[0]) for c in cols]
          rows = list(zip(*cols))
  
      if not isinstance(tablefmt, TableFormat):
          tablefmt = _table_formats.get(
              tablefmt, _table_formats["simple"]
          )
  
      return _format_table(tablefmt, headers, rows, minwidths, aligns)
  
imports: from __future__ import print_function
  from __future__ import unicode_literals
  from collections import namedtuple
  from platform import python_version_tuple
  import re
label_desc: Use image node_id 22 for calling a global function with example usage: tabulate(tabular_data, headers, tablefmt, floatfmt, numalign, stralign, missingval) and returns: _format_table