Unit V.pptx

UNIT V
FILES, MODULES, PACKAGES

FILES, MODULES, PACKAGES
• Files and exception:
• Text files
• Reading and writing files
• Format operator;
• Command line arguments
• Errors and exceptions
• Handling exceptions
• Modules
• Packages
• Illustrative programs:
• word count
• copy file

FILES
• Most of the programs we have seen so far are transient in the sense that they run for a
short time
• Produce some output, but when they end, their data disappears. If you run the program
again, it starts with a clean slate.
• Other programs are persistent: they run for a long time (or all the time); they keep at
least some of their data in permanent storage (a hard drive, for example);
• if they shut down and restart, they pick up where they left off.
• One of the simplest ways for programs to maintain their data is by reading and writing
text files.
• It is an alternative is to store the state of the program in a database.

Text Files
• A text file is a sequence of characters stored on a permanent medium like a hard drive, flash
memory, or CD-ROM.
• Text file contain only text, and has no special formatting such as bold text, italic text,
images, etc.
• Text files are identified with the .txt file extension.
Reading and Writing to Text Files
• Python provides inbuilt functions for creating, writing and reading files.
• There are two types of files that can be handled in python, normal text files and binary files
(written in binary language,0s and 1s).
 Text files: In this type of file, each line of text is terminated with a special character
called EOL (End of Line), which is the new line character (‗n‘) in python by default.
 Binary files: In this type of file, there is no terminator for a line and the data is stored
after converting it into machine understandable binary language.

In order to perform some operations on files we have to follow below steps:
 Opening
 Reading or writing
 Closing
File Access Modes
• Access modes govern the type of operations possible in the opened file.
• It refers to how the file will be used once its opened.
• These modes also define the location of the File Handle in the file.
• File handle is like a cursor, which defines from where the data has to be read or written in
the file.
There are 6 access modes in python:
Read Only (‘r’) : Open text file for reading. The handle is positioned at the beginning of the
file. If the file does not exists, raises I/O error. This is also the default mode in which file is
opened.
Read and Write (‘r+’) : Open the file for reading and writing. The handle is positioned at the
beginning of the file. Raises I/O error if the file does not exists.

• Write Only (‘w’) : Open the file for writing. For existing file, the data is truncated
and over-written. The handle is positioned at the beginning of the file. Creates the
file if the file does not exists.
• Write and Read (‘w+’) : Open the file for reading and writing. For existing file, data
is truncated and over-written. The handle is positioned at the beginning of the file.
• Append Only (‘a’) : Open the file for writing. The file is created if it does not exist.
The handle is positioned at the end of the file. The data being written will be
inserted at the end, after the existing data.
• Append and Read (‘a+’) : Open the file for reading and writing. The file is created if
it does not exist. The handle is positioned at the end of the file. The data being
written will be inserted at the end, after the existing data.

Opening a File
It is done using the open() function. No module is required to be imported for this function.
Syntax:
File_object = open(r"File_Name","Access_Mode")
• The file should exist in the same directory as the python program file else, full address
(path will be discussed in later section of this unit) of the file should be written on place of
filename.
• Note: The r is placed before filename to prevent the characters in filename string to be
treated as special character.
• For example, if there is temp in the file address, then t is treated as the tab character and
error is raised of invalid address.
• The r makes the string raw, that is, it tells that the string is without any special characters.
• The r can be ignored if the file is in same directory and address is not being placed.
Example:
>>> f1 = open("sample.txt","a")
>>> f2 = open(r"G:classpythonsample3.txt","w+")
f1 is created as object for sample.txt and f3 as object for sample3.txt (in G:classpython)

Closing a File
• close() function closes the file and frees the memory space acquired by that file. It is used at
the time when the file is no longer needed or if it is to be opened in a different file mode.
Syntax:
File_object.close()
Example:
>>> f1 = open("smapl.txt","a")
>>>f1.close()
After closing a file we can‘t perform any operation on that file. If want to do so, we have to
open the file again.
Reading from a File
To read the content of a file, we must open the file in reading mode.

There are three ways to read data from a text file.
1. read() :
Returns the read bytes in form of a string. Reads n bytes, if no n specified, reads the entire file.
File_object.read([n])
2. readline() :
Reads a line of the file and returns in form of a string.For specified n, reads at most n bytes.
However, does not reads more than one line, even if n exceeds the length of the line.
File_object.readline([n])
3. readlines() :
Reads all the lines and return them as each line a string element in a list.
File_object.readlines()

