字符串
用单引号或双引号扩起来一个或多个字符的都是字符串。
字符串是可迭代的，即有索引值。
字符串是不可变的数据类型，即无法修改字符串中的字符，如果想要修改，就必须将原来的字符串复制一份存储在新开辟的内存空间中，然后再进行修改并生成新的字符串，原字符串内容不变。
In [1]: string = "ABCD"
In [2]: print(string, type(string), id(string))
ABCD <class 'str'> 139635933102856
In [3]: string = "1234" # 修改 string 的值
In [4]: print(string, type(string), id(string)) # 新的内存空间地址
1234 <class 'str'> 139635922028448
1.通过 + 号连接多个String
可使用加法操作符，将两个或多个字符串组合在一起，结果就是由第一个字符串中的字符和其它字符串中的字符共同构成的一个新字符串。将字符串组合的做法，被称为字符串拼接。
In [1]: a, b = "Hello", "World"
In [2]: a + b
Out[2]: 'HelloWorld'
2.通过 * 号连接多个String
In [1]: string = "Hello World!" + " "
In [2]: string * 3
Out[2]: 'Hello World! Hello World! Hello World! '
3.String的格式化输出：% 操作符
在Python2.6以前，% 操作符是唯一一种格式化字符串的方法，也可以用于字符串连接。
In [1]: "我叫%s, 今年%d岁, 祖籍%s!" % ("小明", 18, "北京")
Out[1]: '我叫小明, 今年18岁, 祖籍北京!'
In [2]: "%.3f"%(3.1415926) # 注意：四舍五入
Out[2]: '3.142'
%s s=string，万能的，不会出错。
%d d=digit，整数类型的。
%f f=float，小数，默认保存6位小数，第6位小数的值看第7位小数，会四舍五入。
eg.： %.3f，指定保存3位小数。
4.String的格式化输出：format()方法
format()方法是一种代替 % 操作符的字符串格式化方法，也可以用于字符串连接。
In [1]: "我叫{}".format("小明")
Out[1]: '我叫小明'
In [2]: "我叫{name},今年{age}岁，祖籍{hometown}！".format(name="小明", age=18, hometown="北京")
Out[2]: '我叫小明,今年18岁，祖籍北京！'
In [3]: "我叫{0},今年{1}岁，祖籍{2}！".format("小明", 18, "北京")
Out[3]: '我叫小明,今年18岁，祖籍北京！'
5.String的格式化输出：f-string
在 Python3.6 中引入了 Formatted String Literals（字面量格式化字符串），简称 f-string，它是 % 操作符和 format 方法的进化版。f-string 的性能比 % 操作符和 format() 方法都好。
In [1]: name = "小明"
In [2]: age = 18
In [3]: hometown = "北京"
In [4]: f"我叫{name}, 今年{age}, 祖籍{hometown}！"
Out[4]: '我叫小明, 今年18, 祖籍北京！'
6.String的取值
String的取值就是使用其索引来取值的，正序索引从 0 开始，倒序索引从 -1 开始。
正序索引取值（从左至右）
取单个值
In [1]: string = "ABCD1234"
In [2]: string[0] # 第一个元素
Out[2]: 'A'
In [3]: string[-1] # 最后一个元素
Out[3]: '4'
切片
将一个可迭代对象中元素的子集，创建为一个新的可迭代对象。
使用切片取多个值，格式：[开始索引值:结束索引值:步长]，开始索引值或结束索引值是空值的情况下默认取所有值，步长可以省略。
切片取值遵循顾首不顾尾的原则
In [1]: string = "ABCD1234"
In [2]: string[:] # 切片两边都不写，默认取所有值。
Out[2]: 'ABCD1234'
In [3]: string[:3] # 顾首不顾尾，即最后一个索引值无法检索。
Out[3]: 'ABC'
In [4]: string[-3:-1] # 正序索引取值，从左至右。
Out[4]: '23'
In [5]: string[::3] # 步长取值
Out[5]: 'AD3'
开始索引值或结束索引值都是0，取不到值。
In [1]: string = "ABCD1234"
In [2]: string[0:0]
Out[2]: ''
倒序索引取值（从右至左）
-1 表示正常的倒序取值（必须加 -1 ），非 -1 则表示倒序步长，比如-2，-3。
In [1]: string = "ABCD1234"
In [2]: string[2::-1] # -1 是倒序取值
Out[2]: 'CBA'
In [3]: string[:3:-1]
Out[3]: '4321'
In [4]: string[::-3] # 大于 -1 即步长
Out[4]: '41B'
7.String的内置方法
capitalize()
字符串中的第一个字符若是字母则转大写其余字母全部转小写，若不是字母则全部转成小写。
对数字和特殊字符没有影响。
In [1]: string = "aBCD1234"
In [2]: string.capitalize()
Out[2]: 'Abcd1234'
In [3]: string = "1234aBCD"
In [4]: string.capitalize()
Out[4]: '1234abcd'
upper()
将字符串中的小写字母全部转为大写字母。
In [1]: string = "1234abcd"
In [2]: string.upper()
Out[2]: '1234ABCD'
isupper()
检测字符串中所有的字母是否都全部为大写，条件满足则返回 True ，否则返回 False 。
In [1]: string = "ABCD1234"
In [2]: string.isupper()
Out[2]: True
In [3]: string = "abcd1234"
In [4]: string.isupper()
Out[4]: False
lower()
把字符串中所有大写字母全部转换为小写。
In [1]: string = "ABCD1234"
In [2]: string.lower()
Out[2]: 'abcd1234'
islower()
检测字符串中所有的字母是否都全部为小写，条件满足则返回 True ，否则返回 False 。
In [1]: string = "abcd1234"
In [2]: string.islower()
Out[2]: True
In [3]: string = "abCD1234"
In [4]: string.islower()
Out[4]: False
swapcase()
对字符串的大小写字母进行翻转。
In [1]: string = "AbCd1234"
In [2]: string.swapcase()
Out[2]: 'aBcD1234'
title()
把字符串中所有单词的首字母转化为大写，其余字母均为小写。
非字母开头的单词第一个字母将转换为大写字母，其余字母均为小写。
In [1]: string = "abcd1234"
In [2]: string.title()
Out[2]: 'Abcd1234'
In [3]: string = "1234abcd"
In [4]: string.title()
Out[4]: '1234Abcd'
istitle()
检测字符串中第一个字母是否为大写且其它字母为小写，条件满足则返回 True ，否则返回 False 。
In [1]: string = "Abcd1234"
In [2]: string.istitle()
Out[2]: True
In [3]: string = "ABcd1234"
In [4]: string.istitle()
Out[4]: False
center(width, fillchar)
以指定的宽度居中字符串，两边以自定义字符进行填充，默认是空格。
如果指定的宽度小于字符串宽度则直接返回字符串，否则使用 fillchar 去填充。
width：字符串的总宽度。
fillchar：填充的字符。
ljust()
以指定的宽度左对齐字符串，两边以自定义字符进行填充，默认是空格。
rjust()
以指定的宽度右对齐字符串，两边以自定义字符进行填充，默认是空格。
In [1]: string = "ABCD1234"
In [2]: string.center(2) # 指定宽度小于字符串本身的宽度，返回字符串。
Out[2]: 'ABCD1234'
In [3]: string.center(10) # 设置字符串的总宽度是10，以宽度10来居中字符串，两边以空格填充。
Out[3]: ' ABCD1234 '
In [4]: string.center(10, "%") # 以 % 填充。
Out[4]: '%ABCD1234%'
count(sub, start=None, end=None)
统计字符在字符串中出现的次数。
sub：搜索的字符
start：开始索引值，默认从索引0开始。
end：结束索引值。
In [1]: string = "ABCD1234"
In [2]: string.count("A")
Out[2]: 1
In [3]: string.count("D", 1, 5) # 指定查找的索引范围
Out[3]: 1
In [4]: string.count("CD12") # 把 CD12 看成一个整体，这是重点思想。
Out[4]: 1
decode(encoding=‘UTF-8’, errors=‘strict’)
以指定的编码格式解码 bytes 对象。默认编码为 UTF-8。
encoding：要使用的编码，默认编码为UTF-8。
errors：设置不同错误的处理方案。默认为 ‘strict’，这意味着编码错误会引发UnicodeError。 其他可能得值有 ‘ignore’， ‘replace’， ‘xmlcharrefreplace’，‘backslashreplace’ 以及通过 codecs.register_error() 注册的任何值。
encode(encoding=‘UTF-8’, errors=‘strict’)
以指定的编码格式编码字符串。
encoding：要使用的编码，默认编码为UTF-8。
errors：设置不同错误的处理方案。默认为 ‘strict’，这意味着编码错误会引发UnicodeError。 其他可能得值有 ‘ignore’， ‘replace’， ‘xmlcharrefreplace’，‘backslashreplace’ 以及通过 codecs.register_error() 注册的任何值。
In [1]: string = "我爱你"
In [2]: string_utf8 = string.encode(encoding="utf-8", errors="strict")
In [3]: "UTF-8编码：", string_utf8
Out[3]: ('UTF-8编码：', b'\xe6\x88\x91\xe7\x88\xb1\xe4\xbd\xa0')
In [4]: "UTF-8解码：", string_utf8.decode(encoding="utf-8", errors="strict")
Out[4]: ('UTF-8解码：', '我爱你')
In [5]: string_gbk = string.encode(encoding="gbk", errors="strict")
In [6]: "GBK编码：", string_gbk
Out[6]: ('GBK编码：', b'\xce\xd2\xb0\xae\xc4\xe3')
In [7]: "GBK解码：", string_gbk.decode(encoding="gbk", errors="strict")
Out[7]: ('GBK解码：', '我爱你')
startswith(prefix, start=None, end=None)
判断字符串是否以指定字符开头，条件满足返回 True，否则返回 False。
prefix：该参数可以是一个字符串或者是一个元素。
start：切片开始的位置。
end：切片结束的位置。
endswith(suffix, start=None, end=None)
判断字符串是否以指定字符结尾，条件满足返回 True，否则返回 False。
In [1]: string = "ABCD1234"
In [2]: string.startswith("A")
Out[2]: True
In [3]: string.endswith("4")
Out[3]: True
find(sub, start=None, end=None)
从左边开始查找指定的字符是否包含在字符串中，条件满足则返回该字符的索引值，否则返回 -1 。
rfind(sub, start=None, end=None)
从右边开始查找指定的字符是否包含在字符串中，条件满足则返回该字符的索引值，否则返回 -1 。
注意：从左至右匹配到字符后就不在查找，即使后面的还有能匹配到字符也不在查找。
sub：搜索的字符。
start：开始索引值，默认从索引0开始。
end：结束索引值。
In [1]: string = "ABCD1234"
In [2]: string.find("D")
Out[2]: 3
In [3]: string.find("CD") # 把 is 看作成为一个整体，只返回第一个字符的索引值。
Out[3]: 2
In [4]: string.find("1", 2, 5)
Out[4]: 4
In [5]: string.find("E") # 未找到此字符，返回 -1 。
Out[5]: -1
index(sub, start=None, end=None)
从左边开始查找指定的字符是否包含在字符串中，条件满足则返回该字符的索引值，否则返回一个错误异常（ValueError: substring not found） 。
rindex(sub, start=None, end=None)
从右边开始查找指定的字符是否包含在字符串中，条件满足则返回该字符的索引值，否则返回一个错误异常（ValueError: substring not found） 。
sub：搜索的字符
start：开始索引值，默认从索引0开始。
end：结束索引值。
In [1]: string = "ABCD1234"
In [2]: string.index("D")
Out[2]: 3
In [3]: string.index("CD")
Out[3]: 2
In [4]: string.index("1", 2, 5)
Out[4]: 4
In [5]: string.index("E")
ValueError: substring not found
isalnum()
检测字符串是否由字母或数字组成，条件满足则返回 True ，否则返回 False 。
In [1]: string = "ABCD1234"
In [2]: string.isalnum()
Out[2]: True
In [3]: string = "%ABCD1234%"
In [4]: string.isalnum()
Out[4]: False
isalpha()
检测字符串是否只由字母组成，条件满足则返回 True ，否则返回 False 。
In [1]: string = "ABCD1234"
In [2]: string.isalpha()
Out[2]: False
In [3]: string = "ABCD"
In [4]: string.isalpha()
Out[4]: True
isdigit()
检测字符串是否只由数字组成，条件满足则返回 True ，否则返回 False 。
In [1]: string = "ABCD1234"
In [2]: string.isdigit()
Out[2]: False
In [3]: string = "1234"
In [4]: string.isdigit()
Out[4]: True
join()
1.将序列中的元素以指定的字符连接生成一个新的字符串。
In [1]: var = " "
In [2]: result = "ABCD1234"
In [3]: var.join(result)
Out[3]: 'A B C D 1 2 3 4'
2.数据类型转换，列表转字符串用 join() 方法。
In [1]: var = " "
In [2]: list = ["Hello", "Word", "!"]
In [3]: var.join(list)
Out[3]: 'Hello Word !'
len()
返回对象（字符串、列表、元组等）长度或个数。
In [1]: string = "ABCD1234"
In [2]: len(string)
Out[2]: 8
In [3]: len(string[3])
Out[3]: 1
strip()
删除字符串两边的字符，默认是空格，也可以手动指定。
In [1]: string = " ABCD1234 "
In [2]: string.strip()
Out[2]: 'ABCD1234'
In [3]: string = "%ABCD1234%"
In [4]: string.strip("%") # 指定删除
Out[4]: 'ABCD1234'
lstrip()
删除字符串左边的字符，默认是空格，也可以手动指定。
rstrip()
删除字符串右边的字符，默认是空格，也可以手动指定。
split()
通过指定分隔符对字符串进行切片，返回一个列表。分隔符默认是空格，也可以是字符串中的某个字符，分隔符不会出现在返回值中。
数据类型转换，字符串转列表用 split() 方法。
In [1]: string = "A B C D 1 2 3 4"
In [2]: string.split()
Out[2]: ['A', 'B', 'C', 'D', '1', '2', '3', '4']
In [3]: string = "ABCD%1234"
In [4]: string.split("%") # 指定分割符
Out[4]: ['ABCD', '1234']
replace(self, old, new, count=None)
把字符串中的 old（旧字符串）替换成 new（新字符串）。
In [1]: string = "ABCD1234"
In [2]: string.replace("D", "E")
Out[2]: 'ABCE1234'
in 检查某个字符串是否在另一个字符串中，返回结果为 True 或 False。
sIn [1]: string = "ABCD1234"
In [2]: "D" in string
Out[2]: True
not in 检查某个字符串是否不在另一个字符串中，返回结果为 True 或 False。
In [1]: string = "ABCD1234"
In [2]: "E" not in string
Out[2]: True
8.String转义
在Python中具有特殊意义的字符（如双引号）前加上一个符号，告诉Python在本例中该字符代表的只是一个字符，没有特殊意义。
在Python 中用反斜杠进行转义。
In [1]: "She said \"Surely.\""
Out[1]: 'She said "Surely."'
9.String换行符
在字符串中加入\n 来表示换行.
In [1]: print("line1\nline2\nline3")
line1
line2
line3