UNIT-IV

Modules, Packages and File Handling in Python

Python Modules

A python module can be defined as a python program file which contains a python
code including python functions, class, or variables. In other words, we can say that
our python code file saved with the extension (.py) is treated as the module. We may
have a runnable code inside the python module.
Modules in Python provides us the flexibility to organize the code in a logical way.
To use the functionality of one module into another, we must have to import the
specific module.
Example
In this example, we will create a module named as file.py which contains a function
func that contains a code to print some message on the console.
Let's create the module named as file.py.
1. #displayMsg prints a message to the name being passed.
2. def displayMsg(name)
3. print("Hi "+name);
Here, we need to include this module into our main module to call the method
displayMsg() defined in the module named file.
Loading the module in our python code
We need to load the module in our python code to use its functionality. Python
provides two types of statements as defined below.
1. The import statement
2. The from-import statement

The import statement

The import statement is used to import all the functionality of one module into
another. Here, we must notice that we can use the functionality of any python source
file by importing that file as the module into another python source file.
We can import multiple modules with a single import statement, but a module is
loaded once regardless of the number of times, it has been imported into our file.
The syntax to use the import statement is given below.
1. import module1,module2,. module n
Hence, if we need to call the function displayMsg() defined in the file file.py, we have
to import that file as a module into our module as shown in the example below.
Example:
1. import file;
2. name = input("Enter the name?")
3. file.displayMsg(name)
Output:
Enter the name?John
Hi John
The from-import statement
Instead of importing the whole module into the namespace, python provides the
flexibility to import only the specific attributes of a module. This can be done by using
from? import statement. The syntax to use the from-import statement is given below.
1. from < module-name> import <name 1>, <name 2>..,<name n>
Consider the following module named as calculation which contains three functions
as summation, multiplication, and divide.
calculation.py:
1. #place the code in the calculation.py
2. def summation(a,b):
3. return a+b
4. def multiplication(a,b):
5. return a*b;
6. def divide(a,b):
7. return a/b;

Main.py:
1. from calculation import summation
2. #it will import only the summation() from calculation.py
3. a = int(input("Enter the first number"))
4. b = int(input("Enter the second number"))
5. print("Sum = ",summation(a,b)) #we do not need to specify the module name while
accessing summation()
Output:
Enter the first number10
Enter the second number20
Sum = 30
The from...import statement is always better to use if we know the attributes to be
imported from the module in advance. It doesn't let our code to be heavier. We can
also import all the attributes from a module by using *.
Consider the following syntax.
from <module> import *

Renaming a module
Python provides us the flexibility to import some module with a specific name so that
we can use this name to use that module in our python source file.
The syntax to rename a module is given below.
1. import <module-name> as <specific-name>
Example
1. #the module calculation of previous example is imported in this example as cal.
2. import calculation as cal;
3. a = int(input("Enter a?"));
4. b = int(input("Enter b?"));
5. print("Sum = ",cal.summation(a,b))
Output:
Enter a?10
Enter b?20
Sum = 30

Python Math Module

