Python-Tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "055074cc-d13a-40a9-859b-290c54d26f43",
   "metadata": {},
   "source": [
    "**Python** is interpreted, interactive, and object-oriented scripting language\n",
    "\n",
    "# Python is an interpreted language\n",
    "An interpreted language is any programming language that executes its statements line by line. Programs written in Python run directly from the source code, with no intermediary compilation step.\n",
    "\n",
    "- Python is an interpreted language, so it doesn’t need to be compiled before execution, unlike languages such as C.\n",
    "- Python is dynamically typed, so there is no need to declare a variable with the data type. Python Interpreter will identify the data type on the basis of the value of the variable.\n",
    "- Python follows an object-oriented programming paradigm with the exception of having access specifiers.\n",
    "- Python is a cross-platform language, i.e., a Python program written on a Windows system will also run on a Linux system with little or no modifications at all.\n",
    "- Python is literally a general-purpose language, i.e., Python finds its way in various domains such as web application development, automation, Data Science, Machine Learning, and more."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "139be0b5-59b3-4023-a77d-435aef7026d8",
   "metadata": {},
   "source": [
    "# PEP 8\n",
    "\n",
    "PEP stands for Python Enhancement Proposal. A PEP is an official design document providing information to the Python community, or describing a new feature for Python or its processes. PEP 8 is especially important since it documents the style guidelines for Python Code. Apparently contributing to the Python open-source community requires you to follow these style guidelines sincerely and strictly."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ca67660-7ede-4926-b285-3a0994d8c6e1",
   "metadata": {},
   "source": [
    "# Memory managed in Python\n",
    "- Memory in Python is managed by Python private heap space. All Python objects and data structures are located in a private heap. This private heap is taken care of by Python Interpreter itself, and a programmer doesn’t have access to this private heap.\n",
    "- Python memory manager takes care of the allocation of Python private heap space.\n",
    "- Memory for Python private heap space is made available by Python’s in-built garbage collector, which recycles and frees up all the unused memory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9d007764-aca7-46f7-8686-7cea4a1b03d1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "ec3a064b-d897-4c82-80f3-fc9f2c093197",
   "metadata": {},
   "source": [
    "# Data types in Python\n",
    "Python doesn't require data types to be defined explicitly during variable declarations \n",
    "\n",
    "1. **None Type**: Represents the NULL values in Python.\n",
    "2. **int**: Stores integer literals including hex, octal and binary numbers as integers\n",
    "3. **float**: Stores literals containing decimal values and/or exponent signs as floating-point numbers\n",
    "4. **complex**: Stores complex numbers in the form (A + Bj) and has attributes: real and imag\n",
    "5. **bool**: Stores boolean value (True or False).\n",
    "\n",
    "**Python Collections (Arrays)**:\n",
    "\n",
    "6. **Lists**: sequence data type, can have different data types. Square brackets `['sara', 6, 0.19]`. Lists are mutable, can be modified, appended or sliced on the go.\n",
    "7. **Tuples**: sequence data type, can have different data types. Parantheses `('ansh', 5, 0.97)`. Tuples are immutable objects, remain constant and cannot be modified in any manner.\n",
    "8. **Set**: is a collection which is unordered, unchangeable*, and unindexed. No duplicate members.\n",
    "9. **Dictionary** is a collection which is ordered and changeable. No duplicate members. A mapping object can map hashable values to random objects in Python. Mappings objects are **mutable** and there is currently only one standard mapping type, the dictionary: **dict**.\n",
    "\n",
    "\n",
    "10. **Range**: Represents an immutable sequence of numbers generated during execution.\n",
    "11. **Immutable**: sequence of Unicode code points to store textual data."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7fe95424-24db-4d93-b907-af487c9803c1",
   "metadata": {},
   "source": [
    "### ----------- Lists and Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "4677acbf-e9ce-417f-ae11-64540eb6933d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "print list item: sara\n",
      "print tuple item: sara\n",
      "Oops! modifying tuple => throws an error\n",
      "print updated list item: ansh\n",
      "print non-updated tuple item: sara\n",
      "<class 'range'>\n",
      "range(3, 6)\n"
     ]
    }
   ],
   "source": [
    "my_tuple = ('sara', 6, 5, 0.97)\n",
    "my_list = ['sara', 6, 5, 0.97]\n",
    "print(\"print list item:\",my_list[0])     \n",
    "print(\"print tuple item:\",my_tuple[0])     \n",
    "my_list[0] = 'ansh'    # modifying list => list modified\n",
    "try:\n",
    "    my_tuple[0] = 'ansh'\n",
    "except Exception:\n",
    "    print(\"Oops! modifying tuple => throws an error\")\n",
    "print(\"print updated list item:\",my_list[0])     \n",
    "print(\"print non-updated tuple item:\",my_tuple[0])  \n",
    "\n",
    "x = range(3, 6)\n",
    "print(type(x))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60af466b-7246-4468-a84a-076e7470d180",
   "metadata": {},
   "source": [
    "### List -------Slicing & Sub selection\n",
    "\n",
    "- Syntax for slicing is [start : stop : step] and ‘slicing’ is taking parts of from start to stop with step.\n",
    "- Default value for start is 0, stop is number of items, step is 1.\n",
    "- Slicing can be done on strings, arrays, lists, and tuples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "21976d67-eb6f-40c4-9700-93a01dc63694",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
      "[0, 1]\n",
      "[0, 2, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "print(x)\n",
    "x_sub = x[0:2] #<---- ONE :\n",
    "print(x_sub)\n",
    "\n",
    "x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "x_sub = x[0::2] #<---- TWO :  this is slicing\n",
    "print(x_sub)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04aeead6-9525-40c0-bb1a-03979d8d8312",
   "metadata": {},
   "source": [
    "# Negative indexes\n",
    "\n",
    "- Negative indexes are the indexes from the end of the list or tuple or string.\n",
    "- Arr[-1] means the last element of array Arr[]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "febba79a-46f0-4b36-9280-ce9888a66c3d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "arr = [1, 2, 3, 4, 5, 6]\n",
    "#get the last element\n",
    "print(arr[-1]) #output 6\n",
    "#get the second last element\n",
    "print(arr[-2]) #output 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee041d8b-4e09-464b-b7aa-af36f45e1ede",
   "metadata": {},
   "source": [
    "# Comprehensions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "281a0bc9-2dfb-403f-b959-25566f5539e7",
   "metadata": {},
   "source": [
    "- Performing mathematical operations on the entire list\n",
    "- Better way to iterate a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "0db37c86-7f09-47b4-b934-61481a348c46",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 9, 25, 49, 121]\n",
      "{2: 4, 3: 9, 5: 25, 7: 49, 11: 121}\n"
     ]
    }
   ],
   "source": [
    "my_list = [2, 3, 5, 7, 11]\n",
    "squared_list = [x**2 for x in my_list]    # list comprehension\n",
    "print(squared_list)\n",
    "squared_dict = {x:x**2 for x in my_list}    # dict comprehension\n",
    "print(squared_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "410d59e5-75bb-4a75-962f-48cf439f7ce6",
   "metadata": {},
   "source": [
    "- Performing conditional filtering operations on the entire list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "6baae791-0ce6-4a28-a724-3ec21666fcc0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9, 25, 49, 121]\n",
      "{3: 9, 5: 25, 7: 49, 11: 121}\n"
     ]
    }
   ],
   "source": [
    "my_list = [2, 3, 5, 7, 11]\n",
    "squared_list = [x**2 for x in my_list if x%2 != 0]    # list comprehension\n",
    "print(squared_list)\n",
    "squared_dict = {x:x**2 for x in my_list if x%2 != 0}    # dict comprehension\n",
    "# output => {11: 121, 3: 9 , 5: 25 , 7: 49}\n",
    "print(squared_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d69740b-7f6c-4b24-8a66-aed79423fd7f",
   "metadata": {},
   "source": [
    "### Zip function\n",
    "- Combining multiple lists into one"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "0d4e9152-4b80-48e0-8f60-5d18927541eb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8, 10, 12]\n",
      "[(1, 7), (1, 8), (1, 9), (2, 7), (2, 8), (2, 9), (3, 7), (3, 8), (3, 9)]\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "b = [7, 8, 9]\n",
    "combined_list = [(x + y) for (x,y) in zip(a,b)]  # parallel iterators\n",
    "print(combined_list)\n",
    "combined_dict = [(x,y) for x in a for y in b]    # nested iterators\n",
    "print(combined_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1af524e-2f81-479b-bb0a-9e42cdd3df95",
   "metadata": {},
   "source": [
    "- Flattening a multi-dimensional list\n",
    "A similar approach of nested iterators (as above) can be applied to flatten a multi-dimensional list or work upon its inner elements. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "db5158ff-4de7-41b5-b474-cf0a844ecaec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 20, 30, 40, 50, 60, 70, 80, 90]\n"
     ]
    }
   ],
   "source": [
    "my_list = [[10,20,30],[40,50,60],[70,80,90]]\n",
    "flattened = [x for temp in my_list for x in temp]\n",
    "print(flattened)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc40264c-651e-43fd-b6b3-11e9d8400879",
   "metadata": {},
   "source": [
    "# Generators\n",
    "\n",
    "- Generators are functions that return an iterable collection of items, one at a time, in a set manner. Generators, in general, are used to create iterators with a different approach. They employ the use of yield keyword rather than return to return a generator object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "1c52d084-a7ee-4159-ad3d-e3dd4c5a8c6e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "4\n",
      "9\n",
      "25\n",
      "49\n",
      "121\n",
      "<class 'list'>\n",
      "<class 'generator'>\n"
     ]
    }
   ],
   "source": [
    "def squared_function(mylist):\n",
    "    for item in mylist:\n",
    "        yield item*item\n",
    "\n",
    "my_list = [2, 3, 5, 7, 11]\n",
    "squared_generator = squared_function(my_list)\n",
    "print(type(squared_generator))\n",
    "for item in squared_generator:\n",
    "    print(item)\n",
    "\n",
    "#------ OR\n",
    "\n",
    "my_list = [2, 3, 5, 7, 11]\n",
    "squared_list = [x**2 for x in my_list]  \n",
    "print(type(squared_list))\n",
    "squared_generator = (x**2 for x in my_list) #<--- insted of [ we place (\n",
    "print(type(squared_generator))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2badbdb5-276f-435f-898d-259861e8de0c",
   "metadata": {},
   "source": [
    "# Iterators\n",
    "\n",
    "- An iterator is an object that contains a countable number of values.\n",
    "- An iterator is an object that can be iterated upon, meaning that you can traverse through all the values.\n",
    "- Technically, in Python, an iterator is an object which implements the iterator protocol, which consist of the methods __iter__() and __next__().\n",
    "- Lists, tuples, dictionaries, sets and strings are all iterable objects. \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "0f47a83c-e10b-4964-a870-5ea908511c1d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple\n",
      "banana\n",
      "cherry\n"
     ]
    }
   ],
   "source": [
    "mytuple = (\"apple\", \"banana\", \"cherry\")\n",
    "myit = iter(mytuple)\n",
    "\n",
    "print(next(myit))\n",
    "print(next(myit))\n",
    "print(next(myit))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d31ef66-990d-4923-9c76-a000022ebaaa",
   "metadata": {},
   "source": [
    "# Enumerate()\n",
    "- Enumerate() method adds a counter to an iterable and returns it in a form of enumerating object.\n",
    "- This enumerated object can then be used directly for loops or converted into a list of tuples using the list() method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "id": "7f798ddc-696b-4b30-8d5c-7accf3995d56",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 2\n",
      "1 3\n",
      "2 5\n",
      "3 7\n",
      "4 11\n",
      "----\n",
      "3 2\n",
      "4 3\n",
      "5 5\n",
      "6 7\n",
      "7 11\n"
     ]
    }
   ],
   "source": [
    "my_list = [2, 3, 5, 7, 11]\n",
    "for i, element in enumerate(my_list, start=0):\n",
    "    print(i, element)\n",
    "print(\"----\")\n",
    "for i, element in enumerate(my_list, start=3):\n",
    "    print(i, element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "8f21d278-eaa0-4542-8105-cc8893db0e9b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(0, 2), (1, 3), (2, 5), (3, 7), (4, 11)]\n"
     ]
    }
   ],
   "source": [
    "to_list = list(enumerate(my_list, start=0))\n",
    "print(to_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e8936bd-bddf-4dfa-8b27-767684be7c8d",
   "metadata": {},
   "source": [
    "### ----------- Arrays and lists\n",
    "- **Arrays** in python can only contain elements of same data types i.e., data type of array should be homogeneous. It is a thin wrapper around C language arrays and consumes far less memory than lists.\n",
    "- **Lists** in python can contain elements of different data types i.e., data type of lists can be heterogeneous. It has the disadvantage of consuming large memory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "310cb93a-15a2-40e1-8542-906dd98f8611",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array('i', [1, 2, 3])\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "import array\n",
    "a = array.array('i', [1, 2, 3]) # 'i' difines integer\n",
    "print(a) # we use nampy array, easier\n",
    "print(a[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7122d688-d74a-452d-af7b-fbc7c1c06e37",
   "metadata": {},
   "source": [
    "### ----------- Sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "26719793-a399-41e3-9eda-2d09788f2237",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'set'>\n",
      "banana\n",
      "apple\n",
      "cherry\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "thisset = {\"apple\", \"banana\", \"cherry\"}\n",
    "print(type(thisset))\n",
    "for item in thisset:\n",
    "    print(item)\n",
    "\n",
    "print(\"banana\" in thisset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "a5171672-279b-4c24-b07a-fa82036175a3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'set'>\n",
      "banana\n",
      "apple\n",
      "cherry\n",
      "True\n",
      "{'banana', 'apple', 'cherry'}\n",
      "{'banana', 'orange', 'apple', 'cherry'}\n",
      "{'banana', 'orange', 'papaya', 'mango', 'pineapple', 'apple', 'cherry'}\n",
      "{'b', 1, 'a', 2, 3, 'c'}\n",
      "{'apple'}\n",
      "{'google', 'cherry', 'banana', 'microsoft'}\n",
      "{'orange', 'papaya', 'mango', 'pineapple', 'apple', 'cherry'}\n",
      "{'orange', 'papaya', 'mango', 'apple', 'cherry'}\n",
      "orange\n",
      "{'papaya', 'mango', 'apple', 'cherry'}\n",
      "set()\n"
     ]
    }
   ],
   "source": [
    "thisset = set((\"apple\", \"banana\", \"cherry\")) # note the double round-brackets\n",
    "print(thisset)\n",
    "\n",
    "thisset.add(\"orange\")\n",
    "print(thisset)\n",
    "\n",
    "tropical = {\"pineapple\", \"mango\", \"papaya\"}\n",
    "thisset.update(tropical) # Add elements \n",
    "print(thisset)\n",
    "\n",
    "set1 = {\"a\", \"b\" , \"c\"}\n",
    "set2 = {1, 2, 3}\n",
    "set3 = set1.union(set2)\n",
    "print(set3)\n",
    "\n",
    "x = {\"apple\", \"banana\", \"cherry\"}\n",
    "y = {\"google\", \"microsoft\", \"apple\"}\n",
    "x.intersection_update(y) # Keep the items that exist in both set x, and set y\n",
    "print(x)\n",
    "\n",
    "x = {\"apple\", \"banana\", \"cherry\"}\n",
    "y = {\"google\", \"microsoft\", \"apple\"}\n",
    "x.symmetric_difference_update(y) # Keep the items that are not present in both sets\n",
    "print(x)\n",
    "\n",
    "thisset.remove(\"banana\")\n",
    "print(thisset)\n",
    "\n",
    "thisset.discard(\"pineapple\")\n",
    "print(thisset)\n",
    "\n",
    "x = thisset.pop()\n",
    "print(x)\n",
    "print(thisset)\n",
    "\n",
    "thisset.clear() # or del thisset\n",
    "print(thisset)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4230c50-f759-4d0e-92fe-f88d1565fa44",
   "metadata": {},
   "source": [
    "### Dict ----------- Mapping: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "74996135-8197-46cd-8176-75dc3b6a55f4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n",
      "{'brand': 'Ford', 'electric': False, 'year': 1964, 'colors': ['red', 'white', 'blue']}\n",
      "Ford\n",
      "4\n",
      "brand Ford\n",
      "electric False\n",
      "year 1964\n",
      "colors ['red', 'white', 'blue']\n",
      "----\n",
      "brand\n",
      "electric\n",
      "year\n",
      "colors\n",
      "----\n",
      "brand\n",
      "electric\n",
      "year\n",
      "colors\n",
      "----\n",
      "Ford\n",
      "False\n",
      "1964\n",
      "['red', 'white', 'blue']\n",
      "----\n",
      "Ford\n",
      "False\n",
      "1964\n",
      "['red', 'white', 'blue']\n"
     ]
    }
   ],
   "source": [
    "thisdict = {\n",
    "  \"brand\": \"Ford\",\n",
    "  \"electric\": False,\n",
    "  \"year\": 1964,\n",
    "  \"colors\": [\"red\", \"white\", \"blue\"]\n",
    "}\n",
    "print(type(thisdict))\n",
    "print(thisdict)\n",
    "print(thisdict[\"brand\"])\n",
    "print(len(thisdict))\n",
    "\n",
    "for x, y in thisdict.items():\n",
    "    print(x, y)\n",
    "print(\"----\")\n",
    "for x in thisdict:\n",
    "    print(x)\n",
    "print(\"----\")\n",
    "for x in thisdict.keys():\n",
    "    print(x)\n",
    "print(\"----\")\n",
    "for x in thisdict:\n",
    "    print(thisdict[x])\n",
    "print(\"----\")\n",
    "for x in thisdict.values():\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "3d280a1c-69e4-4a1e-9acd-dfdb2a4b1094",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ford\n",
      "Ford\n",
      "dict_keys(['brand', 'electric', 'year', 'colors'])\n",
      "dict_values(['Ford', False, 1964, ['red', 'white', 'blue']])\n",
      "Yes, 'brand' is one of the keys in the thisdict dictionary\n",
      "{'brand': 'Ford', 'electric': False, 'year': 1964, 'colors': ['red', 'white', 'blue'], 'doors': 5}\n",
      "{'brand': 'Ford', 'electric': False, 'year': 1964, 'colors': ['red', 'white', 'blue'], 'doors': 4}\n",
      "{'brand': 'Ford', 'electric': False, 'year': 1964, 'colors': ['red', 'white', 'blue'], 'doors': 3}\n",
      "{'brand': 'Ford', 'electric': False, 'year': 1964, 'colors': ['red', 'white', 'blue']}\n",
      "{'brand': 'Ford', 'electric': False, 'year': 1964}\n",
      "{'brand': 'Ford', 'electric': False}\n",
      "{}\n"
     ]
    }
   ],
   "source": [
    "thisdict = {\n",
    "  \"brand\": \"Ford\",\n",
    "  \"electric\": False,\n",
    "  \"year\": 1964,\n",
    "  \"colors\": [\"red\", \"white\", \"blue\"]\n",
    "}\n",
    "\n",
    "# ----------- Get values\n",
    "x = thisdict[\"brand\"]\n",
    "print(x)\n",
    "x = thisdict.get(\"brand\")\n",
    "print(x)\n",
    "x = thisdict.keys()\n",
    "print(x)\n",
    "x = thisdict.values()\n",
    "print(x)\n",
    "\n",
    "# ----------- Checks values\n",
    "if \"brand\" in thisdict:\n",
    "  print(\"Yes, 'brand' is one of the keys in the thisdict dictionary\")\n",
    "\n",
    "# ----------- Add Modify values\n",
    "thisdict[\"doors\"] = 5 # add a new key and value\n",
    "print(thisdict)\n",
    "thisdict[\"doors\"] = 4 # modify an existing key and value\n",
    "print(thisdict)\n",
    "thisdict.update({\"doors\": 3}) # modify an existing key and value\n",
    "print(thisdict)\n",
    "\n",
    "# ----------- Remove values\n",
    "thisdict.pop(\"doors\") # removes the item with the specified key name\n",
    "print(thisdict)\n",
    "thisdict.popitem() # removes the last inserted item\n",
    "print(thisdict)\n",
    "del thisdict[\"year\"] # removes the item with the specified key name & can also delete the dictionary completely\n",
    "print(thisdict)\n",
    "thisdict.clear() # method empties the dictionary\n",
    "print(thisdict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "6a501755-228b-4e40-bf2d-664a96a90c13",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'brand': 'Ford', 'electric': False, 'year': 1964, 'colors': ['red', 'white', 'blue']}\n",
      "{'brand': 'Ford', 'electric': False, 'year': 1964, 'colors': ['red', 'white', 'blue']}\n"
     ]
    }
   ],
   "source": [
    "thisdict = {\n",
    "  \"brand\": \"Ford\",\n",
    "  \"electric\": False,\n",
    "  \"year\": 1964,\n",
    "  \"colors\": [\"red\", \"white\", \"blue\"]\n",
    "}\n",
    "\n",
    "mydict = thisdict.copy()\n",
    "print(mydict)\n",
    "mydict = dict(thisdict)\n",
    "print(mydict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "614cd4c5-66e9-49ad-a823-5fa6bba9fa3a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['child1', 'child2', 'child3'])\n",
      "child1\n",
      "child2\n",
      "child3\n"
     ]
    }
   ],
   "source": [
    "myfamily = {\n",
    "  \"child1\" : {\n",
    "    \"name\" : \"Emil\",\n",
    "    \"year\" : 2004\n",
    "  },\n",
    "  \"child2\" : {\n",
    "    \"name\" : \"Tobias\",\n",
    "    \"year\" : 2007\n",
    "  },\n",
    "  \"child3\" : {\n",
    "    \"name\" : \"Linus\",\n",
    "    \"year\" : 2011\n",
    "  }\n",
    "}\n",
    "print(myfamily.keys())\n",
    "for key in myfamily.keys():\n",
    "    print(key)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "bcd24dc9-2243-4048-b34e-ee183128f580",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n",
      "{}\n",
      "{'a': 0, 'b': 2}\n"
     ]
    }
   ],
   "source": [
    "outgoing_count = {}\n",
    "print(type(outgoing_count))\n",
    "print(outgoing_count)\n",
    "outgoing_count['a'] = outgoing_count.get('a',0)\n",
    "outgoing_count['b'] = outgoing_count.get('b',1)\n",
    "outgoing_count['b'] = outgoing_count.get('b',0)+1\n",
    "print(outgoing_count)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c85684cc-e2d9-4a6d-a85e-0a3e100c4639",
   "metadata": {},
   "source": [
    "# Copy an object\n",
    "- the assignment statement (= operator) does not copy objects. Instead, it creates a binding between the existing object and the target variable name. To create copies of an object in Python, we need to use the copy module. Moreover, there are two ways of creating copies for the given object using the copy module -\n",
    "    - Shallow Copy is a bit-wise copy of an object. The copied object created has an exact copy of the values in the original object. If either of the values is a reference to other objects, just the reference addresses for the same are copied.\n",
    "    - Deep Copy copies all values recursively from source to target object, i.e. it even duplicates the objects referenced by the source object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "920dbd21-d596-4361-b47e-a1d5ac767f32",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 5, 4]\n",
      "[0, 2, 3, 5, 4]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1, 2, [3, 5, 6], 4]"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_1 = [1, 2, 3, 5, 4]\n",
    "print(list_1)\n",
    "list_2 = list_1\n",
    "list_2[0] = 0\n",
    "print(list_1) # <---- changed list_1\n",
    "\n",
    "from copy import copy, deepcopy\n",
    "list_1 = [1, 2, [3, 5], 4]\n",
    "## shallow copy\n",
    "list_2 = copy(list_1) \n",
    "list_2[3] = 7\n",
    "list_2[2].append(6)\n",
    "list_2    # output => [1, 2, [3, 5, 6], 7]\n",
    "list_1    # output => [1, 2, [3, 5, 6], 4]\n",
    "## deep copy\n",
    "list_3 = deepcopy(list_1)\n",
    "list_3[3] = 8\n",
    "list_3[2].append(7)\n",
    "list_3    # output => [1, 2, [3, 5, 6, 7], 8]\n",
    "list_1    # output => [1, 2, [3, 5, 6], 4]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c925193-eb1f-4c76-bedb-39b8cc22c4c0",
   "metadata": {},
   "source": [
    "# Linked List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "bdd966e6-906c-41d7-9165-22d16f74ab70",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "1\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "class ListNode:\n",
    "    def __init__(self, val=0, next=None):\n",
    "        self.val = val\n",
    "        self.next = next\n",
    "        \n",
    "data = [5, 1, 7, 96]\n",
    "tail = head = ListNode(data[0])\n",
    "for x in data[1:]:\n",
    "    tail.next = ListNode(x) # Create and add another node\n",
    "    tail = tail.next # Move the tail pointer\n",
    "    \n",
    "print(head.val)\n",
    "print(head.next.val)\n",
    "print(head.next.next.val)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59528865-84bd-461c-94e5-95a5c8e27e0f",
   "metadata": {},
   "source": [
    "# Modules and Packages in Python\n",
    "- **Modules**, are simply Python files with a .py extension and can have a set of functions, classes, or variables defined and implemented. They can be imported and initialized once using the import statement. If partial functionality is needed, import the requisite classes or functions using from foo import bar.\n",
    "- **Packages** allow for hierarchial structuring of the module namespace using dot notation. As, modules help avoid clashes between global variable names, in a similar manner, packages help avoid clashes between module names.\n",
    "\n",
    "Creating a package is easy since it makes use of the system's inherent file structure. So just stuff the modules into a folder and there you have it, the folder name as the package name. Importing a module or its contents from this package requires the package name as prefix to the module name joined by a dot.\n",
    "\n",
    "# Break, Continue and Pass in Python\n",
    "- **Break**: The break statement terminates the loop immediately and the control flows to the statement after the body of the loop.\n",
    "- **Continue**: The continue statement terminates the current iteration of the statement, skips the rest of the code in the current iteration and the control flows to the next iteration of the loop.\n",
    "- **Pass**: As explained above, the pass keyword in Python is generally used to fill up empty blocks and is similar to an empty statement represented by a semi-colon in languages such as Java, C++, Javascript, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85673c92-3135-43b8-9641-cd61c2c3438f",
   "metadata": {},
   "source": [
    "# pickling and unpickling\n",
    "\n",
    "- Python library offers a feature - serialization out of the box. Serializing an object refers to transforming it into a format that can be stored, so as to be able to deserialize it, later on, to obtain the original object. Here, the pickle module comes into play.\n",
    "\n",
    "    - Pickling is the name of the serialization process in Python. Any object in Python can be serialized into a byte stream and dumped as a file in the memory. \n",
    "    - Unpickling is the complete inverse of pickling. It deserializes the byte stream to recreate the objects stored in the file and loads the object to memory."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd59227e-f619-4659-baa6-adac4c078069",
   "metadata": {},
   "source": [
    "# Docstring in Python\n",
    "- Documentation string or docstring is a multiline string used to document a specific code segment.\n",
    "- The docstring should describe what the function or method does.\n",
    "\n",
    "Docstring in Methods:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "0d090ab9-68be-4613-a4c1-24ebff612f7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def square(n):\n",
    "    '''Takes in a number n, returns the square of n'''\n",
    "    return n**2\n",
    "\n",
    "print(square.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80070ccc-bedd-4b60-94f9-11e96e5966e6",
   "metadata": {},
   "source": [
    "Docstring in build in functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "760350ae-1e7d-4a57-8e23-91b760c57544",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n",
      "\n",
      "Prints the values to a stream, or to sys.stdout by default.\n",
      "Optional keyword arguments:\n",
      "file:  a file-like object (stream); defaults to the current sys.stdout.\n",
      "sep:   string inserted between values, default a space.\n",
      "end:   string appended after the last value, default a newline.\n",
      "flush: whether to forcibly flush the stream.\n"
     ]
    }
   ],
   "source": [
    "print(print.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91e2a3fd-8384-4d46-91ae-425ffb9bb2ff",
   "metadata": {},
   "source": [
    "Docstring in classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "f708eb23-2a8a-4cb0-85a1-a111c9f0a6df",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "    A class to represent a person.\n",
      "    \n",
      "-----\n",
      "\n",
      "        Constructs all the necessary attributes for the person object.\n",
      "        \n",
      "-----\n",
      "\n",
      "        Prints the person's name and age.\n",
      "        \n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    \"\"\"\n",
    "    A class to represent a person.\n",
    "    \"\"\"\n",
    "    def __init__(self, name, surname, age):\n",
    "        \"\"\"\n",
    "        Constructs all the necessary attributes for the person object.\n",
    "        \"\"\"\n",
    "        self.name = name\n",
    "        self.surname = surname\n",
    "        self.age = age\n",
    "\n",
    "    def info(self, additional=\"\"):\n",
    "        \"\"\"\n",
    "        Prints the person's name and age.\n",
    "        \"\"\"\n",
    "\n",
    "print(Person.__doc__)\n",
    "print(\"-----\")\n",
    "print(Person.__init__.__doc__)\n",
    "print(\"-----\")\n",
    "print(Person.info.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb17ec96-dd59-4cb8-b70a-609df7b09602",
   "metadata": {},
   "source": [
    "### Making a Python script executable and runnable from anywhere\n",
    "\n",
    "On unix systems, Python scripts can be made executable using the following process:\n",
    "1. Add this line as the first line in the script:\n",
    "`#!/usr/bin/env python3`\n",
    "2. At the unix command prompt, type the following to make myscript.py executable:\n",
    "`$ chmod +x myscript.py`\n",
    "3. Move myscript.py into your bin directory, and it will be runnable from anywhere."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46021af0-397f-423b-b9d8-3044a18a6acc",
   "metadata": {},
   "source": [
    "### Scope Resolution in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "259a940c-c5d0-49ba-9940-02af8c0ef821",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "temp = 10   # global-scope variable\n",
    "def func():\n",
    "    temp = 20   # local-scope variable\n",
    "    print(temp)\n",
    "print(temp)   # output => 10\n",
    "func()    # output => 20\n",
    "print(temp)   # output => 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "bd829f0d-98de-450a-a79e-2a44366592de",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n",
      "20\n"
     ]
    }
   ],
   "source": [
    "temp = 10   # global-scope variable\n",
    "def func():\n",
    "    global temp #<------- use the global variable\n",
    "    temp = 20   # local-scope variable\n",
    "    print(temp)\n",
    "print(temp)   # output => 10\n",
    "func()    # output => 20\n",
    "print(temp)   # output => 20"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26c2cc89-d8ab-442c-a30b-3e5a7e4a0724",
   "metadata": {},
   "source": [
    "# *args and **kwargs\n",
    "- *args is a special syntax used in the function definition to pass variable-length arguments.\n",
    "- “*” means variable length and “args” is the name used by convention. You can use any other.\n",
    "- **kwargs is a special syntax used in the function definition to pass variable-length keyworded arguments.\n",
    "- Here, also, “kwargs” is used just by convention. You can use any other name.\n",
    "- Keyworded argument means a variable that has a name when passed to a function.\n",
    "- It is actually a dictionary of the variable names and its value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "6158b24c-ddcf-4e65-b9bb-7e730d73391d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "120\n",
      "arg1: argument 1\n",
      "arg2: argument 2\n",
      "arg3: argument 3\n"
     ]
    }
   ],
   "source": [
    "def multiply(a, b, *argv):\n",
    "    mul = a * b\n",
    "    for num in argv:\n",
    "        mul *= num\n",
    "    return mul\n",
    "print(multiply(1, 2, 3, 4, 5)) #output: 120\n",
    "\n",
    "def tellArguments(**kwargs):\n",
    "    for key, value in kwargs.items():\n",
    "        print(key + \": \" + value)\n",
    "tellArguments(arg1 = \"argument 1\", arg2 = \"argument 2\", arg3 = \"argument 3\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc432515-aadd-449c-b7db-be54c4f34e74",
   "metadata": {},
   "source": [
    "### Decorators\n",
    "- Decorators in Python are essentially functions that add functionality to an existing function in Python without changing the structure of the function itself. They are represented the @decorator_name in Python and are called in a bottom-up fashion. For example:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "d6cd55f1-ec33-449b-bc4a-5cacc5218dbb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am ordinary\n",
      "---\n",
      "I got decorated\n",
      "I am ordinary\n"
     ]
    }
   ],
   "source": [
    "def make_pretty(func): # is a decorator\n",
    "    def inner():\n",
    "        print(\"I got decorated\")\n",
    "        func()\n",
    "    return inner\n",
    "\n",
    "def ordinary():\n",
    "    print(\"I am ordinary\")\n",
    "\n",
    "ordinary()\n",
    "print(\"---\")\n",
    "pretty = make_pretty(ordinary) # got decorated and the returned function was given the name pretty\n",
    "pretty()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec999d02-5ca4-4ce0-8edc-563a5a697d29",
   "metadata": {},
   "source": [
    "- the decorator function added some new functionality to the original function. This is similar to packing a gift. The decorator acts as a wrapper. \n",
    "- We can use the @ symbol along with the name of the decorator function and place it above the definition of the function to be decorated. For example,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "19b1241f-41cc-4bcf-bf16-acee7e967c7c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I got decorated\n",
      "I am ordinary\n"
     ]
    }
   ],
   "source": [
    "@make_pretty\n",
    "def ordinary():\n",
    "    print(\"I am ordinary\")\n",
    "\n",
    "ordinary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "30efa932-9eab-44ea-9228-62f8f175c8e9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am going to divide 2 and 0\n",
      "Whoops! cannot divide\n"
     ]
    }
   ],
   "source": [
    "def smart_divide(func):\n",
    "    def inner(arg_a, arg_b):\n",
    "        print(\"I am going to divide\", arg_a, \"and\", arg_b)\n",
    "        if arg_b == 0:\n",
    "            print(\"Whoops! cannot divide\")\n",
    "            return\n",
    "        return func(arg_a, arg_b)\n",
    "    return inner\n",
    "\n",
    "\n",
    "@smart_divide\n",
    "def divide(a, b):\n",
    "    print(a/b)\n",
    "\n",
    "divide(2,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "9f4313ed-a069-4833-bc26-36bb4d9bcf60",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "splitter\n",
      "lowercase\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Hello World lowercase splitter'"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# decorator function to convert to lowercase\n",
    "def lowercase_decorator(function):\n",
    "    def wrapper():\n",
    "        print(\"lowercase\")\n",
    "        func = function()\n",
    "        string_lowercase = func +\" lowercase\"\n",
    "        return string_lowercase\n",
    "    return wrapper\n",
    "\n",
    "# decorator function to split words\n",
    "def splitter_decorator(function):\n",
    "    def wrapper():\n",
    "        print(\"splitter\")\n",
    "        func = function()\n",
    "        string_split = func +\" splitter\"\n",
    "        return string_split\n",
    "    return wrapper\n",
    "\n",
    "@splitter_decorator # this is executed second\n",
    "@lowercase_decorator # this is executed first\n",
    "def hello():\n",
    "    return 'Hello World'\n",
    "\n",
    "hello()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4abb704c-6257-4294-b594-6a48544de540",
   "metadata": {},
   "source": [
    "### Lambda\n",
    "- Lambda is an anonymous function in Python, that can accept any number of arguments, but can only have a single expression. It is generally used in situations requiring an anonymous function for a short time period. Lambdafunctions can be used in either of the two ways:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "2c013926-3350-48a3-85d5-85d0109cea05",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "# Assigning lambda functions to a variable:\n",
    "mul = lambda a, b : a * b\n",
    "print(mul(2, 5))  \n",
    "\n",
    "# Wrapping lambda functions inside another function:\n",
    "def myWrapper(n):\n",
    "    return lambda a : a * n\n",
    "mulFive = myWrapper(5)\n",
    "print(mulFive(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "6200e334-549c-4dbe-bcf4-178cc4c6e419",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{'name': 'Max', 'age': 6}, {\"'name\": 'Ben', 'age': 9}, {'name': 'Lisa', 'age': 20}]\n"
     ]
    }
   ],
   "source": [
    "data = [{\"name\": \"Max\", \"age\": 6},\n",
    "{\"name\": \"Lisa\", \"age\": 20},\n",
    "{\"'name\": \"Ben\", \"age\": 9}]\n",
    "\n",
    "sorted_data = sorted(data, key=lambda x: x [\"age\"])\n",
    "print(sorted_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "3ba59dc2-64b7-44fd-9d0e-1eafd6b88ce3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['alice', 'bob', 'doe', 'jane']\n"
     ]
    }
   ],
   "source": [
    "arr = [\"bob\", \"alice\", \"jane\", \"doe\"]\n",
    "arr.sort ()\n",
    "print (arr)\n",
    "# Custom sort (by length of string)\n",
    "arr.sort(key=lambda x: len (x))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f3c5df5-636d-4fc4-9837-611b4b77918e",
   "metadata": {},
   "source": [
    "# xrange and range\n",
    "\n",
    "- xrange() and range() are quite similar in terms of functionality. They both generate a sequence of integers, with the only difference that range() returns a Python list, whereas, xrange() returns an xrange object.\n",
    "\n",
    "- So how does that make a difference? It sure does, because unlike range(), xrange() doesn't generate a static list, it creates the value on the go. This technique is commonly used with an object-type generator and has been termed as \"yielding\".\n",
    "\n",
    "- Yielding is crucial in applications where memory is a constraint. Creating a static list as in range() can lead to a Memory Error in such conditions, while, xrange() can handle it optimally by using just enough memory for the generator (significantly less in comparison)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3067bee5-f855-43f8-8f6f-a935e44faf7d",
   "metadata": {},
   "source": [
    "# split() and join() \n",
    "- You can use split() function to split a string based on a delimiter to a list of strings.\n",
    "- You can use join() function to join a list of strings based on a delimiter to give a single string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "ebf5efa0-2274-44a7-8f50-d22fed1277db",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['This', 'is', 'a', 'string.']\n",
      "This is a string.\n"
     ]
    }
   ],
   "source": [
    "string = \"This is a string.\"\n",
    "string_list = string.split(' ') #delimiter is ‘space’ character or ‘ ‘\n",
    "print(string_list) #output: ['This', 'is', 'a', 'string.']\n",
    "print(' '.join(string_list)) #output: This is a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d2d360f0-e47c-4850-987e-2078a5326f39",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "23d6181d-75be-43bf-8e1d-a67cd5dc186b",
   "metadata": {},
   "source": [
    "# Reference\n",
    "\n",
    "- Write Better Python Code: https://www.youtube.com/watch?v=8OKTAedgFYg\n",
    "\n",
    "- Python ALL Interview Questions (really good): https://www.interviewbit.com/python-interview-questions/\n",
    "- Python ALL Interview Questions 2nd source: https://intellipaat.com/blog/interview-question/python-interview-questions/\n",
    "- Python Interviews Core things (Classes, structures, fString): https://www.youtube.com/watch?v=Zee665ssm8Y\n",
    "- Python REFRESH BASICS interview: https://www.youtube.com/watch?v=0K_eZGS5NsU\n",
    "- Python GENERAL interview NOTES: https://www.youtube.com/watch?v=DEwgZNC-KyE\n",
    "\n",
    "- Decorators: https://www.programiz.com/python-programming/decorator\n",
    "- Iterators: https://www.youtube.com/watch?v=jTYiNjvnHZY\n",
    "- Stack, Heap, and Queue: http://bucarotechelp.com/computers/architecture/81051201.asp\n",
    "- Data Structures: https://www.youtube.com/watch?v=kQDxmjfkIKY\n",
    "- Advanced Python Tutorials: https://www.youtube.com/watch?v=iZZtEJjQLjQ&list=PL7yh-TELLS1FuqLSjl5bgiQIEH25VEmIc&index=2\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0b78245-4532-41a3-b62d-6cbaee320a8d",
   "metadata": {},
   "source": [
    "# Future Check\n",
    "- Unit Testing: https://www.youtube.com/watch?v=6tNS--WetLI\n"
   ]
  }
 ],
 "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}