w1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **xSoc Python Course** - Week 1\n",
    "\n",
    "### *Variables, Datatypes & Exceptions*\n",
    "\n",
    "🖋️ *Written by the [Computing Society](https://go.uwcs.uk/links)*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In our first week, we'll cover the basics of:\n",
    "\n",
    "- Built-in Functions\n",
    "    - Print\n",
    "    - Input\n",
    "- Variables\n",
    "    - Syntax and shorthand operators (+=)\n",
    "- Debugging\n",
    "    - Exceptions\n",
    "- Datatypes\n",
    "    - Integers & Floats\n",
    "        - Various mathmatical operations (+, -, *, /, //)\n",
    "    - Strings\n",
    "        - Concatenation and repetition\n",
    "    - Casting between them"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a *Jupyter notebook*. It's a special type of file that allows us to easily run and re-run snippets of Python code, carrying information from one snippet to the other. These snippets are usually called **cells**.\n",
    "\n",
    "Try hovering over the cell below, and press the play button on the left side to run it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "good_food = \"chocolate\"\n",
    "print(\"I love \" + good_food)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables, Integers and a Function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You've probably come across variables before, in the context of maths. Something like 'find $x$, where $42 + x = 111$'. In other words, variables consist of two things - a name and a value. It's pretty similar for Python programs. We have to assign a value of a particular **datatype** (more on those later) to the variable name, and can recall it later in the script.\n",
    "\n",
    "The syntax rules for assigning some datatype value to a variable name is `[variable name] = [expression]`. This assigns the *value* of the right hand side to the *name* on the left hand side. Note that `[variable name]` can't start with a digit, or contain any spaces.\n",
    "\n",
    "Here are some basic examples of assignments, using the integer (whole number) datatype:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "seven = 6\n",
    "favouriteNumber = -74\n",
    "concerningly_long_name_to_represent_a_single_integer = 4321"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The general convention in Python is to write variable names in snake case, putting underscores to represent gaps between words `like_this` or `this` but `notLikeThis`. So, the first and third examples would follow these conventions, if you care about that sort of thing. We'll try to stick to that in our examples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you ran the cell above, you might have noticed the lack of any output. This is because we haven't told Python to output anything! To fix this, let's introduce the `print()` function. It's pretty simple - you put some data between the brackets, and it's going to be displayed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_num = 4\n",
    "print(7)\n",
    "print(my_num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The cell executes line-by-line, top to bottom:\n",
    "- Line 1 assigns the integer value 4 to the variable name `x`.\n",
    "- Line 2 calls the print function with the integer value 7, so we display 7 on the first output line\n",
    "- Line 3 calls the print function with the variable name `x` - this has the integer value 4, so we also display 4 on the next output line.\n",
    "\n",
    "Every function has to be referred to by a name, in this case 'print', and we call the value between the brackets an **argument** - the data the function uses. For now, think of functions as magical black boxes that either do something, or evaluate to something.\n",
    "\n",
    "Some functions can accept multiple arguments, separated by commas. For example, `print()` has a 2-argument version:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = -9\n",
    "y = 13\n",
    "print(y, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before we move on, one more thing about variables. You can overwrite them! Since we execute each line from top to bottom, this will obviously only affect the value for anything below the re-assignment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cool_number = 8\n",
    "epic_number = -16\n",
    "print(cool_number, epic_number)\n",
    "epic_number = -512\n",
    "cool_number = 1024\n",
    "print(epic_number, cool_number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's also introduce some basic infix operations we can use on integers.\n",
    "\n",
    "| Operation | Description | Operation | Description |\n",
    "|:-:|-|:-:|-|\n",
    "| `+` | Adds two numbers | `/` | Divides two numbers, always returns a float (see below) |\n",
    "| `-` | Subtracts two numbers | `//` | Divides two numbers, returning the integer part |\n",
    "| `*` | Multiplies two numbers | `%` | Divides two numbers, returning the remainder |\n",
    "\n",
    "Most of them should be fairly recognisable, but it's worth noting the difference between `/` and `//`. Using the first one reveals another datatype: floating point numbers, or floats! Because not all numbers are created whole. Here's the difference:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Float (normal) division\n",
    "print(7 / 3)\n",
    "print(4 / 4)\n",
    "# Integer (quotient) division\n",
    "print(7 // 3)\n",
    "print(4 // 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also just write something as a float to begin with, like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 2.6\n",
    "print(5.4 + x)  # Outputs 8.0 (float), not 8 (integer)!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you might expect, you're free to switch between variables or direct values when using operations; just remember to put these expressions on the right hand side of an assignment statement. You should also be aware of *operator precedence* - a fancy way to say that Python follows BIDMAS rules when deciding what happens first, and if there's a tie, just evaulates from left to right."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "foo = 5\n",
    "bar = 2\n",
    "\n",
    "bar = bar * 2\n",
    "baz = foo + 3 * bar\n",
    "biz = 50 // (4 + baz)  # Without brackets, division happens first\n",
    "biz = biz - 1\n",
    "\n",
    "print(biz)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For statements like `a = a + b`, Python has a shorthand notation! The `+=` operator allows us to write `a += b`, which just takes the existing value of `a`, adds `b`, and then reassigns it to `a`. This also works for the other operations: subtraction (`-=`), multiplication (`*=`), division (`/=` or `//=`), and modulo (`%=`). \n",
    "\n",
    "Let's rewrite the previous code block using these symbols. If we run it, the result is exactly the same:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "foo = 5\n",
    "bar = 2\n",
    "\n",
    "bar *= 2\n",
    "baz = foo + 3 * bar\n",
    "biz = 50 // (4 + baz)\n",
    "biz -= 1\n",
    "\n",
    "print(biz)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exceptions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is probably a good time to introduce something you'll be seeing a lot - Exceptions. These will pop up whenever something goes wrong with your program, and stop the rest of it from executing. It's normal to run into these. Everyone makes mistakes when programming, even professionals!\n",
    "\n",
    "There are generally 3 'forms' of problems that can arise in your Python code:\n",
    "- **Syntax** - Your script doesn't follow the structural rules of the language.\n",
    "- **Runtime** - The structure is fine, but your script attempts to do something prohibited by the language while it's executing.\n",
    "- **Logic** - The script runs fine, but it doesn't do what you want it to.\n",
    "\n",
    "Obviously, Python exceptions are only going to catch the first two. Make sure to pay attention to the extra information exceptions give you, they usually give a pretty good indicator of the problem. If in doubt, you can always look up the error you're getting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "normal_number = 6\n",
    "uh_oh = normal_number / 0\n",
    "print(uh_oh)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings, Casting, and another Function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python represents text using something called a string - basically a collection of letters strung (get it?) together in some order. We'll revisit them in more detail when we discuss arrays, but for now just think of them as a big chunk of text.\n",
    "\n",
    "When specifying a string, you have to denote where it starts and ends, by surrounding it in either the `\"` character or `'` character. Why? Well, Python normally ignores spacing after the start of any line of code! Each of the three lines here are all equivalent, even if a few of them look cursed..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(    (5+8)//4   )\n",
    "print((5 + 8) // 4)\n",
    "print(          (     5      +   8  )      //    4     )\n",
    "\n",
    "# Be careful! The following would not work: \n",
    "# --- any spacing ---  print((5 + 8) // 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, spaces within string quotes are counted as the literal 'space character', so will be displayed with the `print` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "truth = 'Computers do not like me'\n",
    "print(\"I like computers\")\n",
    "print(truth)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some operations (but not all) that work on integers also work on strings. Strings can also contain special characters, which serve different purposes. We'll go through a few exercises will guide you through these concepts."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Type Casting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings and integers don't really mix. Thankfully, it's possible to turn integers into strings, and (some) strings into integers - this is called type casting. We'll do this using the `str()`, `int()` and `float()` casts. The standard versions accept a single argument, and that's the datatype you're trying to change. No prizes for guessing which cast is which."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var = \"-3\"\n",
    "print(var)\n",
    "\n",
    "# From a string to an integer...\n",
    "var = int(var) + 4\n",
    "print(var)\n",
    "\n",
    "# ...from an integer to a float...\n",
    "var = float(var) - 0.5\n",
    "print(var)\n",
    "\n",
    "# ...and back to a string.\n",
    "var = \"£\" + str(var) + \"0 in my bank account\"\n",
    "print(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are some subtleties when converting between integers and floats. For example:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- What happens when we try to add an integer and a float without converting anything?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "whole = 7\n",
    "floaty = 4.2\n",
    "print(whole + floaty)  # didn't break!\n",
    "print(whole)  # still an integer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As floats are a type of number with more information than an integer - the cast happens automatically. We call this an **implicit cast**, because Python sees that the integer `whole` can have its type *widened* for that calculation. Neat!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- What happens when we convert a float to an integer?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "e = 2.7182818\n",
    "print(int(e))  # The engineer's preferred version"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As floats store more information than an integer does, Python converts it by chopping off everything after the decimal point. This is called **type narrowing**, because we're losing information from the cast. Sorry, `e`!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, you can assign values of a different datatype to the same variable name. Depending on who you ask this was either a wonderfully brilliant or absolutely terrible decision. Other programming languages may not let you do this."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accepting User Input"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far, we've been accepting 'input' to our program by declaring some variables at the top. But it turns out there was an `input()` function for it all along...\n",
    "\n",
    "`input()` accepts a single argument, which will be displayed as a prompt to the user when the cell is run. The script will be paused until you type something, and hit enter. Whatever you typed is then **returned** by the function, as a string. In other words, this function produces a value, and can be assigned to a variable or used in an expression.\n",
    "\n",
    "Try it out below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "your_name = input(\"What's your name? : \")\n",
    "print(\"Hi \" + your_name + \", I'm Dad!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can combine the `input()` function with type casting, to handle datatypes other than strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "your_age = input(\"Enter your age: \")\n",
    "your_age = int(your_age) + 1\n",
    "print(\"You'll be \" + str(your_age) + \" next year? Wow, and I thought my grandpa was old.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function and cast in Lines 1 and 2 above can be condensed into a single line, if you want:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "your_age = int(input(\"Enter your age: \")) + 1\n",
    "print(\"You'll be \" + str(your_age) + \" next year? Wow, and I thought my great grandma was old.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alright, that's everything you need to know for Week 1! Now, let's check you understand it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Review\n",
    "\n",
    "Here's what we've covered this week:\n",
    "\n",
    "- Python programs are executed line-by-line, from top to bottom.\n",
    "- Variable names should be written `like_this` and assigned a value `like = \"this\"`. They can be updated and overwritten throughout the script!\n",
    "- There are three main types of problems that can arise in your Python code: **Syntax**, **Runtime**, and **Logic**. Exceptions catch the first two.\n",
    "- Three of the main datatypes you should know, and their casts, are:\n",
    "\n",
    "| Name | Cast | Example | Description |\n",
    "|:-:|:-:|:-:|-|\n",
    "| String | `str()` | `\"There's spacing, see?\"` | Represents a sequence of letters/characters. |\n",
    "| Integer | `int()` | `-4650` | Represents whole numbers, whether positive or negative. |\n",
    "| Floating Point | `float()` | `31.415926` | Represents real numbers, to a certain degree of accuracy. |\n",
    "\n",
    "- There are a number of common operations: `+`, `-`, `*`, `/`, `//`, `%`. You can use the `+=` shorthand to apply an operation to an existing variable.\n",
    "- Functions, such as `print()` and `input()`, accept arguments `print(like, \"this\")`, and can return values or modify data (Covered more in Week 2)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "🖋️ ***This week was written by the [Computing Society](https://go.uwcs.uk/links)***\n",
    "\n",
    "See you next week!"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.4 64-bit",
   "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.10.7"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "268a003517095b3e00ec49a0832a87899bac50083c754616205934d33472dfcd"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}