类是什么
可以视为种类或者类型的同义词。所有的对象都属于某一个类，称为类的实例。
例如：鸟就是鸟类的实例。这就是一个有很多子类的一般（抽象）类：看到的鸟可能属于子类百灵鸟。可以将鸟类想象成所有鸟的集合，而百灵鸟类是其中的一个子集。当一个对象所属的类是另外一个对象所属类的子集时，前者就被称为后者的子类，所以百灵鸟类是鸟类的子类，鸟类是百灵鸟类的超类
定义子类只是个定义更多方法的过程
创建类
>>> class person:
def setname(self,name):
self.name=name
def getname(self):
return self.name
def greet(self):
print "hello,world! i'm %s" % self.name
>>> foo=person()
>>> bar=person()
>>> foo.setname('nsds')
>>> bar.setname('ysdy')
>>> foo.greet()
hello,world! i'm nsds
>>> bar.greet()
hello,world! i'm ysdy
在调用foo的setname和greet函数时，foo自动将自己作为第一个参数传入函数中，因此命名为self。没有self的话，成员方法就没法访问他们要对其特性进行操作的对象本身了
特性是可以外部访问的：
>>> foo.name
'nsds'
>>> bar.name='yoda'
>>> bar.greet()
hello,world! i'm yoda
特性、函数、方法
self参数事实上正是方法和函数的区别。方法将它们的第一个参数绑定到所属的实例上，因此这个参数可以不必提供。所以可以将特性绑定到一个普通函数上，这样就不会有特殊的self参数了：
（特性是对象内部的变量，对象的状态由它的特性来描述，对象的方法可以改变它的特性，可以直接从对象外部访问特性）
>>> class class:
def method(self):
print 'i have a self!'
>>> def function():
print "i don't..."
>>> s=class()
>>> s.method()
i have a self!
>>> s.method=function
>>> s.method()
i don't...
变量birdsong引用绑定方法bird.sing上，还是对self参数的访问（仍旧绑定到类的相同实例上）
>>> class bird:
song='squaawk'
def sing(self):
print self.song
>>> bird=bird()
>>> bird.sing()
squaawk
>>> birdsong=bird.sing
>>> birdsong()
squaawk
在名称前加上双下划线，可以让方法或者特性变为私有（从外部无法访问）
>>> class secretive:
def __inaccessible(self):
print "bet you can't see me..."
def accessible(self):
print "the secret message is:"
self.__inaccessible()
>>> s=secretive()
>>> s.__inacessible()
traceback (most recent call last):
file "<pyshell#182>", line 1, in <module>
s.__inacessible()
attributeerror: 'secretive' object has no attribute '__inacessible'
>>> s.accessible()
the secret message is:
bet you can't see me...
在类的内部定义中，所有以双下划线开的名字都被"翻译"成前面加上单下划线和类名的形式
>>> secretive._secretive__inaccessible<unbound method secretive.__inaccessible>
>>> s._secretive__inaccessible()
bet you can't see me...
类的命名空间
定义类时，所有位于class语句中的代码都在特殊的命名空间中执行---类的命名空间。这个命名空间可由类内所有成员访问。
类的定义其实就是执行代码块
>>> class membercounter:
members=0
def init(self):
membercounter.members+=1
>>> m1=membercounter()
>>> m1.init()
>>> m1.members
>>> m1.members=2
>>> m1.members
>>> m2=membercounter()
>>> m2.init()
>>> m2.members
>>> m2.init()
>>> m2.members
>>> m1.members
>>>
新members值被写到了m1的特性中，屏蔽了类范围内的变量
超类
>>> 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.init()
>>> f.filter([1,2,3])
[1, 2, 3]
>>> s=spamfilter()
>>> s.init()
>>> s.filter(['spam','spam','egg','name','ff'])
['egg', 'name', 'ff']
继承，超类
>>> class filter:
def init(self):
self.blockes=[]
def filter(self,sequence):
return [x for x in sequence if x not in self.blocked]
>>> class s(filter):
def init(self):
self.blocked=['s']
>>> f=filter()
>>> f.init()
>>> f.filter([1,2,3])
多个超类
先继承的类中的方法会重写后继承的类中的方法
>>> class c():
def calculate(self,expression):
self.value=eval(expression)
>>> class talker():
def talk(self):
print 'hi,my value is',self.value
>>> class talkingcalculator(c,talker):
pass
>>> tc=talkingcalculator()
>>> tc.calculate('1+2*3')
>>> tc.talk()
hi,my value is 7
更多python中类和类型详解。