8--oop

oop-Python面向对象

• Python的面向对象
• 面向对象编程
  • 基础
  • 共有私有
  • 继承
  • 组合，Mixin
• 魔法函数
  • 魔法函数概述
  • 构造类魔法函数
  • 运算类魔法函数

1.面向对象概述（ObjectOriented,00）

• OOP思想
• 几个名词
  • OO：面向对象
  • OOA：面向对象的分析
  • OOD：面向对象的设计
  • OOI：面向对象的实现
  • OOP：面向对象的编程
  • OOA->OOD->OOI：面向对象的实现过程
• 类和对象的概念
  • 类：抽象名词，表明一个集合，共性的事物
  • 对象：具象的事物，单个个体
  • 类跟具象的关系
    • 一个具象，表明一类事物的某一个个体
    • 一个是抽象，表明的是一大类事物
  • 类中的内容，应该具备两个内容
    • 代表事物的特征，叫作属性（变量）
    • 代表事物功能或动做，称为成员方法（函数）

2. 类的基本实现

• 类的命名
  • 遵照变量命名的规范
  • 大驼峰（由一个或多个单词构成，每一个单词首字母大写，单词跟单词直接相连）
  • 尽可能避开跟系统命名类似的命名
• 如何申明一个类
  • 必须用class关键字
  • 类由属性和方法构成，其余不容许出现
  • 成员属性定义能够直接使用变量赋值，若是没有，可使用None
  • 案例 01.py

定义一个学生类，用来形容学生

# 定义一个空的类
class Student():
    # 一个空类，pass表明直接跳过
    # 此处pass必须有
    pass

# 定义一个对象
mingyue = Student()

#在定义一个类，用来描述听Python的学生
class PythonStudent():
    # 用None给不肯定的值赋值
    name = None
    age = 18
    course = "Python"
    
    # 须要注意
    # 1.def doHomework的缩进层级
    # 2.系统默认由一个self参数
    def doHomework(self):
        print("I 在作做业")
        
        # 推荐在函数末尾使用return语句
        return None
        
# 实例化一个叫yueyue的学生，是一个具体的人
yueyue = PythonStudent()
print(yueyue.name)
print(yueyue.age)
# 注意成员函数的调用没有传递进入参数
yueyue.doHomework()

- 案例 02.py

class A():
    name = 'jjc'
    age = 18

for k,v in A.__dict__.items():
    print(k,"--",v)

• 实例化类

  变量 = 类名() # 实例化了一个对象

• 访问对象成员
  -使用点操做符

obj.成员属性名称
        obj.成员方法

• 能够经过默认内置变量检查类和对象的全部成员
  • 对象全部成员检查

  dict先后各有两个下划线
        obj.__dict__

• 类全部的成员

class_name.__dict__

3.anaconda基本使用

- anaconda主要是一个虚拟环境管理器
- 仍是一个安装包管理器
- conda list：显示anaconda安装的包
- conda  env list：显示anconda的虚拟环境列表
- conda create -n xxx python=3.6：建立python版本为3.6的虚拟环境，名称为xxx

4.类和对象的成员分析

• 类和对象均可以存储成员，成员能够归类全部，也能够归对象全部
• 类存储成员时使用的是与类关联的一个对象
• 对象存储成员时是存储在当前对象中
• 对象访问一个成员时，若是对象中没有该成员，尝试访问类中同名的成员，若是对象中有此成员，必定使用对象中的成员
• 创假对象的时候，类中的成员不会放人对象当中，而获得一个空对象，没有成员
• 经过对象对类中成员从新赋值后者经过对象添加成员时，对应成员会保存在对象中，而不会修改类成员

5. 关于self

• self在对象的方法中表示当前对象自己，若是，经过对象调用一个方法，那么该对象会自动传入到当前方法的第一个参数
• self并非关键字，只是一个用于接受对象的普通参数，理论上能够用任何一个普通变量名代替
• 方法中有self形参的方法成为非绑定类的方法，能够经过对象访问，没有self的是绑定类的方法，只能经过类访问
• 使用类访问绑定类的方法时，若是类方法中须要访问当前的成员，能够经过__class__成员来访问

