This document provides an overview of file handling in Python. It begins by outlining learning objectives related to understanding different file types, opening and closing files, and reading from and writing to files. It then discusses the need for data file handling to permanently store program data. Various file types are introduced, including text files, CSV files, and binary files. Methods for opening, reading from, writing to, and closing both text and binary files are described. The pickle module is explained for pickling and unpickling Python objects for storage in binary files. Finally, random access methods like tell() and seek() are briefly covered.

1. LEARNING OBJECTIVES
At the end of this chapter you will be able to learn :
❏ Understanding Files
❏ Types of Files
❏ Understanding Text Files
❏ Opening and closing Text files
❏ Reading and writing in Files
❏ Understanding Binary Files
❏ Pickling and Unpickling
❏ Opening and closing Binary files
❏ Reading and writing in Binary Files
❏ CSV (Comma separated values) files. 1

2. NEED FOR DATA FILE HANDLING
● Mostly, in programming languages, all the values or data are stored in some
variables which are volatile in nature.
● Because data will be stored into those variables during run-time only and will be
lost once the program execution is completed. Hence it is better to save these data
permanently using files.
2

3. INTRODUCTION
● Data Files – The data files are the files that store data pertaining to a specific
application, for later use. The data files can be stored in two ways :
● Text files
● Binary files
3

4. TEXT FILE
● Stores information in the form of ASCII or Unicode characters.
● Each line of text is terminated (delimited)by a special character known as End Of
Line(EOL) character.
● By default the EOL character is the newline character (‘n’) or carriage return,
newline combination(‘rn’)
4

5. TEXT FILE
● Text files can be following types
● Regular Text files – store the text in the same form as it is typed and have
extension .txt
● Delimited Text files – In these specific character is stored to separate the values
i.e. a tab or a comma after every value.
● When a tab character is used to separate the values they are called TSV files
(Tab Separated files). They have extension .txt or .tsv
● When a comma is used to separate the values they are called CSV files
(Comma Separated Values). They have extension .csv
Regular Text file content -------- I am simple text.
TSV file content --------- I → am → simple → text.
CSV file content --------- I, am, simple, text. 5

6. CSV FILES
● CSV stands for Comma Separated Values.
● CSV is just like a text file, in a human readable format which is extensively
used to store tabular data(data in a spreadsheet or database.)
● The separator character of CSV files is called a delimiter.
● Default delimiter is comma (,). Other delimiters are tab (t), colon (:), pipe
(|), semicolon (;) characters.
6

7. BINARY FILE
● A file that contains information in the same format in which information
is held in memory.
● Binary file contains arbitrary binary data.
● So when we work on binary file, we have to interpret the raw bit
pattern(s) read from the file into correct type of data in our program.
● Python provides special module(s) for encoding and decoding of data
for binary file.
7

8. 8

9. STEPS TO PROCESS A FILE
1. Determine the type of file usage.
a. Reading purpose : If the data is to be brought in from a file to memory
b. Writing purpose : If the data is to be sent from memory to file.
2. Open the file and assign its reference to a file object or file-handle.
3. Process the file as required : Perform the desired operation from the file.
4. Close the file.
9

10. OPENING A TEXT FILE
● The key function for working with files in Python is the open() function.
● It accepts two parameters : filename, and mode.
Syntax:
<file_object_name> = open(<file_name>,<mode>)
Example: f = open(“demo.txt”,”r”)
● Can specify if the file should be opened in read or write mode :
○ “r - read - Default mode
○ “w" - write
○ “a”- append 10

11. OPENING A TEXT FILE
Example: f = open(“e:maindemo.txt”,”r”)
f = open(r “e:maindemo.txt”,”r”)
( r indicates raw string – there is no special meaning
attached to any character)
Note : the default file mode is read mode
11

12. ● File Object / File-Handle:
○ It serves as a link to file residing in your computer.
○ It is a reference to the file on the disk. It opens and makes it available for
a number of different task.
● File Access modes / file-mode:
○ It governs the type of operations(such as read or write or append)
possible in the opened file. Or it refers to how the file will be used once it
is opened.
12

