Python序列：字符串，列表和元组（一）

Python序列

Python中有一些类型，它们的 成员有序排列，可以通过下标来访问，这种类型统一被称为序列，包括列表，字符串，数组。其中字符串和元组属于不可变类型，即无法通过下标来赋值。如a[0]=’1’，而列表属于可变类型，可以通过下标来赋值。这篇帖子主要讲字符串，列表和元组在后面的帖子再讲。

1 序列

序列类型有着相同的访问模式：它的每一个元素可以通过指定一个偏移量的方式得到。而多个元素可以通过切片操作的方式一次得到。

1.1 标准类型操作符

Python中的标准类型操作符，即算术操作符、比较操作符、逻辑操作符，可以用作序列类型。

1.2 序列类型操作符

Python中对序列都适用的操作符，有：

成员关系操作符: in, not in
obj in seq，判断obj是否在seq中

链接操作符: +
把一个序列和另一个相同类型的序列做连接
seq1 + seq2

重复操作符: *

seq * int_num

可以获得一个序列的拷贝

>>> a
['2', '2']
>>> a*2
['2', '2', '2', '2']

切片操作符: [],[:],[::]

用索引来获取序列类型的某个元素，或者指定开始或者结束元素，用来获取一段连续的元素。

1.3 内建函数

内建函数list(), str(),和tuple()被用做在各种序列类型之间转换。你可以把它们理解成其它语言的类型转换，但是不是真正的类型转换，因为会将元素值的索引赋值给新创建的元素，也就是说，list()等函数返回值的元素地址，和list()传入参数的返回值地址相同，即使是不同类型之间的转换(浅拷贝)！比如：

>>> a
['2', '2']
>>> b = str(b)
>>> b
"['2', '2']"
>>> id(a[0])
139874793120072
>>> id(b[2])
139874793120072

可以看到a中的元素第一个2和b中元素的第一个2，内存地址相同！

还有一些可操作函数：
enumerate(iter)
len(seq)
max(iter,key=None)
min(iter, key=None)
reversed(seq)
sorted(iter, func=None, key=None, reverse=False)
sum(seq, init=0)
zip([it0, it1,… itN])

等等，后面会提到。

2 字符串

Python里，用单引号或者双引号来表示一个字符串，可以用索引来访问每一个元素，包括切片。
删除字符串：可以通过给字符赋值空值或者用del关键字

>>> a = 'asdf'
>>> del a
>>> a
Traceback (most recent call last):
  File "", line 1, in 
NameError: name 'a' is not defined

>>> a = 'asdfasdf'
>>> a = ''
>>> a
''

看来赋空值还没法删除a

在字符串中，没法用a[0]=’s’这类方法给字符串赋值，因为字符串，元组，数值类型都是不可更新类型，如果想要改变某个字符串的值，就必须通过创建一个新串来实现。比如，可以通过切片技术来获取一个新串。

3 字符串和操作符

3.1 标准类型操作符

链接+，成员操作符(in , not in )很简单了，不用说了。

普通字符串转化为 Unicode 字符串：
如果把一个普通字符串和一个 Unicode 字符串做连接处理,Python 会在连接操作前先把普通字符串转化为 Unicode 字符串:

>>> a = '1'
>>> a
'1'
>>> a = a + u'2'
>>> a
u'12'

4 只适用于字符串的操作符

4.4.1 格式化操作符(%)

>>> "%+d"
'%+d'
>>> "%+d" % 4
'+4'
>>> "%+d" % 10
'+10'
>>> "%+d" % -10\
... 
'-10'
>>> "%+d" % -10
'-10'
>>> repr(1)
'1'
>>> repr('a')
"'a'"
>>> `a`
"u'12'"

更多的就不写了，还有很多用法，网上有。

4.4.2 字符串模板

>>> from string import Template
>>> s = Template('There are ${howmany} ${lang} Quotation Symbols')
>>>
>>> print s.substitute(lang='Python', howmany=3) There are 3 Python Quotation
Symbols
>>>
>>> print s.substitute(lang='Python') Traceback (most recent call last):
File "", line 1, in ?
File "/usr/local/lib/python2.4/string.py", line 172, in substitute
return self.pattern.sub(convert, self.template)
File "/usr/local/lib/python2.4/string.py", line 162, in convert val =
mapping[named]
KeyError: 'howmany'
>>>
>>> print s.safe_substitute(lang='Python') There are ${howmany} Python Quotation
Symbols

4.4.3 原始字符串操作符

