Python中的序列

• 序列类型操作符
  序列操作符                                   作用
  seq[ind]                        获得下标为ind 的元素
  seq[ind1:ind2]              获得下标从ind1 到ind2 间的元素集合
  seq * expr                    序列重复expr 次
  seq1 + seq2                  连接序列seq1 和seq2
  obj in seq                      判断obj 元素是否包含在seq 中
  obj not in seq               判断obj 元素是否不包含在seq 中

>>> a = [1,2,3,4,5]
>>> a
[1, 2, 3, 4, 5]
>>>
>>>
>>> a*3
[1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
>>> a
[1, 2, 3, 4, 5]
>>> b=[2,3,4]
>>> a+b
[1, 2, 3, 4, 5, 2, 3, 4]
>>>

 

切片操作符：

sequence[index]：访问某一数据元素
sequence 是序列的名字，index 是想要访问的元素对应的偏移量.

偏移量可以是正值,范围从0 到偏移最大值(比序列长度少一),用len()函数，可以得到序列长度，实际的范围是 0 <= inde <= len(sequece)-1 .另外，也可以使用负索引，范围是 -1 到序列的负长度，-len(sequence), -len(sequence) <= index <= -1.正负索引的区别在于正索引以序列的开始为起点，负索引以序列的结束为起点

 

 

sequence[starting_index:ending_index]

有个需要注意的地方：从起始索引到结束索引（不包括结束索引对应的元素 ）之间的一"片"元素.起始索引和结束索引都是可选的，如果没有提供或者用None 作为索引值,切片操作会从序列的最开始处开始，或者直到序列的最末尾结束

 

 

序列类型转换的工厂函数：

函数                               含义
list(iter)                把可迭代对象转换为列表
str(obj)                把obj 对象转换成字符串(对象的字符串表示法)
unicode(obj)         把对象转换成Unicode 字符串(使用默认编码)
basestring()         抽象工厂函数,其作用仅仅是为str 和unicode 函数提供父类，所以不能被实例化，也不能被调用
tuple(iter)            把一个可迭代对象转换成一个元组对象

 

 

序列类型可用的内建函数
函数名 功能
enumerate(iter)         接受一个可迭代对象作为参数，返回一个enumerate 对象(同时也是一个迭代器),该对象生成由iter 每个元素的index 值和item 值组成的元组(PEP 279)
len(seq)                      返回seq 的长度
max(iter,key=None) or max(arg0,arg1...,key=None)              返回iter 或(arg0,arg1,...)中的最大值，如果指定了key,这个key 必须是一个可以传给sort()方法的,用于比较的回调函数.

min(iter, key=None) or min(arg0, arg1.... key=None)               返回iter 里面的最小值;或者返回(arg0,arg2,...)里面的最小值;如果指定了key,这个key 必须是一个可以传给sort()方法的,用于比较的回调函数.
reversed(seq)                                          接受一个序列作为参数,返回一个以逆序访问的迭代器(PEP 322)
sorted(iter,func=None, key=None,  reverse=False)c 接受一个可迭代对象作为参数，返回一个有序的列表;可选参数func,key 和reverse 的含义跟list.sort()内建函数的参数含义一样.
sum(seq, init=0)a            返回seq 和可选参数init 的总和, 其效果等同于reduce(operator.add,seq,init)
zip([it0, it1,... itN])d 返回一个列表，其第一个元素是it0,it1,...这些元素的第一个元素组成的一个元组，第二个...,类推.

 

 

>>> s=str(range(4))
>>> s
'[0, 1, 2, 3]'#这里将列表当做一个字符串，其中，也是作为字符串中的一个元素的，和下面的列表a不同。s【2】取值为，而a【2】取值为3.
>>> s[1]
'0'
>>> s[2]
','
>>>
>>> a=[1,2,3,4]
>>> a[1]
2
>>> a[2]
3

 

字符串是不可改变的。

要改变一个字符串就必须通过创建一个新串的方式来实现。也就是说你不能只改变一个字符串的一个字符或者一个子串，然而，通过拼凑一个旧串的各个部分来得到一个新串是被允许的，

 

通过赋一个空字符串或者使用del 语句来清空或者删除一个字符串:

 

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

 

 

string. index ( s , sub [ , start [ , end ] ] ) ¶

Like find() but raise ValueError when the substring is not found.

string. find ( s , sub [ , start [ , end ] ] ) ¶

Return the lowest index in s where the substring sub is found such that sub is wholly contained in s[start:end] . Return -1 on failure. Defaults for start and end and interpretation of negative values is the same as for slices.

>>> a="fdfggfhef"
>>> 'f' in a
True
>>> 'f' not in a
False
>>> 'fd' in a
True
>>> 'dds' not in a
True
>>>
>>> import string
>>> string.find(a,'fd')
0
>>> string.find(a,'he')
6
>>> string.index(a,'g')
3
>>>
find返回字串所在的最低的位置，也即头一次找到，index基本和find相似，不同之处在于找不到会抛出错误，而前者直接返回-1

建议不要用string 模块。原因是Python 必须为每一个参加连接操作的字符串分配新的内存，包括新产生的字符串

使用字符串格式化操作符(%)，或者把所有的字符串放到一个列表中去，然后用一个join()方法来把它们连接在一起。
>>> '%s %s' % ('Spanish', 'Inquisition')

'Spanish Inquisition'
>>>
>>> s = ' '.join(('Spanish', 'Inquisition', 'Made Easy'))
>>> s
'Spanish Inquisition Made Easy'

%格式化操作符仅仅适用于字符串：

格式化字符                         转换方式
%c                        转换成字符(ASCII 码值，或者长度为一的字符串)
%r                       优先用repr()函数进行字符串转换
%s                      优先用str()函数进行字符串转换
%d / %i               转成有符号十进制数
%u                       转成无符号十进制数
%o                       转成无符号八进制数
%x      /%X          (Unsigned)转成无符号十六进制数(x/X 代表转换后的十六进制字符的大小写)
%e/%E                转成科学计数法(e/E 控制输出e/E)
%f/%F                 转成浮点数(小数部分自然截断)
%g/%G %e 和%f/%E 和%F 的简写
%% 输出%

关于str()和repr():

Return a string containing a nicely printable representation of an object. For strings, this returns the string itself. The difference with repr(object) is that str(object) does not always attempt to return a string that is acceptable to eval(); its goal is to return a printable string. If no argument is given, returns the empty string, .

>>> s='hello world'
>>> s
'hello world'
>>> str(s)
'hello world'
>>> repr(s)
"'hello world'"
>>>
>>> str(0.1)
'0.1'
>>> repr(0.1)
'0.1'
>>>
>>> x=10*0.23
>>> y=30*8
>>> s='the value of x is'+repr(x)+',and  is'+repr(y)+'---'
>>> print s
the value of x is2.3000000000000003,and  is240---
>>>
>>> s='the value of x is'+str(x)+',and  is'+str(y)+'---'
>>> print s
the value of x is2.3,and  is240---

函数str() 用于将值转化为适于人阅读的形式，而repr() 转化为供解释器读取的形式（如果没有等价的语法，则会发生SyntaxError 异常） 某对象没有适于人阅读的解释形式的话， str() 会返回与repr()等同的值。很多类型，诸如数值或链表、字典这样的结构，针对各函数都有着统一的解读方式。字符串和浮点数，有着独特的解读方式。

 

 

>>> s='foolbar'
>>> for t in enumerate (s):
...     print t
...
(0, 'f')
(1, 'o')
(2, 'o')
(3, 'l')
(4, 'b')
(5, 'a')
(6, 'r')
>>>
>>>
>>> for i,t in enumerate(s):
...     print i,t
...
0 f
1 o
2 o
3 l
4 b
5 a
6 r

 

 

>>> s,t='dds','dsdfgf'
>>> s
'dds'
>>> t
'dsdfgf'
>>> zip (s,t)
[('d', 'd'), ('d', 's'), ('s', 'd')]
>>>
>>>
>>> zip(t,s)
[('d', 'd'), ('s', 'd'), ('d', 's')]
>>>

字符串的 内建函数：

string.capitalize()  ：把字符串的第一个字符大写
string.center(width)                                   返回一个原字符串居中,并使用空格填充至长度width 的新字符串
string.count(str, beg=0,end=len(string))

返回str 在string 里面出现的次数，如果beg 或者end 指定则返回指定范围内str 出现的次数

string.decode(encoding='UTF-8',errors='strict') ：

 以encoding 指定的编码格式解码string，如果出错默认报一个ValueError 的异常， 除非errors 指定的是'ignore' 或者'replace'

string.encode(encoding='UTF-8',errors='strict')
以encoding 指定的编码格式编码string，如果出错默认报一个ValueError 的异常，除非errors 指定的是'ignore'或者'replace'

string.endswith(obj, beg=0,end=len(string))

检查字符串是否以obj 结束，如果beg 或者end 指定则检查指定的范围内是否以obj 结束，如果是，返回True,否则返回False.

string.expandtabs(tabsize=8)把字符串string 中的tab 符号转为空格，默认的空格数tabsize 是8.
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.isalnum()：如果string 至少有一个字符并且所有字符都是字母或数字则返回True,否则返回False
string.isalpha()：如果string 至少有一个字符并且所有字符都是字母则返回True,否则返回False
string.isdecimal()：如果string 只包含十进制数字则返回True 否则返回False.
string.isdigit()：如果string 只包含数字则返回True 否则返回False.
string.islower()：如果string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回True，否则返回False

 

string.isnumeric()：如果string 中只包含数字字符，则返回True，否则返回False
string.isspace()： 如果string 中只包含空格，则返回True，否则返回False.
string.istitle()：如果string 是标题化的(见title())则返回True，否则返回False
string.isupper()： 如果string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回True，否则返回False
string.join(seq) Merges (concatenates)以string 作为分隔符，将seq 中所有的元素(的字符串表示)合并为一个新的字符串
string.ljust(width)返回一个原字符串左对齐,并使用空格填充至长度width 的新字符串
string.lower() 转换string 中所有大写字符为小写.
string.lstrip() 截掉string 左边的空格

string.partition(str)：

有点像find()和split()的结合体,从str 出现的第一个位置起,把字符串string 分成一个3 元素的元租(string_pre_str,str,string_post_str),如果string 中不包含str 则string_pre_str == string.

string.replace(str1, str2,num=string.count(str1))把string 中的str1 替换成str2,如果num 指定，则替换不超过num 次.
string.rfind(str, beg=0,end=len(string))类似于find()函数，不过是从右边开始查找.
string.rindex( str, beg=0,end=len(string)) 类似于index()，不过是从右边开始.
string.rjust(width)返回一个原字符串右对齐,并使用空格填充至长度width 的新字符串
string.rpartition(str)e 类似于partition()函数,不过是从右边开始查找.
string.rstrip() 删除string 字符串末尾的空格.
string.split(str="", num=string.count(str)) 以str 为分隔符切片string，如果num有指定值，则仅分隔num 个子字符串
string.splitlines(num=string.count('/n'))b, c 按照行分隔，返回一个包含各行作为元素的列表，如果num 指定则仅切片num 个
行.
string.startswith(obj, beg=0,end=len(string))b, e 检查字符串是否是以obj 开头，是则返回True，否则返回False。如果
beg 和end 指定值，则在指定范围内Edit By Vheavens检查.
string.strip([obj]) 在string 上执行lstrip()和rstrip()
string.swapcase() 翻转string 中的大小写
string.title()b, c 返回"标题化"的string,就是说所有单词都是以大写开始，其余字母均为小写(见istitle())
string.translate(str, del="") 根据str 给出的表(包含256 个字符)转换string 的字符,要过滤掉的字符放到del 参数中
string.upper() 转换string 中的小写字母为大写
string.zfill(width) 返回长度为width 的字符串，原字符串string 右对齐，前面填充0

 

与字符串类型有关的模块

string                    字符串操作相关函数和工具，比如Template 类.
re                        正则表达式:强大的字符串模式匹配模块
struct                   字符串和二进制之间的转换
c/StringIO             字符串缓冲对象，操作方法类似于file 对象.
base64                  Base 16,32,64 数据编解码
codecs                  解码器注册和基类
crypt                    进行单方面加密
diffliba                   找出序列间的不同
hashlibb                 多种不同安全哈希算法和信息摘要算法的API
hmac                     HMAC 信息鉴权算法的Python 实现
md5d                     RSA 的MD5 信息摘要鉴权
rotor                     提供多平台的加解密服务
shad                      NIAT 的安全哈希算法SHA
stringprepe             提供用于IP 协议的Unicode 字符串
textwrape               文本打包和填充
unicodedata            Unicode 数据库