code/14-dependencies.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "📝 **Author:** Amirhossein Heydari - 📧 **Email:** <amirhosseinheydari78@gmail.com> - 📍 **Origin:** [mr-pylin/python-workshop](https://github.com/mr-pylin/python-workshop)\n",
    "\n",
    "---\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Table of contents**<a id='toc0_'></a>    \n",
    "- [Dependencies](#toc1_)    \n",
    "  - [How to import](#toc1_1_)    \n",
    "    - [Importing a Whole Module](#toc1_1_1_)    \n",
    "    - [Importing Specific Functions or Classes](#toc1_1_2_)    \n",
    "    - [Importing Multiple Functions or Classes](#toc1_1_3_)    \n",
    "    - [Importing All Functions or Classes](#toc1_1_4_)    \n",
    "    - [Importing with an Alias](#toc1_1_5_)    \n",
    "    - [Importing Specific Functions with an Alias](#toc1_1_6_)    \n",
    "    - [Relative Imports](#toc1_1_7_)    \n",
    "  - [Dependency Hierarchy](#toc1_2_)    \n",
    "    - [Module](#toc1_2_1_)    \n",
    "    - [Package](#toc1_2_2_)    \n",
    "    - [Library](#toc1_2_3_)    \n",
    "    - [Framework](#toc1_2_4_)    \n",
    "  - [Install Dependencies](#toc1_3_)    \n",
    "\n",
    "<!-- vscode-jupyter-toc-config\n",
    "\tnumbering=false\n",
    "\tanchor=true\n",
    "\tflat=false\n",
    "\tminLevel=1\n",
    "\tmaxLevel=6\n",
    "\t/vscode-jupyter-toc-config -->\n",
    "<!-- THIS CELL WILL BE REPLACED ON TOC UPDATE. DO NOT WRITE YOUR TEXT IN THIS CELL -->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <a id='toc1_'></a>[Dependencies](#toc0_)\n",
    "\n",
    "- A dependency refers to an external package, library, or module that your project requires to function correctly.\n",
    "- Dependencies may be a part of the [standard Python library](https://docs.python.org/3/library/index.html) which means they're pre-installed with python.\n",
    "- Dependencies may not be a part of the standard Python library which means you have to install them using a [package manager](https://en.wikipedia.org/wiki/Package_manager) (e.g. [pip](https://github.com/pypa/pip)).\n",
    "\n",
    "📦 **Types of dependencies**\n",
    "\n",
    "<table style=\"margin: 0 auto;\">\n",
    "  <thead>\n",
    "    <tr>\n",
    "      <th>Concept</th>\n",
    "      <th>Description</th>\n",
    "      <th>Example</th>\n",
    "      <th>Scope</th>\n",
    "    </tr>\n",
    "  </thead>\n",
    "  <tbody>\n",
    "    <tr>\n",
    "      <td><strong>Module</strong></td>\n",
    "      <td>A single Python file containing reusable code</td>\n",
    "      <td><code>math</code>, <code>os</code>, <code>random</code>, <code>json</code>, <code>time</code></td>\n",
    "      <td>Smallest unit, one file</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td><strong>Package</strong></td>\n",
    "      <td>A collection of modules organized into a directory</td>\n",
    "      <td><code>urllib</code>, <code>xml</code>, <code>http</code>, <code>asyncio</code></td>\n",
    "      <td>Directory with related modules</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td><strong>Library</strong></td>\n",
    "      <td>A collection of modules/packages for specific tasks</td>\n",
    "      <td><code>numpy</code>, <code>pandas</code>, <code>matplotlib</code>, <code>requests</code></td>\n",
    "      <td>Reusable tools for specific domains</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td><strong>Framework</strong></td>\n",
    "      <td>A structured collection of libraries/tools</td>\n",
    "      <td><code>django</code>, <code>flask</code>, <code>pytorch</code>, <code>tensorflow</code></td>\n",
    "      <td>Structure for building applications</td>\n",
    "    </tr>\n",
    "  </tbody>\n",
    "</table>\n",
    "\n",
    "📦 **Some of Standard/non-standard libraries**\n",
    "\n",
    "<table style=\"width: 48%; float: left; margin-right: 2%;\">\n",
    "  <thead>\n",
    "    <tr>\n",
    "      <th colspan=2>Standard Libraries</th>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <th style=\"width: 40%;\">Application</th>\n",
    "      <th style=\"width: 60%;\">Library</th>\n",
    "    </tr>\n",
    "  </thead>\n",
    "  <tbody>\n",
    "    <tr>\n",
    "      <td>Data Structures</td>\n",
    "      <td><code>collections</code></td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td>File Handling</td>\n",
    "      <td><code>os</code>, <code>io</code></td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td>Mathematical Operations</td>\n",
    "      <td><code>math</code>, <code>cmath</code></td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td>Date & Time Handling</td>\n",
    "      <td><code>time</code>, <code>datetime</code></td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td>Regular Expressions</td>\n",
    "      <td><code>re</code></td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td>Multithreading/Multiprocessing</td>\n",
    "      <td><code>threading</code>, <code>multiprocessing</code></td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td>Networking</td>\n",
    "      <td><code>socket</code></td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td>JSON/XML Parsing</td>\n",
    "      <td><code>json</code>, <code>xml</code></td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td>Testing & Debugging</td>\n",
    "      <td><code>unittest</code>, <code>pdb</code></td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td>Functional Programming</td>\n",
    "      <td><code>functools</code>, <code>itertools</code></td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td>HTTP Requests</td>\n",
    "      <td><code>http</code></td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td>Serialization</td>\n",
    "      <td><code>pickle</code></td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td>Statistics</td>\n",
    "      <td><code>statistics</code></td>\n",
    "    </tr>\n",
    "  </tbody>\n",
    "</table>\n",
    "\n",
    "<table style=\"width: 48%; float: left;\">\n",
    "  <thead>\n",
    "    <tr>\n",
    "      <th colspan=2>Non-Standard Libraries</th>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <th style=\"width: 40%;\">Application</th>\n",
    "      <th style=\"width: 60%;\">Library</th>\n",
    "    </tr>\n",
    "  </thead>\n",
    "  <tbody>\n",
    "    <tr>\n",
    "      <td>Machine Learning/AI</td>\n",
    "      <td><code>pytorch</code>, <code>tensorflow</code>, <code>scikit-learn</code></td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td>Data Analysis</td>\n",
    "      <td><code>pandas</code>, <code>numpy</code></td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td>Data Visualization</td>\n",
    "      <td><code>matplotlib</code>, <code>seaborn</code>, <code>plotly</code></td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td>Natural Language Processing</td>\n",
    "      <td><code>spacy</code>, <code>nltk</code>, <code>transformers</code></td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td>Web Development</td>\n",
    "      <td><code>django</code>, <code>flask</code></td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td>Database Management</td>\n",
    "      <td><code>sqlalchemy</code>, <code>pymongo</code></td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td>Web Scraping</td>\n",
    "      <td><code>beautifulsoup</code>, <code>scrapy</code>, <code>selenium</code></td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td>Computer Vision</td>\n",
    "      <td><code>opencv</code>, <code>pillow</code>, <code>torchvision</code></td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td>Big Data/Parallel Computing</td>\n",
    "      <td><code>dask</code>, <code>pyspark</code></td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td>Networking</td>\n",
    "      <td><code>requests</code>, <code>httpx</code></td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td>APIs</td>\n",
    "      <td><code>fastapi</code>, <code>flask</code></td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td>Unit Testing</td>\n",
    "      <td><code>pytest</code></td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td>Geospatial Analysis</td>\n",
    "      <td><code>geopandas</code>, <code>shapely</code>, <code>folium</code></td>\n",
    "    </tr>\n",
    "  </tbody>\n",
    "</table>\n",
    "\n",
    "📝 **Docs**:\n",
    "\n",
    "- The import system: [docs.python.org/3/reference/import.html](https://docs.python.org/3/reference/import.html)\n",
    "- The import statement: [docs.python.org/3/reference/simple_stmts.html#the-import-statement](https://docs.python.org/3/reference/simple_stmts.html#the-import-statement)\n",
    "- Module: [docs.python.org/3/glossary.html#term-module](https://docs.python.org/3/glossary.html#term-module)\n",
    "- Modules: [docs.python.org/3/tutorial/modules.html](https://docs.python.org/3/tutorial/modules.html)\n",
    "- Package: [docs.python.org/3/glossary.html#term-package](https://docs.python.org/3/glossary.html#term-package)\n",
    "- \\_\\_import\\_\\_: [docs.python.org/3/library/functions.html#import__](https://docs.python.org/3/library/functions.html#import__)\n",
    "- The Python Standard Library: [docs.python.org/3/library/index.html](https://docs.python.org/3/library/index.html)\n",
    "\n",
    "🐍 **PEP**:\n",
    "\n",
    "- Imports: Multi-Line and Absolute/Relative [[PEP 328](https://peps.python.org/pep-0328/)]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a id='toc1_1_'></a>[How to import](#toc0_)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_1_1_'></a>[Importing a Whole Module](#toc0_)\n",
    "\n",
    "- You can import an entire module using the `import` statement.\n",
    "- This makes all functions and classes in the module available but requires prefixing them with the module name.\n",
    "\n",
    "**Syntax**:\n",
    "\n",
    "```python\n",
    "    import module_name\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.0\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "result = math.sqrt(16)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_1_2_'></a>[Importing Specific Functions or Classes](#toc0_)\n",
    "\n",
    "- If you only need specific functions or classes from a module, you can import them directly.\n",
    "- This allows you to use them without the module prefix.\n",
    "\n",
    "**Syntax**:\n",
    "\n",
    "```python\n",
    "    from module_name import function_name\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.0\n"
     ]
    }
   ],
   "source": [
    "from math import sqrt\n",
    "\n",
    "result = sqrt(16)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_1_3_'></a>[Importing Multiple Functions or Classes](#toc0_)\n",
    "\n",
    "- You can import multiple functions or classes from a module in a single line.\n",
    "\n",
    "**Syntax**:\n",
    "\n",
    "```python\n",
    "    from module_name import function_name1, function_name2\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12.0\n"
     ]
    }
   ],
   "source": [
    "from math import sqrt, pow\n",
    "\n",
    "result = sqrt(16) + pow(2, 3)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_1_4_'></a>[Importing All Functions or Classes](#toc0_)\n",
    "\n",
    "- You can import everything from a module using the asterisk (`*`).\n",
    "- This is generally not recommended as it can lead to name conflicts and make the code less readable.\n",
    "- ⚠️ Using the asterisk (*) in Python imports does not always guarantee that all components of a module will be imported.\n",
    "\n",
    "**Syntax**:\n",
    "\n",
    "```python\n",
    "    from module_name import *\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12.0\n"
     ]
    }
   ],
   "source": [
    "from math import *\n",
    "\n",
    "result = sqrt(16) + pow(2, 3)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_1_5_'></a>[Importing with an Alias](#toc0_)\n",
    "\n",
    "- You can give a module or function an alias to simplify the reference or to avoid name conflicts.\n",
    "- This is especially useful for long module names.\n",
    "\n",
    "**Syntax**:\n",
    "\n",
    "```python\n",
    "    import module_name as alias\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   A  B\n",
      "0  1  3\n",
      "1  2  4\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "data = pd.DataFrame({\"A\": [1, 2], \"B\": [3, 4]})\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_1_6_'></a>[Importing Specific Functions with an Alias](#toc0_)\n",
    "\n",
    "- Similar to importing the whole module, you can also import specific functions with aliases.\n",
    "\n",
    "**Syntax**:\n",
    "\n",
    "```python\n",
    "    from module_name import function_name as alias\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.0\n"
     ]
    }
   ],
   "source": [
    "from math import sqrt as square_root\n",
    "\n",
    "result = square_root(16)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_1_7_'></a>[Relative Imports](#toc0_)\n",
    "\n",
    "- Relative imports are used within a package to import modules relative to the current module’s location.\n",
    "- This is typically used in larger projects with nested packages.\n",
    "\n",
    "**Syntax**:\n",
    "\n",
    "```python\n",
    "    from . import module_name   # Import from the current package\n",
    "    from .. import module_name  # Import from the parent package\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a id='toc1_2_'></a>[Dependency Hierarchy](#toc0_)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_2_1_'></a>[Module](#toc0_)\n",
    "\n",
    "- A module is a single Python file (ending with .py) that contains Python code, such as functions, classes, or variables.\n",
    "- It's the smallest building block in Python\n",
    "- **Examples**: `random`, `math`, `os`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.19421460587930972\n",
      "27\n",
      "cherry\n",
      "['cherry', 'banana', 'apple']\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "# generate a random float between 0 and 1\n",
    "print(random.random())\n",
    "\n",
    "# generate a random integer between 10 and 50\n",
    "print(random.randint(10, 50))\n",
    "\n",
    "# choose a random element from a list\n",
    "choices = [\"apple\", \"banana\", \"cherry\"]\n",
    "print(random.choice(choices))\n",
    "\n",
    "# shuffle a list randomly\n",
    "random.shuffle(choices)\n",
    "print(choices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.141592653589793\n",
      "2.718281828459045\n",
      "4.0\n",
      "120\n",
      "1.0\n",
      "2.302585092994046\n",
      "2.0\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "# constants\n",
    "print(math.pi)  # pi\n",
    "print(math.e)  # euler's number\n",
    "\n",
    "# basic math functions\n",
    "print(math.sqrt(16))  # square root of 16\n",
    "print(math.factorial(5))  # factorial of 5\n",
    "\n",
    "# trigonometry\n",
    "print(math.sin(math.pi / 2))  # sine of 90 degrees\n",
    "\n",
    "# logarithms\n",
    "print(math.log(10))  # Natural logarithm of 10\n",
    "print(math.log10(100))  # Base-10 logarithm of 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c:\\Users\\amirh\\Desktop\\GitHub\\python-workshop\\codes\n",
      "['00_introduction-to-python.ipynb', '01_data-structures.ipynb', '02_index-&-slice.ipynb', '03_operator-&-operand.ipynb', '04_type-conversion.ipynb', '05_conditional-statements.ipynb', '06_loops.ipynb', '07_functions.ipynb', '08_built-in-functions.ipynb', '09_namespace-&-scope.ipynb', '10_lambda.ipynb', '11_pack-unpack.ipynb', '12_type-hints-and-docstrings.ipynb', '13_dependencies.ipynb', '20_closure-decorator.ipynb', '20_comprehensions.ipynb', '20_generators.ipynb', '20_object-oriented-programming.ipynb', 'built-in methods']\n",
      "False\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "# get the current working directory\n",
    "print(os.getcwd())\n",
    "\n",
    "# list files and directories in the current directory\n",
    "print(os.listdir())\n",
    "\n",
    "# check if a path exists\n",
    "print(os.path.exists(\"renamed_file.py\"))\n",
    "\n",
    "# get an environment variable\n",
    "print(os.getenv(\"HOME\"))\n",
    "\n",
    "# create a new directory\n",
    "# os.mkdir('new_folder')\n",
    "\n",
    "# rename a file\n",
    "# os.rename('file1.py', 'renamed_file.py')\n",
    "\n",
    "# remove a file\n",
    "# os.remove('file2.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "json_str       : {\"name\": \"John\", \"age\": 30}\n",
      "type(json_str) : <class 'str'>\n",
      "\n",
      "parsed_data       : {'name': 'John', 'age': 30}\n",
      "type(parsed_data) : <class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "\n",
    "# convert Python dictionary to JSON string\n",
    "data = {\"name\": \"John\", \"age\": 30}\n",
    "json_str = json.dumps(data)\n",
    "print(f\"json_str       : {json_str}\")\n",
    "print(f\"type(json_str) : {type(json_str)}\\n\")\n",
    "\n",
    "# convert JSON string back to Python dictionary\n",
    "parsed_data = json.loads(json_str)\n",
    "print(f\"parsed_data       : {parsed_data}\")\n",
    "print(f\"type(parsed_data) : {type(parsed_data)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counter({3: 3, 2: 2, 1: 1})\n",
      "\n",
      "Point(x=10, y=20)\n",
      "10 20\n"
     ]
    }
   ],
   "source": [
    "import collections\n",
    "\n",
    "# use of Counter to count occurrences of elements in a list\n",
    "counter = collections.Counter([1, 2, 2, 3, 3, 3])\n",
    "print(counter, end=\"\\n\\n\")\n",
    "\n",
    "# use of namedtuple for creating immutable objects with named fields\n",
    "Point = collections.namedtuple(\"Point\", [\"x\", \"y\"])\n",
    "p = Point(10, 20)\n",
    "print(p)\n",
    "print(p.x, p.y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_2_2_'></a>[Package](#toc0_)\n",
    "\n",
    "- A package is a collection of related modules stored in a directory.\n",
    "- It organizes the code into hierarchical directories.\n",
    "- A package usually contains an `__init__.py` file, which allows Python to recognize it as a package.\n",
    "- **Examples**: `collections`, `json`, `urllib`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<!doctype html>\n",
      "<html>\n",
      "<head>\n",
      "    <title>Example Domain</title>\n",
      "\n",
      "    <meta charset=\"utf-8\" />\n",
      "    <meta http-equiv=\"Content-type\" content=\"text/html; charset=utf-8\" />\n",
      "    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\" />\n",
      "    <style type=\"text/css\">\n",
      "    body {\n",
      "        background-color: #f0f0f2;\n",
      "        margin: 0;\n",
      "        padding: 0;\n",
      "        font-family: -apple-system, system-ui, BlinkMacSystemFont, \"Segoe UI\", \"Open Sans\", \"Helvetica Neue\", Helvetica, Arial, sans-serif;\n",
      "        \n",
      "    }\n",
      "    div {\n",
      "        width: 600px;\n",
      "        margin: 5em auto;\n",
      "        padding: 2em;\n",
      "        background-color: #fdfdff;\n",
      "        border-radius: 0.5em;\n",
      "        box-shadow: 2px 3px 7px 2px rgba(0,0,0,0.02);\n",
      "    }\n",
      "    a:link, a:visited {\n",
      "        color: #38488f;\n",
      "        text-decoration: none;\n",
      "    }\n",
      "    @media (max-width: 700px) {\n",
      "        div {\n",
      "            margin: 0 auto;\n",
      "            width: auto;\n",
      "        }\n",
      "    }\n",
      "    </style>    \n",
      "</head>\n",
      "\n",
      "<body>\n",
      "<div>\n",
      "    <h1>Example Domain</h1>\n",
      "    <p>This domain is for use in illustrative examples in documents. You may use this\n",
      "    domain in literature without prior coordination or asking for permission.</p>\n",
      "    <p><a href=\"https://www.iana.org/domains/example\">More information...</a></p>\n",
      "</div>\n",
      "</body>\n",
      "</html>\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import urllib.request\n",
    "import urllib.parse\n",
    "\n",
    "# Download a webpage\n",
    "response = urllib.request.urlopen(\"http://www.example.com\")\n",
    "html = response.read().decode(\"utf-8\")\n",
    "print(html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_2_3_'></a>[Library](#toc0_)\n",
    "\n",
    "- A library is a collection of modules or packages that provides specific functionality or tools that can be reused.\n",
    "- Libraries provide functionalities for specific domains, such as data analysis, web requests, or plotting.\n",
    "- Examples: `numpy`, `pandas`, `matplotlib`, `requests`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array   : [1 2 3 4 5]\n",
      "Mean    : 3.0\n",
      "Sum     : 15\n",
      "Squared : [ 1  4  9 16 25]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# create a NumPy array\n",
    "array = np.array([1, 2, 3, 4, 5])\n",
    "\n",
    "# perform basic operations\n",
    "mean = np.mean(array)\n",
    "sum_array = np.sum(array)\n",
    "squared = np.square(array)\n",
    "\n",
    "# log\n",
    "print(f\"Array   : {array}\")\n",
    "print(f\"Mean    : {mean}\")\n",
    "print(f\"Sum     : {sum_array}\")\n",
    "print(f\"Squared : {squared}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   sepal-length  sepal-width  petal-length  petal-width        class\n",
      "0           5.1          3.5           1.4          0.2  Iris-setosa\n",
      "1           4.9          3.0           1.4          0.2  Iris-setosa\n",
      "2           4.7          3.2           1.3          0.2  Iris-setosa\n",
      "3           4.6          3.1           1.5          0.2  Iris-setosa\n",
      "4           5.0          3.6           1.4          0.2  Iris-setosa\n",
      "\n",
      "unique labels: ['Iris-setosa' 'Iris-versicolor' 'Iris-virginica']\n",
      "\n",
      "average sepal-width : 3.0540000000000003\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# iris dataset as a pandas data-frame\n",
    "iris_df = pd.read_csv(\n",
    "    r\"https://raw.githubusercontent.com/mr-pylin/datasets/refs/heads/main/data/tabular-data/iris/dataset.csv\",\n",
    "    encoding=\"utf-8\",\n",
    ")\n",
    "\n",
    "# display first 5 rows\n",
    "print(iris_df.head(), end=\"\\n\\n\")\n",
    "\n",
    "# display unique labels\n",
    "print(f\"unique labels: {iris_df['class'].unique()}\", end=\"\\n\\n\")\n",
    "\n",
    "# calculate the average sepal-width\n",
    "average_age = iris_df[\"sepal-width\"].mean()\n",
    "print(f\"average sepal-width : {average_age}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# data for plotting\n",
    "x = [1, 2, 3, 4, 5]\n",
    "y = [2, 3, 5, 7, 11]\n",
    "\n",
    "# create a line plot\n",
    "plt.plot(x, y, marker=\"o\")\n",
    "\n",
    "# add title and labels\n",
    "plt.title(\"Simple Line Plot\")\n",
    "plt.xlabel(\"X-axis\")\n",
    "plt.ylabel(\"Y-axis\")\n",
    "\n",
    "# show the plot\n",
    "plt.grid()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_2_4_'></a>[Framework](#toc0_)\n",
    "\n",
    "- A framework is a collection of libraries and tools that provide a structure or foundation for building larger applications.\n",
    "- Frameworks often define rules, guidelines, or a specific architecture that developers need to follow.\n",
    "- **Examples**: `django`, `flask`, `pytorch`, `tensorflow`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "random tensor:\n",
      "tensor([[0.8221, 0.4286, 0.5697],\n",
      "        [0.6242, 0.0710, 0.4255]])\n",
      "\n",
      "Added Tensor:\n",
      "tensor([[2.8221, 2.4286, 2.5697],\n",
      "        [2.6242, 2.0710, 2.4255]])\n",
      "\n",
      "Multiplied Tensor:\n",
      "tensor([[1.6442, 0.8571, 1.1393],\n",
      "        [1.2483, 0.1420, 0.8509]])\n"
     ]
    }
   ],
   "source": [
    "# create a random tensor of shape (2, 3)\n",
    "random_tensor = torch.rand(2, 3)\n",
    "print(f\"random tensor:\\n{random_tensor}\\n\")\n",
    "\n",
    "# tensor addition\n",
    "added_tensor = random_tensor + 2\n",
    "print(f\"Added Tensor:\\n{added_tensor}\\n\")\n",
    "\n",
    "# tensor multiplication (element-wise)\n",
    "multiplied_tensor = random_tensor * 2\n",
    "print(f\"Multiplied Tensor:\\n{multiplied_tensor}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a id='toc1_3_'></a>[Install Dependencies](#toc0_)\n",
    "\n",
    "- You can install the required libraries using `pip` in a terminal.\n",
    "- e.g. `pip install numpy`\n",
    "\n",
    "✍️ **Note**\n",
    "\n",
    "- to install dependencies using `pip` directly in a jupyter notebook, you have to add `%` at the beginning.\n",
    "- e.g. `%pip install numpy`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip install numpy"
   ]
  }
 ],
 "metadata": {
  "author_email": "AmirhosseinHeydari78@gmail.com",
  "author_github": "https://github.com/mr-pylin",
  "author_name": "Amirhossein Heydari",
  "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.12.3"
  },
  "origin_repo": "https://github.com/mr-pylin/python-workshop"
 },
 "nbformat": 4,
 "nbformat_minor": 2
}