jupyter5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tic Tac Toe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import clear_output\n",
    "\n",
    "def display_board(board):\n",
    "    clear_output()  # Remember, this only works in jupyter!\n",
    "    \n",
    "    print('   |   |')\n",
    "    print(' ' + board[7] + ' | ' + board[8] + ' | ' + board[9])\n",
    "    print('   |   |')\n",
    "    print('-----------')\n",
    "    print('   |   |')\n",
    "    print(' ' + board[4] + ' | ' + board[5] + ' | ' + board[6])\n",
    "    print('   |   |')\n",
    "    print('-----------')\n",
    "    print('   |   |')\n",
    "    print(' ' + board[1] + ' | ' + board[2] + ' | ' + board[3])\n",
    "    print('   |   |')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   |   |\n",
      " X | O | X\n",
      "   |   |\n",
      "-----------\n",
      "   |   |\n",
      " O | X | O\n",
      "   |   |\n",
      "-----------\n",
      "   |   |\n",
      " X | O | X\n",
      "   |   |\n"
     ]
    }
   ],
   "source": [
    "test_board = ['#','X','O','X','O','X','O','X','O','X']\n",
    "display_board(test_board)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def player_input():\n",
    "    marker = ''\n",
    "    \n",
    "    while not (marker == 'X' or marker == 'O'):\n",
    "        marker = input('Player 1: Do you want to be X or O? ').upper()\n",
    "\n",
    "    if marker == 'X':\n",
    "        return ('X', 'O')\n",
    "    else:\n",
    "        return ('O', 'X')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Player 1: Do you want to be X or O? o\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "('O', 'X')"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "player_input()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def place_marker(board, marker, position):\n",
    "    board[position] = marker"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   |   |\n",
      " X | $ | X\n",
      "   |   |\n",
      "-----------\n",
      "   |   |\n",
      " O | X | O\n",
      "   |   |\n",
      "-----------\n",
      "   |   |\n",
      " X | O | X\n",
      "   |   |\n"
     ]
    }
   ],
   "source": [
    "place_marker(test_board,'$',8)\n",
    "display_board(test_board)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def win_check(board,mark):\n",
    "    \n",
    "    return ((board[7] == mark and board[8] == mark and board[9] == mark) or # across the top\n",
    "    (board[4] == mark and board[5] == mark and board[6] == mark) or # across the middle\n",
    "    (board[1] == mark and board[2] == mark and board[3] == mark) or # across the bottom\n",
    "    (board[7] == mark and board[4] == mark and board[1] == mark) or # down the middle\n",
    "    (board[8] == mark and board[5] == mark and board[2] == mark) or # down the middle\n",
    "    (board[9] == mark and board[6] == mark and board[3] == mark) or # down the right side\n",
    "    (board[7] == mark and board[5] == mark and board[3] == mark) or # diagonal\n",
    "    (board[9] == mark and board[5] == mark and board[1] == mark)) # diagonal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "win_check(test_board,'X')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "def choose_first():\n",
    "    if random.randint(0, 1) == 0:\n",
    "        return 'Player 2'\n",
    "    else:\n",
    "        return 'Player 1'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def space_check(board, position):\n",
    "    \n",
    "    return board[position] == ' '"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def full_board_check(board):\n",
    "    for i in range(1,10):\n",
    "        if space_check(board, i):\n",
    "            return False\n",
    "    return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def player_choice(board):\n",
    "    position = 0\n",
    "    \n",
    "    while position not in [1,2,3,4,5,6,7,8,9] or not space_check(board, position):\n",
    "        position = int(input('Choose your next position: (1-9) '))\n",
    "        \n",
    "    return position"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def replay():\n",
    "    \n",
    "    return input('Do you want to play again? Enter Yes or No: ').lower().startswith('y')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   |   |\n",
      " O |   |  \n",
      "   |   |\n",
      "-----------\n",
      "   |   |\n",
      " X | O | X\n",
      "   |   |\n",
      "-----------\n",
      "   |   |\n",
      " O | X | O\n",
      "   |   |\n",
      "Congratulations! You have won the game!\n",
      "Do you want to play again? Enter Yes or No: no\n"
     ]
    }
   ],
   "source": [
    "print('Welcome to Tic Tac Toe!')\n",
    "\n",
    "while True:\n",
    "    # Reset the board\n",
    "    theBoard = [' '] * 10\n",
    "    player1_marker, player2_marker = player_input()\n",
    "    turn = choose_first()\n",
    "    print(turn + ' will go first.')\n",
    "    \n",
    "    play_game = input('Are you ready to play? Enter Yes or No.')\n",
    "    \n",
    "    if play_game.lower()[0] == 'y':\n",
    "        game_on = True\n",
    "    else:\n",
    "        game_on = False\n",
    "\n",
    "    while game_on:\n",
    "        if turn == 'Player 1':\n",
    "            # Player1's turn.\n",
    "            \n",
    "            display_board(theBoard)\n",
    "            position = player_choice(theBoard)\n",
    "            place_marker(theBoard, player1_marker, position)\n",
    "\n",
    "            if win_check(theBoard, player1_marker):\n",
    "                display_board(theBoard)\n",
    "                print('Congratulations! You have won the game!')\n",
    "                game_on = False\n",
    "            else:\n",
    "                if full_board_check(theBoard):\n",
    "                    display_board(theBoard)\n",
    "                    print('The game is a draw!')\n",
    "                    break\n",
    "                else:\n",
    "                    turn = 'Player 2'\n",
    "\n",
    "        else:\n",
    "            # Player2's turn.\n",
    "            \n",
    "            display_board(theBoard)\n",
    "            position = player_choice(theBoard)\n",
    "            place_marker(theBoard, player2_marker, position)\n",
    "\n",
    "            if win_check(theBoard, player2_marker):\n",
    "                display_board(theBoard)\n",
    "                print('Player 2 has won!')\n",
    "                game_on = False\n",
    "            else:\n",
    "                if full_board_check(theBoard):\n",
    "                    display_board(theBoard)\n",
    "                    print('The game is a draw!')\n",
    "                    break\n",
    "                else:\n",
    "                    turn = 'Player 1'\n",
    "\n",
    "    if not replay():\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'B'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=input().upper()\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to BlackJack! Get as close to 21 as you can without going over!\n",
      "    Dealer hits until she reaches 17. Aces count as 1 or 11.\n",
      "How many chips would you like to bet? 2\n",
      "\n",
      "Dealer's Hand:\n",
      " <card hidden>\n",
      " Seven of Clubs\n",
      "\n",
      "Player's Hand:\n",
      " King of Spades\n",
      " Ace of Diamonds\n",
      "Would you like to Hit or Stand? Enter 'h' or 's' h\n",
      "\n",
      "Dealer's Hand:\n",
      " <card hidden>\n",
      " Seven of Clubs\n",
      "\n",
      "Player's Hand:\n",
      " King of Spades\n",
      " Ace of Diamonds\n",
      " King of Hearts\n",
      "Would you like to Hit or Stand? Enter 'h' or 's' s\n",
      "Player stands. Dealer is playing.\n",
      "\n",
      "Dealer's Hand:\n",
      " <card hidden>\n",
      " Seven of Clubs\n",
      "\n",
      "Player's Hand:\n",
      " King of Spades\n",
      " Ace of Diamonds\n",
      " King of Hearts\n",
      "\n",
      "Dealer's Hand:\n",
      " Seven of Spades\n",
      " Seven of Clubs\n",
      " Three of Clubs\n",
      "Dealer's Hand = 17\n",
      "\n",
      "Player's Hand:\n",
      " King of Spades\n",
      " Ace of Diamonds\n",
      " King of Hearts\n",
      "Player's Hand = 21\n",
      "Player wins!\n",
      "\n",
      "Player's winnings stand at 102\n",
      "Would you like to play another hand? Enter 'y' or 'n' y\n",
      "Welcome to BlackJack! Get as close to 21 as you can without going over!\n",
      "    Dealer hits until she reaches 17. Aces count as 1 or 11.\n",
      "How many chips would you like to bet? 5\n",
      "\n",
      "Dealer's Hand:\n",
      " <card hidden>\n",
      " Two of Hearts\n",
      "\n",
      "Player's Hand:\n",
      " Ace of Clubs\n",
      " Eight of Diamonds\n",
      "Would you like to Hit or Stand? Enter 'h' or 's' s\n",
      "Player stands. Dealer is playing.\n",
      "\n",
      "Dealer's Hand:\n",
      " <card hidden>\n",
      " Two of Hearts\n",
      "\n",
      "Player's Hand:\n",
      " Ace of Clubs\n",
      " Eight of Diamonds\n",
      "\n",
      "Dealer's Hand:\n",
      " Ten of Diamonds\n",
      " Two of Hearts\n",
      " Six of Hearts\n",
      "Dealer's Hand = 18\n",
      "\n",
      "Player's Hand:\n",
      " Ace of Clubs\n",
      " Eight of Diamonds\n",
      "Player's Hand = 19\n",
      "Player wins!\n",
      "\n",
      "Player's winnings stand at 105\n",
      "Would you like to play another hand? Enter 'y' or 'n' y\n",
      "Welcome to BlackJack! Get as close to 21 as you can without going over!\n",
      "    Dealer hits until she reaches 17. Aces count as 1 or 11.\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "suits = ('Hearts', 'Diamonds', 'Spades', 'Clubs')\n",
    "ranks = ('Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight', 'Nine', 'Ten', 'Jack', 'Queen', 'King', 'Ace')\n",
    "values = {'Two':2, 'Three':3, 'Four':4, 'Five':5, 'Six':6, 'Seven':7, 'Eight':8, \n",
    "            'Nine':9, 'Ten':10, 'Jack':10, 'Queen':10, 'King':10, 'Ace':11}\n",
    "\n",
    "playing = True\n",
    "\n",
    "# CLASS DEFINTIONS:\n",
    "\n",
    "class Card:\n",
    "    \n",
    "    def __init__(self,suit,rank):\n",
    "        self.suit = suit\n",
    "        self.rank = rank\n",
    "        \n",
    "    def __str__(self):\n",
    "        return self.rank + ' of ' + self.suit\n",
    "    \n",
    "\n",
    "class Deck:\n",
    "    \n",
    "    def __init__(self):\n",
    "        self.deck = []  # start with an empty list\n",
    "        for suit in suits:\n",
    "            for rank in ranks:\n",
    "                self.deck.append(Card(suit,rank))\n",
    "                \n",
    "    def __str__(self):\n",
    "        deck_comp = ''  # start with an empty string\n",
    "        for card in self.deck:\n",
    "            deck_comp += '\\n '+card.__str__() # add each Card object's print string\n",
    "        return 'The deck has:' + deck_comp\n",
    "                \n",
    "    def shuffle(self):\n",
    "        random.shuffle(self.deck)\n",
    "        \n",
    "    def deal(self):\n",
    "        single_card = self.deck.pop()\n",
    "        return single_card\n",
    "    \n",
    "\n",
    "class Hand:\n",
    "    \n",
    "    def __init__(self):\n",
    "        self.cards = []  # start with an empty list as we did in the Deck class\n",
    "        self.value = 0   # start with zero value\n",
    "        self.aces = 0    # add an attribute to keep track of aces\n",
    "    \n",
    "    def add_card(self,card):\n",
    "        self.cards.append(card)\n",
    "        self.value += values[card.rank]\n",
    "        if card.rank == 'Ace':\n",
    "            self.aces += 1  # add to self.aces\n",
    "    \n",
    "    def adjust_for_ace(self):\n",
    "        while self.value > 21 and self.aces:\n",
    "            self.value -= 10\n",
    "            self.aces -= 1\n",
    "            \n",
    "\n",
    "class Chips:\n",
    "    \n",
    "    def __init__(self):\n",
    "        self.total = 100\n",
    "        self.bet = 0\n",
    "        \n",
    "    def win_bet(self):\n",
    "        self.total += self.bet\n",
    "    \n",
    "    def lose_bet(self):\n",
    "        self.total -= self.bet\n",
    "        \n",
    "\n",
    "# FUNCTION DEFINITIONS:\n",
    "\n",
    "def take_bet(chips):\n",
    "\n",
    "    while True:\n",
    "        try:\n",
    "            chips.bet = int(input('How many chips would you like to bet? '))\n",
    "        except ValueError:\n",
    "            print('Sorry, a bet must be an integer!')\n",
    "        else:\n",
    "            if chips.bet > chips.total:\n",
    "                print(\"Sorry, your bet can't exceed\",chips.total)\n",
    "            else:\n",
    "                break\n",
    "\n",
    "def hit(deck,hand):\n",
    "    hand.add_card(deck.deal())\n",
    "    hand.adjust_for_ace()\n",
    "    \n",
    "def hit_or_stand(deck,hand):\n",
    "    global playing\n",
    "    \n",
    "    while True:\n",
    "        x = input(\"Would you like to Hit or Stand? Enter 'h' or 's' \")\n",
    "        \n",
    "        if x[0].lower() == 'h':\n",
    "            hit(deck,hand)  # hit() function defined above\n",
    "\n",
    "        elif x[0].lower() == 's':\n",
    "            print(\"Player stands. Dealer is playing.\")\n",
    "            playing = False\n",
    "\n",
    "        else:\n",
    "            print(\"Sorry, please try again.\")\n",
    "            continue\n",
    "        break\n",
    "\n",
    "    \n",
    "def show_some(player,dealer):\n",
    "    print(\"\\nDealer's Hand:\")\n",
    "    print(\" <card hidden>\")\n",
    "    print('',dealer.cards[1])  \n",
    "    print(\"\\nPlayer's Hand:\", *player.cards, sep='\\n ')\n",
    "    \n",
    "def show_all(player,dealer):\n",
    "    print(\"\\nDealer's Hand:\", *dealer.cards, sep='\\n ')\n",
    "    print(\"Dealer's Hand =\",dealer.value)\n",
    "    print(\"\\nPlayer's Hand:\", *player.cards, sep='\\n ')\n",
    "    print(\"Player's Hand =\",player.value)\n",
    "    \n",
    "def player_busts(player,dealer,chips):\n",
    "    print(\"Player busts!\")\n",
    "    chips.lose_bet()\n",
    "\n",
    "def player_wins(player,dealer,chips):\n",
    "    print(\"Player wins!\")\n",
    "    chips.win_bet()\n",
    "\n",
    "def dealer_busts(player,dealer,chips):\n",
    "    print(\"Dealer busts!\")\n",
    "    chips.win_bet()\n",
    "    \n",
    "def dealer_wins(player,dealer,chips):\n",
    "    print(\"Dealer wins!\")\n",
    "    chips.lose_bet()\n",
    "    \n",
    "def push(player,dealer):\n",
    "    print(\"Dealer and Player tie! It's a push.\")\n",
    "    \n",
    "# GAMEPLAY!\n",
    "\n",
    "while True:\n",
    "    print('Welcome to BlackJack! Get as close to 21 as you can without going over!\\n\\\n",
    "    Dealer hits until she reaches 17. Aces count as 1 or 11.')\n",
    "    \n",
    "    # Create & shuffle the deck, deal two cards to each player\n",
    "    deck = Deck()\n",
    "    deck.shuffle()\n",
    "    \n",
    "    player_hand = Hand()\n",
    "    player_hand.add_card(deck.deal())\n",
    "    player_hand.add_card(deck.deal())\n",
    "    \n",
    "    dealer_hand = Hand()\n",
    "    dealer_hand.add_card(deck.deal())\n",
    "    dealer_hand.add_card(deck.deal())\n",
    "    \n",
    "    # Set up the Player's chips\n",
    "    player_chips = Chips()  # remember the default value is 100\n",
    "    \n",
    "    # Prompt the Player for their bet:\n",
    "    take_bet(player_chips)\n",
    "    \n",
    "    # Show the cards:\n",
    "    show_some(player_hand,dealer_hand)\n",
    "    \n",
    "    while playing:  # recall this variable from our hit_or_stand function\n",
    "        \n",
    "        # Prompt for Player to Hit or Stand\n",
    "        hit_or_stand(deck,player_hand)\n",
    "        show_some(player_hand,dealer_hand)\n",
    "        \n",
    "        if player_hand.value > 21:\n",
    "            player_busts(player_hand,dealer_hand,player_chips)\n",
    "            break\n",
    "    \n",
    "    # If Player hasn't busted, play Dealer's hand        \n",
    "    if player_hand.value <= 21:\n",
    "        \n",
    "        while dealer_hand.value < 17:\n",
    "            hit(deck,dealer_hand)\n",
    "            \n",
    "        # Show all cards\n",
    "        show_all(player_hand,dealer_hand)\n",
    "        \n",
    "        # Test different winning scenarios\n",
    "        if dealer_hand.value > 21:\n",
    "            dealer_busts(player_hand,dealer_hand,player_chips)\n",
    "\n",
    "        elif dealer_hand.value > player_hand.value:\n",
    "            dealer_wins(player_hand,dealer_hand,player_chips)\n",
    "\n",
    "        elif dealer_hand.value < player_hand.value:\n",
    "            player_wins(player_hand,dealer_hand,player_chips)\n",
    "\n",
    "        else:\n",
    "            push(player_hand,dealer_hand)\n",
    "\n",
    "    # Inform Player of their chips total    \n",
    "    print(\"\\nPlayer's winnings stand at\",player_chips.total)\n",
    "    \n",
    "    # Ask to play again\n",
    "    new_game = input(\"Would you like to play another hand? Enter 'y' or 'n' \")\n",
    "    if new_game[0].lower()=='y':\n",
    "        playing=True\n",
    "        continue\n",
    "    else:\n",
    "        print(\"Thanks for playing!\")\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'A' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-24-7d157d7c000a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mA\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'A' is not defined"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Sample():\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=Sample()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.Sample"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "class kunja():\n",
    "    def __init__(self,name):\n",
    "        self.myname=name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'kunja'"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=kunja(\"kunja\")\n",
    "a.myname"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "from day2 import question"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=question(\"kunja\",\"kunja\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'kunja'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.ques"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n",
      "My name is Kunja\n"
     ]
    }
   ],
   "source": [
    "import kunja\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog():\n",
    "    species=\"mannal\"\n",
    "    def __init__(self,breed,name):\n",
    "        self.mybreed=breed\n",
    "        self.myname=name\n",
    "    def bark(self,number):\n",
    "        print(\"woff! My name is {} and number is {}\".format(self.myname,number))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [],
   "source": [
    "#mydog=Dog(breed=\"lab\",name=\"sammy\")\n",
    "mydog=Dog(\"lab\",\"sammy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'sammy'"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydog.myname"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'mannal'"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydog.species"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "woff! My name is sammy and number is 5\n"
     ]
    }
   ],
   "source": [
    "mydog.bark(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Circle():\n",
    "    pi=3.14\n",
    "    def __init__(self,radius):\n",
    "        self.radius=radius\n",
    "        self.area=radius*radius*self.pi\n",
    "    \n",
    "    def get_circumfrence(self):\n",
    "        return self.radius * self.pi  * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=Circle(10)\n",
    "a.radius"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.14"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "62.800000000000004"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.get_circumfrence()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "314.0"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.area"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Animal:\n",
    "    def __init__(self):\n",
    "        print(\"ANIMAL CREATED\")\n",
    "    def who_am_i(self):\n",
    "        print(\"I am an animal\")\n",
    "    def eat(self):\n",
    "        print(\"I am eating\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ANIMAL CREATED\n"
     ]
    }
   ],
   "source": [
    "a=Animal()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am an animal\n"
     ]
    }
   ],
   "source": [
    "a.who_am_i()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am eating\n"
     ]
    }
   ],
   "source": [
    "a.eat()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog(Animal):\n",
    "    def __init__(self):\n",
    "        #Animal.__init__(self)\n",
    "        print(\"DOG CREATED\")\n",
    "    def who_am_i(self):\n",
    "        print(\"I am a dog\")\n",
    "    def bark(self,name,number):\n",
    "        print(\"Woff! My name is {} and number is {}\".format(name,number))\n",
    "    def eat(self):\n",
    "        print(\"I am a dog and eating\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DOG CREATED\n"
     ]
    }
   ],
   "source": [
    "b=Dog()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am a dog and eating\n"
     ]
    }
   ],
   "source": [
    "b.eat()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am a dog\n"
     ]
    }
   ],
   "source": [
    "b.who_am_i()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cat(Animal):\n",
    "    def __init__(self):\n",
    "        print(\"CAT CREATED\")\n",
    "    def who_am_i(self):\n",
    "        print(\"I am a cat\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CAT CREATED\n"
     ]
    }
   ],
   "source": [
    "c=Cat()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am a cat\n"
     ]
    }
   ],
   "source": [
    "c.who_am_i()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Woff! My name is sam and number is 5\n"
     ]
    }
   ],
   "source": [
    "b.bark(\"sam\",5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}