Python math module is defined as the most famous mathematical functions, which
includes trigonometric functions, representation functions, logarithmic functions, etc.
Furthermore, it also defines two mathematical constants, i.e., Pie and Euler number,
etc.
Pie (n): It is a well-known mathematical constant and defined as the ratio of
circumstance to the diameter of a circle. Its value is 3.141592653589793.
Euler's number(e): It is defined as the base of the natural logarithmic, and its value is
2.718281828459045.
There are different math modules which are given below:
math.log()
This method returns the natural logarithm of a given number. It is calculated to the
base e.
Example
1. import math
2. number = 2e-7 # small value of of x
3. print('log(fabs(x), base) is :', math.log(math.fabs(number), 10))
Output:
log(fabs(x), base) is : -6.698970004336019
math.log10()
This method returns base 10 logarithm of the given number and called the standard
logarithm.
Example
1. import math
2. x=13 # small value of of x
3. print('log10(x) is :', math.log10(x))
Output:
log10(x) is : 1.1139433523068367
math.exp()
This method returns a floating-point number after raising e to the given number.
Example
import math
number = 5e-2 # small value of of x
print('The given number (x) is :', number)
print('e^x (using exp() function) is :', math.exp(number)-1)
Output:
The given number (x) is : 0.05
e^x (using exp() function) is : 0.05127109637602412
math.pow(x,y)
This method returns the power of the x corresponding to the value of y. If value of x is
negative or y is not integer value than it raises a ValueError.
Example
1. import math
2. number = math.pow(10,2)
3. print("The power of number:",number)
Output:
The power of number: 100.0
math.floor(x)
This method returns the floor value of the x. It returns the less than or equal value to
x.
Example:
1. import math
2. number = math.floor(10.25201)
3. print("The floor value is:",number)
Output:
The floor value is: 10
math.ceil(x)
This method returns the ceil value of the x. It returns the greater than or equal value
to x.
1. import math
2. number = math.ceil(10.25201)
3. print("The floor value is:",number)
Output:
The floor value is: 11
math.fabs(x)
This method returns the absolute value of x.
import math
number = math.fabs(10.001)
print("The floor absolute is:",number)
Output:
The absolute value is: 10.001
math.factorial()
This method returns the factorial of the given number x. If x is not integral, it raises
a ValueError.
Example
1. import math
2. number = math.factorial(7)
3. print("The factorial of number:",number)
Output:
The factorial of number: 5040
math.modf(x)
This method returns the fractional and integer parts of x. It carries the sign of x is float.
Example
1. import math
2. number = math.modf(44.5)
3. print("The modf of number:",number)
Output:
The modf of number: (0.5, 44.0)
Python provides the several math modules which can perform the complex task in single-line
of code. In this tutorial, we have discussed a few important math modules.

Python Random module

The Python random module functions depend on a pseudo-random number

generator function random(), which generates the float number between 0.0 and 1.0.
There are different types of functions used in a random module which is given below:

random.random()
This function generates a random float number between 0.0 and 1.0.
random.randint()
This function returns a random integer between the specified integers.
random.choice()
This function returns a randomly selected element from a non-empty sequence.
Example
1. # importing "random" module.
2. import random
3. # We are using the choice() function to generate a random number from
4. # the given list of numbers.
5. print ("The random number from list is : ",end="")
6. print (random.choice([50, 41, 84, 40, 31]))
Output:
The random number from list is: 84
random.shuffle()
This function randomly reorders the elements in the list.
random.randrange(beg,end,step)
This function is used to generate a number within the range specified in its argument.
It accepts three arguments, beginning number, last number, and step, which is used
to skip a number in the range. Consider the following example.
1. # We are using randrange() function to generate in range from 100
2. # to 500. The last parameter 10 is step size to skip
3. # ten numbers when selecting.
4. import random
5. print ("A random number from range is : ",end="")
6. print (random.randrange(100, 500, 10))
Output:
A random number from range is : 290
Source
1. https://www.javatpoint.com/python-tutorial
2. https://www.w3schools.com/python/
3. https://www.tutorialspoint.com/python/index.htm
4. https://www.geeksforgeeks.org/python-programming-language/
19
random.seed()
This function is used to apply on the particular random number with the seed
argument. It returns the mapper value. Consider the following example.
1. # importing "random" module.
2. import random
3. # using random() to generate a random number
4. # between 0 and 1
5. print("The random number between 0 and 1 is : ", end="")
6. print(random.random())
7. # using seed() to seed a random number
8. random.seed(4)
Output:
The random number between 0 and 1 is : 0.4405576668981033

