B12 Badge - Drawing Simple Graphs v1.6.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Badge 12: Drawing Simple Graphs - preparing data and feeding them into a graph.\n",
    "\n",
    "### We're using 'Plotly' an interactive graphs library, but there are many other really good graph libraries out there!\n",
    "\n",
    "This notebook is very advanced, and introduces a lot of advanced concepts, so there are a few ways to interact with it:\n",
    "\n",
    "- **To only learn how to make some basic diagrams** - read the first part of this Notebook all the way to the 3 stars and a wish, and the minitask.\n",
    "- **To just see what Python can do with graphs** - run all the cells in this notebook (even without looking at the code) and see what wonderful and complex graphs can be produced.\n",
    "- **To learn how to create these complex graphs**- try to understand all the code in this Notebook. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This tutorial is a simplified version of and introduction to 'plot.ly/python/'.\n",
    "\n",
    "\n",
    "**We will cover:**\n",
    "\n",
    "- Creating graphs and combining them into more complex inphographics.\n",
    "- Editing/Updating Graphs.\n",
    "- Types of graphs - just briefly, you'll go to documentation by yourself to find out more."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Some new concepts: \n",
    "\n",
    "**CLASSES** are similar to other complicated data types, like LISTS or DICTIONARIES etc. except we import CLASSES from libraries, or create them yourself. You usually use a class to ...\n",
    "\n",
    "**CREATE AN OBJECT OF A CLASS** : By which you create a new item/instance of this class, like how we created a new list or dictionary with `[ 1,2,3]` or `{ 'name':'Pim' }`. When you have an object you can interact with it - just as we can change a list object with `.pop()` or `.sort()`. You create graph objects by using constructors, like ```fig = Figure( some_ttributes )``` or you can use a factory method that will create an object and return it to you ```fig = px.scatter( ... )```.\n",
    "\n",
    "**OBJECT** - is your primary item you will work with when creating graphs.\n",
    "\n",
    "Once you have created an object you can change perform methods on it like...\n",
    "\n",
    "```\n",
    "fig.show()   \n",
    "fig.add_bar( ... )   \n",
    "fig.update_yaxes( ... )\n",
    "``` \n",
    "\n",
    "You can also change its attributes like...\n",
    "\n",
    "```\n",
    "fig.data[1].marker.line.color = \"yellow\"\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**IMPORTING LIBRARIES** - Is a process via which we give our Notebook the ability to use CLASSES and code written by someone else. We specify a library we want and its short name: \n",
    "\n",
    "```\n",
    "import library_you_want as short_name\n",
    "```\n",
    "\n",
    "And the ones we will use the most are: \n",
    "\n",
    "```\n",
    "import pprint as pp\n",
    "\n",
    "import plotly.graph_objects as go        \n",
    "import plotly.express as px      \n",
    "```\n",
    "\n",
    "**IMPORTING INDIVIDUAL METHODS/CLASSES FROM A LIBRARY** - When we need omly a small part of a library, we have the option to specify it and give it a short handy name: \n",
    "\n",
    "```\n",
    "from library_you_want import function_or_class_you_want\n",
    "```\n",
    "\n",
    "Which will look like this: \n",
    "\n",
    "```\n",
    "from plotly.subplots import make_subplots\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Recap: Creating Dictionaries.\n",
    "\n",
    "There are a few ways to create a dictionary. We most of the time used... \n",
    "\n",
    "```{ 'name': 'Scotland', 'population': 5438000 }```\n",
    "\n",
    "But you can also create a dict object, and specify it's attributes, with a **dict()** constructor...\n",
    "\n",
    "```dict(name='Scotland', population = 5438000)```\n",
    "\n",
    "Notice the differences in brackets around the keys.\n",
    "\n",
    "- {} syntax uses : to separete keys and values. Keys are in ''.\n",
    "- dict() sytax uses = to separete keys and values.\n",
    "\n",
    "You will see both syntaxes in this Notebook, often without particular reason. They both work interchangably. Try to be consistent, but use one which is most convenient."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Installing plotly on your Notebook:\n",
    "\n",
    "First let's import plotly from Python Index of Packages. \n",
    "\n",
    "Note: ```pip install some_library``` is a command that will install any pip library you request from the Python Package Index. \n",
    "\n",
    "Python Package Index is like a phone book of all available Python libraries, it contains hundreds of thousands of libraries for anything you can imagine: Data, Graphs, Maps, AI, Internet... You can go and browse them yourself at https://pypi.org/.\n",
    "\n",
    "For now we will only grab Plotly from there with the below line of code. Because every time you start a Noteable Notebook/session you are effectively startig a new instance of a server, you will need to run this code every time you open the new session. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You need to do this ONCE EVERY TIME YOU START A NOTEBOOK. \n",
    "# It will take abotu a MINUTE, and when done will print something like \"Successfully installed plotly\".\n",
    "#!pip install plotly --upgrade\n",
    "\n",
    "!pip install plotly\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# If at some point your graphs stop showing - restart your Kernel, from the top menu. \n",
    "\n",
    "### Your first plot:\n",
    "\n",
    "# Simple bar chart. Create an object of class Figure with its constructor.\n",
    "# Constructor takes a number of possible arguments eg. data, layout_title_text.\n",
    "\n",
    "# You can create an object and call on it a method '.show()':\n",
    "\n",
    "import plotly.graph_objects as go\n",
    "import plotly.io as pio\n",
    "pio.renderers.default='notebook'\n",
    "import pprint as pp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your first graph :D\n",
    "\n",
    "fig = go.Figure(\n",
    "    data=[go.Bar(y=[5, 2, 4], \n",
    "                 x=[\"bananas\", \"kiwis\", \"plums\"], \n",
    "                 marker_color='blue')],\n",
    "    layout=go.Layout(\n",
    "        title=go.layout.Title(text=\"How much I like these fruits\")\n",
    "    )\n",
    ")\n",
    "fig.show('notebook')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here's the same code, but cleaner:\n",
    "\n",
    "values = [5, 2, 4]\n",
    "categories = [\"bananas\", \"kiwis\", \"plums\"]\n",
    "color = 'blue'\n",
    "\n",
    "fig = go.Figure(\n",
    "    data=[go.Bar(y=values, \n",
    "                 x=categories, \n",
    "                 marker_color=color)],\n",
    "    layout=go.Layout(\n",
    "        title=go.layout.Title(text=\"How much I like these fruits\")\n",
    "    )\n",
    ")\n",
    "fig.show('notebook')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Or with colours and variables:\n",
    "\n",
    "import plotly.graph_objects as go\n",
    "import plotly.io as pio\n",
    "pio.renderers.default='notebook'\n",
    "\n",
    "colors = ['yellow', 'green', 'purple']\n",
    "names = [\"banana\", \"kiwi\", \"plum\"]\n",
    "values = [5, 2, 4]\n",
    "\n",
    "fig = go.Figure(\n",
    "    data=[go.Bar(y=values, \n",
    "                 x=names, \n",
    "                 marker_color = colors)],\n",
    "    layout=go.Layout(\n",
    "        title=go.layout.Title(text=\"How much I like these fruits\")\n",
    "    )\n",
    ")\n",
    "fig.show('notebook')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# And from data:\n",
    "\n",
    "import plotly.graph_objects as go\n",
    "import plotly.io as pio\n",
    "pio.renderers.default='notebook'\n",
    "\n",
    "colors = ['yellow', 'green', 'purple']\n",
    "fruit_types = [\"banana\", \"kiwi\", \"plum\"]\n",
    "fruits_I_ate = [\"banana\", \"kiwi\",\"banana\", \"kiwi\",\"banana\", \"kiwi\", \"kiwi\",\"kiwi\",\"plum\",\"banana\"]\n",
    "\n",
    "values = [\n",
    "    fruits_I_ate.count(fruit)\n",
    "    for fruit in fruit_types\n",
    "]\n",
    "\n",
    "\n",
    "fig = go.Figure(\n",
    "    data=[go.Bar(y=values, \n",
    "                 x=names, \n",
    "                 marker_color = colors)],\n",
    "    layout=go.Layout(\n",
    "        title=go.layout.Title(text=\"Which fruits I eat the most\")\n",
    "    )\n",
    ")\n",
    "fig.show('notebook')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# And an even fancier example:\n",
    "\n",
    "import plotly.graph_objects as go\n",
    "import plotly.io as pio\n",
    "pio.renderers.default='notebook'\n",
    "\n",
    "# Raw data:\n",
    "\n",
    "fruit_colors = {\"banana\":\"yellow\", \n",
    "                \"kiwi\": \"green\", \n",
    "                \"plum\": \"purple\"}\n",
    "\n",
    "fruits_I_ate = [\"banana\", \"kiwi\",\"banana\", \"kiwi\",\"banana\", \"kiwi\",\n",
    "                \"kiwi\",\"kiwi\",\"plum\",\"banana\", \"peach\",\"peach\", \"quince\"]\n",
    "\n",
    "# Prepare data:\n",
    "    \n",
    "def create_and_show_fruit_graph(fruits, colors_dict):\n",
    "    fruit_types = list(set(fruits))\n",
    "    fruit_types.sort() # Alphabetically.\n",
    "    fruit_counts = [\n",
    "        fruits.count(fruit)\n",
    "        for fruit in fruit_types\n",
    "    ]\n",
    "    fruit_colors =  [\n",
    "        colors_dict.get(fruit, 'grey') # If colour is unknown, use grey.\n",
    "        for fruit in fruit_types\n",
    "    ]\n",
    "\n",
    "\n",
    "    fig = go.Figure(\n",
    "        data=[go.Bar(y=fruit_counts, \n",
    "                     x=fruit_types, \n",
    "                     marker_color = fruit_colors)],\n",
    "        layout=go.Layout(\n",
    "            title=go.layout.Title(text=\"Which fruits I eat the most\")\n",
    "        )\n",
    "    )\n",
    "    fig.show('notebook')\n",
    "    \n",
    "create_and_show_fruit_graph(fruits_I_ate, fruit_colors )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can find more inspiration here: https://plotly.com/python/bar-charts/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create and Combine Graphs.\n",
    "\n",
    "### Overlapping and neighbouring plots: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from plotly.subplots import make_subplots\n",
    "\n",
    "# 'Make_subplots' takes rows and columns for how many subplots you will want to create.\n",
    "# E.g. To create a 3 by 3 grid of 9 plots, you would say rows=3, cols=3:\n",
    "\n",
    "fig = make_subplots(rows=1, cols=4)\n",
    "\n",
    "# And then we add graphs to that figure with 'add_trace'.\n",
    "# It takes 3 arguments - the graph to display and it's position as row and col:\n",
    "\n",
    "fig.add_trace(go.Scatter(y=[4, 2, 1], mode=\"lines\"),\n",
    "              row=1, \n",
    "              col=1)\n",
    "fig.add_trace(go.Scatter(y=[10, 12, 15]), \n",
    "              row=1, \n",
    "              col=2)\n",
    "fig.add_trace(go.Bar(y=[2, 1, 3]), row=1, col=3)\n",
    "fig.add_trace(go.Bar(y=[6, 5, 3]), row=1, col=4)\n",
    "\n",
    "fig.show('notebook')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q: But why would I need to specify position of each 'trace' (graph/chart/drawing) separately?\n",
    "\n",
    "A: Because you can overlay the graphs on top of each other if you use it skillfully:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here's the same data, presented in 2 different ways. Spot the difference in code:\n",
    "\n",
    "from plotly.subplots import make_subplots\n",
    "fig = make_subplots(rows=2, cols=2)\n",
    "fig.add_trace(go.Scatter(y=[4, 2, 1], mode=\"lines\"),row=1, col=1)\n",
    "fig.add_trace(go.Scatter(y=[10, 12, 15]),           row=1, col=2)\n",
    "fig.add_trace(go.Bar(y=[2, 1, 3]),                  row=2, col=1)\n",
    "fig.add_trace(go.Bar(y=[6, 5, 3]),                  row=2, col=2)\n",
    "\n",
    "fig.show('notebook')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here's the same data, presented in 2 different ways. Spot the difference in code:\n",
    "\n",
    "from plotly.subplots import make_subplots\n",
    "fig = make_subplots(rows=1, cols=2)\n",
    "fig.add_trace(go.Scatter(y=[4, 2, 1], mode=\"lines\"),row=1, col=1)\n",
    "fig.add_trace(go.Scatter(y=[10, 12, 15]),           row=1, col=2)\n",
    "fig.add_trace(go.Bar(y=[2, 1, 3]),                  row=1, col=1)\n",
    "fig.add_trace(go.Bar(y=[6, 5, 3]),                  row=1, col=2)\n",
    "\n",
    "fig.show('notebook')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can customise almost anything! See here https://plotly.com/python/line-and-scatter/.\n",
    "\n",
    "hospital_admissions = [150,210,240,180,160,130]\n",
    "years = [1990,1995,2000,2005,2010,2015,2020]\n",
    "costs = [50,230,240,180,130,80]\n",
    "\n",
    "# Let's start with hardcoded data. In a minute you will see how to make it cleaner. \n",
    "# E.g. How to automatically create colour from a number.\n",
    "\n",
    "colours = ['Green','Orange','Red','Orange','Green','Green']\n",
    "\n",
    "bubble_text = [f\"cost was {cost}\"\n",
    "              for cost in costs]\n",
    "\n",
    "fig = make_subplots(rows=1, cols=1)\n",
    "fig.add_trace(go.Scatter(y=hospital_admissions, \n",
    "                         x=years, \n",
    "                         marker_color = colours, \n",
    "                         marker_size=costs,\n",
    "                         text=bubble_text,\n",
    "                         mode='markers' # Can be 'lines','markers' or 'lines+markers'.\n",
    "                        ), row=1, col=1)\n",
    "\n",
    "fig.update_layout(\n",
    "    title=\"Cost of hospital admissions in relation to number of admissions, over years\",\n",
    "    xaxis_title=\"Year\",\n",
    "    yaxis_title=\"Hospital Admissions\",\n",
    ")\n",
    "fig.show('notebook')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How to use one graph (Figure) vs. when to use graph compilation (Subplots).\n",
    "\n",
    "Look at two examples below. What are the similarities and differences?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We make a compilation (subplots) and add things to it, at desired places: \n",
    "\n",
    "fig = make_subplots(rows=1, cols=2)\n",
    "fig.add_trace(go.Bar(y=[43,21,19], \n",
    "                         x=[\"self-help\",\"fantasy\",\"romance\"]\n",
    "                        ), row=1, col=1)\n",
    "fig.add_trace(go.Bar(y=[12,28,53], \n",
    "                         x=[\"English\",\"Spanish\",\"Mandarin\"]\n",
    "                        ), row=1, col=2)\n",
    "fig.update_layout(\n",
    "    title=\"Number of new Books by genre and original language\",\n",
    ")\n",
    "fig.show('notebook')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We just create a graph - you can have only one. You do not specify row/col position. \n",
    "# But still, you create 'go.Bar()' or 'go.Scatter()' in exactly the same way, and pass it into 'data=[ ]':\n",
    "\n",
    "fig = go.Figure(\n",
    "        data=[ \n",
    "            go.Bar(y=[43,21,19], x=[\"self-help\",\"fantasy\",\"romance\"]) \n",
    "        ]\n",
    "    )\n",
    "\n",
    "fig.update_layout(\n",
    "    title=\"Number of new Books by genre and original language\",\n",
    ")\n",
    "fig.show('notebook')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Final part: From real data into a graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here's an example with real data:\n",
    "\n",
    "cities = [\n",
    " {'Geo': {'AreaKm2': 267.77,\n",
    "          'Coordinates': {'Latitude': 52.48, 'Longitude': -1.9}},\n",
    "  'Name': 'Birmingham',\n",
    "  'Population': 1137100,\n",
    "  'Year_Founded': 601},\n",
    " {'Geo': {'AreaKm2': 551.7,\n",
    "          'Coordinates': {'Latitude': 53.8, 'Longitude': -1.55}},\n",
    "  'Name': 'Leeds',\n",
    "  'Population': 789194,\n",
    "  'Year_Founded': 1893},\n",
    " {'Geo': {'AreaKm2': 142.06,\n",
    "          'Coordinates': {'Latitude': 53.38, 'Longitude': -1.47}},\n",
    "  'Name': 'Sheffield',\n",
    "  'Population': 577800,\n",
    "  'Year_Founded': 701},\n",
    " {'Geo': {'AreaKm2': 110,\n",
    "          'Coordinates': {'Latitude': 51.45, 'Longitude': -2.58}},\n",
    "  'Name': 'Bristol',\n",
    "  'Population': 567111,\n",
    "  'Year_Founded': 1155},\n",
    " {'Geo': {'AreaKm2': 115.6,\n",
    "          'Coordinates': {'Latitude': 53.47, 'Longitude': -2.23}},\n",
    "  'Name': 'Manchester',\n",
    "  'Population': 547627,\n",
    "  'Year_Founded': 1301},\n",
    " {'Geo': {'AreaKm2': 111.84,\n",
    "          'Coordinates': {'Latitude': 53.41, 'Longitude': -2.99}},\n",
    "  'Name': 'Liverpool',\n",
    "  'Population': 513441,\n",
    "  'Year_Founded': 1207},\n",
    " {'Geo': {'AreaKm2': 259,\n",
    "          'Coordinates': {'Latitude': 55.95, 'Longitude': -3.2}},\n",
    "  'Name': 'Edinburgh',\n",
    "  'Population': 488050,\n",
    "  'Year_Founded': 601}]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's prepare the data first. Our goal is to have all we need in variables first:\n",
    "\n",
    "import plotly.graph_objects as go\n",
    "\n",
    "def get_density(city):\n",
    "    return int(city['Population'])/int(city['Geo']['AreaKm2'])\n",
    "\n",
    "def get_description(city):\n",
    "    description = f\"{city['Name']} has {city['Population']} people \"\n",
    "    description += f\"living in area of {city['Geo']['AreaKm2']}km. \"\n",
    "    description += f\"Density is {get_density(city)}\"\n",
    "    return description\n",
    "    # Notice the usage of '=' and '+='.\n",
    "    # These will appear when you hover over a bubble on the graph.\n",
    "\n",
    "def density_into_colour(city):\n",
    "    density = get_density(city)\n",
    "    if density < 4000:\n",
    "        return \"Green\"\n",
    "    elif density < 5000:\n",
    "        return \"Orange\"\n",
    "    else:\n",
    "        return \"Red\"\n",
    "\n",
    "x_axis = [int(city['Population']) \n",
    "          for city in cities]\n",
    "y_axis = [int(city['Geo']['AreaKm2']) \n",
    "          for city in cities]\n",
    "\n",
    "scale_multiplier = 0.01 # We can divide/multiply numbers to make graphs readable. Try changing it to eg. 0.001 or 0.1\n",
    "scale = [int(get_density(city) * scale_multiplier  )\n",
    "         for city in cities] \n",
    "\n",
    "colours = [density_into_colour(city) \n",
    "           for city in cities]\n",
    "texts = [ get_description(city)\n",
    "         for city in cities]\n",
    "\n",
    "print(x_axis)\n",
    "print(y_axis)\n",
    "print(scale)\n",
    "print(colours)\n",
    "print(texts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can customise almost anything! See here https://plotly.com/python/line-and-scatter/.\n",
    "\n",
    "fig = go.Figure(\n",
    "        data=[go.Scatter(y=y_axis, \n",
    "                         x=x_axis, \n",
    "                         marker_color = colours, \n",
    "                         marker_size=sizes,\n",
    "                         text=texts,\n",
    "                         mode='markers' # Can be 'lines','markers' or 'lines+markers'.\n",
    "                        )],\n",
    "        layout=go.Layout(\n",
    "            title=go.layout.Title(text=\"You can set title here, but you can also change it with update\")\n",
    "        )\n",
    "    )\n",
    "fig.update_layout(\n",
    "    title=\"Density of population in British Cities\",\n",
    "    xaxis_title=\"City Population\",\n",
    "    yaxis_title=\"Area in Km2\",\n",
    "    font=dict(\n",
    "        family=\"Courier New, monospace\",\n",
    "        size=20,\n",
    "        color=\"RebeccaPurple\"\n",
    "    )\n",
    ")\n",
    "fig.show('notebook')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Another example, without subplots:\n",
    "\n",
    "fig = go.Figure()\n",
    "\n",
    "fig.add_trace(go.Scatter(\n",
    "    x=[0, 1, 2, 3, 4, 5, 6, 7, 8],\n",
    "    y=[0, 1, 2, 3, 5, 8, 7, 4, 2],\n",
    "    name=\"Name of Trace 1\"       # This sets its legend entry.\n",
    "))\n",
    "\n",
    "\n",
    "fig.add_trace(go.Scatter(\n",
    "    x=[0, 1, 2, 3, 4, 5, 6, 7, 8],\n",
    "    y=[1, 0, 3, 2, -2, 0, 1, 5, 8],\n",
    "    name=\"Name of Trace 2\"\n",
    "))\n",
    "\n",
    "fig.update_layout(\n",
    "    title=\"Plot Title\",\n",
    "    xaxis_title=\"X Axis Title\",\n",
    "    yaxis_title=\"Y Axis Title\",\n",
    "    legend_title=\"Legend Title\",\n",
    "    font=dict(\n",
    "        family=\"Courier New, monospace\",\n",
    "        size=18,\n",
    "        color=\"RebeccaPurple\"\n",
    "    )\n",
    ")\n",
    "\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Another example, with a dictionary.\n",
    "# Here we can prepare data ahead of time, then just 'fill them in' in the graph:\n",
    "\n",
    "fruits = {\n",
    "    'travel_distance':[13,20,24,4,10,220,250],\n",
    "    'costs':[10,13,8,10,10,20,25],\n",
    "    'sizes': [120,110,100,120,110,130,150],\n",
    "    'types': ['apple','apple','apple','apple','apple','banana','banana'],\n",
    "    'colours': ['Red','Green','Green','Red','Red','Yellow','Yellow']\n",
    "}\n",
    "\n",
    "def draw_graph(some_data):\n",
    "    fig = make_subplots(rows=1, cols=1)\n",
    "    fig.add_trace(go.Scatter(\n",
    "                             y=some_data['costs'],\n",
    "                             x=some_data['travel_distance'], \n",
    "                             marker_size=some_data['sizes'], # Or e.g. 200, use one number, or a list of numbers.\n",
    "                             marker_color = some_data['colours'], \n",
    "                             text = some_data['types'], \n",
    "                             mode='markers' # Can be 'lines','markers' or 'lines+markers'.\n",
    "                            ), row=1, col=1)\n",
    "    fig.show('notebook')\n",
    "draw_graph(fruits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ⭐️⭐️⭐️💥 What you have learned in this session: Three stars and a wish.\n",
    "**In your own words** write in your Learn diary:\n",
    "\n",
    "- 3 things you would like to remember from this badge.\n",
    "- 1 thing you wish to understand better in the future or a question you'd like to ask.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ⛏ Minitask 1: Recreate a graph from a newspaper:\n",
    "\n",
    "Use anything you saw in this badge to recreate a graph you have seen recently in a paper. \n",
    "\n",
    "You can choose something easy by just doing an google image search for words \"graph example\". This will show you a number of simple graphs, which might still be quite challanging to recreate in Plotly!. Here is one I found for you: https://img.chandoo.org/c/chart-with-lines-instead-of-columns.png\n",
    "\n",
    "\n",
    "If you'd like to try something much harder, look one of these outlets:\n",
    "\n",
    "Guardian: https://www.theguardian.com/data\n",
    "Economist: https://www.economist.com/graphic-detail/\n",
    "\n",
    "Keep in mind that you do not need to recreate the graph exactly, just try to mimic it a little. You do not need to have real data - just try to guess them, and eg. create a list with numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# This concludes the basic part of the Notebook.\n",
    "\n",
    "### Next parts show many more advanced types of graphs, and also using build-in training datasets. You really do not need to understand any of it. Just have a look at what's possible.\n",
    "\n",
    "## ⭐️⭐️ TOP TIP ⭐️⭐️: If you have a minute, simply run the rest of this Notebook (Shift + Enter) and look at how interesting (and easy to make) some graphs are.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Convenience methods for adding traces quicker: 'add_TYPE'.\n",
    "\n",
    "There is a family of methods that you can use instead of a more generic 'add_trace( SUB_GRAPH )'...\n",
    "\n",
    "```fig.add_scatter( INFO )``` \n",
    "\n",
    "Replaces... \n",
    "\n",
    "```fig.add_trace(go.Scatter( INFO ))```\n",
    "\n",
    "While,\n",
    "\n",
    "```fig.add_bar( INFO )``` \n",
    "\n",
    "Replaces... \n",
    "\n",
    "```fig.add_trace(go.Bar( INFO ))```\n",
    "\n",
    "This saves you having to create objects just so that you can pass them to other objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This code does exactly the same things as the above code:\n",
    "\n",
    "from plotly.subplots import make_subplots\n",
    "fig = make_subplots(rows=1, cols=2)\n",
    "fig.add_scatter(y=[4, 2, 1], mode=\"lines\", row=1, col=1)\n",
    "fig.add_scatter(y=[1, 0.5, 2], mode=\"lines\", row=1, col=2)\n",
    "fig.add_bar(y=[2, 1, 3], row=1, col=2)\n",
    "fig.show('notebook')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Overlapping graphs:\n",
    "\n",
    "Additionally, some graphs will be by default made of other graphs. A good exmaple is scatter graph with a trending line (see below). The line, in some sense, is a graph of its own (has its own data, colour and other qualities). That's why you can assign some graph objects as part of other graph objects.\n",
    "\n",
    "Below scatter plot takes in the 'go.scatter.Line' object as a ```line``` attribute. You can specify it's simple qualities like color, but also other more advanced details."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import plotly.express as px\n",
    "iris = px.data.iris()\n",
    "fig = px.scatter(iris, x=\"sepal_width\", y=\"sepal_length\", color=\"species\")\n",
    "fig.add_trace(\n",
    "    go.Scatter(\n",
    "        x=[2, 4],\n",
    "        y=[4, 8],\n",
    "        mode=\"lines\",\n",
    "        line=go.scatter.Line(color=\"gray\"),\n",
    "        showlegend=False)\n",
    ")\n",
    "fig.show('notebook')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Split layers of your data with facet columns:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# First, without splitting:\n",
    "\n",
    "import plotly.express as px\n",
    "iris = px.data.iris()\n",
    "fig = px.scatter(iris, x=\"sepal_width\", y=\"sepal_length\", color=\"species\")\n",
    "reference_line = go.Scatter(x=[2, 4],\n",
    "                            y=[4, 8],\n",
    "                            mode=\"lines\",\n",
    "                            line=go.scatter.Line(color=\"gray\"),\n",
    "                            showlegend=False)\n",
    "fig.show('notebook')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# If we specify 'facet_col', the graphs will get separated by the values in that column!\n",
    "\n",
    "import plotly.express as px\n",
    "iris = px.data.iris()\n",
    "fig = px.scatter(iris, x=\"sepal_width\", y=\"sepal_length\", color=\"species\", facet_col=\"species\")\n",
    "reference_line = go.Scatter(x=[2, 4],\n",
    "                            y=[4, 8],\n",
    "                            mode=\"lines\",\n",
    "                            line=go.scatter.Line(color=\"gray\"),\n",
    "                            showlegend=False)\n",
    "fig.show('notebook')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Notice that you can add more lines to such graphs:\n",
    "\n",
    "import plotly.express as px\n",
    "iris = px.data.iris()\n",
    "fig = px.scatter(iris, x=\"sepal_width\", y=\"sepal_length\", color=\"species\", facet_col=\"species\")\n",
    "reference_line = go.Scatter(x=[2, 4],\n",
    "                            y=[4, 8],\n",
    "                            mode=\"lines\",\n",
    "                            line=go.scatter.Line(color=\"gray\"),\n",
    "                            showlegend=False)\n",
    "fig.add_trace(reference_line, row=1, col=1)\n",
    "fig.add_trace(reference_line, row=1, col=2)\n",
    "fig.add_trace(reference_line, row=1, col=3)\n",
    "fig.show('notebook')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries with object data as quick replacements of objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# And even further, you could replace...\n",
    "# 'line=go.scatter.Line(color=\"gray\")'\n",
    "# with... \n",
    "# 'line=dict(color=\"gray\")'.\n",
    "# Or even...\n",
    "# 'line={'color':\"gray\"}'.\n",
    "\n",
    "import plotly.graph_objects as go\n",
    "fig = go.Figure(\n",
    "    data=[go.Scatter(y=[1, 3, 2], line=dict(color=\"gray\")) ],\n",
    "    layout=dict(title=dict(text=\"My Chart\"))\n",
    ")\n",
    "fig.show('notebook')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import plotly.graph_objects as go\n",
    "fig = go.Figure(\n",
    "    data=[go.Scatter(y=[1, 3, 2], line={'color':'gray'}) ],\n",
    "    layout={'title': {'text':'My Chart'}}\n",
    ")\n",
    "fig.show('notebook')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Magic Underscore Notation - for dictionaries nested in dictionaries.\n",
    "\n",
    "If you're creating a dictionary just to have one value in it, you can simplify it in this graph library with this new syntax. Take the names of the keys of all the dictionaries you are setting and combine them into one key, with an underscore.\n",
    "```\n",
    "something = {'key1': \n",
    "    {\"key2\" : \"banana\"}\n",
    "} \n",
    "```\n",
    "Can be rewritten as...\n",
    "\n",
    "```\n",
    "something_key1_key2 = \"banana\"\n",
    "```\n",
    "\n",
    "So in the above graph, you would replace...\n",
    "\n",
    "```\n",
    "line={'color':'gray'}) ],\n",
    "layout={'title': {'text':'My Chart'}}\n",
    "```\n",
    "With:\n",
    "```\n",
    "line_color'gray'\n",
    "layout_title_text=\"My Chart\"\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Updating Graphs.\n",
    "\n",
    "### Update methods: when you want to change a 'Trace' (line, graph, element, anything) AFTER YOU CREATED IT.\n",
    "\n",
    "### First without updates, let's create two subplots, each consisting of two layers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here we create a graph:\n",
    "\n",
    "import plotly.graph_objects as go\n",
    "from plotly.subplots import make_subplots\n",
    "\n",
    "# Subplots:\n",
    "\n",
    "fig = make_subplots(rows=1, cols=2, subplot_titles=[\"Banana\", \"Plum\"])\n",
    "\n",
    "# Left:\n",
    "\n",
    "fig.add_scatter(y=[4, 2, 3.5], mode=\"markers\",\n",
    "                marker=dict(size=20, color=\"Purple\"),\n",
    "                name=\"a\", row=1, col=1)\n",
    "\n",
    "fig.add_bar(y=[2, 1, 3],\n",
    "            marker=dict(color=\"Yellow\"),\n",
    "            name=\"b\", row=1, col=1)\n",
    "\n",
    "# Right:\n",
    "\n",
    "fig.add_scatter(y=[2, 3.5, 4], mode=\"markers\",\n",
    "                marker=dict(size=20, color=\"Yellow\"),\n",
    "                name=\"c\", row=1, col=2)\n",
    "\n",
    "fig.add_bar(y=[1, 3, 2],\n",
    "            marker=dict(color=\"Purple\"),\n",
    "            name=\"d\", row=1, col=2)\n",
    "fig.show('notebook')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### UPDATE METHODS:\n",
    "\n",
    "Update attributes of the layout, e.g change title of the figure:\n",
    "\n",
    "``` \n",
    "fig.update_layout( title_text=\"Yay!\"  )\n",
    "``` \n",
    "\n",
    "Update attributes of the traces (graphs, lines, etc), e.g. update all charts to BLUE color:\n",
    "\n",
    "``` \n",
    "fig.update_traces( marker_color=\"Blue\" )\n",
    "``` \n",
    "\n",
    "Additionally you can change qualities of ONLY SOME SELECTED traces. For that you need to use a **SELECTOR** - it will specify which traces should be affected, e.g. update only bar charts to RED colour:\n",
    "\n",
    "``` \n",
    "fig.update_traces(marker_color=\"Red\",\n",
    "                  selector=dict(type=\"bar\"))\n",
    "```\n",
    "                  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now the above code with updates:\n",
    "\n",
    "import plotly.graph_objects as go\n",
    "from plotly.subplots import make_subplots\n",
    "\n",
    "# Same as above:\n",
    "\n",
    "fig = make_subplots(rows=1, cols=2, subplot_titles=[\"Banana\", \"Plum\"])\n",
    "fig.add_scatter(y=[4, 2, 3.5], mode=\"markers\",\n",
    "                marker=dict(size=20, color=\"Purple\"),\n",
    "                name=\"a\", row=1, col=1)\n",
    "fig.add_bar(y=[2, 1, 3],\n",
    "            marker=dict(color=\"Yellow\"),\n",
    "            name=\"b\", row=1, col=1)\n",
    "fig.add_scatter(y=[2, 3.5, 4], mode=\"markers\",\n",
    "                marker=dict(size=20, color=\"Yellow\"),\n",
    "                name=\"c\", row=1, col=2)\n",
    "fig.add_bar(y=[1, 3, 2],\n",
    "            marker=dict(color=\"Purple\"),\n",
    "            name=\"d\", row=1, col=2)\n",
    "\n",
    "# Editing graphs after creation:\n",
    "# With update layout, you don't need to add 'layout_ at' the beginning of your keys.\n",
    "\n",
    "fig.update_layout(title_text=\"Big title on top!\",\n",
    "                  title_font_size=30)\n",
    "\n",
    "# Make all markers blue:\n",
    "\n",
    "fig.update_traces( marker_color=\"Blue\" )\n",
    "\n",
    "# Then make all bar markers red:\n",
    "\n",
    "fig.update_traces(marker_color=\"Red\",\n",
    "                  selector=dict(type=\"bar\"))\n",
    "\n",
    "# Then make all bar markers red:\n",
    "\n",
    "fig.update_traces(marker_color=\"Red\",\n",
    "                  selector=dict(type=\"bar\"))\n",
    "\n",
    "# You could also do something like...\n",
    "# 'selector=dict(marker_color=\"Purple\")'\n",
    "\n",
    "\n",
    "fig.show('notebook')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also:\n",
    "\n",
    "- Use ```col``` and ```row``` to specify rows and columns to do your updates:\n",
    "\n",
    "```selector=dict(marker_color=\"Purple\"), col=1```\n",
    "\n",
    "- Be quite specific with selectors and specify number of qualities:\n",
    "\n",
    "```selector=dict(marker_color=\"Purple\", type=\"bar\" )```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# More detailed selectors with updates:\n",
    "\n",
    "import plotly.graph_objects as go\n",
    "from plotly.subplots import make_subplots\n",
    "\n",
    "# Same as above:\n",
    "\n",
    "fig = make_subplots(rows=1, cols=2, subplot_titles=[\"Banana\", \"Plum\"])\n",
    "fig.add_scatter(y=[4, 2, 3.5], mode=\"markers\",\n",
    "                marker=dict(size=20, color=\"Purple\"),\n",
    "                name=\"a\", row=1, col=1)\n",
    "fig.add_bar(y=[2, 1, 3],\n",
    "            marker=dict(color=\"Yellow\"),\n",
    "            name=\"b\", row=1, col=1)\n",
    "fig.add_scatter(y=[2, 3.5, 4], mode=\"markers\",\n",
    "                marker=dict(size=20, color=\"Yellow\"),\n",
    "                name=\"c\", row=1, col=2)\n",
    "fig.add_bar(y=[1, 3, 2],\n",
    "            marker=dict(color=\"Purple\"),\n",
    "            name=\"d\", row=1, col=2)\n",
    "\n",
    "# Editing graphs after creation:\n",
    "# Select  markers in columnn 1 which are Purple ---> and make them Black:\n",
    "\n",
    "fig.update_traces( marker_color=\"Black\", selector=dict(marker_color=\"Purple\"), col=1 )\n",
    "\n",
    "# Select markers that are bars and are Purple ---> and make them Black:\n",
    "\n",
    "fig.update_traces( marker_color=\"Orange\", selector=dict(marker_color=\"Purple\", type=\"bar\" ) )\n",
    "\n",
    "\n",
    "fig.show('notebook')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Update Axes.\n",
    "\n",
    "There are also methods for updating x and y axes:\n",
    "\n",
    "- 'nticks' is number of ticks.\n",
    "- 'tick0' is the first tick.\n",
    "- 'tickd' is distance between ticks.\n",
    "- 'tickls=\"inside\"' places ticks in a position."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import plotly.express as px\n",
    "iris = px.data.iris()\n",
    "fig = px.scatter(iris, x=\"sepal_width\", y=\"sepal_length\", color=\"species\", facet_col=\"species\")\n",
    "fig.update_xaxes(showgrid=False, nticks=5)\n",
    "fig.update_yaxes(ticks=\"inside\", col=1, tick0=0.25, dtick=0.5)\n",
    "fig.show('notebook')\n",
    "\n",
    "### You can also use object 'dot .' notation and assignment to change figures."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import plotly.express as px\n",
    "iris = px.data.iris()\n",
    "fig = px.scatter(iris, x=\"sepal_width\", y=\"sepal_length\", color=\"species\", facet_col=\"species\")\n",
    "fig.layout.title.text = \"Three charts!\"\n",
    "fig.data[0].marker.line.width = 2\n",
    "fig.data[0].marker.line.color = \"black\"\n",
    "fig.data[1].marker.line.width = 3\n",
    "fig.data[1].marker.line.color = \"yellow\"\n",
    "fig.show('notebook')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Examples of different graph types.\n",
    "\n",
    "### Advanced features of a 'Scatter Plot':"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import plotly.express as px\n",
    "iris = px.data.iris()\n",
    "fig = px.scatter(iris, x=\"sepal_width\", y=\"sepal_length\", color=\"species\", marginal_y=\"violin\",\n",
    "           marginal_x=\"box\", trendline=\"ols\")\n",
    "fig.show('notebook')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import plotly.express as px\n",
    "iris = px.data.iris()\n",
    "iris[\"e\"] = iris[\"sepal_width\"]/100\n",
    "fig = px.scatter(iris, x=\"sepal_width\", y=\"sepal_length\", color=\"species\", error_x=\"e\", error_y=\"e\")\n",
    "fig.show('notebook')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# For easier eyeballing of your data, you can use scatter matrix:\n",
    "\n",
    "import plotly.express as px\n",
    "iris = px.data.iris()\n",
    "fig = px.scatter_matrix(iris, dimensions=[\"sepal_width\", \"sepal_length\", \"petal_width\", \"petal_length\"], \n",
    "                        color=\"species\")\n",
    "fig.show('notebook')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here we're using a different data set: bills and tips in a restaurant - 'px.data.tips()':\n",
    "\n",
    "import plotly.express as px\n",
    "tips = px.data.tips()\n",
    "fig = px.scatter(tips, x=\"total_bill\", y=\"tip\", facet_row=\"time\", facet_col=\"day\", color=\"smoker\",\n",
    "                 trendline=\"ols\",\n",
    "          category_orders={\"day\": [\"Thur\", \"Fri\", \"Sat\", \"Sun\"], \"time\": [\"Lunch\", \"Dinner\"]})\n",
    "fig.show('notebook')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parallel coordinates:\n",
    "\n",
    "import plotly.express as px\n",
    "iris = px.data.iris()\n",
    "fig = px.parallel_coordinates(iris, color=\"species_id\", labels={\"species_id\": \"Species\",\n",
    "                  \"sepal_width\": \"Sepal Width\", \"sepal_length\": \"Sepal Length\",\n",
    "                  \"petal_width\": \"Petal Width\", \"petal_length\": \"Petal Length\", },\n",
    "                    color_continuous_scale=px.colors.diverging.Tealrose, color_continuous_midpoint=2)\n",
    "fig.show('notebook')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tips = px.data.tips()\n",
    "fig = px.parallel_categories(tips, color=\"size\", color_continuous_scale=px.colors.sequential.Inferno)\n",
    "fig.show()\n",
    "\n",
    "import plotly.express as px\n",
    "tips = px.data.tips()\n",
    "fig = px.scatter(tips, x=\"total_bill\", y=\"tip\", color=\"size\", facet_col=\"sex\",\n",
    "           color_continuous_scale=px.colors.sequential.Viridis, render_mode=\"webgl\")\n",
    "fig.show('notebook')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import plotly.express as px\n",
    "gapminder = px.data.gapminder()\n",
    "fig = px.scatter(gapminder.query(\"year==2007\"), x=\"gdpPercap\", y=\"lifeExp\", size=\"pop\", color=\"continent\",\n",
    "           hover_name=\"country\", log_x=True, size_max=60)\n",
    "fig.show('notebook')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interactive Graphs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can animate it yourself, or press play:\n",
    "\n",
    "import plotly.express as px\n",
    "gapminder = px.data.gapminder()\n",
    "fig = px.scatter(gapminder, x=\"gdpPercap\", y=\"lifeExp\", animation_frame=\"year\", animation_group=\"country\",\n",
    "           size=\"pop\", color=\"continent\", hover_name=\"country\", facet_col=\"continent\",\n",
    "           log_x=True, size_max=45, range_x=[100,100000], range_y=[25,90])\n",
    "fig.show('notebook')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import plotly.express as px\n",
    "gapminder = px.data.gapminder()\n",
    "fig = px.scatter(gapminder, x=\"gdpPercap\", y=\"lifeExp\", animation_frame=\"year\", animation_group=\"country\",\n",
    "           size=\"pop\", color=\"continent\", hover_name=\"country\", facet_col=\"continent\",\n",
    "           log_x=True, size_max=45, range_x=[100,100000], range_y=[25,90])\n",
    "fig.show('notebook')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import plotly.express as px\n",
    "election = px.data.election()\n",
    "fig = px.scatter_3d(election, x=\"Joly\", y=\"Coderre\", z=\"Bergeron\", color=\"winner\", size=\"total\", \n",
    "                    hover_name=\"district\",\n",
    "                  symbol=\"result\", color_discrete_map = {\"Joly\": \"blue\", \"Bergeron\": \"green\", \"Coderre\":\"red\"})\n",
    "fig.show('notebook')\n",
    "\n",
    "# You can interact with it with your mouse!!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import plotly.express as px\n",
    "wind = px.data.wind()\n",
    "fig = px.bar_polar(wind, r=\"frequency\", theta=\"direction\", color=\"strength\", template=\"plotly_dark\",\n",
    "            color_discrete_sequence= px.colors.sequential.Plasma[-2::-1])\n",
    "fig.show('notebook')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import plotly.express as px\n",
    "gapminder = px.data.gapminder()\n",
    "fig = px.line_geo(gapminder.query(\"year==2007\"), locations=\"iso_alpha\", color=\"continent\", \n",
    "                  projection=\"orthographic\")\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import plotly.express as px\n",
    "gapminder = px.data.gapminder()\n",
    "fig = px.choropleth(gapminder, locations=\"iso_alpha\", color=\"lifeExp\", hover_name=\"country\", \n",
    "                    animation_frame=\"year\", range_color=[20,80])\n",
    "fig.show('notebook')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For the extra curious here's another plotting library - 'matplotlib.pyplot'.\n",
    "\n",
    "### Stacked Bar Graph.\n",
    "\n",
    "This is an example of creating a stacked bar plot with error bars\n",
    "using ```~matplotlib.pyplot.bar```.  Note, the parameters *yerr* used for\n",
    "error bars, and *bottom* to stack the women's bars on top of the men's\n",
    "bars.\n",
    "\n",
    "To create stacked graphs, we create the bottom graph first, then add other graphs to it with a gap underneath them (see 'bottom' attribute).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "N = 5\n",
    "menMeans = (20, 35, 30, 35, 27)\n",
    "womenMeans = (25, 32, 34, 20, 25)\n",
    "menStd = (2, 3, 4, 1, 2)\n",
    "womenStd = (3, 5, 2, 3, 3)\n",
    "ind = np.arange(N)    # The x locations for the groups.\n",
    "width = 0.35       # The width of the bars: can also be len(x) sequence.\n",
    "\n",
    "p1 = plt.bar(ind, menMeans, width, yerr=menStd)\n",
    "p2 = plt.bar(ind, womenMeans, width,\n",
    "             bottom=menMeans, yerr=womenStd)\n",
    "\n",
    "plt.ylabel('Scores')\n",
    "plt.title('Scores by group and gender')\n",
    "plt.xticks(ind, ('G1', 'G2', 'G3', 'G4', 'G5'))\n",
    "plt.yticks(np.arange(0, 81, 10))\n",
    "plt.legend((p1[0], p2[0]), ('Men', 'Women'))\n",
    "\n",
    "fig.show('notebook')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Another graph library - 'Matplotlib'.\n",
    "\n",
    "### At times it is a bit easier to use, have a look:\n",
    "\n",
    "https://matplotlib.org/stable/gallery/index.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "np.random.seed(0)\n",
    "\n",
    "mu = 200\n",
    "sigma = 25\n",
    "x = np.random.normal(mu, sigma, size=100)\n",
    "\n",
    "fig, (ax0, ax1) = plt.subplots(ncols=2, figsize=(8, 4))\n",
    "\n",
    "\n",
    "ax0.hist(x, 20, histtype='stepfilled', facecolor='g', alpha=0.75)\n",
    "ax0.set_title('stepfilled')\n",
    "\n",
    "# Create a histogram by providing the bin edges (unequally spaced).\n",
    "\n",
    "bins = [100, 150, 180, 195, 205, 220, 250, 300]\n",
    "ax1.hist(x, bins, histtype='bar', rwidth=0.8)\n",
    "ax1.set_title('unequal bins')\n",
    "\n",
    "fig.tight_layout()\n",
    "fig.show('notebook')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "vegetables = [\"cucumber\", \"tomato\", \"lettuce\", \"asparagus\",\n",
    "              \"potato\", \"wheat\", \"barley\"]\n",
    "farmers = [\"Farmer Joe\", \"Upland Bros.\", \"Smith Gardening\",\n",
    "           \"Agrifun\", \"Organiculture\", \"BioGoods Ltd.\", \"Cornylee Corp.\"]\n",
    "\n",
    "harvest = np.array([[0.8, 2.4, 2.5, 3.9, 0.0, 4.0, 0.0],\n",
    "                    [2.4, 0.0, 4.0, 1.0, 2.7, 0.0, 0.0],\n",
    "                    [1.1, 2.4, 0.8, 4.3, 1.9, 4.4, 0.0],\n",
    "                    [0.6, 0.0, 0.3, 0.0, 3.1, 0.0, 0.0],\n",
    "                    [0.7, 1.7, 0.6, 2.6, 2.2, 6.2, 0.0],\n",
    "                    [1.3, 1.2, 0.0, 0.0, 0.0, 3.2, 5.1],\n",
    "                    [0.1, 2.0, 0.0, 1.4, 0.0, 1.9, 6.3]])\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "im = ax.imshow(harvest)\n",
    "\n",
    "# We want to show all ticks...\n",
    "\n",
    "ax.set_xticks(np.arange(len(farmers)))\n",
    "ax.set_yticks(np.arange(len(vegetables)))\n",
    "\n",
    "# ... and label them with the respective list entries\n",
    "\n",
    "ax.set_xticklabels(farmers)\n",
    "ax.set_yticklabels(vegetables)\n",
    "\n",
    "# Rotate the tick labels and set their alignment.\n",
    "\n",
    "plt.setp(ax.get_xticklabels(), rotation=45, ha=\"right\",\n",
    "         rotation_mode=\"anchor\")\n",
    "\n",
    "# Loop over data dimensions and create text annotations.\n",
    "\n",
    "for i in range(len(vegetables)):\n",
    "    for j in range(len(farmers)):\n",
    "        text = ax.text(j, i, harvest[i, j],\n",
    "                       ha=\"center\", va=\"center\", color=\"w\")\n",
    "\n",
    "ax.set_title(\"Harvest of local farmers (in tons/year)\")\n",
    "fig.tight_layout()\n",
    "fig.show('notebook')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}