7. 字符串

7.1 定义与创建

字符串就是Python中的路人脸，它看起来非常普通也是python中最常见的数据类型。但也正是字符串无处不在的原因，让它具有极强的适应能力与包容性：哪儿都有它，它也能为了适应环境拥有多副面孔。

他的无处不在是环境的需要，因此他的创建也要足够简单干脆，把他装进一对引号 '' 或 "" 中，然后赋给一个变量名就好：

# 他可以在单引号中成长：
>>> name1 = 'Think'# 他也可以在双引号下出现：
>>> name2 = "About"

7.2 访问

7.2.1 普通访问

字符串内部存在两套索引，正向索引从0开始每次递增1、反向索引倒着从-1开始每次递减1。我们可以用 变量[索引] 的方式访问：

>>> a = 'Think'
>>> a[3]
'n'

我们还可以用 变量[索引:索引] 的方式来访问，此时记得采取 用 左闭右开 的原则。例如 用 变量[m:n] 即是以索引为m的字符开始截取，截取到索引为n-1的字符：

>>> a = 'Think'
>>> a[1:3]
'hi'

如果从第一个索引开始截取我们可以省略到引号前面的部分，用 变量[:索引] 的方式：

>>> a = 'Think'
>>> a[:2]
'Th'

如果截取到最后一个我们可以省略掉引号后面的部分，用 变量[索引:] 的方式：

>>> a = 'Think'
>>> a[3:]
'nk'

如果截取全部也可以省略掉冒号两边的数字，用 变量[:] 来访问：

>>> a = 'Think'
>>> a[:]
'Think'

为了便于理解，可以见图：

7.2.2 寻找特殊信息

7.2.2.A 查看字符串长度

我们也可以用一些方式来查看字符串的一些特殊信息，例如用 len(变量名) 查看字符串的长度：

>>> a = 'Think'
>>> len(a)
5

7.2.2.B 查看字符串极值

还可以用 max(变量名) 查看字符串中的最大值，或者用 min(变量名) 查看字符串中的最小值等：

>>> a = '3579'# 查看最大值
>>> max(a)
9#查看最小值
>>> min(a)
3

Ⅰ. 当字符串内容为数字或者英文时：

我们发现当字符串内都是整型数字时，即按照数字大小作为规则。当然也可以对英文字母排序，例如：

>>> a = 'abcdef'# 查看最大值
>>> max(a)
'f'#查看最小值
>>> min(a)
'a'

Ⅱ. 当字符串内容为汉字时：

但是当字符串内容为汉字的时候，排序起来就比较麻烦了。网上关于爬虫汉字排序的有不少文章，有人说是按照id值，有人说按照拼音首字母。某些情况下可能确实会出现这样的现象，但是当你对足够多的字符串进行测试后就会发现这个“规律”不是特定的，例如下面这个例题：

>>> a = '你好啊'# 看一下max和min
>>> max(a); min(a)
'好'
'你''''
发现最大值是'好'，最小值是'你'。
而A<H<N，所以显然不可能是按照首字母排序。
'''# 我们再看一下a内三个字符串的id以及三个字本身的id
>>> id(a[0]);id(a[1]);id(a[2])
3099049834736
3099049834496
3099049834496
>>> id('你');id('好');id('啊')
3099049834496
3099049834736
3099052672544#这时我们知道，盛传的“按首字母”和“按id”显然是错误的了。

那究竟是按照什么呢？其实在计算机中汉字排序本身是没有统一的规则的，这和最初计算机对汉字的编码有关系。我能力不够就不打肿脸充胖子了，这里有一篇关于Python汉字排序的文章很好，如果真的感兴趣可以了解一下：

http://gerry.lamost.org/blog/?p=338&from=timeline

Ⅲ. 当字符串英文数字混合时：

还要注意一点是，如果某个字符串中同时出现了字母和整型数字的话，Python默认字母大于数字，基于这个原则再进一步判断。我们可以先用最大的单位整型数字 9 和字母表判断一遍大小验证这个原则：

>>> a = '9'
>>> import string # 调用内部模块 string，这个模块内有很多内容我们可以直接用
>>> for i in string.ascii_lowercase: # 把26个字母赋给 i ，再依次判断它们是否大于a的值9：
···       print(i>a)
True
True
True
True
True
True
True
True
True
True
True
True
True
True
True
True
True
True
True
True
True
True
True
True
True
True

