Python——类的定义和超类

假定你已经学习了Java程序设计，那么就不难理解面向对象程序设计。在面向对象中，有几个非常重要的概念，包括：抽象、封装、继承、多态、方法重载等，不管怎样这些概念都与类相关。在Python中同样有同Java一样的类，用户可以根据设计需要对事物进行抽象，抽取主要的特征来构造需要的类并定义属于类的成员方法。
一、类的定义

# _*_ 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,%s' %self.name)

运算结果：
=========RESTART: C:\Users\Mr_Deng\Desktop\test.py=========
>>> test1=Person()
>>> test1.setName('Jack Chen')
>>> print(test1.getName())
Jack Chen
>>> 

注：self参数是对对象自身的引用，在调用类中的定义的方法时，例如setName函数时，test1自动将自己作为第一个参数传入函数中。没有self变量，成员方法就不能设法访问他们要对其特性进行操作的对象本身了。
二、特性、函数和方法
2.1 self参数时方法和函数的区别，方法将他的第一个参数绑定到所属的实例上，但是这个参数也可以不提供，所以可以将特性绑定到普通函数上，这样就可以消除self参数

# _*_ coding:utf-8 _*_
__metaclass__=type
class Test:
    def A(self):
        print('self')


#另外定义一个函数
def fun():
    print('other function')

运算结果：
=========RESTART: C:\Users\Mr_Deng\Desktop\test.py=========
>>> test=Test()
>>> test.A()
self
>>> test.A=fun
>>> test.A()
other function
>>> 

但是，self参数并不取决于调用方法的方式，上例中采用实例调用的方式，但是实际上也可以引用同一方法的其他变量

# _*_ coding:utf-8 _*_
__metaclass__=type
class Test:
    s='test class'
    def outTest(self):
        print(self.s)

运算结果：
=========RESTART: C:\Users\Mr_Deng\Desktop\test.py=========
>>> test=Test()
>>> test.outTest()
test class
>>> x=test.outTest
>>> x()
test class
>>> 

注：这个例子中的方法调用于前面一个函数调用比较想死，但是x是引用绑定了Test中的方法outTest，也就是说x还是对self参数的访问。
2.2 方法私有化：在Python中若是想让某个方法或者特性变为私有的，在方法的名字前加上双下划綫即可

# _*_ coding:utf-8 _*_
__metaclass__=type
class Test:
    def A(self):
        print('public method')
    def __B(self):
        print('private methon')

运算结果：
=========RESTART: C:\Users\Mr_Deng\Desktop\test.py=========
>>> test=Test()
>>> test.A()
public method
>>> test.B()
Traceback (most recent call last):
  File "<pyshell#92>", line 1, in <module>
    test.B()
AttributeError: 'Test' object has no attribute 'B'
>>> 

三、类的命名空间：位于class语句中的代码都在特殊的命名空间中执行，这个空间就是类命名空间，该命名空间可以由类内所有的成员访问

# _*_ coding:utf-8 _*_
__metaclass__=type
class Member:
    count=0;
    def init(self):
        Member.count+=1

运算结果：
=========RESTART: C:\Users\Mr_Deng\Desktop\test.py=========
>>> test1=Member()
>>> test1.init()
>>> Member.count
1
>>> test2=Member()
>>> test2.init()
>>> Member.count
2
>>> test1.count
2
>>> test2.count
2
>>> 

四、指定超类：子类可以扩展超类的定义，将其他类名写在class语句后的圆括号内可以指定超类，案例如下：

# _*_ coding:utf-8 _*_
__metaclass__=type
class Filter:
    def init(self):
        self.blocked=[]
    def filter(self,seq):
        return [ x for x in seq if x not in self.blocked]

class ExtendFilter(Filter):
    def init(self):
        self.blocked=['1']

运算结果：
=========RESTART: C:\Users\Mr_Deng\Desktop\test.py=========
>>> f=Filter()
>>> f.init()
>>> f.filter([])
[]
>>> ef=ExtendFilter()
>>> ef.init()
>>> ef.filter(['1','2','3','1','1','7'])
['2', '3', '7']
>>> 

在ExtendFilter类中，继承了Filter中的filter方法
五、调查继承性
5.1 查看一个类是否是另一个类的子类，可以使用內建的函数issubclass

# _*_ coding:utf-8 _*_
__metaclass__=type
class Filter:
    def init(self):
        self.blocked=[]
    def filter(self,seq):
        return [ x for x in seq if x not in self.blocked]

class ExtendFilter(Filter):
    def init(self):
        self.blocked=['1'] 

运算结果：
=========RESTART: C:\Users\Mr_Deng\Desktop\test.py=========
>>> issubclass(ExtendFilter,Filter)
True
>>> 

或者使用bases

>>> ExtendFilter.__bases__
(<class '__main__.Filter'>,)
>>> 

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

>>> ef=ExtendFilter()
>>> isinstance(ef,ExtendFilter)
True
>>> 

5.3 查看一个对象属于哪个类

>>> ef.__class__
<class '__main__.ExtendFilter'>
>>> 

六、多个超类

# _*_ coding:utf-8 _*_
__metaclass__=type
class Cauculator:
    def cauculator(self,express):
        self.value=eval(express)

class Result:
    def result(self):
        print('result is :',self.value)

class Compute(Cauculator,Result):
    pass

运算结果：
=========RESTART: C:\Users\Mr_Deng\Desktop\test.py=========
>>> test=Compute()
>>> test.cauculator('12*2+2')
>>> test.result()
result is : 26
>>>