python学习笔记-（十）面向对象基础

面向对象相关知识简介

• 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
• 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
• 数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
• 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖(override),也称为方法的重写。
• 实例变量：定义在方法中的变量，只作用于当前实例的类。
• 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如,有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
• 实例化：创建一个类的实例，类的具体对象。
• 方法：类中定义的函数。
• 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

编程范式

　　编程是程序员用特定的语法+数据结构+算法组成的代码来告诉计算机如何执行任务的过程，一个程序是程序员为了得到一个任务结果而编写的一组指令的集合，正所谓条条大路通罗马，实现一个任务的方式有很多种不同的方式，对这些不同的编程方式的特点进行归纳总结得出来的编程方式类别，即为编程范式。不同的编程范式本质上代表对各种类型的任务采取的不同的解决问题的思路，大多数语言只支持一种编程范式，当然也有些语言可以同时支持多种编程范式。

　　两种最重要的编程范式分别是：面向过程编程和面向对象编程。                         

1.面向过程编程(Procedural Programming)

　　就是程序从上到下一步步执行，一步步从上到下，从头到尾的解决问题。基本设计思路就是程序一开始是要着手解决一个大的问题，然后把一个大问题分解成很多个小问题或子过程，这些子过程再执行的过程再继续分解直到小问题足够简单到可以在一个小步骤范围内解决。

　　这样做的问题也是显而易见的,就是如果你要对程序进行修改，对你修改的那部分有依赖的各个部分你都也要跟着修改,举个例子,如果程序开头你设置了一个变量值为1,但如果其它子过程依赖这个值为1的变量才能正常运行,那如果你改了这个变量,那这个子过程你也要修改,假如又有一个其它子程序依赖这个子过程,那就会发生一连串的影响,随着程序越来越大,这种编程方式的维护难度会越来越高。 　　

　　所以我们一般认为,如果你只是写一些简单的脚本,去做一些一次性任务,用面向过程的方式是极好的;但如果你要处理的任务是复杂的,且需要不断迭代和维护的,那还是用面向对象最方便了。

2. 面向对象编程(Object Oriented Programming)

　　面向对象编程是一种编程方式，此编程方式的落地需要使用"类"和"对象"来实现，所以，面向对象编程其实就是对"类"和"对象"的使用。

　　使用面向对象编程的原因一方面是因为它可以使程序的维护和扩展变得更简单，并且可以大大提高程序开发效率；另外，基于面向对象的程序可以使它人更加容易理解你的代码逻辑，从而使团队开发变得更从容。

2.1 类和对象

　　类就是一个模板，模板里可以包含多个函数，函数里实现一些功能；---函数在类中被称为方法

　　对象则是根据模板创建的实例，通过实例对象可以执行类中的函数；

　　类对象支持两种操作：属性引用和实例化。属性引用使用和Python中所有的属性引用一样的标准语法：obj.name。类对象创建后，类命名空间中所有的命名都是有效属性名。所以如果类定义是这样:

#定义一个类，class是定义类的语法；user是类名；(object)是新式类的写法，必须这么写；（额。。什么是新式类？暂时忘记他吧！）
class user(object):
    def __init__(self,name):#初始化函数，(self,name)里是要初始化的属性,其中self为特殊参数，必填项；name为实际参数
        self.name = name#实例变量，作用域就是实例本身
    def uname(self):#---类中创建了一个方法uname
        print("%s is the best!" % self.name)
i = user('dd')#---根据类user创建对象i
i.uname()#执行uname方法

2.1.1 零散知识点集锦：

• 类变量和实例变量

类变量： 

    是可在类的所有实例之间共享的值（也就是说，它们不是单独分配给每个实例的）。

实例变量：

    实例化之后，每个实例单独拥有的变量。

class Test(object):  
    num_of_instance = 0  
    def __init__(self, name):  
        self.name = name  
        Test.num_of_instance += 1  
  
if __name__ == '__main__':  
    print Test.num_of_instance  
    t1 = Test('cc')  
    print Test.num_of_instance  
    t2 = Test('lucy')  
    print t1.name , t1.num_of_instance  
    print t2.name , t2.num_of_instance   

-------------------------------打印输出-------------------------------
0
1
cc 2
lucy 2

• 析构函数

上面我们已经知道构造函数__init__，具有初始化的作用，也就是当该类被实例化的时候就会执行该函数,那么我们就可以把要先初始化的属性放到这个函数里面。

那么与之对应的就是析构函数__del__,用于释放对象占用的资源的函数，做收尾工作，例如关闭数据库、打开临时文件等;

__del__()也是可选的，如果不提供，则Python 会在后台提供默认析构函数

如果要显式的调用析构函数，可以使用del关键字，方式如下：

