Skip to content
pytablewriter is a Python library to write a table in various formats: CSV / Elasticsearch / HTML / JavaScript / JSON / LaTeX / LDJSON / LTSV / Markdown / MediaWiki / NumPy / Excel / Pandas / Python / reStructuredText / SQLite / TOML / TSV.
Branch: master
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
.travis Try to fix tests for Travis CI Python 2.7/3.4 env Nov 25, 2018
docs Update docs May 5, 2019
examples Update examples Mar 16, 2019
pytablewriter Bump version May 11, 2019
requirements Update requirements May 11, 2019
ss Update README Aug 20, 2017
test Modify an importer skip minversion May 11, 2019
.coveragerc Add .coveragerc Nov 25, 2018
.gitignore Update .gitignore Feb 16, 2019
.travis.yml Remove unnecessary sudo configs from Travis CI May 11, 2019
LICENSE Initial commit May 23, 2016
MANIFEST.in Update MANIFEST.in Jun 19, 2016
Makefile
README.rst Update README May 5, 2019
appveyor.yml Loosen external package dependencies Oct 8, 2018
invoke_pytest.py Update URLs to refer to Sep 9, 2018
pylama.ini Update pylama.ini Jan 20, 2019
pyproject.toml Update pyproject.toml May 11, 2019
setup.cfg Remove build alias May 11, 2019
setup.py Update requirements May 11, 2019
tox.ini Add support for Python 3.8 May 11, 2019

README.rst

Summary

pytablewriter is a Python library to write a table in various formats: CSV / Elasticsearch / HTML / JavaScript / JSON / LaTeX / LDJSON / LTSV / Markdown / MediaWiki / NumPy / Excel / Pandas / Python / reStructuredText / SQLite / TOML / TSV.

PyPI package version Supported Python versions Linux/macOS CI status Windows CI status Test coverage GitHub stars

Features

  • Write a table in various formats:
  • Automatic tabular data formatting
    • Alignment
    • Padding
    • Decimal places of numbers
  • Configure cell styles:
    • Text alignment
    • Font size/weight
    • Thousand separator for numbers: e.g. 1,000/1 000
  • Configure ouput:
    • Write table to a stream such as a file/standard-output/string-buffer/Jupyter-Notebook
    • Get rendered tabular text
  • Data source
  • Multibyte character support
  • ANSI color support

Examples

Write tables

Write a Markdown table

Sample Code:
from pytablewriter import MarkdownTableWriter

writer = MarkdownTableWriter()
writer.table_name = "example_table"
writer.headers = ["int", "float", "str", "bool", "mix", "time"]
writer.value_matrix = [
    [0,   0.1,      "hoge", True,   0,      "2017-01-01 03:04:05+0900"],
    [2,   "-2.23",  "foo",  False,  None,   "2017-12-23 45:01:23+0900"],
    [3,   0,        "bar",  "true",  "inf", "2017-03-03 33:44:55+0900"],
    [-10, -9.9,     "",     "FALSE", "nan", "2017-01-01 00:00:00+0900"],
]

writer.write_table()
Output:
# example_table
|int|float|str |bool |  mix   |          time          |
|--:|----:|----|-----|-------:|------------------------|
|  0| 0.10|hoge|True |       0|2017-01-01 03:04:05+0900|
|  2|-2.23|foo |False|        |2017-12-23 12:34:51+0900|
|  3| 0.00|bar |True |Infinity|2017-03-03 22:44:55+0900|
|-10|-9.90|    |False|     NaN|2017-01-01 00:00:00+0900|
Rendering Result:
markdown_ss

Rendered markdown at GitHub

Write a Markdown table with a margin
Sample Code:
from pytablewriter import MarkdownTableWriter

writer = MarkdownTableWriter()
writer.table_name = "write example with a margin"
writer.headers = ["int", "float", "str", "bool", "mix", "time"]
writer.value_matrix = [
    [0,   0.1,      "hoge", True,   0,      "2017-01-01 03:04:05+0900"],
    [2,   "-2.23",  "foo",  False,  None,   "2017-12-23 45:01:23+0900"],
    [3,   0,        "bar",  "true",  "inf", "2017-03-03 33:44:55+0900"],
    [-10, -9.9,     "",     "FALSE", "nan", "2017-01-01 00:00:00+0900"],
]
writer.margin = 1  # add a whitespace for both sides of each cell