Python packages
The packages in python facilitate the developer with the application development
environment by providing a hierarchical directory structure where a package contains
subpackages,
modules, and sub-modules. The packages are used to categorize the application
level code efficiently.
We usually organize our files in different folders and subfolders based on some criteria, so
that they can be managed easily and efficiently. For example, we keep all our games in a
Games folder and we can even subcategorize according to the genre of the game or
something like that. The same analogy is followed by the packages in Python.
What is a Python Package?
Python Packages are a way to organize and structure your Python code into reusable
components. Think of it like a folder that contains related Python files (modules) that work
together to provide certain functionality. Packages help keep your code organized, make it
easier to manage and maintain, and allow you to share your code with others. They‟re like a
toolbox where you can store and organize your tools (functions and classes) for easy access
and reuse in different projects.
How to Create Package in Python?
Creating packages in Python allows you to organize your code into reusable and manageable
modules. Here‟s a brief overview of how to create packages:
Create a Directory: Start by creating a directory (folder) for your package. This
directory will serve as the root of your package structure.
Source
1. https://www.javatpoint.com/python-tutorial
2. https://www.w3schools.com/python/
3. https://www.tutorialspoint.com/python/index.htm
4. https://www.geeksforgeeks.org/python-programming-language/
20
Add Modules: Within the package directory, you can add Python
files (modules) containing your code. Each module should represent a
distinct functionality or component of your package.
Init File: Include an init .py file in the package directory. This file can be
empty or can contain an initialization code for your package. It signals to Python
that the directory should be treated as a package.
Subpackages: You can create sub-packages within your package by adding
additional directories containing modules, along with their own init .py files.
Importing: To use modules from your package, import them into your Python
scripts using dot notation. For example, if you have a module named module.py
inside a package named mypackage, you would import it like this: from
mypackage import module.
Distribution: If you want to distribute your package for others to use, you can
create a setup.py file using Python‟s setuptools library. This file defines metadata
about your package and specifies how it should be installed.
Code Example
Here‟s a basic code sample demonstrating how to create a simple Python
package:
1. Create a directory named mypackage.
2. Inside mypackage, create two Python files: module1.py and
module2.py.
3. Create an init .py file inside mypackage (it can be empty).
4. Add some code to the modules.
5. Finally, demonstrate how to import and use the modules from the
package.
Example: Now, let‟s create a Python script outside the mypackage directory
 to import and use these modules:
# module1.py
def greet(name):
print(f"Hello, {name}!")
# module2.py
def add(a, b):
return a + b
from mypackage import module1, module2
# Using functions from module1
module1.greet("Alice")
# Using functions from module2
result = module2.add(3, 5)
print("The result of addition is:", result)
When you run the script, you should see the following output:
Example
Let's create a package named Employees in your home directory. Consider the
following steps.
1. Create a directory with name Employees on path /home.
2. Create a python source file with name ITEmployees.py on the path
/home/Employees.
ITEmployees.py
a. def getITNames():
b. List = ["John", "David", "Nick", "Martin"]
c. return List;
3. Similarly, create one more python file with name BPOEmployees.py and create a
function getBPONames()
4. Now, the directory Employees which we have created in the first step contains two
python modules. To make this directory a package, we need to include one more
file here, that is init .py which contains the import statements of the modules
defined in this directory.
init .py
1. from ITEmployees import getITNames
2. from BPOEmployees import getBPONames

Now, the directory Employees has become the package containing two python
modules. Here we must notice that we must have to create init .py inside a
directory to convert this directory to a package.
1. To use the modules defined inside the package Employees, we must have to
import this in our python source file. Let's create a simple python source file at
our home directory (/home) which uses the modules defined in this package. Test.py
1. import Employees
2. print(Employees.getNames())
Output:
['John', 'David', 'Nick', 'Martin']
We can have sub-packages inside the packages. We can nest the packages up to any
level depending upon the application requirements.
The following image shows the directory structure of an application Library
management system which contains three sub-packages as Admin, Librarian, and
Student. The sub-packages contain the python modules.

Python File Handling

File handling in Python is a powerful and versatile tool that can be used to perform a wide range
of operations. However, it is important to carefully consider the advantages and disadvantages of
file handling when writing Python programs, to ensure that the code is secure, reliable, and
performs well.
Python supports file handling and allows users to handle files i.e., to read and write files, along with
many other file handling options, to operate on files. The concept of file handling has stretched over
various other languages, but the implementation is either complicated or lengthy, like other
concepts of Python, this concept here is also easy and short. Python treats files differently as text or
binary and this is important. Each line of code includes a sequence of characters, and they form a
text file. Each line of a file is terminated with a special character, called the EOL or End of Line
characters like comma {,} or newline character. It ends the current line and tells the interpreter a
new one has begun. Let‟s start with the reading and writing files.
Advantages of File Handling in Python
 Versatility: File handling in Python allows you to perform a wide range of operations,
such as creating, reading, writing, appending, renaming, and deleting files.
 Flexibility: File handling in Python is highly flexible, as it allows you to work with
different file types (e.g. text files, binary files, CSV files, etc.), and to perform different
operations on files (e.g. read, write, append, etc.).
 User–friendly: Python provides a user-friendly interface for file handling, making it easy