6. 面向对象的三大特性

• 封装
• 继承
• 多态

6.1 封装

• 封装就是对对象的成员进行访问限制
• 封装的三个级别：
  • 公开，public
  • 受保护的，public
  • 私有的，public
  • public,public,public不是关键字
• 判别对象的位置
  • 对象内部
  • 对象外部
  • 子类中
• 私有
  • 私有成员是最高级别的封装，只能在当前类或对象中访问
  • 在成员前面添加两个下划线便可
  • python的私有不是真私有，是一种name mangling的更名策略，可使用对象._classname__attributename访问

  class Person():
    # name是共有的成员
    name = 'jjc'
    # __age就是私有成员
    __age = 18
  p = Person()
  print(p._Person__age)

• 受保护的封装
  • 受保护的封装是将对象成员进行必定级别的封装，而后，在类中或者子类中均可以进行访问，可是在外部不能够
  • 封装方法：在成员名称添加一个下划线便可
• 公开的
  • 公开的封装实际对成员没有任何操做，任何地方均可以访问

6.2 继承

• 继承就是一个类能够得到另一个类中的成员属性和成员方法
• 做用：减小代码，增长代码的复用功能，同时能够设置类与类直接的关系
• 继承与被继承的概念：
  • 被继承的类叫父类，也叫基类，也叫超类
  • 用于继承的类，叫子类，也叫派生类
  • 继承与被继承必定存在一个 is-a 关系
• 继承的语法

# 继承的语法
# 在python中，任何类都有一个共同的父类叫object

class Person():
    name = 'NoName'
    age = 0
    def sleep(self):
        print('Sleeping')
# 父类写在括号内
class Teacher(Person):
    pass
    
t = Teacher()
t.sleep()
print(t.name)

• 继承的特征
  • 全部的类都继承自object类，即全部的类都是object类的子类
  • 子类一旦继承父类，则可使用父类中除私有成员外的全部内容
  • 子类继承父类后并无将父类成员彻底赋值到子类中，而是经过引用关系访问调用
  • 子类中能够定义独有的成员属性和方法
  • 子类中定义的成员和父类成员相同，则优先使用子类成员
  • 子类想扩充弄父类的方法，能够在定义新方法的同时访问父类成员来进行代码重用，可使用 [父类名.父类成员] 的格式来调用父类成员，也可使用 [super().父类成员] 的格式
• 继承变量函数的查找顺序问题
  • 优先查找本身的变量
  • 没有则查找父类
  • 构造函数若是本类中没有定义，则自动查找调用父类构造函数
  • 若是本类有定义，则再也不继续向上查找

# 继承的语法
# 在python中，任何类都有一个共同的父类叫object
# 子类和父类定义同一个名称变量，则优先使用子类自己
class Person():
    name = 'NoName'
    age = 18
    __score = 0 # 考试成绩是秘密，只有本身知道
    _petname = "sec" # 小名，保护的，子类能够用，但不公用
    def sleep(self):
        print('Sleeping')
        
    def work(self):
        print('make some money')
# 父类写在括号内
class Teacher(Person):
    teacher_id = '9527'
    name = 'jjc'
    def make_test(self):
        print('attention')

    def work(self):
        # 扩充父类的功能只须要调用父类相应的函数
        # Person.work(self)
        # 另外一种方法，super表明父类
        Person.work(self)
        super().work()
        self.make_test()
        
t = Teacher()

t.work()

• 构造函数
  • 是一类特殊的函数，在类进行实例化以前进行调用
  • 若是定义了构造函数，则实例化时使用构造函数，不查找父类构造函数
  • 若是没定义，则自动查找父类构造函数
  • 若是子类没定义，父类的构造函数带参数，则构造对象时的参数应该按父类参数构造

# 构造函数的概念
# 继承中的构造函数
class Animal():
    def __init__(self):
        print('Dong wu')
    
