python之面向对象编程浅谈

1.python中的类与对象

Python中定义类的方式比较简单：

class 类名：

类变量

def __init__(self,paramers):

def 函数(self,...)

…...

其中直接定义在类体中的变量叫类变量，而在类的方法中定义的变量叫实例变量。类的属性包括成员变量和方法，其中方法的定义和普通函数的定义非常类似，但方法必须以self作为第一个参数。

举例：

>>>class MyFirstTestClass:

class Spec="it is a test class"

def__init__(self,word):

print"say "+word

def hello(self,name):

print"hello "+name

 

在Python类中定义的方法通常有三种：实例方法，类方法以及静态方法。这三者之间的区别是实例方法一般都以self作为第一个参数，必须和具体的对象实例进行绑定才能访问，而类方法以cls作为第一个参数，cls表示类本身，定义时使用@classmethod；而静态方法不需要默认的任何参数,跟一般的普通函数类似.定义的时候使用@staticmethod。

>>>class MethodTest():

count= 0

defaddCount(self):

MethodTest.count+=1

print"I am an instance method,my count is"+str(MethodTest.count),self

@staticmethod

defstaticMethodAdd():

MethodTest.count+=1

print"I am a static methond,my count is"+str(MethodTest.count)

@classmethod

defclassMethodAdd(cls):

MethodTest.count+=1

print"I am a class method,my count is"+str(MethodTest.count),cls

 

>>>

>>>a=MethodTest()

>>>a.addCount()

Iam an instance method,my count is 1 <__main__.MethodTest instanceat 0x011EC990>

>>>MethodTest.addCount()

 

Traceback(most recent call last):

File"<pyshell#5>", line 1, in <module>

MethodTest.addCount()

TypeError:unbound method addCount() must be called with MethodTest instance asfirst argument (got nothing instead)

>>>a.staticMethodAdd()

Iam a static methond,my count is2

>>>MethodTest.staticMethodAdd()

Iam a static methond,my count is3

>>>a.classMethodAdd()

Iam a class method,my count is4 __main__.MethodTest

>>>MethodTest.classMethodAdd()

Iam a class method,my count is5 __main__.MethodTest

从上面的例子来看，静态方法和类方法基本上区别不大，特别是有Java编程基础的人会简单的认为静态方法和类方法就是一回事，可是在Python中事实是这样的吗？看下面的例子：

>>>MethodTest.classMethodAdd()

Iam a class method,my count is5 __main__.MethodTest

>>>class subMethodTest(MethodTest):

pass

>>>b=subMethodTest()

>>>b.staticMethodAdd()

Iam a static methond,my count is6

>>>b.classMethodAdd()

Iam a class method,my count is7 __main__.subMethodTest

>>>a.classMethodAdd()

Iam a class method,my count is8 __main__.MethodTest

>>>

如果父类中定义有静态方法a(),在子类中没有覆盖该方法的话，Sub.a()仍然指的是父类的a（）方法。而如果a()是类方法的情况下，Sub.a()指向的是子类。@staticmethod只适用于不想定义全局函数的情况。

2.python的封装

面向对象程序设计中的术语对象（Object）基本上可以看做数据（特性）以及由一系列可以存取、操作这些数据的方法所组成的集合。传统意义上的“程序=数据结构+算法”被封装”掩盖“并简化为“程序=对象+消息”。对象是类的实例，类的抽象则需要经过封装。封装可以让调用者不用关心对象是如何构建的而直接进行使用。

一个简单的Python类封装如下：

_metaclass_=type # 确定使用新式类
class Animal:

    def __init__(self): #构造方法 一个对象创建后会立即调用此方法
        self.Name="Doraemon"
        print self.Name
      
    def accessibleMethod(self): #绑定方法 对外公开
        print "I have a self! current name is:"
        print self.Name
        print "the secret message is:"
        self.__inaccessible()
        
    def __inaccessible(self): #私有方法 对外不公开 以双下划线开头
        print "U cannot see me..."

    @staticmethod
    def staticMethod():
        #self.accessibleMethod() #在静态方法中无法直接调用实例方法 直接抛出异常
        print "this is a static method"

    def setName(self,name): #访问器函数
        self.Name=name

    def getName(self): #访问器函数
        return self.Name

    name=property(getName,setName) #属性 可读可写