to create, read, and manipulate files.
 Cross-platform: Python file-handling functions work across different platforms (e.g.
Windows, Mac, Linux), allowing for seamless integration and compatibility.
Disadvantages of File Handling in Python
 Error-prone: File handling operations in Python can be prone to errors, especially if the
code is not carefully written or if there are issues with the file system (e.g. file
permissions, file locks, etc.).
 Security risks: File handling in Python can also pose security risks, especially if the
program accepts user input that can be used to access or modify sensitive files on the
system.
 Complexity: File handling in Python can be complex, especially when working with
more advanced file formats or operations. Careful attention must be paid to the code to
ensure that files are handled properly and securely.
 Performance: File handling operations in Python can be slower than other programming
languages, especially when dealing with large files or performing complex operations.
For this article, we will consider the following “sample.txt” file as an example.
Hello world
SampleforSample
123 456
Python File Open
Before performing any operation on the file like reading or writing, first, we have to open that file.
For this, we should use Python‟s inbuilt function open() but at the time of opening, we have to
specify the mode, which represents the purpose of the opening file.
f = open(filename, mode)
Where the following mode is supported:
1. r: open an existing file for a read operation.
2. w: open an existing file for a write operation. If the file already contains some data,
then it will be overridden but if the file is not present then it creates the file as well.
3. a: open an existing file for append operation. It won‟t override existing data.
4. r+: To read and write data into the file. The previous data in the file will be overridden.
5. w+: To write and read data. It will override existing data.
6. a+: To append and read data from the file. It won‟t override existing data.
Working in Read mode
There is more than one way to How to read from a file in Python. Let us see how we can
read the content of a file in read mode.
Example 1: The open command will open the Python file in the read mode and the for loop
will print each line present in the file.
 Python3

# a file named "geek", will be opened with the reading mode.

file = open('geek.txt', 'r')

# This will print every line one by one in the file

for each in file:

print (each)

Output:
Hello world
SampleforSample
123 456

Example 2: In this example, we will extract a string that contains all characters in the
Python file then we can use file.read().
Python3

# Python code to illustrate read() mode

file = open("sample.txt", "r")

print (file.read())

Output:
Hello world
SampleforSample
123 456

Example 3: In this example, we will see how we can read a file using the with statement in
Python.
Python3
# Python code to illustrate with()

with open("sample.txt") as file:

data = file.read()

print(data)

Output:
Hello world
SampleforSample
123 456

Example 4: Another way to read a file is to call a certain number of characters like in the
following code the interpreter will read the first five characters of stored data and return it
as a string:
Python3

# Python code to illustrate read() mode character wise

file = open("sample.txt", "r")

print (file.read(5))

Output:
Hello

Example 5: We can also split lines while reading files in Python. The split() function splits the variable
when space is encountered. You can also split using any characters as you wish.
# Python code to illustrate split() function
Python3
with open("sample.txt", "r") as file:

data = file.readlines()

for line in data:

word = line.split()

print (word)
Output:
['Hello', 'world']
['SampleforSample']
['123', '456']
Creating a File using the write() Function
Just like reading a file in Python, there are a number of ways to Writing to file in Python.
Let us see how we can write the content of a file using the write() function in Python.
Working in Write Mode
Let‟s see how to create a file and how the write mode works.
Example 1: In this example, we will see how the write mode and the write() function is
used to write in a file. The close() command terminates all the resources in use and frees the
system of this particular program.
Python3

# Python code to create a file

file = open('geek.txt','w')

file.write("This is the write command")

file.write("It allows us to write in a particular file")

file.close()

Output:
This is the write commandIt allows us to write in a particular file

Example 2: We can also use the written statement along with the with() function.
Python3

# Python code to illustrate with() alongwith write()

with open("file.txt", "w") as f:

f.write("Hello World!!!")

Output:
Hello World!!!
Working of Append Mode
Let us see how the append mode works.
Example: For this example, we will use the Python file created in the previous example.
Python3
# Python code to illustrate append() mode

file = open('geek.txt', 'a')

file.write("This will add this line")

file.close()

