面向对象的程序设计

• 真实世界的对象

 特征：状态和行为
 比如：猫
     状态：名字，颜色，品种
     行为：喵叫，摇尾巴，捉老鼠
 真实世界对象
     这个对象有怎样的状态
     这个对象具有什么行为
 台灯
     状态：开，关
     行为：打开，关闭
 台式收音机
    状态：开，关，当前音量，当前频道
    行为：打开，关闭，增加音量，减少音量，搜索，扫描和调音

• 类：某种类型集合的描述，举例：人

 属性
     类本身的一些特征，如名字，身高和体重等属性
 方法：
     类所能实现的行为，如吃饭，走路和睡觉等方法

• 类定义解析：

class ClassName:  
    block     

注意类名后面有个冒号，并且类名第一个字母要大写，在block块里面就可以定义属性和方法了。当一个类定义完之后，就产生了一个类对象。类对象支持两种操作：引用和实例化。引用操作是通过类对象去调用类中的属性或者方法，而实例化是产生出一个类对象的实例，称作实例对象。比如定义了一个people类：

class   People:  
    #定义一个属性  
    name = 'jack'       
    #定义一个方法  
    def printName(self):  
        print(self.name)  

1.People类定义完成之后就产生了一个全局的类对象，可以通过类对象来访问类中的属性和方法了。
2.当通过People.name（至于为什么可以直接这样访问属性后面再解释，这里只要理解类对象这个概念就行了）来访问时，people.name中的people称为类对象，这点和C++中的有所不同。
3.当然还可以进行实例化操作，方法为p=People()，这样就产生了一个People的实例对象，此时也可以通过实例对象p来访问属性或者方法了(p.name).

• 理解了类、类对象和实例对象的区别之后，我们来了解一下Python中属性、方法和函数的区别。

1.在上面代码中注释的很清楚了，name是一个属性，printName()是一个方法，与某个对象进行绑定的函数称作为方法。

2.一般在类里面定义的函数与类对象或者实例对象绑定了，所以称作为方法；而在类外定义的函数一般没有同对象进行绑定，就称为函数。

• 类中内置的方法

在Python中有一些内置的方法，这些方法命名都有比较特殊的地方（其方法名以2个下划线开始然后以2个下划线结束）。类中最常用的就是构造方法和析构方法。

class classname[(父类]名)]:[成员函数及成员变量]
 __init__构造函数：初始化对象的各属性
     在生成对象时调用，可以用来进行一些初始化操作，不需要显示去调用，系统会默认去执行。构造方法支持重载，如果用户自己没有重新定义构造方法，系统就自动执行默认的构造方法。
 __del__析构函数：销毁对象
     在释放对象时调用，支持重载，可以在里面进行一些释放资源的操作，不需要显示调用。

• 还有其他的一些内置方法，比如 cmp( ), len( )等。下面是常用的内置方法：

__init__():__init__方法在类的一个对象被建立时，马上运行。这个方法可以用来对你的对象做一些你希望的初始化

注意，这个名称的开始和结尾都是双下划线。

• 代码例子1:

# Filename: class_init.py  
class Person:  
    def __init__(self, name):  
        self.name = name  
    def sayHi(self):  
        print('Hello, my name is', self.name)
#实例化
p = Person('init')
#调用方法
p.sayHi() 

• 输出： Hello, my name is init
• 代码例子2：

class Movie(object):

def __init__(self,name,length):
    self.name = name
    self.length = length

def print_name(self):
    print '电影的名称是:%s' % (self.name,)

实例执行情况：