我们看到返回了26个 True ，就说明26个字母中每个字母都比最大的单位整型数字 9 大。

对于刚才遍历26个字母的过程，已经会至少一种方式的可以直接跳过下面这段，对上述代码还有疑惑的可以看这段详细解释：

刚才我在遍历26个字母的时候，用了这样的方式： import string for i in string.ascii_lowercase: 第一行：其中 import … 是调用某个模块的方式，我们在这里调用的是 string 这个内置模块，用它可以直接调用很多常用字符串。 第二行前半句：其中 for 目标 in 模块 是将某个模块下的内容赋给 i 用的，可以将 for … 理解为“给…”。所以 for i in string 的意思为：调用string模块给i。 第二行后半句：我们不需要把整个string模块都给i，只需要把小写字母给他就行了。而小写字母从目录上属于ASCII码，所以我们首先要用 for 目标 in 模块.模块下二级目录_模块下三级目录 的方式让这个调用更精确。所以 string.ascii_lowercase 的意思为：将string模块下ASCII码中的lowercase（小写字母）全部赋值给i。 这样，a~z就都成功给i了。

我们再看一个例子：

>>> a = 'Think25'
>>> max(a); min(a)
'n'
'2'

当字母与数字混合的条件下寻找最大值时，因为数字默认比字母小，所以会略过数字直接在字母中寻找排序最往后的就是最大值。而当寻找最小值时，也会略过字母直接在数字中寻找最小值。

7.2.3 简单查找

我们可以用 '内容' in 变量名 与 '内容' not in 变量名 对字符串内是否存在某个内容进行检索。关于这个用法有两个注意要点：

一次可以检查多个连续的内容。
检索时要区分大小写。

关于这两个特点，我们通过例题来感受：

>>> a = 'Think'
>>> 'h' in a
True
>>> 'in' in a
True
>>> 't' in a
False

通过观察上面的例题我们发现 'in' 可以被检索到，即可得知特点1：一次可以检查多个连续的内容

同时 't' 检索不到，所以得知特点2：检索时区分大小写

7.2.4 特定检查

7.2.4.A 检查内容索引

Ⅰ. 从左边开始检索：

我们不仅仅可以检查字符串中是否包含某个内容，我们还可以用 变量名.find(内容) 和 变量名.index(内容) 来检查具体内容的索引。这两种用法一共有三个特点需要注意：

1. 两种方法都只返回左起第一个出现的字符的索引。
2. find 不会报错，index 会报错。
3. 检索允许设置范围。

以上三个特点我们通过例题来感受：

>>> a = 'ThinkAboutit'# 当内容确实可以检索到时：
>>> a.find('i')
2
>>> a.index('i')
2#当内容检测不到时：
>>> a.find('z')
-1
>>> a.index('z')
ValueError: substring not found

通过观察上面的例题，我们可以观察到这对用法的两个特点：

1.当检查 'i' 的时候，明明字符串中存在两个但是不管用哪种方法都只返回了最左边的那个索引。所以我们得知 特点1 ：两种方法都只返回左起第一个出现的字符的索引。

2.另外当检测的内容不存在时，两者的返回结果时不同的。 变量名.find(内容) 不会报错而是输出一个 -1 ，而 变量名.index(内容) 会报错：

ValueError: substring not found

翻译：俺找不到啊……

所以我们得知特点2：find 不会报错，index 会报错。

这个方法其实还可以用 字符串.find(内容,开始范围,范围截止) 或 字符串.index(内容,开始范围,范围截止) 设置检索范围的：

>>> a = 'ThinkAboutit'
>>> a.index('k',5,11)
ValueError: substring not foun

在检索内容的后面还可以输入两个数字来限定搜索位置，例如 ('k',5,11) ，即是从索引为5的位置开始，截止到索引为11的前一个（即为一个左闭右开区间）。此时我们又得知特点3：检索允许设置范围。

Ⅱ. 从右边开始检索：

刚才我们说过了怎么从左边检索并返回索引，与之对应的还有一对从右边检索的方式。区别的方式很简单，这一对方法即是在 变量名.find() 和 变量名.index() 的基础上加了一个代表 right（右）的 r 而已，即 变量名.rfind() 和 变量名.rindex() ：