构造函数和析构函数

Python的构造函数有两种，__init__和__new__,__init__的调用不会返回任何值，在继承关系中，为了保证父类实例正确的初始化，最好显示的调用父类的__init__方法。与__init__不同，__new__实际是个类方法，以cls作为第一个参数。

如果类中同时定义了__init__和__new__方法，则在创建对象的时候会优先使用__new__.

class A(object):

def __init__(self):

print("in init")

def __new__(self):

print("in new")

 
A()

如果__new__需要返回对象，则会默认调用__init__方法。利用new创建一个类的对象的最常用的方法为：super(currentclass,cls).__new__(cls[, ...])

class A(object):

def __new__(cls):

Object = super(A,cls).__new__(cls)

print "in New"

return Object

def __init__(self):

print "in init"

 
class B(A):

def __init__(self):

print "in B's init"

 

B()

__new__构造函数会可变类的定制的时候非常有用，后面的小节中会体现。

Python由于具有垃圾回收机制，通常不需要用户显示的去调用析构函数，即使调用，实例也不会立即释放，而是到该实例对象所有的引用都被清除掉后才会执行。

>>>class P:

def__del__(self):

print"deleted"

 

 

>>>class S(P):

def__init__(self):

print'initialized'

def__del__(self):

P.__del__(self)

print"child deleted"

 

 

>>>a=S()

initialized

>>>b=a

>>>c=a

>>>id(a),id(b),id(c)

(18765704,18765704, 18765704)

>>>del a

>>>del b

>>>del c

deleted

childdeleted

>>>

 

3. Python中的继承

Python同时支持单继承与多继承，继承的基本语法为class新类名（父类1，父类2,..）,当只有一个父类时为单继承，当存在多个父类时为多继承。子类会继承父类的所有的属性和方法，子类也可以覆盖父类同名的变量和方法。在传统类中，如果子类和父类中同名的方法或者属性，在查找的时候基本遵循自左到右，深度优先的原则。如下列：

>>>class A:

defsayhi(self):

print'I am A hi'

>>>class B:

defsayhi(self):

print'I am B Hi'



>>>class C(A,B):

pass

>>>d=C()

>>>d.sayhi()

Iam A hi

>>>B.sayhi(d)

Iam B Hi

 单继承

_metaclass_=type # 确定使用新式类
class Animal:

    def __init__(self): 
        self.Name="Animal"
      
    def move(self,meters):
        print "%s moved %sm." %(self.Name,meters) 
        
class Cat(Animal): #Cat是Animal的子类

     def __init__(self):  #重写超类的构造方法
        self.Name="Garfield"

##     def move(self,meters): #重写超类的绑定方法
##        print "Garfield never moves more than 1m."

class RobotCat(Animal):

    def __init__(self):  #重写超类的构造方法
        self.Name="Doraemon"

##     def move(self,meters): #重写超类的绑定方法
##        print "Doraemon is flying."

obj=Animal()
obj.move(10) #输出：Animal moved 10m.

cat=Cat()
cat.move(1) #输出：Garfield moved 1m.

robot=RobotCat()
robot.move(1000) #输出：Doraemon moved 1000m.

多重继承

class Animal:
  
    def eat(self,food):
        print "eat %s" %food 
        
class Robot:
      
    def fly(self,kilometers):
        print "flyed %skm." %kilometers 
        
class RobotCat(Animal,Robot): #继承自多个超类

    def __init__(self):  
        self.Name="Doraemon"

robot=RobotCat() # 一只可以吃东西的会飞行的叫哆啦A梦的机器猫
print robot.Name

robot.eat("cookies") #从动物继承而来的eat

