一、字符串的定义
在这里声明一下，由于字符串很常用到，因此很多人都以为字符串是基本类型，但是其实不是的，字符串是组合类型
定义字符串
s = 'hello python'
s = "hello python"
s = '''hello python'''
s = """hello python"""
前面两种是完全一样的，后面两种是完全一样的
在Python中单引号和双引号是区别的，只是个人使用的习惯而已。
三引号是可以定义多行数据的，但是单引号是不可以的，只能定义单行字符串，否则会报出SyntaxError的错误（格式错误）
s = '''
hello
Python
'''
转义字符串
path = r'C:\Program Files'
加 r 前缀代表此字符串是自然字符串， 不会转义
二、字符串的操作
下标操作字符串
str = '123456789'
str[0:3] 截取第一位到第三位的字符
str[:] 截取字符串的全部字符
str[6:] 截取第七个字符到结尾
str[:-3] 截取从头开始到倒数第三个字符之前
str[2] 截取第三个字符
str[-1] 截取倒数第一个字符
str[::-1] 创造一个与原字符串顺序相反的字符串
str[-3:-1] 截取倒数第三位与倒数第一位之前的字符
str[-3:] 截取倒数第三位到结尾
str[:-5:-3] 逆序截取，具体啥意思没搞明白？
str[0] = 10 会报出TypeError的错误，由此我们可以看出字符串是不可变的
字符串是可迭代的对象
我们可以通过for来遍历字符串
for i in str:
print
结果集：
1
2
3
4
5
6
7
8
9
字符串常用方法详解
1. join 将可迭代对象转换成字符串，参数是可迭代对象，接收者是分隔符
lst = ['lan','yu','lei']
','.join(lst) 以逗号为分隔符来将列表中的所有元素连接成字符串
2. 分割操作
** split **
split 将字符串转换成一个可迭代对象，默认是根据空格来分割的，若是有多个连续的空格会当做一个空格来识别，可传递参数指定分隔符是什么。
str = 'lan yu lei'
lst = str.split() 结果集为： ['lan','yu','lei']
lst = str.split(maxsplit=1) 结果集为： ['lan','yulei']
split 从左往右分割字符串，maxsplit参数表示分割多少次，默认值为-1，表示分割所有分割符
split的原理函数解析:
def split(str, sep, maxsplit):
ret = []
tmp = []
i = 0
for c in s:
if c !=sep:
tmp.append(c)
else:
i += 1
ret.append(''.join(tmp))
tmp.clear()
if maxsplit > 0 and i >= maxsplit:
ret.append()
return ret
return ret
** rsplit **
rsplit是从右往左分割的
rsplit的原理函数解析：
def rsplist(str,sep,maxsplit):
ret = []
tmp = []
i = 0
for c in reversed(str):
if c != sep:
tmp.append(c)
else:
i += 1
ret.append(''.join(reversed(tmp)))
tmp.clear()
if maxsplit > 0 and i >= maxsplit:
ret.append()
return reversed(ret)
return reversed(ret)
** splitlines **
splitlines 按行分割，并且返回结果，不带换行符
splitlines 可以传递一个参数，若是传递一个True的参数，则在返回的结果中加入换行符，默认为False
** partition **
'lan yu lei'.partition('') 返回结果：('lan',' ','yulei')
总是返回一个三元组，它按传入的分割符分割一次
partition的原理函数解析：
def partition(s,sep):
if s == '':
return '', '', ''
tmp = s.split(sep, maxsplit=1)
if len(tmp) == 2:
return tmp[0], sep, tmp[1]
if len(tmp) == 1:
return tmp[0], sep, ''
if len(tmp) == 0:
return '', sep, ''
** rpartition **
rpartition是partition的从右往左的版本
2. 字符串的书写规范
s = 'test'
s.upper() 转换成大写
s.lower() 转换成小写
s.title() 将每个单词的首字母转换成大写
s.capitalize() 只将这一组字符串的首字母转换成大写
s.casefold() 不同的平台有不同的表现形式，但是同一平台下，变现形式相同
s.swapcase() 大小写互相转换，将这组数据中的大写变成小写，小写变成大写
'\t'.expandtabs(4) 将table转换成空格，在这里的含义是：将table转换成 4 个空格
3. 字符串的修改
** s.replace (字符串替换)**
s.replace(old, new[, count])
s = 'i very very love python'
s.replace('love','give up') 结果是返回新的字符串，使用参数new的值替换old的值，而且默认是替换所有old的值
s.replace('very', 'not', 1) 在这里当前函数的用法是从左到右只替换一次数据，1 表示一次，可根据需求修改
** s.strip **
默认移除字符串的首尾空白字符（包括：\r,\n,\t,空格等）
>>> strings = ' \n \t \r lanyulei \n \t \r'
>>> strings.strip()
'lanyulei'
移除字符串中指定的字符，例如移除字符串中的 # 字符
>>> strings = '####lan # yu # lei####'
>>> strings.strip('#')
'lan # yu # lei'
** s.lstrip **
与strip表达形式是相同的，但是 lstrip 只处理左端的
>>> strings = '####lan # yu # lei####'
>>> strings.lstrip('#')
'lan # yu # lei####'
** s.rstrip **
与strip表达形式是相同的，但是 lstrip 只处理右端的
>>> strings = '####lan # yu # lei####'
>>> strings.rstrip('#')
'####lan # yu # lei'
** s.ljust **
在此声明，因为Linux和windows中的字符占位不相同，因为结果集可能有差异，但是这些是正常的
与strip相反，ljust是填充数据的
ljusts默认是填充空格的
>>> strings = 'lanyulei'
>>> strings.ljust(10)
'lanyulei '
ljusts填充指定的数据
>>> strings = 'lanyulei'
>>> strings.ljust(10,'#')
'lanyulei###'
** s.rjust **
与ljust的表现是相同的，但是ljust是填充在左边的，但是rjust是填充数据在右边的
** s.center **
填充数据在两侧，原来的数据在新填充数据的中心位置
>>> strings = 'lanyulei'
>>> strings.center(10,'#')
'#lanyulei#'
注意的是，填充的数据只能是单个字符，ljust和rjust也是一样的
>>> strings = 'lanyulei'
>>> strings.center(10,'###')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: The fill character must be exactly one character long
同时如果填充的宽度小于等于原字符串的长度的话，不做任何操作
4. 字符串的查找
** s.find **
用于查找字符数据的
>>> strings = 'i love python'
>>> strings.find('love') 从左往右查找，找到第一个子串，返回子串首字符的索引
2
>>> strings.find('lovel') 当子串不存在的时候，返回-1
-1
>>> strings = 'i very very love python'
>>> strings.find('very', 3) find的start参数，从哪里开始查找
7
>>> strings = 'i very very love python'
>>> strings.find('very', 3 ,5) find的end参数，指定到哪里结束查询， end的索引值不包括在内，也就说当查询的子串中出现了，end参数索引对应的值，那么久无法查找到子串
-1
** s.rfind **
rfind是find的从右往左的版本
>>> strings = 'i very very love python'
>>> strings.rfind('very')
7
start和end的意义是一样的，事实上，是先根据start和end截取字符串，再查找的
** s.index **
index和find是基本完全相同的，唯一的不同就是当子串不存在的时候，抛出的返回值是不相同的
index当子串不存在的时候，抛出ValueError的异常
>>> strings = 'i very very love python'
>>> strings.index('very',8)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: substring not found
find当子串不存在的时候，返回-1
>>> strings = 'i very very love python'
>>> strings.find('very'， 8) 当子串不存在的时候，返回-1
-1
这是index和find的唯一区别
** s.rindex **
同index和find的区别是相同的，rindex和rfind的唯一区别也是，
index当子串不存在的时候，抛出ValueError的异常，而find当子串不存在的时候，返回-1
** s.count **
获取子串在字符串中出现的次数
>>> strings = 'i very very love python'
>>> strings.count('very')
2
count方法也是有start和end的参数的，同index，find的方法的用法是相同的
5. 字符串的判断
** s.startswith **
判断字符串是否以某个前缀开始的，返回结果是bool
strings = 'i very very love python'
strings.startswith('i very')
True
strings.startswith('i verysf')
Falsestartswith也是有start和end参数的
start 参数表示的是从索引 start 的位置开始比较
end 参数表示的是从索引 end 的位置停止比较，end不包含
** s.endswith **
判断字符串是否以某个后缀结尾的，返回结果是bool
strings = 'i very very love python'
strings.endswith('python')
True
strings.endswith('python')
Falseendswith也是有start和end参数的
start 参数表示的是从索引 start 的位置开始比较
end 参数表示的是从索引 end 的位置停止比较，end不包含
** s.is* **
s.isalnum() 判断是否只包含数字和字母
s.isdecimal() 判断是否只包含数字
s.isidebtifier() 判断是否为合法的标识符
* 字母或者下划线开头
* 仅包含字母数字和下划线
等等还有很多判断类型的函数，这些字符串判断类型的方法都不是常用到的，有兴趣的自己google查下。
当不是用maxsplit参数的时候，split和rsplit表现形式一样，但是split效率高于rsplit
reversed 将序列化对象元素顺序反转
sorted 将序列化对象元素序列化