同样，这两种用法也有三个特点需要注意：

1. 两种方法都只返回右起第一个出现的字符的索引。
2. find 不会报错，index 会报错。
3. 检索允许设置范围。

以上三个特点我们通过例题来感受：

>>> a = 'ThinkAboutit'# 当内容确实可以检索到时：
>>> a.rfind('i')
10
>>> a.rindex('i')
10#当内容检测不到时：
>>> a.rfind('z')
-1
>>> a.rindex('z')
ValueError: substring not found

通过观察上面的例题，我们可以观察到这对用法的两个特点：

1.当检查 'i' 的时候，同样出现了两次但是两种方法却都返回的最右边的那个索引，与刚才的检索顺序完全相反。所以我们得知 特点1 ：两种方法都只返回右起第一个出现的字符的索引。

2.与上一对用法一样的是，当检测的内容不存在时，两者的返回结果时不同的。 变量名.rfind(内容) 不会报错而是输出一个 -1 ，而 变量名.rindex(内容) 会报错：

ValueError: substring not found

翻译：俺找不到啊……

所以我们得知特点2：rfind 不会报错，rindex 会报错。

这个方法其实还可以用 字符串.rfind(内容,开始范围,范围截止) 或 字符串.rindex(内容,开始范围,范围截止) 设置检索范围的：

>>> a = 'ThinkAboutit'
>>> a.rindex('k',5,11)
ValueError: substring not foun

在检索内容的后面还可以输入两个数字来限定搜索位置，例如 ('k',5,11) ，即是从索引为5的位置开始，截止到索引为11的前一个（即为一个左闭右开区间）。此时我们又得知特点3：检索允许设置范围。

7.2.4.B 检查特定位置的内容

所谓年年岁岁花相似，一个地域内的野草长得也都是大致相同的。我们可以用 变量名.endswith('内容') 和 变量名.startswith('内容') 的方式来检验字符串开头或者结尾是否有指定的内容。

某天，1年级1班的桃老师让大家学会礼貌的介绍自己的年龄，要求句子以 '大家好' 开头，以 '谢谢大家' 结尾。桃老师可以用这一对用法来检查是否符合格式：

>>> wangyoucai = '我是王有才，我今年6岁，谢谢大噶'
>>> wangyoucai.startswith('我是')
True
>>> wangyoucai.endswith('家')
False

通过观察发现： 变量名.endswith('内容') 用于检查字符串最右边是否是某固定内容， 变量名.startswith('内容') 用于检查字符串最左边是否是某固定内容。

7.2.4.C 检查重复字符出现数量

桃老师看过了大家的介绍草稿，在所有同学修改后在班内开始让大家上台介绍。 '郑士' 同学先上去了：

>>> zhengshi = '大家好，额我是额郑士，我今年6岁了，'额谢谢大家'

'郑士' 同学还是有点儿紧张啦 ，一直带口头禅 '额' 。那…他一共说了几次呢？（一定要这么残忍吗）我们可以先检验下：

>>> zhengshi = '大家好，额我是额郑士，我今年6岁了，'额谢谢大家'
>>> zhengshi.count('额')
3

通过上述案例我们可以知道用 变量名.count('内容') 可以检验某个内容在字符串中共出现了几次。我们还可以给检查设定一个范围例如：

>>> zhengshi = '大家好，额我是额郑士，我今年6岁了，'额谢谢大家'
>>> zhengshi.count('额',3,7)
1

示意图如下：

7.3 Is…判断信息

在Python中还存在一系列更详细的判断用法，它们的共同特征是开头都有一个 'is' ，可以理解为 “是…嘛？”，看到它们你可以自动在它们后面脑补上一个大问号：

它们一共有夺命九连问：

7.3.1 第一问：是数字字符嘛！

我们用 变量名.isnumeric 来判断一个字符串内是否都是数字字符：

>>> a = '12三四⑤⑥ⅦⅧ玖拾' '
>>> a.isnumeric()
True

可能有人想这么乱七八糟的玩意儿也能报真？对呀，你看人家问的是“数字字符”，只要能表达数字的字符都可以。

7.3.2 第二问：是阿拉伯数字嘛！

这次问的时候知道较真了，我问的就是阿拉伯数字：

