从类空间与对象空间的角度研究类
给对象封装属性:
1.在__init__中
2.在类的外部
3.在类的其他方法中
给一个类添加属性:
1.类的外部
2.类的内部
class A: def __init__(self,name,age): self.name = name self.age = age def func(self,sex): self.sex = sex def func1(self): A.country = '中国' #给对象添加属性: obj = A('barry',18) #在__init__中添加属性 obj.height = 176 #在类的外面添加属性 obj.func('男') #在类的方法中添加属性 print(obj.__dict__) #给类添加属性: A.count = 666 #在类的外部 obj.func1() #在类的内部
类对象指针(对象空间):
对象找属性顺序:对象空间--类空间--父类空间
类指针(累空间):
类找属性顺序:类空间--父类空间
以上顺序单向不可逆
类与类的关系
1.依赖关系 : 将一个类的类名或者对象传入到另一个类的方法中
class Elephant: #大象类 def __init__(self,name): self.name = name def open(self,ref): print('%s打开冰箱门'%(self.name)) ref.beopen_door() def close(self,foo): print('%s关闭冰箱门'%(self.name)) foo.beclosed_door() class Refrigerator: #冰箱类 def __init__(self,name): self.name = name def beopen_door(self): print('%s冰箱门被打开了'%(self.name)) def beclosed_door(self): print('%s冰箱门被关闭了'%(self.name)) ele = Elephant('猛犸') #实例化大象对象 haier = Refrigerator('海尔') #实例化冰箱对象 ele.open(haier) #将冰箱对象传入大象类的方法中 ele.close(haier) # gree = Refrigerator('格力') # ele.open(gree) # ele.close(gree)
#大象是主体,可以选择冰箱,冰箱依赖于大象
2.组合(关联,聚合)关系 : 将一个类的对象或者类名封装到另一个类的对象的属性中
class Boy: def __init__(self,name,girlfriend=None): self.name = name self.girlfriend = girlfriend def dinner(self,ref): if self.girlfriend: print('%s和女朋友%s共进晚餐'%(self.name,ref.name)) else: print('今晚吃鸡,大吉大利') class Girl: def __init__(self,name,boyfriend=None): self.name = name self.boyfriend = boyfriend def shopping(self,ref): if self.boyfriend: print('%s和男朋友%s一起逛街'%(self.name,ref.name)) else: print('宅在家') # alex = Boy('alex') #girlfiend 默认为None # alex.dinner() 结果: 今晚吃鸡,大吉大利 #执行else条件下语句 # ruhua = Girl('如花') # alex.girlfriend = ruhua #将ruhua这个对象传给girlfriend # alex.dinner() 结果: alex和女朋友如花共进晚餐 # jinlian = Girl('金莲') # wuda = Boy('武大',jinlian) #将jinlian这个对象在一开始就传给girlfriend # wuda.dinner() 结果: 武大和女朋友金莲共进晚餐 # wuda.girlfriend = None # wuda.dinner() #解除绑定 结果: 今晚吃鸡,大吉大利 # alex = Boy('alex') # ruhua = Girl('如花') # ruhua.boyfriend = alex #将alex这个对象传给boyfriend # ruhua.shopping() 结果: 如花和男朋友alex一起逛街
3.继承(实现)关系 : 有父类和子类,子类可以继承调用父类的内容
继承的好处:
1.减少代码重复率
2.让类与类产生关系,增强耦合性
3.使代码更加规范化,清晰化
在python3中,所有的类都默认继承父类 object
单继承
class Animal: live = '活着' def __init__(self,name,sex,age): self.name = name self.sex = sex self.age = age def eat(self): print('动物都会吃') class Person(Animal): #子类名(父类名) live = '无所谓' 对象: p1 = Person('alex','男',20) #子类中没有,执行父类中的__init__ p1.eat() #子类中没有,执行父类中的eat方法 print(p1.live) #子类和父类中具有相同的属性,先调用自己类中的属性 结果: 无所谓 #子类执行父类的属性和方法,也会将自己的地址传给self 类名: Person.live #自己类中有,调用自己类中的属性 结果: 无所谓
对象既要执行子类的方法,又要执行父类的方法:
1.在子类中写入 父类名.方法名(self,参数)
class Animal: live = '活着' def __init__(self,name,sex,age): self.name = name self.sex = sex self.age = age def eat(self): print('动物都会吃') class Person(Animal): live = '无所谓' def eat(self): Animal.eat(self) #父类名.方法名(self),手动将p1对象传给self print('人类都需要吃饭')
2.在子类的方法中,写入 super().方法名(参数) 自动将子类的对象传入父类方法的self
class Animal: def __init__(self,name,sex,age): self.name = name self.sex = sex self.age = age def eat(self): print('动物都会吃') class Person(Animal): def eat(self): super().eat() #调用父类的eat方法,将p1对象自动传给父类eat方法中的self print('人类都需要吃饭') p1 = Person('alex','男',20) #自动调用父类的__init__方法进行传参 p1.eat() 结果: 动物都会吃 人类都需要吃饭
在子类中封装另外的属性
1.使用类名 不依赖继承
class Animal: def __init__(self,name,sex,age): self.name = name self.sex = sex self.age = age class Person(Animal): def __init__(self,n,s,a,mind): # Animal.__init__(self,n,s,a) #方法一:不依赖继承 类名后可以不加Animal self.mind = mind p1 = Person('邓哥','女',18,'思想')
2.super() 依赖继承
class Animal: def __init__(self,name,sex,age): self.name = name self.sex = sex self.age = ageclass Cat(Animal): def __init__(self,n,s,a,climb): super().__init__(n,s,a) #方法二:依赖继承 self.climb = climb c1 = Cat('大橘','母',4,'爬树')
多继承
多继承的顺序:从左到右
类的分类:
python2x版本:(python2.2之前,只有经典类,python2.2之后出现了新式类)
经典类: 不继承object,多继承遵循深度优先
深度优先:从左到右一条路走到底,没有再继续返回走下一条
新式类 : 继承object的类,多继承遵循c3算法 mro方法查询继承顺序
python3x版本:所有类都默认继承object 只有新式类
mro序列
表头和表尾:
[A,B,C] 表头:A 表尾:B,C
[A] 表头:A 表尾:空
[A] +[B] = [A,B]
merge里面的计算顺序(面试题):
merge([A,O], [C,E,F,O],[C]) #将第一个列表的第一个元素A提取出来,判断这个元素在其他表尾中存不存在,不重复,就单独提取出来 = [A] + merge([O], [C,E,F,O],[C]) #继续提取第一个元素O,跟第二个列表的表尾重复,不进行操作,继续找下一个列表的首个元素C进行判断 = [A,C] + merge([O], [E,F,O]) = [A,C,E] + merge([O], [F,O]) = [A,C,E,F,O]
#练习 class O: pass class D(O): pass class E(O): pass class F(O): pass class B(D,E): pass class C(E,F): pass class A(B,C): pass obj = A()
#按照merge的顺序,可以一步一步推算 mro(A(B,C)) = [A] + merge(mro(B),mro(C),[B,C]) #A继承B,C 计算A的继承顺序的固定格式 mro(B) = mro(B(D,E)) = [B] + merge(mro(D),mro(E),[D,E]) #B继承D,E mro(D(O)) = [D,O] #D继承O mro(E(O)) = [E,O] #E继承O mro(B(D,E)) = [B] + merge([D,O],[E,O],[D,E]) = [B,D] + merge([O],[E,O],[E]) = [B,D,E,O] mro(C) = mro(C(E,F)) = [C] + merge(mro(E),mro(F),[E,F]) #C继承E,F mro(C) = mro(C(E,F)) = [C] + merge([E,O],[F,O],[E,F]) = [C,E] + merge([O],[F,O],[F]) = [C,E,F] + merge([O],[O]) = [C,E,F,O] mro(A(B,C)) = [A] + merge([B,D,E,O],[C,E,F,O],[B,C]) #整合计算 = [A,B] + merge([D,E,O],[C,E,F,O],[C]) = [A,B,D] + merge([E,O],[C,E,F,O],[C]) = [A,B,D,C] + merge([E,O],[E,F,O]) = [A,B,D,C,E] + merge([O],[F,O]) = [A,B,D,C,E,F] + merge([O],[O]) = [A,B,D,C,E,F,O]
在python方法中,也可以直接输出打印:
print(A.mro()) 结果:[<class '__main__.A'>, <class '__main__.B'>, <class '__main__.D'>, <class '__main__.C'>, <class '__main__.E'>, <class '__main__.F'>, <class '__main__.O'>, <class 'object'>]
#和上边计算的结果一样