Python3之面向对象(OOP)全解上（类与对象、关于self、面向对象三大特性等）

1、类中内容：应该具有两个内容

• 表明事物的特征、叫做属性（变量）
• 表明事物功能或动作，称为成员方法（函数）

2、类的基本实现

• 类的命名方法
  • 遵守变量命名规范
  • 大驼峰（由一个或者多个单词构成，每个单词首字母大写，单词跟单词直接相连）
  • 尽量避开跟系统命名相似的命名
• 如何声明一个类
  • 必须用class关键字
  • 类由属性和方法构成，其他不允许出现
  • 成员属性定义可以直接使用变量赋值，如果没有值，可用None
• 实例化类
  • 变量 = 类名( )   #实例化了一个对象
• 访问对象成员
  • 使用点操作符
    • obj.成员属性名称
    • obj.成员方法

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

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

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

#再定义一个类，用来描述听python的学生
class PythonStudent():
    #用None給不确定的值赋值
    name = None
    age = 18
    course = "python"

    #需要注意
    #1、def dohomework的缩进层级
    #系统默认由一个self参数
    def doHomework(self):
        print("我在做作业")

        #推荐在函数末尾使用return语句
        return None

#实例化一个叫yueyue的学生是一个具体的人
yueyue = PythonStudent()
print(yueyue.name)
print(yueyue.age)

#注意成员函数的调用没有传递参数
yueyue.doHomework()

• 可以通过默认内置变量检查类和对象的所有成员
  • 对象所有成员检查
    • obj._dict_   #dict前后各有两个下划线
  • 类的所有成员
    • class_name._dict_    #dict前后各有两个下划线

class Student():
    name = "haha"
    age = 18
print(Student.__dict__)
#实例化
yueyue = Student()
print(yueyue.__dict__)   #运行结果没有显示，但是下面打印名字确实存在
print(yueyue.name)

