lecture1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lecture 1: Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Contents\n",
    "\n",
    "- [About Python](#What’s-Python?)  \n",
    "- [Basic Basics](#Basic-Basics)\n",
    "  - `\"hello wörld\"`\n",
    "  - arithmetic\n",
    "  - variables\n",
    "  - strings\n",
    "  - conditionals\n",
    "  - lists\n",
    "- how to get help"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:** part of this overview is stolen from [QuantEcon](https://quantecon.org/). Thanks!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What’s Python?\n",
    "\n",
    "[Python](https://www.python.org) is a general-purpose programming language conceived in 1989 by Dutch programmer [Guido van Rossum](https://en.wikipedia.org/wiki/Guido_van_Rossum).\n",
    "\n",
    "Python is free and open source, with development coordinated through the [Python Software Foundation](https://www.python.org/psf/).\n",
    "\n",
    "Python has experienced rapid adoption in the last decade and is now one of the most popular programming languages."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> “Python has gotten sufficiently weapons grade that we don’t descend into R\n",
    "> anymore. Sorry, R people. I used to be one of you but we no longer descend\n",
    "> into R.” – Chris Wiggins"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Common Uses\n",
    "\n",
    "Python is a general-purpose language used in almost all application domains such as\n",
    "\n",
    "- communications  \n",
    "- web development  \n",
    "- CGI and graphical user interfaces  \n",
    "- game development  \n",
    "- multimedia, data processing, security, etc., etc., etc.  \n",
    "\n",
    "\n",
    "Used extensively by Internet services and high tech companies including\n",
    "\n",
    "- [Google](https://www.google.com/)  \n",
    "- [Dropbox](https://www.dropbox.com/)  \n",
    "- [Reddit](https://www.reddit.com/)  \n",
    "- [YouTube](https://www.youtube.com/)  \n",
    "- [Walt Disney Animation](https://pydanny-event-notes.readthedocs.org/en/latest/socalpiggies/20110526-wda.html)\n",
    "\n",
    "\n",
    "Python is very beginner-friendly and is often used to [teach computer science and programming](http://cacm.acm.org/blogs/blog-cacm/176450-python-is-now-the-most-popular-introductory-teaching-language-at-top-us-universities/fulltext).\n",
    "\n",
    "For reasons we will discuss, Python is particularly popular within the scientific community with users including NASA, CERN and practically all branches of academia.\n",
    "\n",
    "It is also [replacing familiar tools like Excel](https://news.efinancialcareers.com/us-en/3002556/python-replaced-excel-banking) in the fields of finance and banking."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Relative Popularity\n",
    "\n",
    "The following chart, produced using Stack Overflow Trends, shows one measure of the relative popularity of Python\n",
    "\n",
    "<img src=\"https://s3-ap-southeast-2.amazonaws.com/python-programming.quantecon.org/_static/lecture_specific/about_py/python_vs_matlab.png\" style=\"width:55%;height:55%\">\n",
    "\n",
    "The figure indicates not only that Python is widely used but also that adoption of Python has accelerated significantly since 2012.\n",
    "\n",
    "We suspect this is driven at least in part by uptake in the scientific\n",
    "domain, particularly in rapidly growing fields like data science."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example, the popularity of [pandas](http://pandas.pydata.org/), a library for data analysis with Python has exploded, as seen here.\n",
    "\n",
    "(The corresponding time path for MATLAB is shown for comparison)\n",
    "\n",
    "<img src=\"https://s3-ap-southeast-2.amazonaws.com/python-programming.quantecon.org/_static/lecture_specific/about_py/pandas_vs_matlab.png\" style=\"width:55%;height:55%\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that pandas takes off in 2012, which is the same year that we see\n",
    "Python’s popularity begin to spike in the first figure.\n",
    "\n",
    "Overall, it’s clear that\n",
    "\n",
    "- Python is [one of the most popular programming languages worldwide](https://spectrum.ieee.org/computing/software/the-top-programming-languages-2019).  \n",
    "- Python is a major tool for scientific computing, accounting for a rapidly rising share of scientific work around the globe.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Features\n",
    "\n",
    "Python is a [high-level language](https://en.wikipedia.org/wiki/High-level_programming_language) suitable for rapid development.\n",
    "\n",
    "It has a relatively small core language supported by many libraries.\n",
    "\n",
    "Other features of Python:\n",
    "\n",
    "- multiple programming styles are supported (procedural, object-oriented, functional, etc.)  \n",
    "- it is interpreted rather than compiled.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Syntax and Design\n",
    "\n",
    "\n",
    "<a id='index-2'></a>\n",
    "One nice feature of Python is its elegant syntax — we’ll see many examples later on.\n",
    "\n",
    "Elegant code might sound superfluous but in fact it’s highly beneficial because it makes the syntax easy to read and easy to remember.\n",
    "\n",
    "Remembering how to read from files, sort dictionaries and other such routine tasks means that you don’t need to break your flow in order to hunt down correct syntax.\n",
    "\n",
    "Closely related to elegant syntax is an elegant design.\n",
    "\n",
    "Features like iterators, generators, decorators and list comprehensions make Python highly expressive, allowing you to get more done with less code.\n",
    "\n",
    "[Namespaces](https://en.wikipedia.org/wiki/Namespace) improve productivity by cutting down on bugs and syntax errors."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scientific Programming\n",
    "\n",
    "\n",
    "<a id='index-3'></a>\n",
    "Python has become one of the core languages of scientific computing.\n",
    "\n",
    "It’s either the dominant player or a major player in\n",
    "\n",
    "- [machine learning and data science](http://scikit-learn.org/stable/)  \n",
    "- [astronomy](http://www.astropy.org/)  \n",
    "- [artificial intelligence](https://wiki.python.org/moin/PythonForArtificialIntelligence)  \n",
    "- [chemistry](http://chemlab.github.io/chemlab/)  \n",
    "- [computational biology](http://biopython.org/wiki/Main_Page)  \n",
    "- [meteorology](https://pypi.org/project/meteorology/)  \n",
    "\n",
    "\n",
    "Its popularity in economics is also rising."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic Basics\n",
    "\n",
    "For most part of the course we will be working with Python in your browser using iPython Notebook. Here is an example block of code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Hello wörld')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To run a block of code like the one above, click on it to select it and then you can either click the run button in the menu above:\n",
    "\n",
    "<button id=\"run_b\" title=\"Run Cell\" class=\"ui-button ui-widget ui-state-default ui-button-icon-only ui-corner-left\" role=\"button\" aria-disabled=\"false\"><span class=\"ui-button-icon-primary ui-icon ui-icon-play\"></span><span class=\"ui-button-text\">Run Cell</span></button>\n",
    "\n",
    "or type shift-enter. The output of the block is shown below the block.\n",
    "\n",
    "All of the code blocks on this page are interactive. Please make sure you run them all at least once. Feel free the change the code and see what the affect is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img align='left' src='https://i.pinimg.com/originals/90/6a/d9/906ad9a5dc4ed6ee65fd1b03d63e1663.gif'>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arithmetic\n",
    "\n",
    "Like every programming language, Python is a good calculator. Run the block of code below to make sure the answer is right!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just wow. \n",
    "\n",
    "Now lets say you won the lottery. You are about to collect your millions, but first you have to answer this skill testing question:\n",
    "\n",
    "$$8+6*2*3-(15-13)$$\n",
    "\n",
    "Tricky one. Fortuntely Python can help. The order of operations you learned in school applies, BEDMAS (brackets, exponents, division, multiplication, addition, subtraction)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numbers are valid Python code as are the common operators, +, /, * and -. You can write different types of numbers including integers, real numbers (floating point) and negative integers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>**Modulus tells us if a given number is divisible by another number!**</u>\n",
    "\n",
    "If the result is 0, we know the answer is yes, the number on the left is divisible by the number on the right. \n",
    "\n",
    "If the result is anything but 0, we know the number on the left is not divisible by the number on the right. \n",
    "\n",
    "Modulus is very useful and is widely used even by advanced programmers, and often in context that have nothing to do with mathematics. Soon you will learn more about this."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since 42 is literally 42, we call these numbers *literals*. You are literally writing number in your Python code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables\n",
    "\n",
    "So you just had a big meal to celebrate, and now you need to calculate the tip."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "meal = 200.0\n",
    "tip_percent = 0.1\n",
    "\n",
    "meal * tip_percent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to make it more user friendly you could do the following."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because of BEDMAS we don't need brackets, but `meal * (tip_percent / 100)` would work too."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`meal` and `tip_percent` aren't literal numbers, they are variables.\n",
    "\n",
    "In Python variables are like buckets (dump trucks?). You can put anything you want in them. Just give them a name and you can use them in place of the literal value.\n",
    "\n",
    "Above, `meal` was 200.00 but we could also set meal to the text `'Hello, World'`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "meal = 'Hello, World'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The value a variable has only depends on what it was last assigned.\n",
    "\n",
    "It is like a spreadsheet except you choose the names for the cells yourself."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings\n",
    "\n",
    "Numbers are great... but most of our day to day computing needs involves text, from emails to tweets to documents.\n",
    "\n",
    "We have already seen a text literal in Python, \"Hello, World!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "meal = 'Hello, World'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Text literals are surrounded by quotes. Without the quotes Hello by itself would be viewed as a variable name.\n",
    "\n",
    "You can use either double quotes (\") or single quotes (') for text literals.\n",
    "\n",
    "As we saw before we can also save text literals in variables.\n",
    "\n",
    "### What's a String?\n",
    "\n",
    "Programmers call text literals *strings* because we are weird like that. From now on we will only refer to strings, but we just mean pieces of text inside our code.\n",
    "\n",
    "Let's use strings with variables!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "weird_variable = \"green blobb\"\n",
    "your_name = weird_variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's say you are really happy, and you want to make sure everyone knows it, you can use upper. \"upper\" is short for uppercase and you will see what it does by running the code block below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string = \"Hello, World\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Maybe you are feeling a bit sad and you want to be quiet, you can then use lower."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use the dot (\".\") operator to call these operations on the string. What lower and upper operate on comes before the dot and needs to be a string variable or literal."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Formating\n",
    "---------\n",
    "\n",
    "Sometimes you want to create a string out of a few other strings. Above we printed\n",
    "\n",
    "    Hello,\n",
    "    Your Name\n",
    "\n",
    "by using two print statements, but it would be nice to output \"Hello, Your Name!\" instead. (Where Your Name is actually your name... oh variables)\n",
    "\n",
    "We can do this with the string operation called format. Format is different from lower and upper because it can take other arguments. An *agrument* is what coders call the value passed to an operation or function, it doesn't mean we are fighting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "your_name = \"Gregor\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string = \"hello %s\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cnumber = 1\n",
    "print('my favorite number %s and %s' %(cnumber,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditions\n",
    "\n",
    "Has an application ever ask you a question? Maybe it asks you if you really want to quit because unsaved changed might lost, or if you want to leave a webpage. If you answer OK one thing happen, like your application closing, but if you answer No or Cancel something else happens. In all those cases there is a special piece of code that is being run somewhere, it is an *if* condition.\n",
    "\n",
    "Like all languages, Python allows us to conditionally run code.\n",
    "\n",
    "To have an if condition we need the idea of something being true and something being false. Remember, we call numbers \"integers\" and \"floating point\", and text \"strings\". We call true or false \"boolean\" values. True would represent OK where as false would represent No or Cancel in the example above.\n",
    "\n",
    "The literal values in Python for true and false are \"True\" and \"False\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes you hear the word 'binary' related with computers. Binary just means that there are two options, 0 and 1. For example we may have a case where the statement <i>\"it's raining\"</i>, is <code>True</code> or <code>False</code>.\n",
    "\n",
    "This has to do with the way computers work; the processing unit (CPU) of the computer is made of billions of tiny gates. These tiny gates can only peform one action, they can open or close. Related with this, there is a system of mathematics called boolean logic. Boolean means the same thing as binary, that there are only two possible states. Instead of talking about gates or 0 and 1, in Boolean logic we talk about <code>True</code> and <code>False</code>. Either something is true, or it's false. When you hear about Boolean Logic for the first time, it sounds confusing, but actually it is really as simple as that. \n",
    "\n",
    "Understanding this clearly, you take a giant leap towards understanding computers. Boolean logic, and the statements we use to instruct the computer based on that type of simplistic logic, is the language of computers. Python gives us humans an easy to learn and understand way to use boolean logic to tell computers what we want them to do. Let's see a couple of examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The basic principle is that simple. Boolean logic also leverage 'and' and 'or' statements. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With <code>or</code> statement we are saying that one of the options is true, and with <code>and</code> statement we are saying that both are true. We can also do the reverse and say that something <code>is not</code>. In other words, we have two options, statements that are saying something is true, and if it is true in fact, we get the respone <code>True</code>, and statements that are saying something is not true, and if it is not true, we get the response <code>True</code> (and if it's true, we get <code>False</code>)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Actually, we can join together as many such statements as we like using <code>and</code> and <code>or</code> operators.\n",
    "\n",
    "So, I somehow suspect that `5` is a prime number. So let us see if we can confirm this..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To clarify, we confirm that number 5 is not divisible by any other number than 1 and itself. Actually all numbers are divisible by 1 and itself, so this is to say it's not divisible. Also numbers can't be divisible by numbers that are larger than the number itself, so it's enough to check all the numbers between 1 and the number itself to get the answer if a given number is prime or not. This sounds fine as long as we deal with small numbers, but how about when we want to answer the same question for a very large number?\n",
    "\n",
    "Because it's so easy to say if small numbers are prime or not, mathematicians are generally only interested in finding really big primes. In the next section we'll learn just how big, and then come back to learn how big numbers can be verified using the techniques we've learn already."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can write expressions with operations too."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to write an \"if\" statement we need code that spans multiple lines\n",
    "\n",
    "    if condition:\n",
    "        print(\"Condition is True\")\n",
    "    else:\n",
    "        print(\"Condition is False\")\n",
    "\n",
    "Some things to notice. The if condition ends in a colon (\":\"). In Python blocks of code are indicated with a colon (\":\") and are grouped by white space. Notice the else also ends with a colon (\":\"), \"else:\". Let's try changing the condition and see what happens."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "About that white space, consider the following code:\n",
    "\n",
    "    if condition:\n",
    "        print(\"Condition is True\")\n",
    "    else:\n",
    "        print(\"Condition is False\")\n",
    "    print(\"Condition is True or False, either way this is outputted\")\n",
    "\n",
    "Since the last print statement isn't indented it gets run after the if block or the else block.\n",
    "\n",
    "You can play with this. Try indenting the last print statement below and see what happens."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exercise\n",
    "---------\n",
    "\n",
    "You can also use \"and\" and \"or\" to combine conditions. Let's look at and.\n",
    "\n",
    "    True and True is True\n",
    "    True and False is False\n",
    "    False and True is False\n",
    "    False and False is False\n",
    "\n",
    "With \"and\" both conditions have to be True to be True. \n",
    "\n",
    "Below change the values of the three variables to make the entire \"if condition\" true."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Edit the values of these 3 variables\n",
    "boolean_literal = False\n",
    "number = 8\n",
    "string_literal = \"I like to count sheep before bed.\"\n",
    "\n",
    "# Leave this code the same please\n",
    "if number > 10 and boolean_literal and \"cows\" in string_literal:\n",
    "    print(\"Success!\")\n",
    "else:\n",
    "    print(\"Try again!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python knows a number of _compound_ data types, which are used to group together other values. The most versatile is the [*list*](https://docs.python.org/3.5/library/stdtypes.html#typesseq-list), which can be written as a sequence of comma-separated values (items) between square brackets. Lists might contain items of different types, but usually the items all have the same type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "squares = [1, 4, 9, 16, 25]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like strings (and all other built-in [sequence](https://docs.python.org/3.5/glossary.html#term-sequence) types), lists can be indexed and sliced:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists also support concatenation with the `+` operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unlike strings, which are [immutable](https://docs.python.org/3.5/glossary.html#term-immutable), lists are a [mutable](https://docs.python.org/3.5/glossary.html#term-mutable) type, which means you can change any value in the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cubes = [1, 8, 27, 65, 125]  # Something's wrong here ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the list's `append()` method to add new items to the end of the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cubes.append(216)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can even assign to slices, which can change the size of the list or clear it entirely:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The built-in [`len()`](https://docs.python.org/3.5/library/functions.html#len) function also applies to lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "letters = ['a','b','c']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can nest lists, which means to create lists that contain other lists. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = [1,2,3]\n",
    "x = [n, letters]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List literals are all about square brackets (\"[ ]\") and commas (\",\"). You can create a list of literals by wrapping them in square brackets and separating them with commas.\n",
    "\n",
    "You can even mix different types of things into the same list; numbers, strings, booleans."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[True, \"Awesome\", 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can put variables into a list and set a variable to a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us also review some operations and methods on lists..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Most of these concepts also apply to strings! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sweet. Let's stop learning the basic concepts here and put it in to practice with something interesting in the next episode. But first, let's summarize the learnings of this introductory section."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exceptional Python and getting help\n",
    "\n",
    "Python only understands certain code. When you write something Python doesn't understand it throws an exception and tries to explain what went wrong, but it can only speak in a broken Pythonesque english. Let's see some examples by running these code blocks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gibberish"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Hello' # EOF = End Of File"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Hello)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "200 / 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python tries to tell you where it stopped understanding, but in the above examples, each program is only 1 line long. \n",
    "\n",
    "Finally it tells you the type of thing that went wrong, (NameError, SyntaxError, ZeroDivisionError) and a bit more information like \"name 'gibberish' is not defined\" or \"unexpected EOF while parsing\".\n",
    "\n",
    "Unfortunately you might not find \"unexpected EOF while parsing\" too helpful. EOF stands for End of File, but what file? What is parsing? Python does it's best, but it does take a bit of time to develop a knack for what these messages mean. If you run into an error you don't understand please ask a tutor.\n",
    "\n",
    "Exercises\n",
    "---------\n",
    "\n",
    "Try to fix the two blocks of code so that they run successfully"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(Hello, World!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "answer = 3 * 8\n",
    "print(anwer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Getting help\n",
    "\n",
    "We are happy to help you! But... sometimes it is hard:\n",
    "\n",
    "> \"Geht irgendwie nicht\" (\"it doesn't work\")\n",
    "\n",
    "=> ***Context matters!*** <=\n",
    "\n",
    "Writing a *good* bug report is an art\n",
    "\n",
    "- https://github.com/stevemao/github-issue-templates/blob/master/bugs-only/ISSUE_TEMPLATE.md\n",
    "- https://developer.mozilla.org/en-US/docs/Mozilla/QA/Bug_writing_guidelines\n",
    "- https://www.chiark.greenend.org.uk/~sgtatham/bugs.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> \"So I loaded the disk on to my Windows . . .\"\n",
    "\n",
    "Writing clearly is essential in an error bug report. \n",
    "\n",
    "* **Be specific.** If you can do the same thing two different ways, state which one you used. \"I selected Load\" might mean \"I clicked on Load\" or \"I pressed Alt-L\". Say which you did. Sometimes it matters.\n",
    "* **Be complete.** Tell everything you did. \"I wanted X. You told me to do Y, but X still does not work.\" (...but actually, Y did not work)\n",
    "* **Provide context.** Report the background, such as e.g. the operating system. If you try to do something on Windows 98 and you don't have admin rights, that is definitely an important background.\n",
    "* **Be verbose.** Give more information rather than less. If you say too much, the programmer can ignore some of it. If you say too little, they have to come back and ask more questions. One bug report I received was a single sentence; every time I asked for more information, the reporter would reply with another single sentence. It took me several weeks to get a useful amount of information, because it turned up one short sentence at a time.\n",
    "* **Be careful of pronouns.** Don't use words like \"it\", or references like \"the window\", when it's unclear what they mean. Consider this: \"I started FooApp. It put up a warning window. I tried to close it and it crashed.\" It isn't clear what the user tried to close. Did they try to close the warning window, or the whole of FooApp? It makes a difference. Instead, you could say \"I started FooApp, which put up a warning window. I tried to close the warning window, and FooApp crashed.\" This is longer and more repetitive, but also clearer and less easy to misunderstand.\n",
    "* **Read what you wrote.** Read the report back to yourself, and see if you think it's clear. If you have listed a sequence of actions which should produce the failure, try following them yourself, to see if you missed a step.\n",
    "\n",
    "When you ask for help, make sure that you provide all the information that is potentially necessary."
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}