class PaxingAni(Animal):
    
    def __init__(self,name):
        print('Paxing Dongwu {0}'.format(name))

class Dog(PaxingAni):
    # __init__就是构造函数
    # 每次实例化的时候，第一个被调用
    # 由于主要工做是进行初始化，因此得名
    def __init__(self):
        print("I'm init in dog")
# 实例化的时候，括号内的参数须要跟构造函数参数匹配
# 由于找到了构造函数，则再也不查找父类的构造函数
kaka = Dog()
# 实例化Dog时，查找到Dog的构造函数，参数匹配，不报错


# 猫没有写构造函数
class Cat(PaxingAni):
    pass
# 此时Cat没有构造函数，则向上查找
# 由于PaxingAni的构造函数须要两个参数，实例化的时候给了一个，报错
c = Cat('jjc')

• super
  • super不是关键字，而是一个类
  • super的做用是获取MRO列表中的一个类
  • super与父类没有实质性关系，但经过super能够调用到父类
  • super使用的两个方法，参见在构造函数中调用父类的构造函数
• 单继承和多继承
  • 单继承：每一个类只能继承一个类
  • 多继承：每一个类容许继承多个类
• 单继承和多继承的优缺点
  • 单继承：
    • 传承有序逻辑清晰语法简单隐患少
    • 功能不能无限扩展，只能在当前惟一的继承链中扩展
  • 多继承：
    • 优势：类的功能扩展方便
    • 缺点：继承关系混乱
• 菱形继承/钻石继承问题
  • 多个子类继承自同一个父类，这些子类游被同一个类继承，因而继承关系图星程了一个菱形
  • 关于多继承的MRO
    • MRO就是多继承中，用于保存继承顺序的一个列表
    • python自己采用C3算法来多继承的菱形继承进行计算的结果
    • MRO列表的计算原则：
      • 子类永远在父类以前
      • 若是多个父类，则根据继承语法中括号内类的书写顺序存放
      • 若是多个类继承同一个父类，孙子类中只会选取继承语法括号中第一个父类的父类

# 菱形继承
class A():
    pass
    
class B(A):
    pass

class C(A):
    pass
    
class D(B,C):
    pass

6.3 多态

• 多态就是同一个对象在不一样状况下有不痛的状态出现
• 多态不是语法，是一种设计思想
• 多态性：一种调用方式，不一样的执行效果
• 多态：同一事物的多种形态，动物分为人类，狗类，猪类

