day12_reading_journal.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Day 12 Reading Journal\n",
    "\n",
    "This journal includes several required exercises, but it is meant to encourage active reading more generally.  You should use the journal to take detailed notes, catalog questions, and explore the content from Think Python deeply.\n",
    "\n",
    "Reading: Review Think Python Chapter 18\n",
    "\n",
    "**Due: Monday, March 7 ~~Thursday, March 3~~ at 12 noon**\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Chapter 18](http://www.greenteapress.com/thinkpython/html/thinkpython019.html)\n",
    "\n",
    "The exercises writing class methods in this chapter have a large amount of supporting code. It may be more natural for you to do your development at the command line and you are welcome to, but please paste your solutions back in the notebook when you're done.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "is_question": true,
    "problem": "Exercise 18.3"
   },
   "source": [
    "### Exercise 3  \n",
    "\n",
    "Write a `Deck` method called `deal_hands` that takes two parameters, the number of hands and the number of cards per hand, and that creates new `Hand` objects, deals the appropriate number of cards per hand, and returns a list of `Hand` objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "solution": "Exercise 18.3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'shuffle' is a method of <class '__main__.Deck'>\n",
      "Hand 0:\n",
      "Ace of Clubs\n",
      "9 of Clubs\n",
      "Jack of Diamonds\n",
      "9 of Hearts\n",
      "King of Hearts\n",
      "Hand 1:\n",
      "10 of Clubs\n",
      "9 of Diamonds\n",
      "Jack of Hearts\n",
      "2 of Spades\n",
      "3 of Spades\n",
      "Hand 2:\n",
      "Ace of Diamonds\n",
      "7 of Diamonds\n",
      "3 of Hearts\n",
      "4 of Hearts\n",
      "8 of Spades\n",
      "Hand 3:\n",
      "6 of Clubs\n",
      "7 of Clubs\n",
      "Jack of Clubs\n",
      "6 of Diamonds\n",
      "7 of Hearts\n"
     ]
    }
   ],
   "source": [
    "\"\"\"This module contains code from\n",
    "Think Python by Allen B. Downey\n",
    "http://thinkpython.com\n",
    "\n",
    "Copyright 2012 Allen B. Downey\n",
    "License: GNU GPLv3 http://www.gnu.org/licenses/gpl.html\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "import random\n",
    "\n",
    "\n",
    "class Card(object):\n",
    "    \"\"\"Represents a standard playing card.\n",
    "    \n",
    "    Attributes:\n",
    "      suit: integer 0-3\n",
    "      rank: integer 1-13\n",
    "    \"\"\"\n",
    "\n",
    "    suit_names = [\"Clubs\", \"Diamonds\", \"Hearts\", \"Spades\"]\n",
    "    rank_names = [None, \"Ace\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \n",
    "              \"8\", \"9\", \"10\", \"Jack\", \"Queen\", \"King\"]\n",
    "\n",
    "    def __init__(self, suit=0, rank=2):\n",
    "        self.suit = suit\n",
    "        self.rank = rank\n",
    "\n",
    "    def __str__(self):\n",
    "        \"\"\"Returns a human-readable string representation.\"\"\"\n",
    "        return \"{0} of {1}\".format(Card.rank_names[self.rank],\n",
    "                                   Card.suit_names[self.suit])\n",
    "\n",
    "    def __cmp__(self, other):\n",
    "        \"\"\"Compares this card to other, first by suit, then rank.\n",
    "\n",
    "        Returns a positive number if this > other; negative if other > this;\n",
    "        and 0 if they are equivalent.\n",
    "        \"\"\"\n",
    "        t1 = self.suit, self.rank\n",
    "        t2 = other.suit, other.rank\n",
    "        return cmp(t1, t2)\n",
    "\n",
    "\n",
    "class Deck(object):\n",
    "    \"\"\"Represents a deck of cards.\n",
    "\n",
    "    Attributes:\n",
    "      cards: list of Card objects.\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self):\n",
    "        self.cards = []\n",
    "        for suit in range(4):\n",
    "            for rank in range(1, 14):\n",
    "                card = Card(suit, rank)\n",
    "                self.cards.append(card)\n",
    "\n",
    "    def __str__(self):\n",
    "        res = []\n",
    "        for card in self.cards:\n",
    "            res.append(str(card))\n",
    "        return '\\n'.join(res)\n",
    "\n",
    "    def add_card(self, card):\n",
    "        \"\"\"Adds a card to the deck.\"\"\"\n",
    "        self.cards.append(card)\n",
    "\n",
    "    def remove_card(self, card):\n",
    "        \"\"\"Removes a card from the deck.\"\"\"\n",
    "        self.cards.remove(card)\n",
    "\n",
    "    def pop_card(self, i=-1):\n",
    "        \"\"\"Removes and returns a card from the deck.\n",
    "\n",
    "        i: index of the card to pop; by default, pops the last card.\n",
    "        \"\"\"\n",
    "        return self.cards.pop(i)\n",
    "\n",
    "    def shuffle(self):\n",
    "        \"\"\"Shuffles the cards in this deck.\"\"\"\n",
    "        random.shuffle(self.cards)\n",
    "\n",
    "    def sort(self):\n",
    "        \"\"\"Sorts the cards in ascending order.\"\"\"\n",
    "        self.cards.sort()\n",
    "\n",
    "    def move_cards(self, hand, num):\n",
    "        \"\"\"Moves the given number of cards from the deck into the Hand.\n",
    "\n",
    "        hand: destination Hand object\n",
    "        num: integer number of cards to move\n",
    "        \"\"\"\n",
    "        for i in range(num):\n",
    "            hand.add_card(self.pop_card())\n",
    "    \n",
    "    def deal_hands(self, num_hands, num_cards):\n",
    "        \"\"\"Return a list of new Hand objects dealt from the Deck.\n",
    "        \n",
    "        num_hands: number of Hands to return\n",
    "        num_cards: number of Cards per Hand\n",
    "        \"\"\"\n",
    "        hands=[]\n",
    "        for current_hand in range(num_hands):\n",
    "            hand= Hand()\n",
    "            self.move_cards(hand, num_cards)\n",
    "            hands.append(hand)\n",
    "        return hands\n",
    "\n",
    "\n",
    "class Hand(Deck):\n",
    "    \"\"\"Represents a hand of playing cards.\"\"\"\n",
    "    \n",
    "    def __init__(self, label=''):\n",
    "        self.cards = []\n",
    "        self.label = label\n",
    "\n",
    "\n",
    "def find_defining_class(obj, method_name):\n",
    "    \"\"\"Finds and returns the class object that will provide \n",
    "    the definition of method_name (as a string) if it is\n",
    "    invoked on obj.\n",
    "\n",
    "    obj: any python object\n",
    "    method_name: string method name\n",
    "    \"\"\"\n",
    "    for ty in type(obj).mro():\n",
    "        if method_name in ty.__dict__:\n",
    "            return ty\n",
    "    return None\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    # Example of using find_defining_class to probe object inheritance\n",
    "    test_hand = Hand()\n",
    "    print \"'shuffle' is a method of\", find_defining_class(test_hand, 'shuffle')\n",
    "\n",
    "    # TODO: The following test code won't fully work until you define the deal_hands Deck method\n",
    "    deck = Deck()\n",
    "    deck.shuffle()\n",
    "    hands = deck.deal_hands(4, 5)\n",
    "    for i, hand in enumerate(hands):\n",
    "        print \"Hand {}:\".format(i)\n",
    "        hand.sort()\n",
    "        print hand"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "is_question": true,
    "problem": "Exercise 18.6"
   },
   "source": [
    "### Exercise 6  \n",
    "\n",
    "**Note:** Jupyter notebooks can access code in other cells, so as long as you have run the cell above then the `PokerHand` class above will be able to reference your previous definition of the `Hand` class.\n",
    "\n",
    "\n",
    "The following are the possible hands in poker, in increasing order of value (and decreasing order of probability):\n",
    "\n",
    " 1. **pair:** two cards with the same rank \n",
    " 2. **two pair:** two pairs of cards with the same rank \n",
    " 3. **three of a kind:** three cards with the same rank \n",
    " 4. **straight:** five cards with ranks in sequence (aces can be high or low, so Ace-2-3-4-5 is a straight and so is 10-Jack-Queen-King-Ace, but Queen-King-Ace-2-3 is not.) \n",
    " 5. **flush:** five cards with the same suit \n",
    " 6. **full house:** three cards with one rank, two cards with another \n",
    " 7. **four of a kind:** four cards with the same rank \n",
    " 8. **straight flush:** five cards in sequence (as defined above) and with the same suit \n",
    "\n",
    "The goal of these exercises is to estimate the probability of drawing these various hands. You can go as far as you like with this exercise, but you should at least attempt parts 2 and 3.\n",
    "\n",
    " 1. If you run the code below, it deals seven 7-card poker hands and checks to see if any of them contains a flush. Read this code carefully before you go on.\n",
    " 2. Add methods to `PokerHand` named `has_pair`, `has_twopair`, etc. that return `True` or `False` according to whether or not the hand meets the relevant criteria. Your code should work correctly for “hands” that contain any number of cards (although 5 and 7 are the most common sizes).\n",
    " 3. Write a method named `classify` that figures out the highest-value classification for a hand and sets the label attribute accordingly. For example, a 7-card hand might contain a flush and a pair; it should be labeled “flush”.\n",
    " 4. When you are convinced that your classification methods are working, the next step is to estimate the probabilities of the various hands. Write a function below that shuffles a deck of cards, divides it into hands, classifies the hands, and counts the number of times various classifications appear.\n",
    " 5. Print a table of the classifications and their probabilities. Run your program with larger and larger numbers of hands until the output values converge to a reasonable degree of accuracy. Compare your results to the values at http://en.wikipedia.org/wiki/Hand_rankings.\n",
    "\n",
    "Allen's solution: http://thinkpython.com/code/PokerHandSoln.py. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "collapsed": false,
    "solution": "Exercise 18.6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Trial 0, Class straight_flush:\n",
      "Ace of Clubs\n",
      "5 of Clubs\n",
      "8 of Clubs\n",
      "2 of Diamonds\n",
      "Ace of Hearts\n",
      "9 of Hearts\n",
      "King of Hearts\n",
      "Contains pair? True\n",
      "Contains two pairs? False\n",
      "Contains three of a kind? False\n",
      "Contains flush? False\n",
      "Contains straight? False\n",
      "Contains full house? False\n",
      "Contains four of a kind? False\n",
      "\n",
      "Trial 1, Class straight_flush:\n",
      "3 of Clubs\n",
      "3 of Diamonds\n",
      "7 of Diamonds\n",
      "6 of Hearts\n",
      "7 of Hearts\n",
      "Queen of Spades\n",
      "King of Spades\n",
      "Contains pair? True\n",
      "Contains two pairs? True\n",
      "Contains three of a kind? False\n",
      "Contains flush? False\n",
      "Contains straight? False\n",
      "Contains full house? False\n",
      "Contains four of a kind? False\n",
      "\n",
      "Trial 2, Class straight_flush:\n",
      "2 of Clubs\n",
      "6 of Clubs\n",
      "7 of Clubs\n",
      "10 of Clubs\n",
      "5 of Diamonds\n",
      "3 of Hearts\n",
      "7 of Spades\n",
      "Contains pair? True\n",
      "Contains two pairs? False\n",
      "Contains three of a kind? False\n",
      "Contains flush? False\n",
      "Contains straight? False\n",
      "Contains full house? False\n",
      "Contains four of a kind? False\n",
      "\n",
      "Trial 3, Class straight_flush:\n",
      "Ace of Diamonds\n",
      "9 of Diamonds\n",
      "10 of Diamonds\n",
      "4 of Hearts\n",
      "Queen of Hearts\n",
      "5 of Spades\n",
      "Jack of Spades\n",
      "Contains pair? False\n",
      "Contains two pairs? False\n",
      "Contains three of a kind? False\n",
      "Contains flush? False\n",
      "Contains straight? False\n",
      "Contains full house? False\n",
      "Contains four of a kind? False\n",
      "\n",
      "Trial 4, Class straight_flush:\n",
      "4 of Diamonds\n",
      "8 of Diamonds\n",
      "5 of Hearts\n",
      "8 of Hearts\n",
      "Jack of Hearts\n",
      "Ace of Spades\n",
      "2 of Spades\n",
      "Contains pair? True\n",
      "Contains two pairs? False\n",
      "Contains three of a kind? False\n",
      "Contains flush? False\n",
      "Contains straight? False\n",
      "Contains full house? False\n",
      "Contains four of a kind? False\n",
      "\n",
      "Trial 5, Class straight_flush:\n",
      "4 of Clubs\n",
      "9 of Clubs\n",
      "Jack of Diamonds\n",
      "10 of Hearts\n",
      "3 of Spades\n",
      "8 of Spades\n",
      "9 of Spades\n",
      "Contains pair? True\n",
      "Contains two pairs? False\n",
      "Contains three of a kind? False\n",
      "Contains flush? False\n",
      "Contains straight? False\n",
      "Contains full house? False\n",
      "Contains four of a kind? False\n",
      "\n",
      "Trial 6, Class straight_flush:\n",
      "Queen of Clubs\n",
      "King of Clubs\n",
      "6 of Diamonds\n",
      "Queen of Diamonds\n",
      "King of Diamonds\n",
      "4 of Spades\n",
      "10 of Spades\n",
      "Contains pair? True\n",
      "Contains two pairs? True\n",
      "Contains three of a kind? False\n",
      "Contains flush? False\n",
      "Contains straight? False\n",
      "Contains full house? False\n",
      "Contains four of a kind? False\n",
      "\n"
     ]
    }
   ],
   "source": [
    "\n",
    "class PokerHand(Hand):\n",
    "\n",
    "    def ranks_hist(self):\n",
    "        \"\"\"Builds a histogram of the ranks that appear in the hand.\n",
    "        \n",
    "        Stores the results in attribute ranks.\"\"\"\n",
    "        self.ranks={}\n",
    "        for card in self.cards:\n",
    "            self.ranks[card.rank]= self.ranks.get(card.rank,0) +1\n",
    "    \n",
    "    def suit_hist(self):\n",
    "        \"\"\"Builds a histogram of the suits that appear in the hand.\n",
    "\n",
    "        Stores the result in attribute suits.\n",
    "        \"\"\"\n",
    "        self.suits = {}\n",
    "        for card in self.cards:\n",
    "            self.suits[card.suit] = self.suits.get(card.suit, 0) + 1\n",
    "            \n",
    "    def has_pair(self):\n",
    "        \"\"\"Returns True if the hand has a pair, False if otherwise.\"\"\"\n",
    "        self.ranks_hist()\n",
    "        for val in self.ranks.values():\n",
    "            if val>=2:\n",
    "                return True\n",
    "        return False \n",
    "    \n",
    "    def has_twopair(self):\n",
    "        \"\"\"Returns Trus if the hand has a pair, False if otherwise.\"\"\"\n",
    "        self.ranks_hist()\n",
    "        counter= 0\n",
    "        for val in self.ranks.values():\n",
    "            if val ==2:\n",
    "                counter+=1\n",
    "        if counter>=2:\n",
    "            return True\n",
    "        return False \n",
    "    \n",
    "    def has_three_of_a_kind(self):\n",
    "        \"\"\"Returns True if the hand a three of a kind, False if otherwise.\"\"\"\n",
    "        self.ranks_hist()\n",
    "        for val in self.ranks.values():\n",
    "            if val== 3:\n",
    "                return True\n",
    "        return False    \n",
    "        \n",
    "    def has_straight(self):   \n",
    "        \"\"\"Returns True if the hand has a straight, False if otherwise.\"\"\"\n",
    "        self.ranks_hist()\n",
    "        card_ranks=[]\n",
    "        for key in self.ranks.keys():\n",
    "            card_ranks.append(key)\n",
    "        card_ranks.sort()\n",
    "        \n",
    "        if card_ranks[0]==1:\n",
    "            card_ranks.append(14)\n",
    "        i=0\n",
    "        count=0\n",
    "        while i<len(card_ranks)-1:\n",
    "            if card_ranks[i]== card_ranks[i+1]-1:\n",
    "                i+=1\n",
    "                count+=1\n",
    "                if count==5:\n",
    "                    return True\n",
    "            else:\n",
    "                count=0\n",
    "                i+=1\n",
    "        return False                  \n",
    "            \n",
    "    def has_flush(self):\n",
    "        \"\"\"Returns True if the hand has a flush, False otherwise.\n",
    "      \n",
    "        Note that this works correctly for hands with more than 5 cards.\n",
    "        \"\"\"\n",
    "        self.suit_hist()\n",
    "        for val in self.suits.values():\n",
    "            if val >= 5:\n",
    "                return True\n",
    "        return False\n",
    "    \n",
    "    def has_full_house(self):\n",
    "        \"\"\"Returns True if the hand has a full house, False if otherwise.\"\"\"\n",
    "        if self.has_pair() and self.has_three_of_a_kind():\n",
    "            return True\n",
    "        return False            \n",
    "        \n",
    "    def has_four_of_a_kind(self):\n",
    "        \"\"\"Returns True if the hand has four of a kind, False if otherwise.\"\"\"\n",
    "        self.ranks_hist()\n",
    "        for val in self.ranks.values():\n",
    "            if val==4:\n",
    "                return True  \n",
    "        return False    \n",
    "            \n",
    "    def has_straight_flush(self): \n",
    "        \"\"\"Returns True if the hand has a straight flush, False if otherwise.\"\"\"\n",
    "        #I know this is wrong.  The other idea I had was really complicated and required creating 4 new dictionaries.\n",
    "        if self.has_flush and self.has_straight:\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "\n",
    "    def classify(self):\n",
    "        \"\"\"figures out the highest-value classification for a hand and sets the label attribute accordingly\"\"\"\n",
    "        if self.has_straight_flush():\n",
    "            self.label= 'straight_flush'\n",
    "            return 'straight_flush'\n",
    "        if self.has_four_of_a_kind():\n",
    "            self.label= 'four of a kind'\n",
    "            return 'four of a kind'\n",
    "        if self.has_full_house():\n",
    "            self.label= 'full house'\n",
    "            return 'full house'\n",
    "        if self.has_straight():\n",
    "            self.lable= 'straight'\n",
    "            return 'straight'\n",
    "        if self.has_three_of_a_kind():\n",
    "            self.label= 'three of a kind'\n",
    "            return 'three of a kind'\n",
    "        if self.has_twopair():\n",
    "            self.label='two pairs'\n",
    "            return 'two pairs'\n",
    "        if self.has_pair():\n",
    "            self.label= 'pair'\n",
    "            return 'pair'   \n",
    "\n",
    "if __name__ == '__main__':\n",
    "    # Create a new Deck\n",
    "    deck = Deck()\n",
    "    deck.shuffle()\n",
    "\n",
    "    # Deal the cards and classify the hands. You'll need to add more tests as you create methods\n",
    "    for i in range(7):\n",
    "        print \"Trial {}, Class {}:\".format(i, hand.classify())\n",
    "#         print \"Trial {}:\".format(i)\n",
    "        hand = PokerHand()\n",
    "        deck.move_cards(hand, 7)  \n",
    "#         # Note: Why aren't we using the deal_hands Deck method you wrote? How could we modify it so that we _could_ use it?\n",
    "        hand.sort()\n",
    "        print hand\n",
    "        print \"Contains pair?\", hand.has_pair()\n",
    "        print \"Contains two pairs?\", hand.has_twopair()\n",
    "        print \"Contains three of a kind?\", hand.has_three_of_a_kind()\n",
    "        print \"Contains flush?\", hand.has_flush()\n",
    "        print \"Contains straight?\", hand.has_straight()\n",
    "        print \"Contains full house?\", hand.has_full_house()\n",
    "        print \"Contains four of a kind?\", hand.has_four_of_a_kind()        \n",
    "        print ''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "is_poll": true,
    "is_question": true,
    "problem": "Time spent"
   },
   "source": [
    "## Quick poll\n",
    "About how long did you spend working on this Reading Journal?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "poll_response": true,
    "solution": "Time spent"
   },
   "source": [
    "5.5 hours\n",
    "\n",
    "a few parts became huge timesinks.  they're still not perfect, but I have to move on to my other work now."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "is_question": true,
    "problem": "Feedback"
   },
   "source": [
    "## Reading Journal feedback\n",
    "\n",
    "Have any comments on this Reading Journal? Feel free to leave them below and we'll read them when you submit your journal entry. This could include suggestions to improve the exercises, topics you'd like to see covered in class next time, or other feedback.\n",
    "\n",
    "If you have Python questions or run into problems while completing the reading, you should post them to Piazza instead so you can get a quick response before your journal is submitted."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "feedback_response": true,
    "solution": "Feedback"
   },
   "source": [
    " "
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Edit Metadata",
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}