periodic-trends.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align:center;\">\n",
    "  <img src=\"images/molssi_main_horizontal.png\" style=\"display: block; margin: 0 auto; max-height:200px;\">\n",
    "</div>\n",
    "\n",
    "# Analyzing Periodic Trends with Python\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "\n",
    "Questions:\n",
    "\n",
    "* How can I analyze data using Python?\n",
    "\n",
    "* How can I use Python to visualize data?\n",
    "\n",
    "\n",
    "Objectives:\n",
    "\n",
    "* Learn to import a Python package.\n",
    "\n",
    "* Learn to use Python to analyze tabular data.\n",
    "\n",
    "* Learn to use the Python package `plotly` to create interactive plots.\n",
    "\n",
    "</div>\n",
    "\n",
    "## Introduction\n",
    "\n",
    "As chemists, one of the first things we learn about in our courses is the periodic table.\n",
    "The periodic table arranges chemical elements into rows and columns based on their atomic number and electron configuration.\n",
    "\n",
    "In this notebook, we will use two Python libraries to analyze and visualize periodic trends.\n",
    "\n",
    "Our data is stored in a comma-separated values (CSV) file. You might be familiar with this format from spreadsheet software like Microsoft Excel or Google Sheets.  We will use the `pandas` library to read the data from the CSV file and analyze it. We wiill then examine periodic trends using the `plotly` library to create plots.\n",
    "\n",
    "We obtained this data from the [Periodic Table on PubChem](https://pubchem.ncbi.nlm.nih.gov/periodic-table/). \\\n",
    "For this workshop, we also slightly processed the data so that there is a column for the period of the element in the periodic table.\n",
    "Our data is in a CSV file in the `data` directory of this repository.\n",
    "\n",
    "### Importing Libraries\n",
    "\n",
    "For this notebook, we will be reading and analyzing data using `pandas`. \n",
    "These are not part of standard Python, and we must import the package to use it.\n",
    "When we import a package, we can give it an alias to make it easier to use.\n",
    "\n",
    "The synatx for importing a package is \n",
    "\n",
    "```python\n",
    "import package_name as alias\n",
    "```\n",
    "\n",
    "Then, we can use functions in the package by calling `alias.function_name`.\n",
    "\n",
    "## Reading and Analyzing Data using `pandas`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is how we import the pandas library\n",
    "# we give it the name \"pd\"\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To read data from a CSV file, we will use the `read_csv` function from the `pandas` package.\n",
    "You can read more about this function in your Jupyter notebook by typing `pd.read_csv?` in the cell below. When you run the cell a window will pop up with the documentation for the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use this cell to read about pd.read_csv\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\"> \n",
    "<strong> Python Documentation </strong>\n",
    "\n",
    "Most popular Python libraries have very good online documentation. \n",
    "You can find the pandas documentation by googling \"pandas docs\".\n",
    "You will be able to find the same help message you get for `read_csv` as well as tutorials and other types of documentation.\n",
    "\n",
    "1. [Pandas Documentation](https://pandas.pydata.org/docs/)\n",
    "2. [`read_csv` documentation](https://pandas.pydata.org/docs/reference/api/pandas.read_csv.html)\n",
    "</div>\n",
    "\n",
    "Now that we've read about `read_csv`, let's use the function to read our data. \n",
    "It is common to name the variable from the `read_csv` function `df`. This is short for `DataFrame`.\n",
    "Since this file is relatively simple, we do not need any additional arguments to the function. The `read_csv` function reads in tabular data which is comma delimited by default.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use the read_csv function to read the file \"data/PubChemElements_all.csv\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Examining the data\n",
    "\n",
    "The variable `df` is now a pandas DataFrame with the information contained in the csv file. You can examine the DataFrame using the `.head()` method. \n",
    "This shows the first 5 rows stored in the DataFrame.\n",
    "The first row of the file was used for column headers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use the df.head() method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<div class=\"alert alert-block alert-success\"> \n",
    "<strong>Python Skills: Python Objects</strong>\n",
    "\n",
    "In this notebook, we will be working with Pandas Dataframe objects.\n",
    "In Python, we use the word \"object\" to refer to a variable structure that has associated data and can perform actions (called \"methods\").\n",
    "One example of an object we have seen in notebooks is a list - we could also call it a \"list object\". An object has `attributes` (data) and `methods`. \n",
    "You access information about objects with the syntax\n",
    "\n",
    "```python\n",
    "object.data\n",
    "```\n",
    "where data is the attribute name.\n",
    "\n",
    "You acceess object methods with the syntax\n",
    "```python\n",
    "object.method(arguments)\n",
    "```\n",
    "\n",
    "For example, for a list \"`append` is a method that was covered in the introductory lesson.\n",
    "\n",
    "```\n",
    "my_list = []\n",
    "my_list.append(1) # \"append\" is a method\n",
    "```\n",
    "</div>    \n",
    "\n",
    "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,
   "metadata": {},
   "outputs": [],
   "source": [
    "# use the df.info() method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This output will show information about each column of data.\n",
    "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",
    "We can also see how many values are in each column.\n",
    "\n",
    "We can also see descriptive statisics easily using the `.describe()` command."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# use the df.describe() method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accessing Data in DataFrames\n",
    "\n",
    "One way to get information in a data frame is by using the headers, or the column names using square brackets. The synatx for this is\n",
    "\n",
    "```python\n",
    "dataframe[\"column_name\"]\n",
    "```\n",
    "\n",
    "For example, to get the column with information about the atomic symbol, we would use the \"Symbol\" column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"Symbol\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# try some other column names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# try some other column names\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to select multiple columns, you use a list of column names in square brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[[\"Symbol\", \"AtomicNumber\"]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get data using number index\n",
    "\n",
    "If we want to get information in the dataframe using row and column numbers, we use the `iloc` function.\n",
    "\n",
    "The syntax for `iloc` is\n",
    "\n",
    "```python\n",
    "dataframe.iloc[row_number, column_number]\n",
    "```\n",
    "\n",
    "If you specify only a row number, you will get all the columns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This will get the first row, all of the columns.\n",
    "df.iloc[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This will get the first row and the second column.\n",
    "df.iloc[0, 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\"> \n",
    "\n",
    "<h3>Check Your Understanding</h3>\n",
    "\n",
    "How would you get the `ElectronConfiguration` column?\n",
    "\n",
    "How would you get the value in row index 10 of the `ElectronConfiguration` column?\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Performing Calculations\n",
    "You can do mathematical operations on entire columns  or rows of `pandas` dataframes using single lines of code.\n",
    "For example, if we wanted to subtract 273.15 from our melting point column, we could do so by writing one expression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"MeltingPoint\"] - 273.15"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To save your calculation in a new column in your dataframe,\n",
    "use the syntax\n",
    "\n",
    "```python\n",
    "df[\"new_column_name\"] = CALCULATION\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"MeltingPointC\"] = df[\"MeltingPoint\"] - 273.15"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Filtering Data\n",
    "\n",
    "We can also filter data using signs like greater than `>`, less than `<`, or equal to `==`.\n",
    "\n",
    "In the cell below, we check whether or not each boiling point is greater than 500.\n",
    "If it is, `True` is returned, if not `False`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"BoilingPoint\"] > 500"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use this as an index or slice, similar to how we learned with lists.\n",
    "We can see from the output that this gives us 80 elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "above_500 = df[df[\"BoilingPoint\"]>500]\n",
    "\n",
    "above_500.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\"> \n",
    "\n",
    "<strong>Check Your Understanding</strong>\n",
    "\n",
    "Use filtering to find all elements with a \"Solid\" standard state.\n",
    "\n",
    "You can solve this problem by working in steps:\n",
    "\n",
    "(1) Get the `StandardState` column.\n",
    "\n",
    "(2) Use a logic operation to find if the value of the `StandardState` column is equal to \"Solid\".\n",
    "\n",
    "(3) Use the result of the logic operation to filter the data.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Put your code here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Saving a new DataFrame\n",
    "\n",
    "If you wanted to save your data to a csv, you could do it using the method `to_csv`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.to_csv(\"data/periodic_data_processed.csv\", index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualization: Analyzing Periodic Trends\n",
    "\n",
    "Now that we've learned how to access and manipulate data in a DataFrame, we can start to analyze periodic trends.\n",
    "\n",
    "The first trends we'll observe are related to **Atomic radius** - how does the atomic radius change as we increase atomic number? How does it change across a period or down a group? An effective way to see this will be to create visualizations of the trends. We will use a library called [plotly](https://plotly.com/python/) to create interactive plots. \n",
    "\n",
    "Plotly is a powerful library for interactive plotting in Jupyter notebooks. \n",
    "You can see examples by clicking the provided link.\n",
    "\n",
    "In this workshop, we'll be keeping our plots simple. We'll use an interface called `plotly.express`, which is meant to be a quick way to create plots."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import plotly.express as px"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After we've imported the `plotly.express` package, we can use the `line` function to create a line plot.\n",
    "The first argument is the DataFrame, the second argument is the x-axis, and the third argument is the y-axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = px.line(df, x=\"AtomicNumber\", y=\"AtomicRadius\")\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you hover your mouse over the points in the plot above, you can see the values of the data points. This is a feature of `plotly` plots.\n",
    "\n",
    "You could also use the `scatter` function to create a scatter plot.\n",
    "Try using the `scatter` function to create a plot with `AtomicRadius` on the y-axis and `AtomicNumber` on the x-axis in the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use px.scatter to make a scatter plot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\"> \n",
    "\n",
    "<strong>Check Your Understanding</strong>\n",
    "\n",
    "Create a scatter plot with `ElectronAffinity` on the y-axis and `AtomicNumber` on the x-axis.\n",
    "\n",
    "Try adding another argument called `color` to the `scatter` function and set it equal to `GroupBlock`. Try coloring by `Period`. Are there any trends you can see in the data?\n",
    "\n",
    "What happens if you use `px.line` instead of `px.scatter`?\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plotly can also be used to create box plots to more easily see data distributions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Create a box plot\n",
    "fig = px.box(df, x=\"GroupBlock\", y=\"AtomicRadius\", title=\"Atomic Radius by Group Block\")\n",
    "\n",
    "# Show plot\n",
    "fig.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\"> \n",
    "\n",
    "<strong>Final Challenge</strong>\n",
    "\n",
    "Create a line plot with `ElectronAffinity` on the y axis and `Period` on the x axis. Your plot have a line for `Halogen`, a line for `Alkali metal`, and a line for `Noble gas`. \n",
    "\n",
    "Starting code is given in the cell below to show you how to filter the data for multiple groups.\n",
    "\n",
    "The steps to solving this will be:\n",
    "\n",
    "1. Add `Alkali metal` to the filter.\n",
    "\n",
    "2. Get just the rows where the filter is `True` using indexing.\n",
    "\n",
    "3. Save a new dataframe with the filtered data.\n",
    "\n",
    "4. Create the line plot with the new dataframe.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This will tell you if the value in \"GroupBlock\" for each row is either \"Halogen\" or \"Noble gas\"\n",
    "df[\"GroupBlock\"].isin([\"Halogen\", \"Noble gas\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "biochemist-python",
   "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.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}