Basic Python in 2 hours.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "0f2f3052",
   "metadata": {},
   "source": [
    "This is a simple Python Refresher that's good for 2 hours. Enjoy the ride!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16e03b89",
   "metadata": {},
   "source": [
    "# STEP 0 - INTRODUCTION\n",
    "\n",
    "## What is Python?\n",
    "Python is a high-level, general-purpose programming language. Its design philosophy emphasizes code readability with the use of significant indentation. Python is dynamically-typed and garbage-collected. It supports multiple programming paradigms, including structured, object-oriented and functional programming.\n",
    "![](https://media.giphy.com/media/KAq5w47R9rmTuvWOWa/giphy.gif)\n",
    "## Why Python?\n",
    "### Python is Easy to Learn and Use\n",
    "Python is incredibly [easy to learn](https://i.imgur.com/slj6rkq.png) and use for beginners and newcomers in the industry. The language is the most accessible among all the programming languages available because it has simplified syntax that is not complicated at all and gives more emphasis on natural language.\n",
    "### It’s Open Source\n",
    "Python is open-source, which means it’s free and uses a community-based model for development.\n",
    "### It’s Well-Supported\n",
    "Anything that can go wrong will go wrong, and if you’re using something that you didn’t need to pay for, getting help can be quite a challenge. Fortunately, Python has a large following and is heavily used in academic and industrial circles, which means that there are plenty of useful analytics libraries available."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7efc35b0",
   "metadata": {},
   "source": [
    "# STEP 1 - ENVIRONMENT SETUP\n",
    "\n",
    "![](https://media.giphy.com/media/OxCVIkMpdVZdV7rSLl/giphy.gif)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4ff81b6",
   "metadata": {},
   "source": [
    "## Install Locally\n",
    "There are a lot of Python installers in the internet, for our purposes we will use Anaconda.\n",
    "\n",
    "1. Go to https://www.anaconda.com/\n",
    "2. Click download\n",
    "3. Install (you will need admin access)\n",
    "\n",
    "**Anaconda** offers the easiest way to perform Python/R *data science and machine learning* on a single machine. Start working with thousands of open-source packages and libraries today."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af952064",
   "metadata": {},
   "source": [
    "## Use cloud\n",
    "Online development environment hosted on cloud platforms has been the recent trend lately. It allows us to not sure local resources and keep all development activities on a separate location. Similarly, there are a lot of cloud platforms out there but for our purposes we recommend using Google Colab.\n",
    "\n",
    "1. Open Chrome (or whatever internet browser you use)\n",
    "2. Go to https://colab.research.google.com/\n",
    "3. You might want to login into your Google account to maximize the experience"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03a825cb",
   "metadata": {},
   "source": [
    "There are some minor differences on using your local environment vs cloud platforms as development environments, but for now we can just base it on your personal development preferences. In the long run (and bigger picture) this will vary wildly depending on business requirements and your company's development process and data science workflow.\n",
    "\n",
    "**Depending on what you plan to use you can use Spyder or Jupyter (From Anaconda), or the Colab Notebook (From Google Colab)**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b6237d8",
   "metadata": {},
   "source": [
    "# STEP 2 - PROGRAMMING CONCEPTS"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37997c65",
   "metadata": {},
   "source": [
    "## 5 basic programming concepts\n",
    "The following are fundamental concepts that exists in all programming / scripting languages. Understanding of them will be important in your education of Python.\n",
    "\n",
    "- Variables \n",
    "- Data Structures\n",
    "- Control Structures\n",
    "- Syntax\n",
    "- Tools\n",
    "\n",
    "Let's dive deeper into what each of them means!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f83852c",
   "metadata": {},
   "source": [
    "### Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "936832fa",
   "metadata": {},
   "source": [
    "A Python variable is a symbolic name that is a reference or pointer to an object. Once an object is assigned to a variable, you can refer to the object by that name."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b51bae4",
   "metadata": {},
   "source": [
    "### Data Structures"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75256619",
   "metadata": {},
   "source": [
    "The basic Python data structures in Python include list, set, tuples, and dictionary. Each of the data structures is unique in its own way. Data structures are “containers” that organize and group data according to type. The data structures differ based on mutability and order."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59412799",
   "metadata": {},
   "source": [
    "### Control Structures"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6de35d0",
   "metadata": {},
   "source": [
    "A control structure (or flow of control) is a block of programming that analyses variables and chooses a direction in which to go based on given parameters. In simple sentence, a control structure is just a decision that the computer makes."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93507d77",
   "metadata": {},
   "source": [
    "### Syntax"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce849da6",
   "metadata": {},
   "source": [
    "The syntax of the Python programming language is the set of rules that defines how a Python program will be written and interpreted (by both the runtime system and by human readers)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd5b5f7d",
   "metadata": {},
   "source": [
    "### Tools\n",
    "A tool in programming is a piece of software that, when used while you code, allows you to get your program done faster!\n",
    "- IDE (Integrated Development Environment)\n",
    "- Bug Tracker\n",
    "- Build Automation\n",
    "- Code Review\n",
    "- Debugger\n",
    "- Documentation Generator\n",
    "- Revision Control / Code Repository\n",
    "- External code libraries\n",
    "- Code Tester"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "364fd76c",
   "metadata": {},
   "source": [
    "![\"Extreme Programming Workflow\"](https://www.tutorialspoint.com/extreme_programming/images/extreme_programming_in_nutshell.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f26a668",
   "metadata": {},
   "source": [
    "# STEP 3 - YOUR FIRST PROGRAM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "00abf84b",
   "metadata": {},
   "outputs": [],
   "source": [
    "print 'Hello Python world!' \n",
    "name = input(\"What is your name? \") #input is one of the many things you will learn today (can you guess what it does?)\n",
    "print(\"Hello, \",name+\"! - Python\") #here, we allow Python to say hi back"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36c23d75",
   "metadata": {},
   "source": [
    "Variables\n",
    "===\n",
    "A variable holds a value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e4a1d32e",
   "metadata": {},
   "outputs": [],
   "source": [
    "message = \"Pwede ba lumabas, Python world?\"\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b000e3d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "message = \"Bawal Lumabas!\"\n",
    "print(message)\n",
    "\n",
    "message = \"Python is my favorite language!\"\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c6984e9",
   "metadata": {},
   "source": [
    "Naming rules\n",
    "---\n",
    "- Variables can only contain letters, numbers, and underscores. Variable names can start with a letter or an underscore, but can not start with a number.\n",
    "- Spaces are not allowed in variable names, so we use underscores instead of spaces. For example, use student_name instead of \"student name\".\n",
    "- You cannot use [Python keywords](http://docs.python.org/3/reference/lexical_analysis.html#keywords) as variable names.\n",
    "- Variable names should be descriptive, without being too long. For example mc_wheels is better than just \"wheels\", and number_of_wheels_on_a_motorycle.\n",
    "- Be careful about using the lowercase letter l and the uppercase letter O in places where they could be confused with the numbers 1 and 0."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a662d398",
   "metadata": {},
   "source": [
    "NameError\n",
    "---\n",
    "There is one common error when using variables, that you will almost certainly encounter at some point. Take a look at this code, and see if you can figure out why it causes an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1f58373b",
   "metadata": {},
   "outputs": [],
   "source": [
    "message = \"Mag print ba ako?\"\n",
    "print(mesage)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b68b8bb0",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "message = \"Mag print ba ako?\"\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4d28591",
   "metadata": {},
   "source": [
    "Strings\n",
    "===\n",
    "Strings are sets of characters. Strings are easier to understand by looking at some examples."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b76010a1",
   "metadata": {},
   "source": [
    "Single and double quotes\n",
    "---\n",
    "Strings are contained by either single or double quotes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2f095398",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_string = \"This is a double-quoted string.\"\n",
    "my_string = 'This is a single-quoted string.'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23f6e9fd",
   "metadata": {},
   "source": [
    "This lets us make strings that contain quotations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d04fc756",
   "metadata": {},
   "outputs": [],
   "source": [
    "quote = \"Winter is coming. - Someone\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37d56171",
   "metadata": {},
   "source": [
    "Changing case\n",
    "---\n",
    "You can easily change the case of a string, to present it the way you want it to look."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c6fcf839",
   "metadata": {},
   "outputs": [],
   "source": [
    "first_name = 'sara'\n",
    "\n",
    "print(first_name)\n",
    "print(first_name.title())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2c5fd00b",
   "metadata": {},
   "outputs": [],
   "source": [
    " \n",
    "first_name = 'sara'\n",
    "\n",
    "print(first_name)\n",
    "print(first_name.title())\n",
    "print(first_name.upper())\n",
    "\n",
    "first_name = 'Sara'\n",
    "print(first_name.lower())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e272f997",
   "metadata": {},
   "source": [
    "A method is something that can be done to a variable. The methods 'lower', 'title', and 'upper' are all functions that have been written into the Python language, which do something to string objects. Later on, you will learn to write your own methods."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52abaff1",
   "metadata": {},
   "source": [
    "Combining strings (concatenation)\n",
    "---\n",
    "It is often very useful to be able to combine strings into a message or page element that we want to display. Again, this is easier to understand through an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bdf80e30",
   "metadata": {},
   "outputs": [],
   "source": [
    "first_name = 'kylo'\n",
    "last_name = 'ren'\n",
    "\n",
    "full_name = first_name + ' ' + last_name\n",
    "\n",
    "print(full_name.title())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3700805e",
   "metadata": {},
   "source": [
    "The plus sign combines two strings into one, which is called \"concatenation\". You can use as many plus signs as you want in composing messages. In fact, many web pages are written as giant strings which are put together through a long series of string concatenations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dc723b7c",
   "metadata": {},
   "outputs": [],
   "source": [
    " \n",
    "first_name = 'kylo'\n",
    "last_name = 'ren'\n",
    "full_name = first_name + ' ' + last_name\n",
    "\n",
    "message = full_name.title() + ' ' + \"is the commander and later the Supreme Leader of the First Order.\"\n",
    "\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b41bd330",
   "metadata": {},
   "source": [
    "Whitespace\n",
    "---\n",
    "The term \"whitespace\" refers to characters that the computer is aware of, but are invisible to readers. The most common whitespace characters are spaces, tabs, and newlines.\n",
    "\n",
    "Spaces are easy to create, because you have been using them as long as you have been using computers. Tabs and newlines are represented by special character combinations.\n",
    "\n",
    "The two-character combination \"\\t\" makes a tab appear in a string. Tabs can be used anywhere you like in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c4f71e4b",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello everyone!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c129e131",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"\\tHello everyone!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fd5fc325",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello \\teveryone!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66164630",
   "metadata": {},
   "source": [
    "The combination \"\\n\" makes a newline appear in a string. You can use newlines anywhere you like in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cc940ea8",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello everyone!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d9677454",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"\\nHello everyone!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8a83efc3",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello \\neveryone!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8468c33e",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"\\n\\n\\nHello everyone!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d9f2615",
   "metadata": {},
   "source": [
    "### Stripping whitespace\n",
    "\n",
    "Many times you will allow users to enter text into a box, and then you will read that text and use it. It is really easy for people to include extra whitespace at the beginning or end of their text. Whitespace includes spaces, tabs, and newlines.\n",
    "\n",
    "It is often a good idea to strip this whitespace from strings before you start working with them. For example, you might want to let people log in, and you probably want to treat 'eric ' as 'eric' when you are trying to see if I exist on your system.\n",
    "\n",
    "You can strip whitespace from the left side, the right side, or both sides of a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3f8f787a",
   "metadata": {},
   "outputs": [],
   "source": [
    "name = ' sara '\n",
    "\n",
    "print(name.lstrip())\n",
    "print(name.rstrip())\n",
    "print(name.strip())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40f62d6b",
   "metadata": {},
   "source": [
    "It's hard to see exactly what is happening, so maybe the following will make it a little more clear:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8820207f",
   "metadata": {},
   "outputs": [],
   "source": [
    "name = ' sara '\n",
    "\n",
    "print('-' + name.lstrip() + '-')\n",
    "print('-' + name.rstrip() + '-')\n",
    "print('-' + name.strip() + '-')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf7d772e",
   "metadata": {},
   "source": [
    "Numbers\n",
    "===\n",
    "Dealing with simple numerical data is fairly straightforward in Python, but there are a few things you should know about."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4b6f546",
   "metadata": {},
   "source": [
    "Integers\n",
    "---\n",
    "You can do all of the basic operations with integers, and everything should behave as you expect. Addition and subtraction use the standard plus and minus symbols. Multiplication uses the asterisk, and division uses a forward slash. Exponents use two asterisks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a58a9aa1",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(3+2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5072d845",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(3-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ad68482c",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(3*2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0b3c8bef",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(3/2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "be8eb1ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(3**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26a5a0a3",
   "metadata": {},
   "source": [
    "You can use parenthesis to modify the standard order of operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0f01e1ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "standard_order = 2+3*4\n",
    "print(standard_order)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "684cdd02",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_order = (2+3)*4\n",
    "print(my_order)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fcb02ee",
   "metadata": {},
   "source": [
    "Floating-Point numbers\n",
    "---\n",
    "Floating-point numbers refer to any number with a decimal point. Most of the time, you can think of floating point numbers as decimals, and they will behave as you expect them to."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2371e5af",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(0.1+0.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c137eb22",
   "metadata": {},
   "source": [
    "However, sometimes you will get an answer with an unexpectly long decimal part:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3dfbada8",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(0.1+0.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c986c946",
   "metadata": {},
   "source": [
    "There is no exact representation for 0.3 in powers of two, and we see that in the answer to 0.1+0.2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ee1b0ea0",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(3*0.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "adbedb25",
   "metadata": {},
   "source": [
    "### Division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c837b02f",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(4/2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4707ee31",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(3/2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "149607b4",
   "metadata": {},
   "source": [
    "If you are getting numerical results that you don't expect, or that don't make sense, check if the version of Python you are using is treating integers differently than you expect."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05b4c515",
   "metadata": {},
   "source": [
    "Comments\n",
    "===\n",
    "As you begin to write more complicated code, you will have to spend more time thinking about how to code solutions to the problems you want to solve. Once you come up with an idea, you will spend a fair amount of time troubleshooting your code, and revising your overall approach.\n",
    "\n",
    "Comments allow you to write in English, within your program. In Python, any line that starts with a pound (#) symbol is ignored by the Python interpreter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d1e505f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# This line is a comment.\n",
    "print(\"This line is not a comment, it is code.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46e1cbde",
   "metadata": {},
   "source": [
    "What makes a good comment?\n",
    "---\n",
    "- It is short and to the point, but a complete thought. Most comments should be written in complete sentences.\n",
    "- It explains your thinking, so that when you return to the code later you will understand how you were approaching the problem.\n",
    "- It explains your thinking, so that others who work with your code will understand your overall approach to a problem.\n",
    "- It explains particularly difficult sections of code in detail.\n",
    "\n",
    "When should you write comments?\n",
    "---\n",
    "- When you have to think about code before writing it.\n",
    "- When you are likely to forget later exactly how you were approaching a problem.\n",
    "- When there is more than one way to solve a problem.\n",
    "- When others are unlikely to anticipate your way of thinking about a problem.\n",
    "\n",
    "Writing good comments is one of the clear signs of a good programmer. If you have any real interest in taking programming seriously, start using comments now. You will see them throughout the examples in these notebooks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7f264606",
   "metadata": {},
   "outputs": [],
   "source": [
    "# I learned how to strip whitespace from strings.\n",
    "name = '\\t\\teric'\n",
    "print(\"I can strip tabs from my name: \" + name.strip())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31ed4f93",
   "metadata": {},
   "source": [
    "Lists & Tuples\n",
    "==="
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0d507e4",
   "metadata": {},
   "source": [
    "Example\n",
    "---\n",
    "A list is a collection of items, that is stored in a variable. The items should be related in some way, but there are no restrictions on what can be stored in a list. Here is a simple example of a list, and how we can quickly access each item in the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0188e059",
   "metadata": {},
   "outputs": [],
   "source": [
    "students = ['eugene', 'jeremiah', 'toguro']\n",
    "\n",
    "for student in students:\n",
    "    print(\"Hello, \" + student.title() + \"!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c485903a",
   "metadata": {},
   "source": [
    "Naming and defining a list\n",
    "---\n",
    "Since lists are collection of objects, it is good practice to give them a plural name. If each item in your list is a car, call the list 'cars'. If each item is a dog, call your list 'dogs'. This gives you a straightforward way to refer to the entire list ('dogs'), and to a single item in the list ('dog').\n",
    "\n",
    "In Python, square brackets designate a list. To define a list, you give the name of the list, the equals sign, and the values you want to include in your list within square brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "54b8e23e",
   "metadata": {},
   "outputs": [],
   "source": [
    "pokemons = ['charmander', 'bulbasaur', 'squirtle']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a09fb8b",
   "metadata": {},
   "source": [
    "Accessing one item in a list\n",
    "---\n",
    "Items in a list are identified by their position in the list, starting with zero. This will almost certainly trip you up at some point. Programmers even joke about how often we all make \"off-by-one\" errors, so don't feel bad when you make this kind of error.\n",
    "\n",
    "To access the first element in a list, you give the name of the list, followed by a zero in parentheses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75d5bdad",
   "metadata": {},
   "outputs": [],
   "source": [
    "pokemons = ['charmander', 'bulbasaur', 'squirtle']\n",
    "\n",
    "pokemon = pokemons[0]\n",
    "print(pokemon.title())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99bb6c64",
   "metadata": {},
   "source": [
    "The number in parentheses is called the **index** of the item. Because lists start at zero, the index of an item is always one less than its position in the list. So to get the second item in the list, we need to use an index of 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "76df075a",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "pokemons = ['charmander', 'bulbasaur', 'squirtle']\n",
    "\n",
    "pokemon = pokemons[1]\n",
    "print(pokemon.title())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8c1b562",
   "metadata": {},
   "source": [
    "Common List Operations\n",
    "==="
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d59b5fe",
   "metadata": {},
   "source": [
    "Modifying elements in a list\n",
    "---\n",
    "You can change the value of any element in a list if you know the position of that item."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4703ea47",
   "metadata": {},
   "outputs": [],
   "source": [
    "dogs = ['charmander', 'bulbasaur', 'squirtle']\n",
    "\n",
    "dogs[0] = 'australian shepherd'\n",
    "print(dogs)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "193828de",
   "metadata": {},
   "source": [
    "Finding an element in a list\n",
    "---\n",
    "If you want to find out the position of an element in a list, you can use the index() function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d8896af3",
   "metadata": {},
   "outputs": [],
   "source": [
    "pokemons = ['charmander', 'bulbasaur', 'squirtle']\n",
    "\n",
    "print(pokemons.index('squirtle'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1b33569",
   "metadata": {},
   "source": [
    "This method returns a ValueError if the requested item is not in the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b7ce43af",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "pokemons = ['charmander', 'bulbasaur', 'squirtle']\n",
    "\n",
    "print(pokemons.index('charmander'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "051e8ec9",
   "metadata": {},
   "source": [
    "Testing whether an item is in a list\n",
    "---\n",
    "You can test whether an item is in a list using the \"in\" keyword. This will become more useful after learning how to use if-else statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8ed253f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "pokemons = ['charmander', 'bulbasaur', 'squirtle']\n",
    "\n",
    "print('charmander' in pokemons)\n",
    "print('pikachu' in pokemons)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28ad3ccc",
   "metadata": {},
   "source": [
    "Adding items to a list\n",
    "---\n",
    "### Appending items to the end of a list\n",
    "We can add an item to a list using the append() method. This method adds the new item to the end of the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d563f9cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "pokemons = ['charmander', 'bulbasaur', 'squirtle']\n",
    "pokemons.append('poodle')\n",
    "\n",
    "for pokemon in pokemons:\n",
    "    print(pokemon.title() + \"s are cool.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56cd1672",
   "metadata": {},
   "source": [
    "### Inserting items into a list\n",
    "We can also insert items anywhere we want in a list, using the **insert()** function. We specify the position we want the item to have, and everything from that point on is shifted one position to the right. In other words, the index of every item after the new item is increased by one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7ec0ecdb",
   "metadata": {},
   "outputs": [],
   "source": [
    "pokemons = ['charmander', 'bulbasaur', 'squirtle']\n",
    "pokemons.insert(1, 'pikachu')\n",
    "\n",
    "print(pokemons)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "265a68bc",
   "metadata": {},
   "source": [
    "Note that you have to give the position of the new item first, and then the value of the new item. If you do it in the reverse order, you will get an error."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf3eb601",
   "metadata": {},
   "source": [
    "More information about lists can be found [here](https://www.w3schools.com/python/python_lists.asp)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5fbbf19",
   "metadata": {},
   "source": [
    "Tuples\n",
    "===\n",
    "Tuples are basically lists that can never be changed. Lists are quite dynamic; they can grow as you append and insert items, and they can shrink as you remove items. You can modify any element you want to in a list. Sometimes we like this behavior, but other times we may want to ensure that no user or no part of a program can change a list. That's what tuples are for.\n",
    "\n",
    "Technically, lists are *mutable* objects and tuples are *immutable* objects. Mutable objects can change (think of *mutations*), and immutable objects can not change.\n",
    "\n",
    "Defining tuples, and accessing elements\n",
    "---\n",
    "\n",
    "You define a tuple just like you define a list, except you use parentheses instead of square brackets. Once you have a tuple, you can access individual elements just like you can with a list, and you can loop through the tuple with a *for* loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cae8aa1e",
   "metadata": {},
   "outputs": [],
   "source": [
    "pokemons = ('charmander', 'bulbasaur', 'squirtle')\n",
    "print(\"The first pokemon is: \" + pokemons[0])\n",
    "\n",
    "print(\"\\nThe available pokemons are:\")\n",
    "for pokemon in pokemons:\n",
    "    print(\"- \" + pokemon)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5bf2c712",
   "metadata": {},
   "source": [
    "If you try to add something to a tuple, you will get an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b517c479",
   "metadata": {},
   "outputs": [],
   "source": [
    "pokemons = ('charmander', 'bulbasaur', 'squirtle')\n",
    "pokemons.append('pikachu')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "527b990f",
   "metadata": {},
   "source": [
    "The same kind of thing happens when you try to remove something from a tuple, or modify one of its elements. Once you define a tuple, you can be confident that its values will not change."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a39f165",
   "metadata": {},
   "source": [
    "Using tuples to make strings\n",
    "---\n",
    "We have seen that it is pretty useful to be able to mix raw English strings with values that are stored in variables, as in the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b5481c1c",
   "metadata": {},
   "outputs": [],
   "source": [
    "animal = 'dog'\n",
    "print(\"I have a \" + animal + \".\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51c42762",
   "metadata": {},
   "source": [
    "This was especially useful when we had a series of similar statements to make:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e8750921",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "animals = ('dog', 'cat', 'bear')\n",
    "for animal in animals:\n",
    "    print(\"I have a \" + animal + \".\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d5af696",
   "metadata": {},
   "source": [
    "I like this approach of using the plus sign to build strings because it is fairly intuitive. We can see that we are adding several smaller strings together to make one longer string. This is intuitive, but it is a lot of typing. There is a shorter way to do this, using *placeholders*.\n",
    "\n",
    "Python ignores most of the characters we put inside of strings. There are a few characters that Python pays attention to, as we saw with strings such as \"\\t\" and \"\\n\". Python also pays attention to \"%s\" and \"%d\". These are placeholders. When Python sees the \"%s\" placeholder, it looks ahead and pulls in the first argument after the % sign:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "97947358",
   "metadata": {},
   "outputs": [],
   "source": [
    "animal = 'dog'\n",
    "print(\"I have a %s.\" % animal)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "945651c1",
   "metadata": {},
   "source": [
    "This is a much cleaner way of generating strings that include values. We compose our sentence all in one string, and then tell Python what values to pull into the string, in the appropriate places.\n",
    "\n",
    "This is called *string formatting*, and it looks the same when you use a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e38bdd1b",
   "metadata": {},
   "outputs": [],
   "source": [
    "animals = ('dog', 'cat', 'bear')\n",
    "for animal in animals:\n",
    "    print(\"I have a %s.\" % animal)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ead672b",
   "metadata": {},
   "source": [
    "If you have more than one value to put into the string you are composing, you have to pack the values into a tuple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "80b9bbe4",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "animals = ('dog', 'cat', 'bear')\n",
    "print(\"I have a %s, a %s, and a %s.\" % (animals[0], animals[1], animals[2]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55357b29",
   "metadata": {},
   "source": [
    "More information about tuples can be found [here](https://www.w3schools.com/python/python_tuples.asp)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5890659",
   "metadata": {},
   "source": [
    "### When to use Lists vs Tuples?\n",
    "Tuples are more memory efficient than the lists. When it comes to the time efficiency, again tuples have a slight advantage over the lists especially when lookup to a value is considered. **If you have data which is not meant to be changed in the first place, you should choose tuple data type over lists**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "026e5c7b",
   "metadata": {},
   "source": [
    "### String formatting with numbers\n",
    "\n",
    "If you recall, printing a number with a string can cause an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e1a1b6e9",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "number = 42\n",
    "print(\"My favorite number is \" + number + \".\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af13a6de",
   "metadata": {},
   "source": [
    "Python knows that you could be talking about the value 23, or the characters '23'. So it throws an error, forcing us to clarify that we want Python to treat the number as a string. We do this by *casting* the number into a string using the *str()* function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d06b27c2",
   "metadata": {},
   "outputs": [],
   "source": [
    " \n",
    "number = 42\n",
    "print(\"My favorite number is \" + str(number) + \".\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b5e73e3",
   "metadata": {},
   "source": [
    "The format string \"%d\" takes care of this for us. Watch how clean this code is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "218bfff9",
   "metadata": {},
   "outputs": [],
   "source": [
    " \n",
    "number = 42\n",
    "print(\"My favorite number is %d.\" % number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa7da47d",
   "metadata": {},
   "outputs": [],
   "source": [
    " \n",
    "float_number = 42.01\n",
    "print(\"My favorite number is %f.\" % float_number) #example of a float"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36373638",
   "metadata": {},
   "source": [
    "If you want to use a series of numbers, you pack them into a tuple just like we saw with strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "da1efeb3",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "numbers = (7, 23, 42)\n",
    "print(\"My favorite numbers are %d, %d, and %d.\" % (numbers[0], numbers[1], numbers[2]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52b6ee94",
   "metadata": {},
   "source": [
    "Just for clarification, look at how much longer the code is if you use concatenation instead of string formatting:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6dc8e052",
   "metadata": {},
   "outputs": [],
   "source": [
    " \n",
    "numbers = (7, 23, 42)\n",
    "print(\"My favorite numbers are \" + str(numbers[0]) + \", \" + str(numbers[1]) + \", and \" + str(numbers[2]) + \".\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be680e3e",
   "metadata": {},
   "source": [
    "You can mix string and numerical placeholders in any order you want."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "281e1a87",
   "metadata": {},
   "outputs": [],
   "source": [
    "names = ('jericho', 'alfred')\n",
    "numbers = (23, 2)\n",
    "print(\"%s's favorite number is %d, and %s's favorite number is %d.\" % (names[0].title(), numbers[0], names[1].title(), numbers[1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb28dd8f",
   "metadata": {},
   "source": [
    "There are more sophisticated ways to do string formatting in Python 3, but we will save that for later because it's a bit less intuitive than this approach. For now, you can use whichever approach consistently gets you the output that you want to see."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a90f33e",
   "metadata": {},
   "source": [
    "# STEP 4 - EXPANDING YOUR VOCABULARY"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fc6e1b9",
   "metadata": {},
   "source": [
    "What is an *if* statement?\n",
    "===\n",
    "An *if* statement tests for a condition, and then responds to that condition. If the condition is true, then whatever action is listed next gets carried out. You can test for multiple conditions at the same time, and respond appropriately to each condition.\n",
    "\n",
    "Example\n",
    "---\n",
    "Here is an example that shows a number of the desserts I like. It lists those desserts, but lets you know which one is my favorite."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cbb27066",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A list of desserts I like.\n",
    "desserts = ['ice cream', 'chocolate', 'apple crisp', 'cookies']\n",
    "favorite_dessert = 'apple crisp'\n",
    "\n",
    "# Print the desserts out, but let everyone know my favorite dessert.\n",
    "for dessert in desserts:\n",
    "    if dessert == favorite_dessert:\n",
    "        # This dessert is my favorite, let's let everyone know!\n",
    "        print(\"%s is my favorite dessert!\" % dessert.title())\n",
    "    else:\n",
    "        # I like these desserts, but they are not my favorite.\n",
    "        print(\"I like %s.\" % dessert)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3ca5c70",
   "metadata": {},
   "source": [
    "#### What happens in this program?\n",
    "\n",
    "- The program starts out with a list of desserts, and one dessert is identified as a favorite.\n",
    "- The for loop runs through all the desserts.\n",
    "- Inside the for loop, each item in the list is tested.\n",
    "    - If the current value of *dessert* is equal to the value of *favorite_dessert*, a message is printed that this is my favorite.\n",
    "    - If the current value of *dessert* is not equal to the value of *favorite_dessert*, a message is printed that I just like the dessert.\n",
    "    \n",
    "You can test as many conditions as you want in an if statement, as you will see in a little bit."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9253b1b3",
   "metadata": {},
   "source": [
    "Logical Tests\n",
    "===\n",
    "Every if statement evaluates to *True* or *False*. *True* and *False* are Python keywords, which have special meanings attached to them. You can test for the following conditions in your if statements:\n",
    "\n",
    "- [equality](#equality) (==)\n",
    "- [inequality](#inequality) (!=)\n",
    "- [other inequalities](#other_inequalities)\n",
    "    - greater than (>)\n",
    "    - greater than or equal to (>=)\n",
    "    - less than (<)\n",
    "    - less than or equal to (<=)\n",
    "- [You can test if an item is **in** a list.](#in_list)\n",
    "\n",
    "### Whitespace\n",
    "Do you know about [PEP 8](http://introtopython.org/lists_tuples.html#pep8)? There is a [section of PEP 8](http://www.python.org/dev/peps/pep-0008/#other-recommendations) that tells us it's a good idea to put a single space on either side of all of these comparison operators. If you're not sure what this means, just follow the style of the examples you see below."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec8514a4",
   "metadata": {},
   "source": [
    "Equality\n",
    "---\n",
    "Two items are *equal* if they have the same value. You can test for equality between numbers, strings, and a number of other objects which you will learn about later. Some of these results may be surprising, so take a careful look at the examples below.\n",
    "\n",
    "In Python, as in many programming languages, two equals signs tests for equality.\n",
    "\n",
    "**Watch out!** Be careful of accidentally using one equals sign, which can really throw things off because that one equals sign actually sets your item to the value you are testing for!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "de8b7e48",
   "metadata": {},
   "outputs": [],
   "source": [
    "5 == 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6870f4f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "3 == 5 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "961f1874",
   "metadata": {},
   "outputs": [],
   "source": [
    "5 == 5.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3c219a56",
   "metadata": {},
   "outputs": [],
   "source": [
    "'eric' == 'eric'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9d06ef93",
   "metadata": {},
   "outputs": [],
   "source": [
    "'Eric' == 'eric'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4a56f82",
   "metadata": {},
   "outputs": [],
   "source": [
    "'Eric'.lower() == 'eric'.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "21a5086c",
   "metadata": {},
   "outputs": [],
   "source": [
    "'5' == 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d68f7fac",
   "metadata": {},
   "outputs": [],
   "source": [
    "'5' == str(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b287f00",
   "metadata": {},
   "source": [
    "Inequality\n",
    "---\n",
    "Two items are *inequal* if they do not have the same value. In Python, we test for inequality using the exclamation point and one equals sign.\n",
    "\n",
    "Sometimes you want to test for equality and if that fails, assume inequality. Sometimes it makes more sense to test for inequality directly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a0cd21d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "3 != 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "befa4f7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "5 != 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c6addd28",
   "metadata": {},
   "outputs": [],
   "source": [
    "'Eric' != 'eric'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29466c84",
   "metadata": {},
   "source": [
    "Other Inequalities\n",
    "---\n",
    "### greater than"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ae917742",
   "metadata": {},
   "outputs": [],
   "source": [
    "5 > 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd8a9ab6",
   "metadata": {},
   "source": [
    "### greater than or equal to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "012935f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "5 >= 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9684790c",
   "metadata": {},
   "outputs": [],
   "source": [
    "3 >= 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd8fa574",
   "metadata": {},
   "source": [
    "### less than"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e1250ac4",
   "metadata": {},
   "outputs": [],
   "source": [
    "3 < 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "444f8b6d",
   "metadata": {},
   "source": [
    "### less than or equal to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "507405bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "3 <= 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "46a6049a",
   "metadata": {},
   "outputs": [],
   "source": [
    "3 <= 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f84ed733",
   "metadata": {},
   "source": [
    "Checking if an item is **in** a list\n",
    "---\n",
    "You can check if an item is in a list using the **in** keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bc47293e",
   "metadata": {},
   "outputs": [],
   "source": [
    "vowels = ['a', 'e', 'i', 'o', 'u']\n",
    "'a' in vowels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cbf07a5c",
   "metadata": {},
   "outputs": [],
   "source": [
    "vowels = ['a', 'e', 'i', 'o', 'u']\n",
    "'b' in vowels"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ed423d3",
   "metadata": {},
   "source": [
    "The if-elif...else chain\n",
    "===\n",
    "You can test whatever series of conditions you want to, and you can test your conditions in any combination you want."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d86e1bf",
   "metadata": {},
   "source": [
    "Simple if statements\n",
    "---\n",
    "The simplest test has a single **if** statement, and a single statement to execute if the condition is **True**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "176c9aa0",
   "metadata": {},
   "outputs": [],
   "source": [
    "dogs = ['willie', 'hootz', 'peso', 'juno']\n",
    "\n",
    "if len(dogs) > 3:\n",
    "    print(\"Wow, we have a lot of dogs here!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cef86086",
   "metadata": {},
   "source": [
    "In this situation, nothing happens if the test does not pass."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e70a7b7e",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "dogs = ['willie', 'hootz']\n",
    "\n",
    "if len(dogs) > 3:\n",
    "    print(\"Wow, we have a lot of dogs here!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ab475da",
   "metadata": {},
   "source": [
    "Notice that there are no errors. The condition `len(dogs) > 3` evaluates to False, and the program moves on to any lines after the **if** block."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ae83549",
   "metadata": {},
   "source": [
    "if-else statements\n",
    "---\n",
    "Many times you will want to respond in two possible ways to a test. If the test evaluates to **True**, you will want to do one thing. If the test evaluates to **False**, you will want to do something else. The **if-else** structure lets you do that easily. Here's what it looks like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "572e73eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "dogs = ['willie', 'hootz', 'peso', 'juno']\n",
    "\n",
    "if len(dogs) > 3:\n",
    "    print(\"Wow, we have a lot of dogs here!\")\n",
    "else:\n",
    "    print(\"Okay, this is a reasonable number of dogs.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e07db45",
   "metadata": {},
   "source": [
    "Our results have not changed in this case, because if the test evaluates to **True** only the statements under the **if** statement are executed. The statements under **else** area only executed if the test fails:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edef8541",
   "metadata": {},
   "source": [
    "if-else statements\n",
    "---\n",
    "Many times you will want to respond in two possible ways to a test. If the test evaluates to **True**, you will want to do one thing. If the test evaluates to **False**, you will want to do something else. The **if-else** structure lets you do that easily. Here's what it looks like:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f20457f",
   "metadata": {},
   "outputs": [],
   "source": [
    "dogs = ['willie', 'hootz', 'peso', 'juno']\n",
    "\n",
    "if len(dogs) > 3:\n",
    "    print(\"Wow, we have a lot of dogs here!\")\n",
    "else:\n",
    "    print(\"Okay, this is a reasonable number of dogs.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a878901",
   "metadata": {},
   "source": [
    "Our results have not changed in this case, because if the test evaluates to **True** only the statements under the **if** statement are executed. The statements under **else** area only executed if the test fails:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "49e374b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "###highlight=[2]\n",
    "dogs = ['willie', 'hootz']\n",
    "\n",
    "if len(dogs) > 3:\n",
    "    print(\"Wow, we have a lot of dogs here!\")\n",
    "else:\n",
    "    print(\"Okay, this is a reasonable number of dogs.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8f86e07",
   "metadata": {},
   "source": [
    "The test evaluated to **False**, so only the statement under `else` is run."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c4e8326",
   "metadata": {},
   "source": [
    "if-elif...else chains\n",
    "---\n",
    "Many times, you will want to test a series of conditions, rather than just an either-or situation. You can do this with a series of if-elif-else statements\n",
    "\n",
    "There is no limit to how many conditions you can test. You always need one if statement to start the chain, and you can never have more than one else statement. But you can have as many elif statements as you want."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "594ba370",
   "metadata": {},
   "outputs": [],
   "source": [
    "dogs = ['willie', 'hootz', 'peso', 'monty', 'juno', 'turkey']\n",
    "\n",
    "if len(dogs) >= 5:\n",
    "    print(\"Holy mackerel, we might as well start a dog hostel!\")\n",
    "elif len(dogs) >= 3:\n",
    "    print(\"Wow, we have a lot of dogs here!\")\n",
    "else:\n",
    "    print(\"Okay, this is a reasonable number of dogs.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d48691a6",
   "metadata": {},
   "source": [
    "It is important to note that in situations like this, only the first test is evaluated. In an if-elif-else chain, once a test passes the rest of the conditions are ignored."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "983fc620",
   "metadata": {},
   "source": [
    "More than one passing test\n",
    "===\n",
    "In all of the examples we have seen so far, only one test can pass. As soon as the first test passes, the rest of the tests are ignored. This is really good, because it allows our code to run more efficiently. Many times only one condition can be true, so testing every condition after one passes would be meaningless.\n",
    "\n",
    "There are situations in which you want to run a series of tests, where every single test runs. These are situations where any or all of the tests could pass, and you want to respond to each passing test. Consider the following example, where we want to greet each dog that is present:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6410ffed",
   "metadata": {},
   "outputs": [],
   "source": [
    "dogs = ['willie', 'hootz']\n",
    "\n",
    "if 'willie' in dogs:\n",
    "    print(\"Hello, Willie!\")\n",
    "if 'hootz' in dogs:\n",
    "    print(\"Hello, Hootz!\")\n",
    "if 'peso' in dogs:\n",
    "    print(\"Hello, Peso!\")\n",
    "if 'monty' in dogs:\n",
    "    print(\"Hello, Monty!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0c14591",
   "metadata": {},
   "source": [
    "If we had done this using an if-elif-else chain, only the first dog that is present would be greeted"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e0ab3e7",
   "metadata": {},
   "source": [
    "For more info about Control structures visit [here](https://www.w3schools.com/python/python_conditions.asp)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc104a57",
   "metadata": {},
   "source": [
    "What is a while loop?\n",
    "===\n",
    "A while loop tests an initial condition. If that condition is true, the loop starts executing. Every time the loop finishes, the condition is reevaluated. As long as the condition remains true, the loop keeps executing. As soon as the condition becomes false, the loop stops executing."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17910262",
   "metadata": {},
   "source": [
    "General syntax\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b23b6902",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set an initial condition.\n",
    "game_active = True\n",
    "\n",
    "# Set up the while loop.\n",
    "while game_active:\n",
    "    # Run the game.\n",
    "    # At some point, the game ends and game_active will be set to False.\n",
    "    game_active = False\n",
    "    #   When that happens, the loop will stop executing.\n",
    "    \n",
    "# Do anything else you want done after the loop runs."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed5ede39",
   "metadata": {},
   "source": [
    "- Every while loop needs an initial condition that starts out true.\n",
    "- The `while` statement includes a condition to test.\n",
    "- All of the code in the loop will run as long as the condition remains true.\n",
    "- As soon as something in the loop changes the condition such that the test no longer passes, the loop stops executing.\n",
    "- Any code that is defined after the loop will run at this point."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fccbc6d9",
   "metadata": {},
   "source": [
    "Example\n",
    "---\n",
    "Here is a simple example, showing how a game will stay active as long as the player has enough power."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c25817c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# The player's power starts out at 5.\n",
    "power = 5\n",
    "\n",
    "# The player is allowed to keep playing as long as their power is over 0.\n",
    "while power > 0:\n",
    "    print(\"You are still playing, because your power is %d.\" % power)\n",
    "    # Your game code would go here, which includes challenges that make it\n",
    "    #   possible to lose power.\n",
    "    # We can represent that by just taking away from the power.\n",
    "    power = power - 1\n",
    "    \n",
    "print(\"\\nOh no, your power dropped to 0! Game Over.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d337aaad",
   "metadata": {},
   "source": [
    "Accepting user input\n",
    "===\n",
    "Almost all interesting programs accept input from the user at some point. You can start accepting user input in your programs by using the `input()` function. The input function displays a messaget to the user describing the kind of input you are looking for, and then it waits for the user to enter a value. When the user presses Enter, the value is passed to your variable."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28d5be10",
   "metadata": {},
   "source": [
    "<a id=\"General-syntax-input\"></a>\n",
    "General syntax\n",
    "---\n",
    "The general case for accepting input looks something like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c3bf4b94",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get some input from the user.\n",
    "variable = input('Please enter a value: ')\n",
    "# Do something with the value that was entered."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9ccd194",
   "metadata": {},
   "source": [
    "You need a variable that will hold whatever value the user enters, and you need a message that will be displayed to the user."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2dfc87e3",
   "metadata": {},
   "source": [
    "<a id=\"Example-input\"></a>\n",
    "Example\n",
    "---\n",
    "In the following example, we have a list of names. We ask the user for a name, and we add it to our list of names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "44e043f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Start with a list containing several names.\n",
    "names = ['sara', 'cedie', 'liz']\n",
    "\n",
    "# Ask the user for a name.\n",
    "new_name = input(\"Please tell me someone I should know: \")\n",
    "\n",
    "# Add the new name to our list.\n",
    "names.append(new_name)\n",
    "\n",
    "# Show that the name has been added to the list.\n",
    "print(names)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a199e60",
   "metadata": {},
   "source": [
    "Using while loops to keep your programs running\n",
    "===\n",
    "Most of the programs we use every day run until we tell them to quit, and in the background this is often done with a while loop. Here is an example of how to let the user enter an arbitrary number of names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "51679c16",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Start with an empty list. You can 'seed' the list with\n",
    "#  some predefined values if you like.\n",
    "names = []\n",
    "\n",
    "# Set new_name to something other than 'quit'.\n",
    "new_name = ''\n",
    "\n",
    "# Start a loop that will run until the user enters 'quit'.\n",
    "while new_name != 'quit':\n",
    "    # Ask the user for a name.\n",
    "    new_name = input(\"Please tell me someone I should know, or enter 'quit': \")\n",
    "\n",
    "    # Add the new name to our list.\n",
    "    names.append(new_name)\n",
    "\n",
    "# Show that the name has been added to the list.\n",
    "print(names)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b30eac41",
   "metadata": {},
   "source": [
    "That worked, except we ended up with the name 'quit' in our list. We can use a simple `if` test to eliminate this bug:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f62c103f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Start with an empty list. You can 'seed' the list with\n",
    "#  some predefined values if you like.\n",
    "names = []\n",
    "\n",
    "# Set new_name to something other than 'quit'.\n",
    "new_name = ''\n",
    "\n",
    "# Start a loop that will run until the user enters 'quit'.\n",
    "while new_name != 'quit':\n",
    "    # Ask the user for a name.\n",
    "    new_name = input(\"Please tell me someone I should know, or enter 'quit': \")\n",
    "\n",
    "    # Add the new name to our list.\n",
    "    if new_name != 'quit':\n",
    "        names.append(new_name)\n",
    "\n",
    "# Show that the name has been added to the list.\n",
    "print(names)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9368d054",
   "metadata": {},
   "source": [
    "For more info about While loops click [here](https://www.w3schools.com/python/python_while_loops.asp)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "292a43f2",
   "metadata": {},
   "source": [
    "# Python For Loops\n",
    "A for loop is used for iterating over a sequence (that is either a list, a tuple, a dictionary, a set, or a string)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "35347bef",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's consider how we might make a list of the first ten square numbers. We could do it like this:\n",
    "\n",
    "# Store the first ten square numbers in a list.\n",
    "# Make an empty list that will hold our square numbers.\n",
    "squares = []\n",
    "\n",
    "# Go through the first ten numbers, square them, and add them to our list.\n",
    "for number in range(1,11):\n",
    "    new_square = number**2\n",
    "    squares.append(new_square)\n",
    "    \n",
    "# Show that our list is correct.\n",
    "for square in squares:\n",
    "    print(square)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c007755",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Consider some students.\n",
    "students = ['eugene', 'toguro', 'jeremiah']\n",
    "\n",
    "# Let's turn them into great students.\n",
    "great_students = []\n",
    "for student in students:\n",
    "    great_students.append(student.title() + \" the great!\")\n",
    "\n",
    "# Let's greet each great student.\n",
    "for great_student in great_students:\n",
    "    print(\"Hello, \" + great_student)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d10a095",
   "metadata": {},
   "source": [
    "For more info about For loops click [here](https://www.w3schools.com/python/python_for_loops.asp)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a00d0f8",
   "metadata": {},
   "source": [
    "What are dictionaries?\n",
    "===\n",
    "Dictionaries are a way to store information that is connected in some way. Dictionaries store information in *key-value* pairs, so that any one piece of information in a dictionary is connected to at least one other piece of information.\n",
    "\n",
    "Dictionaries do not store their information in any particular order, so you may not get your information back in the same order you entered it."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0dac012f",
   "metadata": {},
   "source": [
    "General Syntax\n",
    "---\n",
    "A general dictionary in Python looks something like this:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "253317fb",
   "metadata": {},
   "source": [
    "dictionary_name = {key_1: value_1, key_2: value_2, key_3: value_3}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abb8508f",
   "metadata": {},
   "source": [
    "Since the keys and values in dictionaries can be long, we often write just one key-value pair on a line. You might see dictionaries that look more like this:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fad0fabe",
   "metadata": {},
   "source": [
    "dictionary_name = {key_1: value_1,\n",
    "                   key_2: value_2,\n",
    "                   key_3: value_3,\n",
    "                   }"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7946c54",
   "metadata": {},
   "source": [
    "This is a bit easier to read, especially if the values are long."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe1f02de",
   "metadata": {},
   "source": [
    "Example\n",
    "---\n",
    "A simple example involves modeling an actual dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "090c82f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "python_words = {'list': 'A collection of values that are not connected, but have an order.',\n",
    "                'dictionary': 'A collection of key-value pairs.',\n",
    "                'function': 'A named set of instructions that defines a set of actions in Python.',\n",
    "                }"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64fe3939",
   "metadata": {},
   "source": [
    "We can get individual items out of the dictionary, by giving the dictionary's name, and the key in square brackets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "21ae5c98",
   "metadata": {},
   "outputs": [],
   "source": [
    "python_words = {'list': 'A collection of values that are not connected, but have an order.',\n",
    "                'dictionary': 'A collection of key-value pairs.',\n",
    "                'function': 'A named set of instructions that defines a set of actions in Python.',\n",
    "                }\n",
    "\n",
    "print(\"\\nWord: %s\" % 'list')\n",
    "print(\"Meaning: %s\" % python_words['list'])\n",
    "      \n",
    "print(\"\\nWord: %s\" % 'dictionary')\n",
    "print(\"Meaning: %s\" % python_words['dictionary'])\n",
    "\n",
    "print(\"\\nWord: %s\" % 'function')\n",
    "print(\"Meaning: %s\" % python_words['function'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "959e46c6",
   "metadata": {},
   "source": [
    "This code looks pretty repetitive, and it is. Dictionaries have their own for-loop syntax, but since there are two kinds of information in dictionaries, the structure is a bit more complicated than it is for lists. Here is how to use a for loop with a dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c234e155",
   "metadata": {},
   "outputs": [],
   "source": [
    "python_words = {'list': 'A collection of values that are not connected, but have an order.',\n",
    "                'dictionary': 'A collection of key-value pairs.',\n",
    "                'function': 'A named set of instructions that defines a set of actions in Python.',\n",
    "                }\n",
    "\n",
    "# Print out the items in the dictionary.\n",
    "for word, meaning in python_words.items():\n",
    "    print(\"\\nWord: %s\" % word)\n",
    "    print(\"Meaning: %s\" % meaning)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "457c0637",
   "metadata": {},
   "source": [
    "The output is identical, but we did it in 3 lines instead of 6. If we had 100 terms in our dictionary, we would still be able to print them out with just 3 lines.\n",
    "\n",
    "The only tricky part about using for loops with dictionaries is figuring out what to call those first two variables. The general syntax for this for loop is:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "7d37910a",
   "metadata": {},
   "source": [
    "for key_name, value_name in dictionary_name.items():\n",
    "    print(key_name) # The key is stored in whatever you called the first variable.\n",
    "    print(value_name) # The value associated with that key is stored in your second variable."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f572ebe3",
   "metadata": {},
   "source": [
    "For more info about Dictionaries click [here](https://www.w3schools.com/python/python_dictionaries.asp)"
   ]
  },
  {
   "cell_type": "raw",
   "id": "e7e70df3",
   "metadata": {},
   "source": [
    "if else\n",
    "for loops\n",
    "while loops\n",
    "dictionaries\n",
    "catch exceptions and testing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "929c4d90",
   "metadata": {},
   "source": [
    "# STEP 5 - WRITE CODE ONCE"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "360ec895",
   "metadata": {},
   "source": [
    "What are functions?\n",
    "===\n",
    "Functions are a set of actions that we group together, and give a name to. You have already used a number of functions from the core Python language, such as *string.title()* and *list.sort()*. We can define our own functions, which allows us to \"teach\" Python new behavior."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67014190",
   "metadata": {},
   "source": [
    "General Syntax\n",
    "---\n",
    "A general function looks something like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71154883",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's define a function.\n",
    "def function_name(argument_1, argument_2):\n",
    "    return\n",
    "\t# Do whatever we want this function to do,\n",
    "\t#  using argument_1 and argument_2\n",
    "\n",
    "# Use function_name to call the function.\n",
    "function_name(\"value_1\", \"value_2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f58b9cf8",
   "metadata": {},
   "source": [
    "This code will not run, but it shows how functions are used in general.\n",
    "\n",
    "- **Defining a function**\n",
    "    - Give the keyword `def`, which tells Python that you are about to *define* a function.\n",
    "    - Give your function a name. A variable name tells you what kind of value the variable contains; a function name should tell you what the function does.\n",
    "    - Give names for each value the function needs in order to do its work.\n",
    "        - These are basically variable names, but they are only used in the function.\n",
    "        - They can be different names than what you use in the rest of your program.\n",
    "        - These are called the function's *arguments*.\n",
    "    - Make sure the function definition line ends with a colon.\n",
    "    - Inside the function, write whatever code you need to make the function do its work.\n",
    "- **Using your function**\n",
    "    - To *call* your function, write its name followed by parentheses.\n",
    "    - Inside the parentheses, give the values you want the function to work with.\n",
    "        - These can be variables such as `current_name` and `current_age`, or they can be actual values such as 'eric' and 5."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb1abcd9",
   "metadata": {},
   "source": [
    "Basic Examples\n",
    "===\n",
    "For a simple first example, we will look at a program that compliments people. Let's look at the example, and then try to understand the code. First we will look at a version of this program as we would have written it earlier, with no functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b86fa662",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"You are doing good work, harry!\")\n",
    "print(\"Thank you very much for your efforts on this project.\")\n",
    "\n",
    "print(\"\\nYou are doing good work, ron!\")\n",
    "print(\"Thank you very much for your efforts on this project.\")\n",
    "\n",
    "print(\"\\nYou are doing good work, hermione!\")\n",
    "print(\"Thank you very much for your efforts on this project.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7313473e",
   "metadata": {},
   "source": [
    "Functions take repeated code, put it in one place, and then you call that code when you want to use it. Here's what the same program looks like with a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "89d42953",
   "metadata": {},
   "outputs": [],
   "source": [
    "def thank_you(name):\n",
    "    # This function prints a two-line personalized thank you message.\n",
    "    print(\"\\nYou are doing good work, %s!\" % name)\n",
    "    print(\"Thank you very much for your efforts on this project.\")\n",
    "    \n",
    "thank_you('harry')\n",
    "thank_you('ron')\n",
    "thank_you('hermione')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb3308ff",
   "metadata": {},
   "source": [
    "In our original code, each pair of print statements was run three times, and the only difference was the name of the person being thanked. When you see repetition like this, you can usually make your program more efficient by defining a function.\n",
    "\n",
    "The keyword *def* tells Python that we are about to define a function. We give our function a name, *thank\\_you()* in this case. A variable's name should tell us what kind of information it holds; a function's name should tell us what the variable does.  We then put parentheses. Inside these parenthese we create variable names for any variable the function will need to be given in order to do its job. In this case the function will need a name to include in the thank you message. The variable `name` will hold the value that is passed into the function *thank\\_you()*.\n",
    "\n",
    "To use a function we give the function's name, and then put any values the function needs in order to do its work. In this case we call the function three times, each time passing it a different name."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16b9ff85",
   "metadata": {},
   "source": [
    "### A common error\n",
    "A function must be defined before you use it in your program. For example, putting the function at the end of the program would not work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b516174c",
   "metadata": {},
   "outputs": [],
   "source": [
    "thank_you('harry')\n",
    "thank_you('ron')\n",
    "thank_you('hermione')\n",
    "\n",
    "def thank_you(name):\n",
    "    # This function prints a two-line personalized thank you message.\n",
    "    print(\"\\nYou are doing good work, %s!\" % name)\n",
    "    print(\"Thank you very much for your efforts on this project.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0847c37e",
   "metadata": {},
   "source": [
    "On the first line we ask Python to run the function *thank\\_you()*, but Python does not yet know how to do this function. We define our functions at the beginning of our programs, and then we can use them when we need to."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87f759ba",
   "metadata": {},
   "source": [
    "### Advantages of using functions\n",
    "You might be able to see some advantages of using functions, through this example:\n",
    "\n",
    "- We write a set of instructions once. We save some work in this simple example, and we save even more work in larger programs.\n",
    "- When our function works, we don't have to worry about that code anymore. Every time you repeat code in your program, you introduce an opportunity to make a mistake. Writing a function means there is one place to fix mistakes, and when those bugs are fixed, we can be confident that this function will continue to work correctly.\n",
    "- We can modify our function's behavior, and that change takes effect every time the function is called. This is much better than deciding we need some new behavior, and then having to change code in many different places in our program."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba1a70c0",
   "metadata": {},
   "source": [
    "Returning a Value\n",
    "---\n",
    "Each function you create can return a value. This can be in addition to the primary work the function does, or it can be the function's main job. The following function takes in a number, and returns the corresponding word for that number:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8a3f42bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_number_word(number):\n",
    "    # Takes in a numerical value, and returns\n",
    "    #  the word corresponding to that number.\n",
    "    if number == 1:\n",
    "        return 'one'\n",
    "    elif number == 2:\n",
    "        return 'two'\n",
    "    elif number == 3:\n",
    "        return 'three'\n",
    "    # ...\n",
    "    \n",
    "# Let's try out our function.\n",
    "for current_number in range(0,4):\n",
    "    number_word = get_number_word(current_number)\n",
    "    print(current_number, number_word)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea2e0576",
   "metadata": {},
   "source": [
    "It's helpful sometimes to see programs that don't quite work as they are supposed to, and then see how those programs can be improved. In this case, there are no Python errors; all of the code has proper Python syntax. But there is a logical error, in the first line of the output.\n",
    "\n",
    "We want to either not include 0 in the range we send to the function, or have the function return something other than `None` when it receives a value that it doesn't know. Let's teach our function the word 'zero', but let's also add an `else` clause that returns a more informative message for numbers that are not in the if-chain."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3916ff9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_number_word(number):\n",
    "    # Takes in a numerical value, and returns\n",
    "    #  the word corresponding to that number.\n",
    "    if number == 0:\n",
    "        return 'zero'\n",
    "    elif number == 1:\n",
    "        return 'one'\n",
    "    elif number == 2:\n",
    "        return 'two'\n",
    "    elif number == 3:\n",
    "        return 'three'\n",
    "    else:\n",
    "        return \"I'm sorry, I don't know that number.\"\n",
    "    \n",
    "# Let's try out our function.\n",
    "for current_number in range(0,6):\n",
    "    number_word = get_number_word(current_number)\n",
    "    print(current_number, number_word)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "716d9436",
   "metadata": {},
   "source": [
    "If you use a return statement in one of your functions, keep in mind that the function stops executing as soon as it hits a return statement. For example, we can add a line to the *get\\_number\\_word()* function that will never execute, because it comes after the function has returned a value:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86e14f91",
   "metadata": {},
   "source": [
    "To know more about functions click [here](https://www.w3schools.com/python/python_functions.asp)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49982579",
   "metadata": {},
   "source": [
    "## What is PIP?\n",
    "- PIP is a package manager for Python packages, or modules if you like.\n",
    "- To search for packages just go to pip https://pypi.org/\n",
    "- to install packages just open an Anaconda terminal (or terminal within Google Colab) and just type **pip instsall package_name**\n",
    "- You can also just type **!pip instsall package_name** within a notebook cell"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d4dc74e",
   "metadata": {},
   "source": [
    "## External packages is what makes python GREAT\n",
    "Let's use a popular package by the name of Pandas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a9232da",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dffede95",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Let's create a list of dictionaries that we will convert into a dataframe\n",
    "\n",
    "tmp_list = [{ \"name\":\"sara\",\"job\":\"princess\"},{ \"name\":\"cedie\",\"job\":\"prince\"},{ \"name\":\"pikachu\",\"job\":\"pokemon\"}]\n",
    "tmp_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "10fdd988",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a dataframe from this list\n",
    "\n",
    "tmp_df = pd.DataFrame(tmp_list)\n",
    "tmp_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f2e6a623",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's save it to a csv file\n",
    "tmp_df.to_csv(\"file.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b8a98db",
   "metadata": {},
   "source": [
    "External packages help save time by providing code that someone else has already written!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc9753cf",
   "metadata": {},
   "source": [
    "- Normally Pypi.org can show you the package docs but in case it's not there you can always check Google.com or Github.com\n",
    "- For Pandas, you can get more info [here](https://pandas.pydata.org/docs/index.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6e572af",
   "metadata": {},
   "source": [
    "# STEP 6 - DEBUGGING, TIPS, & TRICKS"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3792e2b",
   "metadata": {},
   "source": [
    "Ever since **Python**, we can now say that learning how to program is EASY, yet it is still HARD to master. \n",
    "*Here are some tips to level up your python-fu!*"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c314130d",
   "metadata": {},
   "source": [
    "- SEARCH: No one knows everything, use https://www.google.com/ and https://stackoverflow.com/!\n",
    "- DOCUMENTATION: Everything is free and open for everyone to read https://docs.python.org/3/\n",
    "- ASK: Don't be afraid to engage old programming wizards in Python communities https://www.facebook.com/groups/570524223003384 and https://www.reddit.com/r/python\n",
    "- CHEAT: No one says you can't cheat in Python https://www.pythoncheatsheet.org/\n",
    "- CODE: Start a project and don't stop until you are done.\n",
    "- FAIL: Failing in development is cheap. And failure speeds up the learning process. Don't be afraid to make mistakes.\n",
    "- PRACTICE: There are a lot of small beginner projects you can do to sink your teeth into. [Try them out!](https://github.com/topics/python-project-beginner)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "993abd1a",
   "metadata": {},
   "source": [
    "# Take home activity\n",
    "\n",
    "Implement this using Python\n",
    "\n",
    "**Address book** stores name, gender, and contact number, allows you to add, remove, edit, delete, print the list on screen, save the list to csv, load the list from csv to the program, generate statistics e.g. total entries, gender counts\n",
    "\n",
    "You can submit in .py (python script) or .ipynb (notebook file)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4632736",
   "metadata": {},
   "source": [
    "# STEP 7 - CLOSING REMARKS"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1984d7c",
   "metadata": {},
   "source": [
    "## Being a programmer is really just being a problem-solver, so solving problems is the most important part.\n",
    "You need to try (and fail at) several attempts to approach a problem so you can understand how different uses of your tools change the outcome. And then you need to keep refining your solution. While the solution to the problem is the immediate goal, the act of solving that problem increases your problem-solving skills, and that is the longer-term benefit.\n",
    "\n",
    "\n",
    "![Alt Text](https://raw.githubusercontent.com/ogbinar/python101/master/img/O-Comic-Zelda-Sword.gif)\n",
    "\n",
    "You are now ready for what comes next, **Good luck!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cfe9b1f3",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}