Exceptions

An exception is an error that occurs while a program is running, causing the program to abruptly halt. Some exceptions cannot be avoided regardless of how carefully a program is written.

Python, like most modern programming languages, allows you to write code that responds to exceptions when they are raised, and prevents the program from abruptly crashing. Such code is called an exception handler and is written with the try/except statement. There are several ways to write a try/except statement, but the following general format shows the simplest variation:

try:

statement

statement

etc.

except  ExceptionName:

statement

statement

etc.

First the key word try appears, followed by a colon. Next, a code block appears which we will refer to as the try suite. The try suite is one or more statements that can potentially raise an exception.

After the try suite, an except clause appears. The except clause begins with the key word except, optionally followed by the name of an exception, and ending with a colon. Beginning on the next line is a block of statements that we will refer to as a handler.

When the try/except statement executes, the statements in the try suite begin to execute. The following describes what happens next:

• If a statement in the try suite raises an exception that is specified by the ExceptionName in an except clause, then the handler that immediately follows the except clause executes. Then, the program resumes execution with the statement immediately following the try/except statement.

• If a statement in the try suite raises an exception that is not specified by the ExceptionName in an except clause, then the program will halt with a traceback error message.

• If the statements in the try suite execute without raising an exception, then any except clauses and handlers in the statement are skipped and the program resumes execution with the statement immediately following the try/except statement.

Handling Multiple Exceptions

In many cases, the code in a try suite will be capable of throwing more than one type of exception. In such a case, an except clause for each type of exception has to be written that you want to handle.

def main():

# Initialize an accumulator.

total = 0.0

try:

# Open the sales_data.txt file.

infile = open('sales_data.txt', 'r')

# Read the values from the file and

# accumulate them.

for line in infile:

amount = float(line)

total += amount

# Close the file.

infile.close()

# Print the total.

print(format(total, ',.2f'))

except IOError:

print('An error occured trying to read the file.')

except ValueError:

print('Non-numeric data found in the file.')

except:

print('An error occured.')

# Call the main function.

main()

If an exception occurs in the try suite, the Python interpreter examines each of the except clauses, from top to bottom, in the try/except statement. When it finds an except clause that specifies a type that matches the type of exception that occurred, it branches to that except clause. If none of the except clauses specifies a type that matches the exception, the interpreter branches to the except clause.

Using One except Clause to Catch All Exceptions

Sometimes you might want to write a try/except statement that simply catches any exception that is raised in the try suite and, regardless of the exception’s type, responds the same way. This can be accomplished by a try/except statement by writing one except clause that does not specify a particular type of exception.

def main():

# Initialize an accumulator.

total = 0.0

try:

# Open the sales_data.txt file.

infile = open('sales_data.txt', 'r')

# Read the values from the file and

# accumulate them.

for line in infile:

amount = float(line)

total += amount

# Close the file.

infile.close()

# Print the total.

print(format(total, ',.2f'))

except:

print('An error occured.')

# Call the main function.

main()

Displaying an Exception’s Default Error Message

When an exception is thrown, an object known as an exception object is created in memory. The exception object usually contains a default error message pertaining to the exception. When an except clause is written, the exception object can be optionally assigned to a variable, as shown here:

except ValueError as err:

This except clause catches ValueError exceptions. The expression that appears after the except clause specifies that we are assigning the exception object to the variable err.

The else Clause

The try/except statement may have an optional else clause, which appears after all the except clauses. Here is the general format of a try/except statement with an else clause:

try:

statement

statement

etc.

except ExceptionName:

statement

statement

etc.

else:

statement

statement

etc.

The block of statements that appears after the else clause is known as the else suite. The statements in the else suite are executed after the statements in the try suite, only if no exceptions were raised. If an exception is raised, the else suite is skipped.

The finally Clause

The try/except statement may have an optional finally clause, which must appear after all the except clauses. Here is the general format of a try/except statement with a finally clause:

try:

statement

statement

etc.

except ExceptionName:

statement

statement

etc.

finally:

statement

statement

etc.

