6. Tuples, list and dict cont.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "878018de-50f1-4c3b-b169-6f8c50c2141f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'Rajat Jain', 'course': 'Python'}\n"
     ]
    }
   ],
   "source": [
    "dict1 = {\n",
    "    \"name\" : \"Rajat Jain\",\n",
    "    'course' : 'Python',\n",
    "}\n",
    "\n",
    "print(dict1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77a65b4b-cef2-4909-9668-50bb62e82a0b",
   "metadata": {},
   "source": [
    "## Tuples in python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "38d87302-b58a-4de7-8bad-b362169fc624",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(12, 14, 'Rajat')\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "t1 = (12, 14, \"Rajat\")\n",
    "print(t1)\n",
    "print(type(t1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "85b77750-6491-46c1-9435-0139cb785f42",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rajat\n"
     ]
    }
   ],
   "source": [
    "print(t1[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "ad50fd4f-f15d-4b42-aa7c-5c0b6bbe258f",
   "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)",
      "Cell \u001b[1;32mIn[27], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m t1[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m100\u001b[39m\n",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "t1[0] = 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "0bfe035d-db62-40b1-8011-0af5da4fb169",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2428223858240\n",
      "2428224051456\n",
      "(100, 50)\n"
     ]
    }
   ],
   "source": [
    "t1 = (12, 14, \"Rajat\")\n",
    "print(id(t1))\n",
    "t1 = (100, 50)\n",
    "print(id(t1))\n",
    "print(t1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "5b9af2d5-742e-4042-b162-45accf343821",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5092506917918050556"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(hash(t1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "da74b35f-aaab-4c04-a89d-3d489cf7c64b",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'Rajat Jain', 'course': 'Python', (23, 34): 'abc'}\n"
     ]
    }
   ],
   "source": [
    "dict1 = {\n",
    "    \"name\" : \"Rajat Jain\",\n",
    "    'course' : 'Python',\n",
    "    (23, 34): \"abc\"\n",
    "}\n",
    "del dict1['name']\n",
    "print(dict1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "82b2ba43-b9e4-4b74-ba26-dfb52800c05e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "t2 = tuple([1,2,3])\n",
    "print(t2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "cdf48fb2-b491-4f4c-bddd-e4d0be00102d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "34 55\n"
     ]
    }
   ],
   "source": [
    "def myfunc():\n",
    "    return (34, 55)\n",
    "\n",
    "x = myfunc()\n",
    "print(x[0], x[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 274,
   "id": "c226ff4d-7e97-4e37-8e5a-1aaf813c2ff9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'key1': 'val1', 'key2': 'val2'}\n",
      "2428225822912\n",
      "{'key1': 'newVal', 'key2': 'val2'}\n",
      "2428225822912\n"
     ]
    }
   ],
   "source": [
    "f1={\n",
    "    'key1' : 'val1',\n",
    "    'key2' : 'val2',\n",
    "}\n",
    "print(f1)\n",
    "print(id(f1))\n",
    "\n",
    "f1['key1']='newVal'\n",
    "print(f1)\n",
    "print(id(f1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "7e4240df-0cd4-4e8b-b97e-4fda18155589",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "a = tuple([3])\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "089a9fc2-e017-4c5f-b269-cb5f00d58ea9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inside: [1, 2, 3, 5]\n",
      "Outside:  (1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "list1 = p1,2,3)\n",
    "\n",
    "def myFun(mylist):\n",
    "    x = list(mylist) # new reference\n",
    "    x.append(5)\n",
    "    print('inside:', x )\n",
    "\n",
    "myFun(list1)\n",
    "print(\"Outside: \", list1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "307bb0d7-5a4f-4869-b42f-bbf5940221ed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "x = [1,2,3]\n",
    "y = x\n",
    "y.append(4)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5028d00e-8f9a-47f8-81b5-deb102030ee5",
   "metadata": {},
   "source": [
    "### Copying a list with new reference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "37610446-1d70-42c0-b665-e217d76b3fb8",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [1,2,3]\n",
    "y = x.copy()\n",
    "# for i in x:\n",
    "#     y.append(i)\n",
    "# y = x\n",
    "y.append(4)\n",
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5837909-53a1-42a0-bdcd-b2e399781898",
   "metadata": {},
   "source": [
    "### Nested Dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "e2397089-ee61-4112-8a19-a58d33d598ab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': [1, 2, 3], 'b': [100, 200, 300], 'c': (7, 8, 9), 'd': {'1': ['A', 'B', 'C'], '2': 'Hello'}}\n"
     ]
    }
   ],
   "source": [
    "list1 = [1,2,3]\n",
    "list2 = [\"A\", \"B\", \"C\"]\n",
    "t2 = (7,8,9)\n",
    "\n",
    "dict1 = {\n",
    "    'a' : list1,\n",
    "    'b' : [100, 200, 300],\n",
    "    'c' : t2,\n",
    "    'd' : {\n",
    "        '1' : list2,\n",
    "        '2' : 'Hello'\n",
    "    }\n",
    "}\n",
    "print(dict1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "b136a89b-12f7-4d4b-b1f3-3d6eec3d8641",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': [1, 2, 3], 'b': [100, 200, 300, 20], 'c': (7, 8, 9), 'd': {'1': ['A', 'B', 'C'], '2': 'Hello'}}\n"
     ]
    }
   ],
   "source": [
    "dict2 = dict1\n",
    "dict2['b'].append(20)\n",
    "print(dict1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "95fdd0ad-b280-472d-99b7-ee4777c946d7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': [1, 2, 3], 'b': [100, 200, 300], 'c': (7, 8, 9), 'd': {'1': ['A', 'B', 'C'], '2': 'Hello'}}\n"
     ]
    }
   ],
   "source": [
    "list1 = [1,2,3]\n",
    "list2 = [\"A\", \"B\", \"C\"]\n",
    "t2 = (7,8,9)\n",
    "\n",
    "dict1 = {\n",
    "    'a' : list1,\n",
    "    'b' : [100, 200, 300],\n",
    "    'c' : t2,\n",
    "    'd' : {\n",
    "        '1' : list2,\n",
    "        '2' : 'Hello'\n",
    "    }\n",
    "}\n",
    "print(dict1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "87bcb9f5-7451-4e7e-927f-5d6a5d9ff690",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'B'"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict1['d']['1'][1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "42a9b8dd-403c-4b46-b233-ad050986ffa1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': [1, 2, 3], 'b': [100, 200, 300], 'c': (7, 8, 9), 'd': {'1': ['A', 'B', 'C'], '2': 'Hello'}}\n",
      "{'a': [1, 2, 3], 'b': [100, 200, 300, 40], 'c': (7, 8, 9), 'd': {'1': ['A', 'B', 'C'], '2': 'Hello'}}\n"
     ]
    }
   ],
   "source": [
    "dict2 = dict1.copy()\n",
    "# dict2['b'] = dict1['b'].copy()\n",
    "dict2['b'].append(40)\n",
    "print(dict1)\n",
    "print(dict2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "id": "21d09a5c-26ee-4c93-8397-9640fdd91bad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': [1, 2, 3],\n",
      " 'b': [100, 200, 300],\n",
      " 'c': (7, 8, 9),\n",
      " 'd': {'1': ['A', 'B', 'C'], '2': 'Hello'}}\n",
      "{'a': [1, 2, 3],\n",
      " 'b': [100, 200, 300],\n",
      " 'c': (7, 8, 9),\n",
      " 'd': {'1': ['A', 'B', 'C'], '2': 'world'}}\n"
     ]
    }
   ],
   "source": [
    "import pprint\n",
    "list1 = [1,2,3]\n",
    "list2 = [\"A\", \"B\", \"C\"]\n",
    "t2 = (7,8,9)\n",
    "\n",
    "dict1 = {\n",
    "    'a' : list1,\n",
    "    'b' : [100, 200, 300],\n",
    "    'c' : t2,\n",
    "    'd' : {\n",
    "        '1' : list2,\n",
    "        '2' : 'Hello'\n",
    "    }\n",
    "}\n",
    "dict2 = dict1.copy()\n",
    "dict2['d'] = dict2['d'].copy()\n",
    "dict2['d']['2'] = \"world\"\n",
    "pprint.pprint(dict1)\n",
    "pprint.pprint(dict2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "068d755d-abb8-4d57-82ef-9bf9a4723821",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = dict['d']\n",
    "x['name'] = \"Rajat"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c6ebe9a-801f-4d1f-b915-1bec969de648",
   "metadata": {},
   "source": [
    "#### Tuples cannot be copied"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "id": "f55131c3-6919-4255-91d6-e95dcafa221f",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'tuple' object has no attribute 'copy'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[142], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m t3 \u001b[38;5;241m=\u001b[39m (\u001b[38;5;241m7\u001b[39m,\u001b[38;5;241m8\u001b[39m,\u001b[38;5;241m9\u001b[39m)\n\u001b[1;32m----> 2\u001b[0m t4 \u001b[38;5;241m=\u001b[39m t3\u001b[38;5;241m.\u001b[39mcopy()\n",
      "\u001b[1;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'copy'"
     ]
    }
   ],
   "source": [
    "t3 = (7,8,9)\n",
    "t4 = t3.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "a3d36316-7acd-4127-9456-5c672e11197e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2428225264256\n",
      "2428225263040\n"
     ]
    }
   ],
   "source": [
    "x = (1,2,3)\n",
    "y = (1,2,3)\n",
    "print(id(x))\n",
    "print(id(y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "id": "f410e66d-4278-4135-93d5-03127baa7d46",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "529344067295497451\n",
      "529344067295497451\n"
     ]
    }
   ],
   "source": [
    "print(hash(x))\n",
    "print(hash(y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "id": "ec08a130-9bc7-4354-b993-4a7ffb3ad04f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "Keys:  ['b', 'e', 'a', 'c']\n",
      "Keys:  ['a', 'b', 'c', 'e']\n",
      "30\n",
      "10\n",
      "40\n",
      "20\n"
     ]
    }
   ],
   "source": [
    "dict2 = {\n",
    "    'b' : 10,\n",
    "    'e' : 20,\n",
    "    'a' : 30,\n",
    "    'c' : 40\n",
    "}\n",
    "x = list(dict2.keys())\n",
    "print(type(x))\n",
    "print(\"Keys: \", x)\n",
    "x.sort()\n",
    "print(\"Keys: \", x)\n",
    "for i in x:\n",
    "    print(dict2[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "id": "ce82288e-d5a8-40d3-8964-c61be8114586",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n"
     ]
    }
   ],
   "source": [
    "l1 = [0] * 10\n",
    "print(l1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "id": "3932e0e3-0b5d-4a43-a060-91013c1b268f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n"
     ]
    }
   ],
   "source": [
    "x = [[1,2,3], [4,5,6], [7,8,9]]\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "id": "d9392ea0-5945-4db1-a200-22e766f4c04b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[100, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
      "[[100, 2, 3], [4, 5, 6], [7, 8, 9]]\n"
     ]
    }
   ],
   "source": [
    "x = [[1,2,3], [4,5,6], [7,8,9]]\n",
    "y = x.copy()\n",
    "y[0][0] = 100\n",
    "print(x)\n",
    "print(y)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "id": "d1b72ddd-b223-44da-8826-5aaa8cd9529a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2, 3], [4, 5, 6], [7, 8, 9, 10, 11]]\n",
      "[[1, 2, 3], [4, 5, 6], [7, 8, 9, 10, 11], [10, 11, 12]]\n"
     ]
    }
   ],
   "source": [
    "x = [[1,2,3], [4,5,6], [7,8,9, 10 ,11]]\n",
    "y = x.copy()\n",
    "y.append([10,11,12])\n",
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e0bf433-436d-4675-a49e-785cc4bd89d6",
   "metadata": {},
   "source": [
    "### 2D array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 268,
   "id": "f65e4251-e32c-4fdd-8e51-c5042545702f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
      " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
      " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
      " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
      " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
      " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
      " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
      " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
      " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
      " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]\n",
      "[[0, 0, 0, 100, 0, 0, 0, 0, 0, 0], [0, 0, 0, 100, 0, 0, 0, 0, 0, 0], [0, 0, 0, 100, 0, 0, 0, 0, 0, 0], [0, 0, 0, 100, 0, 0, 0, 0, 0, 0], [0, 0, 0, 100, 0, 0, 0, 0, 0, 0], [0, 0, 0, 100, 0, 0, 0, 0, 0, 0], [0, 0, 0, 100, 0, 0, 0, 0, 0, 0], [0, 0, 0, 100, 0, 0, 0, 0, 0, 0], [0, 0, 0, 100, 0, 0, 0, 0, 0, 0], [0, 0, 0, 100, 0, 0, 0, 0, 0, 0]]\n"
     ]
    }
   ],
   "source": [
    "import pprint\n",
    "l1 = [0] * 10\n",
    "l2 = [ [0] * 10] * 10\n",
    "# l2 = []\n",
    "# for i in range(10):\n",
    "#     l2.append([0] * 10)\n",
    "pprint.pprint(l2)\n",
    "l2[1][3] = 100\n",
    "print(l2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 260,
   "id": "8fbb4470-dcb6-4ecb-922c-3631646143f0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]\n"
     ]
    }
   ],
   "source": [
    "l2 = []\n",
    "for i in range(10):\n",
    "    x = []\n",
    "    for j in range(10):\n",
    "        x.append(0)\n",
    "    l2.append(x)\n",
    "print(l2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "id": "2f99c1e5-dfdf-442c-8e5e-a117730e498f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
      " [0, 0, 0, 100, 0, 0, 0, 0, 0, 0],\n",
      " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
      " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
      " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
      " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
      " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
      " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
      " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
      " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]\n"
     ]
    }
   ],
   "source": [
    "l2[1][3] = 100\n",
    "pprint.pprint(l2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 280,
   "id": "d5479208-a081-45f8-8434-28ed68f6aee4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': [1, 2, 3], 'b': [100, 200, 300], 'c': (7, 8, 9), 'd': {'1': ['A', 'B', 'C'], '2': 'Hello'}}\n",
      "{'a': [1, 2, 3, 101], 'b': [100, 200, 300], 'c': (7, 8, 9), 'd': {'1': ['A', 'B', 'C'], '2': 'Hello'}}\n",
      "{'a': [1, 2, 3, 101], 'b': [100, 200, 300], 'c': (7, 8, 9), 'd': {'1': ['A', 'B', 'C'], '2': 'Hello'}}\n",
      "{'a': [1, 2, 3, 101], 'b': [100, 200, 300], 'c': (7, 8, 9), 'd': {'1': ['A', 'B', 'C'], '2': 'Hello'}}\n"
     ]
    }
   ],
   "source": [
    "list1 = [1,2,3]\n",
    "list2 = [\"A\", \"B\", \"C\"]\n",
    "t2 = (7,8,9)\n",
    "\n",
    "dict1 = {\n",
    "    'a' : list1,\n",
    "    'b' : [100, 200, 300],\n",
    "    'c' : t2,\n",
    "    'd' : {\n",
    "        '1' : list2,\n",
    "        '2' : 'Hello'\n",
    "    }\n",
    "}\n",
    "\n",
    "dict2 = dict1.copy()\n",
    "dict2['a'] = dict2['a'].copy()\n",
    "dict2['a'].append(101)\n",
    "print(dict1)\n",
    "print(dict2)\n",
    "\n",
    "dict2 = dict1\n",
    "dict2['a'].append(101)\n",
    "print(dict1)\n",
    "print(dict2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69dbd53a-cb17-4b67-befa-0491085dfeee",
   "metadata": {},
   "source": [
    "### List comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 286,
   "id": "1f3a44e2-0c97-465c-9af6-c4d10d7b7119",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple', 'banana', 'cherry', 'kiwi', 'mango']\n",
      "['apple', 'banana', 'cherry', 'kiwi', 'mango']\n"
     ]
    }
   ],
   "source": [
    "fruits = [\"apple\", \"banana\", \"cherry\", \"kiwi\", \"mango\"]\n",
    "\n",
    "x = []\n",
    "for i in fruits:\n",
    "    x.append(i)\n",
    "\n",
    "y = [i for i in fruits]\n",
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 292,
   "id": "5b6d8488-e6f5-4cb4-b418-d13cbce565d7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple', 'banana', 'mango']\n",
      "['apple', 'banana', 'cherry', 'mango']\n"
     ]
    }
   ],
   "source": [
    "fruits = [\"apple\", \"banana\", \"cherry\", \"kiwi\", \"mango\"]\n",
    "\n",
    "x = []\n",
    "for i in fruits:\n",
    "    if 'a' in i:  \n",
    "        x.append(i)\n",
    "\n",
    "y = [ i for i in fruits if \"a\" in i ]\n",
    "\n",
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 294,
   "id": "d9904ce2-dce4-4a5b-873a-f512721c9486",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple', 'banana', 'cherry', 'mango']\n"
     ]
    }
   ],
   "source": [
    "fruits = [\"apple\", \"banana\", \"cherry\", \"kiwi\", \"mango\"]\n",
    "\n",
    "y = [ i for i in fruits if len(i) > 4 ]\n",
    "\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 308,
   "id": "5c8bbd8e-3ed8-4983-8a3f-40351e2f0872",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['H', 'E', 'L', 'L', 'O', ' ', 'W', 'O', 'E', 'L', 'D']\n",
      "['H', 'E', 'L', 'L', 'O', ' ', 'W', 'O', 'E', 'L', 'D']\n"
     ]
    }
   ],
   "source": [
    "x = \"Hello Woeld\"\n",
    "y = [i.upper() for i in x]\n",
    "print(y)\n",
    "\n",
    "z = []\n",
    "for i in x:\n",
    "    z.append(i.upper())\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 314,
   "id": "4ac300b8-38b7-4a3c-9a05-d0857cdf6982",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple', 'orange', 'cherry', 'kiwi', 'mango']\n"
     ]
    }
   ],
   "source": [
    "fruits = [\"apple\", \"banana\", \"cherry\", \"kiwi\", \"mango\"]\n",
    "x= []\n",
    "for i in fruits:\n",
    "    if i != \"banana\":\n",
    "        x.append(i)\n",
    "    else:\n",
    "        x.append(\"orange\")\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 318,
   "id": "8f434684-c22e-4c13-be19-7ea5661acbc6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple', 'orange', 'cherry', 'kiwi', 'mango']\n"
     ]
    }
   ],
   "source": [
    "fruits = [\"apple\", \"banana\", \"cherry\", \"kiwi\", \"mango\"]\n",
    "x = [i if i!= \"banana\" else \"orange\" for i in fruits]\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0fc875b-caac-468d-951d-1e7073d68711",
   "metadata": {},
   "source": [
    "#### More examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 346,
   "id": "d2fa14d6-7296-48a6-bf6a-e8b7e52be0ed",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unhashable type: 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[346], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m x \u001b[38;5;241m=\u001b[39m ([\u001b[38;5;241m1\u001b[39m,\u001b[38;5;241m2\u001b[39m,\u001b[38;5;241m3\u001b[39m], [\u001b[38;5;241m4\u001b[39m,\u001b[38;5;241m5\u001b[39m,\u001b[38;5;241m6\u001b[39m])\n\u001b[1;32m----> 2\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;28mhash\u001b[39m(x))\n\u001b[0;32m      3\u001b[0m \u001b[38;5;28mprint\u001b[39m(x)\n\u001b[0;32m      4\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;28mtype\u001b[39m(x))\n",
      "\u001b[1;31mTypeError\u001b[0m: unhashable type: 'list'"
     ]
    }
   ],
   "source": [
    "x = ([1,2,3], [4,5,6])\n",
    "print(hash(x))\n",
    "print(x)\n",
    "print(type(x))\n",
    "print(x[0].append(4))\n",
    "print(x)\n",
    "\n",
    "# print(hash(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 344,
   "id": "82bcf712-7235-4eed-a813-258cca534fb5",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unhashable type: 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[344], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m mydict \u001b[38;5;241m=\u001b[39m {\n\u001b[0;32m      2\u001b[0m     ([\u001b[38;5;241m1\u001b[39m,\u001b[38;5;241m2\u001b[39m,\u001b[38;5;241m3\u001b[39m], [\u001b[38;5;241m4\u001b[39m,\u001b[38;5;241m5\u001b[39m,\u001b[38;5;241m6\u001b[39m]) : \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhello\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m      3\u001b[0m }\n\u001b[0;32m      4\u001b[0m \u001b[38;5;28mprint\u001b[39m(mydict)\n",
      "\u001b[1;31mTypeError\u001b[0m: unhashable type: 'list'"
     ]
    }
   ],
   "source": [
    "mydict = {\n",
    "    ([1,2,3], [4,5,6]) : \"hello\"\n",
    "}\n",
    "print(mydict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 350,
   "id": "c88e7aaf-bd74-4a29-bd63-ced17b4a7e8b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{(1, 2): ([1, 2, 3], [4, 5, 6])}\n"
     ]
    }
   ],
   "source": [
    "dict1 = {\n",
    "    (1,2) : ([1,2,3], [4,5,6]),\n",
    "}\n",
    "print(dict1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 352,
   "id": "1c5f2600-8cab-4653-b2bd-d22fbdcb32eb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class dict in module builtins:\n",
      "\n",
      "class dict(object)\n",
      " |  dict() -> new empty dictionary\n",
      " |  dict(mapping) -> new dictionary initialized from a mapping object's\n",
      " |      (key, value) pairs\n",
      " |  dict(iterable) -> new dictionary initialized as if via:\n",
      " |      d = {}\n",
      " |      for k, v in iterable:\n",
      " |          d[k] = v\n",
      " |  dict(**kwargs) -> new dictionary initialized with the name=value pairs\n",
      " |      in the keyword argument list.  For example:  dict(one=1, two=2)\n",
      " |\n",
      " |  Built-in subclasses:\n",
      " |      StgDict\n",
      " |\n",
      " |  Methods defined here:\n",
      " |\n",
      " |  __contains__(self, key, /)\n",
      " |      True if the dictionary has the specified key, else False.\n",
      " |\n",
      " |  __delitem__(self, key, /)\n",
      " |      Delete self[key].\n",
      " |\n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |\n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |\n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |\n",
      " |  __getitem__(self, key, /)\n",
      " |      Return self[key].\n",
      " |\n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |\n",
      " |  __init__(self, /, *args, **kwargs)\n",
      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
      " |\n",
      " |  __ior__(self, value, /)\n",
      " |      Return self|=value.\n",
      " |\n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |\n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |\n",
      " |  __len__(self, /)\n",
      " |      Return len(self).\n",
      " |\n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |\n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |\n",
      " |  __or__(self, value, /)\n",
      " |      Return self|value.\n",
      " |\n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |\n",
      " |  __reversed__(self, /)\n",
      " |      Return a reverse iterator over the dict keys.\n",
      " |\n",
      " |  __ror__(self, value, /)\n",
      " |      Return value|self.\n",
      " |\n",
      " |  __setitem__(self, key, value, /)\n",
      " |      Set self[key] to value.\n",
      " |\n",
      " |  __sizeof__(...)\n",
      " |      D.__sizeof__() -> size of D in memory, in bytes\n",
      " |\n",
      " |  clear(...)\n",
      " |      D.clear() -> None.  Remove all items from D.\n",
      " |\n",
      " |  copy(...)\n",
      " |      D.copy() -> a shallow copy of D\n",
      " |\n",
      " |  get(self, key, default=None, /)\n",
      " |      Return the value for key if key is in the dictionary, else default.\n",
      " |\n",
      " |  items(...)\n",
      " |      D.items() -> a set-like object providing a view on D's items\n",
      " |\n",
      " |  keys(...)\n",
      " |      D.keys() -> a set-like object providing a view on D's keys\n",
      " |\n",
      " |  pop(...)\n",
      " |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.\n",
      " |\n",
      " |      If the key is not found, return the default if given; otherwise,\n",
      " |      raise a KeyError.\n",
      " |\n",
      " |  popitem(self, /)\n",
      " |      Remove and return a (key, value) pair as a 2-tuple.\n",
      " |\n",
      " |      Pairs are returned in LIFO (last-in, first-out) order.\n",
      " |      Raises KeyError if the dict is empty.\n",
      " |\n",
      " |  setdefault(self, key, default=None, /)\n",
      " |      Insert key with a value of default if key is not in the dictionary.\n",
      " |\n",
      " |      Return the value for key if key is in the dictionary, else default.\n",
      " |\n",
      " |  update(...)\n",
      " |      D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.\n",
      " |      If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]\n",
      " |      If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v\n",
      " |      In either case, this is followed by: for k in F:  D[k] = F[k]\n",
      " |\n",
      " |  values(...)\n",
      " |      D.values() -> an object providing a view on D's values\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods defined here:\n",
      " |\n",
      " |  __class_getitem__(...)\n",
      " |      See PEP 585\n",
      " |\n",
      " |  fromkeys(iterable, value=None, /)\n",
      " |      Create a new dictionary with keys from iterable and values set to value.\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |\n",
      " |  __new__(*args, **kwargs)\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |\n",
      " |  __hash__ = None\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 360,
   "id": "8da3c030-b144-4353-b017-48e4c3b1ecb2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4)\n",
      "<class 'tuple'>\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "(1, 2, 3, 4, 5, 65, 7)\n",
      "<class 'tuple'>\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "65\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "def my_function(*args):\n",
    "    print(args)\n",
    "    print(type(args))\n",
    "    for arg in args:\n",
    "        print(arg)\n",
    "\n",
    "my_function(1, 2, 3, 4)\n",
    "\n",
    "my_function(1, 2, 3, 4,5,65,7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 370,
   "id": "65a89642-c812-4b2f-8d66-0e97541e35c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "140703205964312\n",
      "140703205964312\n",
      "140703205964312\n"
     ]
    }
   ],
   "source": [
    "a = 4\n",
    "print(id(a))\n",
    "b = a\n",
    "print(id(b))\n",
    "\n",
    "x = 4\n",
    "print(id(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "62794d2e-cfc2-45d6-88f5-3fba5594a7ea",
   "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.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}