robot.fly(10000000) #从机器继承而来的fly

需要注意的地方，即如果一个方法从多个超类继承，那么务必要小心继承的超类（或者基类）的顺序：

class Animal:
  
    def eat(self,food):
        print "eat %s" %food

    def move(self,kilometers): #动物的move方法
        pass
        
class Robot:
      
    def move(self,kilometers): #机器的move方法
        print "flyed %skm." %kilometers 
        
class RobotCat(Animal,Robot): #继承自多个超类 如方法名称相同，注意继承的顺序
#class RobotCat(Robot,Animal): 
    def __init__(self):  
        self.Name="Doraemon"

robot=RobotCat() # 一只可以吃东西的会飞行的叫哆啦A梦的机器猫
print robot.Name

robot.eat("cookies") #从动物继承而来的eat

robot.move(10000000) #本来是要从机器继承move方法，但是因为继承的顺序，这个方法直接继承自动物而pass掉

关于继承的构造函数：

1.如果子类没有定义自己的构造函数，父类的构造函数会被默认调用，但是此时如果要实例化子类的对象，则只能传入父类的构造函数对应的参数，否则会出错

classAddrBookEntry(object):

'addressbook entry class'

def__init__(self, nm, ph):

self.name= nm

self.phone= ph

print'Created instance for:', self.name

defupdatePhone(self, newph):

self.phone = newph

print'Updated phone# for:', self.name

  

classEmplAddrBookEntry(AddrBookEntry):

'EmployeeAddress Book Entry class'

defupdateEmail(self, newem):

self.email= newem

print'Updated e-mail address for:', self.name

 

john= EmplAddrBookEntry('John Doe', '408-555-1212')

printjohn.name

 2.如果子类定义了自己的构造函数，而没有显示调用父类的构造函数，则父类的属性不会被初始化

classAddrBookEntry(object):

'addressbook entry class'

def__init__(self, nm, ph):

self.name= nm

self.phone= ph

print'Created instance for:', self.name

defupdatePhone(self, newph):

self.phone = newph

print'Updated phone# for:', self.name

 

 

classEmplAddrBookEntry(AddrBookEntry):

'EmployeeAddress Book Entry class'

def__init__(self, nm, ph, id, em):

#AddrBookEntry.__init__(self, nm,ph)

self.empid= id

self.email= em

 

defupdateEmail(self, newem):

self.email= newem

print'Updated e-mail address for:', self.name

 

john= EmplAddrBookEntry('John Doe', '408-555-1212',42, 'john@spam.doe')

printjohn.email

printjohn.empid

 

输出：

john@spam.doe

42

Traceback(most recent call last):

 

printjohn.name

AttributeError:'EmplAddrBookEntry' object has no attribute 'name'



3.如果子类定义了自己的构造函数，显示调用父类，子类和父类的属性都会被初始化

 

classAddrBookEntry(object):

'addressbook entry class'

def__init__(self, nm, ph):

self.name= nm

self.phone= ph

print'Created instance for:', self.name

defupdatePhone(self, newph):

self.phone = newph

print'Updated phone# for:', self.name

 

 

classEmplAddrBookEntry(AddrBookEntry):

'EmployeeAddress Book Entry class'

def__init__(self, nm, ph, id, em):

AddrBookEntry.__init__(self, nm,ph)

self.empid= id

self.email= em

 

defupdateEmail(self, newem):

self.email= newem

print'Updated e-mail address for:', self.name

 

john= EmplAddrBookEntry('John Doe', '408-555-1212',42, 'john@spam.doe')

printjohn.email

printjohn.empid

printjohn.name

4.python的多态

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由谁（哪种类型）去做怎么去实现我们并不关心。

#!/usr/bin/env python
# -*- coding:utf-8 -*-
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()

就in_the_forest函数而言，参数对象是一个鸭子类型和person类型，它实现了两个类型的相同名称的方法，打印的内容不一样，只是因为

下面是运算符号（方法）的多态

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'