Python_09-面向对象编程
目录：
1 面向对象编程
1.1 简单例子
1.2 调用
1.3 python命名规范（约定）
1.4 类的设计
1.4.1 Exception 异常捕获结构
1.4.2 自定义异常
1.4.3 __init__.
1.4.4 __new__.
1.4.5 __new__ 的作用
1.4.6 用__new__来实现单例
1.4.7 静态方法
1.4.8 类方法
1.5 面向对象编程
1.5.1 Python支持多继承
1.5.2 多态 (override overload)
1.6 super关键字
1.6.1 普通继承
1.6.2 super继承
1 面向对象编程
1.1 简单例子
#!/usr/bin/python
#-*- encoding:utf-8 -*-
class test: #定义一个test类
desc = "这是一个测试类。" #在类中定义一个属性desc
def __init__(self,name1): #对象构造函数，初始化类
self.name1 = name1
def show(self,name2): #在类中定义一个方法show()
print("hello world")
print('name1:',self.name1)
print('name2:',name2)
1.2 调用
obj = test('这是传递给name1的值') #生成test类的实例对象
print(obj.desc) #调用类中的desc属性
obj.show('这是传递给name2的值') #调用类中的show()方法
1.3 python命名规范（约定）
类里面 “单下划线” 开始的成员变量叫做保护变量, 意思是只有类对象和子类对象自己能访问到这些变量;
而 "双下划线" 开始的是私有成员, 意思是只有类对象自己能访问, 连子类对象也不能访问到这个数据。
类的首字母大写, 没有特别原因不要在前面加 “T” 或者 “C” 什么的
函数和变量尽量全小写, 单词间用下划线连接。
1.4 类的设计
class Foo:
def __init__(self, a, b):
self.a = a
self.b = b
def show_a(self):
print self.a
def show_b(self):
print self.b
__init__ 函数：每次生成类的时候都会执行的, self 指向类对象自身。
记住, 类函数(或者叫做方法) 它的第一个参数 “self” 不要忘记写了
其中的“__del__”就是一个析构函数了，当使用del 删除对象时，会调用他本身的析构函数，另外当对象在某个作用域中调用完毕，在跳出其作用域的同时析构函数也会被调用一次，这样可以用来释放内存空间。
foo_obj = Foo("I'm A", "I'm B")
foo_obj.show_a()
foo_obj.b = "Hello world!"
foo_obj.show_b()
1.4.1 Exception 异常捕获结构
try:
……
except Exceptionname：
…….
except:
…….
else:
…….
finally:
…….
1.4.2 自定义异常
class MyError(Exception):
pass
raise 关键字 可以抛出自定义的异常
例： raise MyError
注意：一定注意先后顺序， 要先定义异常类后才可以使用， 而不能上来就用。
1.4.3 __init__
程序cPerson.py：
class Person(object):
"""Silly Person"""
def __init__(self, name, age):
self.name = name
self.age = age
def __str__(self):
return '<Person: %s(%s)>' % (self.name, self.age)
if __name__ == '__main__':
piglei = Person('piglei', 24)
print piglei
运行：
>>> import cPerson
>>> str(a)
'<Person: yong(22)>'
>>> a=cPerson.Person('LiLee',22)
>>> str(a)
'<Person: LiLee(22)>'
1.4.4 __new__
每一个 new-style class 都有一个名为{{_new_}}的静态方法. 当你调用 C(args,kwds)创建一个C实例时,python内部调用的是 C._new_(C,*args,*kwds).
{_new_}}方法的返回值 x 就是该类的实例. 在确认 x 是C的实例以后, python调用C.{{_init_(x,args,*kwds)来初始化这个实例. 也就是说,对新类C来讲,语句 x=C(23)等同于
x = C._new_(C, 23)
if isinstance(x, C): C._init_(x, 23)
_new方法拥有函数工厂的绝大部分弹性. 根据实际需求,我们可以让new_返回一个已有的实例或者创建一个新的实例.
下面举一个通过重载_new_方法实现独身对象的设计模式的例子:
class Singleton(object):
_singletons = {}
def _new_(cls, *args, **kwds):
if not cls._singletons.has_key(cls): #若还没有任何实例
cls.singletonscls
= object.new_(cls) #生成一个实例
return cls._singletonscls #返回这个实例
Singleton的所有子类(当然是没有重载_new方法的子类)都只可能有一个实例. 如果该类的子类定义了一个init方法,那么它必须保证它的init_方法能够安全的对同一实例进行多次调用.
__new__方法接受的参数虽然也是和__init__一样，但__init__是在类实例创建之后调用，而 __new__方法正是创建这个类实例的方法。
# -*- coding: utf-8 -*-
class Person(object):
"""Silly Person"""
def __new__(cls, name, age):
print '__new__ called.'
return super(Person, cls).__new__(cls, name, age)
def __init__(self, name, age):
print '__init__ called.'
self.name = name
self.age = age
def __str__(self):
return '<Person: %s(%s)>' % (self.name, self.age)
if __name__ == '__main__':
piglei = Person('piglei', 24)
print piglei
执行结果：
执行方法1：
$ python new_and_init.py
__new__ called.
__init__ called.
<Person: piglei(24)>
执行方法2：
>>>
>>> import cPerson
>>> a=Person('dd',39)
__new__ called.
__init__ called.
通过运行这段代码，我们可以看到，__new__方法的调用是发生在__init__之前的。其实当你实例化一个类的时候，具体的执行逻辑是这样的：
- p = Person(name, age)
- 首先执行使用name和age参数来执行Person类的__new__方法，这个__new__方法会返回Person类的一个实例（通常情况下是使用 super(Persion, cls).__new__(cls, ... ...) 这样的方式），
- 然后利用这个实例来调用类的__init__方法，上一步里面__new__产生的实例也就是 __init__里面的的 self
所以，__init__ 和 __new__ 最主要的区别在于：
- __init__ 通常用于初始化一个新实例，控制这个初始化的过程，比如添加一些属性，做一些额外的操作，发生在类实例被创建完以后。它是实例级别的方法。
- __new__ 通常用于控制生成一个新实例的过程。它是类级别的方法。
参考：
http://my.oschina.net/leejun2005/blog/207371
1.4.5 __new__ 的作用
依照Python官方文档的说法，__new__方法主要是当你继承一些不可变的class时(比如int, str, tuple)， 提供给你一个自定义这些类的实例化过程的途径。还有就是实现自定义的metaclass。
首先我们来看一下第一个功能，具体我们可以用int来作为一个例子：
假如我们需要一个永远都是正数的整数类型，通过集成int，我们可能会写出这样的代码。
class PositiveInteger(int):
def __init__(self, value):
super(PositiveInteger, self).__init__(self, abs(value))
i = PositiveInteger(-3)
print i
但运行后会发现，结果根本不是我们想的那样，我们任然得到了-3。这是因为对于int这种 不可变的对象，我们只有重载它的__new__方法才能起到自定义的作用。
这是修改后的代码：
class PositiveInteger(int):
def __new__(cls, value):
return super(PositiveInteger, cls).__new__(cls, abs(value))
i = PositiveInteger(-3)
print i
通过重载__new__方法，我们实现了需要的功能。
另外一个作用，关于自定义metaclass。其实我最早接触__new__的时候，就是因为需要自定义 metaclass，但鉴于篇幅原因，我们下次再来讲python中的metaclass和__new__的关系。
1.4.6 用__new__来实现单例
事实上，当我们理解了__new__方法后，我们还可以利用它来做一些其他有趣的事情，比如实现 设计模式中的 单例模式(singleton) 。
因为类每一次实例化后产生的过程都是通过__new__来控制的，所以通过重载__new__方法，我们可以很简单的实现单例模式。
class Singleton(object):
def __new__(cls):
# 关键在于这，每一次实例化的时候，我们都只会返回这同一个instance对象
if not hasattr(cls, 'instance'):
cls.instance = super(Singleton, cls).__new__(cls)
return cls.instance
obj1 = Singleton()
obj2 = Singleton()
obj1.attr1 = 'value1'
print obj1.attr1, obj2.attr1
print obj1 is obj2
输出结果：
value1 value1
True
可以看到obj1和obj2是同一个实例。
class Singleton(object):
__instance = None
def __init__(self, *args, **kwargs):
pass
def __new__(cls, *args, **kwargs):
if not cls.__instance:
# if not hasattr(cls, 'instance'):
cls.__instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
cls.__instance.aa = args[0]
print type(cls), type(cls.__instance), type(cls.__instance.aa)
return cls.__instance
obj1 = Singleton(1, 2, 3, b=2)
obj2 = Singleton(1, 2, 3, b=2)
obj1.attr1 = 'value1'
obj2.attr2 = 'value2'
print obj1.attr1, obj1.attr2
print obj1 is obj2
print obj1.aa, obj2.attr1
结果：
<type 'type'> <class '__main__.Singleton'> <type 'int'>
value1 value2
True
1 value1
1.4.7 静态方法
@staticmethod #静态方法修饰符，表示下面的方法是一个静态方法
def astatic( ): print 'a static method'
anInstance = AClass( )
AClass.astatic( ) # prints: a static
method
anInstance.astatic( ) # prints: a static
method
1.4.8 类方法
@classmethod #类方法修饰符
def aclassmet(cls): print 'a class method
for', cls._name_
class ADeriv(ABase): pass
bInstance = ABase( )
dInstance = ADeriv( )
ABase.aclassmet( ) # prints: a class
method for ABase
bInstance.aclassmet( ) # prints: a class
method for ABase
ADeriv.aclassmet( ) # prints: a class
method for ADeriv
dInstance.aclassmet( ) # prints: a class
method for ADeriv
1.5 面向对象编程
前面提到的操作函数和语句块是传统的面向过程编程，而编写大型程序，通常采用面向对象编程。类和对象是面向对象编程的两个主要方面，类创建一个新类型，而对象是类的实例。Python没有什么值类型与引用类型之分，它把所有事物统统看作是类。
面向对象实质上是一种思想，并不是一门技术。面向对象讲求一切皆对象.
面向对象的三大特性
继承
封装
多态
为什么要面向对象？
灵活性， 重用性。
继承关系可以被传递，如果c1是c2的子类，c2是c3的子类，那么c1也是c3的子类。
如果a继承b， 那么a具有b的一切属性和方法。
1.5.1 Python支持多继承
class A:
def __init__(self):
pass
class B:
def __init__(self):
pass
class C(A,B):
def __init__(self):
pass
sex=''
def Say(self):
print self.name+ self.sex+self.age
1.5.2 多态 (override overload)
Python 中的多态并没有完全实现，Python中只是利用多元化来实现部分多态的特性
class Person:
def __init__(self,name):
self.Name=name
Name='name'
Sex='man'
Age='age'
def Say(self,message):
print self.Name+message
class Role(Person):
def __init__(self,name,roleName):
Person.__init__(self,name)
self.RoleName=roleName
RoleName='roleName'# light or dark
def Say(self,message):
print self.RoleName+self.Name+message
1.6 super关键字
super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。
总之前人留下的经验就是：保持一致性。要不全部用类名调用父类，要不就全部用 super，不要一半一半。
1.6.1 普通继承
代码：
[python]view plaincopy在CODE上查看代码片派生到我的代码片
class FooParent(object):
def __init__(self):
self.parent = 'I\'m the parent.'
print 'Parent'
def bar(self,message):
print message, 'from Parent'
class FooChild(FooParent):
def __init__(self):
FooParent.__init__(self)
print 'Child'
def bar(self,message):
FooParent.bar(self,message)
print 'Child bar function.'
print self.parent
if __name__=='__main__':
fooChild = FooChild()
fooChild.bar('HelloWorld')
1.6.2 super继承
代码
[python]view plaincopy在CODE上查看代码片派生到我的代码片
class FooParent(object):
def __init__(self):
self.parent = 'I\'m the parent.'
print 'Parent'
def bar(self,message):
print message,'from Parent'
class FooChild(FooParent):
def __init__(self):
super(FooChild,self).__init__()
print 'Child'
def bar(self,message):
super(FooChild, self).bar(message)
print 'Child bar fuction'
print self.parent
if __name__ == '__main__':
fooChild = FooChild()
fooChild.bar('HelloWorld')
程序运行结果相同，为：
Parent
Child
HelloWorld from Parent
Child bar fuction
I'm the parent.
从运行结果上看，普通继承和super继承是一样的。但是其实它们的内部运行机制不一样，这一点在多重继承时体现得很明显。在super机制里可以保证公共父类仅被执行一次，至于执行的顺序，是按照mro进行的（E.__mro__）。
注意：super继承只能用于新式类，用于经典类时就会报错。
新式类：必须有继承的类，如果没什么想继承的，那就继承object
经典类：没有父类，如果此时调用super就会出现错误：
super() argument 1 must be type, not classobj
1.7 python的cls，self，classmethod，staticmethod
python类里会出现这三个单词，self和cls都可以用别的单词代替，类的方法有三种，
1.通过def定义的 普通的一般的，需要至少传递一个参数，一般用self，这样的方法必须通过一个类的实例去访问，类似于c++中通过对象去访问；
2.在def前面加上@classmethod，这种类方法的一个特点就是可以通过类名去调用，但是也必须传递一个参数，一般用cls表示class，表示可以通过类直接调用；
3.在def前面加上@staticmethod，这种类方法是静态的类方法，类似于c++的静态函数，他的一个特点是参数可以为空，同样支持类名和对象两种调用方式；
class A:
member = "this is a test."
def __init__(self):
pass
@classmethod
def Print1(cls):
print "print 1: ", cls.member
def Print2(self):
print "print 2: ", self.member
@classmethod
def Print3(paraTest):
print "print 3: ", paraTest.member
@staticmethod
def print4():
print "hello"
a = A()
A.Print1()
a.Print1()
#A.Print2()
a.Print2()
A.Print3()
a.Print3()
A.print4()
1.8 python中self，cls
普通的方法，第一个参数需要是self，它表示一个具体的实例本身。
如果用了staticmethod，那么就可以无视这个self，而将这个方法当成一个普通的函数使用。
而对于classmethod，它的第一个参数不是self，是cls，它表示这个类本身。
>>> class A(object):
def foo1(self):
print "Hello",self
@staticmethod
def foo2():
print "hello"
@classmethod
def foo3(cls):
print "hello",cls
>>> a = A()
>>> a.foo1() #最常见的调用方式，但与下面的方式相同
Hello <__main__.A object at 0x9f6abec>
>>> A.foo1(a) #这里传入实例a，相当于普通方法的self
Hello <__main__.A object at 0x9f6abec>
>>> A.foo2() #这里，由于静态方法没有参数，故可以不传东西
hello
>>> A.foo3() #这里，由于是类方法，因此，它的第一个参数为类本身。
hello <class '__main__.A'>
>>> A #可以看到，直接输入A，与上面那种调用返回同样的信息。
<class '__main__.A'>
1.8.1 其他例子
cls是class的缩写。
class A:
member = "this is a test."
def __init__(self):
pass
@classmethod
def Print1(cls):
#
print "print 1: ", cls.member
def Print2(self):
print "print 2: ", self.member
@classmethod
def Print3(paraTest):
print "print 3: ", paraTest.member
a = A()
A.Print1() #相当于Print1(A)
a.Print2() #相当于Print2(a)， 请注意@classmethod
A.Print3()
可以看出来，python在通过“.”调用成员函数的时候，会将“.”前面的东西当作函数的第一个参数调用。
而且pyhon并不关心我们把类的成员函数的第一个参数的名称是什么，我们可以用任意的名称，可以看Print3的定义就知道了。
