夯实Python基础（2）
Python字符串
我们知道，字符串是Python的内置对象，用来存储和表现基于文本的信息。通过《Python入门》的学习，我们已经了解和掌握了字符串的如下特性：
1、字符串是一种常量
正如数字一样，字符串也是一种常量，它的值就是它自己，所以，它同样是一种字面常量。就是说，你看到它是什么，它就是什么，不能（原地）修改。
例如：
>>>‘abc’
‘abc’
2、字符串是一种序列类型的常量
字符串之所以名字上有个“串”字，我们可以通俗的理解为它一般不只包含一个字符，大多数时候，可能会是由多个、或者很多个字符构成的。但是，这些“多个字符”一旦“串”在了一起，它就构成了一个独立的字符串常量。在计算机的内存中，它表现为一小块存储空间，并且它存储的信息不能被原地修改。
也正因为不能被修改，它就拥有了固定的字符顺序，所以，它也成为了一种序列类型的数据。与其他序列类型的数据一样，它拥有这个序列的顺序（索引index）、索引值（指定位置的字符index[n]）、和序列的长度（len）。
例如：
>>> ‘abc’[0]
‘a’
>>> len(‘abc’)
3
3、字符串可以作为一个拥有值的常量赋值给一个变量
既然字符串是一个常量，它就可以赋值给一个变量，让一个变量拥有它的值。当某个字符串被赋值给某个变量时，在计算机的内存中，实际上是为这个变量添加了一个引用，这个引用指向了内存空间中那个字符串的存储区域。
例如：
>>> x = ‘abc’
>>> x
‘abc’
好了，
在回顾了这些有关字符串的常识以后，
今天我们要重点介绍一下字符串的操作。
Python为我们提供了大量的内置函数（方法），
方便我们在需要对字符串进行必要处理的时候，
能够轻松地一招搞定。
这也是我们在Python编程实际应用中，
会大量遇到和应该熟悉和掌握的基本知识和技能。
1、字符串的大小操作
（1）大小写转换
str.lower()# 返回str字符串的小写格式。
str.upper()# 返回str字符串的大写格式。
PS：请注意，这个新生成的字符串，不是对原有的内存地址添加引用，而是，重新生成了一个内存片段。
例如：
>>> 'aBcDeF'.lower()
'abcdef'
>>> 'aBcDeF'.upper()
'ABCDEF'
（2）驼峰式转换
str.title()# 返回字符串中所有单词首字母大写其他字母小写的新字符串
str.capitalize()# 返回首字母大写、其他字母全部小写的新字符串
例如：
>>> print('ab XY'.title())
Ab Xy
>>> print('abc DE'.capitalize())
Abc de
（3）大小写反转
str.swapcase()#所有字符串做大小写转换(大写-->小写，小写-->大写)
例如：
>>> print('abc XYZ'.swapcase())
ABC xyz
2、字符串的判断操作
（1）判断字符串是否是数字、字母、字母或数字
str.isnumeric() #判断字符串是否为数字（不含小数点）
str.isalpha() #判断字符串是否字母
str.isalnum() #判断字符串是否字母和数字混合（不含其它字符）
例如：
>>> print('34'.isnumeric())
True
>>> print('abc'.isalpha())
True
>>> print('a34'.isalnum())
True
（2）判断字符串或首字母是否大小写
str.islower() #字符串是否大写？
str.isupper() #字符串是否小写？
str.istitle() #字符串每个单词是否首字母大写，且其他字符小写？
PS:要求字符串str中至少要包含一个字符串字符（比如不能纯数字），否则返回False。
例如：
>>> print('a34'.islower())
True
>>> print('AB'.isupper())
True
>>> print('Aa'.isupper())
False
>>> print('Aa Bc'.istitle())
True
>>> print('Aa_Bc'.istitle())
True
>>> print('Aa bc'.istitle())
False
>>> print('Aa_bc'.istitle())
False
>>> print('Aa BC'.istitle())
False
（3）判断字符串是否为空、是否可打印、是否符合标识符定义规则
str.isspace()#字符串是否为空白（空格、制表符、换行符等）
str.isprintable()#字符串是否可打印
str.isidentifier()#字符串是否满足标识符定义规则
例如：
（1）判断是否为空白。没有任何字符是不算是空白。
>>> print(' '.isspace())
True
>>> print(' \t'.isspace())
True
>>> print('\n'.isspace())
True
>>> print(''.isspace())
False
>>> print('abc'.isspace())
False
（2）判断是否是可打印字符。
>>> print('\n'.isprintable())
False
>>> print('\t'.isprintable())
False
>>> print('acd'.isprintable())
True
>>> print(' '.isprintable())
True
>>> print(''.isprintable())
True
（3）判断是否满足标识符定义规则：只能是字母或下划线开头、不能包含除数字、字母和下划线以外的任意字符。
>>> print('abc'.isidentifier())
True
>>> print('2abc'.isidentifier())
False
>>> print('abc2'.isidentifier())
True
>>> print('_abc2'.isidentifier())
True
>>> print('_abc_2'.isidentifier())
True
>>> print('_Abc_2'.isidentifier())
True
>>> print('Abc_2'.isidentifier())
True
3、填充操作
（1）字符串居中（往两边）填充
str.center(width[, fillchar])
字符串居中，左右两边使用fillchar进行填充，使得整个字符串的长度达到width指定的大小。
fillchar默认为空格。
如果width小于字符串的长度，则无法填充直接返回字符串本身，也不会创建新字符串对象
例如：使用下划线填充并居中字符串
>>> print('abc'.center(5,'_'))
_ab_
>>> print('abc'.center(6,'_'))
__abc_
（2）字符串偏左/右，往另一边填充
str.ljust(width[, fchar])
#使用fchar填充在字符串的右边，使得整体长度为width。
str.rjust(width[, fchar])
#使用fchar填充在字符串的左边，使得整体长度为width。
PS：如果不指定fchar，则默认使用空格填充。如果width小于或等于字符串的长度，则无法填充，直接返回原字符串，且不会创建新的字符串对象。
例如：
>>> print('xyz'.ljust(5,'_'))
xyz__
>>> print('xyz'.rjust(5,'_'))
__xyz
（3）填充零
str.zfill(width)
- 用0填充在字符串的左边使其长度为width。
- 如果S前右正负号+/-，则0填充在这两个符号的后面，且符号也算入长度。
- 如果width小于或等于S的长度，则无法填充，直接返回原字符串，且不会创建新字符串对象。
例如：
>>> print('abc'.zfill(5))
00abc
>>> print('-abc'.zfill(5))
-0abc
>>> print('+abc'.zfill(5))
+0abc
>>> print('42'.zfill(5))
00042
4、字符串的子串搜索
（1）返回字符串中子串出现的次数
str.count(sub[, start[, end]])
PS：可以通过索引编号，指定从哪里开始计算(start)以及计算到哪里结束(end)，默认索引从0开始计算，不包括end边界。
例如：
>>> print('aaxyzaabbcaa'.count('aa'))
3
（2）判断字符串以什么字符开头或结尾
str.startswith(fix[, start[, end]])
# 判断字符串是否以fix开头
str.endswith(fix[, start[, end]])
# 判断字符串是否以fix结尾
- 返回布尔值：True和False。
- fix可以是一个元组(tuple)。
- 可以指定起始start和结尾end的搜索边界。
例如：fix是普通的字符串时
>>> print('abcxyz'.startswith('abc'))
True
# False，因为限定了搜索范围为从索引4开始
>>> print('abcxyz'.endswith('xyz',4))
False
# False，因为搜索范围为'abcxy'
>>> print('abcxyz'.endswith('xyz',0,5))
False
fix是元组(tuple)时，只要tuple中任意一个元素满足endswith的条件，就返回True。
# tuple中的'xyz'满足条件
>>> print('abcxyz'.endswith(('ab','xyz')))
True
# tuple中'ab'和'xy'都不满足条件
>>> print('abcxyz'.endswith(('ab','xy')))
False
（3）搜索字符串中是否包含某子串
str.find(sub[, start[, end]])
str.rfind(sub[, start[, end]])
str.index(sub[, start[, end]])
str.rindex(sub[, start[, end]])
find()搜索字符串中是否包含子串sub，如果包含，则返回sub的索引位置，否则返回"-1"。可以指定起始start和结束end的搜索位置。
rfind()则是返回搜索到的最右边子串的位置，如果只搜索到一个或没有搜索到子串，则和find()是等价的。
index()和find()一样，唯一不同点在于当找不到子串时，抛出ValueError错误。
例如：
>>> 'abcxyzXY'.find('xy')
3
>>> 'abcxyzXY'.find('xy',4)
-1
>>> 'xyzabcabc'.rfind('bc')
7
可以使用in操作符来判断字符串是否包含子串sub，它返回的不是索引位置，而是布尔值。
>>> 'xy' in 'abxycd'
True
>>> 'xyz' in 'abxycd'
False
5、替换操作
（1）将字符串中的子串old替换为new字符串
str.replace(old, new[, count])
PS：如果给定count，则表示只替换前count个old子串。如果str中搜索不到子串old，则无法替换，直接返回原字符串，且不创建新字符串对象。
>>> 'abcxyzoxy'.replace('xy','XY')
‘abcXYzoXY’
>>> 'abcxyzoxy'.replace('xy','XY',1)
‘abcXYzoxy’
>>> 'abcxyzoxy'.replace('mn','XY',1)
‘abcxyzoxy’
（2）字符串映射转换（可以理解为一种简单的加密方法）
str.translate(table)
static str.maketrans(x[, y[, z]])
str.maketrans()生成一个字符一 一映射的table，然后使用translate(table)对字符串中的每个字符进行映射。
例如，现在想要对"I love you"做一个简单的加密，将里面部分字符都替换为数字，这样别人就不知道转换后的这句话是什么意思。
第一步：创建映射表
# maketrans()生成映射表
>>> in_str='abcxyzlij'
>>> out_str='123456789'
>>> map_table=str.maketrans(in_str,out_str)
第二步：使用映射表实现映射（加密）
# 使用translate()进行映射
>>> mylove = 'I love you'
>>> result = mylove.translate(map_table)
>>> print(result)
I 7ove 5ou
PS：maketrans(x[, y[, z]])中的x和y都是字符串，且长度必须相等。如果maketrans(x[, y[, z]])给定了第三个参数z，则这这个参数字符串中的每个字符都会被映射为None。
例如:
>>> in_str='abcxyz'
>>> out_str='123456'
>>> map_table=str.maketrans(in_str,out_str,'ar')
>>> mylove='How are you'
>>> result=mylove.translate(map_table)
>>> print(result)
How e 5ou
6、字符串分割操作
（1）分割为三元组
str.partition(sep)
str.rpartition(sep)
搜索字符串中的子串sep，并从sep处对字符串进行分割，最后返回一个包含3元素的元组：sep左边的部分是元组的第一个元素，sep自身是元组的二个元素，sep右边是元组的第三个元素。
partition(sep)从左边第一个sep进行分割，rpartition(sep)从右边第一个sep进行分割。
如果搜索不到sep，则返回的3元素元组中，有两个元素为空。partition()是后两个元素为空，rpartition()是前两个元素为空。
例如：
>>> print('abcxyzxyzopq'.partition('xy'))
('abc', 'xy', 'zxyzopq')
>>> print('abcxyzxyzopq'.rpartition('xy'))
('abcxyz', 'xy', 'zopq')
（2）分割字符串，并生成一个列表
str.split(sep=None, maxsplit=-1)
str.rsplit(sep=None, maxsplit=-1)
str.splitlines([keepends=True])
split()根据sep对字符串进行分割，maxsplit用于指定分割次数，如果不指定maxsplit或者给定值为"-1"，则会从左向右搜索并且每遇到sep一次就分割直到搜索完字符串。
如果不指定sep或者指定为None，则改变分割算法：以空格为分隔符，且将连续的空白压缩为一个空格。
rsplit()和split()是一样的，只不过是从右边向左边搜索。
splitlines()专门用来分割换行符。虽然它有点像split('\n')或split('\r\n')，但它们是有区别的。
>>> '1,2,3'.split(',')
['1', '2', '3']
>>> '1,2,3'.split(',',1)
['1', '2,3'] # 只分割了一次
>>> '1,2,,3'.split(',')
['1', '2', '', '3'] # 不会压缩连续的分隔符
>>> '<hello><><world>'.split('<')
['', 'hello>', '>', 'world>']
>>> '<hello><><world>'.split('<>')
['<hello>', '<world>']
>>> '1 2 3'.split()# 不指定sep时
['1', '2', '3']
>>> '1 2 3'.split(maxsplit=1)
['1', '2 3']
>>> ' 1 2 3 '.split()
['1', '2', '3']
>>> ' 1 2 3 \n'.split()
['1', '2', '3']
# 显式指定sep为空格、制表符、换行符时
>>> ' 1 2 3 \n'.split(' ')
['', '1', '', '2', '', '3', '', '\n']
>>> ' 1 2 3 \n'.split('\t')
[' 1 2 3 \n']
>>> ' 1 2\n3 \n'.split('\n')
[' 1 2', '3 ', ''] # 注意列表的最后一项''
>>> ''.split('\n')
['']
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines()
['ab c', '', 'de fg', 'kl']
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)
['ab c\n', '\n', 'de fg\r', 'kl\r\n']
将split()和splitlines()相比较一下：
#### split()
>>> ''.split('\n')
[''] # 因为没换行符可分割
>>> 'One line\n'.split('\n')
['One line', '']
#### splitlines()
>>> "".splitlines()
[] # 因为没有换行符可分割
>>> 'Two lines\n'.splitlines()
['Two lines']
7、join操作
str.join(iterable)
将可迭代对象(iterable)中的字符串使用str字符串连接起来。
注意，iterable中必须全部是字符串类型，否则报错。
如果你还是python的初学者，还不知道iterable是什么，却想来看看join的具体语法，那么你可以暂时将它理解为：字符串string、列表list、元组tuple、字典dict、集合set。
例如：
字符串
>>> X1='python'
>>> '_'.join(X1)
'p_y_t_h_o_n'
元组
>>> X2=('1','2','3')
>>> '_'.join(X2)
'1_2_3'
集合。注意，集合无序。
>>> X3={'p','y','t','h','o','n'}
>>> '_'.join(X3)
'n_o_p_h_y_t'
列表
>>> X4=['py','th','o','n']
>>> '_'.join(X4)
'py_th_o_n'
字典
>>> X5={'name':"malongshuai",'gender':'male','from':'China','age':18}
>>> '_'.join(X5)
'name_gender_from_age'
iterable参与迭代的部分必须是字符串类型，不能包含数字或其他类型。
8、修剪操作
移除左右两边、左边、右边的字符char。如果不指定chars或者指定为None，则默认移除空白(空格、制表符、换行符)。
str.strip([chars])
str.lstrip([chars])
str.rstrip([chars])
唯一需要注意的是，chars可以是多个字符序列。在移除时，只要是这个序列中的字符，都会被移除。
例如：移除单个字符或空白。
>>> ' abcde '.strip()
'abcde'
>>> print('www.example.com'.lstrip('cmowz.'))
example.com