# 先创建一个稀奇古怪的数字字符串
>>> a = '5五⑤伍Ⅴ'
# 我们把里面的每个单独的字符都先后赋给i
>>> for i in a:
...     i.isdecimal() #然后检验这5个i们能不能被报真
...
True
False
False
False
False

发现这次只有第一个 '5' 被报真了，验证确实只是阿拉伯数字才能通过检验。

7.3.3 第三问：字母是小写嘛！

我们还可以通过 变量名.islower 来检测字符串内所有英文是否都是小写（注意这句话的语序），我们通过例子观察一下：

>>> a = 'think'
>>> b = 'About'
>>> a.islower()
True
>>> b.islower()
False

我们发现只有当所有字母都是小写的时候才会报对，而 'About' 中有一个大写字母 'A' 所以就会报错。

除此之外，我们再观察一个例子：

>>> a = 'thinkabout可能性'
>>> a.islower()
True

字符串中出现了汉字 '可能性' 却仍然报真，说明这个用法是在 “检验是否所有字母都是小写的” 而不是 “检验是否都是小写字母” 。如果字符串中有其他类型会直接忽略。

7.3.4 第四问：字母是大写嘛！

除了检查字母是否为小写，我们当然还可以通过 变量名.isupper 来检测字符串内所有英文是否都是小写（注意这句话的语序），我们通过例子观察一下：

>>> a = 'Think'
>>> b = 'THINK'
>>> a.isupper()
False
>>> b.isupper()
True

同样，只有当所有字母都是大写的时候才会报对，而 'Think' 中 'hink' 均不是大写字母，所以就会报错。

除此之外，我们再观察一个例子：

>>> a = 'THINKABOUTIT现在'
>>> a.isupper()
True

字符串中出现了汉字 '现在' 却仍然报真，说明这个用法是在 “检验是否所有字母都是大写的” 而不是 “检验是否都是大写字母” 。如果字符串中有其他类型会直接忽略。

7.3.5 第五问：是标题格式的嘛！

我们可以检验某个文本中的某句英文是否为标题格式，那标题是啥样？我们随便去谷歌搜搜去年书单：

可以看到一个共同特点：所有字母的首字母均为大写。

但是要注意一个问题，上面的选例并不能代表普遍情况。熟悉英文标题书写的朋友应该会知道，字母在三个以及以下的介词、连词等可以不用小写等规则。但在Python中Title类型判断上，必须所有单词首字母都为大写才可以报真：

>>> a = 'Washington Black'
>>> b = 'How to Read a Book'
>>> a.istitle()
True
>>> b.istitle()
False

老话说得好，在什么地方就唱什么地方的戏。我们可以看到 How to Read a Book 这个绝对正确的标题名却报错了，说明在Python中对标题类型的判断还是要遵守单词首字母必须大写这一规矩的。

7.3.6 第六问：是字符嘛！

看似很简单的一个问题，通过的范围还是很广的。不仅仅英语字母是字符，其他语言的文字也可以划为字符的范围中。

我们将俄文、英文、中文和日文字符串都放到一个列表里，然后用 变量名.isalpha() 的方式检验一下：

>>> a = ['Д','Think','思考','できる']
>>> for i in a:
...     print(i.isalpha())
...
True
True
True
True

发现都是可以通过的。还一个要注意的是，在这个用法下阿拉伯数字是不能通过的，但汉字的数字字符行不行呢?

>>> a='四百二十五'
>>> a.isnumeric()
True
>>> a.isalpha()
True

我们通过观察上面的例题发现：

'四百二十五' 可以同时通过检验数字字符的和检验字符的。因为 '四百二十五' 属于汉字字符，所以可以通过 变量名.isalpha() ；因为 '四百二十五' 还是汉语中的字符，所以它自然也能通过 变量名.isnumeric() 的检测。

7.3.7 第七问：是字母数字嘛！

我们还可以用 变量名.isalnum() 来检查某个字符串内是否是由字母或者数字构成的，只要有其中一类即可报真。

我们将只包含英文的、只包含数字的和数字英文混合的三个字符串放到列表中。然后分别用 变量名.isalnum() 检验他们：

>>> a = ['Think','Think25','25']
>>> for i in a:
...     print(i.isalnum())
...
True
True
True