运行结果：
{'__module__': '__main__', 'name': 'haha', 'age': 18, '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>, '__doc__': None}
{} 
haha

3、类和对象的成员分析

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

class A():
    name = "dana"
    age = 19

    #注意say的写法，参数有一个self，相当于C++里的this
    def say(self):
        self.name = "aa"
        self.age = 20

#此时，A称为类实例
print(A.name)
print(A.age)

#id可以鉴别一个变量是否和另一个变量是同一个变量
print(id(A.name))
print(id(A.age))
print("*" * 20)

a=A()
print(a.name)
print(a.age)
print(id(a.name))
print(id(a.age))

a.name = "lala"
print(a.__dict__)
print(a.name)
print(id(a.name))

运行结果：                     类实例的属性和其对象的实例的属性在不对对象实例属性赋
dana                          值的前提下，指向同一个变量
19
2271742027008
140715391256064
********************
dana
19
2271742027008
140715391256064

{'name': 'lala'}              类实例对象赋值后，有自己存储的变量
lala
2660405365536         

4、关于self

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

class Student():
    name = "dana"
    age = 19

    #注意say的写法，参数有一个self，写成其他的也行
    def say(self):
        self.name = "aa"
        self.age = 20
        print("My name is {0}".format(self.name))
        print("My age is {0}".format(__class__.age)) #可访问类中成员变量
    def sayAgain():
        print(__class__.name)
        print(__class__.age)
        print("hello")

st = Student()
st.say()
#st.sayAgain()   会报类型错误，如果没有参数，怎么办呢？
#调用绑定类函数（没有传入形参）使用类名调用
Student.sayAgain()

 实例：

class Student():
    name = "dana"
    age = 19

    def __init__(self):   #构造参数
        self.name = "lala"
        self.age = 13

    def say(self):
        print(self.name)
        print(self.age)

class B():
    name = 'bbb'
    age = 23

a = Student()
#此时，系统会默认把a作为第一个参数传入函数
a.say()
'''Student.say()报错TypeError: say() missing 1 required positional argument: 'self'，
    Student类名不会被当作self参数传进函数，只有实例对象可以
'''
#此时，self被a替代，手动把a传进去
Student.say(a)
#同样可以把A作为参数传入
Student.say(Student)

#此时，传入的是类实例B，因为B具有name和age属性，所以不会报错
Student.say(B)

#以上代码，利用了鸭子模型（传进来可以用就行，不管是谁）

运行结果：
lala
13
lala
13
dana
19
bbb
23

5、面向对象的三大特性

• 封装、继承、多态

（1）封装

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

class Person():
    #name是共有的成员
    name = "kaka"
    #__age就是私有成员
    __age = 13

p = Person()
print(p.name)

# AttributeError: 'Person' object has no attribute '__age'
#print(p.__age) 对象不能这样访问私有变量
print(Person.__dict__)
p._Person__age  =12 #改个名访问，但是都私有化不想让访问了就别访问了
print(p._Person__age)

运行：
kaka
{'__module__': '__main__', 'name': 'kaka', '_Person__age': 13, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}
12

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

（2）继承

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

#在python中，任何类都有一个共同的父类叫object
class Person():
    name = "NoName"
    age = 19
    _petname = "sec" #小名，是保护的，子类可以用，但不能公用
    __score = 0  #考试成绩是私有
    def sleep(self):
        print("Sleeping。。。。")

#父类写在括号里
class Teacher(Person):
    name = "dada"
    teacher_id = "3451"
    def make_test(self):
        print("attention")      

t = Teacher()
#就近调用
print(t.name)
print(Teacher.name)
print(t._petname)
t.make_test()

t.sleep()

• 继承的特征
  • 所有的类都继承object类，即所有的类都是object类的子类
  • 子类一旦继承父类，则可以使用父类中除私有成员外的所有内容
  • 子类继承父类后并没有将父类成员完全赋值到子类中，而是通过引用关系访问调用
  • 子类中可以定义独有的成员属性和方法
  • 子类中定义的成员和父类成员如果相同，则优先使用子类成员
  • 子类如果想扩充父类的方法，可以在定义新方法的同时访问父类成员来进行代码复用。可以使用 父类名.父类成员 的格式来调用父类成员，也可以使用 super().父类成员的格式来调用

#子类扩充父类
class Person():
    def sleep(self):
        print("Sleeping。。。。")

    def work(self):
        print("make money")
#父类写在括号里
class Teacher(Person):
    def make_test(self):
        print("attention")

    def work(self):
        #扩充父类的功能只需要调用父类相应的函数就可以了
        #一种：Person.work(self)
        #扩充父类的另一种方法,super代表父类
        super().work()
        self.make_test()

t = Teacher()
#就近调用
t.work()

运行结果：
make money
attention

• 继承变量函数的查找顺序问题
  • 优先查找自己的变量，没有则查找父类
  • 构造函数如果本类中没有定义，则自动查找调用父类构造函数；如果本类有定义，则不在继续向上查找
• 构造函数
  • 是一类特殊的函数，在类进行实例化之前进行调用
  • 如果定义了构造函数，则实例化时使用构造函数，不查找父类构造函数。如果没定义，则按照MRO顺序自动查找父类构造函数
  • 如果子类没定义，父类的构造函数带参数，则构造队形应该按父类参数构造

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

运行结果：I am init in dog


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

#实例化时自动调用了Dog的构造函数
#因为找到了构造函数，则不在查找父类的构造函数
kaka =Dog()

#猫没有写构造函数
class Cat(PaxingAni):
    pass

#此时应该自动调用构造函数，因为Cat没有构造函数，所以查找父类的构造函数
#因为PaxingAni的构造函数需要两个参数，实例化时给了一个，报错
#c = Cat()
运行结果：
I am init in dog

• super
  • super不是关键字，而是一个类
  • super的作用是获取MRO (MethodRestionOrder)列表中的第一个类
  • super于父类没有任何实质性关系，但通过super可以调用父类
  • super常见的两个方法参见在构造函数中调用父类的构造函数

class A():
    pass

class B(A):
    pass

print(A.__mro__)
print(B.mro())
print(C)

运行结果：
(<class '__main__.A'>, <class 'object'>)
[<class '__main__.B'>, <class '__main__.A'>, <class 'object'>]

• 单继承和多继承（子类可以直接拥有父类的属性和方法，私有属性和方法除外）
  • 单继承：每个类只能继承一个类；多继承：每个类允许继承多个类
  • 优缺点：
    • 单继承：传承有序逻辑清晰语法简单隐患少；功能不能无限扩展，只能在当前唯一的继承链中扩展
    • 多继承：类的功能扩展方便；继承关系混乱
• 菱形继承/钻石继承问题
  • 多个子类继承同一个父类，这些子类由同一个类继承，于是继承关系图形形成一个菱形
  • 【MRO】http://www.cnblogs.com/whatisfantasy/p/6046991.html
  • 关于多继承的MRO(MRO就是多继承中，用于保存继承顺序的一个列表)
    • MRO列表计算原则：
      • 如果多个类继承了同一个父类，孙子类中只会选取继承语法括号中第一个父类的父类
      • 如果多个父类，则根据继承语法中括号内类的书写顺序存放
      • 子类永远在父类前面
      • python本身采用C3算法来多继承的菱形继承进行计算的结果

class Fish():
    def __init__(self,name):
        self.name = name
    def swim(self):
        print("I am swimming....")

class Bird():
    def __init__(self,name):
        self.name = name

    def fly(self):
        print("I am flying")

class Person():
    def __init__(self,name):
        self.name = name

    def work(self):
        print("Working...")

#注意多继承顺序，从左往右，第一、二、三...个父亲
class SuperMan(Person,Bird,Fish):
    def __init__(self, name):
        self.name = name

s = SuperMan("yueyue")
s.fly()
s.swim()

#单继承
class Student(Person):
    def __init__(self,name):
        self.name = name
stu = Student("haha")
stu.work()

运行：
I am flying
I am swimming....
Working...

• 多态：就是同一个对象在不同情况下有不同的状态出现
  • 多态不是语法，是一种设计思想（python中）
  • 多态性：一种调用方式，不同的执行效果
  • 多态：同一事物的多种形态，动物分为人类、狗类、猪类
  • 多态和多态性：http://www.cnblogs.com/luchuangao/p/6739557.html
• Mixin设计模式（多继承+相应规则）
  • 主要采用多继承方式对类的功能进行扩展（）
  • 我们使用多继承语法来实现MInxin，使用Mixin实现多继承的时候非常小心首先她必须表示某一单一功能（鸟就是飞，me'y），而不是某个物品
  • 职责必须单一，如果多个功能，则写多个Mixin
  • Mixin不能依赖于子类的实现
  • 子类即使没有继承这个Mixin类，也能照样工作，只是缺了某个功能
• 优点
  • 使用Mixin可以不对类进行任何修改的情况下，扩充功能
  • 可以方便组织和维护不同功能组件的划分
  • 可以根据需要任意调整功能类的组合
  • 可以避免创建很多新的类，导致类的继承混乱

class Person():
    name = "haha"
    age = 28

    def eat(self):
        print("eat...")

    def drink(self):
        print("drink...")

    def sleep(self):
        print("sleep...")

class Teacher(Person):
    def work(self):
        print("work")

class Student(Person):
    def study(self):
        print("Study...")

class Tutor(Teacher,Student):
    pass

t = Tutor()
print(Tutor.mro())
print(t.__dict__)
print(Tutor.__dict__)
print("*"*20)

class TeacherMixin():
    def work(self):
        print("work")

class StudentMixin():
    def study(self):
        print("Study...")

class TutorM(Person,TeacherMixin,StudentMixin):
    pass

tt = Tutor()
print(TutorM.mro())
print(tt.__dict__)
print(TutorM.__dict__)
运行结果：
[<class '__main__.Tutor'>, <class '__main__.Teacher'>, <class '__main__.Student'>, <class '__main__.Person'>, <class 'object'>]
{}
{'__module__': '__main__', '__doc__': None}
********************
[<class '__main__.TutorM'>, <class '__main__.Person'>, <class '__main__.TeacherMixin'>, <class '__main__.StudentMixin'>, <class 'object'>]
{}
{'__module__': '__main__', '__doc__': None}

其他内容见面向对象~下