面向对象有三大特性:封装,继承,多态
1.继承
1 .什么是继承: 继承是一种关系,再程序中,继承描述的就是类与类之间的关系,例如A继承了B,A就可以使用B已经存在的方法和属性,A就称为是B的子类,B也就是父类,也称为基类
2.继承的特点:继承的一方可以直接使用被继承一方已经有的方法和属性.可以重用已经有的代码.提高代码的重用性
3:继承语法格式:
class A: pass class B(A): # B类继承了A类 pass class C(B,A): # C类同时继承了B类与A类 pass
3.抽象. 再我们使用继承时不要盲目的去写要先进行抽象,抽象就是否将多个子类中相同的部分进行抽取,形成一个新的类,这个过程就时抽象
4.继承的使用流程: 1 先抽象再继承 2,继承一个已经存在的类,扩展或时修改原始的功能
5.属性的查找顺序: 先从对象自己本身找,然后再是自身所在类中,再找所在类的父类中查找.层层递进,最终层为Object,若找不到则报错
class A: num = 1 class B(A): num = 2 d = B() d.num = 3 print(d.num) # 3
class A: num = 1 class B(A): num = 2 d = B() print(d.num) # 2
class A: num = 1 class B(A): # num = 2 pass d = B() print(d.num) # 1
6.派生: 当一个子类中出现了与父类中不同的内容是,这个子类就称之为派生类,通常子类都会有一些新的代码.所以一般的子类都是派生类
7.覆盖: 当子类出现了和父类名称完全一致的属性或方法时.子类在定义这些相同的方法的时候就会父类的这些方法进行覆盖 也称为重写overrides
8.子类中访问父类的内容 通过super() 语法
方式1: super(当前类名称,self).你要调的父类的属性或方法 方式2: super().你要调的父类的属性或方法 方式3: # 与继承无关 类名称.你要调的父类的属性或方法(self)
注意: 当继承一个现有的类,并且覆盖了父类的__init__方法时,必须要在初始化方法的第一行调用父类的初始化方法,并传入父类所需的参数
9 : 练习,实现一个可以限制元素类型的列表
class MyList(list): def __init__(self): super().__init__() def append(self,name): if type(name) is str: print("不能是字符串") else: super().append(name) m = MyList() m.append('6666') print(m[0])
10: 组合: 组合是描述两个对象什么有什么的关系,当两个类之间没有太大的关系,完全不属于同类,如果我们使用继承就不符合正常逻辑了.这是我们又需要去访问令一个类中的方法或属性,这时候我们就可以使用组合,使用组合最终目的也是提高代码的复用性,降低代码的耦合度
class Phone: def __init__(self,kind,price): self.kind = kind self.price = price def call(self): print('拨号中') class Stu: def __init__(self,name,age,iphone): self.name = name self.age = age self.iphone = iphone def with_call(self): print('我要打电话') iphone = Phone('苹果',6000) s1 = Stu('小明',18,iphone) s1.iphone.call()
11.新式类与经典类
新式类:任何显式或隐式的继承了object的类就称为新式类,在python3中所有的类都是新式类
经典类: 没有继承object的类,只有在python2中出现
当出现菱形继承是. 都是先深度,当遇到相同父类时就广度 ,可使用类中__mro__方法查看查找顺序
class Init(object): def __init__(self, v): print("init") self.val = v class Add2(Init): def __init__(self, val): print("Add2") super(Add2, self).__init__(val) print(self.val) self.val += 2 class Mult(Init): def __init__(self, val): print("Mult") super(Mult,self).__init__(val) self.val *= 5 class HaHa(Init): def __init__(self, val): print("哈哈") super(HaHa, self).__init__(val) self.val /= 5 class Pro(Add2,Mult,HaHa): pass class Incr(Pro): def __init__(self, val): super(Incr, self).__init__(val) self.val+= 1 # Incr Pro Add2 Mult HaHa Init p = Incr(5) print(p.val) # Add2 Mult 哈哈 init 5.0 8.0 c = Add2(2) print(c.val) # Add2 init 2 4 print() print(Incr.__mro__) # (<class '__main__.Incr'>, <class '__main__.Pro'>, <class '__main__.Add2'>, <class '__main__.Mult'>, <class '__main__.HaHa'>, <class '__main__.Init'>, <class 'object'>)
13:习题:
# 程序员,拥有,姓名,性别,年龄,工资,和编程技能 # 项目经理必须有程序员晋升而来,拥有奖金,和管理技能 # 请使用面向对象来表达这种关系 # 选做需求,让程序员和项目经理都能调用save将对象序列化到文件 import pickle import os class BaseClass: # 我们希望可以将存取操作抽取出来.以降低程序的耦合度 def save(self): # 先判断系统是否由想要存放的文件夹 if not os.path.exists(self.__class__.__name__): # 如果没有此文件则创建 os.makedirs(self.__class__.__name__) path = os.path.join(self.__class__.__name__, self.name) with open(path, 'wb') as f: pickle.dump(self, f) f.flush() @classmethod def select(cls, name): path = os.path.join(cls.__name__, name) if os.path.exists(path): with open(path, 'rb', ) as f: return pickle.load(f) class Coder(BaseClass): def __init__(self, name, gender, age, balance): self.name = name self.gender = gender self.age = age self.balance = balance def program(self): print(f"我是{self.name},我会编程") class Pm(Coder, BaseClass): def __init__(self, name, gender, age, balance, prize): super().__init__(name, gender, age, balance) self.prize = prize def menage(self): print(f"我会管理") p = Pm('小明', '男', 18, 18000, 6000) p.save() code1 = Pm.select('小明') print(type(code1)) code1.menage()
2.封装
1. 封装 : 封装就是将复杂丑陋的隐私的细节隐藏到内部,也就是隐藏内部的实现细节,并提供给外部访问的接口
2. 封装的目的: 1. 为了保证关键数据的安全性 2.对外部隐藏实现细节,隔离复杂度
3. 封装的使用环境 1. 当一些数据不希望被外界直接修改时 2. 当有一些函数或属性不希望被外界使用的时候
4. 使用方法: 私用化: 在属性或方法前加双下划线 特点: 外界不能直接访问 内部依然可以使用
class A: def __init__(self,name, age): self.name = name self.__age = age # 私有属性 def __say(self): # 私有化方法 print("from __say") def test(self): # 在自身内可以直接访问私有属性与私有方法 print(self.__age,) self.__say() def say(self): print('from say') class B(A): pass a = B('小明',18) print(a.name) # 小明 print(a.age) # 报错.'B' object has no attribute 'age' a.__say() # 报错 'B' object has no attribute '__say' a.say() # from say a.test() # 18 from __say
5. 在外界访问私有的内容,属性与函数虽然被封装了,,但是有时候我们还是需要在外界访问.这时候我们就可以通过定义方法来完成对私有属性的修改与访问
class Person: def __init__(self, name, age, id_card): self.name = name self.age = age self.__id_card = id_card def get_id_card(self): return self.__id_card def alter_id_card(self, new_id_card): if len(new_id_card) == 18 or len(new_id_card) == 15: print("修改成功") self.__id_card = new_id_card else: print("错误") f = Person('a', 14, '11111111111') f.id_card = 2222222 # 在外界临时修改,重新定义,内部并没有修改 print(f.id_card) # 2222222 print(f.get_id_card()) # 在外部通过方法获取内置的私有方法 f.alter_id_card('222222222222222') # 在外部定义方法来修改私有属性 print(f.id_card) # 2222222 print(f.get_id_card()) # 222222222222222 内部修改成功
6.在通过方法来修改或访问属性,本身并没有是什么问题,但是这给对象的使用者带来了麻烦,使用者必须要知道那些是普通属性,哪些是私有属性,并且使用不同的方式法来调用他们 ,然后python 就给我们提供了3个有关的装饰器
@property 获取属性方法 2 @key,setter 修改属性方法 3 @key.deleter 删除属性方法 @property可以将私有属性伪装成普通属性,与普通属性的访问方法一致 key是被property装饰的方法名称,也就是属性的名称,内部会创建一个对象,变量名称就是函数名称 所以再是由setter与deleter时必须保证使用对象的名称去调用方法所以时key.setter
class Person: def __init__(self,name,age ,id_card): self.name = name self.age = age self.__id_card = id_card @property def id_card(self): return self.__id_card @id_card.setter def id_card(self, new_id_card): if len(new_id_card) == 18 or len(new_id_card) == 15: print("修改成功") self.__id_card = new_id_card else: print("错误") @id_card.deleter def id_card(self): print('不能删') f = Person('a',14,'11111111111') print(f.id_card) # 11111111111 f.id_card = "222222222222222" print(f.id_card) # 222222222222222 del f.id_card # 不能删
7.封装的原理: 就是再加载类的时候,把__方法或属性 替换成了_类名__方法或属性.... 封装的实现原理本质就时替换了变量名称
8.property 可以用来实现计算属性 计算属性的值不能直接获得,必须通过计算才能获得
# kg/m**2 class Person: def __init__(self,height,weight): self.height = height self.weight = weight @property def bmi(self): return self.weight/pow(self.height,2) jay = Person(170,60) print(jay.bmi) # 0.0020761245674740486
9.接口类:接口就是一组功能的集合,但是接口中仅包含功能的名字,不包含具体的实现代码.接口本质就时一套协议标准,遵循的对象就能被调用,接口的目的就时为了提高扩展性
class USB: def open(self): pass def close(self): pass def read(self): pass def write(self): pass class Mouse(USB): def open(self): print("鼠标开机.....") def close(self): print("鼠标关机了...") def read(self): print("获取了光标位置....") def write(self): print("鼠标不支持写入....") def pc(usb_device): usb_device.open() usb_device.read() usb_device.write() usb_device.close() m = Mouse() # 将鼠标传给电脑 pc(m) class KeyBoard(USB): def open(self): print("键盘开机.....") def close(self): print("键盘关机了...") def read(self): print("获取了按键字符....") def write(self): print("可以写入灯光颜色....") # 来了一个键盘对象 k = KeyBoard() pc(k)
10 抽象类 指的就是包含抽象方法,没有具体函数体方法的类.可以限制子类必须类中定义的抽象方法 导入abc模块
import abc class A(metaclass=abc.ABCMeta): @abc.abstractmethod def open(self): pass @abc.abstractmethod def close(self): pass @abc.abstractmethod def read(self): pass @abc.abstractmethod def write(self): pass class Mouse(A): def open(self): print("鼠标开机.....") def close(self): print("鼠标关机了...") def read(self): print("获取了光标位置....") def write(self): print("鼠标不支持写入....") def pc(usb_device): usb_device.open() usb_device.read() usb_device.write() usb_device.close() m = Mouse() # 将鼠标传给电脑 pc(m) class KeyBoard(A): def open(self): print("键盘开机.....") def close(self): print("键盘关机了...") def read(self): print("获取了按键字符....") def write(self): print("可以写入灯光颜色....") # 来了一个键盘对象 k = KeyBoard() pc(k)
总结:接口类就是一套协议规范,明确子类们应该具备哪些方法功能
抽象类就是导入abc模块,强制要求子类必须按照协议中规定来实现
然后,python不推崇限制语法,所以我们可以设计成为鸭子类型,就是让多个不同类对象具备相同的属性和方法