day06 面向对象编程

面向对象：

面向对象：

世界万物，皆可分类

世界万物，皆为对象

 

只要是对象，就肯定属于某种品类

只要是对象，就肯定有属性

 

 

 

 

特性：

多态：

一个统一的接口，多种实现

 例如:  一个公司 有程序员，销售，前台，但是他们都属于员工

          老板只需说工作， 那么下面的员工就开始各自的工作，不管你是程序猿，前台 都会各自做各自的事情

定义语法:

 

#定义一个狗类型

class  Dog:

          def bulk(self):          #会叫

                print("汪汪汪")

 

 

#创建一个狗

dog1 = Dog()

 

#创建多个狗:

dog2 = Dog()

dog3 = Dog()

 

 

#就为了传名字

 

构造函数：

#在实际化时做一些类的初始化的工作.

 

 

就是把 r1 这个变量名传进去类里了

self  就是你创建的对象的变量名

实践：

 class Role:
     def __init__(self,name,role,weapon,life_value=100,money=15000):
         self.name = name
         self.role = role
         self.weapon = weapon
         self.life_value = life_value
         self.money = money
     def shot(self):
         print("shotting ...")
     def got_shot(self):
         print("ah .... ,i got shot ...")
     def buy_gun(self,gun_name):
         print("{_name} buy the {_gun_name} gun".format(_name=self.name,_gun_name=gun_name))
 r1 = Role("Alex","F","ak-47")
 r2 = Role("小明","T","m4-a1")
 r1.buy_gun("m4")
 r2.got_shot()

运行结果：

实例变量：

也就是静态属性：

方法：

也就是动态属性

类变量：

新加变量：

默认去找实例变量，找不到实例变量才去找类变量

r1添加变量，r2 实例化不变，因为是r1 添加变量

改变类变量，如果实例里没有那个变量，那么就会跟着改变

对于list  会导致所有的改变

实验：

验证 字符串及其他变量的区别：

 class Role:
     n = 123
     n_lsit = []
     def __init__(self,name,role,weapon,life_value=100,money=15000):
         self.name = name
         self.role = role
         self.weapon = weapon
         self.life_value = life_value
         self.money = money
     def shot(self):
         print("shotting ...")
     def got_shot(self):
         print("ah .... ,i got shot ...")
     def buy_gun(self,gun_name):
         print("{_name} buy the {_gun_name} gun".format(_name=self.name,_gun_name=gun_name))
 r1 = Role("Alex","F","ak-47")
 r2 = Role("小明","T","m4-a1")
 # r1.buy_gun("m4")
 #
 # r2.got_shot()
 print("r1",r1.n,r1.n_lsit)
 print("r2",r2.n,r2.n_lsit)
 r1.n = "heh1"
 r2.n = "hah2"
 print("Class:",Role.n,Role.n_lsit)
 r1.n_lsit.append("r11")
 print("r1",r1.n,r1.n_lsit)
 r2.n_lsit.append("r22")
 print("r2",r2.n,r2.n_lsit)
 print("Class:",Role.n,Role.n_lsit)
 print("r1",r1.n,r1.n_lsit)

运行结果：

得出：

1 实例变量：  就是每个实例的特有属性

2 类变量：     就是大家共用的属性，节省内存开销， 如下两个的区别即是

 

 

析构函数：

在实例释放、销毁的时候自动执行的，通常用于做一些收尾工作，比如：

     1 关闭数据库连接

     2 关闭打开的临时文件

写一个：

如果在这之前就del  那么就会提前执行，也就是这个会在一个实例销毁时执行的

私有属性：

 

例如生命值，只有自己可以访问，别人不能调用也不能访问：

 

把这个变量隐藏了，对外不可用

外面想要查看，那么就定义一个函数然后在外面来调用这个函数即可

当然外面的不能访问，必然不能修改，所以想修改就要在里面定义好修改的方式，如下:

私有方法：

同上，把对应的方法前加__ 就不能在外面调用了，只能在里面调用：

实践 私有属性：

 class Role:
     n = 123
     n_lsit = []
     def __init__(self,name,role,weapon,life_value=100,money=15000):
         self.name = name
         self.role = role
         self.weapon = weapon
         self.__life_value = life_value
         self.money = money
     def shot(self):
         print("shotting ...")
     def got_shot(self):
         print("ah .... ,i got shot ...")
     def show_life_value(self):
         print("{_name}'s life value is {_life_value}".format(_name=self.name,
                                                              _life_value=self.__life_value))
     def buy_gun(self,gun_name):
         print("{_name} buy the {_gun_name} gun".format(_name=self.name,_gun_name=gun_name))
 r1 = Role("Alex","F","ak-47")
 r2 = Role("小明","T","m4-a1")
 r1.buy_gun("m4")
 r2.got_shot()
 r1.show_life_value()
 r2.show_life_value()