del对象名

• 私有属性和方法

1)类的私有属性

__private_attrs：两个下划线开头，声明该属性为私有，不能在类地外部被使用或直接访问。在类内部的方法中使用时self.__private_attrs。

2)类的私有方法

__private_method：两个下划线开头，声明该方法为私有方法，不能在类地外部调用。在类的内部调用 slef.__private_methods。

class JustCounter:
    __secretCount = 0  # 私有变量
    publicCount = 0    # 公开变量
 
    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print(self.__secretCount)
    def __count(self):#私有方法
        self.__secretCount -=1
        self.publicCount -= 1
        print(self.__secretCount)
counter = JustCounter()
counter.count()
print(counter.publicCount)
print(counter.__secretCount)  # 报错，实例不能访问私有变量

-----------打印输出----------------
AttributeError: 'JustCounter' object has no attribute '__secretCount'

#---------------------------我是华丽的分割线-------------------------

#我们注释掉print(counter.__secretCount)，加上下面这句再试试

counter.__count()#访问私有方法

-----------打印输出----------------
1
1
Traceback (most recent call last):
File "E:/python/new/new.py", line 20, in <module>
   counter.__count()#访问私有方法
AttributeError: 'JustCounter' object has no attribute '__count'

2.2 面向对象的三大特性

2.2.1 封装

封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。

所以，在使用面向对象的封装特性时，需要：

• 将内容封装到某处
• 从某处调用被封装的内容

第一步：将内容封装到某处

self是一个形式参数,当执行obj1=Foo('cc',18)时,self等于obj1；当执行obj2=Foo('coco',22)时,self等于obj2；

所以,内容其实被封装到了对象obj1和obj2中,每个对象中都有name和age属性,在内存里类似于下图来保存。

 

第二步：从某处调用被封装的内容

调用被封装的内容时，有两种情况：

• 通过对象直接调用
• 通过self间接调用

1、通过对象直接调用被封装的内容

上图展示了对象 obj1 和 obj2 在内存中保存的方式，根据保存格式可以如此调用被封装的内容：对象.属性名

class Foo:
    def __init__(self, name, age):
        self.name = name
        self.age = age
obj1 = Foo('cc', 18)
print(obj1.name)   # 直接调用obj1对象的name属性
print(obj1.age)     # 直接调用obj1对象的age属性
obj2 = Foo('coco', 22)
print(obj2.name)    # 直接调用obj2对象的name属性
print(obj2.age)     # 直接调用obj2对象的age属性
----------------------------打印输出-------------------------------------
cc
18
coco
22

2、通过self间接调用被封装的内容

执行类中的方法时，需要通过self间接调用被封装的内容

# 创建一个类，类名是Class_basis
class Class_basis:
    # 在类里面创建了一个方法ret
    def ret(self,):
        # 输出self的内存地址
        print("方法ret的self内存地址", id(self))

# 创建一个对象obj，类名后面加括号
obj = Class_basis()

# 输出对象obj的内存地址
print("obj对象内存地址", id(obj))

# 通过对象调用类中的ret方法
obj.ret()
-------------------打印输出---------------------------
obj对象内存地址 2513776
方法ret的self内存地址 2513776

通过上面的测试可以很清楚的看到obj对象和类的方法中self内存地址是一样的，那么方法中的self就等于obj；

----------self是形式参数，由python自行传递

综上所述，对于面向对象的封装来说，其实就是使用构造方法将内容封装到对象中，然后通过对象直接或者self间接获取被封装的内容。综上所述，对于面向对象的封装来说，其实就是使用构造方法将内容封装到对象中，然后通过对象直接或者self间接获取被封装的内容。

2.2.2 继承

面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。

通过继承创建的新类称为“子类”或“派生类”。

被继承的类称为“基类”、“父类”或“超类”。

继承的过程，就是从一般到特殊的过程。

要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。

• 什么时候用：

上面我们说过，用继承可以代码重用；那么大家可以考虑下：我定义几个类，而这些类有一些公共的属性和方法，那么我们可以把相同的属性和方法提取出来作为基类的成员，特殊的方法和属性在本类定义；这样只需要继承基类这个动作，就可以访问到基类的属性和方法了，它提高了代码的可扩展性。

• 缺点：

凡事必有两面性，了解了继承的优点，我们也需要对他的缺点有所了解：可能特殊的本类又有其他特殊的地方，又会定义一个类，其下也可能再定义类，这样就会造成继承的那条线越来越长，使用继承的话,任何一点小的变化也需要重新定义一个类,很容易引起类的爆炸式增长,产生一大堆有着细微不同的子类. 所以有个“多用组合少用继承”的原则。

• 特点：

1）在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用；