>>> movie = Movie('大圣归来',90)
大圣归来
>>> print(movie.length
90

• class Movie(object): 是固定写法，class表明正在声明的是一个类，Movie是类名，（object）表示继承自那些父类，就像java一样，所有的类都是继承自object类的，所以如果你写的不继承自其他的类就将其写成继承自object，当继承自object，括号连同括号里的object都可以省略写成：class Movie:

• 第一个方法init是构造方法，构造方法的第一个参数永远是self，表示这个类的对象本身，真正构造对象时，self这个参数不用写，python编译器会自己加上去，构造方法的作用就是对self对象进行赋值，如上面的将电影的名字和长度赋给self。

对于上面的Movie类我们可以用下面的代码来调用它：

#不继承任何类,就继承object类
class Movie:

def __init__(self,name,length):
    self.name = name
    self.length = length

def print_name(self):
    print ('电影的名称是:%s' % (self.name,))

• 有了init方法，在创建实例的时候，就不能传入空的参数了，必须传入与init方法匹配的参数，但self不需要传，Python解释器自己会把实例变量传进去：

>>> movie = Movie('大圣归来',90)
大圣归来

>>> print(movie.length
90

和普通的函数相比，在类中定义的函数只有一点不同，就是第一个参数永远是实例变量self，并且，调用时，不用传递该参数。除此之外，类的方法和普通函数没有什么区别，所以，你仍然可以用默认参数、可变参数、关键字参数和命名关键字参数。

__new__():__new__()在__init__()之前被调用，用于生成实例对象。利用这个方法和类属性的特性可以实现设计模式中的单例模式。单例模式是指创建唯一对象吗，单例模式设计的类只能实例化一个对象。

• 代码如下：

class Singleton(object):  
    __instance = None                       # 定义实例  
  
    def __init__(self):  
        pass  
  
    def __new__(cls, *args, **kwd):         # 在__init__之前调用  
        if Singleton.__instance is None:    # 生成唯一实例  
            Singleton.__instance = object.__new__(cls, *args, **kwd)  
        return Singleton.__instance  

__getattr__()、__setattr__()和__getattribute__():当读取对象的某个属性时，python会自动调用__getattr__()方法。例如，fruit.color将转换为fruit.__getattr__(color)。当使用赋值语句对属性进行设置时，python会自动调用__setattr__()方法。__getattribute__()的功能与__getattr__()类似，用于获取属性的值。但是__getattribute__()能提供更好的控制，代码更健壮。注意，python中并不存在__setattribute__()方法。

代码例子：

class Fruit(object):  
    def __init__(self, color="red", price=0):  
        self.__color = color  
        self.__price = price  
  
    def __getattribute__(self, item):              # <span style="font-family:宋体;font-size:12px;">获取属性的方法</span>  
        return object.__getattribute__(self, item)  
  
    def __setattr__(self, key, value):  
        self.__dict__[key] = value  
  
if __name__ == "__main__":  
    fruit = Fruit("blue", 10)  
    print fruit.__dict__.get("_Fruit__color")    # <span style="font-family:宋体;font-size:12px;">获取color属性</span>  
    fruit.__dict__["_Fruit__price"] = 5  
    print (fruit.__dict__.get("_Fruit__price") )   # <span style="font-family:宋体;font-size:12px;">获取price属性</span> 
    
    
#输出
blue
5

Python不允许实例化的类访问私有数据，但你可以使用object._className__attrName访问这些私有属性。

__getitem__():如果类把某个属性定义为序列，可以使用__getitem__()输出序列属性中的某个元素.假设水果店中销售多钟水果，可以通过__getitem__()方法获取水果店中的没种水果。

• 代码例子：

class FruitShop:  
 def __getitem__(self, i):      # 获取水果店的水果  
     return self.fruits[i]        

if __name__ == "__main__":  
    shop = FruitShop()  
    shop.fruits = ["apple", "banana"]  
    print shop[1]  
    for item in shop:               # 输出水果店的水果  
        print(item),
#输出
banana
apple
banana

__str__():__str__()用于表示对象代表的含义，返回一个字符串.实现了__str__()方法后，可以直接使用print语句输出对象，也可以通过函数str()触发__str__()的执行。这样就把对象和字符串关联起来，便于某些程序的实现，可以用这个字符串来表示某个类。

• 代码例子：

class Fruit:       
'''''Fruit类'''               #为Fruit类定义了文档字符串  
def __str__(self):          # 定义对象的字符串表示  
    return self.__doc__  

if __name__ == "__main__":  
    fruit = Fruit()  
    print (str(fruit) )          # 调用内置函数str()触发__str__()方法，输出结果为:Fruit类  
    print( fruit )                #直接输出对象fruit,返回__str__()方法的值，输出结果为:Fruit类 
#输出
''Fruit类
''Fruit类

__call__():在类中实现__call__()方法，可以在对象创建时直接返回__call__()的内容。使用该方法可以模拟静态方法。

• 代码例子:

class Fruit:  
class Growth:        # 内部类  
    def __call__(self):  
        print ("grow ...")  

grow = Growth()      # 调用Growth()，此时将类Growth作为函数返回,即为外部类Fruit定义方法grow(),grow()将执行__call__()内的代码  
if __name__ == '__main__':  
    fruit = Fruit()  
    fruit.grow()         # 输出结果：grow ...  
    Fruit.grow()         # 输出结果：grow ...
#输出
grow ...
grow ...

举例1：GPA计算

 学生课程评估：学分和平均绩点GPA
 绩点计算以GPA 4分为准则
      一门课程3学分
      同学得了 “A”
      3*4=12量分数

GPA计算以4分为准则，学生的成绩是“A”（即4点），“B”（即3点），“Ｃ”（即２点），“D”（即1点），“E”（即0点），GPA的计算如下：

在申请入学时,很多学校有GPA规定。GPA的计算为：
1.每个科目点数乘以学分。比如微积分是4分的课，成绩是A（即4点），微积分一科可以得16点
2.如果一学期修了4门课，英文3学分（成绩4点），历史3学分（成绩2点）物理3学分（成绩3点），加上微积分。

GPA是16+4x3+3x2+3x3 = 43,43/13 = 3.31

• GPA=(所有科目的总点数)/(总学分)。
  记录学生成绩的文件包含多个学生的记录，每个记录为一行，包括该学生的姓名，总学分和量分数（即所有科目的总点数），学生成绩表如下：

  
  
  image.png

记录学生成绩文件students.txt.编写程序，通过读取文件找出平均绩点最高的学生，然后输出他的名字，学分和平均绩点。

• 定义Student类

 class Student:
    def __init__(self,name,hours, qpoints):
        self.name = name
        self.hours = float(hours)
        self.qpoints = float(qpoints)
        
    def getName(self):
        return self.name
    
    def getHouse(self):
        return self.hours
        
    def getQPoints(self):
         return self.qpoints

    def gpa(self):
        return self.gpoints/self.hours

• GPU算法描述为

获取文件名
打开文件
设置第一个学生为best
对文件中的每一个学生
    
    if s.gpa()>best.gpa()
        设置s为best
        
打印best学生的信息

代码执行：

#定义Student类
class Student:
    #初始化
    def __init__(self,name,hours, qpoints):
        self.name = name
        self.hours = float(hours)
        self.qpoints = float(qpoints)
    #方法1：返回名字   
    def getName(self):
        return self.name
    #方法2：返回分数
    def getHouse(self):
        return self.hours
    #方法3：返回   
    def getQPoints(self):
         return self.qpoints

    def gpa(self):
        return self.qpoints/self.hours
    
    def makeStudent(infoString):
            name,scores,qpoints=infoString.split()
            return Student(name,scores,qpoints)



# 主函数
def main():
    #打开输入文件
    fileName=input('Enter name of the grade file:')
    f=open(fileName,'r')
    #设置文件中第一个学生为best
    best= makeStudent(f.readline())
    #处理文件中剩余的行数据
    for line in f:
        #将文件中的每一行数据转换为一个学生对象
        s= makeStudent(line)
        #如果该学生是目前GPA最高的，则记录下来
        if s.gpa()>best.gpa():
            best=s
    f.close()
    #打印GPA成绩最高的学生信息
    print('The best student is:',best.getName())
    print('scores:',best.getHouse())
    print('GPA:',best.gpa())
if __name__ =="__main__":
    main()
    
    
# 执行结果：
Enter name of the grade file:C:\Users\Administrator\Desktop\exercise\python_learning\面向对象\students.txt
The best student is: 李四
scores: 100.0
GPA: 4.0

举例2:铅球飞行轨迹计算

 铅球对象属性
     xpos
     ypos
     xvel
     Yvel
 构建投射体类Projectile
 创建和更新对象的变量

• 主函数

def main():
    angle,vel,h0,time = getInputs()
    shot = Projectile(angle,vel,h0)
    while shot.getY() >=0:
        shot.updata(time)
    print("\nDistance traveled:{0:0.1f}meters.".format(shot.getX()))
    
    
    
    
    
    
    
#Projectile类
from math import sin,cos,radians

class Projectile:

    def __init__(self, angle, velocity, height):
        #根据给定的发射角度，初始速度和位置创建一个投射体对象
        self.xpos = 0.0
        self.ypos = height
        theta = radians(angle)
        self.xvel = velocity * cos(theat)
        self.yvel = velocity * sin(theta)
    

    
    def getXYComponents(vel,angle):
        theta = radians(angle)
        xvel = vel * cos(theta)
        yvel = vel * sin(theta)
        return xvel, yvel
        
    def updatPosition(time, xpos,ypos,xvel,yvel):
        xpos = xpos + time * xvel
        yvell = yvel - time * 9.8
        ypos = ypos + time * (yvel + yvell) / 2.0
        yvel = yvell
        return xpos, ypos,yvel

• 引入对象，程序模块化

from Projectile import *

def getInputs():
    angle = eval(input("Enter the launch angle (in degrees):"))
    vel = eval(input("Enter the initial velocity (in meters/sec):"))
    h0 = eval(input("Enter the initial height (in meters):"))
    time = eval(input("Enter the time interval:"))
    return angle,vel,h0,time

def main():
    angle,vel,h0,time = getInputs()
    shot = Projectile(angle,vel,h0)
    while ypos >= 0:
        xpos, ypos, yvel = updatPosition(time,xpos,ypos,xvel,yvel)
    print("\nDistance traveled:{0:0.1f}meters.".format(xpos))

所用代码在jupyter notebook中:

from math import sin,cos,radians
class Projectile:
    def __init__(self,angle,velocity,height):
        #根据给定的发射角度，初始速度和位置创建一个投射体对象
        self.xpos=0.0
        self.ypos=height
        theta=radians(angle)
        self.xvel=velocity*cos(theta)
        self.yvel=velocity*sin(theta)


    def update(self,time):
        #更新投射体的状态
        self.xpos=self.xpos+time*self.xvel
        yvel1=self.yvel-9.8*time
        self.ypos=self.ypos+time*(self.yvel+yvel1)/2.0
        self.yvel=yvel1


    def getY(self):
        #返回投射体的y轴坐标
        return self.ypos


    def getX(self):
        #返回投射体的x轴坐标（即水平距离）
        return self.xpos




def getInputs():
    a=eval(input('Enter the launch angle(in degrees):'))
    v=eval(input('Enter the initial velocity(in meters/sec):'))
    h=eval(input('Enter the initial height(in meters):'))
    t=eval(input('Enter the time interval:'))
    return a,v,h,t


def main():
    angle,vel,h0,time=getInputs()
    shot=Projectile(angle,vel,h0)
    while shot.getY()>=0:
        shot.update(time)
    print('\nDistance traveled:{0:0.1f} meters.'.format(shot.getX()))
 
输出结果：
Enter the launch angle(in degrees):41
Enter the initial velocity(in meters/sec):14
Enter the initial height(in meters):1.8
Enter the time interval:0.8

Distance traveled:25.4 meters.

面向对象的特点

• 封装

 从业务逻辑中抽象对象时，赋予对象相关数据与操作，把一些数据和操作打包在一起的过程就是**封装**
对象的实现和使用是独立的
 支持代码复用

• 举例：封装

 Projectile将投射体属性和方法封装在类的内部
 不必关心铅球内部如何实现
 Projectile类可以被多个程序，多个对象所使用

• 多态

 对象怎么回应一个依赖于对象类型或种类的消息
 在不同情况下用一个函数启用不同的方法
 灵活性

• 举例:多态

能够直接说明多态的两段示例代码如下：
　　
　　
　 1、方法多态

　　_metaclass_=type # 确定使用新式类  
    class calculator:  
        
        def count(self,args):  
            return 1  
      
    calc=calculator() #自定义类型  
      
    from random import choice  
    obj=choice(['hello,world',[1,2,3],calc]) #obj是随机返回的 类型不确定  
    print (type(obj) ) 
    print (obj.count('a')) #方法多态  

对于一个临时对象obj，它通过Python的随机函数取出来，不知道具体类型（是字符串、元组还是自定义类型），都可以调用count方法进行计算，至于count由谁（哪种类型）去做怎么去实现我们并不关心。

有一种称为”鸭子类型（duck typing）“的东西，讲的也是多态：

_metaclass_=type # 确定使用新式类  
class Duck:  
    def quack(self):   
        print ("Quaaaaaack!")  
    def feathers(self):   
        print ("The duck has white and gray feathers.")  
   
class Person:  
    def quack(self):  
        print ("The person imitates a duck." ) 
    def feathers(self):   
        print ("The person takes a feather from the ground and shows it." ) 
   
def in_the_forest(duck):  
    duck.quack()  
    duck.feathers()  
   
def game():  
    donald = Duck()  
    john = Person()  
    in_the_forest(donald)  
    in_the_forest(john)  
   
game() 

#输出
Quaaaaaack!
The duck has white and gray feathers.
The person imitates a duck.
The person takes a feather from the ground and shows it.

就in_the_forest函数而言，参数对象是一个鸭子类型，它实现了方法多态。但是实际上我们知道，从严格的抽象来讲，Person类型和Duck完全风马牛不相及。

2、运算符多态
def add(x,y):  
return x+y  

print (add(1,2)) #输出3  
  
print (add("hello,","world")) #输出hello,world  
  
print (add(1,"abc")) #抛出异常 

TypeError: unsupported operand type(s) for +: 'int' and 'str'

上例中，显而易见，Python的加法运算符是”多态“的，理论上，我们实现的add方法支持任意支持加法的对象，但是我们不用关心两个参数x和y具体是什么类型。
　　
Python同样支持运算符重载，实例如下：

class Vector:  
def __init__(self, a, b):  
  self.a = a  
  self.b = b  

def __str__(self):  
  return 'Vector (%d, %d)' % (self.a, self.b)  
 
def __add__(self,other):  
  return Vector(self.a + other.a, self.b + other.b)  

v1 = Vector(2,10)  
v2 = Vector(5,-2)  
print (v1 + v2)  
#输出：
Vector (7, 8)

一两个示例代码当然不能从根本上说明多态。普遍认为面向对象最有价值最被低估的特征其实是多态。

• 参考文献：

http://www.cnblogs.com/dolphin0520/archive/2013/03/29/2986924.html

http://www.cnblogs.com/jeffwongishandsome/archive/2012/10/06/2713258.html

• 继承

  在C++和Java中，使用继承时，子类的构造函数会自动调用父类的构造函数，但在Python中，子类必须显式的在init()函数中再次调用父类中的init()函数。如下例：

 一个类（subclass）可以借用另一个类(superclass)的行为
 避免重复操作
 提升代码复用程度


- 举例：继承


 员工信息系统
 Employee类 #包含所有员工通用一般信息
     Employee类属性raisesalary() #返回员工工资信息
 Employee子类：work()
     共享raisesalary() 属性
     自己work()属性
class Employee(object):  
    def __init__(self, name, salary = 0):  
        self.name = name  
        self.salary = salary  
    def raisesalary(self, percent):  
        self.salary = self.salary  * (1 + percent)  
    def work(self):  
        print (self.name, "writes computer code" ) 


子类Designer也可以使用super来进行初始化。

class Designer(Employee):  
    def __init__(self, name):  
        super(Designer, self).__init__(name, 5000)  
    def work(self):  
        print self.name, "writes design document"   

2.多继承

在C++中，使用虚继承来实现多继承，以避免子类在继承时多次调用基类的构造函数，而在Java中，则取消了多继承，使用接口来达到多继承的效果。在Python中的解决方案是MRO即Method Resolution Order，方法解析顺序。主要是通过super方法实现的。但如果用super方法来解决多继承问题，由于各个父类中的init()函数中参数的数量可能不同，那应该怎么初始化呢？如下例。

class A(object):  
    def __init__(self, a):  
        print a  
class B(object):  
    def __init__(self, a, b):  
        print a+b  
class C(A, B):  
    def __init__(self):  
        super(C,self).__init__(?)  
  
c = C()