Python3.2中的字符串函数学习总结

Sequence Types

sequence类型有六种：strings, byte sequences (bytes objects), byte arrays(bytearray objects), list, tuple, range objects.

sequence类型都支持的通用操作：
成员检查：in、not in
连接：+
复制：*
下标取值：s[i]
切片：s[i : j]
长度检查：len(s)
最小值：min(s)
最大值：max(s)
索引取值：s.index(i)
字符串统计：s.count(i)

String Methods

判断类方法，通常返回一个布尔值：

str.endswith(suffix[, start[, end]])：

判断字符串是否以指定后缀结尾，返回True或False。start和end指定判断的起始范围，默认全字符串。如：

复制代码 代码如下:
\’abcde\’.endswith(\’de\’)   –>True
\’abcde\’.endswith(\’de\’, 0, 3)   –>Flase

str.startwith(prefix[, start[, end]])：

与str.endwith()相反，判断字符串是否以指定前缀开始。

str.islower()：

判断字符串中的字母字符是否全部为小写，该方法仅判断字符串中的字母字符，不理会其它字符。字符串必须至少包含一个字母字符，否则返回False。如：

复制代码 代码如下:
‘中国\’.islower()   –>False
‘ab中国\’.islower()   –>True

str.isupper()：

与st.islower()方法相反，判断所有字母字符是否全部大写。

str.istitle()：

判断字符串每个单词的首字母是否大写。字符串必须至少包含一个字母字符，否则返回False。即使首字母字符前面有非字母字符，如中文、数字、下划线等，也不影响对首字母字符的判断。

复制代码 代码如下:
‘中国\’.istitle()   –>False    //字符串不包含字母，返回False
‘中国Abc\’.istitle()   –>True    //虽然首字母字符A前面有非字母字符，仍然返回True
‘-Abc xyz\’.istitle()   –>False    //后一个单词的首字母不是大写，返回False

str.isalnum()：

判断字符串是否只包含由文字数字式字符，字符串仅包含中文字符合法。若字符串包含空格、下划线、~等非文字数字式字符，均返回False。如：

复制代码 代码如下:
‘3\’.isalnum()   –>True
‘中国\’.isalnum()   –>True
‘-\’.isalnum()   –>False

注：alphanumberic是一个特殊词汇，它表明这个字符串由数字字符或文字字符组成。如，\’3\’包括了一个数字字符，\’a\’包含了一个文字字符，而\’3a\’同时包括数字字符和字母字符。

str.isalpha()：
判断字符串是否只包含文字字符，字符串仅包含中文字符合法。如：

复制代码 代码如下:
‘中国\’.isalpha()   –>True
‘3\’.isalpha()   –>False

str.isidentifier()：

判断字符串是否是合法的标识符，字符串仅包含中文字符合法，实际上这里判断的是变量名是否合法。如：

复制代码 代码如下:
‘_a\’.isidentifier()   –>True
‘3a\’.isidentifier()   –>False
‘中国\’.isidentifier()   –>True

str.isprintable()：

判断字符串所包含的字符是否全部可打印。字符串包含不可打印字符，如转义字符，将返回False。

str.isspace()：

判断字符串是否仅包含空格或制表符。注意：空格字符与空白是不同的，如：

复制代码 代码如下:
\’\’.isspace()   –>False
\’ \’.isspace()   –>True

str.isdecimal()：

判断字符串是否只包含十进制数字字符，包括多国语言的十进制数字字符表现形式。如：

复制代码 代码如下:‘3\’.isdecimal()   –>True
‘\\u0660\’.isdeciaml()   –>True

其它语言的十进制数字形式参考：http://www.fileformat.info/info/unicode/category/Nd/list.htm

str.isdigit()：

判断字符串是否只包含数字，这里的数字包括十进制数字和其它特殊数字（如上标数字等）。一般地，一个数字是拥有如下属性值的字符：Numeric_Type=Digit或Numeric_Type=Decimal。

str.isnumeric()：

判断字符串是否只包含数字字符。数字字符范围很大，一般来说，数字字符是拥有如下属性值的字符：Numeric_Type=Digit, Numeric_Type=Decimal或Numeric_Type=Numeric。
比较isdecimal()、isdigit()、isnumeric()，几个方法检测的范围依次扩大。

格式化类方法，返回一个格式化的新字符串：

str.encode(encoding=”utf-8”, errors=”strict”)：

将字符串以utf-8格式进行编码。

str.lower()：

把全部字母字符转换成小写，不去管其它非字母字符。字符串全部为非字母字符也是合法的，但返回原字符串。如：

