python中的类与对象（2）

目录

一. 类的基本语法

二. 类属性的应用场景

三. 类与类之间的依赖关系

（1）依赖关系

（2）关联关系

（3）组合关系

四. 类的继承

---

一. 类的基本语法

先看一段最简单的代码：

class Dog():
    d_type = "二哈"  # 属性，类属性，类变量

    def say_hi(self):  # 在类里面的函数称为方法，第一个参数必须是self，代表实例本身
        print("hello,i am a dog,my type is",self.d_type)

dog1 = Dog()  # 生成了一个实例
dog1.say_hi()  # 实例.方法
# hello,i am a dog,my name is 二哈
print(dog1.d_type)  # 实例.属性
# 二哈

这段代码定义了一个名为Dog的类，其中有一个类属性d_type设置为"二哈"，以及一个实例方法say_hi用于打印一句话。然后创建了一个名为dog1的实例，并调用了say_hi方法和打印了实例属性d_type的值。

这里d_type是Dog类的属性（类属性/类变量/公共属性），从Dog类生成的对象都自带这个属性，如果我们想要定义每条狗的实例属性/实例变量/成员变量，如姓名，年龄，主人信息等，则使用__init__方法定义私有属性。我们并没有调用__init__(self,xxxx)，但它会自动执行。因为它叫初始化函数，就是在实例化的时候，用来初始化一些数据的，比如初始化实例的名字、年龄等私有属性。

这些写在__init__(self,xxxx)里name，age等实例变量，跟公共属性d_type有什么区别呢?换句话说私有属性和共有属性有什么区别？区别就是，d_type是存在Dog类自己的内存里，self.name，self.age是存在每个实例自己的内存里。

class Dog():
    d_type = "二哈"
    def __init__(self, name, age):  # __init__函数称为初始化方法，构造方法，构造函数，在创建对象时自动调用
        # 第一个参数必须是self，代表实例本身
        # 要想把私有属性name, age真正的存到实例里，就要把2个值和实例绑定
        self.name = name  # 绑定__init__参数值到对象
        self.age = age

    def say_hi(self):  # 第一个参数必须是self
        print("hello,i am a dog,my name is",self.name)

dog1 = Dog("zhaopeng",4)  # 实例化对象，相当于__init__(dog1, "zhaopeng", 4)
dog1.say_hi()  # 相当于类中say_hi(dog1)
print(dog1.name, dog1.d_type)  # 打印对象的公共属性和私有属性
print(id(dog1.d_type), id(Dog.d_type))  # 公共属性，对象和类共享内存
dog1.name = "zhangsan"
dog1.d_type = "藏獒"
print(dog1.name, dog1.d_type)  # 对象属性可以在类外重写

这里需要重点搞明白self什么意思，我们先搞明白实例化的过程：

step 1，d=Dog("毛毛"，2,"Alex")，会申请一会内存空间，指向变量名d

step 2，__init__这个初始化方法需要把接收到参数存下来， 存到这个d的内存空间里