实践 私有方法：

同上，如果在外面调用此方法就会提示错误：

正确方式就是在类里定义另一个方法来调用这个方法：

 class Role:
     n = 123
     n_lsit = []
     def __init__(self,name,role,weapon,life_value=100,money=15000):
         self.name = name
         self.role = role
         self.weapon = weapon
         self.__life_value = life_value
         self.money = money
     def shot(self):
         print("shotting ...")
     def __got_shot(self):
         print("ah .... ,i got shot ...")
         self.__life_value -= 50
     def show_life_value(self):
         print("{_name}'s life value is {_life_value}".format(_name=self.name,
                                                              _life_value=self.__life_value))
     def buy_gun(self,gun_name):
         print("{_name} buy the {_gun_name} gun".format(_name=self.name,_gun_name=gun_name))
     def out_shot(self):
         print("调用里面的私有方法被射中...")
         self.__got_shot()
 r2 = Role("小明","T","m4-a1")
 r2.out_shot()
 r2.show_life_value()

封装  就是把实现的方式内部用私有方法，私有变量实现

 

继承  

写一个大类：

class People:

 

 

 

写一个男人：

增加新功能，并先调用父类方法：

这就等于重构了父类的方法

创建一个woman：

实践：

 class People:
     def __init__(self,name,age):
         self.name = name
         self.age = age
     def eat(self):
         print("{_name} is eatting ...".format(_name=self.name))
     def sleep(self):
         print("{_name} is sleepping ...".format(_name=self.name))
 class Man(People):
     def piao(self):  #添加新的方法，这个方法只能是这个类来用
         print("{_name} can piaoing ...".format(_name=self.name))
     def sleep(self):    #修改父类里的方法，添加功能，实现个性化
         People.sleep(self)
         print("给睡觉添加新的功能")
 class Woman(People):
     def sheng(self):   #添加新的方法，这个方法只能是这个类来用
         print("{_name} can shenghaizi ...".format(_name=self.name))
 m1 = Man("小明",22)
 w1 = Woman("小花",18)
 print("m1")
 m1.sleep()
 print("w1")
 w1.sleep()
 print("m1")
 m1.piao()
 print("w1")
 w1.sheng()

子类中的初始化：

对构造函数进行重构：

父类的所有参数都要写一遍，写完后面加自己的初始化变量

 下面功能一样： 更方便一些。当大类修改了后子类不需要修改

 

 

类：

新式和经典的区别就是新式和经典的多继承不一样了

 

 多继承，  python  支持，  有的语言支持，有的语言不支持

 

 

 实践：

 class People:
     def __init__(self,name,age):
         self.name = name
         self.age = age
     def eat(self):
         print("{_name} is eatting ...".format(_name=self.name))
     def sleep(self):
         print("{_name} is sleepping ...".format(_name=self.name))
 class Action(object):
     def make_friends(self,object):
         print("{_name} is making from {_obj_name}".format(_name=self.name,
                                                       _obj_name=object.name))
 class Man(People,Action):
     def piao(self):  #添加新的方法，这个方法只能是这个类来用
         print("{_name} can piaoing ...".format(_name=self.name))
     def sleep(self):    #修改父类里的方法，添加功能，实现个性化
         People.sleep(self)
         print("给睡觉添加新的功能")
 class Woman(People):
     def sheng(self):   #添加新的方法，这个方法只能是这个类来用
         print("{_name} can shenghaizi ...".format(_name=self.name))
 m1 = Man("小明",22)
 w1 = Woman("小花",18)
 m1.make_friends(w1)

