Python自动化开发学习的第六周------面向对象学习

1.面向过程 VS 面向对象

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

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

面向过程编程（Procedural Programming）

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

　　这样做的问题也是显而易见的，就是如果你要对程序进行修改，对你修改的那部分有依赖的各个部分你都也要跟着修改， 举个例子，如果程序开头你设置了一个变量值 为1 ， 但如果其它子过程依赖这个值 为1的变量才能正常运行，那如果你改了这个变量，那这个子过程你也要修改，假如又有一个其它子程序依赖这个子过程 ， 那就会发生一连串的影响，随着程序越来越大， 这种编程方式的维护难度会越来越高。 
　　所以我们一般认为， 如果你只是写一些简单的脚本，去做一些一次性任务，用面向过程的方式是极好的，但如果你要处理的任务是复杂的，且需要不断迭代和维护 的， 那还是用面向对象最方便了。

面向对象编程（object-oriented programming）

　　面向对象编程是利用“类”和“对象”来创建各种模型来实现对真实世界的描述，使用面向对象编程的原因一方面是因为它可以使程序的维护和扩展变得更简单，并且可以大大提高程序开发效率 ，另外，基于面向对象的程序可以使它人更加容易理解你的代码逻辑，从而使团队开发变得更从容。

2.汽水与类

这一章我们将会使用汽水讲解关于类的概念，实际上编程中的概念都可以在显示生活中找到很好的例子进行对照理解的，为了加强理解，你最好出去买瓶汽水，然后开始学习！

定义一个类

正如“类”的名称一样，它描述的概念和我们现实生活中的类的概念很相似。生物有不同种类，食物有不同种类，人类社会的种种商品也有不同的种类。但是可被称为一类的物体，他们都是有着相似的特性和行为方式。也就是说，类是有一些系列有共同特征和行为事物的抽象概念的总和。

对于汽水来说，相同品牌的汽水，它们有着相同的成分，称之为“配方”。工厂进行批量生产时遵循同一标准，正是因为有着相同的配方，所有的汽水才能一个口味。我们用python的类来表达这个事

class Soda(object):
    formula = ["water","sugar"]

 我们使用class定义一个类，就如同创建一个函数时使用def定义一个函数一样简单。第二行是一个被赋值为变量formula的列表，在类里面赋值的变量就是类的变量，我们叫做类的属性（Class Atrribute）

类的变量与我们接触到的变量没有什么区别的，既然字符串，列表，字典，整数等等都可以是变量，那么它们当然都可以成为类的属性

接下来我们按照定义好的配方生产汽水，按照这个配方生产出来的汽水味道都是一样的

class Soda(object):
    formula = ["water","sugar"]

soda_to_me = Soda()
soda_to_you = Soda()

print(Soda.formula)
print(soda_to_me.formula)
print(soda_to_you.formula)

运行结果：
['water', 'sugar']
['water', 'sugar']
['water', 'sugar']

 左边我们创建一个变量，右边写上类的名称，这样看起来很像是赋值的行为，我们称为类的实例化。而被实例化后的对象，我们称为实例，或者是类的实例。

按照配方把汽水生产出来的过程就是实例化的过程

类属性的引用

在类的名字后面加上".",IDE就会自动联想出我们之前在定义类的时候写进去的属性，这就是类属性的引用（attribute references）

类的属性会被所有类的实例共享，所以你在类的实例后面再加上“.”,索引用的属性值是完全一样的

print(Soda.formula)
print(soda_to_me.formula)
print(soda_to_you.formula)

运行结果：
['water', 'sugar']
['water', 'sugar']
['water', 'sugar']

 上面的代码告诉我们，“告诉我汽水的配方”和“告诉我你手中汽水的配方”，结果是一样的

类的属性与正常的变量并没有区别，如下代码：

for element in soda_to_me.formula:
    print(element)

运行结果：
water
sugar

实例属性

不同的地方，为了适应当地的语言和习惯，汽水的叫法也不一样，在外国汽水叫可乐

class Soda(object):
    formula = ["water","sugar"]

coke_for_usa = Soda()
coke_for_usa.local_logo = "可乐"

print(coke_for_usa.local_logo)

运行结果：
可乐

 上面的代码，我们在创建类之后，通过object.new_attr 的形式进行一个赋值，于是我们得到一个新的实例的变量，实例的变量就是实例变量，我们称为实例属性

实例方法

方法是供实例使用的，所有我们可以称类的实例为实例方法

当你和一瓶汽水是，你会从汽水中获取到大量的能量，如果使用类来表示这个“功能”，就是这样的：

class Soda(object):
    formula = ["water","sugar"]
    def drink(self):
        print("Energy!!")

coke = Soda()
coke.drink()

运行结果：
Energy!!

 self？  我知道你现在关注一定在这个地方，似乎self没有什么用处。我们来修改下代码，在来看看

class Soda(object):
    formula = ["water","sugar"]
    def drink(coke):
        print("Energy!!")

coke = Soda()
coke.drink()

运行结果：
Energy!!

 是不是找到问题了？ 其实这个self参数就是被创建的实例本身

也就是说一个类一旦被实例化，那么其实我们可以使用和我们用的函数相似的方式：

