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, ' ', 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
')
>>> myfile.close()
>>> myfile = open('myfile','r')
>>> myfile.readline()
'hello text file 12'
>>> 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程序处理
数字 → 整数 → 整数、长整数
→ 浮点数、复数
集合 → 序列 → 不可变的 → 字符串、元组
→ 可变的 → 列表
→ 映射 → 字典
可调用的 → 函数、类、方法 → 绑定
→ 非绑定
其他 → 模块、实例、文件、空
内部 → 类型、代码、框架、轨迹
内置类型的常见问题
- 赋值生成引用而不是拷贝
>>> 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'] - 同层深度的重复加。当我们介绍序列重复的时候，我们说他有些像在序列后加上自身的某些倍数。这是正确的，但是当可变的对象嵌套的时候，效果可能不总向我们想的那样。
>>> 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]]
解决办法：这的确是另一个触发共享可被对象引用的方法，这样，上面同样的方法可以应用在左边。并且如果你记得重复、合并、分片复制只是在操作对象的顶层的话，这一类的例子更加有用。 - 不可变类型在原位不可以被改变
>>> 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)
解决办法：用分片、合并等等操作生成一个新的对象。但是如果需要的话向后赋值给原引用。这样看上去像额外的编码工作，但是这样做的优点就是，当使用元组和字符串这样的不可变对象的时候，不会发生先前的问题。因为他们在原位置可以被改变，不会产生类似列表中的副作用。