Explore topic-wise InterviewSolutions in .

UnboundLocalError: local variable ‘ptr’ referenced before assignment.

Abstract method : An unimplemented method is an abstract method. When an abstract method is declared in a base class, the driven class has to either define the method or raise” Nothlmplemented Error”

class Shape (object):

def findArea (self):

pass

class Square (Shape):

def_ init_(self, side):

self, side = side

def find Area (self):

return self.side*self.side

Note: We can use @ abstract method to enable parent class method to be executed.

The objects are declared after a class is defined. The object declaration create object of that class and memory is allocated for the created object. The object are created using the following syntax:
classname objectname1, objectname2,……………;
for example
student obj1, obj2;
the obj1 and obj2 are the objects of class type student.
The object names are used to access the data members through member functions by invoking member functions.
For example
obj1.getdata(5, 25);

here, getadata() is the member function of a class student and function call is give using object obj1 which assign the value 5 and 25 to the data members of the class. The memory is allocated separately for data members of each object.

In C++, the member functions can be coded in two ways :

1. Inside class definition
2. Outside class definition using scope resolution operator (::)

The code of the function is same in both the cases, but the function header is different as explained below:
1. Inside Class Definition:

When a member function is defined inside a class, we do not require to place membership label along with the function name. We use only small functions inside the class definition and such functions are known as inline functions.
In case of inline function, program execution is faster but memory penalty is there.

2. Outside Class Definition Using Scope Resolution Operator (::)

The member function declared in the class must be defined outside the class. Here the operator :: known as scope resolution operator helps in defining the member function outside the class.
In this case the function’s full name (qualified_name) is written as shown: Name_of_the_class :: function_name()
The syntax for a member function definition outside the class definition is:

return type name_of_the_class::function_name (argument list)
{
body of function;
}

The member functions declared outside a class has the following characteristics:

1. Data type and number of argument in member function must be same as data types and number of data declared in class definition.
2. Type scope resolution operator (::) helps in defining the member function outside the class. It also identifies the function as a member of particular class.
3. The different classes can use same member function names. Membership label will resolve their scope limiting a particular class.
4. Member function can access private and protected data of a class, but not a non-member function.

Syntax: classname objectname1, objectname2, …. ,objectname………… n ;
For example, Largest ob1,ob2; //object declaration will create two objects ob1 and ob2 of largest class type.

The object is an instance of a class.

The access specifiers used with a class are private, protected and public.

The data members and member functions can be accessed using access specifiers. They define the scope of members. The members of class are classified based on private/public/protected members.

1. Private members:
The member data and members functions defined using access specifier private, can be accessed by member functions of that class only. Non-members of . the class cannot access private members of the class. If no access specifier is mentioned for the members, then it is treated as private members.

2. Protected members:
The protected members are similar to private members of a class in a single class. But, if a class is derived from an existing class, then protected members of the base class are accessible to the derived class.

3. Public members:
The public members can be accessed by member functions of the class and non member function (outside the class) of the class. The public member functions can access private, protected and public data members of the class.

The private access specifer is implicitly used in a class.

Yes, the public members can be accessed by member functions of the class and non-member function (outside the class) of the class.

The data members and member functions can be accessed using access specifiers. They define the scope of members. The different access specifiers are private, protected and public.

The member functions are behaviour of a class and can access or manipulate data members without passing them as parameters.

The variables are declared inside the class and are called data members.

The public members can be accessed by member functions of the class and non member function (outside the class) of the class.

The two types of member referenced in a class are data members and member functions.

The class members are referenced using dot (.) operator. The public data members of a class can be accessed using dot (.) operator using objects of that class.
For example, objectname . datamember;
The member function is invoked by a object name dot operator and member function name.
For example, obj1.getdata();

The protected members are similar to private members of a class in a single class. But, if a class is derived from an existing class, then protected members of the base class are accessible to the derived class.

The public members of a class can be accessed by member functions of that class and also non member functions (outside the class) of the class. The public member functions can access private, protected and public data members of the class.

The public members can be accessed by member functions of the class and non member function (outside the class) of the class.

The dot (.) is used to access members of a class.

The operator :: known as scope resolution operator helps in defining member function outside the class.

A class definition is a process of naming a class and data variables and interface operations of the class. A class declaration specifies the representation of objects of the class and set of operations that can be applied to such objects.

Syntax: classname objectname₁, objectname₂, …. ,objectname_n ;
For example, Largest ob1,ob2; //object declaration

The array of class type is known as array of objects.

class SOCIETY:

# constructor to create an object

def init (self):

#constructor

self. society_name=‘Surya Apartments’

self.house_no=20

self.no_of_members=3

self.flat=AType’

self.income=25000

def Inputdata(self):

self. society_name = raw_input (“Enter Society Name”)

self.house_no=input(“Enter House Number”)

