python数据类型-----字符串

今天来总结下python3.4版本字符串的一些操作方法，对这些方法先作一个简单的分类，按照分类来进行总结。

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)

一、字符串中字符大小写的变换

　　1、str.capitalize()

　　　　返回字符串的副本，首字符大写，其余字符小写。

　　2、str.casefold()

　　　　将str中大写转化为小写，并将一些如：换行符、制表符等显示出来。

　　3、str.swapcase()

　　　　将str中字符大写转化为小写，小写转化为大写。

　　4、str.upper()　

　　　　将str字符小写转化为为大写。

　　5、str.lower()

　　　　将str字符大写转化为为小写。

　　6、str.title()

　　　　只有首字母大写，其余为小写，模块中没有这个方法。

二、字符串的分割和组合

　　1、sep.join(iterable)

　　　　返回一个字符串，为iterable可迭代对象中字符串的连接,连接符为sep。

　　2、str.split(sep=None, maxsplit=-1)

　　　　返回字符串中的单词列表，使用sep作为分隔符字符串。如果给出maxsplit，则至多拆分maxsplit次（因此，列表中将最多有maxsplit+1个元素）;

　　　　如果没有指定maxsplit或为-1，那么分割的数量没有限制（进行所有可能的分割）。

　　3、str.rsplit(sep=None, maxsplit=-1)

　　　　在字符串中，使用sep作为分隔符字符串返回一个单词列表。如果给出了maxsplit ，顶多分裂为maxsplit+1个元素，从最右边开始。

　　　　如果未指定sep或没有任何空格的字符串是一个分隔符。除了从右边分裂。

　　4、str.splitlines([keepends])　

　　　　返回字符串中行组成的列表，在行的边界截断。此方法使用通用换行符方法分隔行。换行符不包含在结果列表中，除非给定keepends给定且为真。

　　　　在Unix环境下：'\n'；在Windows环境下：'\r\n'

　　　　例如：

　　　　　　'ab c\n\nde fg\rkl\r\n'.splitlines() returns ['ab c', '', 'de fg', 'kl']

　　　　　　'ab c\n\nde fg\rkl\r\n'.splitlines() returns ['ab c\n', '\n', 'de fg\r', 'kl\r\n']

　　5、str.maketrans(x[, y[, z]])

　　　　　返回一个翻译表提供给str.translate()使用。

　　　　　返回一个使用参数map转换后的字符串，map必须是一个unicode字符码（整形）到unicode字符，字符串或None的映射表，未被映射的字符保持不表，被映射为None的字符将被删除。

　　　　　如果只有一个参数，它必须是一个字典映射Unicode序数（整数）或字符的Unicode序数、字符串或None。字符键将转换为序数。

　　　　　如果有两个参数，它们必须是相同长度的字符串，并在结果的字典中，每个字符在x将被映射到在Y在同一位置的字符。

　　　　　如果有三个参数，它必须是一个字符串，其字符在结果中将被映射为None。

　　6、str.translate(map)

　　　　返回一个字符串的副本，所有的字符被映射通过给定的转换表，必须映射到Unicode Unicode序数序数，字符串，或None。未映射的字符保持不变，映射到None的字符被删除。

　　

三、字符串中的搜索和替换

　　1、str.count(sub[, start[, end]])

　　　　返回非重复子串sub的在start和end之间出现的次数，可选参数start和end被解释为切片表示法。

　　2、str.eapandtabs(tabsize=8)

　　　　把str中的tab字符替换为空格，每个tab替换为tabsize个空格，默认是8个

　　3、str.find(sub[, start[, end]])

　　　　返回str中第一次出现的sub的第一个字母的下标，如果str中没有sub则返回-1，可选参数start和end被解释为切片表示法。

　　4、str.rfind(sub[, start[, end]])

　　　　返回str中最后一次出现的sub的第一个字母的下标，如果str中没有sub则返回-1，可选参数start和end被解释为切片表示法。

　　5、str.index(sub[, start[, end]])

　　　　与str.find()类似，但是sub未找到的话会引发ValueError错误。

　　6、str.rindex(sub[, start[, end]])

　　　　与str.rfind()类似，但是sub未找到的话会引发ValueError错误。

　　7、str.replace(old, new[, count])

　　　　把S中的old替换为new，count为替换次数；如果给定count，则new替换出现的count次old

