Last active
September 2, 2024 14:21
-
-
Save pfandzelter/0ae861f0dee1fb4fd1d11344e3f85c9e to your computer and use it in GitHub Desktop.
Bar Chart With a Broken Y Axis in Python Using Seaborn
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| { | |
| "cells": [ | |
| { | |
| "cell_type": "code", | |
| "execution_count": 24, | |
| "metadata": {}, | |
| "outputs": [], | |
| "source": [ | |
| "# import seaborn, pyplot (for plotting), and pandas (to build the dataframe)\n", | |
| "import seaborn as sns\n", | |
| "import pandas as pd\n", | |
| "import matplotlib.pyplot as plt" | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "metadata": {}, | |
| "source": [ | |
| "First, we input our data as the following table: \n", | |
| "\n", | |
| "| | X1 | X2 | X3 |\n", | |
| "| :------------- | :----------: | :----------: | -----------: |\n", | |
| "| Test T1 | 36.08911234 | 35.44650908 | 13.28387507 |\n", | |
| "| Test T2 | 334.0905209 | 332.8183322 | 114.2073644 |\n", | |
| "| Test T3 | 125.7836401 | 331.9770472 | 132.2351763 |\n", | |
| "\n", | |
| "Then, we make a pandas dataframe from it." | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "execution_count": 25, | |
| "metadata": {}, | |
| "outputs": [ | |
| { | |
| "name": "stdout", | |
| "output_type": "stream", | |
| "text": [ | |
| " Experiment Setup T1 T2 T3\n", | |
| "0 X1 36.089112 334.090521 125.783640\n", | |
| "1 X2 35.446509 332.818332 331.977047\n", | |
| "2 X3 13.283875 114.207364 132.235176\n" | |
| ] | |
| } | |
| ], | |
| "source": [ | |
| "# input data\n", | |
| "data = {\"Experiment Setup\": [\"X1\", \"X2\", \"X3\"],\n", | |
| " \"T1\": [36.08911234, 35.44650908, 13.28387507],\n", | |
| " \"T2\": [334.0905209, 332.8183322, 114.207364],\n", | |
| " \"T3\": [125.7836401, 331.977047, 132.2351763]\n", | |
| " }\n", | |
| "\n", | |
| "# make a dataframe\n", | |
| "data = pd.DataFrame(\n", | |
| " data, columns=[\"Experiment Setup\", \"T1\", \"T2\", \"T3\"])\n", | |
| "\n", | |
| "print(data)" | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "metadata": {}, | |
| "source": [ | |
| "Next, melt the dataframe to make data easier to handle for seaborn.\n", | |
| "It will look something like this: \n", | |
| "\n", | |
| "| Test | Experiment Setup | Latency in ms |\n", | |
| "| :------------- | :----------: | -----------: |\n", | |
| "| Test T1 | X1 | 36.08911234 |\n", | |
| "| Test T1 | X2 | 35.44650908 |\n", | |
| "| Test T1 | X3 | 13.28387507 |\n", | |
| "| Test T2 | X1 | 334.0905209 |\n", | |
| "| Test T2 | X2 | 332.8183322 |\n", | |
| "| Test T2 | X3 | 114.2073644 |\n", | |
| "| Test T3 | X1 | 125.7836401 |\n", | |
| "| Test T3 | X2 | 331.9770472 |\n", | |
| "| Test T3 | X3 | 132.2351763 |\n" | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "execution_count": 26, | |
| "metadata": {}, | |
| "outputs": [ | |
| { | |
| "name": "stdout", | |
| "output_type": "stream", | |
| "text": [ | |
| " Experiment Setup Test Latency in ms\n", | |
| "0 X1 T1 36.089112\n", | |
| "1 X2 T1 35.446509\n", | |
| "2 X3 T1 13.283875\n", | |
| "3 X1 T2 334.090521\n", | |
| "4 X2 T2 332.818332\n", | |
| "5 X3 T2 114.207364\n", | |
| "6 X1 T3 125.783640\n", | |
| "7 X2 T3 331.977047\n", | |
| "8 X3 T3 132.235176\n" | |
| ] | |
| } | |
| ], | |
| "source": [ | |
| "# transform dataframe\n", | |
| "\n", | |
| "data_M = pd.melt(data, id_vars=\"Experiment Setup\", var_name=\"Test\",\n", | |
| " value_name=\"Latency in ms\")\n", | |
| "\n", | |
| "print(data_M)" | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "execution_count": 27, | |
| "metadata": {}, | |
| "outputs": [], | |
| "source": [ | |
| "# set style for seaborn plot\n", | |
| "sns.set(style=\"whitegrid\", font=\"CMU Sans Serif\")\n", | |
| "# create a color palette (we only have three different colors for the three different tests T1...T3)\n", | |
| "pal = sns.color_palette(n_colors=3)" | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "execution_count": 28, | |
| "metadata": {}, | |
| "outputs": [ | |
| { | |
| "data": { | |
| "image/png": "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", | |
| "text/plain": [ | |
| "<Figure size 432x288 with 2 Axes>" | |
| ] | |
| }, | |
| "metadata": {}, | |
| "output_type": "display_data" | |
| } | |
| ], | |
| "source": [ | |
| "# let's create a figure for our two plots to live in\n", | |
| "# we need a lower part (anything below the cutoff), which will be ax2\n", | |
| "# and an upper part (anything above the cutoff) which will be ax1\n", | |
| "# because we have only two plots above each other, we set ncols=1 and nrows=2\n", | |
| "# also, they should share an x axis, which is why we set sharex=True\n", | |
| "f, (ax1, ax2) = plt.subplots(ncols=1, nrows=2,\n", | |
| " sharex=True)\n", | |
| "\n", | |
| "# we want the \"Test\" to appear on the x axis as individual parameters\n", | |
| "# \"Latency in ms\" should be what is shown on the y axis as a value\n", | |
| "# hue should be the \"Experiment Setup\"\n", | |
| "# this will result three ticks on the x axis with X1...X3 and each with three bars for T1...T3\n", | |
| "# (you could turn this around if you need to, depending on what kind of data you want to show)\n", | |
| "ax1 = sns.barplot(x=\"Test\", y=\"Latency in ms\",\n", | |
| " hue=\"Experiment Setup\", data=data_M, palette=pal, ax=ax1)\n", | |
| "\n", | |
| "# we basically do the same thing again for the second plot\n", | |
| "ax2 = sns.barplot(x=\"Test\", y=\"Latency in ms\",\n", | |
| " hue=\"Experiment Setup\", data=data_M, palette=pal, ax=ax2)\n", | |
| "\n", | |
| "# here is the fun part: setting the limits for the individual y axis\n", | |
| "# the upper part (ax1) should show only values from 250 to 400\n", | |
| "# the lower part (ax2) should only show 0 to 150\n", | |
| "# you can define your own limits, but the range (150) should be the same so scale is the same across both plots\n", | |
| "# it could be possible to use a different range and then adjust plot height but who knows how that works\n", | |
| "ax1.set_ylim(250, 400)\n", | |
| "ax2.set_ylim(0, 150)\n", | |
| "\n", | |
| "# the upper part does not need its own x axis as it shares one with the lower part\n", | |
| "ax1.get_xaxis().set_visible(False)\n", | |
| "\n", | |
| "# by default, each part will get its own \"Latency in ms\" label, but we want to set a common for the whole figure\n", | |
| "# first, remove the y label for both subplots\n", | |
| "ax1.set_ylabel(\"\")\n", | |
| "ax2.set_ylabel(\"\")\n", | |
| "# then, set a new label on the plot (basically just a piece of text) and move it to where it makes sense (requires trial and error)\n", | |
| "f.text(0.05, 0.55, \"Latency in ms\", va=\"center\", rotation=\"vertical\")\n", | |
| "\n", | |
| "# by default, seaborn also gives each subplot its own legend, which makes no sense at all\n", | |
| "# soe remove both default legends first\n", | |
| "ax1.get_legend().remove()\n", | |
| "ax2.get_legend().remove()\n", | |
| "# then create a new legend and put it to the side of the figure (also requires trial and error)\n", | |
| "ax2.legend(loc=(1.025, 0.5), title=\"Design\")\n", | |
| "\n", | |
| "# let's put some ticks on the top of the upper part and bottom of the lower part for style\n", | |
| "ax1.xaxis.tick_top()\n", | |
| "ax2.xaxis.tick_bottom()\n", | |
| "\n", | |
| "# finally, adjust everything a bit to make it prettier (this just moves everything, best to try and iterate)\n", | |
| "f.subplots_adjust(left=0.15, right=0.85, bottom=0.15, top=0.85)\n", | |
| "\n", | |
| "plt.show()" | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "execution_count": 29, | |
| "metadata": {}, | |
| "outputs": [ | |
| { | |
| "data": { | |
| "image/png": "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", | |
| "text/plain": [ | |
| "<Figure size 432x288 with 2 Axes>" | |
| ] | |
| }, | |
| "metadata": {}, | |
| "output_type": "display_data" | |
| } | |
| ], | |
| "source": [ | |
| "# now for the fun part, this is just copied from https://matplotlib.org/examples/pylab_examples/broken_axis.html\n", | |
| "# (most of this is, actually)\n", | |
| "# here, we create these little diagonal lines that bring this chart to a whole new level:\n", | |
| "\n", | |
| "# This looks pretty good, and was fairly painless, but you can get that\n", | |
| "# cut-out diagonal lines look with just a bit more work. The important\n", | |
| "# thing to know here is that in axes coordinates, which are always\n", | |
| "# between 0-1, spine endpts are at these locations (0,0), (0,1),\n", | |
| "# (1,0), and (1,1). Thus, we just need to put the diagonals in the\n", | |
| "# appropriate corners of each of our axes, and so long as we use the\n", | |
| "# right transform and disable clipping.\n", | |
| "\n", | |
| "d = .01 # how big to make the diagonal lines in axes coordinates\n", | |
| "# arguments to pass to plot, just so we don't keep repeating them\n", | |
| "kwargs = dict(transform=ax1.transAxes, color=\"k\", clip_on=False)\n", | |
| "ax1.plot((-d, +d), (-d, +d), **kwargs) # top-left diagonal\n", | |
| "ax1.plot((1 - d, 1 + d), (-d, +d), **kwargs) # top-right diagonal\n", | |
| "\n", | |
| "kwargs.update(transform=ax2.transAxes) # switch to the bottom axes\n", | |
| "ax2.plot((-d, +d), (1 - d, 1 + d), **kwargs) # bottom-left diagonal\n", | |
| "ax2.plot((1 - d, 1 + d), (1 - d, 1 + d), **kwargs) # bottom-right diagonal\n", | |
| "\n", | |
| "# display new plot again\n", | |
| "# https://stackoverflow.com/questions/50452455/plt-show-does-nothing-when-used-for-the-second-time\n", | |
| "from IPython.display import display\n", | |
| "display(f) # Shows plot again" | |
| ] | |
| } | |
| ], | |
| "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.9.10" | |
| } | |
| }, | |
| "nbformat": 4, | |
| "nbformat_minor": 1 | |
| } |
I wonder if the "looking break-like" between both graphs is because of the subplot definition "f, (ax1, ax2) = plt.subplots(ncols=1, nrows=2 sharex=True)". Particularly, the common 'y-axis' and the absence of a 'x-axis title" for the upper graphs creates an effect of "break-like"
I hope this insight is beneficial
@rafmora Yes I think you're exactly right. The "broken" look is exactly what we wanted to achieve to present the data without cutting off outliers or using a logarithmic scale, which can both be misleading
Hi pfandzelter
running your code I get this:
I have pandas 1.4.2 and seaborn 0.11.2.
Do you know why the bars are not displaying in the correct scale and inside the y-axis limits?
Thanks a lot
Gonzalo
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Offiziell Most Savage Plot Ive Seen today