网站建设设计制作,网站开发客户流程 6个阶段,思科网站建设配置站点dns服务,深圳网站开目录
一. 类的基本语法
二. 类属性的应用场景
三. 类与类之间的依赖关系
#xff08;1#xff09;依赖关系
#xff08;2#xff09;关联关系
#xff08;3#xff09;组合关系
四. 类的继承 一. 类的基本语法
先看一段最简单的代码#xff1a;
class Dog():d_…目录
一. 类的基本语法
二. 类属性的应用场景
三. 类与类之间的依赖关系
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)里nameage等实例变量跟公共属性d_type有什么区别呢?换句话说私有属性和共有属性有什么区别区别就是d_type是存在Dog类自己的内存里self.nameself.age是存在每个实例自己的内存里。 class Dog():d_type 二哈def __init__(self, name, age): # __init__函数称为初始化方法构造方法构造函数在创建对象时自动调用# 第一个参数必须是self代表实例本身# 要想把私有属性name, age真正的存到实例里就要把2个值和实例绑定self.name name # 绑定__init__参数值到对象self.age agedef say_hi(self): # 第一个参数必须是selfprint(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 1dDog(毛毛2,Alex)会申请一会内存空间指向变量名d
step 2__init__这个初始化方法需要把接收到参数存下来 存到这个d的内存空间里
step 3传给初始化方法里的name,age想绑定到d的空间里怎么存呢就得把d的内存空间传到这个方法里所以self就是用来接收d的地址的。dDog(“毛毛”2,AIex”)相当于Dog(d,毛毛,2,Aex”)那self.namename 也就相当于d.name name。我们在实例时没有手动传递d到Dog类里只写了dDog(“毛毛”,2,Alex”)是Python解释器帮你自动干了这个事。 到此我们终于明白原来self就是代表实例本身。实例化时python会自动把这个实例本身通过self参数传进去。接下来看第二个方法
def say_hi(self): # 第一个参数必须是selfprint(hello,i am a dog,my name is,self.name)
这里为何也要加入self参数那是因为你自己也看到了 这个类的方法其实就是函数。函数被一个实例调用时它需要知道是谁在调用它函数内部要用到一些实例的属性的时候去哪里取呢比如在say_hi函数里怎么取到d.named.age只能你先传递给它。所以这就是为何类下的每个方法第一个参数都要是self因为为了接收实例这个对象本身。
*注意self在实例化时自动将对象/实例本身传给__init__的第一个参数你也可以给他起个别的名字但是正常人都不会这么做因为你瞎改别人就不认识。
二. 类属性的应用场景
仍然是通过一段代码说明如何调用和修改类属性实例属性
class People():nationality CN # nationality是公共属性def __init__(self, name, age, sex): # name, age, sex是私有属性self.name nameself.age ageself.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 100def __init__(self, name, d_type, attack_val):self.name nameself.d_type d_typeself.attack_val attack_valdef bite(self, person):person.life_val - self.attack_valprint(狗[%s]咬了[%s]一口人掉血[%s]剩余血量[%s]%(self.name, person.name, self.attack_val, person.life_val))class Person():life_val 100def __init__(self, name, age, attack_val):self.name nameself.age ageself.attack_val attack_valdef beat(self, dog):dog.life_val - self.attack_valprint(人[%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 100def __init__(self, name, d_type, attack_val, master):self.name nameself.d_type d_typeself.attack_val attack_valself.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 100def __init__(self, name, age, attack_val):self.name nameself.age ageself.attack_val attack_valdef beat(self, dog):dog.life_val - self.attack_valprint(人[%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 nameself.age ageself.sex sexself.partner partnerperson1 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 nameself.age ageself.sex sexself.partner Noneperson1 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 nameself.age ageself.sex sexperson1 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 nameself.age ageself.sex sexself.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 nameself.age ageself.sex sexself.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 50self.name 枪dog.life_val - self.attack_valprint([%s]被[%s]攻击了掉血[%s]还剩血量[%s]%(dog.name, self.name, self.attack_val, dog.life_val))def knife(self, dog):self.attack_val 20self.name 匕首dog.life_val - self.attack_valprint([%s]被[%s]攻击了掉血[%s]还剩血量[%s]%(dog.name, self.name, self.attack_val, dog.life_val))def AK47(self, dog):self.attack_val 80self.name AK47dog.life_val - self.attack_valprint([%s]被[%s]攻击了掉血[%s]还剩血量[%s]%(dog.name, self.name, self.attack_val, dog.life_val))class Person():life_val 100def __init__(self, name, age, sex):self.name nameself.age ageself.sex sexself.weapon Weapon() # 把对象是谁加到实例属性里面class Dog():life_val 100def __init__(self, name, d_type, attack_val):self.name nameself.d_type d_typeself.attack_val attack_valdef bite(self, person):person.life_val - self.attack_valprint(狗[%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 nameself.sex sexself.num_eyes 2self.has_tails Falsedef 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 nameself.sex sexself.num_eyes 2self.has_tails Truedef 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 nameself.sex sexself.num_eyes 2def 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 nameself.sex sexself.num_eyes 2def 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 Falsedef 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 nameself.sex sexself.num_eyes 2def 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 Falsedef read(self):print(self.name,在读书)class Cat(Mammul):def __init__(self, name, sex):super().__init__(name, sex)self.has_tails Truedef 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
