{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d9be6007",
   "metadata": {},
   "source": [
    "# Variables\n",
    "In Python, variables are used to store and manage data. Each variable has a name and a value, and the type of the variable indicates what kind of data it can hold.\n",
    "### Variable Naming Rules:\n",
    " * Variable names in Python can contain alphanumerical characters `a-z`, `A-Z`, `0-9` and some special characters such as `_`.\n",
    " * Normal variable names must start with a letter.\n",
    " * By convention, variable names start with a lower-case letter, and Class names start with a capital letter.\n",
    " * In addition, there are a number of Python keywords that cannot be used as variable names. These keywords are:\n",
    "\n",
    "    and, as, assert, break, class, continue, def, del, elif, else, except, \n",
    "    exec, finally, for, from, global, if, import, in, is, lambda, not, or,\n",
    "    pass, print, raise, return, try, while, with, yield\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "736c7bab",
   "metadata": {},
   "source": [
    "## Assignment in Python\n",
    "The assignment operator in Python is `=`.\n",
    "\n",
    "Assigning a value to a new variable creates the variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f17cbaf7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 John True\n"
     ]
    }
   ],
   "source": [
    "#Assigning values to variable\n",
    "x = 10\n",
    "name = \"rafay\"\n",
    "is_student = True\n",
    "\n",
    "#print the variable\n",
    "print(x, name, is_student)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3fe322b1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What is your name?ali\n",
      "Name: ali\n"
     ]
    }
   ],
   "source": [
    "#using input and output in python\n",
    "\n",
    "name= input(\"What is your name?\")\n",
    "print(\"Name:\", name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0ecf03c",
   "metadata": {},
   "source": [
    "# Operators\n",
    "Most operators and comparisons in Python work as one would expect:\n",
    "\n",
    "### Arithmetic operators `+`, `-`, `*`, `/`, `//` (integer division), '**' power\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4dc5a097",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 -1 2 3\n"
     ]
    }
   ],
   "source": [
    "print  (1 + 2, 1 - 2, 1 * 2, 7 // 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "8ccede4f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.0 -1.0 2.0 0.5\n"
     ]
    }
   ],
   "source": [
    "print  (1.0 + 2.0, 1.0 - 2.0, 1.0 * 2.0, 1.0 / 2.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "96b9d6a0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    "# Integer division of float numbers\n",
    "print (3.0 // 2.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "499597eb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.5\n"
     ]
    }
   ],
   "source": [
    "# Flaot division of integers\n",
    "print (3/2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "9082a90f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "# The power operators in python isn't ^, but **\n",
    "print (2 ** 2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43c97990",
   "metadata": {},
   "source": [
    "Note: The `/` operator always performs a floating point division in Python 3.x.\n",
    "This is not true in Python 2.x, where the result of `/` is always an integer if the operands are integers.\n",
    "to be more specific, `1/2 = 0.5` (`float`) in Python 3.x, and `1/2 = 0` (`int`) in Python 2.x (but `1.0/2 = 0.5` in Python 2.x)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0c64a24",
   "metadata": {},
   "source": [
    "* The boolean operators are spelled out as the words `and`, `not`, `or`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "c875a486",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print  (True and False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "74efcd1e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print (not False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "db035d4c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print  (True or False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f2f3959",
   "metadata": {},
   "source": [
    "* Comparison operators `>`, `<`, `>=` (greater or equal), `<=` (less or equal), `==` equality, `is` identical."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "4a655ee1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True False\n"
     ]
    }
   ],
   "source": [
    "print  (2 > 1, 2 < 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "960280fa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True True\n"
     ]
    }
   ],
   "source": [
    "print (2 >= 2, 2 <= 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "009ceee9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# equality\n",
    "print ([1,2] == [1,2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "414deba4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# objects identical?\n",
    "l1=l2=[1,2]\n",
    "\n",
    "print  (l1 is l2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "280e319e",
   "metadata": {},
   "source": [
    "# Data Types\n",
    "Python is a dynamically typed language, so we do not need to specify the type of a variable when we create one.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "1f3cb259",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n",
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "x=1.2\n",
    "print(type(x))\n",
    "\n",
    "#If we assign a new value to a variable, its type can change.\n",
    "x=3\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "0a507159",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "#integers\n",
    "x = 1\n",
    "print (type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "bf1a321c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "# float\n",
    "x = 1.0\n",
    "print (type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "32492b1d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "# boolean\n",
    "b1 = True\n",
    "b2 = False\n",
    "\n",
    "print (type(b1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "9cf80875",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'complex'>\n"
     ]
    }
   ],
   "source": [
    "# complex numbers: note the use of `j` to specify the imaginary part\n",
    "x = 1.0 - 1.0j\n",
    "print (type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "1d1bc47e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1-1j)\n",
      "1.0 -1.0\n"
     ]
    }
   ],
   "source": [
    "print(x)\n",
    "print(x.real, x.imag)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f8f7f88",
   "metadata": {},
   "source": [
    "Check if a certain variable is integer or float...."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "5c422cc5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "x= 5\n",
    "print (type(x) is int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "e915abab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "x= 5.0\n",
    "print (type(x) is int)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5efd598",
   "metadata": {},
   "source": [
    "We can also use the `isinstance` method for testing types of variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "2b2880c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print (isinstance(x, float))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ea12c90",
   "metadata": {},
   "source": [
    "# Type casting\n",
    "Typecasting in Python refers to the process of converting a variable from one data type to another. Python provides several built-in functions for typecasting. Here are some common typecasting functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "ee5598a3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "# int(x)\n",
    "\n",
    "float_num = 3.14\n",
    "int_num = int(float_num)\n",
    "print(int_num)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "a02a2e54",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.0\n"
     ]
    }
   ],
   "source": [
    "# float(x)\n",
    "\n",
    "int_num = 5\n",
    "float_num = float(int_num)\n",
    "print(float_num)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "514957ba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "# bool(x)\n",
    "\n",
    "number = 0\n",
    "bool_value = bool(number)\n",
    "print(bool_value)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "322e28b2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['h', 'e', 'l', 'l', 'o']\n"
     ]
    }
   ],
   "source": [
    "#list(x)\n",
    "\n",
    "string = \"hello\"\n",
    "list_chars = list(string)\n",
    "print(list_chars)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61b6449d",
   "metadata": {},
   "source": [
    "Complex variables cannot be cast to floats or integers. We need to use `z.real` or `z.imag` to extract the part of the complex number we want:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "f261b3fb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.0 4\n"
     ]
    }
   ],
   "source": [
    "z = 3 + 4.2j\n",
    "float_z= float(z.real)\n",
    "int_z  = int(z.imag)\n",
    "print(float_z, int_z)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71304a89",
   "metadata": {},
   "source": [
    "# Compound data types: Strings, List and dictionaries\n",
    "## Strings\n",
    "Strings are the variable type that is used for storing text messages. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "c29c3b59",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "s = \"Hello world\"\n",
    "print (type(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "77ec8e67",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n"
     ]
    }
   ],
   "source": [
    "# length of the string: the number of characters\n",
    "print (len(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "f7e42b91",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello test\n"
     ]
    }
   ],
   "source": [
    "# replace a substring in a string with somethign else\n",
    "s2 = s.replace(\"world\", \"test\")\n",
    "print (s2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dcc1affc",
   "metadata": {},
   "source": [
    "We can index a character in a string using `[]`:\n",
    "\n",
    "Indexing starts with 0\n",
    "\n",
    "We can extract a part of a string using the syntax `[start:stop]`, which extracts characters between index `start` and `stop` -1 (the character at index `stop` is not included):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "6faf3700",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H\n"
     ]
    }
   ],
   "source": [
    "print (s[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "a42f0cb6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hell\n"
     ]
    }
   ],
   "source": [
    "print (s[0:4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "8935ac5c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "o\n"
     ]
    }
   ],
   "source": [
    "print (s[4:5])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45f6987c",
   "metadata": {},
   "source": [
    "If we omit either (or both) of `start` or `stop` from `[start:stop]`, the default is the beginning and the end of the string, respectively:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "e148143f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    }
   ],
   "source": [
    "print (s[:5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "f0262e12",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "world\n"
     ]
    }
   ],
   "source": [
    "print (s[6:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "94c70a81",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world\n"
     ]
    }
   ],
   "source": [
    "print  (s[:])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8cae043b",
   "metadata": {},
   "source": [
    " We can also define the step size using the syntax `[start:end:step]` (the default value for `step` is 1, as we saw above)\n",
    " \n",
    " \n",
    "This technique is called *slicing*. Read more about the syntax here: http://docs.python.org/release/2.7.3/library/functions.html?highlight=slice#slice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "6dd4bde8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hlowrd\n",
      "He\n"
     ]
    }
   ],
   "source": [
    "print (s[::2])\n",
    "print (s[:2:1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "e914acdf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "str1 str2 str3\n"
     ]
    }
   ],
   "source": [
    "print (\"str1\", \"str2\", \"str3\")  # The print statement concatenates strings with a space"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "cf65e8d7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "str1 1.0 False (-0-1j)\n"
     ]
    }
   ],
   "source": [
    "print (\"str1\", 1.0, False, -1j)  # The print statements converts all arguments to strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "1ced3e89",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "str1str2str3\n"
     ]
    }
   ],
   "source": [
    "print (\"str1\" + \"str2\" + \"str3\") # strings added with + are concatenated without space"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed451e26",
   "metadata": {},
   "source": [
    "## Lists\n",
    "In Python, lists are mutable, commonly used to store collection of items.\n",
    "\n",
    "Lists contain comma separated values within square brackets `[]`:\n",
    "\n",
    "Elements in a list do not all have to be of the same type\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "8cc70b96",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apple']"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = [1, 2, 3, 'apple', 'orange']\n",
    "my_list =['apple']\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83421420",
   "metadata": {},
   "source": [
    "Python lists can be inhomogeneous and arbitrarily nested:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "0685822d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1,\n",
       " [2,\n",
       "  3,\n",
       "  [4,\n",
       "   5,\n",
       "   [6, 7, 8, [9, [10, 11, [12, 13, [14, [15, [16]], [23]]], [22]]], [21]]],\n",
       "  [20]],\n",
       " [19]]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k=[1,2.2,3,'a']\n",
    "k=[1,[2,3,[4,5,[6,7,8,[9,[10,11,[12,13,[14,[15,[16]],[23]]],[22]]],[21]]],[20]],[19]]\n",
    "k"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3dc3f384",
   "metadata": {},
   "source": [
    "There are a number of convenient functions for generating lists of various types, for example the `range` function:\n",
    "\n",
    "    in python 3 \"range\" generates an interator, which can be converted to a list using 'list(...)'.\n",
    "    It has no effect in python 2\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "9b3ee3d4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1,\n",
       " 3,\n",
       " 5,\n",
       " 7,\n",
       " 9,\n",
       " 11,\n",
       " 13,\n",
       " 15,\n",
       " 17,\n",
       " 19,\n",
       " 21,\n",
       " 23,\n",
       " 25,\n",
       " 27,\n",
       " 29,\n",
       " 31,\n",
       " 33,\n",
       " 35,\n",
       " 37,\n",
       " 39,\n",
       " 41,\n",
       " 43,\n",
       " 45,\n",
       " 47,\n",
       " 49,\n",
       " 51,\n",
       " 53,\n",
       " 55,\n",
       " 57,\n",
       " 59,\n",
       " 61,\n",
       " 63,\n",
       " 65,\n",
       " 67,\n",
       " 69,\n",
       " 71,\n",
       " 73,\n",
       " 75,\n",
       " 77,\n",
       " 79,\n",
       " 81,\n",
       " 83,\n",
       " 85,\n",
       " 87,\n",
       " 89,\n",
       " 91,\n",
       " 93,\n",
       " 95,\n",
       " 97,\n",
       " 99]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#print list(range(start, stop, step))\n",
    "list(range(1,100,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "9a1a1d14",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "print (list(range(-10, 10)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "0590772d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Peshawar'"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#different list operations\n",
    "list1= [\"Lahore\", \"Karachi\", \"Peshawar\", \"Islamabad\"]\n",
    "\n",
    "#indexing\n",
    "list1[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "33febd53",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Karachi']"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#slicing\n",
    "list1[1:2]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "632913fb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Lahore', 'Karachi', 'Peshawar', 'Islamabad', 4, 5, 6]"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Concatenation\n",
    "list2 = list1 + [4, 5, 6]\n",
    "list2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "e04c4d3e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Lahore',\n",
       " 'Karachi',\n",
       " 'Peshawar',\n",
       " 'Islamabad',\n",
       " 'Lahore',\n",
       " 'Karachi',\n",
       " 'Peshawar',\n",
       " 'Islamabad']"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Repitition\n",
    "repeat_list = list1 * 2\n",
    "repeat_list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96bd06df",
   "metadata": {},
   "source": [
    "### List Methods\n",
    "#### Adding, inserting, modifying, and removing elements from lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "7beb2e8b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 6, 8, 9, 0, 1, 'banana']"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#add an element to the end of the list\n",
    "my_list = [3, 6, 8, 9, 0, 1]\n",
    "my_list.append('banana')\n",
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "ed2af4bb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 6, 8, 9, 0, 1, 'banana', 7, 8, 9]"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Extend the list by appending elements from an iterable.\n",
    "my_list.extend([7, 8, 9])\n",
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "3a8236ff",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 6, 'grape', 8, 9, 0, 1, 'banana', 7, 8, 9]"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Insert an element at a specified index.\n",
    "my_list.insert(2, 'grape')  # Insert 'grape' at index 2\n",
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "5fa0b722",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 6, 'grape', 8, 9, 0, 1, 7, 8, 9]"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Remove the first occurrence of a specified value\n",
    "my_list.remove('banana')\n",
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "2f9c99ce",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 6, 8, 9, 0, 1, 7, 8, 9]"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Removes and returns the element at a specified index.\n",
    "my_list.pop(2)\n",
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "c1b50c99",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Return the index of the first occurrence of a value.\n",
    "index = my_list.index(6)\n",
    "index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "4e6f634b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Return the number of occurrences of a value.\n",
    "count_of_2 = my_list.count(2)\n",
    "count_of_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "80d2b6ed",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 3, 6, 7, 8, 8, 9, 9]"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Sorts the list in ascending order.\n",
    "my_list.sort()\n",
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "d003dade",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[9, 9, 8, 8, 7, 6, 3, 1, 0]"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Reverse the order of elements in the list.\n",
    "my_list.reverse()\n",
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "3a0f7451",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[9, 'a', 'd', 'd', 7, 6, 3, 1, 0]"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#list can also be modified by assigning the values at specific index\n",
    "my_list[1:4]= ['a', 'd', 'd']\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42fb862a",
   "metadata": {},
   "source": [
    "## Tuple\n",
    "Tuples are like lists, except that they cannot be modified once created, that is they are *immutable*. \n",
    "\n",
    "In Python, tuples are created using the syntax `(..., ..., ...)`, or even `..., ...`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "5273ebdf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 'apple', 'orange')"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#creating a tuple\n",
    "my_tuple = (1, 2, 3, 'apple', 'orange')\n",
    "my_tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "f5cc6bda",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "first_element = my_tuple[0]  # Access the first element\n",
    "first_element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "a7eee4af",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 'apple', 'orange', 4, 5, 6)"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " # concatenate a tuple\n",
    "new_tuple = my_tuple + (4, 5, 6)\n",
    "new_tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "d4c6836d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 'apple', 'orange', 1, 2, 3, 'apple', 'orange')"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# repeat a tuple using * operator\n",
    "repeated_tuple = my_tuple * 2\n",
    "repeated_tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "fc1e669f",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[1;32mIn [78]\u001b[0m, in \u001b[0;36m<cell line: 2>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;66;03m# tuples are immutable so u cant modify it\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m my_tuple[\u001b[38;5;241m1\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m11\u001b[39m\n",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "# tuples are immutable so u cant modify it\n",
    "#modifying a tuple would result in error\n",
    "my_tuple[1] = 11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "997cb5f0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 20) <class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "point = 10, 20\n",
    "\n",
    "print (point, type(point))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2ae0783",
   "metadata": {},
   "source": [
    "# Dictionaries\n",
    "In Python, a dictionary is a collection type that allows you to store key-value pairs. Dictionaries are also known as associative arrays, hash maps, or hash tables in other programming languages. They are defined by enclosing comma-separated key-value pairs within curly braces {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "0cca9c25",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}\n",
    "my_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "664db423",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Ali': [2.7, 'B+'], 'Ahmad': [3.1, 'A'], 'Zain': [3.4, 'A']}"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict = {\n",
    "    'Ali': [2.7, \"B+\"],\n",
    "    'Ahmad': [3.1, \"A\"],\n",
    "    \"Zain\": [3.4, \"A\"]\n",
    "}\n",
    "my_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "661e601b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2.7, 'B+']"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#accessing an element using key value\n",
    "my_dict['Ali']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "a6b07ecf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Ali': [2.7, 'B+'],\n",
       " 'Ahmad': [3.1, 'A'],\n",
       " 'Zain': [3.4, 'A'],\n",
       " 'Ayesha': [4.0, 'A+']}"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict['Ayesha'] = [4.0, \"A+\"]  # Add a new entry\n",
    "my_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "87d36f4e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Ali': [2.3, 'C+'],\n",
       " 'Ahmad': [3.1, 'A'],\n",
       " 'Zain': [3.4, 'A'],\n",
       " 'Ayesha': [4.0, 'A+']}"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict['Ali'] = [2.3, \"C+\"] # Modify an existing entry\n",
    "my_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "324d4f24",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Ali': [2.3, 'C+'], 'Zain': [3.4, 'A'], 'Ayesha': [4.0, 'A+']}"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del my_dict['Ahmad']  # Remove the entry with key \n",
    "my_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "360a3779",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['Ali', 'Zain', 'Ayesha'])"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Return a view of all keys in the dictionary.\n",
    "my_dict.keys()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "8d4022d3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values([[2.3, 'C+'], [3.4, 'A'], [4.0, 'A+']])"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Returns a view of all values in the dictionary.\n",
    "my_dict.values()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "7397cd93",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('Ali', [2.3, 'C+']), ('Zain', [3.4, 'A']), ('Ayesha', [4.0, 'A+'])])"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Returns a view of all key-value pairs as tuples.\n",
    "my_dict.items()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30e7fa96",
   "metadata": {},
   "source": [
    "# Sets\n",
    "In Python, a set is an unordered and mutable collection of unique elements. Sets are defined by enclosing comma-separated values within curly braces {}. Here are some key characteristics and examples of sets in Python:\n",
    "### Key Characteristics:\n",
    "#### Uniqueness:\n",
    "\n",
    "Sets only allow unique elements. If you try to add a duplicate element, it will not be added.\n",
    "#### Unordered:\n",
    "\n",
    "Sets are unordered, meaning the elements do not have a specific order.\n",
    "#### Mutability:\n",
    "\n",
    "Sets are mutable, so you can add or remove elements after the set is created.\n",
    "### Creating Sets:\n",
    "You can create a set using the following syntax:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "f955e645",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5}"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_set = {1, 2, 3, 4, 5}\n",
    "my_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "4c8de147",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6}"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#You can add elements to a set using the add() method.\n",
    "my_set.add(6)\n",
    "my_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "05bb1e10",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 4, 5, 6}"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#You can remove elements using the remove() or discard() methods.\n",
    "my_set.remove(3)\n",
    "my_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "bec000ac",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set()"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Removes all elements from the set\n",
    "my_set.clear()\n",
    "my_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "ea745432",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5}"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#You can perform a union of two sets using the union() method or the | operator.\n",
    "set1 = {1, 2, 3}\n",
    "set2 = {3, 4, 5}\n",
    "union_set = set1.union(set2)\n",
    "union_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "23b956c5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3}"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#You can perform an intersection of two sets using the intersection() method or the & operator.\n",
    "intersection_set = set1.intersection(set2)\n",
    "intersection_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "90449f5b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2}"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#You can find the difference between two sets using the difference() method or the - operator.\n",
    "difference_set = set1.difference(set2)\n",
    "difference_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "3edda799",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 4, 5}"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# You can find the symmetric difference between two sets using the symmetric_difference() method or the ^ operator.\n",
    "symmetric_difference_set = set1.symmetric_difference(set2)\n",
    "symmetric_difference_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "39ab8750",
   "metadata": {},
   "outputs": [],
   "source": [
    "set1.add(4)\n",
    "set1.add(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "240f7a53",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "subset = set1.issubset(set2)\n",
    "subset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "831460d0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "superset = set1.issuperset(set2)\n",
    "superset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5538bceb",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}