Python的平凡之路（6）

一、面向对象编程介绍

1 编程范式：

         编程范式（Programming Paradigm）是某种编程语言典型的编程风格或者说是编程方式。随着编程方法学和软件工程研究的深入，特别是OO思想的普及，范式（Paradigm）以及编程范式等术语渐渐出现在人们面前。面向对象编程（OOP）常常被誉为是一种革命性的思想，正因为它不同于其他的各种编程范式。编程范式也许是学习任何一门编程语言时要理解的最重要的术语。编程范式是编程语言的一种分类方式，它并不针对某种编程语言。就编程语言而言，一种编程语言也可以适用多种编程范式。  OO开发范式大致为：划分对象→抽象类→将类组织成为层次化结构(继承和合成) →用类与实例进行设计和实现几个阶段。 

 

2 面向过程：

     “面向过程”(Procedure Oriented)是一种以过程为中心的编程思想。“面向过程”也可称之为“面向记录”编程思想，他们不支持丰富的“面向对象”特性（比如继承、多态），并且它们不允许混合持久化状态和域逻辑。就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。面向过程其实是最为实际的一种思考方式,就算是面向对象的方法也是含有面向过程的思想.可以说面向过程是一种基础的方法.它考虑的是实际地实现.一般的面向过程是从上往下步步求精.所以面向过程最重要的是模块化的思想方法.对比面向过程,面向对象的方法主要是把事物给对象化,对象包括属性与行为.当程序规模不是很大时,面向过程的方法还会体现出一种优势,因为程序的流程很清楚,按着模块与函数的方法可以很好的组织.

 

3 面向对象（oop）：

        面向对象编程（Object Oriented Programming，OOP，面向对象程序设计）是一种计算机编程架构。OOP 的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象组合而成。OOP 达到了软件工程的三个主要目标：重用性、灵活性和扩展性。为了实现整体运算，每个对象都能够接收信息、处理数据和向其它对象发送信息。    

 

 

二、面向对象的好处

        面向对象出现以前，结构化程序设计是程序设计的主流，结构化程序设计又称为面向过程的程序设计。在面向过程程序设计中，问题被看作一系列需要完成的任务，函数（在此泛指例程、函数、过程）用于完成这些任务，解决问题的焦点集中于函数。其中函数是面向过程的，即它关注如何根据规定的条件完成指定的任务。

在多函数程序中，许多重要的数据被放置在全局数据区，这样它们可以被所有的函数访问。每个函数都可以具有它们自己的局部数据。

这种结构很容易造成全局数据在无意中被其他函数改动，因而程序的正确性不易保证。面向对象程序设计的出发点之一就是弥补面向过程程序设计中的一些缺点：对象是程序的基本元素，它将数据和操作紧密地连结在一起，并保护数据不会被外界的函数意外地改变。

比较面向对象程序设计和面向过程程序设计，还可以得到面向对象程序设计的其他优点：

1）数据抽象的概念可以在保持外部接口不变的情况下改变内部实现，从而减少甚至避免对外界的干扰；

2）通过继承大幅减少冗余的代码，并可以方便地扩展现有代码，提高编码效率，也减低了出错概率，降低软件维护的难度；

3）结合面向对象分析、面向对象设计，允许将问题域中的对象直接映射到程序中，减少软件开发过程中中间环节的转换过程；

4）通过对对象的辨别、划分可以将软件系统分割为若干相对为独立的部分，在一定程度上更便于控制软件复杂度；

5）以对象为中心的设计可以帮助开发人员从静态（属性）和动态（方法）两个方面把握问题，从而更好地实现系统；

6）通过对象的聚合、联合可以在保证封装与抽象的原则下实现对象在内在结构以及外在功能上的扩充，从而实现对象由低到高的升级。

 

 

三、面向对象的三大特性：

1、封装

 封装（有时也被称为信息隐藏）就是把数据和行为结合在一个包中，并对对象的使用者隐藏数据的实现过程。信息隐藏是面向对象编程的基本原则，而封装是实现这一原则的一种方式。 封装使对象呈现出“黑盒子”特性，这是对象再利用和实现可靠性的关键步骤。 

