8-2_more_OOP_methods.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Lecture 8-2\n",
    "\n",
    "# A Few More OOP methods and Some Pythonic Features\n",
    "\n",
    "## Week 8 Wednesday\n",
    "\n",
    "## Miles Chen, PhD"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## The `Card` class so far"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `Card` class has an `__init__` method which assigns a numeric value to the suit and to the rank.\n",
    "\n",
    "It has a few methods: \n",
    "\n",
    "- `__str__` which is used to show the card in a user-friendly form.\n",
    "- `__lt__` which is used for comparison and allows card objects to be sorted\n",
    "- `__eq__` which is used to test equality"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "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": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## The Deck class so far\n",
    "\n",
    "The `Deck` class has a few methods: \n",
    "\n",
    "- `__init__` method which creates 52 cards and stores them in a list `self.cards`\n",
    "- `__str__` which iterates through all items in the `self.cards` list and prints them\n",
    "- `pop_card` which pops the last card in the list `self.cards`\n",
    "- `add_card` which appends a card in the list `self.cards`\n",
    "- `shuffle` which shuffles the list `self.cards`\n",
    "- `sort` which sorts the list `self.cards`. It is able to do this because the `Card` objects have `__lt__` which allows for comparison\n",
    "- `move_cards` which moves cards from the deck to a hand.\n",
    "\n",
    "Note: `shuffle` requires us to import the `random` module into Python\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import random\n",
    "random.seed(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## The Hand class so far\n",
    "\n",
    "The `Hand` class inherits from the `Deck` class, so it learns all of the same methods.\n",
    "\n",
    "We change the `__init__` method so the hand starts off empty. We also provide the hand a label."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Hand(Deck):\n",
    "    def __init__(self, label = \"\"):\n",
    "        self.cards = []\n",
    "        self.label = label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "deck = Deck()\n",
    "hand = Hand('new hand')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "deck.move_cards(hand, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "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": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## Current limitation\n",
    "\n",
    "Even though we have a string representation of the card, when we create a card, the object itself is represented as an object in memory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "card1 = Card()\n",
    "card2 = Card(3, 11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.Card at 0x133d1cec0>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "card1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 of Clubs\n"
     ]
    }
   ],
   "source": [
    "print(card1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.Card at 0x133d1f350>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "card2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jack of Spades\n"
     ]
    }
   ],
   "source": [
    "print(card2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "This is even worse when looking at a deck or hand object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<__main__.Card at 0x133d1cf20>,\n",
       " <__main__.Card at 0x133d1cd70>,\n",
       " <__main__.Card at 0x133d1cd10>,\n",
       " <__main__.Card at 0x133d1d010>,\n",
       " <__main__.Card at 0x133d1ce90>]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hand = Hand('new hand')\n",
    "deck.move_cards(hand, 5)\n",
    "hand.cards"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As it stands, this is completely unintelligible"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## The `__repr__` method\n",
    "\n",
    "The dunder (double-underscore) method `__repr__` is used to show the 'official' representation of the card object. The output should be the command that is able to create this card object.\n",
    "\n",
    "When we created the Jack of Spades and set it equal, we called\n",
    "\n",
    "`card2 = Card(3, 11)`\n",
    "\n",
    "Thus, `Card(3, 11)` would be the official representation of this object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "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 __repr__(self):\n",
    "        return \"Card({:s}, {:s})\".format(str(self.suit), str(self.rank))\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": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.Card at 0x133d1f350>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# card2 was created under the old Card definition and does not have the __repr__ method\n",
    "card2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jack of Spades\n"
     ]
    }
   ],
   "source": [
    "print(card2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "card3 = Card(3, 11) # We create a nother jack of Spades using the new Card class with the repr method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Card(3, 11)"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "card3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jack of Spades\n"
     ]
    }
   ],
   "source": [
    "print(card3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "card3 == card2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# must redefine the Deck class to use the new definition of the Card class\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()\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": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Hand(Deck):\n",
    "    def __init__(self, label = \"\"):\n",
    "        self.cards = []\n",
    "        self.label = label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "deck = Deck()\n",
    "hand = Hand('new hand')\n",
    "deck.move_cards(hand, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "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": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Card(3, 13), Card(3, 12), Card(3, 11), Card(3, 10), Card(3, 9)]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hand.cards # although not as easy to read as the string representation, the represenation makes more sense."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## How many cards are in the deck or hand?\n",
    "\n",
    "Right now, if we want to know how many cards are in the deck or hand, we have to access the list of cards in the hand or deck directly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.Hand at 0x133d3bef0>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hand"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "object of type 'Hand' has no len()",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)\n",
      "Cell \u001b[0;32mIn[29], line 1\u001b[0m\n",
      "\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mhand\u001b[49m\u001b[43m)\u001b[49m\n",
      "\n",
      "\u001b[0;31mTypeError\u001b[0m: object of type 'Hand' has no len()"
     ]
    }
   ],
   "source": [
    "len(hand)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'cards': [Card(3, 13), Card(3, 12), Card(3, 11), Card(3, 10), Card(3, 9)],\n",
       " 'label': 'new hand'}"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vars(hand)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(hand.cards)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## Defining the length of a class\n",
    "\n",
    "We can fix this issue by defining the `__len__` special method, which will return the length of `self.cards`\n",
    "\n",
    "```\n",
    "    def __len__(self):\n",
    "        return len(self.cards)\n",
    "```        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "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 __len__(self):\n",
    "        return len(self.cards)\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": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Hand(Deck):\n",
    "    def __init__(self, label = \"\"):\n",
    "        self.cards = []\n",
    "        self.label = label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "52"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "deck = Deck()\n",
    "len(deck)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "hand = Hand('new hand')\n",
    "deck.move_cards(hand, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(hand)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "47"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(deck)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## What if we wanted to access the first 5 cards from the deck?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'Deck' object is not subscriptable",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)\n",
      "Cell \u001b[0;32mIn[38], line 1\u001b[0m\n",
      "\u001b[0;32m----> 1\u001b[0m \u001b[43mdeck\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m:\u001b[49m\u001b[38;5;241;43m5\u001b[39;49m\u001b[43m]\u001b[49m\n",
      "\n",
      "\u001b[0;31mTypeError\u001b[0m: 'Deck' object is not subscriptable"
     ]
    }
   ],
   "source": [
    "deck[0:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Right now, our deck cannot be sliced."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'Deck' object is not subscriptable",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)\n",
      "Cell \u001b[0;32mIn[39], line 1\u001b[0m\n",
      "\u001b[0;32m----> 1\u001b[0m \u001b[43mdeck\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\n",
      "\n",
      "\u001b[0;31mTypeError\u001b[0m: 'Deck' object is not subscriptable"
     ]
    }
   ],
   "source": [
    "deck[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## What if we want to iterate through the deck?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'Deck' object is not iterable",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)\n",
      "Cell \u001b[0;32mIn[40], line 1\u001b[0m\n",
      "\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mcard\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mdeck\u001b[49m\u001b[43m:\u001b[49m\n",
      "\u001b[1;32m      2\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;28;43mprint\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mcard\u001b[49m\u001b[43m)\u001b[49m\n",
      "\n",
      "\u001b[0;31mTypeError\u001b[0m: 'Deck' object is not iterable"
     ]
    }
   ],
   "source": [
    "for card in deck:\n",
    "    print(card)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Right now, our deck is not iterable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## What if we want to see the hand sorted without changing the hand?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'Hand' object is not iterable",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)\n",
      "Cell \u001b[0;32mIn[41], line 1\u001b[0m\n",
      "\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;43msorted\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mhand\u001b[49m\u001b[43m)\u001b[49m\n",
      "\n",
      "\u001b[0;31mTypeError\u001b[0m: 'Hand' object is not iterable"
     ]
    }
   ],
   "source": [
    "sorted(hand)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is not possible right now."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "# Making the class behave like a list or container:\n",
    "\n",
    "https://docs.python.org/3/reference/datamodel.html#emulating-container-types\n",
    "\n",
    "We can take the class and allow the user to slice the object as well as perform iteration.\n",
    "\n",
    "This is achieved with the dunder method: `__getitem__(self, key)` which tells Python what to do when a particular position is requested from the class object.\n",
    "\n",
    "In our case, we will use the `key` as an index `position`. We return the card located in the requested `[position]` from the `self.cards` list.\n",
    "\n",
    "```\n",
    "    def __getitem__(self, position):\n",
    "        return self.cards[position]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "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 __len__(self):\n",
    "        return len(self.cards)\n",
    "    \n",
    "    def __getitem__(self, position):\n",
    "        return self.cards[position]\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": 43,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "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": [
    "deck = Deck()\n",
    "print(deck)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Card(0, 1),\n",
       " Card(0, 2),\n",
       " Card(0, 3),\n",
       " Card(0, 4),\n",
       " Card(0, 5),\n",
       " Card(0, 6),\n",
       " Card(0, 7),\n",
       " Card(0, 8)]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can now perform slicing\n",
    "deck[0:8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "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"
     ]
    }
   ],
   "source": [
    "# We can also perform iteration\n",
    "for item in deck[0:8]:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "With `__getitem__` implemented, all of the slicing rules now work with our Class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Card(0, 13), Card(1, 13), Card(2, 13), Card(3, 13)]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# I select the index-12th card, the King of clubs and get every 13th card after:\n",
    "deck[12::13]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "King of Clubs\n",
      "King of Diamonds\n",
      "King of Hearts\n",
      "King of Spades\n"
     ]
    }
   ],
   "source": [
    "for item in deck[12::13]:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Hand(Deck):\n",
    "    def __init__(self, label = \"\"):\n",
    "        self.cards = []\n",
    "        self.label = label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "deck = Deck()\n",
    "deck.shuffle()\n",
    "hand = Hand('new hand')\n",
    "deck.move_cards(hand, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 of Clubs\n",
      "2 of Hearts\n",
      "5 of Hearts\n",
      "Jack of Hearts\n",
      "King of Spades\n"
     ]
    }
   ],
   "source": [
    "# sorted arranges by suit\n",
    "for card in sorted(hand):\n",
    "    print(card)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jack of Hearts\n",
      "3 of Clubs\n",
      "2 of Hearts\n",
      "5 of Hearts\n",
      "King of Spades\n"
     ]
    }
   ],
   "source": [
    "print(hand) # original hand is left unchanged"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "a,b,c,d,e = hand # now the we have get_item, we can also perform tuple unpacking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Card(2, 11)"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 of Clubs\n"
     ]
    }
   ],
   "source": [
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.Hand at 0x133d4ade0>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hand"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jack of Hearts\n",
      "3 of Clubs\n",
      "2 of Hearts\n",
      "5 of Hearts\n",
      "King of Spades\n"
     ]
    }
   ],
   "source": [
    "print(hand)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Card(2, 11)"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hand[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'Hand' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)\n",
      "Cell \u001b[0;32mIn[58], line 1\u001b[0m\n",
      "\u001b[0;32m----> 1\u001b[0m \u001b[43mhand\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m \u001b[38;5;241m=\u001b[39m Card(\u001b[38;5;241m2\u001b[39m,\u001b[38;5;241m1\u001b[39m)\n",
      "\n",
      "\u001b[0;31mTypeError\u001b[0m: 'Hand' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "hand[0] = Card(2,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## set item\n",
    "\n",
    "The `__setitem__` method allows you to set items in the Class.\n",
    "\n",
    "In our case, we can use it to assign a particular Card object to a particular position in the list of cards. \n",
    "\n",
    "```\n",
    "    def __setitem__(self, key, value):\n",
    "        self.cards[key] = value\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions like `random.shuffle()` use the `__setitem__` method to rearrange the objects inside a container.\n",
    "\n",
    "With `__setitem__` implemented, we can get rid of the internal `deck.shuffle()` method and simply use the `shuffle()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "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 __len__(self):\n",
    "        return len(self.cards)\n",
    "    \n",
    "    def __getitem__(self, position):\n",
    "        return self.cards[position]\n",
    "    \n",
    "    def __setitem__(self, key, value):\n",
    "        self.cards[key] = value\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",
    "    # no longer needed:\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": 60,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "deck = Deck()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ace of Clubs\n",
      "2 of Clubs\n",
      "3 of Clubs\n",
      "4 of Clubs\n"
     ]
    }
   ],
   "source": [
    "for card in deck[0:4]:\n",
    "    print(card)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Card(0, 1)"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "deck[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "deck[0] = Card(3,1) # with _setitem_ in place, you can change values of objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ace of Spades\n",
      "2 of Clubs\n",
      "3 of Clubs\n",
      "4 of Clubs\n"
     ]
    }
   ],
   "source": [
    "for card in deck[0:4]:\n",
    "    print(card)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "random.shuffle(deck) # We can call random.shuffle() directly on deck instead of calling deck.shuffle()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9 of Diamonds\n",
      "5 of Spades\n",
      "Ace of Spades\n",
      "King of Hearts\n",
      "4 of Diamonds\n",
      "10 of Spades\n",
      "Jack of Diamonds\n",
      "5 of Diamonds\n",
      "2 of Clubs\n",
      "9 of Spades\n"
     ]
    }
   ],
   "source": [
    "for card in deck[0:10]:\n",
    "    print(card)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "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",
      "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": [
    "for i in sorted(deck):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## \"Prviate\" attributes in Classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example taken from \"Fluent Python\" by Luciano Ramalho\n",
    "\n",
    "Let's say we wanted to make a simple class to represent a vector in 2D. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Vector2d:\n",
    "    def __init__(self, x, y):\n",
    "        self.x = float(x)     \n",
    "        self.y = float(y)\n",
    "    def __iter__(self): # makes the object iterable and unpackable\n",
    "        return (i for i in (self.x, self.y))\n",
    "    def __repr__(self):\n",
    "        class_name = type(self).__name__\n",
    "        return '{}({}, {})'.format(class_name, *self)   \n",
    "    def __str__(self):\n",
    "        return str(tuple(self)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "myvector = Vector2d(3,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vector2d(3.0, 4.0)"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myvector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'(3.0, 4.0)'"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(myvector)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, anyone can change the values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "myvector.x = \"dog\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vector2d(dog, 4.0)"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myvector"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This problem can be addressed by using private attributes by preceeding the name with two underscores.\n",
    "\n",
    "In order to access these values, we can create a function called `x` or `y`, and use the `@property` decorator.\n",
    "\n",
    "More information: https://www.freecodecamp.org/news/python-property-decorator/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Vector2d:\n",
    "    def __init__(self, x, y):\n",
    "        self.__x = float(x)   \n",
    "        self.__y = float(y)\n",
    "        \n",
    "    @property   \n",
    "    def x(self):   \n",
    "        return self.__x   \n",
    "        \n",
    "    @property   \n",
    "    def y(self):\n",
    "        return self.__y\n",
    "        \n",
    "    def __iter__(self):\n",
    "        return (i for i in (self.x, self.y))\n",
    "    def __repr__(self):\n",
    "        class_name = type(self).__name__\n",
    "        return '{}({}, {})'.format(class_name, *self)   \n",
    "    def __str__(self):\n",
    "        return str(tuple(self)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "myvector = Vector2d(3,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myvector.x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "property 'x' of 'Vector2d' object has no setter",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)\n",
      "Cell \u001b[0;32mIn[77], line 1\u001b[0m\n",
      "\u001b[0;32m----> 1\u001b[0m \u001b[43mmyvector\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mx\u001b[49m \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdog\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;66;03m# no longer works\u001b[39;00m\n",
      "\n",
      "\u001b[0;31mAttributeError\u001b[0m: property 'x' of 'Vector2d' object has no setter"
     ]
    }
   ],
   "source": [
    "myvector.x = \"dog\" # no longer works"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Vector2d' object has no attribute '__x'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)\n",
      "Cell \u001b[0;32mIn[78], line 1\u001b[0m\n",
      "\u001b[0;32m----> 1\u001b[0m \u001b[43mmyvector\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m__x\u001b[49m \u001b[38;5;66;03m# cannot access value directly\u001b[39;00m\n",
      "\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'Vector2d' object has no attribute '__x'"
     ]
    }
   ],
   "source": [
    "myvector.__x # cannot access value directly"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "'private' values in python aren't truly private because \n",
    "there is still a hidden way to access the value directly, \n",
    "but this is discouraged and violates \"pythonic\" principles.\n",
    "The form to get the private attribute is:\n",
    "`object._classname__privateAttribute`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myvector._Vector2d__x # 'secret' way to directly access and even modify the value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "# Pythonic Features\n",
    "\n",
    "Taken from Chapter 19 of Think Python by Allen B Downey"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Python has a number of features that are not necessary, but with them you can sometimes write code that's more concise, readable, or efficient."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "## Conditional Expressions\n",
    "\n",
    "A conditional expression will check a condition and run the associated code.\n",
    "\n",
    "The following example shows how we can ask Python to find the natural log of a number. logs do not exist for non-positive values, so if x is less than or equal to zero, we want to return `nan` instead of an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = -3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "nan"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "if x > 0:\n",
    "    y = math.log(x)\n",
    "else:\n",
    "    y = float('nan')\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "We can express the same idea more concisely with a conditional expression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = math.e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = math.log(x) if x > 0 else float('nan')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "nan"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = -5\n",
    "y = math.log(x) if x > 0 else float('nan')\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Recursive functions can be rewritten as conditional expressions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "def factorial(n):\n",
    "    if n == 0:\n",
    "        return 1\n",
    "    else:\n",
    "        return n * factorial(n-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factorial(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "def factorial(n):\n",
    "    return 1 if n == 0 else n * factorial(n - 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "720"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factorial(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "The conditional expression is certainly more concise. Whether it is more readable is debatable.\n",
    "\n",
    "In general, if both branches of a conditional statement are simple expressions that are assignmened or a returned, it can be written as a conditional expression."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Variable Length Arguments and Key-Word Arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we covered tuples, we saw that you can gather arguments together with `*`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_all(*args):\n",
    "    for a in args:\n",
    "        print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "print_all(1,2,3,4,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "from random import randint\n",
    "\n",
    "def roll(*dice):\n",
    "    total = 0\n",
    "    for die in dice:\n",
    "        roll = randint(1, die)\n",
    "        print(roll)\n",
    "        total += roll\n",
    "    return total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "roll(20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "4\n",
      "8\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "roll(6, 6, 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "5\n",
      "2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "roll(4, 6, 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "3\n",
      "8\n",
      "3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "17"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "roll(6, 6, 20, 20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Similarly, you can gather key-word pairs as arguments and create a function that uses them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_contents(**kwargs):\n",
    "    for key, value in kwargs.items(): \n",
    "        print (\"key %s has value %s\" % (key, value))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "key CA has value California\n",
      "key OH has value Ohio\n"
     ]
    }
   ],
   "source": [
    "print_contents(CA = \"California\", OH = \"Ohio\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'CA': 'California', 'OH': 'Ohio', 'TX': 'Texas', 'WA': 'Washington'}\n"
     ]
    }
   ],
   "source": [
    "keys = ['CA', 'OH', 'TX', 'WA']\n",
    "names = [\"California\", \"Ohio\", \"Texas\", \"Washington\"]\n",
    "d = dict(zip(keys, names))\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "print_contents() takes 0 positional arguments but 1 was given",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)\n",
      "Cell \u001b[0;32mIn[101], line 2\u001b[0m\n",
      "\u001b[1;32m      1\u001b[0m \u001b[38;5;66;03m# if you want to pass a dictionary to the function, you have to use `**` to scatter them\u001b[39;00m\n",
      "\u001b[0;32m----> 2\u001b[0m \u001b[43mprint_contents\u001b[49m\u001b[43m(\u001b[49m\u001b[43md\u001b[49m\u001b[43m)\u001b[49m\n",
      "\n",
      "\u001b[0;31mTypeError\u001b[0m: print_contents() takes 0 positional arguments but 1 was given"
     ]
    }
   ],
   "source": [
    "# if you want to pass a dictionary to the function, you have to use `**` to scatter them\n",
    "print_contents(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "key CA has value California\n",
      "key OH has value Ohio\n",
      "key TX has value Texas\n",
      "key WA has value Washington\n"
     ]
    }
   ],
   "source": [
    "# if you want to pass a dictionary to the function, you have to use `**` to scatter them\n",
    "print_contents(**d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "key CA has value California\n",
      "key OH has value Ohio\n",
      "key TX has value Texas\n",
      "key WA has value Washington\n"
     ]
    }
   ],
   "source": [
    "print_contents(**dict(zip(keys, names)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# popular use case: matplotlib \n",
    "# {color = \"blue\", line_type = 2, line_width = 3}\n",
    "# you want to make 5 plots all with the same settings\n",
    "# rather than copy paste the settings into all of the plots,\n",
    "# make a dictionary with the settings, and pass the dictionary using **kwargs"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.12.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}