OOP - python面向对象

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

面向对象概述

• OOP思想
  • 接触到任意一个人物，首先想到的是这个任务世界的构成，有模型构成
• 几个名词
  • OO：面向对象
  • OOA：面向对象的分析
  • OOD：面向对象的设计
  • OOI：面向对象的实现
  • OOP：面向对象的编程
  • OOA->OOD->OOI：面向对象的实现过程
• 类和对象的概念
  • 类：抽象名词，代表一个集合，共性的事物
  • 对象：具象的事物，单个个体
  • 类跟对象的关系
    • 一个具象，代表一类事物的某一个个体
    • 一个是抽象，代表的是一大类事物
• 类中的内容，应该具有两个内容
  • 表明事物的特征，叫做属性（变量）
  • 表明事物的功能或动作，称为成员方法（函数）
• 如何声明一个类
  • 必须用class关键字
  • 类有属性和方法构成，其他不予许
  • 成员属性定义直接使用变量赋值，如果没有值，允许使用None

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

#再定义一个类
class PythonStudent():
    #用None给不确定的值赋值
    name = None
    age = 18
    course = "python"
    
    #系统默认有一个self参数
    def doHomework(self):
        print("我在学python")
        #推荐在函数末尾使用return语句
        return None

#实例化一个叫liqian的学生，是一个具体的人
liqian = PythonStudent()
print(liqian.name)
print(liqian.age)
#注意成员函数的调用没有传入参数
liqian.doHomework()

• 实例化类

    变量 = 类名（）#实例化了一个对象
  

• 访问对象成员

  • 使用.操作符

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

• 可以通过默认内置变量检查类和对象的所有成员

  • 对象所有成员的检测

      #dict前后各有两个下划线
      obl.__dict__
    

  • 类所有的成员

      #dict前后各有两个下划线
      class_name.__dict__
    

类的基本实现

• 类的命名
  • 遵守变量名的规范
  • 大驼峰
  • 尽量避开跟系统命名相似的命名

anaconda基本使用

• anaconda主要是一个虚拟环境管理器
• 还是一个安装包管理器
• conda list：显示anaconda安装的包
• conda env list：显示anaconda安装的包
• conda create -n XXX python=3.6：创建python版本为3.6的虚拟环境，名为XXX

类跟对象的成员分析

• 类和对象都可以存储成员，成员可以归类所有，也可以归对象所有
• 类存储成员时使用的是与类关联的对象
• 对象访问成员时，如果对象中没有该成员，尝试访问类中的同名成员，如果对象中有此成员，一定使用对象中的成员
• 创建对象的时候，类中的成员不会自动放入对象中，而是得到一个空对象，没有成员
• 通过对象对类中成员重新赋值或者通过对象添加成员时，对应的成员会保存在对象中，而不会修类成员

关于self

• self在对象的方法中表示当前对象本身，如果通过对象条用一个方法，那么该对象会自动传入第一个参数中
• self并不是关键字，只是一个接受对象的普通参数，理论上可以用一个普通参数代替
• 方法中有self形参的方法为非绑定类的方法，可以通过对象访问，没有self的是绑定类方法，只能通过类访问
• 使用类访问绑定类的方法时，如果类方法中需要访问当前了的成员，可以通过__class__成员名来访问

#关于self的案例
class A();
    name = "liqian"
    age = 18
    
    def __init__(self):
        self.name = "aaa"
        self.age = 200
        
    def say(self):
        print(self.name)
        print(self.age)
    
class B():
    name = "bbb"
    age = 90

a = A()
#此时，系统会默认把a作为第一个参数
a.say()
#此时，self被a替换
A.say(a)
#同样可以把A作为参数传入
A.say(A)

#此时，传入的是类实例B，因为B具有name和age属性，所以不报错
A.say(B)
#以上代码，利用了鸭子模型

运行结果
aaa
200
aaa
200
liqian
18

面向对象三大特性

• 封装
• 继承
• 多态

封装

• 封装就是对对象的成员进行访问限制
• 封装的三个级别：
  • 公开：public
  • 受保护的：protected
  • 私有的：private
  • public，protected，private不是关键字
• 判别对象的位置
  • 对象内部
  • 对象外部
  • 子类中
• 私有
  • 私有成员时最高级别的封装，只能在当前类或对象中访问
  • 在成员前面添加两个下划线

