目录
一. 类的基本语法
二. 类属性的应用场景
三. 类与类之间的依赖关系
（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
