examples/ipynb/pytablewriter_examples.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "\n",
    "from textwrap import dedent\n",
    "\n",
    "import pytablewriter\n",
    "\n",
    "table_name = \"example_table\"\n",
    "headers = [\"int\", \"float\", \"str\", \"bool\", \"mix\", \"time\"]\n",
    "data = [\n",
    "    [0,   0.1,      \"hoge\", True,   0,      \"2017-01-01 03:04:05+0900\"],\n",
    "    [2,   \"-2.23\",  \"foo\",  False,  None,   \"2017-12-23 12:34:51+0900\"],\n",
    "    [3,   0,        \"bar\",  \"true\",  \"inf\", \"2017-03-03 22:44:55+0900\"],\n",
    "    [-10, -9.9,     \"\",     \"FALSE\", \"nan\", \"2017-01-01 00:00:00+0900\"],\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "csv\n",
      "elasticsearch\n",
      "excel\n",
      "htm\n",
      "html\n",
      "javascript\n",
      "js\n",
      "json\n",
      "json_lines\n",
      "jsonl\n",
      "latex_matrix\n",
      "latex_table\n",
      "ldjson\n",
      "ltsv\n",
      "markdown\n",
      "md\n",
      "mediawiki\n",
      "ndjson\n",
      "null\n",
      "numpy\n",
      "pandas\n",
      "py\n",
      "python\n",
      "rst\n",
      "rst_csv\n",
      "rst_csv_table\n",
      "rst_grid\n",
      "rst_grid_table\n",
      "rst_simple\n",
      "rst_simple_table\n",
      "space_aligned\n",
      "sqlite\n",
      "toml\n",
      "tsv\n",
      "unicode\n"
     ]
    }
   ],
   "source": [
    "for name in pytablewriter.TableWriterFactory.get_format_names():\n",
    "    print(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "csv\n",
      "htm\n",
      "html\n",
      "js\n",
      "json\n",
      "jsonl\n",
      "ldjson\n",
      "ltsv\n",
      "md\n",
      "ndjson\n",
      "py\n",
      "rst\n",
      "sqlite\n",
      "sqlite3\n",
      "tex\n",
      "toml\n",
      "tsv\n",
      "xls\n",
      "xlsx\n"
     ]
    }
   ],
   "source": [
    "for name in pytablewriter.TableWriterFactory.get_extensions():\n",
    "    print(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# zone\n",
      "|zone_id|country_code|   zone_name    |\n",
      "|------:|------------|----------------|\n",
      "|      1|AD          |Europe/Andorra  |\n",
      "|      2|AE          |Asia/Dubai      |\n",
      "|      3|AF          |Asia/Kabul      |\n",
      "|      4|AG          |America/Antigua |\n",
      "|      5|AI          |America/Anguilla|\n"
     ]
    }
   ],
   "source": [
    "from pytablewriter import MarkdownTableWriter\n",
    "\n",
    "writer = MarkdownTableWriter()\n",
    "writer.table_name = \"zone\"\n",
    "writer.headers = [\"zone_id\", \"country_code\", \"zone_name\"]\n",
    "writer.value_matrix = [\n",
    "    [\"1\", \"AD\", \"Europe/Andorra\"],\n",
    "    [\"2\", \"AE\", \"Asia/Dubai\"],\n",
    "    [\"3\", \"AF\", \"Asia/Kabul\"],\n",
    "    [\"4\", \"AG\", \"America/Antigua\"],\n",
    "    [\"5\", \"AI\", \"America/Anguilla\"],\n",
    "]\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"int\",\"float\",\"str\",\"bool\",\"mix\",\"time\"\n",
      "0,0.1,\"hoge\",True,0,\"2017-01-01 03:04:05+0900\"\n",
      "2,-2.23,\"foo\",False,,\"2017-12-23 12:34:51+0900\"\n",
      "3,0,\"bar\",True,Infinity,\"2017-03-03 22:44:55+0900\"\n",
      "-10,-9.9,,False,NaN,\"2017-01-01 00:00:00+0900\"\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.CsvTableWriter()\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " PID   USER  PR  NI    VIRT   RES   SHR   S  %CPU  %MEM   TIME+     COMMAND   \n",
      "32866  root  20    0   48344  3924  3448  R   5.6   0.2  0:00.03  top         \n",
      "    1  root  20    0  212080  7676  5876  S   0.0   0.4  1:06.56  systemd     \n",
      "    2  root  20    0       0     0     0  S   0.0   0.0  0:01.92  kthreadd    \n",
      "    4  root   0  -20       0     0     0  S   0.0   0.0  0:00.00  kworker/0:0H\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.SpaceAlignedTableWriter()\n",
    "writer.headers = [\"PID\", \"USER\", \"PR\", \"NI\", \"VIRT\", \"RES\", \"SHR\", \"S\", \"%CPU\", \"%MEM\", \"TIME+\", \"COMMAND\"]\n",
    "writer.value_matrix = csv1 = [\n",
    "    [32866, \"root\", 20, 0, 48344, 3924, 3448, \"R\", 5.6, 0.2, \"0:00.03\", \"top\"],\n",
    "    [1, \"root\", 20, 0, 212080, 7676, 5876, \"S\", 0, 0.4, \"1:06.56\", \"systemd\"],\n",
    "    [2, \"root\", 20, 0, 0, 0, 0, \"S\", 0, 0, \"0:01.92\", \"kthreadd\"],\n",
    "    [4, \"root\", 0, -20, 0, 0, 0, \"S\", 0, 0, \"0:00.00\", \"kworker/0:0H\"],\n",
    "]\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"int\"\t\"float\"\t\"str\"\t\"bool\"\t\"mix\"\t\"time\"\n",
      "0\t0.1\t\"hoge\"\tTrue\t0\t\"2017-01-01 03:04:05+0900\"\n",
      "2\t-2.23\t\"foo\"\tFalse\t\t\"2017-12-23 12:34:51+0900\"\n",
      "3\t0\t\"bar\"\tTrue\tInfinity\t\"2017-03-03 22:44:55+0900\"\n",
      "-10\t-9.9\t\tFalse\tNaN\t\"2017-01-01 00:00:00+0900\"\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.TsvTableWriter()\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<table id=\"example_table\">\n",
      "    <caption>example_table</caption>\n",
      "    <thead>\n",
      "        <tr>\n",
      "            <th>int</th>\n",
      "            <th>float</th>\n",
      "            <th>str</th>\n",
      "            <th>bool</th>\n",
      "            <th>mix</th>\n",
      "            <th>time</th>\n",
      "        </tr>\n",
      "    </thead>\n",
      "    <tbody>\n",
      "        <tr>\n",
      "            <td align=\"right\">0</td>\n",
      "            <td align=\"right\">0.10</td>\n",
      "            <td align=\"left\">hoge</td>\n",
      "            <td align=\"left\">True</td>\n",
      "            <td align=\"right\">0</td>\n",
      "            <td align=\"left\">2017-01-01 03:04:05+0900</td>\n",
      "        </tr>\n",
      "        <tr>\n",
      "            <td align=\"right\">2</td>\n",
      "            <td align=\"right\">-2.23</td>\n",
      "            <td align=\"left\">foo</td>\n",
      "            <td align=\"left\">False</td>\n",
      "            <td align=\"left\"></td>\n",
      "            <td align=\"left\">2017-12-23 12:34:51+0900</td>\n",
      "        </tr>\n",
      "        <tr>\n",
      "            <td align=\"right\">3</td>\n",
      "            <td align=\"right\">0.00</td>\n",
      "            <td align=\"left\">bar</td>\n",
      "            <td align=\"left\">True</td>\n",
      "            <td align=\"left\">Infinity</td>\n",
      "            <td align=\"left\">2017-03-03 22:44:55+0900</td>\n",
      "        </tr>\n",
      "        <tr>\n",
      "            <td align=\"right\">-10</td>\n",
      "            <td align=\"right\">-9.90</td>\n",
      "            <td align=\"left\"></td>\n",
      "            <td align=\"left\">False</td>\n",
      "            <td align=\"left\">NaN</td>\n",
      "            <td align=\"left\">2017-01-01 00:00:00+0900</td>\n",
      "        </tr>\n",
      "    </tbody>\n",
      "</table>\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.HtmlTableWriter()\n",
    "writer.table_name = table_name\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "const example_table = [\n",
      "    [\"int\", \"float\", \"str\", \"bool\", \"mix\", \"time\"],\n",
      "    [0, 0.1, \"hoge\", true, 0, \"2017-01-01 03:04:05+0900\"],\n",
      "    [2, -2.23, \"foo\", false, null, \"2017-12-23 12:34:51+0900\"],\n",
      "    [3, 0, \"bar\", true, Infinity, \"2017-03-03 22:44:55+0900\"],\n",
      "    [-10, -9.9, \"\", \"FALSE\", NaN, \"2017-01-01 00:00:00+0900\"]\n",
      "];\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.JavaScriptTableWriter()\n",
    "writer.table_name = table_name\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[\n",
      "{\n",
      "    \"bool\": true,\n",
      "    \"float\": 0.1,\n",
      "    \"int\": 0,\n",
      "    \"mix\": 0,\n",
      "    \"str\": \"hoge\",\n",
      "    \"time\": \"2017-01-01 03:04:05+0900\"\n",
      "},\n",
      "{\n",
      "    \"bool\": false,\n",
      "    \"float\": -2.23,\n",
      "    \"int\": 2,\n",
      "    \"mix\": null,\n",
      "    \"str\": \"foo\",\n",
      "    \"time\": \"2017-12-23 12:34:51+0900\"\n",
      "},\n",
      "{\n",
      "    \"bool\": true,\n",
      "    \"float\": 0,\n",
      "    \"int\": 3,\n",
      "    \"mix\": \"Infinity\",\n",
      "    \"str\": \"bar\",\n",
      "    \"time\": \"2017-03-03 22:44:55+0900\"\n",
      "},\n",
      "{\n",
      "    \"bool\": \"FALSE\",\n",
      "    \"float\": -9.9,\n",
      "    \"int\": -10,\n",
      "    \"mix\": \"nan\",\n",
      "    \"str\": \"\",\n",
      "    \"time\": \"2017-01-01 00:00:00+0900\"\n",
      "}]\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.JsonTableWriter()\n",
    "#writer.table_name = \"Timezone\"\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"int\": 0, \"float\": 0.1, \"str\": \"hoge\", \"bool\": \"true\", \"mix\": 0, \"time\": \"2017-01-01 03:04:05+0900\"}\n",
      "{\"int\": 2, \"float\": -2.23, \"str\": \"foo\", \"bool\": \"false\", \"mix\": \"null\", \"time\": \"2017-12-23 12:34:51+0900\"}\n",
      "{\"int\": 3, \"float\": 0, \"str\": \"bar\", \"bool\": \"true\", \"mix\": \"Infinity\", \"time\": \"2017-03-03 22:44:55+0900\"}\n",
      "{\"int\": -10, \"float\": -9.9, \"str\": \"\", \"bool\": \"FALSE\", \"mix\": \"nan\", \"time\": \"2017-01-01 00:00:00+0900\"}\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.JsonLinesTableWriter()\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{ \"example_table\" : [\n",
      "{\n",
      "    \"bool\": true,\n",
      "    \"float\": 0.1,\n",
      "    \"int\": 0,\n",
      "    \"mix\": 0,\n",
      "    \"str\": \"hoge\",\n",
      "    \"time\": \"2017-01-01 03:04:05+0900\"\n",
      "},\n",
      "{\n",
      "    \"bool\": false,\n",
      "    \"float\": -2.23,\n",
      "    \"int\": 2,\n",
      "    \"mix\": null,\n",
      "    \"str\": \"foo\",\n",
      "    \"time\": \"2017-12-23 12:34:51+0900\"\n",
      "},\n",
      "{\n",
      "    \"bool\": true,\n",
      "    \"float\": 0,\n",
      "    \"int\": 3,\n",
      "    \"mix\": \"Infinity\",\n",
      "    \"str\": \"bar\",\n",
      "    \"time\": \"2017-03-03 22:44:55+0900\"\n",
      "},\n",
      "{\n",
      "    \"bool\": \"FALSE\",\n",
      "    \"float\": -9.9,\n",
      "    \"int\": -10,\n",
      "    \"mix\": \"nan\",\n",
      "    \"str\": \"\",\n",
      "    \"time\": \"2017-01-01 00:00:00+0900\"\n",
      "}]}\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.JsonTableWriter()\n",
    "writer.table_name = table_name\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{equation}\n",
      "    A = \\left( \\begin{array}{rrr}\n",
      "        0.01 &      0.0012 & 0.000 \\\\\n",
      "        1.00 &     99.9000 & 0.010 \\\\\n",
      "        1.20 & 999999.1230 & 0.001 \\\\\n",
      "    \\end{array} \\right)\n",
      "\\end{equation}\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.LatexMatrixWriter()\n",
    "writer.table_name = \"A\"\n",
    "writer.value_matrix = [\n",
    "    [0.01, 0.00125, 0.0],\n",
    "    [1.0, 99.9,  0.01],\n",
    "    [1.2, 999999.123, 0.001],\n",
    "]\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\begin{equation}\n",
    "    A = \\left( \\begin{array}{rrr}\n",
    "        0.01 &      0.0012 & 0.000 \\\\\n",
    "        1.00 &     99.9000 & 0.010 \\\\\n",
    "        1.20 & 999999.1230 & 0.001 \\\\\n",
    "    \\end{array} \\right)\n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{equation}\n",
      "    B = \\left( \\begin{array}{llll}\n",
      "        a_{11} & a_{12} & \\ldots & a_{1n} \\\\\n",
      "        a_{21} & a_{22} & \\ldots & a_{2n} \\\\\n",
      "        \\vdots & \\vdots & \\ddots & \\vdots \\\\\n",
      "        a_{n1} & a_{n2} & \\ldots & a_{nn} \\\\\n",
      "    \\end{array} \\right)\n",
      "\\end{equation}\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.LatexMatrixWriter()\n",
    "writer.table_name = \"B\"\n",
    "writer.value_matrix = [\n",
    "    [\"a_{11}\", \"a_{12}\", \"\\\\ldots\", \"a_{1n}\"],\n",
    "    [\"a_{21}\", \"a_{22}\", \"\\\\ldots\", \"a_{2n}\"],\n",
    "    [r\"\\vdots\", \"\\\\vdots\", \"\\\\ddots\", \"\\\\vdots\"],\n",
    "    [\"a_{n1}\", \"a_{n2}\", \"\\\\ldots\", \"a_{nn}\"],\n",
    "]\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\begin{equation}\n",
    "    B = \\left( \\begin{array}{llll}\n",
    "        a_{11} & a_{12} & \\ldots & a_{1n} \\\\\n",
    "        a_{21} & a_{22} & \\ldots & a_{2n} \\\\\n",
    "        \\vdots & \\vdots & \\ddots & \\vdots \\\\\n",
    "        a_{n1} & a_{n2} & \\ldots & a_{nn} \\\\\n",
    "    \\end{array} \\right)\n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{array}{r | r | l | l | l | l} \\hline\n",
      "    \\verb|int| & \\verb|float| & \\verb|str | & \\verb|bool | & \\verb| mix  | & \\verb|          time          | \\\\ \\hline\n",
      "    \\hline\n",
      "      0 &  0.10 & hoge & True  &      0 & \\verb|2017-01-01 03:04:05+0900| \\\\ \\hline\n",
      "      2 & -2.23 & foo  & False &        & \\verb|2017-12-23 12:34:51+0900| \\\\ \\hline\n",
      "      3 &  0.00 & bar  & True  & \\infty & \\verb|2017-03-03 22:44:55+0900| \\\\ \\hline\n",
      "    -10 & -9.90 &      & False & NaN    & \\verb|2017-01-01 00:00:00+0900| \\\\ \\hline\n",
      "\\end{array}\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.LatexTableWriter()\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\begin{array}{r | r | l | l | l | l} \\hline\n",
    "    \\verb|int| & \\verb|float| & \\verb|str| & \\verb|bool| & \\verb|mix| & \\verb|time| \\\\ \\hline\n",
    "    \\hline\n",
    "    0 & 0.10 & hoge & True & 0 & \\verb|2017-01-01 03:04:05+0900| \\\\ \\hline\n",
    "    2 & -2.23 & foo & False &  & \\verb|2017-12-23 12:34:51+0900| \\\\ \\hline\n",
    "    3 & 0.00 & bar & True & \\infty & \\verb|2017-03-03 22:44:55+0900| \\\\ \\hline\n",
    "    -10 & -9.90 &  & False & NaN & \\verb|2017-01-01 00:00:00+0900| \\\\ \\hline\n",
    "\\end{array}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# example_table\n",
      "|int|float|str |bool |  mix   |          time          |\n",
      "|--:|----:|----|-----|-------:|------------------------|\n",
      "|  0| 0.10|hoge|True |       0|2017-01-01 03:04:05+0900|\n",
      "|  2|-2.23|foo |False|        |2017-12-23 12:34:51+0900|\n",
      "|  3| 0.00|bar |True |Infinity|2017-03-03 22:44:55+0900|\n",
      "|-10|-9.90|    |False|     NaN|2017-01-01 00:00:00+0900|\n"
     ]
    }
   ],
   "source": [
    "from pytablewriter import MarkdownTableWriter\n",
    "\n",
    "writer = MarkdownTableWriter()\n",
    "writer.table_name = table_name\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# write example with a margin\n",
      "| int | float | str  | bool  |   mix    |           time           |\n",
      "|----:|------:|------|-------|---------:|--------------------------|\n",
      "|   0 |  0.10 | hoge | True  |        0 | 2017-01-01 03:04:05+0900 |\n",
      "|   2 | -2.23 | foo  | False |          | 2017-12-23 12:34:51+0900 |\n",
      "|   3 |  0.00 | bar  | True  | Infinity | 2017-03-03 22:44:55+0900 |\n",
      "| -10 | -9.90 |      | False |      NaN | 2017-01-01 00:00:00+0900 |\n"
     ]
    }
   ],
   "source": [
    "from pytablewriter import MarkdownTableWriter\n",
    "\n",
    "writer = MarkdownTableWriter()\n",
    "writer.table_name = \"write example with a margin\"\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "writer.margin = 1  # add a whitespace for both sides of each cell\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{| class=\"wikitable\"\n",
      "|+example_table\n",
      "! int\n",
      "! float\n",
      "! str\n",
      "! bool\n",
      "! mix\n",
      "! time\n",
      "|-\n",
      "| style=\"text-align:right\"| 0\n",
      "| style=\"text-align:right\"| 0.10\n",
      "| hoge\n",
      "| True\n",
      "| style=\"text-align:right\"| 0\n",
      "| 2017-01-01 03:04:05+0900\n",
      "|-\n",
      "| style=\"text-align:right\"| 2\n",
      "| style=\"text-align:right\"| -2.23\n",
      "| foo\n",
      "| False\n",
      "| \n",
      "| 2017-12-23 12:34:51+0900\n",
      "|-\n",
      "| style=\"text-align:right\"| 3\n",
      "| style=\"text-align:right\"| 0.00\n",
      "| bar\n",
      "| True\n",
      "| Infinity\n",
      "| 2017-03-03 22:44:55+0900\n",
      "|-\n",
      "| style=\"text-align:right\"| -10\n",
      "| style=\"text-align:right\"| -9.90\n",
      "| \n",
      "| False\n",
      "| NaN\n",
      "| 2017-01-01 00:00:00+0900\n",
      "|}\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.MediaWikiTableWriter()\n",
    "writer.table_name = table_name\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "example_table = np.array([\n",
      "    [\"int\", \"float\", \"str\", \"bool\", \"mix\", \"time\"],\n",
      "    [0, 0.1, \"hoge\", True, 0, \"2017-01-01 03:04:05+0900\"],\n",
      "    [2, -2.23, \"foo\", False, None, \"2017-12-23 12:34:51+0900\"],\n",
      "    [3, 0, \"bar\", True, np.inf, \"2017-03-03 22:44:55+0900\"],\n",
      "    [-10, -9.9, \"\", False, np.nan, \"2017-01-01 00:00:00+0900\"],\n",
      "])\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.NumpyTableWriter()\n",
    "writer.table_name = table_name\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "example_table = pd.DataFrame([\n",
      "    [0, 0.1, \"hoge\", True, 0, \"2017-01-01 03:04:05+0900\"],\n",
      "    [2, -2.23, \"foo\", False, None, \"2017-12-23 12:34:51+0900\"],\n",
      "    [3, 0, \"bar\", True, np.inf, \"2017-03-03 22:44:55+0900\"],\n",
      "    [-10, -9.9, \"\", False, np.nan, \"2017-01-01 00:00:00+0900\"],\n",
      "], columns=[\"int\", \"float\", \"str\", \"bool\", \"mix\", \"time\"])\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.PandasDataFrameWriter()\n",
    "writer.table_name = table_name\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "example_table = pd.DataFrame([\n",
      "    [0, 0.1, \"hoge\", True, 0, \"2017-01-01 03:04:05+0900\"],\n",
      "    [2, -2.23, \"foo\", False, None, \"2017-12-23 12:34:51+0900\"],\n",
      "    [3, 0, \"bar\", True, np.inf, \"2017-03-03 22:44:55+0900\"],\n",
      "    [-10, -9.9, \"\", False, np.nan, \"2017-01-01 00:00:00+0900\"],\n",
      "], columns=[\"int\", \"float\", \"str\", \"bool\", \"mix\", \"time\"])\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.PandasDataFrameWriter()\n",
    "writer.table_name = table_name\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "writer.is_datetime_instance_formatting = False\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "example_table = [\n",
      "    [\"int\", \"float\", \"str\", \"bool\", \"mix\", \"time\"],\n",
      "    [0, 0.1, \"hoge\", True, 0, \"2017-01-01 03:04:05+0900\"],\n",
      "    [2, -2.23, \"foo\", False, None, \"2017-12-23 12:34:51+0900\"],\n",
      "    [3, 0, \"bar\", True, float(\"inf\"), \"2017-03-03 22:44:55+0900\"],\n",
      "    [-10, -9.9, \"\", False, float(\"nan\"), \"2017-01-01 00:00:00+0900\"],\n",
      "]\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.PythonCodeTableWriter()\n",
    "writer.table_name = table_name\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "example_table = [\n",
      "    [\"int\", \"float\", \"str\", \"bool\", \"mix\", \"time\"],\n",
      "    [0, 0.1, \"hoge\", True, 0, \"2017-01-01 03:04:05+0900\"],\n",
      "    [2, -2.23, \"foo\", False, None, \"2017-12-23 12:34:51+0900\"],\n",
      "    [3, 0, \"bar\", True, float(\"inf\"), \"2017-03-03 22:44:55+0900\"],\n",
      "    [-10, -9.9, \"\", False, float(\"nan\"), \"2017-01-01 00:00:00+0900\"],\n",
      "]\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.PythonCodeTableWriter()\n",
    "writer.table_name = table_name\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "writer.is_datetime_instance_formatting = False\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ".. table:: example_table\n",
      "\n",
      "    +---+-----+----+-----+--------+------------------------+\n",
      "    |int|float|str |bool |  mix   |          time          |\n",
      "    +===+=====+====+=====+========+========================+\n",
      "    |  0| 0.10|hoge|True |       0|2017-01-01 03:04:05+0900|\n",
      "    +---+-----+----+-----+--------+------------------------+\n",
      "    |  2|-2.23|foo |False|        |2017-12-23 12:34:51+0900|\n",
      "    +---+-----+----+-----+--------+------------------------+\n",
      "    |  3| 0.00|bar |True |Infinity|2017-03-03 22:44:55+0900|\n",
      "    +---+-----+----+-----+--------+------------------------+\n",
      "    |-10|-9.90|    |False|     NaN|2017-01-01 00:00:00+0900|\n",
      "    +---+-----+----+-----+--------+------------------------+\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.RstGridTableWriter()\n",
    "writer.table_name = table_name\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ".. table:: example_table\n",
      "\n",
      "    ===  =====  ====  =====  ========  ========================\n",
      "    int  float  str   bool     mix               time          \n",
      "    ===  =====  ====  =====  ========  ========================\n",
      "      0   0.10  hoge  True          0  2017-01-01 03:04:05+0900\n",
      "      2  -2.23  foo   False            2017-12-23 12:34:51+0900\n",
      "      3   0.00  bar   True   Infinity  2017-03-03 22:44:55+0900\n",
      "    -10  -9.90        False       NaN  2017-01-01 00:00:00+0900\n",
      "    ===  =====  ====  =====  ========  ========================\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.RstSimpleTableWriter()\n",
    "writer.table_name = table_name\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ".. csv-table:: example_table\n",
      "    :header: \"int\", \"float\", \"str\", \"bool\", \"mix\", \"time\"\n",
      "    :widths: 5, 7, 6, 6, 8, 26\n",
      "\n",
      "    0, 0.10, \"hoge\", True, 0, \"2017-01-01 03:04:05+0900\"\n",
      "    2, -2.23, \"foo\", False, , \"2017-12-23 12:34:51+0900\"\n",
      "    3, 0.00, \"bar\", True, Infinity, \"2017-03-03 22:44:55+0900\"\n",
      "    -10, -9.90, , False, NaN, \"2017-01-01 00:00:00+0900\"\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.RstCsvTableWriter()\n",
    "writer.table_name = table_name\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int:0\tfloat:0.1\tstr:\"hoge\"\tbool:True\tmix:0\ttime:\"2017-01-01 03:04:05+0900\"\n",
      "int:2\tfloat:-2.23\tstr:\"foo\"\tbool:False\ttime:\"2017-12-23 12:34:51+0900\"\n",
      "int:3\tfloat:0\tstr:\"bar\"\tbool:True\tmix:Infinity\ttime:\"2017-03-03 22:44:55+0900\"\n",
      "int:-10\tfloat:-9.9\tbool:False\tmix:NaN\ttime:\"2017-01-01 00:00:00+0900\"\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.LtsvTableWriter()\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[example_table]]\n",
      "int = 0\n",
      "float = \"Decimal('0.1')\"\n",
      "str = \"hoge\"\n",
      "bool = true\n",
      "mix = 0\n",
      "time = \"2017-01-01 03:04:05+0900\"\n",
      "\n",
      "[[example_table]]\n",
      "int = 2\n",
      "float = \"Decimal('-2.23')\"\n",
      "str = \"foo\"\n",
      "bool = false\n",
      "time = \"2017-12-23 12:34:51+0900\"\n",
      "\n",
      "[[example_table]]\n",
      "int = 3\n",
      "float = 0\n",
      "str = \"bar\"\n",
      "bool = \"true\"\n",
      "mix = \"Decimal('Infinity')\"\n",
      "time = \"2017-03-03 22:44:55+0900\"\n",
      "\n",
      "[[example_table]]\n",
      "int = -10\n",
      "float = \"Decimal('-9.9')\"\n",
      "str = \"\"\n",
      "bool = \"FALSE\"\n",
      "mix = \"Decimal('NaN')\"\n",
      "time = \"2017-01-01 00:00:00+0900\"\n",
      "\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.TomlTableWriter()\n",
    "writer.table_name = table_name\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "// without type hints:  column data types detected automatically by default\n",
      "const without_type_hint = [\n",
      "    [\"header_a\", \"header_b\", \"header_c\"],\n",
      "    [-1.1, \"2017-01-02 03:04:05\", new Date(\"2017-01-02T03:04:05\")],\n",
      "    [0.12, \"2017-02-03 04:05:06\", new Date(\"2017-02-03T04:05:06\")]\n",
      "];\n",
      "// with type hints: Integer, DateTime, String\n",
      "const with_type_hint = [\n",
      "    [\"header_a\", \"header_b\", \"header_c\"],\n",
      "    [-1, new Date(\"2017-01-02T03:04:05\"), \"2017-01-02 03:04:05\"],\n",
      "    [0, new Date(\"2017-02-03T04:05:06\"), \"2017-02-03 04:05:06\"]\n",
      "];\n"
     ]
    }
   ],
   "source": [
    "from datetime import datetime\n",
    "import pytablewriter as ptw\n",
    "\n",
    "writer = ptw.JavaScriptTableWriter()\n",
    "writer.headers = [\"header_a\", \"header_b\", \"header_c\"]\n",
    "writer.value_matrix = [\n",
    "    [-1.1, \"2017-01-02 03:04:05\", datetime(2017, 1, 2, 3, 4, 5)],\n",
    "    [0.12, \"2017-02-03 04:05:06\", datetime(2017, 2, 3, 4, 5, 6)],\n",
    "]\n",
    "\n",
    "print(\"// without type hints:  column data types detected automatically by default\")\n",
    "writer.table_name = \"without type hint\"\n",
    "writer.write_table()\n",
    "\n",
    "print(\"// with type hints: Integer, DateTime, String\")\n",
    "writer.table_name = \"with type hint\"\n",
    "writer.type_hints = [ptw.Integer, ptw.DateTime, ptw.String]\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "python_variable_without_type_hints = [\n",
      "    [\"float\", \"infnan\", \"string\", \"datetime\"],\n",
      "    [-1.1, float(\"inf\"), \"2017-01-02 03:04:05\", dateutil.parser.parse(\"2017-01-02T03:04:05\")],\n",
      "    [0.12, float(\"nan\"), \"2017-02-03 04:05:06\", dateutil.parser.parse(\"2017-02-03T04:05:06\")],\n",
      "]\n",
      "python_variable_with_type_hints = [\n",
      "    [\"hint_int\", \"hint_str\", \"hint_datetime\", \"hint_str\"],\n",
      "    [-1, \"inf\", dateutil.parser.parse(\"2017-01-02T03:04:05\"), \"2017-01-02 03:04:05\"],\n",
      "    [0, \"nan\", dateutil.parser.parse(\"2017-02-03T04:05:06\"), \"2017-02-03 04:05:06\"],\n",
      "]\n"
     ]
    }
   ],
   "source": [
    "from datetime import datetime\n",
    "import pytablewriter as ptw\n",
    "\n",
    "writer = ptw.PythonCodeTableWriter()\n",
    "writer.value_matrix = [\n",
    "    [-1.1, float(\"inf\"), \"2017-01-02 03:04:05\", datetime(2017, 1, 2, 3, 4, 5)],\n",
    "    [0.12, float(\"nan\"), \"2017-02-03 04:05:06\", datetime(2017, 2, 3, 4, 5, 6)],\n",
    "]\n",
    "\n",
    "# column data types detected automatically by default\n",
    "writer.table_name = \"python variable without type hints\"\n",
    "writer.headers = [\"float\", \"infnan\", \"string\", \"datetime\"]\n",
    "writer.write_table()\n",
    "\n",
    "# set type hints\n",
    "writer.table_name = \"python variable with type hints\"\n",
    "writer.headers = [\"hint_int\", \"hint_str\", \"hint_datetime\", \"hint_str\"]\n",
    "writer.type_hints = [ptw.Integer, ptw.String, ptw.DateTime, ptw.String]\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "| i | f  | c  | if |ifc|bool |  inf   |nan|mix_num |          time           |\n",
      "|--:|---:|----|---:|---|-----|--------|---|-------:|-------------------------|\n",
      "|  1|1.10|aa  | 1.0|  1|True |Infinity|NaN|       1|2017-01-01 00:00:00+09:00|\n",
      "|  2|2.20|bbb | 2.2|2.2|False|Infinity|NaN|Infinity|2017-01-02 03:04:05+09:00|\n",
      "|  3|3.33|cccc|-3.0|ccc|True |Infinity|NaN|     NaN|2017-01-01 00:00:00+09:00|\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.MarkdownTableWriter()\n",
    "writer.from_csv(dedent(\"\"\"\\\n",
    "    \"i\",\"f\",\"c\",\"if\",\"ifc\",\"bool\",\"inf\",\"nan\",\"mix_num\",\"time\"\n",
    "    1,1.10,\"aa\",1.0,\"1\",True,Infinity,NaN,1,\"2017-01-01 00:00:00+09:00\"\n",
    "    2,2.20,\"bbb\",2.2,\"2.2\",False,Infinity,NaN,Infinity,\"2017-01-02 03:04:05+09:00\"\n",
    "    3,3.33,\"cccc\",-3.0,\"ccc\",True,Infinity,NaN,NaN,\"2017-01-01 00:00:00+09:00\"\n",
    "    \"\"\"))\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# ps\n",
      "|USER|PID|%CPU|%MEM| VSZ |RSS |TTY|STAT|START|TIME|   COMMAND    |\n",
      "|----|--:|---:|---:|----:|---:|---|----|-----|----|--------------|\n",
      "|root|  1|   0| 0.4|77664|8784|?  |Ss  |May11|0:02|/sbin/init    |\n",
      "|root|  2|   0| 0.0|    0|   0|?  |S   |May11|0:00|[kthreadd]    |\n",
      "|root|  4|   0| 0.0|    0|   0|?  |I<  |May11|0:00|[kworker/0:0H]|\n",
      "|root|  6|   0| 0.0|    0|   0|?  |I<  |May11|0:00|[mm_percpu_wq]|\n",
      "|root|  7|   0| 0.0|    0|   0|?  |S   |May11|0:01|[ksoftirqd/0] |\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.MarkdownTableWriter()\n",
    "writer.table_name = \"ps\"\n",
    "writer.from_csv(\n",
    "    dedent(\"\"\"\\\n",
    "        USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND\n",
    "        root         1  0.0  0.4  77664  8784 ?        Ss   May11   0:02 /sbin/init\n",
    "        root         2  0.0  0.0      0     0 ?        S    May11   0:00 [kthreadd]\n",
    "        root         4  0.0  0.0      0     0 ?        I<   May11   0:00 [kworker/0:0H]\n",
    "        root         6  0.0  0.0      0     0 ?        I<   May11   0:00 [mm_percpu_wq]\n",
    "        root         7  0.0  0.0      0     0 ?        S    May11   0:01 [ksoftirqd/0]\n",
    "    \"\"\"),\n",
    "    delimiter=\" \")\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# specify alignment for each column manually\n",
      "|left|   right   |   center   |auto (int)|auto (str)|None (same as AUTO)|\n",
      "|----|----------:|:----------:|---------:|----------|-------------------|\n",
      "|0   |          r|center align|         0|a         |n                  |\n",
      "|11  |right align|     c      |        11|auto      |none               |\n"
     ]
    }
   ],
   "source": [
    "from pytablewriter import MarkdownTableWriter\n",
    "from pytablewriter.style import Align, Style\n",
    "\n",
    "writer = MarkdownTableWriter()\n",
    "writer.table_name = \"specify alignment for each column manually\"\n",
    "writer.headers = [\"left\", \"right\", \"center\", \"auto (int)\", \"auto (str)\", \"None (same as AUTO)\"]\n",
    "writer.value_matrix = [\n",
    "    [0, \"r\", \"center align\", 0, \"a\", \"n\"],\n",
    "    [11, \"right align\", \"c\", 11, \"auto\", \"none\"],\n",
    "]\n",
    "\n",
    "# set alignments for each column\n",
    "writer.styles = [\n",
    "    Style(align=Align.LEFT),\n",
    "    Style(align=Align.RIGHT),\n",
    "    Style(align=Align.CENTER),\n",
    "    Style(align=Align.AUTO),\n",
    "    Style(align=Align.AUTO),\n",
    "    None,\n",
    "]\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# set style by styles\n",
      "|auto align|left align|center align|  bold  |italic|bold italic ts|\n",
      "|---------:|----------|:----------:|-------:|-----:|-------------:|\n",
      "|        11|11        |     11     |  **11**|  _11_|      _**11**_|\n",
      "|      1234|1234      |    1234    |**1234**|_1234_|   _**1,234**_|\n"
     ]
    }
   ],
   "source": [
    "from pytablewriter import MarkdownTableWriter\n",
    "from pytablewriter.style import Style\n",
    "\n",
    "writer = MarkdownTableWriter()\n",
    "writer.table_name = \"set style by styles\"\n",
    "writer.headers = [\n",
    "    \"auto align\",\n",
    "    \"left align\",\n",
    "    \"center align\",\n",
    "    \"bold\",\n",
    "    \"italic\",\n",
    "    \"bold italic ts\",\n",
    "]\n",
    "writer.value_matrix = [\n",
    "    [11, 11, 11, 11, 11, 11],\n",
    "    [1234, 1234, 1234, 1234, 1234, 1234],\n",
    "]\n",
    "\n",
    "# specify styles for each column\n",
    "writer.styles = [\n",
    "    Style(),\n",
    "    Style(align=\"left\"),\n",
    "    Style(align=\"center\"),\n",
    "    Style(font_weight=\"bold\"),\n",
    "    Style(font_style=\"italic\"),\n",
    "    Style(font_weight=\"bold\", font_style=\"italic\", thousand_separator=\",\"),\n",
    "]\n",
    "\n",
    "writer.write_table()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# set style by index\n",
      "| A  |   B    |  C  |\n",
      "|---:|:------:|----:|\n",
      "|  11| **11** |   11|\n",
      "|1234|**1234**|1 234|\n",
      "\n",
      "# set style by header\n",
      "| A  |  B   |  C  |\n",
      "|---:|-----:|----:|\n",
      "|  11|  _11_|   11|\n",
      "|1234|_1234_|1 234|\n"
     ]
    }
   ],
   "source": [
    "from pytablewriter import MarkdownTableWriter\n",
    "from pytablewriter.style import Style\n",
    "\n",
    "writer = MarkdownTableWriter()\n",
    "writer.headers = [\"A\", \"B\", \"C\",]\n",
    "writer.value_matrix = [[11, 11, 11], [1234, 1234, 1234]]\n",
    "\n",
    "writer.table_name = \"set style by index\"\n",
    "writer.set_style(1, Style(align=\"center\", font_weight=\"bold\"))\n",
    "writer.set_style(2, Style(thousand_separator=\" \"))\n",
    "writer.write_table()\n",
    "writer.write_null_line()\n",
    "\n",
    "writer.table_name = \"set style by header\"\n",
    "writer.set_style(\"B\", Style(font_style=\"italic\"))\n",
    "writer.write_table()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "|int|float|str |bool |  mix   |          time          |\n",
      "|--:|----:|----|-----|-------:|------------------------|\n",
      "|  0| 0.10|hoge|True |       0|2017-01-01 03:04:05+0900|\n",
      "|  2|-2.23|foo |False|        |2017-12-23 45:01:23+0900|\n",
      "|  3| 0.00|bar |True |Infinity|2017-03-03 33:44:55+0900|\n",
      "|-10|-9.90|    |False|     NaN|2017-01-01 00:00:00+0900|\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import pytablewriter\n",
    "\n",
    "writer = pytablewriter.MarkdownTableWriter()\n",
    "writer.headers = [\"int\", \"float\", \"str\", \"bool\", \"mix\", \"time\"]\n",
    "writer.value_matrix = [\n",
    "    [0,   0.1,      \"hoge\", True,   0,      \"2017-01-01 03:04:05+0900\"],\n",
    "    [2,   \"-2.23\",  \"foo\",  False,  None,   \"2017-12-23 45:01:23+0900\"],\n",
    "    [3,   0,        \"bar\",  \"true\",  \"inf\", \"2017-03-03 33:44:55+0900\"],\n",
    "    [-10, -9.9,     \"\",     \"FALSE\", \"nan\", \"2017-01-01 00:00:00+0900\"],\n",
    "]\n",
    "\n",
    "print(writer.dumps())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "|wo_format| comma_i |  space_f  |\n",
      "|--------:|--------:|----------:|\n",
      "|     1000|1,234,567|1 234 567.8|\n",
      "|     1000|1,234,567|1 234 567.8|\n",
      "|     1000|1,234,567|1 234 567.8|\n"
     ]
    }
   ],
   "source": [
    "from pytablewriter import MarkdownTableWriter\n",
    "from pytablewriter.style import ThousandSeparator\n",
    "\n",
    "writer = MarkdownTableWriter()\n",
    "writer.headers = [\"wo_format\", \"comma_i\", \"space_f\"]\n",
    "writer.value_matrix = [\n",
    "    [1000, 1234567, 1234567.8],\n",
    "    [1000, 1234567, 1234567.8],\n",
    "    [1000, 1234567, 1234567.8],\n",
    "]\n",
    "writer.styles = [\n",
    "    Style(thousand_separator=ThousandSeparator.NONE),\n",
    "    Style(thousand_separator=ThousandSeparator.COMMA),\n",
    "    Style(thousand_separator=ThousandSeparator.SPACE),\n",
    "]\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{array}{r | r | r | r | r | r} \\hline\n",
      "    \\verb|none| & \\verb|empty_style| & \\verb|  tiny   | & \\verb|  small   | & \\verb|    medium     | & \\verb|  large   | \\\\ \\hline\n",
      "    \\hline\n",
      "     111 &         111 & \\tiny 111 & \\small 111 & \\normalsize 111 & \\large 111 \\\\ \\hline\n",
      "    1234 &        1234 & \\tiny 1234 & \\small 1234 & \\normalsize 1234 & \\large 1234 \\\\ \\hline\n",
      "\\end{array}\n"
     ]
    }
   ],
   "source": [
    "from pytablewriter import LatexTableWriter\n",
    "from pytablewriter.style import Style, FontSize\n",
    "\n",
    "writer = LatexTableWriter()\n",
    "writer.table_name = \"style test: font size\"\n",
    "writer.headers = [\"none\", \"empty_style\", \"tiny\", \"small\", \"medium\", \"large\"]\n",
    "writer.value_matrix = [[111, 111, 111, 111, 111, 111], [1234, 1234, 1234, 1234, 1234, 1234]]\n",
    "writer.styles = [\n",
    "    None,\n",
    "    Style(),\n",
    "    Style(font_size=FontSize.TINY),\n",
    "    Style(font_size=FontSize.SMALL),\n",
    "    Style(font_size=FontSize.MEDIUM),\n",
    "    Style(font_size=FontSize.LARGE),\n",
    "]\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\begin{array}{r | r | r | r | r | r} \\hline\n",
    "    \\verb|none| & \\verb|empty_style| & \\verb|tiny| & \\verb|small| & \\verb|medium| & \\verb|large| \\\\ \\hline\n",
    "    \\hline\n",
    "     111 &         111 & \\tiny 111 & \\small 111 & \\normalsize 111 & \\large 111 \\\\ \\hline\n",
    "    1234 &        1234 & \\tiny 1234 & \\small 1234 & \\normalsize 1234 & \\large 1234 \\\\ \\hline\n",
    "\\end{array}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "┌───┬─────┬────┬─────┬────────┬────────────────────────┐\n",
      "│int│float│str │bool │  mix   │          time          │\n",
      "├───┼─────┼────┼─────┼────────┼────────────────────────┤\n",
      "│  0│ 0.10│hoge│True │       0│2017-01-01 03:04:05+0900│\n",
      "├───┼─────┼────┼─────┼────────┼────────────────────────┤\n",
      "│  2│-2.23│foo │False│        │2017-12-23 12:34:51+0900│\n",
      "├───┼─────┼────┼─────┼────────┼────────────────────────┤\n",
      "│  3│ 0.00│bar │True │Infinity│2017-03-03 22:44:55+0900│\n",
      "├───┼─────┼────┼─────┼────────┼────────────────────────┤\n",
      "│-10│-9.90│    │False│     NaN│2017-01-01 00:00:00+0900│\n",
      "└───┴─────┴────┴─────┴────────┴────────────────────────┘\n"
     ]
    }
   ],
   "source": [
    "from pytablewriter import UnicodeTableWriter\n",
    "\n",
    "writer = UnicodeTableWriter()\n",
    "writer.table_name = table_name\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}