Example:
Consider the content of file sample.txt that is present in location G:classpythoncode as
Read Only
Read and Write
Write Only
Write and Read
Append Only
Append and Read
Now execute the following file reading script.
>>> f1=open("G:classpythoncodesample.txt","r")
>>>f1.read()
'Read OnlynRead and WritenWrite OnlynWrite and ReadnAppend OnlynAppend and
Read'
>>>f1.read()
''

>>>f1.read(10)
'Read Onlyn'
>>>f1.readline()
'Read Onlyn'
>>>f1.readlines()
['Read Onlyn', 'Read and Writen', 'Write Onlyn', 'Write and Readn', 'Append Onlyn',
'Append and Read']‘
File Positions :
tell():The tell() method tells you the current position within the file; in other words, the next
read or write will occur at that many bytes from the beginning of the file.

seek():
• The seek(offset[, from]) method changes the current file position.
• The offset argument indicates the number of bytes to be moved.
• The from argument specifies the reference position from where the bytes are to be moved.
• If from is set to 0, it means use the beginning of the file as the reference position and 1
means use the current position as the reference position and if it is set to 2 then the end of
the file would be taken as the reference position.
• If the second argument is omitted, it also means use the beginning of the file as the
reference position.
Example:
>>>f1.tell()
0L
>>>f1.readline()
'Read Onlyn'

>>>f1.tell()
11L
>>>f1.seek(0)
>>>f1.tell()
0L
>>>f1.seek(5)
>>>f1.tell()
5L
>>>f1.readline()
'Onlyn'
Writing to a File
In order to write into a file we need to open it in write 'w' or append 'a'. We need to be
careful with the 'w' mode as it will overwrite into the file if it already exists. All previous data
are erased.

There are two ways to write in a file.
1. write() : Inserts the string str1 in a single line in the text file.
File_object.write(str1)
2. writelines() : For a list of string elements, each string is inserted in the text file.Used to
insert multiple strings at a single time.
File_object.writelines(L) for L = [str1, str2, str3]
Example:
>>> f4=open("fruit.txt","w")
>>>fruit_list=['Applen','Orangen','Pineapplen']
>>>f4.writelines(fruit_list)
>>>f4.write('Strawberryn')
>>>f4.close()
>>> f4=open("fruit.txt","r")
>>>f4.read()
'ApplenOrangenPineapplenStrawberryn'

Appending to a File
Adding content at the end of a file is known as append. In order to do appending
operation, we have to open the file with append mode.
Example:
>>> f4=open('fruit.txt','a')
>>>f4.write('Banana')
>>>f4.close()
>>> f4=open('fruit.txt','r')
>>>f4.read()
'ApplenOrangenPineapplenStrawberrynBananan'
The File Object Attributes
Once a file is opened and you have one file object, you can get various information
related to that file.

Here is a list of all attributes related to file object:
Format Operator
• The argument of write has to be a string, so if we want to put other values in a file, we have
to convert them to strings.
• The easiest way to do that is with str.
>>> f5=open('stringsample.txt','w')
>>>f5.write(5)
TypeError: expected a string or other character buffer object
>>>f5.write(str(5))

• An alternative is to use the format operator, %.
• When applied to integers, % is the modulus operator.
• When the first operand is a string, % is the format operator.
• The first operand is the format string, which contains one or more format sequences,
which specify how the second operand is formatted. The result is a string.
For example,
the format sequence '%d' means that decimal value is converted to string.
>>> run=8
>>> '%d'%run
'8'
The result is the string '8', which is not to be confused with the integer value 8. Some other
format strings are.

Some other format strings are given below:

More Examples:
>>> 'India need %d runs'%3
'India need 3 runs'
>>> 'India need %d runs in %d balls'%(3,5)
'India need 3 runs in 5 balls'
>>> '%d %s price is %g rupees'%(5,'apple',180.50)
'5 apple price is 180.500000 rupees'
>>> '%d %d %d' % (1, 2)
TypeError: not enough arguments for format string
>>> '%d' % 'apple'
TypeError: %d format: a number is required, not str

