Python - Control Flow, Errors, & Exceptions

Question 1

Which of the following have their own scope?

functions
list comprehensions
generator comprehensions
try-except blocks
for + while loops
classes

Answer 1

These have their own scope:

functions
list comprehensions
generator comprehensions
classes

These do not have their own scope:
(and hence you can access their variables that are inside the block outside of it)

try-except blocks
for + while loops

Question 2

Which statement DOES NOT ALLOW you to print ( i ) due to i not being in scope?
\_\_\_\_\_
mylist = [i for i in range(5)]
print(mylist)
print(i)

_____

mylist2 = []
for i in range(5):
mylist2.append(i)

print(mylist2)
print(i)

Answer 2

The former DOES NOT work and i is out of scope:

mylist = [i for i in range(5)]
print(mylist)
print(i)

_____
The latter allows you to reference i outside the block since it is still in scope (loops don’t have scope):

mylist2 = []
for i in range(5):
mylist2.append(i)

print(mylist2)
print(i)

Question 3

What does ‘break’ do in this statement?

while a < 10:
    while b < 5:
        if c == someNumber:
            break
        else:
            ....

Answer 3

‘break’ automatically jumps you out of the innermost loop that you are currently in

(so the inner while loop)

Question 4

What does ‘pass’ do in this statement?

while a < 10:
    while b < 5:
        if c == someNumber:
            pass
        else:
            ....

Answer 4

What does ‘pass’ do in this statement?

‘pass’ automatically jumps to the next iteration of the innermost loop you are currently in

Question 5

What does ‘pass’ do in this statement?

def some_function():
    pass

Answer 5

What does ‘pass’ do in this statement?

‘pass’ automatically allows the function to keep running regardless whether you return a statement or not

Question 6

What does ‘try-except’ do in the following?

try:
…some code…

except:
…some different code…

Answer 6

If the code in the try block doesn’t work it goes to the code in the except block.

Question 7

What does ‘try-except’ do in the following?

try:
…some code…

except someExceptionErrorHere:
…some different code…

except someOtherExceptionErrorHere as aliasHere:
…I can reference ‘alias’ here…
…like print(alias)…
…some different code…

except:
…some different code…

Answer 7

If the code in the try block doesn’t work it goes to the code in the first except block if that exception is valid, else it goes to the next except block where you can now reference the error as an alias, and if this except block doesn’t work then you can go to the “catch-all” exception block which is the last one.

Question 8

How can I use try-except to debug when the following loop fails?

for i in range(5):
   if someCondition:
      ....
   else:
      ....

Answer 8

I can debug by embedding the for loop in the try block, and printing anything that throws in error in the except block:

try:
    for i in range(5):
        if someCondition:
            ....
    else:
        ....

except:
print( f ‘ The loop goes wrong at iteration { i } ‘ )

_____
***notice how I can still reference variable i outside the try block and outside the for loop. That is because try blocks and for loops don’t have a concept of scope.

Question 9

Is it good practice to use ASSERT statements for program control flow?

How do ASSERT statements work?

Answer 9

No! ASSERTS should be used for debugging only! If you wanna continue having the program run and are just trying to control the flow, use conditionals / loops / breaks / pass / try-excepts…NOT assert statements.

_____

Python has built-in assert statement to use assertion condition in the program. assert statement has a condition or expression which is supposed to be always true. If the condition is false assert halts the program and gives an AssertionError.

Syntax for using Assert in Python:

assert
assert ,

Question 10

What’s a smart way to use try-except for any possible division error below?

def divide(x, y):
    return x / y

Answer 10

def divide(x, y):
    try:
        return x / y
    except ZeroDivisionError:
        if x == 0:
             return float('NaN')
        return float('inf')

Question 11

How would you use try-except to catch different scenarios in the below WITHOUT using multiple except blocks?

Let’s say you want to capture ZeroDivisionErrors and TypeErrors

***Hint: use tuples

def divide(x, y):
    return x / y

Answer 11

def divide(x, y):
  try:
    return x / y
  except (ZeroDivisionError, TypeError):
    return 'Error!'

Question 12

What would the following program output, assuming the user types “abc”? (Note that the options below do not include what the user types)

try:
    my_number = int(input('Enter number: '))
    print(my_number + 1)
except ValueError:
    print('Oh no!')

___ 1 ___

Enter number:
Traceback (most recent call last): File “python”, line 1, in ValueError: invalid literal for int() with base 10: abc
Oh no!

___ 2 ___

Enter number:
Oh no!

___ 3 ___

Enter number:
Oh no!
1

___ 4 ___

Enter number:
Traceback (most recent call last): File “python”, line 1, in ValueError: invalid literal for int() with base 10: abc

Answer 12

try:
    my_number = int(input('Enter number: '))
    print(my_number + 1)
