python的内置对象

python的内置对象

对象类型	常量示例/用法
Number（数字）	3.14159, 1234, 999L 3+4j
String（字符串）	'spam', "guido's"
List（列表）	[1,[2, 'Three'],4]
Dictionary（字典）	{'food':'spam', 'taste':'yum'}
Tuple（元组）	(1,'spam',4,'U')
File（文件）	text=open('egges','r').read()

数字

常量

常量	解释
1234, -24, 0	正常整数（C的长整型）
999999999999999L	长整数（无限大小）
1.23, 3.14e-10, 4E210, 4.0e+210	浮点数（C的双整型）
0177, 0x9ff	八进制和十六进制常量
3+4j, 3.0+4.0j, 3J	复数常量

数字的表达式操作和预处理

操作	描述
x or y	逻辑或（只有x为假，y才被计算）
lambda args: expression	匿名函数
x and y	逻辑与（只有x为真的时候，y才被计算）
not x	逻辑反
<,<=,>,>=,==,<>,!=,	比较操作
is, is not,	身份测试
in, not in	序列成员关系测试
x | y	位或
x ^ y	位异或
x & y	位与
x<<y, x>>y	把x向左或向右移动y位
x+y, x-y	相加/合并，相减
x*y, x/y, x%y	乘/重复，除，余数/格式
-x, +x, ~x	一元取反，一致，位取补
x[i], x[i:j], x.y, x(...)	索引，分片，限定，函数调用
(...), [...], {...}, '...'	元组，列表，字典，转化为字符串

内置函数和内置模块用于数字处理：（模块是外部组件，但内置函数却包含在名字空间中）
>>> import math
>>> math.pi
3.14159265359
>>> abs(-42), 2**4, pow(2,4)
(42,16,16)

字符串

字符串常量和操作

操作	解释
S1 = ' '	空字符串
S2 = "spam 's"	双引号
block = " " " ..." " "	三引号块
s1 + s2	合并
s2 * 3	重复
s2[i]	索引
s2[i:j]	分片
len(s2)	长度
"a %s parror" % 'dead'	字符串格式
for x in s2,	迭代
'm' in s2	成员关系

string模块可到处大多数标准C库的字符串处理工具
regex和re模块为字符串田间了正则表达式匹配

空字符串可以写成中间为空的两个引号。注意字符串常量可以用单引号或双引号包围；两种方式都同样工作，但它们都允许一个引号字符出现在字符串内部而无需用反斜线转义。

三引号块（表第3行）：当字符串被三个引号围起来时，它们可以跨过多行。python将所有三引号文本收集到一个多行字符串中，该字符串带有嵌入的换行符。