step 3，传给初始化方法里的name,age想绑定到d的空间里，怎么存呢？就得把d的内存空间传到这个方法里，所以self就是用来接收d的地址的。d=Dog(“毛毛”，2,"AIex”)相当于Dog(d,"毛毛",2,"Aex”)，那self.name=name 也就相当于d.name =name。我们在实例时没有手动传递d到Dog类里，只写了d=Dog(“毛毛”,2,"Alex”)，是Python解释器帮你自动干了这个事。

到此，我们终于明白，原来self就是代表实例本身。实例化时python会自动把这个实例本身通过self参数传进去。接下来看第二个方法：

def say_hi(self):  # 第一个参数必须是self
    print("hello,i am a dog,my name is",self.name)

这里为何也要加入self参数？那是因为，你自己也看到了， 这个类的方法其实就是函数。函数被一个实例调用时，它需要知道是谁在调用它？函数内部要用到一些实例的属性的时候去哪里取呢？比如在say_hi函数里怎么取到d.name，d.age？只能你先传递给它。所以这就是为何类下的每个方法第一个参数都要是self，因为为了接收实例这个对象本身。

*注意：self在实例化时自动将对象/实例本身传给__init__的第一个参数，你也可以给他起个别的名字，但是正常人都不会这么做，因为你瞎改别人就不认识。

二. 类属性的应用场景

仍然是通过一段代码说明如何调用和修改类属性，实例属性：

class People():
    nationality = "CN"  # nationality是公共属性
    def __init__(self, name, age, sex):  # name, age, sex是私有属性
        self.name = name
        self.age = age
        self.sex = sex
# 实例化
p1 = People("zhangsan",31,"M")
p2 = People("lisi",25,"M")
p3 = People("wangwu",21,"F")
# 调用公共属性
print(People.nationality)
print(p2.nationality)
# 调用实例属性
print(p1.age)  # 实例属性不能在类中调用，只能在实例中调用
print(People.age)  # AttributeError: type object 'People' has no attribute 'age'
# 修改私有属性
p1.age = 22  # 修改私有属性
print(p1.age)
# 修改公共属性
p1.nationality = "TW"  # 修改公共属性
print(p1.nationality)  # TW
print(p2.nationality,People.nationality)  # CN CN
# 修改p1的公共属性不改变People类，实际上是因为p1.nationality = "TW" 这句相当于为p1增加了实例属性nationality

搞懂了这个我们就可以重写上一节的引子，利用类方法来写：

class Dog():
    life_val = 100
    def __init__(self, name, d_type, attack_val):
        self.name = name
        self.d_type = d_type
        self.attack_val = attack_val
    def bite(self, person):
        person.life_val -= self.attack_val
        print("狗[%s]咬了[%s]一口，人掉血[%s]，剩余血量[%s]"%(self.name, person.name, self.attack_val, person.life_val))

class Person():
    life_val = 100
    def __init__(self, name, age, attack_val):
        self.name = name
        self.age = age
        self.attack_val = attack_val
    def beat(self, dog):
        dog.life_val -= self.attack_val
        print("人[%s]打了狗[%s]一棒，狗掉血[%s]，剩余血量[%s]"%(self.name, dog.name, self.attack_val, dog.life_val))

dog1 = Dog("FWE", "二哈", 10)
person1 = Person("zhaopeng", 25, 30)
dog1.bite(person1)
# 狗[FWE]咬了[zhaopeng]一口，人掉血[10]，剩余血量[90]
person1.beat(dog1)
# 人[zhaopeng]打了狗[FWE]一棒，狗掉血[30]，剩余血量[70]

三. 类与类之间的依赖关系

大千世界，万物之间皆有规则和规律。类和对象是对大千世界中的所有事物进行归类，事物之间存在着相对应的关系，类与类之间也同样如此。类与类中存在以下关系：

• 依赖关系，狗和主人的关系。
• 关联关系，你和你的女友之间的关系就是关联关系。
• 聚合关系，电脑的各部件组戒完整的电脑，电脑里有CPU，硬盘，内存等。每个组件有自己的生命周期，电脑挂了，CPU还是好的，还是完整的个体。
• 组合关系，比聚合还要紧密。比如人的大脑，心脏，各个器官，这些器官组合成一个人。这时人如果挂了，其他的东西也跟着挂。
• 继承关系，类的三大特性之一，子承父业。

（1）依赖关系

class Dog():
    life_val = 100
    def __init__(self, name, d_type, attack_val, master):
        self.name = name
        self.d_type = d_type
        self.attack_val = attack_val
        self.master = master  # 人作为一个对象，和狗产生依赖关系
        self.say_hi()
    def say_hi(self):
        print("Hello, i am a dog, my name is [%s], and my master is [%s]"%(self.name, self.master.name))

class Person():
    life_val = 100
    def __init__(self, name, age, attack_val):
        self.name = name
        self.age = age
        self.attack_val = attack_val
    def beat(self, dog):
        dog.life_val -= self.attack_val
        print("人[%s]打了狗[%s]一棒，狗掉血[%s]，剩余血量[%s]"%(self.name, dog.name, self.attack_val, dog.life_val))

person1 = Person("zhaopeng", 25, 30)
dog1 = Dog("FWE", "二哈", 10, person1)

（2）关联关系

构造男生和女生谈恋爱的关联：如果直接加一个partner实例属性：

class Person():
    def __init__(self, name, age, sex, partner):
        self.name = name
        self.age = age
        self.sex = sex
        self.partner = partner
    
person1 = Person("zhaopeng", 25, "M", person2)  # NameError: name 'person2' is not defined.
person2 = Person("wangwu", 25, "F", person1)

因为实例化person1时，需要向里传person2，而此时person2还没创建出来，所以此时会报NameError。我们可以先把self.partner初始为None，然后再建立联系：

class Person():
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex
        self.partner = None
    
person1 = Person("zhaopeng", 25, "M")  
person2 = Person("wangwu", 25, "F")
person1.partner = person2  # 建立联系
person2.partner = person1
print(person1.partner.name,person2.partner.name)  # wangwu zhaopeng

这似乎解决了问题，但是：男生和女生的恋爱关系是一个双向的过程，这种写法我们必须同时写两句，来建立或者删除联系。如何只用一条指令就同时建立和删除双方之间的联系？一种思路是，单独写一个类relationship专门处理，存储2个人的关系状态，2个人在查自己的感情状态时，都到这个单独的实例里来查：

class Relationship():
    def __init__(self):
        self.relationship = []  # 生成空列表
    def make_couple(self, p1, p2):  # 建立恋爱关系
        self.relationship = [p1, p2]
        print("[%s]和[%s]确定了恋爱关系"%(p1.name, p2.name))

class Person():
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex
    
person1 = Person("zhaopeng", 25, "M")  
person2 = Person("wangwu", 25, "F")
relationship = Relationship()
relationship.make_couple(person1, person2)
# [zhaopeng]和[wangwu]确定了恋爱关系

现在我们再做一点改进，我们希望能在人的属性里面查到自己的男朋友/女朋友，这里就需要对Person类进行修改：

class Relationship():
    def __init__(self):
        self.relationship = []  # 生成空列表
    def make_couple(self, p1, p2):  # 建立恋爱关系
        self.relationship = [p1, p2]
        print("[%s]和[%s]确定了恋爱关系"%(p1.name, p2.name))

class Person():
    def __init__(self, name, age, sex, relation):
        self.name = name
        self.age = age
        self.sex = sex
        self.relation = relation  # 把对象是谁加到实例属性里面
    
relationship = Relationship()
person1 = Person("zhaopeng", 25, "M", relationship)  
person2 = Person("wangwu", 25, "F", relationship)
relationship.make_couple(person1, person2)
print(person1.relation.relationship)
# 这里person1.relation其实就是之前建立的relationship = Relationship()
# 然后再.relationship输出的是那个列表

但是这样显示是个列表，我们再优化Relationship类，使得它更完整：

class Relationship():
    def __init__(self):
        self.relationship = []  # 生成空列表
    def make_couple(self, p1, p2):  # 建立恋爱关系
        self.relationship = [p1, p2]
        print("[%s]和[%s]确定了恋爱关系"%(p1.name, p2.name))
    def get_partner(self, person):  # 找寻另一半
        # 这里还要传入person是因为，self.relationship列表里有两个人，需要确定具体是显示哪一个的另一半
        if len(self.relationship) == 0:
            print("[%s]没有对象！" % person.name)
        else:
            for i in self.relationship:
                if i != person:
                    print("[%s]的对象是[%s]" % (person.name, i.name))
    def break_up(self):  # 模拟分手
        if len(self.relationship) == 0:
            print("两人已经分手了")
        else:
            print("[%s]和[%s]分手了"%(self.relationship[0].name, self.relationship[1].name))
            self.relationship = []
            

class Person():
    def __init__(self, name, age, sex, relation):
        self.name = name
        self.age = age
        self.sex = sex
        self.relation = relation  # 把对象是谁加到实例属性里面

# 实例化
relationship = Relationship()
person1 = Person("zhaopeng", 25, "M", relationship)  
person2 = Person("wangwu", 25, "F", relationship)

relationship.make_couple(person1, person2)  # 建立恋爱关系
# [zhaopeng]和[wangwu]确定了恋爱关系
person1.relation.get_partner(person1)  # 找到person1的另一半是谁
# [zhaopeng]的对象是[wangwu]
person1.relation.break_up()  # 分手
# [zhaopeng]和[wangwu]分手了
person2.relation.get_partner(person2)  # 此时获取person2的对象，显示无
# [wangwu]没有对象！

以上我们就同步了两个人的恋爱关系，同时导演了一部恋爱到分手的大戏（大雾）。

（3）组合关系

# 组合关系：由一堆组件构成一个完整的实体，组件本身独立但又不能自己运行，必须跟宿主组合在一起运行
# 这里的武器类就必须依赖人来运行，人实例化对象的同时也实例化武器
class Weapon():
    def gun(self, dog):
        self.attack_val = 50
        self.name = "枪"
        dog.life_val -= self.attack_val
        print("[%s]被[%s]攻击了，掉血[%s]，还剩血量[%s]"%(dog.name, self.name, self.attack_val, dog.life_val))

    def knife(self, dog):
        self.attack_val = 20
        self.name = "匕首"
        dog.life_val -= self.attack_val
        print("[%s]被[%s]攻击了，掉血[%s]，还剩血量[%s]"%(dog.name, self.name, self.attack_val, dog.life_val))

    def AK47(self, dog):
        self.attack_val = 80
        self.name = "AK47"
        dog.life_val -= self.attack_val
        print("[%s]被[%s]攻击了，掉血[%s]，还剩血量[%s]"%(dog.name, self.name, self.attack_val, dog.life_val))
        

class Person():
    life_val = 100
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex
        self.weapon = Weapon()  # 把对象是谁加到实例属性里面

class Dog():
    life_val = 100
    def __init__(self, name, d_type, attack_val):
        self.name = name
        self.d_type = d_type
        self.attack_val = attack_val
    def bite(self, person):
        person.life_val -= self.attack_val
        print("狗[%s]把人[%s]咬了,人掉血[%s],现在人剩余血量[%s]"%(self.name, person.name, self.attack_val, person.life_val))

dog1 = Dog("zhangsan", "二哈", 5)
person1 = Person("Alex", 25, "M")
person1.weapon.gun(dog1)
# [zhangsan]被[枪]攻击了，掉血[50]，还剩血量[50]
dog1.bite(person1)
# 狗[zhangsan]把人[Alex]咬了,人掉血[5],现在人剩余血量[95]

四. 类的继承

现在我们写人和猫。众所周知人和猫有很多相似之处，如它们都有姓名，性别，有2只眼睛，都会呼吸，会拉粑粑；也有不同之处，例如人会看书，猫会挠人的沙发，写成代码就是这样的：

class Person():
    def __init__(self, name, sex):
        self.name = name
        self.sex = sex
        self.num_eyes = 2
        self.has_tails = False
    def breathe(self):
        print(self.name,"在呼吸")
    def poop(self):
        print(self.name,"在拉粑粑")
    def read(self):
        print(self.name,"在读书")

class Cat():
    def __init__(self, name, sex):
        self.name = name
        self.sex = sex
        self.num_eyes = 2
        self.has_tails = True
    def breathe(self):
        print(self.name,"在呼吸")
    def poop(self):
        print(self.name,"在拉臭臭")
    def scratch_sofa(self):
        print(self.name,"在挠主人的沙发")

person1 = Person("Alex", "M")
cat1 = Cat("MiaoMiao", "F")
person1.poop()
cat1.scratch_sofa()

现在我们要实现代码的重复利用，就可以使用类的继承，首先提取其公共部分写成mammul类：

class Mammul():
    def __init__(self, name, sex):
        self.name = name
        self.sex = sex
        self.num_eyes = 2
    def breathe(self):
        print(self.name,"在呼吸")
    def poop(self):
        print(self.name,"在拉粑粑")

然后重写Person()和Cat()类，在括号内填写继承的父类名称，这个时候父类的__init__构造函数，还有breathe和poop方法都被继承了过来，虽然我们没有在Person()和Cat()类下面写他们。现在创建一个猫猫实例，由于Cat类没有__init__构造函数，系统会自动调用它继承的父类Mammul的构造函数，让实例具有姓名，性别，眼睛数等属性（我们先不写实例属性has_tails）：

class Person(Mammul):
    def read(self):
        print(self.name,"在读书")

class Cat(Mammul):
    def scratch_sofa(self):
        print(self.name,"在挠主人的沙发")

person1 = Person("Alex", "M")
cat1 = Cat("MiaoMiao", "F")
person1.poop()  # Alex 在拉粑粑
cat1.scratch_sofa()  # MiaoMiao 在挠主人的沙发

然而，如果我们在子类里面写了专属于人的拉屎方法，就会优先调用子类的，没有的话才去父类找同名方法用：

class Mammul():
    def __init__(self, name, sex):
        self.name = name
        self.sex = sex
        self.num_eyes = 2
    def breathe(self):
        print(self.name,"在呼吸")
    def poop(self):
        print(self.name,"在拉粑粑")
   
class Person(Mammul):
    def poop(self):
        print(self.name,"在拉shi")
    def read(self):
        print(self.name,"在读书")

person1 = Person("Alex", "M")
person1.poop()  # Alex 在拉shi

注意到我们还没有写实例属性has_tails，而如果在子类直接写：

class Person(Mammul):
    def __init__(self):
        self.has_tails = False
    def poop(self):
        print(self.name,"在拉shi")
    def read(self):
        print(self.name,"在读书")

则根据前面的，系统会直接调用子类的__init__构造函数，所以父类的姓名，性别，2只眼属性都没办法继承过来，为了解决这个问题，标准写法应该加上super()，它也是一个类，既不是方法也不是函数。super会返回当前类的父类，在子类的构造函数中写super().__init__就会调用父类的构造函数。所以本节最开始的代码优化后可以这样写：

class Mammul():
    def __init__(self, name, sex):
        self.name = name
        self.sex = sex
        self.num_eyes = 2
    def breathe(self):
        print(self.name,"在呼吸")
    def poop(self):
        print(self.name,"在拉粑粑")
   
class Person(Mammul):
    def __init__(self, name, sex):
        super().__init__(name, sex)
        self.has_tails = False
    def read(self):
        print(self.name,"在读书")

class Cat(Mammul):
    def __init__(self, name, sex):
        super().__init__(name, sex)
        self.has_tails = True
    def scratch_sofa(self):
        print(self.name,"在挠主人的沙发")

person1 = Person("Alex", "M")
cat1 = Cat("MiaoMiao", "F")
person1.poop()  # Alex 在拉shi
cat1.scratch_sofa()  # MiaoMiao 在挠主人的沙发
print(cat1.num_eyes)  # 2

最后我们再写一个人力资源管理系统作为类继承的练习：

# 类继承练习:人力系统
# 员工分为两类:全职员工FullTimeEmployee、兼职员工PartTimeEmployee。全职和兼职都有"姓名 name"、"工号 id"属性,
# 都具备"打印信息 print_info"(打印姓名、工号)方法。
# 全职有"月薪 monthly_salary"属性，兼职有"日薪 daily_salary"属性、"每月工作天数 work_days"的属性。
# 全职和兼职都有"计算月薪 calculate_monthly_pay"的方法，但具体计算过程不一样。
class Employee():
    def __init__(self, name, id):
        self.name = name
        self.id = id
    def print_info(self):
        print("员工的姓名是：", self.name)
        print("员工的id是：", self.id)

class FullTimeEmployee(Employee):
    def __init__(self, name, id, month_salary):
        super().__init__(name, id)
        self.month_salary = month_salary
        self.type = "全职员工"
    def caculate_month_salary(self):
        print("员工[%s]是全职员工，当月月薪是：[%s]"%(self.name, self.month_salary))

class PartTimeEmployee(Employee):
    def __init__(self, name, id, day_salary, work_days):
        super().__init__(name, id)
        self.day_salary = day_salary
        self.work_days = work_days
        self.type = "兼职员工"
    def caculate_month_salary(self):
        print("员工[%s]是兼职员工，当月工作天数是[%s]，每天工资是[%s]，本月工资是：[%s]"%(self.name, self.work_days, self.day_salary, self.day_salary*self.work_days))

employee1 = FullTimeEmployee("Alex", 4312890, 2500)
employee2 = PartTimeEmployee("Jack", 5410984, 25, 14)
employee1.print_info()
# 员工的姓名是： Alex
# 员工的id是： 4312890
employee1.caculate_month_salary()
#员工[Alex]是全职员工，当月月薪是：[2500]
employee2.caculate_month_salary()
# 员工[Jack]是兼职员工，当月工作天数是[14]，每天工资是[25]，本月工资是：[350]