intro-to-python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "_uuid": "625c587f57522c988f35e92b515b8d8ef1f323d6"
   },
   "source": [
    "# Intro to Programming in Python\n",
    "## This notebook is an interactive tool to share/run code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " > \"Programming languages allow us to formalize instructions and express logical rules, business rules, mathematics, processes, and automation instructions in one single notation.\" - Ryan Orsinger"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Getting Started\n",
    "0. Ensure you're logged into your Google Account\n",
    "1. Navigatge to https://colab.research.google.com/github/ryanorsinger/learn-to-code-python-workshop/blob/main/intro-to-python.ipynb\n",
    "2. Once the notebook opens, go to File and then \"Save a copy in Drive\" to make your own copy\n",
    "3. Be sure to save your work as you go!\n",
    "\n",
    "### Learning to Program and Code\n",
    "- You can make a new blank cell for Python code at any time in this document.\n",
    "- If you want more freedom to explore learning Python in a blank notebook, go here https://colab.research.google.com/#create=true and make yourself a blank, new notebook.\n",
    "- Programming is an intellectual activity of designing a solution. \"Coding\" means turning your programmatic solution into code w/ all the right syntax and parts of the programming language.\n",
    "- Expect to make mistakes and adopt the attitude that **the error message provides the information you need to proceed**. You will put lots of error messages into search engines to learn this craft!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 0. Orientation\n",
    "- Notebooks are made of cells\n",
    "- Each cell contains either code or text. \n",
    "- Code cells run the code, text cells render the text\n",
    "- To run a cell, click on the cell and click the Play button or do \"shift + Enter\" on your keyboard.\n",
    "- Python runs in all kinds of environments. These instructions are specific to Google Colab."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part I - Basic Buiding Blocks\n",
    "0. Orientation - How to run code in this notebook\n",
    "1. Printing values\n",
    "2. Using comments\n",
    "3. Variables, assignment, and re-assignment\n",
    "4. Data Types\n",
    "5. Mathematical operations in Python\n",
    "6. Comparison operators\n",
    "7. Logical operations in Python\n",
    "8. Conditionals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Printing values with the `print()` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Good afternoon, ya'll!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# assigning a value to a variable\n",
    "today = \"Today is a great day to learn\"\n",
    "print(today)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Use the print command\")\n",
    "print(\"To print\")\n",
    "print(\"Prints each and every line\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Notebook cells automatically print the last line of code\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Multiple lines\"\n",
    "\"do not print automatically\"\n",
    "\"only the last line\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"I'm writing Python with ya'll right now\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"That means\")\n",
    "print(\"The print command is important.\")\n",
    "print(\"When we want to print each line\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Print your name in this cell. Be sure to use quotation marks around the letters.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Print your favorite number in this cell\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Print the number 7 in this cell\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Print out 3 + 4 in this cell\n",
    "# Make Python do the math rather than adding 3 + 4 in your head\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Print out 3 * 5 in this cell, * means multiply\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Comments are how we notate our code with descriptive text\n",
    "- Python comments are created by the hashtag symbol. \n",
    "- The hashtag \"comments out\" everything to the right of the hashtag.\n",
    "- Comments exist in the code but do not execute\n",
    "- Commenting your code is an industry best practice\n",
    "- A hashtag at the beginning of a line \"comments out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is a comment. Run this cell. Do you see anything? Why or why not?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# First, run this cell.\n",
    "# Then delete the hashtag at the beginning of the last line.\n",
    "# Last, run the cell again.\n",
    "# print(\"This is a 'commented out' print command\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# In Python\n",
    "# Comments are a best-practice when it comes to communicating to your future self and to fellow developers\n",
    "print(\"Once the # at the beginning of this line is removed, this string will print.\") # additional hashtags make additional comments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Variables point to values and give them a name\n",
    "- \"Assigning a variable\" means to bind value to a variable\n",
    "- Variables allow us to name values\n",
    "- Variables hold onto values for later.\n",
    "- Variables hold their assigned value(s) until \n",
    "- Applications use the same variable to hold different values for different users "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Variables hold values that we use later in the program by name.\n",
    "# \"Assigning a variable\"\n",
    "# Single = sign is called the assignment operator\n",
    "message = \"Hello, Everybody!\"\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "favorite_quote = \"If you can't solve a problem, then there is an easier problem you can solve:  find it.\"\n",
    "print(favorite_quote)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Variables are assigned to point to values.\n",
    "favorite_food = \"lasagna\"\n",
    "print(\"My favorite food is\", favorite_food)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Variables can also be re-assigned to point to different values.\n",
    "favorite_food = \"pizza\" \n",
    "print(\"I changed my mind. My favorite food is actually\", favorite_food)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Reassign the favorite_food variable to hold your own favorite food, then print the variable.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Create and assign the variable favorite_number to hold your own favorite number.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Reassign the favorite_food variable to hold the number 7. \n",
    "# What happens and why? Does this match your expectations?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Data Types \n",
    "\n",
    "Each piece of data has two fundamental characteristics:\n",
    "- The value of the data itself.\n",
    "- Every value has a data type which explains what kind of data the value is.\n",
    "- For example, the integer 2 has the value of 2 and the data type is integer.\n",
    "- The first data-types to learn:\n",
    "    - None\n",
    "    - Boolean\n",
    "    - Integer\n",
    "    - Float\n",
    "    - String\n",
    "    - List\n",
    "    - Function\n",
    "    - Dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The \"None\" data type represents the absence of a value. This is called \"null\" in some other programming languages\n",
    "type(None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Numbers without a decimal are integers. Integers can be negative or positive.\n",
    "type(-99)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(2.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ".5 * .5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(\"Howdy!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# True and False are the only two Boolean values.\n",
    "True\n",
    "False\n",
    "\n",
    "print(True)\n",
    "print(False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. Mathematical Operations in Python\n",
    "- Computers are not intelligent. They do 2nd grade math as fast as possible.\n",
    "- Programming languages need to have the ability to perform mathematical operations.\n",
    "- Mathematical operators in Python evaluate and provide\n",
    "- Order of operations in Python follows PEMDAS:\n",
    "    - Parentheses\n",
    "    - Exponents\n",
    "    - Multiplication\n",
    "    - Division\n",
    "    - Addition\n",
    "    - Subtraction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Operators operate on values and produce values\n",
    "#### Let's look at some math operators in Python\n",
    "- `+` adds two numbers together\n",
    "- `-` subtracts the second number from the first\n",
    "- `*` multiplies both numbers and returns the product\n",
    "- `/` divides the first number by the second\n",
    "- `%` provides the remainder of dividing the first number by the second.  (called the modulo operator)\n",
    "- `**` is the exponentiation operator. 2 raised to the 3rd power is `2**3`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Add 1 plus 2 plus 3 plus 4 plus 5 plus 6 plus 7 plus 8 plus 9 plus 10\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Subtract 23 from 55\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Multiply 2.3 by 4.4. What's the data-type that this returns?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Multiply 3 by 5.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Print out the data-type of the result of multiplying 11 * 7\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Divide 1 by 2. What happens? What data type is returned?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Divide 5 by 0. What happens? Why do you think that is?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Use the % modulo operator to obtain the remainder of dividing 8 by 2\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Use the % modulo operator to obtain the remainder of dividing 7 by 2\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Use the exponent operator to raise 2 to the 3rd power\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Use the exponent operator to raise 10 to the 10th power\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Use the exponent operator to raise 100 to the 100th power\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Use the exponent operator to raise 2 to the negative 1st power\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Use the exponent operator to raise 123 to the 0th power\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Comparison Operators\n",
    "\n",
    "### Python Comparison Operators compare two values and return a True or False\n",
    "- `==` compares two values to see if they are the same value.\n",
    "- `!=` asks if the values on each side of the operator are **not** the same.]\n",
    "- `<` and `<=` are less than and less than or equal to\n",
    "- `>` and `>=` are greater than and greater than or equal to, respectively.\n",
    "\n",
    "### Let's look at some concrete examples of using comparison operators and values that return a True or a False.\n",
    "\n",
    "- `2 < 3` returns `True` because it's a true statement that two is less than three\n",
    "- `2 <= 2` returns `True` because two is less than or equal to two\n",
    "- `2 < 2` returns `False` because two is not less than two\n",
    "- `4 <= 2` returns `False` because four is not less than or equal to two\n",
    "- `10 < 5` returns `False` because 10 is not less than 5\n",
    "- `10 > 5` returns `True` because ten is greater than 5\n",
    "- `2 == 2` returns `True` because the number two is equal to the number two\n",
    "- `2 == 3` returns `False` because two is not three\n",
    "- `3 != 2` returns `True` because three is not equal to two.\n",
    "- `4 in [1, 2, 3, 4]` returns `True` because 4 exists in the list `[1, 2, 3, 4]`\n",
    "- `\"b\" in \"banana\"` returns `True` because the string \"b\" exists inside the string `\"banana\"`\n",
    "\n",
    "If we have `x = 3` followed by `result = x > 0` on the next line, the result variable will hold `True` because 3 is greater than 0. \n",
    "\n",
    "### Comparison Operators ask the following questions\n",
    "- Are these two things equal?\n",
    "- Are these two things not equal?\n",
    "- Is A greather than B?\n",
    "- Is A greater than or equal to B?\n",
    "- Is A less than B?\n",
    "- Is A less than or equal to B?\n",
    "- Does A exist in a list or collection of values named B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Comparison operators give us back a True or False\n",
    "\n",
    "print(5 == 5)\n",
    "\n",
    "print(-4 + 4 == 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# False because they're not the same data type\n",
    "5 == \"5\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello\" == \"Goodbye\")\n",
    "print(\"Hello\" != \"Goodbye\") # != means \"not equal to\" \n",
    "# = assignment# False because they're not the same data type\n",
    "5 == \"5\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: assign the variable favorite_number to hold your favorite number\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "c4830a133cdd79071a8c68ad633ff996b88856ed"
   },
   "outputs": [],
   "source": [
    "# Exercise: Write the Python code necessary to answer if your favorite number is less than 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Write the code to determine if your favorite number is greater than 0\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Write the code to determine if your favorite number is five\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Write the code to determine if your favorite number is greater than or equal to 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Write the code to determine if your favorite number is greater than or equal to -100\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Before running this code, consider if this will return True or False, given your favorite_number variable's value\n",
    "\n",
    "\n",
    "# favorite_number < 0 and favorite_number > 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Before running this code, consider if this will return True or False, given your favorite_number variable's value\n",
    "\n",
    "# favorite_number < 10 or favorite_number > 20"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. Logical Operators\n",
    "\n",
    "### Evaluating what's True in Python\n",
    "- Most common logical operations are:\n",
    "    - And\n",
    "    - Or\n",
    "    - Not\n",
    "- For a reminder, see [Conjunction Junction from School House Rock](https://www.youtube.com/watch?v=4AyjKgz9tKg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "c4830a133cdd79071a8c68ad633ff996b88856ed"
   },
   "outputs": [],
   "source": [
    "not True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "c4830a133cdd79071a8c68ad633ff996b88856ed"
   },
   "outputs": [],
   "source": [
    "not False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Truth table for AND\n",
    "print(\"Truth Table for AND logic\")\n",
    "print(\"True and True is:\", True and True)\n",
    "print(\"True and False is:\", True and False)\n",
    "print(\"False and True is:\", False and True)\n",
    "print(\"False and False is:\", False and False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Truth table for OR\n",
    "print(\"Truth Table for OR logic\")\n",
    "print(\"True or True is:\", True or True)\n",
    "print(\"True or False is:\", True or False)\n",
    "print(\"False or True is:\", False or True)\n",
    "print(\"False or False is:\", False or False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8. Conditional Logic with Conditionals\n",
    "- Using `if`\n",
    "- Using `if, else`\n",
    "- Using `if, elseif, else`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The \"if\" statement is how we write \"If this then that\" \n",
    "- If the code evalutates to `True` then Python runs the code that's indented after the \"if\" line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "c4830a133cdd79071a8c68ad633ff996b88856ed"
   },
   "outputs": [],
   "source": [
    "# the \"if\" evaluates the code to the right to see if it returns True or False.\n",
    "# If the code returns `True`, then we run the code that's indented below the if.\n",
    "\n",
    "right_here_now = True\n",
    "\n",
    "if right_here_now:\n",
    "    print(\"So glad you made it today!\")\n",
    "    print(\"Wherever you go, there you are.\")\n",
    "else:\n",
    "    print(\"You are not right here now.\")\n",
    "    \n",
    "print(\"Unindented means the if/else is over, and we're back to our regularly scheduled programming.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "c4830a133cdd79071a8c68ad633ff996b88856ed"
   },
   "outputs": [],
   "source": [
    "# Before running this cell, think about and predict the outcome.\n",
    "# the \"if\" evaluates the code to the right to see if it returns True or False.\n",
    "# If true, then we run the code that's indented below the if.\n",
    "\n",
    "on_the_moon = False\n",
    "\n",
    "if on_the_moon:\n",
    "    print(\"You are currently on a lunar base.\")\n",
    "else:\n",
    "    print(\"You are not on the moon!\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "c4830a133cdd79071a8c68ad633ff996b88856ed"
   },
   "outputs": [],
   "source": [
    "# Before running this cell, think about and predict the outcome.\n",
    "\n",
    "if right_here_now and learning_python:\n",
    "    print(\"We are right here now and learning python.\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "c4830a133cdd79071a8c68ad633ff996b88856ed"
   },
   "outputs": [],
   "source": [
    "# Before running this cell, think about and predict the outcome.\n",
    "if right_here_now and learning_python and on_the_moon:\n",
    "    print(\"You must be magic since you're on the moon and here and learning Python all at the same time.\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "c4830a133cdd79071a8c68ad633ff996b88856ed"
   },
   "outputs": [],
   "source": [
    "# Before running this cell, think about and predict the outcome.\n",
    "if right_here_now or on_the_moon:\n",
    "    print(\"How many True values does it take with an OR for the entirety to be True?\")\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "c4830a133cdd79071a8c68ad633ff996b88856ed"
   },
   "outputs": [],
   "source": [
    "   \n",
    "# Before running this cell, think about and predict the outcome.\n",
    "# Carefully consider the parentheses...\n",
    "if learning_python and (right_here_now or on_the_moon):\n",
    "    print(\"In addition to learning python, you are either right here now or on the moon\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Create a variable called is_raining and assign it True or False depending on if it's raining right now\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Create a variable named will_rain_later and assign a value of True or False if it may rain later today\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Create an \"if\" condition that checks if it's raining now or later. \n",
    "# If it is going to rain now or later, then print out \"I'll bring an umbrella\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part II -  Lists and Loops\n",
    "- With programming and analysis, we work with lots of lists of numbers.\n",
    "- The primary data type in Python for holding lists of numbers is called a list. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists are ordered lists of values.\n",
    "- Created with square brackets\n",
    "- Lists can hold any value(s)\n",
    "- Lists can hold lists. \n",
    "- Think of a list as a column of values in a spreadsheet (1 dimensional list)\n",
    "- Think of a list of lists as an the entire spreadsheet  (2 dimensional list)\n",
    "- We can have lists of lists of lists, and that's like having a workbook of spreadsheets (3 dimensions)\n",
    "- There are other types of sequences and collections in Python, but lists are a solid start!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lists are created with square brackets. Each item on the list is separated by a comma. Lists can hold any data type\n",
    "beatles = [\"John\", \"Paul\", \"George\"]\n",
    "print(beatles)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lists have built-in functions\n",
    "beatles.append(\"Ringo\") # Don't forget Ringo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "beatles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# .append and .reverse are some of the built-in list functions\n",
    "beatles.reverse()\n",
    "print(beatles)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "beatles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lists are zero indexed\n",
    "beatles[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The index 1 actually means the 2nd element in the list\n",
    "# beatles[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can also access elements from the end\n",
    "# beatles[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Looping to access elements of a list:\n",
    "for beatle in beatles:\n",
    "    print(beatle, \"is one of the Beatles.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating a new list by transforming an existing list\n",
    "numbers = [1, 2, 3, 4, 5]\n",
    "\n",
    "# our output will start as an empty list\n",
    "numbers_plus_one = []\n",
    "\n",
    "for number in numbers:\n",
    "    n = number + 1\n",
    "    numbers_plus_one.append(n)\n",
    "\n",
    "numbers_plus_one"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We also use conditional logic inside of loops to filter lists. Consider the following example:\n",
    "# This code will only print the even numbers\n",
    "for number in numbers:\n",
    "    if number % 2 == 0:  \n",
    "        print(number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We also use conditional logic inside of loops to filter lists. Consider the following example:\n",
    "# This code will only print the odd numbers\n",
    "for number in numbers:\n",
    "    if number % 2 != 0:  \n",
    "        print(number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Loop Exercise\n",
    "# Now it's your turn! Write a loop with a conditional that will only output the numbers 5 and greater\n",
    "numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_uuid": "2fa39d1e0b03a084c2a3b409a3f71194d2d40372"
   },
   "source": [
    "## Functions \n",
    "- Functions are reuseable blocks of code, sequences of steps that solve a problem\n",
    "- There are 2 kinds of functions in Python: built-in and user defined functions.\n",
    "\n",
    "Some built in functions:\n",
    "- type, print, len, sum, abs, range, list, min, max, round, etc...\n",
    "- For a complete list of build in functions, see https://docs.python.org/3/library/functions.html\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sum is a built in function\n",
    "numbers = [2, 3, 5, 7]\n",
    "sum(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# len is a built-in function short for length\n",
    "len(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# calculate the average of a list of numbers\n",
    "sum(numbers) / len(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The len function also works on strings\n",
    "programming_language = \"Python\"\n",
    "print(\"The number of letters in Python is\", len(programming_language))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Let's Create Some Example Functions\n",
    "\n",
    "Imagine the exercise asks us to write a function called is_five that takes in a variable and returns True/False if that variable is the number five.\n",
    "The function would look like this:\n",
    "\n",
    "```python\n",
    "def is_five(x):\n",
    "    result = x == 5\n",
    "    return result\n",
    "```\n",
    "\n",
    "Or we could write this a little more succinctly (since returning the result is the same as returning the expression assigned to the result variable)\n",
    "```python\n",
    "def is_five(x):\n",
    "    return x == 5\n",
    "```\n",
    "\n",
    "The result of this function is entirely dependent on the input values we send into the function.\n",
    "For example:\n",
    "- `is_five(10)` will return `False`\n",
    "- `is_five(-5)` returns `False` because -5 is not 5.\n",
    "- `is_five(\"hello\"`) returns `False` because the string \"hello\" certainly isn't the number 5.\n",
    "- `is_five(5)` returns `True` because 5 == 5 evaluates to True.\n",
    "\n",
    "Notice how this function is returning the result of a comparison operation and that the comparison operator will give us a True or a False, depending on the value contained in the input variable sent into the function.\n",
    "\n",
    "If the exercise was to make a function named is_more_than_three, we could define the function in the following way:\n",
    "```python\n",
    "def is_more_than_three(x):\n",
    "    return x > 3\n",
    "```\n",
    "\n",
    "Notice that we're returning the result of x > 3, which can change with different inputs.\n",
    "For example:\n",
    "- `is_more_than_three(10)` returns `True`\n",
    "- `is_more_than_three(30)` returns `True`\n",
    "- `is_more_than_three(3)` returns `False` (because 3 is not greater than 3)\n",
    "- `is_more_than_three(3.025`) returns `True` because 3.023 > 3 returns True.\n",
    "- `is_more_than_three(-23)` returns `False` b/c  negative 23 is less than 3.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# how to define our own functions\n",
    "# def function_name(variable_name_for_the_input):\n",
    "#      output = guts of the function\n",
    "#      return output\n",
    "def is_even(number):\n",
    "    remainder = number % 2 # the % operator returns the remainder of integer division of the number on the left by the number on the right\n",
    "    if remainder == 0: # even numbers have no remainder\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "\n",
    "# calling a function means to run it\n",
    "print(is_even(2))\n",
    "print(is_even(4))\n",
    "print(is_even(2.3))\n",
    "print(is_even(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Write a function named is_odd that takes in a number and returns True or False if that number is odd.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "c410084e558eb0215cd63e626d1116329aef9329"
   },
   "outputs": [],
   "source": [
    "# lots of built in functions work on sequences\n",
    "names = [\"John\", \"Paul\", \"George\", \"Ringo\"]\n",
    "\n",
    "print(\"The number of items on the list is\", len(names))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "c410084e558eb0215cd63e626d1116329aef9329"
   },
   "outputs": [],
   "source": [
    "numbers = [2, 3, 5, 7]\n",
    "print(\"The highest number on the list is\", max(numbers))\n",
    "print(\"The smallest number on the list is\", min(numbers))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "975e69701f4384666bd841fcacc0b75c8caf0fee"
   },
   "outputs": [],
   "source": [
    "# def keyword to define, name_of_function, parentheses for parameters\n",
    "def square(number):\n",
    "    return number * number # return is the output we hand back to the code that called the function (calling == execute == run)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "square(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "square(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "6f3e14214a6d601f28e3a794cab504c67c74c0d8"
   },
   "outputs": [],
   "source": [
    "# How to average a list of numbers.\n",
    "numbers = [2, 3, 5, 7]\n",
    "total = sum(numbers)\n",
    "average = total / len(numbers)\n",
    "average"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def average(numbers):\n",
    "    total = sum(numbers)\n",
    "    average = total / len(numbers)\n",
    "    return average"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(average([1, 2, 3]))\n",
    "print(average([1, 2]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Use the examples above to write a function called is_greater_than_1 that takes in an input and returns True/False if that number is greater than 1\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: Use the examples above to write a function called is_less_than_100 that takes in an input and returns True/False if that number is less than 100\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Homework \n",
    "\n",
    "## To get better at Python super fast, work through [101 Exercises](https://colab.research.google.com/github/ryanorsinger/101-exercises/blob/main/101-exercises.ipynb)"
   ]
  },
  {
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}