面向过程与面向对象(一)
一.面向过程与面向对象:
面向过程：
重过程：解决问题，考虑的是解决问题的流程
解决问题的思路清晰，但拓展性不强
面向对象：
重对象：解决问题，找到解决问题的对象
解决问题的思路可能不止一条（理解解决问题的难度增加），但拓展性强
二.名称空间:
能产生名称空间的有：文件 | 函数 | 类
能产生名称空间的对象有__dict__这个值，通过该这个值访问到名字与地址的对应关系
def func(): pass func.__dict__['index'] = 10000 print(func.__dict__)
属性: print(func.__dict__['index']) print(func.index)
方法: func.add = lambda n1, n2: n1 + n2 print(func.__dict__) print(func.add(10, 20))
三.类与对象:
类：具有相同特征与行为个体集合的抽象
对象：有特征、行为的具体个体，就是类的具体体现
1.类拥有自己的名称空间，类的对象也拥有自己的名称空间
2.属性的访问顺序：对象优先加载自身的属性与方法，如果没有再考虑类的
四.对象的特有的名称空间:
class Student: # __init__方法会在实例化对象时被调用 , student=Student() # 1.会为实例化的对象形成空的名称空间 # 2.就是一个方法，可以被传参，在 类名(实参) 这种方式下调用并传参 __init__(self, 形参) # 3.第一个self就是要产生的当前对象 # 重点：在方法内部，形参拿到了实参值，利用self.属性名 = 形参 = 实参值，对对象的名称空间添加属性 def __init__(self, name, sex): print('2>>>', self) self.name = name self.sex = sex def fn(): print('fn run')
五.对象绑定类方法:
class A: def test(self): print(self) pass a = A()
#绑定的三种方式: a.test() A.test(a) A.__dict__['test'](a)
六.类方法的调用:
class Tool: # 类方法：可以被类与对象调用的方法，第一个参数一定是类 # 类方法不建议拿对象来调用 @classmethod def add(cls, n1, n2): print(id(cls)) cls.test() return n1 + n2 @classmethod def test(cls): pass print(Tool.add(10, 20)) tool = Tool() print(tool.add(100, 200)) print(id(Tool), id(tool)) # 对象调用所属类的类方法，默认第一个参数传入的是 对象.__class__ 就是所属类
七.属性与方法的总结:
class OldBoy: # 属于类的属性 name = '老男孩' # 属于对象的属性 def __init__(self, name): self.name = name # 属于类的方法 # 需求：获取机构的名字 @classmethod def get_class_name(cls): return cls.name # 属于对象的方法 # 需求：获取校区的名字 def get_school_name(self): return self.name # 先创建校区 shanghai = OldBoy('上海校区') shenzhen = OldBoy('深圳校区') # 类方法的使用 # 建议使用类调用 print(OldBoy.get_class_name()) # 类方法拿对象调用并没有多少新增的意义，不建议拿对象调用 print(shanghai.get_class_name()) print(shenzhen.get_class_name()) # 对象方法的使用 # 类调用对象方法，必须把要操作的对象手动传入，不建议使用 print(OldBoy.get_school_name(shanghai)) print(OldBoy.get_school_name(shenzhen)) # 对象调用对象方法，默认将自身传入，建议使用 print(shanghai.get_school_name()) print(shenzhen.get_school_name())
八.封装:
简单地说, 将方法与属性打包封在一个类中称为封装,方便之后调用操作.
九.类的隐藏:
隐藏：对外隐藏类中一些属性与方法的实现细节
优点：外界不能直接访问，让内部的属性与方法具有安全保障
class A:
# __开头的属性，在外界不能通过 cord | __cord 直接访问：对外隐藏了
__cord = '01012300'
# __开头的方法，在外界不能通过 get_money | __get_money 直接访问：对外隐藏了
@classmethod
def __get_money(cls):
print('输入密码，取出100w零花钱')
# 内部还是可以直接访问__开头的属性与方法
@classmethod
def test(cls, flag):
print('test方法被外界调用')
# 在调用test与访问具体数据与功能间添加安全处理的操作
if flag == '自家人':
print(cls.__cord)
cls.__get_money()
隐藏原理： 把用__开头的名字更名为 _类名__变量名
# print(A.__dict__) print(A._A__cord) A._A__get_money()
十.对象的隐藏(利用接口调用):
class AAA: def __init__(self, money): self.__money = money # 取值 @property # 在外界可以 对象.money 进行取值 def money(self): # print('走方法拿到的money') return self.__money # 赋值 @money.setter # 在外界可以 对象.money = 新值 进行赋值 def money(self, money): self.__money = money # 删除 @money.deleter def money(self): # print('逗你玩') del self.__money def get_money(self, flag): if flag == '自家人': return self.__money return 0 def set_money(self, money): self.__money += money print(a.money) a.money = 999999 print(a.money) del a.money print(a.money)
十一.组合: 自定义类的对象作为另外一个类的属性
class Teacher: def __init__(self, name, age): self.name = name self.age = age t1 = Teacher("Owen", 17) print(type(t1.name), type(t1.age)) class Student: # 学生可以有 老师 属性 def __init__(self, name, age, teacher): self.name = name self.age = age # 自定义类的对象作为类的属性：组合 self.teacher = teacher # 创建一个学生 stu = Student('Bob', 18, t1) print(stu.__dict__) # 学生的老师年龄和姓名 print(stu.name) print(stu.teacher) print(stu.teacher.name) print(stu.teacher.age)
十二.继承
1.继承语法:
继承的语法： # class 类名(父类名): pass class A: pass print(A.__bases__) # object 没有定义的类都是继承object print(Leader.__bases__) # Student 定义了父类就继承父类
2.父类隐藏后的继承:
class Sup: __num = 10 def __init__(self, name): self.__name = name @property def name(self): print(self) # <__main__.Sub object at 0x02BA8490>
print(self.__dic__) # 名称空间的key是'_Sup_name' return self.__name @classmethod def __c_fn(cls): print(cls, 'c fn') def __o_fn(self): print(self.name, 'o fn') class Sub(Sup): def test(self): print(self.__dict__) # {'_Sup__name': 'sssssssss'} print(self._Sup__name) pass sub = Sub('sssssssss') print(sub.name) sub.test()
sub._Sup__c_fn()
3.方法的重写(完全不用父类的):
有继承关系下的属性查找顺序: 1.优先找自身，自身没有找父类 2.父类没有找父类的父类 3.一直找到最顶级的父类，如果还没有报错 # 两个名词： 先写子类，抽离 出父类 先写父类，派生 出子类 class Sup: num = 10 def test(self): print('test sup') class Sub(Sup): num = 100 # 先写好父类的方法，由于父类方法的功能不满足子类需求， # 子类可以重写父类方法：方法名与父类相同，自定义方法的实现体 def test(self): print('test sub') print(Sub.num) Sub().test()
4.方法的重用(部分仍用父类的):
class Sup: def test(self): print('>>>sup', self) print('test sup') class Sub(Sup): pass # 重用：还需要父类方法的功能，在父类方法功能基础上再添加新功能 # 突破点：在子类中去调用父类的方法，还有保证调用者是子类(子类的对象) def test(self): # Sup().test() # python2中写法 # super(Sub, self).test() # python3中简化写法 super().test() print('>>>sub', self) print('test sub') Sub().test()
5.__init__结合super()使用:
# 人类：只需要初始化 - name # 老师: 要初始化 - name salary # 学生: 要初始化 - name grade class Sup: def test(self): print(self) def __init__(self, name): self.name = name class Sub(Sup): # 有继承关系下，只要名字相同，即使产生不同，还是属于同一个方法 def test(self, num): super().test() print(num) # 默认父级的__init__可以被继承过来， # 但是会出现子类对象的属性比父类多 def __init__(self, name, salary): super().__init__(name) # 父级有的共性功能通过super()交给父级做 self.salary = salary # 子类特有的自己来完成 # Sub().test(10) # Sub().test() # 使用还是使用自身带参的，不能使用父级不带参的 # (本质名字相同就是一个，优先查找自己的)
6.多继承:
# 简单的多继承 ''' # 属性的查找顺序：优先找自己的，如果没有，按照继承先后查找父级 class A: name = 'A' num = 10 class B: name = 'B' count = 100 # 子类可以继承所有父类的所有可继承属性 class C(A, B): # 自己 => A => B # name = 'C' pass print(C.num) print(C.count) print(C.name) # 打印属性查找的顺序 print(C.mro()) ''' # 复杂的多继承 ''' class A: name = "A" class B(A): name = "B" class C: name = "C" class D(C): name = "D" class E(B, D): name = "E" print(E.mro()) ''' # 经典类：python2中才有，没有继承任何类的类 # 新式类：python2中直接或间接继承object的类，python中所定义的所有类 class G: name = "G" class C(G): pass class B(C): pass class E(G): pass class D(E): name = "D" class F(G): pass class A(B, D, F): pass print(A.mro())
7.菱形继承:
经典类：python2中才有，没有继承任何类的类 - 深度优先 新式类：python2中直接或间接继承object的类，python中所定义的所有类 - 广度优先 深度优先，在查找第一个分支是就将菱形的头查找了 广度优先，菱形的头在所有分支查找接收后再被查找 通过 类.mro() 查看继承顺序图
十三.接口思想:
# 接口类：用来定义功能的类，为继承它的子类提供功能的， # 该类的功能方法一般不需要有实现体，实现体有继承它的子类自己去实现 class PetInterface: def close_master(self): pass class WatchInterface: def watch_door(self): pass class Dog(PetInterface, WatchInterface): def jiao(self): pass def chi(self): pass def pao(self): pass # 一定要重写接口的方法
十四.抽象类:
# 抽象父类：拥有抽象方法(子类共有的方法，但是父类不能有具体的实现体)的父类 # 抽象方法：方法名是具体的，但是实现体是抽象的(在子类中重写来具象化) # python中借助abc来实现抽象父类 import abc # abstract base class class Quan(metaclass=abc.ABCMeta): def __init__(self, name): self.name = name def run(self): print(self.name + 'running') # 抽象父类中的抽象方法，在继承它的子类中必须有自己的实现体 # -- 抽象父类中的抽象方法实现体就没有意义，实现与不实现都是pass填充 @abc.abstractmethod def chi(self): # print(self.name + '肉') pass @abc.abstractmethod def jiao(self): # print('汪汪汪') pass @classmethod @abc.abstractmethod def fn(cls): pass class Dog(Quan): @classmethod def fn(cls): pass def kanmen(self): print(self.name + '看门') def chi(self): super().chi() print(self.name + '狗粮') def jiao(self): print('汪汪汪') class Wolf(Quan): @classmethod def fn(cls): pass def bulie(self): print(self.name + '捕猎') def chi(self): print(self.name + '肉') def jiao(self): print('嗷嗷嗷') dog = Dog('来福') wolf = Wolf('常委') dog.jiao() # wolf.jiao() # dog.run() # wolf.run()
十五.多态:
# 多态：对象的多种状态 - 父类对象的多种(子类对象)状态 import abc class People(metaclass=abc.ABCMeta): def __init__(self, name): self.name = name @abc.abstractmethod def speak(self): pass class Chinese(People): def speak(self): print('说中国话') class England(People): def speak(self): print('说英国话') if __name__ == '__main__': # 多态的体现：功能或是需求，需要父类的对象，可以传入父类对象或任意子类对象均可以 # 注：一般都是规定需要父类对象，传入子类对象 def ask_someone(obj): print('让%s上台演讲' % obj.name) # 父类提供，自己直接继承 obj.speak() # 父类提供，只不过子类重写了 ch = Chinese('王大锤') en = England('Tom') ask_someone(ch) ask_someone(en)
十六.鸭子类型
import abc class People(metaclass=abc.ABCMeta): def __init__(self, name): self.name = name @abc.abstractmethod def speak(self): pass class Chinese(People): def speak(self): print('说中国话') class England(People): def speak(self): print('说英国话') # 鸭子类型： # 1.规定有什么属性及什么方法的类的类型叫鸭子类型 # 2.能提供出规定的属性与方法的对象就是鸭子 class Test: def __init__(self, name): self.name = name def speak(self): print('说鸟语') if __name__ == '__main__': def ask_someone(obj): print('让%s上台演讲' % obj.name) obj.speak() test = Test('鸭子') ask_someone(test)
十七.格式化与析构方法
class A: def __init__(self, name, age): self.name = name self.age = age # 格式化方法：在外界打印该类对象是被调用 # 格式化外界直接打印该类对象的字符串表示结果 def __str__(self): # return 'abc' # return super().__str__() return '<name:%s | age:%s>' % (self.name, self.age) # 析构方法：在对象被消耗的那一刹那被调用，在被消耗前可以做一些事情 def __del__(self): # del会在self代表的对象被消耗的时候被调用 # 我们可以在析构函数中释放该对象持有的其他资源， # 或者将一些持有资源持久化(保存到文件或数据库中) del self.name # 也可以将name存起来
十八.反射:通过字符串与类及类的对象的属性(方法)建立关联
class A: num = 10 print(hasattr( A ,'num')) #判断类中是否有num属性 True print(getattr(A,'num','default')) #获取类中num的属性值,没有则拿默认值 10 delattr(A,'num') #删除类中num属性 setattr(A,'tag',10) #在类中设置一个tag属性 class B: def __init__(self,name): self.name=name b = B('BOb') print(hasattr( b ,'name')) #判断对象中是否有name属性 True print(getattr(b,'name','default')) #获取对象中name的属性值,没有则拿默认值 10 delattr(b,'name') #删除对象中name属性 setattr(b,'tag',10) #在对象中设置一个tag属性 print(b.tag) class C: def fn(self): print('fn') @classmethod def func(cls): print('func') #类调对象方法,需要传入对象当做参数 fn=getattr(C,'fn') c = C() fn(c) #对象调对象方法 c = C() fn=getattr(c,'fn') fn() #类调类方法 func = getattr(C,'func') func()
十九.异常处理:
# 程序运行时的错误 # 程序中的异常处理机制： # 1.程序中的所有异常都会被处理 # 2.程序中的所有异常都需要手动处理 # 3.如果没有手动处理异常，异常会交给Python解释器处理 # -- 处理的方式就是打印异常信息，并停止接收器 # 异常信息的三部分： # 1.异常的追踪信息：提示错误位置 # 2.异常的类型：告知处理异常应该捕获什么类型 # 3.异常的内容：告知错误信息 # 处理异常的语法： ''' try: # 会出现异常的代码块 except 异常类型 as 异常别名: # 异常处理逻辑 else: # 没有出现异常会执行该分支 finally: # 无论是否出现异常都会执行该分支 ''' try: print(adsdasadsdasadsdas) except NameError as e: print('异常信息：', e) else: print('被检测的代码块正常') finally: print('异常是否出现都会执行该分支') print('end')
