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)

 多态：