　　8、str.strip([chars])

　　　　返回一个去除了chars中指定的字符的字符串副本，如果chars未被指定，则默认去除空格，chars不是一个前缀或者后缀，相反，其值中的所有组合都被剥离。

　　9、str.lstrip([chars])

　　　　与str.strip()类似，只是去除的是左边的指定字符。

　　10、str.rstrip([chars])

　　　　与str.strip()类似，只是去除的是右边的指定字符。

四、字符串在输出时的对齐

　　1、str.ljust(width,[fillchar])

　　　　输出width个字符，str左对齐，不足部分用单个字符fillchar填充，默认的为空格。如果width小于或等于len(str)则返回原始字符串。

　　2、str.rjust(width,[fillchar]) 

　　　　输出width个字符，str右对齐，不足部分用单个字符fillchar填充，默认的为空格。如果width小于或等于len(str)则返回原始字符串。

　　3、str.center(width,[fillchar]) 

　　　　输出width个字符，str中间对齐，两边部分用单个字符fillchar填充，默认的为空格。如果width小于或等于len(str)则返回原始字符串。

　　4、str.zfill(width)

　　　　把str变成width长，并在右对齐，不足部分用0补足，如果width小于或等于len(str)则返回原始字符串。

　

五、字符串的测试函数，这些函数返回的都是bool值

　　1、str.isalnum()

　　　　如果字符串中的所有字符是字母或者数字并至少有一个字符则返回true，否则为false。如果下列之一返回true则字符c是一个字母字符：c. isalpha()，c. isdecimal()，c. isdigit()，

　　　　c.isnumeric()。

　　2、str.isalpha()

　　　　如果字符串中的所有字符是字母并至少有一个字符则返回true，否则为false。

　　3、str.isdecimal()

　　　　如果字符串中的所有字符为十进制并至少有一个字符则返回true，否则返回false。bytes字符串无此方法

　　4、str.isdigit()

　　　　如果字符串中的所有字符为十进制并至少有一个字符则返回true，否则返回false。

　　5、str.isnumeric()

　　　　如果字符串中的所有字符为数字字符并至少有一个字符则返回true，否则返回false。数字字符包括数字字符和所有的具有Unicode值属性的汉字，如："四"。

　　6、str.isprintable()

　　　如果字符串中的所有字符均为可打印字符或者字符串为空则返回true，否则返回false。

　　7、str.isspace()

　　　　判如果字符串仅包含空格或制表符并至少有一个字符则返回true，否则返回false。注意：空格字符与空白是不同的。

　　8、str.istitle()

　　　　如果字符串每个单词的首字母是大写并至少包含一个字母字符则返回true，否则返回False。即使首字母字符前面有非字母字符，如中文、数字、下划线等，

　　　　也不影响对首字母字符的判断。

　　9、str.isupper()

　　　　如果字符串中的字母字符全部为大写并至少包含一个字母字符则返回true，否则返回False。该方法仅判断字符串中的字母字符，不理会其它字符。

　　10、str.islower()　

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

　　11、str.isidentifier()

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

　　12、str.endswith(suffix[, start[, end]])　　

　　　　 判断str是否以suffix结尾。

　　13、str.startswith(prefix[, start[, end]])

　　　　判断str是否以prefix开头。

六、字符串编码和解码的函数

　　1、str.encode(encoding="utf-8", errors="strict")

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

　　2、bytes.decode(encoding="utf-8", errors="strict")

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

 =>总结加实例解析

判断类方法，通常返回一个布尔值
　　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

　　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]])
　　　　它的用途是返回一个转换表，以供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']

str.maketrans(x[,y[,z]])和str.translate(map)

举例说明：

1）使用一个dict参数，创建字符到字符的转换表

[python]

>>> s = 'abcxyz123'

>>> m = {'a':'A', 'b':'B'} #用于创建一个<span style="font-family: Arial, Helvetica, sans-serif;">'a' -> 'A', 'b' -> 'B' </span>的转换表

>>> trans = str.maketrans(m)

>>> s.translate(trans)

'ABcxyz123'

2）使用一个dict参数，创建一个字符到多个字符的转换表

[python]

<pre code_snippet_id="74638" snippet_file_name="blog_20131120_2_2882177" name="code" class="python"></pre>>>> s = 'abcxyz123'<br>

