Session1_Introduction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Programming for Chemists\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "The aim of this course is to provide you with the skills to utilise computers in your own scientific work, from data management, analysis and presentation to solving real scientific problems. The beginning of the course focuses more on the formal aspects of the Python language but then transitions into focusing more on solving scientific problems. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Learning Outcomes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At the end of this course participants should be able to demonstrate:\n",
    "\n",
    "* Knowledge of the Python 3 programming language.\n",
    "* An understanding of key data types and structures in Python.\n",
    "* The skills to write and develop simple programs in Python.\n",
    "* The ability to import data from files for analysis and presentation.\n",
    "* The ability to detect errors in programs.\n",
    "* The ability to describe and document the results of a programming project."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Resources"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Recommended textbook:\n",
    "    * Learning Scientific Programming with Python, C. Hill, 2016. Cambridge University Press. **Sussex Ebook link:** https://sussex-primo.hosted.exlibrisgroup.com/permalink/f/c622i2/44SUS_ALMA_DS51141926100002461\n",
    "2. Supplementary reading:\n",
    "    * Python notes for professionals: https://books.goalkicker.com/PythonBook/\n",
    "3. Recommended online resources:\n",
    "    * Official Python documentation: https://docs.python.org/3/\n",
    "4. Mathematical/computer programming problems (Good for application of what you learn, but some are very\n",
    "advanced):\n",
    "    * Project Euler: https://projecteuler.net/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Running Python Code Locally"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The goal of this course is that you will feel comfortable using Python in your own work. In order for this to be realistic, programming using only Jupyter notebooks in web browsers is not that feasible, so I wrote a separate, short tutorial on how to setup an easy and versatile solution for Python programming locally on your own computer using the Visual Studio Code software. Follow [this link](https://adambaskerville.github.io/posts/LocalProgramming/) if this interests you"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Course Overview"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Introduction and Jupyter Notebook.\n",
    "2. Key data types and uses.\n",
    "3. Control Flow Statements.\n",
    "4. Basic NumPy and arrays. \n",
    "5. File input/output using pandas and plotting using matplotlib.\n",
    "6. Physical chemistry using NumPy, SciPy and Sympy.\n",
    "7. Hands on machine learning for chemists."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Programming for Chemists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q. Why learn to program as a chemist?**\n",
    "* The world of chemistry is changing, laboratories are generating increasing quantities of digital data, and chemists need the ability to efficiently process, analyze, and visualize these data.\n",
    "* An increasing number of chemistry and biochemistry related jobs specifically ask for programming experience.\n",
    "* It opens more opportunities in different areas of science outside of your degree subject.\n",
    "* It will make you a more efficient and effective scientist."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q. Why use the Python programming language?**\n",
    "\n",
    "* It is a powerful, general-purpose programming language.\n",
    "* It is a high-level language, meaning it automates fundamental operations such as memory management carried out at the processor level.\n",
    "* It has a large variety of data structures such as lists, tuples, dictionaries and sets.\n",
    "* It can easily interface with lower-level languages such as `C`, `C++`, `Fortran`, `Rust` etc. . . \n",
    "* [It is becoming increasingly popular](https://stackoverflow.blog/2017/09/06/incredible-growth-python/):\n",
    "\n",
    "\n",
    "<center><img src=\"https://raw.githubusercontent.com/adambaskerville/ProgrammingForChemists/master/images/PythonGrowth.png\" width=\"600\" height=\"600\" /></center>\n",
    "\n",
    "* It has a shallow learning curve with a clean and simple syntax.\n",
    "\n",
    "**Example:** Consider printing items from a shopping list using Python vs. using C. To run the Python code element click on the code and hold <kbd>SHIFT</kbd> and press <kbd>ENTER</kbd>. This notebook can not run the C code as it only works with one kernel at a time. You do not need to understand the syntax here as we will discuss it in a future session."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Python Syntax:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "shopping = [\"Bread\", 'Oranges', 'Soup', 'Tea'] \n",
    "for item in shopping:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**C Syntax (cannot be run in this notebook):**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "#include <stdlib.h>\n",
    "#include <string.h>\n",
    "#define MAX_STRING_LENGTH 20\n",
    "#define NUMBER_OF_STRINGS 4\n",
    "int main()\n",
    "{\n",
    "    int i;\n",
    "    char shopping[NUMBER_OF_STRINGS][MAX_STRING_LENGTH + 1];\n",
    "    strcpy(shopping[0], \"Bread\");\n",
    "    strcpy(shopping[1], \"Oranges\");\n",
    "    strcpy(shopping[2], \"Soup\");\n",
    "    strcpy(shopping[3], \"Tea\");\n",
    "    \n",
    "    for (i=0; i<NUMBER_OF_STRINGS; i++) {\n",
    "        fprintf(stdout, \"%s\\n\", shopping[i]);\n",
    "    }\n",
    "}\n",
    "\n",
    "# Output:\n",
    "Bread\n",
    "Oranges\n",
    "Soup\n",
    "Tea"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python was designed to be a highly readable language, with a relatively uncluttered visual layout making use of English keywords where other languages use punctuation. Python aims to be simple and consistent in the design of its syntax which is clear from the above example."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Google Colab\n",
    "\n",
    "\n",
    "Google Colab is the platform we will use to host and interact with the Jupyter notebooks. To access the Jupyter notebooks in this course:\n",
    "\n",
    "1. Visit my website: https://adambaskerville.github.io/tabs/progchem/. \n",
    "2. Click the `Open in Colab` button.\n",
    "\n",
    "    [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/adambaskerville/ProgrammingForChemists/blob/master/)\n",
    "\n",
    "3. You can then select which notebook you want to view and interact with. You can save copies of your version of the notebooks to your local drive or to cloud storage, but **cannot override the master copies on GitHub** as all your changes are done locally on your ocmputer.\n",
    "4. When I update the worksheets, Binder may take slightly longer to start the next time you use it, as it has to re-initialize the server.\n",
    "5. If Google Colab is not working you can use Binder instead, but the sessions will take longer to load.\n",
    "\n",
    "    [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/adambaskerville/ProgrammingForChemists/HEAD)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Jupyter Notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **The Jupyter notebook is what you are using now.** It is an open document that can contain documentation, code, interactive elements, and the output of your Python code such as plots and numerical values.\n",
    "* It is an interactive environment, ideal for data processing and visualisation and suitable for sharing with others.\n",
    "* It is Free and Open Source Software (FOSS) and accessible anywhere, either online or downloadable for offline use.\n",
    "* Each interactive session will take place at a computer using a Jupyter Notebook and any required data files.\n",
    "* **Note** you do not *need* a Jupyter notebook to run Python code. Python code is most commonly developed in text editors locally and run through your computers' terminal. The Jupyter notebook is used in these tutorials for the convenience of allowing text and usable code cells in the same format and without the need for UNIX commands."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Notebook Interface\n",
    "\n",
    "The Jupyter interface will hopefully not look entirely alien; after all, Jupyter is essentially an advanced word processor. Take a look around the menus and get a feel for the options. There are two terms that you should notice, cells and kernels, which are key to understanding Jupyter and to what makes it more than just a word processor:\n",
    "\n",
    "* A **kernel** is a “computational engine” that executes the code contained in a notebook document.\n",
    "* A **cell** is a container for text to be displayed in the notebook or code to be executed by the notebook’s kernel.\n",
    "\n",
    "Cells form the body of a Jupyter notebook, and they come in two main types:\n",
    "\n",
    "* A **code** cell contains code to be executed in the kernel and displays its output below the cell.\n",
    "* A **Markdown** cell contains text formatted using the Markdown language and displays its output in-place when it is run.\n",
    "\n",
    "By **double clicking** the text elements you can **modify the text** giving you full control over the notebook; allowing you to add your own notes or reword parts to make them clearer to you. None of this affects the master branch. To exit the editor hold <kbd>SHIFT</kbd> and press <kbd>ENTER</kbd>. See the following gif for what this looks like:\n",
    "\n",
    "<center><img src=\"https://raw.githubusercontent.com/adambaskerville/ProgrammingForChemists/master/images/markdownEdit.gif\" width=\"auto\" height=\"auto\" /></center>\n",
    "\n",
    "\n",
    "To use Python in a Jupyter notebook, type your Python code into a code cell which is one of these: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is a code cell!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and hold <kbd>SHIFT</kbd> and press <kbd>ENTER</kbd> to run the code or click the play button at the left hand side of the cell; and the output is printed below the cell. It is **highly encouraged** to add your own code to the example code cells as you progress through the sessions and experiment with what you are learning and test any ideas you have. \n",
    "\n",
    "<font color='red'>Throughout the notebooks are red text statements highlighting where code is required or suggested from you.</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Unhiding Cells "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Google Colab has an annoying feature whereby it will automatically collapse cells in order to shorten the length of the notebook. This is a minor inconvenience, but we can expand all the cells to be visible by doing the following: \n",
    "\n",
    "1. Click `Edit -> Select all cells.` \n",
    "2. Click `View -> Expand sections.`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inserting and Deleting Cells"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can insert new code cells above or below the currently selected one by clicking `Insert -> Code cell` on the top menu.\n",
    "\n",
    "You can insert new text (markdown) cells by clicking `Insert -> Text cell` on the top menu.\n",
    "\n",
    "You can delete cells by clicking `Edit -> Delete selected cells` on the top menu."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Saving Your Notebooks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All of the changes you make or add to the notebooks can be downloaded and saved to your local computer. Remember that **anything not saved before you exit the notebooks will be deleted.** If you want to download the jupyter notebook you can go to `File -> Download -> Download .ipynb`. A variety of applications can open and run these including `VScode`. You can also save the notebooks to Google Drive from the `File` menu."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Getting Started with Python 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hello World!\n",
    "\n",
    "A tradition when learning a new language is to print \"Hello World!\" to the screen, which we will now do. To print this in Python we need to invoke the `print` function and inside it write, \"Hello World\" in quotation marks which represent the **string** datatype in the Python language; we will cover strings in more detail in the next session. To learn the syntax and how to run the code, <font color='red'>type this into the code box below `print(\"Hello World!\")` then run the code</font>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note the importance of the quotation marks in the above code example. Run the following code which does not include them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(Hello World)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is invalid syntax as we have now told Python to print variables Hello and World which we have not defined. \n",
    "\n",
    "Now we have got to grips with Jupyter, let's learn some Python fundamentals. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating Variables and Assigning Values\n",
    "One of the most important things that we want to do is create **variables** which represent a quantity whose value can change. To do this in Python, we need to specify the variable name, and then assign a value to it, which is done using the following syntax, `variable name = value`. \n",
    "\n",
    "<font color='red'>Lets assign the value 10 to the letter `x` as follows; printing the value to the screen as well:</font>\n",
    "\n",
    "`x = 10`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variable assignment works from left to right. <font color='red'>So the following will give you a syntax error:</font>\n",
    "\n",
    "`10 = x`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are strict rules for naming of variables:\n",
    "\n",
    "1. Variable names must start with a letter or an underscore:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 10 # valid\n",
    "_y = 10 # valid\n",
    "\n",
    "9x = 10 # Invalid as starts with numeral\n",
    "$y = False # Invalid as starts with symbol"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. The remainder of your variable name may consist of letters, numbers and underscores."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Names are case sensitive:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 9 # Define variable lower case x\n",
    "y = X*5 # 'Accidentally' call upper case X "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you use `=` to do an assignment, what's on the left of `=` is a **name** for the **object** on the right. `=` assigns the **reference** of the object on the right to the **name** on the left. That is:\n",
    "\n",
    "```a_name = an_object # \"a_name\" is now a name for the reference to the object \"an_object\"```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can assign multiple values to multiple variables in one line, but there must be an equal number of arguments on the left and right sides of the `=` operator. <font color='red'>This is done using the syntax:</font>\n",
    "\n",
    "`x, y, z = 1, 2, 3`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "print(x, y, z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also assign a single value to several variables simultaneously. <font color='red'>This is done using the syntax:</font>\n",
    "\n",
    "`x = y = z = 1`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "print(x, y, z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variable values can be updated with new values throughout the program:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1\n",
    "y = 2\n",
    "print(x + y)\n",
    "\n",
    "x = 3 # Assign a different object to x\n",
    "print(x + y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comments\n",
    "In the above examples you may have noticed multiple `#` symbols with text written after them. These are known as **comments** and are a crucial and often underused aspect of programming languages. Comments are lines that exist in computer programs that are ignored by the program. Including comments in programs makes code more readable for humans:\n",
    "\n",
    "* It provides some information or explanation about what each part of a program is doing. \n",
    "* It is a good idea to write comments while you are writing or updating a program as it is easy to forget your thought process later on.\n",
    "* Comments written later may be less useful in the long term\n",
    "* Comments are very appreciated by someone who may use your program or be tasked with modifying parts of it, as they need an insight into your thought process.\n",
    "\n",
    "Try to avoid **W.E.T** comments meaning you 'Wrote Everything Twice'. Comments such as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a)  # prints a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Your comments should be **D.R.Y.** (Don’t Repeat Yourself) and offer insight into how the code truly functions. Do not be afraid to write about limitations or future changes you want to make with the code as **no program is perfect.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Review"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this session we covered:\n",
    "\n",
    "* Motivation for learning to program.\n",
    "* Motivation for using Python.\n",
    "* How to use a Jupyter notebook.\n",
    "* Printed Hello World!\n",
    "* How to assign variables in Python.\n",
    "* How to write comments in python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Assign the number 45 to the letter f.\n",
    "2. Assign the number 13 to the letter g. \n",
    "3. Print both these variables to screen. \n",
    "4. Reassign the value of f to the value of g and print the sum of the two numbers. \n",
    "5. Add a comment at the top of the code box explaining what the short code does."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Glossary\n",
    "\n",
    "Throughout this course many acronyms and phrases will be used, presented here for easy lookup:\n",
    "\n",
    "* **AI:** Artificial Intelligence.\n",
    "* **Algorithm:** A list of steps to finish a task.\n",
    "* **Code:** The language that programmers create and use to tell a computer what to do.\n",
    "* **CPU:** Central Processing Unit. This is the electronic circuitry within a computer that executes instructions that make up a computer program.\n",
    "* **Data:** Information. Often, quantities, characters, or symbols that are the inputs and outputs of computer programs.\n",
    "* **Debugging:** Finding and fixing problems in an algorithm or program.\n",
    "* **DL:** Deep Learning.\n",
    "* **Function:** A piece of code that you can easily call over and over again.\n",
    "* **GPU:** Graphical Processing Unit. A specialized, electronic circuit designed to rapidly manipulate and alter memory to accelerate the creation of images. a specialized, electronic circuit designed to rapidly manipulate and alter memory to accelerate the creation of images  \n",
    "* **Hard Drive (HDD):** This is an example of non-volatile random-access memory; where the non-volatile means the disk keeps its bytes even after being powered off.\n",
    "* **Loop:** The action of doing something over and over again.\n",
    "* **ML:** Machine Learning.\n",
    "* **Program:** An algorithm that has been coded into something that can be run by a machine.\n",
    "* **Pseudocode:** Pseudocode is a plain language description of the steps in an algorithm or another system.\n",
    "* **RAM:** Random Access Memory. This is a form of computer memory that can be read and changed in any order, typically used to store working data and machine code.\n",
    "* **Variable:** A placeholder for a piece of information that can change."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Library Information"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This section is included for information on the relevant libraries used throughout this course:\n",
    "    \n",
    "- numpy        = 1.16.4\n",
    "- scipy        = 1.3.1\n",
    "- sympy        = 1.4\n",
    "- pandas       = 1.1.1\n",
    "- scikit-learn = 0.20.3\n",
    "- seaborn      = 0.9.0\n",
    "- matplotlib   = 3.1.0\n",
    "- deepchem     = 2.3.0\n",
    "- tensorflow   = 1.14\n",
    "- gast         = 0.2.2"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.3"
  },
  "toc-autonumbering": true
 },
 "nbformat": 4,
 "nbformat_minor": 4
}