APEX INSTITUTE OF TECHNOLOGY

DEPARTMENT OF COMPUTER SCIENCE & ENGINEERING

Programming in Python (22CSH-287)

Faculty: Mr. Siddharth Kumar (E12853)

Lecture – 31 & 32
DISCOVER . LEARN . EMPOWER
Abstract Data Types 1
 COURSE OBJECTIVES

The course aims to:

1) To be able to understand programming skills in Python.

2) To be able to comprehend various operators of Python Programming Language.
3) To demonstrate about Python data structures like Lists, Tuples, Sets and Dictionaries
4) To understand about Functions, Modules and Regular Expressions in Python
Programming.
5) To develop the ability to write applications in Python.

2
 COURSE OUTCOMES
On completion of this course, the students shall be able to:-
Identify and interpret the basics syntax of Python Programming Language and be fluent
CO1
in the use of Python.

Express proficiency in the handling of conditional statements, loops, strings and

CO2
functions.

Understanding the data structures like Lists, Tuples, Sets and Dictionaries in
CO3
programming paradigms of Python Programming Language.

Ability to create practical and contemporary applications using Functions, Abstract Data
CO4
Types and Modules in Python.

Implementation of Python based applications using file input and output operations in
CO5
Python Programming.
3
 Unit-3 Syllabus
Unit-3 Contact Hours: 12 Hours

Abstract Data Abstract data types and ADT interface in Python Programming.
Types
Classes Class definition and other operations in the classes, Special Methods (such as _init_,
_str_, comparison methods and Arithmetic methods etc.), Class Example, Inheritance,
Inheritance and OOP.

Iterators & Recursive Fibonacci, Tower of Hanoi.

Recursion
Search Simple Search and Estimating Search Time, Binary Search and Estimating Binary Search
Time.
Sorting & Merging Selection Sort, Merge List, Merge Sort, Higher Order Sort.

File I/O File input and output operations in Python Programming Exceptions and Assertions.

Modules Introduction and Importing Modules

4
 SUGGESTIVE READINGS
Text Books / Reference Books
TEXT BOOKS
T1: Allen B. Downey, “Think Python: How to Think Like a Computer Scientist” 2nd Edition, Version 2.4.0, O'Reilly Media, Inc.";
2012 Aug 13.
T2: Dierbach, Charles. Introduction to computer science using python: A computational problem-solving focus. Wiley
Publishing, 2012.
T3: Guido van Rossum and Fred L. Drake Jr, -An Introduction to Python - Revised and updated for Python 3.2, Network Theory
Ltd., 2011.
T4: Andreas C. Müller, Sarah Guido, ― "Introduction to Machine Learning with Python",O'Reilly Media, Inc.; 2016.
REFERENCE BOOKS
R1: Timothy A. Budd, ―Exploring Python, Mc-Graw Hill Education (India) Private Ltd. 2015.
R2: Kenneth A. Lambert, ―Fundamentals of Python: First Programs, CENGAGE Learning, 2012.
R3: Charles Dierbach, ―Introduction to Computer Science using Python: A Computational Problem Solving Focus, Wiley India
Edition, 2013.
R4: Paul Gries, Jennifer Campbell and Jason Montojo, ―Practical Programming: An Introduction to Computer Science using
Python 3, Second edition, Pragmatic Programmers, LLC, 2013.

5
 Contents to be covered
Abstract Data Types (ADT) in Python

ADT interface in Python Programming

6
 Abstract Data Types (ADT) & Interface in Python

 In this PPT, we will learn about ADT but before understanding what ADT is let us consider different in-built
data types that are provided to us. Data types such as int, float, double, long, etc. are considered to be in-built
data types and we can perform basic operations with them such as addition, subtraction, division,
multiplication, etc. Now there might be a situation when we need operations for our user-defined data type
which have to be defined. These operations can be defined only as and when we require them. So, in order to
simplify the process of solving problems, we can create data structures along with their operations, and such
data structures that are not in-built are known as Abstract Data Type (ADT).
 Abstract Data type (ADT) is a type (or class) for objects whose behavior is defined by a set of values and a
set of operations. The definition of ADT only mentions what operations are to be performed but not how
these operations will be implemented. It does not specify how data will be organized in memory and what
algorithms will be used for implementing the operations. It is called “abstract” because it gives an
implementation-independent view.
 The process of providing only the essentials and hiding the details is known as abstraction.
7
 The user of data type does not need to
know how that data type is implemented,
for example, we have been using
Primitive values like int, float, char data
types only with the knowledge that these
data type can operate and be performed on
without any idea of how they are
implemented.
 So a user only needs to know what a data
type can do, but not how it will be
implemented. Think of ADT as a black
box which hides the inner structure and
design of the data type. Now we’ll define
three ADTs namely List ADT, Stack ADT,
8
Queue ADT.
 1. List ADT
• The data is generally stored in key sequence in a list which has a head structure consisting of count, pointers and address of compare
function needed to compare the data in the list.

• The data node contains the pointer to a data structure and a self-referential pointer which points to the next node in the list.

• The List ADT Functions is given below:

• get() – Return an element from the list at any given position.

• insert() – Insert an element at any position of the list.

• remove() – Remove the first occurrence of any element from a non-empty list.

• removeAt() – Remove the element at a specified location from a non-empty list.

View of List
• replace() – Replace an element at any position by another element.

• size() – Return the number of elements in the list.