Filenames and Paths
• Files are organized into directories (also called ―folders‖). Every running program has a
―current directory‖, which is the default directory for most operations.
• For example, when you open a file for reading, Python looks for it in the current directory.
• The os module provides functions for working with files and directories (―os‖ stands for
―operating system‖)
• os.getcwd returns the name of the current directory:
>>> import os
>>>os.getcwd()
'C:Python27'
• cwd stands for ―current working directory‖.
• A string like 'C:Python27' that identifies a file or directory is called a path.
• A simple filename, like 'stringsample.txt' is also considered a path, but it is a relative path
because it relates to the current directory.
• If the current directory 'C:Python27', the filename 'stringsample.txt' would refer to
'C:Python27stringsample.txt'.

Absolute Path :
• A path that begins with drive letter does not depend on the current directory; it is called an
absolute path. To find the absolute path to a file, you can use os.path.abspath:
>>>os.path.abspath('stringsample.txt')
'C:Python27stringsample.txt'
os.path provides other functions for working with filenames and paths. For example,
os.path.exists checks whether a file or directory exists:
>>>os.path.exists('memo.txt')
True
If it exists, os.path.isdir checks whether it‘s a directory:
>>>os.path.isdir('memo.txt')
False
>>>os.path.isdir ('C:Python27')
True

os.path.isfile checks whether it‘s a file. os.listdir returns a list of the files (and other
directories) in the given directory:
>>>cwd=os.getcwd()
>>>os.listdir(cwd)
['DLLs', 'Doc', 'include', 'infinitLoop.py', 'Lib', 'libs', 'LICENSE.txt', 'NEWS.txt',
'parameter.py', 'python.exe', 'pythonw.exe', 'README.txt', 'sample.txt',
'sample2.txt', 'Scripts', 'stringsample.txt', 'swapwith third.py', 'tcl', 'Tools',
'w9xpopen.exe', 'wc.py', 'wc.pyc']
>>>def walk(dirname):
for name in os.listdir(dirname):
path = os.path.join(dirname, name)
if os.path.isfile(path):
print(path)
else:
walk(path)
>>>cwd=os.getcwd()
>>>walk(cwd)

Output:
C:Python27DLLsbz2.pyd
C:Python27DLLspy.ico
C:Python27DLLspyc.ico
C:Python27DLLspyexpat.pyd
C:Python27DLLsselect.pyd
C:Python27DLLssqlite3.dll
C:Python27DLLstcl85.dll
C:Python27includeabstract.h
C:Python27includeasdl.h
C:Python27includeast.h
os.path.join takes a directory and a file name and joins them into a complete path.
>>>os.path.join(cwd,'stringsample.txt')
'C:Python27stringsample.txt'

COMMAND LINE ARGUMENTS
• It is possible to pass some values from the command line to your python programs when
they are executed.
• These values are called command line arguments and many times they are important for
your program especially when you want to control your program from outside instead of
hard coding those values inside the code.
• The command line arguments are handled using sys module. We can access command-line
arguments via the sys.argv.
• This serves two purposes −
 sys.argv is the list of command-line arguments.
 len(sys.argv) is the number of command-line arguments.
Here sys.argv[0] is the program name. ie. script name.

Example 1
Consider the following script command_line.py
import sys
print 'There are %d arguments'%len(sys.argv)
print 'Argument are', str(sys.argv)
print 'File Name is: ', sys.argv[0]
Now run above script as follows – in Command prompt:
C:Python27>python.exe command_line.py vinu ranjith
This produce following result –
There are 3 arguments
Argument are ['command_line.py', 'vinu', 'ranjith']
File Name is: command_line.py

Example 2 - To copy the contents of one file into another, do the following steps
1) Open file name with command line argument one as read mode (input file).
2) Open file name with command line argument two as write mode (output file).
3) Read each line from the input file and write it into the output file until the end of
input file. 4) Exit.
Program
import sys
source=open(sys.argv[1],'r')
destination=open(sys.argv[2],'w')
while(True):
new_line=source.readline()
if new_line=='':
break
destination.write(new_line)
source.close()
destination.close()
Now run above script as follows – in Command prompt:
C:Python27>python.exe copy_file.py input_file.txt output_file.txt

ERRORS AND EXCEPTIONS
There are two distinguishable kinds of errors: syntax errors and exceptions.
Syntax Errors
• Syntax errors, also known as parsing errors, are perhaps the most common kind of
complaint you get while you are still learning Python.
• Syntax error is an error in the syntax of a sequence of characters or tokens that is
intended to be written in python.
• For compiled languages, syntax errors are detected at compile-time. A program will not
compile until all syntax errors are corrected.
• For interpreted languages, however, a syntax error may be detected during program
execution, and an interpreter's error messages might not differentiate syntax errors from
errors of other kinds.
Exceptions
• Even if a statement or expression is syntactically correct, it may cause an error when an
attempt is made to execute it.
• Errors detected during execution are called exceptions.