>>> m = {'a':'AAA', 'b':'BB'} <span style="font-family:Arial,Helvetica,sans-serif">

#用于创建一个'a' -> 'AAA', 'b' -> 'BB'的转换表</span><br>

>>> trans = str.maketrans(m)<br>

>>> s.translate(trans)<br>

'AAABBcxyz123'

<pre></pre>

<pre></pre>

3）使用一个dict参数，创建字符到None的转换表（用于过滤要删除的字符）

[python]

>>> s = 'abcxyz123'

>>> m = {'a':None, 'b':None} <span style="font-family: Arial, Helvetica, sans-serif;">#用于创建一个删除'a', 'b'的转换表</span>

>>> trans = str.maketrans(m)

>>> s.translate(trans)

'cxyz123'

4）使用两个参数，创建字符到字符的转换表

[python]

>>> s = 'abcxyz123'

>>> trans = str.maketrans('abc', 'ABC')

>>> s.translate(trans)

'ABCxyz123'

5）使用三个参数，创建字符到字符的转换表，并同时包含要过滤删除的字符表

[python]

>>> s = 'abcxyz123'

>>> trans = str.maketrans('abc', 'ABC', '123456')

>>> s.translate(trans)

'ABCxyz'

6）使用unicode字符的情况

[python]

>>> hex(ord('我'))

'0x6211'

>>> hex(ord('你'))

'0x4f60'

>>> hex(ord('兵'))

'0x5175'

>>> s = '我是一个兵！'

>>> m = {'\u6211':'\u4f60', '\u5175':'流氓'}

>>> trans = str.maketrans(m)

>>> s.translate(trans)

'你是一个流氓！'

参考cookbook，对translate进行简单封装

[python]

>>> def translator(frm='', to='', delete=''):

    if len(to) == 1:

        to = to * len(frm) #eg. from:'12345678' to:'#'

    trans = str.maketrans(frm, to, delete)

    def translate(s):

        return s.translate(trans)

    return translate

>>> s = 'abcxyz123'

>>> trans = translator('abc', 'ABC', '123')

>>> trans(s)

'ABCxyz'

>>> trans = translator('1234567890', '#')

>>> trans(s)

'abcxyz###'  

 

python中str函数isdigit、isdecimal、isnumeric的区别

num = "1"  #unicode
num.isdigit()   # True
num.isdecimal() # True
num.isnumeric() # True

num = "1" # 全角
num.isdigit()   # True
num.isdecimal() # True
num.isnumeric() # True

num = b"1" # byte
num.isdigit()   # True
num.isdecimal() # AttributeError 'bytes' object has no attribute 'isdecimal'
num.isnumeric() # AttributeError 'bytes' object has no attribute 'isnumeric'

num = "IV" # 罗马数字
num.isdigit()   # False
num.isdecimal() # False
num.isnumeric() # True

num = "四" # 汉字
num.isdigit()   # False
num.isdecimal() # False
num.isnumeric() # True

===================
isdigit()
True: Unicode数字，byte数字（单字节），全角数字（双字节），罗马数字
False: 汉字数字
Error: 无

isdecimal()
True: Unicode数字，，全角数字（双字节）
False: 罗马数字，汉字数字
Error: byte数字（单字节）

isnumeric()
True: Unicode数字，全角数字（双字节），罗马数字，汉字数字
False: 无
Error: byte数字（单字节）

================
import unicodedata

unicodedata.digit("2")   # 2
unicodedata.decimal("2") # 2
unicodedata.numeric("2") # 2.0

unicodedata.digit("2")   # 2
unicodedata.decimal("2") # 2
unicodedata.numeric("2") # 2.0

unicodedata.digit(b"3")   # TypeError: must be str, not bytes
unicodedata.decimal(b"3") # TypeError: must be str, not bytes
unicodedata.numeric(b"3") # TypeError: must be str, not bytes

unicodedata.digit("Ⅷ")   # ValueError: not a digit
unicodedata.decimal("Ⅷ") # ValueError: not a decimal
unicodedata.numeric("Ⅷ") # 8.0

unicodedata.digit("四")   # ValueError: not a digit
unicodedata.decimal("四") # ValueError: not a decimal
unicodedata.numeric("四") # 4.0

#"〇","零","一","壱","二","弐","三","参","四","五","六","七","八","九","十","廿","卅","卌","百","千","万","万","亿"