• isEmpty() – Return true if the list is empty, otherwise return false.

• isFull() – Return true if the list is full, otherwise return false. 9

 2. Stack ADT
• In Stack ADT Implementation instead of data being stored in each node, the pointer to data is stored.
• The program allocates memory for the data and address is passed to the stack ADT.
• The head node and the data nodes are encapsulated in the ADT. The calling function can only see the
pointer to the stack.
• The stack head structure also contains a pointer to top and count of number of entries currently in stack.
• push() – Insert an element at one end of the stack called top.
• pop() – Remove and return the element at the top of the stack, if it is not empty.
• peek() – Return the element at the top of the stack without removing it, if the stack is not empty.
• size() – Return the number of elements in the stack.
• isEmpty() – Return true if the stack is empty, otherwise return false. View of Stack
10
• isFull() – Return true if the stack is full, otherwise return false.
 3. Queue ADT
• The queue abstract data type (ADT) follows the basic design of the stack abstract data type.
• Each node contains a void pointer to the data and the link pointer to the next element in the queue.
• The program’s responsibility is to allocate memory for storing the data.
• enqueue() – Insert an element at the end of the queue.
• dequeue() – Remove and return the first element of the queue, if the queue is not empty.
• peek() – Return the element of the queue without removing it, if the queue is not empty.
• size() – Return the number of elements in the queue.
• isEmpty() – Return true if the queue is empty, otherwise return false.
• isFull() – Return true if the queue is full, otherwise return false. View of Queue
11
 Features of ADT: Abstract data types (ADTs) are a way of encapsulating data and operations on that data into a single unit. Some of the
key features of ADTs include:
• Abstraction: The user does not need to know the implementation of the data structure only essentials are provided.
• Better Conceptualization: ADT gives us a better conceptualization of the real world.
• Robust: The program is robust and has the ability to catch errors.
• Encapsulation: ADTs hide the internal details of the data and provide a public interface for users to interact with the data. This
allows for easier maintenance and modification of the data structure.
• Data Abstraction: ADTs provide a level of abstraction from the implementation details of the data. Users only need to know the
operations that can be performed on the data, not how those operations are implemented.
• Data Structure Independence: ADTs can be implemented using different data structures, such as arrays or linked lists, without
affecting the functionality of the ADT.
• Information Hiding: ADTs can protect the integrity of the data by allowing access only to authorized users and operations. This
helps prevent errors and misuse of the data.
• Modularity: ADTs can be combined with other ADTs to form larger, more complex data structures. This allows for greater flexibility
and modularity in programming. 12
 Advantages:

• Encapsulation: ADTs provide a way to encapsulate data and operations into a single unit, making it easier
to manage and modify the data structure.

• Abstraction: ADTs allow users to work with data structures without having to know the implementation
details, which can simplify programming and reduce errors.

• Data Structure Independence: ADTs can be implemented using different data structures, which can make it
easier to adapt to changing needs and requirements.

• Information Hiding: ADTs can protect the integrity of data by controlling access and preventing
unauthorized modifications.

• Modularity: ADTs can be combined with other ADTs to form more complex data structures, which can
increase flexibility and modularity in programming.
13
 Disadvantages:

• Overhead: Implementing ADTs can add overhead in terms of memory and processing, which can affect
performance.

• Complexity: ADTs can be complex to implement, especially for large and complex data structures.

• Learning Curve: Using ADTs requires knowledge of their implementation and usage, which can take time
and effort to learn.

• Limited Flexibility: Some ADTs may be limited in their functionality or may not be suitable for all types
of data structures.

• Cost: Implementing ADTs may require additional resources and investment, which can increase the cost of
development.

14
 Summary
 Abstract Data Types (ADT): An Abstract Data Type (ADT) is a high-level description of a set of operations
that can be performed on a data structure, independent of its implementation.
 Focus on Operations: ADTs emphasize what operations can be performed on data rather than how they are
implemented.
 Encapsulation: ADTs encapsulate data and operations into a unified concept, promoting modularity.
 Characteristics of ADTs: Encapsulation and Information Hiding: ADTs encapsulate data and hide
implementation details, emphasizing the separation of concerns.
 Defined Operations: ADTs define a set of operations that can be performed on instances of the data type.
 Implementation Flexibility: Different implementations of an ADT can provide the same set of operations.
 Interface in Python: An interface in Python is a collection of abstract methods that define a contract for
classes implementing the interface. Interface methods are declared without providing an implementation.
 Enforcing Contracts: Classes implementing an interface must provide concrete implementations for all the
15
methods defined in the interface.
 Assessment Questions
Q Define Abstract Data Types (ADTs) and explain their purpose in software design.
Q Provide an example of a real-world scenario where an ADT could be beneficial.
Q Discuss the key characteristics of Abstract Data Types, focusing on encapsulation and information hiding.
Q How do ADTs contribute to modularity in software development?
Q Explain the concept of implementation flexibility in the context of Abstract Data Types.
Q Provide an example of how different implementations of the same ADT can coexist.
Q Define what an interface is in Python and describe its role in object-oriented programming.
Q How does an interface contribute to the concept of contractual agreement in classes?
Q Discuss the significance of abstract methods in Python interfaces.
Q Provide an example of an interface with abstract methods.
Q Explain how multiple inheritance is facilitated by interfaces in Python.
16
THANK YOU

For queries
Email: [email protected]
17