>>> import string #标准的模块
>>> S = "spammify"
>>> string.upper(S) #转化为大写
>>> string.find(S, "mm") #返回索引的子串
>>> string.atoi("42"),'42' #转化字符串。atoi把字符串转化为一个数字，并把反引号所引的任何对象都转化为字符串形式的
(42,'42')
>>> string.join(string.split(S, ”mm", "XX") #split把一个字符串截成一列被界定符和空格符围绕的子字符串。join把它们放在一起，两个中间有一个传递性的分界符或空格。以"XX"代 替"mm"像是一个迂回方法，但是这是一个任意替代全局子字符串的方法。
'spaXXify'

普通类型的概念

    通用的概念在很多场合应用。就内置类型而言，同属一个类别的所有类型的操作都是相同的。

同种类型共享操作：字符串是不可变的序列，不能在原为被改变，而是有序的集合，可以根据偏移访问。

Python中有三种操作类别：
    数字：支持+ 和* 的操作
    序列：支持索引、分片、合并等操作
    映射：支持键索引等操作

可变类型在原位可以改变，不可变类型在原位不可以改变，只能制作一个拷贝。

列表

主要属性：任意对象的有序集合，通过偏移存取，可变长度、异构、任意嵌套，属于序列可变的类型，对象应用的数组

常用列表常量和操作

操作	解释
L1 = []	一个空的列表
L2 = [0,1,2,3]	四项：索引为0到3
L3 = ['abc', ['def', 'ghi']]	嵌套的子列表
L2[i], L3[i][j]	索引
L2[i:j]	分片
len(L2)	求长度
L1 + L2	合并
L3 * 3	重复
for x in L2,	迭代
3 in L2	成员关系
L2.append(4),	方法：增长
L2.sort(),	排序
L2.index(1),	查找
L2.reverse()	反转，等等
del L2[k] L2[i:j] = []	缩小
L2[i] = 1,	索引赋值
L2[i:j] = [4,5,6]	分片赋值
range(4), xrange(0,4)	生成整数的列表/元组

    append和sort在原位改变了关联的列表对象，但是不返回列表（严格地说，它们都返回一个叫None的值），如果写成L = L.append(X)的话，你不会得到L调整后的值（事实上，同时失去对列表的引用）。当使用append、sort这样的属性时，对象本身会同时被改 变，所以无需重新赋值。
    L.append(X)与L+[X]效果是类似的，但前者是在原位改变，后者生成一个新的列表。与“+”合并不同，append无需生成新的对象，所以它更快。

字典

    除了列表之外，字典可能是python中最有弹性的内置数据结构类型。列表是有序的对象集合，字典就是无序的集合；他们的主要区别就是字典中的项是通过键 来存取的，列表是通过偏移存取。字典的主要属性有：通过键而不是偏移量来存取，无序的任意对象集合，可变长度、异构、任意嵌套，属于可变映射类型，对象引 用表（散列表，但在底层，字典像列表一样存储对引用）

常见的字典对象常量和操作

操作	解释
d1 = {}	空的字典
d2 = {'spam':2, 'eggs':3}	两项的字典
d3 = {'food':{'ham':1,'egg':2}}	嵌套
d2['eggs'],d3['food']['ham']	通过键索引
d2.has_key('eggs'),	方法：成员关系测试，
d2.keys(),	键的列表
d2.values()	值的列表，等等
len(d1)	长度（所存储的项的数目）
d2[key] = new, del d2[key]	添加/改变 删除

    和列表一样，向字典中已经存在的索引进行赋值会改变与它相关联的值。与列表不同的是，一旦你给一个新的字典键赋值，你就在字典中生成了一个新的项。在列表 中不用，因为python认为超出了列表末尾的偏移就是越界的。要扩充一个列表，你要用append方法或者分片赋值。

>>> table = { ' Python': 'Guido van Rossum', 'Perl': 'Larry Wall', 'Tcl': 'John Ousterhout' }
>>> for lang in table.keys(): print lang, '\t', table[lang]

    因为字典不是序列的，你不能像在字符串和列表中那样直接通过一个for语句迭代它们。遍历各项就需要上面所述的方法。

请留意：字典接口

    有些python扩展程序还提供了表面与实际工作都和字典一样的接口。

python的dbm按键存取文件接口看上去特别像一个已经打开的字典：可用键索引来存储、取得字符串：
    import anydbm
    file = anydbm.open("filename") #连接到扩展文件
    file['key'] = 'data' #通过键存储数据
    data = file['key'] #通过键取得数据
如果我们用“shelve”代替“anydbm“，可以存储整个python的对象（shelve是通过键访问的持久的python数据库）

在Internet工作中，python的CGI脚本也支持实现了一个类似字典的接口。一个对cgi.FieldStorage范围的调用产生了一个类似字典的对象。在客户端Web页上每一个输入字段有一项：
    import cgi
    form = cgi.FieldStorage() #解析格式数据(stdin,environ)
    if form.has_key('name') :
        showReply('Hello, '+ form['name'].value)

使用字典的注意事项：序列操作不能工作，赋值给新的索引将添加项，键没有必要总是字符串

元组tuple

元组由简单的对象组构成。除了不能原位改变（它们是不可变的），并且通常写成一串圆括号中的项之外，元组与列表类似。元组的属性有：任意对象的有序集合，通过偏移存取，属于不可变序列类型，固定长度、异常、任意嵌套，对象引用的数组

常见的元组常量和操作

操作	解释
()	一个空的元组
t1 = (0,)	只有一项的元组（不是一个表达式）单项元组
t2 = (0,1,2,3,4)	一个有五项的元组
t2 = 0,1,2,3,4	另一个有五项的元组（同上一行一样）
t3 = ('abc', ('def', 'ghi'))	嵌套
t1[i], t3[i][j] t1[i:j] len(t1)	索引 分片 求长度
t1+t2 t2*3	合并 重复
for x in t2, 3 in t2	迭代 成员关系

    +、*和分片操作将返回新的元组，并且元组不提供我们在列表和字典中的方法。一般的说，在python中，只有可变对象可以输出可调用方法。

有了列表，为何还要使用元组？

元组的不可变性可以提供某些整体性能；你能可定的是在一个程序中一个元组不会被另一个引用改变。而列表就没有这样的保证。
某些内置操作也需要元组而不是列表。例如，内置函数apply动态调用函数的时候，参数表由元组构成
有一个来自实践的原则：列表可以用于想变动的有序集合的工具；元组则处理其他事情

文件

内 置函数open创建了一个python文件对象，可作为计算机中一个文件的链接。调用open后，通过调用文件对象的方法，你可以读写相关的外部文件。严 格地说，文件就是一个预建立的C扩展类型，提供了底层C stdio文件系统之上的一个包裹层。事实上，文件对象方法和C标准库中的函数是一一对应的。

常见的文件操作

操作	解释
output = open('/tmp/spam', 'w')	生成输出文件（'w'代表写）（'a'代表为在文件尾部追加内容而打开文件）
input = open('data', 'r')	生成输入文件（'r'代表读）
S = input.read()	把整个文件读到一个字符串中
S = input.read(N)	读N个字节（1个或多个）
S = input.readline()	读下一行（越过行结束标记）
L = input.readlines()	读取整个文件到一个行字符串的列表中
output.write(S)	把字符串S写入文件
output.writelines(L)	将列表L中所有的行字符串写到文件中
output.close()	手工关闭（或者在垃圾收集时进行）

在一个文件中seek函数复位当前位置。flush强制刷新缓存种终止输出便于写等等

>>> myfile = open('myfile','w')
>>> myfile.write('hello text file\n')
>>> myfile.close()
>>> myfile = open('myfile','r')
>>> myfile.readline()
'hello text file\012'
>>> myfile.readline() #空字符串：文件结尾
' '

文件类的可用工具

基于描述文件的文件
    os模块提供了使用低级基于描述文件的接口

DBM键（keyed）文件
    anydbm提供了一个通过键访问文件的接口

持久文件
    shelve和pickle模块对保存整个对象提供支持（不只是简单的字符串）

管道
    os模块也提供了POSIX接口以便于处理管道

其他
    还有些对数据库系统的可选接口，基于B树的文件，等等

＝＝＝＝＝＝总结＝＝＝＝＝＝

操作符重载：如果你想提供一个新的特殊的序列对象，它由内置序列组成，写一个类可以重载索引、分片、合并等操作：
    class MySequence:
        def __getitem__(self,index):
            # [index], for x in self, x in self
        def __getslice__(self,low,high):
            # called on self[low:high]
        def __add__(self,other):
            # called on self + other
    python的内置类型是真正的预编码C扩展程序类型。在你写自己的代码的时候，你需要知道类型的类别。

共性：列表、字典和元组可以包括任何种类的对象；列表、字典和元组可以任意嵌套；列表、字典可以动态扩大和缩小

比较、相等性和真值：
    ==操作符测试值是否相等
        python运行了一个相等测试，递归比较所有的内嵌对象。
    is 操作符测试对象的一致性
        python测试它们是否真的是同一个对象（例如：在同一个地址中）
示例对象真值

对象	值
"spam"	真
" "	假
[ ]	假
{ }	假
1	真
0.0	假
None	假

None总被认为是假的，他是python中唯一的特殊数据结构。它通常起一个空的占位作用，特别类似C语言中的Null指针。

Python的类型层次：Python中任何东西都是对象类型，可以由python程序处理

数字 → 整数 → 整数、长整数
       → 浮点数、复数

集合 → 序列 → 不可变的 → 字符串、元组
                  → 可变的 → 列表
       → 映射 → 字典

可调用的 → 函数、类、方法 → 绑定
                                   → 非绑定

其他 → 模块、实例、文件、空

内部 → 类型、代码、框架、轨迹

内置类型的常见问题

1. 赋值生成引用而不是拷贝
   >>> L = [1,2,3]
   >>> M = ['X', L ,'Y'] #对L的嵌套引用
   >>> M
   ['X', [1,2,3], 'Y']
   >>> L[1] = 0
   >>> M
   ['X', [1,0,3], 'Y']
   解决方法：这种影响通常只在大型程序中会很重要，而有的时候共享引用绝不是你真正想要的。如果不是这样，你可以通过拷贝他们以避免共享对象。在列表中，你总能生成使用一个空的有限分片生成的高级拷贝。
   >>> L = [1,2,3]
   >>> M = ['X', L[:] ,'Y'] #一个嵌入的L的拷贝
   >>> L[1] = 0 #只改变L，不改变M
   >>> M
   ['X', [1,2,3], 'Y']
2. 同层深度的重复加。当我们介绍序列重复的时候，我们说他有些像在序列后加上自身的某些倍数。这是正确的，但是当可变的对象嵌套的时候，效果可能不总向我们想的那样。
   >>> L = [4,5,6]
   >>> X = L * 4    # 类似[4,5,6]+[4,5,6]+...
   >>> Y = [L] * 4 # [L]+[L]+...
   >>> X
   [4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6]
   >>> Y
   [[4, 5, 6], [4, 5, 6], [4, 5, 6], [4, 5, 6]]
   >>> L[1] = 0 # 影响Y但是不影响X
   >>> X
   [4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6]
   >>> Y
   [[4, 0, 6], [4, 0, 6], [4, 0, 6], [4, 0, 6]]
   解决办法：这的确是另一个触发共享可被对象引用的方法，这样，上面同样的方法可以应用在左边。并且如果你记得重复、合并、分片复制只是在操作对象的顶层的话，这一类的例子更加有用。
3. 不可变类型在原位不可以被改变
   >>> T = (1,2,3)
   >>> T[2]=4
   Traceback (most recent call last):
   File "<stdin>", line 1, in ?
   TypeError: object does not support item assignment
   >>> T = T[:2]+(4,)
   >>> T
   (1, 2, 4)
   解决办法：用分片、合并等等操作生成一个新的对象。但是如果需要的话向后赋值给原引用。这样看上去像额外的编码工作，但是这样做的优点就是，当使用元组和字符串这样的不可变对象的时候，不会发生先前的问题。因为他们在原位置可以被改变，不会产生类似列表中的副作用。