Day 2-List, Tuples and sets.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Structures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists are mutable which means they can be changed and they are indexed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Creation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 'ramu', 24, 1.24]\n"
     ]
    }
   ],
   "source": [
    "emptyList=[]\n",
    "lst=['one','two','three','four'] #list of strings\n",
    "lst2=[1,2,3,4] #list of integers\n",
    "lst3=[[1,2],[3,4]]#list of lists\n",
    "lst4=[1,'ramu',24,1.24] #list of different datatypes\n",
    "print(lst4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ### List Length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "lst=['one','two','three','four']\n",
    "\n",
    "#find length of list\n",
    "print(len(lst))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Append"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['one', 'two', 'three', 'four', 'five']\n"
     ]
    }
   ],
   "source": [
    "lst.append('five')\n",
    "print (lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['one', 'two', 'hey', 'three', 'four', 'five']\n"
     ]
    }
   ],
   "source": [
    "lst.insert(2,'hey')\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Remove"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['one', 'two', 'three', 'four', 'five']\n"
     ]
    }
   ],
   "source": [
    "lst.remove('hey')\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List append & extend"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['one', 'two', 'three', 'four', ['five', 'six']]\n"
     ]
    }
   ],
   "source": [
    "lst=['one','two','three','four']\n",
    "lst2=['five','six']\n",
    "lst.append(lst2)\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['one', 'two', 'three', 'four', ['five', 'six'], 'five', 'six']\n"
     ]
    }
   ],
   "source": [
    "lst.extend(lst2)\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Delete"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['one', 'three', 'four', 'five']\n",
      "three\n",
      "['one', 'four', 'five']\n"
     ]
    }
   ],
   "source": [
    "lst=['one','two','three','four','five']\n",
    "\n",
    "del lst[1]\n",
    "print(lst)\n",
    "\n",
    "a=lst.pop(1)\n",
    "print (a)\n",
    "\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ML\n"
     ]
    }
   ],
   "source": [
    "let=['one','two','three','four']\n",
    "\n",
    "if 'two' in lst:\n",
    "    print('AI')\n",
    "    \n",
    "#keyword 'not' can combined with 'in'\n",
    "if 'six' not in lst:\n",
    "    print('ML')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Sorting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorted List:  [1, 2, 3, 6, 8]\n",
      "original list:  [3, 1, 6, 2, 8]\n"
     ]
    }
   ],
   "source": [
    "#creates a list with number\n",
    "numbers=[3,1,6,2,8]\n",
    "\n",
    "sorted_list=sorted(numbers)\n",
    "print(\"Sorted List: \",sorted_list)\n",
    "\n",
    "print (\"original list: \",numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reverse Sorted List :  [8, 6, 3, 2, 1]\n",
      "Original list:  [3, 1, 6, 2, 8]\n"
     ]
    }
   ],
   "source": [
    "#print a list in reverse sorted order\n",
    "print(\"Reverse Sorted List : \",sorted(numbers,reverse=True))\n",
    "\n",
    "#Original list remains unchanged \n",
    "print(\"Original list: \",numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst=[1,20,5,5,4.2]\n",
    "\n",
    "#sort the list and stored in itself\n",
    "lst.sort()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4.2, 5, 5, 20]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List having Multiple references"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original List:  [1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "lst=[1,2,3,4,5]\n",
    "abc=lst\n",
    "abc.append(6)\n",
    "\n",
    "#print original list\n",
    "print(\"Original List: \",lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String split to create a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['one', 'two', 'three', 'four', 'five']\n"
     ]
    }
   ],
   "source": [
    "s=\"one,two,three,four,five\"\n",
    "slst=s.split(',')\n",
    "print(slst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['This', 'is', 'applied', 'AI', 'course']\n"
     ]
    }
   ],
   "source": [
    "s=\"This is applied AI course\"\n",
    "split_lst=s.split()\n",
    "print(split_lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "lst=[1,2,3,4]\n",
    "print(lst[1]) #print second element\n",
    "\n",
    "#print last element using negative index\n",
    "print(lst[-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 20, 30, 40, 50, 60, 70, 80]\n",
      "[10, 20, 30, 40]\n"
     ]
    }
   ],
   "source": [
    "numbers=[10,20,30,40,50,60,70,80]\n",
    "#print all numbers\n",
    "print(numbers[:])\n",
    "\n",
    "#print from index0 to index 3\n",
    "print(numbers[0:4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 20, 30, 40, 50, 60, 70, 80]\n",
      "[10, 30, 50, 70]\n",
      "[30, 50, 70]\n"
     ]
    }
   ],
   "source": [
    "print(numbers)\n",
    "#print alternate elements in a list\n",
    "print(numbers[::2])\n",
    "\n",
    "#print elements start from 0 through rest of the list\n",
    "print(numbers[2::2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List extending using \"+\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 'verma', 'naveen', 'murali', 'brahma']\n"
     ]
    }
   ],
   "source": [
    "lst1=[1,2,3,4]\n",
    "lst2=['verma','naveen','murali','brahma']\n",
    "lst=lst1+lst2\n",
    "\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "numbers=[1,2,3,1,3,4,2,5]\n",
    "\n",
    "#frequency of 1 in a list\n",
    "print(numbers.count(1))\n",
    "\n",
    "print(numbers.count(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Looping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "one\n",
      "two\n",
      "three\n",
      "four\n"
     ]
    }
   ],
   "source": [
    "#loop through a list \n",
    "lst=['one','two','three','four']\n",
    "\n",
    "for ele in lst:\n",
    "    print(ele)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Comprehensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
     ]
    }
   ],
   "source": [
    "#without using list comprehension\n",
    "square=[]\n",
    "for i in range(10):\n",
    "    square.append(i**2)\n",
    "print (square)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
     ]
    }
   ],
   "source": [
    "#using list comprehension\n",
    "square=[i**2 for i in range(10)]\n",
    "print(square)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-20, -40, 20, 40, 100]\n",
      "[10, 20, 50]\n",
      "[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25), (6, 36), (7, 49), (8, 64), (9, 81)]\n"
     ]
    }
   ],
   "source": [
    "#example\n",
    "\n",
    "lst=[-10,-20,10,20,50]\n",
    "\n",
    "#create a new list with values doubled\n",
    "new_lst=[i*2 for i in lst]\n",
    "print(new_lst)\n",
    "\n",
    "#filter the list to exclude negative numbers\n",
    "new_lst=[i for i in lst if i>=0]\n",
    "print(new_lst)\n",
    "\n",
    "#create a list of tuples \n",
    "new_lst=[(i,i**2) for i in range(10)]\n",
    "print(new_lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nested List Comprehensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]\n"
     ]
    }
   ],
   "source": [
    "#let's suppose we have a matrix \n",
    "matrix=[\n",
    "    [1,2,3,4],\n",
    "    [5,6,7,8],\n",
    "    [9,10,11,12]\n",
    "]\n",
    "\n",
    "#transpose of a matrix without list comprehension\n",
    "transposed=[]\n",
    "for i in range(4):\n",
    "    lst=[]\n",
    "    for row in matrix:\n",
    "        lst.append(row[i])\n",
    "    transposed.append(lst)\n",
    "    \n",
    "print(transposed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]\n"
     ]
    }
   ],
   "source": [
    "#with list comprehension\n",
    "transposed=[[row[i] for row in matrix] for i in range(4)]\n",
    "print(transposed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuple creation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n",
      "(1, 'raju', 28, 'abc')\n",
      "(1, (2, 3, 4), [1, 'raju', 28, 'abc'])\n"
     ]
    }
   ],
   "source": [
    "#empty tuple\n",
    "t=()\n",
    "\n",
    "#tuple having integers\n",
    "t=(1,2,3)\n",
    "print(t)\n",
    "\n",
    "#tuple with mixed datatypes\n",
    "t=(1,'raju',28,'abc')\n",
    "print(t)\n",
    "\n",
    "#nested tuples\n",
    "t=(1,(2,3,4),[1,'raju',28,'abc'])\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#only parenthesis is not enough\n",
    "t=('Yashaswi')\n",
    "type(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#need a comma at the end \n",
    "t=('Yashaswi',)\n",
    "type(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n",
      "('Yashaswi',)\n"
     ]
    }
   ],
   "source": [
    "#paranthesis is optional\n",
    "t=\"Yashaswi\",\n",
    "print(type(t))\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accessing Elements in Tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "murali\n"
     ]
    }
   ],
   "source": [
    "t=('Yashaswi','murali','naveen','srinu','brahma')\n",
    "\n",
    "print(t[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "brahma\n"
     ]
    }
   ],
   "source": [
    "print(t[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Yashaswi', 'naveen', 'srinu')\n"
     ]
    }
   ],
   "source": [
    "#nested tuple\n",
    "t=('ABC',('Yashaswi','naveen','srinu'))\n",
    "print(t[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "srinu\n"
     ]
    }
   ],
   "source": [
    "print((t[1][2]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3, 4)\n",
      "(1, 2, 3, 4)\n",
      "(1, 2, 3, 4, 5, 6)\n"
     ]
    }
   ],
   "source": [
    "#slicing\n",
    "t=(1,2,3,4,5,6)\n",
    "print(t[1:4])\n",
    "\n",
    "#print element from starting to 2nd last element\n",
    "print(t[:-2])\n",
    "\n",
    "#print elements from starting to end\n",
    "print(t[:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Changing a tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples are immutable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "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)",
      "\u001b[1;32m<ipython-input-41-b56c55674466>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mt\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m6\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m7\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mt\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'x'\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "#creating tuple\n",
    "t=(1,2,3,4,[5,6,7])\n",
    "\n",
    "t[2]='x' "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4, [5, 'Yashaswi', 7])\n"
     ]
    }
   ],
   "source": [
    "t[4][1]='Yashaswi'\n",
    "print (t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4, 5, 6)\n"
     ]
    }
   ],
   "source": [
    "#concatinating tuples\n",
    "t=(1,2,3)+(4,5,6)\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Yashaswi ', 'Yashaswi ', 'Yashaswi ', 'Yashaswi ')\n"
     ]
    }
   ],
   "source": [
    "#repeat the elements in a tuple for a given number of times using the * operation\n",
    "t=(('Yashaswi ',)*4)\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ### Tuple Deletion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "t=(1,2,3,4,5,6)\n",
    "del t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuple count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t=(1,2,3,1,3,3,4,1)\n",
    "\n",
    "#get the frequency of particular element appears in a tuple\n",
    "t.count(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuple Index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "t=(1,2,3,1,3,3,4,1)\n",
    "print(t.index(3)) #return index of the first eleement of the index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuple membership"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "#test if an item exists in a tuple or not , using the keyword in \n",
    "t=(1,2,3,4,5,6)\n",
    "\n",
    "print(1 in t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(7 in t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuple Length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "t=(1,2,3,4,5,6)\n",
    "print(len(t))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuple Sort"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "t=(4,5,1,2,3)\n",
    "\n",
    "new_t=sorted(t)\n",
    "print(new_t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "#get the largest element in a tuple\n",
    "t=(2,5,1,6,9)\n",
    "\n",
    "print(max(t))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(min(t))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23\n"
     ]
    }
   ],
   "source": [
    "print(sum(t))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set Creation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3}\n"
     ]
    }
   ],
   "source": [
    "#set of integers\n",
    "s={1,2,3}\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'set'>\n"
     ]
    }
   ],
   "source": [
    "print(type(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3}\n"
     ]
    }
   ],
   "source": [
    "#set doesn't allows the duplicate\n",
    "a={1,2,3,1,4}\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3}\n"
     ]
    }
   ],
   "source": [
    "#we can make a set from list\n",
    "s=set([1,2,3,1])\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'set'>\n"
     ]
    }
   ],
   "source": [
    "#initialize a set with set() method\n",
    "s=set()\n",
    "\n",
    "print(type(s))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Add element to a set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3}\n",
      "{1, 2, 3, 5, 6}\n",
      "{1, 2, 3, 5, 6, 8, 9, 10}\n"
     ]
    }
   ],
   "source": [
    "s={1,3}\n",
    "s.add(2) #add element\n",
    "print(s)\n",
    "\n",
    "s.update([5,6,1]) #add multiple elements\n",
    "print(s)\n",
    "\n",
    "s.update([8,9],{10,2,3}) #add  list and set\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Remove elements from a set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5}\n",
      "{1, 2, 3, 5}\n"
     ]
    }
   ],
   "source": [
    "s={1,2,3,5,4}\n",
    "print(s)\n",
    "\n",
    "s.discard(4)\n",
    "\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 3, 5}\n"
     ]
    }
   ],
   "source": [
    "#remove an element\n",
    "s.remove(2)\n",
    "\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 3, 5}\n"
     ]
    }
   ],
   "source": [
    "#discard an element not present in a set s\n",
    "s.discard( 7)\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "# we can remove items using pop() method\n",
    "s={1,2,3,5,4}\n",
    "s.pop()\n",
    "\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "s.pop()\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set()\n"
     ]
    }
   ],
   "source": [
    "s={1,5,2,3,6}\n",
    "s.clear() #remove all elements in set using clear() method \n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python Set Operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5, 6, 7}\n"
     ]
    }
   ],
   "source": [
    "set1={1,2,3,4,5}\n",
    "set2={3,4,5,6,7}\n",
    "#union of 2 sets using / operator\n",
    "\n",
    "print(set1|set2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5, 6, 7}\n"
     ]
    }
   ],
   "source": [
    "print(set1.union(set2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "print(set1&set2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}