01 - Introduction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook is based on [Python Cheat Sheet](http://ehmatthes.github.io/pcc/cheatsheets/README.html) by [Eric Matthes](https://github.com/ehmatthes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Cheat Sheet\n",
    "Provides an overview of the basics of Python including variables, lists, dictionaries, functions, classes, and more."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variables and Strings\n",
    "Variables are used to store values. A string is a series of characters, surrounded by single or double quotes.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world!\n"
     ]
    }
   ],
   "source": [
    "# Hello world\n",
    "print(\"Hello world!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "# Hello world with a variable\n",
    "msg = \"Hello World!\"\n",
    "print(msg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "albert einstein\n"
     ]
    }
   ],
   "source": [
    "# Concatenation (combining strings)\n",
    "first_name = 'albert'\n",
    "last_name = 'einstein'\n",
    "full_name = first_name + ' ' + last_name\n",
    "print(full_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists\n",
    "A list stores a series of items in a particular order. You access items using an index, or within a loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Make a list\n",
    "bikes = ['trek', 'redline', 'giant']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "trek\n"
     ]
    }
   ],
   "source": [
    "# Get the first item in a list\n",
    "first_bike = bikes[0]\n",
    "print(first_bike)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "giant\n"
     ]
    }
   ],
   "source": [
    "# Get the last item in a list\n",
    "last_bike = bikes[-1]\n",
    "print(last_bike)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "trek\n",
      "redline\n",
      "giant\n"
     ]
    }
   ],
   "source": [
    "# Looping through a list\n",
    "for bike in bikes:\n",
    "    print(bike)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['trek', 'redline', 'giant']\n"
     ]
    }
   ],
   "source": [
    "# Adding items to a list\n",
    "bikes = []\n",
    "bikes.append('trek')\n",
    "bikes.append('redline')\n",
    "bikes.append('giant')\n",
    "\n",
    "print(bikes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n"
     ]
    }
   ],
   "source": [
    "# Making numerical lists\n",
    "squares = []\n",
    "for x in range(1, 11):\n",
    "    squares.append(x**2)\n",
    "    \n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121]\n"
     ]
    }
   ],
   "source": [
    "# List comprehensions\n",
    "squares = [x**2 for x in range(1, 12)]\n",
    "\n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['sam', 'bob']\n"
     ]
    }
   ],
   "source": [
    "# Slicing a list\n",
    "finishers = ['sam', 'bob', 'ada', 'bea']\n",
    "first_two = finishers[:2]\n",
    "\n",
    "print(first_two)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['trek', 'redline', 'giant']\n"
     ]
    }
   ],
   "source": [
    "# Copying a list\n",
    "copy_of_bikes = bikes[:]\n",
    "\n",
    "print(copy_of_bikes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples\n",
    "Tuples are similar to lists, but the items in a tuple can't be modified."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Making a tuple\n",
    "dimensions = (1920, 1080)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### If statements\n",
    "If statements are used to test for particular conditions and respond appropriately."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Conditional tests\n",
    "# equals               x == 42\n",
    "# not equal            x != 42\n",
    "# greater than         x > 42\n",
    "#  or equal to         x >= 42\n",
    "# less than            x < 42\n",
    "#  or equal to         x <= 42"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Conditional test with list\n",
    "print('trek' in bikes)\n",
    "print('surly' not in bikes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Assigning boolean values\n",
    "game_active = True\n",
    "can_edit = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You can vote\n"
     ]
    }
   ],
   "source": [
    "age = 22\n",
    "\n",
    "# A simple if test\n",
    "if age >= 18:\n",
    "    print('You can vote')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "# If-elif-else statements\n",
    "if age < 4:\n",
    "    ticket_price = 0\n",
    "elif age < 18:\n",
    "    ticket_price = 10\n",
    "else:\n",
    "    ticket_price = 15\n",
    "\n",
    "print(ticket_price)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries\n",
    "Dictionaries store connections between pieces of information. Each item in a dictionary is a key-value pair."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# A simple dictionary\n",
    "alien = {'color': 'green', 'points': 5}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'green'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Accessing a value\n",
    "alien['color']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'color': 'green', 'points': 5, 'x-position': 0}\n"
     ]
    }
   ],
   "source": [
    "# Adding a new key-value pair\n",
    "alien['x-position'] = 0\n",
    "\n",
    "print(alien)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "eric loves 17\n",
      "ever loves 4\n"
     ]
    }
   ],
   "source": [
    "# Looping through all key-value pairs\n",
    "fav_numbers = {'eric': 17, 'ever': 4}\n",
    "for name, number in fav_numbers.items():\n",
    "    print(name + ' loves ' + str(number))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "eric loves a number\n",
      "ever loves a number\n"
     ]
    }
   ],
   "source": [
    "# Looping through all keys\n",
    "fav_numbers = {'eric': 17, 'ever': 4}\n",
    "for name in fav_numbers.keys():\n",
    "    print(name + ' loves a number')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17 is a favorite\n",
      "4 is a favorite\n"
     ]
    }
   ],
   "source": [
    "# Looping through all the values\n",
    "fav_numbers = {'eric': 17, 'ever': 4}\n",
    "for number in fav_numbers.values():\n",
    "    print(str(number) + ' is a favorite')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### User inputs\n",
    "Your programs can prompt the user for input. All input is stored as a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What's your name? Sujeevan\n",
      "Hello, Sujeevan!\n"
     ]
    }
   ],
   "source": [
    "# Prompting for a value\n",
    "name = input(\"What's your name? \")\n",
    "print(\"Hello, \" + name + \"!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "How old are you? 22\n",
      "22\n"
     ]
    }
   ],
   "source": [
    "# Prompting for numerical input\n",
    "age = input(\"How old are you? \")\n",
    "age = int(age)\n",
    "print(age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What's the value of pi? 3.14\n",
      "3.14\n"
     ]
    }
   ],
   "source": [
    "pi = input(\"What's the value of pi? \")\n",
    "pi = float(pi)\n",
    "print(pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### While loops\n",
    "A while loop repeats a block of code as long as a certain condition is true."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# A simple while loop\n",
    "current_value = 1\n",
    "while current_value <= 5:\n",
    "    print(current_value)\n",
    "    current_value += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What's your message? Python is Awesome\n",
      "Python is Awesome\n",
      "What's your message? Python is Simple\n",
      "Python is Simple\n",
      "What's your message? quit\n",
      "quit\n"
     ]
    }
   ],
   "source": [
    "# Letting the user choose when to quit\n",
    "msg = ''\n",
    "while msg != 'quit':\n",
    "    msg = input(\"What's your message? \\nEnter 'quit' to end the program.\")\n",
    "    print(msg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions\n",
    "Functions are named blocks of code, designed to do one specific job. Information passed to a function is called an argument, and information received by a function is called a parameter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello!\n"
     ]
    }
   ],
   "source": [
    "# A simple function\n",
    "def greet_user():\n",
    "    \"\"\"Display a simple greeting.\"\"\"\n",
    "    print(\"Hello!\")\n",
    "    \n",
    "greet_user()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, jesse!\n"
     ]
    }
   ],
   "source": [
    "# Passing an argument\n",
    "def greet_user(username):\n",
    "    \"\"\"Display a personalized greeting.\"\"\"\n",
    "    print(\"Hello, \" + username + \"!\")\n",
    "    \n",
    "greet_user('jesse')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Have a bacon pizza!\n",
      "Have a pepperoni pizza!\n"
     ]
    }
   ],
   "source": [
    "# Default values for parameters\n",
    "def make_pizza(topping='bacon'):\n",
    "    \"\"\"Make a single-topping pizza.\"\"\"\n",
    "    print(\"Have a \" + topping + \" pizza!\")\n",
    "    \n",
    "make_pizza()\n",
    "make_pizza('pepperoni')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "# Returning a value\n",
    "def add_numbers(x, y):\n",
    "    \"\"\"Add two numbers and return the sum.\"\"\"\n",
    "    return x + y\n",
    "\n",
    "sum = add_numbers(3, 5)\n",
    "print(sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classes\n",
    "A class defines the behavior of an object and the kind of information an object can store. The information in a class is stored in attributes, and functions that belong to a class are called methods. A child class inherits the attributes and methods from its parent class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Peso is a great dog!\n",
      "Peso is sitting.\n"
     ]
    }
   ],
   "source": [
    "# Creating a dog class\n",
    "class Dog():\n",
    "    \"\"\"Represent a dog.\"\"\"\n",
    "    \n",
    "    def __init__(self, name):\n",
    "        \"\"\"Initialize dog object.\"\"\"\n",
    "        self.name = name\n",
    "        \n",
    "    def sit(self):\n",
    "        \"\"\"Simulate sitting.\"\"\"\n",
    "        print(self.name + \" is sitting.\")\n",
    "        \n",
    "my_dog = Dog('Peso')\n",
    "\n",
    "print(my_dog.name + \" is a great dog!\")\n",
    "my_dog.sit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Willie is a search dog.\n",
      "Willie is sitting.\n",
      "Willie is searching.\n"
     ]
    }
   ],
   "source": [
    "# Inheritance\n",
    "class SARDog(Dog):\n",
    "    \"\"\"Represent a search dog.\"\"\"\n",
    "    \n",
    "    def __init__(self, name):\n",
    "        \"\"\"Initialize the sardog.\"\"\"\n",
    "        super().__init__(name)\n",
    "        \n",
    "    def search(self):\n",
    "        \"\"\"Simulate searching.\"\"\"\n",
    "        print(self.name + \" is searching.\")\n",
    "        \n",
    "my_dog = SARDog('Willie')\n",
    "\n",
    "print(my_dog.name + \" is a search dog.\")\n",
    "my_dog.sit()\n",
    "my_dog.search()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Working with files\n",
    "our programs can read from files and write to files. Files are opened in read mode ('r') by default, but can also be opened in write mode ('w') and append mode ('a')."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is Line 1\n",
      "\n",
      "This is Line 2\n",
      "\n",
      "This is Line 3\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Reading a file and storing its lines\n",
    "filename = 'siddhartha.txt'\n",
    "with open(filename) as file_object:\n",
    "    lines = file_object.readlines()\n",
    "\n",
    "for line in lines:\n",
    "    print(line)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Writing to a file\n",
    "filename = 'journal.txt'\n",
    "with open(filename, 'w') as file_object:\n",
    "    file_object.write(\"I love programming.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Appending to a file\n",
    "filename = 'journal.txt'\n",
    "with open(filename, 'a') as file_object:\n",
    "    file_object.write(\"\\nI love making games.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exceptions\n",
    "Exceptions help you respond appropriately to errors that are likely to occur. You place code that might cause an error in the try block. Code that should run in response to an error goes in the except block. Code that should run only if the try block was successful goes in the else block."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "How many tickets do you need? two\n",
      "Please try again.\n"
     ]
    }
   ],
   "source": [
    "# Catching an exception\n",
    "prompt = \"How many tickets do you need? \"\n",
    "num_tickets = input(prompt)\n",
    "\n",
    "try:\n",
    "    num_tickets = int(num_tickets)\n",
    "except ValueError:\n",
    "    print(\"Please try again.\")\n",
    "else:\n",
    "    print(\"Your tickets are printing.\")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Infinite Skills\n",
    "\n",
    "If you had infinite programming skills, what would you build?\n",
    "\n",
    "As you're learning to program, it's helpful to think about the real-world projects you'd like to create. It's a good habit to keep an \"ideas\" notebook that you can refer to whenever you want to start a new project. If you haven't done so already, take a few minutes and describe three projects you'd like to create."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "##### Notebook created by [Sujeevan Nagarajah](https://github.com/sujee81)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}