5_Tuples.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import timeit"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tuples | Python for Data Science"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = [ 1, 3, 5]\n",
    "type(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = (1, 3, 5)\n",
    "type(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "88"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sys.getsizeof(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "64"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sys.getsizeof(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.055884811001305934"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "timeit.timeit(stmt=\"l = [ 1, 3, 5]\", number=1000000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.019225179003115045"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "timeit.timeit(stmt=\"t = (1, 3, 5)\", number=1000000) # tuples are faster and takes less storage than list. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Writing tuple with 1 element:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "()\n",
      "<class 'tuple'>\n",
      "1\n",
      "<class 'int'>\n",
      "(1, 2, 3)\n",
      "<class 'tuple'>\n",
      "(1,)\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "t1 = ()\n",
    "t2 = (1) # int\n",
    "t3 = (1,2,3)\n",
    "\n",
    "print(t1)\n",
    "print(type(t1))\n",
    "print(t2)\n",
    "print(type(t2)) # considers it as int\n",
    "print(t3)\n",
    "print(type(t3))\n",
    "\n",
    "t2 = (1,) \n",
    "print(t2)\n",
    "print(type(t2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "t4 = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lets see the bright side!!!\n",
      "lets see the bright side!!!\n",
      "lets see the bright side!!!\n",
      "lets see the bright side!!!\n",
      "lets see the bright side!!!\n",
      "lets see the bright side!!!\n",
      "lets see the bright side!!!\n",
      "lets see the bright side!!!\n",
      "lets see the bright side!!!\n",
      "lets see the bright side!!!\n",
      "lets see the bright side!!!\n",
      "lets see the bright side!!!\n",
      "lets see the bright side!!!\n"
     ]
    }
   ],
   "source": [
    "for i in t4:\n",
    "    print(\"lets see the bright side!!!\") # tuple is iterable "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 5, 6, 7, 8, 9)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t4[3:9] # we can slice tuple just like strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t4[3] # indexing can be used "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "t5 = (1, 1, 3, 4, 4, 4, 4, 4)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t5.count(4) # we can count number of occurrences "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t5.index(4) # gives first occurrence of given element"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a program that takes a tuple of numbers and returns the sum of all the numbers in the tuple.\n",
    "\n",
    "Write a program that takes a tuple of strings and returns a new tuple with all the strings in upper case.\n",
    "\n",
    "Write a program that takes a list of tuples, where each tuple contains a name and an age, and returns a new list of tuples sorted by age in ascending order.\n",
    "\n",
    "Write a program that takes a tuple of integers and returns a new tuple with the same integers, but in reverse order.\n",
    "\n",
    "Write a program that takes two tuples of integers of the same length and returns a new tuple with the sum of the corresponding integers in the input tuples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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.10.12"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}