writer.write_table()
Output:
# write example with a margin
| int | float | str  | bool  |   mix    |           time           |
|----:|------:|------|-------|---------:|--------------------------|
|   0 |  0.10 | hoge | True  |        0 | 2017-01-01 03:04:05+0900 |
|   2 | -2.23 | foo  | False |          | 2017-12-23 12:34:51+0900 |
|   3 |  0.00 | bar  | True  | Infinity | 2017-03-03 22:44:55+0900 |
| -10 | -9.90 |      | False |      NaN | 2017-01-01 00:00:00+0900 |

margin attribute can be available for all of the text format writer classes.

Write a reStructuredText table (Grid Tables)

Sample Code:
import pytablewriter

writer = pytablewriter.RstGridTableWriter()
writer.table_name = "example_table"
writer.headers = ["int", "float", "str", "bool", "mix", "time"]
writer.value_matrix = [
    [0,   0.1,      "hoge", True,   0,      "2017-01-01 03:04:05+0900"],
    [2,   "-2.23",  "foo",  False,  None,   "2017-12-23 45:01:23+0900"],
    [3,   0,        "bar",  "true",  "inf", "2017-03-03 33:44:55+0900"],
    [-10, -9.9,     "",     "FALSE", "nan", "2017-01-01 00:00:00+0900"],
]

writer.write_table()
Output:
.. table:: example_table

    +---+-----+----+-----+--------+------------------------+
    |int|float|str |bool |  mix   |          time          |
    +===+=====+====+=====+========+========================+
    |  0| 0.10|hoge|True |       0|2017-01-01 03:04:05+0900|
    +---+-----+----+-----+--------+------------------------+
    |  2|-2.23|foo |False|        |2017-12-23 12:34:51+0900|
    +---+-----+----+-----+--------+------------------------+
    |  3| 0.00|bar |True |Infinity|2017-03-03 22:44:55+0900|
    +---+-----+----+-----+--------+------------------------+
    |-10|-9.90|    |False|     NaN|2017-01-01 00:00:00+0900|
    +---+-----+----+-----+--------+------------------------+
Rendering Result: example_table

int

float

str

bool

mix

time

0

0.10

hoge

True

0

2017-01-01 03:04:05+0900

2

-2.23

foo

False

 

2017-12-23 12:34:51+0900

3

0.00

bar

True

Infinity

2017-03-03 22:44:55+0900

-10

-9.90

 

False

NaN

2017-01-01 00:00:00+0900

Write a table with JavaScript format (as a nested list variable definition)

Sample Code:
import pytablewriter

writer = pytablewriter.JavaScriptTableWriter()
writer.table_name = "example_table"
writer.headers = ["int", "float", "str", "bool", "mix", "time"]
writer.value_matrix = [
    [0,   0.1,      "hoge", True,   0,      "2017-01-01 03:04:05+0900"],
    [2,   "-2.23",  "foo",  False,  None,   "2017-12-23 45:01:23+0900"],
    [3,   0,        "bar",  "true",  "inf", "2017-03-03 33:44:55+0900"],
    [-10, -9.9,     "",     "FALSE", "nan", "2017-01-01 00:00:00+0900"],
]

writer.write_table()
Output:
const example_table = [
    ["int", "float", "str", "bool", "mix", "time"],
    [0, 0.10, "hoge", true, 0, "2017-01-01 03:04:05+0900"],
    [2, -2.23, "foo", false, null, "2017-12-23 12:34:51+0900"],
    [3, 0.00, "bar", true, Infinity, "2017-03-03 22:44:55+0900"],
    [-10, -9.90, "", false, NaN, "2017-01-01 00:00:00+0900"]
];

Write a table to an Excel sheet

Sample Code:
from pytablewriter import ExcelXlsxTableWriter

writer = ExcelXlsxTableWriter()
writer.table_name = "example"
writer.headers = ["int", "float", "str", "bool", "mix", "time"]
writer.value_matrix = [
    [0,   0.1,      "hoge", True,   0,      "2017-01-01 03:04:05+0900"],
    [2,   "-2.23",  "foo",  False,  None,   "2017-12-23 12:34:51+0900"],
    [3,   0,        "bar",  "true",  "inf", "2017-03-03 22:44:55+0900"],
    [-10, -9.9,     "",     "FALSE", "nan", "2017-01-01 00:00:00+0900"],
]
writer.dump("sample.xlsx")
Output:
excel_single

Output excel file (sample_single.xlsx)

Write a Unicode table

Sample Code:
from pytablewriter import UnicodeTableWriter

