python学习之类型和对象

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

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

除此之外，列表还支持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。

s [i ]          返回序列s的元素i
s [i :j ]       返回一个切片
len(s )         序列中元素的个数
min(s)          s 中的最小值
max(s)          s 中的最大值
s [i] = v       给某个元素赋新值
s [i:j] = t     用 序列 t 中的所有元素替换掉 s 序列中的索引从 i 至 j 的元素。
del s[i]        删除序列 s 中索引为 i 的元素。
del s [i :j ]   删除序列 s 中的索引从 i 至 j 的元素
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 模块。

内建函数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 对象。

映射类型用来表示通过关键字索引的任意对象的集合。和序列不同， 映射类型是无序的。映射类型可以使用数字、字符串、或其他不可变对象来索引。映射类型是可变类型。

字典是唯一的内建的映射类型。可以使用任何不可变的对象作为字典的关键字(如字符串、数字、元组等)。列表、字典、及包含可变对象的元组不可以作为关键字。(字典类型需要关键字的值保持不变)

使用索引运算符m[k](k为关键字)可以访问映射对象 m 中索引为 k 的元素。如果映射对象中没有 k 这个关键字，则引发KeyError异常。 len(m)函数返回一个映射对象的元素个数。

方法                                    描述
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 ])      使用字符转换表转换一个字符串
len(m)                  返回m中的条目个数
m[k]                    返回关键字k索引的元素
m[k] = x                设置关键字k索引的值为x
del m[k]                删除一个元素
m.clear()               删除所有元素
m.copy()                返回m的一个浅拷贝
m.has_key(k)            若 m 中存在 key k 返回True,否则返回False
m.items()               返回包含所有关键字和对应值(key ,value )的列表
m.keys()                返回由所有关键字组成的列表
m.update(b)             将字典b中的所有对象加入m
m.values()              返回一个包含m中所有对应值的列表
m.get(k[,v])            返回m[k]，若m[k]不存在时，返回 v
m.setdefault(k[,v])     返回m[k]，若m[k]不存在时，返回 v 并设置m[k] = v
m.popitem()             从 m 中随机删除一个元素，并以元组的形式返回其关键字和值
m.im_self               引用类实例对象，如果是非绑定方法，im_self通常为 None(见下面小注)
m.im_func               引用类中定义的方法对象
m im_class              引用定义该方法的类
m.__doc__               等于 m.im_func.__doc__
m.__name__              等于 m.im_func.__name__
m.__module__            等于 m.im_func.__module__
b.__doc__       文档字符串
b.__name__      函数/方法名
b.__self__      方法所绑定的实例(未绑定时，返回None)
b.__members__   方法的属性名(返回列表)
m.__dict__      保存模块名字空间的字典
m.__doc__       模块的文档字符串
m.__name__      模块名字
m.__file__      模块的文件名
m.__path__      当一个模块通过一个包被引用时，__path__是包的名字
c.__dict__      类 c 的名字空间
c.__doc__       类 c 的文档字符串
c.__name__      类 c 的名字
c.__module__    类 c 的定义所在的模块
c.__bases__     类 c 的所有父类（这是一个元组）
x.__dict__      实例 x 的名字空间
x.__class__     实例 x 所属的类
__getattr__(self , name)                返回属性 self.name
__setattr__(self , name , value)        设置属性 self.name = value
__delattr__(self , name)                删除属性 self .name
例如:

a = x.s       # 调用 __getattr__(x,"s")
x.s = b       # 调用 __setattr__(x,"s", b)
del x.s       # 调用 __delattr__(x,"s")
__lt__(self ,other )            self < other 
__le__(self ,other )            self <= other 
__gt__(self ,other )            self > other 
__ge__(self ,other )            self >= other 
__eq__(self ,other )            self == other 
__ne__(self ,other )            self != other
Integer                 12 bytes
Long integer            12 bytes + (nbits/16 + 1)*2 bytes
Floats                  16 bytes
Complex                 24 bytes
List                    16 bytes + 4 bytes(每个元素)
Tuple                   16 bytes + 4 bytes(每个条目)
String                  20 bytes + 1 byte(每个字符)
Unicode string          24 bytes + 2 bytes(每个字符)
Dictionary              24 bytes + 12*2n bytes, n = log2(nitems)+1
Class instance          16 bytes 加一个字典对象
Xrange object           24 bytes