字符串声明
双引号，单引号，三单引号，三双引号
里面有双引号，外面使用单引号
里面有单引号，外面使用双引号
或者使用转义字符
#字符串
m='hello'
n="hello"
#里面有双引号，外面使用单引号
a='"hello"'
#里面有单引号，外面使用双引号
b="I'm dq"
c='''hello'''
d="""hello"""
i='''I say:"ok"'''
j="""I'dq"""
print(a,b,c,d,i,j,sep='\n')
注意：不能字符串+数字，会报错，必须两者都是字符串
#报错TypeError: can only concatenate str (not "int") to str
print("3243"+3)
print("3243" + 3+"2343")
规定：
两个字符串类型的数据使用加法运算符，用来拼接两个字符串。在Python里数字和字符串不能做加法运算。
数字和字符串之间使用乘法运算符，用于将字符串重复多次。
字符串之间使用比较运算符，会根据各个字符的编码值逐一进行比较。
数字和字符串之间，做 == 运算的结果是 False，做 != 运算的结果是 True，其它的比较运算均不支持，否则会报错。
转义字符
\n换行
\t水平制表符
\斜杠
\r是回车,光标到行首
\v:垂直制表
如：
aaaa水平
a
a
a
a垂直
tab默认四个空格
#字符串2-转义字符
m='he\'ll\'o'
n="he\"ll\"o"
print(m,n,sep='\n')
字符串下标
1.字符串下标
0–n-1
-n-(-1)
2.字符串一旦定义不能发生变化
x=‘89’
x[0]=‘3’(错误)
x=‘2345’(指向一个新的字符串)
3.字符串切片
字符串名称[start :end :step]
step默认为1，从左往右取
如果只设置start，会“截取”到最后。
如果只设置end，会从头开始“截取”到end前一个字符。
这三个都可以缺省，即取出所有的
正向：
#字符串3-切片1
x='1234567'
#[start:end)从0开始-12
print(x[0:2:1],sep='\n')
#[start:end)从0开始-1234567
print(x[0:7:1],sep='\n')
#全部缺省，取出所有的-1234567
print(x[::],sep='\n')
#取出[1,3)--123
print(x[:3:],sep='\n')
#隔2个取--1357
print(x[0::2],sep='\n')
逆向：
step=-1从右往左取
#字符串3-切片2
x='1234567'
#(-n)--(-1):这里-7--(-1)
#step=1从左向右--34
print(x[-5:-3:1],sep='\n')
#step=-1从右到左，7654
print(x[-1:-5:-1],sep='\n')
#从第-2到第-5，从右往左，每隔两个字符做1次切片，输出64
print(x[-2:-5:-2])
##从右往左每隔3个字符做1次切片，输出741
print(x[::-3],sep='\n')
字符串常见函数
获取字符串长度-len()函数
查找内容-find()函数
描述：查找字符串中指定的子字符串sub第一次出现的位置，可以规定字符串的索引查找范围。若无则返回 -1。
语法：str.find(sub,start,end) -> int 返回整数
sum —要索引的子字符串。
start —索引的起始位置。默认值为0。
end —索引的结束位置。默认值为字符串长度len(str)。
[start,end) 不包括end。
#字符串函数-find
x='i love python'
#语法：字符串名称。find(子字符串，开始位置，结束位置)
#返回字符子串python第一次出现的位置(下标，从0开始)
print(x.find('python',0,len(x)),end='\n')
#没有查找到就返回-1
print(x.find('python',0,6),end='\n')
查找内容-rfind()函数
描述：查找字符串中指定的子字符串sub最后一次出现的位置，可以规定字符串的索引查找范围。若无则返回 -1。
语法：str.rfind(sub,start,end) -> int 返回整数
sum —要索引的子字符串。
start —索引的起始位置。默认值为0。
end —索引的结束位置。默认值为字符串长度len(str)。
[start,end) 不包括end。
注：rfind()函数用法与find()函数相似，rfind()函数返回指定子字符串最后一次出现的位置，find()函数返回指定子字符串第一次出现的位置。
#字符串函数-rfind
x='ip lovnep python'
#语法：字符串名称。find(子字符串，开始位置，结束位置)
#返回字符子串python最后一次出现的位置(下标，从0开始)--n
print(x.rfind('n',0,len(x)),end='\n')
#查的是第一个字符：p--10
print(x.rfind("python"))
#没有查找到就返回-1
print(x.rfind('python',0,6),end='\n')
查找内容-index()函数
描述：查找字符串中第一次出现的子字符串的位置，可以规定字符串的索引查找范围[star,end)。若无则会报错。
语法：str.index(sub, start, end) -> int 返回整数
sub —— 查找的子字符串。
start —— 索引的起始位置，默认为0。
end —— 索引的结束位置，默认为字符串的长度。
[star,end)
# 字符串函数-index
str = "i love python"
# 与find用法一致
print(str.index("p", 4, 12))
# 若无则会报错-ValueError: substring not found
print(str.index("k", 4, 12))
print(str.index("i"))
查找内容-rindex()函数
描述：查找字符串中最后一次出现的子字符串的位置，可以规定字符串的索引查找范围[star,end)，若无则会报错。
语法：str.rindex(sub, start, end) -> int 返回整数。
sub —— 查找的子字符串。
start —— 索引的起始位置，默认为0。
end —— 索引的结束位置，默认为字符串的长度。
[star,end)
#字符串函数-rindex
str = "i love python python"
#返回字符子串p后一次出现的位置(下标，从0开始)
print(str.rindex("p"))
#返回字符子串o后一次出现的位置(下标，从0开始)
print(str.rindex("o",0,len(str)))
# 若无则会报错-ValueError: substring not found
print(str.rindex("x"))
判断-endswith()函数
描述：判断字符串是否以指定字符或子字符串结尾。
语法：str.endswith(“suffix”, start, end) 或
str[start,end].endswith(“suffix”) 用于判断字符串中某段字符串是否以指定字符或子字符串结尾。
—> bool 返回值为布尔类型（True,False）
suffix — 后缀，可以是单个字符，也可以是字符串，还可以是元组（"suffix"中的引号要省略）。
start —索引字符串的起始位置。
end — 索引字符串的结束位置。
str.endswith(suffix) star默认为0，end默认为字符串的长度减一（len(str)-1）。
注意：空字符的情况。返回值通常也为True
#字符串函数-endswith
#查找字符串是否以字符结尾，是返回True，不是返回False
str = "i love python"
#True
print(str.endswith("n"))
#False
print(str.endswith("n",0,6))
#True
print(str.endswith("python"))
#True
print(str.endswith("python",0,len(str)))
#True-空字符串
print(str.endswith(""))
判断-startswith()函数
描述：判断字符串是否以指定字符或子字符串开头。
用法与endswitch一致
#字符串函数-startswith
#查找字符串是否以字符开头，是返回True，不是返回False
str = "ilove python"
#True
print(str.startswith("i"))
#True
print(str.startswith("i",0,6))
#True
print(str.startswith("ilove"))
#False
print(str.startswith("python",0,len(str)))
#True-空字符串
print(str.startswith(""))
判断-isalpha()函数
isalpha()的作用是检查一个字符串中所有的字符是否都是由字母构成的，并且至少有1个字符。
string_name.isalpha()
该函数没有参数。
string_name是要判断的字符串或字符串变量。
如果字符串中除了字母和中文外，不包括任何其它字符（数字，符号等）且不是空字符串，则返回True，否则返回False.
示例：
判断- isdigit() 函数
isdigit()方法检测字符串是否只由数字组成。
如果字符串只包含数字则返回 True 否则返回 False。
str = "123456" #True
print (str.isdigit())
str = "this is string example....wow!!!"#False
print (str.isdigit())
str = "thisd22is string example....wow!!!"#False
print (str.isdigit())
str = "可靠 11"#False
print (str.isdigit())
判断-isalnum()函数
检查一个字符串是否是由某门语言的有效字符或数字构成。
1）该函数检查字符串是否由字母[a-z,A-Z]（也包括构成其它语言的字符，如汉字，俄文，日文，韩文）或数字[0-9]及其组合组成的，如果是则返回True，否则返回False。
3）组成字符串的字符中有是空字符串，不能有特殊字符，不可打印字符，控制符，标点符号等返回False。
isalnum使用的例子
1、字符串仅包含字母
str1 = "Python"
print(str1.isalnum())
输出：True
2、字符串仅包含数字
str1 = "5211314"
print(str1.isalnum())
输出：True
3、字符串由字母或数字组成
str1 = "HelloPython3"
print(str1.isalnum())
输出：True
4、字符串由字母和汉字组成
rtn_value = "翔宇亭IT乐园".isalnum()
print(rtn_value)
输出：True
只包括汉字和英文字母，所以为True.
5、字符串中包含空格
str1 = "I am a student"
print(str1.isalnum())
输出：False
6、字符串中包含标点符号
str1 = "Perfect!"
print(str1.isalnum())
输出：False
7、字符串中包含大小写的字母
str1 = "GoodBoy123"
print(str1.isalnum())
输出：True
8、空字符
str1 = ""
print(str1.isalnum())
输出：False
9、非英文字母
str1 = "Ятебялюблю" #俄语
print(str1.isalnum())
输出：True
10、包含特殊字符
str1 = "[email protected]"
print(str1.isalnum())
输出：False
判断-isspace()函数
isspace()的作用是检查字符串是否仅包含空白字符(纯空白字符”“，’‘，转义字符\n,\t,\v,\r)，如果字符串仅包含空白字符则返回True，否则返回False。
示例1：
示例2：
计算-出现次数count(）函数
描述：统计字符串里某个字符出现的次数。可以选择字符串索引的起始位置和结束位置。
str = "i love python,i am learning python"
print(str.count("i"))
print(str.count("i",2))
print(str.count("i",2,5))
print(str.count("am"))
替换内容-replace()函数
replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。
str.replace(old, new[, max])
old – 将被替换的子字符串。
new – 新字符串，用于替换old子字符串。
max – 可选字符串, 替换不超过 max 次
返回字符串中的 old（旧字符串） 替换成 new(新字符串)后生成的新字符串，如果指定第三个参数max，则替换不超过 max 次。
实例
str = "this is string example....wow!!! this is really string"
print (str.replace("is", "was"))
print (str.replace("is", "was", 3))
输出：
thwas was string example…wow!!! thwas was really string
thwas was string example…wow!!! thwas is really string
切割字符串-partition()函数：
描述：根据指定的分隔符(sep)将字符串进行分割。从字符串左边开始索引分隔符sep,索引到则停止索引。
语法：str.partition(sep) -> (head, sep, tail) 返回一个三元元组，head:分隔符sep前的字符串，sep:分隔符本身，tail:分隔符sep后的字符串。
#字符串-partition
#partition('分隔符')指定的分隔符(sep)将字符串进行分割
#遇到第一个分隔符就停止
#有：返回(分隔符左边，分隔符，分隔符右边)
#无：返回(整个字符串，分隔符)
str = "https://www.baidu.com/"
print(str.partition("://"))
print(str.partition(","))
print(str.partition("."))
print(type(str.partition("://")))
# 输出：
# ('https', '://', 'www.baidu.com/')
# ('https://www.baidu.com/', '', '')
# ('https://www', '.', 'baidu.com/')
# <class 'tuple'>
切割字符串-rpartition()函数
描述：根据指定的分隔符(sep)将字符串进行分割。从字符串右边(末尾)开始索引分隔符sep,索引到则停止索引。
语法：str.rpartition(sep) -> (head, sep, tail) 返回一个三元元组，head:分隔符sep前的字符串，sep:分隔符本身，tail:分隔符sep后的字符串。
#字符串-rpartition
#rpartition('分隔符')指定的分隔符(sep)将字符串进行分割--从右往左
#遇到第一个分隔符就停止
#有：返回(分隔符左边，分隔符，分隔符右边)
#无：返回（分隔符，整个字符串)
str = "https://www.baidu.com/"
print(str.rpartition("://"))
print(str.rpartition(","))
print(str.rpartition("."))
print(type(str.rpartition("://")))
# 输出：
# ('https', '://', 'www.baidu.com/')
# ('', '', 'https://www.baidu.com/')
# ('https://www.baidu', '.', 'com/')
# <class 'tuple'>
切割字符串-split（）函数
描述：拆分字符串。通过指定分隔符sep对字符串进行分割，并返回分割后的字符串列表。
语法：str.split(sep=None, maxsplit=-1) -> list of strings 返回 字符串列表 或str.split(sep=None, maxsplit=-1)[n]
sep —— 分隔符，默认为空格,但不能为空即(")。
maxsplit —— 最大分割参数，默认参数为-1。
[n] —— 返回列表中下标为n的元素。列表索引的用法。
#字符串函数-split()
a="d/q.i/s.co/ding"
#没有分割，输出整个字符串--['dqiscoding']
print(a.split())
#以.分割--['dq', 'is', 'coding']
print(a.split("."))
#分割后的字符串的第一个，再次分割，从0开始
print(a.split('.')[0].split('/'))
print(a.split('.')[1].split('/'))
切割字符串-rsplit()函数
rsplit() 方法通过指定分隔符对字符串进行分割并返回一个列表，默认分隔符为所有空字符，包括空格、换行(\n)、制表符(\t)等。类似于 split() 方法，只不过是从字符串最后面开始分割。
#字符串函数-rsplit()
#从字符串最后面开始分割，但输出时还是从前面往后输出
a="d/q.i/s.co/ding"
#没有分割，输出整个字符串--['dqiscoding']
print(a.rsplit())
#以.分割--['dq', 'is', 'coding']
print(a.rsplit("."))
#1为最大分割次数，此时只分割一次
print(a.rsplit(".",1))
#分割后的字符串的第一个，再次分割，从0开始
print(a.rsplit('.')[0].rsplit('/'))
print(a.rsplit('.')[1].rsplit('/'))
切割字符串-splitlines（）函数
splitline()方法用于在线边界处分割线。该函数返回字符串中的行列表，包括换行符(可选)。
用法:
string.splitlines([keepends])
参数：
keepends(可选)：当设置为True时，结果列表中将包含换行符。
这可以是一个数字，指定换行的位置，也可以是任何Unicode字符，例如“\n”，“\r”，“\r\n”等作为字符串的边界。
代码＃1
string = “Welcome everyone to\rthe world of Geeks\nGeeksforGeeks”
print (string.splitlines( ))
print (string.splitlines(0))
print (string.splitlines(True))
输出：
[‘Welcome everyone to’, ‘the world of Geeks’, ‘GeeksforGeeks’]
[‘Welcome everyone to’, ‘the world of Geeks’, ‘GeeksforGeeks’]
[‘Welcome everyone to\r’, ‘the world of Geeks\n’, ‘GeeksforGeeks’]
代码＃2
string = “Cat\nBat\nSat\nMat\nXat\nEat”
print (string.splitlines( ))
print(‘India\nJapan\nUSA\nUK\nCanada\n’.splitlines())
输出：
[‘Cat’, ‘Bat’, ‘Sat’, ‘Mat’, ‘Xat’, ‘Eat’]
[‘India’, ‘Japan’, ‘USA’, ‘UK’, ‘Canada’]
修改大小写-capitalize（）函数
描述：将字符串的第一个字母变成大写，其余字母变为小写。
语法：str.capitalize() —> str 返回字符串
程序示例：
str1 = "i Love python"
str2 = " i Love python"
str3 = "I Love python"
print(str1.capitalize())
print(str2.capitalize())
print(str3.capitalize())
程序运行结果：
I love python
i love python
I love python
修改大小写-title()函数
描述：返回一个满足标题格式的字符串。即所有英文单词首字母大写，其余英文字母小写。
语法：str.title() -> str 返回一个字符串
程序示例：
str = "i love python"
print(str.title())
程序运行结果：
I Love Python
修改大小写-upper()函数
描述：将字符串中的所有小写字母转换为大写字母。
语法：str.upper() -> str 返回字符串
程序示例：
str1 = "i love python"
str2 = "I Love Python"
print(str1.upper())
print(str2.upper())
程序运行结果：
I LOVE PYTHON
I LOVE PYTHON
修改大小写-lower()函数
描述：将字符串中的所有大写字母转换为小写字母。
语法：str.lower() -> str 返回字符串
程序示例：
str1 = "I Love Python"
str2 = "Groß - α"
print(str1.lower())
print(str2.lower())
程序运行结果：
i love python
groß - α
空格处理-ljust()函数
描述：返回一个原字符串左对齐,并使用fillchar填充(默认为空格)至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。
语法：str.ljust(width, fillchar) -> str 返回一个新的字符串
width —— 指定字符串的输出长度。
fillchar—— 将要填充的单字符，默认为空格。
程序示例：
str = "python"
print(str.ljust(30,"*"))
print(str.ljust(30))
print(str.ljust(30),"1")
程序运行结果：
python************************
python
python 1
空格处理- rjust()函数
描述：返回一个原字符串右对齐,并使用fillchar填充(默认为空格)至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。
语法：str.ljust(width, fillchar) -> str 返回一个新的字符串
width —— 指定字符串的输出长度。
fillchar—— 将要填充的单字符，默认为空格。
程序示例：
str = "python"
print(str.rjust(30,"*"))
print(str.rjust(30))
print("1",str.rjust(30))
程序运行结果：
************************python
python
1 python
空格处理-center()函数
描述：返回一个长度为width,两边用fillchar(单字符)填充的字符串，即字符串str居中，两边用fillchar填充。若字符串的长度大于width,则直接返回字符串str。
语法：str.center(width , “fillchar”) -> str 返回字符串 注意：引号不可省
width —— 指定字符串长度。
fillchar —— 要填充的单字符，默认为空格。
程序示例：
str = "i love python"
print(str.center(20,"*"))
print(str.center(1,"*"))
print(str.center(20,"8"))
print(str.center(20))
程序运行结果：
***i love python****
i love python
888i love python8888
i love python
空格处理–strip()函数
描述：从字符串str中去掉在其左右两边chars中列出的字符。
注：chars传入的是一个字符数组，编译器去除两端所有相应的字符，直到出现第一个在chars中不匹配的字符。详看示例。
语法：str.strip(chars) -> str 返回一个新的字符串
chars —— 要去除的字符 默认为空格或换行符。
#字符串函数-strip
str = "123456789321"
#strip()从字符串str中去掉在其左右两边chars中列出的字符
#去掉了两边包含123的字符--456789
print(str.strip("123"))
str1 = "my name is ymyyyy"
#去掉了两边包含myis空格的字符--name
print(str1.strip("my is"))
print(str1.strip("my "))
空格处理–lstrip()函数
描述：从字符串str中去掉在其左边chars中列出的字符。
#字符串函数-lstrip
#去掉左边列出的字符，直到遇到第一个在chars中不匹配的字符
str1 = "bacjabck123kluabc"
print(str1.lstrip("abc"))
str2 = "12578asdfgh12"
print(str2.lstrip("12"))
空格处理-rstrip（）函数
描述：从字符串str中去掉在其右边chars中列出的字符。
#字符串函数-rstrip
#去掉右边列出的字符，直到遇到第一个在chars中不匹配的字符
str1 = "bacjabck123kluabc"
print(str1.rstrip("abc"))
str2 = "12578asdfgh12"
print(str2.rstrip("12"))
字符串拼接-join()函数
join()： 连接字符串数组。将字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串
语法： ‘sep’.join(seq)
参数说明
sep：分隔符。可以为空
seq：要连接的元素序列、字符串、元组、字典
上面的语法即：以sep作为分隔符，将seq所有的元素合并成一个新的字符串
返回值：返回一个以分隔符sep连接各个元素后生成的字符串
#对字符串进行操作
>>> seq2 = "hello good boy doiido"
>>> print ':'.join(seq2)
h:e:l:l:o: :g:o:o:d: :b:o:y: :d:o:i:i:d:o