1 Variables_and_data_types.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Variables and data types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Statements\n",
    "\n",
    "Computer programs are generally written to solve specific problems or to automate certain activities. They consist of instructions or command which tell the computer what to do. Such instructions are referred to as statements. \n",
    "\n",
    "In the Python language, the individual statements are delineated by hard returns. The end of the statement (i.e. the hard return) is a cue which triggers the Python parser to interpret and to execute the statement. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables \n",
    "\n",
    "Virtually all programming languages make use of variables of some sort. Variables can be thought of as containers or as boxes in which information can be stored temporarily. Variables always need to be given a name. This name can be used to retrieve the 'contents' of the variable. These contents (the data assigned to the variable) are referred to as the variable's *value*. \n",
    "\n",
    "### Names\n",
    "\n",
    "Variables names can consist of any combination of alphanumerical characters that you can think of. Underscores are also allowed in variable names. Variable names cannot begin with a digit, however, and they cannot contain spaces, hyphens, quotation marks or other punctuation marks. Also note that variable names are case sensitive. \n",
    "\n",
    "Although it is possible to work with any sequence of characters, your script will evidently be most understandable when you make use of variable names which are meaningful. \n",
    "\n",
    "Note that there are a number of reserved words which have a particular function in the Python language, and which cannot be used as variable names for this reason. The list of reserved words include ‘for’, ‘in’, ‘is’, ‘print’, ‘global’, ‘def’, ‘if, ‘elif’ and ‘else’. \n",
    "\n",
    "### Values\n",
    "\n",
    "As mentioned, variables can be given a value. The act of giving a value to a certain variable is called *assignment*. In the example below, the variable named `planet_name` is assigned the value ‘Mars’. In this first example, the value of the variables consists of alphanumerical characters, surrounded by quotes. Such texts fragments are referred to as **strings**. The second variable, names `distance_to_sun` is used to capture a number. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "planet_name = 'Mars'\n",
    "distance_to_sun = 227900000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Printing output\n",
    "\n",
    "Programs often produce some output. This output can be the result of a calculation, for instance. The `print()` function can be used to communicate the output of the program to the user. A function is *a named collection of statements*. \n",
    "\n",
    "The `print()` function is always used with parentheses. Inside the parentheses, you can provide the string that you would like the computer to display. A string, as was explained above, is a sequence of alphanumerical characters and spaces. \n",
    "\n",
    "The print() function adds a line break after the string by default."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('This program works!')\n",
    "print('This sentence is on a second line.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also add some formatting to the text, to some extent. The character '\\t' prints a tab, and '\\n' creates a hard return."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('This sentence is followed by two line breaks. \\n')\n",
    "print('This line contains \\ta tab. ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you provide the name of a variable inside the `print()` fuction, this will display the *value* that is assigned to this variable, and not the *name* of this variable. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "age = 25\n",
    "print(age)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you try to print a variable that not been defined yet, Python will produce an error message. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(height)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As mentioned, the `print()` function places a line break (i.e. a hard return) after the text provided in parentheses. If you would like to replace this standard line break with another character, you can specify this character in the `end` parameter of the `print()` function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print('This is the string sentence' , end='; ')\n",
    "print('This second string is printed on the same line.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 1.1.\n",
    "\n",
    "Write code that can print the sentence “Hello world” or any other sentence that you can think of."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 1.2.\n",
    "\n",
    "\n",
    "Using a single print statement, try to produce the following output: \n",
    "\n",
    "```\n",
    "This is the first line.\n",
    "This second line contains a        tab. \n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 1.3.\n",
    "\n",
    "Create two variables named `colour1` and `colour2`, and assign the values `blue` and `yellow` to these two variables, respectively.\n",
    "\n",
    "```\n",
    "colour1 = 'blue'\n",
    "colour2 = 'yellow'\n",
    "```\n",
    "\n",
    "Next, write some code which can swap the values of these two variables. In other words, make sure that, at the end of the program, `colour1` has value 'yellow' and `colour2` has value 'blue'. Tip: you can do this by working with a third variable named `swap`, for example, which temporarily stores the value of one of these two variables. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "colour1 = 'blue'\n",
    "colour2 = 'yellow'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data types\n",
    "\n",
    "As discussed above, the values that are assigned to variables are always of a certain type. We can distinguish three general types: **strings**, **numbers** and **boolean values**. \n",
    "\n",
    "\n",
    "**Strings**\n",
    "\n",
    "A string stores a text fragment: a sequence of alphanumeric characters and spaces. Strings can be created either with single quotes, double quotes or triple quotes ('''). The single quote and the double quote are most common. They are often used interchangeably. You can find a number of examples of strings below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Hello world!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'This is a string created with single quotes'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''The triple quotes are conventionally used to create longer strings,\n",
    "i.e. strings with span multiple lines.'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The strings that you want to work with may sometimes contain single or double quotes themselves. Python would normally treat such quotes as the characters that end the end of a string. You need to take special measures to ensure that such strings containing quotes do not lead to syntax errors. If the string only contains single quotes, you can surround it with double quotes. Vice versa, a string containing double quotes can be created using a single quote.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print( \"Code is like humour. When you have to explain it, it's bad.\" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print( 'According to Oscar Wilde, \"Experience is the name everyone gives to their mistakes.\". ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If your string contains both single and double quotes, you may work with the triple quotes. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text_fragment = '''\n",
    "\"But I don’t want to go among mad people\", Alice remarked.\n",
    "\"Oh, you can’t help that,\" said the Cat: \"we're all mad here. I'm mad. You're mad.\"\n",
    "'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yet another approach is to place a forward slash in front of the quote. This forwards slash using within string is the escape character. It indicates that the character that follows immediately does not have its regular function, and that it is should be treated as a literal character."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('According to Larry Wall, \\\"The three chief virtues of a programmer are laziness, impatience and hubris\\\".\" ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 1.4\n",
    "\n",
    "'Debugging' is the process of finding and correcting mistakes in a computer program. It is a very useful skill to have as a programmer.\n",
    "\n",
    "Try to debug the code below. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print( 'It's not always easy to see the mistakes in your code.' )\n",
    "print( \"The ability to debug can be really useful.'' )\n",
    "print( Don't forget to read the error messages!\n",
    "      They're often very useful.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Numbers**\n",
    "\n",
    "*Numbers* form the second data type. In Python, there are two types of numbers. *Integers*, firstly, are whole numbers. They are natural numbers without a fractional or decimal part. Integers can also be negative numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "age = 20\n",
    "nr_pages = 273\n",
    "negative = -3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next to such integers, Python can also work with rational numbers. They are called *floats* or *floating point* numbers.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pi = 3.14159265359"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unlike strings, numbers are **never** surrounded by quotes. When you place a single number in a pair of quotes, this will automatically convert the number into a string. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "umber_of_inhabitants = \"123924\"\n",
    "print( type(number_of_inhabitants) )\n",
    "# this will print <class 'str'>. 'str' stands for 'string'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The type of the data value represented by a variable can always be found by using the `type()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "age = 20\n",
    "print( type(age) )\n",
    "## this will print <class 'int'>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pi = 3.14159265359\n",
    "print( type(pi) )\n",
    "# <class 'float'>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An integer can be converted into a floating point number using the `float()` function. This process of converting data of one type into another type is called *coercion*. When an integer is coerced into a float, this creates a number with a 0 following the decimal point."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grade = 7\n",
    "grade_float = float(grade)\n",
    "print(grade_float)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By the same token, a floating point number can also be *coerced* into an integer using the `int()` function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grade = 7.5\n",
    "grade_int = int(grade)\n",
    "type(grade_int)\n",
    "print(grade_int)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the conversion from a float into an integer may result in a loss of information. When the grade 7.5 is coerced into an integer, the value of this variable will be 7. The use of the `int()` function does not round off the number to the nearest integer, but simply removes all the digits following the decimal point. To actually round off a floating point number to the nearest integer, you can work with `round()`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grade = 7.5\n",
    "grade_rounded = round(grade)\n",
    "print(grade_rounded)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If needed, numbers can also be converted into strings using the function `str()`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "age = 25\n",
    "age_str = str(25)\n",
    "print( type(age_str) )\n",
    "# this will print <class 'str'>. 'str' stands for 'string'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comments\n",
    "\n",
    "In the Python langauge, lines can be preceded by the hash (‘#’) symbol. Lines that start with a hash are called comments. Comments are always ignored by the Python interpreter. They are included exclusively for human readers of the code.\n",
    "\n",
    "Such comments can be very useful when you want to document your code. Computer programs can sometimes be difficut to understand, and, in such situations, comments may help to explain in understandable language what happens exactly in specific parts of the code. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 1.5\n",
    "    \n",
    "As will be explained in the next notebook, you can work with variables in calculations. The code below gives an example.\n",
    "\n",
    "```\n",
    "a = 3\n",
    "b = 4\n",
    "c = a+b\n",
    "print(c)\n",
    "\n",
    "```\n",
    "\n",
    "What happens when you try to make calculations with numbers that have different types? \n",
    "\n",
    "To examine this question, convert the *type* of variable `a` to a floating point number using the `float()` function. Next, try to determine the type of variable that results from the addition. \n",
    "\n",
    "What happens when you coerce variable `a` into a string? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 3\n",
    "b = 4\n",
    "c = a+b\n",
    "print(c)"
   ]
  }
 ],
 "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.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}