扩展版：

 #!/usr/bin/env python3
 # Author: Shen Yang
 class People:
     def __init__(self,name,age):
         self.name = name
         self.age = age
     def eat(self):
         print("{_name} is eatting ...".format(_name=self.name))
     def sleep(self):
         print("{_name} is sleepping ...".format(_name=self.name))
 class Action(object):
     def make_friends(self,object):
         print("{_name} is making from {_obj_name}".format(_name=self.name,
                                                       _obj_name=object.name))
         self.firends.append(object)
     def pay_money(self,object):
         print("{_name} giveing {_obj_name} {_money} money".format(_name=self.name,
                                                                   _obj_name=object.name,
                                                                   _money=self.money))
 class Man(People,Action):
     firends = []
     def __init__(self,name,age,money):
         super(Man,self).__init__(name,age)
         self.money = money
     def piao(self):  #添加新的方法，这个方法只能是这个类来用
         print("{_name} can piaoing ...".format(_name=self.name))
     def sleep(self):    #修改父类里的方法，添加功能，实现个性化
         People.sleep(self)
         print("给睡觉添加新的功能")
 class Woman(People):
     def sheng(self):   #添加新的方法，这个方法只能是这个类来用
         print("{_name} can shenghaizi ...".format(_name=self.name))
 m1 = Man("小明",22,6800)
 w1 = Woman("小花",18)
 m1.make_friends(w1)
 m1.pay_money(w1)
 w1.name ="小花花"
 print(m1.firends[0].name)

多继承的顺序问题：

 

新式类 ：

只继承第一个 的初始化__init__

 

 

 

构造方法查找顺序：

1 广度优先  先找同一级的同一级的没有才往更上一级查找

2 深度优先 查找上级，上级没有就会往更上一级查找

 

 

python3 中的经典类和新式类都是广度优先：

python2 的经典类是按 深度优先  继承，新式类是按 广度优先 继承。。。。。。

 

这就是最大区别

 

 

object 是所有类的类：

 

class SchoolMember(object):

 写一个学校，员工，学生的对象程序：

 #!/usr/bin/env python3
 # Author: Shen Yang
 #object 是所有类的类：
 class School(object):
     def __init__(self,name,addr):
         self.name = name
         self.addr = addr
         self.students = []
         self.staffs = []
     def enroll(self,stu_obj):
         print("为{_stu_obj} 办理了入学手续。。。".format(_stu_obj=stu_obj.name))
         self.students.append(stu_obj)
     def hire(self,staff_obj):
         print("雇佣了新员工 {_staff_obj}".format(_staff_obj=staff_obj.name))
         self.staffs.append(staff_obj)
 class SchoolMember(object):
     def __init__(self,name,age,sex):
         self.name = name
         self.age = age
         self.sex = sex
     def tell(self):
         pass
 class Student(SchoolMember):
     def __init__(self,name,age,sex,stu_id,grade):
         super(Student,self).__init__(name,age,sex)
         self.stu_id = stu_id
         self.grade = grade
     def tell(self):
         print('''
         ----- info of Student: {_name} -----
         Name:{_name}
         Age:{_age}
         Sex:{_sex}
         Stu_id:{_stu_id}
         Grade:{_grade}
         '''.format(_name=self.name,_age=self.age,_sex=self.sex,_stu_id=self.stu_id,_grade=self.grade))
     def pay_tuition(self,amount):
         print("{_name} has paid tuition {_amount}".format(_name=self.name,_amount=amount))
 class Teacher(SchoolMember):
     def __init__(self,name,age,sex,salary,coure):
         super(Teacher,self).__init__(name,age,sex)
         self.salary = salary
         self.coure = coure
     def tell(self):
         print('''
         ----- info of Teacher: {_name} -----
         Name:{_name}
         Age:{_age}
         Sex:{_sex}
         Salary:{_salary}
         Coure:{_coure}
         '''.format(_name=self.name,_age=self.age,_sex=self.sex,_salary=self.salary,_coure=self.coure))
     def teach(self):
         print("{_name} has teach {_coure}".format(_name=self.name,_coure=self.coure))
 #初始化一个学校
 school = School("老男孩","沙河")
 #初始化两个教师
 t1 = Teacher("Oldboy",35,"M",20000,"Linux")
 t2 = Teacher("Alex",22,"M",3000,"Python")
 #初始化一个学生
 s1 = Student("Yang",26,"M",1001,"Python")
 #让第一个老师打印信息然后开始教课
 t1.tell()
 t1.teach()
 #让第二个老师打印信息
 t2.tell()
 #让学生打印信息然后缴费
 s1.tell()
 s1.pay_tuition(6888)
 #学校给学生办理入学手续
 school.enroll(s1)
 #打印学校学生
 print(school.students[0].name)
 school.hire(t1)
 school.hire(t2)
 for i in school.staffs:
     print(i.name)

 多态：