self.no_of_members = input (“Enter No. of members”)

self.income = float(raw_input (“Enter income”))

def Allocate_Flat(self):

if self.income >= 25000:

self.flat = AType’

elif self.income >= 20000 and self.income < 25000 :

self.flat = ‘BTÿpe’ else:

self.flat = ‘CType’

def Showdata(self):

print “Society Name”,

self.society_name

print “House_No”,

self.house_no print “No.of members”,

self.no_of mem-bers

print “Flat Type”,

self.flat print “Income”,

self.income

S = SOCIETY))

S.InputdataO

S.Allocate_Flat()

S.ShowdataO

class PRODUCT:

def init (self):

self. Pid = self. Pname = self. Peostprice = 0.0 self. Psellingprice = 0.0 self. Margin = 0.0 self. Remarks = def SetRemarks (self) :

self . Margin = self.Psellinrprice-self. Peostprice

if (self.Margin < 0) :

self. Ramarks = “Loss”

else:

self. Remarks = “Profit” defGetdetails (self):

self.Pid = rawjnput (“Enter Product Id”)

self.Pname = rawjnput (“Enter Product Name”)

self.Peostprice = input (“Enter Cost Price”)

self.Psellingprice = input (“Enter Selling Price”)

self. SetRemarks ( ) def Setdateils (self) :

print “Product Id” ,

self.Pid print “Product Name”,

self.Pname print “Cost Price”,

self.Pcostprice print “Selling Price”,

self.Esellingprice print “Margin : ” ,

self.Margin print “Incurred :” ,

self.Remarks

# constructor to create an object

def init (self,s=None):

#non-copy constructor if s==None:

self.rollno = 0 self.name = ‘ ’

self.marks = [0,0,0]

self.avg = 0.0 self.grade = ‘ ’

# copy constructor else:

self.rollno = s.rollno self.name = s.name self.marks = s.marks self.avg = s.avg

self.grade = s.grade

def read (self):

# This function gets the details of a student from the user

selfrollno=iaw_input(“Enter roll number.-’)

self.name = raw_input(“Enter name:-”) s=0

for i in range(0,3):

self.marks [i] = int(r a w_input (“Enter the marks ?”)) s = s + self.marksfi] self.avg = s/3

if(self.avg>60):

self.grade=‘A’

elif self.avg>40:

self.grade=‘B’

else:

self.grade=‘C’

def display (self):

# This function prints each student’s details

print self.rollno,“\t”, self, name, “\t\ t”,

self.grade s = StudentO studlist = []

num = int(raw_input(“Enter no. of students:-’’))

for i in range(O.num):

s.read()

studlist. append(Student(s))

print “ STUDENT REPORT \n”

print “***********************************\n”

print “RollNo \t Name \t\t Grade”

print “*******************************************\n”

for i in range(0,num):

studlist[i] .displayO

#Initialize avg as the first student’s avg maxavg = studlist[0].avg totavg = 0

for i in range(l.num):

totavg = totavg + studlist[i].avg if studlist[i].avg > maxavg: maxavg = studlist[i].avg

topper = studlist[i].name totavg = totavg/num

print “Class topper is”,studlist[i],name,“with average”, studlist [i]. avg

print “Class average is”,totavg

class Student:

Name mangling of the double underscore makes the most sense for achieving “private-ness”. Now when a function is called from the ‘self’ instance and it notices that it starts with ‘_’, it just performs the name mangling right there. Name mangling is helpful for letting sub-classes override methods without breaking intra class method calls.

_str_ returns a string representation of a Point object. If a class provides a method named _str _, it overrides the default behavior of the Python built-in

_str_ function.

>>> p = Point(3, 4)

>>> str(p)

‘(3,4)’

Printing a Point object implicitly invokes _str_ on the object, so*- defining _str_

also changes the behavior of print:

>>> p = Point(3,4)

>>> print p(3,4)

Reference counting works by counting the number of times an object is referenced by other objects in the system. Python’s garbage collector runs during program execution and is triggered when an object’s reference count reaches zero. An object’s reference count changes as the number of aliases that point to it change. 

An object’s reference count increases when it is assigned a new name or placed in a container (list, tuple or dictionary). The object’s reference count decreases when it is deleted with del, its reference is reassigned, or its reference goes out of scope. When an object’s reference count reaches zero, Python collects it automatically. 

Automatic garbage collectiomPython deletes the objects which are not required, may it be built-in types or class instances, through the process named garbage collection. When the number of allocations minus the number of de-allocations is greater than the threshold number, the garbage collector is run and the unused block of memory is reclaimed. 

One can inspect the threshold for new objects by loading the garbage collector (GC) module and asking for garbage collection thresholds.

The difference is that the attribute on the class is shared by all instances. The attribute on an instance is unique to that instance.

a. _init_

b. scope

c. _doc_

d. _str_

