欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

第十七天-面向对象03-类与类的关系

程序员文章站 2024-02-05 19:45:16
# 所以想要谁不可哈希 可添加 __hash__ = None# 如上面类中添加 __hash__ = None 该类的对象就不可哈希了 ......

 

# 依赖关系
# 在方法中给方法传递一个对象,把对象当成参数调用,此时类与类之间的关系是最弱的
 1 # 大象装冰箱
 2 class elephant:
 3     def open(self,bx):  # 这里要放一个bx 依赖关系
 4         print("大象高高兴兴走到了冰箱面前")
 5         bx.kai()
 6 
 7     def zhuang(self):
 8         print("自己走进了冰箱")
 9 
10     def close(self,bx): # 这里要放一个bx 依赖关系
11         print("大象自己关闭了冰箱门")
12         bx.guan()
13 
14 class ice:
15     def kai(self):
16         print("我是冰箱,我开门了")
17     def guan(self):
18         print("我是冰箱,我关门了")
19 
20 bx1 = ice()
21 dx = elephant()
22 dx.open(bx1) # 这里把bx1作为一个参数传递进去了 也就是 大象可指定任何一冰箱
23 dx.zhuang()
24 dx.close(bx1)
# 植物大战僵尸
 1 class jiangs:
 2     @classmethod
 3     def zd(cls):
 4         print("战斗开始!")
 5 
 6     def __init__(self,name,hp,power):
 7         self.name = name
 8         self.hp  = hp
 9         self.power = power
10 
11     def chi(self,zw): # 把zw对象作为一个参数给chi调用
12         zw.hp -= self.power
13         print("%s对%s造成了%s伤害"%(self.name,zw.name,self.power))
14         print("%s还有%s血"%(zw.name,zw.hp))
15 
16 class zhiw:
17     def __init__(self,name,power,hp):
18         self.name = name
19         self.power = power
20         self.hp = hp
21 
22     def da(self,js): # 把js对象作为一个参数给da调用
23         js.hp -= self.power
24         print("%s对%s造成了%s伤害" % (self.name, js.name, self.power))
25         print("%s还有%s血" % (js.name,js.hp))
26 
27 
28 zw1 = zhiw("豌豆战士",50,300)
29 js1 = jiangs("看报僵尸",1000,30)
30 
31 # jiangs.zd()
32 # js1.chi(zw1)
33 # zw1.da(js1)
34 # js1.chi(zw1)
35 # zw1.da(js1)
36 # js1.chi(zw1)
37 # zw1.da(js1)

 

 

 

# 关联关系
# 两种事物必须是相互关联的,但在某些情况是可以更改的
 1 # 男女朋友
 2 class boy:
 3     def __init__(self,name,girlfriend = none):
 4         self.name = name
 5         self.girlfriend = girlfriend
 6 
 7     def play(self):
 8         if self.girlfriend:
 9             self.girlfriend.happy() # 调用g的方法happy
10             print("%s和%s在玩游戏"% (self.name,self.girlfriend.name))
11         else:
12             print("没女朋友玩什么玩")
13 
14 class girl:
15     def __init__(self,name):
16         self.name = name
17 
18     def happy(self):
19         print("有好玩的好开心")
20 
21 g = girl("尼美")
22 b = boy("尼玛",g) # g赋值给b对象的girlfriend属性
23 
24 # b.play()
25 # b.girlfriend = none # 突然有天闹掰了
26 # b.play()
# 老师和学生的关系,一对多,反过来一对一多对一
 1 class teacher:
 2     def __init__(self,name,lst=none):
 3         self.name = name
 4         if lst == none: # 判断传递过来的参数是否为空
 5             self.lst = []
 6         else: # 不为空就等于列表
 7             self.lst = lst
 8 
 9     def tianjia(self,student): # 添加学生到列表
10         self.lst.append(student)
11 
12     def display(self): # 输出学生 s
13         for s in self.lst:
14             print(s.name)
15 
16 
17 class student:
18     def __init__(self,num,name,teacher=none):
19         self.name = name
20         self.num = num
21         self.teacher = teacher
22 
23 
24 t = teacher("小苍")
25 s1 = student(1,"大张伟")
26 s2 = student(2,"郭德纲")
27 s3 = student(3,"岳云鹏")
28 s4 = student(4,"薛之谦")
29 
30 # t.tianjia(s1)
31 # t.tianjia(s2)
32 # t.tianjia(s3)
33 # t.tianjia(s4)
34 #
35 # t.display()

 

# 聚合关系 代码上写法与关联一样
# 属于关联关系中的一种特例.不过侧重点是xxx和xxx聚合成xxx.各自有各自的声明
# 周期.如电脑.电脑里有cpu,硬盘,内存等等.电脑挂了.cpu还是好的.还是完整的个体
# 如下:
 1 # 各个类组合成电脑类,但分开又能是单独的个体
 2 
 3 class computer:
 4 
 5     def __init__(self, cpu, memory, yingpan, zhuban, xianshiqi):
 6         pass
 7 
 8 class cpu:
 9     pass
10 
11 class memory:
12     pass

 

# 组合关系 代码上写法与关联一样
# 属于关联关系中的一种特例,写法上差不多.组合关系比聚合还紧密.如⼈,
# 人的大脑,心脏,各个器官.这些器官组合成一个⼈.这时.⼈如果挂了.其他的东西也跟着挂了.

# 关联关系 一对多,反过来一对一多对一 在如:商城购物、通讯软件等广泛使用

第十七天-面向对象03-类与类的关系