有时候，我们不像让字符串里的转义字符发生作用，我们可以使用r/R来让字符串变为原始字符串，这样就不会解释转义字符了。使用小写r或者大写R都可以。如下的例子：

>>> a = '\nasdkfjsad\t'
>>> print a

asdkfjsad   
>>> a = r'\nasdkfjsad\t'
>>> print a
\nasdkfjsad\t

4.4.4 unicode字符串操作符

和上面的原始字符操作符用法基本一样，如下例子：

>>> a = 'asdf'
>>> a = u'asdf'
>>> a
u'asdf'

5 内建函数

5.1 标准类型函数

cmp()

>>> str1 = 'abc'
>>> str2 = 'lmn'
>>> str3 = 'xyz'
>>> cmp(str1, str2)
-11
>>> cmp(str3, str1)
23
>>> cmp(str2, 'lmn')
0

5.2 序列类型函数

这类函数，会举一些小例子：

len()

>>> a
u'asdf'
>>> len(a)
4

max() and min()

>>> a
u'asdf'
>>> len(a)
4
>>> max(a)
u's'
>>> min(a)
u'a'

显然，max和min函数是返回字符串中ascii值最大的和最小的元素

enumerate()

>>> a = 'asdf'
>>> for i , j in enumerate(a):
...   print i ,j
... 
0 a
1 s
2 d
3 f

zip()

>>> zip('123', 'abc')
[('1', 'a'), ('2', 'b'), ('3', 'c')]
>>> a = zip('123', 'abc')
>>> type(a)
'list'>
>>> a = zip('1234', 'abc')
>>> a
[('1', 'a'), ('2', 'b'), ('3', 'c')]
>>> a = zip('12', 'abc')
>>> a
[('1', 'a'), ('2', 'b')]
>>> a = zip('123', 'ac')
>>> a
>>>> a = zip('123', 'ac', 'cvb')
>>> a
[('1', 'a'), ('2', 'c')]
[('1', 'a', 'c'), ('2', 'c', 'v')]
>>> a = zip('123', 'ac', 'cvbfff')
>>> a
[('1', 'a', 'c'), ('2', 'c', 'v')]

可以看出，zip返回一个list列表，把所有参数的第一个元组组成一个元组存储到列表里，再把所有参数的第二个元素都存储在一个元组里，然后再存储到列表里，依次下去，直到其中有一个参数没有元素为止。

6 字符串内建函数

string.find(str, beg=0,end=len(string))
检测 str 是否包含在 string 中,如果 beg 和 end 指定范围,
则检查是否包含在指定范围内,如果是返回开始的索引值,否则
返回-1

string.index(str, beg=0,end=len(string))
跟 find()方法一样,只不过如果 str 不在 string 中会报一个异常.

string.count(str, beg=0,end=len(string))
返回 str 在 string 里面出现的次数,如果 beg 或者 end 指定则
返回指定范围内 str 出现的次数

string.join(seq) Merges (concatenates)以 string 作为分隔符,将 seq 中所有的元素
(的字符串表示)合并为一个新的字符串

>>> a = ['a', 'b', 'c']
>>> " ".join(a)
'a b c'
>>> a = ('a', 'b', 'c')
>>> " ".join(a)
'a b c'
>>> " ".join('abc')
'a b c'

如上所示：元组，列表，字符串都可以当做参数，但是只能是元素只能是字符串，不能传入如[1, 2, 3]这种的列表，因为不接受整数。

string.lstrip() 截掉 string 左边的空格
string.rstrip() 删除 string 字符串末尾的空格.
string.strip([obj])在 string 上执行 lstrip()和 rstrip()
string.split(str=”“, num=string.count(str)) 以 str 为分隔符切片 string,如果 num有指定值,则仅分隔 num 个子字符串

别的函数就不列举了。这几个对我来说很常用。

Unicode

从Python1.6起就开始引进对于字符串的支持，是用来在多种双字节字符的格式、编码进行转换的,其中包括一些对这类字符串的操作管理功能。

unicode术语：

ASCII：美国标准信息交换码
Code point：类似于 ASCII 值,代表 Unicode 字符的值,范围在 range(1114112)或者说0x000000 到 0x10FFFF.
UTF：Unicode 或者 UCS 的转换格式.
UTF-8：八位 UTF 转换格式(无符号字节序列, 长度为一到四个字节)
UTF-16：16 位 UTF 转换格式(无符号字节序列,通常是 16 位长[两个字节],见 UCS2)

UTF-8是unicode编码的其中一种，ASCII在UTF-8编码中，其值和ASCII一样，所以，UTF-8编码很受欢迎。