chapters/Chapter 02 - Getting Started with Variables and Values.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This material is copied (possibily with some modifications) from the [Python for Text-Analysis course](https://github.com/cltl/python-for-text-analysis/tree/master/Chapters)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 2 - Getting Started with Variables and Values\n",
    "\n",
    "*This notebook uses code snippets and explanations from [this course](https://github.com/kadarakos/python-course/blob/master/Chapter%201%20-%20Variables.ipynb).*\n",
    "\n",
    "In this course we will learn how to load, process and save data using a versatile programming language: Python. We are going to practise Python using Notebooks. These Notebooks contain instructions and so called 'code blocks'. The instructions are paragraphs of text that explain the concepts we are going to use. The 'code blocks' contain Python code. \n",
    "\n",
    "Notebooks are pretty straightforward. Some tips:\n",
    "\n",
    "* Cells in a notebook contain code or text. If you run a cell, it will either run the code or render the text.\n",
    "* There are five ways to run a cell:\n",
    "    1. Click the 'play' button next to the 'stop' and 'refresh' button in the toolbar.\n",
    "    2. Alt + Enter runs the current cell and creates a new cell.\n",
    "    3. Ctrl + Enter runs the current cell without creating a new cell. (Cmd + Enter on a Mac.)\n",
    "    4. Shift + Enter runs the current cell and moves to the next one.\n",
    "    5. Use the menu and select Cell/Run all.\n",
    "* The instructions are written in Markdown. [Here](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) is a nice Markdown cheatsheet if you want to write some more.\n",
    "* Explore the menus for more options! You can even create a presentation using Notebooks.\n",
    "\n",
    "**Hint:** when you're writing Python code, press Tab to auto-complete your variable names! We will explain what variable names are in further down in this notebook. \n",
    "\n",
    "\n",
    "#### At the end of this chapter, you will be able to:\n",
    "* print information to your screen using the built-in function `print()`\n",
    "* assign *values* to *variables* (using valid and clear *variable names*)\n",
    "* do calculations in Python\n",
    "* have an understanding of some basic aspects of programming in python\n",
    "\n",
    "\n",
    "#### If you want to learn more about these topics, you might find the following links useful:\n",
    "- Documentation: [The Python 3 documentation](https://docs.python.org/3/)\n",
    "- Glossary: [Glossary](https://docs.python.org/3/glossary.html)\n",
    "- Free e-book: [How to think like a computer scientist](http://www.openbookproject.net/thinkcs/python/english3e/)\n",
    "- Free e-book: [A Byte of Python](https://python.swaroopch.com/)\n",
    "- Community: [Learnpython](https://www.reddit.com/r/learnpython/) -- Reddit community for learners of Python\n",
    "- Video: [Python names and values](http://nedbatchelder.com/text/names1.html) -- Note: this might be a bit too technical at this stage\n",
    "- [PEP8 Style Guide for Python](https://www.python.org/dev/peps/pep-0008/)\n",
    "- [Python Tutor](http://pythontutor.com/) -- Shows you line-by-line what your code does\n",
    "\n",
    "\n",
    "#### Important information for this course:\n",
    "\n",
    "- We work with the latest python version (3.7). Please make sure this is the version you're using. \n",
    "- We highly recommend using the Anaconda [distribution of python](https://www.anaconda.com/distribution/). It comes with a couple of highly useful python installations as well as the jupyter notebook environment. Everything you need will be installed in one go.\n",
    "- This course does not assume any programming background. We strongly believe that anyone can learn how to code. We encourage a playful attitude and do our best to include fear-taking exercises.\n",
    "\n",
    "#### A note on getting stuck:\n",
    "\n",
    "- Please note that learning how to code is a process that usually heavily relies on 'trial and error'. This means that throughout the course, you will repeatedly have to try out different solutions until you find out what works (and hopefully why). Having to try several times is completely normal and part of the process - please do not get discouraged. \n",
    "- It is highly recommended to start learning how to 'debug' your own code early on. If you do not know what to do or get error messages, try and take a step back and think about what you were doing and why. Using pen and paper to break down problems into smaller steps is highly recommeded. We will highlight different debugging strategies throughout the course. \n",
    "- If you still feel lost after having tried to solve your problems yourself, please feel free to contact the teachers. \n",
    "\n",
    "If you have **questions** about this chapter, get in touch with Cody in the Slack group.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Now let's get started!*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Getting started together\n",
    "\n",
    "\n",
    "### 1.1 Hello, world!\n",
    "The best way to learn Python is by jumping right in. Let's start with something really simple. Every programming language is traditionally introduced with a \"Hello world\" example. Please run the following cell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this will print some text\n",
    "print(\"Hello, world!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What happened here? Well, Python has a large set of **built-in functions**, and **`print()`** is one of them. When you use this function, `print()` outputs its *argument* to the screen. 'Argument' is a fancy word for \"object you put in a function\". In this case, the argument is the string \"Hello, world!\". And 'string' just means \"a sequence of characters\".\n",
    "\n",
    "Did you also notice the first line starting with a hash (#) character? This is called a **comment**. We use comments to document our code and explain what's happening. These lines are not executed in Python. We will use them a lot in this course to make our code easy to understand!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Can you edit the block below in such a way that it will print out your own name?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello, Cody!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 Calculations\n",
    "Apart from printing some text to your screen, you can also use Python to do calculations. The code is actually really simple - you probly know most of it from your calculator! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# summing\n",
    "print(3+2)\n",
    "\n",
    "# subtracting\n",
    "print(7-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# multiplication\n",
    "print(3*3)\n",
    "\n",
    "# division\n",
    "print(10/3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# power\n",
    "print(5**2)\n",
    "\n",
    "# combining stuff\n",
    "print(5*2-3+4/2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#using brakets to tell python what to calculate first:\n",
    "print((5+5)*(8+2))\n",
    "# compared to:\n",
    "print(5+5*8+2)\n",
    "#Can you tell what is happening in these examples?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Variables and values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instead of providing the string directly as an argument to the `print` function, we can also create a variable that refers to the string value \"Hello, world!\". \n",
    "\n",
    "When you pass this variable to the `print()` function, you get the same result as before:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cheese = \"Hello, world!\"\n",
    "print(cheese)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Such a piece of text (\"Hello, world!\") is called a **string** in Python (cf. a *string* of characters). Strings in Python must always be enclosed with 'quotes' (e.g. single or double quotes). Without those quotes, Python will think it's dealing with the name of some variable that has been defined earlier, because variable names never take quotes.\n",
    "\n",
    "Programming languages can be seen as **formalized ways of telling your computer what to do**. They rely on very **strict regularities (called syntax)** so they can distinguish different kinds of things. We will see that python knows a couple of different data types, each of which can be used to do different things. Python needs to be able to tell them apart. \n",
    "\n",
    "The following distinction is confusing, but extremely important: variable names (*without* quotes) and string values (*with* quotes) look similar, but they serve a completely different purpose. Compare:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Patrick Bateman\"\n",
    "print(\"name\")   # this is a string value\n",
    "print(name)    # this is a variable name containing a string value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also assign numerical values to variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 22\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 Variable assignment\n",
    "\n",
    "If you vaguely remember your math classes in school, this should look familiar. It is basically the same notation with the name of the variable on the left, the value on the right, and the '=' sign in the middle. This is what is called **assignment**. We stored a value and named it using the '=' symbol, so that we can easily use it later on without having to type the particular value. \n",
    "\n",
    "We can use the box metaphor to further explain this concept. The variable `x` above behaves pretty much like a box on which we write an x with a thick, black marker to find it back later. In this box we can put whatever we want, such as a piece of text or a numerical value. In Python, the term **variable** refers to such a box, whereas the term **value** refers to what is inside this box. \n",
    "![box](./images/box.png)\n",
    "\n",
    "Note that we can re-use variable names for other values, but that any assignment will *overwrite* the original value! In other words: when you **re-asign** a variable, you remove the content of the box and put something new in it. Each variable will always contain the value that you last assigned to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = \"I like apples\"\n",
    "print(text)\n",
    "text = \"I like oranges\"\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we have stored values inside variables, we can do interesting things with these variables. Run the following code block to see what happens. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 3\n",
    "print(x)\n",
    "print(x * x)\n",
    "print(x + x)\n",
    "print(x - 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 Variable names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the **variable names** `text` and `x` used above are not part of Python. In principle, you could use any name you like. Even if you change the variable `text` to something silly like `pikachu` or `sniffles`, the example would still work: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sniffles = \"Hello, world!\"\n",
    "print(sniffles)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, variable names are only **valid** if they:\n",
    "\n",
    "- start with a letter or underscore (\\_)\n",
    "- only contain letters, numbers and underscores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Even though you could use any variable name as long as they are valid, there are some **naming conventions** that are explained in the [PEP8 Style Guide for Python Code](https://www.python.org/dev/peps/pep-0008/). For now, it's enough to remember the following for naming your variables:\n",
    "\n",
    "- use clear, meaningful, descriptive variable names so that your code will remain understandable\n",
    "- use the `lowercase_with_underscores` style, with lowercase characters and underscores for separating words \n",
    "- do not use built-in names, such as `print` or `sum` (these will turn green in Jupyter Notebooks)\n",
    "\n",
    "For example, the following variable name is valid, much more descriptive than `x` would be and follows the naming conventions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "seconds_in_seven_years = 220752000\n",
    "print(seconds_in_seven_years)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3 Copying/referencing variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also 'copy' the contents of a variable into another variable, which is what happens in the code below. In fact, what is happening is that the variable `second_number` now refers to the same data object as `first_number`. You should of course watch out in such cases: make sure that you keep track of the value of each individual variable in your code (later in the course, we will see that this is especially tricky with data types that are *mutable* (i.e. things you can modify after you created them), such as lists). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "first_number = 5\n",
    "print(first_number)\n",
    "\n",
    "\n",
    "second_number = first_number\n",
    "\n",
    "first_number = 3\n",
    "\n",
    "print(first_number)\n",
    "print(second_number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Have a look at this code at [Python Tutor](https://goo.gl/epc7bq) to see what's happening!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4 User input"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Up until now we have defined the values stored in the variables ourselves. However, we can also ask for input from a user. We'll make use of another built-in function: **input()**. This takes user input and returns it as a string. Try it below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = input(\"Please enter some text: \")\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 1: \n",
    "Use Python as a calculator to calculate the number of seconds in seven years (in one line of code). Assign the output to a variable with a clear variable name. Print the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2: \n",
    "Rewrite the code you above before by assigning each of the numerical values to a variable with a clear name. Then use these variables to calculate the number of seconds in seven years."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "days_in_year = 365\n",
    "# assign each of the values to meaningful variable names\n",
    "\n",
    "seconds_in_seven_years = days_in_year * # finish this line\n",
    "print(seconds_in_seven_years)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 3: \n",
    "Run the following code block and see what happens. Can you fix the invalid variable names? You should get no error in the end."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eggs = 3\n",
    "_eggs = 6\n",
    "5eggs = 5\n",
    "eggs$ = 1\n",
    "eggs123 = 9\n",
    "ten_eggs = 10\n",
    "TwelveEggs = 8\n",
    "twelve.eggs = 12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 4: \n",
    "Can you write some code that swaps the values of these two variables? Hint: create an extra variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "first_number = 3\n",
    "second_number = 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 5: \n",
    "Write a program that asks two people for their names using `input()`. Store the names in variables called `name1` and `name2`. Say hello to both of them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# adapt the code\n",
    "name1 = \"Paul\"\n",
    "print(\"Hello,\", name1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 6: \n",
    "\n",
    "The following piece of code will not work. You can see this, because it will print an error message (more on this in the following chapters). Can you figure out how to fix it?\n",
    "\n",
    "Hint 1: Look at the quite (') characters.\n",
    "Hint 2: You can use single quotes (') and double quites(\") to define strings. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_text = 'The word 'python' has many meanings in natural language. '"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.8.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}