对象
对象是python语言中最基本的概念，在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() |
1.数字
常量 | 解释 |
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 y'<<'x | 把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)2.字符串
操作 | 解释 |
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'3. 普通类型的概念
- 通用的概念在很多场合应用。就内置类型而言，同属一个类别的所有类型的操作都是相同的。
- 同种类型共享操作：字符串是不可变的序列，不能在原为被改变，而是有序的集合，可以根据偏移访问。
数字 | 支持+ 和* 的操作 |
序列 | 支持索引、分片、合并等操作 |
映射 | 支持键索引等操作 |
- 可变类型在原位可以改变，不可变类型在原位不可以改变，只能制作一个拷贝。
4. 列表
- 主要属性：任意对象的有序集合，通过偏移存取，可变长度、异构、任意嵌套，属于序列可变的类型，对象应用的数组
操作 | 解释 |
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无需生成新的对象，所以它更快。
5.字典
除了列表之外，字典可能是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语句迭代它们。
- 遍历各项, 需采用：dict.keys() 或者 dict.values() ，类似上面所述的方法。
， 请留意：字典接口
- 有些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)- 使用字典的注意事项：序列操作不能工作，赋值给新的索引将添加项，键没有必要总是字符串
5. 元组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动态调用函数的时候，参数表由元组构成
- 有一个来自实践的原则：列表可以用于想变动的有序集合的工具；元组则处理其他事情
6. 文件
- 内置函数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)解决办法: 用分片、合并等等操作生成一个新的对象。但是如果需要的话向后赋值给原引用。这样看上去像额外的编码工作，但是这样做的优点就是，当使用元组和字符串这样的不可变对象的时候，不会发生先前的问题。因为他们在原位置可以被改变，不会产生类似列表中的副作用。
