(i) The elements of a list can be accessed in two ways.
(ii) The first way is via multiple assignment and the second method is by the element selection operator

Person is referred to as a class or a type, while p1 is referred to as an object or an instance.

(i) A class defines a data abstraction by grouping related data items. A class is not just data, it has functions defined within it.
(ii) Functions are subordinate to the class because their job is to do things with the data of the class.

rational(n, d):
return [n, d]
numer(x):
return x[0]
denom(x):
return x[1]

(i) A pair is a compound data type that holds two other pieces of data. The two ways of representing the pair data type.
(ii) The first way is using List construct and the second way to implement pairs is with the tuple construct.

(i) To implement the concrete level of data abstraction, languages like Python provides a compound structure called Pair which is made up of list or Tuple.
(ii) The first way to implement pairs is with the List construct

The pseudo code for the representation of the rational number using the above constructor and selector is component
x,y:=8,3
rational(n,d)
numer(x)/numer(y)
- - output: 2.6666666666666665

(i) Selector
(ii) Constructor

(i) There can be different ways to implement an ADT, for example, the, List ADT can be implemented using singly linked list or doubly linked list.
(ii) Similarly, stack ADT and Queue ADT can be implemented using lists

(i) A tuple is a comma-separated sequence of values surrounded with parentheses. Tuple is similar to a list.
(ii) The difference between the two is that you cannot change the elements of a tuple once it is assigned whereas in a list, elements can be changed
(iii) Example : colour = ('red', 'blue, 'Green')

List is constructed by placing expressions within square brackets separated by commas. List can store multiple values.
Example:
1st := [10, 20]
x, y:= 1st
In the above example x will become 10 and y will become 20.

(i) Abstract Data type (ADT) is a type (or class) for objects whose behavior is defined by a set of value and a set of operations. 
(ii) The definition of ADT only mentions what operations are to be performed but not how these operations will be implemented.

An ADT for rational numbers:
- - constructor
- - constructs a rational number with numerator n, denominator d
rational(n, d)
- - selector
number(x) \(\rightarrow \) returns the numerator of rational number x
denom(y) \(\rightarrow \) returns the denominator of rational number y

(i) Data abstraction is supported by defining an abstract data type (ADT) which is a collection of constructors and selectors.
(ii) Constructors create an object, bundling together different pieces of information, while selectors extract individual pieces of information from the object.

(i) Constructor
(ii) Selector
(iii) Constructor
(iv) Selector
(v) Selector

(a) List
(b) Tuple
(c) Class
(d) Tuple
(e) List
(f) Class

(i) The elements of a list can be accessed in two ways. The first way is via our familiar method of multiple assignment, which unpacks a list into its elements and binds each element to a different name.
lst := [10, 20]
x, y := lst
(ii) In the above example x will become l0 andy will become 20.
(iii) A second method for accessing the elements in a list is by the element selection operator. Unlike a list literal, a square brackets  expression directly following another expression does not evaluate to a list value, but instead selects an element from the value of the preceding expression.
Ist [0]
10
lst [1]
20

 

(a) Constructors
(b) Selectors
(c) Selectors
(d) Selectors
(e) Constructors
(f) Selectors

A powerful strategy for designing programs, 'wishful thinking'. Wishful Thinking is the formation of beliefs and making decisions according to what might be pleasing to imagine instead of by appealing to reality.

(i) The basic idea of data abstraction is to structure programs so that they operate on abstract data. That is, our programs should use data in such a way, as to make as few assumptions about the data as possible.
(li) At the same time, a concrete data representation is defined as an independent part of the program.
(iii) Any program consist of two parts. The two parts of a program are, the part that operates on abstract data and the part that defines a concrete representation, is connected by a small set of functions that implement abstract data in terms of the concrete representation.
(iv) To illustrate this technique, let us consider an example to design a set of functions for manipulating rational numbers.
(v) Example: A rational number is a ratio of integers, and rational numbers constitute an important sub-class of real numbers. A rational number such as 8/3 or 19/23 is typically written as : < numerator > /< denominator >
(vi) where both the < numerator > and <denominator> are placeholders for integer values. Both parts are needed to exactly characterize the value of the rational number. Actually dividing integers produces a float approximation, losing the exact precision of integers.
(vii) However, you can create an exact representation for rational numbers by combining together the numerator and denominator.
(viii) As we know from using functional abstractions, we can start programming productively before you have an implementation of some parts of our program.
(ix) Let us begin by assuming that you already have a way of constructing a rational number from a numerator and a denominator. You also assume that, given a rational number, you have a way of selecting its numerator and its denominator component.

(i) The structure construct (In OOP languages it's called class construct) is used to represent multi-part objects where each part is named (given a name). Consider the following pseudo code:
Class Person:
creation()
first Name:=""
last Name:=""
id :=""
email :=""
The new data type Person is pictorially represented as

In the case of something more complex, like a person, we have a multí-item object where each item is a named thing: the first name, the last name, the id, and the email. One could use a list to represent a person:
Person = ['padmashri', 'Baskar', '994-222-1234', 'compsci@gmail.com']

(ii) The class (structure) construct defines the from for multi-part objects that represent a person.
(iii) Person is referred to as a class or a type, while pl is referred to as an object or an instance.
(iv) Here class Person as a Cookie cutter, and pl as a particular cookie, Using the cookie cutter you can make many cookies, Same way using class created many objects of that type. 
(v) A class defines a data abstraction by grouping related data items. A class is not just data, it has functions defined within it, We say such  functions are subordinate to the class because their job is to do thngs with the data of the class.

List : 
(i) List is constructed by placing expressions within square brackets separated by commas. Such an expression is called a list literal. List can store  multiple values. Each value can be of any type and can even be another list.
Example for List [10, 20].
(ii) The elenments of a list can be accessed in two ways. The first way is via our familiar method of multiple assignment, which unpacks a list into its elements and binds each elenment to a different name.
Ist := [10, 20]
x, y = lst
(iii) In the above example x will become l0 and y will become 20. A second method for accessing the elements in a list is by the element  selection operator.
(iv) Unlike a list literal, a square-brackets expression directly following another expression does not evaluate to a list value, but instead selects an element from the value of the preceding expression.
lst [0]
10
Ist [1]
20
(v) In both the example mentioned above mathematically we can represent list similar to a set.

Pair :
Any way of bundling two values together into one can be considered as a pair. Lists are a common methodto do so. Therefore List can be called as Pairs.

Data abstraction is used to define an Abstract Data Type (ADT), which is a collection of constructors and selectors. T facilitate data abstraction,you will need to create two types of functions : Constructors and Selectors.
Constructors :
(i) Constructors are functions that build the abstract data type.
(ii) Constructors create an object, bundling together different pieces of information.
(iii) For example, say you have an abstract data type called city.
(iv) This city object will hold the city's name, and its latitude and longitude.
(v) To create a city object, you'd use a function like city = makecity (name, lat, lon).
(vi) Here makecity (name, lat, lon) is the constructor which creates the object city.

Selectors :
(i) Selectors are functions that retrieve information from the data type.
(ii) Selectors extract individual pieces of information fromn the object.
(iii) To extract the information of a city object, you wouldused functions like
getname(city)
getlat(city)
getlon(city)
These are the selectors because these functions extract the information of the city object.