This post is available as an IPython notebook on Github Gist, or on nbviewer.

I've been working on making presentations in IPython lately. I often end up using tables in my presentations and publications, and wanted a way to format them nicely from IPython notebooks. So I added the PrettyTable class, along with some basic themes, to my fork of ipywidgets. This allows for easily formatting the way tables are displayed. This is similar in spirit to the ipy_table repository, but with more modular themes and the ability to add any property to tables that you can do with CSS.

Getting started

Here's an example of how it works to get started. To create a PrettyTable, import ipywidgets and pass a pandas data frame:

We can make it a little bit prettier by giving it a style theme and centering the table:

There are many options for formatting and styling, described below.

Setting cell styles

You can set cell styles by passing PrettyTable.set_cell_style a CellStyle object, or by specifying CSS properties. You can tell set_cell_style a specific set of rows and columns to apply the style to with the arguments rows= and cols=. Or leave those arguments blank to apply to all rows/columns:

You can do the same thing for row/header styles using set_row_header_style and set_col_header_style (and set_corner_style for the awkward corner cell in the case of both row and column headings). Use the indices= argument to only apply to certain headings.

Sometimes you may just want to update the style of a cell, rather than starting over. There are also functions to do this. They behave the same way as the "set style" functions described above, except they just add to the existing style:

Finally, there are a set of "reset style" functions to reset the styles of cells, headings, and corner cells.

Setting cell formats

You can also pass the functions shown above an argument format_function, which will tell the PrettyTable how to display the data. By default, it will call the str of each method. For instance, maybe you have a column of floats you want rounded to 3 decimal places, and another column you'd like to have in scientific notation:

Styles

This section shows the insides of how the styling is set up. All of the styling is based on CSS. The major class is CellStyle. Every time you call a function to modify the style of a part of the table, it is modifying the CellStyle of specific cells.

class CellStyle(object): 
  """ Styles for cells PrettyTable """
  def __init__(self):
      self.style_elements = {} # dictionary of CSS property -> value
      self.format_function = None

  def set(self, key, value):
      self.style_elements[key] = value

  def css(self):
      style = ""
      for key in self.style_elements:
        style += "%s: %s;"%(key, self.style_elements[key])
      return style

  def column_format(self, x):
      if self.format_function is None: return str(x)
      else: return self.format_function(x)

  def copy(self):
      c = CellStyle()
      c.style_elements = self.style_elements.copy()
      c.format_function = self.format_function
      return c

This basically stores a dictionary of CSS properties and values, and a function for how to format the data in cells. By using set(key, value), you can pass any CSS property.The functioncss() converts the style elements to CSS that can be used to style tables.

The wrapper class TableStyle keeps track of separate styles for cells and headings. It also has some preset themes (which I will add to as I need other themes).

class TableStyle(object):
    """
    Keep track of styles for cells/headers in PrettyTable
    """
    def __init__(self, theme=None):
        self.row_head_style = CellStyle()
        self.col_head_style = CellStyle()
        self.cell_style = CellStyle()
        self.corner_style = CellStyle()

        # add themes as needed
        if theme == "basic":
            ...

        if theme == "theme1":
            ...

Of course all the properties can be customized, as shown above.

Conclusion

I plan to add themes to this as I go along, and welcome new additions. The main reason I made this class of tables was so I could use them to animate tables in my presentations, which I describe in my next post.