# 练习 帖子和评论
 1 class tie:
 2     def __init__(self, title, content, author, time, pinglun_lst = none):
 3         self.title = title
 4         self.content = content
 5         self.author = author
 6         self.time = time
 7         if pinglun_lst == none:
 8             self.pinglun_lst = []
 9         else:
10             self.pinglun_lst = pinglun_lst
11 
12 class pinglun:
13     def __init__(self, name, time, content, fav):
14         self.name = name
15         self.time = time
16         self.content = content
17         self.fav = fav
18 
19 
20 pl1 = pinglun("uzi", "昨天1", "uzi发出祝福",1888888)
21 pl2 = pinglun("xiaohu", "昨天2", "uzi发出祝福",1888888)
22 pl3 = pinglun("若风", "昨天3", "uzi发出祝福",1888888)
23 pl4 = pinglun("let me", "昨天3", "uzi发出祝福",1888888)
24 pl5 = pinglun("长长", "昨天4", "uzi发出祝福",1888888)
25 pl6 = pinglun("jackylove", "昨天5", "uzi发出祝福",1888888)
26 pl7 = pinglun("mlxg", "昨天6", "uzi发出祝福",1888888)
27 pl8 = pinglun("miss", "昨天7", "uzi发出祝福",1888888)
28 
29 # 添加评论到列表
30 lst = []
31 lst.append(pl1)
32 lst.append(pl2)
33 lst.append(pl3)
34 lst.append(pl4)
35 lst.append(pl5)
36 lst.append(pl6)
37 lst.append(pl7)
38 lst.append(pl8)
39 
40 # 显示帖子的内容.评论内容
41 tie = tie("s8_ig夺冠. 王思聪怒吃热狗. ", "ig的上单the shy疯了一样. 一个打5个. 自己人都不放过", "王明","某年某月某一天",lst )
42 print(tie.content)
43 
44 # 评论
45 # print(tie.pinglun_lst)  # 直接打印一堆内存地址
46 
47 for pl in tie.pinglun_lst:  # 循环去拿出每条评论
48     print(pl.content)  # 打印 pl.content 评论内容

 

 

 

# 继承关系之self
'''
在面向对象的世界中存在着继承关系.现实中也存在着这样的关系.我们说过.x是一种y,那x就可以继承y.这时理解层面上的.如果
上升到代码层面.我们可认为.子类在不影响父类的程序运行的基础上对父类进行的扩充和扩展.这里.我们可把父类称为超类或者基类.子类被称为派生类.
'''
 1 # 类名和对象默认是可以作为字典的key的
 2 class foo:
 3     def __init__(self):
 4         pass
 5 
 6     def method(self):
 7         pass
 8 
 9     # __hash__ = none  # 该类的对象就不可哈希了
10 
11 print(hash(foo))  # 类 可hash(不可改变)的
12 print(hash(foo())) # 对象 可hash的
13 # 可哈希 所以字典的key可以是对象或者类
14 dic = {}
15 dic[foo] = 123
16 dic[foo()] = 456
17 # print(dic)  # 打印如下 是可用的
18 # {<class '__main__.foo'>: 123, <__main__.foo object at 0x000002bc7568ebe0>: 456}
19 
20 # dic = {foo:foo(),foo():"疙瘩汤"} # 可用
21 
22 # 不可哈希
23 # list   # unhashable type: 'list'  __hash__ = none
24 s = []
25 # print(hash(s))  # list不可哈希

# 所以想要谁不可哈希 可添加 __hash__ = none
# 如上面类中添加 __hash__ = none 该类的对象就不可哈希了

 

# self 谁调用就是谁的
 1 class base:
 2     def __init__(self, num):
 3         self.num = num
 4 
 5     def func1(self):
 6         print(self.num)
 7         self.func2()
 8 
 9     def func2(self):
10         print(111, self.num)
11 
12 class foo(base):
13     def func2(self):
14         print(222, self.num)
15 
16 lst = [base(1), base(2), foo(3)]
17 # for obj in lst:
18 #     obj.func2()   # 111,1  222,2  222,3
# self在访问方法的顺序: 永远先找自己的.自己的找不到再找父类的.

# 类名是变量(类似函数名)
 1 class car:
 2     def run(self):
 3         print("我的车会跑")
 4 
 5 carcarcar = car # 类名是变量
 6 c = carcarcar()
 7 # c.run()
 8 
 9 # 函数名是变量
10 def func():
11     print("我是函数")
12 
13 # func()
14 #
15 # fn = func
16 # fn()

 

 

# 特殊成员
# __init_()就是一个特殊的成员.带双下划线那一堆.这些方法在特殊场景会被自动执行
 1 '''
 2 1.类名() 会自动执行__init__() 
 3 2.对象() 会自动执行__call__() 
 4 3.对象[key] 会自动执行__getitem__() 
 5 4.对象[key] = value 会自动执行__setitem__() 
 6 5.del 对象[key] 会自动执行行 __delitem__() 
 7 6.对象+对象 会自动执行 __add__() 
 8 7.with 对象 as 变量会自动执行__enter__ 和__exit__ 
 9 8.打印对象的时候 会自动执行 __str__ 
10 9.干掉可哈希  __hash__ == none  对象就不可哈希了.
11 10.__repr__()  def __repr__(self):  一个对象的官方字符串表示形式
12 11.__iter__()  可迭代的
13 12.__new__() 构造方法. 用来创建对象的. 开辟内存
14 13.__len__() 返回序列元素个数
15 '''