一个有序的字符的集合，用来存储和表现基于文本的信息，要求使用单引号或双引号括起来（即两边的引号能够配对）。

在 Python3 中有三种字符串的类型：
1.str，用于 Unicode 文本（ASCII或其它）；
2.bytes，用于二进制数据，包含编码的文本；
3.bytearray，bytes的一种可变的变体。

字符串是一个有序的字符的集合，即有索引。

原始字符串
所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串在字符串的第一个引号前加上字母 r（不区分大小写），与普通字符串有着几乎完全相同的语法。Unicode 字符串与 r 连用必需在 r 前面。

>>> str0 = 'Hello Python\t!'
>>> print(str0)
Hello Python    !
>>> str1 = r'Hello Python\t!'  # 直接打印输出，\t 无效。
>>> print(str1)
Hello Python\t!

转义字符，即（  ）反斜杠

字符串格式化
用 % 对字符串进行格式化输出。

>>> print('我叫%s，今年%d岁。'%('小明', 18))
我叫小明，今年18岁。

访问字符串中的字符
通过字符串的索引访问其中的字符，遵循顾首不顾尾的原则。

• 正序索引访问，格式：[开始索引:结束索引:步长]

>>> str0 = 'Hello Python!'
>>> str0[0]  # 第一个字符
'H'
>>> str0[-1]  # 最后一个字符
'!'
>>> str0[1:5]  # 切片
'ello'
>>> str0[:]  # 不加索引默认取全部字符
'Hello Python!'
>>> str0[::3]  # 步长
'HlPh!'

• 倒序索引访问，格式：[开始索引:结束索引:步长]

>>> str0 = 'Hello Python!'
>>> str0[::-1]  # 必须加 -1 ，字符串反转的一种方法。
'!nohtyP olleH'

字符串的内置方法

capitalize() 方法
在字符串中，如果第一个字符是字母则把第一个字母转成大写，其它字母转小写，如果第一个字符不是字母则把所有字母转成小写。

>>> str0 = ’hello PYTHON!‘
>>> str0.capitalize()
'Hello python!'
>>> str1 = ' hello PYTHON!'
>>> str1.capitalize()
' hello python!'

center(width, fillchar=' ') 方法
以指定的宽度居中字符串，如果指定宽度小于字符串宽度直接返回字符串，否则使用 fillchar 去填充，默认为空格。
参数：
width，字符串的总宽度。
fillchar，填充的字符，默认为空格。

>>> str0 = 'Hello Python!'
>>> str0.center(10, '*')  # 指定宽度小于字符串宽度直接返回字符串
'Hello Python!'
>>> str0.center(20, '*')
'***Hello Python!****'

ljust(width, fillchar=' ') 方法
以指定的宽度左对齐字符串，如果指定宽度小于字符串宽度直接返回字符串，否则使用 fillchar 去填充，默认为空格。
参数：
width，字符串的总宽度。
fillchar，填充的字符，默认为空格。

>>> str0 = 'Hello Python!'
>>> str0.ljust(10, '*')
'Hello Python!'
>>> str0.ljust(20, '*')
'Hello Python!*******'

rjust(width, fillchar=' ') 方法
以指定的宽度右对齐字符串，如果指定宽度小于字符串宽度直接返回字符串，否则使用 fillchar 去填充，默认为空格。
参数：
width，字符串的总宽度。
fillchar，填充的字符，默认为空格。

>>> str0.rjust(10, '*')
'Hello Python!'
>>> str0.rjust(20, '*')
'*******Hello Python!'

find(sub[, start[, end]]) 方法
从字符串的左边匹配指定的字符并返回其索引，否则返回 -1。如果有多个相同的字符只匹配第一个，其它的字符不在查找。
参数：
start：开始索引，默认是 0；
end：结束索引。

>>> str0 = 'Hello Python!'
>>> str0.find('o')  # 只查找匹配到的第一个字符
4
>>> str0.find('o', 8, 11)  # 指定索引范围
10
>>> str0.find('lo')  # 把 lo 当作一个整体，返回字符 l 的索引。
3
>>> str0.find('d')  # 未找到返回 -1
-1

rfind(sub[, start[, end]]) 方法
从字符串的右边匹配指定的字符并返回其索引，否则返回 -1。

index(sub[, start[, end]]) 方法
从字符串的左边匹配指定的字符并返回其索引，否则报错 ValueError。如果有多个相同的字符只匹配第一个，其它的字符不在查找。
参数：
start：开始索引，默认是 0；
end：结束索引。

>>> str0 = 'Hello Python!'
>>> str0.index('o')
4
>>> str0.index('o', 8, 11)
10
>>> str0.index('lo')
3
>>> str0.index('d')
Traceback (most recent call last):
  File "<pyshell#14>", line 1, in <module>
    str0.index('d')
