Python_codes/introduction_to_python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# INTRODUCTION TO PYTHON \n",
    "\n",
    "\n",
    "<div style=\"display: flex; justify-content: center; \">\n",
    "     <img src=\"./images/wimlds.png\" style=\"max-width: 40%; height: auto\"/>\n",
    "       <img src=\"./images/aims.jpeg\" style=\"max-width: 40%; height: auto\"/>\n",
    "\n",
    "</div>\n",
    "\n",
    "\n",
    "© WiMLDS Accra 2024. Apache License 2.0.\n",
    "\n",
    "**Authors:** Emmanuel\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Table of Content\n",
    "- [What is Python](#what-is-python)\n",
    "- [Python Basics](#python-basics)\n",
    "    - [Operators](#operators)\n",
    "    - [Variables](#variables)\n",
    "    - [Datatypes](#datatypes)\n",
    "        - [Primitive Datatypes](#primitive-data-types)\n",
    "        - [Collections](#containers)\n",
    "- [Functions Commonly Used on Collections](#functions-commonly-used-on-iterables-containers-or-sequences)\n",
    "- [Branching (Control Flow)](#conditional-statements-branching)\n",
    "- [Loops](#loops-repetitions)\n",
    "- [Functions](#functions)\n",
    "- [Modules](#modules)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### WHAT IS PYTHON?\n",
    "- Python is a general purpose, high level interpreted object-oriented programming language developed by Guido Van Rossum in 1991.  \n",
    "- An interpreted language does not convert code an executable file or machine language instead, th source code is executed line by line by an interpreter during runtime.\n",
    "- It is dynamically typed (we do not have to explicitly declare variables and their data types before using them).\n",
    "- It is easy to read as the syntax are much closer to human language than low level languages.\n",
    "\n",
    "It has several uses including;\n",
    "- Software development\n",
    "- Web development \n",
    "- Data Analytics/Data Science\n",
    "- Graphical User Interface Applications\n",
    "- Scientific Computing.\n",
    "\n",
    "Advantages of Python over other languages\n",
    "- Works on different operating systems (Windows, MAC, Linux, etc).\n",
    "- It enhances readability due to its simple syntax which is similar (close) to the english language.\n",
    "- Programming in Python (the pythonic way) allows programmers to write fewer lines of codes compared to other languages.\n",
    "- It supports object oriented programming\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### PYTHON BASICS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### COMMENTS\n",
    "\n",
    "- These are statements that are not executed by the interpreted.\n",
    "- They are most used to give notes and remarks to the programmer himself or other programmers\n",
    "- In Python, any statement preceeded by one or more \\# is regarded as a comment.\n",
    "\n",
    "Syntax;\n",
    "```python\n",
    "    # This is a comment and won't be executed by the interpreter.\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### VALUES\n",
    "A value is the most basic thing a program deals with. It includes letters, numbers, etc.  \n",
    "Example; 1,2, \"H\", \"Hello World\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### EXPRESSIONS\n",
    "Expressions are the most basic instructions in a programming language. They consist of values and operators and they can be evaluated to produce a result.\n",
    "Example; 2+3 is an expression in a programming language."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### OPERATORS\n",
    "The main kinds of operators in Python are;\n",
    "1. Arithmetic Operators.\n",
    "1. Relational Operators.\n",
    "1. Logical Operators.\n",
    "1. Assignment Operator.\n",
    "1. Compound Assignent Operators."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### ARITHMETIC OPERATORS\n",
    "\n",
    "| Operator | Symbol in Python | Example |\n",
    "|---|---|---|\n",
    "| Addition | + | 2 + 3 = 5 |\n",
    "| Subtraction | - | 3 - 2 = 1|\n",
    "| Multiplication | * | 2 * 3 = 6|\n",
    "| Division | / | 4 / 2 = 2.0 |\n",
    "| Exponents (Powers) | ** | 2 ** 2 = 4 |\n",
    "| Integer Division | // | 4 // 2 = 2 | \n",
    "| Modulus (Remainder) | % | 4 % 3 = 1 |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Addition\n",
    "3 + 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Subtraction\n",
    "3 - 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Multiplication\n",
    "3 * 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Division\n",
    "3 / 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Exponents\n",
    "3 ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Integer Division\n",
    "3 // 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Modulus\n",
    "4 % 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### __NOTE:__ \n",
    "- When you use the division operator ( / ), irrespective of the datatypes, your output will be a floating point value (to be discussed later).\n",
    "- When you use the integer division operator ( // ), the results will be rounded to the nearest integer and the datatype if the output will be an int (aloso to be discussed later)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### OPERATOR PRECEDENCE.\n",
    "Consider, 10 * 5 + 9.\n",
    "- If we perform the multiplication first, the output will be 59\n",
    "- If we perform the addition first, the output will be 145\n",
    "In order to solve this issue and ensure a common result, we use the following order of precedence\n",
    "\n",
    "- Parenthesis\n",
    "- Exponents ( ** )\n",
    "- Multiplication ( * ), Division ( / ), Integer Division ( // ), Modulus ( % )\n",
    "- Addition ( + ), Subtraction ( - )\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### RELATIONAL OPERATORS\n",
    "\n",
    "| Operator | Symbol in Python | Example |\n",
    "| --- | --- | --- |\n",
    "| Greater than | > | 3 > 4 = False |\n",
    "| Less than | < | 3 < 4 = True |\n",
    "| Greater than or equal to | >= | 10 >= 11 = False |\n",
    "| Less than or equal to | <= | 10 <= 11 = True |\n",
    "| Not equal to | != | 10 != 11 = True |\n",
    "| Equal to | == | 10 == 11 = False |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 > 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 < 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 >= 11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 <= 11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 != 11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 == 11"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### LOGICAL OPERATORS\n",
    "\n",
    "###### TRUTHY TABLE FOR ***AND***\n",
    "| OPERAND (VALUE) 1 | OPERAND (VALUE) 2 | OUTPUT |\n",
    "| --- | --- | --- |\n",
    "| True | True | True |\n",
    "| True | False | False |\n",
    "| False | True | False |\n",
    "| False | False | False |\n",
    "\n",
    "###### TRUTHY TABLE FOR ***OR***\n",
    "| OPERAND (VALUE) 1 | OPERAND (VALUE) 2 | OUTPUT |\n",
    "| --- | --- | --- |\n",
    "| True | True | True |\n",
    "| True | False | True |\n",
    "| False | True | True |\n",
    "| False | False | False |\n",
    "\n",
    "###### TRUTHY TABLE FOR ***NOT***\n",
    "| OPERAND (VALUE) 1 | OUTPUT |\n",
    "| --- | --- |\n",
    "| True | False |\n",
    "| False |  True |\n",
    "\n",
    "\n",
    "###### Logical operators and examples\n",
    "| Operator | Symbol in python | Example |\n",
    "| --- | --- | --- |\n",
    "| Logical AND | and | (3 > 2) and (5 < 8) = True |\n",
    "| Logical OR | or | (4 < 3) or (3 > 2) = True |\n",
    "| Logical NOT | not | not True |\n",
    "\n",
    "\n",
    "##### __NOTE:__ \n",
    "- ***AND*** and ***OR*** are binary operators ( They operate on two operands (values))\n",
    "- ***NOT*** is an unary operator ( It operates on a single operand)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### ASSIGNMENT OPERATOR\n",
    "\n",
    "An assignment operator is an operator that assigns (designate) a value to a variable (To be discussed later).  \n",
    "In Python, assignment is done using a single equal to sign ( = ).  \n",
    "For example; x = 4, assigns the value 4 to the variable x. Hence we can reference this value by calling the name of the variable.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### COMPOUND OPERATOR ASSIGNMENT\n",
    "\n",
    "| Operator | Example | Equivalent Statement in Python | \n",
    "| --- | --- | --- |\n",
    "| += | x += 1 | x = x + 1 |\n",
    "| -= | x -= 1 | x = x - 1 |\n",
    "| *= | x *= 2 | x = x * 2 |\n",
    "| /= | x /= 2 | x = x / 2 |\n",
    "| //= | x //= 2 | x = x // 2 |\n",
    "| %= | x %= 2 | x = x % 2 |\n",
    "| **= | x **= 2 | x = x ** 2 |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### VARIABLES\n",
    "A variable is a named reference to a memory location in the computer. It stores values at that specific location in memory and the value can be referenced later using the variable name. Simply put, it is a container that saves a value. \n",
    "\n",
    "##### RULES FOR VARIABLE NAMING\n",
    "There are certain conventions that must be followed when naming your variables, these are\n",
    "1. Variable names cannot start with a number start with.\n",
    "1. The only punctuation that is allowed in a variable name in Python is the underscore ( _ ).\n",
    "1. A variable name can only contain alphanumeric characters ([A-Z], [a-z], [0-9]).\n",
    "1. Variables names cannot be any of the built in names in Python.\n",
    "1. Variable names are case sensitive. \n",
    "\n",
    "##### __NOTE:__ \n",
    "- Variable names must be descriptive. A different programmer should be able to understand the purpose of your variable without any comments.\n",
    "\n",
    "\n",
    "Examples of legal variable names;\n",
    "- myvar = \"John\"\n",
    "- my_var = \"John\"\n",
    "- _my_var = \"John\"\n",
    "- myVar = \"John\"\n",
    "- MYVAR = \"John\"\n",
    "- myvar2 = \"John\"\n",
    "\n",
    "\n",
    "Examples of illegal variable names;\n",
    "- 2myvar = \"John\"\n",
    "- my-var = \"John\"\n",
    "- my var = \"John\"\n",
    "\n",
    "\n",
    "Since a variable stores a value, we now discuss the various datatypes of values a variable can store."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### DATATYPES\n",
    "A data type is an attribute of a data (value) that instructs the interpreter on how the data will be used and the operations that can be performed using that data.\n",
    "\n",
    "There are two main kinds of datatypes in Python. There are;\n",
    "- primitive data types\n",
    "- Containers (sequences)\n",
    "\n",
    "##### PRIMITIVE DATA TYPES\n",
    "- Numbers:\n",
    "    - int (integers)\n",
    "    - float (real numbers or numbers with decimal parts)\n",
    "    - Complex numbers\n",
    "- Boolean\n",
    "- String - Technically speaking, a string is a sequence but since we it's often used (almost every program has a string datatype in it), we might as well consider it as a primitive datatype.\n",
    "\n",
    "Now considering these types individually, we start with the _int._\n",
    "\n",
    "***To check the datatype of a value or variable in Python, we use the type function.***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### INTEGER DATATYPE (int)\n",
    "- In python, the int datatype is used to indicate integer values (numbers without a decimal part).\n",
    "- It is simply any negative or positive whole number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Int\n",
    "\n",
    "a = 33\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can perform operations with int datatypes.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "33 + 67"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1000"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10**3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "100 % 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also create an integer datatyp by explictly casting a numeric value as an _'int'_ using the ***int()*** method.  \n",
    "An illustration is given in the example below.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This the original number 555; \t\t This is the the number after casting into an integer 555\n",
      "This the original number 66.77; \t This is the the number after casting into an integer 66\n"
     ]
    }
   ],
   "source": [
    "a = 555\n",
    "b = 66.77\n",
    "\n",
    "print(f\"This the original number {a}; \\t\\t This is the the number after casting into an integer {int(a)}\")\n",
    "print(f\"This the original number {b}; \\t This is the the number after casting into an integer {int(b)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### FLOATING POINT NUMBERS\n",
    "\n",
    "These are numeric values that have decimal parts (real numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(5.6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As with integers, we can cast numeric variables or values to a _'float'_ using the ***float()*** method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This the original number 11; \t\t This is the the number after casting into an float 11\n",
      "This the original number 65.97; \t This is the the number after casting into an float 65\n"
     ]
    }
   ],
   "source": [
    "c = 11\n",
    "d = 65.97\n",
    "\n",
    "print(f\"This the original number {c}; \\t\\t This is the the number after casting into an float {int(c)}\")\n",
    "print(f\"This the original number {d}; \\t This is the the number after casting into an float {int(d)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### COMPLEX NUMBERS\n",
    "These numeric values represent complex numbers (numbers with both imaginary and real parts present).\n",
    "\n",
    "Generally, a complex number is written as $$a + bi,$$\n",
    "where $a$ denotes the real part and $b$ is the imaginary part.\n",
    "\n",
    "But in python, we use ***j*** to indicate the imaginary part.\n",
    "Hence writing the above complex number in Python will look a like;\n",
    "$$a  + bj$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(9+6j)\n",
      "(10-1j)\n"
     ]
    }
   ],
   "source": [
    "a = 6 + 1j\n",
    "b = 3 + 5j\n",
    "c = 4 - 2j\n",
    "\n",
    "print(a + b)\n",
    "print(a + c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similar to integers and floating point numbers, we can convert number values to complex numbers with $0$ imaginary part."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This the original number 66; \t\t This is the the number after casting into an float (66+0j)\n"
     ]
    }
   ],
   "source": [
    "a = 66\n",
    "\n",
    "print(f\"This the original number {a}; \\t\\t This is the the number after casting into an float {complex(a)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### BOOLEAN DATATYPE\n",
    "\n",
    "As the name suggests, variables of this datatype can only take two values; \n",
    "- **True**\n",
    "- **False**\n",
    "\n",
    "These values are normally the result of an expression involving relational or logical operators."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = True\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#\n",
    "3  > 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result of a or b:  True\n",
      "Result of a and b:  False\n"
     ]
    }
   ],
   "source": [
    "a = 4 == 6\n",
    "b = 6 <= 7\n",
    "\n",
    "print(f\"Result of a or b:  {a or b}\")\n",
    "print(f\"Result of a and b:  {a and b}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generally, there are specific values that are considered falsy (**False**) values. All other values are considered truthy (**True**). \n",
    "\n",
    "##### FALSY VALUES\n",
    "- None\n",
    "- False\n",
    "- Zero i.e 0, 0.0\n",
    "- Empty sequence, for example, '', [], ()\n",
    "- Empty dictionary i.e {}\n",
    "\n",
    "We will talk more about sequences later."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### STRINGS\n",
    "Strings sequences of characters enclosed by single or double quotation marks. It is generally used for storing texts.\n",
    "\n",
    "Since a string is basically a sequence of characters, we can access the individual characters in a string using what is known as an ***index.***\n",
    "\n",
    "- An _index_ is a number that shows the position of a character in string starting from the left (unless negative indices which start from the right).\n",
    "\n",
    "**NOTE:** Python is **0-indexed** meaning it starts counting from position 0. This also means that the position of the last character in the string is one less than the length of the string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abcdefgh'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = \"abcdefgh\"\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the string variable a above, the letter _a_ is at index (position) 0, letter _b_ is at index 1 and so on.  \n",
    "To access a specific character in a string, we use the syntax below\n",
    "\n",
    "- name_of_string\\[index or position\\]\n",
    "\n",
    "An illustration is given below.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'h'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[7]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also start indexing from the right (known as negative indexing).\n",
    "\n",
    "The last character in the string has an index of -1, the second last has an index of -2 and so on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'h'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'g'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[-2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, what happens when we want to select mo than one character in a string (a subset of the string)??\n",
    "\n",
    "We use what we call ***SLICING.*** The syntax for slicing is given below\n",
    "\n",
    "name_of_variable[start index, end index, step]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abc'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Selecting the first 3 letters of the string above\n",
    "a[0:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NOTE:**\n",
    "- the last index is exclusive meaning the slicing operation stops just before the last index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'fgh'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Selecting the last 3 characters\n",
    "a[-3:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NOTE:**\n",
    "- When we leave the starting index open (empty), the slicing starts from the first character at position 0.\n",
    "- Similarly, when we leave the last index open, it slices upto the last character.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abcde'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[:5] # selects the first five characters\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ace'"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[0:5:2] # Selects the first five characters with a step of two"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### MULTILINE STRINGS\n",
    "\n",
    "- This are strings that appear exactly the way they are typed.\n",
    "- This is enclosed in three (3) opening and closing quotation marks\n",
    "- When we use multiline strings without assigning it to a variable, it is treated by the interpreter as a comment (This is what is used in docstrings)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello there\n",
      "How are you doing?\n",
      "Have a nice day\n"
     ]
    }
   ],
   "source": [
    "multistr1 = '''Hello there\n",
    "How are you doing?\n",
    "Have a nice day'''\n",
    "print(multistr1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### STRING METHODS\n",
    "\n",
    "These are functions that are specific to strings only. \n",
    "\n",
    "There are so many methods that it is impractical to cover all of them. We will only discuss the most essential ones.\n",
    "\n",
    "- capitalize(): It converts the first character of a string to upper case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Abcdefgh'"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = \"abcdefgh\"\n",
    "a.capitalize()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- endswith(): Returns _True_ if the string ends with the specified character."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.endswith(\"h\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- find(): It searches a string for a specified value and returns the position where it was found."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.find(\"d\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- index(): Similar to the find method but returns an error when the specified substring is not found."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.index('g')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "substring not found",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[40], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43ma\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mindex\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mk\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "\u001b[1;31mValueError\u001b[0m: substring not found"
     ]
    }
   ],
   "source": [
    "a.index('k')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- islower(): Returns true if all characters in the string are lower case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.islower()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- isupper(): Returns True if all characters in the string are upper case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.isupper()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- isnumeric(): Returns True if all characters in the string are numeric."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.isnumeric()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- join(): Converts elements of an iterable into a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Programming is fun'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = ['Programming', 'is', 'fun']\n",
    "\" \".join(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- split(): This method separates the string by the value passed as an argument and returns a list containing separated parts of the string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['My', 'name', 'is', 'Danny']\n"
     ]
    }
   ],
   "source": [
    "a = 'My name is Danny'\n",
    "b = a.split(' ')\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- lower(): Converts all characters in the string to a lowercase.\n",
    "- upper(): Converts all characters of the string to an upper case.\n",
    "\n",
    "For more string methods, check out this [website](https://www.w3schools.com/python/python_ref_string.asp).\n",
    "\n",
    "**NOTE:** \n",
    "- To check the number of characters in a string, use the _len()_ function.\n",
    "\n",
    "##### FORMATTED STRINGS\n",
    "- They allow us to insert variables into a string directly without using concatenation.\n",
    "- They can be done in two ways"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is Diana and I love apples\n"
     ]
    }
   ],
   "source": [
    "a = 'apples'\n",
    "b = 'Diana'\n",
    "\n",
    "str1 = 'My name is {0} and I love {1}'.format(b,a)\n",
    "print(str1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- We can also leaves the indices out of the curly braces. In this case, the order matters as the first argument to the format method will replace the first curly brace and so on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'My name is apples and I love Diana'"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str2 = 'My name is {} and I love {}'.format(a,b)\n",
    "str2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The second way is what is most used these days. I have used quite a few in the previous topics (😂😂😂😂😂).\n",
    "- It is normally referred to as f-strings.\n",
    "- You simply prefix the string with an _'f'_ and insert your variables or expressions in braces directly where you want them to appear in the string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'My name is Diana and I love apples'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f'My name is {b} and I love {a}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I am 34 years old.'"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f'I am {22+3*4} years old.' "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### CONTAINERS\n",
    "\n",
    "Containers (sequences) are essentially like the variables we've discussed previously but unlike those variables, containers can store more than a single value. The values stored in these containers can be of different datatypes or of the same datatype.\n",
    "\n",
    "In this course we'll talk about the following containers\n",
    "1. List\n",
    "1. Tuples\n",
    "1. Set\n",
    "1. Dictionaries\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### LIST\n",
    "\n",
    "A list is the most common and widely used container. It can be used to store any number of values and the values can be of any data type.\n",
    "\n",
    "***PROPERTIES***\n",
    "- Mutability: We can change the values in the list\n",
    "- Indexable: We can access single or a portion of the values stored in a list using the _index_ and _slicing_ operations discussed under the string section.\n",
    "- Lists are duplicate elements\n",
    "\n",
    "Lists can be created by placing comma-separated values in a square bracket or by using the _list()_ constructor.\n",
    "\n",
    "Examples are given below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 'a', 'b', False]\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "aaa = [1,2,3,'a','b', False]\n",
    "print(aaa)\n",
    "\n",
    "bbb = list()\n",
    "print(bbb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just like we discussed under the string section, we can index and slice lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "aaa[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "aaa[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 'a']"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "aaa[1:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- To know the number of elements contained in a list (size of the list), we use the _len()_ function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(aaa)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### LIST METHODS\n",
    "\n",
    "1. _append():_ This method adds an element to the end of the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple', 'guava', 'pineapple']\n",
      "['apple', 'guava', 'pineapple', 'orange']\n",
      "['apple', 'guava', 'pineapple', 'orange', ['mango', 'watermelon']]\n"
     ]
    }
   ],
   "source": [
    "bb = ['apple', 'guava', 'pineapple']\n",
    "print(bb)\n",
    "\n",
    "bb.append('orange')\n",
    "print(bb)\n",
    "\n",
    "bb.append(['mango', 'watermelon'])\n",
    "print(bb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. _insert():_ This method allows you to add an element to the list in the specified index (position)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple', 'guava', 'boy', 'pineapple', 'orange', ['mango', 'watermelon']]\n"
     ]
    }
   ],
   "source": [
    "bb.insert(2, 'boy')\n",
    "print(bb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. _extend():_ This method also adds elements to the list. One important fact about this method is that when we add other collections using this method, the items get added individually as opposed to the _append_ method which adds the entire collection."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple', 'guava', 'boy', 'pineapple', 'orange', ['mango', 'watermelon'], 'car', 'motobike']\n"
     ]
    }
   ],
   "source": [
    "bb.extend(['car', 'motobike'])\n",
    "print(bb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. _reverse():_ This method reverses the order of the elements in the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['motobike', 'car', ['mango', 'watermelon'], 'orange', 'pineapple', 'boy', 'guava', 'apple']\n"
     ]
    }
   ],
   "source": [
    "bb.reverse()\n",
    "print(bb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. _remove():_ This method removes the specified item from the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['motobike', 'car', ['mango', 'watermelon'], 'orange', 'pineapple', 'guava', 'apple']\n"
     ]
    }
   ],
   "source": [
    "bb.remove('boy')\n",
    "print(bb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6. _pop():_ This method removes the last item in the list and returns it.\n",
    "\n",
    "- We can also pass an index as an argument to the _pop()_ method to remove the element at the specified index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple\n",
      "['motobike', 'car', ['mango', 'watermelon'], 'orange', 'pineapple']\n"
     ]
    }
   ],
   "source": [
    "removed_item = bb.pop()\n",
    "print(removed_item)\n",
    "\n",
    "bb.pop(5)\n",
    "print(bb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NOTE:**\n",
    "- We can add two or more lists together using the concatenation sign ( + ). (This can also be done for strings).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### LIST COMPREHENSION\n",
    "\n",
    "- It is a simpler and quicker way of creating lists from other containers\n",
    "- It basically consists of enclosing expressions in a square bracket.\n",
    "- The expression is evaluated for each element in the container.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "a = [1,2,3,4,5]\n",
    "b = [x**2 for x in a]\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- We can also use conditional statements (to be discussed later) i list comprehensions\n",
    "The syntax is given below;\n",
    "```python\n",
    "    [expression for element in iterable if condition]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 16, 36, 64, 100]\n"
     ]
    }
   ],
   "source": [
    "a = [1,2,3,4,5,6,7,8,9,10]\n",
    "b = [x**2 for x in a if x % 2 == 0]\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### TUPLE\n",
    "\n",
    "Tuples are also containers that can be used to store more than a single value. Tuples are created using parenthesis (), or the tuple constructor.\n",
    "\n",
    "- Tuples are immutable - meaning the elements stored in a tuple cannot be altered. A way to work around this might be to convert the tuple to a list.\n",
    "- Tuples also support indexing and slicing.\n",
    "- To create a tuple with only one item, you must add a comma at the end of that value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 'aa', 'bb', False)\n",
      "()\n",
      "('hi',)\n"
     ]
    }
   ],
   "source": [
    "tt = (1,2,'aa', 'bb', False)\n",
    "print(tt)\n",
    "\n",
    "tt1 = tuple()\n",
    "print(tt1)\n",
    "\n",
    "only_one_item = ('hi',)\n",
    "print(only_one_item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tt[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 'aa', 'bb')"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tt[:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- We can unpack the elements in a tuple using the asterisks ( * ) operator. Unpacking means taking out the elements in the tuple.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "yellow\n",
      "red\n",
      "['blue', 'green', 'brown', 'white']\n"
     ]
    }
   ],
   "source": [
    "tt2 = ('yellow', 'red', 'blue', 'green', 'brown', 'white')\n",
    "yellow, red, *rests = tt2\n",
    "print(yellow)\n",
    "print(red)\n",
    "print(rests)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To join two tuples, you can simply use the concatenation symbol ( + )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('hello', 'how', 'are', 'you?')\n"
     ]
    }
   ],
   "source": [
    "tup1 = ('hello', 'how')\n",
    "tup2 = ('are', 'you?')\n",
    "\n",
    "print(tup1 + tup2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### SETS \n",
    "\n",
    "Sets is also another container that can be used to store multiple values. \n",
    "\n",
    "- They cannot be indexed\n",
    "- They are immutable\n",
    "- They do not contain duplicated elements.\n",
    "\n",
    "They are created by placing comma-separated values within a set of opening and closing braces ( {} ) or by using the _set()_ constructor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'apple', 'guava', 'orange', 'banana'}\n",
      "set()\n"
     ]
    }
   ],
   "source": [
    "s1 = {'apple', 'orange', 'banana', 'guava'}\n",
    "print(s1)\n",
    "\n",
    "s2 = set()\n",
    "print(s2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### SET METHODS\n",
    "\n",
    "1. _add():_ This method adds a new element to the set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'hello'}\n"
     ]
    }
   ],
   "source": [
    "s2.add('hello')\n",
    "print(s2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. _update():_ This method adds another container to the set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'girl', 'hello', 'boy'}\n"
     ]
    }
   ],
   "source": [
    "s3 = ['boy', 'girl']\n",
    "\n",
    "s2.update(s3)\n",
    "print(s2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. _remove():_ This method removes the specified item from the set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'apple', 'orange', 'banana'}\n"
     ]
    }
   ],
   "source": [
    "s1.remove('guava')\n",
    "print(s1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. _discard():_ This method works exactly like the _remove()_ method but it will not raise an error when the specified element does not exist."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'girl', 'boy', 'hi'}\n"
     ]
    }
   ],
   "source": [
    "ss1 = {'hello', 'boy', 'hi', 'girl'}\n",
    "\n",
    "ss1.discard('hello')\n",
    "print(ss1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'boom'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[73], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mss1\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mremove\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mboom\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "\u001b[1;31mKeyError\u001b[0m: 'boom'"
     ]
    }
   ],
   "source": [
    "ss1.remove('boom')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "ss1.discard('boom')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. _Union():_ This method works like the _update()_ method. It adds to sets (it returns a new set with all items from both sets).\n",
    "\n",
    "**NOTE:** Instead of using the _union()_ method, we could use the pipe symbol ( | ) and we'll get the same result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'e', 'c', 'a', 'd', 'b', 'f'}\n",
      "{'e', 'c', 'a', 'd', 'b', 'f'}\n"
     ]
    }
   ],
   "source": [
    "ss2 = {\"a\", \"b\", \"c\"}\n",
    "ss3 = {\"d\", \"e\", \"f\", \"b\", \"c\"}\n",
    "\n",
    "ss4 = ss2.union(ss3)\n",
    "print(ss4)\n",
    "\n",
    "ss5 = ss2 | ss3\n",
    "print(ss5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6. _Intersection():_ This method return only those items that are common in both sets. \n",
    "\n",
    "**NOTE:** You can also use the ampersand symbol ( & ) and you'll get the same result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'b', 'c'}\n",
      "{'b', 'c'}\n"
     ]
    }
   ],
   "source": [
    "ss6 = ss2.intersection(ss3)\n",
    "print(ss6)\n",
    "\n",
    "ss7 = ss2 & ss3\n",
    "print(ss7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7. _difference():_ This method returns the elements that are in the first set but not in the other set.\n",
    "\n",
    "**NOTE:** You can use the hyphen ( - ) to get the same result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a'}\n",
      "{'a'}\n",
      "{'e', 'f', 'd'}\n",
      "{'e', 'f', 'd'}\n"
     ]
    }
   ],
   "source": [
    "ds1 = ss2.difference(ss3)\n",
    "print(ds1)\n",
    "\n",
    "ds2 = ss2 - ss3\n",
    "print(ds2)\n",
    "\n",
    "ds3 = ss3.difference(ss2)\n",
    "print(ds3)\n",
    "\n",
    "ds4 = ss3 - ss2\n",
    "print(ds4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8. _symmetric\\_difference():_ This method returns the elements that are not in the intersection of the sets.\n",
    "\n",
    "**NOTE:** We can get the same result by using the caret symbol ( ^ )."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'e', 'd', 'a', 'f'}\n",
      "{'e', 'd', 'a', 'f'}\n"
     ]
    }
   ],
   "source": [
    "ds5 = ss2.symmetric_difference(ss3)\n",
    "print(ds5)\n",
    "\n",
    "ds6 = ss2 ^ ss3\n",
    "print(ds6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### DICTIONARIES\n",
    "\n",
    "Dictionaries are the last of the containers that we'll discuss. They are used for storing key:value pairs. \n",
    "\n",
    "- They are mutable\n",
    "- They do not allow duplicates\n",
    "\n",
    "They can be created by placing comma-separated key:value pairs in braces ( {} ) or by using the _dict()_ constructor.\n",
    "The key and the value are separated by a colon ( : )."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'Dan', 'age': 64}\n",
      "{}\n"
     ]
    }
   ],
   "source": [
    "dd = {'name': 'Dan', 'age': 64}\n",
    "print(dd)\n",
    "\n",
    "dd1 = dict()\n",
    "print(dd1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The elements in a dictionary can be accessed by using the following syntax;\n",
    "\n",
    "variable_name[key name]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Dan'"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dd['name']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- We can also access an element of a dictionary using the _get()_ method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Dan'"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dd.get('name')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- We can get all the keys using the _keys()_ method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['name', 'age'])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dd.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- We can get all the values using the _values()_ method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values(['Dan', 64])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dd.values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- We can get a tuple of the items in a dictionary by using the _items()_ method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('name', 'Dan'), ('age', 64)])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dd.items()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- To change the value of a key in a dictionary, we can access the element using the key name and set it to a new value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'Manuel', 'age': 64}\n"
     ]
    }
   ],
   "source": [
    "dd['name'] = 'Manuel'\n",
    "print(dd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- We can also add new elements to the dictionary by using the syntax below (which is similar to the one used to reassign a value).\n",
    "\n",
    "variable_name[new key] = new value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'Manuel', 'age': 64, 'height': 155}\n"
     ]
    }
   ],
   "source": [
    "dd['height'] = 155\n",
    "print(dd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- We can also use the _update()_ method add a  new element to the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'Manuel', 'age': 64, 'height': 155, 'birth year': 1900}\n"
     ]
    }
   ],
   "source": [
    "dd.update({'birth year': 1900})\n",
    "print(dd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- _popitem():_ This method removes the last item in the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'Manuel', 'age': 64, 'height': 155}\n"
     ]
    }
   ],
   "source": [
    "dd.popitem()\n",
    "print(dd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- _pop():_ This method removes the element with the specified key."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'age': 64, 'height': 155}\n"
     ]
    }
   ],
   "source": [
    "dd.pop('name')\n",
    "print(dd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### ***THE RANGE FUNCTION***\n",
    "\n",
    "- The range function generates values from the starting value to the stopping value (exclusive) with the specified steps\n",
    "- It returns a range object which can be converted to other containers\n",
    "- It is very useful in generating sequential numbers with a specified range.\n",
    "\n",
    "Syntax is given below\n",
    "```python\n",
    "    range(start, stop, step)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(1, 20)"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = range(1,20)\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see the individual elements by converting it to a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = range(1,20,2)\n",
    "list(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### ***THE IN OPERATOR***\n",
    "\n",
    "- For all the iterables (containers) discussed, we can use the _in_ operator to check if a container contains a specific item.\n",
    "- It is mostly used in _for loops_ (which will be discussed later) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 in a? True\n",
      "a in bb? True\n",
      "nationality in c? False\n"
     ]
    }
   ],
   "source": [
    "a = [1,2,3,4,5]\n",
    "bb = (\"a\", \"b\", \"c\")\n",
    "c = {'name': 'Danny', 'country': 'Ghana', 'age':10}\n",
    "\n",
    "print(f\"3 in a? {3 in a}\")\n",
    "print(f\"a in bb? {'a' in bb}\")\n",
    "print(f\"nationality in c? {'nationality' in c}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### FUNCTIONS COMMONLY USED ON ITERABLES (CONTAINERS OR SEQUENCES)\n",
    "1. _sum():_ This function sums all the values in a given container."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21\n",
      "154\n"
     ]
    }
   ],
   "source": [
    "a = [1,2,3,4,5,6]\n",
    "print(sum(a))\n",
    "\n",
    "b = (22,33,44,55)\n",
    "print(sum(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. _sorted():_ This function sorts (reorders) the elements in a given iterable. By default, it sorts in ascending order.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 2, 5, 7, 8, 38, 53]"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [38,53,2,7,1,5,8,2]\n",
    "sorted(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. _max():_ This function determines the maximum value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "53"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. _min():_ This function determines the minimum value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. _all():_ This function returns True if all the values are truthy values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "a = [1,2,3,4,5,9]\n",
    "print(all(a))\n",
    "\n",
    "b = [0,'',[]]\n",
    "print(all(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6. _any():_ This function returns a True if there is at least one truthy value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "c = ['', 0, (), 1]\n",
    "print(any(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### INPUT AND OUTPUT\n",
    "\n",
    "- To take and input in python, we simply use the _input()_ function.\n",
    "- By default, the _input()_ method always returns a string datatype.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = input(\"What is your name? \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- We use the _print()_ function to output results to the standard output (screen)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World\n"
     ]
    }
   ],
   "source": [
    "print('Hello, World')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### EXERCISE\n",
    "1. Write a program that returns the roots of a quadratic equation.\n",
    "1. Create a container that consists of 10 colors;\n",
    "    - First element.\n",
    "    - Second element.\n",
    "    - Last element.\n",
    "    - Second-to-last element.\n",
    "    - Second and third elements.\n",
    "    - Element at index 4."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### CONDITIONAL STATEMENTS (BRANCHING)\n",
    "\n",
    "They define the control flow of a program based on some conditions.\n",
    "\n",
    "The main control flow structures used in python are;\n",
    "- _if_ statements\n",
    "- _IF-else_ statements\n",
    "- _if-elif-else_ statements\n",
    "- _ternary statements_\n",
    "\n",
    "##### ***IF STATEMENTS***\n",
    "- This is used when we want to make a decision (decide the flow of the program) based on a condition. Example; _If it rains, stay home_.\n",
    "- In the example above, we have a condition (whether or not it will rain) and we take an action only when the condition is true. We are not particularly interested in the doing anything else when the condition is false.\n",
    "\n",
    "The syntax for the _if_ statement is given below\n",
    "```python\n",
    "\n",
    "    if condition:\n",
    "        statements\n",
    "```\n",
    "\n",
    "**NOTE:** \n",
    "- In python, we do not not use braces like other programming languages. Instead, we use colon ( : ) to indicate the end of a condition and spaces (indentations) to indicate the statements. For instance in javascript, the above code block would be written as;\n",
    "\n",
    "```javascript\n",
    "\n",
    "    if condition {\n",
    "        statements\n",
    "    }\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bigger than 30\n"
     ]
    }
   ],
   "source": [
    "a = 55\n",
    "\n",
    "if (a > 30):\n",
    "    print('Bigger than 30')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### ***IF-ELSE STATEMENTS***\n",
    "\n",
    "The second control structure we will discuss is the _if-else statements._\n",
    "\n",
    "- This kind of branching gives us an alternative action even when the primary condition fails.\n",
    "- Example; _if it rains, stay home else go out and play._\n",
    "- In the example above, the condition is the same as in the first example but we now have an alternative action to take when the condition fails. That's if it does not rain, we should _go out and play._\n",
    "\n",
    "The syntax for this control flow is given below;\n",
    "```python\n",
    "\n",
    "    if condition:\n",
    "        statements \n",
    "    else:\n",
    "        statements\n",
    "``` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is not greater than 30\n"
     ]
    }
   ],
   "source": [
    "a = 25\n",
    "if (a > 30):\n",
    "    print('a is greater than 30')\n",
    "else:\n",
    "    print('a is not greater than 30')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### ***IF-ELIF-ELSE STATEMENTS***\n",
    "The next control structure we'll discuss is the _if-elif-else_ structure.\n",
    "\n",
    "- This sturcture allows us to test multiple conditions and take actions depending on which conditions evaluated to a _True_ value.\n",
    "- Example; _if it rains, stay home, else if today is Monday, go to school, else go out and play_\n",
    "\n",
    "The syntax for this structure is given below;\n",
    "\n",
    "```python\n",
    "\n",
    "    if condition 1:\n",
    "        statements\n",
    "    elif condition 2:\n",
    "        statements\n",
    "    else:\n",
    "        statements\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You had an A\n"
     ]
    }
   ],
   "source": [
    "a = 75\n",
    "\n",
    "if (a < 40):\n",
    "    print('You failed')\n",
    "elif (a >= 40 and a < 70):\n",
    "    print('You had a B')\n",
    "else:\n",
    "    print('You had an A')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### ***TERNARY STATEMENTS***\n",
    "\n",
    "- These statements are a shorter way of writing _if-else_ control structures.\n",
    "\n",
    "The syntax for ternary statements in python is given below;\n",
    "\n",
    "```python\n",
    "\n",
    "    truth statement if expression else false statement\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You passed\n"
     ]
    }
   ],
   "source": [
    "a = 46\n",
    "print('You passed') if a > 40 else print('You failed')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**GENERAL NOTES ON CONTROL STRUCTURES**\n",
    "- Make sure the conditions do not overlap else you might get unexpected results\n",
    "- You can nest (embbed) control structures within control structures. For example;\n",
    "```python\n",
    "    if condition1:\n",
    "        if inner condition:\n",
    "            statement\n",
    "        else:\n",
    "            statement\n",
    "    elif condition2:\n",
    "        statement\n",
    "    else:\n",
    "        statement\n",
    "```\n",
    "- Avoid nesting so many conditions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### LOOPS (REPETITIONS)\n",
    "\n",
    "These structures allow us to preform tasks repeatedly.\n",
    "\n",
    "There are two main looping structures in Python\n",
    "- _For loop_\n",
    "- _while loop_\n",
    "\n",
    "##### ***FOR LOOP***\n",
    "These looping structures are basically used for traversing containers (sequences).  \n",
    "For instance, we can loop (iterate) over the characters in a string or the elements in a list, tuple, etc.\n",
    "\n",
    "The syntax for this looping structure is\n",
    "```python\n",
    "\n",
    "    for item in iterable:\n",
    "        do something\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n",
      "d\n",
      "e\n"
     ]
    }
   ],
   "source": [
    "mylist = [\"a\", \"b\", \"c\", \"d\", \"e\"]\n",
    "\n",
    "for element in mylist:\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- There is also another way of using this looping construct in which we can use indices to access elements in a sequence. (This approach becomes quite useful when dealing with algorithmic problems)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n",
      "d\n",
      "e\n"
     ]
    }
   ],
   "source": [
    "for i in range(len(mylist)):\n",
    "    print(mylist[i]) # printing the element in the i position in mylist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### ***WHILE LOOP***\n",
    "\n",
    "- This looping construct evaluates repeated until the specified condition evaluates to false.\n",
    "- When the looping condition beecomes false, the line immediately after the _while loop_ gets executed.\n",
    "- Care should be taken when using this looping construct by providing a terminating condition else the loop might run indefinitely.\n",
    "\n",
    "The syntax for the while loop is given below;\n",
    "```python\n",
    "\n",
    "    while condition:\n",
    "        statements\n",
    "        updating condition\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "while (a < 10):\n",
    "    print(a)\n",
    "    a += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- We can also add an _else_ block to the while block.\n",
    "- The else block gets executed only when the looping condition evaluates to False. If an error is raised or we break out of the loop, the else block won't be executed.\n",
    "\n",
    "The syntax is given below;\n",
    "\n",
    "```python\n",
    "    while conditio:\n",
    "        statements\n",
    "    else:\n",
    "        statement\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "The loop has finished running\n"
     ]
    }
   ],
   "source": [
    "a = 1 \n",
    "while (a < 10):\n",
    "    print(a)\n",
    "    a += 1\n",
    "else:\n",
    "    print('The loop has finished running')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- When the condition inside the looping condition always evaluates to True, we will get an infinite loop.\n",
    "- There are a couple of ways to resolve this;\n",
    "    - Make sure you update the variabe in the condition so that it will evaluate to False at some point\n",
    "    - Use _break_ statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### BREAK AND CONTINUE STATEMENTS\n",
    "\n",
    "##### ***BREAK STATEMENTS***\n",
    "- When we use the break statement, it halts the execution of the loop and takes control out of the loop.\n",
    "- It is mostly used in a conditional statement to halt the execution of the loop when a specific consition is met.\n",
    "\n",
    "Syntax is given below;\n",
    "```python\n",
    "    while condition:\n",
    "        statement\n",
    "        if condition:\n",
    "            break\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "11\n",
      "12\n",
      "13\n",
      "14\n",
      "15\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "while (a < 500):\n",
    "    print(a)\n",
    "    if (a == 15):\n",
    "        break\n",
    "    a += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***CONTINUE STATEMENTS***\n",
    "\n",
    "- This statement skips the current iteration of the loop and moves to the next iteration of the loop\n",
    "- It can be used to skip unwanted executions in a loop\n",
    "\n",
    "Syntax is given below\n",
    "```python\n",
    "    while condition:\n",
    "        statement\n",
    "        if condition:\n",
    "            continue\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "6\n",
      "8\n",
      "10\n",
      "12\n",
      "14\n",
      "16\n",
      "18\n",
      "20\n",
      "22\n",
      "24\n",
      "26\n",
      "28\n",
      "30\n",
      "32\n",
      "34\n",
      "36\n",
      "38\n",
      "40\n",
      "42\n",
      "44\n",
      "46\n",
      "48\n",
      "End of the loop\n"
     ]
    }
   ],
   "source": [
    "# The program below prints even numbers from between 1 and 50 using while loop and continue statements\n",
    "\n",
    "a = 1\n",
    "while (a < 50):\n",
    "    if (a % 2 == 0):\n",
    "        print(a)\n",
    "    else:\n",
    "        a += 1\n",
    "        continue\n",
    "    a += 1\n",
    "else:\n",
    "    print('End of the loop')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NOTE:**\n",
    "- Although in the examples above, I used the _break_ and _continue_ statements with the _while_ loop, it can also be used with the _for_ loop\n",
    "- Similar, I only discussed used the _else_ block with a while loop but it can also be used _for_ loop. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### FUNCTIONS\n",
    "\n",
    "Functions helps us in automating stuffs. It is a block of code that may or may not return a value.\n",
    "- Generally, we write functions for pieces for code that we use quite often in order to avoid writing lenthy lines of code to do the same task over and over again.\n",
    "- Functions essentially improve code reusability and code readability.\n",
    "\n",
    "There are two main kinds of functions\n",
    "- _Built-in_ functions: These are functions that come with the programming language itself. Examples include; _print(),_ _input(),_ etc.\n",
    "- _Custom_ functions: As the name implies, these are functions that are written by the programmer themselves.\n",
    "\n",
    "Aside these two main kinds, we can categorize functions based on how they behave,\n",
    "- _functions that do not return any value_\n",
    "- _functions that have a return value_\n",
    "- _functions that accept no arguments_\n",
    "- _functions that accept arguments_\n",
    "\n",
    "The general syntax for creating a function is given below;\n",
    "```python\n",
    "    def function_name(arguments):\n",
    "        '''docstring'''\n",
    "        function body\n",
    "```\n",
    "\n",
    "- The ```def``` keyword is used to indicate that we are defining a new function, hence the name _def._\n",
    "- The function name can be any name but it should obey the variable naming conventions\n",
    "- A function may or may not accept arguments. Even if the function does not accept any argument, you must still attach the parenthesis to the function name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Defining a function that does not accept any input\n",
    "def my_first_function():\n",
    "    print('This is my first function')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- After a function has been created, we must ***call*** it in order to use it.\n",
    "- To call a function, simply use the syntax below,\n",
    "```python\n",
    "    function_name(arguments)\n",
    "```\n",
    "\n",
    "- Without calling a function, it will do nothing.\n",
    "If we wish to call the function we just created above,\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is my first function\n"
     ]
    }
   ],
   "source": [
    "my_first_function()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now discuss functions with parameters\n",
    "**NOTE:**\n",
    "- _parameters_ are the placeholders we use when creating or defining a function\n",
    "- _arguments_ are the actual values we pass to the function when we call it.\n",
    "- Also, in the general synax I gave above for defining a function, You can see a docstring in there.\n",
    "- Although it is not mandatory, it is considered best practice to always add a docstring when creating a function.\n",
    "- Docstrings are comments that explain the parameters of a function, the return type and any other useful information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is Emelia\n"
     ]
    }
   ],
   "source": [
    "def my_second_fun(name):\n",
    "    print(f\"My name is {name}\")\n",
    "\n",
    "my_second_fun('Emelia')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A function that accepts arguments can have 4 different kinds of arguments in Python\n",
    "1. _default arguments:_ These parameters have default values that will be used, should the user fail to supply the any argument.\n",
    "The syntax is given below\n",
    "\n",
    "```python\n",
    "    def func_name(arg1=value1):\n",
    "        function body\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Emelia\n",
      "Hello, World\n"
     ]
    }
   ],
   "source": [
    "def second_func_modified(name='World'):\n",
    "    print(f'Hello, {name}')\n",
    "\n",
    "second_func_modified('Emelia') # Called with an argument\n",
    "second_func_modified() # Called without an argument"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. _positional arguments:_ The arguments are substituted by their position.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, my name is  Emelia and I am 30 years old\n",
      "Hello, my name is  30 and I am Emelia years old\n"
     ]
    }
   ],
   "source": [
    "def third_func(name, age):\n",
    "    print(f'Hello, my name is  {name} and I am {age} years old')\n",
    "\n",
    "third_func('Emelia', 30)\n",
    "third_func(30, 'Emelia')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- As we can see above, the order in which the argument is passed is very essential hence the name (positional arguments).\n",
    "\n",
    "3. _keyword arguments:_ In this case, the arguments are passed by the parameter (keyword name). It always yields the same result unlike in the case of the positional argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, my name is  Emelia and I am 30 years old\n",
      "Hello, my name is  Emelia and I am 30 years old\n"
     ]
    }
   ],
   "source": [
    "third_func(name='Emelia', age=30)\n",
    "third_func(age=30, name='Emelia')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- One very important thing to notice is that _positional arguments_ must always come before _keyword arguments._\n",
    "\n",
    "4. _arbitrary arguments:_ These can take any arbitrary number of arguments. There are two kinds\n",
    "- _*args:_ non-keyword (positional) arbitrary arguments\n",
    "- _**kwargs:_ keyword arbitrary arguments\n",
    "The syntax is given below.\n",
    "\n",
    "```python\n",
    "    def func_name(*args):\n",
    "        function body\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "def fourth_func(*args):\n",
    "    for i in args:\n",
    "        print(i)\n",
    "\n",
    "fourth_func(1,2,3,4,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n"
     ]
    }
   ],
   "source": [
    "fourth_func(\"a\", \"b\", \"c\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first = Math\n",
      "second = is\n",
      "last = Fun\n"
     ]
    }
   ],
   "source": [
    "def fifth_func(**kwargs):\n",
    "    for key, value in kwargs.items():\n",
    "        print(f\"{key} = {value}\")\n",
    "\n",
    "\n",
    "fifth_func(first='Math', second='is', last='Fun')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### RETURNING A VALUE FROM  A FUNCTION\n",
    "- To return a value from a function, you simply use the ```return``` keyword.\n",
    "\n",
    "```python\n",
    "    def func_name(arguments):\n",
    "        statements\n",
    "        return value\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def next_func(num1, num2):\n",
    "    num3 = num1 + num2\n",
    "    return num3\n",
    "\n",
    "next_func(44,56)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### ANONYMOUS (LAMBDA) FUNCTIONS\n",
    "\n",
    "- These functions are unamed and are typically used for one-line statements.\n",
    "- They have an implicit return statement\n",
    "- They are also known as _lambda_ functions as they use the ```lambda``` keyword.\n",
    "\n",
    "Syntax:\n",
    "```python\n",
    "    variable_name = lambda args: expression\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next_func_modified = lambda num1, num2: num1 + num2\n",
    "\n",
    "next_func_modified(44,56)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### MODULES\n",
    "\n",
    "A module is simply a file that contains code statements and can be reused in another program.\n",
    "- Every python file (files with _.py_ extension) is essenstially a module.\n",
    "\n",
    "Now to use a module or a statement in a module,\n",
    "- we must first import the module.\n",
    "\n",
    "There are several ways of importing a module in python\n",
    "- ```import module``` This essentially imports the entire module\n",
    "- ```from module import *``` This also imports the entire module\n",
    "- ```from module import item1, item2, etc``` This import specific functions, classes, variables, etc from the module.\n",
    "\n",
    "In the next few examples, we look at how to import some built-in python modules."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- When you import a module using the first approach, you must always prefix every statement from that module with the module name to indicate that the function or class you are callng is from that module.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.sqrt(16) # evaluates the square root of 16"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- When you use the second approach, you do not need to prefix every call of a statement in the module with the module name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sqrt(16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.2246467991473532e-16"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import sin, pi\n",
    "\n",
    "sin(pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- When we use the last approach, we only have access to the specific functions we imported from the module."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NOTE:** \n",
    "- In the rest of this course, we will be using modules like;\n",
    "    - [numpy](https://numpy.org/doc/stable/user/absolute_beginners.html)\n",
    "    - [seaborn](https://seaborn.pydata.org/tutorial/introduction)\n",
    "    - [matplotlib](https://matplotlib.org/stable/users/explain/quick_start.html)\n",
    "    - [scipy](https://docs.scipy.org/doc/scipy/tutorial/index.html#user-guide)\n",
    "    - [scikit-learn](https://scikit-learn.org/stable/user_guide.html)\n",
    "\n",
    "- As and when we use a new module, we will introduce the key concept.\n",
    "- You can also use this [link](https://www.geeksforgeeks.org/built-in-modules-in-python/) to explore other built-in python modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### REFERENCES\n",
    "- [Introduction to Python](https://www.geeksforgeeks.org/introduction-to-python/ \"GeekforGeeks\")\n",
    "- [Introduction to Python for Absolute beginners](https://www.geeksforgeeks.org/introduction-to-python-for-absolute-beginners/)\n",
    "- [Python Introduction](https://realpython.com/python-introduction/)\n",
    "- [Introduction to Python](https://datagy.io/introduction-to-python/ \"Datagy\")\n",
    "- [Operators in Python](https://overiq.com/python-101/operators-in-python/)\n",
    "- [Python Variable Names](https://www.w3schools.com/python/python_variables_names.asp \"w3schools\")\n",
    "- [Python Lists](https://www.geeksforgeeks.org/python-lists/)\n",
    "- [Python Functions](https://www.geeksforgeeks.org/python-functions/)\n",
    "\n",
    "#### BOOKS\n",
    "- [Sweigart, A. (2019). Automate the boring stuff with Python: practical programming for total beginners. no starch press.](http://www.ir.juit.ac.in:8080/jspui/bitstream/123456789/5367/1/Automate%20the%20Boring%20Stuff%20with%20Python%2C%202nd%20Edition%20Practical%20Programming%20for%20Total%20Beginners%20by%20Al%20Sweigart.pdf)\n",
    "- [Severance, C. (2016). Python for everybody: Exploring Data using python 3. Charles Severance.](https://dlib.phenikaa-uni.edu.vn/bitstream/PNK/6476/1/Python%20for%20Everybody.pdf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# Congrats! That's it for this tutorial.\n",
    "\n",
    "---\n",
    "<h1>About the Authors:</h1> \n",
    "\n",
    "## Author 1\n",
    " \n",
    "**Emmanuel Afrifa**,   \n",
    "Master's student at AIMS Ghana  \n",
    "Email: eafrifa@aims.edu.gh\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "---\n",
    "*This notebook was originally created for the [Accra WiMLDS chapter ](https://www.linkedin.com/company/98583062/admin/feed/posts/) Mathematics for ML & Data Science course 2024 and is published under [MIT license](https://choosealicense.com/licenses/mit/).*"
   ]
  }
 ],
 "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}