01_primer.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "21642423",
   "metadata": {},
   "source": [
    "Introduction\n",
    "=========="
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0508a0d",
   "metadata": {},
   "source": [
    "<div class=\"overview-this-is-a-title overview\">\n",
    "<p class=\"overview-title\">Overview</p>\n",
    "<p>Questions</p>\n",
    "    <ul>\n",
    "        <li> What is the basic syntax of the python programming language?\n",
    "    </ul>\n",
    "<p>Objectives:</p>\n",
    "    <ul>\n",
    "        <li> Assign values to variables\n",
    "        <li> Use the print function to check how the code is working.\n",
    "        <li> Use multiple assignment to assign several variables at once.\n",
    "        <li> Use a for loop to perform the same action on the items in a list\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a392eb17",
   "metadata": {},
   "source": [
    "## Getting Started\n",
    "Python is a computer programming language that has become ubiquitous in scientific programming.  Our lessons will run python *interactively* through a python interpreter inside a Jupyter notebook.  The [setup](setup.ipynb) page should have provided information on how to install and start a Jupyter notebook.  Everything included in a code block is something you could type into your python interpreter and evaluate.\n",
    "\n",
    "### Setting up your Jupyter notebooks\n",
    "If you are reading this page, then you have succeeded in gaining access to Jupyter notebooks. Now, we will use the notebook to execute Python code. Jupyter notebooks are divided into cells. You run a Jupyter notebook one cell at a time. To execute a cell, click inside the cell and press `shift+enter`.\n",
    "\n",
    "In the upper left corner, click where it says \"Untitled\" and change the name to \"IQB Crash Course\". We have now changed the name of the Jupyter Notebook.\n",
    "\n",
    "Jupyter notebooks allow us to also use something called **markdown** in selected cells. We can use markdown to write descriptions about our notebooks for others to read. It's a good practice to have your first cell be markdown to explain the purpose of the notebook. Let's do that in our first cell. Click inside the first cell, then on the top of the screen select Markdown from the dropdown menu that says *Code*. \n",
    "\n",
    "Now, return to the cell and type the following:\n",
    "\n",
    "```{eval-rst}\n",
    "\n",
    "    # IQB Crash Course Python Scripting in BMB\n",
    "    ## Introduction\n",
    "\n",
    "    This lesson covers Python basics like variable creation \n",
    "    and assignment and using the Jupyter notebook\n",
    "```\n",
    "\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "762d986c",
   "metadata": {},
   "source": [
    "## Assigning variables and data types\n",
    "\n",
    "Any python interpreter can work just like a calculator.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "675fc3ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "3 + 7"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "f4311744",
   "metadata": {},
   "source": [
    "The real power of Python comes when you start creating variables. \n",
    "This allows you to define variable names that have values.\n",
    "A variable can have one single value, like a number, or it can be a collection of values (like a list), or even a collection of actions or calculations and values.\n",
    "\n",
    "To create a variable in Python, the syntax is\n",
    "\n",
    "```python\n",
    "variable_name = variable_value\n",
    "```\n",
    "\n",
    "This is called variable assignment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "965b5239",
   "metadata": {},
   "outputs": [],
   "source": [
    "amount = 0.1 # moles\n",
    "volume = 0.5 # liters"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "3137391b",
   "metadata": {},
   "source": [
    "You can use variables you've defined to perform calculations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c09fe07e",
   "metadata": {},
   "outputs": [],
   "source": [
    "molarity = amount /volume # moles / liter\n",
    "molarity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ff88e8b0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "f75ebf3d",
   "metadata": {},
   "source": [
    "## Data types\n",
    "\n",
    "Each variable is some particular type of data. The most common types of data are strings (str), integers (int), and floating point numbers (float). You can identify the data type of any variable with the function `type(variable_name)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ea222f8d",
   "metadata": {},
   "outputs": [],
   "source": [
    "type(molarity)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "673d1807",
   "metadata": {},
   "outputs": [],
   "source": [
    "# define a 'word' (string)\n",
    "units = \"moles/liter\"\n",
    "type(units)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "09eafb7f",
   "metadata": {},
   "source": [
    "## Formatted (\"f-string\" printing)\n",
    "\n",
    "If you would like to print both variables and text together, you can do so with f-string printing.\n",
    "\n",
    "The syntax for an f-string is\n",
    "\n",
    "```python\n",
    "\n",
    "my_phrase = f\"Hello {variable}\"\n",
    "```\n",
    "\n",
    "where variable is some variable you have defined."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cbf441e2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "da159665",
   "metadata": {},
   "source": [
    "## Lists\n",
    "\n",
    "Another common data structure in python is the list.  Lists can be used to group several values or variables together, and are declared using square brackets \\[_\\]. **Python assigns special meanings to square brackets \\[\\], parentheses () and curly brackets {}, so you must be very careful with these characters.** \n",
    "\n",
    "List values are separated by commas. Python has several built in functions which can be used on lists. The built-in function `len` can be used to determine the length of a list. This code block also demonstrates how to print multiple variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "483c82dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "amounts = [0.1, 0.2, 0.3, 0.5, 0.7]\n",
    "num_elements = len(substrate_concs)\n",
    "\n",
    "# Write a print statement here that prints the length of the list."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "f85e5f96",
   "metadata": {},
   "source": [
    "## Slices\n",
    "\n",
    "If you want to operate on a particular element of the list, you use the list name and then put in brackets which element of the list you want.  **In python counting starts at zero.  So the first element of the list is `list[0]`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "09de3964",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "5e3cba30",
   "metadata": {},
   "source": [
    "Sometimes you will want to make a new list that is a subset of an existing list.  For example, we might want to make a new list that is just the first few elements of our previous list.  This is called a `slice`.  The general syntax is\n",
    "\n",
    "```python\n",
    "new_list = list_name[start:end]\n",
    "```\n",
    "\n",
    "When taking a slice, it is very important to remember how counting works in python.  Remember that counting starts at zero so the first element of a list is `list_name[0]`.  When you specify the last element for the slice, it goes *up to but not including* that element of the list.  So a slice like"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c6c33f8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "ce23bc5a",
   "metadata": {},
   "source": [
    "## Repeating an operation many times: for loops\n",
    "Often, you will want to do something to every element of a list.  The structure\n",
    "to do this is called a `for` loop.  The general structure of a `for` loop is\n",
    "```python\n",
    "for variable in list:\n",
    "    do things using variable\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6307f515",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "89df3aa8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "52c79858",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "3f553d46",
   "metadata": {},
   "source": [
    "## Making choices: Logic Statements\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cf968b6c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "24d974b8",
   "metadata": {},
   "source": [
    "Other logic operations include\n",
    "- equal to `==`\n",
    "- not equal to `!=`\n",
    "- greater than `>`\n",
    "- less than `<`\n",
    "- greater than or equal to `>=`\n",
    "- less than or equal to `<=`\n",
    "\n",
    "You can also use `and`, `or`, and `not` to check more than one condition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aaafe66b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "0fc212ee",
   "metadata": {},
   "source": [
    "## Python Dictionaries\n",
    "\n",
    "An important data type for the workshop today will be a Python dictionary.\n",
    "A Python dictionary is similar to a list in that it is a collection of data, but instead of using numbers to refer to the data, you can use a name.\n",
    "You look up information in a dictionary using names - these are called \"keys\". Each key has an associated value. \n",
    "The syntax for a dictionary is:\n",
    "\n",
    "```python\n",
    "dictionary_name = {\n",
    "    \"key1_name\" : key1_value,\n",
    "    \"key2_name\" : key2_value,\n",
    "}\n",
    "```\n",
    "\n",
    "For instance, we can define a dictionary of amino acids where the three letter code is used for the key, and the values are the molecular weights."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "67e46420",
   "metadata": {},
   "outputs": [],
   "source": [
    "amino_acids = {\n",
    "    \"ALA\": 89.10,\n",
    "    \"ARG\": 174.20\n",
    "}"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "c57ee0d4",
   "metadata": {},
   "source": [
    "We can then \"look up\" values in our dictionary using the keys:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07655e4b",
   "metadata": {},
   "outputs": [],
   "source": [
    "amino_acids[\"ALA\"]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "9b5d7b0f",
   "metadata": {},
   "source": [
    "You can see all of the keys or all of the values of a dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b329e994",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(amino_acids.keys())\n",
    "print(amino_acids.values())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "6892ff76",
   "metadata": {},
   "source": [
    "A common pattern is to loop through a dictionary using `.items()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "37db23b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "for key, value in amino_acids.items():\n",
    "    print(f\"The key is {key}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10abb958",
   "metadata": {},
   "source": [
    "## A note about jupyter notebooks\n",
    "If you use the jupyter notebook for your python interpreter, the notebook only executes the current code block.  This can have several unintended consequences. If you change a value and then go back and run an earlier code block, it will use the new value, not the first defined value, which may give you incorrect analysis.  Similarly, if you open your jupyter notebook later, and try to run a code block in the middle, it may tell you that your variables are undefined, even though you can clearly see them defined in earlier code blocks.  But if you didn't re-run those code blocks, then python doesn't know they exist.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "98cc8d9c",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}