Some Common exceptions :
>>> 55+(5/0)
Traceback (most recent call last):
File "<pyshell#12>", line 1, in <module>
55+(5/0)
ZeroDivisionError: integer division or modulo by zero
>>> 5+ repeat*2
5+ repeat*2
NameError: name 'repeat' is not defined
>>> '5'+5
'5'+5
TypeError: cannot concatenate 'str' and 'int' objects

Python’s built-in exceptions lists and their meanings.

HANDLING EXCEPTIONS
Python provides two very important features to handle any unexpected error in your Python
programs and to add debugging capabilities in them.
• Exception Handling:
• Assertions:
Exception Handling
• An exception is an event, which occurs during the execution of a program that disrupts the
normal flow of the program's instructions.
• When a Python script encounters a situation that it cannot cope with, it raises an exception.
An exception is a Python object that represents an error.
• When a Python script raises an exception, it must either handle the exception immediately
otherwise it terminates and quits.
• If you have some suspicious code that may raise an exception, you can defend your
program by placing the suspicious code in a try: block.
• After the try: block, include an except: statement, followed by a block of code which
handles the problem as elegantly as possible.

Syntax:
try....except...else blocks −
try:
--You do your operations here; ---
exceptException-I:
If there is Exception-I, then execute this block.
exceptException-II:
If there is Exception-II, then execute this block.
......................
else:
If there is no exception then execute this block.
• A single try statement can have multiple except statements. This is useful when the try
block contains statements that may throw different types of exceptions.
• You can also provide a generic except clause, which handles any exception.
• After the except clause(s), you can include an else-clause. The code in the else-block
executes if the code in the try: block does not raise an exception.
• The else-block is a good place for code that does not need the try: block's protection

Example:
This example opens a file with write mode, writes content in the file
try:
fp = open("test_exception.txt", "w")
fp.write("Exception handling")
except IOError:
print "Error: File don't have read permission"
else:
print "Written successfully"
fp.close()
This produces the following result:
Written successfully

Example:
This example opens a file with read mode, and tries to write the file where you do not have
write permission, so it raises an exception :
try:
fp = open("test_exception.txt", "r")
except IOError:
else:
fp.close()
This produces the following result
Error: File don't have read permission

The except Clause with No Exceptions
Use the except statement with no exceptions defined as follows −
Syntax:
try:
You do your operations here;
......................
except:
If there is any exception, then execute this block.
......................
else:
• This kind of a try-except statement catches all the exceptions that occur.
• Using this kind of try-except statement is not considered a good programming practice
though, because it catches all exceptions but does not make the programmer identify the
root cause of the problem that may occur.

The except Clause with Multiple Exceptions
You can also use the same except statement to handle multiple exceptions as follows −
Syntax:
try:
......................
except(Exception1[, Exception2[,...ExceptionN]]]):
If there is any exception from the given exception list, then execute this block.
......................
else:

The try-finally Clause
• You can use a finally: block along with a try: block.
• The finally block is a place to put any code that must execute, whether the try-block
raised an exception or not.
• The syntax of the try-finally statement is this −
try:
......................
Due to any exception, this may be skipped.
finally:
This would always be executed.
......................
• You cannot use else clause as well along with a finally clause.

Example
This example opens a file with write mode, writes content in the file and comes out
gracefully because there is no problem at all
try:
fp = open("test_exception.txt", "w")
except IOError:
else:
finally:
print "Closing file"
fp.close()
Written successfully
Closing file

Example
This example opens a file with read mode, and tries to write the file where you do not have
write permission, so it raises an exception :
try:
fp = open("test_exception.txt", "r")
except IOError:
else:
finally:
print "Closing file"
fp.close()
Error: File don't have read permission
Closing file

Argument of an Exception
• An exception can have an argument, which is a value that gives additional information about
the problem.
• The contents of the argument vary by exception. You capture an exception's argument by
supplying a variable in the except clause as follows − Syntax:
try:
......................
except ExceptionType, Argument:
You can print value of Argument here...
• If you write the code to handle a single exception, you can have a variable follow the name
of the exception in the except statement.
• If you are trapping multiple exceptions, you can have a variable follow the tuple of the
exception.
• This variable receives the value of the exception mostly containing the cause of the
exception.
• The variable can receive a single value or multiple values in the form of a tuple.
• This tuple usually contains the error string, the error number, and an error location.

