part2-2： Python 字符串及相关操作方法，字节串与字符串区别，转义字符和格式化字符使用

Python中的字符串必须使用成对的引号括起来，引号可以是单引号、双引号、三引号。

一、 字符串基础

1、 字符串和转义字符
字符串的内容几乎可以是任何字符，可以是英文字符，也可以是中文字符。字符串是用成对的引号包起来的，当字符串中有引号时，需要做特殊处理：
（1）、使用不同的引号将字符串括起来，例如使用双引号表示字符串时，字符串内部可以有单引号出现。
（2）、对引号进行转义，使用反斜线（\）将字符串中的特殊字符进行转义。

示例：
str1 = "It's a cat"     # 字符串中含有单引号，外面使用双引号括起来
str2 = 'Python is a "programe" language'    # 字符串含有双引号，外面使用单引号
str3 = 'Python\'s a "programe" language'    # 使用反斜线转义字符串中的单引号
str4 = """'Python's a "programe" language"""    # 使用三引号表示字符串时，字符串内可以有单引号、双引号

2、字符串拼接
s1 = 'hello,' "michael"     # 同一行中两个紧挨着的字符串，自动拼接成一个字符串。

Python中真正用于拼接字符串的运算符是加号（+），示例如下：
s2 = 'hello, '
s3 = 'michael'
print(s2 + s3)      # 输出是：hello, michael

还可以使用字符串的 join 方法拼接，例如：
"".join((s2, s3))

3、repr函数和字符串
Python不允许直接拼接字符串和数值，但是可先将数值转换成字符串后再拼接。可使用 str() 或 repr() 函数将数值转换成字符串。

示例：
s1 = "我的年龄是："
age = 25
print(s1 + age)     # 字符串和数值直接拼接，报 TypeError 错误
print(s1 + str(age))    # 使用str 方法将数值转换为字符串后再拼接，输出是：我的年龄是：25
print(s1 + repr(age))   # 使用repr 方法将数值转换为字符串后再拼接，输出是：我的年龄是：25

str 是Python的内置类型，repr() 只是一个函数，repr 的另一个功能是以Python表达式的形式来表示值。例如：
print(s1)               # 输出是：我的年龄是：
print(repr(s1))         # 输出是：'我的年龄是：'

使用 repr() 对字符串进行转换时，输出的结果中字符串在引号内，这就是字符串的 Python 的表达式形式。

在交互式解释器中，输入一个变量或表达式时，Python 会自动用 repr() 函数处理该变量表达式。

4、 使用input 和 raw_input 获取用户输入

input() 函数可用来获取用户输入，在这个函数中可以传递一个参数用于提示信息。input()函数总是将用户输入的内容放入字符串中，因此用户可以输入任何内容。如果输入的纯数值，并希望用于数值运算时，就需要先进行类型转换后再计算。

在Python2.x 版本中的 raw_input() 函数的作用与Python3版本中的input()函数一样。

在Python2版本中的input()函数则要求用户输入的必须是符合 Python 语法的表达式。例如要输入数值：123，要输入字符串：'abc'，这里输入的字符串必须用引号括起来，否则就会报错。

5、 长字符串
长字符串是使用成对的三引号引起来的字符串，长字符串内可以放置任何内容，可以有单引号、双引号、换行符等。长字符串如果没有赋值给任何变量，这个字符串就被解释器忽略，相当于是注释。

转义字符（\）可对换行符进行转义，经过转义后的两行字符串实际是一行。例如：
s2 = 'Linux systems is \
very strong!'
这个s2 字符串输入的是2行，但实际上只是一行字符串。

要对表达式换行，同样可以使用转义字符（\）进行转义，例如：
result = 20 * 10 / 2 + 100 - \
         20 * 5
这个result 变量虽然有两行，但只有一个表达式。

6、原始字符串
在字符串中反斜线有特殊的作用，要表示反斜线的本义时，就需要对反斜线进行转义，对反斜线转义的方法是（\\），这样写免不了有些麻烦。这时可在字符串前面加上 “r”，表示原始字符串，原始字符串不会把反斜线当成特殊字符。例如下面这个表示windows路径的字符串：
r'D:\Python\python38\Scripts\math.py'

原始字符串有引号时，同样要对引号进行转义，此时转义的反斜线会变成字符串的一部分。例如：
s3 =r'"what\'s your name?", michael'
print(s3)       # 输出是："what\'s your name?", michael

