http://xkcd.com/
IS 313 Today
Schedule
Where we've been…
Week 0:
Week 1:
Classes
Week 4:
Functions
and Data
Week 2:
Week 5:
Loops and
language
Week 6:
Where we're going…
42 'a'
key
value
a Dictionary object…
Objects
Week 8:
Week 9:
Week 12:
Dictionaries
and Classes
Week 10:
Week 13:
Week 14:
You're saying that
Python's got
class?
Projects
and
Networks
Watch out!
http://www.youtube.com/watch?v=nBeUGqeYsQg
Objects
42 'a'
"Oh yeah!"
key
value
Data reigns
a Dictionary object…
a String object…
Python ~ an object-oriented
programming language
Classes
input
Methods
Functions
output
Types
Some languages are ALL OBJECTS!
Almost all data in
Java are OBJECTS
The CLASS of an
objects is its type.
METHODS are f'ns ~
"part of the data"!
Now it's data
that's royalty!
Lists vs. Dictionaries
Lists are not perfect…
You can't choose what to name data.
L[0], L[1], …
You have to start at 0.
L[1985] = 'ox'
L[1986] = 'tiger'
Some operations can be slow for big lists …
if 'tiger' in L:
If I had a dictionary, I guess
I could look up what it was!
reference
L
5
42
L[0]
L[1]
More on dictionaries
They don't seem
moronic to me!
Dictionaries have lots of built-in methods, or functions:
>>> d = {1990: 'horse', 1991: ram'}
>>> d.keys()
keys returns a list of all keys
[ 1990, 1991 ]
>>> d.has_key( 1991 )
has_key checks if a key is present
True
>>> d.has_key( 1969 )
False
>>> d.pop( 1988 )
'dragon'
pop deletes a key
and returns its value
Methods
There's madness in
this method!
d.has_key( 1991 )
are functions that are
called by the data itself!
Functions
has_key( 1991, d )
are called on their own…
all data must be passed
in as function inputs…
Warning: this
has_key function
is for example
purposes only. It
does not exist!
Classes and Objects
Design-it-yourself data.
Software Engineering
Building atop the
work of others…
creating and
composing
functions
Insight into details, e.g.,
data storage and retrieval.
loops and
data handling
Invention, not reinvention.
creating new
data structures
Classes & Objects
An object-oriented programming language allows you
to build your own customized types of variables.
(1) A class is a type of variable.
(2) An object is one such variable.
Classes & Objects
An object-oriented programming language allows you
to build your own customized types of variables.
(1) A class is a type of variable.
(2) An object is one such variable.
There will typically
be MANY objects
of a single class.
Using objects and classes:
A particularly appropriate reference …
>>> d = dict()
>>> d['answer'] = 42
an example of the
dictionary constructor
>>> dir(d)
all of the data members and methods of the dictionary class (and thus the object d !)
>>> d.keys()
[ 'answer' ]
>>> d.values()
[ 42 ]
two methods (functions) within
all objects of class dictionary
The CONSTRUCTOR …
Code
class dict:
""" a dictionary class """
def __init__( self ):
""" the CONSTRUCTOR """
# sets all of the data needed
# there's no data here!
defines a new
datatype called
dict
the constructor is
named __init__
but is used via the
class name
It sets all the
Comments
DATA MEMBERS
of a new
object
the object is
called self
The REPR …
Code
class dict:
""" a dictionary class """
def __repr__( self ):
""" a grim method """
s = '{'
for key in self.keys():
s += str(key) + ':'
s += str( self[key] ) + ', '
s += '}'
return s
this method is named
__repr__ and it
provides a string that will
be used when printing
the object
being printed
is called
self
the string to
print gets
returned
Comments
Object-oriented programming
Do-it-yourself data structures!
class: your own TYPE of data
object: a variable of your own class type
data members: data an object contains
Blueprint for
an object
variables of
that type
methods: functions an object contains
benefits: encapsulation & abstraction
An object is alive,
responsible, and intelligent.
- C++ FAQs
Examples…
Python's class libraries…
Graphics libraries
Do reference
libraries have
library
references?
http://docs.python.org/lib/
>>> f = urllib.urlopen( 'http://www.cs.hmc.edu/~dodds/IS313/HW/index.html' )
>>> text = f.read()
>>> text[:50]
Objects
An object is a data structure (like a list), except
(1) Its data elements have names chosen by the programmer.
(2) Data elements are chosen & organized by the programmer
(3) An object can have behaviors built-in by the programmer.
usually called "methods"
instead of functions
User-defined structures that become part of
the language (at least locally…)
But Why ?
• Flexibility
create-your-own
• Reusability
write once, take anywhere
• Abstraction
worry once, use anywhere
ordinary data structures
Date
The Problem
The Design
This is a class. It is a user-defined datatype
(that you'll build in Lab this week!)
We want (or need) to
represent lots of
interacting calendar days
What data should be set
in the constructor?
What functionality will we
need to support?
Are you asking what
Date-a a Date needs?
d.dow()
usually some, but not all,
is known beforehand
Using Dates
>>> d = Date(1,1,2012)
this is a CONSTRUCTOR …
What does
it do?
>>> d
1/1/2012
this is an object of type Date
the representation of a particular object of type Date
>>> d.isLeapYear()
True
the isLeapYear method returns
True or False. How does it know
what year to check?
>>> d2 = Date(11,4,2009)
>>> d2
Another object of type Date again, via the constructor.
11/4/2009
>>> d2.isLeapYear()
False
How does it know to return False,
instead of True in this case ??
class Date:
def __init__( self, m, d, y ):
""" the Date constructor """
self.month = m
self.day = d
self.year = y
def __repr__( self ):
""" used for printing Dates """
s = "%02d/%02d/%04d" % (self.month,
return s
def isLeapYear( self ):
The Date
class
self.day, self.year)
Why is everyone
so far away?!
self
is the specific OBJECT THAT
CALLED THE METHOD !
>>> d = Date(1,1,2012)
>>> d
1/1/2012
These methods need
access to the object
that calls them
>>> d.isLeapYear()
True
>>> d2 = Date(12,31,2011)
>>> d2
12/31/2011
These methods need
access to the object
that calls them
>>> d2.isLeapYear()
False
Why not use d?
Which leap is correct?
def isLeapYear( self ):
def isLeapYear( self ):
""" left-side leap """
""" right-side leap """
if self.yr%400 == 0:
if self.yr%4 == 0:
return True
elif self.yr%100 == 0:
return False
elif self.yr%4 == 0:
return True
else:
return False
return True
elif self.yr%100 == 0:
return False
elif self.yr%400 == 0:
return True
else:
return False
a Leap of faith….
class Date:
def __init__( self, mo, dy, yr ): (constructor)
def __repr__(self): (for printing)
def isLeapYear( self ):
""" here it is """
if self.yr%400 == 0: return True
if self.yr%100 == 0: return False
if self.yr%4 == 0: return True
return False
How about a
4000-year rule?
Date objects are mutable
>>> d = Date(1,1,2008)
but only if we
want them to be!
always created with the
CONSTRUCTOR …
>>> d
01/01/2008
>>> d.yesterday()
>>> d
the yesterday method returns
nothing at all. Is it doing anything?
d has changed!
12/31/2007
>>> d.tomorrow()
>>> d
01/01/2008
Some methods return a value; others
(like this one) change the object
that call it!
Date ids
What date is on your id?
What id is on your Date?
>>> d = Date(11,4,2009)
>>> d
11/4/2009
>>> d2 = Date(11,5,2009)
>>> d2
11/5/2009
>>> d == d2
>>> d2.yesterday()
>>> d == d2
>>> d.equals( d2 )
Will these be
true or false?
Excuse me -ids please!
Double Date
>>> d2 = d
>>> d
11/4/2009
>>> d.yesterday()
>>>
>>> d2
>>> d2 == d
>>> d2.equals(d)
What
happens
here?
Using copy
>>> d2 = d.copy()
But where
does copy
come from?
>>> d
11/3/2009
>>> d2
11/3/2009
>>> d.yesterday()
>>> d2
>>> d2 == d
What
happens
here?
class Date:
def __init__( self, mo, dy, yr ):
def __repr__(self):
def isLeapYear(self):
def copy(self):
""" returns a DIFFERENT object w/same date! """
def equals(self, d2):
""" returns True if they represent
the same date; False otherwise
"""
Where are these
TWO inputs
coming from?
class Date:
Try it…
def isBefore(self, d2):
""" True if self is before d2 """
if self.yr < d2.yr: return True
if self.mo < d2.mo: return True
if self.dy < d2.dy: return True
return False
Why is this method WRONG for the dates
1/1/2010
11/4/2009
how might you fix this problem?
def tomorrow(self):
""" moves the date that calls it ahead 1 day """
DIM = [0,31,28,31,30,31,30,31,31,30,31,30,31]
This tomorrow method
should not return anything.
It just CHANGES the date
object that calls it.
DIM might be helpful…
class Date:
What's wrong?
def isBefore(self, d2):
""" True if self is before d2 """
if self.yr < d2.yr: return True
if self.mo < d2.mo: return True
if self.dy < d2.dy: return True
return False
Why is this method WRONG for the dates
1/1/2010
11/4/2009
class Date:
def tomorrow(self):
""" moves the date that calls it ahead 1 day """
DIM = [0,31,28,31,30,31,30,31,31,30,31,30,31]
HW today / tomorrow
Add these methods to Date
copy(self)
equals(self, d2)
yesterday(self)
tomorrow(self)
addNDays(self, N)
subNDays(self, N)
isBefore(self, d2)
isAfter(self, d2)
diff(self, d2)
dow(self)
and use your Date class to
analyze our calendar a bit…
Prof. Art Benjamin
no computer required…
Unusual calendar years…
Application #2…
Python has no Connect-four datatype…
| | | | | | | |
| | | | | | | |
| | | | | | | |
| | | |X| | | |
| |X| |X|O| | |
|X|O|O|O|X| |O|
--------------0 1 2 3 4 5 6
Aargh!
… but we can correct that!
Can I see a
demo?
Designing classes
1) What data? (Data Members)
Not limited to 7x6!
2) What are objects' crucial capabilities? (Methods)
Connect Four:
Board
b
list
data
the object b
str
str
str
str
str
str
str
str
str
str
str
str
int
width
int
height
data
What is the name of the method
that will construct this data?
Connect Four:
constructor
class Board:
""" a datatype representing a C4 board
with an arbitrary number of rows and cols
"""
def __init__( self, width, height ):
""" the constructor for objects of type Board """
self.width = width
self.height = height
self.data = []
# this will be the board
for row in range( 6 ):
boardRow = []
for col in range( 7 ):
boardRow += [' ']
# add a space to this row
self.data += [boardRow]
Bad magic?
Connect Four:
Board
b
list
data
str
str
str
str
str
str
str
str
str
What is the name of the method
that will print this data?
the object b
str
str
str
| | | | | | | |
| | | | | | | |
| | | | | | | |
| | | |X| | | |
| |X| |X|O| | |
|X|O|O|O|X| |O|
--------------0 1 2 3 4 5 6
int
width
int
height
Connect Four:
__repr__
def __repr__(self):
""" this method returns a string representation
for an object of type Board
"""
s = ''
which row is row 0,
for row in range( 6 ):
row 1, and so on?
s += '|'
for col in range( 7 ):
s += self.data[row][col] + '|'
s += '\n'
To remove?
To add?
return s
def addMove(self, col, ox):
a C4
board
col #
'X' or 'O'
row = self.height-1
while True:
if self.data[row][col] == ' ':
self.data[row][col] = ox
Examples
Step through this
addMove method.
How does it work?
What's wrong?
row -= 1
def allowsMove(self, col):
allowsMove should return
True if col is a valid move;
False otherwise.
C4 Board class:
methods
the “constructor”
__init__( self, width, height )
checks if allowed
allowsMove( self, col )
places a checker
removes a checker
outputs a string
checks if any space is left
checks if a player has won
play!
addMove( self, col, ox )
delMove( self, col )
__repr__( self )
isFull( self )
winsFor( self, ox )
hostGame( self )
Which is trickiest… ?
Checking wins… ?
b
X
O
Thoughts?
corner cases?
Thinking about final projects…
Lab … and hw questions
There are several well-made, concise tutorials…
want to brush
up on anything?
Two good references for looking up syntax…
wikipedia, for sure
http://www.cis.upenn.edu/~matuszek/General/JavaSyntax/
for checking out
just one thing!
"thinking like a computer"
or, at least, like Java.
data
constructor(s)
Aha! But what is
this I see?
Constructors are giving me
a HEAP of trouble!
Descargar

No Slide Title