Intro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Python #\n",
    "### A workshop by Ryan Handley ###\n",
    "\n",
    "Welcome all!  It is my pleasure to guide you through this introductory Python workshop.\n",
    "\n",
    "Over the course of this workshop, I will cover everything you need to know to start using Python, be it in a Jupyter environment such as this one, in Python files, or in the new version of Excel. \n",
    "\n",
    "The topics we will cover include:\n",
    "- Reasons for Learning Python\n",
    "- Setting up Python\n",
    "- Basics \n",
    "    - Syntax, Variables, and Data Types\n",
    "    - Basic Operations\n",
    "    - Control Structures\n",
    "- Functions\n",
    "- Optimization & Big-O Notation\n",
    "- Basic Data Structures\n",
    "    - Lists\n",
    "    - Dictionaries (AKA Hashmaps)\n",
    "    - Tuples & Sets\n",
    "- Libraries & Modules "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Why Learn Python? ##\n",
    "Python is an extremely popular programming language with a wide array of uses.  Python is so popular in part because of its simplicity, readability, and flexibility.\n",
    "- Used heavily across web development and data science\n",
    "- Syntax is close to plain english, and isn't as bulky as a strongly typed programming language like Java\n",
    "- Can run on any OS\n",
    "- Extremely large community of users with extensive libraries enabling a wide array of tasks to be executed\n",
    "- High Demand in analytics and software.\n",
    "- Amazing support for data science, AI, and Machine Learning\n",
    "- Abundant resources and documentation make python simple to learn\n",
    "\n",
    "### Use Cases ###\n",
    "- Web Development with Django, Flask, & Pyramid\n",
    "- Data Analytics and Visualization with Numpy, Pandas, SciPy, Matplotlib, Plotly, Seaborn, Bokeh, and Dash\n",
    "- ML & AI with Scikit-learn, TensorFlow, Keras and Pytorch\n",
    "- Scientific Computing with Scipy, Sympy, and Biopython\n",
    "- Automation and scripting for repetitive tasks like file handling, web scraping, and automataion of reports.\n",
    "- Cyber Security Tasks such as network scanning, penetration testing, and security tool creation.\n",
    "- Algorithmic trading, financial modeling, and risk management in FinTech and InsurTech using the extensive libraries available.\n",
    "- Natural Language Processing for sentiment analysic, automated text processing, and chatbots using NLTK, Spacy, Keras, abd TextBlob\n",
    "- Automate deployment, resource alocation, and configure infrastructure for Cloud Computing & DevOps \n",
    "- Program IoT devices and integrate with hardware through MicroPython and RPi.GPIO.\n",
    "- For teaching programming, as it's the easiest language to learn."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setting Up Python ##\n",
    "- Download Anaconda & Make an Anaconda Cloud Account for sharing Virtual Environments with your team\n",
    "    - This will give us a distribution of both R and Python\n",
    "    - Allows for the creation and redistribution of Virtual Environments (For reproducing code)\n",
    "- Download Visual Studio Code as a development environment\n",
    "- Configure Anaconda in the Command Line and/or Powershell\n",
    "    - So we may activate environments and create packages from our code to distribute easily to the team\n",
    "- Create a GitHub account with your mstransverse email to use Git for version control\n",
    "    - Allows for collaborative coding and peer reviewing\n",
    "- Configure Git in the command line (Use SSH Keys for secure access to repositories)\n",
    "\n",
    "### Working with Python ###\n",
    "\n",
    "- Create a file with the .ipynb extension for a Jupyter Notebook based enviroment (Such as this one)\n",
    "    - Data Analytics & Exploration\n",
    "    - Machine Learning Prototyping \n",
    "    - Education (Like this workshop)  \n",
    "\n",
    "OR\n",
    "- Create a .py file to create a basic python script\n",
    "    - Creating Packages or Modules\n",
    "    - Automation Scripts\n",
    "    - App Development"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Basics ##\n",
    "### Syntax, Variables, and Data Types ###\n",
    "\n",
    "In this section, we will introduce the most basic parts of Python; those being the syntax, variables, and data types.\n",
    "\n",
    "To declare a variable, simply name it and assign it a value such as below.\n",
    "- Variables can be assigned any data type or data structure this way"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "# We comment our code using a single hash\n",
    "\n",
    "string = 'Hello World' #This is the data type String\n",
    "\n",
    "# We can print the contents of a variable by calling the built-in print function as seen below\n",
    "print(string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Integer\n",
    "int = 5\n",
    "\n",
    "# Float (Double precision floating point)\n",
    "float = 3.14\n",
    "\n",
    "# String\n",
    "str = \"Alice\"\n",
    "\n",
    "# Character (A single character string/token)\n",
    "char = 'a'\n",
    "\n",
    "# Boolean (True or False)\n",
    "is_food = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operations ##\n",
    "\n",
    "### Arithmetic Operations ###\n",
    "We can use python to perform the basic arithmetic operations, as well as modulus (Remainder Division)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10\n",
    "b = 3\n",
    "\n",
    "add = a + b # 13\n",
    "sub = a - b # 7\n",
    "multiply = a * b # 30\n",
    "div = a / b # 3.333...\n",
    "mod = a % b # 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Operations ###\n",
    "We can manipulate strings with operations as well"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Full Name: Dave Grohl\n",
      "\n",
      "Name repeated 3 times: Dave Grohl Dave Grohl Dave Grohl \n",
      "\n",
      "First letter: D\n",
      "\n",
      "Last 3 letters: ohl\n",
      "\n"
     ]
    }
   ],
   "source": [
    "f_name = \"Dave\"\n",
    "l_name = \"Grohl\"\n",
    "\n",
    "# String Concatenation\n",
    "full_name = f_name + \" \" + l_name\n",
    "print(\"Full Name: \" + full_name + \"\\n\") # We can also concatenate strings in the print function\n",
    "                                        # We use \\n to make a new line (For formatting)\n",
    "\n",
    "# String repetition\n",
    "rep_name = (full_name + \" \") * 3 \n",
    "print(\"Name repeated 3 times: \" + rep_name + \"\\n\")\n",
    "\n",
    "# String slicing\n",
    "first_letter = full_name[0]\n",
    "print(\"First letter: \" + first_letter + \"\\n\")\n",
    "\n",
    "last_three_letters = full_name[-3:]\n",
    "print(\"Last 3 letters: \" + last_three_letters + \"\\n\")\n",
    "\n",
    "# String Literals \n",
    "single_quote_str = 'Hello, World'\n",
    "double_quote_str = \"Hello, World\"\n",
    "# These next two are really the same, its just preference\n",
    "triple_quote_str = '''Hello, \n",
    "World'''\n",
    "triple_double_quote_str = \"\"\"Hello, \n",
    "World\"\"\"\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Control Structures ##\n",
    "### Conditional Statements ###\n",
    "We use conditional statements as decision making procedures\n",
    "- if, elif, else\n",
    "    - if checks a specific condition\n",
    "    - elif checks for another condition after determining the previous conditions to be false\n",
    "    - else runs if all previous conditions return false"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adult\n"
     ]
    }
   ],
   "source": [
    "age = 18\n",
    "\n",
    "if age >= 18:\n",
    "    print(\"Adult\")\n",
    "elif age > 12:\n",
    "    print(\"Teenager\")\n",
    "else:\n",
    "    print(\"Child\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loops ###\n",
    "Loops are used to repeat code blocks multiple times\n",
    "- For Loop\n",
    "    - Iterates over a set range of data\n",
    "- While Loop\n",
    "    - Iterates over data while the condition is true\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for i in range(5): # Computers start counting from 0, so to print 1 through 5, we must print i + 1\n",
    "    print(i + 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "count = 0 # Counter Variable to track the state of the condition\n",
    "while count < 5:\n",
    "    print(count + 1) # Prints the value of count plus 1\n",
    "    count += 1 # Increments the value of count "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions ##\n",
    "Functions are reusable blocks of code designed to perform a specific task.  They help to organize and structure code, making it easier to read and maintain.\n",
    "They are defined with the *def* keyword, parentheses *($p_1, p_2, ... p_n$)* to accept parameters, and a colon *:* to define the start of the functions code block. \n",
    "\n",
    "- We call a function using it's name and passing it the appropriate parameters.\n",
    "\n",
    "- We can also call functions inside other functions.  These are so called ***helper functions***\n",
    "\n",
    "- Functions may also have local variables, only accessible to the function itself.\n",
    "\n",
    "- Functions also can contain docstrings, a way of defining the purpose, parameters, and return types of a function using string literals. \n",
    "\n",
    "### Exercise 1: Building a Calculator Function ###\n",
    "Here, we will put the basics we just learned to use to create a simple arithmetic calculator, and we will also tackle the basic form of a function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n",
      "3.3333333333333335\n",
      "13\n",
      "7\n",
      "Invalid Operation\n"
     ]
    }
   ],
   "source": [
    "def calculator(num1, num2, operation):\n",
    "    '''\n",
    "    This is a docstring for the function acting as a basic calculator\n",
    "\n",
    "    Parameters:\n",
    "    num1 (Int or Float): The first number\n",
    "    num2 (Int or Float): The second number\n",
    "    operation ([+, -, *, /]): The operation to perform (Only accepts the list of operators provided)\n",
    "\n",
    "    Returns:\n",
    "    No return type (Prints output instead of returning it)\n",
    "    '''\n",
    "\n",
    "    if operation == '+':\n",
    "        result = num1 + num2\n",
    "    elif operation == '-':\n",
    "        result = num1 - num2\n",
    "    elif operation == '*':\n",
    "        result = num1 * num2\n",
    "    elif operation == '/':\n",
    "        result = num1 / num2\n",
    "    else:\n",
    "        result = \"Invalid Operation\"\n",
    "\n",
    "    print(result)\n",
    "\n",
    "calculator(10,3,'*')\n",
    "calculator(10,3,'/')\n",
    "calculator(10,3,'+')\n",
    "calculator(10,3,'-')\n",
    "calculator(10,3,'%')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Normally, variables are scoped to a function and cannot be accessed outside of it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inside Function: 10\n"
     ]
    }
   ],
   "source": [
    "def my_function():\n",
    "    local_var = 10\n",
    "    print(\"Inside Function:\", local_var)\n",
    "\n",
    "my_function()\n",
    "# print(local_var)  # This will produce an error since the variable is inaccessible outside the scope of the function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can make it so that a variables defined outside the function are accessable inside the function using the *global* keyword"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before function: 20\n",
      "Inside Function: 30\n",
      "After Funtion: 30\n"
     ]
    }
   ],
   "source": [
    "global_var = 20\n",
    "print(\"Before function:\", global_var)\n",
    "\n",
    "def my_function():\n",
    "    global global_var\n",
    "    global_var = 30\n",
    "    print(\"Inside Function:\", global_var)\n",
    "\n",
    "my_function()\n",
    "print(\"After Funtion:\", global_var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 2 & 3: Build two functions ##\n",
    "- Build a function to calculate the factorial of an int *n*\n",
    "- Build a function to check to see if *n* is a prime number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def brute_force_factorial(n):\n",
    "    if n == 0 or n == 1:\n",
    "        return 1\n",
    "    for i in range(1, n + 1):\n",
    "        result *= i\n",
    "    return result\n",
    "\n",
    "def brute_force_prime(n):\n",
    "    if n <= 1:\n",
    "        return False\n",
    "    for i in range(2, n):\n",
    "        if n % i == 0:\n",
    "            return False\n",
    "    return True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Optimization ##\n",
    "While the above two functions are correct, they are highly inefficient.  In programming we measure the efficiency of a program in time and space with ***Big O notation***\n",
    "\n",
    "Big-O describes the upper limit on the time and space an algorithm takes up to fully execute.  The following chart details the best Big-O notations.\n",
    "  \n",
    "![Big-O Graph](big-o-chart.png)\n",
    "  \n",
    "- O(1): Constant. The runtime and memory consumption doesn't change regardless of the input size. \n",
    "    - Example: Accessing an element in an array.\n",
    "- O(log n): Logarithmic. The runtime and memory usage increases logarithmically as the input size increases. \n",
    "    - Example: Binary search in a sorted array.\n",
    "- O(n): Linear. The runtime and memory usage increases linearly with the input size. \n",
    "    - Example: A loop that iterates through all elements in an array.\n",
    "- O(n log n): Linearithmic. Common in efficient sorting algorithms like merge sort and quicksort.\n",
    "- O(n^2): Quadratic. The runtime and memory usage increases quadratically as the input size increases. \n",
    "    - Example: A nested loop where each loop runs n times.\n",
    "- O($2^n$) indicates that the time and space it takes to run an algorithm doubles with each additional element in the input. This is exponential growth, meaning the runtime increases very rapidly as 𝑛 increases.\n",
    "    - Solving the subset sum problem / generating all subsets of a set   \n",
    "- O(n!) indicates that the time and space it takes to run an algorithm increases factorially with the input size.  The runtime multiplies by an additional integer each time the input size increases.\n",
    "    - Generating all permutations of a set of numbers.      "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How may we improve the efficiency of exercises 2 & 3? ###\n",
    "The brute force factorial function is about as efficient as it can be written, but python has a function in their math library which is highly optimized for this task.\n",
    "It will remain O(n) in time, and O(1) in space.\n",
    "\n",
    "The brute force prime checker can be improved by checking up to the square root of n and by handling small and even number more effectively, bringing the complexity down from O(n) in time to O($\\sqrt n$), and the space complexity remains constant."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math # Importing a library (This one is native to python)\n",
    "\n",
    "def efficient_factorial(n):\n",
    "    return math.factorial(n)\n",
    "\n",
    "def efficient_prime(n):\n",
    "    if n <= 1:\n",
    "        return False\n",
    "    if n <= 3:\n",
    "        return True\n",
    "    if n % 2 == 0 or n % 3 == 0:\n",
    "        return False\n",
    "\n",
    "    i = 5\n",
    "    while i * i <= n:\n",
    "        if n % i == 0 or n % (i + 2) == 0:\n",
    "            return False\n",
    "        i += 6\n",
    "    return True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Structures ##\n",
    "\n",
    "In this section, we'll cover the most essential data structures used in Python as it pertains to analytics.  Anything more advanced is typically beyond the scope of what is needed in analytics, but it does not hurt to know more advanced concepts either.\n",
    "\n",
    "Far and away one of the most important concepts in computer science, data structures are used to organize and store data so it may be accessed and modified more efficiently.  Efficient data structures are crucial for creating efficient algorithms.\n",
    "\n",
    "### Lists ###\n",
    "Ordered, mutable collections of data.  We can store all different sorts of data in a list at one time. \n",
    "   \n",
    "Operations: \n",
    "- Creation \n",
    "- Access Elements\n",
    "- Add Elements\n",
    "- Remove Elements\n",
    "- List Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "\n",
      "6\n",
      "\n",
      "-1\n",
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "\n",
      "Index: 0, Value: -1\n",
      "Index: 1, Value: 0\n",
      "Index: 2, Value: 1\n",
      "Index: 3, Value: 2\n",
      "Index: 4, Value: 3\n",
      "Index: 5, Value: 4\n",
      "Index: 6, Value: 5\n"
     ]
    }
   ],
   "source": [
    "from collections import deque \n",
    "basic_list = deque([0,1,2,3,4,5])\n",
    "print(str(basic_list[0]) + \"\\n\") # We may convert data to a string with str()\n",
    "\n",
    "# Adding to the front of a list\n",
    "#basic_list.appendleft(-1) # One easy method to insert data to the front of a list (as long as it is a double-ended queue list)\n",
    "# We will see the value in the list when we loop through it later\n",
    "#basic_list = [-1,*basic_list] # Adding to the front via unpacking\n",
    "basic_list.insert(0,-1) # Inserts a value at a certain index, in this case, index 0 gets 0\n",
    "#basic_list = [-1] + basic_list # Adding a value to the begining via list slicing, but only works with normal lists (not deque)\n",
    "\n",
    "basic_list.append(6) # Adds a piece of data to the end of the list\n",
    "print(str(basic_list[-1]) + \"\\n\") # Print the last item in a list with negative indexing\n",
    "\n",
    "basic_list.pop() # Removes the last item on a list\n",
    "# Basic Loop to print a list\n",
    "for i in basic_list:\n",
    "    print(i) #Looping through a list\n",
    "\n",
    "print() # Blank Print will produce a single new line (Use for spacing in outputs)\n",
    "\n",
    "#Loop to print the index and value\n",
    "for i, x in enumerate(basic_list):\n",
    "    print(f\"Index: {i}, Value: {x}\") # Dynamic value rendering using f\"\" as a formatter\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries/Hashmaps ###\n",
    "Unordered, mutable collections of data which consist of key-value pairings.  Known as a hashmap in other programming languages.  \n",
    "  \n",
    "Operations:  \n",
    "- Creation\n",
    "- Access Data\n",
    "- Add Data\n",
    "- Remove Data\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'Ryan', 'age': 21, 'city': 'New York City'}\n",
      "\n",
      "{'name': 'Ryan', 'age': 21}\n",
      "\n",
      "Ryan\n"
     ]
    }
   ],
   "source": [
    "my_dict = {'name' : 'Ryan', 'age': 21 }\n",
    "my_dict['city'] = 'New York City' # Creating a new key value pairing\n",
    "print(str(my_dict) + \"\\n\") # Printing the contents of the dictionary\n",
    "del my_dict['city'] # Removing a key and its associated value\n",
    "print(str(my_dict) + \"\\n\") # Updated dictionary with key removed\n",
    "print(my_dict['name']) # Accessing the value of a specific key "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples & Sets ###\n",
    "Tuples are ordered, immutable collections of data.  \n",
    "  \n",
    "Operations:\n",
    "- Creation\n",
    "- Access"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (1, 2, 3, 4, 5)\n",
    "print(my_tuple[1])  # Not changeable, tuples stay as they are"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sets are unordered collections of unique data (Ie no repeating values)\n",
    "  \n",
    "Operations:  \n",
    "- Creation\n",
    "- Access Data (Only viewable by control structures or printing the whole set, no indexing)\n",
    "- Add Data\n",
    "- Remove Data\n",
    "- Union, Intersection, Difference\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 3, 4, 5, 6}\n",
      "\n",
      "{1, 2, 3, 4, 5}\n",
      "{3}\n",
      "{1, 2}\n"
     ]
    }
   ],
   "source": [
    "my_set = {1, 2, 3, 4, 5}\n",
    "my_set.add(6)\n",
    "my_set.remove(2)\n",
    "my_set.pop() # Removes the first element\n",
    "print(str(my_set) + \"\\n\")\n",
    "set1 = {1, 2, 3}\n",
    "set2 = {3, 4, 5}\n",
    "print(set1 | set2)  # Union\n",
    "print(set1 & set2)  # Intersection\n",
    "print(set1 - set2)  # Difference"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Libraries & Modules ##\n",
    "Libraries and modules are collections of functions which allow us to perform a lot of different actions without implementing code from scratch.  This allows for simpler code, simpler tasks, and a more productive coding experience.\n",
    "\n",
    "We use the keyword *import* to use a library installed in our machine or virtual environment.  We may also use the *from* keyowrd to access specific functionality without wasting memory by importing the whole package.  \n",
    "\n",
    "All libraries & modules have online documentation for how to use them.  We won't go into detail on all of them.  Pandas and Numpy will be covered here as they are important, but will be discussed in more detail in Analytics_with_python.ipynb, along side machine learning with scikit-learn and visualization with Matplotlib and bokeh."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.0\n"
     ]
    }
   ],
   "source": [
    "from math import sqrt\n",
    "print(sqrt(16))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Useful Modules ##\n",
    "- os - Used for IO, environmental variable access, directory management, and other Operating System specific tasks\n",
    "- sys - Used to access variables used & maintained by the python interpreter, as well as functions which interact strongly with the interpreter\n",
    "- datetime - Provides classes (See object oriented programming in Advanced.ipynb) for manipulating dates and times\n",
    "- math - Used for mathematical functions like trigonometry, logarithms, factorial, etc.\n",
    "- json - Provides functions which parse JSON (JavaScript Object Notation) strings and create JSON strings from Python data structures \n",
    "- random - Provides pseudo-random number generation\n",
    "-collections - implements specialized container datatypes such as namedtuple, deque, Counter, and OrderedDict "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Most useful libraries ##\n",
    "- Numpy - For numerical computations, arrays, matrices, and more in depth mathematical functionality\n",
    "- Pandas - data manipulation and analysis library, providing the data structure *dataframes* for handling structured data.  Also capable of some plotting capabilities with matplotlib under the hood.\n",
    "- Scikit-learn - Machine learning model for data analytics and modeling\n",
    "- Tensorflow - Open-source machine learning and deep learning tools from Google\n",
    "- requests - for making HTTP requests\n",
    "- BeautifulSoup - for parsing HTML & XML\n",
    "- Selenium - Automates web browser interactions (For web scraping and whatnot)\n",
    "- Data Visualization Libraries\n",
    "    - Matplotlib - plotting library to create static, animated, and interactive visualizations\n",
    "    - Plotly - Enhances interactivity of matplotlib\n",
    "    - Seaborn - a statistical data vis library built on matplotlib\n",
    "    - Bokeh - For creating Dashboards and highly interactive plots\n",
    "    - Dash - For web-based dashboards with minimal effort, integrating with plotly\n",
    "- OpenCV - Computer vision and image processing"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "MST-Analytics",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}