原始字符串中的反斜线会对引号进行转义，在字符串的结尾处不能有反斜线，否则字符串不能正确结束。如果一定要在字符串结尾使用反斜线，字符串可以使用成对三引号引起来，也可以将反斜线单独写，例如下面这样：
s4 = r'Hello World!' '\\'
print(s4)       # 输出是：Hello World!\

7、 字节串（bytes）
字符串（str）由多个字符组成，以字符为单位进行操作。字节串（bytes）由多个字节组成，以字节为单位进行操作。

str操作的是字符，bytes操作的是字节。这两个支持的所有方法基本相同，bytes也是不可变序列。

bytes以字节（二进制格式）序列来记录数据，数据表示的内容由程序决定。采用合适的字符集，字符串可以转换成字节串；反之，字节串也可以恢复成对应的字符串。

bytes保存的是原始字节（二进制格式）数据，bytes对象可用于网络上传输数据，也可用于存储各种二进制格式的文件，如图片、音乐等。

字符串转换成bytes对象，有下面三种方式：
（1）、字符串内容全是ASCII字符时，可直接在字符串前面加 b 来构建字节串值。
（2）、调用bytes()函数（实际是 bytes 的构造方法）将字符串按指定字符集转换成字节串，如果不指定字符集，默认使用 UTF-8 字符集。
（3）、调用字符串本身的 encode() 方法将字符串按指定字符集转换成字节串，如果不指定字符集，默认使用 UTF-8字符集。

创建字节串示例：
b1 = bytes()        # 创建一个空 bytes
b2 = b''               # 创建一个空 bytes
b3 = b'Python'      # 在字符串前面加前缀 b，创建的是 bytes 类型的值
print(b3)           # 输出是：b'Python'
print(b3[0])        # 输出是第一个字母 P 的ASCII码值：80
print(b3[2:5])      # 输出仍然是字节串：b'tho'

# 调用 bytes 方法将字符串转换成 bytes 对象，并指明使用 utf-8 字符集编码
b4 = bytes("Python编程可应用于多个领域", encoding='utf-8')
print(b4)           # 输出的是字节码，中文字符是 UTF-8 编码，输出类似：b'Python\xe7\xbc...'
print(b4.decode('utf-8'))   # 输出时可使用 decode() 方法按指定字符集解码，此时输出字符串的内容

# 不使用 bytes 方法，直接调用字符串的 encode 方法同样可以按指定字符集编码
b5 = "Python编程可应用于多个领域".encode('utf-8')
print(b5)           # 输出类似于：b'Python\xe7\xbc...'

字符串与字节串非常相似，但是字符串里的每个数据单元都是1字节。字节（Byte）表示1字节，包含8位（bit），1bit就是1位，存储的值是0或1。

字节串中每个数据单元是字节，也就是8位，其中每4位可以用一个十六进制数(0~f)来表示，因此每个字节可以用两个十六进制数来表示，所以在上面的输出中有“\xe7\xbc”，其中“\xe7”就表示1字节，在这个字节中 \x 表示十六进制，e7就是两位的十六进制数。

此外，在程序中的 bytes 对象，可以调用其 decode() 方法将其解码成字符串。例如 b5 字节串就可以调用 decode() 方法：
print(b5.decode('utf-8'))

字符集概念简介：
在计算机底层不能直接保存字符。计算机科学家的方法是：为每个字符编号，当程序保存数据时，实际保存的是字符的编号；当程序读取字符时，实际读取的也是编号。根据编号在“编号-字符对应表”（简称码表）上得到实际的字符。平时说的字符集，就是由所有字符的编号组成的总和。最初的ASCII码表只考虑了英文字母、数字、特殊符号，因此要表示这些英文字母、数字、特殊符号只要1个字节（8位，可支持256个字符编号）即可。后来其他国家都为本国文字进行编号，从而制订了本国的字符集（比如我国的GB2312、GBK等），这些字符集并不兼容。为了兼容各国的字符集，就用了两个字节（16位，支持65536个字符编码）对各国的文字进行统一编号，这就出现了Unicode字符集。实际使用的UTF-8、UTF-16等都属于Unicode字符集。

另外同一个编号在不同的字符集中代表的字符完全有可能是不同的。比如编号111在一个字符集可以表示“中”字，在另一个字符集中可以表示“国”字。因此，对于同一个字符串，如果采用不同的字符集来生成bytes 对象，得到的是不同的 bytes 对象。

