fourth_tut.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Writing Reusable Code using Functions in Python\n",
    "\n",
    "\n",
    "![](https://i.imgur.com/TvNf5Jp.png)\n",
    "\n",
    "These tutorials take a practical and coding-focused approach. The best way to learn the material is to execute the code and experiment with it yourself. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sayhello(): # fucntion define hua hai sirf abhi call nahi hua\n",
    "    print(\"hello world\")\n",
    "    print(\"how are you\")     # print is also a function \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n",
      "how are you\n"
     ]
    }
   ],
   "source": [
    "sayhello() # yaha pr call ho raha hai function ki value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# arguements in function \n",
    "def filter_even(number_list):\n",
    "    result_list = []\n",
    "    for i in number_list:\n",
    "        if i % 2==0:\n",
    "            # result_list = number_list iska koi mtlab hi nahi bana yaaro\n",
    "            result_list.append(i)\n",
    "    return result_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "filter_even([1,2,3,4,5,6,7,8])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Writing great functions in Python\n",
    "\n",
    "As a programmer, you will spend most of your time writing and using functions. Python offers many features to make your functions powerful and flexible. Let's explore some of these by solving a problem:\n",
    "\n",
    "> Radha is planning to buy a house that costs `$1,260,000`. She considering two options to finance her purchase:\n",
    ">\n",
    "> * Option 1: Make an immediate down payment of `$300,000`, and take loan 8-year loan with an interest rate of 10% (compounded monthly) for the remaining amount.\n",
    "> * Option 2: Take a 10-year loan with an interest rate of 8% (compounded monthly) for the entire amount.\n",
    ">\n",
    "> Both these loans have to be paid back in equal monthly installments (EMIs). Which loan has a lower EMI among the two?\n",
    "\n",
    "\n",
    "Since we need to compare the EMIs for two loan options, defining a function to calculate the EMI for a loan would be a great idea.  The inputs to the function would be cost of the house, the down payment, duration of the loan, rate of interest etc. We'll build this function step by step.\n",
    "\n",
    "First, let's write a simple function that calculates the EMI on the entire cost of the house, assuming that the loan must be paid back in one year, and there is no interest or down payment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loan_emi(amount):\n",
    "    emi = amount/12  # ye poore ghr ke amount pr hai \n",
    "    print(\"Your EMI is $: {}\".format(emi))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your EMI is $: 105000.0\n"
     ]
    }
   ],
   "source": [
    "loan_emi(1260000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loan_emi(amount, duration):\n",
    "    emi = amount/duration\n",
    "    # print(\"The EMI is $ :{}\".format(emi))\n",
    "    return emi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13125.0"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "loan_emi(1260000,96)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1312.5\n",
      "10500.0\n"
     ]
    }
   ],
   "source": [
    "emi1= loan_emi(126000, 12*8)\n",
    "emi2 = loan_emi(1260000, 12*10)\n",
    "print(emi1)\n",
    "print(emi2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Optional arguments\n",
    "\n",
    "Next, let's add another argument to account for the immediate down payment. We'll make this an *optional argument* with a default value of 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loan_emi(amount, duration, downpayment=0):\n",
    "    loan_amount = amount - downpayment\n",
    "    emi= loan_amount/duration\n",
    "    return emi "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10000.0"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "emi1=loan_emi(1260000, 12*8, 3e5)  # 3e5 means 3 lakh e(n) is number of zero you want to append\n",
    "emi1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loan_emi(amount, duration, rate, downpayment=0):\n",
    "    loan_amount = amount - downpayment\n",
    "    emi= loan_amount* rate*((1+rate)**duration)/((1+rate)**duration-1)\n",
    "    return emi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14567.19753389219"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "emi1 = loan_emi(1260000, 8*12, 0.1/12, 3e5)\n",
    "emi1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15287.276888775077"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "emi2 =loan_emi(1260000, 10*12, 0.08/12)\n",
    "emi2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Named arguments\n",
    "\n",
    "Invoking a function with many arguments can often get confusing and is prone to human errors. Python provides the option of invoking functions with *named* arguments for better clarity. You can also split function invocation into multiple lines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function ceil in module math:\n",
      "\n",
      "ceil(x, /)\n",
      "    Return the ceiling of x as an Integral.\n",
      "    \n",
      "    This is the smallest integer >= x.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(math.ceil)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10000"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.ceil(emi1) # ye function round up krne mai kaam krta hai bhaut smooth process hai boss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loan_emi(amount, duration, rate, down_payment=0):\n",
    "    loan_amount = amount - down_payment\n",
    "    emi = loan_amount * rate * ((1+rate)**duration) / (((1+rate)**duration)-1)\n",
    "    emi = math.ceil(emi)\n",
    "    return emi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reusing and improving functions \n",
    "\n",
    "Now we know for sure that \"Option 1\" has the lower EMI among the two options. But what's even better is that we now have a handy function `loan_emi` that we can use to solve many other similar problems with just a few lines of code. Let's try it with a couple more questions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Q**: Shaun is currently paying back a home loan for a house he bought a few years ago. The cost of the house was `$800,000`. Shaun made a down payment of `25%` of the price. He financed the remaining amount using a 6-year loan with an interest rate of `7%` per annum (compounded monthly). Shaun is now buying a car worth `$60,000`, which he is planning to finance using a 1-year loan with an interest rate of `12%` per annum. Both loans are paid back in EMIs. What is the total monthly payment Shaun makes towards loan repayment?\n",
    "\n",
    "This question is now straightforward to solve, using the `loan_emi` function we've already defined."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10230"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cost_of_house = 800000\n",
    "home_loan_duration = 6*12 # months\n",
    "home_loan_rate = 0.07/12 # monthly\n",
    "home_down_payment = .25 * 800000\n",
    "\n",
    "emi_house = loan_emi(amount=cost_of_house,\n",
    "                     duration=home_loan_duration,\n",
    "                     rate=home_loan_rate, \n",
    "                     down_payment=home_down_payment)\n",
    "\n",
    "emi_house"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exceptions and `try`-`except`\n",
    "\n",
    "> Q: If you borrow `$100,000` using a 10-year loan with an interest rate of 9% per annum, what is the total amount you end up paying as interest?\n",
    "\n",
    "One way to solve this problem is to compare the EMIs for two loans: one with the given rate of interest and another with a 0% rate of interest. The total interest paid is then simply the sum of monthly differences over the duration of the loan."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1267"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "emi_with_interest = loan_emi(amount=100000, duration=10*12, rate=0.09/12)\n",
    "emi_with_interest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error: Division by zero is not allowed! division by zero\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    # Code that might raise an exception\n",
    "    result = 10 / 0\n",
    "except ZeroDivisionError as e:\n",
    "    # Code to handle the exception\n",
    "    print(\"Error: Division by zero is not allowed!\", e)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# jo uper show ho raha hai vo error hai isi error se bachne k liye we have to use try exception things"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "If i am working with division:\n",
      "failed to compute your division here is some error\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print(\"If i am working with division:\")\n",
    "    result = 5/0\n",
    "    print(\"computational successfully is here:\")\n",
    "except  :\n",
    "    print(\"failed to compute your division here is some error\")\n",
    "    result = None\n",
    "    \n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loan_emi(amount, duration, rate, down_payment=0):\n",
    "    loan_amount = amount - down_payment\n",
    "    try:\n",
    "        emi = loan_amount * rate * ((1+rate)**duration) / (((1+rate)**duration)-1)\n",
    "    except ZeroDivisionError:\n",
    "        emi = loan_amount / duration\n",
    "    emi = math.ceil(emi)\n",
    "    return emi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "834"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "emi_with_interest = loan_emi(amount=100000, duration=10*12, rate=0)\n",
    "emi_with_interest"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Documenting functions using Docstrings\n",
    "\n",
    "We can add some documentation within our function using a *docstring*. A docstring is simply a string that appears as the first statement within the function body, and is used by the `help` function. A good docstring describes what the function does, and provides some explanation about the arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loan_emi(amount, duration, rate, down_payment=0):\n",
    "    \"\"\"Calculates the equal montly installment (EMI) for a loan.\n",
    "    \n",
    "    Arguments:\n",
    "        amount - Total amount to be spent (loan + down payment)\n",
    "        duration - Duration of the loan (in months)\n",
    "        rate - Rate of interest (monthly)\n",
    "        down_payment (optional) - Optional intial payment (deducted from amount)\n",
    "    \"\"\"\n",
    "    loan_amount = amount - down_payment\n",
    "    try:\n",
    "        emi = loan_amount * rate * ((1+rate)**duration) / (((1+rate)**duration)-1)\n",
    "    except ZeroDivisionError:\n",
    "        emi = loan_amount / duration\n",
    "    emi = math.ceil(emi)\n",
    "    return emi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function loan_emi in module __main__:\n",
      "\n",
      "loan_emi(amount, duration, rate, down_payment=0)\n",
      "    Calculates the equal montly installment (EMI) for a loan.\n",
      "    \n",
      "    Arguments:\n",
      "        amount - Total amount to be spent (loan + down payment)\n",
      "        duration - Duration of the loan (in months)\n",
      "        rate - Rate of interest (monthly)\n",
      "        down_payment (optional) - Optional intial payment (deducted from amount)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(loan_emi) # this is the documentation "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Questions for Revision\n",
    "\n",
    "Try answering the following questions to test your understanding of the topics covered in this notebook:\n",
    "\n",
    "1. What is a function?\n",
    "2. What are the benefits of using functions?\n",
    "3. What are some built-in functions in Python?\n",
    "4. How do you define a function in Python? Give an example.\n",
    "5. What is the body of a function?\n",
    "6. When are the statements in the body of a function executed?\n",
    "7. What is meant by calling or invoking a function? Give an example.\n",
    "8. What are function arguments? How are they useful?\n",
    "9. How do you store the result of a function in a variable?\n",
    "10. What is the purpose of the `return` keyword in Python?\n",
    "11. Can you return multiple values from a function?\n",
    "12. Can a `return` statement be used inside an `if` block or a `for` loop?\n",
    "13. Can the `return` keyword be used outside a function?\n",
    "14. What is scope in a programming region? \n",
    "15. How do you define a variable inside a function?\n",
    "16. What are local & global variables?\n",
    "17. Can you access the variables defined inside a function outside its body? Why or why not?\n",
    "18. What do you mean by the statement \"a function defines a scope within Python\"?\n",
    "19. Do for and while loops define a scope, like functions?\n",
    "20. Do if-else blocks define a scope, like functions?\n",
    "21. What are optional function arguments & default values? Give an example.\n",
    "22. Why should the required arguments appear before the optional arguments in a function definition?\n",
    "23. How do you invoke a function with named arguments? Illustrate with an example.\n",
    "24. Can you split a function invocation into multiple lines?\n",
    "25. Write a function that takes a number and rounds it up to the nearest integer.\n",
    "26. What are modules in Python?\n",
    "27. What is a Python library?\n",
    "28. What is the Python Standard Library?\n",
    "29. Where can you learn about the modules and functions available in the Python standard library?\n",
    "30. How do you install a third-party library?\n",
    "31. What is a module namespace? How is it useful?\n",
    "32. What problems would you run into if Python modules did not provide namespaces?\n",
    "33. How do you import a module?\n",
    "34. How do you use a function from an imported module? Illustrate with an example.\n",
    "35. Can you invoke a function inside the body of another function? Give an example.\n",
    "36. What is the single responsibility principle, and how does it apply while writing functions?\n",
    "37. What some characteristics of well-written functions?\n",
    "38. Can you use if statements or while loops within a function? Illustrate with an example.\n",
    "39. What are exceptions in Python? When do they occur?\n",
    "40. How are exceptions different from syntax errors?\n",
    "41. What are the different types of in-built exceptions in Python? Where can you learn about them?\n",
    "42. How do you prevent the termination of a program due to an exception?\n",
    "43. What is the purpose of the `try`-`except` statements in Python?\n",
    "44. What is the syntax of the `try`-`except` statements? Give an example.\n",
    "45. What happens if an exception occurs inside a `try` block?\n",
    "46. How do you handle two different types of exceptions using `except`? Can you have multiple `except` blocks under a single `try` block?\n",
    "47. How do you create an `except` block to handle any type of exception?\n",
    "48. Illustrate the usage of `try`-`except` inside a function with an example.\n",
    "49. What is a docstring? Why is it useful?\n",
    "50. How do you display the docstring for a function?\n",
    "51. What are *args and **kwargs? How are they useful? Give an example.\n",
    "52. Can you define functions inside functions? \n",
    "53. What is function closure in Python? How is it useful? Give an example.\n",
    "54. What is recursion? Illustrate with an example.\n",
    "55. Can functions accept other functions as arguments? Illustrate with an example.\n",
    "56. Can functions return other functions as results? Illustrate with an example.\n",
    "57. What are decorators? How are they useful?\n",
    "58. Implement a function decorator which prints the arguments and result of wrapped functions.\n",
    "59. What are some in-built decorators in Python?\n",
    "60. What are some popular Python libraries?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Alice!\n"
     ]
    }
   ],
   "source": [
    "def outer_function(name):\n",
    "    # Variable defined in the outer function\n",
    "    greeting = f\"Hello, {name}!\"\n",
    "\n",
    "    def inner_function():\n",
    "        # Accessing the outer function's variable\n",
    "        print(greeting)\n",
    "\n",
    "    # Calling the inner function\n",
    "    inner_function()\n",
    "\n",
    "# Calling the outer function\n",
    "outer_function(\"Alice\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python is renowned for its rich ecosystem of libraries that cater to various domains and use cases. Here are some popular Python libraries across different categories:\n",
    "\n",
    "### Data Science and Machine Learning\n",
    "\n",
    "1. **NumPy**\n",
    "   - Provides support for large multi-dimensional arrays and matrices, along with a collection of mathematical functions to operate on these arrays.\n",
    "   - Website: [NumPy](https://numpy.org/)\n",
    "\n",
    "2. **Pandas**\n",
    "   - Offers data structures and data analysis tools for handling structured data seamlessly.\n",
    "   - Website: [Pandas](https://pandas.pydata.org/)\n",
    "\n",
    "3. **Matplotlib**\n",
    "   - A plotting library for creating static, animated, and interactive visualizations in Python.\n",
    "   - Website: [Matplotlib](https://matplotlib.org/)\n",
    "\n",
    "4. **SciPy**\n",
    "   - Used for scientific and technical computing, building on NumPy with additional modules for optimization, integration, and statistics.\n",
    "   - Website: [SciPy](https://www.scipy.org/)\n",
    "\n",
    "5. **Scikit-learn**\n",
    "   - A library for machine learning that provides simple and efficient tools for data mining and data analysis.\n",
    "   - Website: [Scikit-learn](https://scikit-learn.org/)\n",
    "\n",
    "6. **TensorFlow**\n",
    "   - An open-source library for machine learning and artificial intelligence developed by Google.\n",
    "   - Website: [TensorFlow](https://www.tensorflow.org/)\n",
    "\n",
    "7. **Keras**\n",
    "   - An API designed for human beings, not machines, it’s a high-level neural networks API, written in Python and capable of running on top of TensorFlow.\n",
    "   - Website: [Keras](https://keras.io/)\n",
    "\n",
    "8. **PyTorch**\n",
    "   - An open-source machine learning library developed by Facebook’s AI Research lab.\n",
    "   - Website: [PyTorch](https://pytorch.org/)\n",
    "\n",
    "### Web Development\n",
    "\n",
    "1. **Django**\n",
    "   - A high-level web framework that encourages rapid development and clean, pragmatic design.\n",
    "   - Website: [Django](https://www.djangoproject.com/)\n",
    "\n",
    "2. **Flask**\n",
    "   - A lightweight WSGI web application framework that is easy to learn and simple to use.\n",
    "   - Website: [Flask](https://flask.palletsprojects.com/)\n",
    "\n",
    "3. **FastAPI**\n",
    "   - A modern, fast (high-performance), web framework for building APIs with Python 3.6+ based on standard Python type hints.\n",
    "   - Website: [FastAPI](https://fastapi.tiangolo.com/)\n",
    "\n",
    "### Data Visualization\n",
    "\n",
    "1. **Seaborn**\n",
    "   - A data visualization library based on Matplotlib that provides a high-level interface for drawing attractive statistical graphics.\n",
    "   - Website: [Seaborn](https://seaborn.pydata.org/)\n",
    "\n",
    "2. **Plotly**\n",
    "   - A library for interactive graphing and dashboard building, both for the web and Jupyter notebooks.\n",
    "   - Website: [Plotly](https://plotly.com/python/)\n",
    "\n",
    "3. **Bokeh**\n",
    "   - Provides interactive plots and dashboards, and is designed for modern web browsers.\n",
    "   - Website: [Bokeh](https://bokeh.org/)\n",
    "\n",
    "### Networking\n",
    "\n",
    "1. **Requests**\n",
    "   - An elegant and simple HTTP library for Python, built for human beings.\n",
    "   - Website: [Requests](https://requests.readthedocs.io/)\n",
    "\n",
    "2. **Scrapy**\n",
    "   - An open-source and collaborative web crawling framework for Python.\n",
    "   - Website: [Scrapy](https://scrapy.org/)\n",
    "\n",
    "### Automation\n",
    "\n",
    "1. **Beautiful Soup**\n",
    "   - A library for parsing HTML and XML documents, creating parse trees for web scraping.\n",
    "   - Website: [Beautiful Soup](https://www.crummy.com/software/BeautifulSoup/)\n",
    "\n",
    "2. **Selenium**\n",
    "   - A suite of tools for automating web browsers.\n",
    "   - Website: [Selenium](https://www.selenium.dev/)\n",
    "\n",
    "### Image Processing\n",
    "\n",
    "1. **Pillow**\n",
    "   - The Python Imaging Library adds image processing capabilities to your Python interpreter.\n",
    "   - Website: [Pillow](https://python-pillow.org/)\n",
    "\n",
    "2. **OpenCV**\n",
    "   - An open-source computer vision and machine learning software library.\n",
    "   - Website: [OpenCV](https://opencv.org/)\n",
    "\n",
    "### GUI Development\n",
    "\n",
    "1. **Tkinter**\n",
    "   - The standard GUI toolkit for Python, included with most Python installations.\n",
    "   - Documentation: [Tkinter](https://docs.python.org/3/library/tkinter.html)\n",
    "\n",
    "2. **PyQt**\n",
    "   - A set of Python bindings for the Qt application framework.\n",
    "   - Website: [PyQt](https://riverbankcomputing.com/software/pyqt/intro)\n",
    "\n",
    "### Game Development\n",
    "\n",
    "1. **Pygame**\n",
    "   - A set of Python modules designed for writing video games.\n",
    "   - Website: [Pygame](https://www.pygame.org/)\n",
    "\n",
    "### Miscellaneous\n",
    "\n",
    "1. **SQLAlchemy**\n",
    "   - The Python SQL Toolkit and Object Relational Mapper.\n",
    "   - Website: [SQLAlchemy](https://www.sqlalchemy.org/)\n",
    "\n",
    "2. **pytest**\n",
    "   - A framework that makes building simple and scalable test cases easy.\n",
    "   - Website: [pytest](https://pytest.org/)\n",
    "\n",
    "These libraries are widely used and well-supported, making them excellent choices for developers looking to implement specific functionality in their Python projects."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}