2、继承

    继承的思想就是允许在已存在类的基础上构建新的类。一个子类能够继承父类的所有成员，包括属性和方法。

    继承的主要作用：通过实现继承完成代码重用；通过接口继承完成代码被重用。继承是一种规范的技巧，而不是一种实现的技巧。

    继承概念的实现方式有三类：实现继承、接口继承和可视继承。

Ø         实现继承是指使用基类的属性和方法而无需额外编码的能力；

Ø         接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；

Ø         可视继承是指子窗体（类）使用基窗体（类）的外观和实现代码的能力。

3、多态

    多态提供了“接口与实现分离”。多态不但能改善程序的组织架构及可读性，更利于开发出“可扩充”的程序。 继承是多态的基础。多态是继承的目的。 合理的运用基于类继承的多态、基于接口继承的多态和基于模版的多态，能增强程序的简洁性、灵活性、可维护性、可重用性和可扩展性。 Pyhon不直接支持多态，但可以间接实现。封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。

 

 

四、面向对象的重要概念

1、对象（方法）

     世间万事万物都是对象。 面向对象的程序设计的抽象机制是将待解问题抽象为面向对象的程序中的对象。利用封装使每个对象都拥有个体的身份。程序便是成堆的对象，彼此通过消息的传递，请求其它对象 进行工作。 

2、类

 每个对象都是其类中的一个实体。 物以类聚——就是说明：类是相似对象的集合。类中的对象可以接受相同的消息。换句话说：类包含和描述了“具有共同特性（数据元素）和共同行为（功能）”的一组对象。 比如：苹果、梨、橘子等等对象都属于水果类。 

3、方法

     方法决定了某个对象究竟能够接受什么样的消息。面向对象的设计有时也会简单地归纳为“将消息发送给对象”。

4、接口

     每个对象都有接口。接口不是类，而是对符合接口需求的类所作的一套规范。接口说明类应该做什么但不指定如何作的方法。一个类可以有一个或多个接口。 

5、构造函数

     用于初始化类的内容部状态，Python提供的构造函数式 __init__();

__init__()方法是可选的，如果不提供，Python 会给出默认的__init__方法

一般数据的获取需要定义的get和set方法 。如果某类里没有__init__方法函数，通过类名字创建的实例对象为空，切没有初始化；

如果有此方法函数，通常作为类的第一个方法函数，有点像C++等语言里的构造函数。

——————————————————————————————————————

class Ca:

        def __init__(self, v): # 注意前后各两个下划线

                self.name = v

        def pr(self):

                print "a--->", self.name

ia = Ca("Jeapedu") # 本质调用的是__init__方法函数

ia.pr()

Ca.pr(ia)

——————————————————————————————————————

输出结果

a---> Jeapedu

a---> Jeapedu

6、析构函数

      用于释放对象占用的资源，Python 提供的析构函数式__del__();

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

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

del对象名

7、私有方法、私有属性

      python默认的成员函数和成员变量都是公开的，并且没有类似别的语言的public,private等关键词来修饰。 在python中定义私有变量只需要在变量名或函数名前加上 "__"两个下划线，那么这个函数或变量就会为私有的了。 在内部，python使用一种 name mangling 技术，将 __membername替换成 _classname__membername，所以你在外部使用原来的私有成员的名字时，会提示找不到。 比如：

#!/usr/bin/env python
#Author is wspikh
# -*- coding: encoding -*-
class Person(object):

def __init__(self):
       self.__name = 'haha'#私有属性
       self.age = 22

def __get_name(self,old):##私有方法
       #return self.__name
       print("%s 是种表情,和心情无关,但是到了%d的年龄就可以!" %(self.__name,old))

def pos(self):
       self.__get_name(55)

def get_age(self):
       return self.age #返回特定的值

person = Person() #实例化
print(person.get_age()) #打印特定的值
#print(person.__get_name()) #报错,私有的不能访问
person.pos() #直接调用pos()方法

 

运行结果是：

22

haha 是种表情,和心情无关,但是到了55的年龄就可以!