writer = UnicodeTableWriter()
writer.table_name = "example_table"
writer.headers = ["int", "float", "str", "bool", "mix", "time"]
writer.value_matrix = [
    [0,   0.1,      "hoge", True,   0,      "2017-01-01 03:04:05+0900"],
    [2,   "-2.23",  "foo",  False,  None,   "2017-12-23 45:01:23+0900"],
    [3,   0,        "bar",  "true",  "inf", "2017-03-03 33:44:55+0900"],
    [-10, -9.9,     "",     "FALSE", "nan", "2017-01-01 00:00:00+0900"],
]

writer.write_table()
Output:
┌───┬─────┬────┬─────┬────────┬────────────────────────┐
│int│float│str │bool │  mix   │          time          │
├───┼─────┼────┼─────┼────────┼────────────────────────┤
│  0│ 0.10│hoge│True │       0│2017-01-01 03:04:05+0900│
├───┼─────┼────┼─────┼────────┼────────────────────────┤
│  2│-2.23│foo │False│        │2017-12-23 12:34:51+0900│
├───┼─────┼────┼─────┼────────┼────────────────────────┤
│  3│ 0.00│bar │True │Infinity│2017-03-03 22:44:55+0900│
├───┼─────┼────┼─────┼────────┼────────────────────────┤
│-10│-9.90│    │False│     NaN│2017-01-01 00:00:00+0900│
└───┴─────┴────┴─────┴────────┴────────────────────────┘

Write a Markdown table from pandas.DataFrame instance

from_dataframe method of writer classes will set up tabular data from pandas.DataFrame:

Sample Code:
from textwrap import dedent
import pandas as pd
import six
from pytablewriter import MarkdownTableWriter

csv_data = six.StringIO(dedent("""\
    "i","f","c","if","ifc","bool","inf","nan","mix_num","time"
    1,1.10,"aa",1.0,"1",True,Infinity,NaN,1,"2017-01-01 00:00:00+09:00"
    2,2.20,"bbb",2.2,"2.2",False,Infinity,NaN,Infinity,"2017-01-02 03:04:05+09:00"
    3,3.33,"cccc",-3.0,"ccc",True,Infinity,NaN,NaN,"2017-01-01 00:00:00+09:00"
    """))
df = pd.read_csv(csv_data, sep=',')

writer = MarkdownTableWriter()
writer.from_dataframe(df)
writer.write_table()
Output:
| i | f  | c  | if |ifc|bool |  inf   |nan|mix_num |          time           |
|--:|---:|----|---:|---|-----|--------|---|-------:|-------------------------|
|  1|1.10|aa  | 1.0|  1|True |Infinity|NaN|       1|2017-01-01 00:00:00+09:00|
|  2|2.20|bbb | 2.2|2.2|False|Infinity|NaN|Infinity|2017-01-02 03:04:05+09:00|
|  3|3.33|cccc|-3.0|ccc|True |Infinity|NaN|     NaN|2017-01-01 00:00:00+09:00|

Adding a column of the DataFrame index if you specify add_index_column=True:

Sample Code:
import pandas as pd
from pytablewriter import MarkdownTableWriter

writer = MarkdownTableWriter()
writer.table_name = "add_index_column"
writer.from_dataframe(
    pd.DataFrame({"A": [1, 2], "B": [10, 11]}, index=["a", "b"]),
    add_index_column=True,
)
writer.write_table()
Output:
# add_index_column
|   | A | B |
|---|--:|--:|
|a  |  1| 10|
|b  |  2| 11|

Write a markdown table from a space-separated values

Sample Code:
from textwrap import dedent
import pytablewriter

writer = pytablewriter.MarkdownTableWriter()
writer.table_name = "ps"
writer.from_csv(
    dedent("""\
        USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
        root         1  0.0  0.4  77664  8784 ?        Ss   May11   0:02 /sbin/init
        root         2  0.0  0.0      0     0 ?        S    May11   0:00 [kthreadd]
        root         4  0.0  0.0      0     0 ?        I<   May11   0:00 [kworker/0:0H]
        root         6  0.0  0.0      0     0 ?        I<   May11   0:00 [mm_percpu_wq]
        root         7  0.0  0.0      0     0 ?        S    May11   0:01 [ksoftirqd/0]
    """),
    delimiter=" ")