Example - Single exception
def temp_convert(var):
try:
return int(var)
except ValueError, Argument:
print "The argument is not a numbersn", Argument
temp_convert("abc")
The argument is not a numbers
invalid literal for int() with base 10: 'abc'

Hierarchical Exceptions Handle
• Exception handlers don‘t just handle exceptions, if they occur inside functions that are
called (even indirectly) in the try clause.
• For example:
def this_fails():
x = 1/0
try:
this_fails()
except ZeroDivisionError, detail:
print 'Handling run-time error:', detail
Handling run-time error: integer division or modulo by zero
Raising an Exceptions
Syntax: raise [Exception [, args [, traceback]]]
• Exception is the type of exception (for example, NameError)
• argument is a value for the exception argument. The argument is optional;
• traceback, is also optional (and rarely used in practice), and if present, is the traceback
object used for the exception.

Example
An exception can be a string, a class or an object. Most of the exceptions that the
Python raises are classes, with an argument that is an instance of the class.
def functionName( level ):
if level < 1:
raise "Invalid level!", level
# if we raise the exception,code below to this not executed
To capture above exception, we must write the except clause as follows:
Syntax:
try:
Business Logic here...
except "Invalid level!":
Exception handling here...
else:
Rest of the code here...

Assertions in Python
• An assertion is a sanity-check that you can turn on or turn off when you are done with your
testing of the program.
• The easiest way to think of an assertion is to liken it to a raise-if statement (or to be more
accurate, a raise-if-not statement).
• An expression is tested, and if the result comes up false, an exception is raised.
• Assertions are carried out by the assert statement, the newest keyword to Python,
introduced in version 1.5.
The assert Statement
When it encounters an assert statement, Python evaluates the accompanying
expression, which is true. If the expression is false, Python raises an AssertionError exception.
Syntax:
assert Expression[, Arguments]
• If the assertion fails, Python uses ArgumentExpression as the argument for the
AssertionError.
• AssertionError exceptions can be caught and handled like any other exception using the
try-except statement, but if not handled, they will terminate the program and produce a
traceback.

Example
A function that converts a temperature from degrees Kelvin to degrees Fahrenheit. Since zero
degrees Kelvin is as cold as it gets, the function bails out if it sees a negative temperature
def KelvinToFahrenheit(Temperature):
assert (Temperature >= 0),"Colder than absolute zero!“
return ((Temperature-273)*1.8)+32
print KelvinToFahrenheit(275)
print int(KelvinToFahrenheit(509.25))
print KelvinToFahrenheit(-7)
When the above code is executed, it produces the following result
35.6
457
File "G:/class/python/code/assertion.py", line 6, in <module>
print KelvinToFahrenheit(-7)
File "G:/class/python/code/assertion.py", line 2, in KelvinToFahrenheit
assert (Temperature >= 0),"Colder than absolute zero!"
AssertionError: Colder than absolute zero!

MODULES
• A module allows you to logically organize your Python code. Grouping related code into a
module makes the code easier to understand and use.
• A module is a file that contains a collection of related functions. Python has lot of built-in
modules; math module is one of them.
• math module provides most of the familiar mathematical functions.
Before we can use the functions in a module, we have to import it with an import statement:
>>> import math
This statement creates a module object named math.
>>>math
<module 'math' (built-in)>
The module object contains the functions and variables defined in the module. To access one
of the functions, specify the name of the module and the name of the function, separated by
a dot. This format is called dot notation.

>>>math.log10(200)
2.3010299956639813
>>>math.sqrt(10)
3.1622776601683795
>>> import math
>>>dir(math)
['__doc__', '__name__', '__package__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2',
'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs',
'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'hypot', 'isinf', 'isnan', 'ldexp',
'lgamma', 'log', 'log10', 'log1p', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan',
'tanh', 'trunc']
>>>help(pow)
Help on built-in function pow in module __builtin__:
pow(...)
pow(x, y[, z]) -> number

