My Python Notes:class ToolKit & unittest Framework

What is a class ?

Class is way to represent Object found in the Real World.
The way we define a function using the keyword def ,class can be created using the keyword class.
So Lets create a class which describes the behavior of a human being using a Human class. 

Syntax   
class Human(object):

Class allow us to logical group data & functions and the data is know as attributes,functions is referred to as  methods.

As humans  we  have a name & age these are attributes.

Now let create a class Human with name & age.To represent the behavior of the Human we have defined two method eat() & my_stomach().
       

human.py

                      

With human.py we have create a human class ie... we have a blueprint for Humans

Function within a class are known as methods
Now lets create a who Human whose name is Jude Augustine,age 24 from the Human class ie... we are creating an object whose name is Jude Augustine & age 24

                                              object.py

lets run object.py

What have we done we have create a new object from the Human class

Note:
__init__()--- is used to assign value to the object ie..initialize the attributes.
The INIT method doesn't have a return statement, but it return the object that was created.

__str__()--- it return information about the object.

Lets us talk  to Jude why is he so sad.

Let write code it and save it in conversation1.py

Lets make Jude Happy....

Lets write the code for the above and save in conversation2.py

Creating Multiple Objects from Human Class

 Create James & John whose ages are 21 &22 have a sister whose name is Lisa who is 18 year Old,lets
create them using the Human Class.

                                              family.py

                                       
                                 save the above code in family.py & run it
#1 in family.py we are importing the Human class from the file human.py

#2 we create a brother_james with name james & age 21.

#3 we create a brother_john which is an object of class Human with name John & is 22 years old.

Creating multiple objects using List-Comprehension

                                       

from the above code we notice that humans[0] ----> James,24
                                                         humans[1] ----> John,22
                                                         humans[2] ----> Lisa,18

Now lets test  human.py using Unittest module

Lets now write the code for the above test cases.
 
                                    testHuman.py

 Now lets run  it testHuman.py

Now lets write some negative test cases

lets write the code & save it in negative.py

TookKIT
                  Human Class with few TookkIT elements.

class Human(object): """Being a human i have a name & age. We can eat using the eat()--method. The my_stomach return the food_list found in the stomach. """ heart = 1 #Class variable def __init__(self,name,age): """(object,string,number)-> object This method initalize the human object whose name is *name* and age is *age* """ self.name = name #instance variables self.age = age self.food_list = [] def __str__(self): """Return the name & age of the object""" s = "My name is %s. "%self.name s +="I am %d year old."%self.age return s def eat(self,food): """ (object,string)->None Add the food eaten to the food_list """ self.food_list.append(food) def my_stomach(self): #Regular Methods """ (object) ->list contents of my stomach""" talk ="" if self.food_list: talk ="I ate" else: talk ="i am hungry" print(talk,','.join(self.food_list)) return self.food_list @staticmethod #static method def heart_beat_sound(): return("lap--dubp--lap-dubp")  

1)Instance Variables are defined within the __init__ ()--method.

Information about Instance variable may vary as we can see from the multiple objects code.

Eg for Human class , name & age are instance variables.

2)Regular methods----function within a class are know are methods

Eg---- __init__(), __str__() ,eat() , my_stomach() are all methods

all the above method use self ,ie method using self are a parameter are known as Regular Methods.

3)Class Variables--- as human being we all have a heart & every being has One Heart.

   Eg-- heart = 1

4)Static Methods-- method that dont need self as a paramter, because they dont modify the Instance variables.They are helper function which can be used by other Regular Method.
They are added to class using decorators.

Eg   @staticmethod
        def heart_sound():
               print("lup--dup--lup---dup")

How does you heartBeat

the code for the above scenario 

heart.py

from human import Human doctor = Human("DR Andrew",45) patient = Human("joseph",30) print("patient::>> how is my heart beat ") #doctor refers the patients static method print("Doctors::>>",patient.heart_beat_sound())

Run it