CMSC 201 Computer Science I, Section 07, Spring 2015

News Archive

• [Mon May 11 22:00 2015]
  Some more slides that we did not use in class:
  • 17 StacksAndQueues.pptx
  • 18 Asymptomtic.pptx
  • 19 Sorting.pptx

• [Mon May 11 22:00 2015]
  Object-oriented programs shown in class:
  • Original Version. original card.py program from Defining Classes slides: card.py

    The program defines a Card class. Deals out cards. Prints out a hand.

  • Version 1. Separates the code for the Card class from the main program. This is the typical organization of the source code in object-oriented programming. Otherwise does the same thing as the original version.
    • card.py has the class definition of the Card class.
    • main.py has the main program that uses the Card class.
  • Version 2. Added two classes, CardHand and CardDeck. Since these are closely related to Card, the class definitions are placed in card.py
    • card.py has the class definitions for Card, CardHand and CardDeck. Note that RANK_NAMES and SUIT_NAMES are now moved inside the Card class, since these are card-related data.
    • main.py is now much shorter and easier to read because creating a new deck, shuffling and dealing are now CardDeck methods. Also, adding cards to a hand and printing out a hand are CardHand methods.
  • Version 3.
    • card.py Cleaned up the Card class. Removed data members like bJPts (for BlackJack points) because if you want to play BlackJack you should derive a subclass. Reordered suits for bridge (a game that actually cares about ordering of suits). Added SUIT_SYMBOL, SUIT_DICT and RANK_SYMBOL. Can use print() function to print cards now with the addition of the __str__() method that converts a Card to a string.
    • main.py (same as before)
    • bridge.py defines a subclass BridgeHand of CardHand. This means a BridgeHand object has all of the data members and methods of a CardHand plus some additional "features". In this case, it orders and prints the hand in traditional bridge format. Note the use of the key function argument when we call the sort() method in order(). This assumes that sort() is stable.
    • test.py shows using the BridgeHand class to print in traditional bridge format. Note that we can still using the print() method from CardHand by invoking CardHand.print(x).
  • Version 4. One issue with the previous version is that we had to call the order method after adding cards to a BridgeHand. This should be done automatically, because every BridgeHand should be sorted. The change here is to have the addCards() method in CardHand call the order() method when cards are added.
    • card.py: CardHand now has an order() method that sorts the cards from smaller to higher points.
    • main.py is the same as before. Note that addCards() calls the order() method in CardHand as indicated by the debugging output: "Calling CardHand.order()".
    • bridge.py is the same as before, except the order() method prints out: "Calling BridgeHand.order()"
    • test.py is also the same as before, except the call to order() is commented out. Notice that when we add cards to the BridgeHand, the addCards() method calls the BridgeHand.order() method rather than the CardHand.order(). In Python, which method gets invoked is determined at runtime. Since x is a BridgeHand, its order() method is invoked rather than the one in CardHand. This happens even though when we wrote CardHand we may have no idea that someone in the future will derive the BridgeHand class from it. In C++ parlance, all Python methods are virtual.
  • Version 5. Object-oriented programming is good for code reuse. We derive another subclass from CardHand. This time it's PokerHand. The PokerHand class includes many methods used to determine whether a poker hand is a full house, three of a kind, ...
    • card.py (same as before)
    • main.py (same as before)
    • poker.py contains the PokerHand class.
    • test1.py tests if we catch all possible types of hands in poker.
    • test2.py tests a few selected hands.
    • test3.py uses the pokerRank() method and the POKER_RANKS dictionary for testing.
    • test4.py does some statistical analysis of the likelihood of rare hands like four of a kind and royal flush.
  • Version 6. Let's play war --- the simplest card game. This is the third subclass we are deriving from CardHand. A well-designed class can be used over and over again. This code reuse saves time and money. This is one of the main reasons for object-oriented programming.
    • card.py (same as before)
    • war.py contains two classes WarHand and WarGame. Note that the order() method in WarHand does absolutely nothing. This is the desired effect because in war, we are not supposed to rearrange the hand and must play the cards in the order they are dealt. The main method in WarGame is playOneRound(). This plays one round of the game. Note that it is recursive --- in case there is a tie in the two player's cards.
    • main1.py tests the WarHand and WarGame classes. Plays one round and waits for the user to hit return.
    • main2.py shows that you can tie in war --- at least in some versions.
    • main3.py keeps playing until someone wins. It is not unusual to have several hundred rounds in one game.

