Intro_01_5_Python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "4003 Intro 01.5 - Data Structures",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyMJ+1oITNVubw4+K8DG+1F+",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/justinb4003/4003colab/blob/main/Intro_01_5_Python.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EYMpHhxh_XE6"
      },
      "source": [
        "# Variables, Functions, and Data Structures\n",
        "\n",
        "This can be thought of as an optional lesson, or perhaps a reference notebook you refer back to when stuck on a problem and need a refresher on some of the basics.  On one hand details such at this can be considered fundamental and crucial to understanding how to program but on another they can be considered esoteric and pointless.  If you're drawn to content like this by all means dive in and seek out other resources to get into the nitty-gritty of the details.  It won't ever hurt you.  On the other hand if content such as this is merely something you refer to when stuck that's perfectly OK too.\n",
        "\n",
        "## Variables\n",
        "\n",
        "Variables, as a concept, are hopefully familiar from algebra.  For instance, if I tell you $x=5$ and want the value for $y$ from the formula $y=2x+4$  you can mentally substitute in a 5 for the $x$ and see $y=2 \\cdot 5+4$.\n",
        "\n",
        "For numbers they're not too much to think about.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Oz4-NeSic3Dh"
      },
      "source": [
        "x = 5\n",
        "y = 2*x+4\n",
        "print(y)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3jZhLS_7etyH"
      },
      "source": [
        "The next datatype to address is the string.  The text \"Hello World\" is an example of a string that you've already used and we denote a string by using the quotation marks.  In Python you can use a double quotation mark (\") or a single quotation mark (') as they're both valid.  It's completely a style preference but it's generally a good idea to stay consistent within a project.\n",
        "\n",
        "But, even if you have a preference being able to swap styles is sometimes handy when you need to use a quotation mark within your string:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CyB5-kslfTtb"
      },
      "source": [
        "print('Say \"Cheese!\"')\n",
        "print(\"Don't step on the mouse!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lmryg4TCfxSb"
      },
      "source": [
        "# Trying to use the same quotation mark within itself results in an error:\n",
        "print('Don't step on the mouse!')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M714tyrLf88m"
      },
      "source": [
        "# If you have to use a qutation mark, and the mixing trick isn't going to cut\n",
        "# it you can 'escape' the character with a backslash\n",
        "print('Don\\'t step on the mouse!')\n",
        "\n",
        "# And if you need to use an actual backslash you have to escape that:\n",
        "print('The ever handy backslash: \\\\')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GP6RuOPNiBGx"
      },
      "source": [
        "That should cover the basics for our number and string types, so let's combine them. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4NPOuGhbu8EK"
      },
      "source": [
        "# This works, and does what you would probably expect, try it!\r\n",
        "print('Hello ' + 'John!')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QsPNX_J-qKoa"
      },
      "source": [
        "# Functions\n",
        "\n",
        "We'll start by implementing a simple algebraic function $f(x)=2x+4$ in Python.\n",
        "\n",
        "We define a function with the ```def``` keyword, short for define.  It is then followed by the function name and the arguments to it. To implement the logic behind $f(x)=3x+4$ we would write:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KiIYBmEkqwMd"
      },
      "source": [
        "def f(x):\n",
        "    ret = 2*x+4\n",
        "    return ret\n",
        "\n",
        "# Print the value we receive back from the functoin\n",
        "print(f(0))\n",
        "print(f(4))\n",
        "print(f(8))\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QsiyoofYzHTA"
      },
      "source": [
        "You might have noticed that the text under ```def f(x):``` is shifted over, or indented.  In most languages blocking up code nicely when it changes levels is best practice but in Python the indentation itself is what controls the program flow.  Let's make a loop that counts from 1-3 while making some output. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eFksNnjXzG-C"
      },
      "source": [
        "for i in range(1, 4):\n",
        "    print(i);\n",
        "print('Done!')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DqTdfwWs1YSl"
      },
      "source": [
        "# Let's do that again but we'll move the last print statement over\n",
        "for i in range(1, 4):\n",
        "    print(i);\n",
        "    print('Done!')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "l-saoORL1kti"
      },
      "source": [
        "# One more time but we're not going to shift that last print statement over far enough\n",
        "for i in range(1, 4):\n",
        "    print(i);\n",
        "   print('Done!')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BHkHDp9P1rTb"
      },
      "source": [
        "There, now you know what an indentation error that confuses the compiler looks like!\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5-E_28QA0n3O"
      },
      "source": [
        "# Complex data types\n",
        "\n",
        "## Lists\n",
        "\n",
        "Lists let you work with a series of values.  If you're familiar with other programming languages these can sometimes be called arrays.  The concepts are similar."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u67RIs0-0pW0"
      },
      "source": [
        "# Example of creating lists\n",
        "\n",
        "scores_list = [80, 90, 100]\n",
        "students_list = ['David', 'Justin', 'Morrie']\n",
        "print(scores_list)\n",
        "print(students_list)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pra3kX6y3Pta"
      },
      "source": [
        "## Tuples\n",
        "\n",
        "Tuples are a lot like lists.  In fact if I show you an example of how to make one you're probably going to wonder why we have both:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aSw-oPqq3ayW"
      },
      "source": [
        "# Example of creating tuples \n",
        "\n",
        "scores_tuple = (80, 90, 100)\n",
        "students_tuple = ('David', 'Justin', 'Morrie')\n",
        "print(scores_tuple)\n",
        "print(students_tuple)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "amkAGolt4Vfk"
      },
      "source": [
        "At this point you might be thinking the difference betwen [ and ( here is like using \" or ' quotation marks in strings, but they're not.  The difference between tuples and lists does actually matter, but the differerences between the two are subtle.\n",
        "\n",
        "The short answer, and if this is all you understand about their differences you're probably good, is that they are in fact different because a tuple cannot be modified while a list can.\n",
        "\n",
        "Let's try some operations on the tuples and lists we've already created."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ln9ssAXb5M_Z"
      },
      "source": [
        "scores_list[0] = 100  # Set the first item in the scores_list list to 100.\n",
        "print(score_list)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "egCHeBZU5dGx"
      },
      "source": [
        "Ok, so that works with a list, and at this point it's probably a good idea to mention that when we index (go to spot X in a list or tuple) we start from the number 0 instead of 1.  We'll cover actually working with these datatypes in a bit, for now we're just learning about how to put stuff in them.\n",
        "\n",
        "Let's try the same operation on our tuple."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kbA_etXe58YS"
      },
      "source": [
        "scores_tuple[0] = 100  # Set the first item in the scores_tuple tuple to 100.\n",
        "print(score_tuple)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dzul2_gE6HUp"
      },
      "source": [
        "If you ran that you should see at the bottom of the error:\n",
        "\n",
        "TypeError: 'tuple' object does not support item assignment\n",
        "\n",
        "And that's Python's way of telling you what I mentioned earlier: you can't change a tuple.\n",
        "\n",
        "Why? That's kind of a hard question and rather involved.  What it boils down to though is that a tuple is allocated once in memory, that's the space you get, and you cannot add on to it or change anything.  This makes it more efficient at storing small lists of items that will not be changing.  A Python list can be added to, modified in place, and deleted from but all of that requires some management of computer memory and as such it's a less efficient structure for something that would remain small in size and not changing.\n",
        "\n",
        "I am not sure it's worth delving into the issue farther than that.  If students are interested let me know but this will eventually be covered in early CS courses if that's where you're headed.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h7T-Yap693S8"
      },
      "source": [
        "### Tuple Syntax Gotchas\n",
        "\n",
        "I've mentioned before that Python functions and math functions look very similar, but I'd like to call out one area where they differ, the treatment of parenthesis, which is why I introdued tuple vs. list earlier.\n",
        "\n",
        "Let's just look at some code and see what happens in different circumstances.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AlvyNhMR6Jxb"
      },
      "source": [
        "a = 4  # variable a will have value 4\n",
        "b = (4) # variable b will have value 4, the parens just disappear\n",
        "c = (4 + 2)*2 #  variable c will have value 12, the parents just disappear but they are treated just like in math\n",
        "d = (4,)  # The trailing comma after the 4 makes this a tuple with a single value\n",
        "e = [4]  # Same as d=(4,) except here we've made a list, not a tuple, and the [] syntax means we don't need the trailing comma to make it apparent to the compiler\n",
        "print(a)\n",
        "print(b)\n",
        "print(c)\n",
        "print(d)\n",
        "print(e)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y8QkdzVnAKUG"
      },
      "source": [
        "So, the $18 question here is why does it matter?  Let's make a function that takes in a tuple of student scores and student names and prints them out in a table.  We'll then feed data into that function and see what happens."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Vuh7xHR1AxMd"
      },
      "source": [
        "def print_score_table(scores, students):\n",
        "    for i in range(len(scores)):\n",
        "        print(scores[i], students[i])\n",
        "\n",
        "# Print just one row of data\n",
        "print_score_table((90,), ('Justin',))  # That's a lot of weird commas, but it makes more sense with multiple values\n",
        "\n",
        "# Print an empty line to make things easier to see\n",
        "print()\n",
        "\n",
        "# Print two rows of data\n",
        "print_score_table((90, 100), ('Justin', 'Morrie'))  # Commas make more sense now I bet.\n",
        "# Or we can break it down across multiple lines with spaces to make it easier to see\n",
        "# When you're within () or [] marks you are free to break indentation rules.\n",
        "print_score_table((90,       100),\n",
        "                  ('Justin', 'Morrie'))\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oYn2iWvKDo-3"
      },
      "source": [
        "But, if you want to try and make line 6 from above less comma laden you might try this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2VG4Xq_sDnk-"
      },
      "source": [
        "print_score_table((90), ('Justin'))  # That won't work"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6VgGWJwMD3PV"
      },
      "source": [
        "That's just the same as trying this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j4n3HwT5D6UX"
      },
      "source": [
        "print_score_table(90, 'Justin')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AQE4b8BcD_o6"
      },
      "source": [
        "Which results in the same error, in that it doesn't know how to take the len (length) of an int (integer) because it's just a single value, not a tuple or list and has no ```len()``` value.\n",
        "\n",
        "We're getting a bit into the weeds at this point but I would to point out one more way of making this function run when we call it:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4FRqV5pbFO4a"
      },
      "source": [
        "print_score_table([90], ['Justin'])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m1vHffPwFbJa"
      },
      "source": [
        "Due to the nature of Python tuples and lists being so interchangable this syntax, which sends lists to the function, not tuples, works perfectly fine.  The only defect is we've made a full fledged list for a single object, not a memory efficient tuple, and while that doesn't matter at all for this particular example it can at other times.\n",
        "\n",
        "If at any point in our exercises it does make a different I'll be sure to point them out.\n",
        "\n",
        "# Working with lists\n",
        "\n",
        "Here I'll present some common things you might do with a list in some code."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3v54Qj0NkmIE"
      },
      "source": [
        "mylist = ['Phrase 1', 'Phrase 2', 'Phrase 3']  # Create a list of 3 strings\n",
        "\n",
        "# Loop through the list setting the variable 'phrase' to the value of each\n",
        "# element found in mylist one by one.\n",
        "print('beginning loop')\n",
        "for phrase in mylist:\n",
        "    # Print out the value of the phrase variable to demonstrate\n",
        "    # what's happening.\n",
        "    print(phrase)\n",
        "print('loop ended')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QmqgtOavlijO"
      },
      "source": [
        "# You can work with lists of numbers\n",
        "scores = [80, 90, 100]\n",
        "total_score = 0\n",
        "for s in scores:\n",
        "    total_score = total_score + s\n",
        "print('Total value of scores list: ', total_score)\n",
        "print('Average value of scores list: ', total_score / len(scores))\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ryWM74q6pmWA"
      },
      "source": [
        "scores = [80, 90, 100]\n",
        "\n",
        "# We can grab individual elements of the list\n",
        "print(scores[0])  # First element starts at 0\n",
        "print(scores[1])\n",
        "print(scores[2])  # So the last element in a 3 element array is at position 2\n",
        "\n",
        "# We can accomplish the same as the above for loop but with indexes like\n",
        "# this:\n",
        "total_score = 0\n",
        "for index in range(len(scores)):\n",
        "    s = scores[index]\n",
        "    total_score = total_score + s\n",
        "\n",
        "print('Total value of scores list: ', total_score)\n",
        "print('Average value of scores list: ', total_score / len(scores))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nrFg7vcZx8_d"
      },
      "source": [
        "In general, when looping through a data structure avoid adressing it by index.  Python data structures are designed to perform well with iterators and that should be how you use them as a default rule.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BpNMXSzvoEAX"
      },
      "source": [
        "# You can make a list of a mixed type\n",
        "score_data = [80, 'David',\n",
        "              90, 'Justin',\n",
        "              100, 'Morrie']\n",
        "\n",
        "for element in score_data:\n",
        "    print(element)\n",
        "\n",
        "# While you can do this it's generally not a good idea to try and work\n",
        "# with this as an actual data structure, and once you do start trying\n",
        "# this it's a good time to talk about the dictionary"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LGDAoSbdzmOo"
      },
      "source": [
        "## Dictionary type\n",
        "We've seen the list ```mylist = [1, 2, 3]``` and the tuple ``mytuple = (1, 2, 3)`` and now we're going to look at the dictionary or dict type.  The dictionary type maps a string value to another one.\n",
        "\n",
        "An example of how one might use a dictionary:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VqMUQcakTd1S"
      },
      "source": [
        "student_scores = { 'David': 80,\r\n",
        "                   'Justin': 90,\r\n",
        "                   'Morrie': 100 }\r\n",
        "\r\n",
        "print(student_scores['David'])\r\n",
        "print(student_scores['Justin'])\r\n",
        "print(student_scores['Morrie'])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WbHCiTSdUWSh"
      },
      "source": [
        "Here we show how you can define a dictionary and then refer back to elements within it by their name, or key, technically speaking.  \r\n",
        "\r\n",
        "What becomes fun at this point in data structures is if you have dictionaries, and you have lists, and your dictionaries can return lists of keys and values, you can create amazingly complex data structures with just those tools.\r\n",
        "\r\n",
        "Now, for pratcial reasons you should hold off on trying to create complex nested data structures out of the primitives of dicts, lists, and tuples, but if you do run ahead with these primitives and make complex objects from them you'll appreciate classes and objects much more once we get to them."
      ]
    }
  ]
}