llustrating Sorting bars in a Seaborn Bar Plot in Ascending Order Using Pandas

SortingBarPlotExample.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Unsorted and after Sorting Pandas with plot example\n",
    "\n",
    "Based on https://stackoverflow.com/questions/44885933/how-to-sort-bars-in-a-bar-plot-in-ascending-order .\n",
    "\n",
    "Works in notebooks launched from [here](https://github.com/fomightez/vpython-jupyter)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#%matplotlib inline\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "#\"For examples that use the StringIO class, make sure you import it according to your Python version, i.e. from StringIO import StringIO for Python 2 and from io import StringIO for Python 3.\" - http://pandas.pydata.org/pandas-docs/stable/io.html\n",
    "#from StringIO import StringIO # see http://pandas.pydata.org/pandas-docs/stable/io.html\n",
    "from io import StringIO # see http://pandas.pydata.org/pandas-docs/stable/io.html\n",
    "\n",
    "\n",
    "input ='''\n",
    "    Id         Speed\n",
    "    1          30\n",
    "    1          35 \n",
    "    1          31\n",
    "    2          20\n",
    "    2          25\n",
    "    3          80\n",
    "''' "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## First the unsorted example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Id  Speed\n",
      "0   1     30\n",
      "1   1     35\n",
      "2   1     31\n",
      "3   2     20\n",
      "4   2     25\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df = pd.read_table(StringIO(input), header=0, index_col=None,  delim_whitespace=True)\n",
    "print(df.head())\n",
    "result = df.groupby([\"Id\"])['Speed'].aggregate(np.median).reset_index()\n",
    "\n",
    "norm = plt.Normalize(df[\"Speed\"].values.min(), df[\"Speed\"].values.max())\n",
    "#colors = plt.cm.Reds(norm(df[\"Speed\"])) # was causing issues when not at tmpnb.org\n",
    "# and I didn't want to specify a Seaborn only palette, so just let go to default now\n",
    "\n",
    "plt.figure(figsize=(12,8))\n",
    "sns.barplot(x=\"Id\", y=\"Speed\", data=df) # formerly: sns.barplot(x=\"Id\", y=\"Speed\", data=df, palette=colors)\n",
    "plt.ylabel('Speed', fontsize=12)\n",
    "plt.xlabel('Id', fontsize=12)\n",
    "plt.xticks(rotation='vertical')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Result Sorted by Speed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "result = df.groupby([\"Id\"])['Speed'].aggregate(np.median).reset_index().sort_values('Speed')\n",
    "sns.barplot(x='Id', y=\"Speed\", data=df, order=result['Id']) #formerly: sns.barplot(x='Id', y=\"Speed\", data=df, palette=colors, order=result['Id'])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Id</th>\n",
       "      <th>Speed</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>22.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>31.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>80.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Id  Speed\n",
       "1   2   22.5\n",
       "0   1   31.0\n",
       "2   3   80.0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}

is it possible to sort by estimated value:
sns.barplot(x='Id', y="Speed", data=df, estimator=np.mean, order=?)
?

I'm looking for the same thing as you, vladkras, did you find anything useful?

Sorry, I had missed vladkras's comment and not replied earlier. I am looking at this now, but do you have a better example data you are looking at? Even if it is just toy data. I don't see how just changing the aggregate() function to aggregate(np.mean) wouldn't handle that here?

An alternative place to run this notebook is provided by sessions launched from here. Go there and click the launch binder badge to launch a session.

You can pull the notebook into the active session by running curl -O https://gist.githubusercontent.com/fomightez/bb5a9c727d93d1508187677b4d74d7c1/raw/bfa3f34ba635b33c421fa02334c8e711084de4df/SortingBarPlotExample.ipynb in a terminal or running !curl -O https://gist.githubusercontent.com/fomightez/bb5a9c727d93d1508187677b4d74d7c1/raw/bfa3f34ba635b33c421fa02334c8e711084de4df/SortingBarPlotExample.ipynb in a notebook cell. Then in the classic notebook interface you can switch to the dashboard by clicking on the Jupyter logo in the upper right and then you'll see the notebook name SortingBarPlotExample.ipynb displayed among the files listed. In the JupyterLab interface, you'll see it show up in the file list pane.