ITI Midterm 1 – Study Guide
However make sure you know range function. It is on of the keys to
the loops in python.
Module:
Import random
Arithmetic expressions in python (including +,-,*, /,
exponentiation **, integer division //, mod %, ..) :
+, -, *, /, %, **, // (2.5 – 2)
order of operations matters – BEDMAS – use brackets
Strings (including + operator being concatenation on strings):
string (“djfsdkf”)
quote = “live, love, laugh”
quote2 = quote + quote
print(“I don’t like”, end= “”)
print (“newlines”)
>>> I don’t like newlines
new lines = print(“\n” * 7)
string.capitalize() -- will capitalize string
string.find() – will return the len where the insert is in the string
string.isaplha() – string is all letter
.replace—will replace letter
.strip – take away white space
Lists:
Grocery_list = [‘Juice’, ‘Tomates’, ‘Potatoes’, ‘Bananas’]
Print(‘First Item’, grocery_list[0])
>>> First Item Juice
print(grocery_list[1:3])
>>>[‘Tomatoes’, ‘Potatoes’]
grocery_list.append(‘Onions’) --adds onions to the list
grocery_list.insert(1, “pickle”) - will add pickle in 1 position
grocery_list.remove(“pickle”) - will remove pickle
gorcery_list.sort() -- sorts list
grocery_list.reverse() --- will reverse the sort
print(len(list)) - gives the length of the items in the list
print(max(grocery_list)) --- last in terms of alphabetically order bc strings
print(min(grocery_list)) --- first in alphabetically order
Tuples:
Similar to list, but will not be able to change tuple about making it
Pi_tuple = (3,1,4,1,5,9) - round bracket instead of [] for lists
New_tuple = list(pi_tuple) - converts tuple into a list
New_list = tuple(new_tuple) - coverts list into tuple
Len(tuple) – find length the tuple
Min and max will used in same as lists
Print vs return:
print(“Hello World”)
print() doesn’t return anything
return doesn’t print anything
def f_r(x):
return x + 3 **interactive
def f_p(x):
print(x+3) **
Boolean expressions:
Data types in python:
String
Integer
Float
Type conversion:
Int(x) --- makes number into integer
Float(36) -- 36.0 - makes it a float
Str(x) --- makes it a string
Tuple(“”)
List(“”)
Function design:
Def addNumber(fNum, lNum):
sumNum = fNum = lNum
return Num
Docstrings:
‘’’ ‘’’
If statements:
If elif else ==, !=, >, <, >=, <= --- will execute code when the statements apply
Age = 21
If age > 16:
Print(“You are old enough to drive”)
Else:
Print(“You are not old enough to drive”)
If ((age =1) and (age<=18)): ** they both have to be true
If …. Or …. ** only one or the conditions has not apply
If … not …. : ***does the opposite of what is before it
Once a condition is made, the function will stop there, and will not continue on
For loops:
I want to perform something 10 times:
For x in range(0,10):
Print(x, ‘ ‘. End = “”)
For x in range(0,3):
For y in range(0,3):
While loops:
Use when you don’t know how many times you will need to use I t
__ random.randrange(0,100)
while random_sum != 15:
print(random_num)
random_num = random.randrange(0,100)
I = 100
While (1 <=20):
If (i%2==0):
Print(i)
Elif( I ==9):
Break – if we want to go out of the loop completely, not check anymore, break doesit
Else:
I += 1 ( same thing as I = i+1 )
Continue -- while go back to while loop
File:
Test_file = open(“text.txt, “wb”)
Test_file.close()
including slicing, looping over elements of the list, looping over indices
in the list
Mutable vs immutable objects (i.e. variables that refer to
immutable objects like strings, numbers and tuples vs variables
that refer to mutable objects like lists:
Mutable : Lists - can be changes after created
Immutable: strings. Numbers, tuples - cannot be changes after created
Copy vs aliasing (what is happening in the memory):
Copying: when you copy a list, you create a clone of the list. The lists have the same items, but
the lists themselves are different objects at different memory addresses.
Alias: something is a alias when they have the same memory address. U make the list == the
other list
Aliasing is one of th reasons why the notion of mutability is important. Ex) id u make changes to
list x, the same changes should be seen in list y --- this can create lots of hard to find errors ,
however this cant happen to immutable objects like strings , because a string can have be
changes after it is created.
- LOGIC/ALGORITHMS/SOLVING COMPUTATIONAL PROBLEMS
(understanding what a program/function does, writing programs etc)
including solving problems on all of the above data types: lists, strings,
... then solving problems with accumulator variables etc ...
- counting how many times something is printed
Dictionaries:
you cant join them together like you can with lists
Uses {} instead of []
The following functions (operators) appear in many of questions. Make
sure you know everything we have seen about these functions.
print
range
append
len
'in' operator
The following functions appear in at least one function. More sure you
know what these functions do.
input
sorted - returns a copy of the list where the items are in order from smallest
to largest – doesn’t mutate L
math.floor - math.floor(x) – returns the floor of x as an Integral – this is the
largest integer <= x
math.log – returns the log of x to the given base log(x,base)
.isupper (from str module) -- returns true if all characters in the string are
uppercase
***************
Finally here some type of questions that appear frequently in the
midterm:
What does the following code fragment print
or
Which of the options solves the problem correctly?
or
Which of the following algorithm(s) can be used to implement/solve
this problem?
or
What does the following function do?
or
Which of the following functions correctly computes ...
etc
