Programming, problem solving, and algorithms

CPSC 203, 2026 W1

September 29, 2026

Announcements

• Take examlet 1 in ORCA between Thursday Oct 1 and Monday Oct 5.
• Book your slot for examlet 2.

Quick recap: Dataclasses

A dataclass bundles related data together into a custom type.

• Attributes: data stored in the object (radius, colour)
• Methods: functions that belong to the class (diameter)

So a dataclass is a compound data type.

• More general than the compound data types from CPSC 103 / 110 because it allows not just attributes but also methods.
• Reminder about the self parameter for all methods.

A bead bracelet

What data describes a bead?

What data describes a bracelet?

Bead: radius, color

Bracelet: radius, list of beads

Creating a Bracelet

An example of composing data types: a Bracelet contains a list of bead. We use (de)composition to solve big problems a piece at a time.

Use dot and index notation to access deep inside the bracelet:

br = Bracelet(20, [b1, b2, b3])
print(br.beads[1].colour[2])

Aside: The pyodide environment used in the slides maintains its state through multiple slides unless you click start over.

• If you are used to Jupyter, then think of each slide as a cell.
  
• In this case we already ran a cell which defined Bead, so we don’t need to do it again.
• Note that you may get unexpected errors if you skip cells or run them out of order.

Does it Fit?

We choose to say that the beads fit on the bracelet if the sum of their diameters is less than or equal to the circumference of the bracelet.

We will refer to any extra string as slack.

In reality, if we fill up the bracelet then the beads will slightly overlap because of the curvature of the bracelet string. We ignore it for simplicity.

How Much Slack?

Write a dummy call from br before implementation. It will fail because slack is not an attribute or method. Note that we are redefining the Bracelet class every time we re-run that class definition. But the br object will still be using the old version of the class unless we recreate it after the redefinition. br = Bracelet(20, [b1, b2, b3])

Try the dummy call. Point out that Cinda’s stub uses the pass statement. If the stub is executed, what will be returned?

Better to return a value of the appropriate type. Even better to return an unusual value so that the stub will be noticed. (Even better to throw an unimplemented exception, but that’s beyond this course). What is a good choice in this case? I would choose 0.0.

Adding beads safely

We only want to add a bead if it fits!

Fix Cinda’s pass then write a dummy call.

Removing beads

What if we want to swap out a bead?

Jump to next slide and then back here to implement. Just write a valid return value, not full implementation.

• When you mutate an object, you should probably not return that object. Consider string_bead and remove_bead above.

Useful Python: Removing Elements from a List

Lists have a method called pop(index) that removes and returns the item at that index.

• Like append, pop mutates the list.
• Unlike append, pop returns something other than None.

Wait a minute! Lists have methods? In fact, every type that you have already seen in Python is actually class, and most have methods. In particular, you have used list and string methods extensively (such as str.upper()).

• So if you have other aliases for this list, then they will see the removal.
• Why does append return None rather than the updated list? To remind you that it is mutating the list.

Drawing the bracelet

In the activity workspace we provide some code to draw the bracelet.

• We will not expect you to write such code, but we will expect you to run it if we provide it.

The full picture

@dataclass
class Bead:
    radius: float
    colour: tuple[int, int, int]

    def diameter(self) -> float: ...
    def draw(self, ax, x: float, y: float) -> None: ...

@dataclass
class Bracelet:
    radius: float
    beads: list[Bead]

    def circumference(self) -> float: ...
    def slack(self) -> float: ...
    def string_bead(self, bead: Bead) -> bool: ...
    def remove_bead(self, index: int) -> Bead: ...
    def draw(self) -> None: ...

So we have defined two classes, each with some attributes and methods. Now it is your turn to implement some of the stub methods.

Your turn: Implement Bracelet

Try the Bracelet Activity (continued) on PrairieLearn!

Implement these methods:

• circumference() - return \(2 \pi r\).
• slack() - circumference minus total bead diameters.
• string_bead(bead) - add bead if it fits, return True/False.
• remove_bead(index) - remove and return the bead at index.

If you finish early, try Tasks 4 & 5 (brighten methods)!

Extending functionality: Name bracelets

What if we want to make a friendship bracelet with someone’s name on it?

• Let’s create a bead that can hold a letter.

Adding letters to beads

Let’s add an optional letter attribute to our Bead class:

Why is the letter attribute “optional”?

• It isn’t really: All (new) Bead objects will have a letter attribute, but if no value is assigned to that attribute then it will be given the default value (in this case the empty string).
• The programmer still needs to correctly handle the default depending on context.
• Optional in the same way that function parameters with a default are optional.

Useful Python: the enumerate() Function

Sometimes you want both the index and the value of each element as you iterate through a list.

enumerate() gives you tuples of (index, value) as you loop.

Naming a bracelet

Add a name() method to Bracelet that assigns letters to existing beads:

Why reversed? So the name reads correctly around the circle!

Why not use word.reverse() instead of reversed(word)?

• If word is a string, then there is no reverse method.
• If word were a list, then there is a reverse method. But that would mutate the list in place and then return None. Definitely not what we want to do.

Using name()

Your turn: Letter beads

Back to PrairieLearn - try Task 6: Letter Beads!

Design Strategies

1. Identify the objects in your problem (nouns).

2. List the data each object needs (attributes).

3. List the operations each object supports (methods).

4. Decide which object is responsible for what.

5. Implement and test incrementally.

When we say “object” in this list, we mean the normal definition of the word not the programming language definition.

• Would “thing” be less confusing?