复制代码 代码如下:
\’中国123ABC\’.lower()   –> \’中国123abc\’
‘中国123\’.lower()    –>\’中国123\’    //不会报错，返回原字符串

str.upper()：

与str.lower()相反，把全部字母字符转换成大写。如：

复制代码 代码如下:
\’中国123abc\’.upper()   –> \’中国123ABC\’
\’中国123\’.upper()   –>\’中国123\’

str.swapcase()：

把字符串中的大小写字母互换，大写转换成小写，小写转换成大写。不去管非字母类字符。如：

复制代码 代码如下:
\’中国123Ab\’.swapcase()   –>\’中国123aB\’
\’中国123\’.swapcase()   –>\’中国123\’    //不会报错，返回原字符串

str.capitalize()：

字符串首字母大写，其余小写。如果字符串首字符为非字母字符，将返回原字符串。字符串仅包含非字母字符合法，但返回原字符串。如：

复制代码 代码如下:
\’ab  cd\’.capitalize()   –>\’Ab  cd\’    //只转换字符串的首字母
\’中国ab 123cd\’.capitalize()   –>\’中国ab 123cd\’    //首字符为非字母字符，返回原字符串
\’中国 123\’.capitalize()   –>\’中国 123\’    //不会报错，返回原字符串

str.title()：

字符串中每个单词的首字母大写，其余小写。单词的首字符为非字母字符也不影响转换。字符串仅包含非字母字符合法，但返回原字符串。如：

复制代码 代码如下:
\’ab  cd\’.title()   –>\’Ab  Cd\’    //字符串中每个单词的首字母大写
\’中国ab 123cd\’.title()   –>\’中国Ab 123Cd\’    //即使首字符为非字母字符，也可以进行转换
\’中国 123\’.title()   –>\’中国 123\’

str.center(width[,fillchar])：

返回一个原字符串居中，长度为width的新字符串，width要大于len(str)，否则返回原字符串，原字符串开头和结尾处使用fillchar进行填充，默认为空格。
注：width为偶数时，fillchar将平均地填充到原字符串的开头和结尾；为奇数时，fillchar优先填充前面。如：