The block of statements that appears after the finally clause is known as the finally suite. The statements in the finally suite are always executed after the try suite has executed and after any exception handlers have executed. The statements in the finally suite execute whether an exception occurs or not. The purpose of the finally suite is to perform cleanup operations, such as closing files or other resources.

Processing Records

The data that is stored in a file is frequently organized in records. A record is a complete set of data about an item, and a field is an individual piece of data within a record.

Each time a record is written to a sequential access file, the fields that make up the record, are written one after the other.

When a read is made of record from a sequential access file, the data for each field is read one after the other, until we have read the complete record.

Programs that store records in a file typically require more capabilities than simply writing and reading records such as adding records to a file, searching a file for specific records, modifying a record, and deleting a record.

Using Loops to Process Files

When a program uses a file to write or read a large amount of data, a loop is typically involved. Quite often a program must read the contents of a file without knowing the number of items that are stored in the file.

In Python, the readline method returns an empty string (' ') when it has attempted to read beyond the end of a file. This makes it possible to write a while loop that determines when the end of a file has been reached.

Here is the general algorithm, in pseudocode:

Open the file

Use readline to read the first line from the file

While the value returned from readline is not an empty string:

Process the item that was just read from the file

Use readline to read the next line from the file.

Close the file

Using Python’s for Loop to Read Lines

The Python language also allows you to write a for loop that automatically reads line in a file without testing for any special condition that signals the end of the file.

Here is the general format of the loop:

for variable in file_object:

statement

statement

etc.

In the general format, variable is the name of a variable and file_object is a variable that references a file object. The loop will iterate once for each line in the file.

Example:

# This program uses the for loop to read

# all of the values in the sales.txt file.

def main():

# Open the sales.txt file for reading.

sales_file = open('sales.txt', 'r')

# Read all the lines from the file.

for line in sales_file:

                        # Convert line to a float.

amount = float(line)

# Format and display the amount.

print(format(amount, '.2f'))

 # Close the file.

sales_file.close()

 # Call the main function.

main()
 

Files

Data is saved in a file, which is usually stored on a computer’s disk. Once the data is saved in a file, it will remain there after the program stops running. Data that is stored in a file can be retrieved and used at a later time. Programs that are used in daily business operations rely extensively on files.

Programmers usually refer to the process of saving data in a file as “writing data to” the file. The term output file is used to describe a file that data is written to. The process of retrieving data from a file is known as “reading data from” the file. The term input file is used to describe

a file that data is read from.

There are always three steps that must be taken when a file is used by a program.

1. Open the file: Opening a file creates a connection between the file and the program. Opening an output file usually creates the file on the disk and allows the program to write data to it. Opening an input file allows the program to read data from the file.

2. Process the file: in this step data is either written to the file (if it is an output file) or read from the file (if it is an input file).

3. Close the file: when the program is finished using the file, the file must be closed. Closing a file disconnects the file from the program.

In general, there are two types of files: text and binary.

A text file contains data that has been encoded as text, using a scheme such as ASCII or Unicode. Even if the file contains numbers, those numbers are stored in the file as a series of characters. The file may be opened and viewed in a text editor such as Notepad.

A binary file contains data that has not been converted to text. The data that is stored in a binary file is intended only for a program to read.

Most programming languages provide two different ways to access data stored in a file:

sequential access and direct access.

In order for a program to work with a file on the computer’s disk, the program must create a file object in memory. A file object is an object that is associated with a specific file and provides a way for the program to work with that file. In the program, a variable references the file object. This variable is used to carry out any operations that are performed on the file.

Opening a File

The open function creates a file object and associates it with a file on the disk. Here is the general format of how the open function is used:

file_variable = open(filename, mode)

In the general format:

• file_variable is the name of the variable that will reference the file object.

• filename is a string specifying the name of the file.

• mode is a string specifying the mode (reading, writing, etc.) in which the file will be

opened.

File modes used are:

When you pass a file name that does not contain a path as an argument to the open function, the Python interpreter assumes that the file’s location is the same as that of the program.