ValueError: substring not found

rindex(sub[, start[, end]]) 方法
从字符串的右边匹配指定的字符并返回其索引，否则报错 ValueError。

format() 方法
格式化字符串，可以接收多个参数并且不要求位置顺序。

>>> '{} {} {}'.format('Hello', 'Python', '!')
'Hello Python !'
>>> '{0} {1} {2}'.format('Hello', 'Python', '!')
'Hello Python !'
>>> '我叫{name}，{age}岁。'.format(name='小明', age=18)
'我叫小明，18岁。'

isalnum() 方法
检测字符串是否由字母和数字组成，返回 bool 值。

>>> str0 = 'Hello Python!'
>>> str0.isalnum()
False
>>> str1 = 'HelloPython2019'
>>> str1.isalnum()
True

isalpha() 方法
检测字符串是否只由字母组成，返回 bool 值。

>>> str0 = 'HelloPython'
>>> str0.isalpha()
True
>>> str1 = 'Hello Python!'
>>> str1.isalpha()
False

isdigit() 方法
检测字符串是否只由数字组成，返回 bool 值。

>>> str0 = '123456'
>>> str0.isdigit()
True
>>> str1 = 'Hello Python!'
>>> str1.isdigit()
False

isnumeric() 方法
检测字符串是否只由数字组成，这种方法是只适用于 Unicode 对象，在 Python3 中所有的字符串都是 Unicode 字符串。

>>> str0 = '123'
>>> str0.isnumeric()
True
>>> str1 = u'456'
>>> str1.isnumeric()
True
>>> str2 = 'Hello Python!'
>>> str2.isnumeric()
False

isdecimal() 方法
检查字符串是否只包含十进制字符，这种方法是只适用于 Unicode 对象。
注意：定义一个十进制字符串，只需要在字符串前添加 'u' 前缀即可。

>>> str0 = u'123'
>>> str0.isdecimal()
True
>>> str1 = 'Hello Python!'
>>> str1.isdecimal()
False

isidentifier() 方法
检测变量名、函数名、类名等标识符是否正确，返回 bool 。

>>> 'name'.isidentifier()
True
>>> '1name'.isidentifier()
False

isspace() 方法
检测字符串是否只由空白字符组成，返回 bool 。

>>> str0 = '    '
>>> str0.isspace()
True
>>> str1 = 'Hello Python!'
>>> str1.isspace()
False

strip() 方法
删除字符串左边和右边的指定字符，默认是空格，不能删除中间部分的字符。

>>> str0 = ' Hello Python!'
>>> str0.strip()  # 默认删除空格
'Hello Python!'
>>> str1 = '*Hello Python!*'
>>> str1.strip('*')  # 删除指定字符
'Hello Python!'

lstrip() 方法
删除字符串左边的指定字符，默认是空格，不能删除中间部分的字符。
rstrip() 方法
删除字符串右边的指定字符，默认是空格，不能删除中间部分的字符。

startswith(prefix[, start[, end]]) 方法
检查字符串是否以指定字符开头，返回 bool 值。

>>> str0 = 'Hello Python!'
>>> str0.startswith('H')
True
>>> str0.startswith('He', 0, 3)  # 切片
True

endswith(suffix[, start[, end]]) 方法
检查字符串是否以指定字符结尾，返回 bool 值。

encode() 方法
以指定的编码格式编码字符串，返回编码后的字符串，它是一个 bytes 对象。
参数：
encoding，编码，默认为 utf-8 。
errors，不同错误的处理方案，默认为 strict ，意为编码错误引起一个UnicodeError。 其它可能得值有 'ignore', 'replace', 'xmlcharrefreplace' 以及通过 codecs.register_error() 注册的任何值。

>>> str0 = '我是中国人'
>>> str0.encode(encoding='utf-8', errors='strict')  # utf-8 编码
b'\xe6\x88\x91\xe6\x98\xaf\xe4\xb8\xad\xe5\x9b\xbd\xe4\xba\xba'
>>> str0.encode(encoding='gbk', errors='strict')  # gbk 编码
b'\xce\xd2\xca\xc7\xd6\xd0\xb9\xfa\xc8\xcb'

decode() 方法
以指定的编码格式解码 bytes 对象，默认编码为 utf-8 。
参数：
encoding，编码，默认为 utf-8 。
errors，不同错误的处理方案，默认为 strict ，意为编码错误引起一个UnicodeError。 其它可能得值有 'ignore', 'replace', 'xmlcharrefreplace' 以及通过 codecs.register_error() 注册的任何值。

>>> str0 = '我是中国人'
>>> str_utf8 = str0.encode(encoding='utf-8', errors='strict')
>>> str_utf8
b'\xe6\x88\x91\xe6\x98\xaf\xe4\xb8\xad\xe5\x9b\xbd\xe4\xba\xba'
>>> str_utf8.decode(encoding='utf-8', errors='strict')
'我是中国人'

