def fastFib(n, memo):
    global numCalls
    numCalls += 1
    print 'fib1 called with', n
    if not n in memo:
        memo[n] = fastFib(n-1, memo) + fastFib(n-2, memo)
    return memo[n]

def fastFib(n, memo):
    if not n in memo:
        memo[n] = fastFib(n-1, memo) + fastFib(n-2, memo)
    return memo[n]

fastFib(6, {0:0, 1:1}).

def fibonacci():
    a,b = 1,1
    while True:
        yield a
        a,b = b,a+b

for i, seq in enumerate(fibonacci(), start=1):
     print "%d: %d" % (i, seq)

## Is object needed here or can it just be open parameters?
## I observe that it works either way.
class iClass(object):
    def __init__:
        pass
    def action(self):
        pass

class subClass(iClass):
    def __init__:
        pass

class subSub(subClass):
    def __init__:
        pass

    #The question is that I can use either of these to access
    #the action in iClass, but which one is better?
    #Although the teacher used the first option, perhaps to
    #demonstrate inheritance, I found that the second one
    #works as well. I like it better because the flow is easier to
    #see. However, I can see a good argument for the first option
    # since the chain of inheritance goes up the code.

    #I don't know much about over-riding/shadowing atm, so perhaps
    # I am missing that point for now. 
    def action(self):
        return subClass.action(self, param)
        return iClass.action(self, param)

x = 'foo'
x.action(x, 'bar')

class C(B):
    def method(self, arg):
        super(C, self).method(arg)

def silly():
    res = []
    done = False
    while not done:
        elem = raw_input('Enter element. Return when done. ')
        if elem == '':
            done = True
        else:
            res.append(elem)
    #print statement 1
    tmp = res
    #print statement 4
    tmp.reverse()
    #print statemtent 3
    isPal = (res == tmp)
    #print statement 2
    if isPal:
        print 'is a palindrome'
    else:
        print 'is NOT a palindrome'

class MyNewStyleClass(object):
  pass
class MyOldStyleClass:
  pass

>>> a = [1,2,3,9,7,8]
>>> sorted(a)
[1, 2, 3, 7, 8, 9]
>>> a
[1, 2, 3, 9, 7, 8]
>>> a.sort()
>>> a
[1, 2, 3, 7, 8, 9]

#Hold'em poker eval that is extensible to other variants:

import random

#createDeck():
#To create alternate deck, change deck size and/or (numSuits and suits):

#returns dictionary mapping of deck:
####{'hearts': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13],
##'clubs': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13],
##'spades': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13],
##'diamonds': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]}

def createDeck(deck = 52):
    numSuits = deck/4
    deck = {}
    ranks = []
    suits = 'clubs', 'hearts', 'spades', 'diamonds'
    for i in range(1, numSuits + 1):
        ranks.append(i)
    for suitPlace in range(4):
        deck[suits[suitPlace]] = ranks
    return deck

#createDeck()

#Creates pseudo-random two-card hand for each player:
#converts numericals to trump-ranks.
#returns list with tuples:
#ex: [(8, 'hearts'), (7, 'spades')]
#To change hand-size, change handSize
#Only need to change ranked if deck in createDeck() is larger than 52

def createHand():
    wholeDeck = createDeck()
    handSize = 2
    returnHand = []
    while handSize > 0:
        for n in range(handSize):
            suited = random.choice(wholeDeck.keys())
            ranked = random.choice(wholeDeck[suited])
##            This is a bug that I'll get to fixing later:
##            the attempt is to chop off the cards so I don't get doubles
##            del wholeDeck[suited][ranked]
##            print wholeDeck
        if ranked == 1:
            ranked = 'A'
        elif ranked == 10:
            ranked = 'T'
        elif ranked == 11:
            ranked = 'J'
        elif ranked == 12:
            ranked = 'Q'
        elif ranked == 13:
            ranked = 'K'
        handSize -= 1
        newHand = ranked, suited
        returnHand.append(newHand)
    return returnHand

##hand = createHand(1)
##print hand

#Initializes players and returns player hands:

def createPlayerHands(players = 1):
    playerHand = {}
    playerID = 0
    for i in range(players):
        playerID += 1
        rawHand = createHand()
        playerHand[playerID] = rawHand
    return playerHand

#dealBoard decides how many cards to deal. Will create function later that asks what
#streets to deal. 

def dealBoard(cardsUsed = 0):
    cardsToDeal = 5 - cardsUsed
    lessDeck = createDeck()
    returnHand = []
    for i in range(cardsToDeal):
        suited = random.choice(lessDeck.keys())
        ranked = random.choice(lessDeck[suited])
        if ranked == 1:
            ranked = 'A'
        elif ranked == 10:
            ranked = 'T'
        elif ranked == 11:
            ranked = 'J'
        elif ranked == 12:
            ranked = 'Q'
        elif ranked == 13:
            ranked = 'K'
        newHand = ranked, suited
        returnHand.append(newHand)
    return returnHand
        

##showBoard = dealBoard(3)  
##print showBoard

#play starts here:
##example output:
##how many players in this hand? 4
##player 1 : [(9, 'spades'), (4, 'hearts')]
##player 2 : [(7, 'spades'), ('J', 'diamonds')]
##player 3 : [(6, 'spades'), (6, 'diamonds')]
##player 4 : [(5, 'hearts'), (6, 'spades')]

numPlayers = int(raw_input('how many players in this hand? '))    
playerHand = createPlayerHands(numPlayers)
for k, v in playerHand.iteritems():
    print 'player', k, ':', v

#See the error message: tells me how many lines this thing is getting to be:
#createPlayerHan(4)