04 Learn_Tuple.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Learn Tuple\n",
    "\n",
    "1. A tuple is a sequence of values much like a list. \n",
    "2. The values stored in a tuple can be any type, and they are indexed by integers.\n",
    "3. The important difference is that tuples are #immutable.\n",
    "4. A tuple is created by placing all the items (elements) inside by parenthesis().\n",
    "    \n",
    "  - **Create Tuple** \n",
    "  - **Update Tuple**\n",
    "  - **Delete Tuple** \n",
    "  - **Slicing Tuple**   \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create Tuple :- "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('sumsung', 'LG', 'OnePlus', 'Apple')\n",
      "<class 'tuple'>\n",
      "()\n",
      "<class 'tuple'>\n",
      "sumsung\n",
      "<class 'str'>\n",
      "('sumsung',)\n",
      "<class 'tuple'>\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "#Way 1:\n",
    "mobiles = ('sumsung', 'LG', 'OnePlus', 'Apple')\n",
    "        \n",
    "print(mobiles)\n",
    "print(type(mobiles))\n",
    "\n",
    "#********************************************************************\n",
    "\n",
    "#Way 2: \n",
    "#Create empty Tuple\n",
    "mobiles = ()\n",
    "\n",
    "print(mobiles)\n",
    "print(type(mobiles))\n",
    "\n",
    "#********************************************************************\n",
    "\n",
    "#Way 3:\n",
    "# Create single value Tuple - note possible in this way\n",
    "mobiles = ('sumsung')\n",
    "print(mobiles)\n",
    "print(type(mobiles))\n",
    "\n",
    "#Create single value Tuple\n",
    "mobiles = ('sumsung', )\n",
    "print(mobiles)\n",
    "print(type(mobiles))\n",
    "\n",
    "#********************************************************************\n",
    "\n",
    "#Way 4:\n",
    "# Create tuple with collection of values\n",
    "mobiles = 'sumsung', 'LG', 'OnePlus'\n",
    "print(type(mobiles))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Update Tuple:-"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('sumsung', 'LG', 'OnePlus', 'Apple', 1, 2, 3, 4)\n"
     ]
    }
   ],
   "source": [
    "mobiles = ('sumsung', 'LG', 'OnePlus', 'Apple')\n",
    "number = (1,2,3,4)\n",
    "\n",
    "Order = mobiles + number\n",
    "print(Order)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Delete Tuple:-"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'Order' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-9-62f146f50f19>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;31m# can Delete entire Tuple only\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;32mdel\u001b[0m \u001b[0mOrder\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 6\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mOrder\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'Order' is not defined"
     ]
    }
   ],
   "source": [
    "# for Del - Note:: We cann't delete individual value in item\n",
    "# del Order[1]\n",
    "\n",
    "# can Delete entire Tuple only\n",
    "del Order\n",
    "print(Order)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Slicing Tuple (Accessing Item in Tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('sumsung', 'LG', 'OnePlus', 'Apple', 'OnePlus')\n",
      "('OnePlus', 'Apple', 'OnePlus', 'LG', 'sumsung')\n",
      "('sumsung', 'LG', 'OnePlus')\n",
      "('sumsung', 'OnePlus', 'OnePlus')\n",
      "('OnePlus', 'OnePlus', 'sumsung')\n"
     ]
    }
   ],
   "source": [
    "mobiles = ('sumsung', 'LG', 'OnePlus', 'Apple', 'OnePlus')\n",
    "print(mobiles[0::])\n",
    "\n",
    "print(mobiles[::-1])\n",
    "print(mobiles[0:-2:])\n",
    "print(mobiles[0::2])\n",
    "# print(mobiles[::-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic Operations - Tuples:-"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ## Tuple:-\n",
    "   - **for length             :     len(tuple)**               :     its return count of item\n",
    "   - **for Concatenation      :     var_a + var_b**            :     its concatenate 2 diff tuples (Note: new tuple output)\n",
    "   - **for Repetation         :     tuple_var_a*2**            :     its printed tuple twice\n",
    "   - **for membership         :     in / not in**              :     its return True or False(based on Condition)\n",
    "   - **for Iterative          :     for loop**                 :     its returns each item in the tuple\n",
    "   - **for maximum            :     max(tuple)**               :     its will return maximum item in the tuple\n",
    "   - **for minimum            :     min(tuple)**               :     its will return minium item in the tuple\n",
    "   - **for index              :     tuple_var.index(ele)**     :     its will return item position in the tuple\n",
    "   - **for count              :     tuple_var.count(ele)**     :     its will return element count in the tuple\n",
    "   - **for String to tuple    :     tuple('test')**            :     output -> ('t', 'e', 's', 't')\n",
    "   - **for list to tuple      :     tuple(list)**              :     output -> (tuple output)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## get the count of tuple items:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mobiles = ('sumsung', 'LG', 'OnePlus')\n",
    "len(mobiles)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Concatenate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('sumsung', 'LG', 'OnePlus', 1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "mobiles = ('sumsung', 'LG', 'OnePlus')\n",
    "items = (1,2,3)\n",
    "\n",
    "m_item = mobiles + items\n",
    "print(m_item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Repetations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('sumsung', 'LG', 'OnePlus', 'sumsung', 'LG', 'OnePlus')"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mobiles * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## membership - in / not in"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "-----------------------------\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "mobiles = ('sumsung', 'LG', 'OnePlus')\n",
    "\n",
    "print('LG' in mobiles)\n",
    "print('iphone' in mobiles)\n",
    "\n",
    "print('-----------------------------')\n",
    "\n",
    "print('iphone' not in mobiles)\n",
    "print('LG' not in mobiles)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## for loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sumsung\n",
      "LG\n",
      "OnePlus\n"
     ]
    }
   ],
   "source": [
    "for i in mobiles:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## maximum - minimum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximum item :: sumsung\n",
      "Minimum item :: LG\n"
     ]
    }
   ],
   "source": [
    "print('Maximum item ::', max(mobiles))\n",
    "print('Minimum item ::', min(mobiles))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## element index item number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mobiles = ('sumsung', 'LG', 'OnePlus')\n",
    "mobiles.index('LG')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## element item count "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mobiles = ('sumsung', 'LG', 'OnePlus', 'LG')\n",
    "mobiles.count('OnePlus')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## String to Tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('T', 'e', 's', 't', 'l', 'e', 'a', 'f')\n",
      "----------------------------------------\n",
      "('a', 'b', 'c', 'd')\n",
      "['a', 'b', 'c', 'd']\n"
     ]
    }
   ],
   "source": [
    "a = 'Testleaf'\n",
    "print(tuple(a))\n",
    "\n",
    "print('----------------------------------------')\n",
    "\n",
    "# List to Tuple\n",
    "b = ['a', 'b', 'c', 'd']\n",
    "print(tuple(b))\n",
    "\n",
    "z = tuple(b)\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mobiles = ('sumsung', 'LG', 'OnePlus', 'Apple', None)\n",
    "\n",
    "for i in mobiles:\n",
    "    if (i == None):\n",
    "        print('its null value')"
   ]
  }
 ],
 "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}