count(sub[, start[, end]]) 方法
统计字符串里某个字符出现的次数。

>>> str0 = 'Hello Python!'
>>> str0.count('o')
2
>>> str0.count('l', 1, 3)
1

lower() 方法
把字符串中的所有大写字母字符转小写。

>>> str0 = 'Hello PYTHON!'
>>> str0.lower()
'hello python!'

islower() 方法
检测字符串是否由小写字母组成，返回 bool 值。

>>> str0 = 'hellopython'
>>> str0.islower()
True
>>> str1 = 'Hello Python!'
>>> str1.islower()
False

title() 方法
把字符串中的每个单词的首字母小写转为大写。

>>> str0 = 'hello python!'
>>> str0.title()
'Hello Python!'

istitle() 方法
检测字符串中的每个单词的首字母是否为大写，且其它字母为小写，返回 bool 值。

>>> str0 = 'Hello Python!'
>>> str0.istitle()
True
>>> str1 = 'Hello python!'
>>> str1.istitle()
False

upper() 方法
把字符串中的所有小写字母字符转大写。

>>> str0 = 'Hello Python!'
>>> str0.upper()
'HELLO PYTHON!'

isupper() 方法
检测字符串是否由大写字母组成，返回 bool 值。

>>> str0 = 'HELLO PYTHON!'
>>> str0.isupper()
True
>>> str1 = 'Hello Python!'
>>> str1.isupper()
False

replace(old, new, count=-1) 方法
把字符中的指定字符替换成新的字符。
count，替换的次数，默认值 -1 ，全部替换。

>>> str0 = 'Hello Python!'
>>> str0.replace('!', '.')
'Hello Python.'
>>> str1 = 'aaabc'
>>> str1.replace('a', 'A', 2)  # 只替换 2 次
'AAabc'

translate() 方法
根据参数 table 给出的表（包含 256 个字符）转换字符串的字符，要过滤掉的字符放到 deletechars 参数中。

语法：

str.translate(table)
bytes.translate(table, delete=b'')
bytearray.translate(table, delete=b'')

参数：
table，翻译表，翻译表是通过 maketrans() 方法转换而来。
deletechars， 字符串中要过滤的字符列表。

maketrans() 方法
用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串表示需要转换的字符，第二个参数也是字符串表示转换的目标。两个字符串的长度必须相同。
注：Python3.4 已经没有 string.maketrans() 了，取而代之的是内建函数: bytearray.maketrans()、bytes.maketrans()、str.maketrans() 。

语法：

str.maketrans( in_table, out_table)

参数：
in_table，需要替换的字符串。
out_table，与 in_table 映射后的字符串。

>>> str0 = 'Hello Python!'
>>> in_table = 'eloptn'
>>> out_table = '123456'
>>> translate_table = str0.maketrans(in_table, out_table)
>>> str0.translate(translate_table)
'H1223 Py5h36!'

join() 方法
将序列中的元素以指定的字符连接生成一个新的字符串，重要用法即列表转字符串。

>>> list0 = ['P', 'y', 't', 'h', 'o', 'n']
>>> str0 = ''.join(list0)
>>> str0
'Python'
>>> list1 = ['P', 'y', 't', 'h', 'o', 'n']
>>> str1 = '-'.join(list1)  # 指定字符连接
>>> str1
'P-y-t-h-o-n'

split(sep=None, maxsplit=-1) 方法
通过指定分隔符对字符串进行切片，重要用法即 字符串转列表，分隔符不出现在结果中。
参数：
sep=None：分隔符，默认为所有的空字符，包括空格、\n、\t 等。
maxsplit=-1：分割的次数，-1，无限制

>>> str0 = 'Hello Python!'
>>> str0.split()  # 以空格为分隔符
['Hello', 'Python!']
>>> str0.split('o')  # 以字符 o 为分隔符
['Hell', ' Pyth', 'n!']  # 分隔符 o 不在列表中
>>> str0.split('o', 1)  # 以字符 o 为分隔符，分割 1 次。
['Hell', ' Python!']

swapcase() 方法
把字符串的字母进行大小写转换。

>>> str0 = 'hELLO pYTHON'
>>> str0.swapcase()
'Hello Python'

字符串的内置函数
len() 函数
返回字符串中字符的个数。

>>> str0 = 'Hello Python!'
>>> len(str0)
13

max() 函数
根据 ASCII 返回字符串中最大的字符。

>>> str0 = 'Hello Python!'
>>> max(str0)
'y'

min() 函数
根据 ASCII 返回字符串中最小的字符。

>>> str0 = 'Hello Python!'
>>> min(str0)
' '