7-2_OOP_inheritance.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Lecture 7-1\n",
    "\n",
    "# Classes and Inheritance\n",
    "\n",
    "## Week 7 Friday\n",
    "\n",
    "## Miles Chen, PhD\n",
    "\n",
    "Taken directly from Chapter 18 of Think Python by Allen B Downey"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Inheritance\n",
    "\n",
    "**Inheritance** is the ability to define a new class that is a modified version of an existing class.\n",
    "\n",
    "In this chapter, we will demonstrate inheritance using classes to represent playing cards, decks of cards, and poker hands.\n",
    "\n",
    "https://en.wikipedia.org/wiki/List_of_poker_hands"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Card objects\n",
    "\n",
    "There are 52 cards in a deck.\n",
    "\n",
    "There are 4 suits: Spades, Hearts, Diamonds, and Clubs (descending order in bridge).\n",
    "\n",
    "Each suit has 13 ranks: Ace, 2, 3, 4, 5, 6, 7, 8, 9, 10, Jack, Queen, King.\n",
    "\n",
    "If we define a new object to represent a playing card, the attributes will be `rank` and `suit`.\n",
    "\n",
    "How we should store the attributes is not obvious. If we use strings, it will not be easy to compare cards to see which has a higher rank or suit.\n",
    "\n",
    "Another option is to use integers to *encode* the ranks and suits. For example, we use the following for the suits:\n",
    "\n",
    "+ spades: 3\n",
    "+ hearts: 2\n",
    "+ diamonds: 1\n",
    "+ clubs: 0\n",
    "\n",
    "For the ranks, we'll use the numeric value, with Jacks: 11, Queens: 12, Kings: 13"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Card:\n",
    "    \"\"\"Represents a standard playing card.\"\"\"\n",
    "    \n",
    "    def __init__(self, suit = 0, rank = 2):\n",
    "        self.suit = suit\n",
    "        self.rank = rank"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The default card would be a two of Clubs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "queen_of_diamonds = Card(1, 12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "We also want the card objects to be read easily by humans.\n",
    "\n",
    "So we need a way to go from the integer codes back to suits and ranks.\n",
    "\n",
    "We'll do this by creating a list of names and then defining the `__str__` method to represent the card."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Card:\n",
    "    def __init__(self, suit = 0, rank = 2):\n",
    "        self.suit = suit\n",
    "        self.rank = rank\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 __str__(self):\n",
    "        return \"{:s} of {:s}\".format(Card.rank_names[self.rank],\n",
    "                             Card.suit_names[self.suit])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Variables like `suit_names` and `rank_names`, which are defined inside a class but outside of any method, are called **class attributes** because they are associated with the class object `Card`. Note that in their definition, `suit_names` and `rank_names` are not preceeded by `self`.\n",
    "\n",
    "This term distinguishes them from variables like `suit` and `rank`, which are called **instance attributes** because they are associated with a particular instance. These attributes are preceeded by `self` \n",
    "\n",
    "If we create multiple cards, every card has its own `suit` and `rank` but there is only copy of `suit_names` and `rank_names`.\n",
    "\n",
    "The first value (index zero) in `rank_names` is `None` because there is no card with a rank zero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jack of Hearts\n"
     ]
    }
   ],
   "source": [
    "card1 = Card(2, 11)\n",
    "print(card1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ace of Diamonds\n"
     ]
    }
   ],
   "source": [
    "card1 = Card(1, 1)\n",
    "print(card1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6 of Spades\n"
     ]
    }
   ],
   "source": [
    "card1 = Card(3, 6)\n",
    "print(card1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Comparing Cards\n",
    "\n",
    "For built-in types, we can use relational operators like >, <, == that compare values and determine when one is greater than, less than, or equal to another.\n",
    "\n",
    "For our own defined classes, we can use a special method `__lt__` which stands for 'less than'. Similarly, there is another dunder method `__eq__` that can be used to test equality.\n",
    "\n",
    "We'll arbitrarily choose to rank suits as more important, so all of the Spades will outrank all of the Diamonds.\n",
    "\n",
    "To perform the comparison, we'll use tuple comparison"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Card:\n",
    "    def __init__(self, suit = 0, rank = 2):\n",
    "        self.suit = suit\n",
    "        self.rank = rank\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 __str__(self):\n",
    "        return \"{:s} of {:s}\".format(Card.rank_names[self.rank],\n",
    "                             Card.suit_names[self.suit])\n",
    "    \n",
    "    def __lt__(self, other):\n",
    "        t1 = self.suit, self.rank\n",
    "        t2 = other.suit, other.rank\n",
    "        return t1 < t2\n",
    "    \n",
    "    def __eq__(self, other):\n",
    "        t1 = self.suit, self.rank\n",
    "        t2 = other.suit, other.rank\n",
    "        return t1 == t2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Queen of Diamonds\n"
     ]
    }
   ],
   "source": [
    "card1 = Card(1, 12)\n",
    "print(card1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jack of Hearts\n"
     ]
    }
   ],
   "source": [
    "card2 = Card(2, 11)\n",
    "print(card2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# diamonds are ranked lower than Hearts\n",
    "card1 < card2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Queen of Hearts\n"
     ]
    }
   ],
   "source": [
    "card3 = Card(2, 12)\n",
    "print(card3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "card3 < card2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "card4 = Card(1, 12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Queen of Diamonds\n"
     ]
    }
   ],
   "source": [
    "print(card1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Queen of Diamonds\n"
     ]
    }
   ],
   "source": [
    "print(card4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "card1 == card4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Queen of Hearts\n"
     ]
    }
   ],
   "source": [
    "print(card3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "card1 == card3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Building a Deck\n",
    "\n",
    "Now that we have Cards, the next step is to define Decks. Since a deck is made up of cards, it is natural for each Deck to contain a list of cards as an attribute.\n",
    "\n",
    "The following is a class definition for Deck. The `__init__` method creates the attribute cards and generates the standard set of fifty-two cards.\n",
    "\n",
    "The `__str__` method builds a list of the string representation of cards and uses the string method `join`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Deck:\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",
    "    def __str__(self):\n",
    "        res = []\n",
    "        for card in self.cards:\n",
    "            res.append(str(card))\n",
    "        return '\\n'.join(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "deck = Deck()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ace of Clubs\n",
      "2 of Clubs\n",
      "3 of Clubs\n",
      "4 of Clubs\n",
      "5 of Clubs\n",
      "6 of Clubs\n",
      "7 of Clubs\n",
      "8 of Clubs\n",
      "9 of Clubs\n",
      "10 of Clubs\n",
      "Jack of Clubs\n",
      "Queen of Clubs\n",
      "King of Clubs\n",
      "Ace of Diamonds\n",
      "2 of Diamonds\n",
      "3 of Diamonds\n",
      "4 of Diamonds\n",
      "5 of Diamonds\n",
      "6 of Diamonds\n",
      "7 of Diamonds\n",
      "8 of Diamonds\n",
      "9 of Diamonds\n",
      "10 of Diamonds\n",
      "Jack of Diamonds\n",
      "Queen of Diamonds\n",
      "King of Diamonds\n",
      "Ace of Hearts\n",
      "2 of Hearts\n",
      "3 of Hearts\n",
      "4 of Hearts\n",
      "5 of Hearts\n",
      "6 of Hearts\n",
      "7 of Hearts\n",
      "8 of Hearts\n",
      "9 of Hearts\n",
      "10 of Hearts\n",
      "Jack of Hearts\n",
      "Queen of Hearts\n",
      "King of Hearts\n",
      "Ace of Spades\n",
      "2 of Spades\n",
      "3 of Spades\n",
      "4 of Spades\n",
      "5 of Spades\n",
      "6 of Spades\n",
      "7 of Spades\n",
      "8 of Spades\n",
      "9 of Spades\n",
      "10 of Spades\n",
      "Jack of Spades\n",
      "Queen of Spades\n",
      "King of Spades\n"
     ]
    }
   ],
   "source": [
    "print(deck)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Add, remove, shuffle, and sort\n",
    "\n",
    "To deal cards, we can create a method that removes a card from the deck and returns it. We can use define the following method inside the class:\n",
    "\n",
    "~~~\n",
    "    def pop_card(self):\n",
    "        return self.cards.pop()\n",
    "~~~\n",
    "\n",
    "To add a card, we can use the list method `append`\n",
    "\n",
    "~~~\n",
    "    def add_card(self, card):\n",
    "        self.cards.append(card)\n",
    "~~~\n",
    "\n",
    "We can also add a `shuffle` method to mix the cards\n",
    "\n",
    "~~~\n",
    "    def shuffle(self):\n",
    "        random.shuffle(self.cards)\n",
    "~~~\n",
    "\n",
    "Because we have defined the method `__lt__` for the cards, we can perform `sort` operations to sort the cards\n",
    "\n",
    "~~~\n",
    "    def sort(self):\n",
    "        self.cards.sort()\n",
    "~~~"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "class Deck:\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",
    "    def __str__(self):\n",
    "        res = []\n",
    "        for card in self.cards:\n",
    "            res.append(str(card))\n",
    "        return '\\n'.join(res)\n",
    "    \n",
    "    def pop_card(self):\n",
    "        return self.cards.pop()\n",
    "    \n",
    "    def add_card(self, card):\n",
    "        self.cards.append(card)\n",
    "    \n",
    "    def shuffle(self):\n",
    "        random.shuffle(self.cards)\n",
    "    \n",
    "    def sort(self):\n",
    "        self.cards.sort()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "deck = Deck()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "52"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(deck.cards)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ace of Clubs\n",
      "2 of Clubs\n",
      "3 of Clubs\n",
      "4 of Clubs\n",
      "5 of Clubs\n",
      "6 of Clubs\n",
      "7 of Clubs\n",
      "8 of Clubs\n",
      "9 of Clubs\n",
      "10 of Clubs\n",
      "Jack of Clubs\n",
      "Queen of Clubs\n",
      "King of Clubs\n",
      "Ace of Diamonds\n",
      "2 of Diamonds\n",
      "3 of Diamonds\n",
      "4 of Diamonds\n",
      "5 of Diamonds\n",
      "6 of Diamonds\n",
      "7 of Diamonds\n",
      "8 of Diamonds\n",
      "9 of Diamonds\n",
      "10 of Diamonds\n",
      "Jack of Diamonds\n",
      "Queen of Diamonds\n",
      "King of Diamonds\n",
      "Ace of Hearts\n",
      "2 of Hearts\n",
      "3 of Hearts\n",
      "4 of Hearts\n",
      "5 of Hearts\n",
      "6 of Hearts\n",
      "7 of Hearts\n",
      "8 of Hearts\n",
      "9 of Hearts\n",
      "10 of Hearts\n",
      "Jack of Hearts\n",
      "Queen of Hearts\n",
      "King of Hearts\n",
      "Ace of Spades\n",
      "2 of Spades\n",
      "3 of Spades\n",
      "4 of Spades\n",
      "5 of Spades\n",
      "6 of Spades\n",
      "7 of Spades\n",
      "8 of Spades\n",
      "9 of Spades\n",
      "10 of Spades\n",
      "Jack of Spades\n",
      "Queen of Spades\n",
      "King of Spades\n"
     ]
    }
   ],
   "source": [
    "print(deck)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "deck.shuffle()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 of Spades\n",
      "2 of Diamonds\n",
      "Jack of Diamonds\n",
      "Queen of Hearts\n",
      "King of Diamonds\n",
      "9 of Diamonds\n",
      "3 of Spade\n",
      "...\n",
      " of Spades\n",
      "8 of Diamonds\n",
      "Queen of Clubs\n",
      "Jack of Spades\n",
      "5 of Diamonds\n",
      "Jack of Clubs\n",
      "Queen of Diamonds\n"
     ]
    }
   ],
   "source": [
    "print(str(deck)[:100])\n",
    "print(\"...\")\n",
    "print(str(deck)[-100:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Queen of Diamonds\n"
     ]
    }
   ],
   "source": [
    "print(deck.pop_card())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jack of Clubs\n"
     ]
    }
   ],
   "source": [
    "print(deck.pop_card())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(deck.cards)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 of Spades\n",
      "2 of Diamonds\n",
      "Jack of Diamonds\n",
      "Queen of Hearts\n",
      "King of Diamonds\n",
      "9 of Diamonds\n",
      "3 of Spade\n",
      "...\n",
      "\n",
      "6 of Diamonds\n",
      "Ace of Diamonds\n",
      "9 of Spades\n",
      "8 of Diamonds\n",
      "Queen of Clubs\n",
      "Jack of Spades\n",
      "5 of Diamonds\n"
     ]
    }
   ],
   "source": [
    "print(str(deck)[:100])\n",
    "print(\"...\")\n",
    "print(str(deck)[-100:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Inheritance\n",
    "\n",
    "Inheritance is the ability to define a new class that is a modified version of an existing class.\n",
    "\n",
    "For example, let's say we want a new class to represent a \"hand\", that is, the cards held by one player.\n",
    "\n",
    "A hand is similar to a deck: both are made up of a collection of cards, and both require operations like adding and removing cards.\n",
    "\n",
    "A hand is also different from a deck; there are operations we want for hands that don’t make sense for a deck. For example, in poker we might compare two hands to see which one wins. In bridge, we might compute a score for a hand in order to make a bid.\n",
    "\n",
    "This relationship between classes—similar, but different—lends itself to inheritance. \n",
    "\n",
    "To define a new class that inherits from an existing class, you put the name of the existing class in parentheses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Hand(Deck):\n",
    "    \"\"\"Represents a hand of playing cards.\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "This definition indicates that Hand inherits from Deck; that means we can use methods like `pop_card` and `add_card` for Hands as well as Decks.\n",
    "\n",
    "When a new class inherits from an existing one, the existing one is called the **parent** and the new class is called the **child**.\n",
    "\n",
    "If we have nothing else defined, then `Hand` inherits `__init__` from `Deck`, which is not what we want.\n",
    "\n",
    "If we provide an `init` method in the `Hand` class, it overrides the one from `Deck`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Hand(Deck):\n",
    "    def __init__(self, label = \"\"):\n",
    "        self.cards = []\n",
    "        self.label = label"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "When you create a Hand, Python invokes this init method, not the one in Deck."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hand = Hand('new hand')\n",
    "hand.cards"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'new hand'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hand.label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "deck = Deck()\n",
    "card = deck.pop_card()\n",
    "hand.add_card(card)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "King of Spades\n"
     ]
    }
   ],
   "source": [
    "print(hand)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "We can add these steps into a method called `move_cards` into the `Deck` class.\n",
    "\n",
    "~~~\n",
    "    def move_cards(self, hand, num):\n",
    "            for i in range(num):\n",
    "                hand.add_card(self.pop_card())\n",
    "~~~\n",
    "\n",
    "`move_cards` takes two arguments, a Hand object and the number of cards to deal. It modifies both `self` and `hand`, and returns `None`.\n",
    "\n",
    "In some games, cards are moved from one hand to another, or from a hand back to the deck. You can use `move_cards` for any of these operations: `self` can be either a Deck or a Hand, and `hand`, despite the name, can also be a Deck.\n",
    "\n",
    "Inheritance is a useful feature. Some programs that would be repetitive without inheritance can be written more elegantly with it. Inheritance can facilitate code reuse, since you can customize the behavior of parent classes without having to modify them. \n",
    "\n",
    "In some cases, the inheritance structure reflects the natural structure of the problem, which makes the design easier to understand.\n",
    "\n",
    "On the other hand, inheritance can make programs difﬁcult to read. When a method is invoked, it is sometimes not clear where to find its definition. The relevant code may be spread across several modules."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Deck:\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",
    "    def __str__(self):\n",
    "        res = []\n",
    "        for card in self.cards:\n",
    "            res.append(str(card))\n",
    "        return '\\n'.join(res)\n",
    "    \n",
    "    def pop_card(self):\n",
    "        return self.cards.pop()\n",
    "    \n",
    "    def add_card(self, card):\n",
    "        self.cards.append(card)\n",
    "    \n",
    "    def shuffle(self):\n",
    "        random.shuffle(self.cards)\n",
    "    \n",
    "    def sort(self):\n",
    "        self.cards.sort()\n",
    "        \n",
    "    def move_cards(self, hand, num):\n",
    "        for i in range(num):\n",
    "            hand.add_card(self.pop_card())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "deck = Deck()\n",
    "hand = Hand('new hand')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "deck.move_cards(hand, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "King of Spades\n",
      "Queen of Spades\n",
      "Jack of Spades\n",
      "10 of Spades\n",
      "9 of Spades\n"
     ]
    }
   ],
   "source": [
    "print(hand)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "deck = Deck()\n",
    "hand = Hand('new hand')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k of Clubs\n",
      "Jack of Hearts\n",
      "6 of Clubs\n",
      "Jack of Spades\n",
      "4 of Clubs\n",
      "Ace of Clubs\n",
      "3 of Clubs\n",
      "5 of Diamonds\n"
     ]
    }
   ],
   "source": [
    "deck.shuffle()\n",
    "print(str(deck)[-100:])\n",
    "deck.move_cards(hand, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 of Diamonds\n",
      "3 of Clubs\n",
      "Ace of Clubs\n",
      "4 of Clubs\n",
      "Jack of Spades\n"
     ]
    }
   ],
   "source": [
    "print(hand)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lubs\n",
      "Jack of Hearts\n",
      "6 of Clubs\n"
     ]
    }
   ],
   "source": [
    "print(str(deck)[-30:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Class relationships\n",
    "\n",
    "Class diagrams are useful to represent the relationships that exist between classes.\n",
    "\n",
    "There are different kids of relationships between classes:\n",
    "\n",
    "+ Objects in one class might contain references to objects in another class. For example, each Rectangle contains a reference to a Point, and each Deck contains references to many Cards. This kind of relationship is called **HAS-A**, as in \"a Rechtangle has a point\"\n",
    "+ One class might inherit from another. This relationship is called **IS-A**, as in \"a Hand is a kind of a Deck\"\n",
    "+  One class might depend on another in the sense that objects in one class take objects in the second class as parameters, or use objects in the second class as part of a computation. This kind of relationship is called a **dependency**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'cards': [<__main__.Card at 0x2255bfb65b0>,\n",
       "  <__main__.Card at 0x2255bfbf6a0>,\n",
       "  <__main__.Card at 0x2255bfbf850>,\n",
       "  <__main__.Card at 0x2255bfb6070>,\n",
       "  <__main__.Card at 0x2255bfa1f40>],\n",
       " 'label': 'new hand'}"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vars(hand)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Here's a design suggestion: when you override a method, the interface of the new method should be the same as the old. It should take the same parameters, return the same type, and obey the same preconditions and postconditions. If you follow this rule, you will find that any function designed to work with an instance of a parent class, like a Deck, will also work with instances of child classes like a Hand and PokerHand."
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}