13. ● Various Modes for opening a text file are:
Text
Mode
Binary
Mode
Description
“r” “rb” Read Default mode. Opens a file for reading, error if the file does not exist.
“w” “wb” Write Opens a file for writing, creates the file if it does not exist.
If exist truncate and over-write in the file.
“a” “ab” Append Retains the data in the file and appends the new data, creates the file
if it does not exist.( write only mode)
“r+” “r+b” or
“rb+”
Read and
Write
File must exist otherwise error is raised.Both reading and writing
operations can take place.
“w+” “w+b” or
“wb+”
Write and
Read
File is created if it does not exist.If the file exists past data is lost
(truncated).Both reading and writing operations can take place.
“a+” “a+b” or
“ab+”
Append and
Read
File is created if it does not exist.If the file exists past data is not lost
.Both reading and writing(appending) operations can take place.
13

14. CLOSING A FILE
● close()- function breaks the link of file-object and the file on the disk. After
close() no task can be performed on that file through the file-object.
Syntax:
<fileObject>.close()
Example : f.close()
● It is important to close your files, if the program exits unexpectedly there are
chances that the data may be lost.
14

15. READING FROM A FILE
➔ A Program reads a text/binary file from hard disk. Here File acts like an input to the
program.
➔ Followings are the methods to read a data from the file:
◆ read() METHOD
◆ <filehandle>.read([n]) --- returns the read bytes in the form of string
◆ readline() METHOD
◆ <filehandle>.readline([n]) --- returns the read bytes in the form of string
◆ readlines() METHOD
◆ <filehandle>.readlines() --- returns the read bytes in the form of list.
15

16. read() METHOD
● By default the read() method returns the whole text, but you can also specify
how many characters/bytes you want to return by passing the size as argument.
Syntax: <file_object>.read([n])
where n is the size
● To read entire file : <file_object>.read()
● To reads only a part of the File : <file_object>.read(size)
f = open("demo.txt", "r")
print(f.read(15))
Returns the 15 first characters of the file "demo.txt". 16

17. 17

18. 18

19. readline() METHOD
● readline() will return a line read, as a string from the file.
Syntax:
<file_object>.readline([n])
● Example
f = open("demo.txt", "r")
print(f.readline())
● This example program will return the first line in the file “demo.txt”
irrespective of number of lines in the text file.
19

20. 20

21. 21

22. 22
● Another way of printing file line by line
myfile=open(“poem.txt”,”r”)
for line in myfile:
print(line)

23. readlines() METHOD
● readlines() method reads all the lines and returns them in a list
● readlines() can be used to read the entire content of the file.
.
Syntax:
<file_object>.readlines()
● It returns a list, which can then be used for manipulation.
Example : f = open("demofile.txt", "r")
print(f.readlines())
f.close() 23

24. Read a file using Readlines()
24

25. # To find the total no of characters
myfile=open(“aa.txt”, “r”)
a=myfile.read()
print(len(a))
myfile.close()
#To find no of characters in a line
myfile=open(“aa.txt”, “r”)
a=myfile.readline()
print(len(a))
myfile.close()
#To find total no of lines
myfile=open(“aa.txt”, “r”)
a=myfile.readlines()
print(len(a))
myfile.close()
25
Including EOF(End
of File character)

26. #To find no of characters
myfile=open("aa.txt", "r")
s1=" "
with_eof=0
without_eof=0
while s1:
s1=myfile.readline()
with_eof=with_eof+len(s1)
without_eof=without_eof+len(s1.strip())
print("total characters with eof",with_eof)
print("total characters without eof",without_eof)
myfile.close()
strip() removes the given character from both ends
rstrip() removes the given character from trailing end i.e right end
lstrip() removes the given character from leading end i.e left end
26
without EOF(End of
File character)

27. WRITING TO A TEXT FILE
● A Program writes into a text/binary file in hard disk.
● Followings are the methods to write a data to the file.
○ write () METHOD
○ <filehandle>.write(str) –Writes a string to the file
○ writelines() METHOD
○ <filehandle>.write(L) -- Writes all strings in the list to file
● To write to an existing file, you must add a parameter to the open()
Function which specifies the mode :
○ "a" - Append - will append to the end of the file
○ "w" - Write - will overwrite any existing content
27

