0% found this document useful (0 votes)
68 views8 pages

Fast Review Midterm Compilation

This document summarizes key concepts for an upcoming midterm exam. It discusses data types, functions, errors, loops, strings, lists, object-oriented programming, and graphics. Key points include different types of errors, short-circuit evaluation, slicing strings, appending vs extending lists, and how to dynamically allocate 2D lists without aliasing rows. Methods are differentiated from attributes, and drawing shapes, text, and circles on a canvas is explained.

Uploaded by

Adadad
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
68 views8 pages

Fast Review Midterm Compilation

This document summarizes key concepts for an upcoming midterm exam. It discusses data types, functions, errors, loops, strings, lists, object-oriented programming, and graphics. Key points include different types of errors, short-circuit evaluation, slicing strings, appending vs extending lists, and how to dynamically allocate 2D lists without aliasing rows. Methods are differentiated from attributes, and drawing shapes, text, and circles on a canvas is explained.

Uploaded by

Adadad
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 8

Speed Review: Midterm Edition!

Data Types/Functions
Printing with end: end parameter means the line ends with the value passed (default is ‘\n’):
print(“blah”, end=” “) ​ends line with space and next print statement starts after space

Error Types:
● Syntax: code looks grammatically bad
● Runtime: code looks grammatically ok, but runs bad
● Logical: code looks grammatically ok, runs ok, but doesn’t work like expected

Negative integer division goes down to the more negative number: ​-7//3 == 7//-3 == -3