writer.write_table()
Output:
# ps
|USER|PID|%CPU|%MEM| VSZ |RSS |TTY|STAT|START|TIME|   COMMAND    |
|----|--:|---:|---:|----:|---:|---|----|-----|----|--------------|
|root|  1|   0| 0.4|77664|8784|?  |Ss  |May11|0:02|/sbin/init    |
|root|  2|   0| 0.0|    0|   0|?  |S   |May11|0:00|[kthreadd]    |
|root|  4|   0| 0.0|    0|   0|?  |I<  |May11|0:00|[kworker/0:0H]|
|root|  6|   0| 0.0|    0|   0|?  |I<  |May11|0:00|[mm_percpu_wq]|
|root|  7|   0| 0.0|    0|   0|?  |S   |May11|0:01|[ksoftirqd/0] |

Get rendered tabular text as str

dumps method returns rendered tabular text. dumps only available for text format writers.

Sample Code:
import pytablewriter

writer = pytablewriter.MarkdownTableWriter()
writer.headers = ["int", "float", "str", "bool", "mix", "time"]
writer.value_matrix = [
    [0,   0.1,      "hoge", True,   0,      "2017-01-01 03:04:05+0900"],
    [2,   "-2.23",  "foo",  False,  None,   "2017-12-23 45:01:23+0900"],
    [3,   0,        "bar",  "true",  "inf", "2017-03-03 33:44:55+0900"],
    [-10, -9.9,     "",     "FALSE", "nan", "2017-01-01 00:00:00+0900"],
]

print(writer.dumps())
Output:
|int|float|str |bool |  mix   |          time          |
|--:|----:|----|-----|-------:|------------------------|
|  0| 0.10|hoge|True |       0|2017-01-01 03:04:05+0900|
|  2|-2.23|foo |False|        |2017-12-23 45:01:23+0900|
|  3| 0.00|bar |True |Infinity|2017-03-03 33:44:55+0900|
|-10|-9.90|    |False|     NaN|2017-01-01 00:00:00+0900|

Configure table styles

Writers can specify cell Style for each column manually by styles attribute of writer classes.

Sample Code:
from pytablewriter import MarkdownTableWriter
from pytablewriter.style import Style

writer = MarkdownTableWriter()
writer.table_name = "set style by styles"
writer.headers = [
    "auto align",
    "left align",
    "center align",
    "bold",
    "italic",
    "bold italic ts",
]
writer.value_matrix = [
    [11, 11, 11, 11, 11, 11],
    [1234, 1234, 1234, 1234, 1234, 1234],
]

# specify styles for each column
writer.styles = [
    Style(),
    Style(align="left"),
    Style(align="center"),
    Style(font_weight="bold"),
    Style(font_style="italic"),
    Style(font_weight="bold", font_style="italic", thousand_separator=","),
]

writer.write_table()
Output:
# set style by styles
|auto align|left align|center align|  bold  |italic|bold italic ts|
|---------:|----------|:----------:|-------:|-----:|-------------:|
|        11|11        |     11     |  **11**|  _11_|      _**11**_|
|      1234|1234      |    1234    |**1234**|_1234_|   _**1,234**_|

Rendering result

You can also set Style to a specific column with index or header by using set_style method:

Sample Code:
from pytablewriter import MarkdownTableWriter
from pytablewriter.style import Style

writer = MarkdownTableWriter()
writer.headers = ["A", "B", "C",]
writer.value_matrix = [[11, 11, 11], [1234, 1234, 1234]]

writer.table_name = "set style by index"
writer.set_style(1, Style(align="center", font_weight="bold"))
writer.set_style(2, Style(thousand_separator=" "))
writer.write_table()
writer.write_null_line()

writer.table_name = "set style by header"
writer.set_style("B", Style(font_style="italic"))
writer.write_table()
Output:
# set style by index
| A  |   B    |  C  |
|---:|:------:|----:|
|  11| **11** |   11|
|1234|**1234**|1 234|

# set style by header
| A  |  B   |  C  |
|---:|-----:|----:|
|  11|  _11_|   11|
|1234|_1234_|1 234|

Make tables for specific applications

Create Elasticsearch index and put data

Sample Code:
import datetime
import json

from elasticsearch import Elasticsearch
import pytablewriter as ptw

es = Elasticsearch(hosts="localhost:9200")

writer = ptw.ElasticsearchWriter()
writer.stream = es
writer.index_name = "es writer example"
writer.headers = [
    "str", "byte", "short", "int", "long", "float", "date", "bool", "ip",
]
writer.value_matrix = [
    [
        "abc", 100, 10000, 2000000000, 200000000000, 0.1,
        datetime.datetime(2017, 1, 2, 3, 4, 5), True, "127.0.0.1",
    ],
    [
        "def", -10, -1000, -200000000, -20000000000, 100.1,
        datetime.datetime(2017, 6, 5, 4, 5, 2), False, "::1",
    ],
]