发现英文字母与阿拉伯数字只要至少包含其中一种，即可报真。

7.3.8 第八问：是十进制字符嘛！

我们还可以使用 变量名.isdecimal() 来检验字符串内是否都是十进制字符，可以通过的只有两类：Unicode数字、全角数字。

>>> a = '123４５６'
>>> a.isdecimal()
True

我们可以看到unicode数字 '123' 和全角数字 '４５６' 都可以报真。

7.3.9 第九问：是空白的嘛！

空白还管？管！用 变量名.isspace() 来判断一个字符串内容是否为空白：

>>> a = '  '
>>> b = ''
>>> c = 'T h i n k'
>>> a.isspace()
True
>>> b.isspace()
False
>>> c.isspace()
False

注意：空白的意思是内容均为空格，一个没有内容的字符串当然也不包含空格，所以自然报假。

7.4 更改

7.4.1 修改

野草之所以可以无处不在，是因为它永远可以适应环境的生存下去。只要某处需要它，它就可以变成任何指定的样子。

7.4.1.A 它可以整个变小

我们用 变量名.lower() 让一个字符串中的所有英文字母变成小写的：

>>> a = 'Think25'
>>> a.lower()
'think25'

lower只管将所有英文字母变成小写，如果有其他的类型存在则会直接忽视。

7.4.1.B 它可以整个变大

我们用 变量名.upper() 让一个字符串中的所有英文字母变成大写的：

>>> a = 'Think25'
>>> a.upper()
'THINK25'

upper 只管将所有英文字母变成大写，如果有其他的类型存在也会直接忽视。

7.4.1.C 它还可以大小互换

我们甚至可以用 变量名.swapcase() 让一个字符串中的所有英文字母的大小态互换：

>>> a = 'Think25'
>>> a.swapcase()
'tHINK25'

swapcase 只管将所有英文字母的大小写状态互换，如果有其他的类型存在仍会直接忽视。

7.4.1.D 它可以只让头大

不不…不是这个头大。用 变量名.capitalize() 可以把一个字符串的首字母大写：

# 只有英文时
>>> a = 'MAKE A BIG THING'
>>> a.capitalize()
'Make a big thing'# 英文和其他类型内容并存，第一个字符为英文时
>>> b = 'MAKE A BIG 12 THING25'
>>> b.capitalize()
'Make a big 12 thing25'# 英文和其他类型内容并存，第一个字符不是英文时>>> c = '23 MAKE A BIG THING'
>>> c.capitalize()
'23 make a big thing'

通过上述例题可以观察到三个特点：

1.当字符串中只有英文时：会使第一个英文字母变成大写 2.当字符串不只有英文时：若索引为0的字符时英文字母，把那个字母变成大写 3.当字符串不只有英文时：若索引为0的字符不是英文字母，无变化

概括就一个重点：如果想让这个用法有效，要保证第一个字符确实为英文字母。

7.4.1.E 字符串的内部替换

字符串除了检索内容、变成某种特定形式外，我们还可以用 变量名.replace('要替换的内容','替换目标内容') 将字符串中特定的内容替换成指定的内容。

比如我们将 'Think about it' 打成了 'Thunk about it' ，我们就可以用这个方式替换下试试：

>>> a = 'Thunk about it'
>>> a.replace('u','i')
'Think aboit it'

我们发现不对啊！ 'Think' 虽然对了，可是怎么 'about' 里的 'u' 也替换成 'i' 了？这说明我们需要设置替换次数，即 变量名.replace('要替换的内容','替换目标内容','替换次数') ：

>>> a = 'Thunk about it'
>>> a.replace('u','i',1)
'Think about it'

当我们给替换设置好次数就可以了，不设置次数的时候默认将所有内容替换。

7.4.1.F 变成标题

还记得刚才我们提过的 istitle() 吗，刚才那个用法可以判断一个字符串的格式是否是标题格式的。而此处的用法 变量名.title() 则是将某个字符串中的英文部分变成标题格式：

>>> a = 'How to Read a Book'
>>> a.title()
'How To Read A Book'

可以看到原来的字符中的每一个单词都变成首字母大写的格式了，那如果句子中有别的类型会像 capitlize() 一样被干扰执行吗？我们看一下：

