现在开始不用伪代码了，用真正的python代码来理解类。当然，例子还是要用读者感兴趣的例子。
## [](https://github.com/qiwsir/StarterLearningPython/blob/master/207.md#新式类和旧式类)新式类和旧式类
因为python是一个不断发展的高级语言（似乎别的语言是不断发展的，甚至于自然语言也是），导致了在python2.x的版本中，有“新式类”和“旧式类（也叫做经典类）”之分。新式类是python2.2引进的，在此后的版本中，我们一般用的都是新式类。本着知其然还要知其所以然的目的，简单回顾一下两者的差别。
~~~
>>> class AA:
... pass
...
~~~
这是定义了一个非常简单的类，而且是旧式类。至于如何定义类，下面会详细说明。读者姑且囫囵吞枣似的的认同我刚才建立的名为`AA`的类，为了简单，这个类内部什么也不做，就是用`pass`一带而过。但不管怎样，是一个类，而且是一个旧式类（或曰经典类）
然后，将这个类实例化（还记得上节中实例化吗？对，就是那个王美女干的事情）：
~~~
>>> aa = AA()
~~~
不要忘记，实例化的时候，类的名称后面有一对括号。接下来做如下操作：
~~~
>>> type(AA)
<type 'classobj'>
>>> aa.__class__
<class __main__.AA at 0xb71f017c>
>>> type(aa)
<type 'instance'>
~~~
解读一下上面含义：
* `type(AA)`：查看类`AA`的类型，返回的是`'classobj'`
* `aa.__class__`：aa是一个实例，也是一个对象，每个对象都有`__class__`属性，用于显示它的类型。这里返回的结果是`<class __main__.AA at 0xb71f017c>`，从这个结果中可以读出的信息是，aa是类AA的实例，并且类AA在内存中的地址是`0xb71f017c`。
* `type(aa)`：是要看实例aa的类型，它显示的结果是`'instance`，意思是告诉我们它的类型是一个实例。
在这里是不是有点感觉不和谐呢？`aa.__class__`和`type(aa)`都可以查看对象类型，但是它们居然显示不一样的结果。比如，查看这个对象：
~~~
>>> a = 7
>>> a.__class__
<type 'int'>
>>> type(a)
<type 'int'>
~~~
别忘记了，前面提到过的“万物皆对象”，那么一个整数7也是对象，用两种方式查看，返回的结果一样。为什么到类（严格讲是旧式类）这里，居然返回不一样呢？太不和谐了。
于是乎，就有了新式类，从python2.2开始，变成这样了：
~~~
>>> class BB(object):
... pass
...
>>> bb = BB()
>>> bb.__class__
<class '__main__.BB'>
>>> type(bb)
<class '__main__.BB'>
~~~
终于把两者统一起来了，世界和谐了。
这就是新式类和旧式类的不同。
当然，不同点绝非仅仅于此，这里只不过提到一个现在能够理解的不同罢了。另外的不同还在于两者对于多重继承的查找和调用方法不同，旧式类是深度优先，新式类是广度优先。可以先不理解，后面会碰到的。
不管是新式类、还是旧式类，都可以通过这样的方法查看它们在内存中的存储空间信息
~~~
>>> print aa
<__main__.AA instance at 0xb71efd4c>
>>> print bb
<__main__.BB object at 0xb71efe6c>
~~~
分别告诉了我们两个实例是基于谁生成的，不过还是稍有区别。
知道了旧式类和新式类，那么下面的所有内容，就都是对新式类而言。“喜新厌旧”不是编程经常干的事情吗？所以，旧式类就不是我们讨论的内容了。
还要注意，如果你用的是python3，就不用为新式类和旧式类而担心了，因为在python3中压根儿就没有这个问题存在。
如何定义新式类呢？
第一种定义方法，就是如同前面那样：
~~~
>>> class BB(object):
... pass
...
~~~
跟旧式类的区别就在于类的名字后面跟上`(object)`，这其实是一种名为“继承”的类的操作，当前的类BB是以类object为上级的（object被称为父类），即BB是继承自类object的新类。在python3中，所有的类自然地都是类object的子类，就不用彰显出继承关系了。对了，这里说的有点让读者糊涂，因为冒出来了“继承”、“父类”、“子类”，不用着急，继续向下看。下面精彩，并且能解惑。
第二种定义方法，在类的前面写上这么一句：`__metaclass__ == type`，然后定义类的时候，就不需要在名字后面写`(object)`了。
~~~
>>> __metaclass__ = type
>>> class CC:
... pass
...
>>> cc = CC()
>>> cc.__class__
<class '__main__.CC'>
>>> type(cc)
<class '__main__.CC'>
~~~
两种方法，任你选用，没有优劣之分。
## [](https://github.com/qiwsir/StarterLearningPython/blob/master/207.md#创建类)创建类
因为在一般情况下，一个类都不是两三行能搞定的。所以，下面可能很少使用交互模式了，因为那样一旦有一点错误，就前功尽弃。我改用编辑界面。你用什么工具编辑？python自带一个IDE，可以使用。我习惯用vim。你用你习惯的工具即可。如果你没有别的工具，就用安装python是自带的那个IDE。
~~~
#!/usr/bin/env python
# coding=utf-8
__metaclass__ = type
class Person:
def __init__(self, name):
self.name = name
def getName(self):
return self.name
def color(self, color):
print "%s is %s" % (self.name, color)
~~~
上面定义的是一个比较常见的类，一般情况下，都是这样子的。下面对这个“大众脸”的类一一解释。
### [](https://github.com/qiwsir/StarterLearningPython/blob/master/207.md#新式类)新式类
`__metaclass__ = type`，意味着下面的类是新式类。
### [](https://github.com/qiwsir/StarterLearningPython/blob/master/207.md#定义类)定义类
`class Person`，这是在声明创建一个名为"Person"的类。类的名称一般用大写字母开头，这是惯例。如果名称是两个单词，那么两个单词的首字母都要大写，例如`class HotPerson`，这种命名方法有一个形象的名字，叫做“驼峰式命名”。当然，如果故意不遵循此惯例，也未尝不可，但是，会给别人阅读乃至于自己以后阅读带来麻烦，不要忘记“代码通常是给人看的，只是偶尔让机器执行”。既然大家都是靠右走的，你就别非要在路中间睡觉了。
接下来，分别以缩进表示的，就是这个类的内容了。其实那些东西看起来并不陌生，你一眼就认出它们了——就是已经学习过的函数。没错，它们就是函数。不过，很多程序员喜欢把类里面的函数叫做“方法”。是的，就是上节中说到的对象的“方法”。我也看到有人撰文专门分析了“方法”和“函数”的区别。但是，我倒是认为这不重要，重要的是类的中所谓“方法”和前面的函数，在数学角度看，丝毫没有区别。所以，你尽可以称之为函数。当然，听到有人说方法，也不要诧异和糊涂。它们本质是一样的。
需要再次提醒，函数的命名方法是以`def`发起，并且函数名称首字母不要用大写，可以使用`aa_bb`的样式，也可以使用`aaBb`的样式，一切看你的习惯了。
不过，要注意的是，类中的函数（方法）的参数跟以往的参数样式有区别，那就是每个函数必须包括`self`参数，并且作为默认的第一个参数。这是需要注意的地方。至于它的用途，继续学习即可知道。
### [](https://github.com/qiwsir/StarterLearningPython/blob/master/207.md#初始化)初始化
`def __init__`，这个函数是一个比较特殊的，并且有一个名字，叫做**初始化函数**（注意，很多教材和资料中，把它叫做构造函数，这种说法貌似没有错误，但是一来从字面意义上看，它对应的含义是初始化，二来在python中它的作用和其它语言比如java中的构造函数还不完全一样，因为还有一个`__new__`的函数，是真正地构造。所以，在本教程中，我称之为初始化函数）。它是以两个下划线开始，然后是init，最后以两个下划线结束。
> 所谓初始化，就是让类有一个基本的面貌，而不是空空如也。做很多事情，都要初始化，让事情有一个具体的起点状态。比如你要喝水，必须先初始化杯子里面有水。在python的类中，初始化就担负着类似的工作。这个工作是在类被实例化的时候就执行这个函数，从而将初始化的一些属性可以放到这个函数里面。
此例子中的初始化函数，就意味着实例化的时候，要给参数name提供一个值，作为类初始化的内容。通俗点啰嗦点说，就是在这个类被实例化的同时，要通过name参数传一个值，这个值被一开始就写入了类和实例中，成为了类和实例的一个属性。比如：
~~~
girl = Person('canglaoshi')
~~~
girl是一个实例对象，就如同前面所说的一样，它有属性和方法。这里仅说属性吧。当通过上面的方式实例化后，就自动执行了初始化函数，让实例girl就具有了name属性。
~~~
print girl.name
~~~
执行这句话的结果是打印出`canglaoshi`。
这就是初始化的功能。简而言之，通过初始化函数，确定了这个实例（类）的“基本属性”（实例是什么样子的）。比如上面的实例化之后，就确立了实例girl的name是"canglaoshi"。
初始化函数，就是一个函数，所以，它的参数设置，也符合前面学过的函数参数设置规范。比如
~~~
def __init__(self,*args):
pass
~~~
这种类型的参数：*args和前面讲述函数参数一样，就不多说了。忘了的看官，请去复习。但是，self这个参数是必须的。
很多时候，并不是每次都要从外面传入数据，有时候会把初始化函数的某些参数设置默认值，如果没有新的数据传入，就应用这些默认值。比如：
~~~
class Person:
def __init__(self, name, lang="golang", website="www.google.com"):
self.name = name
self.lang = lang
self.website = website
self.email = "qiwsir@gmail.com"
laoqi = Person("LaoQi")
info = Person("qiwsir",lang="python",website="qiwsir.github.io")
print "laoqi.name=",laoqi.name
print "info.name=",info.name
print "-------"
print "laoqi.lang=",laoqi.lang
print "info.lang=",info.lang
print "-------"
print "laoqi.website=",laoqi.website
print "info.website=",info.website
#运行结果
laoqi.name= LaoQi
info.name= qiwsir
-------
laoqi.lang= golang
info.lang= python
-------
laoqi.website= www.google.com
info.website= qiwsir.github.io
~~~
在编程界，有这样一句话，说“类是实例工厂”，什么意思呢？工厂是干什么的？生产物品，比如生产电脑。一个工厂可以生产好多电脑。那么，类，就能“生产”好多实例，所以，它是“工厂”。比如上面例子中，就有两个实例。
### [](https://github.com/qiwsir/StarterLearningPython/blob/master/207.md#函数方法)函数（方法）
还是回到本节开头的那个类。构造函数下面的两个函数：`def getName(self)`,`def color(self, color)`，这两个函数和前面的初始化函数有共同的地方，即都是以self作为第一个参数。
~~~
def getName(self):
return self.name
~~~
这个函数中的作用就是返回在初始化时得到的值。
~~~
girl = Person('canglaoshi')
name = girl.getName()
~~~
`girl.getName()`就是调用实例girl的方法。调用该方法的时候特别注意，方法名后面的括号不可少，并且括号中不要写参数，在类中的`getName(self)`函数第一个参数self是默认的，当类实例化之后，调用此函数的时候，第一个参数不需要赋值。那么，变量name的最终结果就是`name = "canglaoshi"`。
同样道理，对于方法：
~~~
def color(self, color):
print "%s is %s" % (self.name, color)
~~~
也是在实例化之后调用：
~~~
girl.color("white")
~~~
这也是在执行实例化方法，只是由于类中的该方法有两个参数，除了默认的self之外，还有一个color，所以，在调用这个方法的时候，要为后面那个参数传值了。
至此，已经将这个典型的类和调用方法分解完毕，把全部代码完整贴出，请读者在从头到尾看看，是否理解了每个部分的含义：
~~~
#!/usr/bin/env python
# coding=utf-8
__metaclass__ = type #新式类
class Person: #创建类
def __init__(self, name): #构造函数
self.name = name
def getName(self): #类中的方法（函数）
return self.name
def color(self, color):
print "%s is %s" % (self.name, color)
girl = Person('canglaoshi') #实例化
name = girl.getName() #调用方法（函数）
print "the person's name is: ", name
girl.color("white") #调用方法（函数）
print "------"
print girl.name #实例的属性
~~~
保存后，运行得到如下结果：
~~~
$ python 20701.py
the person's name is: canglaoshi
canglaoshi is white
------
canglaoshi
~~~
### [](https://github.com/qiwsir/StarterLearningPython/blob/master/207.md#类和实例)类和实例
有必要总结一下类和实例的关系：
* “类提供默认行为，是实例的工厂”（源自Learning Python），这句话非常经典，一下道破了类和实例的关系。所谓工厂，就是可以用同一个模子做出很多具体的产品。类就是那个模子，实例就是具体的产品。所以，实例是程序处理的实际对象。
* 类是由一些语句组成，但是实例，是通过调用类生成，每次调用一个类，就得到这个类的新的实例。
* 对于类的：`class Person`，class是一个可执行的语句。如果执行，就得到了一个类对象，并且将这个类对象赋值给对象名（比如Person）。
也许上述比较还不足以让看官理解类和实例，没关系，继续学习，在前进中排除疑惑。
## [](https://github.com/qiwsir/StarterLearningPython/blob/master/207.md#self的作用)self的作用
类里面的函数，第一个参数是self，但是在实例化的时候，似乎没有这个参数什么事儿，那么self是干什么的呢？
self是一个很神奇的参数。
在Person实例化的过程中`girl = Person("canglaoshi")`，字符串"canglaoshi"通过初始化函数（`__init__()`）的参数已经存入到内存中，并且以Person类型的面貌存在，组成了一个对象，这个对象和变量girl建立引用关系。这个过程也可说成这些数据附加到一个实例上。这样就能够以:`object.attribute`的形式，在程序中任何地方调用某个数据，例如上面的程序中以`girl.name`的方式得到`"canglaoshi"`。这种调用方式，在类和实例中经常使用，点号“.”后面的称之为类或者实例的属性。
这是在程序中，并且是在类的外面。如果在类的里面，想在某个地方使用实例化所传入的数据（"canglaoshi"），怎么办？
在类内部，就是将所有传入的数据都赋给一个变量，通常这个变量的名字是self。注意，这是习惯，而且是共识，所以，看官不要另外取别的名字了。
在初始化函数中的第一个参数self，就是起到了这个作用——接收实例化过程中传入的所有数据，这些数据是初始化函数后面的参数导入的。显然，self应该就是一个实例（准确说法是应用实例），因为它所对应的就是具体数据。
如果将上面的类稍加修改，看看效果：
~~~
#!/usr/bin/env python
# coding=utf-8
__metaclass__ = type
class Person:
def __init__(self, name):
self.name = name
print self #新增
print type(self) #新增
~~~
其它部分省略。当初始化的时候，就首先要运行构造函数，同时就打印新增的两条。结果是：
~~~
<__main__.Person object at 0xb7282cec>
<class '__main__.Person'>
~~~
证实了推理。self就是一个实例（准确说是实例的引用变量）。
self这个实例跟前面说的那个girl所引用的实例对象一样，也有属性。那么，接下来就规定其属性和属性对应的数据。上面代码中：
~~~
self.name = name
~~~
就是规定了self实例的一个属性，这个属性的名字也叫做name，这个属性的值等于初始化函数的参数name所导入的数据。注意，`self.name`中的name和初始化函数的参数`name`没有任何关系，它们两个一样，只不过是一种起巧合（经常巧合，其实是为了省事和以后识别方便，故意让它们巧合。），或者说是写代码的人懒惰，不想另外取名字而已，无他。当然，如果写成`self.xxxooo = name`，也是可以的。
其实，从效果的角度来理解，这么理解更简化：类的实例girl对应着self，girl通过self导入实例属性的所有数据。
当然，self的属性数据，也不一定非得是由参数传入的，也可以在构造函数中自己设定。比如：
~~~
#!/usr/bin/env python
#coding:utf-8
__metaclass__ = type
class Person:
def __init__(self, name):
self.name = name
self.email = "qiwsir@gmail.com" #这个属性不是通过参数传入的
info = Person("qiwsir") #换个字符串和实例化变量
print "info.name=",info.name
print "info.email=",info.email #info通过self建立实例，并导入实例属性数据
~~~
运行结果
~~~
info.name= qiwsir
info.email= qiwsir@gmail.com #打印结果
~~~
通过这个例子，其实让我们拓展了对self的认识，也就是它不仅仅是为了在类内部传递参数导入的数据，还能在初始化函数中，通过`self.attribute`的方式，规定self实例对象的属性，这个属性也是类实例化对象的属性，即做为类通过初始化函数初始化后所具有的属性。所以在实例info中，通过info.email同样能够得到该属性的数据。在这里，就可以把self形象地理解为“内外兼修”了。或者按照前面所提到的，将info和self对应起来，self主内，info主外。
怎么样？在"canglaoshi"的陪伴下，是不是明白了类的奥妙？
- 第零章 预备
- 关于Python的故事
- 从小工到专家
- Python安装
- 集成开发环境
- 第壹章 基本数据类型
- 数和四则运算
- 除法
- 常用数学函数和运算优先级
- 写一个简单的程序
- 字符串(1)
- 字符串(2)
- 字符串(3)
- 字符串(4)
- 字符编码
- 列表(1)
- 列表(2)
- 列表(3)
- 回顾list和str
- 元组
- 字典(1)
- 字典(2)
- 集合(1)
- 集合(2)
- 第贰章 语句和文件
- 运算符
- 语句(1)
- 语句(2)
- 语句(3)
- 语句(4)
- 语句(5)
- 文件(1)
- 文件(2)
- 迭代
- 练习
- 自省
- 第叁章 函数
- 函数(1)
- 函数(2)
- 函数(3)
- 函数(4)
- 函数练习
- 第肆章 类
- 类(1)
- 类(2)
- 类(3)
- 类(4)
- 类(5)
- 多态和封装
- 特殊方法(1)
- 特殊方法(2)
- 迭代器
- 生成器
- 上下文管理器
- 第伍章 错误和异常
- 错误和异常(1)
- 错误和异常(2)
- 错误和异常(3)
- 第陆章 模块
- 编写模块
- 标准库(1)
- 标准库(2)
- 标准库(3)
- 标准库(4)
- 标准库(5)
- 标准库(6)
- 标准库(7)
- 标准库(8)
- 第三方库
- 第柒章 保存数据
- 将数据存入文件
- mysql数据库(1)
- MySQL数据库(2)
- mongodb数据库(1)
- SQLite数据库
- 电子表格
- 第捌章 用Tornado做网站
- 为做网站而准备
- 分析Hello
- 用tornado做网站(1)
- 用tornado做网站(2)
- 用tornado做网站(3)
- 用tornado做网站(4)
- 用tornado做网站(5)
- 用tornado做网站(6)
- 用tornado做网站(7)
- 第玖章 科学计算
- 为计算做准备
- Pandas使用(1)
- Pandas使用(2)
- 处理股票数据
- 附：网络文摘
- 如何成为Python高手
- ASCII、Unicode、GBK和UTF-8字符编码的区别联系