03_python_data_science.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e01f169d-b397-401c-b1f5-972cf3395303",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# apply Jupyter notebook style\n",
    "from IPython.core.display import HTML\n",
    "\n",
    "from custom.styles import style_string\n",
    "\n",
    "HTML(style_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e072e018",
   "metadata": {},
   "source": [
    "<div style=\"text-align:center;\">\n",
    "  <img src=\"custom/molssi_main_horizontal.png\" style=\"display: block; margin: 0 auto; max-height:200px;\">\n",
    "</div>\n",
    "\n",
    "Python Data Science Libraries - Pandas and Seaborn\n",
    "===================================================\n",
    "\n",
    "<div class=\"overview admonition\"> \n",
    "<p class=\"admonition-title\">Overview</p>\n",
    "\n",
    "Questions:\n",
    "\n",
    "* How can I use pandas to examine data?\n",
    "\n",
    "* How can I use seaborn to visualize relationships?\n",
    "\n",
    "Objectives:\n",
    "\n",
    "* Learn the basics of pandas dataframes\n",
    "\n",
    "* Use seaborn to make plots.\n",
    "\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf44a96a",
   "metadata": {},
   "source": [
    "Pandas is a Python library used for data analysis and manipulation. Within the world of data science, it is a ubiquitous and widely used library. If you are learning how to analyze data in Python, it will be almost impossible to avoid pandas. \n",
    "\n",
    "Pandas is very powerful. In this session, we'll be learning how to access information in pandas dataframes and how to do some basic manipulation and analysis. The first step in using pandas is importing it. Typically when pandas is imported, it is shortened to `pd`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "853340f7",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5298ab99",
   "metadata": {},
   "source": [
    "The first data set we are looking at in this workshop is solubility data. \n",
    "This is a data set which gives molecular descriptors along with solubility calculated using the ESOL method. \n",
    "The data was obtained from [moleculenet](https://moleculenet.org/datasets-1).\n",
    "The dataset has been downloaded and placed in your `data` folder.\n",
    "\n",
    "<div class=\"note admonition\"> \n",
    "<p class=\"admonition-title\">The ESOL Dataset</p>\n",
    "\n",
    "For this notebook and the next notebook, we will be working with a data set called ESOL.\n",
    "ESOL is short for \"estimated solubility\". \n",
    "The data set originates [from a paper published in 2004 by John. S. Delaney](https://pubs.acs.org/doi/epdf/10.1021/ci034243x), \n",
    "where he used it to fit a model for estimated solubility of small molecules using a linear model.\n",
    "\n",
    "In this notebook, we will not be analyzin the data too deeply. Instead, we will use it to get accquainted with the pandas data science library.\n",
    "\n",
    "</div>\n",
    "\n",
    "Later in the workshop, we'll be seing how we can fit this model ourselves using Python, but for now we are just going to examine the data using pandas. \n",
    "The data is saved in a csv file. CSV stands for \"comma separated values\". \n",
    "This is a file format where commas separate values. \n",
    "You can also typically read files like this into excel. \n",
    "In fact, initially in this session you may not yet see what advantages pandas offers over Excel. \n",
    "However, functionalites in pandas will be more useful once we start cleaning and fitting data.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f093772",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"data/delaney-processed.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1443798a",
   "metadata": {},
   "source": [
    "## Examining the data\n",
    "\n",
    "Now that we have used the pandas `read_csv` function, our data is in a variable called `df`. This variable is a **pandas dataframe**. This means it has lots of special functionalities thanks to pandas. For example, you can preview the first 5 rows using the `.head` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "23ed7e5d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6769ca04",
   "metadata": {},
   "source": [
    "The `.info` function will give information about the columns and the data type of those columns. The data type will become very important later as we work with more data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "67ca8b13",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c6505d9",
   "metadata": {},
   "source": [
    "Pandas assigns data types to columns, and will do its best to decide the data column for each column based on what is in the column. \n",
    "You will see that this dataframe has `1128` values in each column. \n",
    "\n",
    "We see that the column `Minimum Degree` has the data type of `int64`. Here, `int` means `integer` and `64` means `64 bit`.  The `64 bit` refers to the amount of computer memory the variable can occupy. It won't really be important for us. Similarly, `float64` means `64 bit floating point`. These are decimal numbers.\n",
    "\n",
    "The other column names which read `object` are not numeric. They might be strings or they might be something else. We'll discuss more later.\n",
    "\n",
    "The `describe` function can be used on a dataframe to quickly see statistics about columns with numerical data. If you look at the columns that statistics are computed for and compare to the data type shown from `info`, you will see that we only get statistics for columns which had `int64` or `float64` data types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9a80a1f3",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13c61a11",
   "metadata": {},
   "source": [
    "## Accessing Data\n",
    "\n",
    "One great thing about pandas dataframes is how easy it is to access information. Pandas allows you to access information in a dataframe using both data indexes and names.\n",
    "\n",
    "Pandas dataframes have rows and columns, you can see how many rows and columns using `.shape`. This will return the shape as `(num_rows, num_columns)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "80d9c4df",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e206eb98",
   "metadata": {},
   "source": [
    "### Accessing with rows and column numbers \n",
    "\n",
    "#### The `.iloc` function\n",
    "Access on a particular row and column using `.iloc` followed by square brackets and the row and column numbers you want to access. If you only put one number, it will be assumed to be the row number you want.\n",
    "\n",
    "The following gets row number 35."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b7cff7eb",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df.iloc[35]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a6149b5",
   "metadata": {},
   "source": [
    "We can also specify a number of columns by adding a second number to the slicing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c6f9c28c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df.iloc[35, :3]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0f2c40e",
   "metadata": {},
   "source": [
    "### Accessing with names\n",
    "\n",
    "Each dataframe has an index (rows) and columns. The rows and columns have names. For the columns, these are indicated in `.head` by the bold row at the top of the dataframe. The row names are similarly listed in bold in the left of the dataframe. The index can be named, but by default it is usually just numbered. \n",
    "\n",
    "You can see information about the index or the columns using `df.index` or `df.columns`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fe8421c4",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df.index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fea32803",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df.columns"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba64a576",
   "metadata": {},
   "source": [
    "Some of these column names are very long, and we might not want to type them \n",
    "when we want to reference data. \n",
    "We will rename some of these columns to make accessing the data more convenient."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34d56e51",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df.rename( columns = {\n",
    "    \"ESOL predicted log solubility in mols per litre\": \"ESOL solubility (mol/L)\",\n",
    "    \"measured log solubility in mols per litre\" : \"measured solubility (mol/L)\"\n",
    "}, inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1dccc85a",
   "metadata": {},
   "source": [
    "To access part of a dataframe using the index or column names, would use the `loc` function.\n",
    "\n",
    "Because our index names are just numbers, this doesn't look that different than `iloc` when we are accessing rows.\n",
    "\n",
    "#### The `.loc` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0d700d98",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df.loc[35]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62e0e533",
   "metadata": {},
   "source": [
    "However, we can now use column names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "da288a9b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df.loc[35, \"smiles\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54950b86",
   "metadata": {},
   "source": [
    "#### Using column names\n",
    "\n",
    "You can pull a column of several columns of information using the syntax\n",
    "\n",
    "```python\n",
    "df[column_name]\n",
    "```\n",
    "\n",
    "To pull several columns, do\n",
    "\n",
    "```python\n",
    "df[[colname1, colname2]]\n",
    "```\n",
    "\n",
    "For example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a867a5a7",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df[\"Compound ID\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "15a99ad9",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df[[\"Compound ID\", \"smiles\"]]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "185e0dd7",
   "metadata": {},
   "source": [
    "## Filtering Data\n",
    "\n",
    "There are two ways filtering in dataframes are typically done. Both are shown here for completeness, and because you will see both when looking at code others have written.\n",
    "\n",
    "In the first method, the strategy is that you first establish where something is true within a dataframe, then use that to filter the dataframe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "67e8ba10",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df[\"Polar Surface Area\"] >17"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c6a280d",
   "metadata": {},
   "source": [
    "This gives us a list of values with either `True` or `False` that can be used to index into the dataframe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7bd812f1",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df[df[\"Polar Surface Area\"] > 17]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a9b3e0a1-3198-4909-a6a8-78492440f4d9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e643231-beb2-43a2-99ef-47c6332d83b4",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "62e309f8-bb0d-4ce7-88c4-ad4aaefb49d1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "1208209c",
   "metadata": {},
   "source": [
    "## Sorting Data\n",
    "\n",
    "Pandas allows you to easily sort data using the `sort_values` method. Inside of the function call you list the column you would like to sort by. By default, the values will be sorted from lowest to highest (or `ascending`). This method will `return` a sorted dataframe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a559acad",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df.sort_values(\"Number of H-Bond Donors\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36c8401e",
   "metadata": {},
   "source": [
    "If you include more than one column name, the dataframe will be sorted by multiple columns. First, it will be sorted by the first column indicated, then that sort will be sorted by the second. Consider the following examples. We first sort by `Number of H-Bond Donors`. Within that sort, we sort by `Molecular Weight`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d22687d5",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df_sorted = df.sort_values([\"Number of H-Bond Donors\", \"Molecular Weight\"])\n",
    "df_sorted.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f93be496-c20d-4cec-ba5b-1fb37528551f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87f5ec90-0408-41d6-81ba-e87e73a7f6ab",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "43905fb9",
   "metadata": {},
   "source": [
    "Note the bolded indices to the left of the dataframe. After we perform our sort, these are no longer in order. In the sorted dataframe, `loc` and `iloc` do not return the same values using the same number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4d8ca81f",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df_sorted.loc[934]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8fbc2664",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df_sorted.iloc[934]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37f40ab9",
   "metadata": {},
   "source": [
    "## Performing Operations on Multiple Cells\n",
    "\n",
    "### Broadcasting\n",
    "\n",
    "Pandas dataframes have the convenient feature that they use something called `broadcasting`. This means that if you are doing something like subtracting a number, multiplying, etc to a column or dataframe of information, it can be done all at once instead of with a `for` loop. Consider if we wanted to express the molecular surface area in $nm^2$ instead of Å$^2$. To do this, we would need to divide each value by 100.\n",
    "\n",
    "Instead of writing a `for` loop that does this, we can just write the following code. This will return a pandas Series (one dimensional dataframe). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c0c69c15",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df[\"Polar Surface Area\"] / 100"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51f6f9a8",
   "metadata": {},
   "source": [
    "To save it as a new column, we need to capture the output in a column. You can create a new column in a dataframe using the following syntax."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "85b81987",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df[\"Polar Surface Area (nm^2)\"] = df[\"Polar Surface Area\"] / 100"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4086f42a",
   "metadata": {},
   "source": [
    "You can also add, subtract, or multiply two columns with one another. For example, we might want to calculate the difference between the predicted and observed values for this solubility model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c3e6d45b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df[\"ESOL solubility (mol/L)\"] - df[\"measured solubility (mol/L)\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e046192",
   "metadata": {},
   "source": [
    "\n",
    "<div class=\"exercise admonition\">\n",
    "<p class=\"admonition-title\">Check Your Understanding</p>\n",
    "<p>  Save the difference between the predicted and measured solubility in a column named \"difference\". </p>\n",
    "</div>\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "001723ed-8fd8-472e-9a3b-3af65a90eb1b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d0b22d51-8dfa-4384-aae9-319c6d60a76e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6783e024-7760-47a5-b632-f70292e880e8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "0a02b745",
   "metadata": {},
   "source": [
    "### The `.apply` method - for rows and columns\n",
    "\n",
    "The apply method is used to apply a function to either the rows or columns of a dataframe.  If you use this on a single column, the function will be applied to every value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4d98ca22",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df[\"Compound ID\"].apply(len)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "92aaee4c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df[[\"smiles\", \"Compound ID\"]].apply(len)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13b48f35-0f4c-4741-b618-2ddddb03f574",
   "metadata": {
    "tags": []
   },
   "source": [
    "\n",
    "<div class=\"exercise admonition\">\n",
    "<p class=\"admonition-title\">Check Your Understanding</p>\n",
    "<p>Some libraries from RDKit are imported below. PandasTools for RDKit will be fully explained in the next lesson. Use the apply function to apply Chem.MolFromSmiles to the smiles column of your dataframe. This will create a list of RDKit molecule objects. Save this in a new column called \"molecule\"</p>\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1463cc75-b1d5-454e-9e5c-2737c058e59f",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from rdkit import Chem\n",
    "\n",
    "from rdkit.Chem import PandasTools\n",
    "\n",
    "PandasTools.RenderImagesInAllDataFrames(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bc53dd31-bc3e-4658-bba3-082a32f26b55",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Your code here\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d5c3d022-8f06-4daa-b0c6-329873b5b5a3",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20aa6aa1-3c05-4707-833f-157f9c65ee15",
   "metadata": {},
   "source": [
    "## Visualization with seaborn\n",
    "\n",
    "If you have programmed with Python before, you are probably familiar with the library matplotlib.\n",
    "In this workshop, we will use a library called seaborn. \n",
    "Seaborn is built on top of matplotlib and is commoly used for statistical visualizations.\n",
    "\n",
    "Seaborn [regplot](https://seaborn.pydata.org/generated/seaborn.regplot.html) can be good for seeing linear relationships.\n",
    "It will plot the data of interest with a linear regression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7f784a0a-b629-46b8-b416-a4dd8318b9a9",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "\n",
    "sns.regplot(x=\"Molecular Weight\", y=\"measured solubility (mol/L)\", data=df)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db68c624-de80-4c4d-ba4e-78222ba78274",
   "metadata": {},
   "source": [
    "We can also quickly get a glance at the relationship between variables using a pandas correlation matrix (`df.corr(numeric_only=True))`) and a seaborn heatmap."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9057d79c-ec66-4829-a0e2-a118ec6cb0d3",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "sns.heatmap(df.corr(numeric_only=True), cmap=\"Blues\", annot=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "39b33fc3-6a1a-45c0-8ca4-cb8d85d6da2c",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.columns"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ead6cee9-f1af-4448-8f9a-608b62f4969e",
   "metadata": {},
   "source": [
    "It is common in data science to visualize the relationship of many variables to a quantity of interest by creating several linear plots. \n",
    "In these plots, the variable of interest is typically placed on the y-axis, while each of the other variables takes its turn on the x-axis. This approach allows for a clear view of individual relationships and easy comparison across different variables.\n",
    "\n",
    "Usually, for this visualization, the data must be converted from \"wide format\"\n",
    "to \"long format\".\n",
    "\n",
    "#### 1. Wide Format\r\n",
    "\r\n",
    "In the wide format, each row represents a compound, and each column represents a different attribute or measurement for that compound. This is typically the format that many might first encounter when looking at a spreadsheet or database table.\r\n",
    "\r\n",
    "**Example:**\r\n",
    "\r\n",
    "| Compound ID | Molecular Weight | LogP | Melting Point |\r\n",
    "|-------------|------------------|------|---------------|\r\n",
    "| C1          | 180.16           | 2.3  | 156°C         |\r\n",
    "| C2          | 208.23           | 3.1  | 134°C         |\r\n",
    "| C3          | 152.15           | 1.8  | 165°C         |\r\n",
    "\r\n",
    "#### 2. Long Format\r\n",
    "\r\n",
    "In the long format, each row represents a single measurement or attribute for a particular compound. Instead of having separate columns for each measurement, there are typically columns denoting the compound, the type of measurement, and the value.\r\n",
    "\r\n",
    "**Example:**\r\n",
    "\r\n",
    "| Compound ID | Measurement      | Value  |\r\n",
    "|-------------|------------------|--------|\r\n",
    "| C1          | Molecular Weight | 180.16 |\r\n",
    "| C1          | LogP             | 2.3    |\r\n",
    "| C1          | Melting Point    | 156°C  |\r\n",
    "| C2          | Molecular Weight | 208.23 |\r\n",
    "| C2          | LogP             | 3.1    |\r\n",
    "| C2          | Melting Point    | 134°C  |\r\n",
    "| C3          | Molecular Weight | 152.15 |\r\n",
    "| C3          | LogP             | 1.8    |\r\n",
    "| C3          | Melting Point    | 165°C  |\r\n",
    "\n",
    "\n",
    "Seaborn and pandas are commonly used to create these plots quickly.\n",
    "First, we must use pandas to transform our data to \"long format\" using `pd.melt`.\n",
    "Long format, often referred to as \"tidy\" format, is a way of structuring a dataset where each row is an observation a\n",
    "\n",
    "To get our data in long format, we will need to determine our variables of interest. Let's remind ourselves of our columns.nd each column is a variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b5fe643-d38b-441b-9820-bbdefedbfb09",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.columns"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3d7e28a-bccd-4a94-a9be-9e5de03615c7",
   "metadata": {},
   "source": [
    "For this visualization, we will want only our numeric columns as values. We can use a pandas command to do this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a98268ed-ae02-49e6-bad1-22a8908ec482",
   "metadata": {},
   "outputs": [],
   "source": [
    "numeric_cols = df.select_dtypes(include=['number']).columns.tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1faaa488-d0a7-4533-8afd-ef9b325f6243",
   "metadata": {},
   "outputs": [],
   "source": [
    "long_df = pd.melt(df, id_vars=\"measured solubility (mol/L)\", value_vars=numeric_cols)\n",
    "long_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1fd9eca9-a3c0-417a-90fd-697f6f796aeb",
   "metadata": {},
   "outputs": [],
   "source": [
    "g = sns.lmplot(data=long_df, y=\"measured solubility (mol/L)\", \n",
    "               x=\"value\", col=\"variable\", \n",
    "               col_wrap=2, facet_kws={\"sharex\": False})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "81ff6800-a7fa-49a2-ad06-c34d7e508df5",
   "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.10.12"
  },
  "vscode": {
   "interpreter": {
    "hash": "16d4a7bb199d969b1271ebe46f77414b0d9cd01b3c3983c2b2742fc6cd4503d3"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}