Writing Modules
Any file that contains Python code can be imported as a module. For example, suppose you
have a file named addModule.py with the following code:
def add(a, b):
result = a + b
print(result)
add(10,20)
>>> import addModule  output :30
Now you have a module object addModule as : >>>addModule
<module 'addModule' from 'G:/class/python/codeaddModule.py'>
The module object provides add():
>>>addModule.add(120,150)  output : 270
def add(a, b):
result = a + b
print(result)
if __name__ == '__main__':
add(10,20)
Now while importing addModule test case is not running : >>> import addModule

PACKAGES
• Packages are namespaces which contain multiple packages and modules themselves.
• Each package in Python is a directory which must contain a special file called __init__.py.
• This file can be empty, and it indicates that the directory it contains is a Python package, so
it can be imported the same way a module can be imported.
• If we create a directory called sample_package, which marks the package name, we can
then create a module inside that package called sample_module. To use the module
sample_module, we can import it in two ways:
>>> import sample_package.sample_module
or
>>>from sample_package import sample_module
Alternative Method
The __init__.py file can also decide which modules the package exports as the API, while
keeping other modules internal, by overriding the __all__ variable, like so:
__init__.py:
__all__ = ["sample_module"]

WORD COUNT - program print each word in the specified file occurs how many times.
import sys
def word_count(file_name):
try:
file=open(file_name,"r")
wordcount={}
entier_words=file.read().split()
for word in entier_words:
if word not in wordcount:
wordcount[word] = 1
else:
wordcount[word] += 1
file.close();
print ("%-30s %s " %('Words in the File' , 'Count'))
for key in wordcount.keys():
print ("%-30s %d " %(key , wordcount[key]))
except IOError:
print ("No file found with name %s" %file_name)
fname=raw_input("Enter New File Name:")
word_count(fname)
try:
word_count(sys.argv[1])
except IndexError:
print("No file name passed as command line Argument")
fname=raw_input("Enter File Name:")
word_count(fname)

Content of a sample file word_count_input.txt is:
word count is the program which count each word in file appears how many times.
c:Python27>python wordcount1.py
No file name passed as command line Argument
Enter File Name:word_count_input
No file found with name word_count_input
Enter New File Name:word_count_input.txt
Words in the File Count
count 2
word 2
file 1
many 1
is 1
in 1
times 1
how 1
program 1
which 1
each 1
the 1
appears 1

Example -- >Following program counts number of words in the given file.
import sys
defword_count(file_name):
count=0
try:
file=open(file_name,"r")
entier_words=file.read().split()
for word in entier_words:
count=count+1
file.close();
print ("%s File have %d words" %(file_name,count))
except IOError:
print ("No file found with name %s" %file_name)
fname=raw_input("Enter New File Name:")
word_count(fname)
try:
word_count(sys.argv[1])
except IndexError:
print("No file name passed as command line Argument")
fname=raw_input("Enter File Name:")
word_count(fname)

c:Python27>python wordcount2.py
No file name passed as command line Argument
Enter File Name:word_count_input
No file found with name word_count_input
Enter New File Name:word_count_input.txt
word_count_input.txt File have 15 words
COPY FILE
This is a Python Program to copy the contents of one file into another. In order to perform
the copying operation we need to follow the following steps.
1. Open source file in read mode.
2. Open destination file in write mode.
3. Read each line from the input file and write it into the output file.
4. Exit.

Example:
import sys
def copy(src,dest):
try:
source=open(src,'r')
destination=open(dest,'w')
while(True):
new_line=source.readline()
if new_line=='':
break
destination.write(new_line)
source.close()
destination.close()
exceptIOError:
print ("Problem with Source or Destination File Name ")
source_name=raw_input("Enter New Source File Name:")
destination_name=raw_input("Enter New Destination File Name:")
copy(source_name,destination_name)
try:
copy(sys.argv[1],sys.argv[2])
exceptIndexError:
print("Insufficent Command line argument!")
source_name=raw_input("Enter Source File Name:")
destination_name=raw_input("Enter Destination File Name:")
copy(source_name,destination_name)
finally:
print("Copying Done.....")

C:Python27>python copy_file_exception.py input_file.txt
Insufficent Command line argument!
Enter Source File Name:input_file.tx
Enter Destination File Name:output_file.txt
Problem with Source or Destination File Name
Enter New Source File Name:input_file.txt
Enter New Destination File Name:output_file.txt
Copying Done.....

Unit V.pptx

More Related Content

Similar to Unit V.pptx

Recently uploaded

Unit V.pptx