Output:
This is the write commandIt allows us to write in a particular fileThis will add this line
There are also various other commands in Python file handling that are used to handle
various tasks:
rstrip(): This function strips each line of a file off spaces from the right-hand side.
lstrip(): This function strips each line of a file off spaces from the left-hand side.
It is designed to provide much cleaner syntax and exception handling when you are
working with code. That explains why it‟s good practice to use them with a statement
where applicable. This is helpful because using this method any files opened will be closed
automatically after one is done, so auto-cleanup.

Implementing all the functions in File Handling

In this example, we will cover all the concepts that we have seen above. Other than those,
we will also see how we can delete a file using the remove() function from Python os
module.
Python3

import os

def create_file(filename):

try:

with open(filename, 'w') as f:

f.write('Hello, world!\n')

print("File " + filename + " created successfully.")

except IOError:

print("Error: could not create file " + filename)

def read_file(filename):

try:

with open(filename, 'r') as f:

contents = f.read()

print(contents)

except IOError:

print("Error: could not read file " + filename)

def append_file(filename, text):

try:

with open(filename, 'a') as f:

f.write(text)

print("Text appended to file " + filename + " successfully.")

except IOError:

print("Error: could not append to file " + filename)

def rename_file(filename, new_filename):

try:

os.rename(filename, new_filename)

print("File " + filename + " renamed to " + new_filename + " successfully.")

except IOError:

print("Error: could not rename file " + filename)

def delete_file(filename):
 try:

os.remove(filename)

print("File " + filename + " deleted successfully.")

except IOError:

print("Error: could not delete file " + filename)

if name == ' main ':

filename = "example.txt"

new_filename = "new_example.txt"

create_file(filename)

read_file(filename)

append_file(filename, "This is some additional text.\n")

read_file(filename)

rename_file(filename, new_filename)

read_file(new_filename)

delete_file(new_filename)

Output:
File example.txt created successfully.
Hello, world!
Text appended to file example.txt successfully.
Hello, world!
This is some additional text.
File example.txt renamed to new_example.txt successfully.
Hello, world!
This is some additional text.
File new_example.txt deleted successfully.

Reading and Writing to text files in Python

 Python provides built-in functions for creating, writing, and reading files. Two types of
files 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.
This article will focus on opening, closing, reading, and writing data in a text file. Here, we
will also see how to get Python output in text file.

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. The file handle is like a cursor, which defines from where the data has to
be read or written in the file and we can get Python output in text file.
There are 6 access modes in Python:
 Read Only („r‟)
 Read and Write („r+‟)
 Write Only („w‟)
 Write and Read („w+‟)
 Append Only („a‟)
 Append and Read („a+‟)
Read Only („r‟) : Open text file for reading. The handle is positioned at the beginning of
the file. If the file does not exist, raises the I/O error. This is also the default mode in which
a 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 exist.
Write Only („w‟) : Open the file for writing. For the existing files, 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 exist.
Write and Read („w+‟) : Open the file for reading and writing. For an 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.

How Files are Loaded into Primary Memory?

There are two kinds of memory in a computer i.e. Primary and Secondary memory every
file that you saved or anyone saved is on secondary memory cause any data in primary
memory is deleted when the computer is powered off. So when you need to change any text
file or just to work with them in python you need to load that file into primary memory.
Python interacts with files loaded in primary memory or main memory through “file
handlers” ( This is how your operating system gives access to python to interact with the
file you opened by searching the file in its memory if found it returns a file handler and
then you can work with the file ).
Opening a Text File in Python
It is done using the open() function. No module is required to be imported for this function.
File_object = open(r"File_Name","Access_Mode")
The file should exist in the same directory as the python program file else, the full address
of the file should be written in place of the filename. Note: The r is placed before the
filename to prevent the characters in the filename string to be treated as special characters.
For example, if there is \temp in the file address, then \t is treated as the tab character, and
an 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 the same
directory and the address is not being placed.
Python

# Open function to open the file "MyFile1.txt"

# (same directory) in append mode and

file1 = open("MyFile1.txt","a")

# store its reference in the variable file1

# and "MyFile2.txt" in D:\Text in file2

file2 = open(r"D:\Text\MyFile2.txt","w+")

Here, file1 is created as an object for MyFile1 and file2 as object for MyFile2

Closing a Text File in Python

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.
File_object.close()
Python

# Opening and Closing a file "MyFile.txt"

