UNIT - 3

Files
 Types of files
 File Paths
 File Methods to Read and Writing Data
 Pickle Module
 Reading and Writing CSV files

Object-Oriented Programming

 Classes and Objects

 Creating Classes in Python
 Creating Objects in Python
 Constructor Method
 Classes with Multiple Objects
 Class Attributes Versus Data Attributes
 Encapsulation
 Inheritance
 Polymorphism
What is a file?
 File is a named location on disk to store related information. It is used to
permanently store data in a non-volatile memory (e.g. hard disk).
 Since, random access memory (RAM) is volatile which loses its data
when computer is turned off, we use files for future use of the data.
 When we want to read from or write to a file, we need to open it first.
When we are done, it needs to be closed, so that resources that are tied
with the file are freed.
 We can retrieve data whenever required.
 File Handling in Python enables us to create, update, read, and delete the
files stored on the file system through our python program.

Types of Files

1. Text Files
2. Binary Files

1.Text Files

 While both binary and text files contain data stored as a series of bits
(binary values of 1s and 0s).
 Text files are more restrictive than binary files since they can only contain
textual data.
 A small error in a text file can be corrected after opening a text file.
 Text files Python are that contain human-readable text and are encoded
using either ASCII or Unicode character sets.

 Termination of each line in a text file is denoted with the end of line (EOL).
