Lab6_CodeStyle-Final.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "athletic-store",
   "metadata": {},
   "source": [
    "**Useful Links**\n",
    "\n",
    "Flake8 Documentation: https://flake8.pycqa.org/en/latest/\n",
    "\n",
    "Pep 8 Documentation: https://www.python.org/dev/peps/pep-0008\n",
    "\n",
    "Error Codes: https://pep8.readthedocs.io/en/release-1.7.x/intro.html#error-codes\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "golden-eight",
   "metadata": {},
   "source": [
    "**Linting Your Python Code**\n",
    "\n",
    "One class of productivity tools that can be used to support the development of code that conforms to a particular style guide or coding convention such as PEP8 are known as code linters.\n",
    "\n",
    "These tools provide offline, static analysis of code and can generate reports that describe where code diverges from the style guide.\n",
    "\n",
    "Some tools may also automatically correct code style, although from a learning perspective it can often be more useful to be warned when you diverge from the code style guidelines so that you can fix the code (and learn how to write it correctly) rather than having the code style automatically corrected for you."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "champion-timeline",
   "metadata": {},
   "source": [
    "**Installation**\n",
    "\n",
    "The pycodestyle_magic extension provides some IPython magic for automatically running the flake8 PEP8 linter against code cells each time you run them.\n",
    "\n",
    "If your code diverges from PEP8 style guidelines, a warning will be issued.\n",
    "\n",
    "Install the package by running the following command, which also installs some additional linting rules, such as rules covering function name styling and docstrings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "id": "explicit-format",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: flake8 in ./miniconda3/lib/python3.8/site-packages (3.8.4)\r\n",
      "Requirement already satisfied: pycodestyle_magic in ./miniconda3/lib/python3.8/site-packages (0.5)\r\n",
      "Requirement already satisfied: mccabe<0.7.0,>=0.6.0 in ./miniconda3/lib/python3.8/site-packages (from flake8) (0.6.1)\r\n",
      "Requirement already satisfied: pycodestyle<2.7.0,>=2.6.0a1 in ./miniconda3/lib/python3.8/site-packages (from flake8) (2.6.0)\r\n",
      "Requirement already satisfied: pyflakes<2.3.0,>=2.2.0 in ./miniconda3/lib/python3.8/site-packages (from flake8) (2.2.0)\r\n"
     ]
    }
   ],
   "source": [
    "!pip install flake8 pycodestyle_magic"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "neither-listening",
   "metadata": {},
   "source": [
    "To disable rules associated with a particular flake8 extension package, uninstall it and then restart the notebook kernel. For example:\n",
    "\n",
    "!pip uninstall -y flake8-bugbear\n",
    "\n",
    "Other flake8 extensions can be found in this awesome list of flake8 extensions."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "greatest-glasgow",
   "metadata": {},
   "source": [
    "**Loading the Magic**\n",
    "\n",
    "Each time you want to run the linter, you need to load the magic into a notebook using the command:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "id": "hawaiian-appointment",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The pycodestyle_magic extension is already loaded. To reload it, use:\n",
      "  %reload_ext pycodestyle_magic\n"
     ]
    }
   ],
   "source": [
    "%load_ext pycodestyle_magic"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "auburn-bangladesh",
   "metadata": {},
   "source": [
    "**Enabling the Magic**\n",
    "\n",
    "\n",
    "The linter can be enabled within a particular notebook by running the magic command:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "id": "connected-sandwich",
   "metadata": {},
   "outputs": [],
   "source": [
    "%flake8_on"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "id": "palestinian-teens",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1:7: E271 multiple spaces after keyword\n"
     ]
    }
   ],
   "source": [
    "import   seaborn"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "wound-brook",
   "metadata": {},
   "source": [
    "With the linter enabled, each time you run a code cell the code within it will be passed through the linter, and any deviations from the flake installed style conventions will be reported on."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sustained-talent",
   "metadata": {},
   "source": [
    "Automatic running of the linter within a notebook can be disabled by using the command: %flake8_off"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "id": "efficient-zambia",
   "metadata": {},
   "outputs": [],
   "source": [
    " %flake8_off"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "corrected-strategy",
   "metadata": {},
   "source": [
    "**Examples: Indentation**\n",
    "\n",
    "\n",
    "Use 4 spaces per indentation level.\n",
    "\n",
    "Continuation lines should align wrapped elements either vertically using Python's implicit line joining inside parentheses, brackets and braces, or using a hanging indent [7]. When using a hanging indent the following should be considered; there should be no arguments on the first line and further indentation should be used to clearly distinguish itself as a continuation line:\n",
    "\n",
    "\n",
    "**Blank Lines**\n",
    "\n",
    "Surround top-level function and class definitions with two blank lines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "id": "equipped-brand",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "# Wrong:\n",
    "# Further indentation required as indentation is not distinguishable.\n",
    "var_one = 1\n",
    "var_two = 2\n",
    "var_three = 3\n",
    "var_four = 4\n",
    "\n",
    "def long_function_name(\n",
    "    var_one, var_two, var_three,\n",
    "    var_four):\n",
    "    print(var_one)\n",
    "# Arguments on first line forbidden when not using vertical alignment.\n",
    "foo = long_function_name(var_one, var_two,\n",
    "    var_three, var_three)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "id": "flush-wisconsin",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "# Correct:\n",
    "var_one = 1\n",
    "var_two = 2\n",
    "var_three = 3\n",
    "var_four = 4\n",
    "\n",
    "\n",
    "# Aligned with opening delimiter.\n",
    "foo = long_function_name(var_one, var_two,\n",
    "                         var_three, var_four)\n",
    "\n",
    "\n",
    "# Add 4 spaces (an extra level of indentation) to distinguish arguments\n",
    "#  from therest.\n",
    "def long_function_name(\n",
    "        var_one, var_two, var_three,\n",
    "        var_four):\n",
    "    print(var_one)\n",
    "\n",
    "\n",
    "# Hanging indents should add a level.\n",
    "foo = long_function_name(\n",
    "    var_one, var_two,\n",
    "    var_three, var_four)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "driven-diesel",
   "metadata": {},
   "source": [
    "**Tabs or Spaces?**\n",
    "\n",
    "\n",
    "Spaces are the preferred indentation method.\n",
    "\n",
    "Tabs should be used solely to remain consistent with code that is already indented with tabs.\n",
    "\n",
    "Python 3 disallows mixing the use of tabs and spaces for indentation.\n",
    "\n",
    "Python 2 code indented with a mixture of tabs and spaces should be converted to using spaces exclusively."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "constitutional-netherlands",
   "metadata": {},
   "source": [
    "**Should a Line Break Before or After a Binary Operator?**\n",
    "\n",
    "\n",
    "For decades the recommended style was to break after binary operators. But this can hurt readability in two ways: the operators tend to get scattered across different columns on the screen, and each operator is moved away from its operand and onto the previous line. Here, the eye has to do extra work to tell which items are added and which are subtracted:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "id": "respiratory-operation",
   "metadata": {},
   "outputs": [],
   "source": [
    "gross_wages = 100\n",
    "taxable_interest = 10\n",
    "dividends = 5\n",
    "qualified_dividends = 3\n",
    "ira_deduction = 2\n",
    "student_loan_interest = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "id": "disturbed-debate",
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO\n",
    "# Wrong:\n",
    "# operators sit far away from their operands\n",
    "# No: operators sit far away from their operands\n",
    "income = (gross_wages +\n",
    "          taxable_interest +\n",
    "          (dividends - qualified_dividends) -\n",
    "          ira_deduction -\n",
    "          student_loan_interest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "id": "developmental-addiction",
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO\n",
    "# Correct:\n",
    "# easy to match operators with operands\n",
    "# Yes: easy to match operators with operands\n",
    "income = (gross_wages\n",
    "          + taxable_interest\n",
    "          + (dividends - qualified_dividends)\n",
    "          - ira_deduction\n",
    "          - student_loan_interest)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "judicial-unknown",
   "metadata": {},
   "source": [
    "**Imports**\n",
    "\n",
    "\n",
    "Imports should usually be on separate lines\n",
    "\n",
    "Imports are always put at the top of the file, just after any module comments and docstrings, and before module globals and constants."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "id": "surrounded-utility",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Wrong:\n",
    "import sys, os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "id": "awful-restaurant",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correct:\n",
    "import os\n",
    "import sys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "id": "generic-nashville",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correct:\n",
    "# It's okay to say this though:\n",
    "from subprocess import Popen, PIPE"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "potential-madagascar",
   "metadata": {},
   "source": [
    "Imports should be grouped in the following order:\n",
    "\n",
    "Standard library imports.\n",
    "Related third party imports.\n",
    "Local application/library specific imports.\n",
    "You should put a blank line between each group of imports.\n",
    "\n",
    "Absolute imports are recommended, as they are usually more readable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "id": "conventional-howard",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot\n",
    "from seaborn import distplot"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "african-myrtle",
   "metadata": {},
   "source": [
    "However, explicit relative imports are an acceptable alternative to absolute imports, especially when dealing with complex package layouts where using absolute imports would be unnecessarily verbose:\n",
    "\n",
    "from . import sibling\n",
    "\n",
    "from .sibling import example"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "diagnostic-blackjack",
   "metadata": {},
   "source": [
    "When importing a class from a class-containing module, it's usually okay to spell this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "id": "color-confusion",
   "metadata": {},
   "outputs": [
    {
     "ename": "ModuleNotFoundError",
     "evalue": "No module named 'myclass'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-208-e1ae9431b34e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Will not run\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0mmyclass\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mMyClass\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mfoo\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbar\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0myourclass\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mYourClass\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'myclass'"
     ]
    }
   ],
   "source": [
    "# Will not run\n",
    "from myclass import MyClass\n",
    "from foo.bar.yourclass import YourClass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "floral-revolution",
   "metadata": {},
   "source": [
    "If this spelling causes local name clashes, then spell them explicitly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "contained-macro",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Will not run\n",
    "import myclass\n",
    "import foo.bar.yourclass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "refined-strength",
   "metadata": {},
   "source": [
    "and use \"myclass.MyClass\" and \"foo.bar.yourclass.YourClass\"."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "rapid-alexandria",
   "metadata": {},
   "source": [
    "**Whitespace in Expressions and Statements**\n",
    "\n",
    "Immediately inside parentheses, brackets or braces.\n",
    "Between a trailing comma and a following close parenthesis\n",
    "Immediately before a comma, semicolon, or colon:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "enabling-locking",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Wrong:\n",
    "print( ham[ 1 ], { eggs: 2 } )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "short-interaction",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correct:\n",
    "spam(ham[1], {eggs: 2})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "sealed-tolerance",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Wrong:\n",
    "if x == 4 : print x , y ; x , y = y , x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "imperial-delivery",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correct:\n",
    "if x == 4:\n",
    "    print(x, y)\n",
    "    x, y = y, x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "recreational-gather",
   "metadata": {},
   "source": [
    "mmediately before the open parenthesis that starts the argument list of a function call:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "binding-multimedia",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Wrong:\n",
    "spam (1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "tired-insert",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correct:\n",
    "spam(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "spoken-contributor",
   "metadata": {},
   "source": [
    "Immediately before the open parenthesis that starts an indexing or slicing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "enormous-modern",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Wrong:\n",
    "dct ['key'] = lst [index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "portuguese-baghdad",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correct:\n",
    "dct['key'] = lst[index]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "genetic-tyler",
   "metadata": {},
   "source": [
    "More than one space around an assignment (or other) operator to align it with another:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "technological-knitting",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Wrong:\n",
    "x             = 1\n",
    "y             = 2\n",
    "long_variable = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "integrated-romantic",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correct:\n",
    "x = 1\n",
    "y = 2\n",
    "long_variable = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "waiting-model",
   "metadata": {},
   "source": [
    "**Other Recommendations**\n",
    "\n",
    "Avoid trailing whitespace anywhere. Because it's usually invisible, it can be confusing: e.g. a backslash followed by a space and a newline does not count as a line continuation marker. Some editors don't preserve it and many projects (like CPython itself) have pre-commit hooks that reject it.\n",
    "\n",
    "Always surround these binary operators with a single space on either side: assignment (=), augmented assignment (+=, -= etc.), comparisons (==, <, >, !=, <>, <=, >=, in, not in, is, is not), Booleans (and, or, not).\n",
    "\n",
    "If operators with different priorities are used, consider adding whitespace around the operators with the lowest priority(ies). Use your own judgment; however, never use more than one space, and always have the same amount of whitespace on both sides of a binary operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "reflected-joshua",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Wrong:\n",
    "i=i+1\n",
    "submitted +=1\n",
    "x = x * 2 - 1\n",
    "hypot2 = x * x + y * y\n",
    "c = (a + b) * (a - b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "personalized-wagner",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correct:\n",
    "i = i + 1\n",
    "submitted += 1\n",
    "x = x*2 - 1\n",
    "hypot2 = x*x + y*y\n",
    "c = (a+b) * (a-b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "forty-reasoning",
   "metadata": {},
   "source": [
    "**Comments**\n",
    "\n",
    "\n",
    "Comments that contradict the code are worse than no comments. Always make a priority of keeping the comments up-to-date when the code changes!\n",
    "\n",
    "Comments should be complete sentences. The first word should be capitalized, unless it is an identifier that begins with a lower case letter (never alter the case of identifiers!).\n",
    "\n",
    "Block comments generally consist of one or more paragraphs built out of complete sentences, with each sentence ending in a period.\n",
    "\n",
    "Use inline comments sparingly."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "choice-mailman",
   "metadata": {},
   "source": [
    "**Documentation Strings**\n",
    "\n",
    "Write docstrings for all public modules, functions, classes, and methods. Docstrings are not necessary for non-public methods, but you should have a comment that describes what the method does. This comment should appear after the def line.\n",
    "\n",
    "The \"\"\" that ends a multiline docstring should be on a line by itself, For one liner docstrings, please keep the closing \"\"\" on the same line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "italic-liberal",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Return a foobang\n",
    "\n",
    "Optional plotz says to frobnicate the bizbaz first.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dramatic-russian",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Return an ex-parrot.\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "indian-creator",
   "metadata": {},
   "source": [
    "**Naming Conventions**\n",
    "\n",
    "**Overriding Principle**\n",
    "Names that are visible to the user as public parts of the API should follow conventions that reflect usage rather than implementation.\n",
    "\n",
    "**Descriptive: Naming Styles**\n",
    "There are a lot of different naming styles. It helps to be able to recognize what naming style is being used, independently from what they are used for.\n",
    "\n",
    "The following naming styles are commonly distinguished:\n",
    "\n",
    "b (single lowercase letter)\n",
    "\n",
    "B (single uppercase letter)\n",
    "\n",
    "lowercase\n",
    "\n",
    "lower_case_with_underscores\n",
    "\n",
    "UPPERCASE\n",
    "\n",
    "UPPER_CASE_WITH_UNDERSCORES\n",
    "\n",
    "CapitalizedWords (or CapWords, or CamelCase -- so named because of the bumpy look of its letters [4]). This is also sometimes known as StudlyCaps.\n",
    "\n",
    "Note: When using acronyms in CapWords, capitalize all the letters of the acronym. Thus HTTPServerError is better than HttpServerError.\n",
    "\n",
    "mixedCase (differs from CapitalizedWords by initial lowercase character!)\n",
    "\n",
    "Capitalized_Words_With_Underscores (ugly!)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "innocent-somewhere",
   "metadata": {},
   "source": [
    "**Prescriptive: Naming Conventions**\n",
    "\n",
    "Names to Avoid\n",
    "Never use the characters 'l' (lowercase letter el), 'O' (uppercase letter oh), or 'I' (uppercase letter eye) as single character variable names.\n",
    "\n",
    "In some fonts, these characters are indistinguishable from the numerals one and zero. When tempted to use 'l', use 'L' instead."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ordered-feeling",
   "metadata": {},
   "source": [
    "**Package and Module Names**\n",
    "Modules should have short, all-lowercase names. Underscores can be used in the module name if it improves readability. Python packages should also have short, all-lowercase names, although the use of underscores is discouraged.\n",
    "\n",
    "When an extension module written in C or C++ has an accompanying Python module that provides a higher level (e.g. more object oriented) interface, the C/C++ module has a leading underscore (e.g. _socket)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sharing-bones",
   "metadata": {},
   "source": [
    "**Class Names**\n",
    "\n",
    "\n",
    "Class names should normally use the CapWords convention.\n",
    "\n",
    "The naming convention for functions may be used instead in cases where the interface is documented and used primarily as a callable.\n",
    "\n",
    "Note that there is a separate convention for builtin names: most builtin names are single words (or two words run together), with the CapWords convention used only for exception names and builtin constants."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "tracked-prize",
   "metadata": {},
   "source": [
    "**Type Variable Names**\n",
    "\n",
    "Names of type variables introduced in PEP 484 should normally use CapWords preferring short names: T, AnyStr, Num. It is recommended to add suffixes _co or _contra to the variables used to declare covariant or contravariant behavior correspondingly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "interim-latest",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import TypeVar\n",
    "\n",
    "VT_co = TypeVar('VT_co', covariant=True)\n",
    "KT_contra = TypeVar('KT_contra', contravariant=True)\n",
    "print(VT_co)\n",
    "print(KT_contra)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sufficient-melbourne",
   "metadata": {},
   "source": [
    "**Class Names**\n",
    "\n",
    "Class names should normally use the CapWords convention.\n",
    "\n",
    "The naming convention for functions may be used instead in cases where the interface is documented and used primarily as a callable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "talented-performer",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyClass:\n",
    "    def MyRules():\n",
    "        print('UglyCodeStyles')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "restricted-algeria",
   "metadata": {},
   "source": [
    "**Exception Names**\n",
    "\n",
    "Because exceptions should be classes, the class naming convention applies here. However, you should use the suffix \"Error\" on your exception names (if the exception actually is an error).\n",
    "\n",
    "Remember EmailFormatError from HW1!!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "limited-spine",
   "metadata": {},
   "outputs": [],
   "source": [
    "class EmailFormatError(Exception):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "future-russell",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}