• [多态及多态性[(https://www.cnblogs.com/luchuangao/p/6739557.html)

• Mixin设计模式
  • 主要采用多继承方式对类的功能进行扩展
  • 咱们使用多继承语法来实现MIxin
  • 使用Mixin实现多继承的时候很是当心
    • 首先他必须表示某一单一功能，而不是某个物品
    • 职责必须单一，若是由多个功能，则写多个Mixin
    • Mixin不能依赖于子类的实现
    • 子类即便没有继承这个Mixin类，也能照样工做，只是缺乏了某个功能
  • 优势
    • 使用Mixin能够在不对类进行任何修改的状况下，扩展功能
    • 能够方便的组织和维护不一样功能组件的划分
    • 能够根据须要任意调整功能类的组合
    • 能够避免建立不少新的类，致使类的继承混乱

7. 类相关函数

• issubclass：检测一个类是不是另外一个类的子类
• isinstance：检测一个对象是不是一个类的实例
• hasattr：检测一个对象是否有成员XXX
• getattr： get attribute
• setattr： set attribute
• delattr：delete attribute
• dir：获取对象的成员列表

class A():
    name = 'Jjc'
class B(A):
    pass
class C():
    pass
#检测B是否为A的子类
print(issubclass(B,A))
print(issubclass(B,object))
# 返回True

a=A()
print(isinstance(a,A))

print(hasattr(a,'name'))

8. 类的成员描述符（属性）

# 属性案例
# 建立Student类，描述学生类
# 学生具备Student.name属性
# 但 named格式不统一

class Student():
    def __init__(self,name,age):
        self.name = name
        self.age = age
        #self.setName(name)
    def intro(self):
        print('Hi, my name is {0}'.format(self.name.upper()))
    
    def setName(self,name):
        self.name = name.title()
        
        
s1 = Student('jJC',19)
s2 = Student('wcx',18.0)
s1.intro()
s2.intro()

• 类的成员描述符是为了在类中对类的成员属性进行相关操做而建立的一种方式
  • get：获取属性的操做
  • set：修改后者添加属性操做
  • delete：删除属性的操做
• 若是想使用类的成员描述符，大概有三种方法
  • 使用类实现描述器
  • 使用属性修饰符
  • 使用property函数
    • property（fget, fset, fdel,doc）
• 案例

# property案例
class A():
    def __init__(self):
        self._name = 'haha'
        self._age = 18
    # 此功能，是对类变量进行读取操做的时候应该执行的函数功能
    def fget(self):
        print("{0}被读取了".format(self._name))
        return self._name
    # 模拟的是对变量进行写操做的时候执行的功能
    def fset(self, val):
        print("{0}我被写入了，可是还能够作好多事情".format(val))
        self._name = '我是' + val
        
    # fdel模拟的是删除变量的时候进行的操做
    def fdel(self):
        del self._name
    
    name = property(fget, fset, fdel, "这是一个property的例子")
    
a = A()
a.name = "jjc"
print(a.name)

#上面的代码等价于下面的代码

class A(object):
    
    @property
    def name(self):
        print("{0}被读取了".format(self._name))
        return self._name
    
    @name.setter
    def name(self,val):
        print("{0}我被写入了，可是还能够作好多事情".format(val))
        self._name = '我是' + val
        
    @name.deleter
    def name(self):
        del self._name
        
a = A()
a.name = "jjc"
print(a.name)

• 不管哪一种修饰符都是为了队成员属性进行相应的控制
  • 类的方式：适合多个类中的多个属性共用一个描述符
  • property：使用当前类中使用，能够控制一个类中多个属性
  • 属性修饰符：使用于当前类中使用，控制一个类中的一个属性

9. 类的内置属性

- __dict__：以字典的方式显示类的成员组成
- __doc__：获取类的文档信息
- __name__：获取类的名称，若是在模块中使用，获取模块的名称
- __bases__：获取某个类的全部父类，以元组的方式显示

10. 类的经常使用魔术方法

• 魔术方法就是不须要人为调用的方法，基本是在特定的时刻自动触发
• 魔术方法的统一的特征，方法名被先后各两个下划线包裹
• 操做类
  • 'init'：构造函数
  • 'new'：对象实例化方法
  • 'call'：对象当函数使用的时候触发
  • 'str'：当对象被当作字符串使用的时候调用
  • repr：返回字符串，跟__str__

# __init__ 举例
class A():
    def __init__(self,name = 0):
        print("sa")
    # __call__举例
    
    def __call__(self):
        print("我被举报了")
    
    def __str__(self):
        return 'bu'
a = A()
a()
print(a)

• 描述符相关
  • set
  • get
  • delete
• 属性操做相关
  • getattr：访问一个不存在的属性时触发,案例
  • setattr：对成员属性进行设置的时候触发，案例
    • 参数：
      • self用来获取当前对象
      • 被设置的属性名称，以字符串形式出现
      • 须要对属性名称设置的值
    • 做用：进行属性设置的时候进行验证或者修改
    • 注意：在该方法中不能对属性直接进行赋值操做，不然死循环

class A():
    def __getattr__(self,name):
        print('没找到')
        print(name)
a = A()

print(a.name)
print(a.addr)

# __setattr__案例
class Person():
    def __init__(self):
        pass
    
    def __setattr__(self, name, value):
        print('设置属性：{0}'.format(name))
        # 下面语句会致使问题，死循环
        #self.name = value
        # 此种状况，为了不死循环，规定统一调用父类魔法函数
        super().__setattr__(name,value)
p = Person()
print(p.__dict__)
p.age = 18

• 运算分类相关魔术方法
  • gt：进行大于判断的时候触发的函数
    • 参数
      • self
      • 第二个参数是第二个对象
      • 返回值能够是任意值，推荐返回布尔值
      • 案例

# __get__
class Student():
    def __init__(self,name):
        self._name = name
    
    def __gt__(self,obj):
        print("haha, {0}会比{1}大吗？".format(self._name,obj._name))
        return self._name > obj._name
# 字符串的比较是按什么规则
stu1 = Student('one')
stu2 = Student('two')
print(stu1 > stu2)
# 问，如何让显示结果美观，one 会比 twi大吗

11. l类和对象的三种方法

• 实例方法
  • 须要实例化对象才能使用的方法，使用过程当中可能须要截止对象的其余的方法完成
• 静态方法
  • 不须要实例化，经过类直接访问
• 类方法
  • 不须要实例化
• 参看案例

# 三种方法案例
class Person:
    # 实例方法
    def eat(self):
        print(self)
        print('Eating……')
        
    # 类方法
    # 类方法的第一个参数，通常命名为cls，区别于self
    @classmethod
    def play(cls):
        print(cls)
        print('Playing……')
        
    # 静态方法
    # 不须要用第一个参数表示自身或者类
    @staticmethod
    def say():
        print('Saying……')
yueyue = Person()

#实例方法
yueyue.eat()
# 类方法
Person.play()
yueyue.play()
# 静态方法
Person.say()
yueyue.say()

12.抽象类

• 抽象方法：没有具体实现内容的方法成为抽象方法
• 抽象方法的主要意义是规范了子类的行为和接口
• 抽象类的使用须要借助abc模块
  • import abc
• 抽象类：包含抽象方法的类叫抽象类，一般成为ABC类
• 抽象类的使用
  • 抽象类能够包含抽象方法，也能够包含具体方法
  • 抽象类中能够有方法也能够有属性
  • 抽象类不容许直接实例化
  • 必须继承才可使用，且继承的子类必须实现全部继承来的抽象方法
  • 假定子类没有实现全部的抽象方法，则子类也不能实例化
  • 抽象类的主要做用是设定类的标准，以便于开发的时候具备统一的规范

# 抽象类的实现
import abc
# 申明一个类而且制定当前类的元类
class Human(metaclass = abc.ABCMeta):
    
    # 定义一个抽象的方法
    @abc.abstractmethod
    def smoking(self):
        pass
        
    # 定义类抽象方法
    @abc.abctractclassmethod
    def drink():
        pass
    
    # 定义静态抽象方法  
    @abc.abstractstaticmethod
    def play():
        pass

13.自定义类

• 类实际上是一个类定义和各类方法的自由组合

# 本身组装一个类
# 若是要绑定对象,用下面一句代码，绑定类，不须要
from types import MethodType

class A():
    pass
    
def say(self):
    print("saying……")
    
a = A()
a.tt = MethodType(say,A)
a.tt()

• 能够定义类和函数，而后本身经过类直接赋值
• 能够借助MethodType实现
• 借助于type实现
• 利用元类实现，MetaClass
  • 元类是类
  • 备用来创造别的类

# 利用type造一个类
# 先定义类应该具备的成员函数
def say(self):
    print("saying……")
def talk(self):
    print("Talking……")

# 用type来建立一个类
A = type("AName",(object,),{"class_say":say, "class_talk":talk})

# 而后能够像正常访问同样使用类
a = A()

a.class_say()
a.class_talk()

# 元类演示
# 元类写法是固定的，必须继承自type
# 元类通常命名以MetaClass结尾
class TulingMetaClass(type):
    # 注意一下写法
    def __new__(cls, name, bases, attrs):
        # 本身的业务处理
        print("我是元类")
        attrs['id'] = '000000'
        attrs['addr'] = "苏州市"
        return type.__new__(cls, name, bases, attrs)

# 元类定义完就可使用，使用注意写法
class Teacher(object, metaclass = TulingMetaClass):
    pass
    
t = Teacher()

t.id