• [Mon May 11 19:45 2015]
  Some slides from past semesters. We used the slides on object-oriented programming. The other slides contain topics we discussed.
  • Defining Classes (Object-oriented programming)
  • Object-Oriented Design
  • Sorting (Part 1)
  • Sorting (Part 2)
  • Searching and Algorithmic Analysis
  • Recursion
  • Python Datatypes
  • Abstract Datatypes

• [Mon Apr 27 11:30 2015]
  Some programs shown in class that test the running times of linear search, binary search, Bubble Sort and Quicksort: sort.

• [Mon Apr 27 11:17 2015]
  Some programs shown in class that test the running times of various Python data structures: runtime.

• [Mon Apr 27 11:02 2015]
  Slides on Python's built-in data structures: 15 DataStructures - Chang.pptx

• [Tue Apr 14 13:15 2015]
  Some slides used in class:
  • 11 Debugging.pptx
  • 12 PythonTricks - Chang.pptx
  • 13 FileIO.pptx
  • 14 Recursion.pptx (didn't actually use this one.)

• [Tue Apr 14 13:15 2015]
  Some programs shown in class: recurse.

• [Wed Apr 01 01:58 2015]
  Some programs shown in class:

  • A program that prints out a yearly calendar: calendar.py.

  • Programs that demonstrate the curses module: curses examples.

  • Programs that demonstrate the graphics module by developing a "snake" program: snake programs.

• [Tue Mar 10 12:48 2015]
  Midterm exam topics

• [Thu Feb 26 15:03 2015]
  Some programs shown yesterday. Here's a series explaining local vs global scope: global01.py, global02.py, global03.py, global04.py, global05.py, global06.py, global07.py, global08.py, global09.py and global10.py.

  Here is a series showing a failed attempt at modifying a global variable passed as a parameter. This is to show that parameters are local: scope1.py, scope2.py, scope3.py, scope4.py, scope5.py and scope6.py.

  These two show how to return multiple values from a program: multiple_return1.py, and multiple_return2.py.

• [Thu Feb 26 15:03 2015]
  Slide on functions: 09 Functions - Chang.pptx

• [Fri Feb 20 09:45 2015]
  Additional slides on lists: 08 Lists - Chang.pptx

• [Fri Feb 20 09:45 2015]
  Some programs explained in class on Thursday.

  Print without printing a newline:

  • newline.py

  Using nested for loops to "draw" boxes:

  • nested1.py
  • nested2.py
  • nested3.py

  Using nested for loops to "draw" lines:

  • line1.py
  • line2.py
  • line3.py
  • line4.py

  Using nested for loops to "draw" a parabola:

  • parabola.py

  Displaying a sine wave on the screen:

  • sin.py

• [Wed Feb 18 08:45 2015]
  Get list of slides.

• [Wed Feb 18 08:45 2015]
  Reorganized naming of some slides:
  • 07.b For Loops - Chang.pptx
  • 07.a Lists vs Strings - Chang.pptx
  • 06.b Exceptions - Chang.pptx
  • 06.a While Loops - Chang.pptx

• [Thu Feb 12 14:40 2015]
  Some programs using exceptions shown today. (links updated)
  • exception.py
  • badger1.py
  • badger2.py
  • badger3.py
  • badger4.py

• [Wed Feb 11 23:45 2015]
  More slides:
  • 07 Lists - Chang.pptx (renamed)
  • 06.a Exceptions - Chang.pptx (renamed)
  • 06 Loops - Chang.pptx (renamed)

• [Tue Feb 10 14:47 2015]
  Updated 05 Decisions - Chang.pptx

• [Thu Feb 05 22:17 2015]
  Updated 04 Expressions - Chang.pptx.

• [Thu Feb 05 08:10 2015]
  More slides:
  • 05 Decisions - Chang.pptx
  • 04 Expressions - Chang.pptx
  • 03 Variables - Chang.pptx (updated)

• [Tue Feb 03 11:00 2015]
  Slides for Lectures 2 and 3:
  • 03 Variables - Chang.pptx
  • 02 class4_algorithms - Chang.pptx

• [Tue Jan 27 14:45 2015]
  Modified slides shown today:
  • 01.b fundamentals - Chang.ppt
  • 01.a Intro-Chang.pptx

• [Sat Jan 24 12:00 2015]
  If you are downloading the Think Python book, make sure you get the version for Python 3.0 .

• [Sat Jan 24 12:00 2015]
  Web page up.