You know the saying about Python visualization libraries — you could spend a lifetime and still only know half.
Here's what Daniel wrote to us. "Python is famous for having a rich array of data visualization libraries and packages like matplotlib. I suspect that they are in that category of programs that you could spend your life learning and still not know half the functions. The half you did learn will probably be more than you'll ever need already. Yet many people looking for data visualization turn to subscription services doing things that could be achieved readily in Python. Let's talk about the data visualization library ecosystem in Python: packages like matplotlib, as well as additional tools that could be used for geo-visualization."
So today we're going to map out this ecosystem — literally, in the geo case — and ask whether the subscription reflex is rational or just inertia.
And I want to start with the number that puts this whole thing in perspective. The pyviz dot org tools page catalogs over thirty Python visualization libraries. Thirty. Organized by capability. And that's just the ones they bothered to list.
Thirty libraries. And matplotlib's own third-party ecosystem page lists over a hundred extensions built on top of it. A hundred.
Right. So the core tension here is genuinely strange. These are free, open-source, absurdly capable tools. Yet Tableau charges seventy dollars a month per user — per user — and commands a massive subscription revenue stream. Power BI has its own enormous footprint. ArcGIS starts at fifteen hundred dollars a year per user. And these aren't niche products — they're industry standards.
So the question isn't whether Python can do what these tools do. It can. The question is why smart people keep reaching for their wallets.
And I think the answer starts with understanding what's actually in this ecosystem, because it's bigger than most people realize. Let me lay out the map. At the foundation you've got matplotlib. That's the engine under almost everything. Then you've got high-level wrappers like seaborn and plotnine that sit on top and give you a cleaner interface. For interactivity there's Bokeh, Plotly, and HoloViews. And then there's an entirely separate geospatial branch — GeoPandas, Folium, Kepler dot gl, a whole stack of tools that most Python users have never touched.
That's already what, nine libraries and we haven't even gotten specific yet.
And here's the thing about the "lifetime to learn half" claim Daniel made. Matplotlib alone has something like seventy thousand words of documentation. Seven submodules — pyplot, axes, patches, collections, transforms, and on and on. You could absolutely spend years plumbing the depths of just that one library.
But.
But. The Pareto principle applies here brutally. Twenty functions cover ninety-five percent of what anyone actually does. Plot, scatter, bar, hist, subplots, legend, xlabel, ylabel, title, savefig. Maybe a handful more. That's it. That's most of a career.
So the "lifetime learning" framing is... what, technically true but practically misleading?
The depth is real, but the real barrier isn't capability — it's discoverability. Nobody tells you which twenty functions matter. The documentation is comprehensive, which means it's also overwhelming. A new user opens the matplotlib docs and sees this vast API reference and thinks, I have to know all of this. They don't.
It's like walking into a library and assuming you need to read every book before you can write a sentence.
That's... actually a perfect analogy. And I say that as someone who reads a lot.
I know you do. So let's get into the foundation. Matplotlib. What is actually going on under the hood that makes it feel so complicated?
The single biggest source of confusion is that matplotlib has two APIs living side by side. There's the pyplot state-machine interface — that's the one every tutorial shows you, where you call plt dot plot and plt dot show and matplotlib keeps track of what figure you're working on behind the scenes. And then there's the object-oriented API, where you explicitly create figure and axes objects and call methods on them directly.
And the problem is they get mixed.
Constantly. People start with pyplot, then they need to do something more sophisticated — customize a tick label, add an inset axis — and suddenly they're in object-oriented territory without realizing they've crossed a border. The error messages don't help because they reference internals that assume you already understand the architecture.
So the learning curve isn't really about the number of functions. It's that the mental model you start with is wrong for anything beyond basic plots.
And here's where the subscription comparison gets interesting. A typical scatter plot in matplotlib is five lines of code. Import matplotlib dot pyplot as plt, plt dot scatter of x and y, plt dot xlabel, plt dot ylabel, plt dot show. In Tableau it's three clicks — drag the fields, pick scatter from the chart type menu, done.
Five lines versus three clicks. That doesn't sound like a huge gap.
It's not, for one chart. But the matplotlib version has properties the Tableau version doesn't. It's reproducible — run the script again next month with new data and you get the same chart, no clicking required. It's scriptable — you can generate five hundred charts from five hundred data files while you go get coffee. And it costs zero dollars.
So why are people paying seventy dollars a month?
Three rational reasons. One, drag-and-drop lowers the cognitive barrier for people who don't write code. A marketing analyst who lives in Excel should not have to learn Python to make a bar chart. Two, IT departments love vendor support contracts. If Tableau breaks, you call Tableau. If your matplotlib script breaks at 2 a., you're on your own. And three, interactive dashboards are harder to build in pure matplotlib. Not impossible — but harder.
That third one is where the gap used to be enormous. Is it still?
That's what's changed in the last few years. Plotly Express now provides high-level charting that's remarkably similar to Tableau's drag-and-drop in terms of output — you write Python code, but what you get is an interactive HTML chart with hover tooltips, zoom, pan, the whole thing. HoloViews from the pyviz project takes a declarative approach — you describe what you want to visualize, and it figures out how to render it, composing naturally with pandas DataFrames.
So the output is interactive HTML, no subscription, and you can embed it anywhere.
And here's a concrete example. Plotly has this famous gapminder animation demo — it shows life expectancy versus GDP per capita for countries over time, animated, with a playback slider and hover details. It's interactive, it's beautiful, it exports to a single HTML file you can send to anyone, and the whole thing is maybe thirty lines of Python. Tableau can do that too, but you're paying eight hundred forty dollars a year for the privilege.
Per user.
Per user. Now, I'm not saying Tableau is a bad product. It's excellent at what it does. But the capability gap that justified the price gap has shrunk dramatically. What's left is mostly a convenience tax and an ecosystem lock-in effect.
The convenience tax I get. What's the lock-in effect?
Once a company has built fifty dashboards in Tableau, with all their data pipelines feeding into Tableau Server, and trained two hundred employees on Tableau... switching costs are enormous. Even if the free alternative is technically better, the organizational inertia is massive. The subscription isn't paying for charts anymore — it's paying to not retrain the whole company.
So the rational choice for an individual learning today is different from the rational choice for a company that made this decision in twenty sixteen.
Right. And that's where Daniel's "half you learn is more than you'll ever need" observation lands perfectly. If you're starting today, learning matplotlib's core twenty functions plus one high-level interactive library — Plotly or HoloViews — gets you capabilities that would cost thousands per year in subscription fees. The half you learn really is more than enough.
Alright. Let's shift to the geo side, because Daniel specifically asked about that, and it's a whole different branch of the tree.
And it's where things get exciting. The geospatial branch of the Python ecosystem has matured enormously. The centerpiece is GeoPandas.
Which is... pandas for maps?
That's exactly how to think about it. GeoPandas extends pandas DataFrames with geometry types and spatial operations. So a GeoDataFrame has all the normal pandas columns you're used to, plus a geometry column that holds points, lines, polygons — the shapes that make up spatial data. It relies on Shapely for the actual geometry operations and Fiona for reading and writing file formats.
So you load a shapefile the same way you'd load a CSV.
GeoPandas dot read file, point it at a shapefile or a GeoJSON file, and you've got a GeoDataFrame. Then you call dot plot on it and it renders a map using matplotlib under the hood. Add contextily and you can pull in basemaps from OpenStreetMap or other tile providers. The whole thing is maybe fifteen lines of code.
Give me a concrete example.
Mapping US county vaccination rates. You load a county shapefile, merge it with a CSV of vaccination data by county FIPS code, call dot plot with the column set to the vaccination rate and a colormap, add a basemap with contextily, and you've got a publication-quality choropleth map. Fifteen lines, free, reproducible, scriptable. The ArcGIS equivalent requires a fifteen hundred dollar per year license.
Fifteen hundred dollars a year. Per user.
And ArcGIS is excellent software — the cartography is polished, the support is professional, the tooling is comprehensive. But for the specific task of "I need to make a choropleth map from this dataset," the free Python workflow is not just cheaper — it's faster once you've written the script once.
Because the second time you just change the filename.
Change the filename and the column name. Ten seconds. The ArcGIS workflow might take ten minutes of clicking through menus each time.
So the subscription advantage inverts when the workflow becomes repetitive.
Completely inverts. And that's before we get to the specialized tools. Folium wraps Leaflet dot js — that's the JavaScript library that powers OpenStreetMap's interactive maps — and lets you create interactive web maps from Python. Earthquake epicenters with popup markers, fifteen lines of code. Click a point, see the magnitude and depth. Pan, zoom, switch between terrain and satellite view. All in a single HTML file.
And there's another one that handles really large datasets?
Kepler dot gl. That's Uber's open-source tool for visualizing large point clouds with GPU acceleration. We're talking a million GPS points with clustering and time animation, all from a Jupyter notebook. You can watch ship movements over a year, taxi pickups over a day, migration patterns — datasets that would choke a normal browser renderer just slide around smoothly.
A million points.
With clustering. As you zoom in, the clusters break apart into individual points. As you zoom out, they re-aggregate. It's the kind of visualization that used to require a dedicated GIS workstation. Now it runs in a browser tab.
And Plotly has map stuff too?
Plotly's mapbox integration lets you build interactive dashboards with maps as components. So you can have a scatter plot on the left, a map on the right, and brushing a region on the map filters the scatter plot. That's dashboard-level interactivity that competes directly with what people pay Tableau for.
The geo branch alone has... GeoPandas for static maps, Folium for interactive web maps, Kepler dot gl for massive point clouds, Plotly for dashboards with maps. That's four tools, all free.
Here's where Daniel's observation about "half you learn is more than you'll ever need" hits again. Most geo-visualization tasks — point maps, choropleths, heatmaps — use less than ten percent of GeoPandas' functionality. The depth is there for advanced spatial analysis: intersections, buffers, coordinate reference system transformations, spatial joins. But the average user doesn't need any of that.
The same Pareto pattern holds.
Across the entire ecosystem. The depth is real, the depth is impressive, and the depth is mostly irrelevant to getting work done.
If someone's listening and thinking, alright, I'm convinced, but where do I actually start without drowning — what's the path?
Three practical takeaways. First, learn matplotlib's core twenty functions. Plot, scatter, bar, hist, subplots, legend, xlabel, ylabel, title, savefig, figure, axes, imshow, text, annotate, fill between, errorbar, boxplot, grid, and tight layout. That's your foundation. Everything else in matplotlib you can look up when you need it.
Twenty functions. That's a weekend.
A weekend. Then pick one high-level wrapper. If you do statistical visualization, seaborn. If you need interactivity, Plotly Express. That combination — matplotlib fundamentals plus one wrapper — covers ninety-five percent of use cases.
And for geo?
Start with GeoPandas plus contextily for static maps. That gets you choropleths, point maps, and basic spatial plots. Add Folium when you need interactivity — clickable markers, popups, layer toggles. Those two tools cover the vast majority of what people actually need from GIS software.
And the third takeaway?
Before paying for a subscription, ask yourself one question. Is my need for interactivity that Python can't produce, or for a specific chart type that doesn't exist in the ecosystem? If it's the latter, check Plotly Express or HoloViews first. The subscription is almost always a convenience tax, not a capability gap.
Convenience is a legitimate thing to pay for. I'm not anti-convenience.
Neither am I. If you're a team of fifty analysts and nobody writes code, Tableau is the right choice. The subscription buys you a shared language that everyone already speaks. But if you're an individual, or a small team with some Python fluency, paying for what you could do for free is... well, it's paying for the story that these tools are too hard to learn.
That story is mostly maintained by people who've never actually tried to learn them.
Or who opened the matplotlib docs once, saw seventy thousand words of API reference, and closed the tab.
The docs are doing active harm at that point.
They are. The documentation is accurate and comprehensive and it terrifies beginners. There's a reason the most popular matplotlib tutorial on the internet is not the official documentation — it's blog posts and YouTube videos that say "here are the ten things you actually need."
It's almost like the project needs a curated onboarding path that hides the other sixty-nine thousand nine hundred words until you're ready.
Some of the high-level libraries are doing exactly that. Plotly Express deliberately exposes a small, clean API. HoloViews is built around the idea that you declare what you want and the library handles the implementation. The ecosystem is moving toward declarative interfaces that lower the barrier.
Which brings us to the bigger question. As AI-assisted coding tools get better — and they're getting better fast — does the learning curve for Python visualization flatten enough to make subscriptions obsolete?
I think about this a lot. Right now, you can describe a chart to Claude or ChatGPT in plain English and get working matplotlib or Plotly code back. "Make a scatter plot of these two columns with a color gradient based on a third column and add a trend line." Thirty seconds later you have code that works.
The coding barrier is evaporating.
It's evaporating for the generation step. But you still need to understand enough to verify that the output is correct — that the axes are labeled right, that the color scale means what you think it means, that the chart isn't lying to you.
The communication part. Which is what you've always said visualization is fundamentally about.
Right. The fundamental purpose of a visualization is communication, not analysis. AI can generate the code, but it can't know whether the chart communicates what you intend to your specific audience. That judgment still requires human understanding of the tools.
The "lifetime learning" problem doesn't go away entirely — it just shifts from "learn every function" to "learn what makes a chart honest and clear."
Which is a much smaller and more interesting problem. And the declarative APIs — HoloViz, Plotly Express — are moving in the same direction. They're saying, describe what you want to show, not how to render it. The library handles the how.
The ecosystem is solving its own complexity problem from both ends. Higher-level APIs on one side, AI assistance on the other.
The subscription services are feeling it. Tableau's been adding AI features. They know the ground is shifting.
The misconception I keep running into is that you need to know all of matplotlib to make good visualizations. People believe this. They look at the API reference and think, I can't possibly learn all that, so I'll just pay for Tableau.
The reality is twenty functions. Twenty. Most of which you'll use so often they become muscle memory within a week. The rest of matplotlib's vastness is there for the edge cases, and when you hit an edge case, you Google it. That's what everyone does. That's what I do.
The walking encyclopedia Googles things.
Constantly. The skill isn't knowing everything — it's knowing what's possible and how to find the specifics when you need them.
One last thought I want to land. The geo-visualization tools we talked about — GeoPandas, Folium, Kepler dot gl — these aren't just free alternatives to ArcGIS. They represent a fundamentally different workflow. Scriptable, reproducible, version-controllable. You can put a GeoPandas script in a git repository and track every change. You can run it in a CI pipeline. You can't do that with a point-and-click GIS project file.
That's the part that doesn't get enough attention. The reproducibility angle. In science, in journalism, in any field where someone needs to verify your work, a script that generates the map from raw data is worth a thousand screenshots of an ArcGIS session.
The map becomes a product of code, not a product of a GUI session that nobody can replay.
That's where the ecosystem is superior, not just cheaper. The free tools are better at reproducibility than the paid ones, because they're built on a programming paradigm rather than a document paradigm.
Where does this leave someone who's been paying for subscriptions and is now wondering if they've been wasting money?
They probably haven't been wasting money if the subscription solved a real problem at the time. But it's worth re-evaluating. The ecosystem today is not the ecosystem of five years ago. Plotly Express didn't exist in its current form. HoloViews has matured enormously. GeoPandas has gone from a niche academic project to a widely-used library with commercial backing. The gap has closed.
The price of the paid tools hasn't dropped to match.
If anything it's gone up. Tableau's pricing has been creeping upward for years. ArcGIS has never been cheap. Meanwhile the free tools keep getting better, and the AI assistance keeps lowering the barrier to entry. The economics are shifting in one direction.
Alright. We should probably leave it there before you start reading API documentation into the microphone.
I wasn't going to do that.
You were thinking about it.
I was thinking about the transforms module, actually. There's a fascinating thing about how matplotlib handles coordinate systems that—
And we're done.
Fine. Fine. But it really is interesting.
I believe you. Thanks to our producer Hilbert Flumingtop for making this possible.
This has been My Weird Prompts. If you enjoyed the episode, leave a review wherever you listen — it helps other people find the show.
We'll be back soon.