>>> a = '25 How to Read 87 a Book 56'
>>> a.title()
'25 How To Read 87 A Book 56'

发现执行没有受到任何影响，说明 变量名.title() 会将每个单词的首字母大写化，无论字符中是否有其他类型的字符串干扰。

7.4.1.G 易容方法：按照某种规则编码

字符串不仅仅可以修改格式与某部分的样子，它甚至可以按照某种规则将整体变成另一个样子，这就是字符串的编码。我们使用 变量名.encode('编码类型') 的方式，将字符串内容以其他编码的形式输出：

# 创建一个以中文为内容的字符串
>>> a = '求学时'# 我们可以用UTF-8的编码方式输出结果：
>>> a.encode('utf-8')
b'xe6xb1x82xe5xadxa6xe6x97xb6'#或者以GBK的编码方式输出结果：
>>> a.encode('GBK')
b'xc7xf3xd1xa7xcaxb1'#注意：原字符串是不会发生改变的
>>> a
'求学时'

7.4.1.H 打回原形：按照某种规则解码

我们还可以使用 变量名.decode('解码类型') 将UTF-8、GBK或者其他编码方式的内容转换回来：

# 先创建一个中文字符串，然后编码为utf-8
>>> a = '求学时'
>>> b = a.encode('utf-8')
>>> b
b'xe6xb1x82xe5xadxa6xe6x97xb6'# 再转化回来：
>>> b.decode('utf-8')
'求学时'

7.4.2 填充并对齐

字符串还可以设置在某个长度下的对齐方式，并再对齐后产生的空白空间上设置指定字符来填充。

7.4.2.A 居中

我们可以用 变量名.center(填充后的总长度,'填充内容') 的方式将某个字符串填充到某个长度后居中，多出来的空白长度则可以使用指定的内容填充。

例如我们想把字符串 'Think' 填充到 20 个长度，并让它在总长度中处于居中位置，其他部分用 '-' 符号填充，我们可以这样：

>>> a = 'Think'
>>> a.center(20,'-')
'-------Think--------'
>>> a
'Think'

要注意这时仍然没有更改原变量，如果想要更新这个结果到 a 中去我们可以通过对 a 赋值的方式：

# 创建 a 并将结果重新赋值
>>> a = 'Think'
>>> a = a.center(20,'-')# 返回一下 a 的值：
>>> a
'-------Think--------'# 计数一下 a 的长度：
>>> len(a)
20

当我们不填写后面的填充内容时，则默认使用空格填充：

>>> a = 'Think'
>>> a.center(20)
'       Think        '

7.4.2.B 左对齐

Ⅰ. 自定义左对齐:

除了居中，我们还可以用 变量名.ljust(填充后的总长度,'填充内容') 的方式将某个字符串填充到某个长度后左对齐，多出来的空白长度则可以使用指定的内容填充。

例如我们想把字符串 'Think' 填充到 20 个长度，并让它在总长度中处于左对齐的位置，其他部分用 '-' 符号填充，我们可以这样：

>>> a = 'Think'
>>> a.ljust(20,'-')
'Think---------------'
>>> a
'Think'

要注意这时仍然没有更改原变量，如果想要更新这个结果到 a 中去我们可以通过对 a 赋值的方式：

# 创建 a 并将结果重新赋值
>>> a = 'Think'
>>> a = a.ljust(20,'-')# 返回一下 a 的值：
>>> a
'Think---------------'# 计数一下 a 的长度：
>>> len(a)
20

当我们不填写后面的填充内容时，则默认使用空格填充：

>>> a.ljust(20)
'Think               '

Ⅱ. 用数字0左对齐:

还有一种左对齐方式，即将某字符串用数字 '0' 填充至某长度，然后将字符左对齐：

>>> a = 'Think'
>>> a.zfill(20)
'000000000000000Think'
>>> a
'Think'

注意，这种方式下填充内容只能为 '0' ，如果我们强行传入一个填充字符就会报错：

>>> a.zfill(20,'-')
TypeError: zfill() takes exactly one argument (2 given)

报错内容：

zfill() takes exactly one argument (2 given)

翻译：俺只能要一个（你却给了俺俩）。

7.4.2.C 右对齐

除了居中，我们还可以用 变量名.rjust(填充后的总长度,'填充内容') 的方式将某个字符串填充到某个长度后右对齐，多出来的空白长度则可以使用指定的内容填充。

