CS101 - Spring 2025

Object Construction and User Interface

Programming
Lecture 10

School of Computing, KAIST

Roadmap

Last week we learned

• Objects
- Object creation
- Object attributes

This week we will learn

• Objects
- Object methods
- Object constructors
- String conversion
• User Interface programming

CS101 Copyright (c) School of Computing, KAIST 2

Blackjack – continued

There are 52 cards.

Each card has a face and a suit.

• Suits: clubs, spades, hearts and diamonds

• Faces: Ace, 2, 3, . . . , 10, Jack, Queen, and King

class Card(object):
"""A Blackjack card."""
pass

card = Card()
card.face = "Ace"
card.suit = "Spades"
card.value = 11

CS101 Copyright (c) School*ofobject

Computing,could
KAIST be another class for Inheritance
3
"Card" inherits attributes and methods from "object"

class Card(object): class object

"""A Blackjack card.""" __doc__
pass ...

__str__()
__eq__()
By specifying "object" as shown, ...
the Card class inherits the attributes and methods
of the object class.
class Card
__doc__
This is not required in Python 3. face
• All classes in Python 3 inherit from object suit
implicitly. value
...
class Card(object): __str__()
"""A Blackjack card.""" __eq__()
pass ...

Spring 2020 CS101 Copyright (c) School of Computing, KAIST 4

Object methods

We do not really need the value attribute, since the value can be computed
from the face attribute.

So, we add a method, value(), to our Card class:

class Card(object):
"""A Blackjack card."""
method of Card
def value(self):
if type(self.face) == int:
return self.face
elif self.face == "Ace":
return 11 self refers to the object itself
else:
inside the method
return 10

CS101 Copyright (c) School of Computing, KAIST 5

self?
card1 = Card()
card1.face = "Ace"
card1.suit = "Spades"
card2 = Card()
card2.face = 2
card2.suit = "Spades"
card1.value()

def value(self):
if type(self.face) == int:
return self.face
elif self.face == "Ace":
return 11 if type(card1.face) == int:
else: return card1.face
return 10 elif card1.face == "Ace":
return 11
else:
return 10

6
The value() method works like this

>>> card1 = Card()

class Card(object):
>>> card1.face = "Ace" """A Blackjack card."""
>>> card1.suit = "Spades"
>>> card1.value() def value(self):
11 if type(self.face) == int:
return self.face
>>> card2 = Card()
elif self.face == "Ace":
>>> card2.face = 2 return 11
>>> card2.suit = "Clubs" else:
>>> card2.value() return 10
2

CS101 Copyright (c) School of Computing, KAIST 7

Better syntax to create a card?

We can create a card and add attributes to it as follows:

>>> card1 = Card()

>>> card1.face = "Ace"
>>> card1.suit = "Spades"

How about this: doing both in a single line?

>>> card1 = Card("Ace", "Spades")

How?

CS101 Copyright (c) School of Computing, KAIST 8

Constructors

Objects can have a special method __init__, called a constructor.

Whenever an object of this type is created, the constructor is automatically

called.

Class Card(object):
"""A Blackjack card."""
def __init__(self, face, suit):
self.face = face
self.suit = suit

CS101 Copyright (c) School of Computing, KAIST 9

Now creating cards is elegant!

class Card(object):
"""A Blackjack card."""
def __init__(self, face, suit):
self.face = face
self.suit = suit

hand = [Card("Ace", "Spades"), Card(8, "Diamonds"),

Card("Jack", "Hearts"), Card(10, "Clubs")]

CS101 Copyright (c) School of Computing, KAIST 10

Constructor is a good place to validate the attributes

FACES = list(range(2, 11)) +

['Jack', 'Queen', 'King', 'Ace']
SUITS = ['Clubs', 'Diamonds', 'Hearts', 'Spades']

Class Card(object):
"""A Blackjack card."""
def __init__(self, face, suit):
assert face in FACES and suit in SUITS
self.face = face
self.suit = suit Check if the face and suit values are
valid. Otherwise, it throws an
AssertionError.

CS101 Copyright (c) School of Computing, KAIST 11

assert keyword

“assert <Boolean expression>” is used for checking your expectations

