The :meth:`~astropy.table.Table.read` and :meth:`~astropy.table.Table.write` methods can be used to read and write text-based table data in a wide variety of supported formats. In addition to common formats like CSV and :ref:`fixed-width <fixed_width_gallery>`, the unified interface also supports specialized formats like LaTeX tables and the AAS :class:`MRT <astropy.io.ascii.Mrt>` format.

Most of the formats are provided by :ref:`table_io_ascii`, which is a flexible and powerful interface for reading and writing text tables. In addition, the interface provides wrappers around select I/O functions in the pandas library for additional flexibility and performance.

These formats use a character delimiter to separate columns. This is most commonly a comma (CSV) or a whitespace character like space or tab.

These formats use fixed-width columns, where each column has a fixed width in characters. This can be useful for tables that are intended to also be read by humans.

Be aware that in many cases reading tables from published HTML journal articles will not work for a variety of reasons, including inconsistent mark-ups, CAPTCHAs, changing formats, embedded javascript, or the table actually being an image. If possible you should consider retrieving the table in a standard data format such as CSV or FITS, perhaps from an archive such as CDS/Vizier.

The :ref:`astropy.io.ascii <io-ascii>` sub-package provides read and write support for :ref:`many different formats <supported_formats>`, including astronomy-specific formats like AAS Machine-Readable Tables (MRT).

We strongly recommend using the unified interface for reading and writing tables via the :ref:`astropy.io.ascii <io-ascii>` sub-package. This is done by prefixing the :ref:`format name <supported_formats>` with the ascii. prefix. For example to read a DAOphot table (in this example we use a file that is installed with astropy):

>>> from astropy.table import Table
>>> from astropy.utils.data import get_pkg_data_filename
>>> photometry_file = get_pkg_data_filename('data/daophot4.dat',
...                                         package='astropy.io.ascii.tests')
>>> t = Table.read(photometry_file, format='ascii.daophot')

Use format='ascii' in order read a table and guess the table format by successively trying most of the available formats in a specific order. This can be slow for large tables and :ref:`might read the table in a different format than expected <io_ascii_should_specify_format>`.

>>> latex_file = get_pkg_data_filename('data/latex1.tex',
...                                     package='astropy.io.ascii.tests')
>>> t = Table.read(latex_file, format='ascii')
>>> print(t)
cola colb colc
---- ---- ----
   a    1    2
   b    3    4

When writing a table with format='ascii' the output is a basic space-delimited file with a single header line containing the column names.

All additional arguments are passed to the astropy.io.ascii :func:`~astropy.io.ascii.read` and :func:`~astropy.io.ascii.write` functions. Further details are available in the sections on :ref:`io_ascii_read_parameters` and :ref:`io_ascii_write_parameters`. For example, to change the column delimiter and the output format for the colc column use:

>>> import sys
>>> t.write(sys.stdout, format='ascii', delimiter='|', formats={'colc': '%0.2f'})
#
#
cola|colb|colc
a|1|2.00
b|3|4.00

astropy ~astropy.table.Table supports the ability to read or write tables using some of the :ref:`I/O methods <pandas:io>` available within pandas. This interface thus provides convenient wrappers to the following functions / methods:

Notes:

• This is subject to the limitations discussed in :ref:`astropy-table-and-dataframes`.
• There is no fixed-width writer in pandas.
• Reading HTML requires BeautifulSoup4 and html5lib to be installed.

When reading or writing a table, any keyword arguments apart from the format and file name are passed through to pandas, for instance:

.. doctest-requires:: pandas

  >>> t.write('data.csv', format='pandas.csv', sep=' ', header=False)
  >>> t2 = Table.read('data.csv', format='pandas.csv', sep=' ', names=['a', 'b', 'c'])

.. testcleanup::
  >>> import os
  >>> if os.path.exists('data.csv'):
  ...     os.remove('data.csv')

The pyarrow library provides a highly-performant CSV reader that can be used in Astropy with Table.read(input_file, format="pyarrow.csv", ...). This can by up to 15 times faster and more memory-efficient than the :ref:`astropy.io.ascii <io-ascii>` fast reader or the default pandas.csv reader. The best performance is achieved for files with only numeric data types, but even for files with mixed data types, the performance is still better than the standard :ref:`astropy.io.ascii <io-ascii>` fast CSV reader.

This reader uses the :func:`~astropy.io.misc.pyarrow.csv.read_csv` function, which in turn uses the PyArrow CSV reader and sets the various options to pyarrow.csv.read_csv() appropriately. The interface is designed to be similar to the :ref:`io.ascii read interface <io_ascii_read_parameters>` where possible, but there are differences, most notably:

• Input can only be a string file name, pathlib.Path, or a binary file-like object.
• Whitespace in string data fields and header column names is preserved.
• Use dtypes instead of converters to specify the column data types.
• Use null_values instead of fill_values to specify the null (missing) values.
• No guess parameter and no guessing of the table format (e.g., delimiter).
• No data_end parameter.
• No exclude_names parameter.
• Columns consisting of only string values True and False are parsed as boolean data.
• Columns with ISO 8601 date/time strings are parsed as shown below: - 12:13:14.123456: object[datetime.time] - 2025-01-01: np.datetime64[D] - 2025-01-01T01:02:03: np.datetime64[s] - 2025-01-01T01:02:03.123456: np.datetime64[ns]
• Timestamp parsing behavior can be customized with the timestamp_parsers parameter.

The :mod:`astropy.io.misc.pyarrow.csv` module also provides the :func:`~astropy.io.misc.pyarrow.csv.convert_pa_table_to_astropy_table` function to allow converting a pyarrow.Table to an astropy.table.Table. This allows using the PyArrow CSV reader directly with custom options that are not available in the astropy interface.