# delete existing index ---
es.indices.delete(index=writer.index_name, ignore=404)

# create an index and put data ---
writer.write_table()

# display the result ---
es.indices.refresh(index=writer.index_name)

print("----- mappings -----")
response = es.indices.get_mapping(index=writer.index_name, doc_type="table")
print("{}\n".format(json.dumps(response, indent=4)))

print("----- documents -----")
response = es.search(
    index=writer.index_name,
    doc_type="table",
    body={
        "query": {"match_all": {}}
    }
)
for hit in response["hits"]["hits"]:
    print(json.dumps(hit["_source"], indent=4))
Output:
----- mappings -----
{
    "es_writer_example": {
        "mappings": {
            "table": {
                "properties": {
                    "bool": {
                        "type": "boolean"
                    },
                    "byte": {
                        "type": "byte"
                    },
                    "date": {
                        "type": "date",
                        "format": "date_optional_time"
                    },
                    "float": {
                        "type": "double"
                    },
                    "int": {
                        "type": "integer"
                    },
                    "ip": {
                        "type": "text"
                    },
                    "long": {
                        "type": "long"
                    },
                    "short": {
                        "type": "short"
                    },
                    "str": {
                        "type": "text"
                    }
                }
            }
        }
    }
}

----- documents -----
{
    "str": "def",
    "byte": -10,
    "short": -1000,
    "int": -200000000,
    "long": -20000000000,
    "float": 100.1,
    "date": "2017-06-05T04:05:02",
    "bool": false,
    "ip": "::1"
}
{
    "str": "abc",
    "byte": 100,
    "short": 10000,
    "int": 2000000000,
    "long": 200000000000,
    "float": 0.1,
    "date": "2017-01-02T03:04:05",
    "bool": true,
    "ip": "127.0.0.1"
}

Render a table on Jupyter Notebook

https://nbviewer.jupyter.org/github/thombashi/pytablewriter/blob/master/examples/ipynb/jupyter_notebook_example.ipynb

jupyter_notebook_table

Table formatting for Jupyter Notebook

Multibyte charater support

Write a table using multibyte character

You can use multibyte characters as table data. Multibyte characters also properly padded and aligned.

Sample Code:
import pytablewriter

writer = pytablewriter.RstSimpleTableWriter()
writer.table_name = "生成に関するパターン"
writer.headers = ["パターン名", "概要", "GoF", "Code Complete[1]"]
writer.value_matrix = [
    ["Abstract Factory", "関連する一連のインスタンスを状況に応じて、適切に生成する方法を提供する。", "Yes", "Yes"],
    ["Builder", "複合化されたインスタンスの生成過程を隠蔽する。", "Yes", "No"],
    ["Factory Method", "実際に生成されるインスタンスに依存しない、インスタンスの生成方法を提供する。", "Yes", "Yes"],
    ["Prototype", "同様のインスタンスを生成するために、原型のインスタンスを複製する。", "Yes", "No"],
    ["Singleton", "あるクラスについて、インスタンスが単一であることを保証する。", "Yes", "Yes"],
]
writer.write_table()
Output:
multi_byte_char_table

Output of multi-byte character table

For more information

More examples are available at https://pytablewriter.rtfd.io/en/latest/pages/examples/index.html

Installation

Install from PyPI

pip install pytablewriter

Some of the formats require additional dependency packages, you can install the dependency packages as follows:

  • Elasticsearch
    • pip install pytablewriter[es6] or pip install pytablewriter[es5]
  • Excel
    • pip install pytablewriter[excel]
  • HTML
    • pip install pytablewriter[html]
  • SQLite
    • pip install pytablewriter[sqlite]
  • TOML
    • pip install pytablewriter[toml]
  • All of the extra dependencies
    • pip install pytablewriter[all]

Install from PPA (for Ubuntu)

sudo add-apt-repository ppa:thombashi/ppa
sudo apt update
sudo apt install python3-pytablewriter

Dependencies

Python 2.7+ or 3.5+

Optional dependencies

Test dependencies

Documentation

https://pytablewriter.rtfd.io/

Related Project

  • pytablereader
    • Tabular data loaded by pytablereader can be written another tabular data format with pytablewriter.

Tasks

https://trello.com/b/kE0XG34y

You can’t perform that action at this time.