例如我们想把字符串 'Think' 填充到 20 个长度，并让它在总长度中处于右对齐的位置，其他部分用 '-' 符号填充，我们可以这样：

>>> a = 'Think'
>>> a.rjust(20,'-')
'---------------Think'
>>> a
'Think'

要注意这时仍然没有更改原变量，如果想要更新这个结果到 a 中去我们可以通过对 a 赋值的方式：

# 创建 a 并将结果重新赋值
>>> a = 'Think'
>>> a = a.rjust(20,'-')# 返回一下 a 的值：
>>> a
'---------------Think'# 计数一下 a 的长度：
>>> len(a)
20

当我们不填写后面的填充内容时，则默认使用空格填充：

>>> a.rjust(20)
'               Think'

7.4.3 翻译

我们甚至可以利用python做一个基础的加密方法，让指定的内容按照加密方式加密成另一种形式。

我们先梳理一下最简单的将文本加密并解密的过程：

1. 首先要明确一份所有可以被转换的内容（信息1）
2. 其次要制作一份所有与之对应的转换后的内容（信息2）
3. 然后这两部分的转换等式就是转换规则（信息1 → 信息2）
4. 另外有时候被输入内容可能存在其他无关项，这些东西是不需要被转换的。 这时候我们可以在 “信息1 → 信息2 ”的这个过程中列出来，明确哪些内容要删除。

而反转换同理：根据转换规则（信息1 → 信息2）分别把 转换后的信息 对应成 转换前的信息（ 信息2→ 输入），再剔除相关不需要被转换的内容，从而实现解密。明确了这个思路，我们来具体看方法：

'''
转换规则 = bytes.maketrans(b'信息1',b'信息2')
加密后 = b'要转换的内容'.translate(转换规则,b'不需要转换的内容')
'''

我们来上手试一下，比如需要将 tounokyou@gmail.com 这个邮箱地址加密，看看应该怎么做。

第一行：转换规则 = bytes.maketrans(b'信息1',b'信息2')

我们首先要把确定哪些文字需要被转换，全部写到 信息1 中去，；这些信息要被转换成什么文字，全部写道 信息2 中去：

'''
为避免转换混乱，需要将邮箱中重复字符去除后输入到 信息1 的位置去
同时 信息2 长度应与 信息1 保持一致
'''
>>> myrule = bytes.maketrans(b'tounky@gmail.c',b'cReUhWkSiTpZaD')

第二行：加密后 = b'要转换的内容'.translate(转换规则,b'不需要转换的内容')

然后将目标内容 tounokyou@gmail.com 和 规则名 myrule 置入第二行公式的对应位置中，这里可以设置不将 @ 和 . 列入转换范围。

>>> myrule = bytes.maketrans(b'tounky@gmail.c',b'cReUhWkSiTpZaD')
>>> b'tounokyou@gmail.com'.translate(myrule,b'@.')
b'cReURhWReSiTpZDRi'

转换成功！

这里需要解释一下过程和结果频繁出现的 b 是什么：

第一行：myrule = bytes.maketrans('tounky@gmail.c','cReUhWkSiTpZaD')

这里出现了两次 b ，分别在 信息1 和 信息2 这两个字符串位置的前面。在我们的用法 bytes... 中，只能接受传入 bytes类型 的内容，而在字符串前面加 b 的意思是：这后面的字符串变为byte类型字符串。加上一个 普通字符串 → bytes类型 的过程会避免报错。如果不加这个 b 将会报错：

>>> myrule = bytes.maketrans('tounky@gmail.c','cReUhWkSiTpZaD')
TypeError: a bytes-like object is required, not 'str'

错误代码：

TypeError: a bytes-like object is required, not 'str'

翻译：俺只接受bytes类型的，哪怕长得像（bytes-like）也行啊！str（字符串）俺可不要。

第二行：b'tounokyou@gmail.com'.translate(myrule,b'@.')

因为在第一行中我们在 信息1 和 信息2 处传入的都是 bytes类型 的字符串，这里只有输入 bytes类型 的字符串才能在转换规则中找到它们，所以这里也需要输入 b 。

结果：b'cReURhWReSiTpZDRi'