coke = Soda
coke.drink() == Soda.drink(coke)

 被实例化的对象会被编译器默默地传入到后面的方法的括号内，作为第一个参数。上面的这两种方法是一样的，但是我们更多的会写在前面的那种形式。其实self这个参数名称是可以随便更改的。但是按照python的规矩，我们还是使用self

和函数一样，类的方法也能有属于自己的参数，我们在drink上做些改动：

class Soda(object):
    formula = ["water","sugar"]
    def drink(self,how_much):
        if how_much == "a sip":
            print("cool!!")
        if how_much == "whole bottle":
            print("headache")


ice_coke = Soda()
ice_coke.drink("a sip")
运行结果：
cool！！

类的方法的初始化

python中存在一些方法，其中__init__就是其中一个，它的神奇之处在于，如果你在类中定义了它，在创建实例的时候它能帮你自动处理很多事情，比如新增实例属性。在上面的代码中，我们创建了一个实例属性，但是那是在定义完类之后做的。

其实__init__是initialize（初始化）的缩写，这就意味着即使我们在创建实例的时候不去引用init（）的方法，其中的命令也会先被自动执行。

class Soda(object):
    formula = ["water","sugar"]
    def __init__(self):
        self.local_logo = "可乐"

    def drink(self):
        print("Energy!!")


coke = Soda()
print(coke.local_logo)

除了必须写的self的参数之外，__init__（）同样可以有自己的参数，同时也不需要这样的obj.__init__()的方式来调用（因为是自动执行）而是在实例化的时候往类的后面的括号内放入参数，相应的所有参数会自动传递到这个特殊的__init__()方法中，和函数的参数方法完全相同

class Soda(object):
    formula = ["water","sugar"]
    def __init__(self,name):
        self.name = name

    def drink(self):
        print("Energy!!")


coke = Soda("可乐")
print(coke.name)
>>>可乐

self.name = name 左边的是变量作为类的属性，右边的是传入这个参数作为变量，也就是说这个变量的赋值所存储的结果将取决于初始化的时候所传进来的参数，传进来什么那么它就将是什么

3.面向对象的特性

封装

封装是面向对象的特征之一，是对象和类概念的主要特性。

封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

继承

面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

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

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

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

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

在某些 OOP 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。先继承在构造！！！

继承概念的实现方式主要有2类：实现继承、接口继承。

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

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

在考虑使用继承时，有一点需要注意，那就是两个类之间的关系应该是“属于”关系。例如，Employee 是一个人，Manager 也是一个人，因此这两个类都可以继承 Person 类。但是 Leg 类却不能继承 Person 类，因为腿并不是一个人。

 

抽象类仅定义将由子类创建的一般属性和方法。

OO开发范式大致为：划分对象→抽象类→将类组织成为层次化结构(继承和合成) →用类与实例进行设计和实现几个阶段。

class SchoolMember(object):
    members = 0 #初始学校人数为0
    def __init__(self,name,age):
        self.name = name
        self.age = age
 
    def  tell(self):
        pass
 
    def enroll(self):
        '''注册'''
        SchoolMember.members +=1
        print("33[32;1mnew member [%s] is enrolled,now there are [%s] members.33[0m " %(self.name,SchoolMember.members))
     
    def __del__(self):
        '''析构方法'''
        print("33[31;1mmember [%s] is dead!33[0m" %self.name)
class Teacher(SchoolMember):
    def __init__(self,name,age,course,salary):
        super(Teacher,self).__init__(name,age)
        self.course = course
        self.salary = salary
        self.enroll()
 
 
    def teaching(self):
        '''讲课方法'''
        print("Teacher [%s] is teaching [%s] for class [%s]" %(self.name,self.course,'s12'))
 
    def tell(self):
        '''自我介绍方法'''
        msg = '''Hi, my name is [%s], works for [%s] as a [%s] teacher !''' %(self.name,'Oldboy', self.course)
        print(msg)
 
class Student(SchoolMember):
    def __init__(self, name,age,grade,sid):
        super(Student,self).__init__(name,age)
        self.grade = grade
        self.sid = sid
        self.enroll()
 
 
    def tell(self):
        '''自我介绍方法'''
        msg = '''Hi, my name is [%s], I'm studying [%s] in [%s]!''' %(self.name, self.grade,'Oldboy')
        print(msg)
 
if __name__ == '__main__':
    t1 = Teacher("Alex",22,'Python',20000)
    t2 = Teacher("TengLan",29,'Linux',3000)
 
    s1 = Student("Qinghua", 24,"Python S12",1483)
    s2 = Student("SanJiang", 26,"Python S12",1484)
 
    t1.teaching()
    t2.teaching()
    t1.tell()

　　

多态

多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。

那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。

 

Pyhon 很多语法都是支持多态的，比如 len(),sorted(), 你给len传字符串就返回字符串的长度，传列表就返回列表长度。

class Animal(object):
    def __init__(self, name):  # Constructor of the class
        self.name = name
 
    def talk(self):              # Abstract method, defined by convention only
        raise NotImplementedError("Subclass must implement abstract method")
 
 
class Cat(Animal):
    def talk(self):
        print('%s: 喵喵喵!' %self.name)
 
 
class Dog(Animal):
    def talk(self):
        print('%s: 汪！汪！汪！' %self.name)
 
 
 
def func(obj): #一个接口，多种形态
    obj.talk()
 
c1 = Cat('小晴')
d1 = Dog('李磊')
 
func(c1)
func(d1)