2.4 Python Exceptions and Functions

Key Points

Introduction to Python exception handling

Introduction to Python functions

Preparation Before Class

Checking Pip Commands

Input pip in the command prompt or pip or pip3 in your terminal, and you will get how to use pip.

Course Content

Exception Handling

1. Python Built-in Exceptions

What is an exception?

2. Detecting and Catching Python Exceptions

The try-except statement in Python is used to catch and handle exceptions.

It is used to test code for an error that is written in the try clause. If an error is encountered, the contents of the except clause are run. If you don't want to terminate your program when an exception occurs, just catch it in try.

Here is a simple syntax of try…except…else statement:

try:
You do your operations here;
......
except ExceptionI:
If there is ExceptionI, then execute this block.
except ExceptionII:
If there is ExceptionII, then execute this block.
......
else:
If there is no exception then execute this block.

The working principle of try-except statement is:

This example opens a file, writes content in the file, and comes out successfully because there is no problem at all:

#!/usr/bin/python

try:
   fh = open("testfile", "w")
   fh.write("This is my test file for exception handling!!")
except IOError:
   print "Error: can\'t find file or read data"
else:
   print "Written content in the file successfully"
   fh.close()

This produces the following result:

Written content in the file successfully

This example tries to open a file where you do not have write permission, so it raises an exception:

#!/usr/bin/python

try:
   fh = open("testfile", "r")
   fh.write("This is my test file for exception handling!!")
except IOError:
   print "Error: can\'t find file or read data"
else:
   print "Written content in the file successfully"

This produces the following result:

Error: can't find file or read data

Python Functions

1. Definition of Functions

You can define functions to provide the required functionality. Here are simple rules to define a function in Python:

Defining a Function

In Python, a function is defined using the def keyword.

def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x
print(my_abs(-99))

Can a function return multiple values?

import math

def move(x, y, step, angle=0):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny
x, y = move(100, 100, 60, math.pi / 6)
print(x, y)

Parameters and Arguments

In the following example, the userName is the parameter, while David is the argument.

Local Variables and Global Variables

#!/usr/bin/python
total = 0 #a global variable
#define a function
def sum(arg1, arg2):
   #return the sum of the two arguments
   total = arg1 + arg2 #total is a local variable
   print ("a local variable : ", total)
   return total
#call the sum function
sum( 10, 20 )
print("a global variable : ", total)

Declare a variable as a global variable in a function:

#Define a global variable in a function
a=0
def plus_a():
  global a
  a +=1

Arguments

1. Positional Arguments

Write a function to calculate x²:

def power(x):
    return x * x

In the power(x) function, x is a positional argument. When you call the power() function, you must pass in one and only one positional argument x.

>>> power(5)
25
>>> power(15)
225

Note that the power() function only calculates the square of a number. Then how to calculate the cube of a number or any higher power?

You can modify the function definition to accept an exponent as a second argument. Then the function changes into power(x, n).

def power(x, n):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

This function calculates the result of raising a given number x to the power of a given exponent n.

>>> power(5, 2)
25
>>> power(5, 3)
125

In the power(x, n) function, x and n are both positional arguments. When you call the power() function, the arguments are passed to the function in the order they are listed in the function definition.

2. Default Arguments

After defining the power(x, n) function, you cannot call the power(x) function successfully. This is because the new function has the same name as the old function and then replaces it. Therefore, when you try to call the old power(x) function, Python will show that the function lacks an argument.

>>> power(5)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: power() missing 1 required positional argument: 'n'

The TypeError shows that the power() function is missing one required positional argument n. In this case, you can use default arguments to call the power(x) function.

Modify the power(x, n) function to use a default value of 2 for the n parameter:

def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

In this way, when you call power(5), it's equivalent to calling power(5, 2):

>>> power(5)
25
>>> power(5, 2)
25

If you want to call the power(x, n) function with a value of n other than the default value of 2, you can pass the value as the second argument, such as power(5, 3).

Here are some tips for setting default arguments:

When a function has multiple parameters, it is recommended to place the parameters that are subject to frequent changes before the ones that remain mostly constant. The parameters that remain constant can be set as default parameters. Therefore, default arguments make the function easier to call.

3. Variable-length Arguments

Variable-length arguments are a way to pass an arbitrary number of arguments to a function. For example, the number of arguments can be one, two, or zero. There are two types of variable-length arguments, non-keyword variable-length arguments and keyword variable-length arguments.

1) Non-keyword Arguments

Suppose there is a list of a, b, c... and you want to calculate a²+b²+c²+... in Python.

To define this function, you need to determine the input parameters. Since the number of parameters is uncertain, you may want to pass a, b, c... as a list or tuple. The function can be defined as follows:

def calc(numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

You must first create a list or tuple before calling the function:

>>> calc([1, 2, 3])
14
>>> calc((1, 3, 5, 7))
84

However, you can also use variable-length arguments:

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

Variable-length arguments allow you to pass an arbitrary number of arguments directly to the function without the need for a list or tuple. You only need to add an asterisk (*) before the parameter name. Inside the function, the arguments are automatically packed into a tuple, so the function code remains unchanged. When calling the function, any number of arguments can be passed, including zero.

>>> calc(1, 2)
5
>>> calc()
0

If you already created a list or tuple, how to call a function with variable-length arguments? Input:

>>> nums = [1, 2, 3]
>>> calc(nums[0], nums[1], nums[2])
14

This method is too complicated. You can also use the * operator to unpack the elements and pass them as separate arguments to the function.

>>> nums = [1, 2, 3]
>>> calc(*nums)
14

Note: nums means passing all the elements of the nums list as variable-length arguments. This writing method is very useful and common.

2) Keyword Arguments

The above example shows that non-keyword variable-length arguments allow you to pass in any number of arguments to a function, and these arguments are automatically packed into a tuple when the function is called.

Keyword variable-length arguments, on the other hand, allow you to pass in any number of keyword arguments to a function. The arguments are automatically packed into a dictionary, and the parameter with two asterisks (**) before all the keyword arguments. For example:

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)

The function person takes three arguments. The first two arguments, name and age, are mandatory, while the third argument **kw is optional. When you call this function, you can just pass in the mandatory parameters.

>>> person('Michael', 30)
name: Michael age: 30 other: {}
#You can pass any number of arguments to the function
>>> person('Bob', 35, city='Beijing')
name: Bob age: 35 other: {'city': 'Beijing'}
>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

Then what is the use of keyword arguments? It can extend the functionality of the function.

For example, in the person function, you can not only receive the name and age parameters but also other parameters if the caller wants to provide more information.

Imagine you are designing a user registration program, you want to set the username and age as required fields and all other fields as optional. Then using keyword variable-length arguments to define a function can meet your needs.

Similar to non-keyword arguments, you can use a dictionary to pass keyword arguments to a function:

>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, city=extra['city'], job=extra['job'])
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

Of course, the above complex call can be simplified as follows:

>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **extra)
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

Extra means to pass all the key-value pairs of the variable as keyword arguments to the kw parameter of the function. The kw parameter will receive a dictionary, which is a copy of the dictionary extra. Note that changes to kw will not affect extra outside the function.