信息1 和 信息2 处记录的规则都是用 bytes类型 的字符串记录的，输入的邮箱也是以 bytes类型 传入的，所以结果自然也是 bytes类型 的。

7.4.4 去除指定位置的内容

关于字符串有三个 strip 用法，分别用于去除位于字符串左边、右边以及两端的指定内容。

7.4.4.A 具体用法：

变量名.lstrip('要去除的位于左边的特指内容') 用来去除左边的：

>>> a = '-----Think-----'
>>> a.lstrip('-')
'Think-----'

变量名.rstrip('要去除的位于左边的特指内容') 用来去除右边的：

>>> a = '-----Think-----'
>>> a.rstrip('-')
'-----Think'

变量名.strip('要去除的位于左边的特指内容') 用来去除两端的：

>>> a = '-----Think-----'
>>> a.strip('-')
'Think'

7.4.4.A 两个要点：

Ⅰ. 不能指定删除个数：

这三个用法均无法像刚才的 replace 一样可以指定删除的个数，如果我们强行指定删除个数的话：

>>> a = '-----Think-----'
>>> a.strip('-',1)
TypeError: strip expected at most 1 arguments, got 2

报错内容：

strip expected at most 1 arguments, got 2

翻译：俺只能要一个（你却给了俺俩）。

Ⅱ. 不会变动原字符串：

三种用法均只是返回一个结果，而不能对原字符串进行更改：

>>> a.rstrip('-')
'-----Think'
>>> a
'----Think----'

除非通过将结果重新赋值给原变量的方式，可以将改变的结果直接更改到原字符串上：

>>> a = '-----Think-----'
>>> a = a.strip('-')
>>> a
'Think'

7.4.5 按标志分割组成列表

如果某个字符串内有某种符号组成有规律的分隔，我们可以用 变量名.split(‘分割标志’) 的用法，以这种符号作为标志，将几个部分拆分成列表的几个元素进行输出：

>>> b = '1-2-3-4-5-6-7-8-9'
>>> b.split('-')
['1', '2', '3', '4', '5', '6', '7', '8', '9']

观察上面的例题可以发现，将原字符串按照 '-' 这个标志分割成了 9 个部分，它们又重新以元素的身份组成了一个列表。

我们还可以对分隔的次数进行设置，用法为 变量名.split(‘分割标志’,分割次数-1) ：

>>> b = '1-2-3-4-5-6-7-8-9'
>>> b.split('-',5)
['1', '2', '3', '4', '5', '6-7-8-9']

要注意的是分割次数是 -1 次，比如我想分割成 3 部分，那应该写作 变量名.split(‘分割标志’,2) 。

按行分隔的用法： splitlines

刚才我们介绍了指定某种字符为标志进行分隔的方法，我们在爬网页时经常需要以行为标志进行分隔，行的分隔标志一般为： r 、 rn 、 n ，在Python中已经有一种内置的方法可以直接以上述三种字符为标志的分隔用法，即 变量名.splitlines() ：

>>> 'ab cnnde fgrklrn'.splitlines()
['ab c', '', 'de fg', 'kl']

我们观察上面例题发现，内容中包含这三类符号的地方皆当作了分隔的标志，从而将原字符串分割成了四部分。

本文至此结束，谢谢您花时间阅读。

预告：运算符与转义符部分内容过多，将在在第八篇和第九篇单独讲述，以下为大纲：

8.1 运算符

8.1.1 普通运算符

+链接、*重复输出、[]截取、[m:n]截取部分左闭右开

8.1.2 %格式化

c字符鱼ASCII码、s字符串、 d整数、u无符号整型、o八进制、x十六进制、X大写十六进制、f浮点型、e/E科学计数法格式浮点、g/G为f/e/E的简写、p十六进制数格式化变量的地址

8.1.3 格式化辅助指令

-左对齐、*定义宽度或小数点精度、+正数前显示加号、正数前显示空格、#八进制前显示0，十六进制前显示0x/0X、0显示的数字前填充0、%%输出一个单一的%、(var)映射变量、m.n最小显示m宽度，共n位小数

9.转义符

行尾续行、反斜杠、'单引号、"双引号、a响铃、b退格、e转义、000空、n换行、v纵向制表符、t横向制表符、r回车、f换页、o八进制数换行、x十六进制换行、other其它的字符以普通格式输出