2.1.2 Python详解类

1，新式类和旧式类

Python 2.x的版本中，有“新式类”和“旧式类（也叫做经典类）”之分。新式类是Python 2.2引进的，在此后的版本中，我们一般用的都是新式类。

注意，如果你用的是Python 3，就不用为新式类和旧式类而担心了，因为在Python 3中压根儿就不存在这个问题。

定义一个简单的类：

>>> class A:

pass

这定义了一个非常简单的类，而且是旧式类。

然后，将这个类实例化：

>>> a = A()

不要忘记实例化的时候类的名称后面有一对括号。接下来做如下操作：

>>> type(A)

<type 'classobj'>

>>> a.__class__

<class __main__.A at 0x02A1FA78>

>>> type(a)

<type 'instance'>

type（A）：查看类AA的类型，返回的是'classobj'。

aa.__class__：aa是一个实例，也是一个对象，每个对象都有__class__属性，用于显示它的类型。这里返回的结果是，从这个结果中可以读出的信息是，aa是类AA的实例，并且类AA在内存中的地址是0x02A1FA78。

type（a）：是要看实例aa的类型，它显示的结果是instance，意思是告诉我们它的类型是一个实例。

在这里是不是感觉有点不和谐呢？a.__class__和type（a）都可以查看对象类型，但是它们显示不一样的结果。

于是乎，就有了新式类，从Python 2.2开始，变成这样了：

>>> class B(object):

pass

>>> b = B()

>>> b.__class__

<class '__main__.B'>

>>> type(b)

<class '__main__.B'>

这就是新式类和旧式类的不同。

定义新式类的2种方式：

>>> class B(object):

pass

跟旧式类的区别就在于类的名字后面跟上（object），这其实是一种名为“继承”的类的操作

第二种方式：

>>> __metaclass__ = type

>>> class C:

pass

>>> c = C()

>>> c>__class__

>>> c.__class__

<class '__main__.C'>

>>> type(c)

<class '__main__.C'>

两种方法，任你选用，没有优劣之分。

2，创建类

在一般情况下，一个类不是两三行就能搞定的。所以，下面可能很少使用交互模式了，因为那样一旦有一点错误就前功尽弃。下面改用编辑界面。

#! /usr/bin/evn 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)

上面定义的是一个比较常见的类，下面对这个“大众脸”的类进行一一解释。

（1）新式类

__metaclass__=type，意味着下面的类是新式类。

（2）定义类

class Person，这是在声明创建一个名为“Person”的类。类的名称一般用大写字母开头，这是惯例。如果名称是两个单词，那么两个单词的首字母都要大写，例如class HotPerson，这种命名方法有一个形象的名字，叫作“驼峰式命名”。

分别以缩进表示的就是这个类的内容了。很多程序员喜欢把类里面的函数叫作“方法”，就是说到的对象的“方法”。

需要 再次提醒，函数的命名方法是以def发起，并且函数名称首字母不要用大写，可以使用aa_bb的样式，也可以使用aaBb的样式，一切看你的习惯了。

（3）初始化

def__init__这个函数一个比较特殊，并且有一个名字，叫作初始化函数。它是以两个下画线开始，然后是init，最后以两个下画线结束。

所谓初始化，就是让类有一个基本的面貌。做很多事情都要初始化，让事情有一个具体的起点状态。

此例子中的初始化函数就意味着实例化的时候，要给参数name提供一个值，作为类初始化的内容。

>>> girl = Person("liuyifei")

>>> print girl.name

liuyifei

很多时候，并不是每次都要从外面传入数据，有时候会把初始化函数的某些参数设置默认值，如果没有新的数据传入，就应用这些默认值。

>>> class Person:

def __init__(self,name,lang="golang",website="www.google.com"):

self.name = name

self.lang = lang

self.website = website

self.email = "python.@163.com"

>>> xiaowang = Person("xiaowang")

>>> info = Person("liuyifei",lang="hello",website="hello@163.com")

>>> print "xiaowang.name",xiaowang.name

xiaowang.name xiaowang

>>> print "info.name",info.name

info.name liuyifei

>>> print "xiaowang.lang=",xiaowang.lang

xiaowang.lang= golang

>>> print "info.lang=",info.lang

info.lang= hello

3，类中的函数（方法）

>>> __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)

构造函数的后面有两个函数：def getName（self）和def color（self，color），这两个函数和前面的初始化函数有共同的地方，都是以self作为第一个参数。

def getName(self):

return self.name

这个函数的作用就是返回在初始化时得到的值，初始化函数中self.name的值能够在这个函数中被使用，其原因就在于此函数中不可缺少的参数self。

>>> girl = Person("liuyifei") #实例化

>>> name = girl.getName() #调用方法（函数）

>>> name

'liuyifei'

girl.getName()就是调用实例girl的getName()方法（函数）。

同样道理，对于方法：

def color(self, color):

print "%s is %s" % (self.name, color)

可以这样调用：

>>> col = girl.color("white") #调用方法（函数）

liuyifei is white

这也是在执行实例化方法，只是由于类中的该方法有两个参数，除了默认的self之外，还有一个color，所以，在调用这个方法的时候，要为后面那个参数传值。

4，类和实例

类和实例的关系：

（1）“类提供默认行为，是实例的工厂”。所谓工厂，就是可以用同一个模子做出很多具体的产品。类就是那个模子，实例就是具体的产品。所以，实例是程序处理的实际对象。

（2）类由一些语句组成，但是实例通过调用类生成，每次调用一个类，就得到这个类的新的实例。

（3）命名类必须用class，例如class Person。Class发起了一个可执行的语句，如果执行，就得到一个类对象，并且将这个类对象赋值给对象名（比如Person）。

5，self作用

类里面的函数，第一个参数是self，而且不能省略。但是在实例化的时候，这个参数不需要写，也不需要为这个参数传值，似乎没有这个参数什么事儿了

在类内部，就是将所有传入的数据都赋给一个变量，通常这个变量的名字是self。注意，这是习惯，而且是共识，所以，你就不要费尽心机另外取别的名字了。

在初始化函数中的第一个参数self就是起到了这个作用——接收实例化过程中传入的所有数据，这些数据是初始化函数的参数导入的。显然，self应该就是一个实例（准确说法是应用实例），因为它所对应的就是具体数据。

它不仅仅是为了在类内部传递参数导入的数据，还能在初始化函数中，通过self.attribute的方式，规定self实例对象的属性，这个属性也是类实例化对象的属性，即作为类通过初始化函数初始化后所具有的属性。

6，文档注释

注释在编程当作 非常重要，一定要养成写注释的习惯。

在函数里面，可以用三重引号来写说明，在类中也可以，其实在文件开头的部分也能用三重引号写文档字符串说明。这样写的最大好处是能够用help()函数看。

"""这个类是描写整个文档的"""

def start_fun(arg):

"""这个时方法注释"""

pass

# 井号也是一个注释格式