COMP 204 Final

Converting from binary to decimal
(i.e. 11010)

(1*2^4)+(1*2^3)+(0*2^2)+(1*2^1)+(0*2^0) \= 26

Converting from decimal to binary

divide by two and take remainder, then continue until result is 0 and write reminders from bottom (2/2 or 1/2) to top (initial number)

int type

integer without decimal

float type

integer with decimal

modulus (%)

returns remainder

division (/)

gives a float number even if both are integers

floor division (//)

rounds down to nearest whole number, will be a float if at least one number is a float

print("Hello " + "World")

Hello World
Concatenation

print("Hello " * 5)

Hello Hello Hello Hello Hello

How to swap variables

X \= 137
y \= 42
temp \= x
x \= y
y \= temp

input()

pauses program and waits for user to type information and press enter

math.pi

value of pi
need to input math first

math.factorial()

Returns the factorial of a number

when is None returned

when no return statement is in the function

slicing strings

fruit \= "banana"
print(fruit[:3])

ban

variable.upper()

makes string variable upper case (can also do lower)

variable.startswith("something")

if the string variable starts with "something", it will return True (can also do .endswith)

while loop

while CONDITION:
\>>statement_block
(can create a counter and increment it a certain amount of times)

break

stops a loop during its execution

for loop

for VARIABLE in OBJECt:
\>>> STATEMENT_BLOCK

for range loop

for VARIABLE in range(start,stop, step)

recursion

calls a function within itself

string{}.format(x)

replaces {} with X

Specify decimal points

{:.nf} where n is the decimal points
- use with .format to input a value

are strings mutable

no

are lists mutable

yes
can say list[1] \= new_value and it will be replaced

traversing a list

for variable in range(len(list))

Concatenate a list

new_list \= list1 + list2

repeating a list

zeros \= [0] * 5
\[0,0,0,0,0]

equality of lists

only the same if the lists have the same elements in the same order

list slicing

t \= [1,2,3,4,5]
print(t[start:stop:step)

call a function

function_name(arguments)

call a method (a function that belongs to an object)

object.method_name(arguments)

list.append(element)

adds new elements to the end of the list
-does not return a value

list.extend(other_list)

adds all elements of a list to the end of the other without changing the added list
-does not return a value

list.insert(index, value)

inserts an element at a particular index and moves all other elements to the right
-does not return a value

list.sort()

sorts elements in a list
and does not return a value

element.isupper()

True if the element is uppercase

Can you add a method that does not return a value to a variable?

no

del names [start,stop,step]

deletes list elements

remove \= list.pop(index)

removes the element from the list and returns it in the variable

list.remove(element)

Removes the first matching element from a list.
return value is None

list.index(element)

returns the index of the first matching item in a list

new \= list.count(element)

returns the number of occurences of an element in a list

len(list)

Find the length of the list.

min(list)

Get the minimum element in the list.

max(list)

Find the element in list with the largest value.

sum(list)

Find the sum of all elements of a list (numbers only).

splitting \= list.split(delimiter)

will split the list according to the value in the delimiter

joining \= delimiter.join(list)

joins a list of strings and concatenates the elements at the delimiter

new_list \= list[:]

makes a clone of a list

dictionary[key] \= value

-add new key value pair

dictionary.values()

Returns view of all values in dictionary

keys \= list(dictionary)

returns a list of the keys

dictionary.update(other_dictionary)

combines two dictionaries

tuple \= (element,)

needs the comma after if just one element

can tuples be modified?

no, they are immutable and elements can not be added or removed but can be replaced with another tuple (len,min,max, and sum work the same)

new_set \= set([list])

adds all unique items from a list to an unordered set. can also add immutable objects with set \= (tuple)

set.add(element)

adds an element to a set

set.remove(element)

removes element from a set

common \= setA.intersection.setB

returns a new set of the common values of sets A and B

union \= setA.union(setB)

returns a new set that is a union of sets A and B

diff \= setA.difference(setB)

returns a new set that is the set difference of sets A and B

Handling an exception

try:
\>> \#code that isn't trusted

except EXCEPTION TYPE
\>> action

finally:
\>>anything here will always be printed

raise Value Error

proactively cause an error so this doesn't disrupt the rest of the code

fobj \= open(filename."r")

reads file

fobj \= open(filename."w")

writing or overwriting if the file already exists

fobj \= open(filename. "a")

appends to the end of a file

file_content \= fobj.read()

returns a string containing file content

for line in fobj:
\>>words \= line.split(delimiter)

produces a sequence of lines contained in the file separated with delimiter

content \= fobj.readlines()

returns a list containing each line in the file

content \= fobj.write(writing \n)

writes string on new line (\t is new tab)

for line in fobj:
\>>list \= line.strip()

gets rid of all \n in a CSV file

Local scope variable

variable only exists within a function - python assumes local scope

Binary Search Algorithm

def search(seq, item)
\>>low \= 0
\>>high \= len(seq) -1
\>>while low < \= high
\>> mid \= (low+high)//2
\>> if seq[mid] < item:
\>> low \= mid +1
\>> elif seq[mid] \> item:
\>> high \= mid - 1
\>> else:
\>> return mid
return None

Selection Sort Algorithm

def sort(seq):
\>>N \= len(seq)
\>>for i in range(N):
\>> min \= i
\>> for k in range(i+1, N):
\>> if seq[k]

Two List Insert Sort

def insert(sort,unsort):
\>>for item in unsort:
\>> if item\>sort[-1]:
\>> sort +\=[item]
\>> continue
\>> for i in range(len(sort):
\>> if sort[i] < item:
\>> continue
\>> else:
\>> half1 \= sort[0:index]
\>> half2 \= sort[index:]
\>> sort \= half1 +[i] + half2
\>> break
\>>return sort

plt.plot(values)

plots the values

import matplotlib.pyplot as plt

imports Matplotlib to plot data

plt.show()

displays the graph

plt.title("label", fontsize)
plt.ylabel
plt.xlabel

inputs titles, along with x and y label

plt.bar(x axis, y axis, width, color)

Creates a bar graph

plt.scatter(x,y,size, marker, color)

Creates a scatter plot

plt.savefig(file.png)

saves a figure

array \= np.array([list],dtype\=int/np.float)

creates a NumPy array which is different from a regular array as it can not change its size and all values must be the same type

np.shape()

indicates the length in each dimension

np.zeros(number)

creates an array of zeros with shape of the number

np.ones(number)

creates an array of 1s with shape of the number

np.full(shape,value)

creates an array of shape shape with value value

np.arange(start, stop, step)

An array of number starting with start, going up in increments of step, and going up to but excluding step.

np.linespace(start,stop,\# in list)

creates a list of evenly-spaced numbers within a range

np.sin(array)

broadcasts math function to all elements in the array

np.exp(array)

broadcasts exponents to all elements

Vectorized numpy arrays

array1 + array2
does math function on an element-by-element basis

copy \= np.copy(array)

gets a copy of an array

size \= np.reshape(array(r,c))

reshapes an array to one with 2 rows and 3 columns

matrix[rstart: rstop: rstep, cstart: cstop: cstep]

slices a matrix with row slices, colum slices

OOP objects

objects all have data and methods that belong to a single theme

OOP Class

keyword to declare code belonging to an object

OOP Instance

the action of creating an object from a class