About
在之前的学习中，我们已经学习了Python中的基础数据类型：int、float、bool、complex，这一章呢，我们来学习新的数据类型。
首先要了解两个概念。
什么是序列？
所谓序列，指的是一块可存放多个值的连续内存空间，这些值按一定顺序排列，可通过每个值所在位置的编号（称为索引）访问它们。
为了更形象的认识序列，可以将它看做是一家旅店，那么店中的每个房间就如同序列存储数据的一个个内存空间，每个房间所特有的房间号就相当于索引值。也就是说，通过房间号（索引）我们可以找到这家旅店（序列）中的每个房间（内存空间）。
在 Python 中，序列类型包括字符串、列表、元组、集合和字典，这些序列支持通过索引取值、切片、相加、相乘等通用通用的操作。但比较特殊的是，集合和字典不支持索引、切片、相加和相乘操作。
字符串也是一种常见的序列，它也可以直接通过索引访问字符串内的字符。
Python为序列中的每个元素分配一个序号，即元素的位置，也叫做索引，序列中的第一个元素索引为0，第二个索引为1，依此类推。
注意：Python中序列编号机制是从0开始的，其他大部分的语言都是如此设计。另外，这里的序列如无特指，一律为有序序列。
字符串可以说是Python中最受欢迎的数据类型了。字符串在表示方面也更为灵活多变。
字符串的创建
Python语言用引号来创建（界定）字符串。一般的通过引号（单引号，双引号），三引号（单、双三引号）都可以标识字符串，英文用str函数表示。
s1 = \'我是单引号表示的字符串\'
s2 = "我是双引号表示的字符串"
s3 = \'\'\'我是3个单引号表示的字符串\'\'\'
s4 = """我是3个双引号表示的字符串"""
print(s1, type(s1)) # 我是单引号表示的字符串 <class \'str\'>
print(s2, type(s2)) # 我是双引号表示的字符串 <class \'str\'>
print(s3, type(s3)) # 我是3个单引号表示的字符串 <class \'str\'>
print(s4, type(s4)) # 我是3个双引号表示的字符串 <class \'str\'>
通常，我们使用引号（单、双都行）来创建字符串。也是程序中最常用的形式，三引号（单、双都行）允许字符跨越多行，并在输出时保持原来的格式，字符串中可以包含换行符、制表符、及其他特殊字符。主要用于一些特殊格式，如文档型的字符串，也用来对代码进行注释。但需要注意的是，只要不是三引号，就只能在一行内表示(你肯定会说那我加个换行符不就行了么！好吧，你成功的骗了自己，但Python解释器显然不这么认为)。
转义字符反斜杠
一般的，Python中用单引号还是双引号并没有区别，但有些情况单双引号的结合使用更方便，比如我们会碰到如下的情况。
\'I\'m oldboy\'
Python解释器在读取字符串的时候，碰到第二个单引号就已经解释成了字符串，但又无法解释后面的字符串而报错，你可能会说，用双引号来创建字符串。
"I\'m oldboy"
没错，能解决，但是碰到下面这样的情况呢？
\'"I\'m oldboy" he said\'
这时候就要用字符串之转义字符反斜杠。
s5 = \'"I\\'m oldboy",he said\'
print(s5) # "I\'m oldboy",he said
因为上面的单引号被当做界定符，所以字符串内部的单引号要用字符\来转变意义为普通字符，才能被解释器正常解释执行。下面的\ 和\一样，被当成普通的字符了。
s6 = "\"I\'am oldboy\", he said"
print(s6) # "I\'am oldboy", he said
原生（始）字符串
有时候，我们会打印一些特殊的字符串，而不希望反斜杠被当成特殊字符如打印一个路径。
print(\'C:\\nowhere\') # C:\nowhere
但结果已经不是我们想要的样子了，这时，你可能说，加俩反斜杠啊！真聪明，这么快就想到了，没错，是解决了这个问题。
print (\'C:\\\\nowhere\') # C:\\nowhere
但如果碰到比较长的路径呢？这样写是不是很头疼？
print(\'C:\\\\Users\\\\Anthony\\\\AppData\\\\Roaming\\\\Microsoft\\\\Windows\\\\Start Menu\\\\Programs\') # C:\\Users\\Anthony\\AppData\\Roaming\\Microsoft\\Windows\\Start Menu\\Programs
这里还有一种方法，使用原生字符串(或称原始字符串)来解决这个问题，在字符串前加一个r，原生字符串不会将反斜杠视为特殊字符，原生字符串中的每个字符都会原封不动的输出。
print(r\'C:\\nowhere\') # C:\\nowhere
print(r\'C:\\Users\\Anthony\\AppData\\Roaming\\Microsoft\\Windows\\Start Menu\\Programs\') # C:\\Users\\Anthony\\AppData\\Roaming\\Microsoft\\Windows\\Start Menu\\Programs
字符串基本操作
首先来知道一个名词，元素，我们称字符串内（\'abc\'）的每个值（\'a\'）为该字符的元素，后续讲列表或者元组中也是这么个意思。
按索引取值
本章开头提到数据类型的概念时说字符串是序列类型。那么也就是说字符串内每个字符（元素）都有自己的索引序号，所以我们可以通过其索引序号来确定字符串中字符的位置，并且访问该位置上的字符。
<字符串>[数值表达式]
尖角号为字符串，后面的中括号内的数值表达式就是索引位置。
print(\'abc\'[0]) # a
索引位置返回的结果就是该索引位置上的字符。正如上例所示，我们获取字符串abc中索引为0的字符，通过打印结果来看，成功拿到索引为0的字符a。
再来看一个示例：
s1 = \'https://www.cnblogs.com/Neeo/\'
print(s1[0]) # 取索引位置为0的字符 h
print(s1[3]) # 取索引位置为3的字符 p
print(s1[-1]) # 取索引位置最后一个字符 /
上例中，我们取最后一个字符选择的索引序号是-1，那这是什么意思呢？在Python中，字符串（或别的有序数据类型）的索引序号，可以通过左右两个方向来获取：
- 从左到右的顺序，从0开始计算,如
0、1、2...... - 从右到左的顺序，从
-1开始计算,如-1、-2、-3......
上图展示了字符串的索引顺序，由左到右索引从0开始，由右到左索引从-1开始。
切（分）片
字符串（包含其他数据类型）除了能按照索引取值之外，我们还可以截取字符串中指定范围内的字符，比如从字符串abcd中截取bc，这种操作称为切（分）片。
有意思的是，切片在国外的一些Python书籍译本中，叫分片，而我大天朝一般亲切的称为切片，所以在别处看到分片字样其实就是指切片。
str[start_index:end_index:step]
s2 = \'abcd\'
print(s2[1:3]) # bc
print(s2[1:3:1]) # bc
start_index表示索引（从左到右的顺序）开始的位置。end_index表示索引结束的位置。step表示取值的步长，默认为1（所以，我们可以省略不写），切记，步长的值不能为0。步长也就是说，从哪到哪，每隔几个取一个，由上图可以看出，切片[1:3]取的是索引1,2对应的字符，但我们的end_index写的是3，是因为，索引1~2取一个值b，索引2~3取一个值c，步长为1则是这两个值都取。
来做个练习：
>>> str1 = \'http://www.oldboyedu.com/\'
>>> str1[-3] # 取倒数第三个字符
\'o\'
>>> str1[:6] # 取前六个字符
\'http:/\'
>>> str1[5:] # 从第六个字符开始取到末尾
\'//www.oldboyedu.com/\'
>>> str1[6:9] # 从两者之间的字符
\'/ww\'
>>> str1[2:9:2] # 两者之间，每2个字符取一个
\'t:/w\'
>>> str1[::4] # 所有字符中每4个取一个
\'h:wly./\'
>>> str1[::-1] # 反转字符串，通过负数的步进，实现反转
\'/moc.udeyobdlo.www//:ptth\'
再来看切片中的表达式：
>>> str1 = \'http://www.oldboyedu.com/\'
>>> str1[3 + 2]
\'/\'
>>> str1[2 * 4]
\'w\'
利用切片复制字符串：
>>> str1 = \'http://www.oldboyedu.com/\'
>>> str2 = str1[:]
>>> str2
\'http://www.oldboyedu.com/\'
>>> id(str1), id(str2)
(9240264, 9240264)
id()为Python中的内置函数，用来获取变量在内存中的内存地址。 另外，Python中的字符串具有不可变特性，也就是创建后不能在原基础上改变它，如无法执行如下操作：
>>> str1 = \'http://www.oldboyedu.com/\'
>>> str1[2] = \'x\'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: \'str\' object does not support item assignmen
上例，我们试图修改字符串中索引为2的字符，而结果告诉我们，不能修改。 但在开发中，我们要对这个字符串做类似的操作，那么我们可以通过合并、切片等操作创建一个新的字符串来实现，如有必要再将结果重新赋给原来的变量。
>>> str1 = \'oldboy\'
>>> "I\'m" + str1
"I\'moldboy"
>>> "I\'m " + str1
"I\'m oldboy"
>>> str1 = "I\'m " + "O" + str1[1:]
>>> str1
"I\'m Oldboy"
字符串的拼接（合并） +
字符串的合并操作，也叫字符串的拼接，此操作应用十分广泛，比如刚才在上面的例子中已经用到了：
>>> \'100\' + \'-\' + \'1800\' + \'-\' + \'18000\'
\'100-1800-18000\'
由多个字符串拼接成一个新的字符串。
字符串的复制*
>>> name = \'oldboy\'
>>> name * 5
\'oldboyoldboyoldboyoldboyoldboy\'
相当于将元字符复制5份，组成新的字符串。
字符串成员测试：in，not in
>>> \'o\' in \'oldboy\'
True
>>> \'ol\' in \'oldboy\'
True
>>> \'od\' in \'oldboy\'
False
>>> \'od\' not in \'oldboy\'
True
字符串的成员资格测试，就是判断指定字符在不在字符串中。
字符串格式化运算符： %系列
字符串的格式化输出。格式化输出就是按照某种固定的格式进行字符串输出，这个字符串称为模板字符串，我们在模板里用格式定义符%占住一个空位，然后我们把运算得出的数据再放到这个空位里，字符串格式化运算符%的基本用法如下：
<模板字符串> % (<数据1>， …，数据n>)
%s这个字符串格式化运算符就是说我要往字符串中放入的数据是字符串类型的值，这也是最常用的用法，但仅凭%s不足以包打天下，所以，这一节我们在学习几个其他常用的与%搭配的其他的字符，以实现不同的功能，比如商店消费的小票上，或者银行等涉及到金钱的输出都有固定格式，比如我们怎么用格式化输出￥1.50呢？你可能会说，简单，这样干：
>>> "金额：￥%s 元" % 1.50
\'金额：￥1.5 元\'
最后一位没显示出来，很明显，%s在这种情况下并不好使，所以我们面对类似的情况就要用别的格式化运算符了——浮点型%f。
>>> "金额：￥%.2f 元" % 1.50
\'金额：￥1.50 元\'
格式定义符还可以通过如下方式对格式字符进行进一步的控制：
<模板字符> %[flags][width].[precision]<模板字符> % (数据1, … 数据n)
上例各参数说明如下：
- 模板字符就是普通的字符串。
- flags可以是
+、-或0，+表示右对齐（默认右对齐，加号不写，写上会显示出来），-表示左对齐，0表示填充字符为0 - width表示显示宽度（比如说，显示宽度为10，表示十个字符宽度，如果字符不够十个，就默认填充空格）。
- precision表示小数的位数。
print("金额：￥%+9.2f 元" % 1.50000) # 金额：￥ +1.50 元
print("金额：￥%-9.2f 元" % 1.50000) # 金额：￥1.50 元
print("金额：￥%09.2f 元" % 1.50000) # 金额：￥000001.50 元
上例中：
-
%+9.2f表示格式化字符右对齐（一般加号可以省略不写，写上的话，会当成格式化字符填充进去）、宽度是9，小数位保留2位，需要填充的是浮点型的数据。 -
%-9.2f表示格式化字符左对齐，宽度是9，小数位保留2位，需要填充的是浮点型的数据。 -
%09.2f表示格式化字符填充0，宽度是9，需要填充的是浮点型的数据。
要注意的是，如果使用的是浮点型的格式定义符，那么数据也必须是浮点型数据或int类型。
>>> "金额：￥%f 元" % 4
\'金额：￥4.000000 元\'
>>> "金额：￥%.2f 元" % 4
\'金额：￥4.00 元\'
>>> "金额：￥%.2f 元" % \'str\'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: a float is required
这同样适用于其他的格式定义符，比如说如果是你用int类型的格式定义符“%d”,而你的数据是str类型，那就会报错。
>>> "金额：￥%d 元" % \'1\'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: %d format: a number is required, not str
>>> "金额：￥%d 元" % 1
\'金额：￥1 元\'
除了%s和%f，还有其他的格式化符号（不完全）：
| 格式化符号 | 描述 | 重要程度 |
|---|---|---|
| %s | 将需要格式的数据以字符串的形式格式化进去，使用频率最高 | ***** |
| %f | 格式化字符为浮点类型的实数 | **** |
| %F | 浮点实数 | ** |
| %c | 单个字符 | ** |
| %d | 十进制整数 | ** |
| %g | 指数（e）或浮点数 | ** |
| %G | 指数（E）或浮点数 | ** |
| %e | 指数（小写字母‘e’） | ** |
| %E | 指数（大写字母‘E’） | ** |
来看示例：
>>> print(\'%c\'%\'a\')
a
>>> print(\'%c\'%111)
o
>>> print(\'%d\'%11)
11
>>> print(\'%f\'%.6)
0.600000
>>> print(\'%F\'%.6)
0.600000
>>> print(\'%g\'%.6)
0.6
>>> print(\'%G\'%.6)
0.6
字符串的常用方法
Python为字符串提供了很多方法，也有很多的内置函数和声明可以应用于字符串，比如说使用len(str)方法获取字符串的长度。这里我们仅介绍最常用的字符串方法。
str.strip(obj)
去除字符串两边的指定字符，默认去除字符串两边的空格或者换行符，没有指定字符则略过。返回去除指定字符后的新字符串。
s2 = \'****oldb***oy*******\'
print(s2.strip()) # ****oldb***oy*******
print(s2.strip(\'*\')) # oldb***oy
那问题来了，如上例所示，strip方法只能去除字符串两边的指定字符，那我想把中间的星号去掉怎么办？
s2 = \'****oldb***oy*******\'
print(s2.replace(\'*\', \'\')) # oldboy
问题解决，但是replace是什么？
str.replace(old, new, [max])
将字符串中指定字符替换成新的字符，替换次数最多不超过max次。返回替换后的新的字符串。
s1 = "\'python是最美的语言\', python said"
new_str = s1.replace(\'p\', \'P\')
print(new_str) # \'Python是最美的语言\', Python said
print(s1.replace(\'p\', \'P\', 1)) # \'Python是最美的语言\', python said
str.split(obj=\'\', num) & str.rsplit(obj=\'\', num)
以指定的字符分割字符串，可以指定分割次数，默认是全部分割，并以列表的形式返回。
s3 = "hello python"
print(s3.split(\'o\')) # [\'hell\', \' pyth\', \'n\']
print(s3.split(\'o\', 1)) # [\'hell\', \' python\']
分割字符串也就是说遇到指定的分割字符就以指定字符把字符串分两半！通过返回结果可以看到，这种分割顺序是从左到右开始的。对应的，我们也可以从右到左分割，我们可以用str.rsplit(obj=\'\', num)完成：
s4 = "hello python"
print(s4.rsplit(\'o\')) # [\'hell\', \' pyth\', \'n\']
print(s4.rsplit(\'o\', 1)) # [\'hello pyth\', \'n\']
一般的，除了分割，包括替换在内的顺序都是从左到右地顺序，这是默认的。
str.join(sequence)
返回以指定字符将sequence连接后的新字符串。
s5 = \'abc\'
new_str = \'-\'.join(s5)
print(new_str) # a-b-c
需要注意的是，sequence中的元素必须是字符串类型，否则报错。
s6 = [\'1\', \'2\', \'3\']
s7 = [1, 2, 3]
print(\'-\'.join(s6)) # 1-2-3
print(\'-\'.join(s7)) # TypeError: sequence item 0: expected str instance, int found
上例中，s6和s7同为列表，但其内的元素类型不同，可以看到，如果其中的对象是int类型，就会报错。
str.upper() & str.lower()
返回字符串中英文字母大写形式的新字符串，非英文字母、本身就是大写形式的英文字母略过。
s8 = \'张开说Python就像1+1等于2那么简单\'
print(s8.upper()) # 张开说PYTHON就像1+1等于2那么简单
与之对应的是就是返回字符串中英文字母小写形式的新字符串，非英文字母、本身就是小写形式的英文字母略过。
s9 = \'张开说Python就像1+1等于2那么简单\'
print(s9.lower()) # 张开说python就像1+1等于2那么简单
这两个方法用处很多，比如我们在登录验证码的判断这里就可以用到，因为验证码是随机的，并且含有大小写和特殊字符的一串字符串，那么怎么判断呢，其中就可以通过upper()和lower()这两个方法来判断。
verification_code = \'12n%C\'
result = input(\'输入验证码: \')
if verification_code.upper() == result.upper(): # 也可以将验证码都以小写形式来判断
print(\'验证码正确\')
else:
print(\'验证码输入错误\')
str.index(obj) & str.find(obj)
返回字符串中指定字符的索引位置，顺序是从左到右的顺序，找到就返回。
s1 = \'abcd\'
print(s1.find(\'a\')) # 0
print(s1.find(\'w\')) # -1
s2 = \'abcd\'
print(s2.index(\'a\')) # 0
print(s2.index(\'w\')) # ValueError: substring not found
找到就返回这没错，但需要我们注意的是，如果字符串中不存在指定的字符，两个方法的返回结果也是不一样的，如果字符串没有指定字符，str.find返回-1，而str.index则报错。
str.startswith(obj) & str.endswith(obj)
判断字符串是否已指定字符开头或者结尾，并以布尔值的形式返回。
s1 = \'abcd\'
print(s1.startswith(\'a\')) # True
print(s1.startswith(\'ab\')) # True
print(s1.startswith(\'acb\')) # False
s2 = \'abcd\'
print(s2.endswith(\'d\')) # True
print(s2.endswith(\'cd\')) # True
print(s2.endswith(\'cbd\')) # False
通过结果可以看到，指定字符如果是多个，必须是连续的。
str.count(obj, start=0, end=len(str))
返回字符串中，指定索引范围内的指定元素出现的次数，如果指定字符不在字符串中，则返回0。开始位置默认为0，结束位置为字符串结束的位置。
s = \'https://www.cnblogs.com/Neeo/\'
print(s.count(\'w\')) # 3
print(s.count(\'w\', 1, 10)) # 2
print(s.count(\'1\')) # 0
str.center( width， filler)
返回一个指定宽度的字符串，如果width的宽度小于字符串本身的宽度，就直接返回该字符串，否则字符串两边填充filler字符，filler默认是空格，且filler必须是单个字符，否则报错。
s = \'开车，嘟嘟嘟\'
print(s.center(10)) # 开车，嘟嘟嘟
print(s.center(5, \'*\')) # 开车，嘟嘟嘟
print(s.center(10, \'*\')) # **开车，嘟嘟嘟**
print(s.center(20, \'*\')) # *******开车，嘟嘟嘟*******
print(s.center(20, \'*%\')) # filler如果是多个字符，报错：TypeError: The fill character must be exactly one character long
str.format()
自Python 2.6版本开始，就增加了format函数，它增强了字符串格式化的功能，基本语法是通过“{}”和“:”来代替“%”。format函数可以接受不限个数的参数，位置也可不按顺序。下面通过示例来学习 一下format函数的用法：
- 按照默认顺序传参：
print(\'{} {}\'.format(\'hello\', \'Anthony\')) # hello Anthony
默认的，format将“hello”填充到第一个花括号内，将“oldboy”填充到第二个花括号内。相当于平行赋值。
- 按照指定位置传递参数：
print(\'{0} {1}\'.format(\'hello\', \'Anthony\')) # hello Anthony
print(\'{0} {0}\'.format(\'hello\', \'Anthony\')) # hello hello
print(\'{1} {0}\'.format(\'hello\', \'Anthony\')) # Anthony hello
print(\'{1} {1}\'.format(\'hello\', \'Anthony\')) # Anthony Anthony
上例中，我们可以这样理解，format内两个参数都有自己的位置序号。然后根据序号填充字符串。
- 设置参数：
s = \'name: {name} | url:{url}\'
print(s.format(name=\'Anthony\', url=\'https://www.cnblogs.com/Neeo/\')) # name: Anthony | url:https://www.cnblogs.com/Neeo/
上例中，我们为format中的参数起个别名，然后字符串根据别名填充对应的内容。
- 通过列表索引设置参数
user_list = [\'Anthony\', \'https://www.cnblogs.com/Neeo/\']
s = \'name: {0[0]} | url:{0[1]}\'.format(user_list)
print(s) # name: Anthony | url:https://www.cnblogs.com/Neeo/
- 通过字典设置参数
user_dict = {\'name\': \'Anthony\', \'url\': \'https://www.cnblogs.com/Neeo/\'}
s = \'name: {name} | url:{url}\'.format(**user_dict)
print(s) # name: Anthony | url:https://www.cnblogs.com/Neeo/
注意：**user_dict表示把整个字典传递进去，这种传递参数的方式称为按关键字传参。
| 格式 | 说明 |
|---|---|
| {:.4f} | 保留四舍五入后的4位小数 |
| {:+.2f} | 带符号保留小数点后2位 |
| {:-.2f} | 带符号保留小数点后2位 |
| {:.0f} | 保留整数位 |
| {:0<3d} | 数字补0,填充在右侧，宽度为3 |
| {:0^3d} | 数字补0,填充在两边，宽度为3 |
| {:0>3d} | 数字补0,填充在左侧，宽度为3 |
| {:r<3d} | 数字补字母“r”，填充在右侧，宽度为3 |
| {:r^3d} | 数字补字母“r”，填充在两侧，宽度为3 |
| {:r>3d} | 数字补字母“r”，填充在左侧，宽度为3 |
| {:.2%} | 指定位数的百分比格式 |
| {:,} | 以逗号分隔数字格式 |
| {:20d} | 默认右对齐，宽度20 |
| {:>20d} | 右对齐，宽度20 |
| {:<20d} | 左对齐，宽度20 |
| {:^20d} | 居中，宽度20 |
看示例：
>>> \'{:.4f}\'.format(3.1415926)
\'3.1416\'
>>> \'{:+.2f}\'.format(1)
\'+1.00\'
>>> \'{:-.2f}\'.format(-1)
\'-1.00\'
>>> \'{:.0f}\'.format(3.1415926)
\'3\'
>>> \'{:r<3d}\'.format(2)
\'2rr\'
\'{:r^3d}\'.format(2)
\'r2r\'
>>> \'{:r>3d}\'.format(2)
\'rr2\'
>>> \'{:0<3d}\'.format(2)
\'200\'
>>> \'{:0^3d}\'.format(2)
\'020\'
>>> \'{:0>3d}\'.format(2)
\'002\'
>>> \'{:,}\'.format(2000000)
\'2,000,000\'
>>> \'{:2%}\'.format(3)
\'300.000000%\'
>>> \'{:.2%}\'.format(3)
\'300.00%\'
>>> \'{:20d}\'.format(2000000)
\' 2000000\'
>>> \'{:>20d}\'.format(2000000)
\' 2000000\'
>>> \'{:<20d}\'.format(2000000)
\'2000000 \'
>>> \'{:^20d}\'.format(2000000)
\' 2000000 \'
注意：“^”、“<”、“>”分别代表居中，左对齐，右对齐，后面跟填充的宽度，不指定则默认用空格填充，另外还有其他的用法。
>>> format(\'居中，后面的20则是指定宽度\', \'^20\')
\' 居中，后面的20则是指定宽度 \'
>>> format(\'右对齐，后面的20则是指定宽度\', \'>20\')
\' 右对齐，后面的20则是指定宽度\'
>>> format(\'左对齐，后面的20则是指定宽度\', \'<20\')
\'左对齐，后面的20则是指定宽度 \'
format的功能还不止于此，它还能传递对象。
>>> class Bar(object):
... def __init__(self, value):
... self.value = value
...
>>> bar = Bar(4)
>>> \'value: {0.value}\'.format(bar)
\'value: 4\'
关于上面的例子中的类，我们后面会详细的讲解，这里只需知道format有能传递对象的功能就行了。
小结，下表为部分字符串的其他的方法：
| 方法 | 描述 | 重要程度 |
|---|---|---|
| str.capitalize | 将字符串的一个字符转换为大写 | ** |
| str.center | 返回指定宽度的居中的字符串 | *** |
| str.count | 返回指定字符在字符串内出现的次数 | **** |
| str.endswith | 检查字符串是否以指定字符结尾 | *** |
| str.startswith | 检查字符串是否在指定字符开始位置 | *** |
| str.find | 判断字符是否在字符串中 | *** |
| str.index | 判断字符是否在字符串中 | ** |
| str.join | 以指定分割符，将seq中所有元素合并为一个新的字符串 | ***** |
| str.lower | 将字符串内的所有大写字符转为小写 | *** |
| str.upper | 将字符串内的所有小写字符转为大写 | *** |
| str.replace | 将字符串内指定的old字符转换为new并返回为新的字符串 | ***** |
| str.split | 以指定字符为分隔符分隔字符串，并返回字符串列表 | ***** |
| str.isdigit | 检测字符串是否由数字组成 | *** |
| bytes.decode | 指定解码方式给bytes对象解码 | ***** |
| str.encode | 指定编码方式给str编码 | ***** |
| str.expandtabs | 转换字符串中的tab符号为空格，tab符号默认的空格数是8 | * |
| str.isalnum | 检测字符串是否有字符和数字组成 | ** |
| str.isalpha | 检测字符串是否只有字母组成 | *** |
| str.islower | 检测字符串是否只有小写字母组成 | *** |
| str.isupper | 检测字符串是否只有小写字母组成 | *** |
| str.isnumeric | 检测字符串是否只包含数字字符 | * |
| str.isspace | 检测字符串是否只有空格组成 | * |
| str.title | 返回字符串中首字母大写其余字母小写形式 | ** |
| str.istitle | 如果字符串是首字母大写其余字母小写形式的则返回 True，否则返回 False | * |
| str.isdecimal | 检查字符串是否只包含十进制字符 | * |
| str.ljust | 返回原字符串的左对齐 | * |
| str.rjust | 返回原字符串的右对齐 | * |
| str.lstrip | 删除字符串开始的指定字符 | ** |
| str.rstrip | 删除字符串末尾的指定字符 | ** |
| str.rfind | 如find()方法，但从右侧开始查找 | * |
| str.rindex | 如index()方法，但从右侧开始查找 | * |
| str.splitlines | 以列表的形式按照换行符返回分割后的字符串 | * |
| str.maketrans | 创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标 | ** |
| str.translate | 根据字符串给出的表转换字符串的字符，要过滤掉的字符放到delete参数中 | *** |
| str.zfill | 返回指定长度的字符串，原字符串右对齐，前面补0 | ***** |
| str.swapcase | 将字符串中的大写字符转换位小写，小写字母转换为大写 | ** |
再来复习一下字符串中常用的操作符：
| 字符串的操作 | 描述 | 重要程度 |
|---|---|---|
| [] | 索引操作 | ***** |
| [:] | 切片操作 | ***** |
| + | 合并(拼接)字符串 | **** |
| * | 复制字符串 | *** |
| in ，not in | 成员测试 | ***** |
我们在之前的学习中，知道了内置函数len(str)，这里再来介绍两个常用内置函数，它们都可以应用于各数据类型中，
- max(str)根据字符串中的字符在ASCII码表中的位置，返回（同类型，比如都是数字类型或者都是字母）字符串中最大的字符。比如a和z在ASCII中对应的分别是97和122，那么max(“az”)返回的是z。
- min(str)同max一致，只是返回的是（同类型，比如都是数字类型或者都是字母）字符串中最小的字符。
s = \'abcd\'
print(max(s)) # d
print(min(s)) # a
print(len(s)) # 4
字符串类型转换
在之前学习逻辑运算符的时候，有个用户验证的示例，你对代码中的123要这样写成“123”肯定会有点迷惑。
username = input(\'please your name:\')
password = input(\'please your password:\')
if username == \'oldboy\' and password == \'111\':
print(\'login successful, welcome：%s\'%username)
else:
print(\'login error\')
因为，input返回的是str类型，而我们认为输入的是整型数，但整型数和字符串类型无法比较。所以不得不写成字符串类型。而我们也渐渐的了解到字符串可以和其他类型转换。
while 1:
user = input(\'用户名: \')
pwd = input(\'密码: \')
if user == \'oldboy\' and int(pwd) == 123:
print(\'login successful\')
break
else:
print(\'login error\')
continue
注意：上面的例子中我们用到了while 1这个操作，之前讲while循环的时候也用过，但为什么要在这提一下呢，因为讲完了bool类型！其实while 1和while True一样，但是，客观的说，while 1要比while True性能好一些，因为计算机“只认识”0和1，while True要进一步的解释为while 1，所以，这里用哪个都可以的，大家不要疑惑。
用int()转换为整形进行判断，这只是其中的一例，我们在实际的开发中难免遇到将字符串转换为如int类型的其他的类型，或者其他类型转换为str类型。为了达到这些目的，先看一个方法。
>>> eval(\'3*2+3\')
9
>>> eval(\'3*2+a\')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<string>", line 1, in <module>
TypeError: unsupported operand type(s) for +: \'int\' and \'str\'
>>> a = 3
>>> eval(\'3*2+a\')
9
eval()方法接收一个字符串，并将该字符串解释成Python的表达式进行求值，得到特定类型的值，如果该字符串无法解释成合法的Python表达式则会报错。
这在特定的一些场合会用到eval()方法，但虽然其功能强大，也具有较大的安全隐患，所以，我们只做简单的介绍，但一般不推荐使用此方法。
一般地，int和float都可以和str类型相互转换，但请注意只有当字符串内为数字的时候才能转换。
>>> int(\'123\')
123
>>> float(\'12.3\')
12.3
>>> str(123)
\'123\'
>>> str([\'a\',1, 2])
"[\'a\', 1, 2]"
最后，善用help
这一章将学习大量的方法，包括接下来要讲的列表、元组、字典，都有相关的方法，你可能会问，那么多的方法，我怎么记得每个数据类型都有哪些方法？每个方法都是怎么用的？甚至到后面你可能会迷糊某个方法有没有参数等一大堆的问题。这里隆重介绍一个函数——help()，help()函数能够查看当前的数据类型的所有相关方法及介绍。
Python 3.5.4 (v3.5.4:3f56838, Aug 8 2017, 02:07:06) [MSC v.1900 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> help(str)
Help on class str in module builtins:
class str(object)
| str(object=\'\') -> str
| str(bytes_or_buffer[, encoding[, errors]]) -> str
|
| Create a new string object from the given object. If encoding or
| errors is specified, then the object must expose a data buffer
| that will be decoded using the given encoding and error handler.
| Otherwise, returns the result of object.__str__() (if defined)
| or repr(object).
| encoding defaults to sys.getdefaultencoding().
| errors defaults to \'strict\'.
|
| Methods defined here:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return key in self.
|
| __eq__(self, value, /)
| Return self==value.
|
| __format__(...)
| S.__format__(format_spec) -> str
|
| Return a formatted version of S as described by format_spec.
-- More --
如上示例，我们通过help(str)函数查看关于str的所有说明文档帮助。除此之外，我们还可以通过help()函数查看某个方法的具体说明。
Python 3.5.4 (v3.5.4:3f56838, Aug 8 2017, 02:07:06) [MSC v.1900 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> help(str.strip)
Help on method_descriptor:
strip(...)
S.strip([chars]) -> str
Return a copy of the string S with leading and trailing
whitespace removed.
If chars is given and not None, remove characters in chars instead.
help()函数不仅能返回字符串的帮助，也可以返回别的数据类型的帮助信息。
提示：无论何时，我们都要想着用用help()，会有意想不到的收获。
欢迎斧正，that\'s all,see also：