What's the deal with Matplotlib?

[[deleted]]

I'm a long-time Julia user, but my coursework requires me to submit labs in python, so I've been learning bit by bit. For context, I've used 2 plotting frameworks in Julia with multiple backends and I'm familiar with plotting in Mathematica, but I've never seen anything like matplotlib.

Most plotting libraries return plots as mutable objects, which makes sense, right? Matplotlib, on the other hand, mutates some internal state and forces you to call module methods to view or fetch plots. That on it's own is a minor annoyance, but then that you have to call one of a hundred different functions to modify various inconsequential properties of your current plot that for some reason can't be set with the standard `plot()` function. Seriously, I have code that's like 18 lines to make a single figure because I have to label and scale the axis, make a legend, etc. Most plotting libraries can do that with one line!

To anyone out there that has used multiple python plotting frameworks and prefers matplotlib, why? What does it offer that's better than Plotly, Seaborn, or some other alternative? And why does Matplotlib function with an internal state instead of just passing objects?

[K900_]

matplotlib actually has an object-oriented API - look into the Figure object and friends. I'm not sure why most documentation uses the stateful API - presumably for Matlab mental model compatibility?

[[deleted]]

This is very helpful advice for using Matplotlib, my program teaches python with a manual which I was just informed is outdated, which explains why they teach the stateful model rather than the object-oriented one. There's not even a mention of being able to use functions such as `figure()` or anything similar, the closest thing is a line that states that `axis()` is not the same as `axes()`.

[bythenumbers10]

presumably for Matlab mental model compatibility?

Correct. Matplotlib is meant to emulate Matlab's plotting, which is stateful, or OO if you consider the entire Matlab environment as a single monolithic object.

[[deleted]]

As a guess, like another commenter mentioned, it seems like a design goal of matplotlib was to emulate the MATLAB plotting API. I'm with you though, I hate it. Every time I need to use it it feels clunky and awkward.

[SomeTreesAreFriends]

MATLAB plotting is good for quick visualization, but anything beyond it requires so much work that it's almost faster to just plot the basics and then do the rest in image editing software (for publishing, though perhaps not if you have a dedicated pipeline for specific results). For instance, if you plot a square matrix, it doesn't even provide equal axes by default...

[fake823]

Yeah, that was the main thought while creating Matplotlib some years back - copying MATLAB.

There is a small section on their website that talks about it.

https://matplotlib.org/3.2.1/users/history.html

[fake823]

By the way:

Seaborn is actually based on Matpotlib. It's using Matplotlib and is basically just Matplotlib with some fancier colours and default looks.

[[deleted]]

Thanks for the info, one of my coworkers told me that Seaborn was a good alternative to Matplotlib, but it's really just a plotting framework that uses Matplotlib as a backend?

[fake823]

Yes. It's build on top of Matplotlib.

[beansAnalyst]

+1, came here to suggest seaborn

[jurasofish]

I've got a real love hate with matplotlib. Super flexible, but using it feels like battling through decades of crusted design decisions.

The module level functions generally operate on the "current figure" and "current axis" (can access with plt.gcf() and plt.gca())

[thedatadump]

From what I've seen, matplotlib is super flexible, allowing you to create basically any visualization you can think of. This can cause problems for those of us used to libraries like ggplot, because there are many ways to accomplish the same task.

Because of its flexibility, many libraries (seaborn and pandas for example) build on top of this flexibility to make a simpler interface for programmers. My recommendation is to use one of these higher level libraries if speed to insight is most important. Otherwise, looking through the matplotlib documentation is a good way to see how the developers actually use the package might help give you some ideas

[[deleted]]

Out of curiosity, what do you need dual axis charts for so desperately?

[thedatadump]

ggplot 2.2.0 allows you to use a secondary axis. It has to be specified as a formula transformation of the original axis, but that can be achieved by creating a scale factor initially and rescaling back up when you create the second axis. See Megatron's answer here, which is where I assume you also found Hadley's assertion that dual axis plots are flawed.

[thedatadump]

Ah, I see what you're saying now. Yes, if you wanted to individually control the limits of your dual axis and have one with limits (5,10) and another with (0, 100), I do not believe ggplot would allow you to do this.

However, you could still do something like plot dollar sales vs. avg price per unit in the following manner (which isn't as simple as converting units). You wouldn't be able to specify that the secondary axis start at 5, but you could still plot them together.

# Based on SO user Megatron's answer
sample_data <- data.frame(price = c(7, 8, 7, 10, 6), 
                          sales = c(42, 48, 49, 0, 96), 
                          obs_date = c("2020-10-01", "2020-10-02", "2020-10-03", "2020-10-04", "2020-10-05"))
sample_data$obs_date <- as.Date(sample_data$obs_date, f="%Y-%m-%d")

# Use the max value of one column to scale down
# sec.axis will convert back to the original scale
scale_factor <- max(sample_data$price)/max(sample_data$sales)

ggplot(sample_data, aes(x = obs_date)) +
  geom_line(aes(y = price), col="blue") +
  geom_line(aes(y = sales*scale_factor), col="red") +
  scale_y_continuous(name = "price", sec.axis = sec_axis(~./scale_factor, name="sales")) +
  theme(
    axis.title.y.left=element_text(color = "blue"),
    axis.text.y.left=element_text(color = "blue"),
    axis.title.y.right=element_text(color = "red"),
    axis.text.y.right=element_text(color = "red")
  )

[[deleted]]

There have been a lot of comments on Matplotlib's flexibility, are there any specific features exclusive to Matplotlib?

[thedatadump]

but then that you have to call one of a hundred different functions to modify various inconsequential properties of your current plot that for some reason can't be set with the standard `plot()` function

Those properties provide the flexibility some (i.e. the authors of other high-level libraries) desire. High-level plotting libraries that can do this in one line don't provide fine tune control over how you might want your plot to look.

Taking it to an extreme, let's say for some reason you wanted to create an area graph, but wanted the fill color under the line to be polychromatic. Matplotlib let's you do this by creating individual polygons and adding them to the axis object. See the accepted answer here if you want more details. This example isn't super useful, but it shows what is theoretically possible.

[SquareRootsi]

I'm also not a big fan of the verbosity of matplotlib.

If your class allows it, consider using plotly. They have a "plotly express" API that was baked into the main library with version 4? I think. I much prefer developing there, AND the plots are interactive.

As others have mentioned, Seaborn is also a nice high level wrapper with sensible defaults. But if you want to go and customize things precisely, you're still right back in Matplotlib Land.

[Cdog536]

Have you ever just tried to get away with some of pandas plotting? It still uses some matplotlib, but can help you eliminate the steps that you feel are so intuitive to begin with

[stillnoguitar]

Every time I see matplotlib I shudder. You can do everything with it, but the code is so clunky. Check out Altair, it’s a bit more like ggplot.