转:python的内置对象

字符串

字符串常量和操作

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中有三种操作类别：
    数字：支持+ 和* 的操作
    序列：支持索引、分片、合并等操作
    映射：支持键索引等操作

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

列表

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

常用列表常量和操作

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

字典

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

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

    和列表一样，向字典中已经存在的索引进行赋值会改变与它相关联的值。与列表不同的是，一旦你给一个新的字典键赋值，你就在字典中生成了一个新的项。在列表 中不用，因为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

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

常见的元组常量和操作

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

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

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

文件

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

常见的文件操作

在一个文件中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测试它们是否真的是同一个对象（例如：在同一个地址中）
示例对象真值

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)
   解决办法：用分片、合并等等操作生成一个新的对象。但是如果需要的话向后赋值给原引用。这样看上去像额外的编码工作，但是这样做的优点就是，当使用元组和字符串这样的不可变对象的时候，不会发生先前的问题。因为他们在原位置可以被改变，不会产生类似列表中的副作用。