python_basics/notebooks/Python Bootcamp - Data Constructs.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Constructs\n",
    "## Python Environments\n",
    "There are a few different ways that you can interact with python: \n",
    "\n",
    "<img src=\"python_cli.png\" height=\"300\" width=\"300\" align=\"left\">  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "CLI = command line interface\n",
    "- Type \"python\" from your command line\n",
    "- You are now in a python interpreter\n",
    "- This is great for testing out code\n",
    "- Does not persist after you close this session   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"python_ide.png\" height=\"600\" width=\"600\" align=\"left\">  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python IDE's = integrated development environment\n",
    "- Self-contained development environments\n",
    "- A stand-alone program/envirnoment\n",
    "- Save code to work on between sessions\n",
    "- Test and run code\n",
    "- Syntax/error checking\n",
    "- Learning curve for setting up and using\n",
    "- Recommended IDE's include: Spyder, PyCharm, Eclipse  \n",
    "\n",
    "Python scripts\n",
    "- You can distribute these as programs that perform a task \n",
    "- Can gather user input\n",
    "- Can be re-run\n",
    "- Standalone, run using exe or command line interface\n",
    "- Usually the final product  \n",
    "\n",
    "Jupyter Notebook\n",
    "- Document your code with text as you go along\n",
    "- Test and view output as you develop\n",
    "- Great for analysis, scientific research\n",
    "- View graphs and tables inline\n",
    "- Not great for larger datasets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables\n",
    "Think of variables as containers. You create them, you name them, and you determine what value they will store.\n",
    "\n",
    "### Naming variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "steven= 17"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "steven"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_var = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_var"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "my_var is a made up name for your variable. You can call it whatever you want."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "rando_var = 5  \n",
    "steve = 5 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rando_var"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "steve"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reserved Words\n",
    "Words used to trigger an action <b>cannot</b> be used as variable names:\n",
    "\n",
    "- and\n",
    "- as\n",
    "- break\n",
    "- del\n",
    "- true\n",
    "- false\n",
    "- int\n",
    "- str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-8-320f7056c0a1>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-8-320f7056c0a1>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    break = 'test'\u001b[0m\n\u001b[0m          ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "break = 'test'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Statements and Commands\n",
    "### Statement\n",
    "A complete instruction, like a sentence in English:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Go fish!\n"
     ]
    }
   ],
   "source": [
    "print(\"Go fish!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Command (aka Executing a Function)\n",
    "Think of a command as a verb; you are telling python to do something."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "print()  \n",
    "round()  \n",
    "sum()  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Always lowercase\n",
    "- Always followed by a parenthesis\n",
    "- Called a function, or method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Expressions\n",
    "Expressions don't have any action to them, but they contain values.\n",
    "\n",
    "\"Go fish!\"  \n",
    "27 + 12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Line Continuation\n",
    "Line Continuation Characters\n",
    "To make things pretty, or to continue a long function on the next line, use \"\\\":"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "def my_long_function():\n",
    "    print(\"My string \\\n",
    "    is really long \\\n",
    "    and has to be continued \\\n",
    "    on another line\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Documenting your code\n",
    "It's always good coding practice to make notes that help people use and understand your code. There are two ways to let the python interpreter know that you want to it to ignore something: \n",
    "\n",
    "### Docstrings\n",
    "Docstrings are used for longer comments, often at the beginning of a script, to let people know: \n",
    "- how to run your script\n",
    "- dependencies\n",
    "- versions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nDocstrings are enclosed between a series of three single quotes. \\nAnything entered here is a comment and is skipped over by the \\npython interpreter. \\n'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''\n",
    "Docstrings are enclosed between a series of three single quotes. \n",
    "Anything entered here is a comment and is skipped over by the \n",
    "python interpreter. \n",
    "'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comments\n",
    "For leaving quick notes within your code itself, start a a comment with a hash sign. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this is me designing a silly variable\n",
    "bob = \"steve\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Spacing\n",
    "You might have noticed that the pass statement is indented four spaces. In python, spaces matter! \n",
    "\n",
    "Python breaks up code blocks using spaces. Think of it like a programmatic form of an outine with roman numerals. Instead of roman numerals, we organize our python code by using spaces. \n",
    "\n",
    "Here's an example python script to show you how this works: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def say_howdy(x, y):\n",
    "    print(\"Hello {}, you're a young looking {}\".format(x, y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if x < 5:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 0\n",
    "while x < 5:\n",
    "    x += 1\n",
    "    print(x)\n",
    "    if x%2 == 0:\n",
    "        print(\"{} is even\".format(x))"
   ]
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}