2）在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数；

3）Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。 

• 经典类与新式类

经典类和新式类，从字面上可以看出一个老一个新，新的必然包含了跟多的功能，也是之后推荐的写法，从写法上区分的话，如果 当前类或者父类继承了object类，那么该类便是新式类，否则便是经典类。

class u1:
    pass #经典类
class u2(u1):
    pass #经典类

class t1(object):
    pass #新式类
class t2(t1):
    pass #新式类

• 怎么用：

1）普通继承

class SchoolMember(object):
    members = 0  # 初始学校人数为0
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def tell(self):
        print("SchoolMember的名字是：%s!"%self.name)
class Teacher(SchoolMember):#继承了父类
    def __init__(self,name,age,course,salary):
        SchoolMember.__init__(self,name,age)#继承了父类的属性
        self.course = course
        self.salary = salary
        print("Teacher的名字是：%s!" % self.name)

    def teaching(self):
        '''讲课方法'''
        print("Teacher [%s] is teaching [%s] for class [%s]" % (self.name, self.course, 's12'))
class Student(SchoolMember):
    def __init__(self, name, age,classes):
        SchoolMember.__init__(self,name, age)  # 继承了父类的属性
        self.classes = classes
    def tell(self):#覆盖了父类的tell方法
        SchoolMember.tell(self)
        print("Student的名字是：%s!" % self.name)
teacher = Teacher("cc",18,"python",10000)
teacher.tell()
student = Student("tt",20,307)
student.tell()

----------------------打印输出-------------------------
Teacher的名字是：cc!
SchoolMember的名字是：cc!
SchoolMember的名字是：tt!
Student的名字是：tt!

2）super继承

class SchoolMember(object):
    members = 0  # 初始学校人数为0
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def tell(self):
        print("SchoolMember的名字是：%s!"%self.name)
class Teacher(SchoolMember):#继承了父类
    def __init__(self,name,age,course,salary):
        super(Teacher,self).__init__(name, age)#继承了父类的属性
        self.course = course
        self.salary = salary
        print("Teacher的名字是：%s!" % self.name)

    def teaching(self):
        '''讲课方法'''
        print("Teacher [%s] is teaching [%s] for class [%s]" % (self.name, self.course, 's12'))
class Student(SchoolMember):
    def __init__(self, name, age,classes):
        super(Student, self).__init__(name, age)  # 继承了父类的属性
        self.classes = classes
    def tell(self):#覆盖了父类的tell方法
        print("Student的名字是：%s!" % self.name)
teacher = Teacher("cc",18,"python",10000)
teacher.tell()
student = Student("tt",20,307)
student.tell()

------------------------打印输出------------------------
Teacher的名字是：cc!
SchoolMember的名字是：cc!
Student的名字是：tt!

3）多继承

多继承的意思就是继承多个类；

那么问题来了：Python的类如果继承了多个类，他寻找方法的查询策略是什么呢? 

Python2中经典类是按深度优先来继承的；新式类是按广度优先来继承的；

Python3中经典类和新式类都是统一按广度优先来继承的；

class D(object):
    # def bar(self):
    #     print('D.bar')
    pass
class C(D):
    # def bar(self):
    #     print('C.bar')
    pass
class B(D):
    # def bar(self):
    #     print('B.bar')
    pass
class A(B, C):
    # def bar(self):
    #     print('A.bar')
    pass

a = A()
a.bar()
# 执行bar方法时
# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
# 所以，查找顺序：A --> B --> C --> D
# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了

#上面我们可以看到最终的结果是报错：AttributeError: 'A' object has no attribute 'bar'；可依次调整查看结果是否与预期一致

 

总结：上面我们可以看出super与普通继承相比，公共类只被执行了一次，这一点在多重继承时体现的非常明显；

2.2.3 多态

多态是允许将父对象设置成为和一个或多个它的子对象相等的技术，比如Parent:=Child； 多态性使得能够利用同一类(基类)类型的指针来引用不同类的对象,以及根据所引用对象的不同,以不同的方式执行相同的操作.

python是一种动态语言，参数在传入之前是无法确定参数类型的,so python本身是不支持多态的，不过可以间接实现。

class Animal:
    def __init__(self, name):    
        self.name = name
    def talk(self):             
        raise NotImplementedError("Subclass must implement abstract method")
 
class Cat(Animal):
    def talk(self):
        return 'Meow!'
 
class Dog(Animal):
    def talk(self):
        return 'Woof! Woof!'
 
animals = [Cat('Missy'),
           Dog('Lassie')]
 
for animal in animals:
    print(animal.name + ': ' + animal.talk())

-----------------打印输出----------------------
Missy: Meow!
Lassie: Woof! Woof!