# for object name file1.

file1 = open("MyFile.txt","a")
file1.close()

Writing to a file in Python

There are two ways to write in a file:
 Using write()
 Using writelines()

Writing to a Python Text File Using write()

write() : Inserts the string str1 in a single line in the text file.
File_object.write(str1)

Writing to a Text File Using writelines()

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]
Reference: write() VS writelines()

Reading from a file in Python

There are three ways to read data from a text file:
 Using read()
 Using readline()
 Using readlines()

Reading From a File Using read()

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])

Reading a Text File Using readline()

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])

Reading a File Using readlines()

readlines() : Reads all the lines and return them as each line a string element in a list.
File_object.readlines()
Note: „\n‟ is treated as a special character of two bytes.
In this example, a file named “myfile.txt” is created and opened in write mode ("w"). Data
is written to the file using write and writelines methods. The file is then reopened in read
and append mode ("r+"). Various read operations, including read, readline, readlines, and
the use of seek, demonstrate different ways to retrieve data from the file. Finally, the file is
closed.
Python3
# Program to show various ways to read and

# write data in a file.

file1 = open("myfile.txt", "w")

L = ["This is Delhi \n", "This is Paris \n", "This is London \n"]

# \n is placed to indicate EOL (End of Line)

file1.write("Hello \n")

file1.writelines(L)

file1.close() # to change file access modes

file1 = open("myfile.txt", "r+")

print("Output of Read function is ")

print(file1.read())

print()

# seek(n) takes the file handle to the nth

# byte from the beginning.

file1.seek(0)

print("Output of Readline function is ")

print(file1.readline())

print()
file1.seek(0)

# To show difference between read and readline

print("Output of Read(9) function is ")

print(file1.read(9))

print()

file1.seek(0)

print("Output of Readline(9) function is ")

print(file1.readline(9))

file1.seek(0)

# readlines function

print("Output of Readlines function is ")

print(file1.readlines())

print()

file1.close()

Output:
Output of Read function is
Hello
This is Delhi
This is Paris
This is London
Output of Readline function is
Hello
Output of Read(9) function is
Hello
Th
Output of Readline(9) function is
Hello
Output of Readlines function is
['Hello \n', 'This is Delhi \n', 'This is Paris \n', 'This is London \n']

Appending To a File in Python

In this example, a file named “myfile.txt” is initially opened in write mode ("w") to write
lines of text. The file is then reopened in append mode ("a"), and “Today” is added to the
existing content. The output after appending is displayed using readlines. Subsequently, the
file is reopened in write mode, overwriting the content with “Tomorrow”. The final output
after writing is displayed using readlines.
Python3

# Python program to illustrate

# Append vs write mode

file1 = open("myfile.txt","w")

L = ["This is Delhi \n","This is Paris \n","This is London \n"]

file1.writelines(L)

file1.close()

# Append-adds at last

file1 = open("myfile.txt","a")#append mode

file1.write("Today \n")

file1.close()

file1 = open("myfile.txt","r")

print("Output of Readlines after appending")

print(file1.readlines())

print()

file1.close()

# Write-Overwrites
file1 = open("myfile.txt","w")#write mode

file1.write("Tomorrow \n")

file1.close()

file1 = open("myfile.txt","r")

print("Output of Readlines after writing")

print(file1.readlines())

print()

file1.close()

Output:
Output of Readlines after appending
['This is Delhi \n', 'This is Paris \n', 'This is London \n', 'Today \n']
Output of Readlines after writing
['Tomorrow \n']

File Objects in Python

A file object allows us to use, access and manipulate all the user accessible files. One can
read and write any such files.
When a file operation fails for an I/O-related reason, the exception IOError is raised. This
includes situations where the operation is not defined for some reason, like seek() on a tty
device or writing a file opened for reading.
Files have the following methods:
 open(): Opens a file in given access mode.
open(file_address, access_mode)
Examples of accessing a file: A file can be opened with a built-in function called
open(). This function takes in the file‟s address and the access_mode and returns a file
object.
There are different types of access_modes:
r: Opens a file for reading only
r+: Opens a file for both reading and writing
w: Opens a file for writing only
w+: Open a file for writing and reading.
a: Opens a file for appending
a+: Opens a file for both appending and reading
When you add 'b' to the access modes you can read the file in binary format rather than
 the default text format. It is used when the file to be accessed is not in text.
 read([size]): It reads the entire file and returns it contents in the form of a string. Reads
