code: def read_html(
      io,
      match=".+",
      flavor=None,
      header=None,
      index_col=None,
      skiprows=None,
      attrs=None,
      parse_dates=False,
      tupleize_cols=None,
      thousands=",",
      encoding=None,
      decimal=".",
      converters=None,
      na_values=None,
      keep_default_na=True,
      displayed_only=True,
  ):
      r"""Read HTML tables into a ``list`` of ``DataFrame`` objects.
  
      Parameters
      ----------
      io : str or file-like
          A URL, a file-like object, or a raw string containing HTML. Note that
          lxml only accepts the http, ftp and file url protocols. If you have a
          URL that starts with ``'https'`` you might try removing the ``'s'``.
  
      match : str or compiled regular expression, optional
          The set of tables containing text matching this regex or string will be
          returned. Unless the HTML is extremely simple you will probably need to
          pass a non-empty string here. Defaults to '.+' (match any non-empty
          string). The default value will return all tables contained on a page.
          This value is converted to a regular expression so that there is
          consistent behavior between Beautiful Soup and lxml.
  
      flavor : str or None, container of strings
          The parsing engine to use. 'bs4' and 'html5lib' are synonymous with
          each other, they are both there for backwards compatibility. The
          default of ``None`` tries to use ``lxml`` to parse and if that fails it
          falls back on ``bs4`` + ``html5lib``.
  
      header : int or list-like or None, optional
          The row (or list of rows for a :class:`~pandas.MultiIndex`) to use to
          make the columns headers.
  
      index_col : int or list-like or None, optional
          The column (or list of columns) to use to create the index.
  
      skiprows : int or list-like or slice or None, optional
          0-based. Number of rows to skip after parsing the column integer. If a
          sequence of integers or a slice is given, will skip the rows indexed by
          that sequence.  Note that a single element sequence means 'skip the nth
          row' whereas an integer means 'skip n rows'.
  
      attrs : dict or None, optional
          This is a dictionary of attributes that you can pass to use to identify
          the table in the HTML. These are not checked for validity before being
          passed to lxml or Beautiful Soup. However, these attributes must be
          valid HTML table attributes to work correctly. For example, ::
  
              attrs = {'id': 'table'}
  
          is a valid attribute dictionary because the 'id' HTML tag attribute is
          a valid HTML attribute for *any* HTML tag as per `this document
          <http://www.w3.org/TR/html-markup/global-attributes.html>`__. ::
  
              attrs = {'asdf': 'table'}
  
          is *not* a valid attribute dictionary because 'asdf' is not a valid
          HTML attribute even if it is a valid XML attribute.  Valid HTML 4.01
          table attributes can be found `here
          <http://www.w3.org/TR/REC-html40/struct/tables.html#h-11.2>`__. A
          working draft of the HTML 5 spec can be found `here
          <http://www.w3.org/TR/html-markup/table.html>`__. It contains the
          latest information on table attributes for the modern web.
  
      parse_dates : bool, optional
          See :func:`~pandas.read_csv` for more details.
  
      tupleize_cols : bool, optional
          If ``False`` try to parse multiple header rows into a
          :class:`~pandas.MultiIndex`, otherwise return raw tuples. Defaults to
          ``False``.
  
          .. deprecated:: 0.21.0
             This argument will be removed and will always convert to MultiIndex
  
      thousands : str, optional
          Separator to use to parse thousands. Defaults to ``','``.
  
      encoding : str or None, optional
          The encoding used to decode the web page. Defaults to ``None``.``None``
          preserves the previous encoding behavior, which depends on the
          underlying parser library (e.g., the parser library will try to use
          the encoding provided by the document).
  
      decimal : str, default '.'
          Character to recognize as decimal point (e.g. use ',' for European
          data).
  
          .. versionadded:: 0.19.0
  
      converters : dict, default None
          Dict of functions for converting values in certain columns. Keys can
          either be integers or column labels, values are functions that take one
          input argument, the cell (not column) content, and return the
          transformed content.
  
          .. versionadded:: 0.19.0
  
      na_values : iterable, default None
          Custom NA values
  
          .. versionadded:: 0.19.0
  
      keep_default_na : bool, default True
          If na_values are specified and keep_default_na is False the default NaN
          values are overridden, otherwise they're appended to
  
          .. versionadded:: 0.19.0
  
      displayed_only : bool, default True
          Whether elements with "display: none" should be parsed
  
          .. versionadded:: 0.23.0
  
      Returns
      -------
      dfs : list of DataFrames
  
      See Also
      --------
      pandas.read_csv
  
      Notes
      -----
      Before using this function you should read the :ref:`gotchas about the
      HTML parsing libraries <io.html.gotchas>`.
  
      Expect to do some cleanup after you call this function. For example, you
      might need to manually assign column names if the column names are
      converted to NaN when you pass the `header=0` argument. We try to assume as
      little as possible about the structure of the table and push the
      idiosyncrasies of the HTML contained in the table to the user.
  
      This function searches for ``<table>`` elements and only for ``<tr>``
      and ``<th>`` rows and ``<td>`` elements within each ``<tr>`` or ``<th>``
      element in the table. ``<td>`` stands for "table data". This function
      attempts to properly handle ``colspan`` and ``rowspan`` attributes.
      If the function has a ``<thead>`` argument, it is used to construct
      the header, otherwise the function attempts to find the header within
      the body (by putting rows with only ``<th>`` elements into the header).
  
          .. versionadded:: 0.21.0
  
      Similar to :func:`~pandas.read_csv` the `header` argument is applied
      **after** `skiprows` is applied.
  
      This function will *always* return a list of :class:`DataFrame` *or*
      it will fail, e.g., it will *not* return an empty list.
  
      Examples
      --------
      See the :ref:`read_html documentation in the IO section of the docs
      <io.read_html>` for some examples of reading in HTML tables.
      """
      _importers()
  
      # Type check here. We don't want to parse only to fail because of an
      # invalid value of an integer skiprows.
      if isinstance(skiprows, numbers.Integral) and skiprows < 0:
          raise ValueError(
              "cannot skip rows starting from the end of the "
              "data (you passed a negative value)"
          )
      _validate_header_arg(header)
      return _parse(
          flavor=flavor,
          io=io,
          match=match,
          header=header,
          index_col=index_col,
          skiprows=skiprows,
          parse_dates=parse_dates,
          tupleize_cols=tupleize_cols,
          thousands=thousands,
          attrs=attrs,
          encoding=encoding,
          decimal=decimal,
          converters=converters,
          na_values=na_values,
          keep_default_na=keep_default_na,
          displayed_only=displayed_only,
      )
  
imports: from distutils.version import LooseVersion
  import numbers
  import os
  import re
  import pandas.compat
  from pandas.compat import binary_type, iteritems, lmap, lrange, raise_with_traceback, string_types, u
  from pandas.errors import AbstractMethodError, EmptyDataError
  from pandas.core.dtypes.common import is_list_like
  from pandas import Series
  from pandas.io.common import _is_url, _validate_header_arg, urlopen
  from pandas.io.formats.printing import pprint_thing
  from pandas.io.parsers import TextParser
label_desc: Use image node_id 12 for calling a global function with example usage: read_html(io, match, flavor, header, index_col, skiprows, attrs, parse_dates, tupleize_cols, thousands, encoding, decimal, converters, na_values, keep_default_na, displayed_only) and returns: _parse