Mod (for when negative numbers are involved): ​a%b == (a-(a//b)*b)

Exponents: read right to left (←): ​2**2**3 == 256 (2**8)

Floating-point approx. is not completely accurate/off by a bit (use math.isclose() instead): ​0.1
+ 0.1 + 0.1 != 0.3

Short circuit:
● and: False and ____
● or: True or ___

Functions always return None if no return statement is specified

Assert crashes if it’s false


Loops
For loops: when you know the exact number of times to loop (i.e. wash plates 5 times)
While loops: when you don’t know the exact number of times to loop - usually have a condition
instead (i.e. wash plates until done)

range(start, end, step)


● Start: included
● End: excluded

Sum digits:
def sumDigits(n):
total = 0
while n > 0:
total += n % 10
n //= 10
return total

Nth template:
def nthBlah(n):
guess = 0
found = 0
while found <= n:
guess += 1
if isBlah(guess):
found += 1
return guess

Best template (largestNumber example: takes a string and finds the largest number)
Key idea: having a best and current variable and updating them appropriately
def largestNumber(s):
best = 0
current = 0
for c in s:
if c.isdigit():
current = current * 10 + int(c)
else:
if current > best:
best = current
current = 0
if current > best: # for when the entire string is a number
best = current
return best
Strings
Strings are immutable!!! (no .pop(), .remove(), etc.) instead: s = s[:index] + s[index + 1:]

String index example (including negative equivalents):


“ h e l l o w o r l d “

0 1 2 3 4 5 6 7 8 9 10

-11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1

Escape sequences that are actually length 1 (Note ​\ ​by itself/not escape sequence is length 1):
● \”
● \\
● \n
● \t

Multiplying strings is ok: ​“wow” * 3 == “wowwowwow”

Slicing: ​s[start:end:step]
● Start: inclusive
● End: exclusive
● s[index:] ​index to end
● s[:index] ​up to index (exclusive)
● s[::-1] ​reverse string
● Watch out for bad direction: ​s[0:2:-1] == “”

Some particularly useful functions:


● s.replace(old, new[, max]) ​replaces instances of ​old​ in ​s​ with ​new​ (optional
max​ parameter)
● s.count(substring)​ returns number of times ​substring​ appeared in ​s
● s.startswith(substring)​ checks if ​s​ started with ​substring
● s.endswith(substring)​ similar idea to above/startswith
● s.find(substring)​ returns starting index of ​substring​ in ​s
○ Does​ ​not crash ​if substring doesn’t exist, ​returns -1 instead
● s.index(substring)​ exact same idea to above/find but:
○ Crashes ​if substring doesn’t exist
1D Lists
Appending vs. extending:
Append creates another cell and puts whatever parameter was passed inside the cell
Extend concatenates the parameter (must be a list) to the list
L = [1, 2, 3]
L.append([4]) == [1, 2, 3, [4]]
L.extend([4]) == [1, 2, 3, 4]
(Note extend() behaves somewhat similarly to the following, but they are not the same!):
L += [4] == [1, 2, 3, 4]
L = L + [4] == [1, 2, 3, 4]

Destructive vs. Non-destructive Methods (Particularly confusing ones highlighted):


Non-Destructive Destructive

● L = L + lst ● L += lst
● L = L[:index] ● L.extend(lst)
● sorted(L) ● L.append(item)
● reversed(L) ● L.insert(index, item)
● L.index(index) ● L[index] = value
● L.count(item) ● del L[index]
● L.remove(item)
● L.pop(index)
● del(L[:index])
● L.sort()
● L.reverse()

Aliasing vs. copying without aliasing


Copying without aliasing Aliasing

● a = copy.copy(b) ● a = b
● a = copy.deepcopy(b)
● a = b + []
● a = b[:]
● a = list(b)

.pop()​ removes the last value of the list if no index is specified and returns the popped value

Some useful builtins:


● L.count(item) ​returns the number of occurrences of item in L
● L.sort() or sorted(L) ​sort a list in order
● L.reverse() or reversed(L) ​reverse a list (most useful for looping through a list
backwards!: ​for item in reversed(L)​)

Tuples are immutable!


2D Lists
Starting a 2D list
● Static allocation (w/ fixed values): ​L = [[1, 2], [3, 4]]
● Dynamic allocation (variable-length):
○ DO NOT (will alias rows): ​L = [[0] * cols] * rows
○ DO: ​for row in range(rows): L += [[0] * cols]
○ DO: ​L = [[0] * cols for row in range(rows)]

copy.copy(L)​ now does a shallow copy (the rows will be aliased still)
copy.deepcopy(L)​ instead (Note: pretty much any copy is a shallow copy except for
copy.deepcopy)

See 1D list notes for row-wise aliasing


OOP
Main idea: If you want to make objects that contain specific ​qualities​ and ​abilities​, use classes!
● Attributes: The qualities of your objects, define them in __init__ (Ex: name, physics
attributes, etc.)
● Methods: The abilities of your objects, define them as methods within your class (Ex:
move(), eat(), etc.)

All class methods pass self as an attribute!

How to differentiate methods vs attributes when reading code: methods end with () but attributes
do not!
● dog.isRunning -> attribute (no parentheses)
● dog.run() -> method (parentheses!)
Graphics
Drawing methods:
● Shapes (Note: dimensions can be inputted as a list)
○ canvas.create_rectangle(topX, topY, bottomX, bottomY)
○ canvas.create_oval(topX, topY, bottomX, bottomY)
■ When creating a circle, do it relative to the center: ​cx - r, cy - r,
cx + r, cy + r
○ canvas.create_polygon(x1, y1, x2, y2, x3, y3, etc..)
○ canvas.create_line(x1, y1, x2, y2)
■ Does not have outline parameter
○ Extra parameters:
■ fill [color string]: specify color to fill
■ width [float or int]: specify thickness of outline
■ outline [color string]: specify color for outline
● Text:
○ canvas.create_text(x, y, text = [string])
■ fill [color string]: text color
■ font [string]: format: ​Font type_Font size_Extra features
■ anchor [string]: default = “CENTER” (see below for others):

Anchors relative to canvas:


SE S SW

E CENTER W

NE N NW

Drawing circles given center x (​cx​), center y (​cy​), angle (in radians, so use ​math.pi​), and
radius (​r​):
● x = cx + r * math.cos(angle)
● y = cy - r * math.sin(angle)

 
 
 
 
 
 
 
YOU CAN DO IT!!!! :) 

You might also like