Susan Eileen Fox
October 13, 2025
Meet in the Library for this session (room TBA)
len, list, strlst[3], myName[0:5]+ or *: "sun" + "flower"Immutable, a key idea:
String methods
Keep handy the Python documentation on List Methods.
| Example | Description |
|---|---|
ls = [5, 2, 4, 7, 1, 9, 6] |
Set up the initial list |
ls.append(23) |
Add a new value at the end |
ls.extend([5, 2, 1]) |
Add new elements at the end |
ls.pop(0) |
Remove the value at given position |
ls.insert(2, 80) |
Insert at given position new value |
ls.remove(9) |
Remove the first occurrence from list |
ls.index(4) |
Return the index of first occurrence |
ls.count(1) |
Count the number of occurrences |
ls.sort() |
Modify list to be sorted |
ls.reverse() |
Modify list to be in reverse order |
ls.copy() |
Returns a shallow copy (sublists not copied) |
Aliasing refers to a situation when more than one variable name references the same actual data in the computer’s memory. When that happens, the data has its original name, plus an “alias”. Confusion can arise if we don’t realize when using the alias that we are also referring to the original variable. We care about these things because lists are mutable. If a list is shared across multiple variables, then changing the list through one variable makes the other variable ’s value change as well! This is an easy mistake to make when modifying lists. Here is an example:
lstA = ['a', 'b', 'c', 'd']
lstB = lstA.copy() # makes a copy of lstA
lstC = lstA # makes lstC be an alias of lstA
print("A:", lstA)
print("B:", lstB)
print("C:", lstC)
lstA[2] = 'zzzz'
print("A:", lstA)
print("B:", lstB)
print("C:", lstC)A: ['a', 'b', 'c', 'd']
B: ['a', 'b', 'c', 'd']
C: ['a', 'b', 'c', 'd']
A: ['a', 'b', 'zzzz', 'd']
B: ['a', 'b', 'c', 'd']
C: ['a', 'b', 'zzzz', 'd']A shorthand notation for a for loop that builds one list from the contents of another. It does the same work Abbreviated notation, still does the same work. You can always do what a list comprehension does with loops and accumulator variables
First general form:
is equivalent to
Second general form:
is equivalent to
Examples:
int
float
Fixed-length numbers: The hardware of the computer implements integers of specific lengths, typically 8 bits, 16 bits, 32 bits, and 64 bits. Flaoting point numbers are either 32 or 64 bits long. It can also distinguish between unsigned integers and signed integers. Unsigned integers are either zero or positive only; signed integers include both positive and negative values.
Numpy defines numeric types for all these fixed-size numbers. The table below lists the different numeric types in Numpy:
| Signed | Unsigned | Float | |
|---|---|---|---|
| 8 bits | int8 |
uint8 |
|
| 16 bits | int16 |
uint16 |
|
| 32 bits | int32 |
uint32 |
float32 |
| 64 bits | int64 |
uint64 |
float64 |
Numpy arrays:
dtype (typically)shapeuint8 for each pixel/channel valueHere are two images of very different sizes. One, we convert to grayscale as well, and print the sizes and data types for each array.
import cv2
img1 = cv2.imread("SampleImages/GoogleyEye.png")
img2 = cv2.imread("SampleImages/landscape1.jpg")
img3 = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)
print("Image 1 shape:", img1.shape, "and dtype", img1.dtype)
print("Image 2 shape:", img2.shape, "and dtype", img2.dtype)
print("Image 3 shape:", img3.shape, "and dtype", img3.dtype) Numpy has an incredible number of tools, we will use just a fraction of them.
Numpy Documentation is excellent: use it!
Functions:
np.array converts an input list, array, string, tuple into an array of the same dimensionsnp.asarray similar, but doesn’t always copy the dataarray.astype an array method, produces a view or copy with a new typenp.zeros creates an array of an input size and type, filled with zerosnp.ones similar, but fills with onesnp.arange, given a starting value, ending value, and step size, builds an array with those values (works on floats!)np.random.rand, creates an array of a given size and data type, filled with random values in a specified rangeRather than writing code that loops over rows and columns of a Numpy matrix, we usually try to perform matrix/vector arithmetic. We can add two arrays together, if they are the same shape. This adds corresponding values together and builds an array of the result. We can do subtraction, multiplication, and division similarly. We can also compute dot product and cross produce, if needed.
Examples:
import numpy as np
a1 = np.array([[1, 2, 3, 4], [2, 3, 4, 5]])
a2 = np.array([[6, 5, 4, 3], [7, 6, 5, 4]])
print("a1 + a2:")
print(a1 + a2)
print("a1 - a2:")
print(a1 - a2)
print("a1 * a2:")
print(a1 * a2)
print("3 * a1")
print(3 * a1)a1 + a2:
[[7 7 7 7]
[9 9 9 9]]
a1 - a2:
[[-5 -3 -1 1]
[-5 -3 -1 1]]
a1 * a2:
[[ 6 10 12 12]
[14 18 20 20]]
3 * a1
[[ 3 6 9 12]
[ 6 9 12 15]]Slicing on arrays works similarly to slicing on strings or lists. But we can specify multiple dimensions at one time. Slicing weirdness: if the bound on the slice goes beyond the limits of the list, string, or array, Python doesn’t given an error. It just treats that as a “go to the end” marker and returns up to the end of the current dimensions.
We won’t really need these much, but they are very cool!
MSCS events:
Class announcements:
split and merge functions.BallFinding.zip for the current activity in new section at the top of our Moodle pageSome typical uses for image arithmetic
Example 1: Boost the green
#| eval: false
img = cv2.imread("SampleImages/grandTetons.jpg")
boostIm = img.copy()
boostIm[:, :, 1] = cv2.add(boostIm[:, :, 1], 25)Example 2: Blending images
#| eval: false
img1 = cv2.imread("SampleImages/mightyMidway.jpg")
img2 = cv2.imread("SampleImages/antiqueTractors.jpg")
# Find the smallest dimensions across both images
(h1, w1, d1) = img1.shape
(h2, w2, d2) = img2.shape
wid = min(w1, w2)
hgt = min(h1, h2)
# Crop the two images to the sizes they share
newImg1 = img1[:hgt, :wid]
newImg2 = img2[:hgt, :wid]
# Blend the resulting images
blendIm = cv2.addWeighted(newImg1, 0.5, newImg2, 0.5, 0)
cv2.imshow("Blended", blendIm)
cv2.waitKey()split and merge functionsWe can pull images apart using Numpy commands, but sometimes OpenCV’s are easier to remember.
The split function takes in a color image, and returns a tuple of its channels as separate arrays The merge function takes in a tuple of channels, and combines them together.
The code example below creates various negative versions of an image. In film cameras, the film stores a negative version of the image, where light parts are dark, and vice versa. This is turned into correct colors or brightness during film process.
We can create negatives by reversing the values in one or all channels of an image. So if a pixel had the value 0 originally it will become 255, if it had the value 10, it will become 245, and if it had the value 200, it would become
This might seem difficult to compute, but actually it is very simple. If we subtract the image array from 255, it gives us this negative effect.
The code example below demonstrates both negative images, and the split and merge functions.
import cv2
# Read original image
img = cv2.imread("SampleImages/landscape1MuchSmaller.jpg")
cv2.imshow("orig", img)
# Grayscale, and gray negative
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
grayNeg = 255 - gray
cv2.imshow("Gray original", gray)
cv2.imshow("Negative gray", grayNeg)
cv2.waitKey()
# Overall negative
img2 = 255 - img
cv2.imshow("OverallNegative", img2)
cv2.waitKey()
(bc, gc, rc) = cv2.split(img)
negGC = 255 - gc
negBC = 255 - bc
negRC = 255 - rc
# Only blue channel negative
newIm1 = cv2.merge((negBC, gc, rc))
cv2.imshow("newBlue", newIm1)
cv2.waitKey()
# Only green channel negative
newIm2 = cv2.merge((bc, negGC, rc))
cv2.imshow("newGreen", newIm2)
cv2.waitKey()
# Only red channel negative
newIm3 = cv2.merge((bc, gc, negRC))
cv2.imshow("newRed", newIm3)
cv2.waitKey()MSCS events:
Class announcements:
A region of interest is just a rectangular section of an image that we want to isolate and work with.
We can make regions of interest using Numpy’s slicing operator. But we must remember that by default we get a view to the original data, and not a copy of the data. Changes made to the ROI usually show in the original image.
Notice that with slicing we put the row range first, and then the column range. If we wanted to draw a rectangle around the region on the image, we would swap the order of the indices to give the upper left and lower right points (as in the code below).
An algorithm is an idea, a concept. It is a description, in any form, of a process for solving a problem. Remember examples of daily-life algorithms we discussed at the beginning of the semester:
In Computer Science, we have whole courses that study algorithms.
Pseudocode is a step-by-step description of an algorithm, written for human use, not machine use.
What does that mean, exactly?
Reason one: It is easier to read and write pseudocode as people than to read and write code, especially if you are not fluent in the specific language the code is written in.
Reason two: Coding works better if we take time to design our code before we start writing it in our programming language.
An analogy: Imagine you needed to express something complicated in a language you know a little bit, but are not completely fluent in. Writing down what you want to say in your native language, and then translating it into the new language, might be a sensible way to proceed. That’s what we are doing when we write out what we want the computer to do in English, as pseudocode, first.
Algorithm drawCenteredSquares(image, color)
--- This takes an image and a color, and draws 3 squares with sizes 50, 100, 150,
--- centered in the image
1. Find out the width and height of the image
--- Calculate the midpoint of the image
2. Let midX = width / 2
3. Let midY = height / 2
4. Repeat for size = [50, 100, 150]
--- Compute the upper-left and lower-right corners of the square
5. Let ulx = midX - (size / 2)
6. Let uly = midY - (size / 2)
7. Let lrx = midX + (size / 2)
8. Let lry = midY + (size / 2)
--- Draw the square
9. Draw the square on the image using OpenCV, with
tuples (ulx, uly), (lrx, lry), color, and thickness of 2You should replace the TODO comment with a for loop that repeats six time with i as its loop variable. Inside the loop:
colors listimage with the calculated x value, and a y value of 150, a radius of 50, and the selected colorcv2 modulegrandTeton.jpg image and save it in a variablecv2 and the os moduleos.listdir("SampleImages") to get a list of the files and folders in SampleImages. Save the returned value into a variable called allFiles.
print statement, and print the value of allFiles. Examine it, make sense of what the list contains, and make sure it is doing the right thing (ask for help if it isn’t)for loop that loops over the strings in allFiles: call the loop variable name.
SampleImagesif statement to check if the current name is an image file:
name[-3:]or to perform two comparisons: Compare the sliced substring to jpg, and separately compare it to pngif is True, then:
"SampleImages/" + name"Slideshow" windowSuppose I have a list of names, and I want to make a new list that has all the names that start with a certain letter.
Algorithm selectNames(letter, nameList)Will do the rest live in the video and post the result here:
Algorithm selectNames(letter, nameList)
1. Set up answerList as an empty list
2. Loop over names in nameList, let name be the next name each time
3. If the first letter in name equals letter (from above) then
4. Add name to answerList
5. Return/output answerListSuppose I am taking a road trip, and I want to calculate how many hours I spend driving on a given day, excluding the time I might spend off the road: at a rest stop, eating, getting gas/charging my car, visiting roadside attractions. So I write down all the times when I started or stopped driving.
For example, this might be my record for one day of my trip:
We want to compute how many hours I actually spent on the road.
Step one: Representing the data (this will often be given to you). I want to represent the start and stop times in Python.
[10, 45][[8, 10], [10, 45], [11, 5], [13, 20], [14, 0], [16, 50], [18, 0], [20, 35]]Now we have refined the problem to something we can tackle: I want to write an algorithm that takes in this list of sublists, pairs up adjacent times that represent starting and stopping times, and for each calculates the time difference, and then adds them all up.
(I’ll do the rest of this live in the video, and will add the final product here)
Algorithm computeDriveTime(startStopList)
totalMins = 0
Repeat over pairs from startStopList, looking at 1st and 2nd, then 3rd and 4th, etc.
Let start be the first time of the current pair
Let stop be the second time of the current pair
Convert start to be in minutes ( start[0] * 60 + start[1] )
Convert stop to be in minutes ( stop[0] * 60 + stop[1] )
Compute elapsedMins as stop - start
Add elapsedMins to totalMins
Return totalMins / 60Indefinite looping is when the loop continues for an unknown number of repetitions. The number of repetitions depends on a boolean test: the loop continues until the test becomes False.
While loops are a more “primitive” kind of loop, more simple, leaving more responsibility on the programmer. As the programmer, you are responsible for setting up and updating the loop variable as well as any ordinary accumulator variables.
Below is a version of the Numpy arange function, but for lists. Given a starting value, and ending value, and a step size, all floating-point numbers, it produces a list containing the sequence of values starting with the starting value and increasing by step size each time, up to but not including the end point.
Processing frames from a live webcam works the same as processing saved video files (.avi or .mp4 formats). Videos are just sequences of images, but we have to talk to the operating system for permission to connect with the camera or to get the frames from a saved video.
OpenCV provides a VideoCapture object that knows how to connect to cameras or video files. We first create an instance of a VideoCapture object, and then use its read method to get the images from the video.
VideoCapture has one required input: either the number of the webcam on your system, or a string that gives the path to a saved video file. The built-in webcam is (usually) number zero.To see the frames of the video in real-time, we need to change how we use waitKey and use more of its capabilities.
Notes about waitkey:
waitKey is responsible for actually displaying the windows with imageswaitKey takes in a number, if 0, then it pauses indefinitely to wait for the user to hit a key, if the input is a positive integer, it pauses only for that many milliseconds and then returns and lets the program continuewaitKey returns a number that indicates the user’s input: -1 if they didn’t input anything, and the numeric code for the key the entered, otherwise.We started with image arithmetic and ROIs learning about how we can manipulate images. We can brighten, darken, and blend images together. We can separate an image into separate channels and manipulate those, and we can crop out regions of an image using Numpy array slicing.
Starting today, we are going to explore more image processing methods, ones that transform the image to simplify it in one way or another. We need to simplify images in order for the computer to be able to extract information from them.
Extracting information from images is the foundational goal of computer vision. By that we mean:
A mask is a black and white image (every pixel is either black or white) that we use to block out part of an image and let other parts show through.
A metaphor:
Making a mask:
There are two main ways to make a mask:
The second method is what we do with thresholding: generate black and white images
OpenCV provides a function, cvtColor, for converting from one color representation to another. The table below shows three examples of uses of this function, and when we might want to use it.
cvtColor Example |
Description |
|---|---|
cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) |
Converts img from color to grayscale |
cv2.cvtColor(img, cv2.COLOR_BGR2HSV') |
Converts img from BGR color to HSV color |
cv2.cvtColor(img, cv2.COLOR_GRAY2BGR') |
Converts img from grayscale to BGR |
In particular, we will need to convert color images to grayscale for some of the thresholding functions we will be using in the next sections. We also could create a mask with just width and height, and then turn it into a color shape using cvtColor, as well.
When we threshold an image, we separate the pixels in the image according to whether their values are above or below some threshold, or within some range. Most often, the result is a black and white image, although some threshold functions can be used in other ways.
The threshold function
img is the image to be thresholdedthreshVal is the threshold value, between 0 and 255maxVal is the value to set pixel who are over threshVal to (usually set to 255)mode specifies which of many modes to run, cv2.THRESH_BINARY is the most commonthreshImage is the returned value, a new thresholded imageThe adaptiveThreshold function
Performs similar thresholding as threshold, but it chooses a patch around each pixel and dynamically chooses the threshold value for you.
The inRange function
Works on color images, finds all pixels that lie within an input range, and marks them as white in the threshold image.
The backproject function
This one is optional at this point. We won’t need to use it, but it can be interesting to play with if you want to.
Here is the process for computing the backprojection:
backproject on a new HSV image, and it will mark the pixels that match the hues from the reference imageFALL BREAK!!