python-data/exercises/ex05_matplotlib.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e2574b49-2028-4bdf-a012-60d339dca6ac",
   "metadata": {},
   "source": [
    "# Exercise 5: matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c39c2af-dc7c-4905-8535-f7280c4e9a37",
   "metadata": {},
   "source": [
    "## Aim: Get to grips with how to create plots and customise them with matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "315d3123-78fd-44b4-874b-5638d478d112",
   "metadata": {},
   "source": [
    "Find the teaching resources here: https://matplotlib.org/stable/users/explain/quick_start.html"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10599a64-226b-4789-89c1-093f0564bedf",
   "metadata": {},
   "source": [
    "### Issues covered:\n",
    "\n",
    "- Creating plots\n",
    "- Parts of a figure\n",
    "- Styling the colours, linestyles, linewidths, markersizes etc\n",
    "- Labelling plots: axis labels, titles, annotations and legends\n",
    "- Axes properties: scales, ticks, plotting dates and strings\n",
    "- Multiple figures, multiple axes,\n",
    "- Colour-mapped data: colormaps, colorbars, normalizations"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3612836-233d-479f-a2a8-e7ed99dc1133",
   "metadata": {},
   "source": [
    "## Simple example"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6bc7192f-0962-4168-b6c6-5fd44daa24b2",
   "metadata": {},
   "source": [
    "Q1. Let's create some sample data to plot. Create an array called `xaxis` with the value `[1,2,3,4,5]` and an array called `yaxis` with the value `[2, 16, 4, 8, 7]`. Plot this data on a single axes. Don't forget to import matplotlib!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "df631937-9c0c-4453-80f0-c44da68ac71a",
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2024-11-08T14:55:44.502584Z",
     "iopub.status.busy": "2024-11-08T14:55:44.502263Z",
     "iopub.status.idle": "2024-11-08T14:55:46.365779Z",
     "shell.execute_reply": "2024-11-08T14:55:46.365119Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "clear_answer_cell"
    ]
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "5a84dc80-d94a-4440-8806-c51a2fbf9077",
   "metadata": {},
   "source": [
    "## Parts of a figure"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9cfacc0a-5af7-4912-b79e-0ac0743e20e5",
   "metadata": {},
   "source": [
    "Q2. Create 6 empty plots in a 2x3 grid."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "71cd4946-e8bd-40b0-9d21-c7a6fedb11bd",
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2024-11-08T14:55:46.368639Z",
     "iopub.status.busy": "2024-11-08T14:55:46.368283Z",
     "iopub.status.idle": "2024-11-08T14:55:46.910842Z",
     "shell.execute_reply": "2024-11-08T14:55:46.910332Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "clear_answer_cell"
    ]
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f2e84578-b714-46db-b276-9e11029552dc",
   "metadata": {},
   "source": [
    "## Types of inputs to plotting functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97d9019c-750c-4a23-b023-2c9ed472f154",
   "metadata": {},
   "source": [
    "Q3. Some inputs won't work as intended. Run the following cell to create a pandas dataframe:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d2a59056-927b-4f16-b0b0-6ce0f0262fd4",
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2024-11-08T14:55:46.913475Z",
     "iopub.status.busy": "2024-11-08T14:55:46.913187Z",
     "iopub.status.idle": "2024-11-08T14:55:48.226287Z",
     "shell.execute_reply": "2024-11-08T14:55:48.225657Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "df = pd.DataFrame({\n",
    "    'A': [1, 2, 3, 4],\n",
    "    'B': [4, 5, 6, 7],\n",
    "    'C': ['a', 'b', 'c', 'd']\n",
    "})"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5b75a4b-7810-4b08-8b3c-f1f2c3bb75d9",
   "metadata": {},
   "source": [
    "Try plotting the dataframe directly. Do you know why there is an error?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e15026a5-a78f-4033-bc80-017e539f7d64",
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2024-11-08T14:55:48.229435Z",
     "iopub.status.busy": "2024-11-08T14:55:48.229042Z",
     "iopub.status.idle": "2024-11-08T14:55:49.609311Z",
     "shell.execute_reply": "2024-11-08T14:55:49.608644Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "clear_answer_cell",
     "allow_errors"
    ]
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "8d0a5420-bd47-4771-aebb-125ab192f458",
   "metadata": {},
   "source": [
    "Q4. We need to extract only the numeric values to plot. Let's extract them as a numpy array and try again. Use `np.asarray(df[['A', 'B']])` to create a numpy array from the numeric data. Try plotting it now."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "58bf6119-5e1a-45af-8e3a-03ed80d381a5",
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2024-11-08T14:55:49.611989Z",
     "iopub.status.busy": "2024-11-08T14:55:49.611712Z",
     "iopub.status.idle": "2024-11-08T14:55:49.772084Z",
     "shell.execute_reply": "2024-11-08T14:55:49.771535Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "clear_answer_cell"
    ]
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "43bcbb06-d568-4091-a7a3-1e6ab4db0358",
   "metadata": {},
   "source": [
    "Q5. Let's unpack the example given in the tutorial of using matplotlib with string-indexable objects. Instead of passing numpy arrays directly, we'll pass the names of the variables as strings.\n",
    "\n",
    "\n",
    "Run the following cell to create a dictionary where `a` is a numpy array of integers from 0 to 49, `c` is random integers between 0 and 50 we can use as the colour, and `d` is the absolute value of randomly generated numbers which we will use as the size of each scatter point. Then `b` is set to a noisy version of `a`. Finally, `d` is scaled to be larger."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "734cb070-a7d1-425a-ba47-cd3d64bc8882",
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2024-11-08T14:55:49.774679Z",
     "iopub.status.busy": "2024-11-08T14:55:49.774396Z",
     "iopub.status.idle": "2024-11-08T14:55:49.778904Z",
     "shell.execute_reply": "2024-11-08T14:55:49.778398Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Step 1: Create the dictionary\n",
    "data = {'a': np.arange(50),\n",
    "        'c': np.random.randint(0, 50, 50),\n",
    "        'd': np.random.randn(50)}\n",
    "# Step 2: Add b - the noisy version of a, and scale d to be bigger\n",
    "data['b'] = data['a'] + 10 * np.random.randn(50)\n",
    "data['d'] = np.abs(data['d']) * 100"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6e0aaa3-a75b-4493-8828-67ea004480a2",
   "metadata": {},
   "source": [
    "Now we can plot the scatter plot using the syntax `ax.scatter(xvalues, yvalues, c=colours, s=scatter_point_size, data=data)`. Hint: the x and y data is 'a' and 'b' and you should know what the colour and size is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e0bb152c-7a3e-4cfa-9dce-49e19ed62d81",
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2024-11-08T14:55:49.781816Z",
     "iopub.status.busy": "2024-11-08T14:55:49.781290Z",
     "iopub.status.idle": "2024-11-08T14:55:49.935648Z",
     "shell.execute_reply": "2024-11-08T14:55:49.935110Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "clear_answer_cell"
    ]
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b057c40a-511b-43ba-840a-bae423a697e9",
   "metadata": {},
   "source": [
    "## Coding styles"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce3d4439-773f-4a61-8556-9967942f7300",
   "metadata": {},
   "source": [
    "Q6. So far, we've been creating plots in the object oriented way: explicitly creating figures and axes. The pyplot-style is very subtly different - we just don't need to create the axis or subplots.\n",
    "- Create x axis data using `np.linspace(min, max, num)`. Create 10 values between 0 and 10.\n",
    "- Create y axis data using `np.linspace` to create 10 values between 0 and 100.\n",
    "- Plot this data on the implicit axes using `plt.plot()` - don't worry about seeting the figsize and layout."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "3467e2c1-ab23-43ac-9bf0-3b34852d87f5",
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2024-11-08T14:55:49.938331Z",
     "iopub.status.busy": "2024-11-08T14:55:49.938015Z",
     "iopub.status.idle": "2024-11-08T14:55:50.089870Z",
     "shell.execute_reply": "2024-11-08T14:55:50.089123Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "clear_answer_cell"
    ]
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "8f6ba121-ea31-441c-8ac6-83ad85605684",
   "metadata": {},
   "source": [
    "## Styling"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d18ed69-464a-4f6f-af12-4b43de5fb010",
   "metadata": {},
   "source": [
    "Q7. Let's use the x and y values from before and create some new y values to practice styling plots.\n",
    "- Create `y2 = np.linspace(0, -100, 10)`.\n",
    "- Plot both of these sets of data on the same axes using the [Styling Artists example](https://matplotlib.org/stable/users/explain/quick_start.html#styling-artists).\n",
    "- Plot the original y data in purple with the `--` linestyle and the new y data in green with the `:` linestyle.\n",
    "- What other values can you give for linestyle? Try editing them to be any character you want and see what happens! Can you make the lines thicker?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "30c1faed-af70-4784-9c82-0c6758d2083a",
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2024-11-08T14:55:50.092794Z",
     "iopub.status.busy": "2024-11-08T14:55:50.092463Z",
     "iopub.status.idle": "2024-11-08T14:55:50.245875Z",
     "shell.execute_reply": "2024-11-08T14:55:50.245318Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "clear_answer_cell"
    ]
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "d3bba7b2-208b-4927-a246-b1ff18cadbf9",
   "metadata": {},
   "source": [
    "Q8. There are lots of different customisation options in matplotlib for colour! You can even have different colours for the markers and outlines in a scatter plot. Use the following to generate some data for a scatter plot:\n",
    "```\n",
    "data1, data2 = np.random.randn(2,100)\n",
    "```\n",
    "Plot this data as an `ax.scatter` plot, using a magenta outline with a green marker. Hint: you'll need to visit the [allowable color definitions](https://matplotlib.org/stable/users/explain/colors/colors.html#colors-def) page to see how colours are defined."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "0746263b-80fb-4e68-a215-34872daff4f8",
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2024-11-08T14:55:50.248847Z",
     "iopub.status.busy": "2024-11-08T14:55:50.248580Z",
     "iopub.status.idle": "2024-11-08T14:55:50.392506Z",
     "shell.execute_reply": "2024-11-08T14:55:50.392014Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "clear_answer_cell"
    ]
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "e1308dc3-fc3c-4a49-a762-3fdb0a54eff4",
   "metadata": {},
   "source": [
    "Q9. Generate two more scatter plot datasets as we did above then plot all 4 on one graph. Give each dataset a label and a different marker style - e.g. stars (`*`), plus (`P`) or diamonds (`D`). You can see more options for markers [in the documentation](https://matplotlib.org/stable/gallery/lines_bars_and_markers/marker_reference.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "0658cc3b-c291-404a-b446-a388edfef3d4",
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2024-11-08T14:55:50.394985Z",
     "iopub.status.busy": "2024-11-08T14:55:50.394725Z",
     "iopub.status.idle": "2024-11-08T14:55:50.547987Z",
     "shell.execute_reply": "2024-11-08T14:55:50.547463Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "clear_answer_cell"
    ]
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "007ed496-b9c6-4c28-84b3-fa72264bb9e4",
   "metadata": {},
   "source": [
    "## Labelling"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a912305e-861a-428b-8223-9d245004baf7",
   "metadata": {},
   "source": [
    "Q10. Take the plot we just created in the previous question and give it `xlabel`, `ylabel` and a `title` of your choice. Add some text to the plot saying `some text` at `50, 0`. Add an annotation at top saying `some annotation` with a black arrow pointing to some data using `xy=(40,2)` and `xytext=(3,1.5)`. Also add a legend identifying each data set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "2de354bb-2ef6-4c1a-a7d4-ec408a0e444e",
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2024-11-08T14:55:50.550870Z",
     "iopub.status.busy": "2024-11-08T14:55:50.550603Z",
     "iopub.status.idle": "2024-11-08T14:55:50.975569Z",
     "shell.execute_reply": "2024-11-08T14:55:50.975074Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "clear_answer_cell"
    ]
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "59e3abfd-3389-4ee9-87be-029af1fce401",
   "metadata": {},
   "source": [
    "## Axes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27c4fc57-9ca3-442b-a62b-469a5f7d73c5",
   "metadata": {},
   "source": [
    "Q11. Let's practice plotting some log scale data.\n",
    "- Create the xdata using `xdata = np.arange(5)`.\n",
    "- Create the ydata using `ydata = np.array([0.1, 0.5, 1, 5, 10])`.\n",
    "- Transform the y data by raising it to the power of 10 using `ydata = 10**ydata`.\n",
    "- Plot two suplots - plot the x and y data in both plots. Set the y-axis of the second subplot to a logairthmic scale.\n",
    "- Try experimenting with different datasets by changing the values in ydata. Try changing the base of the log scale - e.g. using `base=2`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "8749ab24-0c45-4935-90e2-3df1186cf611",
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2024-11-08T14:55:50.978562Z",
     "iopub.status.busy": "2024-11-08T14:55:50.978294Z",
     "iopub.status.idle": "2024-11-08T14:55:51.374280Z",
     "shell.execute_reply": "2024-11-08T14:55:51.373658Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "clear_answer_cell"
    ]
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "447fc1f2-81e1-4034-bbcb-b00d57ab88b3",
   "metadata": {},
   "source": [
    "Q12. To demonstrate the difference between automatic and manual ticks, let's create two subplots. Follow the following steps:\n",
    "\n",
    "- Create some data using `xdata = np.linspace(0, 99, 100)`, and `ydata = np.sin(xdata / 10)`\n",
    "- Create a figure with 2 subplots arranged vertically.\n",
    "- For the first subplot, plot the data and allow matplotlib to automatically place the ticks on the y and x axes\n",
    "- For the second subplot, manually set the x-axis ticks at intervals of 30 using `np.arange(0,100,30)`, provide custom labels for these x-ticks using `('zero', '30', 'sixty', '90')` and manually set the yaxis ticks at `[-1.5, 0, 1.5]` without specifying labels so that default labels are used.\n",
    "- Add titles to both subplots to distinguish between automatic and manual ticks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "886e54a6-54e6-47fd-bec2-74c1eded9274",
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2024-11-08T14:55:51.376817Z",
     "iopub.status.busy": "2024-11-08T14:55:51.376549Z",
     "iopub.status.idle": "2024-11-08T14:55:51.759482Z",
     "shell.execute_reply": "2024-11-08T14:55:51.758935Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "clear_answer_cell"
    ]
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "ecc8e915-c9ad-44a3-9964-2d047516a3bb",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Q13. Let's see how matplotlib handles plotting dates. We'll create a time series plot using an array of dates and random cumulative data:\n",
    "- Run the following cell to generate a numpy array of dates starting from `2022-01-01` to `2022-01-10` at intervals of 3 hours then create a cumulative sum of random numbers for the same length of the array of dates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "0d9bfaa3-723b-4e77-a109-5754e231527c",
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2024-11-08T14:55:51.762161Z",
     "iopub.status.busy": "2024-11-08T14:55:51.761888Z",
     "iopub.status.idle": "2024-11-08T14:55:51.765450Z",
     "shell.execute_reply": "2024-11-08T14:55:51.764965Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Step 1: Generate the numpy dates\n",
    "dates = np.arange(np.datetime64('2022-01-01'), np.datetime64('2022-01-10'), np.timedelta64(3, 'h'))\n",
    "\n",
    "# Step 2: Create the cumulative sum\n",
    "data = np.cumsum(np.random.randn(len(dates)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19cd7611-93d3-4b18-813e-fd0ac144e115",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "- Plot the data with the dates on the x axis and `data` on the y axis.\n",
    "- Take a look at the dates if we don't format the axis - do they look all bunched up?\n",
    "- Format the x-axis with `ConciseDateFormatter` for better readability of the date ticks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "b44349e4-73cd-450f-b61e-304fb727b80b",
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2024-11-08T14:55:51.767596Z",
     "iopub.status.busy": "2024-11-08T14:55:51.767361Z",
     "iopub.status.idle": "2024-11-08T14:55:52.044766Z",
     "shell.execute_reply": "2024-11-08T14:55:52.044268Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "clear_answer_cell"
    ]
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "0f022a40-f65d-4649-a63e-bcdbd4cdf4a1",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Q14. Let's have a go at plotting some categorical data. We'll create a bar chart using a list of categories and random values:\n",
    "- Run the following cell to define a list of four fruit names `['apple', 'banana', 'cherry', 'date']` and generate random data for these categories."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "d78e6837-6fa3-41cd-bc4b-f897dc0935ec",
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2024-11-08T14:55:52.047329Z",
     "iopub.status.busy": "2024-11-08T14:55:52.047063Z",
     "iopub.status.idle": "2024-11-08T14:55:52.050131Z",
     "shell.execute_reply": "2024-11-08T14:55:52.049658Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Step 1: Define fruit list\n",
    "categories = ['apple', 'banana', 'cherry', 'date']\n",
    "\n",
    "# Step 2: Generate random data\n",
    "values = np.random.rand(len(categories))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56f95cac-6d0d-4635-b8ee-25728b2a7995",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Create a bar plot using these categories and their corresponding random values using `ax.bar()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "491a7449-45a9-4ef9-88a5-ab6d1244c3ca",
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2024-11-08T14:55:52.052449Z",
     "iopub.status.busy": "2024-11-08T14:55:52.052056Z",
     "iopub.status.idle": "2024-11-08T14:55:52.222108Z",
     "shell.execute_reply": "2024-11-08T14:55:52.221570Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "clear_answer_cell"
    ]
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "9d86f4d0-fd73-40b4-aa36-beb40ffbab10",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Q15. Let's create a plot that demonstrates the use of both a secondary y-axis and a secondary x-axis with different scales:\n",
    "- Run the following cell to generate a time series `t` ranging from 0 to 2π with 100 points and create two datasets: `s` for a sine wave and `l` for a linearly increasing dataset between 0 and the length of `t`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "3b550c94-f3c6-49e9-a336-af67c2bb5679",
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2024-11-08T14:55:52.224657Z",
     "iopub.status.busy": "2024-11-08T14:55:52.224400Z",
     "iopub.status.idle": "2024-11-08T14:55:52.227759Z",
     "shell.execute_reply": "2024-11-08T14:55:52.227277Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Step 1: Generate the time series\n",
    "t = np.linspace(0, 2 * np.pi, 100)\n",
    "\n",
    "# Step 2: Create the s and l datasets\n",
    "s = np.sin(t)\n",
    "l = np.arange(len(t))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ae2c7cf-12d0-404c-80b5-4e8c16111727",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "- Plot both datasets on the same figure\n",
    "    - On the first subplot plot the sine wave on the left y axis and the linear data on the right y axis using `twinx()`\n",
    "    - On the second subplot plot the sine wave with a secondary x axis that converts radians to degrees using `secondary_xaxis()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "eb48d19a-3a71-45f4-961f-73e529185796",
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2024-11-08T14:55:52.229862Z",
     "iopub.status.busy": "2024-11-08T14:55:52.229636Z",
     "iopub.status.idle": "2024-11-08T14:55:53.110273Z",
     "shell.execute_reply": "2024-11-08T14:55:53.109779Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "clear_answer_cell"
    ]
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "ef2b0027-33a2-4c69-8bff-fada5fcc0daa",
   "metadata": {
    "editable": true,
    "jupyter": {
     "source_hidden": true
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## Colour mapped data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a4d9f48-0dbc-4b5e-a54a-f440c6c9f46b",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Q16. Let's create a series of suplots to practice visualizing data with colormaps:\n",
    "- Run the following cell to generate x, y, and z data. Then generate 2 datsets to use for our scatter plot and a third dataset to use for the colors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "10d56aef-9a1d-406d-89ea-5fe657dbb932",
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2024-11-08T14:55:53.112929Z",
     "iopub.status.busy": "2024-11-08T14:55:53.112669Z",
     "iopub.status.idle": "2024-11-08T14:55:53.121109Z",
     "shell.execute_reply": "2024-11-08T14:55:53.120598Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Step 1: Generate x and y data\n",
    "x,y = np.meshgrid(np.linspace(-3, 3, 128), np.linspace(-3, 3, 128))\n",
    "\n",
    "# Step 2: Generate z data\n",
    "z = (1 - x/2 + x**5 + y**3) * np.exp(-x**2 - y**2)\n",
    "\n",
    "# Step 3: Create 3 datasets\n",
    "data1 = np.random.randn(100)\n",
    "data2 = np.random.randn(100)\n",
    "data3 = np.random.rand(100)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03263f96-ddd6-4cc6-beca-0f9abd222533",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "- Create 4 subplots in a 2x2 grid\n",
    "- First plot: use `pcolormesh()` to display z values with a colormap\n",
    "- Second plot: use `contourf()` to create a filled contour plot\n",
    "- Third plot: use `imshow()` with a logarithmic color scale (`LogNorm`) to represent the square of z values\n",
    "- Fourth plot: create a scatter plot where the colour of each point depends on that third datset we made\n",
    "- Add colorbars to each plot to indicate the mapping between data and colours"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "75e37d2d-a0cd-4694-a7dd-5f1c2fb8e468",
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2024-11-08T14:55:53.123288Z",
     "iopub.status.busy": "2024-11-08T14:55:53.123038Z",
     "iopub.status.idle": "2024-11-08T14:55:54.808669Z",
     "shell.execute_reply": "2024-11-08T14:55:54.808122Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "clear_answer_cell"
    ]
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "71a90323-7b93-4bda-b519-6a945e812e3a",
   "metadata": {},
   "source": [
    "## Multiple figures/axes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d431ef9-295d-4c21-b9ef-2f4b118b11c6",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Q17. Let's create a figure with multiple subplots using the `suplot_mosiac` method. Each subplot should have its own distinct data and be customized with titles, labels, and a legend. You will also need to manipulate different axes in a single figure and work with multiple figures in a single program:\n",
    "- Run the following cell to create data for the plots."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "cc1b0ee4-744b-4265-97c0-a6c71e8a4b1d",
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2024-11-08T14:55:54.812190Z",
     "iopub.status.busy": "2024-11-08T14:55:54.811895Z",
     "iopub.status.idle": "2024-11-08T14:55:54.816798Z",
     "shell.execute_reply": "2024-11-08T14:55:54.816065Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Step 1: Generate the data\n",
    "x = np.linspace(0,2 * np.pi, 100)\n",
    "y_sin = np.sin(x)\n",
    "y_cos = np.cos(x)\n",
    "categories = ['A', 'B', 'C']\n",
    "values = np.random.rand(len(categories))\n",
    "random_x = np.random.rand(50)\n",
    "random_y = np.random.rand(50)\n",
    "x_exp = np.arange(0, 10, 0.1)\n",
    "y_exp = np.exp(x_exp)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a60c1d9c-0546-47b6-9d65-7a13bbd5d6c7",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "- Create a figure using `plt.subplot_mosaic()` with the following layout: `[['top', 'top', 'right'], ['bottom-left', 'bottom-right', 'right']]` with the layout set to `constrained` so the figure is properly spaced\n",
    "- In the `top` subplot, plot `x` and `y_sin`. Label the plot and give it the color `blue`. Label the x and y axes and give a legend.\n",
    "- In the `bottom-left` subplot, plot `x` and `y_cos`. Label the plot and give it the color `orange`. Label the x and y axes and give a legend.\n",
    "- In the `bottom-right` subplot, plot `random_x` and `random_y`. Label the plot and give it the color `green`.Label the x and y axes.\n",
    "- In the `right` subplot, plot `categories` and `values` as a bar chart and give it the colors `['purple', 'red', 'yellow']`. Label the x and y axes.\n",
    "- Give appropriate titles to each subplot using `set_title()`\n",
    "- Create a new figure using `plt.figure()` and plot a simple line graph of exponential growth in a single subplot using `x_exp` and `y_exp`. Give the plot x and y axis labels, a title, and a legend.\n",
    "- Ensure both the mosaic figure and extra figure are displayed properly "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "3d3d277c-3440-484a-a9a4-69f1d0168ec4",
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2024-11-08T14:55:54.820377Z",
     "iopub.status.busy": "2024-11-08T14:55:54.819717Z",
     "iopub.status.idle": "2024-11-08T14:55:55.981606Z",
     "shell.execute_reply": "2024-11-08T14:55:55.980878Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "clear_answer_cell"
    ]
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 + Jaspy",
   "language": "python",
   "name": "jaspy"
  },
  "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.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}