python中简述对象和类的关系_python面向对象之 类的关系

内容梗概:

1. 依赖关系

2. 关联关系, 组合关系, 聚合关系

3. 继承关系, self到底是什什么鬼?

4. 类中的特殊成员

1. 依赖关系

def:在方法中给方法传递一个对象. 此时类与类之间的关系是最轻的,

我⽤用着你. 但是你不属于我. 这种关系是最弱的.比如临时工.

详见实例:

class JiangShi():

def __init__(self,name,HP):

self.name = name

self.HP = HP

def beida(self): #方法中给方法传递一个对象

print("我是僵尸%s,我被暴打了一顿"%(self.name))

class ZhiWu():

def __init__(self,name,power,jineng):

self.name = name

self.power = power

self.jineng = jineng

def attack(self,el):

print("我是植物%s,我刚刚用%s攻击了僵尸%s"%(self.name,self.jineng,el.name ))

el.beida()

el.HP -= self.power

print("%s血量还剩下%s"%(el.name,el.HP))

zw = ZhiWu("小菊花",10,"无敌萌萌拳")

js = JiangShi("小可爱",1000)

zw.attack(js)

zw.attack(js)

2. 关联关系, 组合关系, 聚合关系

定义:

1. 关联关系. 两种事物必须是互相关联的. 但是在某些特殊情况下是可以更更改和更更换的.

2. 聚合关系. 属于关联关系中的一种特例例. 侧重点是xxx和xxx聚合成xxx. 各⾃有各⾃的声明周期.

比如电脑. 电脑里里有CPU, 硬盘, 内存等等. 电脑挂了了. CPU还是好的. 还是完整的个体

3. 组合关系. 属于关联关系中的一种特例.写法上差不多.组合关系比聚合还要紧密.比如人的大脑,心脏,各个器官.

这些器官组合成⼀个人. 这时. 人如果挂了了. 其他的东⻄也跟着挂了.

实例1:男女朋友

class Boy():

def __init__(self,name,girlfriend=None):

self.name = name

self.girlfriend = girlfriend

def chi(self):

if self.girlfriend:

print("%s和%s在街边吃麻辣烫"%(self.name,self.girlfriend.name))

else:

print("单身狗自己在家抠脚就好")

class Girl:

def __init__(self,name):

self.name = name

b1 = Boy("小鲜肉")

g1 = Girl("小白菜")

b1.girlfriend = g1

b1.chi()

b1.girlfriend = None

b1.chi()

实例2:老师和学生

class Teacher():

def __init__(self,name,student_list = None):

self.name = name

if student_list == None:

self.student_list = []

else:

self.student_list = student_list

def add(self,stu):

self.student_list.append(stu)

def show(self):

for el in self.student_list:

print(el.name)

class Student():

def __init__(self,num,name):

self.name = name

self.num = num

s1 = Student(1,"宋小宝")

s2 = Student(2,"赵四")

s3 = Student(3,"刘能")

s4 = Student(4,"小沈阳")

t1 = Teacher("赵本山",[s1,s2])

t1.add(s3)

t1.add(s4)

t1.show()

3.继承关系, self到底是什什么鬼?

定义:继承

在⾯面向对象的世界中存在着继承关系. 我们现实中也存在着这样的关系. 我们说过. x是⼀种y, 那x就可以继承y.

这时理解层⾯面上的.如果上升到代码层⾯.我们可以这样认为.子类在不影响父类的程序运行的基础上对父类进行的扩充和扩展.

这里.我们可以把父类被称为超类或者基类. 子类被称为派生类.

3.1注意tips:

首先, 类和对象默认都是可哈希的

class Foo:

def __init__(self):

pass

def method(self):

pass

__hash__ = None

print(hash(Foo))

print(hash(Foo()))

既然可以hash. 那就是说字典的key可以是对象或者类

3.2 self.

记住. 不管方法之间如何进行调用. 类与类之间是何关系. 默认的self都是访问这个方法的对象.

实例一:

class Base:

def __init__(self, num):

self.num = num

def func1(self):

print(self.num)

self.func2()

def func2(self):

print(111, self.num)

class Foo(Base):

def func2(self):

print(222, self.num)

lst = [Base(1), Base(2), Foo(3)]

for obj in lst:

obj.func1() #做完这个基本就会了

总结:

1.self在访问方法的顺序: 永远先找⾃己的. ⾃己的找不到再找父类的

2.不管方法之间如何进行调用. 类与类之间是何关系, 默认的self都是访问这个方法的对象

4. 类中的特殊成员

4.1 列举特殊成员

__init__() ,当构建生成对象时自动调用

__getitem__() ,当调用索引类操作的时候会自动调用 对象[索引]

__setitem__() ,当创建字典时会自动调用 对象[key] = values

__delitem__() ,当删除字典,自动调用 del 对象[key]

__enter__(),__exit__() ,当使用文件操作, with 对象 as 变量, 的时候进入和退出时自动调用

__call__() ,调用方法或函数时,对象()

__add__() ,有加法的时候会自动调用 +

__str__() ,当打印输出的时候,会自动调用(平民输出)

__repr__() ,当打印输出的时候,会自动调用(官方输出)

__hash__ == None ,此方法可是对象不可哈希

__len__() ,当调用查询对象长度时 len(对象)

__dir__() 当查询对象方法时自动调用 dir(对象)

__iter__() 对可迭代对象进行迭代会自动调用. 如for 变量 in 可迭代对象

__bool__() 点用布尔值的时候 bool(对象)

创建对象的真正步骤:

首先, 在执行类名()的时候. 系统会⾃动先执行__new__()来开辟内存. 此时新开辟出来的内存区域是空的.

紧随其后, 系统⾃动调用__init__()来完成对象的初始化工作. 按照时间轴来算.

1. 加载类

2. 开辟内存(__new__)

3. 初始化(__init__)

4. 使用对象⼲干xxxxxxxxx

实例1:

class Car:

def __init__(self, color, pai): # 初始化方法

print("哪有地呀")

self.color = color

self.pai = pai

# 这里才是真正的构造方法

def __new__(cls, *args, **kwargs):

print("我的天哪")

# 固定的返回值

return object.__new__(cls)

c = Car("红色", "京A66666") # 先执行__new__ 返回object.__new__(cls).把返回的空对象传递给 __init__()

print(c.color)