示例：
b1 = bytes('你好，成都', encoding='utf-8')       # 定义一个字节串，并指定编码为 utf-8 字符集
print(b1)           # 输出b1字节串，输出是：b'\xe4\xbd\xa0\xe5\xa5\xbd\xef\xbc\x8c\xe6\x88\x90\xe9\x83\xbd'
print(b1.decode('gbk'))             # 报错或者输出乱码，不能用GBK字符集解码 utf-8 字符串
print(b1.decode('GB2312'))      # 报错或者输出乱码，不能用GB2312字符集解码 utf-8 字符串
print(b1.decode())                    # 默认使用 utf-8 字符集解码字符串
print(b1.decode('utf-8'))          # 明确指定使用 utf-8 字符集解码字符串

二、 深入使用字符串

字符串在每一种编程语言中都是最常用的类型之一，非常重要。

1、 转义字符
在字符串中使用反斜线（\）进行转义。如果字符串中本身含有反斜线时，需要使用双反斜线转义（\\）。在Python中除了这个转义符外，还有下面这些转义字符。
\b      退格符
\n      换行符
\r      回车符
\t      制表符
\"      双引号
\'      单引号
\\      反斜线

示例：
s1 = 'Hello\nworld!\nHello\npython!'        # 在字符串中加入换行符 \n
s2 = '名称\t\t价格\t\t\数量'                  # 在字符串加入制表符

2、 字符串格式化

Python中使用 “%” 对各种类型数据格式化输出。例如下面的代码：
num = 100
print("the number is %s" % num)

上面的print 代码中就是格式化输出代码，这里 print 函数内有三个部分，第一部分是格式化字符串（字符串模板），在格式化字符串中的 “%s” 表示占位符，表示这个位置会被第三部分的变量或表达式的值代替；第二部分是固定使用的分隔符 “%”；第三部分用于替换第一部分的占位符。

格式化字符串中的 “%s” 是转换说明符（Conversion Specifier），其作用是一个占位符，它会被后面的变量表达式的值替换。“%s”指定将变量或值使用 str() 函数转换为字符串。在格式化字符串中当有多个 “%s” 点位符时，第三部分也要对应的提供多个变量，并将这些变量放在小括号中。例如下面的代码：
name = 'michael'
age = 25
print("%s is %s years old!" % (name, age))      # 第一部分有两个点位符，第三部分就提供两个变量

下面总结Python中的转换说明符：
d,i     转换为带符号的十进制形式整数
o       转换为带符号的八进制形式整数
x,X     转换为带符号的十六进制形式整数
e,E     转化为科学计算法表示的浮点数
f,F     转换为十进制形式的浮点数
g       智能选择使用 f 或 g 格式
G       智能选择使用 F 或 G 格式
C       转换为单字符（只接受整数或单字符字符串）
r       使用 repr() 将变量或表达式转换为字符串
s       使用 str() 将变量或表达式转换为字符串

使用这些转换说明符时，可指定转换后最小宽度。示例如下：
num = -29
print("num is: %6i" % num)      # 输出带符号的整数，6位宽，输出：num is:    -29
print("num is: %6d" % num)      # 同上
print("num is: %6o" % num)      # 输出带符号的八进制整数，6位宽，输出：num is:    -35
print("num is: %6x" % num)      # 输出带符号的十六进制整数，6位宽，输出：num is:    -1d
print("num is: %6X" % num)      # 输出带符号的十六进制整数，6位宽，输出：num is:    -1D
print("num is: %6s" % num)      # 使用 str() 函数将变量或表达式转化为字符串，输出：num is:    -29

通过指定了字符串的最小宽度为6位后，在输出转换后的数值时总宽度为6，自动在数值前面补充空格来对齐。默认输出是右对齐，不够宽时左边补充空格。Python还允许在最小宽度之间添加一个标志来改变这种行为，这种标志有3个，这些标志可以同时存在，标志如下：
- ：指定左对齐。
+ ：表示数值总要带符号，正数带“+”号，负数带 “-” 号。
0 ：表示不补充空格，而是补充 0。

示例如下：
num = 39
print("num is: %06d" % num)      #  最小宽度为6，左边不足的用 0 补充，输出：num is: 000039
print("num is: %+06d" % num)    # 最小宽度为6，左边补0，总是带上符号，输出：num is: +00039
print("num is: %-6d" % num)       # 最小宽度为6，左对齐，输出是：num is: 39