复制代码 代码如下:
\’abcd\’.center(3)   –>\’abcd\’
\’abcd\’.center(8） –>\’  abcd  \’
\’abcd\’.center(8, *)   –>\’**abcd**\’
\’abcd\’.center(7, *)   –>\’**abcd*\’

str.ljust(width[, fillchar])：

返回一个长度为width，左对齐的字符串，最右边填充fillchar，默认为空格。width要大于len(str)，否则返回原字符串。如：

复制代码 代码如下:
‘abcd\’.ljust(10)   –>\’abcd      ‘

str.rjust(width[, fillchar])：

与str.ljust()类似，但是它返回一个右对齐的字符串，最左边填充fillchar。

str.lstrip([chars])：

返回一个去除前了导字符的新字符串，chars参数是一个字符串，它包含了所有将要被移除的字符集合。默认为空格。
注：关于lstrip函数（包括rstrip和strip），网上有很多文章，但都讲的不清不楚。它实际的意思是，从原字符串的最左边开始，匹配chars里包含的所有字符，直至遇到第一个非chars字符为止，原字符串中匹配到的所有字符都被移除。

复制代码 代码如下:
‘www.example.com\’.lstrip(‘cmowz.\’)   –>example.com

从字符串的最左边开始匹配，直至遇到了非chars字符e为止，一共匹配了3个w字符和一个.字符，遇到e匹配结束。
复制代码 代码如下:
\’xyxxyy testyx yx yyx\’.lstrip(\’xy \’)   –>\’testyx yx yyx\’

从字符串的最左边开始匹配，直至遇到非chars字符t为止，一共匹配了三个x三个y，和一个空格，遇到t匹配结束。

str.rstrip([chars])：
与str.lstrip()相反，从最右边开始匹配。

复制代码 代码如下:
\’xyxxyy testyx yx yyx\’.rstrip(\’xy \’)   –>\’xyxxyy test\’

str.strip([chars])：
从字符串的两头开始匹配。

复制代码 代码如下:
\’xyxxyy testyx yx yyx\’.strip(\’xy \’)   –>test

str.expandtabs([tabsize])：
把字符串中的所有制表符替换成零个或多个空格，每个制表符替换成多少个空格，由制表符在字符串中的位置和tabsize共同决定。tabsize指定每个制表符替换成的空格数，默认为8个。如：

复制代码 代码如下:
\’\\t\\t this\\tis test.\’.expandtabs(8)   –>\’                 this    is test.\’

上述示例中，前两个\\t，每个都替换成了8个空格，而第三个\\t貌似只替换成了4个。实际上不然，因为制表符的制表位是从每行开头算起的，所以第三个制表符的制表位是从行首开始的第24个位置，刚好在is的i前面，而不是从this后面开始算的第8个位置。这就是所谓的共同决定。

str.zfill(width)：
返回一个长度为width的数字字符串，最左边填充0。如果width小于等于原字符串长度，则返回原字符串。主要用于数字类字符串的格式化。如：

复制代码 代码如下:
\’abc\’.zfill(5)   –> \’00abc\’    //一般不会做这种格式化，没什么意义
\’123\’.zfill(5)   –> \’00123\’

查找 & 替换类方法：

str.count(sub[, start[, end]])：

统计某个字符中子字符串sub的个数。start和end指定统计范围，未指定则默认全字符串范围内统计。如：

复制代码 代码如下:
\’abcdabac\’.count(\’ab\’)   –>2
\’abcdabac\’.count(\’ab\’, 2,)   –>1

str.find(sub[, start[, end]])：
查找子字符串在字符串中出现的第一个位置，start和end指定一个查找范围。未找到返回-1。

复制代码 代码如下:
\’0123234\’.find(\’23\’)   –>2
\’0123234\’.find(\’23\’, 1)   –>2

注：1、find查找的是子字符串在全字符串中出现的第一个位置，匹配到字符串就结束查找，不管后面还有没有匹配的字符串。
2、find查找的是子字符串在全字符串出现的第一个位置，而不是指定切片中的第一个位置。
3、如果仅想判断子字符串是否在某一字符串中，用in判断符即可，无需find。

str.rfind(sub[, start[, end]])：
跟find方法一样，返回指定子串的index位置，只不过rfind从字符串的最右边开始查找，找不到时返回-1。注意：从最右边开始查找，但index位置却是从原字符串的最左边开始算的。如：

复制代码 代码如下:
\’ABCDEEF\’.find(\’E\’)   –>4   //从最左边开始查找，从A到第一个D后面的E结束，返回索引值4
\’ABCDEEF\’.rfind(\’E\’)   –>5   //从最右边开始查找，从A到第一个F前面的E结束，返回索引值5

str.format(*args, **kwargs)：
调用fortmat方法的字符串中不但有纯文本，也有使用{}界定符包括起来的替换字段。替换字段既可以是位置参数的数值索引，也可以是字典或属性的Key值。该方法返回的字符串里，所有替换字段都被相应参数的值所替代。如：

复制代码 代码如下:
‘User ID: {0}\’.format(‘root\’)   –>User ID: root
‘User ID: {UID}  Last login: {last_login}\’.format(UID = ‘root\’, last_login = ‘5 Mar 2012\’)   –>User ID: root   Last login: 5 Mar 2012

str.index(sub[, start[, end]])：

类似str.find()，但是如果没有找到子串，返回raised ValueError。

str.rindex(sub[, start[, end]])：

类似于str.rfind()，但是如果没有找到，返回raises ValueError。

str.replace(old, new[, count])：
返回一个新字符串，原串中的old被替换为new，country指定替换次数。如：

复制代码 代码如下:
\’AAABBBCCC\’.replace(\’A\’, \’D\’)   –>DDDBBBCCC
\’AAABBBCCC\’.replace(\’A\’, \’D\’, 2)   –>DDABBBCCC

static str.maketrans(x[, [y, z]])：
这个方法我不是很明白，特别是它还有一个static修饰符。
大致上，它的用途是返回一个转换表，以供str.translate()方法使用，两个方法常配合使用。
如：

复制代码 代码如下:
table = str.maketrans(\’cs\’, \’kz\’)
\”please don\’t knock at my door!\”.translate(table)   –>\”pleaze don\’t knokk at my door!\”   //\’c\’被替换成了k，\’s\’被替换成了z。说明参数可以包含多个字符，但第一个参数包含的字符数和第二个参数包含的字符数必须相等。

table = str.maketrans(\’cs\’, \’kz\’, \’o\’)
\”please don\’t knock at my door!\”.translate(table)   –>\”pleaze dn\’t knkk at my dr!\”   //如果有三个参数，则第三个参数的意思是删除原字符串中的相应字符。

str.translate(map)：

和str.maketrans()函数配合使用，替换相应的字符。

拆分 & 组合类方法：

str.partition(sep)：

该方法用于拆分字符串，返回一个包含三个元素的元组。如果未能在原字符串中找到Sep，则元组的三个元素为：原字符串，空串，空串；否则，从原字符串中遇到的第一个Sep字符开始拆分，元组的三个元素为：Sep之前的字符串，Sep字符，Sep之后的字符串；如：

复制代码 代码如下:
\’abcdee\’.partition(\’f\’)   –> (\’abcdee\’, \’\’, \’\’)
\’abcdee\’.partition(\’e\’)   –> (\’abcd\’, \’e\’, \’e\’)

str.rpartition(sep)：

与str.partition()相反，从原字符串的最右边开始拆分，但是同样返回包含三个元素的元组：倒数第一个Sep之前的字符串，Sep字符，Sep之后的字符串。
注意”倒数Sep之前的字符串”，这个之前的字符串，是从原字符串的最左边开始算，并不是最右边。如：

复制代码 代码如下:
\’abcdee\’.rpartition(\’e\’)   –> (\’abcde\’, \’e\’, \’\’)    //拆分的三个元素分别是：倒数第一个e之前的元素，e本身，e之后的元素，此外为空格
\’abcdee\’.rpartition(\’f\’)   –> (\’\’, \’\’, \’abcdee\’)    //拆分的三个元素分别是：空格，空格，原字符串

str.split([sep[, maxsplit]])：

返回一个以Sep分隔的列表，maxsplit指定拆分次数（因此，列表中元素的个数为maxsplit + 1）。Sep默认为空格，maxsplit默认不限制拆分次数。
注意：1）如果未指定Sep或指定Sep为None（\’\’），str两端的空格将舍弃；如果指定Sep（不管能否在原字符串中找到Sep），str两端的空格将保留
2）如果未能在原字符串中找到Sep，则返回一个仅包含一个元素的列表，这个元素就是原字符串。
如：

复制代码 代码如下:
\’  abcbdbee  \’.split()   –> [\’abcbdbee\’]    //未指定Sep，返回仅包含一个元素的列表，舍弃str两端的空格
\’  abcbdbee \’.split(\’f\’)   –> [\’  abcbdbee \’]    //指定f为Sep（虽然找不到f），返回仅包含一个元素的列表，保留两端的空格
\’  abcbdbee \’.split(\’b\’)   –> [\’  a\’, \’c\’, \’d\’, \’ee \’]   //指定b为Sep，不限定拆分次数，str两端的空格被保留
\’  abcbdbee  \’.split(\’b\’, 2)   –> [\’  a\’, \’c\’, \’dbee  \’]    //以b为分隔符，拆分两次

注：有点像str.partition()，但是str.partition()返回一个元组，而且分隔符Sep是元组中的一个元素；而str.split(0返回一个列表，分隔符Sep不在列表中

str.rsplit([sep[, maxsplit]])：

与str.split()类似，只是它从最右边开始拆分。只有在指定maxsplit的情况下才会看到效果。如：

复制代码 代码如下:
\’abcbdbee\’.rsplit(\’b\’)   –> [\’a\’, \’c\’, \’d\’, \’ee\’]     //不指定maxsplit，返回的结果与str.split()相同
\’abcbdbee\’.rsplit(\’b\’, 2)   –> [\’abc\’, \’d\’, \’ee\’]    //可以看出与str.split(‘b\’, 2)的差别

str.join(iterable)：

使用连接符str来连接iterable对象中的元素，返回一个被str连接起来的，由iterable对象的元素组成的字符串。如果传入一个非iterable对象，如整数、布尔值等，将返回Type Error。 如：

复制代码 代码如下:
‘A B\’. join([\’1\’, \’2\’, \’中国\’])   –>1A B2A B中国
‘A B\’.join(‘12中国\’)   –>1A B2A B中国
‘A B\’.join(123)   –>Type Error

注：iterable object或iterator type最主要的特征是支持两个函数：__iter__()和__next__()，虽然不是很准确，但可以简单的认为支持使用for语句逐个取值的数据类型都是迭代器对象。
sequence type（六种：strings、byte objects、byte arrays、lists、tuples、range objects）和dictionary都属于iterable对象。

str.splitlines([keepends])：

拆分一个包含多行的字符串，以每行为一个元素返回一个列表。如果字符串不是多行的，则返回原字符串。keepends是一个True字符或非零整数，表示保留行尾标志。该方法多用于处理文件。如：

复制代码 代码如下:
Line = ‘AB
CD
EF\’\’\’
Line.splitlines()   –>[\’AB\’, \’CD\’, \’EF\’]

Line = \’AB\\nCD\\nEF\’
Line.splitlines()   –>[\’AB\’, \’CD\’, \’EF\’]

Line = \’AB\\nCD\\nEF\’
Line.splitlines(True)   –> [\’AB\\n\’, \’CD\\n\’, \’EF\’]