我们这里定义的__name是私有属性，__get_name()是私有方法。如果直接访问的话，会提示找不到相关的属性或者方法，但是如果你真要访问私有的相关数据的话， 也是可以访问的，严格地说，私有方法在它们的类外是可以访问的，只是不容易处理。在 Python 中没有什么是真正私有的；在内部，私有方法和属性的名字被忽然改变和恢复，以致于使得它们看上去用它们给定的名字是无法使用的

8、类变量、实例变量

       类变量：是可在类的所有实例之间共享的值（也就是说，它们不是单独分配给每个实例的）。例如下例中，num_of_instance 就是类变量，用于跟踪存在着多少个Test 的实例。

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

#测试类变量和实例变量

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('jack')
     print(Test.num_of_instance)
     t2 = Test('lucy')
     print(t1.name , t1.num_of_instance)

     print(t2.name , t2.num_of_instance)

结果如下：

0

1

jack 2

lucy 2

 

 

五、补充：

1、“只要是对象，肯定有品类，只要是对象，肯定有属性”

2、“实例化也就是初始化一个类，造了一个对象。即把一个类变成一个具体对象的过程”

3、“类变量是类中公用的属性，节省开销。“

4、”析构函数是在实例、销毁的时候执行的，通常用于做一些收尾工作，如关闭一些数据库连接，打开的临时文件

5、继承例子：#!/usr/bin/env python

#Author is wspikh
# -*- coding: encoding -*-
class School(object):
    def __init__(self,name,addr):
        self.name =name
        self.addr = addr
        self.student_list = []
        self.staff_list =[]

    def enroll(self,stu_obj):
        print("为学员%s办理注册手续"%stu_obj.name)
        self.student_list.append(stu_obj)

    def hire(self,stuff_obj):
        self.staff_list.append(stuff_obj)
        print("雇佣新员工%s"%stuff_obj.name)

class SchoolMember(object):
    def __init__(self,name,age,sex):
        self.name = name
        self.age =age
        self.sex = sex

    def tell(self):
        pass

class Teacher(SchoolMember):
    def __init__(self,name,age,sex,salary,course):
        super(Teacher,self).__init__(name,age,sex)
        self.salary = salary
        self.course = course

    def tell(self):
        pass

    def tech(self):
        print("%s is teaching course [%s]" %(self.name,self.course))

class Student(SchoolMember):
    def __init__(self, name, age, sex, stu_id, grade):
        super(Student, self).__init__(name, age, sex)
        self.stu_id = stu_id
        self.grade = grade

    def tell(self):
        print('''
        --------info of student %s
        Name：%s
        Age: %s
        Sex: %s
        Stu_id：%s
        Grade:%s
        ''' % (self.name, self.name, self.age, self.sex, self.stu_id, self.grade))

    def pay_tuition(self, amonut):
        print("%s has paid tuition for %s" % (self.name, amonut))

school= School("老男孩IT","沙河")

t1 = Teacher("Oldboy",56,"MF",2000000,"Linux")
t2 = Teacher("Alex",22,"M",3000,"PythonDevops")
s1 = Student("ChenRonghua",36,"MF",1001,"PythonDevops")
s2 = Student("xuliangwei",19,"M",1002,"Linux")

t1.tech()
t2.tech()
s1.tell()
s2.tell()
s1.pay_tuition(5000)
s2.pay_tuition(3000)
school.hire(t1)
school.hire(t2)
school.enroll(s1)
school.enroll(s2)

6、多态

#!/usr/bin/env python

#Author is wspikh
# -*- coding: encoding -*-
class Animal:
    def __init__(self,name):
        self.name = name
    def talk(slef):
        raise NotImplementedError("Subclass must implement abstract method")

class Cat(Animal):
    def talk(slef):
        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())

六、思考：

1 子类要增加一个变量，必须要引用父类的构造函数，譬如

def cs(object):

       def __init__(self,name,age)

       # print(“This is fuel”) 

def cos (cs):

       def __init__(self,name,age,hobby)

             cs.__init__(self,name,age)

             #print(“This is zilei”)

cos1 = cos(“x”,18,money)

print(cos1.hobby)

2 广度优先 （Python3)

   py2  经典类深度优先 新式类广度优先

   py3  经典类和新式类都是广度优先

3 多态：一个接口，重用