If to open a file in a different location, specify a path as well as a filename in the argument that is passed to the open function. If you specify a path in a string literal (particularly on a Windows computer), be sure to prefix the string with the letter r.

Here is an example:

test_file = open(r 'C:\Users\Ashraf\temp\test.txt', 'w')

The r prefix specifies that the string is a raw string. This causes the Python interpreter to read the backslash characters as literal backslashes. Without the r prefix, the interpreter would assume that the backslash characters were part of escape sequences, and an error would occur.

Writing Data to a File

Once you have opened a file, you use the file object’s methods to perform operations on the file. File objects have a method named write that can be used to write data to a file. Here is the general format of how you call the write method:

file_variable.write(string)

In the format, file_variable is a variable that references a file object, and string is a string that will be written to the file. The file must be opened for writing (using the 'w' or 'a' mode) or an error will occur.

Once a program is finished working with a file, it should close the file. Closing a file disconnects the program from the file. The process of closing an output file forces any unsaved data that remains in the buffer to be written to the file.

In Python you use the file object’s close method to close a file. For example, the following statement closes the file that is associated with customer_file:

customer_file.close()

Storing Functions in Modules

A module is simply a file that contains Python code. A large program can be made into smaller modules, and each module contains functions that perform related tasks. With this Large programs are easier to debug and maintain when they are divided into modules.

This approach, which is called modularization, makes the program easier to understand, test, and maintain.

Modules also make it easier to reuse the same code in more than one program. Import the module in each program that needs to call one of the module functions.

import circle

When the Python interpreter reads this statement it will look for the file circle.py in the same folder as the program that is trying to import it. If it finds the file, it will load it into memory. If it does not find the file, an error occurs. Once a module is imported you can call its functions.

Generating Random Numbers

Random numbers are useful for lots of different programming tasks. The following are just a few examples.

• Random numbers are commonly used in games.

• Random numbers are useful in simulation programs.

• Random numbers are useful in statistical programs that must randomly select data for analysis.

• Random numbers are commonly used in computer security to encrypt sensitive data.

Python provides several library functions for working with random numbers. These functions are stored in a module named random in the standard library.

To use functions form random module, import statement is used at the top of your program:

import random

This statement causes the interpreter to load the contents of the random module into memory.

1. randint ( random-number generating function)

The following statement shows an example of how you might call the randint function.

number = random.randint (1, 100)

this function takes two arguments for range to generate random numbers.

2. The randrange, random, and uniform Functions

The randrange function takes the same arguments as the range function. The difference is that the randrange function does not return a list of values. Instead, it returns a randomly selected value from a sequence of values.

For example, the following statement assigns a random number in the

range of 0 through 9 to the number variable:

number = random.randrange(10)

The argument, in this case 10, specifies the ending limit of the sequence of values. The function will return a randomly selected number from the sequence of values 0 up to, but not including, the ending limit.

The following statement specifies both a starting value and an ending limit for the sequence:

number = random.randrange(5,10)

When this statement executes, a random number in the range of 5 through 9 will be assigned to number

The following statement specifies a starting value, an ending limit, and a step value:

number = random.randrange(0, 101, 10)

Both the randint and the randrange functions return an integer number.

The random function returns a random floating-point number. No arguments are passed to the random function. When a call is made to it, it returns a random floating point number in the range of 0.0 up to 1.0 (but not including 1.0).

Here is an example:

number = random.random()

The uniform function also returns a random floating-point number, but allows specifying the range of values to select from.

Here is an example:

number = random.uniform(1.0, 10.0)

In this statement the uniform function returns a random floating-point number in the range of 1.0 through 10.0 and assigns it to the number variable.

Standard Library functions

Python, as well as most other programming languages, comes with a standard library of functions that have already been written( known as library functions ). Many of the functions in the standard library, however, are stored in files that are known as modules. These modules, which are copied to your computer when you install Python, help organize the standard library functions.

In order to call a function that is stored in a module, you have to write an import statement at the top of your program. An import statement tells the interpreter the name of the module that contains the function.

Ex:

import math