at most size bytes from the file (less if the read hits EOF before obtaining size bytes). If
the size argument is negative or omitted, read all data until EOF is reached.

# Reading a file

f = open( file , 'r')

#read()

text = f.read(10)

print(text)

f.close()

 readline([size]): It reads the first line of the file i.e till a newline character or an EOF in
case of a file having a single line and returns a string. If the size argument is present and
non-negative, it is a maximum byte count (including the trailing newline) and an
incomplete line may be returned. An empty string is returned only when EOF is
encountered immediately.

# Reading a line in a file

f = open( file , 'r')

#readline()

text = f.readline(20)

print(text)

f.close()
 readlines([sizehint]): It reads the entire file line by line and updates each line to a list
which is returned.Read until EOF using readline() and return a list containing the lines
thus read. If the optional sizehint argument is present, instead of reading up to EOF,
whole lines totalling approximately sizehint bytes (possibly after rounding up to an
internal buffer size) are read.

# Reading a file

f = open( file , 'r')

#readline()

text = f.readlines(25)

print(text)

f.close()

 write(string): It writes the contents of string to the file. It has no return value. Due to
buffering, the string may not actually show up in the file until the flush() or close()
method is called.

# Writing a file

f = open( file , 'w')

line = 'Welcome Geeks\n'

#write()

f.write(line)

f.close()

More Examples in different modes:

# Reading and Writing a file

f = open( file , 'r+')

lines = f.read()

f.write(lines)

f.close()

# Writing and Reading a file

f = open( file , 'w+')

lines = f.read()

f.write(lines)

f.close()

# Appending a file

f = open( file , 'a')

lines = 'Welcome Geeks\n'

f.write(lines)

f.close()

# Appending and reading a file

 f = open( file , 'a+')

lines = f.read()

f.write(lines)

f.close()

 writelines(sequence): It is a sequence of strings to the file usually a list of strings or

any other iterable data type. It has no return value.

# Writing a file

f = open( file , 'a+')

lines = f.readlines()

#writelines()

f.writelines(lines)

f.close()

 tell(): It returns an integer that tells us the file object‟s position from the beginning of
the file in the form of bytes

# Telling the file object position

f = open( file , 'r')

lines = f.read(10)

#tell()
 print(f.tell())

f.close()

 seek(offset, from_where): It is used to change the file object‟s position. Offset

indicates the number of bytes to be moved. from_where indicates from where the bytes
are to be moved.

# Setting the file object position

f = open( file , 'r')

lines = f.read(10)

print(lines)

#seek()

print(f.seek(2,2))

lines = f.read(10)

print(lines)

f.close()

 flush(): Flush the internal buffer, like stdio„s fflush(). It has no return value. close()
automatically flushes the data but if you want to flush the data before closing the file
then you can use this method.

# Clearing the internal buffer before closing the file

f = open( file , 'r')

lines = f.read(10)
 #flush()

f.flush()

print(f.read())

f.close()

 fileno(): Returns the integer file descriptor that is used by the underlying
implementation to request I/O operations from the operating system.

# Getting the integer file descriptor

f = open( file , 'r')

#fileno()

print(f.fileno())

f.close()

 isatty(): Returns True if the file is connected to a tty(-like) device and False if not.

# Checks if file is connected to a tty(-like) device

f = open( file , 'r')

#isatty()

print(f.isatty())

f.close()
 next(): It is used when a file is used as an iterator. The method is called repeatedly. This
method returns the next input line or raises StopIteration at EOF when the file is open
for reading( behaviour is undefined when opened for writing).

# Iterates over the file

f = open( file , 'r')

#next()

try:

while f.next():

print(f.next())

except:

f.close()

 truncate([size]): Truncate the file‟s size. If the optional size argument is present, the
file is truncated to (at most) that size. The size defaults to the current position. The
current file position is not changed. Note that if a specified size exceeds the file‟s
current size, the result is platform-dependent: possibilities include that the file may
remain unchanged, increase to the specified size as if zero-filled, or increase to the
specified size with undefined new content.

# Truncates the file

f = open( file , 'w')

