Better Plots (in Three Lines!)

PJ Trainor — Thu, 14 Mar 2019 00:39:50 +0000

If you've done any plotting in python, you've almost certainly used matplotlib. While it offers a simple approach to making plots, they are sometimes... well they can be a bit ugly, by default.

I'll go over two quick tips to give your plots a little more personality:

Replacing the default styles
Making prettier titles

Note There are plenty of other plotting options with their own styles (seaborn, plotly, bokeh, etc.), but matplotlib is the most widely used, so that's what I'll focus on

You can skip to the repl.it below to play around with these styles!

1. Replacing the Default Styles

Next time you type in that import statement, consider adding just one more line:

import matplotlib.pyplot as plt
plt.style.use('ggplot')

Now when you make a plot, it will use the styles found in ggplot, a popular plotting library in R.

There are plenty of other options, such as fivethirtyeight and seaborn-colorblind!

Note: If you don't want to apply one style to every plot, you can do:

with plt.style.context('ggplot'):
  plt.plot(x, y)

2. Making Prettier Titles

Matplotlib puts titles in the center, right at the top. Did you know you can move that title around? Did you know that you can have multiple titles? We can use both to make nicer titles:

plt.title("The Main Title", loc='left', fontsize=18)
plt.title("a subtitle", loc='right', fontsize=13, color='grey')

If you have something plotted already, then this moves your main title to the left, and adds a smaller and greyed-out subtitle on the right. It's a great way to give your plots more context, and make them look better!

I'll even leave you with a function that makes this easier to implement:

def fancy_titles(t1, t2, ax=None):
  if ax:
    ax.set_title(t1, loc='left', fontsize=18)
    ax.set_title(t2, loc='right', fontsize=13, color='grey')
  else:
    plt.title(t1, loc='left', fontsize=18)
    plt.title(t2, loc='right', fontsize=13, color='grey')

plt.plot(x, y)
fancy_titles("A Cool Title", "a cooler subtitle")

Lastly, here's a repl.it, so you can play around with different styles:

Extending the Pandas DataFrame

PJ Trainor — Tue, 05 Mar 2019 12:49:46 +0000

Pandas offers a lot of convenient utilities for handling tabular data. The pandas DataFrame is versatile, but some operations can only be done in a single command. I'll offer some advice on how you can extend DataFrame to better suit your workflow. Also, when I say DataFrame, I'm referring to the class in the pandas library.

Suppose you had a collection of students, and you'd like to select all the students that have an "A" in Ms. Frizzle's class.

Here's one way to do this in pandas:

(students.query("grade == 'A'")
         .query("teacher == 'Frizzle'"))

But what if we had a custom method?

students.select_by_grade_and_teacher("A", "Frizzle")

Note: by enclosing the operations in parentheses, you can chain several pandas operations on multiple lines, since they all return DataFrames. This is called method-chaining.

What Extending Means

All I want to do is add custom methods to the standard pandas DataFrame. Custom methods are useful because they:

♻️ simplify repeatable, multi-line logic
⛓ chain with built-in methods in DataFrame

So extending just means adding additional methods to DataFrame; these methods can return another DataFrame, or anything else.

Note: We could write a function, but that doesn't fit into the method-chaining workflow, producing more lines of code

How to Extend `DataFrame`

Since we'd like to add new methods to DataFrame without losing the old ones, we should consider subclassing DataFrame. That is, defining a new class that inherits from the DataFrame class.

This comes with a few caveats. We need to make sure:

🏠 it keeps all of the methods in DataFrame
🤝 when a custom method is called, it returns our class, and not DataFrame (i.e. not the subclass)

The second point ensures we can continue to use custom methods for method-chaining.

The following class does just that:

import pandas as pd

class ExtendedDataFrame(pd.DataFrame):
    def __init__(self, *args, **kwargs):
        # use the __init__ method from DataFrame to ensure
        # that we're inheriting the correct behavior
        super(ExtendedDataFrame, self).__init__(*args, **kwargs)

    # this method is makes it so our methods return an instance
    # of ExtendedDataFrame, instead of a regular DataFrame
    @property
    def _constructor(self):
        return ExtendedDataFrame

    # now define a custom method!
    # note that `self` is a DataFrame
    def select_by_grade_and_teacher(self, grade, teacher):
        return (self
                .query("grade == @grade")
                .query("teacher == @teacher"))

See it in action in this repl.it

Note: The pandas documentation has a page on extensions, but it's quite advanced, and includes many other topics

When to Extend

This is a useful pattern for data exploration, especially in Jupyter Notebooks, or any environment that has code-completion. You can use it to:

⏲ shorten highly-repeated tasks
👩🏽‍🎓 as a utility packaged with a specific dataset, to share with your team... especially if they're not pandas experts like you
📊 construct methods that make plots outside of the standard functionality

Final Thoughts

I do not recommend using this pattern in production, since it's not officially endorsed by pandas. Furthermore, you run the risk of conflicting with the current/future DataFrame API.

I'll leave you with an extended DataFrame that I often use. It has some more advanced features, and all of the methods begin with my initials, pj_ (so it's easier to find in code-completion).

Link to my DataFrame

Feel free to ask any questions, and let me know if you find something interesting!

DEV Community: PJ Trainor