in the debugging phase of programming.

def mysqrt(x):
assert x >= 0.0
return math.sqrt(x)
print(mysqrt(1))
print(mysqrt(-1))

<The output of the above program>

1.0
Traceback (most recent call last):
File “....py", line 8, in <module>
print(mysqrt(-1))
File “....py", line 4, in mysqrt
assert x >= 0.0
AssertionError

12
Better syntax for printing a card?

We can use card_string to print a card:

>>> card_string(card1)
'an Ace of Spades'
>>> card_string(card2)
'a 2 of Clubs'

However, this looks better!

>>> card1.string()
'an Ace of Spades'
>>> card2.string()
'a 2 of Clubs'

How?

CS101 Copyright (c) School of Computing, KAIST 13

card_string(card) into card.string()

Define the card.string() method:

class Card(object):
"""A Blackjack card."""
...
def string(self):
article = "a "
if self.face in [8, "Ace"]:
article = "an "
return (article + str(self.face) +
" of " + self.suit)

Then, you can do this:

>>> for card in hand:

... print(card.string(), "has value", card.value())

CS101 Copyright (c) School of Computing, KAIST 14

Even nicer syntax
>>> for card in hand:
... print(str(card), "has value", card.value())
>>> for card in hand:
... print(card, "has value", card.value())

print automatically converts card’s arguments to str

How?

Define method __str__, which is called when str(card) is called:

class Card(object):
"""A Blackjack card."""
"""Already defined __init__ and value methods"""
def __str__(self):
article = "a "
if self.face in [8, "Ace"]:
article = "an "
return (article + str(self.face) + " of " + self.suit)

CS101 Copyright (c) School of Computing, KAIST 15

Chickens again

CS101 Copyright (c) School of Computing, KAIST 16

Creating a Chicken object (from Lecture 9)
def make_chicken(hen = False):
layer = Layer()
if hen:
body = Ellipse(70,80)
body.setFillColor("white")
else:
body = Ellipse(40,50)
body.setFillColor("yellow")
body.move(0, 10)
body.setBorderColor("yellow")
body.setDepth(20)
layer.add(body)
# similarly for wing, eye, beak, dots
...
# finally, create a chicken, add attributes, and return it
ch = Chicken()
ch.layer = layer
ch.body = body
...

CS101 Copyright (c) School of Computing, KAIST 17

Using Chicken objects (from Lecture 9)

We use Chicken objects by accessing their attributes:

hen = make_chicken(True)
chick1 = make_chicken()
chick1.layer.move(120, 0)

chick2 = make_chicken()
chick2.layer.move(800, 200)

18
How about this?

hen = Chicken(True)
chick1 = Chicken()
chick1.move(120, 0)

chick2 = Chicken()
chick2.move(800, 200)

Looks better!

Then, how?

19
More elegant way to make a Chicken

class Chicken(object):
"""Graphic representation of a chicken."""
def __init__(self, hen = False):
layer = Layer()
# make all the parts
self.layer = layer
self.body = body
self.wing = wing
self.eye = eye
...

We can also add methods for Chicken like this:

class Chicken(object):
"""Graphic representation of a chicken."""
def move(self, dx, dy):
self.layer.move(dx, dy)

CS101 Copyright (c) School of Computing, KAIST 20

Blackjack with a command-line interface
You are dealt a 6 of Hearts
Dealer is dealt a hidden card
You are dealt a 3 of Spades
Dealer is dealt a 9 of Hearts
Your total is 9
Would you like another card? (y/n) y
You are dealt an Ace of Clubs
Your total is 20
Would you like another card? (y/n) n
The dealer's hidden card was a 10 of Spades
The dealer's total is 19
Your total is 20
The dealer's total is 19
You win!

Let’s learn Blackjack: L10_05.py

CS101 Copyright (c) School of Computing, KAIST 21
Deck object
Let’s create an object that represents a shuffled deck of 52 cards.

We only need one method: drawing a card from the top of the deck:

class Deck(object):
"""A deck of cards."""
def __init__(self):
"""Create a deck of 52 cards and shuffle them."""
self.cards = []
for suit in SUITS:
for face in FACES:
self.cards.append(Card(face, suit))
random.shuffle(self.cards)

