chapters/Chapter 1 - Intro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 1 - Basic Python Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Everything to the **_left_** of the equal sign is a **_variable_** name, while everything to the right of the equal sign is a value that gets assigned to the variable name. \n",
    "This comes in handy when you want to reference a value later in your code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number = 12345\n",
    "float_number = 12.345\n",
    "some_text = 'This is text (a string)!'\n",
    "a_boolean = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Go ahead and run the next cell to see what happens."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(number)\n",
    "print(float_number)\n",
    "print(some_text)\n",
    "print(a_boolean)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how the _names_ don't show up, but the values the names represent do.\n",
    "Also, printing is cool!\n",
    "\n",
    "Just like SQL or Excel, python has _types_.\n",
    "We've already covered a few of the basic and most common types.\n",
    "\n",
    "* Integer - `int()`\n",
    "* Float - `float()`\n",
    "* String - `str()`\n",
    "* Bool - `bool()`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### YOUR TURN\n",
    "\n",
    "Go ahead and create 4 new variables: int, float, str, and bool\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Print them out just like we did above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### You can also check the **type** of a variable with the `type()` method. Check the types of the variables you created.\n",
    "- find the type `type(my_variable)`\n",
    "- print the type `print(type(my_variable))`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Integer / Float\n",
    "Wanna do some math? \n",
    "These characters should be your go-to.\n",
    "They can do everything you think numbers should be able to do.\n",
    "\n",
    "Take it away `int`s!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(1 + 1)\n",
    "print(10 - 5)\n",
    "print(2 * 3)\n",
    "print(6 / 2)\n",
    "print(5 / 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now the `float`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(1.0 + 1.0)\n",
    "print(10.3 - 5.75)\n",
    "print(0.12345 * 0.6789)\n",
    "print(2_000_000.123 / 150.23)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since we know how to use variables..\n",
    "Let's create a few variables to use in a couple equations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "left = 3\n",
    "right = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "left + right"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "left - right"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "left * right"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "left / right"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Order of Operations..\n",
    "\n",
    "You can use parenthesis to help orchestrate your math flow.\n",
    "Remember **PEMDAS**??\n",
    "* `P`: Parentheses first\n",
    "* `E`: Exponents (ie Powers and Square Roots, etc.)\n",
    "* `MD`: Multiplication and Division (left-to-right)\n",
    "* `AS`: Addition and Subtraction (left-to-right)\n",
    "\n",
    "These rules still apply."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "20 * 2 - (1/2) * 9.8 * 2**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note: \\*\\* is exponent** (`2**2` means 2 to the second power)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's use variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "foo = 1000\n",
    "bar = 1001\n",
    "baz = -1\n",
    "foo + bar + baz"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### YOUR TURN\n",
    "\n",
    "Do some math! \n",
    "- Create two new variables and add them together.\n",
    "- Create yet another variable..\n",
    "- And add it to the other two!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "## String\n",
    "\n",
    "_Text_.\n",
    "Nothing too special here!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('I am text.. With single quotes!')\n",
    "print(\"I am text.. With DOUBLE quotes!\")\n",
    "print(\"I am text..\" + ' Using both!!!!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With python, you can do some pretty cool things with text.\n",
    "Right out of the box!\n",
    "What if we wanted to dynamically create a greeting, for example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "greeting_name = 'FooBar'\n",
    "greeting = 'Hello, my name is.. {name}'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice the `name` parameter there?\n",
    "We can substitute that with a variable!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(greeting.format(name=greeting_name))\n",
    "\n",
    "a_different_name = 'NotFooBar'\n",
    "print(greeting.format(name=a_different_name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### YOUR TURN\n",
    "\n",
    "\n",
    "First declare a name variable..\n",
    "Then print it using the greeting from before!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "### Thoughts on _Methods_\n",
    "\n",
    "Remember the `SUM`, `MIN`, or `AVG` functions in SQL?\n",
    "You would use them like this: \n",
    "```postgresql\n",
    "SELECT SUM(column) as sum_of_column \n",
    "FROM table\n",
    "```\n",
    "\n",
    "In this scenario, `SUM` is a _function_. \n",
    "Some function attributes might be:\n",
    "* Can take an argument, or arguments\n",
    "* Available to you with no strings attached.. \n",
    "Use right out of the box\n",
    "* Performs an _action_.\n",
    "It goes out and tries to _do_ something. \n",
    "**_Verb!!_**\n",
    "\n",
    "_Methods_ are pretty much the same thing..\n",
    "Except they **_are attached to another object_**. \n",
    "They are actions specific to an object."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As an example.. \n",
    "```\n",
    "People can run.\n",
    "Trees cannot run.\n",
    "\n",
    "People can drive.\n",
    "Trees cannot drive.\n",
    "\n",
    "People can consume water.\n",
    "Trees can consume water.\n",
    "```\n",
    "\n",
    "In this scenario, people and trees are objects.\n",
    "Run, drive, and consume are all actions. \n",
    "\n",
    "People would have the following methods: \n",
    "* run\n",
    "* drive\n",
    "* consume \n",
    "\n",
    "Tree would only have the following method:\n",
    "* consume\n",
    "\n",
    "If this were code, it may look something like this:\n",
    "```python\n",
    "people.run()\n",
    "people.drive()\n",
    "people.consume('water')\n",
    "\n",
    "trees.consume('water')\n",
    "```\n",
    "\n",
    "Most objects in python have _methods_ associated with them. \n",
    "They have the ability to do things!\n",
    "Just like people and trees can do things.\n",
    "The syntax for that looks like: `object.method()`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "## A Few of String Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sentence = 'this is a sentence! '"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "String's have quite a few methods available for use (and [many more](https://docs.python.org/2.5/lib/string-methods.html)).\n",
    "* `format` - We did this one up above! \n",
    "Allows you to pass variables into some text.\n",
    "Check [this](https://docs.python.org/3/library/string.html#custom-string-formatting) out for some other ways to use it. \n",
    "* `capitalize` - Capitalize the first letter\n",
    "* `upper` - Uppercase all the letters in the string\n",
    "* `replace` - Replace part of the string with something else\n",
    "* `strip` - Remove all leading and trailing whitespaces"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(sentence.capitalize())\n",
    "print(sentence.lower())\n",
    "print(sentence.replace('sentence', 'not a sentence'))\n",
    "print(sentence.strip())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### YOUR TURN\n",
    "\n",
    "* Assign a string to a new variable.\n",
    "* Run `capitalize` on the string. \n",
    "What happens?\n",
    "* Lowercase the variable\n",
    "* Replace a word.\n",
    "Replace another word!\n",
    "* _Titlecase_ the string. \n",
    "This may require you to look up the method you need to use!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "## Boolean\n",
    "\n",
    "True or False?? \n",
    "Yes or No? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "this = True\n",
    "that = False\n",
    "\n",
    "print(this, that)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can _compare_ values to check whether or not they are True or False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(this == True)\n",
    "print(that == True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just like SQL, we can reference _logical operators_ in our code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(this or that)\n",
    "print(this and that)\n",
    "print(this and not that)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ok, these have all been absolute / static. \n",
    "What else is can evaluate to True or False?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('foo' == 'foo')\n",
    "print('foo' == 'bar')\n",
    "print('foo' != 'foo')\n",
    "\n",
    "print(1 < 2)\n",
    "print(35 == 35.0)\n",
    "print(bool(''))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And of course.. We can combine them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(True if '' and 1 else False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### YOUR TURN\n",
    "\n",
    "* Create a variable with a boolean.\n",
    "* Print it\n",
    "* Check if it is equal to True\n",
    "* Check if it is equal to False\n",
    "* How else can you test this?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}