reading-journal-14.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Day 14 Reading Journal\n",
    "\n",
    "Read _Think Python_, [Chapter 18](http://www.greenteapress.com/thinkpython2/html/thinkpython2019.html)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Chapter 18](http://www.greenteapress.com/thinkpython2/html/thinkpython2019.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 in a text editor/at the command line and you are welcome to do so, but please paste your solutions back in the notebook for submission when you're done.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "is_question": true,
    "problem": "Exercise 18.3"
   },
   "source": [
    "### Exercise 2  \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`s."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "solution": "Exercise 18.3"
   },
   "outputs": [],
   "source": [
    "\"\"\"This module contains a code example related to\n",
    "\n",
    "Think Python, 2nd Edition\n",
    "by Allen Downey\n",
    "http://thinkpython2.com\n",
    "\n",
    "Copyright 2015 Allen Downey\n",
    "\n",
    "License: http://creativecommons.org/licenses/by/4.0/\n",
    "\"\"\"\n",
    "\n",
    "import random\n",
    "\n",
    "\n",
    "class Card:\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 '%s of %s' % (Card.rank_names[self.rank],\n",
    "                             Card.suit_names[self.suit])\n",
    "\n",
    "    def __eq__(self, other):\n",
    "        \"\"\"Checks whether self and other have the same rank and suit.\n",
    "\n",
    "        returns: boolean\n",
    "        \"\"\"\n",
    "        return self.suit == other.suit and self.rank == other.rank\n",
    "\n",
    "    def __lt__(self, other):\n",
    "        \"\"\"Compares this card to other, first by suit, then rank.\n",
    "\n",
    "        returns: boolean\n",
    "        \"\"\"\n",
    "        t1 = self.suit, self.rank\n",
    "        t2 = other.suit, other.rank\n",
    "        return t1 < t2\n",
    "\n",
    "\n",
    "class Deck:\n",
    "    \"\"\"Represents a deck of cards.\n",
    "\n",
    "    Attributes:\n",
    "      cards: list of Card objects.\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self):\n",
    "        \"\"\"Initializes the Deck with 52 cards.\n",
    "        \"\"\"\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",
    "        \"\"\"Returns a string representation of the deck.\n",
    "        \"\"\"\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",
    "\n",
    "        card: Card\n",
    "        \"\"\"\n",
    "        self.cards.append(card)\n",
    "\n",
    "    def remove_card(self, card):\n",
    "        \"\"\"Removes a card from the deck or raises exception if it is not there.\n",
    "        \n",
    "        card: Card\n",
    "        \"\"\"\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, cards_per_hand):\n",
    "        hand_list = []\n",
    "        for i in range(num_hands):\n",
    "            hand_list.append(Hand())\n",
    "            move_cards(hand_list[i], cards_per_hand)\n",
    "        return hand_list\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",
    "    deck = Deck()\n",
    "    deck.shuffle()\n",
    "\n",
    "    hand = Hand()\n",
    "    print(find_defining_class(hand, 'shuffle'))\n",
    "\n",
    "    deck.move_cards(hand, 5)\n",
    "    hand.sort()\n",
    "    print(hand)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "is_question": true,
    "problem": "Exercise 18.6"
   },
   "source": [
    "### (Optional) Going Beyond - Exercise 3 \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. Because this part is an optional Going Beyond secion, you can go as far as you like with this exercise.\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://thinkpython2.com/code/PokerHandSoln.py."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "solution": "Exercise 18.6"
   },
   "outputs": [],
   "source": [
    "from Card import Hand, Deck\n",
    "\n",
    "\n",
    "class PokerHand(Hand):\n",
    "    \"\"\"Represents a poker hand.\"\"\"\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_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",
    "\n",
    "if __name__ == '__main__':\n",
    "    # make a deck\n",
    "    deck = Deck()\n",
    "    deck.shuffle()\n",
    "\n",
    "    # deal the cards and classify the hands\n",
    "    for i in range(7):\n",
    "        hand = PokerHand()\n",
    "        deck.move_cards(hand, 7)\n",
    "        hand.sort()\n",
    "        print(hand)\n",
    "        print(hand.has_flush())\n",
    "        print('')\n"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Edit 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.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}