28. write() Method
● <filehandle>.write(strl)
● write() method takes a string ( as parameter ) and writes it in the file.
● For storing data with end of line character, you will have to add n character to end
of the string
● Example:
Open the file "demo_append.txt" and append content to the file:
f = open("demo_write.txt", "a”)
f.write("Hello students n We are learning data file handling…..!")
f.close()
f = open("demo_write.txt", "r") #open and read the file after the appending
print(f.read())
28

29. 29

30. 30
s=open("newwrite.txt","w")
for r in range(5):
new1=input("enter name")
s.write(new1+"n")
s.close()

31. 31
This program will both read and write
s=open("aa.txt","a+")
s.write("hello")
s.seek(0) ---places the file-pointer to beginning of file
print(s.read())
s.close()

32. writelines() METHOD
● For writing a string at a time, we use write() method, it can't be used
for writing a list, tuple etc. into a file.
● Python file method writelines() writes a sequence of strings to the file.
The sequence can be any iterable object producing strings, typically a
list of strings.
● So, whenever we have to write a sequence of string, we will use
writelines(), instead of write().
● writelines() method writes all strings in a list
32

33. 33

34. 34

36. 36
With r+, the position is initially at the beginning, but reading it once will push it towards the end, allowing you to append.
With a+, the position is initially at the end.
with open("filename", "r+") as f:
# here, position is initially at the beginning
text = f.read()
# after reading, the position is pushed toward the end
f.write("stuff to append")
with open("filename", "a+") as f:
# here, position is already at the end
f.write("stuff to append")
If you ever need to do an entire reread, you could return to the starting position by doing f.seek(0).
s=open("aa.txt","a+")
s.write("hello")
s.seek(0) -----places the file-pointer to beginning of file
print(s.read())
s.close()

37. The flush()
The flush function forces the writing of data on disc still pending on the
output buffer.
Syntax : <file_object>.flush()
37

38. 38

39. Standard input, output and error streams
The standard input and output devices are implemented as files in python
called standard streams.
These standard streams i.e
stdin --- to read from keyboard
stdout – to print to the display
stderr – same as stdout but used for errors.
can be used by importing sys module
39

40. Standard input, output and error streams
40

41. with statement
The with statement will automatically close the file after the
nested block of code.
with open(“aa.txt”, “r”) as f:
f.write (“Hi”)
Even if an exception (a runtime error) occurs before the end of
the block, the with statement will handle it and close the file.
41

42. Relative path and absolute path
The absolute path are from the topmost level of the directory structure.
Ex. E:accountshistorycash.act
The relative paths are relative to the current working directory
denoted as a dot(.) while its parent directory is denoted with two dots(..)
1) ..historycash.act
2) .cash.act
42

43. DATA FILE HANDLING IN BINARY
FILES
● Files that store objects as some byte stream are called binary files.
● That is, all the binary files are encoded in binary format , as a sequence of
bytes, which is understood by a computer or machine.
● In binary files, there is no delimiter to end the line.
● Since they are directly in the form of binary, there is no need to translate
them hence faster and easier to access.
● But they are not in human readable form and hence difficult to
understand.
43

44. Opening and closing binary files
Opening a binary file:
Similar to text file except that it should be opened in binary
mode.Adding a ‘b’ to the text file mode makes it binary - file mode.
EXAMPLE :
f = open(“demo.dat”,”rb”)
Closing a binary file
f.close()
44

45. ● Various Modes for opening a text file are:
Text
Mode
Binary
Mode
Description
“r” “rb” Read Default mode. Opens a file for reading, error if the file does not exist.
“w” “wb” Write Opens a file for writing, creates the file if it does not exist.
If exist truncate and over-write in the file.
“a” “ab” Append Retains the data in the file and appends the new data, creates the file
if it does not exist.( write only mode)
“r+” “r+b” or
“rb+”
Read and
Write
File must exist otherwise error is raised.Both reading and writing
operations can take place.
“w+” “w+b” or
“wb+”
Write and
Read
File is created if it does not exist.If the file exists past data is lost
(truncated).Both reading and writing operations can take place.
“a+” “a+b” or
“ab+”
Append and
Read
File is created if it does not exist.If the file exists past data is not lost
.Both reading and writing(appending) operations can take place.
45

