Post on 12-Jan-2016
description
The CS 5 Herald
Goodwill Gesture Goes AwryClaremont (AP): Seven rooms were damaged in a Harvey Mudd College dormitory Tuesday evening after a misguided attempt to cheer up sleep-deprived students. “We were approached by a group of three penguins who wanted to sing Christmas carols,” explained a witness. “They promised that it would help us study.” Instead, the raucous squawking of the untrained and untalented birds quickly led to a violent dispute between supporters and detractors. One student attempted to encase the singers in foam rubber, but a second set fire to the material in hopes of freeing the animals. The resulting explosion unleashed a conflagration that spread to North Dorm, where there was extensive damage. However, losses in North were estimated at only $35.47, due to the advanced age of the furniture there.
“Forced” Methods
Some methods are required by languageMust always have __init__
Good to have one of __repr__ or __str__
Others not required, but very commoncopy (to do deep copies)
show (to print self)
Construction and Destruction
Constructor (__init__) builds an instanceCalled when object created
Best to initialize everything to reasonable values
Destructor (__del__) rarely neededUnlike C++
Unpredictable when (or if) it's called
Best to avoid
__repr__ and __str__
__str__ implements the str(…) built-inAutomatically called by print
__repr__ should give Python syntaxE.g., Date(11, 26, 2007)
Automatically called when interpreter is returning a result
If __str__ undefined, __repr__ usedQuick shortcut: only do the latter
Class Globals ("statics")
How to put debug in your Date class?Don't want to depend on user's debug
Might not exist
User might not care about Date debugging
Solution: variable that's global within classOnly one copy across all objects
Also useful for things like counting objects
A Self-Counting Class
class Counter:
instances = 0
def __init__(self):
self.id = Counter.instances
Counter.instances += 1
def unique(self): return self.id
Computational Classes
It’s often useful to define classes that provide mathematical objects
Infinite-precision numbers
Rational numbers
Matrices
Modular fields
Writing code using these classes can be painful:y = add(mult(a,mult(x,x)),add(mult(b,x),c))
Operator Overloading
Overloading means giving an operator (or function) a definition that depends on contextExample: a/b means something different
depending on whether a and b are ints or floats
Some languages (including Python) let users overload operators at will
y = a*x*x + b*x + c
Overloading in Python
Most Python operators can be overloadedJust define a special function in a class
Annoying exception: plain assignment
Many finicky rulesNames aren’t always obvious
Some operators have “forward” and “reverse” versions
Some operators derive from others by default
Basic Overloading
class MyMath:
def __init__(self, …): …
def __add__(self, rhs):
# Only works if rhs is a MyMath
result = self.value + rhs.value
return result
def __sub__(self, rhs): …
# etc.
Important Details
Overloaded operators should return a resultShould not modify “self” or right-hand side
Often useful to have copy method
Exception: Ops in “i” series modify “self”
Possibility of rhs not being same typeMany packages don’t handle this case well
Overloaded Operator Naming
+ add
- sub
* mul
/ div/ truediv (future)
// floordiv
% mod
** pow
+ pos
- neg
abs
int
float
complex
== eq
!= ne
<= le
>= ge
< lt
> gt
Remember, every name needs two underscores
before and after it!
The r… and i… series
radd, rsub, etc. implement reversed operatorsIf x is special and y is built-in (e.g., integer), then x+y invokes x.add(y), and y+x invokes y.radd(x)
However, if radd isn’t defined, Python will try y.add(x)
iadd, isub, etc. implement incremental operatorsE.g., x.iadd(y) implements x += y
Modifies x
Should return None (i.e., no explicit return value)
The Alien’s Life Advice
Ask questions when you don’t get it!
It makes you seem human!
OK, maybe you won’t get a date with Xohptzl, but you’ll learn more!
Worksheet: Designing a Class
Design class Rational, to store rational numbers (integer divided by integer)
Choose reasonable string representation
Enumerate data, "special" functions, things it should be able to doE.g., a.add(b) adds b to a, modifying a
I looove rationals! They’re so logical!
More On Rationals
Should there be any “extra” methods beyond the obvious mathematical ones?
Rules for Connect Four
Tic-Tac-Toe with stacking
7x6 board
Checkers slide down onto top of column
Four in a row (including diagonal) wins
A C4Board Class
class C4Board:
width = 7
height = 6
def __init__(self):
board = [width*[0]
for i in range(height)]
…
Artificial Intelligence
Catch-all term for anything that “appears human”Eliza
Chess programs
Expert systems
Many approachesN-ply lookahead:
good for games
Looking into the Future, Part I
Basic ideaGuess a move
See whether it makes your position better
Repeat for many guesses, pick best result
What defines “better”?Simple answer: use board evaluation
function
Evaluating a Connect-4 Board
What are some ways to numerically rate a Connect-4 board?
If opponent has won, 0.0
If I have won, 1.0
Otherwise…
?
Looking Into the Future, Part II
Problem: evaluating a board is HARD
Solution: look at where the board leadsFor each possible move:
Make the move in “trial mode”
For each possible opponent's response:Make that move in “trial mode”
Evaluate that board instead (how?)
Return value of opponent's best optionThis is the “worst case” for us
Our best move is “best of the worst cases”
Limiting Recursion
When do we stop?
That's easy:When we find path that leads to a win
No matter what opponent does (e.g., Nim)
When all paths lead to losses (sigh)
When we have explored all possible moves
The Move Tree
X
O X
O X
O X
O X
X O
X O
X O
X O
X O X
X O X
XO X
O X X
O X X
O X X
O X X
Explosive Growth
Connect-4 move tree has < 742 nodes
Roughly 311×1033
Tree size depends on two parameters:Branching factor per move, B
Maximum moves in game, N
Approximately BN possibilitiesChess: B≈35, N≈150
Backgammon: B≈300, N≈50
Limiting Growth
Simplest strategy: stop looking ahead after evaluating N moves (“plies”)
Alternative: stop after t seconds elapsed
Better: prune move treeDon't follow a path if first move is way worse
Don't explore if already found better choice
Alpha/Beta pruning
The Curse of the AI Researcher
AI is always defined as “something a lot smarter than what my computer can do”
Corollary: if my computer can do it, it's not artificial intelligence⇒ Every time we achieve AI, people
decide it's not really AI!