Python 面向对象类(7) 持续更新

多态、封装、继承

创建一个类

# coding=utf-8

# 确定使用新式类
__metaclass__ = type


class Person:
    def setName(self, name):
        self.name = name

    def getName(self):
        return self.name

    def greet(self):
        print 'Hello', self.name

person1 = Person()
person2 = Person()
person1.setName('Luke')
person2.setName('Aaron')

person1.greet()
person2.greet()

输出

Hello Luke
Hello Aaron

函数self参数(绑定方法)将它们的第一个参数绑定到所属的实例，那么它们就是一个普通函数了。

 

显示绑定实例函数

# coding=utf-8

# 确定使用新式类
__metaclass__ = type

class Class:
    def method(self):
        print 'I have a self!'

def function():
    print 'function'

__class = Class()
__class.method()
__class.method = function
__class.method()

输出

I have a self!
function

私有函数 只要在它的名字前面加上 双下划线 即可

# coding=utf-8

# 确定使用新式类
__metaclass__ = type


class Class:
    def fun1(self):
        print 'fun1'

    def __fun2(self):
        print 'fun2'


__class = Class()
__class.fun1()
__class.__fun2()

调用 私有函数会报错 __fun2，不过它可以这样调用

__class._Class__fun2()

尽量不要这样用，这里只是告诉你，在定义私有方法的时，发生的幕后的事情。

类的命名空间

# coding=utf-8

# 确定使用新式类
__metaclass__ = type


class Class:
    member = 0

    def __init__(self):
        Class.member += 1

__class1 = Class()
__class2 = Class()
print __class1.member, __class2.member
__class1.member = "String"
print __class1.member, __class2.member

member 就是类命名空间的变量。 member变量重新绑定特性，只会影响该实例的特性。

继承

# coding=utf-8

# 确定使用新式类
__metaclass__ = type


class Filter:
    def __init__(self):
        self.blocked = []

    def filter(self, sequence):
        return [x for x in sequence if x not in self.blocked]


class SPAMFilter(Filter):
    def __init__(self):
        self.blocked = ['SPAM']


f = Filter()
f.blocked.append(1)
print f.filter([1, 2, 3])

spam = SPAMFilter()
spam.blocked.append(1)
print spam.filter(['SPAM', 1, 2])

输出

[2, 3]
[2]

检查继承  

print issubclass(SPAMFilter, Filter)

查看基类

print SPAMFilter.__bases__

检查对象是否是一个类的实例

print spam.__class__
print isinstance(spam, SPAMFilter)

如果使用 __metaclass__ = type 或 从 object 继承方式类定义新式类。那么可以

print type(spam)

查看实例所属类

继承多个类

# coding=utf-8

# 确定使用新式类
__metaclass__ = type


class ClassA:
    def A(self):
        print 'Call A'

    def fun(self):
        print 'A fun'


class ClassB:
    def B(self):
        print 'Call B'

    def fun(self):
        print 'B fun'


class ClassC(ClassA, ClassB):
    def C(self):
        print 'Call C'

    # def fun(self):
    #     print 'C fun'

__c = ClassC()
__c.A()
__c.B()
__c.C()
__c.fun()

继承多个类是，遇到同名的函数时，继承的第一个类，会屏蔽后面的同名函数，具体测试上面代码。

print hasattr(__c, 'fun')
print callable(getattr(__c, 'fun'))
print __c.__dict__

callable在Python3.0已经废弃，多用hasattr代替它

getattr对应的函数是setattr函数

对象.__dict__ 可以查看对象内所有对象存储的值

当考虑需要什么类以及类需要什么方法是，应该尝试下面的方法。

1. 写下问题的描述(程序要做什么)，把所有名词、动词和形容词加下划线。
2. 对于所有名字，用作可能的类
3. 队友所有动词，用作可能的方法
4. 对于所有形容词，用作可能的特性。
5. 把所有方法和特性分配到类。

考虑类和对象之间的关系以及它们的作用，可以用一下步骤精炼模型。

1. 写下一系列的使用实例，也就是程序应用使得场景，试着包括所有的功能。
2. 一步步考虑每个使用实例，保证模型包括所有需要的东西。如果有遗漏就添加进去，某处不正取则改正，一直满意为止。

random.choice 序列中获取一个随机元素

>>> import random
>>> random.choice(range(9))
8