46. ● Text files cannot deal with other data objects except strings
● List, tuples and dictionaries Objects have a specific structure to be
maintained while storing or accessing them.
● Thus Python provides a special module called pickle module for to read
and write objects likes list, tuples and dictionaries into a file.
To use the pickle module
Syntax : import pickle
46
https://www.youtube.com/watch?v=e5jbgyHf4-M

47. PICKLE Module
● Before reading or writing to a file, we have to import the pickle
module.
import pickle
● It provides two main functions :
○ dump()
○ load()
47

49. ● PICKLING refers to the process of converting the Python object to a byte
Stream(machine readable format) before writing to a file.
● UNPICKLING is used to convert the byte stream back to the original
structure while reading the contents of the file.
49

50. Pickling and Unpickling
50

51. pickle.dump() Method
● pickle.dump() method is used to write the object in file which is
opened in binary access mode.
Syntax :
pickle.dump(<object-to-be-written>,<FileObject>)
● <object-to-be-written> can be any sequence in Python such as list,
dictionary etc.
● <FileObject> is the file handle of file in which we have to write.
51

52. binary_file.dat file
after execution of
the program.
52

53. pickle.load() Method
● pickle.load() method is used to read data from a file
Syntax :
<structure> = pickle.load(<FileObject>)
● Structure can be any sequence in Python such as list, dictionary etc.
● FileObject is the file handle of file in which we have to write.
53

54. 54

57. Random Access in Files : tell() and seek()
❏ tell() function is used to obtain the current position of the file pointer
Syntax : f.tell()
❏ File pointer is like a cursor, which determines from where data has to be
read or written in the file.
57

58. Random Access in Files : tell()
58

59. Random Access in Files : tell() and seek()
❏ seek () function is used to change the position of the file pointer to a given
position.
Syntax : f.seek(offset,reference_point)
Where f is the file object
59

60. 60

61. 61

62. CSV files
● CSV stands for Comma Separated Values.
● CSV files are delimited files that store tabular data (in spreadsheet or
database) where comma delimits every value.
● Each line of the file is a data record.
● Each record consists of one or more fields, separated by commas.
● The separator character of CSV files is called a delimiter.
● Default delimiter is (,).
● Other delimiters are tab(t), colon (:), pipe(|), semicolon (;) characters.
62

63. Python CSV Module
● CSV module provides two types of objects :
○ reader : to read from cvs files
○ writer : to write into csv files.
● To import csv module in our program , we use the following statement:
import csv
63

64. Opening / Closing a CSV File
● Open a CSV File :
f = open(“demo_csv.csv”,”r”)
OR
f = open(“demo_csv.csv”,”w”)
● Close a CSV File:
f.close()
64

65. Role of argument newline in opening
of csv files :
● newline argument specifies how would python handle new line characters
while working with csv files on different Operating System.
● Additional optional argument as newline = “”(null string no space in
between) with the file open() will ensure that no translation of EOL character
takes place.
● F=open(“stu.csv”,”w”,newline=“”)
65

66. Writing in CSV Files
● csv.writer() :
Returns a writer object which writes data into csv files.
● writerow() :
Writes one row of data onto the writer object.
Syntax : <writer_object>.writerow()
● writerows() :
Writes multiple rows into the writer object
Syntax : <writer_object>.writerow() 66

67. Steps to write data to a csv file
1. Import csv module
import csv
2. Open csv file in write mode.
f = open(“csv_demo.csv”,”w”)
3. Create the writer object.
demo_writer = csv.writer(f) (by default delimiter is comma(,))
OR(for using other delimiter) - demo_writer = csv.writer(f, delimiter=“|”)
4. Write data using the methods writerow() or writerows()
demo_writer.writerow(<iterable_object>)
5. Close the file
f.close() 67