The math module contains various mathematical functions that work with floatingpoint numbers.

Ø  The math Module

The math module in the Python standard library contains several functions that are useful for performing mathematical operations. These functions typically accept one or more values as arguments, perform a mathematical operation using the arguments, and return the result.

The math module also defines two variables, pi and e, which are assigned mathematical values for pi and e. These variables can be used in equations that require their values.

Example:

area = math.pi * radius**2

Value Returning Functions

A value-returning function is a function that returns a value back to the part of the program that called it.

A value-returning function is a special type of function.

• It is a group of statements that perform a specific task.

• When you want to execute the function, you call it.

When a value-returning function finishes, it returns a value back to the part of the program that called it.

Syntax:

def fun():

    statements

    .

    .

    return [expression]

Example:

# Python program to demonstrate return statement

def add(a, b):

            # returning sum of a and b

            return a + b

def is_true(a):

            # returning boolean of a

            return bool(a)

# calling function

res = add(2, 3)

print("Result of add function is {}".format(res))

res = is_true(2<5)

print("\nResult of is_true function is {}".format(res))

Global Variables and Global Constants

When a variable is created by an assignment statement that is written outside all the functions in a program file, the variable is global. A global variable can be accessed by any statement in the program file, including the statements in any function.

Example:

#Create a global variable.

 number = 0

def main():

show_number()

def show_number():

print('The number you entered is', number)

# Call the main function.

main()

An additional step is required if you want a statement in a function to assign a value to a global variable.

Example:

Most programmers agree to restrict the use of global variables, or not use them at all. The reasons are as follows:

• Global variables make debugging difficult. Any statement in a program file can change the value of a global variable. In a program with thousands of lines of code, it can be difficult to track down the statement which is changing to wrong value in global variable.

• Functions that use global variables are usually dependent on those variables. To use such a function in a different program, most likely you will have to redesign it so it does not rely on the global variable.

• Global variables make a program hard to understand. A global variable can be modified by any statement in the program. If you are to understand any part of the program that uses a global variable, you have to be aware of all the other parts of the program that access the global variable.

Ø  Global Constants

A global constant is a global name that references a value that cannot be changed. Because a global constant’s value cannot be changed during the program’s execution, the potential hazards that are associated with the use of global variables are avoided.

Although the Python language does not allow you to create true global constants, you can simulate them with global variables. If you do not declare a global variable with the global key word inside a function, then you cannot change the variable’s assignment inside that function.

Passing Arguments to Functions

An argument is any piece of data that is passed into a function when the function is called. A parameter is a variable that receives an argument that is passed into a function.

If a function needs to receive arguments when it is called, the function must have with one or more parameter variables. A parameter variable, often simply called a parameter, is a special variable that is assigned the value of an argument when a function is called. A function may not take any parameters, may take one parameter or take multiple parameters.

Example:

In addition to this conventional form of argument passing, the Python language allows you to write an argument in the following format, to specify which parameter variable the argument should be passed to:

parameter_name=value

In this format, parameter_name is the name of a parameter variable and value is the value being passed to that parameter. An argument that is written in like this syntax is known as a keyword  argument.

Example:

It is possible to mix positional arguments and keyword arguments in a function call, but the positional arguments must appear first, followed by the keyword arguments. Otherwise an error will occur.

show_interest(10000.0, rate=0.01, periods=10)

In this statement, the first argument, 10000.0, is passed by its position to the principal parameter. The second and third arguments are passed as keyword arguments.

# This will cause an ERROR!

show_interest(1000.0, rate=0.01, 10)

because a non-keyword argument follows a keyword argument.

Local Variables

A local variable belongs to the function in which it is created, and only statements inside that function can access the variable. An error will occur if a statement in one function tries to access a local variable that belongs to another function.

A variable’s scope is the part of a program in which the variable may be accessed. A variable is visible only to statements in the variable’s scope. A local variable’s scope is the function in which the variable is created. A local variable cannot be accessed by code that appears inside the function at a point before the variable has been created. Because a function’s local variables are hidden from other functions, the other functions may have their own local variables with the same name.