在转换浮点数时，可以指定小数点后的位数；转换字符串时，可以指定转换后的字符串的最大字符数。这个标志叫精度值，这个标志放在最小宽度之后，中间用（.）隔开。示例如下：
pi = 3.1415926
print("pi is: %10.4f" % pi)        # 最小宽度为10位，小数点后保留4位，右对齐，输出：pi is:     3.1416
print("pi is: %010.4f" % pi)      # 最小宽度为10位，小数点后保留4位，右对齐，左边补0，输出：pi is: 00003.1416
print("pi is: %+010.4f" % pi)   # 最小宽度为10位，小数点后保留4位，右对齐，左边补0，带符号位，输出：pi is: +0003.1416
name = 'Michael'
print("the name is: %.4s" % name)    # 字符串保留4个字符，输出：the name is: Mich
print("the name is: %8.2s" % name)  # 保留2个字符，最小宽度为8位，输出：the name is:       Mi

三、序列相关方法

字符串是由多个字符组成的，因此可以通过索引来操作字符。可指定获取索引处的字符，也可获取指定字符在字符串中的位置。

字符串的索引在方括号中表示，字符串的索引从0开始，即第一个字符的索引是0，第二个字符的索引是1，以此类推。还可以从最后一个字符开始索引，最后一个字符的索引为-1，倒数第二个字符的索引是-2，以此类推。

此外，在索引时如果超出字符串的长度就报 IndexError 错误。示例如下：
s1 = "python is very Good!"     # 定义一个字符串
print(s1[3])                     # 获取 s1 中索引为 3 的字符，输出是：h
print(s1[-5])                   # 获取 s1 中从右边开始，索引为 5 的字符，输出是：G

在方括号中可以使用范围（或者切片）来获取字符串中的某一段字符，常叫作子串，在使用范围时，左边索引包含，右边索引不包含。示例如下：
print(s1[3:6])                   # 获取 s1 中从索引3到索引6（不包含）的子串，输出是：hon
print(s1[3:-8])                  # 获取 s1 中从索引3到倒数第8个（不包含）字符的子串，输出是：hon is ve
print(s1[-8:-4])                # 获取 s1 中从索引倒数第8个到倒数第4个字符的子串，输出；ry G

在使用切片索引时，可以省略起始或结束索引。省略起始索引就从字符串的开始处截取，省略结束索引就截取到字符串的结束处。示例如下：
print(s1[8:])                   # 获取 s1 中从索引 8 到结束的子串，输出是：s very Good!
print(s1[-8:])                  # 获取 s1 中从倒数第8个字符到结束的子串，输出是：ry Good!
print(s1[:6])                   # 获取 s1 中从开始到索引6的子串，也就是前面6个字符，输出是：python
print(s1[:-6])                  # 获取 s1 中从开始到倒数第6个字符的子串，输出是：python is very

Python字符串还支持 in 运算符来判断是否包含某个子串，判断结果是True 或 False，示例如下：
print('python' in s1)           # 输出：True
print('java' not in s1)         # 还可以使用 not in 来判断是否不包含，输出：True

len() 函数获取字符串长度。min()和max()函数获取字符串中最小字符和最大字符，示例如下：
print(len(s1))                      # 输出：24
print(len('python'))            # 输出：6
print(max(s1))                    # 字符串中最大的字符，输出：y
print(min(s1))                     # 字符串最小的字符，输出是 空格

四、 大小写相关的方法

Python的字符串由内建的 str 类构建，这个类包含有很多的方法。Python是“自带文档”的，在使用帮助时，要熟悉下面两个函数：
dir()：列出指定类或模块包含的全部内容（包括函数、方法、类、变量等）。
help()：查看某个函数或方法的帮助文档。

在查看 str 类包含的全部内容，可在交互式解释器中输入命令：
dir(str)
在列出的 str 类方法中，以“__”开头、“__”结尾的方法约定是私有方法，不希望外部直接使用。要查看某个方法的用法，可使用help()函数：
help(str.title)

在str类中与大小写有关的常用方法如下：
（1）、title()：将每个单词的首字母改为大写，其它字母改为小写。
（2）、lower()：将整个字符串改为小写。
（3）、upper()：将整个字符串改为大写。

示例如下：
s = 'hLLEO world'       # 定义字符串
print(s.title())              # 单词首字母大写，其余字母小写，输出：Hlleo World
print(s.lower())          # 全部字母小写，输出：hlleo world
print(s.upper())         # 全部字母大写，输出：HLLEO WORLD

五、 删除空白
str 类中删除空白的常用方法有：
（1）、strip()：删除字符串起始和结束处的空白。
（2）、lstrip()：删除字符串前面（左边）的空白。
（3）、rstrip()：删除字符串后面（右边）的空白。

