notebooks/02_W1_Tue_Python_and_Variables.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<div style=\"background-color:lightgrey;\n",
    "            padding:10px;\n",
    "            color:black;\n",
    "            border:black dashed 2px; \n",
    "            border-radius:5px;\n",
    "            margin: 20px 0;\">\n",
    "            \n",
    "            \n",
    "# Python and Variables\n",
    "Programming Languages; Why Python; What is a Variable? Practical on variables (print, int, floats, strings, booleans)\n",
    "\n",
    "**Staff:** Walter Daelemans <br/>\n",
    "**Support Material:** [exercises](https://github.com/dtaantwerp/dtaantwerp.github.io/blob/DTA_Bootcamp_2021_students/exercises/Questions_2023/01_EX_Python_and_variables.ipynb) <br/>\n",
    "**Support Sessions:** Friday, September 29 at 2:00 PM \n",
    "\n",
    "</div>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 1: Programming"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Programming Languages\n",
    "    \n",
    "A programming language is similar to a natural language, it has form and meaning, it even has a concept of idioms (programming clichés) and paraphrases (there are many ways to implement the same piece of code). \n",
    "\n",
    "|       | Natural Language | Programming Language |\n",
    "| ----- | -----: | -----: |\n",
    "| Syntax, Semantics, Lexicon, Grammar | ✅&nbsp; | ✅&nbsp; |\n",
    "| Idioms | ✅&nbsp; | ✅&nbsp; |\n",
    "| Paraphrases | ✅&nbsp; | ✅&nbsp; |\n",
    "| Style | ✅&nbsp; | ✅&nbsp; |\n",
    "| Ambiguity and vagueness | ✅&nbsp; | ❌&nbsp; |\n",
    "| Incompleteness | ✅&nbsp; | ❌&nbsp; | \n",
    "\n",
    "Fluency in programming requires \n",
    "- being able to translate ideas into algorithms\n",
    "- formulating the algorithms as efficient code\n",
    "- understanding and adapting code by others \n",
    "- using an appropriate programming style \n",
    "\n",
    "However, ambiguity and incompleteness are *not* allowed! Computers take everything literally.\n",
    "\n",
    "## Algorithms \n",
    "\n",
    "An algorithm (informally) is a finite series of steps computing an output from a (possibly empty) input in a reasonable time. It is similar to the mathematical concept of a function, which also maps inputs to outputs.\n",
    "\n",
    "Some examples of algorithms are:\n",
    "- finding all palindromes in a text (input is a text, output is a list of palindromes),\n",
    "- making a frequency dictionary or 'distribution' on the basis of a corpus (input is a list of texts, output is a dictionary of all the words in the corpus with their frequency in the corpus),\n",
    "etc.\n",
    "\n",
    "Soon you will be able to actually do this yourself!\n",
    "\n",
    "## Programming  \n",
    "\n",
    "The process of programming entails:\n",
    "1. Finding an algorithm for solving a problem (the semantics of the program) \n",
    "2. Implement it in correct, efficient code (the syntax of the program)\n",
    "3. This process often entails decomposition: split up a complex problem into less complex subproblems until they are simple enough to be easily implemented\n",
    "\n",
    "## Why Python?\n",
    "\n",
    "- It is Open Source (free) and available for all computer platforms\n",
    "- It is well-suited for processing text\n",
    "- MANY useful \"libraries\" for Natural Language Processing, Machine Learning, Artificial Intelligence, Scientific programming, Statistics, ...\n",
    "- Good first programming language for people new to programming\n",
    "- Helpful Python community, many tutorials online, e.g., Stackoverflow\n",
    "\n",
    "## Translation\n",
    "\n",
    "- Python is a high-level programming language that has to be translated to a language that the computer understands (machine language)\n",
    "    - Compiler\n",
    "        - Translates a complete “source” program directly to machine code ready for execution by the CPU of the computer\n",
    "    - Interpreter\n",
    "        - Translates incrementally, interactively, one piece at a time\n",
    "\n",
    "[Python](https://www.python.org/) is an interpreted language which is great for exploratory programming and prototyping. (The current version of the language is 3.9.)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example programming task\n",
    "    \n",
    "- Input: a word (e.g. 'Bootcamp')\n",
    "- Output: a representation of the word as a pattern of consonants and vowels (in this case: 'CVVCCVCC')\n",
    "\n",
    "How would you handle this?\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Some Ideas for a Solution\n",
    "\n",
    "Semantics / algorithm:\n",
    "\n",
    "- I have to know which letters are vowels and which ones are consonants (a **test**)\n",
    "- I have to do this test for each letter in the algorithm (a **loop**)\n",
    "- I have to produce a 'C' or 'V' in the output for each letter in the input (**input** and **output**)\n",
    " \n",
    "    \n",
    "Syntax / Code:    \n",
    "    \n",
    "**Don't worry about understanding the details yet!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_vowel (letter):\n",
    "    \"A test to check whether a letter is a vowel or not\"\n",
    "    if letter in ['a', 'e', 'i', 'o', 'u']:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "\n",
    "def CV_convert (word): \n",
    "    \"A function that loops through the letters of a word, \\\n",
    "    checks whether the letter is a vowel and concatenates 'C' or 'V' to the result according \\\n",
    "    to the result of the test.\"\n",
    "    result = ''\n",
    "    for letter in word:\n",
    "        if is_vowel(letter):\n",
    "            result += 'V'\n",
    "        else:\n",
    "            result += 'C'\n",
    "    return result\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "is_vowel('a')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "is_vowel('x')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "CV_convert('Bootcamp')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice:\n",
    "    \n",
    "- Syntax: punctuation (: brackets, ...), indentation, keywords\n",
    "- Semantics: test, loop, ...\n",
    "- Idiom: loop over a sequence and perform a test on each element of the sequence"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Things can go wrong in programming: debugging ###\n",
    "    \n",
    "- The algorithm is wrong (**semantic errors**)\n",
    "   - Forgot that y can be a vowel as well \n",
    "   - What about capital letters? \n",
    "   - What about spaces?\n",
    "   - ...\n",
    "- The code is wrong (**syntactic errors**)\n",
    "   - Missing colon, wrong indentation, …\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "WARNING: If you are completely new to programming and/or linguistics this may all have seemed complex and strange to you. Don't worry and return to the pevious part in a few days, when you have more programming experience."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 2: Variables"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variables are used in programs to give a name to something. In variable **assignment** we link a name to a value by doing *name = value*. The result is that the name is linked to that value, the name is **bound** to the value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "teacher = 'Walter'\n",
    "teacher"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "current_year = 2023\n",
    "current_year"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If a name is used that has not been assigned a value, we get an error message, in this case a `NameError`, because this variable's name hasn't been defined yet:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#next_year"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A variables keeps its value unless we reassign it: we can overwrite the current value of a variable name by assigning it a new value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "current_year"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "current_year = current_year + 1\n",
    "current_year"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "age = 2021 - 2000\n",
    "age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "age + 1"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The single `=` is called the **assignment operator**. Variable assignment is not the same as **equality testing** (for which we use `==`, which we'll cover in greater depth later):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 3 + 5\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x == 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x == 8"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we should add that there exist a couple of **shortcut operators**, like `+=`, `+-`, `+*`, etc. This operators combine a basic arithmetic operation, like an addition, with a reassignment:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "year = 2020\n",
    "year += 1\n",
    "print(year)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This completely equivalent to the following code block, but more concise and \"Pythonesque\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "year = 2020\n",
    "year = year + 1\n",
    "print(year)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Restrictions on the syntax of names \n",
    "\n",
    "- All letters can be used and the underscore (`_`), NOT spaces, hyphens, and other special characters\n",
    "    - Strings (starting with `\"` or `'`) can therefore not be used as names\n",
    "- Python is case-sensitive\n",
    "    - Uppercase and lowercase versions of letters are interpreted by Python as different\n",
    "- Digits can be used but not as the first character in a variable name\n",
    "    - Numbers can therefore not be used as names\n",
    "- Python **reserved words** or **keywords** (names that have special meaning for Python) cannot be used \n",
    "    - Here's a list: **False, True, None, and, or, not, as, assert, break, continue, class, def, del, if, elif, else, except, finally, for, from, global, import, in, is, lambda, nonlocal, pass, raise, return, try, while, with, yield**\n",
    "    - Luckily they are color-coded in most editors!"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Programming Style: Variable names\n",
    "\n",
    "- Use names that make clear what kind of value it is associated with\n",
    "    - age, birthyear, publication_date, name, location, ...\n",
    "- Use names that are not ambiguous\n",
    "    - first_name, family_name, ..."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercises: guess what the output will be before you execute the cell: ###"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(2 + 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 12\n",
    "b = -4\n",
    "\n",
    "b = a + 7\n",
    "\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = b\n",
    "\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = \"apple\"\n",
    "d = \"pear\"\n",
    "\n",
    "print(c+d*3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"appel\" = 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "peach == 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "crazy_laugh = 'ha' * 100\n",
    "crazy_laugh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "room_capacity = 25\n",
    "covid_allowed_use = 1/3\n",
    "number_of_students = 8\n",
    "# Can we fit the students in the room?\n",
    "\n",
    "number_of_students < room_capacity * covid_allowed_use"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What happens behind the scenes?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1  \n",
    "b = a\n",
    "\n",
    "# In memory: a->1, b->1\n",
    "\n",
    "print(a)\n",
    "print(b)\n",
    "\n",
    "a = 2\n",
    "\n",
    "# In memory: a->2, b->1 (not 2!)\n",
    "\n",
    "print(a)\n",
    "print(b)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.13 ('base')",
   "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.13"
  },
  "vscode": {
   "interpreter": {
    "hash": "96e0a4d32f1918f770291244863a4a1e044b05d1a3b8d455e2e179187e01062a"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}