8-1_more_OOP_methods.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Lecture 8-1\n",
    "\n",
    "# A Few More OOP methods and Some Pythonic Features\n",
    "\n",
    "## Week 8 Monday\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\" % (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": 4,
   "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": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "deck = Deck()\n",
    "hand = Hand('new hand')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "deck.move_cards(hand, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "card1 = Card()\n",
    "card2 = Card(3, 11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.Card at 0x1835128bd88>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "card1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 of Clubs\n"
     ]
    }
   ],
   "source": [
    "print(card1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.Card at 0x1835128bf88>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "card2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "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": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<__main__.Card at 0x18351293f48>,\n",
       " <__main__.Card at 0x18351293f08>,\n",
       " <__main__.Card at 0x18351293ec8>,\n",
       " <__main__.Card at 0x18351293e88>,\n",
       " <__main__.Card at 0x18351293e48>]"
      ]
     },
     "execution_count": 13,
     "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": 14,
   "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\" % (Card.rank_names[self.rank],\n",
    "                             Card.suit_names[self.suit])\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return \"Card(\" + 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": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.Card at 0x1835128bf88>"
      ]
     },
     "execution_count": 15,
     "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": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jack of Spades\n"
     ]
    }
   ],
   "source": [
    "print(card2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Card(3, 11)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "card3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jack of Spades\n"
     ]
    }
   ],
   "source": [
    "print(card3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "card3 == card2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "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": 22,
   "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": 23,
   "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": 24,
   "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": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Card(3, 13), Card(3, 12), Card(3, 11), Card(3, 10), Card(3, 9)]"
      ]
     },
     "execution_count": 25,
     "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": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.Hand at 0x183512b3108>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hand"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "object of type 'Hand' has no len()",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-27-b0d5bef14cf4>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mhand\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: object of type 'Hand' has no len()"
     ]
    }
   ],
   "source": [
    "len(hand)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "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": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vars(hand)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 29,
     "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": 30,
   "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": 31,
   "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": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "52"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "deck = Deck()\n",
    "len(deck)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "hand = Hand('new hand')\n",
    "deck.move_cards(hand, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(hand)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "47"
      ]
     },
     "execution_count": 35,
     "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": 36,
   "metadata": {
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'Deck' object is not subscriptable",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-36-1d48695686e2>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mdeck\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;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": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## What if we want to iterate through the deck?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'Deck' object is not iterable",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-37-b03c6461f118>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;32mfor\u001b[0m \u001b[0mcard\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mdeck\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcard\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;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": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'Hand' object is not iterable",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-38-6af56c512718>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0msorted\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mhand\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;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": 39,
   "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": 40,
   "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": 41,
   "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": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can now perform slicing\n",
    "deck[0:8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "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": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Card(0, 13), Card(1, 13), Card(2, 13), Card(3, 13)]"
      ]
     },
     "execution_count": 43,
     "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": 44,
   "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": 45,
   "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": 46,
   "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": 47,
   "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": 48,
   "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": "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": 49,
   "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": 50,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "deck = Deck()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "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",
      "9 of Clubs\n",
      "10 of Clubs\n"
     ]
    }
   ],
   "source": [
    "for card in deck[0:10]:\n",
    "    print(card)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "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": 53,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9 of Diamonds\n",
      "5 of Spades\n",
      "Ace of Clubs\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": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Python 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": 54,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = -3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "nan"
      ]
     },
     "execution_count": 55,
     "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": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = math.e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = math.log(x) if x > 0 else float('nan')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "nan"
      ]
     },
     "execution_count": 59,
     "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": 60,
   "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": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factorial(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "def factorial(n):\n",
    "    return 1 if n == 0 else n * factorial(n - 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "720"
      ]
     },
     "execution_count": 63,
     "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": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_all(*args):\n",
    "    for a in args:\n",
    "        print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "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": 66,
   "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": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "roll(20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "4\n",
      "8\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "roll(6, 6, 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "5\n",
      "2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "roll(6, 6, 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "3\n",
      "8\n",
      "3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "17"
      ]
     },
     "execution_count": 70,
     "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": 71,
   "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": 72,
   "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": 73,
   "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": 74,
   "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[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-74-07f6714a297c>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# if you want to pass a dictionary to the function, you have to use `**` to scatter them\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mprint_contents\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0md\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;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": 75,
   "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": 76,
   "metadata": {},
   "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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## List comprehensions\n",
    "\n",
    "List comprehensions allow us to create new lists concisely based on an existing collection\n",
    "\n",
    "They take the form:\n",
    "\n",
    "`[expr for val in collection if condition]`\n",
    "\n",
    "This is basically equivalent to the following loop:\n",
    "\n",
    "`result = []\n",
    "for val in collection:\n",
    "    if condition:\n",
    "        result.append(expr)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# make a list of the squares \n",
    "[x**2 for x in range(1,11)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1,   4,   9,  16,  25,  36,  49,  64,  81, 100])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "np.array([x**2 for x in range(1,11)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 9, 25, 49, 81]"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# square only the odd numbers\n",
    "[x**2 for x in range(1,11) if x % 2 == 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['BAT', 'CAR', 'DOVE', 'PYTHON']"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# take a list of strings, and write the words that are over 2 characters long in uppercase.\n",
    "strings = ['a', 'as', 'bat', 'car', 'dove', 'python']\n",
    "[x.upper() for x in strings if len(x) > 2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "You can create a list comprehension from any iterable (list, tuple, string, etc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[9, 6, 3, 2, 5, 7]"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# extract the digits from a string\n",
    "string = \"Hello 963257 World\"\n",
    "[int(x) for x in string if x.isdigit()]\n",
    "# for x in string, will look at each character individually\n",
    "# if x is a digit, then convert it using int()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "# iterate over a dictionary's items\n",
    "d = {'a':'apple', 'b':'banana', 'c':'cookie'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('a', 'apple'), ('b', 'banana'), ('c', 'cookie')]"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(d.items())  # recall what dict.items() returns: a list of tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a is for apple', 'c is for cookie']"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[key + ' is for ' + value for key, value in d.items() if key != 'b' ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Dictionary Comprehensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A dict comprehension looks like this:\n",
    "\n",
    "`dict_comp = {key-expr : value-expr for value in collection if condition}`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Look at the list `strings` from above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Apple': 5, 'Mango': 5, 'Banana': 6, 'Cherry': 6}"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a dictionary, where the key is the word capitalized, and the value is the length of the word\n",
    "fruits = ['apple', 'mango', 'banana','cherry']\n",
    "{f.capitalize():len(f) for f in fruits}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# create a dictionary where the key is the index, and the value is the string in the strings list.\n",
    "strings = ['a', 'as', 'bat', 'car', 'dove', 'python']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 'a'), (1, 'as'), (2, 'bat'), (3, 'car'), (4, 'dove'), (5, 'python')]"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(enumerate(strings))  # enumerate produces a collection of tuples, with index and value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 'a', 1: 'as', 2: 'bat', 3: 'car', 4: 'dove', 5: 'python'}"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index_map = {index:val for index, val in enumerate(strings)}\n",
    "index_map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 0, 'as': 1, 'bat': 2, 'car': 3, 'dove': 4, 'python': 5}"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# note that enumerate returns tuples in the order (index, val)\n",
    "# in the creation of a dictionary, you can swap those positions\n",
    "# and even apply functions to them\n",
    "\n",
    "# We create a dictionary where the key is the string, and the value is the index in the strings list.\n",
    "loc_mapping = {val : index for index, val in enumerate(strings)}\n",
    "loc_mapping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "scrolled": true,
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'a'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-90-a566f0150b5c>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mindex_map\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'a'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m: 'a'"
     ]
    }
   ],
   "source": [
    "index_map['a']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "loc_mapping['a']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 0, 'as': 1, 'bat': 2, 'car': 3, 'dove': 4, 'python': 5, 0: 'a', 1: 'as', 2: 'bat', 3: 'car', 4: 'dove', 5: 'python'}\n"
     ]
    }
   ],
   "source": [
    "# combine dictionaries with kwargs \n",
    "dd = {**loc_mapping, **index_map}\n",
    "print(dd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 0,\n",
       " 'as': 1,\n",
       " 'bat': 2,\n",
       " 'car': 3,\n",
       " 'dove': 4,\n",
       " 'python': 5,\n",
       " 0: 'a',\n",
       " 1: 'as',\n",
       " 2: 'bat',\n",
       " 3: 'car',\n",
       " 4: 'dove',\n",
       " 5: 'python'}"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# even better... use dict.update(). This modifies the dictionary in place\n",
    "loc_mapping.update(index_map)\n",
    "loc_mapping"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Generator Expressions\n",
    "\n",
    "Generator Expressions are similar to List comprehensions.\n",
    "\n",
    "You create them with parentheses instead of square brackets.\n",
    "\n",
    "The result is a generator object. You can access values in the generator using `next()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "g = (n**2 for n in range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<generator object <genexpr> at 0x00000183513721C8>"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "16\n",
      "25\n",
      "36\n",
      "49\n",
      "64\n",
      "81\n"
     ]
    }
   ],
   "source": [
    "for val in g:\n",
    "    print(val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-100-35efc4ce126e>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mg\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# calling next after it has run out of iterations will result in an error\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "next(g) # calling next after it has run out of iterations will result in an error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## List Comprehension vs Generator Expressions in Python\n",
    "\n",
    "A Key difference between a list comprehension and a generator is that the generator is lazy.\n",
    "\n",
    "The list comprehension will evaluate the entire sequence of iterations. The generator will only generate the next value when it is asked to do so.\n",
    "\n",
    "Depending on the expression that needs to be evaluated, you may prefer to use a generator over the list comprehension.\n",
    "\n",
    "The following examples are from: https://code-maven.com/list-comprehension-vs-generator-expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [n*2 for n in range(1000)] # List comprehension\n",
    "g = (n*2 for n in range(1000))  # Generator expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "<class 'generator'>\n"
     ]
    }
   ],
   "source": [
    "print(type(l))  # 'list'\n",
    "print(type(g))  # 'generator'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9024\n",
      "120\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "print(sys.getsizeof(l))  # more space in memory\n",
    "print(sys.getsizeof(g))  # less space in memory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'generator' object is not subscriptable",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-104-e29ce47c972b>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# cannot access values in a generator by index\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ml\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m   \u001b[1;31m# 8\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mg\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m   \u001b[1;31m# TypeError: 'generator' object is not subscriptable\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'generator' object is not subscriptable"
     ]
    }
   ],
   "source": [
    "# cannot access values in a generator by index\n",
    "print(l[4])   # 8\n",
    "print(g[4])   # TypeError: 'generator' object is not subscriptable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "998988"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "999000"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(l)"
   ]
  }
 ],
 "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.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}