Programming, problem solving, and algorithms

CPSC 203, 2026 W1

September 24, 2026

Announcements

• POTW 2 and 3…

• Registration for examlet 1.

Colour Representations (Revisited)

Colour and Code

Make the poppies pop!

PC: https://www.epicgardening.com/spring-wildflowers-from-seed/

Examine each pixel. If its red color channel is high (over 200, say), then leave it as is. Otherwise, change the pixel to grey by setting all 3 color channels to the average of their original values.

Colour and Code

If necessary, go back and review the slides on colour representation from previous lecture.

Open the List Activity on PrairieLearn and choose the Make the Poppies Grow question.

Examples of programming idiom:

• “A commonly-used way to code a relatively small construct in a particular programming context.”
• “Using the idioms for a programming context helps a team work together since they lower the cognitive load of the resulting code.”

Reminding students of how to read code.

• If you were starting from blank page, you would not take this approach.
  • May feel like I’m throwing you in the deep end, but that’s what happens when you read somebody else’s code…
• “Idiom” is used slightly differently in programming than in linguistics.
• The normal Python idiom is to put all the libraries at the top of the file (rather than just before they are used).
  • You don’t need to do that in marimo because of the dependency check feature.
  • Common libraries often have idiomatic names (such as np for numpy).
• Tuple notation. New atomic type np.uint8. Is this a compound or arbitrary-size data type? Depends on context: extracting red channel is compound, averaging is arbitrary size.
• Then a bunch of function definitions. How do we know what code is within a function?
• In final cell: What does the with statement do? Equivalent to let in Dr. Racket. In practical terms, it ensures that the file is closed when the block ends.
  • Examine the syntax of Image.open call. Google for PIL.Image. Google for np.array.
    
• In fancify: Look at img.shape. Reminder about assigning multiple values (also allows function to return multiple values through a tuple).
  • We are treating image as an arbitrary-sized, so we are going to use looping. For looping, we need an accumulator.
  • We usually manipulate images in 2D – lists of lists – so we’ll have nested loops.
  • Rather than looping over the elements of the image, we’ll loop over the indexes of the elements and then extract the element of interest using indexing.
  • Reminder of range function.
  • Do the loops traverse the image by rows or columns? Rows. Why is it (rows, columns)? We just need to pick one and stick with it. Note that doesn’t agree with (x,y) notation. Everybody gets it wrong regularly…
• In boost_red_pixels why convert to int? Avoids overflow in addition.
• In final image, why are yellows still present?

Your turn: Change image or boost

Experiment with the code! Try one or more of these:

1. Find a different image URL and boost a different color (green? blue?)
2. Change the threshold value (try 150 instead of 200)
3. Instead of greying, try inverting: red = 255 - red
4. What happens if you boost pixels that are LOW in red instead of high?

Data Classes

Compound Data Types

So far we have focused on

• Simple atomic types, such as built-ins int, str or library types np.uint8.
• Arbitrary-sized types, such as list or tuple.

But we often want to store a fixed number of pieces of information which naturally belong together.

• Representing a UBC student might require a student number, a first name, a last name, a date of birth, etc.
• Representing a car might require a make, a model, a colour, a license plate, etc.
• A license plate might require a jurisdiction and a plate “number”.

For that, we use compound data types.

Our Example: A Bead Bracelet

What data describes a bead?

What data describes a bracelet?

Bead: radius, color Bracelet: radius, list of beads

Previously in CPSC 103 or CPSC 110

In CPSC 103, we used NamedTuple to create a compound type:

from typing import NamedTuple
Bead = NamedTuple('Bead', [('r', float), ('c', tuple[int, int, int])])
B1 = Bead(5.0, (255, 0, 255))

def circumference(b: Bead) -> float:
    return 2 * math.pi * b.r

In CPSC 110, we used define-struct to create a compound type:

(@htdd Bead)
(define-struct bead (r, c))
;; Bead is (make-bead Float Color)
;; interp. A bead with radius r and RGB colour c
(define B1 (make-bead 5.0 `(255, 0, 255)))

(define (circumference b)
  (* 2 pi (bead-r b)))

If you did not take CPSC 103 or 110, don’t worry about these examples.

• We recommend that everybody use dataclasses going forward.

There is an alternative notation for NamedTuple using the class statement.

• See design recipes at course webpage.
• It will make more sense once we look at dataclasses.
• There are some pros/cons to using NamedTuple instead of dataclass, but the alternative class-based notation for NamedTuple is definitely more idiomatic.

Dataclasses in Python

A dataclass bundles related data together into a custom type.

from dataclasses import dataclass

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

This creates a new type called Bead with two attributes.

What type is colour: atomic, arbitrary sized, …? While it is a tuple, we are treating it (mostly) as compound rather than arbitrary sized because:

• It always has three values.
• The values each have a distinct meaning (red, green or blue).
• Should we have created a Colour data type?

Creating Bead Objects

Why use @dataclass rather than just regular Python classes?

• Dataclasses automatically generate a bunch of annoying but important methods, such as the constructor and a display routine (useful when you want to print).
• They have some constraints, but nothing that will come up in CPSC 203.
• Our recommendation:
  • If you are creating your own class, use dataclass.
  • If you are using somebody else’s class, pretend it is a dataclass until you are forced not to.

Vocabulary

• In CPSC 103 / 110 we talked about a type vs an instance of that type.
  • A type is a category of data, and explains how that data maps to information (the representation and interpretation). For example, an int is a type for storing integers.
  • An instance is a concrete example of a type. For example, the value 42 is an instance of the type int.
• In Python (and many other languages) compound types use special terminology.
  • The type is called a class.
  • An instance of a class is called an object.

Your Turn: Beads

What would these print?

Answers: 10.0, 255, 8.0

Adding Behavior: Methods

A dataclass can also have methods.

What is this self parameter?

• The first parameter of any method contains the object on which this method was called. Python idiom is to use the name self for this parameter.
• Calling a method with dot notation is also standard Python idiom, but you could also call it through the class: print(Bead.diameter(b)). Note that you need to explicitly include the bead object as the first parameter in this case.

Adding Behavior: More Methods

Add a draw method:

Demo

• During an exam, we would not expect you to remember how to write the stuff we’re doing with matplotlib in this code.
• You should definitely remember how to create and use a dataclass.