Python_Fundamentals.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IoUaZUlP7pjv"
   },
   "source": [
    "# **Python Fundamentals**<br>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OSbkJ62Ane4V"
   },
   "source": [
    "# Python Hello World\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QBhhYefI8Onr"
   },
   "source": [
    "When learning any new programming language, it is customary to write a Hello World! statement and run it. Keeping with the tradition, let's write our Hello World! statement in Python and run it. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KByrKagGnyj4"
   },
   "source": [
    "### Print \"Hello World\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "p0gzhT7flqtH"
   },
   "source": [
    "In order to print \"Hello World!\", type the syntax: `print(\"Hello World!\")` on Colab notebook and press Ctrl+Enter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "obA5emdkmIHu"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qA8fGRrLmSjW"
   },
   "source": [
    "### Exercise 1.1:\n",
    "Write the syntax to print \"I love Python\" and run it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "Y-5cDzEkmQVl"
   },
   "outputs": [],
   "source": [
    "# write your code to print \"I love Python\" below and run it.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "we8wKXM1Fj0S"
   },
   "source": [
    "## Python comments\n",
    "Comments are descriptions used to briefly describe the code. It is always a good idea to include comments in your code. Code are instructions for the computer, while comments are information for humans. Your code should be understandable to other people, so that other people can maintain and extend your code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "L7CuCGfuGqz_"
   },
   "source": [
    "**Single line Comments**\n",
    "If you want single line comment, you need to put a \"#\" symbol before the comment. Example is shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "rCvPPmSEYuEL"
   },
   "outputs": [],
   "source": [
    "# This is a single line comment. Always comment your code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "08YYbAEiHQSO"
   },
   "source": [
    "**Multi line comments**\n",
    "If your comment is going to be more than one line, you can enclose them with \"\"\" as shown in the example below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "qfKtao9WY9Q5"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "' This is multi-line comment\\nThis is another line of the comment.\\nHere is another one. '"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\" This is multi-line comment\n",
    "This is another line of the comment.\n",
    "Here is another one. \"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VYcE9saNnaZf"
   },
   "source": [
    "# Python Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FqkIPvgtJTqn"
   },
   "source": [
    "Variables are containers that hold data values. Please look at the examples of variables below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "1LQlSHDvJm9N"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 2\n",
      "X = 5\n"
     ]
    }
   ],
   "source": [
    "# examples of variables\n",
    "x = 2 # the variable x holds the value 2\n",
    "\n",
    "# variables are case-sensitive (i.e. variables x and X are different)\n",
    "X = 5 # this variable X is different from x above\n",
    "\n",
    "# You will see that the values of x and X are different\n",
    "print('x =', x)\n",
    "print('X =', X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "BbU0je9nK350",
    "outputId": "e14ddb2e-56e7-487e-ff18-75274813699a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "language:  Python\n",
      "name: John\n"
     ]
    }
   ],
   "source": [
    "# variables can hold string values (text) as well. String needs to be enclosed inside a pair of single or double quotes. \n",
    "language = 'Python'  # string inside single quotes\n",
    "name = \"John\" # string inside double quotes\n",
    "\n",
    "# when you print variables, the values that they hold gets printed\n",
    "print('language: ', language)\n",
    "print('name:', name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BQcbb9xXK2qX"
   },
   "source": [
    "**Rules for variable names**\n",
    "\n",
    "* Variable name should start with either a letter or an underscore. Example: `age` and `_age` are valid variable names.\n",
    "*   Variable name can not start with a number. For example, `7name` is not valid. However, number can be included after the first character. For example, `name7` or `n7ame` are valid.\n",
    "*   Variable name can only contain alpha-numeric ( [a-z], [A-Z], [0,9] ) or underscore ( _ ) characters\n",
    "* Variable names are case-sensitive. Example: `address`, `Address`, `aDdress` are different variables.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "FxXQzSROQQ1n"
   },
   "outputs": [],
   "source": [
    "# the code below will show an error when you run it\n",
    "name = \"Harry\" # variable name cannot start with a number, so you will get an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "YoXTczUCQtEi"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_age: 25\n",
      "name7: Sarah\n",
      "n7ame: Johnson\n",
      "country: Nepal\n",
      "Country: USA\n"
     ]
    }
   ],
   "source": [
    "# the following variable names are valid\n",
    "_age = 25\n",
    "name7 = \"Sarah\" # number can be anywhere after the first character\n",
    "n7ame = 'Johnson' # number can be anywhere after the first character\n",
    "\n",
    "# variable names are case-sensitive. So the following two variables are different although they have the same spelling.\n",
    "country = \"Nepal\" \n",
    "Country = \"USA\"\n",
    "\n",
    "# print the variables\n",
    "print(\"_age:\", _age)\n",
    "print(\"name7:\", name7)\n",
    "print(\"n7ame:\", n7ame)\n",
    "print(\"country:\", country)\n",
    "print(\"Country:\", Country)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xTq1qXQ2Sn2U"
   },
   "source": [
    "**Exercise 2.1**\n",
    "Create variables named 'name' and 'age' and assign your name and age respectively. Then print the variables. Also, put appropriate comments in your code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "irzq_nZZTIFu"
   },
   "outputs": [],
   "source": [
    "# create a variable 'name' and assign your name to it\n",
    "\n",
    "# create a variable 'age' and assign your age to it\n",
    "\n",
    "# print the above two variables\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qLB1omf9nbDG"
   },
   "source": [
    "## Python Data Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uB3yHKd6MPF5"
   },
   "source": [
    "Variables can hold different types of data.\n",
    "\n",
    "Python has the following data types.\n",
    "* Text (String): \t`str`\n",
    "* Numeric (Numbers): \t`int`, `float`, `complex`\n",
    "* Sequence: \t`list`, `tuple`, `range`\n",
    "* Mapping: \t`dict`\n",
    "* Set: \t`set`, `frozenset`\n",
    "* Boolean (True/False): \t`bool`\n",
    "* Binary (ones/zeros): \t`bytes`, `bytearray`, `memoryview`\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uV5idgUgOfxN"
   },
   "source": [
    "Examples of commonly used data types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "EZzlHbLYOfOy"
   },
   "outputs": [],
   "source": [
    "name = \"Sam\" # str type (string)\n",
    "age = 25 # int type (integer)\n",
    "height = 2.45 # float type (floating point)\n",
    "fruits = [\"Apple\", \"Banana\", \"Pear\"] # list type (use square brackets)\n",
    "countries = {\"China\", \"India\", \"Nepal\"} # set type (use curly braces)\n",
    "colors = (\"red\", \"green\", \"blue\") # tuple type (use parentheses)\n",
    "x = range(5) # range type\n",
    "my_info = {name: \"Sam\", age: 25} # dict type (key:value pairs inside a pair of curly braces)\n",
    "is_ok = True # boolean type (either True or False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "baFkIyjJYQdD"
   },
   "source": [
    "You can use type() to show the type of the variable as shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "e4taLMEbYOoU",
    "outputId": "dea69f9a-4d33-47bc-ceca-c89cac09ae91"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type of name variable: <class 'str'>\n",
      "Type of my_info variable: <class 'dict'>\n",
      "Type of is_ok variable: <class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "print(\"Type of name variable:\",type(name))\n",
    "print(\"Type of my_info variable:\",type(my_info))\n",
    "print(\"Type of is_ok variable:\",type(is_ok))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "knSDHWyiSkwF"
   },
   "source": [
    "##Python Type casting\n",
    "You can create a variable of particular type, or convert one type to another type, by something called casting. Here are some examples.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Bijaow6MQda4",
    "outputId": "7fa48ee0-5e0a-4791-b2cf-0784ef507f4a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type of int_var_auto <class 'int'>\n",
      "Type of str_var_auto <class 'str'>\n",
      "Type of float_var_auto <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "int_var = int(2.53) # int_var will contain the value int value 2 (numbers after the decimal are discarded)\n",
    "str_var = str(45) # str_var will contain the value \"45\" in string form\n",
    "float_var = float(\"3.14\") # float_var will contain the value 3.14 in floating point format\n",
    "\n",
    "# you can simply assign the values to the variables and the type is automatically inferred\n",
    "int_var_auto = 4\n",
    "str_var_auto = \"hello\"\n",
    "float_var_auto = 3.14\n",
    "\n",
    "print(\"Type of int_var_auto\", type(int_var_auto))\n",
    "print(\"Type of str_var_auto\", type(str_var_auto))\n",
    "print(\"Type of float_var_auto\", type(float_var_auto))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "NG8VzehTQsqU",
    "outputId": "a5c901d3-4d41-4917-a772-d86d4c1b5a9e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "# let's convert int_var to float type\n",
    "int_var_convert_float = float(int_var)\n",
    "print(int_var_convert_float)\n",
    "print(type(int_var_convert_float))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5NoGGEt4avoK"
   },
   "source": [
    "## Exercise 2.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kQr790sja-5U"
   },
   "source": [
    "Create a variable of type `int` and convert it to `float` and `str` type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "qnIYaHPRaGlJ"
   },
   "outputs": [],
   "source": [
    "# write code below to create a variable of type int\n",
    "\n",
    "# write code below to convert the above int variable to float\n",
    "\n",
    "# write code below to convert the int variable you created above to str type"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Va-dhO_8c7aR"
   },
   "source": [
    "# Python Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "12K8En9ChRTi"
   },
   "source": [
    "Operators are symbols that help perform operations between values and variables. Python has the following groups of operators.\n",
    "\n",
    "  * Arithmetic operators\n",
    "  * Assignment operators\n",
    "  *  Comparison operators\n",
    "  *  Logical operators\n",
    "  * Identity operators\n",
    "  * Membership operators\n",
    "  * Bitwise operators\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5hCBJqnCiBVb"
   },
   "source": [
    "## Arithmetic Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "G78zd3xUiYtY",
    "outputId": "3c4fa5ad-4a3b-4b0a-cec3-9ef0117bb1f1"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Addition (+)\n",
    "2 + 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "RdhQj-J3iqup",
    "outputId": "c659194f-6a64-4627-b525-ddd15f8b2eac"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-2"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Subtraction (-)\n",
    "4 - 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "t24dLaOxi6bQ",
    "outputId": "d42cd7c5-a876-4419-eb1b-7c513d7c64d6"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "28"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Multiplication ( * symbol is used for multiplication)\n",
    "4 * 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Nl-a64ALjAX2",
    "outputId": "1d76b10c-d4b2-46ae-c1ca-0ee0440d93fc"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.75"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Division ( / symbol is used for division)\n",
    "3 / 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "NkXZiudojPWr",
    "outputId": "ed6c3df0-162b-4628-e658-9d9f0abbc40e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Modulus ( % )\n",
    "4 % 3 # ( % yields the remainder of the division); Here the result is 1, which is the remainder when 4 is divided by 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "w1RIKbDEj-1z",
    "outputId": "c214974b-20a1-47be-d2b1-b2a9c163e667"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Exponentiation ( ** ) or power\n",
    "2 ** 3 # the result is 8 since 2 to the power of 3 is 2x2x2 = 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "fhuiqGyLkOmy",
    "outputId": "ce197c23-2f7a-41ff-c1ee-81f956cc1a0b"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Floor division ( // )\n",
    "5 // 3 # the result is 1, since 5/3 = 1.66... and only the number before the decimal is returned as the result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QgoryHQLmZ3_"
   },
   "source": [
    "## Exercise 3.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Bahs9Wv8mf8P"
   },
   "source": [
    "Write the following expressions in Python code.\n",
    "* x = 7(3+8-4)/6\n",
    "* y = int(x) modulus 2\n",
    "* z = y to the power of 3\n",
    "* k = z floor divided by 3\n",
    "\n",
    "Replace 'None' with your code in the following exercises."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "id": "om3RnxsJnyUJ"
   },
   "outputs": [],
   "source": [
    "# write code below for x = 7(3+8-4)/6. Hint: 3(m + n) in Python code is 3*(m+n)  RESULT should be: 8.166666666666666\n",
    "x = None\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "id": "M8BnHg5LoAhg"
   },
   "outputs": [],
   "source": [
    "# write code below for y = int(x) modulus 2 , RESULT should be: 2\n",
    "y = None\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "id": "k59zeK8_oCzj"
   },
   "outputs": [],
   "source": [
    "# write code below for z = y to the power of 3, RESULT should be: 8\n",
    "z = None\n",
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "id": "1RKe5-ZUoFbH"
   },
   "outputs": [],
   "source": [
    "# write code below for z floor divided by 3, RESULT should be: 2 \n",
    "k = None\n",
    "k"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "f4WrokJWnqHi"
   },
   "source": [
    "## Assignment Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "FyIznpWinxRw",
    "outputId": "9a7dc0d4-6772-41e2-d379-e21d4fbb7a25"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# = operator assigns the value on the right hand side to the variable on the left hand side\n",
    "x = 5\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "i1Biby70oDR1",
    "outputId": "e69c4407-2db3-4100-c85e-85e832713d2a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# += \n",
    "x += 3 # same as x = x + 3 # RESULT should be 8\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "GY3g8aRcoj8P",
    "outputId": "d35ca343-740c-479a-8c75-2f830ab100e1"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# -=\n",
    "x -= 3 # same as x = x - 3 # RESULT should be 5\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "wCZVHtWCo_2d",
    "outputId": "69f6ca80-d677-42ca-a771-a93eceea7d1f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# *=\n",
    "x *= 3 # same as x = x * 3 # RESULT should be 15\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "i26r9B5SpTog",
    "outputId": "a93850a2-8983-4146-ff7e-ba1a2a6090dc"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# /=\n",
    "x /= 3 # same as x = x / 3 # RESULT should be 5.0\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "6V3hokBApb86",
    "outputId": "b1eaac38-436a-48c1-eb9c-72b968aeac81"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# %=\n",
    "x %= 3 # same as x = x % 3 # RESULT should be 2.0\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "OoBSJkJuprrX",
    "outputId": "d2b31877-d7df-4390-e2bc-7dc8d2f0848d"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# //=\n",
    "x = 8\n",
    "x //= 3 # same as x = x - 3 # RESULT should be 2\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "sHFMWtVep3Nx",
    "outputId": "08ebe3d0-cbe8-43e5-e345-ecba6ac11ca8"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# **=\n",
    "x **= 3 # same as x = x ** 3 # RESULT should be 8\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "haVhMqhbqsGB"
   },
   "source": [
    "## Comparison Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9mvKsM3crU90"
   },
   "source": [
    "Comparison operators produce a result as boolean (True/False) values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "AlmJ77OGqSHz",
    "outputId": "8855786d-0a18-4509-db83-3fe45213d0bd"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# == (Equal to)\n",
    "2 == 3 # False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "D1DVerh7rkdX",
    "outputId": "902647d9-4d6f-49ef-c661-fc543a610166"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# != (Not equal to)\n",
    "2 != 3 # True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "_GA8NsQnr9rt",
    "outputId": "6d28521c-8840-4bc1-f147-2cf5bb0e4f9b"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# > (Greater than)\n",
    "2 > 3 # False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "7raNOibcsE7T",
    "outputId": "fc415345-9c73-446d-9ef7-8f3391618aaa"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# < (Less than)\n",
    "2 < 3 # True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "1k7PUVXusLeb",
    "outputId": "0f346ab7-89ec-47b6-b7c7-3a817a939a23"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# >= (Greater than or equal to)\n",
    "2 >= 3 # False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "vX6uQI12stFc",
    "outputId": "721b6ba1-3f2e-4195-fdd7-8cf3d67d34c4"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# <= (Less than or equal to)\n",
    "2 <= 2 # True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jRXlmsfbtbjp"
   },
   "source": [
    "Rest of the operators will be introduced after some concepts (e.g. List, Object etc.) related to them are introduced."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "x9Ev4znPpZQQ"
   },
   "source": [
    "## Logical Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "h5yzF0TtploE"
   },
   "source": [
    "In Python, Logical operators are used on conditional statements (either `True` or `False`). \n",
    "\n",
    "They perform \n",
    "* Logical AND, \n",
    "* Logical OR, and \n",
    "* Logical NOT \n",
    "\n",
    "operations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "iVHiyb2FqHQC"
   },
   "source": [
    "\n",
    "* `and`\t=> (Logical AND): `True` if both the operands are true => example:\t`x and y`\n",
    "* `or` =>\t(Logical OR): `True` if either of the operands is true => example:\t`x or y`\n",
    "* `not` => (Logical NOT): `True` if operand is false => example:\t`not x`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "id": "XwQBJHm_rF00"
   },
   "outputs": [],
   "source": [
    "a = 2\n",
    "b = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "-N9c2QrBrOEB",
    "outputId": "a8bd308c-3519-458a-be89-84e3426de895"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a > 2 and b > 2 # False and True = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "-qGauv-grash",
    "outputId": "83072508-5c9a-489f-8d4f-e9f9154a895c"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a > 1 and b > 2 # True and True = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ozCsZMiwrpKd",
    "outputId": "bcf5d203-f518-4553-b027-2c16f5368027"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a < 1 or b > 1 # False or True = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Jn1Hq72-r3Ub",
    "outputId": "72c7507f-208a-405b-a98d-3e8e0657bece"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a < 1 or b < 3 # False or False = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "b6JZ5du3sHyV",
    "outputId": "f162ce7d-e402-4fb2-f046-e10fd2204b1b"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not a > 1 # not True = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "8bNxmnrysPMq",
    "outputId": "567750de-d395-4f84-c1db-4e9f576578b2"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not b < 3 # not False = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ETcvggcps-VJ"
   },
   "source": [
    "## Identity Operators\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dhW6AKT8tCev"
   },
   "source": [
    "The identity operators in Python are used to determine whether a value is of a certain class or type. \n",
    "\n",
    "They are usually used to determine the type of data a certain variable contains. For example, you can combine the identity operators with the built-in type() function to ensure that you are working with the specific variable type.\n",
    "\n",
    "Two identity operators are available in Python:\n",
    "\n",
    "   * `is` – returns `True` if the type of the value in the right operand points to the same type in the left operand. \n",
    "   \n",
    "   For example, `type(3) is int` evaluates to `True` because `3` is indeed an integer number.\n",
    "   * `is not` – returns `True` if the type of the value in the right operand points to a different type than the value in the left operand. \n",
    "   \n",
    "   For example, `type(3) is not float` evaluates to `True` because `3` is not a floating-point value.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "WC-mU86jt3yI",
    "outputId": "ff12ba8d-5124-444f-899e-c83f87f34e29"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 3\n",
    "\n",
    "type(x) is int # type of x is indeed int, so we get True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "WPBu-x06uGsb",
    "outputId": "41869576-a94d-4cc3-d9a4-a75fb747c0f2"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x) is float # type of x is not float, so we get False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "EiOUj1M1uiWw",
    "outputId": "3b8ca26a-7937-4062-b0df-0ea10b4bbeb7"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x) is not str # type of x is not str, so we get True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "u3Z6HBsAu4rY"
   },
   "source": [
    "## Membership Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wRxxtrGsu8_l"
   },
   "source": [
    "Membership operators are used to test if a sequence is present in an object.\n",
    "\n",
    "The two membership operators in Python are:\n",
    "* `in`\n",
    "* `not in`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "tzFxMZ_T2Hl0",
    "outputId": "e7c4e6c9-53eb-4a74-96d0-86bc9a112e0e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'h' in 'hello' # 'h' is in 'hello', so we get True "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "gI9mmHbu2YDf",
    "outputId": "00f630e7-ada8-4ec7-cc63-536d72e6b22e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'ell' in 'hello' # 'ello' is in 'hello', so we get True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "n0A1RgcT2bot",
    "outputId": "bafdaa92-3f69-4f2b-c369-00b94c052674"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'m' in 'python' # 'm' is not in 'python', so we get False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qQKC4Ycu20hi"
   },
   "source": [
    "## Bitwise Operators\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4q5glSro25Cv"
   },
   "source": [
    "In Python, bitwise operators are used to performing bitwise calculations on integers. The integers are first converted into binary and then operations are performed on bit by bit, hence the name bitwise operators. Then the result is returned in decimal format.\n",
    "\n",
    "*Note: Python bitwise operators work only on integers.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "qeiA2okg4QYT",
    "outputId": "95563ca3-bf8e-485d-a1cb-1de7aa76dc2f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Bitwise and (&)\n",
    "2 & 3 \n",
    "# 2 = 10 in binary\n",
    "# 3 = 11 in binary\n",
    "# 2 & 3 = 10 & 11 = 10 => 2 in decimal "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "IY4MkCpI4yZC",
    "outputId": "3db10026-c540-442f-addb-b3334c4f3869"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Bitwise or (|)\n",
    "2 | 3 \n",
    "# 2 = 10 in binary\n",
    "# 3 = 11 in binary\n",
    "# 2 | 3 = 10 | 11 = 11 => 3 in decimal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "zvxn6Y9QDpTN",
    "outputId": "d5b42cfc-b177-4cd7-d170-d23d223fc464"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Bitwise xor\n",
    "6 ^ 5\n",
    "# 6 = 110\n",
    "# 5 = 101\n",
    "# 110 ^ 101 = 011 = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mZUPcmiBAoYU"
   },
   "source": [
    "# **Python List**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Ah2LMJSzA0Et"
   },
   "source": [
    "So far we saw that a variable could store only one value. We can store multiple values in a variable. List helps us do that."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ZVcMmzujs2YL",
    "outputId": "5df59fb5-fad8-4558-9245-fc61bb7425de"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# List is enclosed in square brackets\n",
    "days_of_week = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']\n",
    "days_of_week"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mQ3dzDmTBwJ0"
   },
   "source": [
    "You can find the number of items in the list using len()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "4nLUL_AGBZ5V",
    "outputId": "215184a1-e4cb-4b31-d8ff-f7b5083bb789"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# number of items in the list\n",
    "len(days_of_week)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6UFKv_L3CI9I"
   },
   "source": [
    "The items in the list can be of any data type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "WoueIfQeB-Lv",
    "outputId": "8baedf02-5619-497d-ed27-a6be8590f939"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3.0, 'Hello', True]"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = [1, 3.0, 'Hello', True]\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Xk9Nyf1kCm08"
   },
   "source": [
    "## Access List items"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bR4D2aR8CuDx"
   },
   "source": [
    "List is an ordered collection of items, i.e. each item has an index (position number) associated with it. The index always starts with zero.<br>\n",
    "So, the first item in the list has index 0, second item has index 1 and so on.<br>\n",
    "You can access any item in the list by its index, as shown in the example below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ptnjBrwSDnJ4",
    "outputId": "292ace7e-e365-4375-abf2-def3351ce0eb"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sunday\n",
      "Wednesday\n"
     ]
    }
   ],
   "source": [
    "# Let's access the first item in the list. Index 0.\n",
    "print(days_of_week[0])\n",
    "# fourth item in the list. Index 3\n",
    "print(days_of_week[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "K9kHL77REJKB"
   },
   "source": [
    "**Negative indexing**<br>\n",
    "You can use negative index to access items from the end of the list. The last item in the list has the index -1, second last -2 and so on. Please see the examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "C378N6JUDqPu",
    "outputId": "9a54dabf-7886-4bae-d4c4-89164b4a927a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saturday\n",
      "Thursday\n"
     ]
    }
   ],
   "source": [
    "# last item in the list. Index -1\n",
    "print(days_of_week[-1])\n",
    "# third last item in the list, Index -3\n",
    "print(days_of_week[-3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WqmfGLW8Fzf1"
   },
   "source": [
    "**Range of indexes**<br>\n",
    "You can select more than one contiguous items in the list as a range (start_index : end_index+1). Examples shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "X-smB6KxFPh0",
    "outputId": "fd14e6b6-a172-4019-e138-b73615ba1925"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Monday', 'Tuesday', 'Wednesday']\n",
      "['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']\n"
     ]
    }
   ],
   "source": [
    "days_of_week_0_3 = days_of_week[1:4] # returns a new list with the range of items selected\n",
    "print(days_of_week_0_3) # items with indexes 1, 2, 3 will be printed. Remember the end index 4 is not printed.\n",
    "print(days_of_week) # the original list is unchanged"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "r9luEEudIjqa"
   },
   "source": [
    "If you leave out the start index, the start index will start from 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "dpPwj33JFzBt",
    "outputId": "235e53ca-7790-4d92-f4a9-41ba4ca5b395"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Sunday', 'Monday', 'Tuesday']"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "days_of_week[:3] # indexes 0, 1, 2 will be selected"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6yTkb1oCI_TE"
   },
   "source": [
    "If you leave out the end index, all the items from the start index to the end of the list is selected."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "blZoKSfbI4n_",
    "outputId": "71991428-f7a5-4bd6-8c0d-386a58848eb1"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Friday', 'Saturday']"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "days_of_week[5:] # items 5, 6 will be selected"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qnkGDRpwJ_4z"
   },
   "source": [
    "You can use `in` operator to check if an item is present in the list. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "GAgkL6DVJQD3",
    "outputId": "e29f5f9c-f83c-4b03-d24c-1d019a75bf86"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Saturday' in days_of_week"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "kKd6gGaEJ5um",
    "outputId": "883f411f-e140-4973-a9e4-c10a66e8e3df"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Someday' in days_of_week"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Eee_KHK0D7Z0"
   },
   "source": [
    "## Change List items"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nRgLjEiMENbw"
   },
   "source": [
    "**Change item value**<br>\n",
    "If you assign a value to the list at the item number, you replace the old value with the new one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Eo-ZI7bAEVOF",
    "outputId": "df2cceb1-a32b-4f9b-c958-e44ac51b011a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Sunday', 'Mon', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "days_of_week[1] = \"Mon\"\n",
    "days_of_week"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BEw7AI12FfS_"
   },
   "source": [
    "**Change a range of item values**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "EntIqVUzE6TU",
    "outputId": "5c09b3eb-67b2-421b-fe16-c52f2970774b"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Sunday', 'Mon', 'Tue', 'Wed', 'Thursday', 'Friday', 'Saturday']"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "days_of_week[2:4] = [\"Tue\", \"Wed\"]\n",
    "days_of_week"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aL8gi2JSF615"
   },
   "source": [
    "If you assign more values than idexes specified in the range, the extra values will be inserted and the rest of the original values get pushed to the right."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "XNTEPhxhFw0K",
    "outputId": "438837b9-a508-42fa-fc7c-4e609ea7a354"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Sunday', 'Mon', 'Tue', 'Wed', 'Thursday', 'Fri', 'Sat', 'Saturday']\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "days_of_week[5:6] = [\"Fri\", \"Sat\"]\n",
    "print(days_of_week) \n",
    "print(len(days_of_week)) # note that the size of the list expanded ()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tmrU8EJeHc4l"
   },
   "source": [
    "If you assign less values than the indexes specified in the range, the original values in the indexes not provided values to be replaced for will be deleted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "83qEeahnGch-",
    "outputId": "6e18851b-2607-430b-b4db-5dfec5b00b2a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Sunday', 'Mondi', 'Wed', 'Thursday', 'Fri', 'Sat', 'Saturday']"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "days_of_week[1:3] = [\"Mondi\"] # indexes given: 1, 2; values given \"Mondi\", which goes at index 1 and original \n",
    "                              # value at index 2 (\"Tue\") is deleted. \n",
    "days_of_week"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5jB_Nb8ZIoHv"
   },
   "source": [
    "**Insert items**<br>\n",
    "If you want to insert items without replacing original items, you need to use insert()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "RjjLpjc2HWZu",
    "outputId": "079cd8cd-5490-4bb5-a9ae-1c4887a4d00e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 'inserted', 2, 3]"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = [1,2,3]\n",
    "my_list.insert(1, \"inserted\")\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "M39g66JxJ1nR"
   },
   "source": [
    "## Add List items"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "y3WoG86aKTP2"
   },
   "source": [
    "To add items to the end of the list, use the append() method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ccuTQieaJUWQ",
    "outputId": "8847a799-c756-4bb3-8875-2888a7bf3b70"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = [1,2,3]\n",
    "my_list.append(4)\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Xwka2Q8VLJYb"
   },
   "source": [
    "To add items from another list, use extend() method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "hSlDhpDwKo1d",
    "outputId": "4f46880c-cf5f-49c4-cc7b-8621cf674f99"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 100, 200]"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_to_add = [100, 200]\n",
    "my_list.extend(list_to_add)\n",
    "my_list # the added items are added to the end of the list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3Tb2N-_mYuzr"
   },
   "source": [
    "## Remove List items"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QzHklMRyY7n8"
   },
   "source": [
    "The remove() method removes the specified item provided as argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "i29pFTZpKwUB",
    "outputId": "95f2ef1c-4002-45fe-f160-39bcf4760cbe"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['One', 'Three']"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = [\"One\", \"Two\", \"Three\"]\n",
    "my_list.remove(\"Two\")\n",
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "1GwoFHUbZax8",
    "outputId": "c879b665-19f1-4d37-97d9-011483c10d0e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 4, 2, 3]\n",
      "[1, 3, 4, 3]\n"
     ]
    }
   ],
   "source": [
    "# if there are duplicates of the item to be removed only the first one of the items will be removed\n",
    "my_list = [1,2,3,4,2,3]\n",
    "my_list.remove(2)\n",
    "print(my_list)\n",
    "my_list.remove(2)\n",
    "print(my_list)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "i9VMYl43aTaQ"
   },
   "source": [
    "**Remove item at a specified index**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KFOAYsvtajYd"
   },
   "source": [
    "You can use `pop()` method to remove an item at a specified index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "vx1WF7yoaCHY",
    "outputId": "32e84d25-9ecb-4d19-90f6-41543be8c219"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3]"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = [1,2,3]\n",
    "my_list.pop(1)\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_A00FwIla5MT"
   },
   "source": [
    "If you do not give any argument to `pop()`, the last item in the list will be removed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Om8G8UjlbEcO",
    "outputId": "70b09eee-ade7-4861-858b-6c4d848c10be"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = [1,2,3,4]\n",
    "my_list.pop()\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8ae1ptx-bXcl"
   },
   "source": [
    "`del` keyword can also be used to remove an item at a specified index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "RSPZ0UYZbQ3h",
    "outputId": "93595190-d1da-4405-c742-29eb999dd537"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3]"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = [1, 2, 3]\n",
    "del my_list[0]\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Kl5QvS-Wb5wr"
   },
   "source": [
    "`del` keyword can be used to delete the list itself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 207
    },
    "id": "U1TMH1rncBHA",
    "outputId": "78c36ad0-99db-4428-9169-8b7b0c9946c8"
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'num_list' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32mc:\\Users\\ASUS\\Desktop\\Python Basics\\Python_Fundamentals_Course_Notes_v2.ipynb Cell 144'\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/ASUS/Desktop/Python%20Basics/Python_Fundamentals_Course_Notes_v2.ipynb#ch0000143?line=0'>1</a>\u001b[0m num_list \u001b[39m=\u001b[39m [\u001b[39m1\u001b[39m,\u001b[39m2\u001b[39m,\u001b[39m3\u001b[39m]\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/ASUS/Desktop/Python%20Basics/Python_Fundamentals_Course_Notes_v2.ipynb#ch0000143?line=1'>2</a>\u001b[0m \u001b[39mdel\u001b[39;00m num_list\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/ASUS/Desktop/Python%20Basics/Python_Fundamentals_Course_Notes_v2.ipynb#ch0000143?line=2'>3</a>\u001b[0m num_list\n",
      "\u001b[1;31mNameError\u001b[0m: name 'num_list' is not defined"
     ]
    }
   ],
   "source": [
    "num_list = [1,2,3]\n",
    "del num_list\n",
    "num_list "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "miW9iHCicOL0"
   },
   "source": [
    "**Clear the list**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "czYUrU4DcvzQ"
   },
   "source": [
    "If you want to remove all the list items, you can use `clear()` method. **Think about the difference between del and clear()**. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ngNRZkkucIMy",
    "outputId": "a5a05fa4-014d-443c-b350-c29bd561b3d7"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = [5,6,7]\n",
    "my_list.clear()\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IF8eTWVJdLiw"
   },
   "source": [
    "## Sort List"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3pUE6EY2dR2l"
   },
   "source": [
    "You can sort a list alphanumerically using the `sort()` method. The default is ascending order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "M8NelpEJddO1",
    "outputId": "1a6270b0-832a-4eb6-8cfe-ab0c7ab2a936"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Apr', 'Feb', 'Jan', 'Mar']"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "months_list = [\"Jan\", \"Feb\", \"Mar\", \"Apr\"]\n",
    "months_list.sort()\n",
    "months_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "k6P0ZXVBd7hE",
    "outputId": "4dc23efd-7983-4edc-df2d-e87035e0426d"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1970, 1986, 1999, 2021]"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "years_list = [1999, 1986, 2021, 1970]\n",
    "years_list.sort()\n",
    "years_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8oCQjfZ-eQ41"
   },
   "source": [
    "For sorting by descending order, provide `reverse = True` argument to `sort()` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "-Z0UxNyUeKlb",
    "outputId": "76c95c9d-6dc8-440b-e9d0-02c7d066eb87"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[100, 15, 10, 5, 3, -1]"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num_list = [5,3,10, 15, -1, 100]\n",
    "num_list.sort(reverse=True)\n",
    "num_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JjUI7Hhte73N"
   },
   "source": [
    "The `sort()` method case-sensitive by default. Capital letters are sorted before small letters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "jy0XkllXewlt",
    "outputId": "745ccbce-b030-41bb-c3e3-f57ff2fb6dfa"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Kathmandu', 'Lahore', 'chicago', 'london', 'new york']"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cities_list = [\"Kathmandu\", \"london\", \"chicago\", \"new york\", \"Lahore\"]\n",
    "cities_list.sort()\n",
    "cities_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7QnbzRjBf0Ep"
   },
   "source": [
    "If you want case-insensitive sort, provide the argument `key = str.lower` to `sort()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "6Mk3KeLSfdP3",
    "outputId": "17079421-9a44-4e25-8188-a7e08c977027"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['chicago', 'Kathmandu', 'Lahore', 'london', 'new york']"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cities_list = [\"Kathmandu\", \"london\", \"chicago\", \"new york\", \"Lahore\"]\n",
    "cities_list.sort(key = str.lower)\n",
    "cities_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VZ0N2uyGg39B"
   },
   "source": [
    "**Reverse order**<br>\n",
    "You can use the reverse() method to reverse the order of items in the list. No sorting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "NhhF3HyTgNF7",
    "outputId": "0e0e741d-c945-47e6-fd4f-7fe9f87b30e2"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 1, 4, 3]"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = [3,4,1,5]\n",
    "my_list.reverse()\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qqCg0QpDhiuw"
   },
   "source": [
    "## Make a copy of a list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "shg7gs0thtPV"
   },
   "source": [
    "You can use `copy()` method to make a copy of a list. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "tUZwkte4hXBH",
    "outputId": "75fb8947-bab2-4dea-d1d9-6e5634caf2f9"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 'hello']"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_1 = [1,2,3,\"hello\"]\n",
    "copy_of_list1 = list_1.copy()\n",
    "copy_of_list1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aK37jlyQid7_"
   },
   "source": [
    "You can also copy a list using `list()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "pVt--Cb8iQgj",
    "outputId": "b667ab9d-a521-40d3-d2e7-ebb50efb6090"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 4, 5]"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = [3,4,5]\n",
    "my_list_copy = list(my_list)\n",
    "my_list_copy "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CNA0zxqkjE2j"
   },
   "source": [
    "## Join lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uzlig9N5jK5j"
   },
   "source": [
    "You can join two lists by simply using the `+` operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "MQoX0KoLjduC",
    "outputId": "83231928-2ce7-4bc1-96fc-c51aa9e76884"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 'hi', 'there']\n",
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "list_1 = [1,2,3]\n",
    "list_2 = [\"hi\", \"there\"]\n",
    "list_12 = list_1 + list_2\n",
    "print(list_12)\n",
    "print(list_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QigJ-oXuju3Y"
   },
   "source": [
    "You can also use the `extend()` method to add list_2 to at the end of list_1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "6yNFnB7ujmuT",
    "outputId": "364bd42f-4427-4289-9edb-163e3b70e2bd"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 'hi', 'there']"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_1 = [1,2,3]\n",
    "list_2 = [\"hi\", \"there\"]\n",
    "list_1.extend(list_2)\n",
    "list_1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "r_3eniQIkRcS"
   },
   "source": [
    "**Think about the difference between using the + operator and using the `extend()` method.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yi2oSKhQcDRs"
   },
   "source": [
    "# Python Conditionals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uv4yUnp0gp1E"
   },
   "source": [
    "## if Statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bOzA5RBDckuG"
   },
   "source": [
    "\n",
    "If you want some python code to run only if some condition is true, you can use the `if` keyword. <br>\n",
    "The format of the code is as follows:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "id": "OjD-eIjVj_in"
   },
   "outputs": [],
   "source": [
    "# if <some condtion>:\n",
    "#      code to run only if the condition is true"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "yBzuTSRifA2J",
    "outputId": "aee230e6-8262-4ae3-ae5f-e3b533fbc8ec"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is greater than 5\n"
     ]
    }
   ],
   "source": [
    "# example:\n",
    "x = 7\n",
    "if x > 5:\n",
    "  print(\"x is greater than 5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pwaQRu9_gKJv"
   },
   "source": [
    "In the example above, `x > 5` is the condition, which evaluates to either `True` or `False`. You can use any of the comparison operators we learned earlier, in the condition.\n",
    "\n",
    "Please notice the blank spaces (also called white spaces) before the start of the code right after the `if` statement. Those whitespaces are called **indentation**. \n",
    "\n",
    "**Please keep in mind that you need to indent the line or lines that you want to be part of the `if` statement. The indentation for all the lines in the `if` code block needs to be the same.**\n",
    "\n",
    "Indentation defines the scope of the `if` block. Scope will be covered in detail in the Advanced part of this course."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "id": "ULzh8B7XfR5s"
   },
   "outputs": [],
   "source": [
    "x = 10\n",
    "if x > 10:\n",
    "  print('x is greater than 10')\n",
    "  print('Nothing will get printed if the condition is not True')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lF34E47hkLQ-"
   },
   "source": [
    "## elif keyword"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rBhvgeelkaMl"
   },
   "source": [
    "You can use `elif` with another condition, if the `if` condition before it failed, to see if the new condition passes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "oF0Fa3stfrWK",
    "outputId": "d8eadec5-fa6a-4b14-9473-cfb14dccc8ef"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is greater than 1\n"
     ]
    }
   ],
   "source": [
    "x = 2 # also try with values x = 6, 4, 2\n",
    "\n",
    "if x > 5:\n",
    "  print('x is greater than 5')\n",
    "elif x > 3:\n",
    "  print('x is greater than 3')\n",
    "elif x > 1:\n",
    "  print('x is greater than 1')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mwameaUImg_f"
   },
   "source": [
    "## else keyword"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Lm6OQw5MmpGU"
   },
   "source": [
    "The `else` keyword catches anything not caught by the previous `if` and `elif` statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "NKghQagvmCHb",
    "outputId": "31bb74aa-c239-4530-a31e-7d0dd1f42ab8"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is less than or equal to 1\n"
     ]
    }
   ],
   "source": [
    "# The same code as above with the else keyword at the end\n",
    "x = 1 # also try with values x = 6, 4, 2, 1\n",
    "\n",
    "if x > 5:\n",
    "  print('x is greater than 5')\n",
    "elif x > 3:\n",
    "  print('x is greater than 3')\n",
    "elif x > 1:\n",
    "  print('x is greater than 1')\n",
    "else:\n",
    "  print(\"x is less than or equal to 1\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nZAF0CMVntTt"
   },
   "source": [
    "## Short-hand if"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "S22_pqQSnzTk"
   },
   "source": [
    "You can put the `if` code block in one line as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "dS5rsPzmoA-O",
    "outputId": "c45abf0f-564b-4584-bc87-286824ae0ad8"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is equal to 3\n"
     ]
    }
   ],
   "source": [
    "x = 3\n",
    "if x == 3: print(\"x is equal to 3\")  # if code block in one line"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9Wd4KYfhonH_"
   },
   "source": [
    "## Short-hand if - elif"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hJjKvZ2bous_"
   },
   "source": [
    "You can put `if - else` code block in one line as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "_JD457P6oPVr",
    "outputId": "71b4b89d-1fd5-4024-afd8-f71b307b9ff3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is equal to 2\n"
     ]
    }
   ],
   "source": [
    "x = 2 # also try with x = 3\n",
    "print(\"x is equal to 2\") if x == 2 else print(\"x is not equal to 2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "U4slNMObqI9N"
   },
   "source": [
    "## Nested if"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cO0cdRJ2qRJw"
   },
   "source": [
    "You can put `if` statements inside `if` statements, which are called nested `if` statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "gcw9HkmXqsK3",
    "outputId": "5a56eefd-47ce-4937-af75-c7c6913a4d6c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is greater than 10\n",
      "and it is greater than 30 as well\n"
     ]
    }
   ],
   "source": [
    "x  = 35 # try with x = 20, 35\n",
    "if x > 10:\n",
    "  print(\"x is greater than 10\")\n",
    "  if x < 30:\n",
    "    print(\"but it is less than 30\")\n",
    "  else:\n",
    "    print(\"and it is greater than 30 as well\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ASTb5z9EiWoM"
   },
   "source": [
    "#Python loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9XmP8wz-inSZ"
   },
   "source": [
    "Python has two loop commands:\n",
    "\n",
    "\n",
    "*   while\n",
    "*   for\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "MN7wLcp7l25U"
   },
   "source": [
    "## while loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cV_548BOl7-x"
   },
   "source": [
    "In a `while` loop, the loop runs as long as the condition is true."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "dDChueP9mI7O",
    "outputId": "868ae50d-b092-4c86-c1ee-bfaac4dfcaff"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "while x < 5:\n",
    "  print(x) \n",
    "  x += 1 # DO NOT FORGET to increment x, otherwise the loop will run forever (infinite loop)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LBiRNEtDm_27"
   },
   "source": [
    "### break statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8mXXTl1RnETW"
   },
   "source": [
    "The `break` statement breaks the loop and the execution exits the loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "yASj01UTm-PA",
    "outputId": "3d0a9afd-e91c-49e2-c92f-9cf83e4ad1b4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "while x < 10:\n",
    "  print(x)\n",
    "  x += 1\n",
    "  if x == 4: \n",
    "    break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "A7y1BrLsnvHa"
   },
   "source": [
    "### continue statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5KJJvhDCnq1N"
   },
   "source": [
    "The `continue` statement stops the current loop iteration and continues with the new iteration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "_pSfzpO7oMiJ",
    "outputId": "1e516cce-2f12-41f0-9fb5-4da997833779"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "while x < 10:\n",
    "  x += 1\n",
    "  if x == 3:\n",
    "    continue\n",
    "  print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "L1lY5mq5o9hp"
   },
   "source": [
    "## for loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "htyOpPjwpQsE"
   },
   "source": [
    "The `for` loop is something you will be using a lot. It can iterate over a sequence (i.e. list, tuple, set, dict, string)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "88CwSDguppd_",
    "outputId": "b3c931db-1a6d-4294-89ad-e3189558de1c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "one\n",
      "two\n",
      "three\n"
     ]
    }
   ],
   "source": [
    "# iterate over a list\n",
    "lst = [\"one\", \"two\", \"three\"]\n",
    "for num in lst:\n",
    "  print(num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ENr4febdqLd7",
    "outputId": "ff722241-24fa-49b8-9e8d-4b2501ca899d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p\n",
      "y\n",
      "t\n",
      "h\n",
      "o\n",
      "n\n"
     ]
    }
   ],
   "source": [
    "# iterate over a string (strings are sequence of characters)\n",
    "for i in \"python\":\n",
    "  print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BevPdnigqnX4"
   },
   "source": [
    "You can use `break` and `continue` just like in `while` loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "p5Vaj5NYrYTf"
   },
   "source": [
    "## The range() function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vrEtdXegrVA0"
   },
   "source": [
    "The `range()` function returns a sequence of numbers starting with 0 (by default) and incremented by 1 (by default) up to the number less than one provided as argument. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "_vdo2r87sDN2",
    "outputId": "3fd6c987-f162-4330-d69b-b3af098db0ab"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for i in range(6):\n",
    "  print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "A8u_yKt3ssxz"
   },
   "source": [
    "If two arguments are provided, then the sequence returned will start at the first argument and end at a number one less than the second argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "6wrteezwsqRk",
    "outputId": "5ea319ec-43b7-4e20-bc96-7bbb4bdfd7fc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "for i in range(2, 7):\n",
    "  print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4YYQ-M2usriP"
   },
   "source": [
    "If you provide 3 arguments, then the third argument will be the increment value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "57UKZuvqtfSk",
    "outputId": "631ca06e-0e4d-4e01-bb52-0bc9d26e4de5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "5\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "for i in range(2, 10, 3):\n",
    "  print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "htgppG1kt02c"
   },
   "source": [
    "## Nested loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wLCMigYttzWt"
   },
   "source": [
    "You can put a loop inside a loop, which is called a nested loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "3Fh4s2dkuKfE",
    "outputId": "26e25401-0e5d-4231-9e28-6c0fee019327"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "red chair\n",
      "red table\n",
      "red house\n",
      "blue chair\n",
      "blue table\n",
      "blue house\n",
      "green chair\n",
      "green table\n",
      "green house\n"
     ]
    }
   ],
   "source": [
    "colors = ['red', 'blue', 'green']\n",
    "objects = ['chair', 'table', 'house']\n",
    "\n",
    "for i in colors:\n",
    "  for j in objects:\n",
    "    print(i, j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oUecoRY29eNX"
   },
   "source": [
    "# Python Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3q3DVY_o9sRo"
   },
   "source": [
    "Functions are blocks of code which run only when called. Functions are not executed unless they are called. Functions most often take some input/s known as parameters and return some output."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dG240s3R-W78"
   },
   "source": [
    "## Creating a function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "UZq1c0UW-bpg"
   },
   "source": [
    "You need to use the keyword `def` to create a function in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "IonQBA0E-bO_",
    "outputId": "90d25d05-2171-4ef0-d922-7ca29343c0de"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# function definition\n",
    "def add(x, y): # here 'add' is the function name; x and y are parameters \n",
    "  return x+y # the function returns the sum of x and y\n",
    "\n",
    "# calling the function\n",
    "add(2,3) # here 2 and 3 are inputs to the function which are known as arguments."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QoW1FEn__g9f"
   },
   "source": [
    "**Parameters vs. Arguments** <br>\n",
    "Parameters are the variables defined inside the parentheses right after the function name in the function definition.\n",
    "Arguments are the values provided to the function inside the parentheses right after the function name, when calling the function.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6_lGjZGyBHIt"
   },
   "source": [
    "Functions need to be called with exactly the same number of arguments as the number of parameters defined - not fewer, not more."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 171
    },
    "id": "qQrUWifqBjTA",
    "outputId": "bf575dad-4498-43f7-acae-4824798c9a9a"
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "add() missing 1 required positional argument: 'y'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32mc:\\Users\\ASUS\\Desktop\\Python Basics\\Python_Fundamentals_Course_Notes_v2.ipynb Cell 226'\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/ASUS/Desktop/Python%20Basics/Python_Fundamentals_Course_Notes_v2.ipynb#ch0000226?line=0'>1</a>\u001b[0m add(\u001b[39m2\u001b[39;49m)\n",
      "\u001b[1;31mTypeError\u001b[0m: add() missing 1 required positional argument: 'y'"
     ]
    }
   ],
   "source": [
    "add(2) # add function expects 2 arguments. However, we are passing one argument, so get an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 171
    },
    "id": "eGUScdn8BwR7",
    "outputId": "b20f7902-0fbb-4096-e806-28bf4db4ad18"
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "add() takes 2 positional arguments but 3 were given",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32mc:\\Users\\ASUS\\Desktop\\Python Basics\\Python_Fundamentals_Course_Notes_v2.ipynb Cell 227'\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/ASUS/Desktop/Python%20Basics/Python_Fundamentals_Course_Notes_v2.ipynb#ch0000227?line=0'>1</a>\u001b[0m add(\u001b[39m1\u001b[39;49m,\u001b[39m2\u001b[39;49m,\u001b[39m3\u001b[39;49m)\n",
      "\u001b[1;31mTypeError\u001b[0m: add() takes 2 positional arguments but 3 were given"
     ]
    }
   ],
   "source": [
    "add(1,2,3) # add function expects 2 arguments. However, we are passing more than 2 arguments, so we get an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "colab": {
     "background_save": true
    },
    "id": "UshJbzVdTW-_"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def add(x, y):\n",
    "  return x + y\n",
    "\n",
    "add(3, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5OK6E_VRCO3a"
   },
   "source": [
    "## Arbitrary arguments (*args)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tcf7J-pBCaQp"
   },
   "source": [
    "If you do not know in advance how many arguments will be passed, you can define a function with arbitrary arguments by adding an * (asterisk) before the parameter name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "o3LUXl7UC7e-",
    "outputId": "6e6f143f-1f3a-4138-f62c-eedbd970fa0c"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "29"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def add(*nums):\n",
    "  sum = 0\n",
    "  for i in nums:\n",
    "    sum += i\n",
    "  return sum\n",
    "\n",
    "add(1,2,3,23) # try with different number of arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lBHFd4JkD9eG"
   },
   "source": [
    "## Default parameter value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VIrGEcgiECwN"
   },
   "source": [
    "When defining a function, we can provide a default value to parameters. When we call the function with default parameter value/s, if the argument is not passed for the default parameters, the default value is used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "rZGhu5nXFkNM",
    "outputId": "d838359e-db83-4037-9cde-a69fbe58af5f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def multiply(x, y=3):\n",
    "  return x*y\n",
    "\n",
    "multiply(4) # we did not pass the argument value for y, so y took the default value of 3 as defined in the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "9UgyuHtQGcOF",
    "outputId": "00268327-6569-4d5d-8846-1b0f9952ab3b"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multiply(4,5) # we provided the argument value for y, so the default value is overridden with the value provided."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Q9hOBkJ8G163"
   },
   "source": [
    "When defining functions with default parameter values, make sure that you put them after non-default parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 134
    },
    "id": "ccOtMvhaHIdP",
    "outputId": "22103ece-8a72-4896-eadb-98190fd46351"
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "non-default argument follows default argument (3260646998.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  Input \u001b[1;32mIn [115]\u001b[1;36m\u001b[0m\n\u001b[1;33m    def subtract(x=3,y):\u001b[0m\n\u001b[1;37m                     ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m non-default argument follows default argument\n"
     ]
    }
   ],
   "source": [
    "def subtract(x=3,y):\n",
    "  return x-y\n",
    "\n",
    "subtract(4) # returns error, since 4 is assumed to be the value for x, and consequently it is as if y value is not provided."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DFmm8usRH1aB"
   },
   "source": [
    "## Lambda Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jOFAsCNQH6E2"
   },
   "source": [
    "Lambda functions are anonymous (without a name) functions. They can take any number of arguments, but they can have only one expression. The syntax is of the following form: <br>\n",
    "`lamdba` *arguments : expression*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ab1HGzB7JS35"
   },
   "source": [
    "Lambda functions are quick and compact way of creating small functions. They do not require a name, parentheses, and a return keyword as in a normal function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "QwgpVfj5I0w7",
    "outputId": "b0f71e15-7a07-4cc6-b3c5-44e6bbff8ef1"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum = lambda x,y,z: x+y+z # lambda function defined and assigned to a variable 'sum'\n",
    "sum(1,2,3) # 'sum' lambda function called with arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "eRmkfXc259UV"
   },
   "source": [
    "# Python Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "O-1cAEUX6BoO"
   },
   "source": [
    "Tuples \n",
    "\n",
    "* can store multiple values in a single variable  \n",
    "* are enclosed by parentheses `()`\n",
    "* are ordered collection of items and they are **immutable** (unchangeable)\n",
    "* allow duplicate values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "IqxBh6VM9ubS",
    "outputId": "b1eb762f-50dd-431c-bbd2-dc126581e3b9"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Hi', 'there', 2, 3)"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# example of a tuple\n",
    "my_tuple = (\"Hi\", \"there\", 2, 3)\n",
    "my_tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PmXu7c8o-7my"
   },
   "source": [
    "Just like a Python List, Python Tuple items are indexed starting from 0, i.e. the first item in the tuple has the index 0, the second item has the index 1 and so on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "5h55vcR__l8g",
    "outputId": "5da5bc4e-e18b-46bb-f05d-04469dc9ef65"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi\n",
      "there\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "print(my_tuple[0])\n",
    "print(my_tuple[1])\n",
    "print(my_tuple[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cKmrYMm8_5AZ"
   },
   "source": [
    "Tuple allows duplicates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {
    "id": "acMaaOSZ_4Ie"
   },
   "outputs": [],
   "source": [
    "# duplicate items are allowed in a tuple\n",
    "tuple_1 = (1, 2, \"Apple\", \"Cherry\", \"Apple\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oUy_zsaNAQvM"
   },
   "source": [
    "You can get the size of the tuple (i.e. the number of items in the tuple) using the len() method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "JfqA0ooSAO8H",
    "outputId": "9c6da732-0f5d-497c-8b40-f077352c4f33"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# length (number of items in tuple)\n",
    "len(tuple_1) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "njr5At37A8Mq"
   },
   "source": [
    "If you need to create a tuple with only one element, you need to put a comma after the element. Otherwise, you will not get a tuple type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "DvHUJTrBArZD",
    "outputId": "bc4420aa-879f-4aa2-c250-496f46a92e2d"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple_1element = (\"hello\") # without a comma after the element in one-element tuple, you will not get a tuple type\n",
    "type(tuple_1element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "TuVjNP7PBg_m",
    "outputId": "392438e8-590f-4194-ba87-90f10d85ab83"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple_1element = (\"hello\",) # put a comma after the element in one-element tuple\n",
    "type(tuple_1element)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yDHSieV8EXuf"
   },
   "source": [
    "Accessing tuple items with indexing, negative indexing, range of indexes work just like in Lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "SP4G0XglD-o6",
    "outputId": "bcb2df5e-df7b-4577-b2a1-b2d2626de174"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my_tuple[0] =>  Hello\n",
      "my_tuple[-1] => 8.2\n",
      "my_tuple[1:3] => ('world', 1)\n",
      "my_tuple[-3: -1] => ('world', 1)\n",
      "my_tuple[:2] => ('Hello', 'world')\n",
      "my_tuple[2:] => (1, 8.2)\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (\"Hello\", \"world\", 1, 8.2)\n",
    "print(\"my_tuple[0] => \", my_tuple[0]) # prints the first element of the tuple\n",
    "print(\"my_tuple[-1] =>\",my_tuple[-1]) # last element\n",
    "print(\"my_tuple[1:3] =>\",my_tuple[1:3]) # elements at index 1 (second element) up to index 2 (3rd element) - excluding index 3\n",
    "print(\"my_tuple[-3: -1] =>\",my_tuple[-3: -1]) # element at index -3 up to index -2 (excluding -1)\n",
    "print(\"my_tuple[:2] =>\",my_tuple[:2]) # elements from index 0 up to index 1\n",
    "print(\"my_tuple[2:] =>\",my_tuple[2:]) # elements from index 2 to end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kg7r8Zr6H4WV"
   },
   "source": [
    "**You can not add items, update items, or remove items from a tuple**. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4MtVEJNbJKgW"
   },
   "source": [
    "You can delete a tuple with the `del` keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {
    "id": "NkkdL-09JKJE"
   },
   "outputs": [],
   "source": [
    "del my_tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 171
    },
    "id": "nUXS_RwlIsFd",
    "outputId": "f817dba6-2311-4d6d-e16c-5b0b1109750f"
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'my_tuple' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32mc:\\Users\\ASUS\\Desktop\\Python Basics\\Python_Fundamentals_Course_Notes_v2.ipynb Cell 259'\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/ASUS/Desktop/Python%20Basics/Python_Fundamentals_Course_Notes_v2.ipynb#ch0000259?line=0'>1</a>\u001b[0m my_tuple\n",
      "\u001b[1;31mNameError\u001b[0m: name 'my_tuple' is not defined"
     ]
    }
   ],
   "source": [
    "my_tuple # deleted, so will get error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8gXypYsLJmjA"
   },
   "source": [
    "## Unpack Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "P3kfGxKdJqbY"
   },
   "source": [
    "We can extract the values in tuples to variables, which is called \"unpacking\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "9CO-Ykq_KAoX",
    "outputId": "3d360e34-0062-473f-c002-2191ffe1d475"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sam\n",
      "Harry\n",
      "Tom\n"
     ]
    }
   ],
   "source": [
    "# Remember to provide as many variables as there are values in the tuple\n",
    "student1, student2, student3 = (\"Sam\", \"Harry\", \"Tom\")\n",
    "print(student1)\n",
    "print(student2)\n",
    "print(student3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "GeQTz3sCfWC7"
   },
   "source": [
    "## Loop through a tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fYIIP_hKLECx"
   },
   "source": [
    "You can conveniently loop through a tuple with a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "TCI2i33ofiHL",
    "outputId": "77a80439-c5a0-456e-c25f-47ff9f913b2f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This\n",
      "is\n",
      "great\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (\"This\", \"is\", \"great\")\n",
    "\n",
    "for item in my_tuple:\n",
    "  print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5LJ6vksQgGte"
   },
   "source": [
    "## Join tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "m8J0vZ0_gKoS"
   },
   "source": [
    "You can join tuples with a `+` operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "lc06GhVTfykc",
    "outputId": "ab497d98-d51f-4da4-99ee-df0239066237"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4, 5, 6)\n",
      "(1, 2, 3, 4, 5, 6, 7, 8, 9)\n"
     ]
    }
   ],
   "source": [
    "tuple_1 = (1,2,3)\n",
    "tuple_2 = (4,5,6)\n",
    "tuple_3 = (7,8,9)\n",
    "\n",
    "print(tuple_1 + tuple_2)\n",
    "print(tuple_1 + tuple_2 + tuple_3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9QZGfsE5goX5"
   },
   "source": [
    "## Multiply tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yGIKrIdagtsP"
   },
   "source": [
    "You can multiply a tuple and an integer with a `*` operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "oopa4Blng2_2",
    "outputId": "dd8923c9-5dd3-4aca-d412-278fbf925568"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 1, 2, 3, 1, 2, 3)"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1,2,3) * 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HClW16AqfFlM"
   },
   "source": [
    "# Python Sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0MvOHDnAfJbY"
   },
   "source": [
    "Python set can store multiple values in a variable, just like List and Tuple. \n",
    "\n",
    "Python sets are:\n",
    "\n",
    "\n",
    "*   unordered\n",
    "*   unindexed (as opposed to lists and tuples, which are indexed)\n",
    "* do not allow duplicates (as opposed to lists and tuples, which allow duplicates)\n",
    "* immutable (elements can not be changed, removed or updated) - allows adding of new elements\n",
    "* enclosed by curly braces `{}`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "mrM3EJyVgGkf",
    "outputId": "c909af5b-dc34-4392-d83c-17cc5bc3f3a7"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 5.65, 'Hi', True}"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# use curly braces {} to define a set \n",
    "my_set = {2, \"Hi\", 5.65, True}\n",
    "my_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "eNMvcX5Tg4Id",
    "outputId": "78e80713-d0f9-48f6-c97f-771e0c635a8d"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, False, 'Hi', 'there'}"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# duplicates are not retained\n",
    "set_1 = {1, 2, \"Hi\", \"there\", \"Hi\", False}\n",
    "set_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ct-_1kBBhWmh",
    "outputId": "a989e1c4-4cfa-45d3-90f7-3cdecf2d7748"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# length (number of items) of a set\n",
    "len(set_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lI9vlapsqI43"
   },
   "source": [
    "## Access Set items"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0-Pkdj46qOL_"
   },
   "source": [
    "You can loop through a set to access the items of the set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "bDWYfZuzqVrA",
    "outputId": "e3e857a0-00aa-4dc8-cc69-48e09fb22f28"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "there\n",
      "1\n",
      "2\n",
      "False\n",
      "Hi\n"
     ]
    }
   ],
   "source": [
    "for i in set_1:\n",
    "  print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "sExOO_t0qcUb"
   },
   "source": [
    "You can check if a particular item is in the set by using the `in` keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "6L-iJ4dFqkMQ",
    "outputId": "67a3d05f-865a-4f4f-a9e6-fd34ab21851e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 in set_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "kn8EbClZqniI",
    "outputId": "f2d76476-47df-4966-a8bd-6d0ae4a72438"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Hey\" in set_1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PMxHA2Z-q0KJ"
   },
   "source": [
    "## Add items to set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "K5BaVxvBq34w"
   },
   "source": [
    "You can not change the items already in a set, however, you can add items to the set by using the add() method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "fkP93fkVrAns",
    "outputId": "df40adb7-dad2-4790-e762-8999c6038a63"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 'python'}"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_set = {1,2,3}\n",
    "my_set.add(\"python\")\n",
    "my_set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Kx7bXTY6rYnR"
   },
   "source": [
    "You can add items from another set by using the `update()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "mdrd9ZgMrRCC",
    "outputId": "ed518d2e-c133-49d7-a2e1-9faa4769c699"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 'Hi', 'python', 'there'}"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "your_set = {\"Hi\", \"there\"}\n",
    "my_set.update(your_set)\n",
    "my_set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rT79yRbUr5mv"
   },
   "source": [
    "The `update()` method can take a list, a tuple, or a dictionary. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "DdO2569lsKD5",
    "outputId": "a2044de0-b5c2-45c6-e760-f17a517817e0"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 'four', 'three'}"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# using update() with a list\n",
    "my_set = {1,2}\n",
    "lst = [\"three\", \"four\"]\n",
    "my_set.update(lst)\n",
    "my_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "qYZz7g4qscrV",
    "outputId": "62e07e06-f0fa-4141-8ee7-1c682e418f26"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 'four', 'three'}"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# using update() with a tuple\n",
    "my_set = {1,2}\n",
    "my_tup = (\"three\", \"four\")\n",
    "my_set.update(my_tup)\n",
    "my_set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "sW2gHWZ5Dc3s"
   },
   "source": [
    "# Python Dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PxNGIcygDkuP"
   },
   "source": [
    "Python dictionary stores data in the form of key, value pairs (key:value) separated by commas and the pairs are enclosed by curly braces.\n",
    "\n",
    "Example: ages_dict = {\"Tom\": 30, \"Harry\": 25, \"Sarah\": 28} \n",
    "In the above example, \"Tom\", \"Harry\", and \"Sarah\" are keys, and 30, 25, and 28 are corresponding values.\n",
    "\n",
    "Python dictionaries:\n",
    "\n",
    "\n",
    "*   are ordered (have indexes) [in Python 3.7 and later]\n",
    "*   are mutable (items can be added, updated, and deleted)\n",
    "*   do not allow duplicate keys\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "OELBIvd-Fpp2",
    "outputId": "6c04de65-5b1f-4fa5-ec84-e35f1e57a2c4"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Chicago': 3.5, 'New York': 7, 'LA': 6}"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example\n",
    "city_pop = {\n",
    "  \"Chicago\": 3.5, \n",
    "  \"New York\": 7,\n",
    "  \"LA\": 6\n",
    "}\n",
    "\n",
    "city_pop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "klM34Tigs_nm"
   },
   "source": [
    "## Access dictionary items"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "g67EsfEOrtaj"
   },
   "source": [
    "You can get the value of any key in the dictionary in the following way.\n",
    "\n",
    "**name_of_dict[ key ]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "H9O5CCBerKOJ",
    "outputId": "22b80bf3-e81a-4178-ab99-7727ec53b90e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.5"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# getting the value (population) of \"Chicago\" (key)\n",
    "city_pop[\"Chicago\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XyR46kmqtl0W"
   },
   "source": [
    "You can also use the `get()` method to get the value of the key provided as argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "qWp5cxYJsI8k",
    "outputId": "1231228c-04a3-4bcf-b830-f71f90d00e70"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "city_pop.get(\"LA\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "k_VeG4Dtt3d2"
   },
   "source": [
    "You can use the `keys()` method to get a list of all the keys in the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "5gJ6N0HBuC2R",
    "outputId": "6532d9ef-5647-4206-df87-08674fbee7d7"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['Chicago', 'New York', 'LA'])"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "city_pop.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ZD6jPdusuKnS"
   },
   "source": [
    "You can use the `values()` method to get a list of all the values in the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "bysNhfPIuUQa",
    "outputId": "5ad53e4d-9421-48cc-ee09-329c12a75562"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values([3.5, 7, 6])"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "city_pop.values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "00YDL7j8u-R_"
   },
   "source": [
    "In order to access the items in the dictionary, use the `items()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "eflSm-HXvIR4",
    "outputId": "202e58f0-b931-4ca0-86f1-a574d09679ea"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('Chicago', 3.5), ('New York', 7), ('LA', 6)])"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the result will be a list of tuples, each tuple containing a pair of key and value\n",
    "city_pop.items()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Nvo8O31ivoiA"
   },
   "source": [
    "You can check if a particular key exists in a dicionary, by using the `in` keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ow2C3SrevxmE",
    "outputId": "d9cae5bb-431b-40b2-df9a-7156a085eb26"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Chicago\" in city_pop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "JcAGeWvev2v7",
    "outputId": "5a4d1514-2918-4a62-9a26-7abf37828d55"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"San Franscisco\" in city_pop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3bNNVVB_wJt_"
   },
   "source": [
    "## Change dictionary items"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BxwD8psAwRFt"
   },
   "source": [
    "If you want to update the value of a particular key, then you can just assign a new value to the key in the following way.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "9olaNcAkwuF7",
    "outputId": "fcc07970-a23f-4c3c-806f-c129bfde5678"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Chicago': 3.5, 'New York': 7, 'LA': 20}"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# dict[ key ] = new value\n",
    "city_pop[\"LA\"] = 20\n",
    "city_pop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FMnoR9ENxBQU"
   },
   "source": [
    "You can also update the value of a particular key by using the `update()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "45C_ORitxK1m",
    "outputId": "6bdb353c-1fa4-495b-f9ab-aaf0f01cbfb1"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Chicago': 30, 'New York': 7, 'LA': 20}"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "city_pop.update({ \"Chicago\": 30 })\n",
    "city_pop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "UJn7iVKQxfdM"
   },
   "source": [
    "## Add items to dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "H6cB6HJ-xsn-"
   },
   "source": [
    "If you want to add items to a dictionary, you can do so by assigning a value to a new key in the following manner. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ZCsMVJkExTZA",
    "outputId": "72bc35c3-3f39-48c1-b02f-00d7a60536c9"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Chicago': 30, 'New York': 7, 'LA': 20, 'Kathmandu': 2.5}"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "city_pop[\"Kathmandu\"] = 2.5\n",
    "city_pop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mMNXcxTlyyyH"
   },
   "source": [
    "You can also use the `update()` method to add a new item in the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "SXt6CP0JzCKX",
    "outputId": "9df83d74-6e3e-4ffc-c3ec-13001c307fb1"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Chicago': 30, 'New York': 7, 'LA': 20, 'Kathmandu': 2.5, 'Pokhara': 1.5}"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "city_pop.update({\"Pokhara\": 1.5})\n",
    "city_pop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3bo3tMu4zYxI"
   },
   "source": [
    "## Remove items from dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gUT0mt0bxdp7"
   },
   "source": [
    "You can use the `pop()` method with key specified as argument to remove the item with the key from a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "KO1vHBvtz22v",
    "outputId": "f6512f79-e07b-4983-dc89-df2bdb2175d8"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Chicago': 30, 'New York': 7, 'Kathmandu': 2.5, 'Pokhara': 1.5}"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "city_pop.pop(\"LA\")\n",
    "city_pop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9pFXTIQ_0Kgf"
   },
   "source": [
    "The `del` keyword can also delete a specified key value pair in the following way."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "bBU9VAHa0G_O",
    "outputId": "90eb9ba8-f57a-4d74-b060-da3b2e6b58f1"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Chicago': 30, 'New York': 7, 'Kathmandu': 2.5}"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del city_pop[\"Pokhara\"]\n",
    "city_pop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HLYdvKrS00mS"
   },
   "source": [
    "The `clear()` method deletes all the items in the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "vNROvsH208Cn",
    "outputId": "cca2c813-e84a-4389-a860-b7f71015853c"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "city_pop.clear()\n",
    "city_pop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "L3MIN4HG1BbC"
   },
   "source": [
    "You can use the `del` keyword to delete the dictionary itself from memory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {
    "id": "kEf96bJl1NQa"
   },
   "outputs": [],
   "source": [
    "del city_pop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 167
    },
    "id": "RT3hU3DI1RJB",
    "outputId": "ed6ef104-b177-4ef6-851a-83607f3848e0"
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'city_pop' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32mc:\\Users\\ASUS\\Desktop\\Python Basics\\Python_Fundamentals_Course_Notes_v2.ipynb Cell 327'\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/ASUS/Desktop/Python%20Basics/Python_Fundamentals_Course_Notes_v2.ipynb#ch0000327?line=0'>1</a>\u001b[0m \u001b[39m# city_pop is no longer accessible, as it has already been deleted.\u001b[39;00m\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/ASUS/Desktop/Python%20Basics/Python_Fundamentals_Course_Notes_v2.ipynb#ch0000327?line=1'>2</a>\u001b[0m city_pop\n",
      "\u001b[1;31mNameError\u001b[0m: name 'city_pop' is not defined"
     ]
    }
   ],
   "source": [
    "# city_pop is no longer accessible, as it has already been deleted.\n",
    "city_pop"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "Python Fundamentals - Course Notes.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}