现在读者可能对什么是类有了答题的感觉———或者已经有些不耐烦听我对他进行更多的介绍了。在开始介绍之前，先来认识一下什么是类，已经它和类型又有什么不同（或相同）
类到底是什么
从前面的部分中，类这个词已经多次出现，可以将他或多或少地视为种类或者类型的同义词。从很多方面说，这就是类--一种对象。所有的对象都属于某一个类，称为类的实例（instance）。例如，现在请往窗外看，鸟就是鸟类的实例。鸟类是一个非常通用（抽象）的类，具有很多子类：看到的鸟可能属于子类“百灵鸟”。可以将“鸟类”想象成所有鸟的集合，而“百灵鸟类”是其中的一个子集。当一个对象所属的类是另外一个对象所属类的子集时，前者就被称为后者的子类（subclass），所以“百灵鸟类”是鸟类的子类。相反，“鸟类”是“百灵鸟类”的超类（supclass）。
注意 正日常交谈中，可能经常用复数来描述对象的类，比如birds或者larks。Python中，习惯上都使用单数名词，并且首字母大写，比如Bird和Lark。
这样一比喻，子类和超类就容易理解了。但是在面向对象程序设计中，子类是隐式地，因为一个类的定义取决于他所支持的方法。类的所有势力都会包含这些方法，所以所有子类的所有实例都有这些方法。定义子类只是个定义更多（也有可能是重载已经存在的）的方法的过程。
例如，鸟类Bird可能支持fly方法，而企鹅类Penguin（Bird的子类）可能会增加个EatFish方法。当创建Penguin类时，可能会想要重写（override）超类的方法，对于Penguin的实例来说，这个方法要么什么也不做，要么就产生异常，因为Penguin（企鹅）不会fly（飞）。
7.2.2创建自己的类
终于来了！可以创建自己的类了！先来看一个简单地类：
_metaclass_ = type # 确定使用新式类
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
这个例子包含3个方法定义，除了他们是写在class语句之外，一切都好像是函数定义。Person当然是类的名字。class语句会在函数定义的地方创建自己的命名空间，一切看起来都挺好，但是那个self参数看起来有点奇怪。它是对于对象自身的引用。那么它是什么对象？让我们创建一些实例看看：
>>>foo = Person()
>>>bar = Person()
>>>foo.set.Name(‘LuKe Skywalker‘)
>>>bar.set.Name(‘Anakin Skywalker‘)
>>>foo.greet()
>>>Hello.world!I‘m Lukwalker.
>>>bar.greet()
Hello.world! I‘m Anakin Skywalker.
好了，例子一目了然，应该能说明self的用处了。在调用foo的setName和greet函数时，foo自动将自己作为第一个参数传入函数中——因此形象的命名为self。对于这个变量，每个人可能都会有自己的叫法，但是因为他总是对象自身，所以习惯上叫做self。
显然这就是self的用处和存在的必要性。没有他的话，成员方法就没法访问他们要对其特性进行操作的对象本身了。
和之前一样，特性是可以在外部访问的：
>>>foo.name
‘Luke Skywalker‘
>>>bar.name = ‘Yoda‘
>>>bar.greet()
Hello.world!I‘m Yoda.
7.2.3特性、函数和方法
self参数事实上正是方法和函数的区别。方法（更专业一点可以绑定方法）将他们的第一个参数绑定到所属的实例上，因此你无需显示提供该参数。当然也可以将特性绑定到一个普通函数上，这样就不会有特殊的self参数了：
>>>class Class:
def method(self)
print ‘I have a self‘
>>>def function()
print"I don‘t..."
>>>instance = Class()
>>>instance.method()
I have a self!
>>>instance.method = function
>>>instance.method()
I don‘t...
注意，self参数并不依赖于调用方法的方式，前面我们使用的是instance.method(实例.方法)的形式，可以随意使用其他变量引用同一个方法：
>>>class Bird:
song = ‘Squaak!‘
def sing(self):
print self .song
>>>bird = Bird()
>>>bird.sing()
Squaak!
>>>birdsong = bird.sing
>>>birdsong()
Squaak!
尽管最后一个方法调用看起来与函数调用十分相似，但是变量birdsong引用绑定方法bird.sing上，也就意味着着还是会对self参数进行访问（也就是说，他仍旧绑定到类的相同实例上）
再论私有化
默认情况下，程序可以从外部访问一个对象的特性。再次使用前面讨论过的有关封装的例子：
>>>c.name
‘Sir Lancelot‘
>>>c.name = ‘Sir Gumby‘
>>>c.getName()
‘Sir Gumny‘
有些程序员觉得这样做是可以的，但是有些人（比如SmallTalk之父，SmallTalk的对象特性只允许同一个对象的方法访问）觉得这样就破坏了封装的原则。他们认为对象的状态对于外部应该是完全隐藏的（不可访问）。有人可能觉得奇怪为什么他们会站在如此极端的立场上。每个对象管理自己的特性还不够吗？为什么要对外部世界隐藏呢？毕竟如果能直接使用ClosedObject的name特性的话就不用使用setName和getName方法了。
关键在于其他程序员可能不知道（可能也不应该知道）你的对象内部的具体操作。例如，ClosedOject可能会在其他对象更改自己的名字的时候，给一些管理员发送邮件消息。这应该是setName方法的一部分。但是如果直接使用c.name设定名字会发生什么？什么都没发生，Email也没有发出去。为了避免这类事件的发生，应该使用私有（private）特性，这是外部对象无法访问，但是getName和setName等访问器（accessor）能够访问的特性。
python并不直接支持私有方式，而要靠程序员自己把握在外部进行特性修改的时机。毕竟在使用对象前应该知道如何使用。但是，可以用一些小技巧达到私有特性的效果。
为了让方法或者特性变为私有（从外部无法访问），只要在他的名字前面加上双划线即可：
class Secretive：
def__inaccessible(self):
print "Bet you can‘t see me..."
def accessible(self):
print " The secret message is:"
self.__inaccessible()
现在_inaccessible从外界是无法访问的，而在类内部还能使用（比如从acessible）访问：
>>> s= Secretive()
>>>s._inaccssible()
Traceback(most recent call list):
File "<pyshell#112>", Line 1, in ?
s.inaccessible()
AttributeError: Secretive instance has no attribute ‘_inaccessible‘
>>>s.accessible()
The seret message is:
Bet you can‘t see me...
尽管双下划綫有些奇怪，但是看起来像是其他语言中的标准私有方法。真正发生的事情才是不标准的。类的内部定义中，所有以双下划线的名字都被“翻译”成前面加上单划线和类名的形式。
Secretive._Secretive_inaccessible
<unbound method Secretive._inaccessible>
在了解了这些幕后的事情后，实际上还是能在类外访问这些私有方法，尽管不应该这么做：
>>> s._Secretive__inaccessible()
Bet you can‘t see me ...
简而言之，确保其他人不会访问对象的方法和特性是不可能的，但是这类“名称变化术”就是他们不应该访问这些函数或者特性的强有力信号。
如果不需要使用这种方法，但是又不想其他数据访问内部数据，那么可以使用单下划线。这不过是个习惯，但的确有实际效果。例如前面有下划线的名字都不会被带星号的import语句（from moduel import*）导入。
7.2.4类的命名空间
下面的两个语句（几乎）等价：
def foo(x): return x*x
foo = lambda x: x*x
两者都创建了返回参数平方的函数，而且都将变量foo绑定到函数上。变量foo可以在全局（模块）范围进行定义，也可以处于局部的函数或方法内。定义类时，同样的事情也会发生，所有位于class语句中的代码都在特殊的命名空间中执行——类命名空间（class namespace）。这个命名空间可由类内所有成员访问。并不是所有python程序员都知道类的定义其实就是执行代码块，这一点非常有用，比如，在类的定义区并不限定只能使用def语句：
>>>class C:
print ‘Class C being defined...‘
Class C being defined...
>>>
看起来有点傻，但是看看下面的：
class MemberCouner：
members = 0
def init（self）
MemberCounter.members+=1
>>> m1 = MemberCounter()
>>> m1.init()
>>> MemberCounter.members
1
>>> m2 = MemberCounter()
>>> m2.init()
>>>MemberCounter.members
2
上面的代码中，在类作用域中定义了一个可供成员（实例）访问的变量，用来计算类的成员数量。注意init用来初始化所有实例：
就像方法一样，类作用域内的变量也可以被所有实例访问：
>>> m1.members
2
>>>m2.members
2
那么在实例中重绑定members特性呢？
>>>m1.members = ‘Two‘
>>>m1.members
‘Two‘
>>>m2.members
2
新numbers值被写到了m1的特性中，屏蔽了类范围内的变量。这根函数的局部和全局变量的行为十分类似。