There are a few special characters that are used as EOL, but comma {J and
newlines (\n) are the most common ones.
  Command Examples of Text Files:
 Tabular data: csv, tsv, etc.
 Documents: .txt, .tex, .rtf, etc.
 Web standards: html, xml, css, json etc.
 Configuration: 11M, cfg, reg, etc.
 Program Source Code. .java, .c, .py, .cpp

2.Binary Files
 Computer store every file as a collection of 0s and 1s i.e., in binary form.
 A small error in a binary file may make it unreadable.
 Binary files In Python are files that contain non-human-readable binary
data. Binary data stored a specific format and Its interpretation depends on
the type of binary file.

 All binary files follow a specific format. We can open some binary files in
the normal text editor but can't read the content present Inside the file.
That's because all the binary files Will be encoded in the binary format,
which can be understood only by a specific software
 Common Examples of Binary Files.
 Document files: pdt, -doc
xls etc
 Image files: .png, .jpg, .gif, .bmp etc.
 Audio files: mp3, wav, mka, .aac etc.
 Video files: .mp4, .3gp, .mkv, .avi etc.
File Paths

A file path is the location of a file on a computer system.

There are two types of file paths in python

1.Absolute Path

2.Relative Path

1.Absolute Path: An absolute file path is also called a Fully Qualified File
Path or a Complete File Path. It is called an absolute file path because it
specifies the complete and exact location of a file on a computer system.

Example: C:\\Users\Admin\PythonExamplesprogram\Demo.py

2.Relative Path: A relative file path that is relative to the current working
directory.

Example: Demo.py

Opening a File

When a file is opened using open () function, it returns a file object

called a file handler.

Syntax: file_Object=open (filename, mode, buffering)

Example: file=open (“file.txt”,” r”, buffering=2038)

 The open () function returns a file handler object for the file
name.
 File name: The first arguments is the file name.
 Mode: The second arguments is the file opening mode.
 Buffering: The “buffering” argument is an optional integer
argument that specifies the size of the buffer used for file I/O.
File Opening Modes

Mode Description

‘r’ Open text file for reading. Raises an I/O error if the file does not exist.

Open the file for reading and writing. Raises an I/O error if the file
‘r+’
does not exist.

Open the file for writing. Truncates the file if it already exists. Creates
‘w’
a new file if it does not exist.

Open the file for reading and writing. Truncates the file if it already
‘w+’
exists. Creates a new file if it does not exist.

Open the file for writing. The data being written will be inserted at the
‘a’
end of the file. Creates a new file if it does not exist.

Open the file for reading and writing. The data being written will be
‘a+’
inserted at the end of the file. Creates a new file if it does not exist.

Open the file for reading in binary format. Raises an I/O error if the file
‘rb’
does not exist.

Open the file for reading and writing in binary format. Raises an I/O
‘rb+’
error if the file does not exist.

Open the file for writing in binary format. Truncates the file if it
‘wb’
already exists. Creates a new file if it does not exist.

Open the file for reading and writing in binary format. Truncates the
‘wb+’
file if it already exists. Creates a new file if it does not exist.

Open the file for appending in binary format. Inserts data at the end of
‘ab’
the file. Creates a new file if it does not exist.

Open the file for reading and appending in binary format. Inserts data
‘ab+’
at the end of the file. Creates a new file if it does not exist.
Closing a File

Closing a file in Python is the process of releasing the resources associated with
the file object and saving any changes made to the files.

Syntax: file_Object =close ()

Example: f=open (“file.txt”,” r”)

f. close ()

File Methods to Read and Writing Data

When we use the open () function a file object is created. There are lot of
methods that can be called on file object to read and write data on files.

Reading Methods from a file

File Object read methods are used to read data from a file in Python.

1.read ()

2.readline ()

3.readlines ()

1.read (): This Method reads the entire contents of a file as sting.

Syntax: file_Object. read([size])

Example: with open (“file.txt”,” r”) as f:

Contents=f.read()
print (Contents)

2.readline (): This Method reads a single line of the file.

Syntax: file_Object.readline()

Example: with open (“file.txt”,” r”) as f:

 line =f. readline ()
print (line)

3.readlines (): This Method reads the entire contents of a file as a list of strings,
where each string is a line of the file.

Syntax: file_Object.readline()

Example: with open (“file.txt”,” r”) as f:

lines=file. readlines ()

for line in lines:

print(line)

Write Methods from a file

There are two methods to write to a file in Python.

1.write ()

2.writelines ()

1.write (): The write method is used to write a string to a file.

Syntax: file_Object. write(string)

Example: with open (“file.txt”, “w”) as file:

file. write (“Hello, World!”)

2.writelines (): The writelines method is used to write a list of strings to a file.

Syntax: file_Object.writelines(list of string)

Example: with open (“file.txt”, “w”) as file:

lines= [“line 1\n”, “line 2\n”, “line 3\n”]

file. writelines(lines)
Random Access in a File Using seek () and tell () Methods

1.tell () Method

 The tell () method in Python returns the current position of the file pointer
within a file.
 It returns an integer value representing the number of bytes from the
beginning of the file to the current position of the file pointer.

Syntax: file_Object.tell()

Example:

with open (“file.txt”, “r”) as file:

print (“current position:”, file. tell ())
contents=file. read (5)
print (“current position after reading 5 bytes:”, file. tell ())
contents=file. read (5)
print (“current position after reading another 5 bytes:”, file. tell())

2. seek () Method

 The seek () method in Python is used to move the file pointer to a

specifies position within the file.
 The method moves the file pointer to a specified position within the file,
so that we can read from or write to that position.

Syntax: file_Object. seek (offset, whence)

 offset: is the number of bytes to move the file pointer. It can be a positive
or negative integer value.
 whence is an optional parameter that specifies the starting point from
where the offset is applied.
  0(default)- offset is relative to the beginning of the file.
 1-offset is relative to the current position.
 2-offset is relative to the end of the file.

Example:

with open (“file.txt”, “w+”) as file:

file. write(“Hello”)
file. seek (0)
print (file. read ())
file. seek (6)
file. write(“Mr.”)
file. seek (0)
print (file. read ())

Pickle Module

 The pickle module in Python is a module used to serialize(pickling) and

deserialize(unpickling)Python objects to a byte stream representation of 0s
and 1s.

 It’s important because it enables the conversion of complex Python objects

(such as lists, dictionaries, etc).

 We need to import the pickle module using the import pickle statement in
a program.

What is Pickling and Unpickling

1. Pickling or Serialization  The Process of converting a Python object

into a byte stream representation using the pickle module is called
pickling or Serialization. The pickle. dump () method is used to store the
Python object in the file.
2. Unpickling or Deserialization The process of converting a byte
stream representation into a Python object is called unpickling or
Deserialization. The pickle. load () method is used to retrieve pickled data
from the file.
Advantages of Pickling and Unpickling

 Serialization: Pickling converts Python objects into a binary format for

easy storage or transmission.
 Persistence: It allows storing Python objects on disk, maintaining their
state between program runs.
 Cross-Language compatibility: Pickled files can be read by any Python
program regardless of platform or version.
 Efficiency: Ideal for storing complex data structure without losing their
structure or relationships.
 Security: Pickling secures sensitive data by storing it in a non-human-
readable binary format.
 Ease of Use: Pickling and unpickling are straightforward operations in
Python, requiring minimal code.

Methods For Pickling and Unpickling

1. pickle. dump () -> This method serializes an object and writes it to a file.

Syntax: pickle. dump (obj, open (“file. pickle”,” wb”)

2. pickle. dumps () ->It serializes an object and returns a byte stream.

Syntax: pickle_object=pickle. dumps(obj)

3. pickle. load () -> This method deserializes an object from a file.

Syntax: obj=pickle. load (open (“file. pickle”,” rb”))

4. pickle. loads () ->This method deserializes an object from a byte stream.

Syntax: obj=pickle. loads(pickle_object)

What is the difference between pickle. load () and pickle. loads ()?

 pickle. load (): This function is used to deserialize a binary object

containing pickled data. It reads the pickled data from the file and returns
the corresponding Python object.
 pickle. loads (): This function is used to deserialize a string object
containing pickled data. It takes a string as input, interprets it as pickled
data, and returns the corresponding Python object.

What is the difference between pickle. dump () and pickle. dumps ()?

 pickle. dump (obj, file): This function is used to serialize the Python
object obj into a binary format and write it to the specified file object file.
It saves the pickled data to a file on disk.
 pickle. dumps (obj): This function is used to serialize the Python object
obj into a binary format and return it as a string. It returns the picked data
as a string object, which can be stored in memory or transmitted over a
network.

Pickling and Unpickling Examples

The pickle module in Python provides the ability to serialize and deserialize
Python objects. This means that we can take a Python object, convert it into a
byte representation and store it in a file, and then recreate the object from the file.
This process is called “pickling” and “unpickling”.

Pickling and Unpickling Using dump () and load ()

import pickle

data_to_pickle = {'name': 'John', 'age': 25, 'city': 'New York'}

with open ('data. pickle1', 'wb') as file:

pickle. dump (data_to_pickle, file)

with open ('data. pickle1', 'rb') as file:

loaded data = pickle. load(file)

print ("Loaded Data:", loaded data)

Output:

Loaded Data: {'name': 'John', 'age': 25, 'city': 'New York'}

Pickling and Unpickling Using dumps () and loads ()

import pickle

#Define a Dictionary

data={"name":"gourav","age":23,"city":"Mysore"}

#Serialize data

pick Object=pickle.dumps(data)

print (pick Object)

#deserialize pickle_object

unpick Object=pickle.loads(pick Object)

print (unpick Object)

Output:

b'\x80\x04\x95\x00\x00\x00\x00\x00\x00\x00}\x94(\x8c\x04name\x94\x8c\x06
gourav\x94\x8c\x03age\x94K\x17\x8c\x04city\x94\x8c\x06Mysore\x94u.'

{'name': 'gourav', 'age': 23, 'city': 'Mysore'}

Reading and Writing CSV files

 CSV (Comma-Separator Values) is a file format that stores tabular data

(numbers and text) in plain-text form.
  CSV files are widely used because they are simple and easy to read, and
can be opened in almost any spreadsheet such as google sheets.

Characteristics of a CSV File

• CSV files are stored in plain text format.

• CSV files store data in a tabular format with each row representing a
record and each column representing a field.

• The values in each record are separated by commas, which makes it easy
to extract the data.

• Each line in a csv file represents a separate record.

• CSV files can store different data types, including text, numbers and
dates.

• CSV file is simple to use and can be easily transported b/w different s/w
application and platforms

Uses of a CSV File

• Data Exchange: exchange data b/w different software applications

platforms.

• Data Storage: used to store data for later use.

• Data analysis: easily analysed using various data analysis tools,

including spreadsheets.

• Data sharing: easily shared b/w different users, either email or by

placing file on a network drive.

CSV Module in Python

• CSV module in python is a built-in library that provides functionality for

reading and writing to CSV files.
 • Some of the main uses of the csv module in python

1) Reading CSV data The csv. reader object can be used to read data.

2) Writing CSV data The csv. writer object can be used to write data.

