visualize.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Data visualisation\n",
        "\n",
        "## Introduction\n",
        "\n",
        "> \"The simple graph has brought more information to the data analyst’s mind \n",
        "> than any other device.\" --- John Tukey\n",
        "\n",
        "This chapter will teach you how to visualise your data using Plotly Express. Python has several systems for making graphs, but Plotly is one of the most elegant and versatile. Plotly implements the __declarative visualization__ much like the __grammar of graphics__, a coherent system for describing and building graphs. With plotly, you can do more faster by learning one system and applying it in many places.\n",
        "\n",
        "If you'd like to learn more about Plotly before you start, I'd recommend reading [Guide to Create Interactive Plots with Plotly Python](https://www.analyticsvidhya.com/blog/2021/10/interactive-plots-in-python-with-plotly-a-complete-guide/).\n",
        "\n",
        "We should note that we are building this book using R with the package bookdown.  Rendering Plotly graphics using a python chunk is not straight forward but is not important for our use in VS Code. In VS Code the example chunks will render in the interactive Python viewer automatically. \n",
        "\n",
        "### Prerequisites\n",
        "\n",
        "This chapter focusses on Plotly. Language has been shifted using the material from [Plotly's materials](https://plotly.com/python/). To access the datasets, help pages, and functions that we will use in this chapter, load the Python data science tools by running this code:\n"
      ],
      "id": "c889a57d"
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "import plotly.express as px"
      ],
      "id": "82272fd3",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "If you run this code and get the error message \"No module named 'plotly'\" or \"No module named 'pandas'\", you'll need to first install them.\n",
        "\n",
        "\n",
        "```{bash eval = FALSE}\n",
        "python -m pip install pandas plotly.express\n",
        "```\n",
        "\n",
        "\n",
        "You only need to install a package once, but you need to reload it every time you start a new session.\n",
        "\n",
        "### Plotly data management\n",
        "\n",
        "When [specifying data in Plotly](https://plotly.com/python/px-arguments/), we can use pandas DataFrame objects or other Plotly options. According to the [Plotly documentation](https://plotly.com/python/pandas-backend/), the use of a pandas DataFrame or Series. This means you can now produce interactive plots directly from a data frame, without even needing to import Plotly.\n",
        "\n",
        "In this book, we will render the Plotly charts in the Quarto '.qmd' files to '.html' files. \n",
        "\n",
        "## First steps\n",
        "\n",
        "Let's use our first graph to answer a question: Do cars with big engines use more fuel than cars with small engines? You probably already have an answer, but try to make your answer precise. What does the relationship between engine size and fuel efficiency look like? Is it positive? Negative? Linear? Nonlinear?\n",
        "\n",
        "### The `mpg` data frame\n",
        "\n",
        "You can test your answer with the `mpg` __data frame__ found in ggplot2 (aka  `ggplot2::mpg`). A data frame is a rectangular collection of variables (in the columns) and observations (in the rows). The *'mpg'* data contains observations collected by the US Environmental Protection Agency on 38 models of car. We will identify the *'mpg'* data using `mpg` for the remainder of this introduction.\n"
      ],
      "id": "1511c837"
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "url = \"https://github.com/byuidatascience/data4python4ds/raw/master/data-raw/mpg/mpg.csv\"\n",
        "mpg = pd.read_csv(url)"
      ],
      "id": "b217c4e4",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Among the variables in `mpg` are:\n",
        "\n",
        "1. `displ`, a car's engine size, in litres.\n",
        "\n",
        "1. `hwy`, a car's fuel efficiency on the highway, in miles per gallon (mpg). \n",
        "  A car with a low fuel efficiency consumes more fuel than a car with a high \n",
        "  fuel efficiency when they travel the same distance. \n",
        "\n",
        "To learn more about `mpg`, read its format at [data4python4ds](https://github.com/byuidatascience/data4python4ds/blob/master/data.md).\n",
        "\n",
        "### Creating an Plotly plot\n",
        "\n",
        "To plot `mpg`, run this code to put `displ` on the x-axis and `hwy` on the y-axis:\n"
      ],
      "id": "9fedfbcb"
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "chart = px.scatter(mpg,\n",
        "    x='displ', \n",
        "    y='hwy'\n",
        ")\n",
        "\n",
        "chart.show()"
      ],
      "id": "e2165b7a",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "The plot shows a negative relationship between engine size (`displ`) and fuel efficiency (`hwy`). In other words, cars with big engines use more fuel. Does this confirm or refute your hypothesis about fuel efficiency and engine size?\n",
        "\n",
        "<!-- With Plotly, you begin a plot with the function `Chart()`. `Chart()` creates a Chart object that you can add layers to. The only argument of `Chart()` is the dataset to use in the graph. So `Chart(mpg)` creates an Chart object upon which we can marks.\n",
        "\n",
        "You complete your graph by adding one or more marks to `Chart()`. The attribute `.mark_point()` adds a layer of points to your plot, which creates a scatterplot. Plotly comes with many mark methods that each add a different type of layer to a plot. You'll learn a whole bunch of them throughout this chapter.\n",
        "\n",
        "Each mark method in Plotly has an `.encode()` attribute. This defines how variables in your dataset are encoded to visual properties. The `.encode()` method is always paired with `x` and `y` arguments to specify which variables to map to the x and y axes. Plotly looks for the encoded variables in the `data` argument, in this case, `mpg`. For pandas dataframes, Plotly automatically determines the appropriate data type for the mapped column. -->\n",
        "\n",
        "### A graphing template\n",
        "\n",
        "Let's turn this code into a reusable template for making graphs with Plotly Express. To make a graph, replace the bracketed sections in the code below with a dataset, or a series of data.\n",
        "\n",
        "````\n",
        "```python\n",
        "(px.<TYPE>(<DATA>,  \n",
        "   x=<X_COL>,\n",
        "   y=<Y_COL>\n",
        ")\n",
        "```\n",
        "````\n",
        "\n",
        "The rest of this chapter will show you how to complete and extend this template to make different types of graphs. We will begin with the `<ENCODINGS>` component.\n",
        "\n",
        "### Exercises\n",
        "\n",
        "1.  Run `mpg.tail(200)`. What do you see?\n",
        "\n",
        "1.  How many rows are in `mpg`? How many columns?\n",
        "\n",
        "1.  What does the `drv` variable describe?  \n",
        "\n",
        "1.  Make a scatterplot of `hwy` vs `cyl`.\n",
        "\n",
        "1.  What happens if you make a scatterplot of `class` vs `drv`? Why is\n",
        "    the plot not useful?\n",
        "\n",
        "## Aesthetic mappings\n",
        "\n",
        "> \"The greatest value of a picture is when it forces us to notice what we\n",
        "> never expected to see.\" --- John Tukey\n",
        "\n",
        "In the plot below, one group of points (highlighted in red) seems to fall outside of the linear trend. These cars have a higher mileage than you might expect. How can you explain these cars?\n"
      ],
      "id": "1c6e9cde"
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "mpg = mpg.assign(\n",
        "  color = np.where(\n",
        "    (mpg.displ > 5) & (mpg.hwy >20), \n",
        "      1,\n",
        "      0\n",
        "  ).astype(str),\n",
        "  size = np.where(\n",
        "    (mpg.displ > 5) & (mpg.hwy >20), \n",
        "      5,\n",
        "      2.5\n",
        "  )\n",
        ")\n",
        "\n",
        "chartC = (px.scatter(mpg,\n",
        "  x = 'displ',\n",
        "  y = 'hwy',\n",
        "  color = 'color',\n",
        "  size = 'size',\n",
        "  size_max = 5,\n",
        "  color_discrete_map = {\"1\": 'red',\"0\":'black'}\n",
        "    )\n",
        ")\n",
        "chartC.update_layout(showlegend=False)\n",
        "chartC.show()"
      ],
      "id": "ae36c71a",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Let's hypothesize that the cars are hybrids. One way to test this hypothesis is to look at the `class` value for each car. The `class` variable of the `mpg` dataset classifies cars into groups such as compact, midsize, and SUV. If the outlying points are hybrids, they should be classified as compact cars or, perhaps, subcompact cars (keep in mind that this data was collected before hybrid trucks and SUVs became popular).\n",
        "\n",
        "You can add a third variable, like `class`, to a two dimensional scatterplot by mapping it to an __encoding__. An encoding is a visual property of the objects in your plot. Encodings include things like the size, the shape, or the color of your points. You can display a point (like the one below) in different ways by changing the values of its encoded properties. Since we already use the word \"value\" to describe data, let's use the word \"level\" to describe encoded properties. Here we change the levels of a point's size, shape, and color to make the point small, triangular, or blue:\n",
        "\n",
        "[](/images/encode_example.png)\n",
        "\n",
        "You can convey information about your data by mapping the encodings in your plot to the variables in your dataset. For example, you can map the colors of your points to the `class` variable to reveal the class of each car.\n"
      ],
      "id": "e2264d90"
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "chart = (px.scatter(mpg,\n",
        "  x = \"displ\",\n",
        "  y = \"hwy\",\n",
        "  color = \"class\"\n",
        "  )\n",
        ")\n",
        "chart.show()"
      ],
      "id": "d20b0301",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "(We don't prefer British English, like Hadley, so don't use `colour` instead of `color`.)\n",
        "\n",
        "To map an encoding to a variable, associate the name of the encoding to the name of the variable inside `.encode()`. Plotly will automatically assign a unique level of the encoding (here a unique color) to each unique value of the variable, a process known as __scaling__. Plotly will also add a legend that explains which levels correspond to which values.\n",
        "\n",
        "The colors reveal that many of the unusual points are two-seater cars. These cars don't seem like hybrids, and are, in fact, sports cars! Sports cars have large engines like SUVs and pickup trucks, but small bodies like midsize and compact cars, which improves their gas mileage. In hindsight, these cars were unlikely to be hybrids since they have large engines.\n",
        "\n",
        "In the above example, we mapped `class` to the color encoding, but we could have mapped `class` to the size encoding in the same way. In this case, the exact size of each point would reveal its class affiliation. Mapping an unordered variable (`class`) to an ordered aesthetic (`size`) is not a good idea.\n"
      ],
      "id": "5c060a22"
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "mpg = mpg.assign(\n",
        "  size = mpg['class']\n",
        "    .str.replace('compact','1')\n",
        "    .str.replace('midsize','2')\n",
        "    .str.replace('suv','3')\n",
        "    .str.replace('2seater','4')\n",
        "    .str.replace('minivan','5')\n",
        "    .str.replace('pickup','6')\n",
        "    .str.replace('sub1','7')\n",
        "    .astype(float)\n",
        ")\n",
        "\n",
        "chart = (px.scatter(mpg,\n",
        "  x = \"displ\",\n",
        "  y = \"hwy\",\n",
        "  color = \"class\",\n",
        "  size = \"size\",\n",
        "  size_max = 5,\n",
        "  )\n",
        ")\n",
        "chart.show()"
      ],
      "id": "8bd1dd46",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Or we could have mapped `class` to the _opacity_ encoding, which controls the transparency of the points, or to the shape encoding, which controls the shape of the points.\n",
        "\n",
        "::: columns\n",
        "::: {.column width=\"50%\"}"
      ],
      "id": "00aa789d"
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "# First\n",
        "chart1 = (px.scatter(mpg,\n",
        "    x = \"displ\",\n",
        "    y = \"hwy\",\n",
        "    opacity=0.5\n",
        "    )\n",
        ")\n",
        "chart1.show()"
      ],
      "id": "e1f62fa2",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        ":::"
      ],
      "id": "3a5ec180"
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "# Second\n",
        "chart2 = (px.scatter(mpg,\n",
        "    x = \"displ\",\n",
        "    y = \"hwy\",\n",
        "    symbol = \"class\"\n",
        "    )\n",
        ")\n",
        "chart2.show() "
      ],
      "id": "f2b0b259",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "::: {.column width=\"50%\"}\n",
        "\n",
        "Plotly will only use 8 shapes for one chart. Charting more than 8 shapes is not recommended as the shapes simply recycle.\n",
        "\n",
        "For each encoding, you use `.encode()` to associate the name of the encoding with a variable to display. The `.encode()` function gathers together each of the encoded mappings used by a layer and passes them to the layer's mapping argument. The syntax highlights a useful insight about `x` and `y`: the x and y locations of a point are themselves encodings, visual properties that you can map to variables to display information about the data.\n",
        "\n",
        "Once you map an encoding, Plotly takes care of the rest. It selects a reasonable scale to use with the encoding, and it constructs a legend that explains the mapping between levels and values. For x and y aesthetics, Plotly does not create a legend, but it creates an axis line with tick marks and a label. The axis line acts as a legend; it explains the mapping between locations and values.\n",
        "\n",
        "You can also _configure_ the encoding properties of your mark manually. For example, we can make all of the points in our plot orange:\n"
      ],
      "id": "f276185c"
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "chart = (px.scatter(mpg,\n",
        "  x = 'displ',\n",
        "  y = 'hwy'\n",
        "    )\n",
        ").update_traces(marker=dict(color='orange'))\n",
        "\n",
        "chart.show()"
      ],
      "id": "98244a51",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "<!-- Here, the color doesn't convey information about a variable, but only changes the appearance of the plot. To set an encoding manually, use `alt.value()` by name as an argument of your `.encode()` function; i.e. the value goes _inside_ of `alt.value()`. You'll need to pick a level that makes sense for that encoding:\n",
        "\n",
        "* The name of a color as a character string.\n",
        "\n",
        "* The size of a point in pixels.\n",
        "\n",
        "* The shape of a point as a character string.\n",
        "\n",
        "Note that only a limited set of mark properties can be bound to encodings, so for some (e.g. fillOpacity, strokeOpacity, etc.) the encoding approach using `alt.value()` is not available. Encoding settings will always override local or global configuration settings. There are other methods for manually encoding properties as explained in the [Plotly documentation](https://Plotly-viz.github.io/user_guide/customization.html) -->\n",
        "\n",
        "[Stack Overflow on Plotly Express Colors](https://stackoverflow.com/questions/63460213/how-to-define-colors-in-a-figure-using-plotly-graph-objects-and-plotly-express)\n",
        "\n",
        "### Exercises\n",
        "\n",
        "1.  Which variables in `mpg` are categorical? Which variables are continuous?\n",
        "    How can you see this information when you run `mpg`? (Hint `mpg.dtypes`)\n",
        "\n",
        "1.  Map a continuous variable to `color`, `size`, and `shape`. How do\n",
        "    these aesthetics behave differently for categorical vs. continuous\n",
        "    variables?\n",
        "\n",
        "1.  What happens if you map the same variable to multiple encodings?\n",
        "\n",
        "1.  What does the `stroke` encoding do? What shapes does it work with?\n",
        "    (Hint: use `mark_point()`)\n",
        "\n",
        "## Common problems\n",
        "\n",
        "As you start to run Python code, you're likely to run into problems. Don't worry --- it happens to everyone. I have been writing Python code for months, and every day I still write code that doesn't work!\n",
        "\n",
        "Start by carefully comparing the code that you're running to the code in the book. Python is extremely picky, and a misplaced character can make all the difference. Make sure that every `(` is matched with a `)` and every `\"` is paired with another `\"`. \n",
        "\n",
        "One common problem when creating Plotly graphics as shown in this book, is to put the `()` in the wrong place: the `(` comes before the `alt.chart()` command and the `)` has to come at the end of the command. \n",
        "\n",
        "For example the code below works in Python. \n",
        "\n",
        "```python\n",
        "px.scatter(mpg, x = 'displ', y = 'hwy')\n",
        "```\n",
        "\n",
        "However, the complexity of the more details graphics necessitates placing the code on multiple lines. When using multiple lines we need the enclosing `()`. Make sure you haven't accidentally excluded a `(` or `)` like this\n",
        "\n",
        "```python\n",
        "(px.scatter(mpg,\n",
        "  x = 'displ',\n",
        "  y = 'hwy'\n",
        "    )\n",
        "```\n",
        "\n",
        "or placed the `()` incorrectly like this\n",
        "\n",
        "```python\n",
        "(chart = px.scatter(mpg,\n",
        "  x = 'displ',\n",
        "  y = 'hwy'\n",
        "    )\n",
        ") \n",
        "```\n",
        "\n",
        "If you're still stuck, try the help. You can get help about any Plotly function from their website - <https://plotly.com/python/>, or hovering over the function name in VS Code. If that doesn't help, carefully read the error message. Sometimes the answer will be buried there! But when you're new to python the answer might be in the error message but you don't yet know how to understand it. Another great tool is Google: try googling the error message, as it's likely someone else has had the same problem, and has gotten help online.\n",
        "\n",
        "## Facets\n",
        "\n",
        "One way to add additional variables is with encodings. Another way, particularly useful for categorical variables, is to split your plot into __facets__, subplots that each display one subset of the data.\n",
        "\n",
        "To facet your plot by a single variable, use `.facet()`. Assign a discrete variable to the `.facet` argument and adjust the size of your facet grid using the `columns` argument.\n"
      ],
      "id": "cf65dfca"
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "chart_f = (px.scatter(mpg,\n",
        "  x = 'displ',\n",
        "  y = 'hwy',\n",
        "  facet_col= \"class\", \n",
        "  facet_col_wrap=4\n",
        "    )\n",
        ")\n",
        "\n",
        "chart_f.show()"
      ],
      "id": "e6900892",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "To facet your plot on the combination of two variables, the first argument of `.facet()` is `column` and the second is `row`. This time the formula should contain two discrete variable names.\n"
      ],
      "id": "1c05c6c5"
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "chart_f2 = (px.scatter(mpg,\n",
        "  x = 'displ',\n",
        "  y = 'hwy',\n",
        "  facet_col= \"drv\", \n",
        "  facet_row= \"cyl\"\n",
        "    )\n",
        ")\n",
        "\n",
        "chart_f2.show()"
      ],
      "id": "b6d14742",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "If you prefer to not facet in the rows or columns dimension, simply remove that facet argument. You can read more about [compound charts in the Plotly documentation](https://plotly.com/python/facet-plots/).\n",
        "\n",
        "### Exercises\n",
        "\n",
        "1.  What happens if you facet on a continuous variable?\n",
        "\n",
        "1.  What do the empty cells in plot with `.facet(column = \"drv\", row = \"cyl\")` mean?\n",
        "    How do they relate to this plot?\n"
      ],
      "id": "34eb02d2"
    },
    {
      "cell_type": "code",
      "metadata": {
        "md-indent": "    "
      },
      "source": [
        "(px.scatter(mpg,\n",
        "  x = 'displ',\n",
        "  y = 'hwy'\n",
        "    )\n",
        ")"
      ],
      "id": "a5a81566",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "1.  What plots does the following code make? What does `.` do?\n"
      ],
      "id": "c4c52905"
    },
    {
      "cell_type": "code",
      "metadata": {
        "md-indent": "    "
      },
      "source": [
        "(px.scatter(mpg,\n",
        "  x = 'displ',\n",
        "  y = 'hwy',\n",
        "  facet_col= \"drv\"\n",
        "    )\n",
        ")\n",
        "\n",
        "(px.scatter(mpg,\n",
        "  x = 'displ',\n",
        "  y = 'hwy',\n",
        "  facet_row= \"cyl\"\n",
        "    )\n",
        ")"
      ],
      "id": "edad3688",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "1.  Take the first faceted plot in this section:\n",
        "\n",
        "    What are the advantages to using faceting instead of the colour aesthetic?\n",
        "    What are the disadvantages? How might the balance change if you had a\n",
        "    larger dataset?\n",
        "\n",
        "1.  When using `facet()` you should usually put the variable with more\n",
        "    unique levels in the columns. Why?\n",
        "\n",
        "## Geometric objects\n",
        "\n",
        "How are these two plots similar?\n"
      ],
      "id": "84ddd2fc"
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "chartp = (px.scatter(mpg,\n",
        "  x = 'displ',\n",
        "  y = 'hwy',\n",
        "    )\n",
        ")\n",
        "chartp.show()"
      ],
      "id": "c14973e7",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "chartf = (px.scatter(mpg,\n",
        "  x = 'displ',\n",
        "  y = 'hwy',\n",
        "  trendline = \"lowess\"\n",
        "    )\n",
        ").update_traces(visible=False, selector=dict(mode=\"markers\"))\n",
        "chartf.show()"
      ],
      "id": "b34cfdd1",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Both plots contain the same x variable, the same y variable, and both describe the same data. But the plots are not identical. Each plot uses a different visual object to represent the data. In Plotly syntax, we say that they use different __marks__.\n",
        "\n",
        "A __mark__ is the geometrical object that a plot uses to represent data. People often describe plots by the type of mark that the plot uses. For example, bar charts use bar marks, line charts use line marks, boxplots use boxplot marks, and so on. Scatterplots break the trend; they use the point mark. As we see above, you can use different marks to plot the same data. The first plot uses the point mark, and the second plot uses the line mark, a smooth line fitted to the data is calculated using a transformation. To change the mark in your plot, change the mark function that you add to `Chart()`. \n",
        "\n",
        "Every mark function in Plotly has `encode` arguments. However, not every encoding works with every mark. You could set the shape of a point, but you couldn't set the \"shape\" of a line. On the other hand, you _could_ set the type of line. `.mark_line()` will draw a different line, with a different `strokeDash`, for each unique value of the variable that you map to `strokeDash`.\n"
      ],
      "id": "1d5dbc94"
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "chartl = (px.scatter(mpg,\n",
        "  x = 'displ',\n",
        "  y = 'hwy',\n",
        "  trendline='lowess',\n",
        "  trendline_options=dict(\"frac\",0.666)\n",
        "    )\n",
        ")#.update_traces(visible=False, selector=dict(mode=\"markers\"))\n",
        "chartl.show()\n",
        "\n",
        "# df = px.data.stocks(indexed=True, datetimes=True)\n",
        "# fig = px.scatter(df, trendline=\"rolling\", trendline_options=dict(window=5),\n",
        "#                 title=\"5-point moving average\")\n",
        "# fig.data = [t for t in fig.data if t.mode == \"lines\"]\n",
        "# fig.update_traces(showlegend=True) #trendlines have showlegend=False by default\n",
        "# fig.show()\n",
        "\n",
        "\n",
        "# chartl = (alt.Chart(mpg)\n",
        "#   .transform_loess(\"displ\", \"hwy\", groupby = [\"drv\"])\n",
        "#   .encode(\n",
        "#     x = \"displ\",\n",
        "#     y = \"hwy\",\n",
        "#     strokeDash = \"drv\"\n",
        "#     )\n",
        "#   .mark_line())\n",
        "  \n",
        "# chartl.save(\"screenshots/Plotly_dashed_lines.png\")"
      ],
      "id": "7c3131f4",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Here `.mark_line()` separates the cars into three lines based on their `drv` value, which describes a car's drivetrain. One line describes all of the points with a `4` value, one line describes all of the points with an `f` value, and one line describes all of the points with an `r` value. Here, `4` stands for four-wheel drive, `f` for front-wheel drive, and `r` for rear-wheel drive.\n",
        "\n",
        "If this sounds strange, we can make it more clear by overlaying the lines on top of the raw data and then coloring everything according to `drv`.\n"
      ],
      "id": "5e2f8278"
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "chartp = (alt.Chart(mpg).\n",
        "  mark_circle().\n",
        "  encode(\n",
        "    x = \"displ\",\n",
        "    y = \"hwy\",\n",
        "    strokeDash = \"drv\",\n",
        "    color = \"drv\"\n",
        "  ))\n",
        "\n",
        "chart = chartp + chartp.transform_loess(\"displ\", \"hwy\", groupby = [\"drv\"]).mark_line()\n",
        "\n",
        "chart.save(\"screenshots/Plotly_points_dashed_lines.png\")"
      ],
      "id": "e0f05c34",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Notice that this plot contains two marks in the same graph! If this makes you excited, buckle up. We will learn how to place multiple marks on the same chart very soon.\n",
        "\n",
        "Plotly provides about 15 marks. The best way to get a comprehensive overview is the Plotly marks page, which you can find at <https://Plotly-viz.github.io/user_guide/marks.html>. \n",
        "\n",
        "Many marks, like `.mark_line()`, use a single mark object to display multiple rows of data. For these marks, you can set the `detail` encoding to a categorical variable to draw multiple objects. Plotly will draw a separate object for each unique value of the detail variable. In practice, Plotly will automatically group the data for these marks whenever you map an encoding to a discrete variable (as in the `strokeDash` example). It is convenient to rely on this feature because the detail encoding by itself does not add a legend or distinguishing features to the marks.\n"
      ],
      "id": "0de1e5b5"
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "chartleft = (alt.Chart(mpg)\n",
        "  .encode(\n",
        "    x = \"displ\",\n",
        "    y = \"hwy\",\n",
        "    )\n",
        "  .transform_loess(\"displ\", \"hwy\")\n",
        "  .mark_line())\n",
        "\n",
        "chartmiddle = (alt.Chart(mpg)\n",
        "  .encode(\n",
        "    x = \"displ\",\n",
        "    y = \"hwy\",\n",
        "    detail = \"drv\"\n",
        "    )\n",
        "  .transform_loess(\"displ\", \"hwy\", groupby = [\"drv\"])\n",
        "  .mark_line())\n",
        "\n",
        "chartright = (alt.Chart(mpg)\n",
        "  .encode(\n",
        "    x = \"displ\",\n",
        "    y = \"hwy\",\n",
        "    color=alt.Color(\"drv\", legend=None)\n",
        "    )\n",
        "  .transform_loess(\"displ\", \"hwy\", groupby = [\"drv\"])\n",
        "  .mark_line())\n",
        "  \n",
        "chartleft.save(\"screenshots/Plotly_chartleft.png\")\n",
        "chartmiddle.save(\"screenshots/Plotly_chartmiddle.png\")\n",
        "chartright.save(\"screenshots/Plotly_chartright.png\")"
      ],
      "id": "4b0b6a45",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "To display multiple marks in the same plot, you can used [layered charts](https://Plotly-viz.github.io/user_guide/compound_charts.html) as shown in the example below that uses the `chartleft` object from the above code chunk:\n"
      ],
      "id": "2b7769af"
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "chartp = (alt.Chart(mpg)\n",
        "  .encode(\n",
        "    x = \"displ\",\n",
        "    y = \"hwy\"\n",
        "  )\n",
        "  .mark_circle()\n",
        ")\n",
        "\n",
        "chart = chartp + chartleft  \n",
        "\n",
        "chart.save(\"screenshots/Plotly_chartcombine.png\")\n"
      ],
      "id": "16033cc7",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "This, however, introduces some duplication in our code. Imagine if you wanted to change the y-axis to display `cty` instead of `hwy`. You'd need to change the variable in two places, and you might forget to update one. You can avoid this type of repetition by passing a set of encodings to a base `alt.Chart()`. Plotly will treat these encodings as global encodings that apply to each mark layer in the layered chart.  In other words, this code will produce the same plot as the previous code:\n"
      ],
      "id": "58f90e9d"
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "base = (alt.Chart(mpg)\n",
        "  .encode(\n",
        "    x = \"displ\",\n",
        "    y = \"hwy\"\n",
        "    ))\n",
        "\n",
        "chart = base.mark_circle() + base.transform_loess(\"displ\", \"hwy\").mark_line()\n",
        "\n",
        "chart.save(\"screenshots/Plotly_combine_clean.png\")\n"
      ],
      "id": "6aa54bbc",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "If you place encodings in an encode function, Plotly will treat them as local mappings for the layer. It will use these mappings to extend or overwrite the base encodings _for that layer only_. This makes it possible to display different aesthetics in different layers. Alatair automatically chooses useful plot settings and chart configurations to allow you to think about data instead of the programming mechanics of the chart. You can review their guidance on [customizing visualizations](https://Plotly-viz.github.io/user_guide/customization.html) to see the varied ways to change the look of your graphic.\n"
      ],
      "id": "58f87350"
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "base =(alt.Chart(mpg)\n",
        "  .encode(\n",
        "    x = \"displ\",\n",
        "    y = \"hwy\"\n",
        "  ))\n",
        "\n",
        "chart = base.encode(color = \"drv\").mark_circle() + base.transform_loess(\"displ\", \"hwy\").mark_line()\n",
        "\n",
        "chart.save(\"screenshots/Plotly_combine_clean_color.png\")"
      ],
      "id": "9cb1aebf",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "You can use the same idea to specify different data for each layer. Here, our smooth line displays just a subset of the `mpg` dataset, the subcompact cars. The `.transform_filter` method overrides the global data from the base chart for that layer only.\n"
      ],
      "id": "8a9af83a"
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "#column name of class does not work nicely with Plotly filter.\n",
        "\n",
        "base = (alt.Chart(mpg.rename(columns = {\"class\": \"class1\"}))\n",
        "  .encode(\n",
        "    x = \"displ\",\n",
        "    y = \"hwy\"\n",
        "    ))\n",
        "\n",
        "chart_smooth_sub = (base\n",
        "  .transform_filter(alt.datum.class1 == \"subcompact\")\n",
        "  .transform_loess(\"displ\", \"hwy\")\n",
        "  .mark_line()\n",
        ")  \n",
        "\n",
        "chart = base.encode(color = \"class1\").mark_circle() + chart_smooth_sub\n",
        "\n",
        "chart.save(\"screenshots/Plotly_combine_clean_color_filter.png\")"
      ],
      "id": "906d8929",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "(You'll learn how [pandas filter](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.filter.html) works in the chapter on data transformations. To keep the same base chart, [filtering](https://Plotly-viz.github.io/user_guide/transform/filter.html) is done with Plotly in this example: for now, just know that this command selects only the subcompact cars.)\n",
        "\n",
        "### Exercises\n",
        "\n",
        "1.  What geom would you use to draw a line chart? A boxplot?\n",
        "    A histogram? An area chart?\n",
        "\n",
        "1.  What does `legend=None` in `alt.Color()` do?  What happens if you remove it?\n",
        "    Why do you think I used it earlier in the chapter?\n",
        "\n",
        "\n",
        "1.  Recreate the Python code necessary to generate the following graphs.\n"
      ],
      "id": "3b0d99d1"
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "base = (alt.Chart(mpg)\n",
        "  .encode(\n",
        "    x = \"displ\",\n",
        "    y = \"hwy\"\n",
        "    ))\n",
        "    \n",
        "smooth1 = base.transform_loess(\"displ\", \"hwy\").mark_line()\n",
        "smooth3 = base.transform_loess(\"displ\", \"hwy\", groupby = [\"drv\"]).mark_line()\n",
        "\n",
        "chart1 = base.mark_circle() + smooth1\n",
        "chart2 = base.mark_circle() + smooth3.encode(detail = \"drv\")\n",
        "chart3 = base.mark_circle().encode(color = \"drv\") + smooth3.encode(color = \"drv\")\n",
        "chart4 = base.mark_circle().encode(color = \"drv\") + smooth1\n",
        "chart5 = base.mark_circle().encode(color = \"drv\") + smooth3.encode(strokeDash = \"drv\")\n",
        "chart6 = (base\n",
        "  .encode(\n",
        "    color = alt.ColorValue(\"darkgrey\"),\n",
        "    size = alt.SizeValue(125)\n",
        "    )\n",
        "  .mark_point(filled = True)) + base.mark_circle().encode(color = \"drv\")\n",
        "\n",
        "chart1.save(\"screenshots/Plotly_q_c1.png\")\n",
        "chart2.save(\"screenshots/Plotly_q_c2.png\")\n",
        "chart3.save(\"screenshots/Plotly_q_c3.png\")\n",
        "chart4.save(\"screenshots/Plotly_q_c4.png\")\n",
        "chart5.save(\"screenshots/Plotly_q_c5.png\")\n",
        "chart6.save(\"screenshots/Plotly_q_c6.png\")"
      ],
      "id": "447552ac",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Statistical transformations\n",
        "\n",
        "Next, let's take a look at a bar chart. Bar charts seem simple, but they are interesting because they reveal something subtle about plots. Consider a basic bar chart, as drawn with `.mark_bar()`. The following chart displays the total number of diamonds in the `diamonds` dataset, grouped by `cut`. The `diamonds` dataset comes in ggplot2 R package and can be used in Python using the following Python command. Note that we also need to use pandas to format a few of the columns as ordered categorical to have the diamonds DataFrame act like it does in R.\n"
      ],
      "id": "7539521c"
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "url = \"https://github.com/byuidatascience/data4python4ds/raw/master/data-raw/diamonds/diamonds.csv\"\n",
        "diamonds = pd.read_csv(url)\n",
        "\n",
        "diamonds['cut'] = pd.Categorical(diamonds.cut, \n",
        "  ordered = True, \n",
        "  categories =  [\"Fair\", \"Good\", \"Very Good\", \"Premium\", \"Ideal\" ])\n",
        "\n",
        "diamonds['color'] = pd.Categorical(diamonds.color, \n",
        "  ordered = True, \n",
        "  categories =  [\"D\", \"E\", \"F\", \"G\", \"H\", \"I\", \"J\"])\n",
        "\n",
        "\n",
        "diamonds['clarity'] = pd.Categorical(diamonds.clarity, \n",
        "  ordered = True, \n",
        "  categories =  [\"I1\", \"SI2\", \"SI1\", \"VS2\", \"VS1\", \"VVS2\", \"VVS1\", \"IF\"])\n"
      ],
      "id": "d08f4308",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "It contains information about ~54,000 diamonds, including the `price`, `carat`, `color`, `clarity`, and `cut` of each diamond. The chart shows that more diamonds are available with high quality cuts than with low quality cuts. \n"
      ],
      "id": "62c5e5b4"
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "chart = (alt.Chart(diamonds)\n",
        "  .encode(\n",
        "    x = \"cut\",\n",
        "    y = alt.Y(\"count():Q\")\n",
        "    )\n",
        "  .mark_bar()\n",
        "  .properties(width = 400))\n",
        "\n",
        "chart.save(\"screenshots/Plotly_diamond_bar.png\")"
      ],
      "id": "40ab38ec",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "On the x-axis, the chart displays `cut`, a variable from `diamonds`. On the y-axis, it displays count, but count is not a variable in `diamonds`! Many graphs, like scatterplots, plot the raw values of your dataset. Other graphs, like bar charts, calculate new values to plot:\n",
        "\n",
        "* bar charts, histograms, and frequency polygons bin your data\n",
        "  and then plot bin counts, the number of points that fall in each bin.\n",
        "\n",
        "* smoothers fit a model to your data and then plot predictions from the\n",
        "  model.\n",
        "\n",
        "* boxplots compute a robust summary of the distribution and then display a\n",
        "  specially formatted box.\n",
        "\n",
        "The algorithm used to calculate new values for a graph is called a __transform__, short for transformation. The figure below describes how this process works with `.mark_bar()`.\n",
        "\n",
        "You must explicitely define the transformation a mark uses through transformations using `alt.Y()` or `alt.X()` function. For example, `mark_bar()` requires the `y` encoding `alt.Y(\"count():Q\")`. A histogram is created using `.mark_bar()` with transformations on both the x and y axes. The `bin` argument accepts a boolean or an `alt.Bin()` function where the argument `maxbins` can be used - `bin=alt.Bin(maxbins=100)`.\n"
      ],
      "id": "f49e7188"
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "chart = (alt.Chart(diamonds)\n",
        "  .encode(\n",
        "    x =alt.X(\"price\", bin=True),\n",
        "    y =alt.Y(\"count()\")\n",
        "    )\n",
        "  .mark_bar())\n",
        "\n",
        "chart.save(\"screenshots/Plotly_histogram.png\")"
      ],
      "id": "c6fa4ba0",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "For more complicated transformations Plotly provides __transform__ functions. We saw one of these transforms previously when we used `.mark_line()` to describe each drive type. If you are working with pandas DataFrames then you may want to do these transformations using pandas. [Plotly's transformations](https://Plotly-viz.github.io/user_guide/transform/index.html) can be used with DataFrames as well as JSON files or URL pointers to CSV files. \n"
      ],
      "id": "09ab4594"
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "chartright = (alt.Chart(mpg)\n",
        "  .encode(\n",
        "    x = \"displ\",\n",
        "    y = \"hwy\",\n",
        "    color=alt.Color(\"drv\", legend=None)\n",
        "    )\n",
        "  .transform_loess(\"displ\", \"hwy\", groupby = [\"drv\"]).\n",
        "  .mark_line())"
      ],
      "id": "9963b13b",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Finally, `.mark_boxplot()` is available which does the statistical transformations for you after you specify the encodings for the x and y axes.\n"
      ],
      "id": "97640945"
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "chart = (alt.Chart(diamonds)\n",
        "  .encode(\n",
        "    y =\"price\",\n",
        "    x =\"cut\"\n",
        "    )\n",
        "  .mark_boxplot(size = 25)\n",
        "  .properties(width = 300))\n",
        "\n",
        "chart.save(\"screenshots/Plotly_boxplot.png\")"
      ],
      "id": "8267d3f9",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Position adjustments\n",
        "\n",
        "There's one more piece of magic associated with bar charts. You can colour a bar chart using either the `stroke` aesthetic, or, more usefully, `color`:\n"
      ],
      "id": "c84ef0ea"
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "chart_left = (alt.Chart(diamonds)\n",
        "  .encode(\n",
        "    x = \"cut\",\n",
        "    y = alt.Y(\"count()\"),\n",
        "    stroke = \"cut\"\n",
        "    )\n",
        "  .mark_bar()\n",
        "  .properties(width = 200))\n",
        "  \n",
        "chart_right = (alt.Chart(diamonds)\n",
        "  .encode(\n",
        "    x = \"cut\",\n",
        "    y = alt.Y(\"count()\"),\n",
        "    color = \"cut\"\n",
        "    )\n",
        "  .mark_bar()\n",
        "  .properties(width = 200)) \n",
        "\n",
        "chart_left.save(\"screenshots/Plotly_bar_linecolor.png\")\n",
        "chart_right.save(\"screenshots/Plotly_bar_fillcolor.png\")"
      ],
      "id": "9a09266a",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Note what happens if you map the color encoding to another variable, like `clarity`: the bars are automatically stacked. Each colored rectangle represents a combination of `cut` and `clarity`.\n"
      ],
      "id": "f9e07e8e"
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "chart = (alt.Chart(diamonds)\n",
        "  .encode(\n",
        "    x = \"cut\",\n",
        "    y = alt.Y(\"count()\"),\n",
        "    color = \"clarity\"\n",
        "    )\n",
        "  .mark_bar()\n",
        "  .properties(width = 200))\n",
        "  \n",
        "chart.save(\"screenshots/stacked_barchart.png\")  "
      ],
      "id": "8132a2bf",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "The stacking is performed automatically by `.mark_bar()`. If you don't want a stacked bar chart, you can use use the `stack` argument in  `alt.Y()` one of three other options: `\"identity\"`, `\"dodge\"` or `\"fill\"`.\n",
        "\n",
        "*   `position = \"identity\"` will place each object exactly where it falls in\n",
        "    the context of the graph. This is not very useful for bars, because it\n",
        "    overlaps them. To see that overlapping we either need to make the bars\n",
        "    slightly transparent by setting `alpha` to a small value, or completely\n",
        "    transparent by setting `fill = NA`.\n"
      ],
      "id": "ee22ac97"
    },
    {
      "cell_type": "code",
      "metadata": {
        "md-indent": "    "
      },
      "source": [
        "chart_left = (alt.Chart(diamonds)\n",
        "    .encode(\n",
        "      x = \"cut\",\n",
        "      y = alt.Y(\"count()\", stack=None),\n",
        "      color = \"clarity\",\n",
        "      opacity = alt.value(1/5)\n",
        "      )\n",
        "    .mark_bar()\n",
        "    .properties(width = 200))\n",
        "\n",
        "chart_right = (alt.Chart(diamonds)\n",
        "    .encode(\n",
        "      x = \"cut\",\n",
        "      y = alt.Y(\"count()\", stack=None),\n",
        "      stroke = \"clarity\",\n",
        "      color = alt.value(\"none\")\n",
        "      )\n",
        "    .mark_bar()\n",
        "    .properties(width = 200))\n",
        "\n",
        "chart_left.save(\"screenshots/Plotly_nostack_opacity.png\")\n",
        "chart_right.save(\"screenshots/Plotly_nostack_lines.png\")"
      ],
      "id": "35ffb415",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "*   `position = \"fill\"` works like stacking, but makes each set of stacked bars\n",
        "    the same height. This makes it easier to compare proportions across\n",
        "    groups.\n"
      ],
      "id": "15cd4134"
    },
    {
      "cell_type": "code",
      "metadata": {
        "md-indent": "    "
      },
      "source": [
        "chart = (alt.Chart(diamonds)\n",
        "  .mark_bar()\n",
        "  .encode(\n",
        "    x = \"cut\",\n",
        "    y = alt.Y(\"count()\", stack='normalize'),\n",
        "    color = \"clarity\"\n",
        "    )\n",
        "  .mark_bar()\n",
        "  .properties(width = 200))\n",
        "\n",
        "chart.save(\"screenshots/Plotly_normalize_bar.png\")"
      ],
      "id": "e287a5f7",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "*   Placing overlapping objects directly _beside_ one another is done by using the `column` encoding.     This makes it easier to compare individual values with a common baseline.\n"
      ],
      "id": "9991a33b"
    },
    {
      "cell_type": "code",
      "metadata": {
        "md-indent": "    "
      },
      "source": [
        "chart = (alt.Chart(diamonds)\n",
        "  .encode(\n",
        "    x='clarity',\n",
        "    y=alt.Y('count()'),\n",
        "    color='clarity',\n",
        "    column='cut'\n",
        "    )\n",
        "  .mark_bar())\n",
        "\n",
        "chart.save(\"screenshots/Plotly_position_dodge.png\")"
      ],
      "id": "d261bc64",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Plotly does not have a simple way to add random jitter to points using an encoding or simple argument to `alt.X()` or `alt.Y()`. Plotly can create a jittered point plot, also called a [stripplot](https://Plotly-viz.github.io/gallery/stripplot.html).  However, it is not as straight forward.\n",
        "\n",
        "We should note that Plotly also does not provide piechart or donut chart marks as well.\n",
        "\n",
        "## Coordinate systems (maps)\n",
        "\n",
        "Coordinate systems are generally on an x and y axis in Plotly. This coordinate system is the Cartesian coordinate system, where the x and y positions act independently to determine the location of each point. Maps are on a Cartesian coordinate system, but their behavior is different as they require a [transformation or projection](https://Plotly-viz.github.io/gallery/world_projections.html) of the globe to an x and y Cartesian plane.\n",
        "\n",
        "Visualizing data on maps can get complicated quickly.  Plotly has a some [mapping marks](https://Plotly-viz.github.io/gallery/index.html#maps) available for charts. The data formats for plotting with maps also get more involved.  You can use the [gpdvega](https://iliatimofeev.github.io/gpdvega/) package to help with spatial data in Plotly. Many Python users us [geopandas](https://geopandas.org/) or [Shapely](https://pypi.org/project/Shapely/1.6.3/) to handle spatial data in Python. [PennState has a nice list](https://www.e-education.psu.edu/geog489/node/2201) of spatial tools for Python. \n",
        "\n",
        "## The layered grammar of graphics\n",
        "\n",
        "In the previous sections, you learned much more than how to make scatterplots, bar charts, and boxplots. You learned a foundation that you can use to make _any_ type of plot with Plotly. To see this, let's add position adjustments, stats, coordinate systems, and faceting to our code template:\n",
        "\n",
        "```\n",
        "(alt.Chart(<DATA>)\n",
        "  .encoding(\n",
        "    \n",
        "    )\n",
        "  .facet(\n",
        "    column = <FACET VARIABLE>\n",
        "    )\n",
        "  .<TRANFORM_FUNCTION>()\n",
        "  .<MARK_FUNCTION>()\n",
        "  .properties(\n",
        "    width = ,\n",
        "    height = \n",
        "  ))\n",
        "```\n",
        "\n",
        "Plotly's general template takes four main parameters - `alt.Chart()`, `.mark_*()`, `.encode()`, and `.facet()`. In practice, only need to supply the first three parameters to make a chart because Plotly will provide useful defaults for everything except the data, the encodings, and the mark function.\n",
        "\n",
        "The parameters in the template compose the grammar of graphics, a formal system for building plots. The grammar of graphics is based on the insight that you can uniquely describe _any_ plot as a combination of a dataset, a mark, a set of encodings, a transformation, a position adjustment, and a faceting scheme.\n",
        "\n",
        "To see how this works, consider how you could build a basic plot from scratch: you could start with a dataset and then transform it into the information that you want to display (with a stat).\n",
        "\n",
        "<!-- ```{r, out.width = \"100%\"}\n",
        "knitr::include_graphics(\"images/visualization-grammar-1-Plotly.png\")\n",
        "``` -->\n",
        "\n",
        "Next, you could choose a geometric object to represent each observation in the transformed data. You could then use the aesthetic properties of the geoms to represent variables in the data. You would map the values of each variable to the levels of an aesthetic.\n",
        "\n",
        "<!-- ```{r, out.width = \"100%\"}\n",
        "knitr::include_graphics(\"images/visualization-grammar-2-Plotly.png\")\n",
        "``` -->\n",
        "\n",
        "You'd then select a coordinate system to place the geoms into. You'd use the location of the objects (which is itself an aesthetic property) to display the values of the x and y variables. At that point, you would have a complete graph, but you could further adjust the positions of the geoms within the coordinate system (a position adjustment) or split the graph into subplots (faceting). You could also extend the plot by adding one or more additional layers, where each additional layer uses a dataset, a geom, a set of mappings, a stat, and a position adjustment.\n",
        "\n",
        "<!-- ```{r, out.width = \"100%\"}\n",
        "knitr::include_graphics(\"images/visualization-grammar-3-Plotly.png\")\n",
        "``` -->\n",
        "\n",
        "You could use this method to build _any_ plot that you imagine. In other words, you can use the code template that you've learned in this chapter to build hundreds of thousands of unique plots.\n",
        "\n",
        "## Plotly's grammar of graphics\n",
        "\n",
        "[Plotnine](https://plotnine.readthedocs.io/en/stable/index.html) is a Python implementation of [ggplot2 in R's](https://ggplot2.tidyverse.org/) grammar of graphics using [matplotlib](https://matplotlib.org/) as the plotting backend. Plotly's implementation of the grammar of graphics is much like ggplot2 or plotnine at a high level.  However, it uses the [Vega-Lite](https://vega.github.io/vega-lite/) grammar of graphics constructs and plotting backend. \n",
        "\n",
        "Below are some useful links that will help you dig deeper into the Plotly implementation of the grammar of graphics.\n",
        "\n",
        "- Plotly [mark guidance](https://Plotly-viz.github.io/user_guide/marks.html)\n",
        "- Plotly [encoding guidance](https://Plotly-viz.github.io/user_guide/encoding.html)\n",
        "- Plotly [facet guidance](https://Plotly-viz.github.io/user_guide/compound_charts.html?highlight=bin%20scale)\n",
        "- Plotly [tranformations guidance](https://Plotly-viz.github.io/user_guide/transform/index.html)\n",
        "- Plotly [chart customization](https://Plotly-viz.github.io/user_guide/customization.html)\n",
        "- Plotly [sorting barcharts](https://Plotly-viz.github.io/gallery/bar_chart_sorted.html)\n",
        "- Plotly [theme editing](https://towardsdatascience.com/consistently-beautiful-visualizations-with-Plotly-themes-c7f9f889602)\n",
        "- Plotly [Encoding data types](https://Plotly-viz.github.io/user_guide/encoding.html?highlight=data%20types#encoding-data-types)\n",
        "\n",
        "\n",
        "<!-- https://github.com/Plotly-viz/Plotly/issues/1021 -->\n",
        "<!-- https://Plotly-viz.github.io/gallery/scatter_marginal_hist.html -->\n",
        "<!-- https://Plotly-viz.github.io/case_studies/exploring-weather.html -->\n"
      ],
      "id": "11513487"
    }
  ],
  "metadata": {
    "kernelspec": {
      "name": "python3",
      "language": "python",
      "display_name": "Python 3 (ipykernel)"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}