Description
There are three kinds of errors that can occur in a program. The first type of error is called a syntax
error. This kind of error is generated when a programmer does not follow the rules of constructing
a correct Python program. Forgetting to type a colon after the question in an if-statement, as
shown below, is an example of a syntax error.
The second type of error is called a runtime error. This kind of error only makes itself known when
the program is running. For example, the program below is constructed properly but the variables x
and y hold values that are incompatible. In line 3, print(x + y) says to display the sum of two numbers
or display the concatenation of two strings, but x and y are of incompatible types (they can’t be
summed nor concatenated together).
The third type of error is called a logical error. This kind of error is sometimes difficult to detect
because the program executes and the program produces results but the results are in error! Python
doesn’t flag this kind of error nor can Python detect it. It’s up to the programmer to ferret out the
mistake. These kinds of errors require a technique called debugging, the process of eliminating
errors from a program. The simplest way to debug a program is to insert print() statements in
strategic places in a program to reveal the values of important variables. Comparing these values to
those that are expected, helps pinpoint the location of an error. In a large program this can be a
daunting task. So, the rule of thumb is to enter a section of code, debug it, then and only then move
along to the next section of code to be entered. This way you have an idea of where an error is located
based on the confidence placed in the debugged code. Commenting out sections of code also helps
find where errors are located. Wing allows this to be done by selecting the lines of code to be
commented out, then, from the Source menu choosing Toggle Block Comment. Repeat the process
to undo commenting. Another way to debug a program is to use the debugging tools found in Wing
101. See the last page of this document for a quick start guide to using Wing’s debugging tools.
Debugging a computer program is an art and a programmer only gets better at it through practice,
practice, and more practice!
Use the Wing Debugger, your intuition, or place print() statements or comment out code to locate
where an error occurs in each of these Python programs. Once the error is located, correct the
program so it runs properly. Submit a zip-file containing each corrected program.
Problem A.
Each of these programs is supposed to sum the squares
of the consecutive integers between the inputs a and b
inclusive (note: make sure a <= b). For example, if a = 3
and b = 8, the sum is 32 + 42 + 52 + 62 + 72 + 82 = 199.
Make sure to test your program on more than one or
two sets of inputs to be absolutely sure your “fix” is
correct in general.
### Program A1
a = input(“a: “)
b = input(“b: “)
sumsq = 0
for k in range(int(a),int(b)):
sumsq = sumsq + k*k
print(sumsq)
Problem B.
There are runtime errors in each of the functions below. Can you correct them?
1. This function should return a list of numbers that contains all numbers less than x from num_list.
def collect_those_less_than_x(x, num_list):
new_list = []
x = 0
while x < len(num_list):
if x < num_list[x]:
new_list.append(num_list[x])
x = x + 1
return new_list
2. This function should return a list containing the reverse of the original list.
def reverse_list(lst):
rev_lst = []
i = len(lst)
while i > -1:
rev_lst.append(lst[i])
i = i + 1
return rev_lst
### Program A2
a = input(“a: “)
b = input(“b: “)
sumsq = 0
k = int(a)
while k<=int(b):
sumsq = sumsq + k*k
print(sumsq)
### Program A3
a = int(input(“a: “))
b = int(input(“b: “))
sumsq = 0
for k in range(a,b+1):
temp = 0
for u in range(1,k):
temp = temp + 1
sumsq = sumsq + temp*temp
print(sumsq)