3) Modifying existing CSV data we can read data from a CSV file modify,
and then write it back to the file using the csv module. useful for data cleaning.

4) Handling large datasetsThe csv module is optimized for working with

large datasets and can handle reading and writing large amounts of data
efficiently.

5)Parsing CSV data with different delimiterThe csv module provides the
Dialect class, which can be used to specify the delimiter used in the CSV file.

Note: we need to import csv module using the import csv statement in a
program.

Writing CSV File Using csv. Writer

• The csv. writer object is a class from the CSV module in Python that
provides methods for writing data to a CSV file.

• The csv. writer object methods

1) writerow(row) Writes a single row of data to the CSV file.

2) writerows(rows)Writes multiple rows of data to the CSV file.

3) writerheader () Writes the first row of the CSV file with field names.

Example: Writing Data to CSV File Using csv. writer and writerows ()
Method

import csv

data=[['name','age','occupation'], ['rama',23,'doctor'], ['sita',23,'Lawyer']]

with open ('data.csv','w', newline='') as file:

writer=csv. writer(file)

writer. writerows(data)

Output:

name age occupation

rama 23 doctor
sita 23 Lawyer

Reading CSV Files Using csv. reader

• The csv. reader object is a class from the CSV module in Python that
provides methods for reading data from a CSV file.