except ValueError:
    print('Oh no!')

___ 2 ___

Enter number:
Oh no!

Question 13

What does the word ‘raise’ by itself do?

Answer 13

The raise statement allows the programmer to force a specified exception to occur. For example:

> > > raise NameError(‘HiThere’)
Traceback (most recent call last):
File “”, line 1, in
NameError: HiThere

The sole argument to raise indicates the exception to be raised. This must be either an exception instance or an exception class (a class that derives from Exception). If an exception class is passed, it will be implicitly instantiated by calling its constructor with no arguments:

> > > raise ValueError # shorthand for ‘raise ValueError()’

If you need to determine whether an exception was raised but don’t intend to handle it, a simpler form of the raise statement allows you to re-raise the exception to pass back up and outside the code black:

>>> try:
...     raise NameError('HiThere')
... except NameError:
...     print('An exception flew by!')
...     raise
...
An exception flew by!
Traceback (most recent call last):
  File "", line 2, in 
NameError: HiThere

Question 14

What does the word ‘finally’ do?

Answer 14

A finally clause is always executed before leaving the try statement, whether an exception has occurred or not.

When an exception has occurred in the try clause and has not been handled by an except clause (or it has occurred in an except or else clause), it is re-raised after the finally clause has been executed. The finally clause is also executed “on the way out” when any other clause of the try statement is left via a break, continue or return statement.

>>> try:
...     raise KeyboardInterrupt
... finally:
...     print('Goodbye, world!')
...
Goodbye, world!
KeyboardInterrupt
Traceback (most recent call last):
  File "", line 2, in

Question 15

# This program tries to gracefully handle the case
# where the user enters a non-integer. See if you
# can fix it!

try:
number = int(input(‘Enter number: ‘))
print(‘You typed: {0}’.format(number))
except IndexError:
print(‘You must enter an integer!’)

Answer 15

try:
number = int(input(‘Enter number: ‘))
print(‘You typed: {0}’.format(number))
except ValueError:
print(‘You must enter an integer!’)

Question 16

# This program tries to define an exception class
# and a function that uses that exception class.
# If a negative number is entered, the program
# should print the message given as an argument
# to the constructor of the exception class. See
# if you can fix it!

class NegativeNumberException:
    pass

def retrieve_non_negative_number():
number = int(input(‘Enter non-negative number: ‘))
if number <= 0:
raise NegativeNumberException(‘The number
cannot be negative!’)
return number

try:
print(retrieve_non_negative_number())
except NegativeNumberException as e:
print(e)

Answer 16

# This program tries to define an exception class
# and a function that uses that exception class.
# If a negative number is entered, the program
# should print the message given as an argument
# to the constructor of the exception class. See
# if you can fix it!

class NegativeNumberException(Exception):
    def \_\_init\_\_(self, message):
      self.message = message

def retrieve_non_negative_number():
number = int(input(‘Enter non-negative number: ‘))
if number < 0:
raise NegativeNumberException(‘The number
cannot be negative!’)
return number

try:
print(retrieve_non_negative_number())
except NegativeNumberException as e:
print(e)

Question 17

Write a program with a function called retrieve_integer. This function should ask the user for a number. If they enter an integer, return that integer, if they enter a non-integer, your function should print “Uh oh!”. However, the exception should not stop there; it should continue to wherever your function was called! (Consider using the word raise by itself here.)

Your prompt should look like this:

Enter number:
Your submission should include only your function definition.

Answer 17

def retrieve_integer():

  try:
      user_num = int(input('Enter number: '))
      return user_num
  except ValueError:
      print('Uh oh!')
      raise

\_\_\_\_
# to test it you can run:

try:
print(retrieve_integer())
except ValueError:
print(‘ValueError caught!’)

Question 18

Write a program that reads a file called numbers.txt that is supposed to contain only numbers, one per line. However, the file might contain some accidental non-numerical text as well. Your program should ignore the non-numerical lines and print the sum of the numbers it finds.

Say, for example, that numbers.txt contains the following:

1
2
abc
3
4
Your program should output:

10

Answer 18

current_sum = 0

with open('numbers.txt', 'r') as f:
    for line in f:
        try:
            current_sum += int(line)
        except:
            pass

print(current_sum)

Question 19

What are the 5 reserved words you have with exceptions and what do they do?

Answer 19

try: code block that attempts to execute
except: code block(s) which are thrown if there is an error
else: code block that executes after the try statement IF NO exceptions were caught. You can write this after the except blocks.
finally: code block that executes at the end of try block (and after excepts) regardless of whether exception is thrown or not. ***A return statement embedded within either the try/except blocks will always cause the finally block to execute first before the return!
raise: re-throws the exception to capture later (used within the else blocks