注意，在Python中字符串是不可变类型，不管使用什么方法修改字符串，产生的结果都是副本，原字符串不受任何影响。

查看字符串删除空白函数的帮助信息：
help(str.strip)
从帮助信息可以看出，这个 strip() 方法还可以传入参数，当传入参数时，就删除字符串两边相应的字符。同理 lstrip() 和 rstrip()
函数同样可以传入参数。

示例如下：
s = "  python is very strong!  "
print(s.strip())        # 删除字符串两边的空白，输出：python is very strong!
print(s.lstrip())       # 删除字符串左边空白
print(s.rstrip())       # 删除字符串右边空白
s2 = "python is very strong!"
print(s2.strip('pio!'))     # 删除字符串两边的 p、i、o、! 字符，输出是：ython is very strong
print(s2.lstrip('pio!'))    # 删除字符串左边的 p、i、o、! 字符
print(s2.rstrip('pio!'))    # 删除字符串右边的 p、i、o、! 字符

六、字符串的查找、替换有关的方法

str 类提供的常用查找、替换等操作方法如下。
（1）、startswith()：判断字符串是否以指定子串开头。
（2）、endswith()：判断字符串是否以指定子串结尾。
（3）、find()：查找指定子串在字符串中出现的位置，如果没有找到指定的子串，则返回 -1。
（4）、index()：查找指定子串在字符串中出现的位置，如果没有找到指定子串，则引发ValueError错误。
（5）、replace()：使用指定子串替换字符串中的目标子串。第三个参数可以指定替换次数。
（6）、translate()：使用指定的翻译映射表对字符串执行替换。

示例如下：
s = "python is very strong!"
print(s.startswith('py'))          # 判断 s 字符串是否以 py 开头，是就返回 True。
print(s.endswith('rong!'))      # 判断 s 字符串是否以 rong! 结尾，是就返回 True
print(s.find('on'))                   # 查找 s 字符串中 on 出现的位置，注意索引是从 0 开始，输出：4
print(s.index('on'))                # 同上，如果未找到就报错，输出：4
print(s.find('on', 5))              # 从索引 5 处开始查找 on 出现的位置，输出：18
print(s.index('on', 5))           # 从索引 5 处开始查找 on 出现的位置，未找到则报错，输出：18
print(s.replace('on', 'AA',1))  # 将字符串中的1个 on 替换为 AA，第三个参数1表示替换1次。

table = {111: 945, 112: 946, 116: 964}  # 定义翻译映射表：111(o) -> 945(α)，112(p) -> 946(β)，116(t) -> 964(τ)
print(s.translate(table))       # 使用翻译映射表替换，输出：βyτhαn is very sτrαng!

上面的字符翻译示例中，str 类的 translate() 方法需要根据翻译映射表对字符串进行查找、替换。这个翻译映射表是自定义的，在
实际开发工作中，这样自定义翻译映射表未免太麻烦。str 类提供了一个 maketrans() 方法，这个方法可以方便的创建翻译映射表。
table = str.maketrans('opt', 'αβτ')     # 使用 str 类的 maketrans 创建字符映射表
table       # 输出结果是：{111: 945, 112: 946, 116: 964}

在创建映射表时，定义的是字符与字符之间的对应关系，但是翻译映射表不能使用字符本身，必须使用字符的编码。

在Python2.x 版本中，str 类没有 maketrans() 方法，该方法由 string 模块提供。例如在Python2.x 版本中执行方法如下:
import string
table = string.maketrans('abc', '123')      # 输出结果不直观，但是可以作为 translate() 方法的参数使用

七、 分割、连接方法

str 类提供的分割方法是 split()，连接方法是 join()。
（1）、split()：将字符串按指定分割符分割成多个字符串。
（2）、join()：将多个字符串连接成一个字符串。

示例如下：
s = "python is very strong!"
print(s.split())    # 使用空白对字符串分隔，输出：['python', 'is', 'very', 'strong!']
print(s.split(None, 2)) # 使用空白对字符串分隔，最多分隔前两个单词，输出：['python', 'is', 'very strong!']
print(s.split('is'))    # 使用指定字符作为分隔符，输出：['python ', ' very strong!']
alist = s.split()       # 将分隔后的结果赋值给变量 alist
print(':'.join(alist))  # 使用冒号作为连接符，输出：python:is:very:strong!

由上面示例可知，str 类的 split() 和 join() 方法互为逆操作，split() 方法是将字符串分割成多个子串；join() 是将多个子串连接成一个字符串。