section1-01-basics_but_important_stuff.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# Excel to Python\n",
    "## Section 1 - The Basics\n",
    "\n",
    "### Comments, Variables, Built-In Functions, (Data) Types, Strings, Methods, and Indexing & Slicing\n",
    "##### In the interest of time, I don't cover everything. That said, what I do cover I think are important for an Excel User to be successful in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# <- comments (pound sign) don't affect code\n",
    "# you will see them a lot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nthree quotes = multi-line comments\\nI also use these a lot to show the expected output of a command\\n'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "three quotes = multi-line comments\n",
    "I also use these a lot to show the expected output of a command\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "For example, it's probably worth spending time on following if you don't already know them:\n",
    "\n",
    "#### understand syntax (i.e. whitespace is important, indenting after colons)\n",
    "https://www.w3schools.com/python/python_syntax.asp\n",
    "#### variables - (must start with letter or underscore, no spaces, no special characters, case sensitive)\n",
    "https://www.w3schools.com/python/python_variables_names.asp\n",
    "#### true/false/booleans -  (important for if statements, pandas)\n",
    "https://www.w3schools.com/python/python_booleans.asp\n",
    "#### If Statements (Use them Alot)\n",
    "https://www.w3schools.com/python/python_booleans.asp#\n",
    "#### string \"formatting\"  (use all time for generating filenames/filepaths/urls)\n",
    "https://www.w3schools.com/python/python_strings_format.asp\n",
    "#### casting  (converting strings to integer/float, vice versa )\n",
    "https://www.w3schools.com/python/python_casting.asp\n",
    "#### exception handling -  (if something unexpected happens, allows program to continue\n",
    "https://www.w3schools.com/python/python_try_except.asp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variables\n",
    "### Excel: A1 = \"Hello Pycon\"\n",
    "# Text/Strings require Quotes (single or double)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "260.74\n",
    "\n",
    "# text needs quotes around\n",
    "\"MSFT\"\n",
    "# OR\n",
    "'MSFT'\n",
    "\n",
    "# Variables\n",
    "A1 = 260.74\n",
    "A2 = 143015\n",
    "A3 = \"MSFT\"\n",
    "A4 = True\n",
    "\n",
    "# Better Variable\n",
    "stock_price = 260.74\n",
    "revenues = 143015\n",
    "ticker = \"MSFT\"\n",
    "public_company = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note:  When it comes to writing Python code, their is a \"guide\" outlined in PEP 8 is considered best practice.\n",
    "\n",
    "https://www.python.org/dev/peps/pep-0008/ <- Original PEP 8 Style Guide\n",
    "\n",
    "https://realpython.com/python-pep8/ <- Good Explanation\n",
    "\n",
    "https://inventwithpython.com/beyond/chapter6.html <- Writing Pythonic Code\n",
    "\n",
    "---------------------------------------\n",
    "variable names - use all lowercase, underscores in place of spaces, use names that describe data being stored\n",
    "\n",
    "Good"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "hello_pycon = \"Hello Pycon\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "awesome_message = \"Hello Pycon\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "message = \"Hello Pycon\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bad Variable names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "cannot assign to literal (<ipython-input-8-57ade27194f1>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001B[1;36m  File \u001B[1;32m\"<ipython-input-8-57ade27194f1>\"\u001B[1;36m, line \u001B[1;32m2\u001B[0m\n\u001B[1;33m    0000 = \"Hello Pycon\"\u001B[0m\n\u001B[1;37m    ^\u001B[0m\n\u001B[1;31mSyntaxError\u001B[0m\u001B[1;31m:\u001B[0m cannot assign to literal\n"
     ]
    }
   ],
   "source": [
    "# can't start with number\n",
    "0000 = \"Hello Pycon\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-9-3ca1aa04510e>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001B[1;36m  File \u001B[1;32m\"<ipython-input-9-3ca1aa04510e>\"\u001B[1;36m, line \u001B[1;32m2\u001B[0m\n\u001B[1;33m    hello python = \"Hello Pycon\"\u001B[0m\n\u001B[1;37m          ^\u001B[0m\n\u001B[1;31mSyntaxError\u001B[0m\u001B[1;31m:\u001B[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "# can't have spaces in variables\n",
    "hello python = \"Hello Pycon\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "cannot assign to operator (<ipython-input-10-20bb482d8f53>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001B[1;36m  File \u001B[1;32m\"<ipython-input-10-20bb482d8f53>\"\u001B[1;36m, line \u001B[1;32m2\u001B[0m\n\u001B[1;33m    hello-python = \"Hello Pycon\"\u001B[0m\n\u001B[1;37m    ^\u001B[0m\n\u001B[1;31mSyntaxError\u001B[0m\u001B[1;31m:\u001B[0m cannot assign to operator\n"
     ]
    }
   ],
   "source": [
    "# can't use dashes or other special characters (can use underscores)\n",
    "hello-python = \"Hello Pycon\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### !! IMPORTANT TIP  !!\n",
    "\n",
    "Don't use keywords or built-in functions (below) as variables\n",
    "\n",
    "\n",
    "\n",
    "<img src=\"img/basics/reserved_words.png\" align=\"left\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Built-in functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Excel has Built-In Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/basics/excel-built-in.png\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Full List - https://support.microsoft.com/en-us/office/excel-functions-alphabetical-b3944572-255d-4efb-bb96-c6d90033e188"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python Built-In Functions\n",
    "<img src=\"img/basics/built-in_functions.png\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# In fact, many Python functions act same way Excel built-in functions act:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example, to find length of a cell in Excel:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/basics/built-in_len.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    A1 = \"Hello Pycon\"\n",
    "    B2 = LEN(A1)\n",
    "    Output: 11\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "A1 = \"Hello Pycon\"\n",
    "B2 = len(A1)\n",
    "# Outputs: 11"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### !! VERY IMPORTANT TIP  !!\n",
    "\n",
    "You can use CTRL + Q command when your cursor is in between the parentheses, and your IDE will tell you what the potential inputs are for any function:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/basics/pycharm-function-pop.png\" align=\"left\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Pycon\n"
     ]
    }
   ],
   "source": [
    "# can display the values of variables using the print() function\n",
    "print(hello_pycon)\n",
    "# Hello Pycon"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current Price: 260.74\n",
      "Current Price:\t 260.74\n",
      "Current Price:\n",
      " 260.74\n",
      "Hello Pycon\n"
     ]
    }
   ],
   "source": [
    "print(\"Current Price:\", stock_price)\n",
    "\n",
    "print(\"Current Price:\\t\", stock_price)\n",
    "\n",
    "# \\n adds new line\n",
    "print(\"Current Price:\\n\", stock_price)\n",
    "\n",
    "hello_pycon = \"Hello Pycon\"\n",
    "\n",
    "print(\"Hello Pycon\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function print in module builtins:\n",
      "\n",
      "print(...)\n",
      "    print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n",
      "    \n",
      "    Prints the values to a stream, or to sys.stdout by default.\n",
      "    Optional keyword arguments:\n",
      "    file:  a file-like object (stream); defaults to the current sys.stdout.\n",
      "    sep:   string inserted between values, default a space.\n",
      "    end:   string appended after the last value, default a newline.\n",
      "    flush: whether to forcibly flush the stream.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# if need help with a function, can use the help() function\n",
    "help(print)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### !! IMPORTANT CONCEPT  !!\n",
    "# 1) Types - KNOW THE (DATA) TYPE OF YOUR VARIABLES/OBJECTS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/basics/data-types.png\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### more examples: https://www.w3schools.com/python/python_datatypes.asp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# like excel, we can determine a variables type using the type() function\n",
    "type(\"Hello Pycon\")\n",
    "# str\n",
    "# this of type string (excel calls this text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(1)\n",
    "# int\n",
    "# this of type integer (excel calls this number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(299.0)\n",
    "# float\n",
    "# this of type float (excel calls this number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Using our original Example\n",
    "type(hello_pycon)\n",
    "# str = string = Text (Excel)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Since hello_pycon variable above is of type string (Excel calls it text), this means we can perform a set of actions that are specific to strings\n",
    "\n",
    "In Excel, we have the ability to use to the mouse to click on a cell to perform actions like Cut, Copy, Delete...\n",
    "Or we can click on buttons in the toolbar to perform actions such as change Font to Bold, Cell Color to Red, etc.\n",
    "\n",
    "In Python, we don't use the mouse or have buttons like Excel... So, how do you perform actions?\n",
    "    1) Built-In Functions (shown briefly above)\n",
    "    2) Built-In Methods - you use these built-in methods by using the . (dot) notation (examples below)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### !! IMPORTANT CONCEPT !!\n",
    "# 2) Methods  - how you perform actions on your Variables/Objects\n",
    "#### VERY IMPORTANT CONCEPT especially for Pandas, Requests, Pretty Much Everything)\n",
    "\n",
    "Use methods by using the . (dot) notation AND remember, different data types have different methods.\n",
    "\n",
    "For examples, variables that are string types have a bunch of built-in methods you can use that converts text to lower case (Excel has a built-in function LOWER())\n",
    "\n",
    "online example: https://www.w3schools.com/python/ref_string_lower.asp\n",
    "\n",
    "### !! IMPORTANT CONCEPT - Write Down on Stick Note !!\n",
    "\n",
    "Note:  After you hit the . key, most IDEs will show a popup of available methods\n",
    "       In Jupyter Notebooks, hit the TAB key after type the . (dot)\n",
    "       In Pycharm/VS Code, can hit TAB, CTRL + SPACE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Jupyter Menu - CTRL + TAB"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/basics/jupyter-method.png\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Pycharm Menu - After . hit TAB"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/basics/pycharm-methods.png\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "VS Code Menu - After . hit TAB"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/basics/vscode-method.png\" align=\"left\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "hello_pycon.lower()\n",
    "# Out[104]: 'hello pycon!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# you can perform methods on strings directly\n",
    "\"Hello Pycon!\".lower()\n",
    "# Out[106]: 'hello pycon!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# they also have an upper method\n",
    "hello_pycon.upper()\n",
    "# Out[105]: 'HELLO PYCON!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# you can perform methods on strings directly\n",
    "\"Hello Pycon!\".upper()\n",
    "# Out[107]: 'HELLO PYCON!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# To see all the methods you can perform on any python variable/object, use the dir() built-in function\n",
    "# documentation: https://docs.python.org/3/library/functions.html#dir\n",
    "dir(hello_pycon)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, the variable hello_pycon is a string, so that means we can perform actions specific to strings, using it's methods\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### !! IMPORTANT CONCEPT !!\n",
    "# 3) Indexing & Slicing\n",
    "#### VERY IMPORTANT CONCEPT especially for Pandas, Lists, Dictionary, a lot of thing\n",
    "\n",
    "# Indexing & Slicing\n",
    "\n",
    "Python provides access to certain elements through indexing (for single elements) and slicing for multiple values. This type of access is used in Pandas, Strings, Lists, other places.\n",
    "\n",
    "examples: https://www.w3schools.com/python/python_strings_slicing.asp\n",
    "\n",
    "better explanation for indexing/slicing strings: https://www.digitalocean.com/community/tutorials/how-to-index-and-slice-strings-in-python-3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(hello_pycon)\n",
    "# str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'H'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# access first element in string\n",
    "hello_pycon[0]\n",
    "# Out[111]: H"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# access  elements 0 to 5 in string\n",
    "hello_pycon[0:5]\n",
    "# Out[111]: Hello"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello Pyc'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hello_pycon[:-2]\n",
    "# Out[111]: 'Hello Pyco'"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}