• CSV file reader object methods

1) reader ()  Returns an iterator that iterates over the rows of the CSV
file. Each row is returned as a list of values.

Example:

import csv

with open('data.csv’,’w’) as file:

reader=csv. reader(file)

for row in reader:

print(row)

Output:

['name', 'age', 'occupation']

['rama', '23', 'doctor']
['sita', '23', 'Lawyer']
Object-Oriented Programming

OOPS Concepts

• Object-oriented programming is a programming that focuses on objects

and their interactions, rather than just the procedural steps to solve a
problem.

• OOP is a programming paradigm in which concepts are represented as

objects that have data fields (attributes or states or data members) and
associated functions (methods or behaviours or member functions) and
objects communicate with each other by exchanging messages.

• The focus of OOP is on the state and behaviour of each object, and
everything in a program is viewed as an object.

Difference between Object-Oriented and Procedural Oriented

Programming

Features of Object-Oriented Programming

 More focus is on data rather than functions or procedures.

 Programs are divided into entities known as objects.
 Objects may communicate with each other through function.
  Data is hidden and cannot be accessed by external function.
 Data Structures are designed such that they characterize objects.
 Functions that operate on data of an object are tied together in data
structure.

Basic Concepts of Object-Oriented Programming

 Class: A blueprint for creating objects. It defines attributes and methods

that objects will have.
 Object: An Instance of a class that contains the actual data.
 Attributes: Variables inside a class that store data relevant to the class.
 Methods: Functions inside a class that perform operations on the class's
data.
 Encapsulation: Bundling data and methods within a class to hide
implementation details.
 Abstraction: Hides complex implementation details, exposing only
necessary parts.
 Inheritance: Allows a class (subclass) to inherit attributes and methods
from another class (superclass).
  Polymorphism: It is the ability to exist in more than one form.

Class and Objects

• A class is a collection of objects. A class is a blueprint or template for
creating objects. It defines a set of data and methods that represent the
characteristics and behaviour of the objects created from the class.
• The class contains data and methods bundled together under a single unit.
• The class Keyword is used to create classes.
• By general convention we start names with capital letters.
• Syntax: class ClassName:
#Statement-1
…….
#Statement-N
Object
• Object is an instance of a class, which has data members and uses various
member functions to perform tasks.
• Objects represent a real-world entity and encapsulation data(attributes)
and behavior (methods) associated with the entity. Objects can interact
with each other by sending and receiving messages (method calls).
• Syntax: [object name] = [class_name] (arguments/parameters)
• Three Characteristics of an Object
• State (Data Members or Data Fields): It is represented by the attributes
of an object.
• Behavior (Methods or Functions): It is represented by the methods of
an object.
• Object Identity: It gives a unique name to an object and enables one
object to interact with other objects.
Class and Object Example

Example of Python Class and object

Class and Object Example 2

class Person:

def __init__ (self, name, age):

self.name = name

self.age = age

def introduce(self):

print (hello, my name is {self.name} and I am {self.age} years old.")

# Create objects

person1 = Person ("Alice", 25)

person2 = Person ("Bob", 30)

# Access attributes

print(person1.name)

print(person2.age)

# Access methods

person1.introduce()

person2.introduce()

Output:

Alice

30

Hello, my name is Alice and I am 25 years old.

Hello, my name is Bob and I am 30 years old.

Creating Objects and Accessing Methods in Objects

 Creating an Object in Python

Syntax: Object name=Class_name(arguments)

 Accessing Methods in Python

Syntax: Object_name. instance method(arguments)

 Assign value to an instance variable or data attribute

Syntax: Object_name. instance_variable_name=value

Classes with Multiple Objects

 Creating Multiple Objects in Python is a process of creating

multiple instances of a class. Each call to the constructor creates
a new instance of the class.

 Syntax: class ClassName:

#class data or class variable

#constructor methods, instance methods

#Creating the first Object

Object1=ClassName(constructor_arguments)

#Creating a second object

Object2=ClassName(constructor_arguments)

Objects as Arguments to a Function

Constructor Method

• In OOP, the constructor method is a special method that is called when an

object is created.

• It is used to initialize the object’s properties or instance variables or data

attributes of the class.

• The Constructor Method is called _init_ and it is defined within a class.

• Syntax: def _init_ (self, [arg1, arg2,….])

• Self-parameter is a reference to the instance of the object.

Rules of Constructor

• It starts with the def keyword, like all other functions in Python.

• It is followed by the word init, which is prefixed and suffixed

with double underscores with a pair of brackets i.e., _init_ ().
 • It takes the first argument called self to initialize values to the
instance variables.

• Self is a reference to the current instance of the class.

Example of Constructor Method

Types Of Constructors

• There are three types of constructors in Python

1. Default Constructor

2. Non-Parameterized Constructor

3. Parameterized Constructor

1. Default Constructor

-> A default constructor is a constructor that takes no parameters. It is

automatically created by Python if no constructor method is defined in
the class.
 2. Non-Parameterized Constructor

 A Constructor without any arguments is called a non –

parameterized constructor. This type of constructor is used to
initialize each object with default values.

3. Parameterized Constructor

A parameterized constructor is a constructor that takes parameters and is

used to initialize attributes or instance variables of an object when it is created.
Class Attributes versus Data Attributes

Encapsulation
• Encapsulation is a concept in object-oriented programming
(OOP) that refers to the process of handling data and behaviour
within a single unit or object.
• The Primary objective of encapsulation is to secure data from any
unauthorized modifications from outside sources.
• Example: Customer opens a bank account.
Advantages of Encapsulation
 Protection of objects from unauthorized access.
 Prevention of access to private class members by other classes.
 Increased security by protecting code and logic from external inheritance.
 Improved readability and maintainability through bundling of data and
methods with a single class.
 Avoid accidental data modification through private and protected access
levels.
Different Ways of Achieving Encapsulation
1. Using Private Variables
 Access to these variables can only be done through methods within the
class.
 The Private variables are declared with two underscores in front of their
names.
 Example: __variableName
2. Using Protected Variables
 Protected variables can be accessed by the same class and its subclasses,
but cannot be accessed from outside the class or other subclasses.
 Protected variables are denoted by a single underscore before the variable
name.
 Example: _protectedVariable
3. Using Getter and Setter
 The getter and setter are common techniques to achieve encapsulation
and data hiding.
 A getter method is used to retrieve the value of an attribute.
 A setter method is used to set the value of an attribute.
 These methods can be defined within a class and can be used to control
access to the attributes of the class.
Example:
class Bank Account:
def __init__ (self, balance):
self. Balance = balance
def deposit (self, amount):
self. Balance += amount
def withdraw (self, amount):
self. Balance -= amount
# Creating an instance of the Bank Account class
Bank_Account = Bank Account (1000)
# Accessing the balance directly and modifying
print (Bank_Account.balance)
Bank_Account.withdraw(100)
print (Bank_Account.balance)
Output:
1000
900
Example 2:
Access Modifiers in Python
• Encapsulation along with data hiding is achieved by declaring a class’s
data members and methods as either private or protected.
• Access modifiers are used to limit access to the variables and methods of
a class.
• Python Provides three types of access modifiers public, private, and
protected.
• Public: A Public member can be accessed from outside the class.
• Private: A Private member can only be accessed within the same class.
• Protected: A Protected member can be accessed within the same class
and any subclasses.

Public
Private

Protected

Inheritance
 The derived class inherits attributes and behaviours from the
base class.
  The new class is called the derived class or subclass or child
class and the existing class is referred to as the base class or
super class or parent class.
 Definition: Inheritance can be defined as the process of
acquiring properties of one object from other objects.
 The Main use of inheritance is to reuse existing code and extend
its functionality in the subclass.
 Syntax:

Types of Inheritance
There are five types of Inheritance
1. Single Inheritance
2. Multilevel Inheritance
3. Hierarchical Inheritance
4. Multiple Inheritance
5. Hybrid Inheritance
Single Inheritance
• Single Inheritance when a child class inherits from a single
parent class.
Syntax: class BaseClassName:
#body of the derived class
Class DerivedClassName (BaseClassName):
#body of the derived class
Example:

Multilevel Inheritance
• When a class inherits from a class that has already inherited from another
class.

Syntax:
class BaseClass:
#base class code here
class DerivedClass1(BaseClass):
 #derived class 1 code here
class DerivedClass2(DerivedClass1):
#derived class 2 code here
Example:

Hierarchical Inheritance
• When multiple classes inherit from a single base class.

Syntax:
class BaseClass:
#base class code here
class DerivedClass1(BaseClass):
#derived class 1 code here
class DerivedClass2(BaseClass):
#derived class 2 code here
Example:

Multiple Inheritance
• When a child class inherits from multiple parent classes.

Syntax: class DerivedClass (Base1, Base2, …, BaseN):

#class body
Example:

Hybrid Inheritance
• When a combination of two or more inheritance types are used in a single
program.
Syntax: class A:
#class A code here
class B(A):
#class B code here
class C(A):
#class C code here
class D (B, C):
#class D code here
Example:

Polymorphism
• Polymorphism in Object-Oriented Programming refers to the ability of an
object to take on multiple forms.
• The word poly means ‘many’ and morphs means ‘many forms.
• The Main use of Polymorphism is, Increase code reusability.
Types of Polymorphism
1. Compile Time Polymorphism
 Compile Time Polymorphism is also known as Static Polymorphism.
 Method Overloading is an example of compile-time polymorphism.
 Python does not support Method overloading and hence there is no
compile-time polymorphism in Python.
2. Runtime Polymorphism
Runtime Polymorphism is also Known as Dynamic Polymorphism.
Runtime polymorphism is a polymorphism that is resolved during the
runtime or the program execution.
. Method Overriding is an Example of Runtime Polymorphism.

Method Overloading
 Method overloading is a feature in some programming languages that
allows to have multiple methods with the same name but different
parameter lists within a single class.

 Python does not support method overloading directly.

Example:
class Rectangle:
def_init_ (self, width=0, height=0):
self. width=width
self. height=height
def area(self):
return self. width * self. height
rect1=Rectangle ()
rect2=Rectangle (10,20)
print (rect1.area())
print (rect2.area())
Output:
0
200

Method Overriding
 Method Overriding is the process of providing a new implementation for a
method that is already defined in a parent class. In object-oriented
programming it allows a subclass to provide a different implementation for
a method that is already defined in a superclass.

 The method in the superclass is known as the Overridden Method, while

the method in the subclass is known as the overriding method.

Advantages of Method Overriding

• Improved code reuse -> allows for greater code reuse and reduces the
amount of code duplication.
• Polymorphism ->which means that objects of different classes can be
treated as objects of the same class.
• Better control over inheritance -> allows a subclass to have more control
over the behavior inherited from its parent class.
• Better abstraction -> enables a better abstraction of code by allowing the
implementation of methods to be specific classes.
Example:
class Camera:
def shoot(self):
print (“shoot with a standard camera”)
class SLRCamera (Camera):
def shoot(self):
print (“shoot with an SLR Camera”)
std_camera=Camera ()
slr_camera=SLRCamera ()
std_camera. shoot ()
slr_camera. shoot ()

Super () Function
 The super () function in Python returns a temporary object of the immediate
parent class that can be used to call methods of the parent class.

 It allows a subclass to call methods on its parent class without having to

specify the name of the parent class.

 This makes the code more flexible and reduces the risk of maintenance
issues when the parent class.

Example: