[:PythonEssentialRef3:Python精要参考第三章]

第三章 类型和对象

Python 程序中的一切数据都是对象。对象包括自定义对象及基本的数据类型如数值、字符串、列表、字典等。你能够以类或扩展类型的方式创建自定义对象。本章主要描述 Python对象模型及第四章--运算符与表达式中要用到的一些预备知识。

术语

程序中的一切数据都是对象，每个对象都有三个基本属性，即标识(类似人的标识证号)、类型和值。

例如，当你写下 a = 42 这行代码，你就创建了一个值为 42 的整数对象。 type()和id()函数用来查看对象的类型标识。id(a)可以查看该对象的标识(当前的实现是该对象在内存中的位置)。在这个例子中，a就是这个位置的引用。

一个对象的类别决定了可以对该对象进行何种操作(如，这个对象有长度吗?)。当一个特定类型的对象被创建时，这个对象被称为该类型的一个实例(注意：不要将类型的的实例和用户自定义类的实例混淆)。在一个对象被创建之后，它的标识和类型就再不能被改变。某些对象的值是可变的，这些对象就被称为可变对象(mutable);另一些对象的值是不可变的，那就被称为不变对象(immutable)。某类对象可以包含其它对象的引用，我们称这类对象为容器。

注1:关于类型的不可改变
从python2.2开始，Python开发小组开始有步骤的合并某些类别和类，因此书中的某些结论可能不是百分之百精确和完整。在某些特定条件下，有可能允许改变一个对象的类型。但是，在本手册扩展修订之前，我们就应该一如既往的认为这些经典类型是不可改变的。考虑到兼容性，python2.2和2.3也是这样默认处理的。

注2:不变对象的不可变并不是绝对的，当一个不变容器对象包含一个可变对象的引用时，可变对象的值变化会引起该不变容器对象的值发生变化。这种情况下，我们仍然认为该容器对象为不变对象，因为该容器所包含并不是引用对象的值，而仅仅是该对象的引用，这里的引用可以理解为该对象的内存地址。不管被包含对象的值如何变化，被包含对象的引用确实是始终不变的)。一个对象是否可变取决于它的类型，举例来说，数字、字符串、tuple类型是不可变类型，字典与列表是可变类型。

--WeiZhong

除了保存值以外，许多对象还拥有一系列的属性(attribute)。广义的属性是指对象的相关数据或者该对象能够具有的行为（如狗对象拥有颜色体重等相关数据，还拥有叫、吃、跑等行为，这些都是对象的广义的属性），狭义的属性只包含对象的相关数据，对于对象的行为，更常用的叫法是方法(method)。方法是对象可调用的属性，一个对象有多少个方法(method)，它就具有多少种行为。要访问一个对象的属性或者调用一个对象方法，使用点(.)操作符：

a = 3 + 4j              # 创建一个复数
r = a.real              # 取得一个复数的实部，访问该对象的一个属性

b = [1, 2, 3]           # 创建一个列表)
b.append(7)             # 使用 append 方法为列表加入新的元素

对象的标识与类型

内建函数id()返回一个对象的标识。该返回值是一个整数，目前的实现该整数通常就是对象在内存中的位置。is 运算符用来比较两个对象的标识。内建函数type()返回一个对象的类型:

   1 # 比较两个对象
   2 def compare(a,b):
   3     print 'The identity of a is ', id(a)
   4     print 'The identity of b is ', id(b)
   5     if a is b:
   6         print 'a and b are the same object'
   7     if a == b:
   8         print 'a and b have the same value'
   9     if type(a) is type(b):
  10         print 'a and b have the same type'

对象的类型也是对象，这个对象具有唯一性。对同一类型的所有实例应用type()函数总是会返回同一个类型对象。因此，类型之间可以使用 is 运算符来进行比较。标准模块 types 内包含所有内建类型对象，我们可以通过它来完成类型检查工作:

   1 import types
   2 if type(s) is types.ListType:
   3     print 'Is a list'
   4 else:
   5     print 'Is not a list'

若要比较两个自定义类实例对象的类型，最好是使用isinstance()函数。 函数 isinstance(s,C)用于测试 s 是否是 C 或 C 的子类的实例。详细内容请参阅第七章--类和面向对象的编程。

引用计数与垃圾收集

一切对象都是引用计数的。当分配一个新的名字给一个对象，或者其将放入到一个容器比如列表、元组、或者字典中，该对象的引用计数就会增加1次。如:

   1 a = 3.4      # 创建一个对象 '3.4'，引用计数为 1
   2 b = a        # 对象 '3.4' 引用计数增加 1，此时对象 '3.4' 的引用计数为 2
   3 c = []
   4 c.append(b)  # 对象 '3.4' 引用计数增加 1，此时对象 '3.4' 的引用计数为 3

例子中创建了一个包含值3.4的一个对象。变量 a 是一个指向该对象的名字。当用 a 来为 b 赋值时，b 成为同一个对象新的名称，此时对象的引用计数就会增1。同样地， 当你把 b 放入一个列表中时，对象的引用计数再次增1。在例子中，自始至终只有一个值为 3.4 的整数对象，b 与 c[0] 都仅仅是该对象的引用。

del语句、脱离变量作用域或者变量被重新定义，都会使对象的引用计数减少。

   1 del a           # 直接删除一个引用，对象 3.4 引用减1
   2 b = 7.8         # 某个引用被赋新值，对象 3.4 引用减1
   3 c[0]=2.0        # 某个引用被赋新值，对象 3.4 引用减1

当一个对象的引用计数减少至零时，它就会在适当时机被垃圾回收车拉走。然而，特定情况(循环引用)会阻止垃圾回收车销毁不再使用的对象，看下面的例子：

   1 a = { }         # a 的引用为 1
   2 b = { }         # b 的引用为 1
   3 a['b'] = b              # b 的引用增 1，b的引用为2
   4 b['a'] = a              # a 的引用增 1，a的引用为 2
   5 del a           # a 的引用减 1，a的引用为 1
   6 del b           # b 的引用减 1,  b的引用为 1

在这个例子中,del语句减少了 a 和 b 的引用计数并删除了用于引用的变量名，可是由于两个对象各包含一个对方对象的引用，虽然最后两个对象都无法通过名字访问了，但引用计数并没有减少到零。因此这个对象不会被销毁，它会一直驻留在内存中，这就造成了内存泄漏。为解决这个问题，Python解释器会定期的运行一个搜索器，若发现一个对象已经无法被访问，不论该对象引用计数是否为 0 ，都销毁它。这个搜索器的算法可以通过 gc 模块的函数来进行调整和控制。具体内容参阅附录A：Python 库。

引用与副本

当运行语句 a = b 时，就创建了对象 b 的一个新引用a。对于不可变对象(数字或字符串等)，改变对象的一个引用就会创建一个新对象。

   1 a=100                   #创建一个新对象 100
   2 b=a                     #对象 100 增加了一个新的引用 b
   3 print id(a),id(b)       #打印 a 和 b 的标识，你会发现两个标识是相同的
   4 b=20                    #现在 b 不再是 a 的引用，变成新对象 20 的一个引用了
   5 print id(a),id(b)       #现在 a 和 b 的标识不再相同

对于可变对象(列表或字典等)，改变对象的一个引用就等于改变了该对象所有的引用，见下例:

   1 b = [1,2,3,4]
   2 a = b                   # a 是 b 的一个引用
   3 a[2] = -100             # 改变 a 中的一个元素
   4 print b                 # b的值也随之改变为 '[1, 2, -100, 4]'

因为 a 和 b 指向相同的对象，所以改变了 a 就等于改变了 b 。为了避免这种情况，你应该创建一个可变对象的副本，然后对该副本进行操作。这样就不会影响到原始对象了。

有两种方法用来创建可变对象的副本：浅复制(shallow copy)和深复制(deep copy)。浅复制创建一个新对象，但它包含的子元素仍然是原来对象子元素的引用:

   1 b = [ 1, 2, [3,4] ]
   2 a = b[:]                # 创建b的一个 浅拷贝 a
   3 a.append(100)           # a 对象添加一个新元素
   4 print b                 # 打印 b 的值，得到 '[1,2, [3,4]]'， b 没有改变
   5 a[0]=-100               # 改变 a 的一个不可变子对象
   6 print b                 # 打印 b 的值，得到 '[1,2, [3,4]]'， b 没有改变
   7 a[2][0] = -100          # 改变 a 的一个可变子对象
   8 print b                 # 打印 b 得到 '[1,2, [-100,4]]'，b 被改变了

a 和 b 虽然是彼此独立的对象，但他们包含的元素却是共享的。这样，修改 a 中的一个可变元素也会影响 b 中的这个可变元素。

深复制创建一个新对象，并递归复制所有子对象。python并没有内建的深复制函数，不过在标准库中提供有一个copy模块，该模块有一个deepcopy()函数可以漂亮的干这件事：

   1 import copy
   2 b = [1, 2, [3, 4] ]
   3 a = copy.deepcopy(b)

内建类型

Python的解释器内建数个大类，共二十几种数据类型，表 3.1列出了全部内建类型。一些类别包含最常见的对象类型，如数值、序列等，其它类型则较少使用。后面几节将详细描述这些最常用的类型。

表 3.1 Python内建类型
分类                              类型名称                    描述
None                            NoneType                        null 对象
数值                            IntType                         整数
                                LongType                        任意精度整数
                                FloatType                       浮点数
                                ComplexType                     复数
序列                            StringType                      字符串
                                UnicodeType                     Unicode字符串
                                ListType                        列表
                                TupleType                       元组
                                XRangeType                      xrange()函数返回的对象
                                BufferType                      buffer()函数返回的对象
映射                            DictType                        字典
可调用类型                      BuiltinFunctionType             内建函数
                                BuiltinMethodType               内建方法
                                ClassType                       类
                                FunctionType                    用户定义函数
                                InstanceType                    类实例
                                MethodType                      Bound class method
                                UnboundMethodType               Unbound class method
模块                            ModuleType                      模块
类                              ClassType                       类定义
类实例                          InstanceType                    类实例
文件                            FileType                        文件对象
内部类型                        CodeType                        字节编译码
                                FrameType                       执行框架
                                TracebackType                   异常的堆栈跟踪
                                SliceType                       由扩展切片操作产生
                                EllipsisType                    在扩展切片中使用

注意: ClassType和InstanceType在表中之所以出现两次，是因为在特定环境下类及类实例都能被调用。

None类型

None表示空对象。如果一个函数没有显式的返回一个值，None就被返回。None经常被用做函数中可选参数的默认值。None对象没有任何属性。None的布尔值为假。

数值类型

Python拥有四种数值类型:整型,长整型,浮点类型,以及复数类型。所有数值类型都是不可变类型。

整数类型用来表示从-2147483648 到 2147483647之间的任意整数(在某些电脑系统上这个范围可能会更大，但绝不会比这个更小)。在系统内部，一个整数以一个32位或者更多位的二进制补码形式储存。如果某次整数运算的结果超出了这个表示范围，一般情况下Python会自动将运算结果由整型升级为长整型返回，不过在有些情况下会引发一个溢出异常，我们正在努力彻底消灭这个异常(OverflowError)。

长整数可以表示任意范围的整数(只要你的内存足够大就行)。

Python中只有双精度浮点数(64位)，它提供大约17个数字的精确度和-308到308的指数，这与C中的double类型相同。Python不支持32位单精度的浮点数。如果你的程序很关心精确度和存储空间，推荐你使用Numerical Python (http://numpy.sourceforge.net`)`。

复数使用一对浮点数表示，虚数 z 的实部和虚部分别用 z.real 和 z.imag 访问。

序列类型

序列是由非负整数索引的对象的有序集合。它包括字符串、Unicode字符串、列表、元组、xrange对象以及缓冲区对象。字符串和缓冲区对象是字符序列，xrange对象是整数的序列，列表和元组是任意Python对象的序列。字符串、Unicode字符串及元组是不可变序列，列表是可变序列，允许插入，删除，替换元素等操作。缓冲区对象将在本节后面详细描述。

Table 3.2列出所有序列对象均支持的操作及方法。序列 s 中的元素 i 使用索引运算符 s[i] 来访问，通过切片运算符 s[i:j] 可以得到一个序列的子序列(这些运算符在第四章有详细介绍)。内建函数 len(s) 可以返回任意序列 s 的长度。你还能使用内建函数 min(s) 和 max(s) 来获得一个序列的最大值和最小值。不过，这两个函数必须使用在元素可排序的序列中(典型的可排序序列是数值和字符串)。

Table 3.3介绍了可变序列(如列表)支持的其它操作 Table 3.2. 所有序列类型都支持的操作和方法

项目              描述
s [i ]          返回序列s的元素i
s [i :j ]       返回一个切片
len(s )         序列中元素的个数
min(s)          s 中的最小值
max(s)          s 中的最大值

'''Table 3.3. 可变序列适用的操作'''
项目              描述
s [i] = v       给某个元素赋新值
s [i:j] = t     用 序列 t 中的所有元素替换掉 s 序列中的索引从 i 至 j 的元素。
del s[i]        删除序列 s 中索引为 i 的元素。
del s [i :j ]   删除序列 s 中的索引从 i 至 j 的元素

除此之外，列表还支持Table 3.4中的方法。内建函数 list(s) 把可以把任意一个序列对象转换为一个列表。如果 s 本身是一个列表，这个函数就创建一个 s 的浅拷贝。 s.append(x) 方法可以在列表的末尾加入一个元素 x。 s.index(x) 方法在列表中查找值 x 第一次出现时的索引，若没有找到就引发一个ValueError异常。同样地，s.remove(x)方法删除第一次出现的值 x。 s.extend(t)方法通过将链表 t 的所有元素添加到 s 的末尾来扩充列表s。 s.sort()方法会将列表中的元素进行排序，该方法接受自定义比较函数，自定义比较函数必须有两个参数，若参数1小于参数2，则返回-1，若参数1等于参数2，返回0，否则就返回1。 s.reverse()方法反转列表中的所有元素。sort()和reverse()方法都是直接操作列表中元素并返回None。

Table 3.4. 列表的方法

方法                      描述
list(s )                把序列s转换为一个列表
s.append(x)             把一个元素添加到列表的结尾,相当于` s[len(s):] = [x]`
s.extend(t)             将链表 t 的所有元素添加到 s 的末尾来扩充列表 s，相当于 `s[len(s):] = t`
s.count(x)              返回值 x 在列表 s 中出现的次数
s.index(x)              返回列表s中第一个值为 x 的元素的索引值
s.insert(i,x)           在 s[i] 前插入一个元素 x
s.pop([i])              返回 s[i] 的值并将 s[i] 元素从列表中删除。如果 i 被省略，` s.pop()` 就对最后一个元素进行操作。
s.remove(x )            删除列表中值为 x 的第一个元素
s.reverse()             翻转 s 中的全部元素
s.sort([cmpfunc ])      对列表 s 中的元素进行排序，cmpfunc 是一个可选的比较函数

字符串类型

Python拥有两种字符串类型。标准字符串是单字节字符序列，允许包含二进制数据和嵌入的null字符。 Unicode 字符串是双字节字符序列，一个字符使用两个字节来保存，因此可以有最多65536种不同的unicode字符。尽管最新的Unicode标准支持最多100万个不同的字符，Python现在尚未支持这个最新的标准。

标准字符串和Unicode字符串都支持表 3.5中的方法。虽然这些方法都是用于操作一个字符串实例，但所有的字符串方法都不会改变原始字符串。它们有的返回一个新得字符串，如 s.capitalize(), s.center(), s.expandtabs()。有的返回True或者False,如特征测试方法 s .isalnum() 和 s .isupper()，值得一提的是，这些方法当字符串长度为零时返回False。 s .find()、 s .rfind()、s .index()、 s .rindex() 方法被用来在 s 中寻找一个子串，如果找到子串，这些函数都返回s的整数索引值。 当找不到子串时,find()方法返回-1，而index()方法则引发一个 ValueError 异常。有很多数字符串方法接受两个可选的参数：start 和 end ，用于指定 s 中开始位置和结束位置的索引。s.translate()方法根据一个字典来转换原始字符串，该函数在附录A中的 string模块中有详细描述。 s.encode()` 方法用来将字符串转换为指定的字符集，如'ascii'、 'utf-8' 或 'utf-16'等。这个方法主要用于将 Unicode字符串转换为适合输入输出的字符编码，关于此方法的的详细介绍在第九章--输入和输出。要了解更多关于字符串方法的细节请参阅附录A中的 string 模块。

Table 3.5. 字符串方法

方法                                      描述
s.capitalize()                          第一个字母变大写
s.count(sub [,start [,end ]])           子串sub出现的次数
s.encode([encoding [,errors ]])         改变字符串的编码                
s.startswith(prefix [,start [,end ]])   检查字符串的开头是否为prefix
s.endswith(suffix [,start [,end ]])     检查字符串的结尾是否是suffix       
s.expandtabs([tabsize ])                将制表符转换为一定数量的空格
s.find(sub [,start [,end ]])            返回子串 sub 首次出现的位置或者 -1
s.rfind(sub [,start [,end ]])           返回子串 sub 末次出现的位置或者 -1
s.index(sub [,start [,end ]])           返回子串 sub 首次出现的位置或者引起异常
s.rindex(sub [,start [,end ]])          返回子串 sub 末次出现的位置或者引发异常
s.isalnum()                             字符是否都为字母或数字
s.isalpha()                             字符是否都为字母
s.isdigit()                             字符是否都为数字
s.islower()                             字符是否都为小写
s.isspace()                             字符是否都为空白
s.istitle()                             检查字符是否为标题格式(每个单词的第一个字母大写)
s.isupper()                             字符是否都为大写
s.join(t)                               用 s 连接 t 中的所有字符串
s.center(width)                         在长度为 width 范围内将字符串置中
s.ljust(width )                         在宽度为 width 内左对齐
s.rjust(width )                         在宽度为 width 内右对齐
s.lower()                               s 中所有字符小写
s.upper()                               s 中所有字符大写
s.replace(old , new [,maxreplace ])     将子串 old 替换为 new
s.lstrip()                              删去字符串s开头的空白
s.rstrip()                              删去字符串s末尾的空白
s.strip()                               删去字符串s开头和末尾的空白
s.split([sep [,maxsplit ]])             将字符串 s 分割成一个字符串列表，其中 sep 为分隔符，maxsplit是最大分割次数
s.splitlines([keepends ])               将字符串按行分割为一个字符串列表，若keepends为1，则保留换行符'\n'
s.swapcase()                            串内字符大写变小写，小写变大写，没有大小写的不变
s.title()                               s 转换为标题格式(每个单词的第一个字母大写)
s.translate(table [,deletechars ])      使用字符转换表转换一个字符串

XRangeType 类型

内建函数range([i,]j[,stride])建立一个整数列表，列表内容为k(i <= k < j)。第一个参数i和第三个参数stride是可选的，默认值分别为 0 和 1 。内建函数xrange([i,]j[,stride])与 range 有相似之处，但xrange返回的是一个不可改变的XRangeType对象。这是一个迭代器，也就是只有用到那个数时才临时通过计算提供值。当 j 值很大时，xrange能更有效地利用内存。XRangeType提供一个方法 s.tolist()，它可以将自己转换为一个列表对象返回。

缓冲区类型

缓冲区对象将内存的一个连续区域模拟为一个单字节字符序列。Python没有直接创建缓冲区对象的语句，你可以使用内建函数buffer(obj[,offset[,size]])来创建此类对象。 缓冲区对象与对象 obj 共享相同的内存，对于字符串切片操作或者其他字节数据操作来说，这样会有非常高的效率。另外， 缓冲区对象还可以用来访问其他Python类型储存的原始数据，比如array模块中的数组、 Unicode字符串等。缓冲器对象是否可变，取决于 obj 对象。