01_basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The Basics: Variables and Printing\n",
    "\n",
    "This notebook is based on materials kindly provided by the [IN1900]( https://www.uio.no/studier/emner/matnat/ifi/IN1900/h19/) team.\n",
    "\n",
    "Programming is a way of telling the computer what to do.\n",
    "Computer programs are a kind of recipe, like cooking or knitting recipes.\n",
    "However, cooking recipes can sometimes be vague or imprecise. For example, an instruction could be \"add 4-5 eggs\" \tor \"bake for 25-30 minutes till done\".\n",
    "Because humans have discretion, we can make sense of such vague instructions.\n",
    "Unfortunately, computers don't have discretion.\n",
    "Therefore, computer programs must be both precise and correct."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python as a Calculator \n",
    "You can do simple math like this:\n",
    "\n",
    "- $a + b$ in Python :  `a + b`\n",
    "- $a - b$ in Python :  `a - b`\n",
    "- $a \\times b$ in Python :  `a * b`  \n",
    "- $\\frac{a}{b}$ in Python :  `a / b`  \n",
    "- $a^b$ in Python : `a**b`  \n",
    "- $3.2 \\times 10^7$ in Python :  `3.2e7` \n",
    "\n",
    "You’ll need to use parenthesizes for larger expressions. See examples below.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1+2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "4-3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1/3\n",
    "1/(5*2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Printing to the Screen (Terminal)\n",
    "\n",
    "As we can see above, Jupyter Notebook only displays the value of the final expression in a cell.\n",
    "If you want to see the value of other expressions, you need to print them to the screen.\n",
    "\n",
    "In Python, you can use the function `print()` to display things on the screen.\n",
    "Put the item to be printed inside the parentheses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can print multiple items separated by commas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to print text, it must be in quotes, like below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"This message will be printed\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  <span style=\"color:green\"> Exercise: Your First Program </span>\n",
    "Print out the message \"Hello, World!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your Solution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables\n",
    "\n",
    "In the examples above, the computer \"forgets\" the information as soon as it has been printed.\n",
    "We need some way to store information in our program. This is what variables are for.\n",
    "Variables are like handles we use to retrieve information.\n",
    "\n",
    "In Python, variables can be declared as shown in the code snippet below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 2\n",
    "print(\"a =\", a)\n",
    "b = a + 1\n",
    "print(\"b =\", b)\n",
    "a = a + 3\n",
    "print(\"a =\", a)\n",
    "print(\"b =\", b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the left side is assigned the value of the right side. Contrary to math, it is therefore \"allowed\" to, for example, set variables to themselves plus something, as shown above.\n",
    "\n",
    "Note that `b` does not change value when you change `a` *after* declaring `b`.\n",
    "\n",
    "**Remember that Python reads the file from the top line downwards.** Therefore, you must declare `a` before ` b` in the code snippet above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variable Names\n",
    "\n",
    "Python doesn't really care which variable names you use. Variable names can contain:\n",
    "- all letters, both uppercase and lowercase, found in the **English alphabet**.\n",
    "- **underscore**: _\n",
    "- numbers, but **a number cannot be the first character of the name**\n",
    "- no other characters are allowed in variable names\n",
    "\n",
    "These rules are illustrated below, with a terribly long variable name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "VARIABLE_NAME_with_1_2_3 = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Use descriptive names\n",
    "\n",
    "As mentioned, Python doesn’t care what variable names you use, but we humans do.\n",
    "You should create descriptive variable names to increase the readability of your code. Variable names should not be too long, but should be descriptive enough for others (or you in the future) to understand what the variable is.\n",
    "Once the variable is declared, it can be used!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pi = 3.14\n",
    "\n",
    "print(\"pi =\", pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  <span style=\"color:green\"> Exercise: Variable Names </span>\n",
    "\n",
    "Why does the code below yield an error? Fix the code such that the name is printed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Arthur\"\n",
    "print(Name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables as Sticky Notes\n",
    "\n",
    "Python variables are *independent* from each other.\n",
    "Let's define two variables. Alice is 20 years old, and her classmate Bob is the same age:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alice_age = 20\n",
    "bob_age = alice_age"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then it's Alice's birthday. Now, what's the value of bob_age?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alice_age = 21\n",
    "print(bob_age)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "![picture of sticky notes](images/Alice_age.jpg)\n",
    "\n",
    "The variable bob_age is independent from alice_age, even though it was initially assigned the value from alice_age.\n",
    "This is just the way variables are defined in Python. It would be perfectly fine to have another kind of variable where the two variables are connected, but this is not how standard python variables work."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  <span style=\"color:green\"> Exercise: Understanding Variables </span>\n",
    "\n",
    "Go through the following lines of code step-by-step.\n",
    "What are the values of the different variables after each step?\n",
    "You can check your answers by executing each line in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "length = 5\n",
    "width = 3.5\n",
    "length = length * 2\n",
    "width = width - 1.5\n",
    "print(length, width)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  <span style=\"color:green\"> Exercise: Using Variables to Perform Simple Calculations</span>\n",
    "\n",
    "Alice weighs 65 kg, and Bob weighs 70 kg.\n",
    "1. Create variables containing these data. Try to think of descriptive variable names.\n",
    "2. Create a new variable containing their total weight, calculated from the two variables from 1.\n",
    "3. Charlie weighs 85 kg. Calculate Alice, Bob and Charlie's average weight."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your Solution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data types\n",
    "\n",
    "Variables can be of different types besides whole numbers (integers).\n",
    "We will look at some of the types in Python. You can use the function `type()`to find the type of a variable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Integers (Whole Numbers)\n",
    "\n",
    "In Python a whole number is called an *integer*, but when programming we use the abbreviation `int`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(type(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Float (Decimal Numbers)\n",
    "\n",
    "A decimal number is called a `floating point number`, but when programming it is abbreviated `float`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(type(1.2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String (Text) \n",
    "\n",
    "In Python, text is called *String*, abbreviated `str`. \n",
    "\n",
    "Did you wonder why we used quotes when printing text? If we don't quote text, python will think the string is a variable name.\n",
    "The quotes make it clear that text is *not* a variable name, but a `String`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(type(\"spam\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below, we try to print a string that is not enclosed in quotes.\n",
    "Therefore, python thinks that we are trying to use the variable name `spam`.\n",
    "We get an error message stating that python cannot find this variable:\n",
    "`NameError: name 'spam' is not defined`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(spam)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  <span style=\"color:green\">Exercise: Datatypes</span>\n",
    "\n",
    "Can you change the variables below, so that all three contains the value two, but with different datatypes? The output should be the title of each exercise.\n",
    "\n",
    "####  <span style=\"color:green\">a) <class 'int'> </span>\n",
    "Let the variable `int_2` be an integer with the value two.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int_2 = ?\n",
    "print(type(int_2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  <span style=\"color:green\">b) <class 'float'> </span>\n",
    "Let the variable `float_2` be a decimal number with the value two.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "float_2 = ?\n",
    "print(type(float_2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  <span style=\"color:green\">c) <class 'str'> </span>\n",
    "Let the variable `str_2` be the text containing the number two. (Not \"two\"). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "str_2 = ?\n",
    "print(type(str_2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing Libraries/Modules\n",
    "\n",
    "A module is a collection of functions that someone has written. A library is a collection of modules.\n",
    "There are innumerable python libraries available for performing diverse tasks.\n",
    "For example, Python comes with a built-in module called `math`, which contains variables and functions for doing math.\n",
    "The statement `import <module_name>`, makes the module available to use in your program.\n",
    "To use a function in the module, you write\n",
    "    \n",
    "    <module_name>.<function_name>\n",
    "    \n",
    "as demonstrated below.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "print(time.time())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you are only using a few functions from a module, you can import those functions directly.\n",
    "You do this with the from statement:\n",
    "\n",
    "    from <module_name> import <function_name_1>, <function_name_2>\n",
    "\n",
    "If you import multiple functions, separate them with a comma.\n",
    "See an example below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from time import time, ctime\n",
    "\n",
    "t = ctime(time())\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  <span style=\"color:green\">Exercise: Importing a Module </span> \n",
    "\n",
    "We will use the library `datetime` to print out which date it is today. The library contains an object, called `date`, which  contains a function `today`. The code for *calling* the function `today` to extract and print out todays date is given below. This code will not work, as `date` is not imported. \n",
    "\n",
    "Import `date` from the module `datetime` . "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the Module on the Line Below:\n",
    "\n",
    "\n",
    "print(\"date today: \", date.today())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Commenting Code\n",
    "\n",
    "Comments can make your code easier to understand. You can use a `#` character to start a single line comment. \n",
    "To write a comment consisting of multiple lines, you use three quotes `'''` before and after the comment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is how to make a comment on a single line\n",
    "\n",
    "a = 13   # Can be used on the right side of your code\n",
    "\n",
    "'''\n",
    "This is how to \n",
    "comment over \n",
    "\n",
    "several \n",
    "\n",
    "lines\n",
    "'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  <span style=\"color:blue\">Key Points</span>\n",
    "\n",
    "- Use `variable = value` to assign a value to the variable to store it for later use\n",
    "- Use `print(something)` to show the value of `something`.\n",
    "- Python variables can be strings, integers or floats.\n",
    "- Python variables are independent from each other"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}