#truncate()

f.truncate(10)

f.close()
  close(): Used to close an open file. A closed file cannot be read or written any more.

# Opening and closing a file

f = open( file , 'r')

#close()

f.close()

Attributes:
 closed: returns a boolean indicating the current state of the file object. It
returns true if the file is closed and false when the file is open.
 encoding: The encoding that this file uses. When Unicode strings are written
to a file, they will be converted to byte strings using this encoding.
 mode: The I/O mode for the file. If the file was created using the open()
built-in function, this will be the value of the mode parameter.
 name: If the file object was created using open(), the name of the file.
 newlines: A file object that has been opened in universal newline mode have
this attribute which reflects the newline convention used in the file. The
value for this attribute are “\r”, “\n”, “\r\n”, None or a tuple containing all the
newline types seen.
 softspace: It is a boolean that indicates whether a space character needs to be
printed before another value when using the print statement.

f = open( file , 'a+')

print(f.closed)

print(f.encoding)

print(f.mode)

print(f.newlines)

print(f.softspace)

Auxiliary Modules for File I/O

File objects supply all functionality that is strictly needed for file I/O. There are some auxiliary
Python library modules, however, that offer convenient supplementary functionality, making I/O
even easier and handier in several important special cases.
The fileinput Module

The fileinput module lets you loop over all the lines in a list of text files. Performance is quite
good, comparable to the performance of direct iteration on each file, since fileinput uses
internal buffering to minimize I/O. Therefore, you can use module fileinput for line-oriented
file input whenever you find the module‟s rich functionality convenient, without worrying
about performance. The input function is the main function of module fileinput, and the
module also provides a FileInput class that supports the same functionality as the module‟s
functions.

The linecache Module

The linecache module lets you read a given line (specified by number) from a file with a given
name. The module keeps an internal cache, so if you need to read several lines from a file, the
operation is cheaper than opening and examining the file each time.Module linecache exposes the
following functions.

The struct Module

The struct module lets you pack binary data into a string, and then unpack the bytes of such a string
back into the data they represent. Such operations can be useful for various kinds of low-level
programming. Most often, you use module struct to interpret data records from binary.

StringIO and cStringIO – Work with text buffers using file-like API
Purpose: Work with text buffers using file-like API

Available In: StringIO: 1.4, cStringIO: 1.5

StringIO provides a convenient means of working with text in memory using the file API (read,
write. etc.). There are two separate implementations. The cStringIO version is written in C for
speed, while StringIO is written in Python for portability. Using cStringIO to build large strings
can offer performance savings over some other string conctatenation techniques.

Example

Here are some pretty standard, simple, examples of using StringIO buffers:
# Find the best implementation available on this platform
try:
from cStringIO import StringIO
except:
from StringIO import StringIO

# Writing to a buffer
output = StringIO()
output.write('This goes into the buffer. ')
print >>output, 'And so does this.'

# Retrieve the value written

print output.getvalue()
 output.close() # discard buffer memory # Initialize a

read buffer
input = StringIO('Inital value for read buffer')

# Read from the buffer

print input.read()

This example uses read(), but the readline() and readlines() methods are also available. The
StringIO class also provides a seek() method so it is possible to jump around in a buffer while
reading, which can be useful for rewinding if you are using some sort of look-ahead parsing
algorithm.

$ python stringio_examples.py

This goes into the buffer. And so does this.

Inital value for read buffer

Real world applications of StringIO include a web application stack where various parts of the
stack may add text to the response, or testing the output generated by parts of a program which
typically write to a file.

The application we are building at work includes a shell scripting interface in the form of several
command line programs. Some of these programs are responsible for pulling data from the database
and dumping it on the console (either to show the user, or so the text can serve as input to another
command). The commands share a set of formatter plugins to produce a text representation of an
object in a variety of ways (XML, bash syntax, human readable, etc.). Since the formatters
normally write to standard output, testing the results would be a little tricky without the StringIO
module. Using StringIO to intercept the output of the formatter gives us an easy way to collect the
output in memory to compare against expected results.

References:

1. https://www.javatpoint.com/python-tutorial
2. https://www.w3schools.com/python/
3. https://www.tutorialspoint.com/python/index.htm
4. https://www.geeksforgeeks.org/python-programming-language