Week_07.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating & Instantiating a Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# creating your first class\n",
    "\n",
    "class Car():\n",
    "    pass    # simply using as a placeholder until we add more code tomorrow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Car object at 0x000001EB5280AF28>\n"
     ]
    }
   ],
   "source": [
    "# instantiating an object from a class\n",
    "\n",
    "class Car():\n",
    "    pass\n",
    "\n",
    "ford = Car()   # creates an instance of the Car class and stores into the variable ford\n",
    "\n",
    "print(ford)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-9223371904966448019\n",
      "131888327786\n"
     ]
    }
   ],
   "source": [
    "# instantiating multiple objects from the same class\n",
    "\n",
    "class Car():\n",
    "    pass\n",
    "\n",
    "ford = Car()\n",
    "subaru = Car()    # creates another object from the car class\n",
    "\n",
    "print(hash(ford))\n",
    "print(hash(subaru))   # hash outputs a numerical representation of the location in memory for the variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Attributes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "red\n"
     ]
    }
   ],
   "source": [
    "# how to define a class attribute\n",
    "\n",
    "class Car():\n",
    "    sound = 'beep'   # all car objects will have this sound attribute and its' value\n",
    "    color = 'red'    # all car objects will have this color attribute and its' value\n",
    "\n",
    "ford = Car()\n",
    "\n",
    "print(ford.color)   # known as 'dot syntax'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "beep\n",
      "honk\n"
     ]
    }
   ],
   "source": [
    "# changing the value of an attribute\n",
    "\n",
    "class Car():\n",
    "    sound = 'beep'\n",
    "    color = 'red'\n",
    "    \n",
    "ford = Car()\n",
    "\n",
    "print(ford.sound)  # will output 'beep'\n",
    "\n",
    "ford.sound = 'honk'   # from now on the value of fords' sound is honk, this does not affect other instances\n",
    "\n",
    "print(ford.sound)   # will output 'honk'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "blue\n"
     ]
    }
   ],
   "source": [
    "# using the init method to give instances personalized attributes upon creation\n",
    "\n",
    "class Car():\n",
    "    def __init__(self, color):\n",
    "        self.color = color    # sets the attribute color to the value passed in\n",
    "        \n",
    "ford = Car('blue')   # instantiating a Car class with the color blue\n",
    "\n",
    "print(ford.color)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "blue 2016\n",
      "red 2018\n"
     ]
    }
   ],
   "source": [
    "# defining different values for multiple instances\n",
    "\n",
    "class Car():\n",
    "    def __init__(self, color, year):\n",
    "        self.color = color    # sets the attribute color to the value passed in\n",
    "        self.year = year\n",
    "        \n",
    "ford = Car('blue', 2016)   # create a car object with the color blue and year 2016\n",
    "subaru = Car('red', 2018)  # create a car object with the color red and year 2018\n",
    "\n",
    "print(ford.color, ford.year)\n",
    "print(subaru.color, subaru.year)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "beep\n",
      "beep blue\n"
     ]
    }
   ],
   "source": [
    "# using and accessing global class attributes\n",
    "\n",
    "class Car():\n",
    "    sound = 'beep'  # global attribute, accessible through the class itself\n",
    "    \n",
    "    def __init__(self, color):\n",
    "        self.color = 'blue'   # instance specific attribute, not accessible through the class itself\n",
    "        \n",
    "print(Car.sound)\n",
    "\n",
    "# print(Car.color)  will not work, as color is only available to instances of the Car class, not the class itself\n",
    "\n",
    "ford = Car('blue')\n",
    "\n",
    "print(ford.sound, ford.color)   # color will work as this is an instance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bark\n"
     ]
    }
   ],
   "source": [
    "# defining and calling our first class method\n",
    "\n",
    "class Dog():\n",
    "    def makeSound(self):\n",
    "        print('bark')\n",
    "        \n",
    "sam = Dog()\n",
    "\n",
    "sam.makeSound()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bark\n"
     ]
    }
   ],
   "source": [
    "# using the self keyword to access attributes within class methods\n",
    "\n",
    "class Dog():\n",
    "    sound = 'bark'\n",
    "    \n",
    "    def makeSound(self):\n",
    "        print(self.sound)   # self required to access attributes defined in the class\n",
    "        \n",
    "sam = Dog()\n",
    "\n",
    "sam.makeSound()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am a dog.\n",
      "bark\n"
     ]
    }
   ],
   "source": [
    "# understanding which methods are accessible via the class itself and class instances\n",
    "\n",
    "class Dog():\n",
    "    sound = 'bark'\n",
    "    \n",
    "    def makeSound(self):\n",
    "        print(self.sound)\n",
    "        \n",
    "    def printInfo():\n",
    "        print('I am a dog.')\n",
    "        \n",
    "Dog.printInfo()  # able to run printInfo method because it does not include self parameter\n",
    "\n",
    "# Dog.makeSound()  would produce error, self is in reference to instances only\n",
    "\n",
    "sam = Dog()\n",
    "\n",
    "sam.makeSound()  # able to access, self can reference the instance of sam\n",
    "\n",
    "# sam.printInfo()   will produce error, instances require the self parameter to access methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "# writing methods that accept parameters\n",
    "\n",
    "class Dog():\n",
    "    def showAge(self, age):\n",
    "        print(age)   # does not need self, age is referencing the parameter not an attribute\n",
    "        \n",
    "sam = Dog()\n",
    "\n",
    "sam.showAge(6)  # passing the integer 6 as an argument to the showAge method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sammi\n"
     ]
    }
   ],
   "source": [
    "# using methods to set or return attribute values, proper programming practice\n",
    "\n",
    "class Dog():\n",
    "    name = ''   # would normally use init method to declare, this is for testing purposes\n",
    "    \n",
    "    def setName(self, new_name):\n",
    "        self.name = new_name   # declares the new value for the name attribute\n",
    "        \n",
    "    def getName(self):\n",
    "        return self.name   # returns the value of the name attribute\n",
    "    \n",
    "sam = Dog()\n",
    "\n",
    "sam.setName('Sammi')\n",
    "\n",
    "print(sam.getName())   # prints the returned value of self.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "# incrementing/decrementing attribute values with methods, best programming practice\n",
    "\n",
    "class Dog():\n",
    "    age = 5\n",
    "    \n",
    "    def happyBirthday(self):\n",
    "        self.age += 1\n",
    "        \n",
    "sam = Dog()\n",
    "\n",
    "sam.happyBirthday()   # calls method to increment value by one\n",
    "\n",
    "print(sam.age)   # better practice use getters, this is for testing purposes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Puppy!\n"
     ]
    }
   ],
   "source": [
    "# calling a class method from another method\n",
    "\n",
    "class Dog():\n",
    "    age = 6\n",
    "    \n",
    "    def getAge(self):\n",
    "        return self.age\n",
    "    \n",
    "    def printInfo(self):\n",
    "        if self.getAge() < 10:    # need self to call other method for an instance\n",
    "            print('Puppy!')\n",
    "            \n",
    "sam = Dog()\n",
    "\n",
    "sam.printInfo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a dog class\n"
     ]
    }
   ],
   "source": [
    "# using magic methods\n",
    "\n",
    "class Dog():\n",
    "    def __str__(self):\n",
    "        return \"This is a dog class\"\n",
    "    \n",
    "sam = Dog()\n",
    "\n",
    "print(sam)   # will print the return of the string magic method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Inheritance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "roar\n"
     ]
    }
   ],
   "source": [
    "# inheriting a class and accessing the inherited method\n",
    "\n",
    "class Animal():\n",
    "    def makeSound(self):\n",
    "        print('roar')\n",
    "        \n",
    "class Dog(Animal):   # inheriting Animal class\n",
    "    species = 'Canine'\n",
    "    \n",
    "sam = Dog()\n",
    "\n",
    "sam.makeSound()   # accessible through inheritance\n",
    "\n",
    "lion = Animal()\n",
    "\n",
    "# lion.species  not accessible, inheritance does not work backwards"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Canine\n"
     ]
    }
   ],
   "source": [
    "# using the super() method to declare inherited attributes\n",
    "\n",
    "class Animal():\n",
    "    def __init__(self, species):\n",
    "        self.species = species\n",
    "        \n",
    "class Dog(Animal):\n",
    "    def __init__(self, species, name):\n",
    "        self.name = name\n",
    "        super().__init__(species)   # using super to declare the species attribute defined in Animal\n",
    "        \n",
    "sam = Dog('Canine', 'Sammi')\n",
    "\n",
    "print(sam.species)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bark\n",
      "roar\n"
     ]
    }
   ],
   "source": [
    "# overriding methods defined in the superclass\n",
    "\n",
    "class Animal():\n",
    "    def makeSound(self):\n",
    "        print('roar')\n",
    "        \n",
    "class Dog(Animal):\n",
    "    def makeSound(self):\n",
    "        print('bark')\n",
    "        \n",
    "sam, lion = Dog(), Animal()   # declaring multiple variables on a single line\n",
    "\n",
    "sam.makeSound()   # overriding will call the makeSound method in Dog\n",
    "\n",
    "lion.makeSound()   # no overriding occurs as Animal does not inherit anything"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9.8 Ford\n"
     ]
    }
   ],
   "source": [
    "# how to inherit multiple classes\n",
    "\n",
    "class Physics():\n",
    "    gravity = 9.8\n",
    "    \n",
    "class Automobile():\n",
    "    def __init__(self, make, model, year):\n",
    "        self.make, self.model, self.year = make, model, year   # declaring all attributes on one line\n",
    "        \n",
    "class Ford(Physics, Automobile):   # able to access Physics and Automobile attributes and methods\n",
    "    def __init__(self, model, year):\n",
    "        Automobile.__init__(self, \"Ford\", model, year)  # super does not work with multiple \n",
    "        \n",
    "truck = Ford(\"F-150\", 2018)\n",
    "\n",
    "print(truck.gravity, truck.make)   # output both attributes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Friday Project: Creating Blackjack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "c\n",
      "===========\n",
      "8 of Spades\n",
      "9 of Hearts\n",
      "Total = 17\n",
      "\n",
      "Dealer\n",
      "===========\n",
      "6 of Hearts\n",
      "K of Clubs\n",
      "5 of Hearts\n",
      "Total = 21\n",
      "Dealer has higher cards, you lose!\n"
     ]
    }
   ],
   "source": [
    "# import necessary functions\n",
    "from random import randint\n",
    "from IPython.display import clear_output\n",
    "\n",
    "# create the blackjack class, which will hold all game methods and attributes\n",
    "class Blackjack():\n",
    "    def __init__(self):\n",
    "        self.deck = []    # set to an empty list\n",
    "        self.suits = (\"Spades\", \"Hearts\", \"Diamonds\", \"Clubs\")\n",
    "        self.values = (2, 3, 4, 5, 6, 7, 8, 9, 10, 'J', 'Q', 'K', 'A')\n",
    "        \n",
    "    # create a method that creates a deck of 52 cards, each card should be a tuple with a value and suit\n",
    "    def makeDeck(self):\n",
    "        for suit in self.suits:\n",
    "            for value in self.values:\n",
    "                self.deck.append((value, suit))   # ex: (7, \"Hearts\")\n",
    "        \n",
    "    # method to pop a card from deck using a random index value\n",
    "    def pullCard(self):\n",
    "        return self.deck.pop(randint(0, len(self.deck) - 1))\n",
    "    \n",
    "# create a class for the dealer and player objects\n",
    "class Player():\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        self.hand = []\n",
    "        \n",
    "    # take in a tuple and append it to the hand\n",
    "    def addCard(self, card):\n",
    "        self.hand.append(card)\n",
    "        \n",
    "    # if not dealer's turn, then only show one of his cards, otherwise show all cards\n",
    "    def showHand(self, dealer_start=True):\n",
    "        print(\"\\n{}\".format(self.name))\n",
    "        print(\"===========\")\n",
    "        \n",
    "        for i in range(len(self.hand)):\n",
    "            if self.name == 'Dealer' and i == 0 and dealer_start:\n",
    "                print(\"- of -\")  # hide first card\n",
    "            else:\n",
    "                card = self.hand[i]\n",
    "                print(\"{} of {}\".format(card[0], card[1]))\n",
    "        print(\"Total = {}\".format(self.calcHand(dealer_start)))\n",
    "                \n",
    "    # if not dealer's turn then only give back total of second card\n",
    "    def calcHand(self, dealer_start=True):\n",
    "        total = 0\n",
    "        aces = 0   # calculate aces afterwards\n",
    "        card_values = {1:1, 2:2, 3:3, 4:4, 5:5, 6:6, 7:7, 8:8, 9:9, 10:10, 'J':10, 'Q':10, 'K':10, 'A':11}\n",
    "        \n",
    "        if self.name == 'Dealer' and dealer_start:\n",
    "            card = self.hand[1]\n",
    "            return card_values[card[0]]\n",
    "        \n",
    "        for card in self.hand:\n",
    "            if card[0] == 'A':\n",
    "                aces += 1\n",
    "            else:\n",
    "                total += card_values[card[0]]\n",
    "                \n",
    "        for i in range(aces):\n",
    "            if total + 11 > 21:\n",
    "                total += 1\n",
    "            else:\n",
    "                total += 11\n",
    "                \n",
    "        return total\n",
    "                \n",
    "game = Blackjack()\n",
    "game.makeDeck()\n",
    "\n",
    "name = input(\"What is your name?\")\n",
    "player = Player(name)\n",
    "dealer = Player(\"Dealer\")\n",
    "\n",
    "# add two cards to the dealer and player hand\n",
    "for i in range(2):\n",
    "    player.addCard(game.pullCard())\n",
    "    dealer.addCard(game.pullCard())\n",
    "    \n",
    "# show both hands using method\n",
    "player.showHand()\n",
    "dealer.showHand()\n",
    "    \n",
    "player_bust = False\n",
    "\n",
    "while input('Would you like to stay or hit?').lower() != 'stay':\n",
    "    clear_output()\n",
    "    \n",
    "    # pull card and put into player's hand\n",
    "    player.addCard(game.pullCard())\n",
    "    \n",
    "    # show both hands using method\n",
    "    player.showHand()\n",
    "    dealer.showHand()\n",
    "    \n",
    "    # check if over 21\n",
    "    if player.calcHand() > 21:\n",
    "        player_bust = True\n",
    "        break\n",
    "        \n",
    "# handling the dealer's turn, only run if player didn't bust\n",
    "dealer_bust = False\n",
    "\n",
    "if not player_bust:\n",
    "    while dealer.calcHand(False) < 17:\n",
    "        # pull card and put into player's hand\n",
    "        dealer.addCard(game.pullCard())\n",
    "\n",
    "        # check if over 21\n",
    "        if dealer.calcHand(False) > 21:\n",
    "            dealer_bust = True\n",
    "            break\n",
    "\n",
    "clear_output()\n",
    "\n",
    "# show both hands using method\n",
    "player.showHand()\n",
    "dealer.showHand(False)\n",
    "        \n",
    "# calculate a winner\n",
    "if player_bust:\n",
    "    print('You busted, better luck next time!')\n",
    "elif dealer_bust:\n",
    "    print('The dealer busted, you win!')\n",
    "elif dealer.calcHand(False) > player.calcHand():\n",
    "    print('Dealer has higher cards, you lose!')\n",
    "elif dealer.calcHand(False) < player.calcHand():\n",
    "    print('You beat the dealer! Congrats!')\n",
    "else:\n",
    "    print('You pushed, no one wins!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Monday Exercises - Answers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "1. <b>Animals:</b> Create a class called \"Animals\" and create two instances from it. Use two variables with names of \"lion\" and \"tiger\".\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Animals():\n",
    "    pass\n",
    "\n",
    "lion = Animals()\n",
    "tiger = Animals()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "2. <b>Problem Solving:</b> What's wrong with the code below?\n",
    "</p>\n",
    "\n",
    "<p>\n",
    ">>> class Bus: <br>\n",
    ">>>&nbsp;&nbsp;&nbsp;&nbsp;pass <br>\n",
    ">>> school_bus = Bus() <br>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# there's nothing wrong with this code, the parenthesis are optional after \"class Bus\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tuesday Exercises - Answers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "1. <b>Dogs:</b> Create a Dog class that has one global attribute and two instance level attributes. The global attribute should be \"species\" with a value of \"Canine\". The two instance attributes should be \"name\" and \"breed\". Then instantiate two dog objects, a Husky named Sammi, and a Chocolate Lab named Casey.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Canine'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Dog():\n",
    "    species = \"Canine\"\n",
    "    \n",
    "    def __init__(self, name, breed):\n",
    "        self.name = name\n",
    "        self.breed = breed\n",
    "        \n",
    "dog1 = Dog('Sammi', 'Husky')\n",
    "dog2 = Dog('Casey', 'Chocolate Lab')\n",
    "\n",
    "dog1.species"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "2. <b>User Input:</b> Create a Person class that has a single instance level attribute of \"name\". Ask the user to input their name and create an instance of the Person class with the name they typed in. Then print out their name.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What is your name? Connor\n",
      "Connor\n"
     ]
    }
   ],
   "source": [
    "class Person():\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "\n",
    "name = input('What is your name? ')\n",
    "\n",
    "p = Person(name)\n",
    "\n",
    "print(p.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Wednesday Exercises - Answers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "1. <b>Animals:</b> Create a class definition of an animal that has a species attribute and both a setter and getter to change or access the attributes' value. Create an instance called \"lion\" and call the setter method with an argument of \"feline\". Then print out the species by calling the getter method.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Feline'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Animal():\n",
    "    def __init__(self):\n",
    "        species = ''\n",
    "        \n",
    "    def setSpecies(self, species):\n",
    "        self.species = species\n",
    "        \n",
    "    def getSpecies(self):\n",
    "        return self.species\n",
    "    \n",
    "lion = Animal()\n",
    "\n",
    "lion.setSpecies('Feline')\n",
    "\n",
    "lion.getSpecies()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "2. <b>User Input:</b> Create a class Person, that takes in a name when instantiated, but sets an age to 0. Within the class definition setup, a setter and getter that will ask the user to input their age and set the age attribute to the value input. Then output the information in a formatted string as \"You are 64 years old.\" Assuming the user input 64 as their age.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "How old are you? 64\n",
      "You are 64 years old.\n"
     ]
    }
   ],
   "source": [
    "class Person():\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        self.age = 0\n",
    "        \n",
    "    def setAge(self, age):\n",
    "        self.age = age\n",
    "        \n",
    "    def getAge(self):\n",
    "        return self.age\n",
    "    \n",
    "p = Person('Kathy')\n",
    "\n",
    "num = input('How old are you? ')\n",
    "\n",
    "p.setAge(num)\n",
    "\n",
    "print('You are {} years old.'.format(p.getAge()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Thursday Exercises - Answers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "1. <b>Good Guys/Bad Guys:</b> Create three classes, a superclass called \"Characters\" that will be defined with the following attributes and methods: <br><br>\n",
    "a. Attributes: name, team, height, weight <br>\n",
    "b. Methods: sayHello <br><br>\n",
    "\n",
    "The sayHello method should output the statement \"Hello, my name is Max and I'm on the good guys.\". The team attribute should be declared to a string of either \"good\" or \"bad\". The other two classes, which will be subclasses, will be all the attributes that the superclass requires. The subclasses do not need any other methods or attributes. Instantiate one player on each team and call the sayHello method for each. The output should result in the following:\n",
    "</p>\n",
    "\n",
    "<p>\n",
    ">>> \"Hello, my name is Max and I'm on the good guys\" <br>\n",
    ">>> \"Hello, my name is Tony and I'm on the bad guys\" \n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, my name is Max and I'm on the good guys.\n",
      "Hello, my name is Tony and I'm on the bad guys.\n"
     ]
    }
   ],
   "source": [
    "class Characters():\n",
    "    def __init__(self, name, team, height, weight):\n",
    "        self.name = name\n",
    "        self.team = team\n",
    "        self.height = height\n",
    "        self.weight = weight\n",
    "        \n",
    "    def sayHello(self):\n",
    "        print(\"Hello, my name is {} and I'm on the {} guys.\".format(self.name, self.team))\n",
    "        \n",
    "class Good(Characters):\n",
    "    def __init__(self, name, height, weight):\n",
    "        super().__init__(name, 'good', height, weight)\n",
    "        \n",
    "class Bad(Characters):\n",
    "    def __init__(self, name, height, weight):\n",
    "        super().__init__(name, 'bad', height, weight)\n",
    "        \n",
    "\n",
    "char1 = Good('Max', '5\\'11\"', 183)\n",
    "char2 = Bad('Tony', '6\\'3\"', 201)\n",
    "\n",
    "char1.sayHello()\n",
    "char2.sayHello()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# End of Week Exercises - Answers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "1. <b>Game Loop:</b> Using the code from our Friday project, create a game loop so that you can continually play a new hand until the player decides to quit. The cell should only stop running if the player types in \"quit\", otherwise you should continue to play new hands.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import necessary functions\n",
    "from random import randint\n",
    "from IPython.display import clear_output\n",
    "\n",
    "# create the blackjack class, which will hold all game methods and attributes\n",
    "class Blackjack():\n",
    "    def __init__(self):\n",
    "        self.deck = []    # set to an empty list\n",
    "        self.suits = (\"Spades\", \"Hearts\", \"Diamonds\", \"Clubs\")\n",
    "        self.values = (2, 3, 4, 5, 6, 7, 8, 9, 10, 'J', 'Q', 'K', 'A')\n",
    "        \n",
    "    # create a method that creates a deck of 52 cards, each card should be a tuple with a value and suit\n",
    "    def makeDeck(self):\n",
    "        for suit in self.suits:\n",
    "            for value in self.values:\n",
    "                self.deck.append((value, suit))   # ex: (7, \"Hearts\")\n",
    "        \n",
    "    # method to pop a card from deck using a random index value\n",
    "    def pullCard(self):\n",
    "        return self.deck.pop(randint(0, len(self.deck) - 1))\n",
    "    \n",
    "# create a class for the dealer and player objects\n",
    "class Player():\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        self.hand = []\n",
    "        \n",
    "    # take in a tuple and append it to the hand\n",
    "    def addCard(self, card):\n",
    "        self.hand.append(card)\n",
    "        \n",
    "    # if not dealer's turn, then only show one of his cards, otherwise show all cards\n",
    "    def showHand(self, dealer_start=True):\n",
    "        print(\"\\n{}\".format(self.name))\n",
    "        print(\"===========\")\n",
    "        \n",
    "        for i in range(len(self.hand)):\n",
    "            if self.name == 'Dealer' and i == 0 and dealer_start:\n",
    "                print(\"- of -\")  # hide first card\n",
    "            else:\n",
    "                card = self.hand[i]\n",
    "                print(\"{} of {}\".format(card[0], card[1]))\n",
    "        print(\"Total = {}\".format(self.calcHand(dealer_start)))\n",
    "                \n",
    "    # if not dealer's turn then only give back total of second card\n",
    "    def calcHand(self, dealer_start=True):\n",
    "        total = 0\n",
    "        aces = 0   # calculate aces afterwards\n",
    "        card_values = {1:1, 2:2, 3:3, 4:4, 5:5, 6:6, 7:7, 8:8, 9:9, 10:10, 'J':10, 'Q':10, 'K':10, 'A':11}\n",
    "        \n",
    "        if self.name == 'Dealer' and dealer_start:\n",
    "            card = self.hand[1]\n",
    "            return card_values[card[0]]\n",
    "        \n",
    "        for card in self.hand:\n",
    "            if card[0] == 'A':\n",
    "                aces += 1\n",
    "            else:\n",
    "                total += card_values[card[0]]\n",
    "                \n",
    "        for i in range(aces):\n",
    "            if total + 11 > 21:\n",
    "                total += 1\n",
    "            else:\n",
    "                total += 11\n",
    "                \n",
    "        return total\n",
    "                \n",
    "game = Blackjack()\n",
    "game.makeDeck()\n",
    "\n",
    "name = input(\"What is your name?\")\n",
    "playing = True\n",
    "\n",
    "# start loop here\n",
    "while playing:\n",
    "    player = Player(name)\n",
    "    dealer = Player(\"Dealer\")\n",
    "\n",
    "    # add two cards to the dealer and player hand\n",
    "    for i in range(2):\n",
    "        player.addCard(game.pullCard())\n",
    "        dealer.addCard(game.pullCard())\n",
    "\n",
    "    # show both hands using method\n",
    "    player.showHand()\n",
    "    dealer.showHand()\n",
    "\n",
    "    player_bust = False\n",
    "\n",
    "    while input('Would you like to stay or hit?').lower() != 'stay':\n",
    "        clear_output()\n",
    "\n",
    "        # pull card and put into player's hand\n",
    "        player.addCard(game.pullCard())\n",
    "\n",
    "        # show both hands using method\n",
    "        player.showHand()\n",
    "        dealer.showHand()\n",
    "\n",
    "        # check if over 21\n",
    "        if player.calcHand() > 21:\n",
    "            player_bust = True\n",
    "            break\n",
    "\n",
    "    # handling the dealer's turn, only run if player didn't bust\n",
    "    dealer_bust = False\n",
    "\n",
    "    if not player_bust:\n",
    "        while dealer.calcHand(False) < 17:\n",
    "            # pull card and put into player's hand\n",
    "            dealer.addCard(game.pullCard())\n",
    "\n",
    "            # check if over 21\n",
    "            if dealer.calcHand(False) > 21:\n",
    "                dealer_bust = True\n",
    "                break\n",
    "\n",
    "    clear_output()\n",
    "\n",
    "    # show both hands using method\n",
    "    player.showHand()\n",
    "    dealer.showHand(False)\n",
    "\n",
    "    # calculate a winner\n",
    "    if player_bust:\n",
    "        print('You busted, better luck next time!')\n",
    "    elif dealer_bust:\n",
    "        print('The dealer busted, you win!')\n",
    "    elif dealer.calcHand(False) > player.calcHand():\n",
    "        print('Dealer has higher cards, you lose!')\n",
    "    elif dealer.calcHand(False) < player.calcHand():\n",
    "        print('You beat the dealer! Congrats!')\n",
    "    else:\n",
    "        print('You pushed, no one wins!')\n",
    "        \n",
    "    print('Type \"quit\" to stop playing...')\n",
    "    ans = input('Would you like to play again? ').lower()\n",
    "    \n",
    "    if ans == 'quit':\n",
    "        playing = False\n",
    "        \n",
    "    clear_output()\n",
    "    \n",
    "print('Thanks for playing!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "2. <b>Adding Currency:</b> Using the code from our Friday project, add the ability to wager currency in the game. Be sure to track the currency within the Player class, as the attribute should belong to that object. Before each hand, ask the user how much they would like to wager, if they win, add that amount to their currency, if they lose subtract that amount from what they currently have, and if they tie, nothing should happen.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Connor\n",
      "===========\n",
      "7 of Hearts\n",
      "8 of Spades\n",
      "Total = 15\n",
      "\n",
      "Dealer\n",
      "===========\n",
      "A of Diamonds\n",
      "4 of Spades\n",
      "Q of Diamonds\n",
      "J of Diamonds\n",
      "Total = 25\n",
      "The dealer busted, you win!\n",
      "You ended with $550.\n"
     ]
    }
   ],
   "source": [
    "# import necessary functions\n",
    "from random import randint\n",
    "from IPython.display import clear_output\n",
    "\n",
    "# create the blackjack class, which will hold all game methods and attributes\n",
    "class Blackjack():\n",
    "    def __init__(self):\n",
    "        self.deck = []    # set to an empty list\n",
    "        self.suits = (\"Spades\", \"Hearts\", \"Diamonds\", \"Clubs\")\n",
    "        self.values = (2, 3, 4, 5, 6, 7, 8, 9, 10, 'J', 'Q', 'K', 'A')\n",
    "        \n",
    "    # create a method that creates a deck of 52 cards, each card should be a tuple with a value and suit\n",
    "    def makeDeck(self):\n",
    "        for suit in self.suits:\n",
    "            for value in self.values:\n",
    "                self.deck.append((value, suit))   # ex: (7, \"Hearts\")\n",
    "        \n",
    "    # method to pop a card from deck using a random index value\n",
    "    def pullCard(self):\n",
    "        return self.deck.pop(randint(0, len(self.deck) - 1))\n",
    "    \n",
    "# create a class for the dealer and player objects\n",
    "class Player():\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        self.hand = []\n",
    "        self.currency = 500\n",
    "        \n",
    "    def getCurrency(self):\n",
    "        return self.currency\n",
    "        \n",
    "    def setCurrency(self, amount, won):\n",
    "        '''\n",
    "            Take in amount to be added or subtracted, the won parameter will \n",
    "            handle whether or not the player won and should be added or subtracted.\n",
    "        '''\n",
    "        if won:\n",
    "            self.currency += amount\n",
    "        elif not won:\n",
    "            self.currency -= amount\n",
    "            \n",
    "    # take in a tuple and append it to the hand\n",
    "    def addCard(self, card):\n",
    "        self.hand.append(card)\n",
    "        \n",
    "    # if not dealer's turn, then only show one of his cards, otherwise show all cards\n",
    "    def showHand(self, dealer_start=True):\n",
    "        print(\"\\n{}\".format(self.name))\n",
    "        print(\"===========\")\n",
    "        \n",
    "        for i in range(len(self.hand)):\n",
    "            if self.name == 'Dealer' and i == 0 and dealer_start:\n",
    "                print(\"- of -\")  # hide first card\n",
    "            else:\n",
    "                card = self.hand[i]\n",
    "                print(\"{} of {}\".format(card[0], card[1]))\n",
    "        print(\"Total = {}\".format(self.calcHand(dealer_start)))\n",
    "                \n",
    "    # if not dealer's turn then only give back total of second card\n",
    "    def calcHand(self, dealer_start=True):\n",
    "        total = 0\n",
    "        aces = 0   # calculate aces afterwards\n",
    "        card_values = {1:1, 2:2, 3:3, 4:4, 5:5, 6:6, 7:7, 8:8, 9:9, 10:10, 'J':10, 'Q':10, 'K':10, 'A':11}\n",
    "        \n",
    "        if self.name == 'Dealer' and dealer_start:\n",
    "            card = self.hand[1]\n",
    "            return card_values[card[0]]\n",
    "        \n",
    "        for card in self.hand:\n",
    "            if card[0] == 'A':\n",
    "                aces += 1\n",
    "            else:\n",
    "                total += card_values[card[0]]\n",
    "                \n",
    "        for i in range(aces):\n",
    "            if total + 11 > 21:\n",
    "                total += 1\n",
    "            else:\n",
    "                total += 11\n",
    "                \n",
    "        return total\n",
    "                \n",
    "game = Blackjack()\n",
    "game.makeDeck()\n",
    "\n",
    "name = input(\"What is your name?\")\n",
    "player = Player(name)\n",
    "dealer = Player(\"Dealer\")\n",
    "\n",
    "# ask player how much they want to wager\n",
    "wager = 0\n",
    "print('You have ${}.'.format(player.getCurrency()))\n",
    "\n",
    "while wager == 0 or player.getCurrency() - wager < 0:\n",
    "    # handle getting and converting wager\n",
    "    try:\n",
    "        wager = int(input(\"How much would you like to wager? \"))\n",
    "        \n",
    "        # if wager is too much print message\n",
    "        if player.getCurrency() - wager < 0:\n",
    "            print(\"Sorry you don't have that much money. Try again!\")\n",
    "    except:\n",
    "        print('Something went wrong, please try again!')\n",
    "\n",
    "# add two cards to the dealer and player hand\n",
    "for i in range(2):\n",
    "    player.addCard(game.pullCard())\n",
    "    dealer.addCard(game.pullCard())\n",
    "    \n",
    "# show both hands using method\n",
    "player.showHand()\n",
    "dealer.showHand()\n",
    "    \n",
    "player_bust = False\n",
    "\n",
    "while input('Would you like to stay or hit?').lower() != 'stay':\n",
    "    clear_output()\n",
    "    \n",
    "    # pull card and put into player's hand\n",
    "    player.addCard(game.pullCard())\n",
    "    \n",
    "    # show both hands using method\n",
    "    player.showHand()\n",
    "    dealer.showHand()\n",
    "    \n",
    "    # check if over 21\n",
    "    if player.calcHand() > 21:\n",
    "        player_bust = True\n",
    "        break\n",
    "        \n",
    "# handling the dealer's turn, only run if player didn't bust\n",
    "dealer_bust = False\n",
    "\n",
    "if not player_bust:\n",
    "    while dealer.calcHand(False) < 17:\n",
    "        # pull card and put into player's hand\n",
    "        dealer.addCard(game.pullCard())\n",
    "\n",
    "        # check if over 21\n",
    "        if dealer.calcHand(False) > 21:\n",
    "            dealer_bust = True\n",
    "            break\n",
    "\n",
    "clear_output()\n",
    "\n",
    "# show both hands using method\n",
    "player.showHand()\n",
    "dealer.showHand(False)\n",
    "        \n",
    "# calculate a winner\n",
    "if player_bust:\n",
    "    print('You busted, better luck next time!')\n",
    "    player.setCurrency(wager, False)\n",
    "elif dealer_bust:\n",
    "    print('The dealer busted, you win!')\n",
    "    player.setCurrency(wager, True)\n",
    "elif dealer.calcHand(False) > player.calcHand():\n",
    "    print('Dealer has higher cards, you lose!')\n",
    "    player.setCurrency(wager, False)\n",
    "elif dealer.calcHand(False) < player.calcHand():\n",
    "    print('You beat the dealer! Congrats!')\n",
    "    player.setCurrency(wager, True)\n",
    "else:\n",
    "    print('You pushed, no one wins!')\n",
    "    \n",
    "print('You ended with ${}.'.format(player.getCurrency()))"
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}