Day11 - Tuples In Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **Tuples In Python**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A tuple in Python is an immutable, ordered collection of elements. It is similar to a list in that it can store a variety of data types, including numbers, strings, and other objects, but unlike lists, tuples cannot be modified once they are created. \n",
    "\n",
    "This immutability means that you can't add, remove, or change elements within a tuple after it's been defined.\n",
    "\n",
    "Characterstics\n",
    "\n",
    "- Ordered\n",
    "- Unchangeble\n",
    "- Allows duplicate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "()\n",
      "('hello',)\n",
      "<class 'tuple'>\n",
      "(1, 2, 3, 4, 5)\n",
      "(1, 2.5, True, [1, 2, 3])\n",
      "(1, 2, 3, (4, 5))\n",
      "('h', 'e', 'l', 'l', 'o')\n"
     ]
    }
   ],
   "source": [
    "# How to create empty tuple\n",
    "t1 =()\n",
    "print(t1)\n",
    "\n",
    "# creating tuple with single item\n",
    "t2 = ('hello',)\n",
    "print(t2)\n",
    "print(type(t2))\n",
    "\n",
    "# homo\n",
    "t3 = (1,2,3,4,5)\n",
    "print(t3)\n",
    "\n",
    "# hetero\n",
    "t4 = (1,2.5,True,[1,2,3])\n",
    "print(t4)\n",
    "\n",
    "# tuple\n",
    "t5 = (1,2,3,(4,5))\n",
    "print(t5)\n",
    "\n",
    "# using type conversion\n",
    "t6 = tuple('hello')\n",
    "print(t6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Accessing items in Tuples\n",
    "\n",
    "* Indexing\n",
    "* Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4, 5)\n"
     ]
    }
   ],
   "source": [
    "print(t3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "(3, 4, 5)\n"
     ]
    }
   ],
   "source": [
    "# extract 4 from the tuple\n",
    "print(t3[3])\n",
    "\n",
    "# extract 3,4,5\n",
    "print(t3[2:])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, (4, 5))\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(t5)\n",
    "t5[-1][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Editing items in tuple/Deleting  in tuple\n",
    "\n",
    "- Tuple are immutable like string it cannot change or Delete"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, (4, 5))\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'tuple' object doesn't support item deletion",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32mc:\\Users\\disha\\Downloads\\Pythoon 100 Days\\100_Days_OF_Python\\Day11 - Tuples In Python.ipynb Cell 10\u001b[0m line \u001b[0;36m2\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/disha/Downloads/Pythoon%20100%20Days/100_Days_OF_Python/Day11%20-%20Tuples%20In%20Python.ipynb#X22sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m \u001b[39mprint\u001b[39m(t5)\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/disha/Downloads/Pythoon%20100%20Days/100_Days_OF_Python/Day11%20-%20Tuples%20In%20Python.ipynb#X22sZmlsZQ%3D%3D?line=1'>2</a>\u001b[0m \u001b[39mdel\u001b[39;00m t5[\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m]\n",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object doesn't support item deletion"
     ]
    }
   ],
   "source": [
    "print(t5)\n",
    "del t5[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operation on Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4, 5, 6, 7, 8)\n",
      "True\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# + and *\n",
    "t1 = (1,2,3,4)\n",
    "t2 = (5,6,7,8)\n",
    "\n",
    "print(t1 + t2)\n",
    "\n",
    "# membership \n",
    "print(1 in t1)\n",
    "\n",
    "# iteration/loops\n",
    "for i in t3:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuple Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "15\n",
      "1\n",
      "5\n",
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "# len/sum/min/max/sorted\n",
    "t = (1,2,3,4,5)\n",
    "\n",
    "print(len(t))\n",
    "\n",
    "print(sum(t))\n",
    "\n",
    "print(min(t))\n",
    "\n",
    "print(max(t))\n",
    "\n",
    "print(sorted(t))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# count\n",
    "t = (1,2,3,4,5)\n",
    "\n",
    "t.count(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# index\n",
    "t = (4,64567,3454,11,33,55)\n",
    "\n",
    "t.index(64567)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Special Syntax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n"
     ]
    }
   ],
   "source": [
    "# tuple unpacking\n",
    "a,b,c = (1,2,3)\n",
    "print(a,b,c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 1\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "b = 2\n",
    "a,b = b,a\n",
    "\n",
    "print(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2\n",
      "[3, 4]\n"
     ]
    }
   ],
   "source": [
    "a,b,*others = (1,2,3,4)\n",
    "print(a,b)\n",
    "print(others)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((1, 5), (2, 6), (3, 7), (4, 8))"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# zipping tuples\n",
    "a = (1,2,3,4)\n",
    "b = (5,6,7,8)\n",
    "\n",
    "tuple(zip(a,b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Difference between Lists and Tuples\n",
    "Lists and tuples are both data structures in Python, but they have several differences in terms of syntax, mutability, speed, memory usage, built-in functionality, error-proneness, and usability. Let's compare them in these aspects:\n",
    "\n",
    "1. Syntax:\n",
    "   - Lists are defined using square brackets `[ ]`, e.g., `my_list = [1, 2, 3]`.\n",
    "   - Tuples are defined using parentheses `( )`, e.g., `my_tuple = (1, 2, 3)`.\n",
    "\n",
    "2. Mutability:\n",
    "   - Lists are mutable, which means you can change their elements after creation using methods like `append()`, `insert()`, or direct assignment.\n",
    "   - Tuples are immutable, which means once created, you cannot change their elements. You would need to create a new tuple if you want to modify its contents.\n",
    "\n",
    "3. Speed:\n",
    "   - Lists are slightly slower than tuples in terms of performance because they are mutable. Modifying a list may involve resizing or copying elements, which can introduce overhead.\n",
    "   - Tuples, being immutable, are generally faster for accessing elements because they are more memory-efficient and do not require resizing or copying.\n",
    "\n",
    "4. Memory:\n",
    "   - Lists consume more memory than tuples due to their mutability. Lists require extra memory to accommodate potential resizing and other internal bookkeeping.\n",
    "   - Tuples are more memory-efficient since they don't have the overhead associated with mutable data structures.\n",
    "\n",
    "5. Built-in Functionality:\n",
    "   - Both lists and tuples have common operations like indexing, slicing, and iteration.\n",
    "   - Lists offer more built-in methods for manipulation, such as `append()`, `insert()`, `remove()`, and `extend()`. Lists are better suited for situations where you need to add or remove elements frequently.\n",
    "   - Tuples have a more limited set of operations due to their immutability but offer security against accidental modifications.\n",
    "\n",
    "6. Error-Prone:\n",
    "   - Lists are more error-prone when it comes to accidental modification, especially in large codebases, as they can be changed throughout the code.\n",
    "   - Tuples are less error-prone since they cannot be modified once created, making them more predictable.\n",
    "\n",
    "7. Usability:\n",
    "   - Lists are typically used when you need a collection of items that can change over time. They are suitable for situations where you want to add, remove, or modify elements.\n",
    "   - Tuples are used when you want to create a collection of items that should not change during the program's execution. They provide safety and immutability.\n",
    "\n",
    "In summary, the choice between lists and tuples depends on your specific needs. Use lists when you require mutability and dynamic resizing, and use tuples when you want to ensure immutability and need a more memory-efficient, error-resistant data structure."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.18"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}