class Person():
    #name是共有成员
    name = "liqian"
    #__age就是私有成员
    __age = 18

- python的私有不是真的私有，是一种成为name mangling的改名策略，可以使用对象，_classname_attributename访问

• 受保护的封装 protected
  • 受保护的封装是将对象成员进行一定级别的封装，然后，在类或者子类中都可以进行访问，但是在外部不可以
  • 封装方法：在成员名称前添加一个下划线即可
• 公开的，公共的 public
  • 公共的封装实际对成员没有任何操作，任何地方都可以访问

继承

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

#继承的语法
#在python中，任何一个类都有一个共同的父类叫object
class Person():
    name = "Noname"
    age = 0
    def sleep(self):
        print("Sleeping......")
        
#父类写在括号里面
class Teacher(Person):
    pass

t = Teacher()
print(t.name)
print(Teacher.name)

#运行结果
Noname
Noname

• 继承的特征
  • 所有的类都继承自object类，即所有的类都是object的子类
  • 子类一但继承父类，则可以使用父类中除私有成员外的所有内容
  • 子类继承父类后并没有将父类成员完全赋值到子类中，而是通过引用关系调用
  • 子类中可以定义独有的成员属性和方法
  • 子类中定义的成员和父类如果相同，则优先使用子类成员
  • 子类如果想扩充父类的方法，可以在定义新方法的同时访问父类成员来进行代码重用，可以使用 父类名.父类成员 的格式来调用父类成员，也可以使用super().父类成员的格式来调用
• 继承变量函数的查找顺序
  • 任何情况都是优先查找自己的变量
  • 没有则查找父类
  • 构造函数如果本类中没有定义，则自动查找调用父类构造函数
  • 如果本类有定义，则不再继续向上查找
• 构造函数
  • 是一类特殊的函数，在类进行实例化之前进行调用
  • 如果定义了构造函数，则实例化时使用构造函数，不查找父类构造函数
  • 如果没定义，则自动查找父类构造函数
  • 如果子类没有定义，父类的构造函数带参数，则构造对象时的参数应该按父类参数构造
• super
  • super不是一个关键字，而是一个类
  • super的作用是获取MRO（MethodResolustionOrder）列表中的第一个类
  • super与父类直接没有任何实质性的关系，但通过super可以调用到父类

# 构造函数的概念
class Dog():
    # __init__就是构造函数
    # 每次实例化的时候，第一个被自动的调用
    # 因为主要工作是进行初始化，所以得名
    def __init__(self):
        print("I am init in dog")
# 实例化的时候，括号里的参数需要跟构造函数参数匹配
kaka = Dog()

#运行结果
I am init in dog

# 继承中的构造函数 —— 1
class Animal():
    pass

class PaxingAni(Animal):
    pass

class Dog(PaxingAni):
    # __init__就是构造函数
    # 每次实例化的时候，第一个被自动的调用
    # 因为主要工作是进行初始化，所以得名
    def __init__(self):
        print("I am init in dog")
#实例化的时候，自动调用了Dog的构造函数
kaka = Dog()

#运行结果
I am init in dog

# 继承中的构造函数 —— 2
class Animal():
    print("anmial")

class PaxingAni(Animal):
    def __init__(self):
        pritn("Paxing animal")
        
class Dog(PaxingAni):
    # __init__就是构造函数
    # 每次实例化的时候，第一个被自动的调用
    # 因为主要工作是进行初始化，所以得名
    def __init__(self):
        print("I am init in dog")
#实例化的时候，自动调用了Dog的构造函数
#因为找到了构造函数，则不再查找父类的构造函数
kaka = Dog()
#猫没写构造函数
class Cat(PaxingAni):
    pass
#此时应该自动调用构造函数，因为Cat没有构造函数，所以查找父类构造函数
c = Cat()

#运行结果
I am init in dog
Paxing animal

# 继承中的构造函数 —— 3
class Animal():
    print("anmial")

class PaxingAni(Animal):
    def __init__(self,name):
        print("Paxing animal {0}".format(name)
        
class Dog(PaxingAni):
    # __init__就是构造函数
    # 每次实例化的时候，第一个被自动的调用
    # 因为主要工作是进行初始化，所以得名
    def __init__(self):
        print("I am init in dog")
        
d = Dog()

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

单继承和多继承

• 单继承：每个类只能集成一个类
• 多继承：每个类允许继承多个类

多态

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