tips.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cool Python Cheat Codes / Tips - 2024"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A. Working Numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### -- Assign Multiple Variables on One Line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value of 'a' is 12 and Value of 'a' is 30\n"
     ]
    }
   ],
   "source": [
    "a, b = 12, 30 \n",
    "\n",
    "# Rather \n",
    "# a = 12\n",
    "# b = 30\n",
    "\n",
    "print(\"Value of 'a' is\" , a ,\"and Value of 'a' is\" , b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Raise a number to a Power"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Power of 3 raise to 5:  243\n"
     ]
    }
   ],
   "source": [
    "power = pow(3, 5)\n",
    "print(\"Power of 3 raise to 5: \", power)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Banker's Rounding - Half towards Even"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Round of 10.5 is 10\n",
      "Round of 11.5 is 12\n"
     ]
    }
   ],
   "source": [
    "print(\"Round of 10.5 is\" , round(10.5)) # round down to 10\n",
    "print(\"Round of 11.5 is\" , round(11.5)) # round up to 12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### --  Using \"Underscores\" in Large Numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Billion : 1000000000\n"
     ]
    }
   ],
   "source": [
    "billion = 1_000_000_000\n",
    "print(\"Billion :\", billion)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Primitive data types are \"Immutable\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Address of data1 is:  2615765789264\n",
      "Address of data1 is:  2615765788976\n",
      "Data 1 now is:  10\n"
     ]
    }
   ],
   "source": [
    "primitive_data1 = 10\n",
    "primitive_data2 = primitive_data1\n",
    "primitive_data2 = 1 # replaced data2\n",
    "\n",
    "print(\"Address of data1 is: \", id(primitive_data1)) # different addresses\n",
    "print(\"Address of data1 is: \", id(primitive_data2)) # different addresses\n",
    "print(\"Data 1 now is: \", primitive_data1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Check if exists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial value of 'age': 16\n",
      "'age' in locals(): True\n",
      "'age' in globals(): True\n",
      "'age' in locals(): False\n",
      "'age' in globals(): False\n",
      "\n",
      "\n",
      "After setting 'age' to None: None\n",
      "'age' in locals(): True\n",
      "'age' in globals(): True\n"
     ]
    }
   ],
   "source": [
    "# Set the variable 'age' to the value 16\n",
    "age = 16\n",
    "print(\"Initial value of 'age':\", age)\n",
    "\n",
    "# Check if 'age' is in the local and global namespaces\n",
    "print(\"'age' in locals():\", 'age' in locals())\n",
    "print(\"'age' in globals():\", 'age' in globals())\n",
    "\n",
    "# Delete the variable 'age'\n",
    "del age\n",
    "# print(\"After deleting 'age':\", age)  # This will raise an error since 'age' is deleted\n",
    "\n",
    "# Check again if 'age' is in the local and global namespaces\n",
    "print(\"'age' in locals():\", 'age' in locals())\n",
    "print(\"'age' in globals():\", 'age' in globals())\n",
    "\n",
    "print(\"\\n\")\n",
    "# Set the variable 'age' to the value None\n",
    "age = None\n",
    "print(\"After setting 'age' to None:\", age)\n",
    "\n",
    "# Check again if 'age' is in the local and global namespaces\n",
    "print(\"'age' in locals():\", 'age' in locals())\n",
    "print(\"'age' in globals():\", 'age' in globals())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Unpacking operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Character to 5 10 15\n"
     ]
    }
   ],
   "source": [
    "def position(x, y, z):\n",
    "    print(f'Character to {x} {y} {z}')\n",
    "    \n",
    "pos = [5, 10, 15]\n",
    "position(*pos) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Using \"all\" operator instead of \"and\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You're a standard user. Not allowed the access.\n"
     ]
    }
   ],
   "source": [
    "age = 21\n",
    "reputation = 20\n",
    "\n",
    "conditions = [ \n",
    "    age >= 21,\n",
    "    reputation > 25\n",
    "]\n",
    "    \n",
    "if all(conditions):\n",
    "    print(\"You're an admin. Allowed the access.\")\n",
    "else:\n",
    "    print(\"You're a standard user. Not allowed the access.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Using \"any\" operator instead of \"or\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You're an admin. Allowed the access.\n"
     ]
    }
   ],
   "source": [
    "age = 21\n",
    "reputation = 20\n",
    "\n",
    "conditions = [ \n",
    "    age >= 21,\n",
    "    reputation > 25\n",
    "]\n",
    "    \n",
    "if any(conditions):\n",
    "    print(\"You're an admin. Allowed the access.\")\n",
    "else:\n",
    "    print(\"You're a standard user. Not allowed the access.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## B. Working with String"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Printing Colored Text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[97mCoding is \u001b[92mexciting\n",
      "\u001b[97mCoding is \u001b[92mcreative\n",
      "\u001b[97mCoding is \u001b[91mchallenging\n",
      "\u001b[97mCoding is \u001b[91mstressful\n",
      "\n",
      "\n",
      "\u001b[93mCoding Everyday!\n"
     ]
    }
   ],
   "source": [
    "print(f\"\\033[97mCoding is \\033[92mexciting\")\n",
    "print(f\"\\033[97mCoding is \\033[92mcreative\")\n",
    "print(f\"\\033[97mCoding is \\033[91mchallenging\")\n",
    "print(f\"\\033[97mCoding is \\033[91mstressful\")\n",
    "print(\"\\n\")\n",
    "print(f\"\\033[93mCoding Everyday!\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Open a Web Browser"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import webbrowser\n",
    "\n",
    "webbrowser.open('https://www.google.com')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Concatenation without \"+\" Operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, this string concatenation without using '+' sign.\n"
     ]
    }
   ],
   "source": [
    "message = \"Hello, this \" \"string concatenation\" \" without using '+' sign.\"\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- \"split\" Function of string object "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Analytical Nikita.io\n"
     ]
    }
   ],
   "source": [
    "full_name = \"Analytical_Nikita.io\"\n",
    "first_name , last_name = full_name.split(sep= \"_\")\n",
    "print(first_name, last_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- \"join\" Function of string object "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Analytical_Nikita.io\n"
     ]
    }
   ],
   "source": [
    "names = [\"Analytical\", \"Nikita.io\"]\n",
    "full_name = \"_\".join(names)\n",
    "print(full_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Working with \"in\" Substring "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The substring is present at 0 index.\n"
     ]
    }
   ],
   "source": [
    "if \"Analytical\" in \"AnalyticalNikita.io\":\n",
    "    print(\"The substring is present at\", \"AnalyticalNikita.io\".index(\"Analytical\"), \"index.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Note: If the value is not present in the substring it will throw error. For this reason we use find() funtion."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Get index using find() method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The substring is present at -1 index.\n"
     ]
    }
   ],
   "source": [
    "print(\"The substring is present at\", \"AnalyticalNikita.io\".find(\"Analytics\"), \"index.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Using \"id\" to get identity of the data\n",
    "Guarenteed to be unique for each object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Address of this data is:  2615849709376\n"
     ]
    }
   ],
   "source": [
    "data = {\"AnalyticalNikita.io\": 1}\n",
    "print(\"Address of this data is: \", id(data))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Aliases\n",
    "We use an alias if we want two variables pointing to the same data or if we want functions to be able to modify arguments passed it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Address of data1 is:  2615850448448\n",
      "Address of data2 is:  2615850448448\n",
      "Data1 now is:  {'AnalyticalNikita.io': 1, 'DataAnalytics': 9}\n"
     ]
    }
   ],
   "source": [
    "data1 =  {\"AnalyticalNikita.io\": 1}\n",
    "data2 = data1\n",
    "data2['DataAnalytics'] = 9\n",
    "\n",
    "print(\"Address of data1 is: \",id(data1))\n",
    "print(\"Address of data2 is: \",id(data2))\n",
    "print(\"Data1 now is: \", data1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Using print end = \" \" to change ending"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python SQL Power BI Tableau SAS Alterxy \n"
     ]
    }
   ],
   "source": [
    "favorite_technologies = [\"Python\", \"SQL\", \"Power BI\", \"Tableau\", \"SAS\", \"Alterxy\"]\n",
    "\n",
    "for technology in (favorite_technologies):\n",
    "    print(technology, end = \" \")\n",
    "    \n",
    "print(\"\") #to go to next line for the next output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### --  Print multiple elements with commas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AnalyticalNikita.io is proficient in ['Python', 'SQL', 'Power BI', 'Tableau', 'SAS', 'Alterxy']\n"
     ]
    }
   ],
   "source": [
    "name = \"AnalyticalNikita.io\"\n",
    "favorite_technologies = [\"Python\", \"SQL\", \"Power BI\", \"Tableau\", \"SAS\", \"Alterxy\"]\n",
    "\n",
    "print(name, \"is proficient in\", favorite_technologies)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- String formatting using \"f-string\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is AnalyticalNikita.io.\n"
     ]
    }
   ],
   "source": [
    "name = \"AnalyticalNikita.io\"\n",
    "\n",
    "print(f\"My name is {name}.\") #implict string conversion\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Returning multiple values and Assigning to multiple variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A tuple (5, 10, 15, 20)\n",
      "Assigning to multiple variables:  x is 5 y is 10 z is 15 a is 20\n"
     ]
    }
   ],
   "source": [
    "def returning_position():\n",
    "    #get from user or something\n",
    "    return 5, 10, 15, 20\n",
    "\n",
    "print(\"A tuple\", returning_position()) \n",
    "x, y, z, a = returning_position()\n",
    "print(\"Assigning to multiple variables: \", \"x is\", x, \"y is\", y,\"z is\", z,\"a is\", a)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Ternary conditional operator or string comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "admin\n",
      "visitor\n"
     ]
    }
   ],
   "source": [
    "# Method 1: If - else\n",
    "reputation = 30\n",
    "if reputation > 25:\n",
    "    name = \"admin\"\n",
    "else:\n",
    "    name = \"visitor\"\n",
    "print(name)\n",
    "\n",
    "# Method 2: String comprehension\n",
    "reputation = 20\n",
    "name = \"admin\" if reputation > 25 else \"visitor\"\n",
    "print(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Flag variable: \n",
    "Break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yes, 'orange' is in the list.\n",
      "apple banana orange grape kiwi \n",
      "Yes, 'kiwi' is in the list.\n",
      "apple banana orange grape kiwi apple \n",
      "No 'grapefruit' found in the list.\n"
     ]
    }
   ],
   "source": [
    "fruits = ['apple', 'banana', 'orange', 'grape', 'kiwi', 'apple']\n",
    "\n",
    "# Option 1: Check if 'orange' is in the list directly\n",
    "if 'orange' in fruits: print(\"Yes, 'orange' is in the list.\")\n",
    "\n",
    "# Option 2: Use a flag variable to check for 'kiwi'\n",
    "kiwi_found = False # Assume\n",
    "for fruit in fruits:\n",
    "    print(fruit, end=\" \") # do something with each element if needed\n",
    "    if fruit == 'kiwi':\n",
    "        kiwi_found = True # could count elements\n",
    "        break\n",
    "\n",
    "if kiwi_found: print(\"\\nYes, 'kiwi' is in the list.\")\n",
    "\n",
    "# Option 3: Check if 'grapefruit' is in the list without using break\n",
    "for fruit in fruits:\n",
    "    print(fruit, end=\" \")\n",
    "    if fruit == 'grapefruit':\n",
    "        break\n",
    "else: #no break\n",
    "    print(\"\\nNo 'grapefruit' found in the list.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Remove list duplicates using set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unique fruits are:  ['apple', 'kiwi', 'banana']\n"
     ]
    }
   ],
   "source": [
    "fruits = ['apple', 'banana', 'banana', 'banana', 'kiwi', 'apple']\n",
    "unique_fruits = list(set(fruits))\n",
    "print(\"Unique fruits are: \", unique_fruits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Using \"in\" method instead of complex conditional \n",
    "It is popularly used while Checking against list of values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Plan is cancelled\n"
     ]
    }
   ],
   "source": [
    "weather = \"rainy\"\n",
    "\n",
    "if weather in ['rainy', 'cold', 'snowy']:\n",
    "    print(\"Plan is cancelled\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# C. Working with List/s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Reverse a List with Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reversed of the string :  [5, 4, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "data = [1, 2, 3, 4, 5]\n",
    "print(\"Reversed of the string : \", data[::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Reverse a List using reverse() method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reversed of the string :  [5, 4, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "data = [1, 2, 3, 4, 5]\n",
    "data.reverse()\n",
    "print(\"Reversed of the string : \", data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- in-place  methods\n",
    "Python operate \"IN PLACE\", like [].sort and [].reverse -- the algorithm does not use extra space for manipulating the input but may require a small though nonconstant extra space for its operation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Address of original list is:  2615849898048\n",
      "Sorted list is:  [1, 2, 3]\n",
      "Address of Sorted list is:  2615849898048\n",
      "Reversed list is:  [3, 2, 1]\n",
      "Address of Reversed  list is:  2615849898048\n"
     ]
    }
   ],
   "source": [
    "sort_data = [3, 2, 1]\n",
    "print(\"Address of original list is: \", id(sort_data))\n",
    "sort_data.sort()\n",
    "print(\"Sorted list is: \", sort_data)\n",
    "print(\"Address of Sorted list is: \", id(sort_data))\n",
    "sort_data.reverse()\n",
    "print(\"Reversed list is: \", sort_data)\n",
    "print(\"Address of Reversed  list is: \", id(sort_data))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hence all three addresses are same."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Replacing \"list\" vs Replacing list's \"content\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original list of languages is: ['C', 'C++', 'JavaScript', 'Python']\n",
      "Modified list of languages is: ['C', 'C++', 'JavaScript', 'Python']\n",
      "Unmodified list of languages is: ['Programming Languages']\n"
     ]
    }
   ],
   "source": [
    "# Modifies argument pass in (Replace the list with new list)\n",
    "def replace_list(data):\n",
    "    \"\"\"\n",
    "    The function `replace_list(data)` is creating a new local variable `data` and assigning it the value `['Programming Languages']`. \n",
    "    This does not modify the original list `programming_languages` that was passed as an argument.\n",
    "    \"\"\"\n",
    "    data = ['Programming Languages']\n",
    "    \n",
    "# Doesn't Modifies argument pass in (Change the data of the list)\n",
    "def replace_list_content(data):\n",
    "    \"\"\"\n",
    "    The function `replace_list_content` is modifying the content of the list passed as an argument. \n",
    "    It uses the slice assignment `data[:]` to replace all the elements in the list with the new list `['Programming Languages']`. \n",
    "    This means that the original list `programming_languages` will be modified and will now contain only the element `'Programming Languages'`.\n",
    "    \"\"\"\n",
    "    data[:] = ['Programming Languages']\n",
    "    \n",
    "    # If you need to keep same id just use slicing\n",
    "    \n",
    "    \n",
    "programming_languages = ['C', 'C++', 'JavaScript', 'Python']\n",
    "\n",
    "print(\"Original list of languages is:\", programming_languages)\n",
    "\n",
    "# When function modifies the passed-in argument:\n",
    "replace_list(programming_languages)\n",
    "print(\"Modified list of languages is:\", programming_languages)\n",
    "\n",
    "# When function modifies the content of the passed-in argument:\n",
    "replace_list_content(programming_languages)\n",
    "print(\"Unmodified list of languages is:\", programming_languages) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Copying a List using \"Slicing\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Id of 'programming_languages' is : 1899836578560 \n",
      "Id of 'learning_programming_languages' is : 1899836579328\n"
     ]
    }
   ],
   "source": [
    "# Do not point to same exact list address in the memory even if it is copied\n",
    "programming_languages = ['C', 'C++', 'JavaScript', 'Python']\n",
    "learning_programming_lamnguages = programming_languages[:]\n",
    "\n",
    "print(\"Id of 'programming_languages' is :\", id(programming_languages), \"\\n\" \"Id of 'learning_programming_languages' is :\", id(learning_programming_lamnguages))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Copy a List using \"copy()\" method\n",
    "Return a shallow copy of 'programming_language'. If there is any Nested objects just the reference to those objects is what copied (address) and the data object iself is not copied."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Id of 'programming_languages' is : 1899836614272 \n",
      "Id of 'learning_programming_languages' is : 1899836577536\n"
     ]
    }
   ],
   "source": [
    "programming_languages = ['C', 'C++', 'JavaScript', 'Python']\n",
    "learning_programming_lamnguages = programming_languages.copy() \n",
    "\n",
    "print(\"Id of 'programming_languages' is :\", id(programming_languages), \"\\n\" \"Id of 'learning_programming_languages' is :\", id(learning_programming_lamnguages))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Copying a List using \"deepcopy()\"\n",
    "A deep copy constructs a new compound object and then, recursively, inserts copies into it of the objects found in the original."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original List: [1, ['X', 3], [4, 5]]\n",
      "Shallow Copied List: [1, ['X', 3], [4, 5]]\n",
      "Deep Copied List: [1, [2, 3], [4, 5]]\n"
     ]
    }
   ],
   "source": [
    "import copy\n",
    "\n",
    "original_list = [1, [2, 3], [4, 5]]\n",
    "shallow_copied_list = copy.copy(original_list)\n",
    "deep_copied_list = copy.deepcopy(original_list) # To use 'deepcopy' : from copy import deepcopy\n",
    "\n",
    "# Modify the original list\n",
    "original_list[1][0] = 'X'\n",
    "\n",
    "print(\"Original List:\", original_list)\n",
    "print(\"Shallow Copied List:\", shallow_copied_list)\n",
    "print(\"Deep Copied List:\", deep_copied_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Concatenating lists using \"+\" Operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The concatenated list is: [1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "x = [1, 2, 3]\n",
    "y = [4, 5, 6]\n",
    "z = [7, 8, 9]\n",
    "\n",
    "print(\"The concatenated list is:\", x + y + z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Comparing \"not\" vs \"is None\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Is data1 empty: True\n",
      "Is data1 None: False\n",
      "Is data2 Empty: True\n",
      "Is data2 None: True\n"
     ]
    }
   ],
   "source": [
    "data1 = []\n",
    "data2 = None\n",
    "print(\"Is data1 empty:\", not data1)\n",
    "print(\"Is data1 None:\", data1 is None)\n",
    "\n",
    "\n",
    "# None evaluates to false\n",
    "print(\"Is data2 Empty:\", not data2) # `not data2` is checking if `data2` is empty or evaluates to `False`. In this case, since `data2` is `None`, it evaluates to `False`, so `not data2` evaluates to `True`.\n",
    "print(\"Is data2 None:\",data2 is None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Checking a list is empty or none\n",
    "\"Not data\" work whether it's \"None\" or \"empty\" list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None or empty list: True\n",
      "Anything but None: False\n",
      "None only: True\n"
     ]
    }
   ],
   "source": [
    "data = None # []\n",
    "\n",
    "print(\"None or empty list:\", not data) #empty, None, or zero \n",
    "\n",
    "#You can also check these things:\n",
    "print(\"Anything but None:\", data is not None) \n",
    "print(\"None only:\", data is None) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Use range to generate lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 3, 6, 9]\n",
      "<class 'range'>\n"
     ]
    }
   ],
   "source": [
    "print(list(range(0, 10, 3)))\n",
    "print(type(range(0, 10, 3))) # python 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- List comprehension (Removing certain elements from a list) instead of \"for row\" loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fruits are:  ['banana', 'orange', 'grape']\n"
     ]
    }
   ],
   "source": [
    "fruits = ['apple', 'banana', 'orange', 'grape', 'kiwi', 'apple']\n",
    "\n",
    "removing_fruits = [fruit for fruit in fruits if fruit not in [\"kiwi\", \"apple\"]]\n",
    "print(\"Fruits are: \", removing_fruits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- List \"reversed\" method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple kiwi grape orange banana apple "
     ]
    }
   ],
   "source": [
    "fruits = ['apple', 'banana', 'orange', 'grape', 'kiwi', 'apple']\n",
    "for pet in reversed(fruits):\n",
    "    print(pet, end=\" \")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### --  \"flatten\" a list of nested lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Flattened List (using nested loop): [1, 2, 3, 4, 5, 6, 7, 8]\n",
      "Flattened List (using list comprehension): [1, 2, 3, 4, 5, 6, 7, 8]\n",
      "Flattened List (using recursive function): [1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "nested_list = [[1, 2, 3], [4, 5], [6, 7, 8]]\n",
    "\n",
    "\n",
    "# Method 1: Using Nested Loop:\n",
    "\n",
    "flattened_list = []\n",
    "for sublist in nested_list:\n",
    "    for item in sublist:\n",
    "        flattened_list.append(item)\n",
    "\n",
    "print(\"Flattened List (using nested loop):\", flattened_list)\n",
    "\n",
    "\n",
    "# Method 2: Using List Comprehension:\n",
    "flattened_list = [item for sublist in nested_list for item in sublist]\n",
    "\n",
    "print(\"Flattened List (using list comprehension):\", flattened_list)\n",
    "\n",
    "# Method 3 : Using Recursive Function:\n",
    "def flatten_list(nested_list):\n",
    "    flattened_list = []\n",
    "    for item in nested_list:\n",
    "        if isinstance(item, list):\n",
    "            flattened_list.extend(flatten_list(item))\n",
    "        else:\n",
    "            flattened_list.append(item)\n",
    "    return flattened_list\n",
    "\n",
    "nested_list = [[1, 2, 3], [4, 5], [6, 7, [8, 9]]]\n",
    "flattened_list_recursive = flatten_list(nested_list)\n",
    "\n",
    "print(\"Flattened List (using recursive function):\", flattened_list_recursive)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Space separated numbers to integer list\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The list:  [1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "user_input = \"1 2 3 4 5\"\n",
    "new_list = list(map(int, user_input.split()))\n",
    "print(\"The list: \", new_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Combine two lists as a list of lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('Alice', 80), ('Bob', 300), ('Eva', 50), ('David', 450)]\n"
     ]
    }
   ],
   "source": [
    "# Different set of names and points\n",
    "names = ['Alice', 'Bob', 'Eva', 'David']\n",
    "points = [80, 300, 50, 450]\n",
    "\n",
    "zipped = list(zip(names, points))\n",
    "\n",
    "print(zipped)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Convert list of tuples to list of lists\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['Alice', 80], ['Bob', 300], ['Eva', 50], ['David', 450]]\n"
     ]
    }
   ],
   "source": [
    "# Different set of names and points\n",
    "names = ['Alice', 'Bob', 'Eva', 'David']\n",
    "points = [80, 300, 50, 450]\n",
    "\n",
    "zipped = list(zip(names, points))\n",
    "\n",
    "data = [list(item) for item in zipped]\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# D. General "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- \"do-while\" loop in python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Choose an option:\n",
      "1. play game\n",
      "2. load game\n",
      "3. high scores\n",
      "4. quit\n"
     ]
    }
   ],
   "source": [
    "\n",
    "while True:\n",
    "    print(\"\"\"Choose an option:\n",
    "1. play game\n",
    "2. load game\n",
    "3. high scores\n",
    "4. quit\"\"\")\n",
    "    \n",
    "    # if input() == \"4\":\n",
    "    if True: \n",
    "        break\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Doing nothing in Python with \"pass\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "def positional_variables():\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- enumerate() function insted of range(len())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index 0: apple\n",
      "Index 1: banana\n",
      "Index 2: kiwi\n",
      "Index 3: orange\n",
      "\n",
      "\n",
      "Index 1: apple\n",
      "Index 2: banana\n",
      "Index 3: kiwi\n",
      "Index 4: orange\n"
     ]
    }
   ],
   "source": [
    "fruits = ['apple', 'banana', 'kiwi', 'orange']\n",
    "\n",
    "# Using enumerate to iterate over the list with both index and value\n",
    "for index, fruit in enumerate(fruits):\n",
    "    print(f\"Index {index}: {fruit}\")\n",
    "\n",
    "print(\"\\n\")\n",
    "# You can also specify a start index (default is 0)\n",
    "for index, fruit in enumerate(fruits, start=1):\n",
    "    print(f\"Index {index}: {fruit}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Assigning a function to a variable - just don’t use ()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Doing things....\n"
     ]
    }
   ],
   "source": [
    "def done():\n",
    "    print(\"done\")\n",
    "   \n",
    "def do_something(callback):\n",
    "    print(\"Doing things....\") # callback function as an argument and prints \"Doing things....\" before calling the provided callback.\n",
    "   \n",
    "    \"\"\"\n",
    "    callback()  # Call the provided callback function \n",
    "    \n",
    "    # to print output \n",
    "    Doing things....\n",
    "    done\n",
    "    \"\"\"\n",
    "    \n",
    "# Call do_something with the done function as the callback\n",
    "do_something(done)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Wait with time.sleep"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Doing things....\n",
      "done\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "def done():\n",
    "    print(\"done\")\n",
    "   \n",
    "def do_something(callback):\n",
    "    time.sleep(2) # it will print output after some time for ex 2 means 2.0s\n",
    "    print(\"Doing things....\") # callback function as an argument and prints \"Doing things....\" before calling the provided callback.\n",
    "    callback() # Call the provided callback function \n",
    "\n",
    "    \n",
    "# Call do_something with the done function as the callback\n",
    "do_something(done)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Sort complex iterables with sorted()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorted data:  [{'name': 'Max', 'age': 6}, {'name': 'Max', 'age': 36}, {'name': 'Max', 'age': 61}]\n"
     ]
    }
   ],
   "source": [
    "dictionary_data = [{\"name\": \"Max\", \"age\": 6},\n",
    "                   {\"name\": \"Max\", \"age\": 61},\n",
    "                   {\"name\": \"Max\", \"age\": 36},\n",
    "                   ]\n",
    "\n",
    "sorted_data = sorted(dictionary_data, key=lambda x : x[\"age\"])\n",
    "print(\"Sorted data: \", sorted_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Save memory with \"Generators\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "499500\n",
      "Size of list 8856 bytes\n",
      "499500\n",
      "Size of generator 112 bytes\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "\n",
    "my_list = [i for i in range(1000)]\n",
    "print(sum(my_list))\n",
    "print(\"Size of list\", sys.getsizeof(my_list), \"bytes\")\n",
    "\n",
    "\n",
    "my_gen = (i for i in range(1000))\n",
    "print(sum(my_gen))\n",
    "print(\"Size of generator\", sys.getsizeof(my_gen), \"bytes\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Using zip:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number: 1, Letter: a\n",
      "Number: 2, Letter: b\n",
      "Number: 3, Letter: c\n"
     ]
    }
   ],
   "source": [
    "# Example using zip with two lists\n",
    "numbers = [1, 2, 3]\n",
    "letters = ['a', 'b', 'c']\n",
    "\n",
    "# Zip combines corresponding elements from both lists\n",
    "zipped_result = zip(numbers, letters)\n",
    "\n",
    "# Iterate over the zipped result\n",
    "for number, letter in zipped_result:\n",
    "    print(f\"Number: {number}, Letter: {letter}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Using zip_longest from itertools:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number: 1, Letter: a\n",
      "Number: 2, Letter: b\n",
      "Number: 3, Letter: N/A\n"
     ]
    }
   ],
   "source": [
    "from itertools import zip_longest\n",
    "\n",
    "# Example using zip_longest with two lists of different lengths\n",
    "numbers = [1, 2, 3]\n",
    "letters = ['a', 'b']\n",
    "\n",
    "# zip_longest fills missing values with a specified fillvalue (default is None)\n",
    "zipped_longest_result = zip_longest(numbers, letters, fillvalue='N/A')\n",
    "\n",
    "# Iterate over the zipped_longest result\n",
    "for number, letter in zipped_longest_result:\n",
    "    print(f\"Number: {number}, Letter: {letter}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Default Arguments\n",
    "When you have default values, you can pass arugments by name positional arguments must remain on the left "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['Alice', 100], ['Bob', 250], ['Eva', 30], ['David', 600], ['Sam', None], ['Ace', None]]\n"
     ]
    }
   ],
   "source": [
    "from itertools import zip_longest\n",
    "\n",
    "\n",
    "def zip_lists(list1=[], list2=[], longest=True):\n",
    "    if longest:\n",
    "        return [list(item) for item in zip_longest(list1, list2)]\n",
    "    else:\n",
    "        return [list(item) for item in zip(list1, list2)]\n",
    "    \n",
    "names = ['Alice', 'Bob', 'Eva', 'David', 'Sam', 'Ace']\n",
    "points = [100, 250, 30, 600]\n",
    "\n",
    "print(zip_lists(names, points))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Keyword Arguments\n",
    "You can pass named arguments in any order and can skip them even."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[None, 'Eva']]\n"
     ]
    }
   ],
   "source": [
    "from itertools import zip_longest\n",
    "\n",
    "\n",
    "def zip_lists(list1=[], list2=[], longest=True):\n",
    "    if longest:\n",
    "        return [list(item) for item in zip_longest(list1, list2)]\n",
    "    else:\n",
    "        return [list(item) for item in zip(list1, list2)]\n",
    "\n",
    "\n",
    "print(zip_lists(longest=True, list2=['Eva']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Get the Python version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.9.13\n"
     ]
    }
   ],
   "source": [
    "from platform import python_version\n",
    "\n",
    "print(python_version())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Define default values in Dictionaries with .get() and .setdefault()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Count is there or not: None\n",
      "Count is there or not: 9\n",
      "Updated my_dict: {'name': 'Max', 'age': 6, 'count': 9}\n"
     ]
    }
   ],
   "source": [
    "my_dict = {\"name\": \"Max\", \"age\": 6}                   \n",
    "count = my_dict.get(\"count\")\n",
    "print(\"Count is there or not:\", count)\n",
    "\n",
    "# Setting default value if count is none\n",
    "count = my_dict.setdefault(\"count\", 9)\n",
    "print(\"Count is there or not:\", count)\n",
    "print(\"Updated my_dict:\", my_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Using \"Counter\" from collections "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Count of the numbers are:  Counter({2: 4, 4: 4, 1: 2, 3: 1, 5: 1})\n",
      "Most Common Number is:  (2, 4)\n"
     ]
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "my_list = [1,2,1,2,2,2,4,3,4,4,5,4]\n",
    "counter = Counter(my_list)\n",
    "print(\"Count of the numbers are: \", counter)\n",
    "\n",
    "most_commmon = counter.most_common(2) # passed in Number will denotes how many common numbers we want (counting starts from 1-n)\n",
    "print(\"Most Common Number is: \", most_commmon[0]) # printin zeroth index element from 2 most common ones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Merging two dictionaries using **"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Here is merged dictionary:  {'name': 'Max', 'age': 6, 'city': 'NY'}\n"
     ]
    }
   ],
   "source": [
    "d1 = {\"name\": \"Max\", \"age\": 6}   \n",
    "d2 = {\"name\": \"Max\", \"city\": \"NY\"}   \n",
    "\n",
    "merged_dict = {**d1, **d2}\n",
    "print(\"Here is merged dictionary: \", merged_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Get current date and time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2023-11-22 22:23:49.672825\n",
      "22 11 2023 22 23 49\n"
     ]
    }
   ],
   "source": [
    "from datetime import datetime\n",
    "now = datetime.now()\n",
    "print(now)\n",
    "print(now.day, now.month, now.year, now.hour, now.minute, now.second)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Countdown\n",
    "You can do this in a loop if you need.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1087 days, 1:34:50.201422\n"
     ]
    }
   ],
   "source": [
    "now = datetime.now()\n",
    "end = datetime(2020, 12, 1)\n",
    "print(end-now) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Elapsed time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'datetime.timedelta'>\n",
      "0:00:02.690219\n",
      "2 690219\n"
     ]
    }
   ],
   "source": [
    "start = datetime.now()\n",
    "\n",
    "for i in range(100_000_000): # to pass time\n",
    "    pass\n",
    "\n",
    "end = datetime.now()\n",
    "\n",
    "print(type(end-start))\n",
    "elapsed = end-start\n",
    "print(elapsed)\n",
    "print(elapsed.seconds, elapsed.microseconds)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Parentheses for operations with object members\n",
    "operator precedence - dot operator comes ahead of +/- operator.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "Wrong\n"
     ]
    }
   ],
   "source": [
    "now = datetime.now()\n",
    "then = datetime.now()\n",
    "\n",
    "elapsed = (then-now).microseconds\n",
    "print(elapsed)\n",
    "\n",
    "try:\n",
    "    print(then-now.microseconds)\n",
    "except:\n",
    "    print(\"Wrong\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Runtime error vs syntax error\n",
    "Syntax errors are impossible to be correct and will prevent execution\n",
    "\n",
    "Runtime errors deal with incorrect data found during runtime"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Get a random number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "from random import randint\n",
    "print(randint(0, 12)) #inclusive #inclusive"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Class Parenthesis Optional but Not Function Parenthesis\n",
    "- It shows two ways to define a class: class Container(): and class Container:.\n",
    "- The parentheses after Container are optional for classes, but they are needed if you are inheriting from another class.\n",
    "- In contrast, function parentheses are always required when defining a function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Container():\n",
    "    def __init__(self, data):\n",
    "        self.data = data\n",
    "\n",
    "class Container: \n",
    "    def __init__(self, data):\n",
    "        self.data = data\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Wrapping a Primitive to Change Within a Function\n",
    "Container is a simple class that wraps a primitive (in this case, an integer)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3125\n"
     ]
    }
   ],
   "source": [
    "# The code defines a class called `Container` with a constructor method `__init__` \n",
    "# that takes a parameter `data` and assigns it to an instance variable `self.data`.\n",
    "class Container:\n",
    "    def __init__(self, data):\n",
    "        self.data = data\n",
    "    \n",
    "def calculate(input):\n",
    "    input.data **= 5\n",
    "    \n",
    "container = Container(5)\n",
    "calculate(container)\n",
    "print(container.data)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Compare Identity with \"is\" operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1274963509840 1274946106128\n",
      "False\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "c1 = Container(5)\n",
    "c2 = Container(5)\n",
    "\n",
    "print(id(c1), id(c2))\n",
    "print(id(c1) == id(c2))  # returns False because they are different objects.\n",
    "print(c1 is c2) # same objects but returns False because they are distinct instances.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Add a Method Dynamically\n",
    "- A custom __eq__ method is defined outside the class.\n",
    "- This method is then added to the Container class dynamically using Container.__eq__ = __eq__.\n",
    "- The print(Container.__eq__) statement shows the memory address of the __eq__ method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function __eq__ at 0x00000128D8FE04C0>\n"
     ]
    }
   ],
   "source": [
    "def __eq__(self, other):\n",
    "    return self.data == other.data\n",
    "\n",
    "Container.__eq__ = __eq__\n",
    "\n",
    "print(Container.__eq__)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Now Compare by Value\n",
    "The __eq__ method added dynamically in the previous step is used for the equality check (c1 == c2)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "c1 = Container(5)\n",
    "c2 = Container(5)\n",
    "\n",
    "print(c1 == c2)  # Compares by value\n",
    "# This time, the result is True because the custom __eq__ method compares \n",
    "# the values inside the Container instances.\n",
    "\n",
    "print(c1 is c2)  # Compares by identity (address)\n",
    "# The is operator still returns False because it checks for identity.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Fibonacci Generator and Yield\n",
    "- fib is a generator function that generates Fibonacci numbers up to a specified count.\n",
    "- gen is an instance of the generator, and next is used to retrieve the next values.\n",
    "- The second loop demonstrates using a generator in a for loop to print the first 20 Fibonacci numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 1 2 3\n",
      "0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 "
     ]
    }
   ],
   "source": [
    "def fib(count):\n",
    "    a, b = 0, 1\n",
    "    while count:\n",
    "        yield a\n",
    "        a, b = b, b + a\n",
    "        count -= 1\n",
    "\n",
    "gen = fib(100)\n",
    "print(next(gen), next(gen), next(gen), next(gen), next(gen))\n",
    "\n",
    "for i in fib(20):\n",
    "    print(i, end=\" \")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### --  Infinite Number and Infinite Generator\n",
    "- math.inf represents positive infinity.\n",
    "- The fib generator is used with an infinite loop, and values are printed until the condition i >= 200 is met.\n",
    "\n",
    "This code demonstrates the use of positive infinity, a Fibonacci number generator, and how to break out of the generator loop based on a condition.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inf\n",
      "inf inf\n",
      "0 1 1 2 3 5 8 13 21 34 55 89 144 "
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "# Printing Infinity: special floating-point representation \n",
    "print(math.inf)\n",
    "\n",
    "# Assign infinity to a variable and perform an operation\n",
    "inf = math.inf\n",
    "print(inf, inf - 1)  # Always infinity, Even when subtracting 1, the result is still infinity\n",
    "\n",
    "\n",
    "# Fibonacci Generator:\n",
    "def fib(count):\n",
    "    a, b = 0, 1\n",
    "    while count:\n",
    "        yield a\n",
    "        a, b = b, b + a\n",
    "        count -= 1\n",
    "\n",
    "# Using the Fibonacci Generator:\n",
    "# Use the Fibonacci generator with an infinite count\n",
    "f = fib(math.inf)\n",
    "\n",
    "# Iterate through the Fibonacci numbers until a condition is met\n",
    "for i in f:\n",
    "    if i >= 200:\n",
    "        break\n",
    "    print(i, end=\" \")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- List from Generator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.0, 1.0, 1.0, 1.414, 1.732, 2.236, 2.828, 3.606, 4.583, 5.831]\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "# The code is creating a Fibonacci sequence generator using a generator function called `fib`.\n",
    "def fib(count):\n",
    "    a, b = 0, 1\n",
    "    while count:\n",
    "        yield a\n",
    "        a, b = b, b + a\n",
    "        count -= 1\n",
    "\n",
    "# The `fib` function takes a parameter `count` which determines the number of Fibonacci numbers to generate.\n",
    "f = fib(10)\n",
    "\n",
    "# This code generates Fibonacci numbers and creates a list containing the square root of each Fibonacci number.\n",
    "data = [round(math.sqrt(i), 3) for i in f]\n",
    "print(data)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Simple Infinite Generator with \"itertools\"\n",
    "The generator function could be simpler without having to take a max count property.\n",
    "This can be done easily with itertools."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181]\n"
     ]
    }
   ],
   "source": [
    "import itertools\n",
    "\n",
    "def fib():\n",
    "    a, b = 0, 1\n",
    "    while True:\n",
    "        yield a\n",
    "        a, b = b, b + a\n",
    "\n",
    "# itertools.islice is used to get the first 20 values from an infinite generator.\n",
    "print(list(itertools.islice(fib(), 20)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Iterate Through Custom Type with __iter__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "10\n",
      "15\n",
      "20\n"
     ]
    }
   ],
   "source": [
    "# Defines a custom LinkedList class with a Node class as an element.\n",
    "\n",
    "class Node:\n",
    "    def __init__(self, data, next_node=None):\n",
    "        self.data = data\n",
    "        self.next = next_node\n",
    "\n",
    "class LinkedList:\n",
    "    def __init__(self, start):\n",
    "        self.start = start\n",
    "    \n",
    "    # The __iter__ method is implemented to allow iteration over the linked list.\n",
    "    def __iter__(self):\n",
    "        node = self.start\n",
    "        while node:\n",
    "            yield node\n",
    "            node = node.next\n",
    "            \n",
    "ll = LinkedList(Node(5, Node(10, Node(15, Node(20)))))\n",
    "for node in ll:\n",
    "    print(node.data)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### -- Falsey for Custom Types (not)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "4\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Demonstrates how not works with custom types, considering an empty list as True.\n",
    "print(not [])  # True because it's empty\n",
    "print(len([]) == 0)  # This is how `not` is evaluated\n",
    "\n",
    "# Adds a custom __len__ method to the LinkedList class to get the length of the linked list.\n",
    "def __len__(self):\n",
    "    count = 0\n",
    "    for i in self:\n",
    "        count += 1\n",
    "    return count\n",
    "\n",
    "LinkedList.__len__ = __len__\n",
    "    \n",
    "ll = LinkedList(Node(5, Node(10, Node(15, Node(20)))))\n",
    "print(len(ll))\n",
    "ll = LinkedList(None)\n",
    "print(not ll)  # True\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}