Notes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# Beginner Notes"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "* You can type the integer 1MM as 1_000_000 and it is still type int\n",
    "* 8/4 will become a float but 8//4 will become an int\n",
    "* int(2.6) will cast the float as an int *without rounding*, i.e., becomes 2\n",
    "* draw.io is a useful drawing tool for making flow charts\n",
    "* % is the modulo and shows the remainder (e.g., 7 % 2 == 1)\n",
    "* Python prefers spaces to tabs, and as of Python 3, the two cannot be intermixed\n",
    "* An indentation is made up of 4 spaces\n",
    "* Break exits a loop while continue restarts the loop\n",
    "* re.sub(r'[^a-zA-Z0-9]', '', string) removes non-alphanumeric items from string using regex\n",
    "* Names: def function(parameter=argument)\n",
    "* A \"positional argument\" is like (parameter1, parameter2) but a \"keyword argument is (parameter=argument)\n",
    "* Functions can return multiple results (e.g., def fun(a, b): / a += 1 / b += 1/ return a, b / new_a, new_b = fun(1, 2)\n",
    "* Recursion is when you call a function within a function\n",
    "* The local and global scope of methods is part of a namespace\n",
    "* Python does not have block scope (e.g., variables defined within an if statement do not have different scope)\n",
    "* Avoid modifying global scope\n",
    "* Global constants by convention are written is all caps (e.g., PI, CREDENTIALS)\n",
    "* https://pythontutor.com/visualize.html#mode=edit is a useful debugging tool"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Intermediate Notes"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "* PEP 8 is the conventional style guide for Python\n",
    "* Add two digits to num = 0.1 in an f-string by print(f'{num:.2f}')\n",
    "* A modeled object (a la OOP) has attributes and methods\n",
    "* A class is a blueprint used to create objects\n",
    "* Classes are written by convention in Pascal case"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "outputs": [],
   "source": [
    "# Intro to object-oriented programming with the turtle class\n",
    "# https://docs.python.org/3/library/turtle.html\n",
    "import random\n",
    "from turtle import Turtle, Screen\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "franklin = Turtle()\n",
    "franklin.shape('turtle')\n",
    "franklin.color('red')\n",
    "franklin.forward(100)\n",
    "\n",
    "my_screen = Screen()\n",
    "my_screen.exitonclick()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "* pypi.org (Python Package Index) is useful for package searches\n",
    "* A third way to install packages is going PyCharm -> Preferences -> Project: my_project_name -> Python Interpreter -> +\n",
    "* Access underlying python file of a package by right-clicking package name -> Go To -> Implementation(s)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+------------+----------+\n",
      "| Pokemon    | Type     |\n",
      "+------------+----------+\n",
      "| Pikachu    | Electric |\n",
      "| Squirtle   | Water    |\n",
      "| Charmander | Fire     |\n",
      "+------------+----------+\n"
     ]
    }
   ],
   "source": [
    "from prettytable import PrettyTable\n",
    "\n",
    "table = PrettyTable()\n",
    "table.add_column('Pokemon', ['Pikachu', 'Squirtle', 'Charmander'])\n",
    "table.add_column('Type', ['Electric', 'Water', 'Fire'])\n",
    "table.align = 'l' #align is an attribute in the PrettyTable class\n",
    "\n",
    "print(table)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "* If a Class is a blueprint, then the Constructor (aka initializing) are the specifications for that blueprint\n",
    "* \"The attributes are the thing that an object had and the methods are the things that an object does.\"\n",
    "* Code -> Auto-Indent Lines is a cool featrure"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "# Example from Day 17\n",
    "class User:\n",
    "    def __init__(self, user_id, username):\n",
    "        self.id = user_id\n",
    "        self.username = username\n",
    "        self.followers = 0\n",
    "        self.following = 0\n",
    "\n",
    "    def follow(self, user):\n",
    "        user.followers += 1\n",
    "        self.following += 1\n",
    "\n",
    "user1 = User('001', 'aaron')\n",
    "user2 = User('002', 'tom')\n",
    "\n",
    "print(user1.following)\n",
    "user1.follow(user2)\n",
    "print(user1.following)\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "&quot;Hello world!&quot;\n"
     ]
    },
    {
     "data": {
      "text/plain": "'\"Hello world!\"'"
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Removed parsing/encoding issue with quotation marks (among others)\n",
    "import html.parser\n",
    "text = '&quot;Hello world!&quot;'\n",
    "print(text)\n",
    "html.unescape(text)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "* Functions used as inputs should not include parentheses\n",
    "* A class can inherit the properties of another class. E.g., class Fish(Animal): / def __init__(self): / super().__init__()\n",
    "* Slicing is defined by [at_starting_position:before_ending_position:increment], e.g., [::2] returns every other item from a list and [::-1] returns the list in reverse\n",
    "* Modes when opening a file: read (r, default), write (w), append (a)\n",
    "* Using <with open('my_file.txt') as file> is better than <file = open('my_file.txt')> because the latter then needs to use <file.close()> or else it will use up memory\n",
    "* Opening a non-existent file in write mode will create a new file\n",
    "* List comprehension (e.g., [new_item for item in list]) is rather unique to the Python language\n",
    "* Convert a dataframe to a dictionary using {index:row for (row, index) in df.interrows()}\n",
    "* Shift F6 is the refactor shortcut on a Mac"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "outputs": [
    {
     "data": {
      "text/plain": "55"
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# An example of a function with unlimited positional arguments\n",
    "def add(*args):\n",
    "    total = 0\n",
    "    for n in args:  # args is a tuple\n",
    "        total += n\n",
    "    return total\n",
    "\n",
    "add(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'add': 3, 'multiply': 5}\n",
      "add 3\n",
      "multiply 5\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# An example of a function with unlimited keyword arguments\n",
    "def calculate(**kwargs):\n",
    "    print(kwargs)\n",
    "    for key, value in kwargs.items():\n",
    "        print(key, value)\n",
    "    print(kwargs['add'])\n",
    "\n",
    "calculate(add=3, multiply=5)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "# kwargs are useful in defining classes\n",
    "class Car:\n",
    "    def __init__(self, **kw):\n",
    "        # kw.get() is useful because it will return None if not specified\n",
    "        self.make = kw.get('make')\n",
    "        self.model = kw.get('model')\n",
    "\n",
    "my_car = Car(make='Kia')\n",
    "print(my_car.model)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "* Tkinter has three layout managers\n",
    "    * *pack* just packs everything together in a vaguely logical order\n",
    "    * *place* assigns a widget to an x, y coordinate\n",
    "    * *grid* assigns a widget to a column, row; however, this is relative to other components\n",
    "* colorhunt.co is useful for picking a pallet of colors with associated hex codes.\n",
    "* Python is \"strongly typed\", meaning it records the data type of a saved variable.\n",
    "* Python is also \"dynamically typed\", meaning the variable type can be changed if the variable changes (e.g., a=2, a='2').\n",
    "* Types of errors:\n",
    "    * try: something that might cause an exception\n",
    "    * except: do this If there was an exception\n",
    "    * else: do this if there were no exceptions\n",
    "    * finally: do this no matter what happens\n",
    "* PEP 8 recommends \"except\" to be followed by an error type"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Web Foundations / Intermediate+ Notes"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "* SMTP (Simple Mail Transfer Protocol) is the backbone of email\n",
    "* An Application Programming Interface (API) is a set of commands, functions, protocols, and objects that programmers can use to create software or interact with an external system.\n",
    "* Type of API error codes (see a longer list [here](https://httpstatuses.com)):\n",
    "    * 1XX: Hold on\n",
    "    * 2XX: Here you go\n",
    "    * 3XX Go away\n",
    "    * 4XX You screwed up\n",
    "    * 5XX I screwed up\n",
    "* Before the '?' is the API url and after are the parameters\n",
    "* Variables can be set as a type before being defined (e.g., age: int)\n",
    "    * This is especially useful for function inputs, e.g., def can_drive(age: int) -> bool: ...\n",
    "        * The '-> bool' addition is a 'hint' that says the output should be of type boolean\n",
    "* Four common types of HTTP Requests are get, post, put, delete\n",
    "* Basic websites are built with three types of code files\n",
    "    * HTML is responsible for building the structure of the site\n",
    "    * CSS provides styling and appearance\n",
    "    * JavaScript provides functions and actions to occur on the website\n",
    "* Codepen.io is a useful way to preview web development with HTML, JS, CSS\n",
    "* https://devdocs.io provides useful documentation for many languages, packages\n",
    "* The technical name of garbled text from bad decoding is Mojibake\n",
    "* Mac shortcut to the emoji keyboard is Command + Control + Space\n",
    "* Cascading Style Sheet (CSS) was the response to how bad HTML was at layout.\n",
    "* If CSS code is not working, look into the default CSS setting used by the browser.\n",
    "* CSS is based on stacked boxes. Pesticide is a Chrome extension that will display those boxes.\n",
    "* It's better to set widths as a percent to adjust to device size\n",
    "* Developer tools are available in Chrome through the elipses -> More tools -> Developer tools\n",
    "* CSS syntax follows selector{property:value;} or who{what:how;}\n",
    "* It's recommended to write the style properties in alphabetical order\n",
    "* Emojipedia shows emojis by platforms\n",
    "* Class selectors (vs. the previously discussed tag selectors) in CSS can let you define different styles by class\n",
    "* Define class selectors with .class_name {} and id selectors with #tag_name {}\n",
    "* Classes can add multiple items while an id is for just one item\n",
    "* :hover is a \"pseudo class\" that changes an item's property when the mouse is hovering over that item\n",
    "* The icon in a browser tab is call a \"favicon\"\n",
    "* The Box Model in CSS includes a margin, border and padding\n",
    "* There are three types of displays: inline, block and inline-block\n",
    "    * Images are like inline-block elements\n",
    "* Four types of positions: Static, Relative, Absolute and Fixed\n",
    "    * Relative is relative to the position the element would have been (left moves right)\n",
    "    * Absolute is relative to the parent element (left moves left)\n",
    "* Download fonts for website embeddings at https://fonts.google.com\n",
    "* https://www.flaticon.com offers free icons\n",
    "* https://css3buttongenerator.com/ helps with button generation\n",
    "* Beautiful Soup works for both html and xml files\n",
    "* Many websites provide guidelines on what can/can't be scraped, e.g., https://wmich.edu/robots.txt\n",
    "* Selenium is preferred to BeautifulSoup when it requires actually navigating to a page to render the desired html\n",
    "* Get http header info from http://myhttpheader.com\n",
    "* Flask and Django back-end web development frameworks (with Flask being easier)\n",
    "    * Flask is a framework, not a library\n",
    "* Back-end development includes three components: client, server, database"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (3853641488.py, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001B[0;36m  File \u001B[0;32m\"/var/folders/8k/1982q0sd17v8dt4gxj5mqhk80000gn/T/ipykernel_16280/3853641488.py\"\u001B[0;36m, line \u001B[0;32m2\u001B[0m\n\u001B[0;31m    cd Projects/Day054  # navigate to working directory\u001B[0m\n\u001B[0m              ^\u001B[0m\n\u001B[0;31mSyntaxError\u001B[0m\u001B[0;31m:\u001B[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "# Run this as a bash command for Flask\n",
    "cd Projects/Day054  # navigate to working directory\n",
    "export FLASK_APP=main.py  # Set environmental variable\n",
    "flask run  # Run the program locally\n",
    "# Close Flask with Control + C"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Common Terminal commands\n",
    "pwd  # Print working directory\n",
    "ls  # List files in current working directory\n",
    "cd  # Change directory (use tab to auto-complete)\n",
    "mkdir  # Make new directory\n",
    "touch # Make new file\n",
    "rm  # Delete file\n",
    "rm -rf  # Delete folder (danger zone!)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "* Functions are \"first-class objects\", meaning they can be passed around as arguments (e.g., int/str/float)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Decorator functions in Python\n",
    "import time\n",
    "def delay_decorator(function):\n",
    "    def wrapper_function():\n",
    "        time.sleep(2)\n",
    "        function()\n",
    "        function()\n",
    "    return wrapper_function\n",
    "\n",
    "# The decorator modifies a function with additional functionality\n",
    "# Method 1\n",
    "@delay_decorator\n",
    "def say_hello():\n",
    "    print('Hello')\n",
    "say_hello()\n",
    "\n",
    "# Method 2\n",
    "decorated_function = delay_decorator(say_hello)\n",
    "decorated_function()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "* Hard reload a webpage in Chrome to update the static cached files by holding down shift and then refresh\n",
    "* Jinja is a templating language that uses double curly braces to determine which aspects of code should be run as Python\n",
    "    * There are other options for multi-lines of code. E.g., {% for item in loop %} ... {% endfor %}\n",
    "* Bootstrap is the most popular front-end package, is responsive and includes pre-styled elements\n",
    "    * A website is \"responsive\" if it reformats itself to the device being used\n",
    "* Balsamiq is used for wire-framing new website layouts\n",
    "* Fontawesome has many glyphs"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Advanced Notes"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Web Development\n",
    "* Don't Repeat Yourself (DRY) > We Enjoy Typing (WET)\n",
    "* Priority of code refactoring: 1. Readability, 2. Modularity, 3. Efficiency, 4. Length\n",
    "* In CSS, use IDs sparingly, usually only for section headers to support navigation. Use classes for all else.\n",
    "* Creating a requirements.txt file: pip freeze > requirements.txt\n",
    "* Using a requirements.txt file: pip3 install -r requirements.txt\n",
    "* I downloaded/used DB Browser of SQLite to view database\n",
    "* SQLAlchemy uses Python to interact with SQL databases\n",
    "* REST [API] stands for REspresentational State Transfer\n",
    "* 5 HTTP verbs used in REST API calls: get, post, put, patch, delete\n",
    "* Serialization is the act of turning an object into JSON\n",
    "* hackertyper.net is incredibly realistic and accurate\n"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Data Science\n",
    "* Change pandas formatting with pd.options.display.float_format = '{:,.2f}'.format\n",
    "* .agg is an efficient way to aggregate data, e.g., df.groupby('year').agg({'id': pd.Series.nunique})\n",
    "* A numpy array is homogenous, meaning all data is of the same type\n",
    "* A *tensor* is an array with 3 or more dimensions\n",
    "* Use **@** to multiply numpy matrices\n",
    "* df.info() shows column names, non-null counts, and data types\n",
    "* Change column without splicing by df['col'].astype(str).str.replace(',', '') and/or df['col'] = pd.to_numeric(df['col'])\n",
    "* Check for NA values: df.isna().values.any()\n",
    "* Check for duplicates: df.duplicated().values.any()"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}