01a_Intro_to_python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "0UBNExO0rS_Z"
   },
   "source": [
    "# Intro to (/review of) python \n",
    "In the next few lessons, we'll review basic python and programming concepts, as well as go over the fundamentals of how to use some common python packages, such as:\n",
    "- numpy\n",
    "- pandas\n",
    "- matplotlib\n",
    "\n",
    "## Importing packages\n",
    "Packages are collections of pre-written code made available for reuse. Packages are convenient because they save you from having to implement every feature and function on your own. The widely-used packages also provide a standard, common set of tools for others to develop with --- allowing interoperability between programs.\n",
    "\n",
    "There are a few different ways to import  package in python:\n",
    "\n",
    "The simplest is just to `import {packagename}`. For this lesson, we'll use `numpy` as the example package\n",
    "```python\n",
    "import numpy\n",
    "```\n",
    "The functions, classes, and variables of the `numpy` package can then be accessed using \"dot\" notation: for example, the numpy array class can be accessed with `numpy.array`\n",
    "\n",
    "---\n",
    "A variant of this is to use `import {packagename} as {shortname}`, as in:\n",
    "```\n",
    "import numpy as np\n",
    "```\n",
    "This reduces the number of characters needed to type, and can be convenient if the package name is long, or you need to use many things from the same package. Accessing the numpy array class, for example, can be done with ```np.array```\n",
    "\n",
    "---\n",
    "\n",
    "If you only need a subset of items from a package, for example, a single class, function, or a submodule (subpackage of the main package), you can use the syntax ``` from {packagename} import {element}```, as in:\n",
    "```\n",
    "from numpy import array\n",
    "```\n",
    "This allows you to use the `array` class directly, without importing the rest of the numpy package, and without needing to use the package prefix dot notation.\n",
    "For example, if you use this import method, then writing\n",
    "```python\n",
    "test_array = array([0])\n",
    "```\n",
    "would be equivalent to writing\n",
    "```python\n",
    "test_array = numpy.array([0])\n",
    "test_array = np.array([0])\n",
    "```\n",
    "using the previous import styles, respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Sh6gjbXsq-Mr"
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Ia4KAaLVv_eA"
   },
   "source": [
    "## Documentation\n",
    "\n",
    "Packages contain functions, classes, and variables which may be helpful. Crucial to the usability of a package is the documentation (or API reference), which (should) list all of the contents of the package, and how to use them.\n",
    "\n",
    "To get the built-in help about a function or class, use the `help()` command\n",
    "\n",
    "Documentation for most common packages are also usually available online. For example, the documentation for [numpy can be found here](https://docs.scipy.org/doc/numpy/reference/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 241
    },
    "colab_type": "code",
    "id": "1HBI-270uEKo",
    "outputId": "a5965918-1d30-427f-daf3-781faff0b010"
   },
   "outputs": [],
   "source": [
    "help(print)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "JRy_xcT2zHyQ"
   },
   "source": [
    "### Commenting code\n",
    "In order for your code to be readable to others (or your future self), you should provide comments on your code to explain what you are doing. The comment character in python is `#`, and any text following a `#` symbol will not be interpreted as code by python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 73
    },
    "colab_type": "code",
    "id": "PZgpEmkSvkWT",
    "outputId": "a4f8027b-9cac-4fb0-d5db-2b93c3ede118"
   },
   "outputs": [],
   "source": [
    "array_of_zeros = np.zeros([3,3]) # this creates a 3x3 array full of zeros\n",
    "print(array_of_zeros) # the print() function displays the value of the variable on screen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## String formatting\n",
    "You can insert variable values into strings a few different ways in python. We will highlight two main ways\n",
    "\n",
    "The first, and preferred method is using `f-strings`, which follow this form:\n",
    "```python\n",
    "x = 10\n",
    "print(f'the value of x is {x}')\n",
    "```\n",
    "should return\n",
    "```\n",
    "the value of x is 10\n",
    "```\n",
    "`f-strings` begin with an `f` and are followed by single `'` or double quotes `\"`, then contain a string, and use curly braces `{}` with a variable name inside of the curly braces to indicate what variable value should be inserted in there. \n",
    "\n",
    "Let's try it! Try changing the value of `x` and rerunning the cell below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 10\n",
    "print(f'the value of x is {x}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also include expressions and operations inside the curly braces. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = 20\n",
    "print(f'the sum of x={x} and y={y} is x+y={x+y}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There's actually a shortcut way of printing out a variable name and value using `f-strings` using the `=` operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f'the sum of {x=} and {y=} is {x+y=}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The second way of including values is using the `.format()` method of strings. This method does not require you to start the string with an `f` before the opening quotation marks, and still uses the curly braces. You can pass in arguments to `.format()`, and the order in which you pass in the arguments is the order in which the curly braces will be filled.\n",
    "\n",
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('the value of x is {} and the value of y is {}'.format(x,y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can get more flexibility for positioning by putting a variable name in the curly braces, and passing in arguments as named arguments to `.format()`. The variables will be filled with the argument name in the `.format()` function, not the global variable name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('the value of x is {a} and it is still {a} no matter what the value of y is, which is {b}'.format(a=x, b=y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In general, we prefer to use `f-string` style formatting, since it is more intuitive which variable's value is being subsituted into the string, but some older documentation may use the `.format()` style.\n",
    "\n",
    "For more flexibility about how numbers are displayed, such as choosing how many digits to display, alignment, etc. Check out this documentation https://docs.python.org/3/library/string.html#format-string-syntax\n",
    "\n",
    "Note that there is an even older way, reminiscent of C-style string formatting using the `%` operator. We will not use that. https://docs.python.org/3/tutorial/inputoutput.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "jx899IXrFTkM"
   },
   "source": [
    "## Code flow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "OcozBa0m5sMX"
   },
   "source": [
    "\n",
    "### Loops\n",
    "A key part of programming is automating repetitive tasks, such as applying the same operation to a list of inputs. This is achieved using \"loops\"; most commonly, the `for` loop.\n",
    "\n",
    "In its simplest form, a python loop iterates over a list, and runs the code within the loop with the variable set equal to the respective element of the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 129
    },
    "colab_type": "code",
    "id": "MKvAT1qCCaUR",
    "outputId": "e039b861-2125-4b50-f18e-7c764b8ec9fa"
   },
   "outputs": [],
   "source": [
    "idx_list = [0,1,2,3,4,5]\n",
    "for idx in idx_list: # loop over idx_list, set idx equal to each element sequentially\n",
    "  print(f'idx is equal to {idx}') # print the current value of idx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ZRpG45DSPYgt"
   },
   "source": [
    "Lists are not the only kinds of objects that can be iterated over (also known as an iterable). A special kind of object, called a generator, does not explicitly store every single value in memory, but instead stores the current value, and the rule to generate the next value. This can often be faster than explicitly storing every element.\n",
    "\n",
    "As an analogy, if you wanted to send to your friend the following sequence of numbers: [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59], you could write each number down and send them the entire list. Or you could write \"the sequence of numbers starting at 1, increasing by 2, but less than 60\"\n",
    "\n",
    "If the sequence is very long, then the second representation becomes preferable to write, because you don't need to explicitly write out every single element. One common generator that is used in python is `range(start, end, increment)`, which creates a generator that produces the sequence of numbers starting at `start`, increments by `increment`, and is less than (__but not equal to__) `end`.  If `increment` is not set, it defaults to 1.\n",
    "\n",
    "This is often used in conjunction with iteration:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 129
    },
    "colab_type": "code",
    "id": "JL8HijzxPWeN",
    "outputId": "3388905a-273b-4f96-9e6d-5437482f8a98"
   },
   "outputs": [],
   "source": [
    "for idx in range(0,6): #equivalent to the above\n",
    "  print(f'idx is equal to {idx}') # print the current value of idx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 129
    },
    "colab_type": "code",
    "id": "qwbL0GxA2NnZ",
    "outputId": "aa073c7d-c9a6-4eb2-b137-0d16789950c2"
   },
   "outputs": [],
   "source": [
    "for idx in range(6): # if you only give one argument, it automatically starts from 0\n",
    "  print(f'idx is currently {idx}') # print the current value of idx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "MQdQLzlFfTxD"
   },
   "source": [
    "### Conditionals\n",
    "Sometimes you want to execute code only if certain conditions are met. The `if`, `elif` (short for else-if), and `else` keywords are used for this purpose"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 111
    },
    "colab_type": "code",
    "id": "AErHQm2wfUJ-",
    "outputId": "a31bbbac-407f-45c4-b2a9-db255ac658b5"
   },
   "outputs": [],
   "source": [
    "for idx in range(1,6):\n",
    "  if idx > 2 : # only execute the following indented block of code if idx is greater than 2\n",
    "    print(f'idx={idx}, which is greater than 2')\n",
    "  elif idx == 2: # only execute if the above condition isn't met, and also idx==2\n",
    "  # note that == is used to check for equality; single = is the assignment operator\n",
    "    print(f'idx={idx} is equal to 2') \n",
    "  else: # execute this code if none of the above conditions are met\n",
    "    print(f'idx={idx} is less than 2')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "xQAVoJ1G9KYX"
   },
   "source": [
    "You can combine different conditions using the keywords `and` and `or`, and negate conditions using `not`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 69
    },
    "colab_type": "code",
    "id": "SOFosKF49UzB",
    "outputId": "94cbab61-4a04-43e0-871a-61ecaf70162f"
   },
   "outputs": [],
   "source": [
    "x = 5\n",
    "y = 10\n",
    "print(x==5 or y==11) # true because first statement is true\n",
    "print(x==5 and y==11) # false because not both are true\n",
    "print(x==5 and not y==11) # true because second condition is negated (flipped)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_86EnzJ86VRX"
   },
   "source": [
    "### List comprehension\n",
    "\n",
    "You can generate a list from any iterable in a couple ways. This is called list comprehension.\n",
    "\n",
    "The simplest way is just to call `list()` on the generator object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "id": "4RXzlU3v2ouq",
    "outputId": "51c83373-978b-44e8-933a-1ed44c829b30"
   },
   "outputs": [],
   "source": [
    "list(range(6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "FwHMdFXo6kTU"
   },
   "source": [
    "Another way is using the following syntax:\n",
    "\n",
    "```python\n",
    "[x for x in iterable]\n",
    "```\n",
    "for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "id": "HyBFG1T16UX8",
    "outputId": "cb1e41df-f86c-4bba-ab2b-8f15bc221a88"
   },
   "outputs": [],
   "source": [
    "list_of_numbers = [x for x in range(6)]\n",
    "print(list_of_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "vOQBvnHH69LF"
   },
   "source": [
    "However, the list comprehension syntax is actually more powerful than that: it allows for functions to be called within the expression\n",
    "```python\n",
    "[expression(x) for x in iterable]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "id": "08Z_-RIm7X10",
    "outputId": "e7fe7125-d4d0-4852-e815-2332471bd839"
   },
   "outputs": [],
   "source": [
    "list_of_first_five_squares = [x**2 for x in range(6)] # the double star ** expression denotes exponentiation\n",
    "# hence, the above gives the first 5 square numbers, including zero\n",
    "print(list_of_first_five_squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "hGn3HhxP7vPs"
   },
   "source": [
    "In fact, the list comprehension syntax is even more powerful: it can also include conditional statements\n",
    "```python\n",
    "[expression(x) for x in iterable if condition]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "id": "uRQy9G6j8KIk",
    "outputId": "513e8b0a-edaa-4954-8d27-ed87855b8c83"
   },
   "outputs": [],
   "source": [
    "list_of_first_few_odd_squares = [x**2 for x in range(10) if np.mod(x,2) == 1] \n",
    "print(list_of_first_few_odd_squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now try to print a list of the first few even cubes using list comprehension. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "coaXDh3Q3Oo4"
   },
   "source": [
    "## Functions\n",
    "Functions are a way to repeat the same lines of code, potentially with different inputs. If you find yourself writing a lot of repetitive code that shares the same structure, you may want to try and formulate it as a function. Functions are declared using the `def` keyword. In this example, we will write a function that checks if a number is prime.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "q3bNz4Bn4LtT"
   },
   "outputs": [],
   "source": [
    "def is_prime(number):\n",
    "    if type(number) is int:\n",
    "        if number < 2: # all negative numbers, 0, and 1 are not prime\n",
    "            return False \n",
    "        sqrt_num = int(np.sqrt(number)) # we only need to check integer factors up to the square root of the number, rounded down (int() always rounds down)\n",
    "        for potential_factor in range(2,sqrt_num+1): #range(a,b) iterates from the value a to b-1\n",
    "            if np.mod(number, potential_factor) == 0: #np.mod() is the modulo (aka remainder) function; thus, if the remainder is zero, then it divides evenly\n",
    "                return False # if it divides evenly, then it's not prime, then we can return and end the function\n",
    "        return True #if we get through all of the potential factors and haven't found a factor, then it's prime\n",
    "    return False\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "id": "j1lbrTdR5Igp",
    "outputId": "1d805f46-7b2f-4326-ca90-6360767c65fa"
   },
   "outputs": [],
   "source": [
    "is_prime(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "imLdWDBqHLsb"
   },
   "source": [
    "## Data structures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "HFVQ3EpTym-B"
   },
   "source": [
    "### Lists\n",
    "We already looked at one python data structure: the list. Lists are _ordered_ collections of values, denoted with square brackets. \n",
    "\n",
    "Lists are _ordered_ in the sense that the order of their elements matter. The list [1,2,3,4] is not the same as [4,3,2,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 111
    },
    "colab_type": "code",
    "id": "5xwkgkHR26F2",
    "outputId": "017218c2-1290-417e-d0c9-e5680ea22cc5"
   },
   "outputs": [],
   "source": [
    "a_list = [2,0,15,5] # square brackets denote a list\n",
    "another_list = [15,0,5,2]\n",
    "print(f'a_list = {a_list}; another_list = {another_list}') \n",
    "\n",
    "print('is a_list equal to another_list?')\n",
    "print(a_list == another_list) # print out the truth value of whether a_list is the same as another_list (it shouldn't be, because they have different ordering)\n",
    "\n",
    "yet_another_list = [2,0,15,5]\n",
    "print('but it is equal to yet_another_list:')\n",
    "print(a_list == yet_another_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "vNEUNwmP3k2u"
   },
   "source": [
    "List elements can be any python object, including strings, numbers, and other lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 54
    },
    "colab_type": "code",
    "id": "iU9e_qCh3gRb",
    "outputId": "a18917aa-19ca-4a66-9486-c0ade3af8206"
   },
   "outputs": [],
   "source": [
    "diverse_list = ['a', False, [0,0,0], 1.0, 10]\n",
    "print(f'the elements of diverse_list are: {diverse_list}'.format())\n",
    "print(f'the data types of the elements are {[type(x) for x in diverse_list]}') # using list comprehension to get the type of each element"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Ybkqbv8k3kKQ"
   },
   "source": [
    "You can access a specific element of a list using the square bracket notation (this is known as indexing)\n",
    "```\n",
    "list_name[idx]\n",
    "```\n",
    "Index values can be negative, which start counting from the end. So `list_name[-1]` gives the __last__ element of the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 54
    },
    "colab_type": "code",
    "id": "PkC6JcEM5fmq",
    "outputId": "4cecd06b-6084-4a77-ce9e-8da480da1636"
   },
   "outputs": [],
   "source": [
    "first_element_of_diverse_list = diverse_list[0] # python starts counting at 0, so the first element is at index 0\n",
    "print(first_element_of_diverse_list)\n",
    "last_element_of_diverse_list = diverse_list[-1]\n",
    "print(last_element_of_diverse_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "MQAwMo3NFBZV"
   },
   "source": [
    "You can \"slice\" a list using the colon `:` notation\n",
    "```\n",
    "list_name[start_idx:end_idx]\n",
    "```\n",
    "Note that the slice starts at the start_idx, but __does not include__ the element at end_idx.\n",
    "\n",
    "If you omit either start_idx or end_idx, it automatically starts at the first element/ends at the last element respectively"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 92
    },
    "colab_type": "code",
    "id": "vSpmioyI5yDG",
    "outputId": "424a1e38-df27-49fd-f63c-cccd9af9f535"
   },
   "outputs": [],
   "source": [
    "print(diverse_list[0:2]) # gets the elements at index 0 and 1\n",
    "print(diverse_list[:2]) # equivalent to the above\n",
    "print(diverse_list[2:]) # gets all elements from index 2 to the end\n",
    "print(diverse_list[:]) # gets all elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "9Ca6c2N1IHcJ"
   },
   "source": [
    "Lists are modifiable: you can append and delete entries, as well as change the values of elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 111
    },
    "colab_type": "code",
    "id": "B2VzVRo05oL9",
    "outputId": "075aa7e4-d3e4-4049-d17c-2697c9ce6818"
   },
   "outputs": [],
   "source": [
    "diverse_list.append('new entry') # add a value to the end\n",
    "print(f'appended an entry to diverse_list: {diverse_list}')\n",
    "diverse_list[0] = 'changed entry' # change the value of entry at index 0\n",
    "print(f'changed an entry of diverse_list: {diverse_list}')\n",
    "first_entry = diverse_list.pop(0) # remove (and return) the value at element 0\n",
    "print(f'removed \"{first_entry}\" from diverse_list: {diverse_list}')\n",
    "diverse_list.remove('new entry') # you can also remove the first entry with a specific value, in this case, the \"new entry\"\n",
    "print(f'removed \"new entry\" from diverse_list: {diverse_list}')\n",
    "diverse_list.insert(0,'a') # insert the value 'a' at index 0\n",
    "print(f'inserted \"a\" back into diverse_list: {diverse_list}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "TlsLwdx-LEi0"
   },
   "source": [
    "### Tuples\n",
    "Tuples are unchangeable, ordered sequences of elements, grouped with regular parentheses:\n",
    "```\n",
    "('a','b','c')\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "id": "9PPsnkeMLRsG",
    "outputId": "5cd102c1-00fc-4bd8-ca69-c5149e228065"
   },
   "outputs": [],
   "source": [
    "a_tuple = ('a','b','c')\n",
    "print(f'the first element of a_tuple is \"{a_tuple[0]}\"') # tuples can be indexed like lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 175
    },
    "colab_type": "code",
    "id": "i71bNiQ3LhH1",
    "outputId": "1c44d6b2-12dd-4a58-ea18-e94c4ecc0745"
   },
   "outputs": [],
   "source": [
    "a_tuple[0] = 10 # however, unlike lists, you cannot change their values once they are set\n",
    "# this will throw a TypeError"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "L1gZ35gMGjYy"
   },
   "source": [
    "### Dictionaries\n",
    "Dictionaries are data structures that store _mappings_ from \"keys\" to respective \"values\". You can think of them as lookup tables which return a specific value for a given key. For example, an english dictionary (the book) could be stored as a python dictionary, where the \"keys\" are each of the words in english, and the \"values\" are the respective definitions.\n",
    "\n",
    "They are defined using the curly braces, or the `dict()` function:\n",
    "```\n",
    "dictionary = {key: value, key2: value2}\n",
    "dictionary = dict([(key, value),(key2, value2)])\n",
    "```\n",
    "\n",
    "Keys can be a variety of data types, including numeric, strings, and tuples. However, they cannot be changeable objects, such as lists, or other dictionaries. Values, on the other hand, can be any data type.\n",
    "\n",
    "Accessing the dictionary values are done using square brackets using the syntax:\n",
    "```\n",
    "dictionary[key] # returns the value associated with key\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "id": "IYd9jDjNF_cM",
    "outputId": "324ccbcc-b93e-419f-873c-f00617233340"
   },
   "outputs": [],
   "source": [
    "pokemon_types = {'bulbasaur':'grass', 'charmander':'fire', 'squirtle':'water'}\n",
    "pokemon_types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(pokemon_types['bulbasaur'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "O3x-7mBXOBwo"
   },
   "source": [
    "You can add or change an element to a dictionary using the following syntax:\n",
    "```\n",
    "dictionary[key] = value\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "id": "mT6If7e3Mf6T",
    "outputId": "7a8751cc-67f9-432f-c10b-e4956b6b56f7"
   },
   "outputs": [],
   "source": [
    "pokemon_types['bulbasaur'] = 'grass/poison' #bulbasaur is actually dual typed, so we'll change its entry\n",
    "pokemon_types['ivysaur'] = 'grass/poison' #let's add an evolution\n",
    "pokemon_types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "DsmMgEJkP-jD"
   },
   "source": [
    "You can get a list of all of the keys to a dictionary using the `.keys()` function, similarly with the `.values()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 54
    },
    "colab_type": "code",
    "id": "t1YzvPgZPSJ7",
    "outputId": "1967f93a-5296-4d0b-8a18-37b2585ceadb"
   },
   "outputs": [],
   "source": [
    "print(pokemon_types.keys())\n",
    "print(pokemon_types.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "JDsPF181P-9S"
   },
   "source": [
    "You can use the function `.items()` to get a list of `(key, value)` tuples. This is often useful for looping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 92
    },
    "colab_type": "code",
    "id": "5ChknNaURRif",
    "outputId": "e5c000be-9856-4747-8950-8964bec868e8"
   },
   "outputs": [],
   "source": [
    "for k, v in pokemon_types.items():\n",
    "  print(f'the type of {k} is {v}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Ku4Uchk2TPMk"
   },
   "source": [
    "# Numpy\n",
    "Numpy is a package for python which provides various tools to make math and numerical computation much easier. One of the key components is the numpy array, which enables matrices.\n",
    "\n",
    "The content in this section is adapted from the Python Data Science Handbook, which is [freely available online](https://github.com/jakevdp/PythonDataScienceHandbook)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "dDPk0KtdVTyr"
   },
   "source": [
    "## numpy arrays\n",
    "numpy arrays provide the ability to create matrices, which are essentially 2-dimensional lists. (They can also be used to create even higher-dimensional arrays: tensors, etc)\n",
    "Unlike python lists, numpy arrays must all have the same data type (e.g. numeric, string). \n",
    "\n",
    "Arrays can be created from python lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 111
    },
    "colab_type": "code",
    "id": "Y-y3R960TRzi",
    "outputId": "5e451047-62ef-498a-a0f1-faa51021abde"
   },
   "outputs": [],
   "source": [
    "print('a vector can be created from a list {}'.format(np.array([1, 4, 2, 5, 3])))\n",
    "print('a matrix can be created from a list of lists:\\n {}'.format(np.array([[1,1,1],[2,2,2],[3,3,3]]))) #\\n is the newline character and makes the following text appear on the next line"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "NqBFDOaqTSYt"
   },
   "source": [
    "There are also a bunch of built-in functions for generating arrays. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "id": "16ADGYQ1X3ED",
    "outputId": "78d8099a-964a-49ab-a279-8edeff5a3b07"
   },
   "outputs": [],
   "source": [
    "# Create a length-10 integer array filled with zeros\n",
    "np.zeros(10, dtype=int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 73
    },
    "colab_type": "code",
    "id": "9RQ_l2hdX7iG",
    "outputId": "fb1848d7-801f-4525-f882-84cc5f827c9a"
   },
   "outputs": [],
   "source": [
    "# Create a 3x5 floating-point array filled with ones\n",
    "np.ones((3, 5), dtype=float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 73
    },
    "colab_type": "code",
    "id": "Ncq8ljPWa169",
    "outputId": "c1a1b1a6-7c7e-498e-8ada-ced68c9d4bfe"
   },
   "outputs": [],
   "source": [
    "# Create a 3x5 array filled with 3.14\n",
    "np.full((3, 5), 3.14)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "id": "XgFvh5hDa43w",
    "outputId": "5a4ad47f-7096-4bed-a856-c24b878479b5"
   },
   "outputs": [],
   "source": [
    "# Create an array filled with a linear sequence\n",
    "# Starting at 0, ending at 20, stepping by 2\n",
    "# (this is similar to the built-in range() function)\n",
    "np.arange(0, 20, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "id": "RiJ1SBxma6qw",
    "outputId": "41bc1976-2958-46b7-db96-89657fd15a1d"
   },
   "outputs": [],
   "source": [
    "# Create an array of five values evenly spaced between 0 and 1\n",
    "np.linspace(0, 1, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Lg0ee2iPzNVC"
   },
   "source": [
    "## Array attributes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 354
    },
    "colab_type": "code",
    "id": "UfESGLmvbEr2",
    "outputId": "9c74d53c-e7e2-4d66-af80-c3d64c626f63"
   },
   "outputs": [],
   "source": [
    "x1 = np.random.randint(10, size=6)  # One-dimensional array\n",
    "x2 = np.random.randint(10, size=(3, 4))  # Two-dimensional array\n",
    "x3 = np.random.randint(10, size=(3, 4, 5))  # Three-dimensional array\n",
    "print('x1=',x1)\n",
    "print('x2=',x2)\n",
    "print('x3=',x3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 73
    },
    "colab_type": "code",
    "id": "ZAuxm5SG0EZs",
    "outputId": "232a4c05-e798-4c3a-8c1d-a13fe491ae21"
   },
   "outputs": [],
   "source": [
    "print(\"x3 ndim: \", x3.ndim)\n",
    "print(\"x3 shape:\", x3.shape)\n",
    "print(\"x3 size: \", x3.size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "KHBoC5BCzYSe"
   },
   "source": [
    "## Array Indexing\n",
    "You can index arrays much in the same way that you can index python lists\n",
    "\n",
    "One-dimensional arrays function just like lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 111
    },
    "colab_type": "code",
    "id": "NqtN3BX5zSvs",
    "outputId": "db72208f-e549-4cc4-e463-9e1cd225e6b9"
   },
   "outputs": [],
   "source": [
    "print('x1 is', x1)\n",
    "print('first entry is', x1[0]) # first entry of the array\n",
    "print('second and third entries are', x1[[1,2]])\n",
    "print('first three entries are', x1[:3]) # slice the array\n",
    "print('a second set of colons in the slice allow you to set the interval:', x1[::2]) # every other element of x1\n",
    "print('you can reverse the order using a negative interval:', x1[3::-1]) # count backwards from entry at index 3 to the beginning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "hNxh7U9r0Ij6"
   },
   "source": [
    "Multi-dimensional arrays are indexed using a tuple of indices. The indices for a 2d array are ordered as `(row_idx, col_idx)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 92
    },
    "colab_type": "code",
    "id": "Y3wUywNkz0mU",
    "outputId": "8435469b-32a1-43b0-a30b-b616f4960ba4"
   },
   "outputs": [],
   "source": [
    "print(x2)\n",
    "print('the element in the second row, third column is: ', x2[(1,2)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "234TJN3cEkQ6"
   },
   "source": [
    "You can slice multidimensional arrays as well!\n",
    "\n",
    "If you change the value of an entry in a slice, you change the value in the original object. This is what's known as a \"view\" of an array. Slices do not return an independent object, but instead can be thought of as just a reference to a subset of elements in the original object.\n",
    "\n",
    "However, if you do not want this behavior, you can avoid it by making a copy using the `.copy()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 204
    },
    "colab_type": "code",
    "id": "pZbc_-XV03-d",
    "outputId": "7bb1b6c2-bb56-4c1a-f337-fb08d263d32d"
   },
   "outputs": [],
   "source": [
    "print('x2 is originally: \\n', x2)\n",
    "slice_of_x2 = x2[1:,2:] # slices the 2nd row to the end, and 3rd column to the end\n",
    "copied_slice_of_x2 = x2[1:,2:].copy() # note that slices provide a direct view of the original object, if you want an independent copy, use the .copy()\n",
    "print('slice_of_x2 is:\\n',slice_of_x2)\n",
    "print('copied_slice_of_x2 is: \\n', copied_slice_of_x2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 204
    },
    "colab_type": "code",
    "id": "eP7DDrC5ZeQ-",
    "outputId": "cddaa849-a2af-4391-a982-70ea675fe995"
   },
   "outputs": [],
   "source": [
    "# let's change the value of slice_of_x2\n",
    "slice_of_x2[0,0] = 99 # we changed the value of top left element to 99; this corresponds to the element in the 2nd row, 3rd column of x2\n",
    "print('now x2 is: \\n', x2)\n",
    "print('slice_of_x2 is:\\n',slice_of_x2)\n",
    "print('and copied_slice_of_x2 is:\\n',copied_slice_of_x2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 148
    },
    "colab_type": "code",
    "id": "5EIBstxdZ5qB",
    "outputId": "9d790c90-ef1f-4bda-a6d1-c61e10aa4e75"
   },
   "outputs": [],
   "source": [
    "# If you change the value of a copy, it does not affect the original object\n",
    "copied_slice_of_x2[0,0] = -50\n",
    "print('copied_slice_of_x2 is: \\n', copied_slice_of_x2)\n",
    "print('x2 is unchanged by this operation:\\n', x2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "zDrMXskEC_4_"
   },
   "source": [
    "## Reshaping\n",
    "You can reshape an array using the `.reshape()` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 104
    },
    "colab_type": "code",
    "id": "obpaBhSIDLdT",
    "outputId": "e13f55a1-9bf8-4b94-c74a-80e8ffacbc35"
   },
   "outputs": [],
   "source": [
    "print('np.arange(12):',np.arange(12))\n",
    "reshaped = np.arange(12).reshape(3,4)\n",
    "print('reshaped into a 3x4 array: \\n',reshaped)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "iYfo8fszc-l-"
   },
   "source": [
    "You can combine and split arrays in numpy. However, we won't be going too much in depth with that. Check out [this tutorial](https://github.com/jakevdp/PythonDataScienceHandbook/blob/master/notebooks/02.02-The-Basics-Of-NumPy-Arrays.ipynb) for more info in that realm."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "bfl_mLfKJMyQ"
   },
   "source": [
    "## Boolean arrays and masking\n",
    "Boolean data represents True/False values, which can also be expressed as 1 or 0 respectively.\n",
    "\n",
    "You can compute boolean operations on arrays in numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 69
    },
    "colab_type": "code",
    "id": "lfK5Q0eaIFgD",
    "outputId": "49dad38f-a5d0-4086-f311-0261b6ff04bc"
   },
   "outputs": [],
   "source": [
    "even_entries_bool = np.mod(reshaped,2)==0\n",
    "print(even_entries_bool)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Ef8uwd0mKXlc"
   },
   "source": [
    "You can then use those arrays to select the entries which match that criteria"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "ajz3_utcbqzX",
    "outputId": "19dcd052-586c-4ddb-e672-26b5b4d07c3d"
   },
   "outputs": [],
   "source": [
    "reshaped[even_entries_bool]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "4Ob_771lLX3n"
   },
   "source": [
    "### Exercise\n",
    "Using the `is_prime()` function we previously wrote, write a function which takes a numpy array and returns a boolean array of the prime entries with the same shape as the input array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "KAN-Wo1TMeRg"
   },
   "outputs": [],
   "source": [
    "def is_prime_array(input_array):\n",
    "  \"\"\"\n",
    "  returns a boolean array of the same shape as input_array\n",
    "  with True if the element in the same position of input_array is prime \n",
    "  and False otherwise\n",
    "  \n",
    "  example: \n",
    "  x = np.array([[ 0,  1,  2,  3],\n",
    "       [ 4,  5,  6,  7],\n",
    "       [ 8,  9, 10, 11]])\n",
    "  is_prime_array(x)\n",
    "  should return\n",
    "  [[False, False, True, True],\n",
    "   [False, True, False, True],\n",
    "   [False, False, False, True]]\n",
    "  \"\"\"\n",
    "  # fill in with your code\n",
    "  return output_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "TFr8SrO9Sxad"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "include_colab_link": true,
   "name": "01a-Intro-to-python.ipynb",
   "provenance": [],
   "version": "0.3.2"
  },
  "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}