def draw(self):
"""Draw the top card from the deck."""
return self.cards.pop() # returns the last

CS101 Copyright (c) School of Computing, KAIST 22

Drawing the cards from the Deck
num_players = 3
num_cards = 5
deck = Deck() A list of lists (one for each player)
hands = []

for j in range(num_players):
hands.append([])
for i in range(num_cards):
for j in range(num_players):
card = deck.draw()
hands[j].append(card)
print("Player", j+1, "draws", card)

for j in range(num_players):
print ("Player %d's hand (value %d):" %
(j+1, hand_value(hands[j])))
for card in hands[j]:
print (" ", card)

CS101 Copyright (c) School of Computing, KAIST 23

Then, you need a way to compare cards

You may need to use the comparison operators: ==, !=, <, etc.

But, they do not work automatically for objects:

>>> Card(8, "Diamonds") == Card(9, "Diamonds")

False
>>> Card(8, "Diamonds") == Card(8, "Diamonds")
False

By default, “==” is same as “is”

24
To make “==” more useful ...

Define the special method __eq__ :

class Card(object):
"""A Blackjack card."""
...
def __eq__(self, rhs):
return (self.face == rhs.face and
self.suit == rhs.suit)
def __ne__(self, rhs):
return not self == rhs

These special methods are called when you say

card1 == card2 card1.__eq__(card2)

card1 != card2
card1.__ne__(card2)

25
Blackjack with a graphical interface (GUI)

CS101 Copyright (c) School of Computing, KAIST 26

Table object

A Table represents the Blackjack table. It provides the following methods:

• clear() clears everything
• close() closes window and end game
• set_score(which, text) where which in [ 0, 1 ]
• set_message(text)
• ask(prompt) waits for y or n and returns True or False

Table has two attributes dealer and player.

These are Hand objects that represent the hand on the table.

Methods of Hand objects:

• clear()
• add(card, hidden = False)
• show() shows all hidden cards
• value() returns the value of hand

CS101 Copyright (c) School of Computing, KAIST 27

Ask and wait for a response
def ask(self, prompt):
self.question.setMessage(prompt)
while True:
e = self.canvas.wait() wait() wait for an input and
d = e.getDescription() return with “an event object”
if d == "canvas close":
sys.exit(1)
if d == "keyboard":
key = e.getKey()
if key == 'y':
return True
if key == 'n':
return False

while True:
if t.ask('Want more card? (y/n)'):
t.set_message('You said Yes')
else:
t.set_message('You said No')

28
More generally - Event Loop!

while True:
e = t.canvas.wait()
if e == None:
sys.exit(1)
d = e.getDescription()
if d == "keyboard":
k = e.getKey()
d = d + '-' + k Handles an event
if k == 'p':
t.player.add(Card("King", "Clubs"))
if k == 'q':
t.close()
elif d == "mouse click":
d = d + '-' + str(e.getMouseLocation())
t.set_message(d)

29
Separating tasks (event handlers) from the loop
while True:
e = t.canvas.wait()
if e == None:
sys.exit(1)
d = e.getDescription()
if d == "keyboard":
k = e.getKey()
d = d + '-' + k
onKey(k) Event Handler
elif d == "mouse click":
onMouseClick() Event Handler
elif ...

With this separation, you are only to provide event handlers in GUI
programming.

An event loop is usually embedded in a GUI programing framework, so

you do not usually see an event loop when you do a GUI programming.
30
GUI programing framework

https://gist.github.com/kassane/f233
GUI application framework 0ef44b070f4a5fa9d59c770f68e9

Spring 2020 CS101 Copyright (c) School of Computing, KAIST 31

Event-based programming

A GUI program is usually an "event-based" program.

That is, it is structured around events.

The program waits for an event to happen and execute an event handler.

For instance, events are

• key presses
• window is minimized, maximized, or closed
• mouse is moved
• mouse button is pressed
• cursor enters window or leaves window

A program doesn’t have a sequential flow of control but consists of event

handlers -- functions that are called by events.

CS101 Copyright (c) School of Computing, KAIST 32

Questions?

CS101 Copyright (c) School of Computing, KAIST 33