e. _delattr_ ()

A namespace is a mapping from names to objects. Examples of namespaces are built-in names, global names in a module and local names in the function invocation.

self is an object reference to the object itself, therefore, they are same. Python methods are not called in the context of the object itself, self in Python may be used to deal with custom object models.

1. _init_ help to create objects and instances in the parent class.

2. It reserves the memory to the members of the class.

super ( ) function is used to call base class methods which have been extended in derived class.

Example :

class GradStudent (Student):

def_ init _(self) :

super (GradStudent, self). _init _( )

self. subject = ” ”

self. working = ” ”

def readGrad (self) :

# Call readStudent method of parent class super (GradStudent, self). 

readStudent ( )

LEGB rule: when a name is encountered during the execution of the program, it searches for that name in the following order:

L. Local – It first makes a local search, i.e. in a current def statement.

E. Enclosing functions – It searches in all enclosing functions, from inner to outer.

G. Global (module) – It searches for global modules or for names declared global

B. Built-in (Python) – Finally it checks for any built-in functions in Python.

When a class doesn’t define any methods or attributes, but syntactically, there needs to be something in the definition, so we use the pass. It is a statement that does nothing and is a good placeholder when you are stubbing out functions or classes.

User classes are considered mutable. Python doesn’t have (absolutely) private attributes, so you can always change a class.

1. getattr(obj, name[, default])

2. delattr(obj, name)

The output is

51

51

1. hasattr (Tl,str)

2. setattr (Tl, str, “Hello”)

Runs scored are : 281

Wickets taken are : 5

Test._ do_ : None

Test._name_ : Match

Test._module_ : main

Test._bases_ : ()

Test. _diet_ : {‘ _module _’: ‘_ main_ ’, ‘_doc _’: None, ‘runs’: 281, ‘_init_ ’:

<function _init_ at 0x0000000002DDFBA8>, ‘wickets’: 5}

class customer:

def _init_(self):

self.customemumber=111

self.customemame=‘Leena’

self.qty=0

self.price=0

self.discount=0

self.netprice=0

def caldiscount(self):

totalprice = self.price*self.qty

if totalprice >= 50000:

self.discount=totalprice * 0.25

elif totalprice >= 25000:

self.discount = totalprice * 0.15 else:

self.discount = totalprice * 0.10

self.netprice = totalprice – self.discount

def input(self):

self.customernumber=input(“Enter Customer Number”)

self.customemame = raw_input(“Enter Customer Name”)

self.qty = input(“Enter Quantity”)

self.price = input(“Enter Price”)

self.caldiscount()

def show(self):

print “Customer Number”,

self.customernumber

print “Customer Name”,

self.customemame

print “Quantity”,self.quanti-ty

print “Price”,self.price

print “Discount”,self.discount

print “Net price”,self.netprice

c = customer()

c.inputO c.show()

class SUPPLY:

• constructor to create an object

def init (self) :

#constructor

self.FoodCode=()

self.FoodName=‘ ’

self.FoodType=‘ ’

self.Sticker=‘ ’

def Foodln(self):

self.FoodCode=input(“Enter Food Code”)

self.FoodName=raw_input(“Enter Food Name”)

self.Sticker=raw_input(“Enter Sticker Colour”)

def GetType(self):

if self.Sticker==‘GREEN’:

self.FoodType = ‘Vegetarian’

elif self.Sticker==’YELLOW’:

self.FoodType = ‘Contains Egg’

elif self.Sticker==‘RED’:

self.FoodType = ‘Non-Vegetarian’ else:

self.FoodType = ‘Not Known’

def FoodOut(self):

print “FoodCode’’,self.FoodCode

print “FoodName”,self.FoodName

print “FoodType”,self.FoodType

print “Sticker”,self.Sticker

S = SUPPLY()

S.FoodIn()

S.GetTÿpe()

S.FoodOut()

class ITEMINFO:

#constructor to create an .object

def_init_(self):

#constructor

self.ICode=0

self.Item=‘ ’

self.Price=0.0

self.Qty=‘ ’

self.Discount=0

self.Netprice=0.0

def Buy(self):

self.ICode=input(“Enter Item Code”)

self. Item=raw_input(“Enter Item Name”)

self.Price=float(raw_input(“Enter Price”))

self.Qty=input(“Enter Quantity”)

def FindDisc(self):

if self.Qty <= 10:

self.Discount = 0

elif self.Qty >= 11 and self.Qty < 20 :

self.Discount = 15

else:

self.Discount = 20

self.Netprice= (self.Price*self.Qty)

self.Discount

def ShowAll(self):

print “Item Code’’,self.ICode

print “Item Name”,self.Item

print “Price”,self.Price

print “Quantity”,self.Qty

print “NetPrice”,self.Netprice

I = ITEMINFO()

I.Buy()

I.FindDisc()

I. Show All ()