exercises/Python_Principles_2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"https://colab.research.google.com/github/chris-lovejoy/CodingForMedicine/blob/main/exercises/Python_Principles_2.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Principles \n",
    "\n",
    "# Part 2 Using and Storing Data:"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this exercise, we will be going through the concept of a variable and data types in more detail. These two concepts are the fundamental programming tools for storing and manipulating data. Variables give us the ability to store information in memory to be able to use and manipulate it. \n",
    "\n",
    "We will also cover data types in much greater detail so that you feel more familiar with the common ones we will encounter in using Python throughout the course. "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Links to Exercises\n",
    "[Python Principles 1](./Python_Principles.ipynb)\n",
    "\n",
    "[Python Principles 2](./Python_Principles_2.ipynb)\n",
    "\n",
    "[Python Principles 3](./Python_Principles_3.ipynb)\n",
    " \n",
    "[Python Principles 4](./Python_Principles_4.ipynb)\n",
    " \n",
    "[Python Principles 5](./Python_Principles_5.ipynb)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Think of variables as containers to hold information. Their purpose is to label and store data in memory so the program can use it. Labelling data allows the code to have meaning and the ability to understand the program clearly.\n",
    "\n",
    "A variable is a named area of a program's memory space where data can be stored. The data we store in a variable can change. \n",
    "\n",
    "Read the code in the cell below. What do you think the output will be? Run the cell to check your understanding."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "answer = 41\n",
    "answer = 42\n",
    "print(answer)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The output is 42. On line one, we declare a variable `answer` and assign it the value of `41`. We set aside a bit of memory to store the value `41` in that area. It also creates a variable named `answer` so that we can access that data.\n",
    "\n",
    "On line two, we **reassign** the value `42` to the variable named `answer`. Python makes `answer` refer to the new value. We are not changing the value of 41, we're assigning a new value to the `answer` variable. When we say reassign we mean that we change one value with another value for a specific variable.\n",
    "\n",
    "Finally, on line three, we are outputting the value. To determine the value that gets outputted, Python retrieves the value stored in a memory location used by the variable.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Naming Variables"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Naming variables can become very difficult in large programs, which may sound odd at first glance. When naming variables the choice of the name should be exact and concisely describe the data it contains. A variable name like `x` has no meaning when you need to look back at the code because it's easy to forget what the variable contains.\n",
    "\n",
    "Python does have some restrictions on how we name variables which are listed below. We've encountered number 5 on the list already.\n",
    "\n",
    "1. A variable must start with a letter or underscore character\n",
    "2. A variable can't start with a number\n",
    "3. A variable name can only contain the following characters A-Z,a-z,0-9 and _\n",
    "4. Variable names are case sensitive\n",
    "5. Variables can not be keywords\n",
    "\n",
    "In the cell below are some examples of valid variable names, albeit not very descriptive. This is because we haven't assigned any values to these variable names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nameVar\n",
    "NameVar\n",
    "_nameVar\n",
    "name_var\n",
    "nameVar2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run the code snippet below to see an example of an invalid variable name. Python will throw a syntax error when we run this cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "$name"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are some variable naming conventions in Programming worth mentioning and when to use them. Camel Case is when you start a name with a lowercase letter and if the name has multiple words start with an uppercase letter. The first variable name in the cell above `nameVar` is an example of camel case. Snake case is when you start a name with a lowercase letter and if the name has multiple words in it, each word is separated by an `_` and later words start with lowercase. For example `name_var` is in the snake case.\n",
    "\n",
    "We might ask why bother knowing this? By convention in Python, we name our variables and function names in snake case as opposed to camel case. The reason is that it improves readability when we use underscores and when code bases get large anything that aids readability is well worth sticking to. Only when you are part of a team where camel case has been used previously in the code base would you use camel case.\n",
    "\n",
    "Note that in other languages this convention varies, for example, JavaScript uses camel case for naming variables and functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When creating a variable, always ask the following \n",
    "\n",
    "1. is it descriptive? \n",
    "2. Is it accurate? \n",
    "3. Is it understandable?\n",
    "\n",
    "In the cell below type out some valid variable names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Declaring and Assigning Variabes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A variable declaration is a statement that asks Python to reserve space in computer memory for that variable with a name. We have seen an example of a variable declaration above.\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "firstName = 'Chris'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `=` is an **assignment operator** which tells Python to give a variable name a value.\n",
    "\n",
    "Consider the following snippet. What is the output? Try to answer before running the cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 4\n",
    "b = a \n",
    "print(b)\n",
    "a = 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You see that b retains the value `4` even though `a` is now 7. The link between `a` and `b` is not that strong. If you change a variable's value, it does not change the value of another with the same value.\n",
    "\n",
    "It is also possible to assign multiple values to multiple variables at once. Look at the code snippet below. What do you think the values of `x`,`y`, and `z` are? Try to answer before running the snippet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x,y,z = 3,4,5\n",
    "print(x,y,z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we are concisely assigning the values 3 to `x`, `4` to `y` and 5 to `z`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variable Scope"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In programming, scope refers to the access of a variable name. Some variables are available everywhere in the code, whereas writing code in an if statement or inside a function may mean that a variable created is only accessible inside that code block.\n",
    "\n",
    "We call a variable available everywhere in the code as having **global scope**. Variables that are only available in certain blocks have **local scope**. If a variable is **in scope** we can access the variable. If you can't access the variable, it means the variable is **out of scope**\n",
    "\n",
    "Scope is an important concept because variables that have global scope can be modified anywhere in the code. Global scope makes it difficult in a large script to maintain the code if you make changes and to catch errors (called debugging). We have to keep all the code in mind when every variable is in the global scope.\n",
    "\n",
    "You can avoid this type of problem by having the ability to restrict the scope. Scope is defined where you have declared the variable.\n",
    "\n",
    "When Python looks at your code as a whole, it applies a set of rules to your variables to determine whether the variable has a global or local scope. We won't go into the exact details of this procedure here, Python does this in the background. However when reading code understanding the difference and avoiding variables in the global scope is part of good programming practices. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5 # Global scope\n",
    "def printNumber():\n",
    "    print(x)\n",
    "    y = x + 2 # Local scope\n",
    "    print(y)\n",
    "\n",
    "printNumber()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the code snippet above, the first line `x = 5` means that variable is in global scope. On line two to five we define a function `printNumber()` don't worry about what it means at the moment think of it as a way to make local scope when we define variables inside this function. \n",
    "\n",
    "We print `x` which outputs `5`. On line four we declare the variable `y` with `x + 2`, here `y` has local scope as its inside the function, `y` evaluates to `7` because we can access the variable `x` within the funciton as it has global scope. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that if we try to display `y` we get a NameError. The variable `y` is not defined outside of the function. What we mean to say is `y` has local scope within the function and is not available elsewhere."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We covered a brief introduction to the concept of a data type in the previous exercise. Data types have type information attached to them, that is they have rules to how they can be manipulated and used. This is why we have data types, we want to provide some constraints the values within Python can and can't do.\n",
    "\n",
    "In this section we will also cover some additional concepts relating to data types too that are worth knowing as well as a deep dive into the data types most used in Python. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Determining the type of data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To understand the different types in Python, we've already come across the built-in method called `type()`. Don't worry too much about the word method yet. Putting a value inside the parentheses of `type()` will tell Python to evaluate and return type information on that value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(\"Hello World\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The output returns `<class 'str'>`. Think of the word class as a synonym for \"data type\" for now. A class refers to something more specific which we wont cover in these exercises."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Type Casting \n",
    "\n",
    "Python allows you to convert data from one to another, we call this **Type Casting**. You may have data that you need to be able to convert from one data type to another within your code. Python provides some built-in functions to do this, the common ones are `int()`, `str()` and `float()`. We will explore these in detail in some sections below."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Type Coercion \n",
    "\n",
    "Consider the following example, what will happen when you run the cell?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = 'Aaron'\n",
    "name + 2"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python raises an error because the string `name` doesn't know how to add to a number.\n",
    "\n",
    "Consider the following example of adding an integer to a float point number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 2\n",
    "y = 5.5\n",
    "x + y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python was able to add these two numbers together. It would be fair to assume that Python automatically converts one into the other. However, Python does something a little more subtle, it asks the integer and float point to add themselves with built-in methods. To explain this another way, some data types in Python knows how to operate with other data types when using specific operators like the addition operator `+`. \n",
    "\n",
    "The concept of automatically converting one type into another is named **type coercion** and is not supported by Python. However, you may come across this concept in other languages like JavaScript."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mutability"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before discussing data types in detail, it's important to understand which data types can change and which can't. When you use a data type, will Python be able to modify the data after creation? This is what mutability means.\n",
    "\n",
    "All data types we are about to discuss are objects. Think of an object as a container that holds information about its type, value and identity. \n",
    "\n",
    "We've covered the idea of a value and type elsewhere. Every object's value lives in a specific part of the computer's memory. We call the memory address (think of street address) its identity, which is unique to the object you create.\n",
    "\n",
    "We can use the built-in `id()` method to obtain an objects identity. \n",
    "\n",
    "Lets consider the number `42` and `24`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "id(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "id(24)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see there's a unique identity for the number `42` and `24`.\n",
    "\n",
    "An **immutable** object is an object that doesn't allow a change in its value. A **mutable** object can change its value without changing its identity.\n",
    "\n",
    "For example, an integer, no matter what you do in Python you can't change that integer value. It's possible to use operators and methods to return something new, but it's not possible to change the number itself this is stored in a piece of memory.\n",
    "\n",
    "We will see data types that can and can't be modified once created. When deciding on data types to store information, this fact is crucial to know in advance and to think about when writing programs.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Integers and floating points"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One of the most basic data type in data science are numbers. Python has three number-related data types, called integers, floating-point numbers and complex numbers. We will discuss integers and floating points only in this exercise.\n",
    "\n",
    "An **integer** is a number with no decimal places. For example, `9` is an integer, but `9.0` is not. \n",
    "\n",
    "Run the cell below to see the output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A **floating-point number** is a number with a decimal place. `9.0` is a floating point number. \n",
    "\n",
    "Run the cell below to see the output.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(9.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes the numbers we deal with are very large. You can use **E-notation** to express very large numbers more clearly.\n",
    "\n",
    "To write in e-notation, type a number followed by the letter e, then another number. For example `1e4`.\n",
    "\n",
    "To convert E-notation back to numbers we multiply the number on the left by 10 raised to the power of the number after the e. So `1e4` is the same as writing `1 x 10^4` which equals `10000.0`.\n",
    "\n",
    "You can also use e notation directly in Python.\n",
    "\n",
    "Run the following cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1e4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The other difference between integers and floating points is that floating points have a maximum size. It depends on your system, however, `2e400` is well beyond most machines' capabilities.\n",
    "\n",
    "In the cell below, enter `2e400` and see what output you get."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2e400"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What gets returned is a value `inf`, which stands for infinity. This means you've created a number beyond the maximum float point value. It's unlikely you'll come across this much but useful to know there is a limit."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Converting between integers and floats"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has a set of built-in functions that make it easy to convert from one data type to another. We will talk about `int()` and `float()` here\n",
    "\n",
    "We can pass a value between the parentheses and Python will convert it from integer to float and vice versa.\n",
    "\n",
    "Let's see an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number_of_students = 15\n",
    "float(number_of_students)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the code snippet above, we've declared a variable `number_of_students` and assigned the integer `15` to that variable. In line two we have passed the variable as an argument into the float method. The output is `15.0`\n",
    "\n",
    "Lets see an example of converting from float to int.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number_of_sessions = 8.5\n",
    "int(number_of_sessions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we pass a value `8.5` into the `int` method. The return value is `8`. Note that Python has rounded down to `8` and not up to `9` here.\n",
    "\n",
    "There are different operations you can modify numbers in Python, we will cover this in detail later, but for now, it's enough to be aware of the different number-related data types.\n",
    "\n",
    "In the next section, we'll be covering strings."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A string is a list of characters in a specific sequence. In programming, we need to work with text data like names, messages, or descriptions. Python uses strings to represent such data. \n",
    "\n",
    "To create a string, use either single or double quotes on either side of the text, Python does not distinguish."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Hello World\"\n",
    "'Hello World'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The quotes around a string are called **delimiters**, they tell Python when a string begins and ends.\n",
    "\n",
    "Run the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"I said 'Python is cool'\" "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how you can still use single quotes inside a string. When Python sees a delimiter it interprets the characters after as a string\n",
    "\n",
    "Run the below cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"I said \"Python is not cool\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python throws an error called a `SyntaxError` because it thinks the string ends at the second \" and doesn't know what to do with the rest.\n",
    "\n",
    "It's a good idea to be consistent whether you use single or double quotes to create strings."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Determine the length of a string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The number of characters of a string with spaces included is called the **length** of a string. \n",
    "\n",
    "For example, the string `\"Python\"` has a length of `6`. \n",
    "\n",
    "To determine the length of a string we use a built-in function `len()`. Anything passed inside `len()` Python will return the number of characters.\n",
    "\n",
    "Run the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(\"Python\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now try to find the length of the string `\"Data Science\"` in the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Its possible to also determine the length of a string that has been assigned to a variable name "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "course = \"Data Science\"\n",
    "len(course)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we assign the variable `course` to the string `Data Science` and pass that string as an argument to the len function. The number `12` is returned as that is the length of the string `Data Science`.\n",
    "\n",
    "Now create a variable `new_course` and give it the value `\"Machine learning\"` and determine the length of that string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Converting between strings and numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We explored in the last section methods to convert integers to floats and vice versa. Python also has a built-in method called `str()` that converts many data types to a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "str(3.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "str(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now convert the number `1000` into a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Concatenation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Concatenation** is a term used describe joining two strings together using the `+` operator\n",
    "\n",
    "Read the code in the cell below,what is the output before running the code? \n",
    "\n",
    "Now run the code snippet below to see the output. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string1 = \"Data\"\n",
    "string2 = \"Science\"\n",
    "course = string1 + string2\n",
    "course"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You might have seen no space between the two words in the return value. Spaces are also characters in Python.\n",
    "\n",
    "Run the cell below to see the output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "first_name = \"Joe\"\n",
    "last_name = \"Bloggs\"\n",
    "full_name = first_name + \" \" + last_name\n",
    "full_name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, we are concatenating three strings together. \n",
    "\n",
    "In the cell below, create a variable that evaluates to a string of your name. Don't just create one single string in a variable, make you variable have several variables similar to above. \n",
    "\n",
    "Notice that its quite easy to change the first and last name now. Try changing the first name and last name and running the cell again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In a string literal, each character has a numbered position we call an **index**. We can access the position of a string by putting a number between two square brackets immediately after the string\n",
    "\n",
    "Look at the code snippet below. Can you guess what the output will be?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "course = \"Data Science\"\n",
    "course[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It might make sense for the index `1` to be the first letter in the string, but counting always starts from zero in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the next cell, try to access the first letter of the string \"Data Science\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What happens if we try to access an index beyond the end of a string? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "courses = \"Data Science\"\n",
    "courses[14]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python will throw an error called `IndexError`. The largest index a string can have is one less than the length of the string (this is because Python starts at 0 for indexes). So if the string is `\"Data\"` the last index will be 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string1 = \"Data\"\n",
    "print(\"The length of the string is\", len(string1))\n",
    "string1[3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Strings also can have negative indexes\n",
    "\n",
    "Try to run the cell below and guess what the output will be."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "courses = \"Data Science\"\n",
    "courses[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In programming, sometimes you want to access the last character of a string, it's quicker to use `-1` instead of having to think about how many characters the word has.\n",
    "\n",
    "Can you figure out another way to find the final index number of a string?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes when dealing with strings, you want to be able to capture only a few characters. We could use indexes for each character to do this, but Python provides another way called **slicing** with much less typing. \n",
    "\n",
    "A portion of a string we slice is called a **substring**. To obtain a substring, we insert a colon between two index numbers inside the square bracket instead of just one number.\n",
    "\n",
    "Before running the cell below, try to use your knowledge to figure out what it might output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "courses = \"Data Science\"\n",
    "courses[0:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the code snippet above, we want to access the characters from index `0` up to but not including index `4`. In this case, it returns the substring `Data`.\n",
    "\n",
    "Another way to slice from the beginning of a string is to omit the first index. Run the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "courses = \"Data Science\"\n",
    "courses[:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's also possible to omit the second index in the slice too. Run the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "courses = \"Data Science\"\n",
    "courses[5:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What would happen if you omit both indexes in the slice? Run the code snippet below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "courses = \"Data Science\"\n",
    "courses[:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see here the whole string was returned. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you try to access an index beyond the string length in a slice Python will not raise an `IndexError` but instead return an empty string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "courses = \"Data Science\"\n",
    "courses[13:15]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Similarly if you go beyond the string length in a slice it will return up to the number of characters in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "courses = \"Data Science\"\n",
    "courses[4:15]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's also possible to use negative indexes when it comes to string slices they work the same way as positive ones."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the cell below you will find a string has been declared. Slice the string such that you only return the first word. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "course = \"Clinical Skills\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now try slicing the second word too."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Strings are immutable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We discussed the concept of mutability in a previous section but we should explicitly point out that strings are immutable. Once you create a string you can't change it. \n",
    "\n",
    "Try creating a string and assigning it to a variable. Then try to change a letter in a string by accessing a character in the string and assigning it to another string value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We should see an error called a `TypeError` which means that strings do not support modification.\n",
    "\n",
    "To change a string you must create a new one. For example say we want to change the string `Science` to `Data Sciences`  we can use slicing and concatenation to do that."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word = 'Science'\n",
    "word = 'Data' + ' ' + word[:] + 's'\n",
    "word"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another way we can manipulate strings is by using string methods that Python has built-in into the language. A method is a special function that we can use on data types. Don't worry about the term function or method, we'll cover this in detail later."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### String interpolation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes you have some placeholder text in your string that you want be able to change the string depending on other data. We can insert variables into a specific location in a string so we can vary what the eventual string looks like. This is called **string interpolation** or f-strings."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are a couple of ways you can provide this type of functionality but we will discuss using f-strings as its a much clearer way to provide this dynamic way of creating strings.\n",
    "\n",
    "Run the cell below to see the output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Joe Bloggs\"\n",
    "course = \"Data Science\"\n",
    "time = 1\n",
    "f\"{name} has been learning {course} for {time} week\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Notice how we start the string with an f and the variable we want to embed starts with curly braces. The variable `time` is assigned the integer `1`. We did not have to convert the number to a string.\n",
    "\n",
    "It's also possible to provide expressions in between the curly braces. Run the cell below to see what the output would be."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Joe Bloggs\"\n",
    "course = \"Data Science\"\n",
    "time = 1\n",
    "f\"{name} is learning {course} for {time + 2} weeks\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see the expression `time + 2` is automatically evaluated."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the cell below create a string but with some placeholders names (refer to code snippet above for reference). For each placeholder you think of create a variable and then assign it a value. Explore changing each of these variables to see the output of the string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Booleans"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Booleans are a way to represent `True` and `False` values. In programming, you often need to know if something is true or false. True and false values provide logic that allows different code to be run (we call this conditional logic). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Determine the type of `True` in the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below, create a variable and assign the value True to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will cover much more about booleans when we cover operators. For now knowing there are values `True` and `False` in Python is enough."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A list is a collection of zero or more values that have a specific order. A list is defined by having values between square brackets `[]`. Each value inside a list is called a **list item** or **list element** which are seperated by commas.\n",
    "\n",
    "Lists allow any data types to be stored. If you need a specific order to access data a list is also the right choice.\n",
    "\n",
    "See the code snippet below to see how a list is created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "colors = ['red','yellow','green','blue']\n",
    "type(colors)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we have a list of colors and we assign this list to the variable `colors`. Notice how each list item is seperated by a comma. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List items can be of any data type in Python and like strings, indexing and slicing work with lists the same way. We can access any list item using index notation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [1,2,\"one\",4, True]\n",
    "numbers[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the cell below try to access the last element in the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [1,2,3,4,5,6,7,8]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slicing also works the same as for strings. \n",
    "\n",
    "In the cell below, access the first 3 list elements of `numbers`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [1,2,3,4,5,6,7,8]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A list is a mutable data type that is to say we can change the list items by assigning new values using index notation. Run the snippet below to see an example of this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "colors = ['red','yellow','green','blue']\n",
    "colors[0] = 'brown'\n",
    "colors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the cell below, change the list element `green` to `purple`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "colors = ['red','yellow','green','blue']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also assign several values with a **slice assignment**. Run the snippet below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "colors = ['red','yellow','green','blue']\n",
    "colors[1:3] = ['orange','magenta']\n",
    "print(colors)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By accessing the index `1` and `2` in this list using the slice operator, we can assign it a list of list items we wish to add to `colors`. In this case we change `yellow` for `orange` and `green` for `magenta`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the cell below, change the last two list elements to `black` and `white`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "colors = ['red','yellow','green','blue']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we've covered the basics of lists we will explore the dictionaries data type."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionaries store a collection of relationships between names and values. Unlike lists, these do not have order. They hold information in pairs of data called **key** and **values**. \n",
    "\n",
    "A **key** is a unique name that identifies the value part of the pair. Compare this to a dictionary, the key is the word you look up and the value is the definition of a word.\n",
    "\n",
    "Each key in this section has been a string, but in Python, there is no rule that says you can't have multiple data types as keys. \n",
    "\n",
    "The only restriction to the data type of a key is that it has to be immutable. Consider if the key was mutable what would be the impact? If we could change the keys the relationship between the key and value pair would be lost within the code. In constrast, a dictionary value can be any valid Python data type.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "capitals = {\n",
    "\t\"Scotland\": \"Edinburgh\",\n",
    "\t\"England\": \"London\",\n",
    "\t\"France\": \"Paris\"\n",
    "}\n",
    "capitals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the cell below, create a dictionary of 3 systems of the body with values that corresponds to specific diseases in that system. For example a key value pair could be `\"cardiac\": \"Myocardial Infarction\"` Assign the dictionary to the name `diseases`. Display the contents of the variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Accessing a dictionary value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To access a dictionary value, we enclose the key inside square brackets at the end of the variable name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "capitals = {\n",
    "\t\"Scotland\": \"Edinburgh\",\n",
    "\t\"England\": \"London\",\n",
    "\t\"France\": \"Paris\"\n",
    "}\n",
    "\n",
    "capitals[\"Scotland\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Accessing items in a list are by indexes, an integer that expresses the order of the items. Dictionary items are accessed by a key which has no defined order and is a label that references the value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the code snippet below, access the capital of france."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "capitals = {\n",
    "\t\"Scotland\": \"Edinburgh\",\n",
    "\t\"England\": \"London\",\n",
    "\t\"France\": \"Paris\"\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Adding and removing dictionary values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionaries like lists are mutable data types, you can add and remove from a dictionary easily.\n",
    "\n",
    "Use the square bracket notation to add the key and use the assignment operator to assign the value you wish for that key to have."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "capitals = {\n",
    "\t\"Scotland\": \"Edinburgh\",\n",
    "\t\"England\": \"London\",\n",
    "\t\"France\": \"Paris\"\n",
    "}\n",
    "\n",
    "capitals['Spain'] = \"Madrid\"\n",
    "print(capitals)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each key can only be assigned one value, if the key has a new value, it will overwrite the old one.\n",
    "\n",
    "In the code snippet below, add the capital of Italy to the dictionary and display the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "capitals = {\n",
    "\t\"Scotland\": \"Edinburgh\",\n",
    "\t\"England\": \"London\",\n",
    "\t\"France\": \"Paris\"\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To remove an item, we use the `del` keyword with the key. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "capitals = {\n",
    "\t\"Scotland\": \"Edinburgh\",\n",
    "\t\"England\": \"London\",\n",
    "\t\"France\": \"Paris\"\n",
    "}\n",
    "del capitals['Scotland']\n",
    "capitals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the code snippet below, delete the key-value pair `\"Scotland\":\"Edinburgh\"`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "capitals = {\n",
    "\t\"Scotland\": \"Edinburgh\",\n",
    "\t\"England\": \"London\",\n",
    "\t\"France\": \"Paris\"\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A tuple is a fixed-ordered size sequence of values. To create a tuple, we use parentheses to start and end the tuple with numbers separated by a comma. For example, `(1,2,3)` is a tuple containing integers.\n",
    "\n",
    "Tuples are immutable data types, once a tuple is created you can't modify them."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Creating a tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number_tuple = (1,2,3)\n",
    "type(number_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples unlike strings can contain any type of value, `(1,2.0, 'three')` is valid syntax."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the cell below, create a tuple of even numbers and assign it a variable name. Display the output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "A tuple that doesn't contain values is called an **empty tuple**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "empty_tuple = ()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Indexing and Slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples can be indexed and sliced like strings and lists.\n",
    "\n",
    "In the cell below, access the 2nd to last element of the tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number_tuple = (1,2,3,4,5,6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the cell below, slice the tuple of the 2nd to 5th items in the tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A set is an unordered mutable collection of unique values. By unique we mean that there are no duplicate elements within a set. It is highly optimised for checking whether a specific element is in a set. \n",
    "\n",
    "Sets can be created similarly to lists however, instead of square brackets we use curly brackets. For example, `{1,2,3}`. Any duplicate elements will be removed when creating a set in this way.\n",
    "\n",
    "Another way we can create a set is by using the `set()` built-in method. Using the set built-in method, any data type that Python can loop over (we call this iterable) we can pass into this method. For this course, lists, tuples and strings can be converted to a set."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Creating a Set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run the code snippets below. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "courseSet = { 'Data','Science','Course' }\n",
    "print(courseSet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "courseSet = { 'Data','Science','Course' }\n",
    "print(courseSet)\n",
    "type(courseSet)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how the order of the elements are not the same as the ones that were typed out.\n",
    "\n",
    "In the cell below, create a set of odd numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also create a set using the `set()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "courseSet = set(['Data','Science','Course'])\n",
    "print(courseSet)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run the code snippet below, what is different about the output ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set('foo')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how string characters have become elements. This is because the characters of a string can be looped over in Python (we will come to this a bit later). However, the 'o' is a duplicated element so only one 'o' is part of the set. That is to say that all values inside a set are unique even if we try to add a duplicate.. \n",
    "\n",
    "Sets can contain only immutable data types in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s1 = {42, 'foo',3.14159, True}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run the cell below to see the difference between the code snippet above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1,2,3]\n",
    "{a}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python will throw an error as a list is a mutable data type."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Length of a set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The built-in `len()` function returns the number of elements in a set. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coursesSet = {'Data Science','Machine Learning'}\n",
    "len(coursesSet)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the code snippet below, find out the length of the set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coursesSet = {'Data Science','Machine Learning', 'Neural Networks','Deep Learning'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " For now it's enough to be aware of what a set is and how to create one."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Choosing a data type\n",
    "\n",
    "We have covered all of the common data types in this exercise. We now know that data types like lists, sets, tuples and dictionaries are suited for storing data. \n",
    "\n",
    "The first question that comes to mind is when do we use one over the other? To answer this question understanding the differences between them we can reason about using one data type over another. The characteristics to know for each datatype is which ones are ordered or not, whether they allow duplicates, whether they allow changes to be made to them (additions and deletions etc) and which data types allow us to change the items already stored.\n",
    "\n",
    "|          |  Ordered   |  Duplicates | Mutable  | Change of element in datatype | \n",
    "| -------- | ---------- | ------------- | ---------- | -------------------- |\n",
    "|Tuple     | Yes   by index   |  Yes           |   No        |  No\n",
    "|List      |      Yes by index       |  Yes            |  Yes        | Yes               | \n",
    "|Set       |     No        |        No    |   Yes       |    No                 | \n",
    "|Dictionary|  Yes by key          |     No         |      Yes   |   Yes"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To summarise this \n",
    "\n",
    "1. Lists are ordered data types that we can change. So use a list when the order matters and there are multiple data types to store.\n",
    "2. Dictionaries are ordered only by keys, they don't allow duplicates but we can change them. Use dictionaries when you want to store relationships between data. That is when it's much better to store data by a relationship to a name, than just storing a list of data.\n",
    "3. Sets - Use sets when you don't care about the order of items, but we care about not having duplicates.\n",
    "4. Tuples are ordered, do allow duplicates but we can't change the number of items within a tuple. So use this structure when you have data that won't change at all, the order matters. Lastly use tuples when you need to access it quickly. This is because accessing data from a tuple is much quicker than a list when there's lots of data."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another factor in choosing data types is speed, particularly when we handle large amounts of data. Certain operations in different data types will have differing performances. For example, adding to a list is much faster than deleting a list item. We call this concept **time complexity**. At the start of your coding journey, it's enough to know that different operations on datatypes that act as collections can have performance differences. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Check your understanding\n",
    "\n",
    "1. What is a variable ?\n",
    "2. Can you give examples of valid and invalid variable names?\n",
    "3. Give an example of assigning a value to a variable.\n",
    "4. What is variable scope ?\n",
    "5. How do you determine the type of a value ?\n",
    "6. What is Type Coercion ?\n",
    "7. What is mutability ?\n",
    "8. Can you give an example of returning a length of a string ?\n",
    "9. Can you give an example of string slicing ?\n",
    "10. What is string interpolation ?\n",
    "11. What is a list ?\n",
    "12. What is a dictionary ?\n",
    "13. What is a tuple ?\n",
    "14. What is a set ?\n",
    "15. Can you give examples of a dictionary, tuple and a list ?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summary\n",
    "\n",
    "In this section, we have covered a breadth of the data types you will see in Python and the essentials of variables. Python has a few data types to know about, we have covered the basics of strings, lists, dictionaries, tuples and sets in this exercise. We have also covered some basic ways to manipulate strings which we will expand upon in a future exercise. \n",
    "\n",
    "Understanding what data we can store in Python and how to store this is fundamental to learning how to code. There are many things you can do with these data types and we will cover this in detail in the next exercise."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Feedback \n",
    "\n",
    "Fill out the form below and we'll provide feedback on your code.\n",
    "\n",
    "**Any feedback on the exercise? Any questions? Want feedback on your code? Please fill out the form [here](https://docs.google.com/forms/d/e/1FAIpQLSdoOjVom8YKf11LxJ_bWN40afFMsWcoJ-xOrKhMbfBzgxTS9A/viewform).**"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "sktime-dev",
   "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.10"
  },
  "vscode": {
   "interpreter": {
    "hash": "6f8d4ee3c8c1e36044fd5c050f9f4b95dc7799fce87a2fff77e5fa8e34145050"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}