68. Writing in CSV Files
● To write data into csv files, writer() function of csv module is used.
● csv.writer():
○ Returns a writer object which writes data into csv files.
● Significance of writer object
○ The csv.writer() returns a writer object that converts the data into
csv writable form i.e. a delimited string form.
68

70. ● <writer_object>.writerow() :
Writes one row of data in to the writer object.
● <writer_object>.writerows()
Writes multiple rows into the writer object.
70

71. 71
import csv
fh=open("student.csv","w“,newline=“”)
swriter=csv.writer(fh)
swriter.writerow(['rollno','name','marks'])
for i in range(5):
print("student record:",i+1)
rollno=int(input("enter rollno"))
name=input("enter name")
marks=float(input("enter marks"))
sturec=[rollno,name,marks]
swriter.writerow(sturec)
fh.close()
While writing if newline is used it displays output without a newline(or space in between two lines)
Write a program to create a CSV file to store student data. Write five records into the file.

72. The writerows() function
72
Create a nested sequence out of the data and then write using the writerows() function
Write a program to create a CSV file.
import csv
fh = open("compresult.csv", "w")
cwriter = csv.writer(fh)
compdata = [ ['Name', 'Points', 'Rank’], ['Shradha', 4500, 23],
['Nishchay', 4800, 31], ['Ali', 4500, 25], ['Adi', 5100, 14] ]
cwriter.writerows (compdata)
fh.close()

73. Reading from CSV Module
● To read data from csv files, reader function of csv module is used.
● csv.reader() :
Returns a reader object.
It loads data from a csv file into an iterable after parsing delimited data.
73

74. Steps to read data from a csv file
1. Import csv module
import csv
2. Open csv file in read mode.
f = open(“csv_demo.csv”,”r”)
3. Create the reader object.
demo_reader = csv.reader(f)
4. Fetch data through for loop, row by row.
for rec in demo_reader:
print(rec)
5. Close the file
f.close()
74

76. 76
import csv
fh=open("student.csv","r")
sreader=csv.reader(fh)
for tr in sreader:
print(tr)
fh.close()
Using newline
import csv
fh=open("student.csv","r“, newline=“rn”)
sreader=csv.reader(fh)
for tr in sreader:
print(tr)
fh.close()
Using with statement
import csv
with open("student.csv","r") as fh
sreader=csv.reader(fh)
for tr in sreader:
print(tr)
While reading if newline is used it displays
output without a newline(or space in
between two lines)

77. QUESTIONS FOR
PRACTICE
Write a method in python to read the content from a file “Poem.txt”
and display the same on the screen.
Write a method in python to read the content from a file “Poem.txt”
line by line and display the same on the screen.
Write a method in python to count the number of lines from a text
file which are starting with an alphabet T.
Write a method in Python to count the total number of words in a file
77

78. Write a method in python to read from a text file “Poem.text” to
find and display the occurrence of the word “Twinkle”
Write a method Bigline() in Python to read lines from a text file
“Poem.txt” and display those lines which are bigger than 50
characters.
Write a method to read data from a file. All the lowercase letter
should be stored in the file “lower.txt” , all upper case characters
get stored inside the file “upper.txt” and other characters stored
inside the file “others.txt”
78

79. ● Text file
Methods
1. <filehandle>.read()
2. <filehandle>.readline()
3. <filehandle>.readlines()
4. <filehandle>.write(str)
5. <filehandle>.writelines(<list>)
79
● Binary File
Import pickle
Functions :
1. pickle.dump(<obj_to_be_written>,<filehandle>)
2. pickle.load(<filehandle>)
● CSV File
Import csv
Functions :
1. <nameofwriterobject>= csv.writer(<filehandle>)
2. <nameofwriterobject>.writerow(<obj_to_be_written>)
3. <nameofwriterobject>.writerows(<obj_to_be_written>)
4. <nameofreaderobject>= csv.reader(<filehandle>)

80. THANK YOU
80