Python3基本数据结构之字符串(String—不可变数据)

1、字符串创建

字符串创建可以使用引号(单引号''或双引号"")，如：

var1 = 'Hello World'

var2 = "Runoob"

2、字符串值访问

使用方括号[]可以截取字符串的值，

# 字符串截取：使用方括号[]可以截取字符串的值
str1 = 'Kobe is hero'
str2 = "python"
print ("str1[1:3]是：" , str1[1:3]) #字符串截取遵循左闭右开原则，不包括最右边第四个字符
print ("str2[0]是：" , str2[0]) # 输出str2中第一个字符
print ("str2[:3]是：" , str2[:3] ) # 左边从str2中第一个开始输出字符，直至第三个字符
print ("str2[:-4]是：" , str2[:-4] ) # 从右边第四个开始向前数，输出字符
print ("str2[1:-2]是：" , str2[1:-2] ) # 左边从第一个字符开始输出，直至从右边第二个结束

输出：

str1[1:3]是： ob
str2[0]是： p
str2[:3]是： pyt
str2[:-4]是： py
str2[1:-2]是： yth

3、字符串更新

字符串可截取部分字符串与其他字符串拼接

# 字符串更新：
str1 = "hello , wuhan"  # 字符串二次赋值
print (str1)
str1 = str1[0:7] + "kobe" # 字符串更新
print (str1)

hello , wuhan
hello , kobe

4、转义字符

转义字符	描述
\(在行尾时)	续行符
\\	反斜杠符号
\'	单引号
\"	双引号
\a	响铃
\b	退格(Backspace)
\000	空
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车
\f	换页
\oyy	八进制数，yy 代表的字符，例如：\o12 代表换行，其中 o 是字母，不是数字 0。
\xyy	十六进制数，yy代表的字符，例如：\x0a代表换行
\other	其它的字符以普通格式输出

 5、字符串运算符

假如：str1 = "Kobe" ；str2 = "Bryant"

操作符	说明	实例
+	字符串连接	str1 + str2返回KobeBryant
*	字符串重复输出	str1 *2 返回KobeKobe
[]	通过索引截取字符串中字符	str1[0]返回K
[:]	截取字符串中的部分字符，遵循左闭右开原则，str[0:2] 是不包含第 3 个字符的	str1[0:2]返回Ko
in	成员运算符：如果字符串中包含给定的字符返回 True	K in str1返回True
not in	成员运算符 ：如果字符串中不包含给定的字符返回 True	y not in str1返回True
%	格式字符串
r\R	原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。	print(r"hello\nworld")返回hello\nworld

 

 

 

 

 

 

 

 

# 字符串运算符
str1 ,str2 = 'Kobe','Bryant'
print("字符串str1和str2拼接：" , str1 + str2)
print("通过索引截取字符串str1中字符：" , str1[0])
print("截取字符串str1中部分字符：" , str1[0:3])
print("字符串str1重复输出：" , str1 * 3)
print ("判断K在str1中:" , str('K' in str1))
print ("判断H不在str1中:" , str('H' not in str1))
print("不使用原始字符串r：\n" , "hello\nworld")
print("使用原始字符串r：" , r"hello\nworld")

输出：

字符串str1和str2拼接： KobeBryant
通过索引截取字符串str1中字符： K
截取字符串str1中部分字符： Kob
字符串str1重复输出： KobeKobeKobe
判断K在str1中: True
判断H不在str1中: True
不使用原始字符串r：
 hello
world
使用原始字符串r： hello\nworld

6、 字符串格式化

字符串格式化最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中，语法如下：

print ("字符串格式符" % (变量1,变量2,变量3...))

# 字符串格式化输出演练
# 定义字符串变量name、Team、number，输出 我的偶像是科比，洛杉矶湖人队球星，身穿24号球衣
# 定义整型变量student_no，输出 我的学号是007
# 定义浮点型变量price、weight、monkey，输出 我今天买了5.0斤苹果，一斤苹果2.0块钱，一共花了10.0块钱
# 定义一个小数scale，输出 今年比去年增长15.00%
name , Team , number , student_no , price , weight , monkey , scale  = '科比','湖人',24 , 7 , 2 , 5 , 10 , 15.0
print ("我的偶像是%s，洛杉矶%s队球星，身穿%d号球衣" % ('科比','湖人',24))
print ('我的学号是%03d' % student_no)
print ('我今天买了%.2f斤苹果，一斤苹果%.2f块钱，一共花了%.3f块钱' % (weight , price , monkey)) # %.2f表示保留小数点后两位数字
print ('今年比去年增长%.2f%%' % scale)  # %.2f表示保留小数点后两位数字；%%表示输出一个%

输出：

我的偶像是科比，洛杉矶湖人队球星，身穿24号球衣
我的学号是007
我今天买了5.00斤苹果，一斤苹果2.00块钱，一共花了10.000块钱
今年比去年增长15.00%

字符串格式化符号：

符号	说明
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数，%06d表示输出的整数显示位数，不足的地方用0补全
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度，%.2f表示小数点后只显示2位
%e	用科学计数法格式化浮点数
%E	作用同%e，用科学计数法格式化浮点数
%g	%f和%e的简写
%G	%f 和 %E 的简写
%p	用十六进制数格式化变量的地址

 

 

 

 

 

 

 

 

 

 

7、三引号

三引号实现字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符

# 三引号
para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )，
也可以使用换行符 [ \n ]等
"""
print(para_str)

输出：

这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( 	 )，
也可以使用换行符 [ 
 ]等

8、f-string

f-string 是 python3.6 之后版本新添加的，称之为字面量格式化字符串，是新的格式化字符串的语法，f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去，如：

# f-string：字面量格式化字符串，f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去
name = 'Kobe'
print ("我的名字叫 %s" % name)  # 日常用%替换变量
print ("f-string替换变量：我的名字叫"f'{name}') # f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来
w = {'name': 'Runoob', 'url': 'www.runoob.com'}
print (f'{w["name"]}: {w["url"]}')

输出：

我的名字叫 Kobe
f-string替换变量：我的名字叫Kobe
Runoob: www.runoob.com

Python 3.8 以后版本可以使用 = 符号来拼接运算表达式与结果，如：

9、字符串内建函数

str1 = "python is a\tprograming language"

str2 = 'Kobe is 24 , aaaaaabbccdd'

str3 = u'123456789'

str4 = 'abcd'

方法	描述	例子
capitalize()	capitalize()将字符串的第一个字母变成大写,其他字母变小写 语法：str.capitalize()	str4.capitalize() 输出： Abcd
center(width, fillchar)	返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。 语法：str.center(width[, fillchar])	print(str4.center(10,"*")) 输出：***abcd*** print(str4.center(20,"*")) 输出： abcd
count(str, beg= 0,end=len(string))	count() 方法用于统计字符串里某个字符出现的次数，可选参数为在字符串搜索的开始与结束位置。 语法： str.count(sub, start= 0,end=len(string)) 参数：  1、sub -- 搜索的子字符串 2、start -- 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。 3、end -- 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。	str1.count('p') str1.count('p' , 0 , len(str1)) str1.count('p', 0 , 6)
bytes.decode(encoding="utf-8", errors="strict")	decode() 方法以指定的编码格式解码 bytes 对象，默认编码为 'utf-8' 语法： bytes.decode(encoding="utf-8", errors="strict") 参数： 1、encoding -- 要使用的编码，如"UTF-8"。 2、errors -- 设置不同错误的处理方案，默认为 'strict',意为编码错误引起一个UnicodeError。 其他可能的错误提示有 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及通过 codecs.register_error() 注册的任何值。 返回值： 该方法返回解码后的字符串	str1.decode('UTF-8','strict')
encode(encoding='UTF-8',errors='strict')	encode() 方法以指定的编码格式编码字符串，errors参数可以指定不同的错误处理方案 语法： str.encode(encoding='UTF-8',errors='strict') 参数： 1、encoding -- 要使用的编码，如"UTF-8"。 2、errors -- 设置不同错误的处理方案，默认为 'strict',意为编码错误引起一个UnicodeError。 其他可能的错误提示有 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及通过 codecs.register_error() 注册的任何值。 返回值： 该方法返回编码后的字符串，它是一个 bytes 对象	str1.encode('UTF_8' , 'strict')
endswith(suffix, beg=0, end=len(string))	endswith() 方法用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回 True，否则返回 False。可选参数 "start" 与 "end" 为检索字符串的开始与结束位置 语法： str.endswith(suffix[, start[, end]]) 参数： 1、suffix -- 该参数可以是一个字符串或者是一个元素 2、start -- 字符串中的开始位置 3、end -- 字符中结束位置 返回值： 如果字符串含有指定的后缀返回 True，否则返回 False	str1.endswith("python") str1.endswith("python" , 6) str1.endswith("python" , 1 , 43)
expandtabs(tabsize=8)	expandtabs() 方法把字符串中的 tab 符号('\t')转为空格，tab 符号默认的空格数是 8 语法： str.expandtabs(tabsize=8) 参数： tabsize -- 指定转换字符串中的 tab 符号('\t')转为空格的字符数 返回值： 该方法返回字符串中的 tab 符号('\t')转为空格后生成的新字符串	str1.expandtabs() str1.expandtabs(24)
find(str, beg=0, end=len(string))	find() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果指定范围内如果包含指定索引值，返回的是索引值在字符串中的起始位置，如果不包含索引值，返回-1。 语法： str.find(str, beg=0, end=len(string)) 参数： 1、str -- 指定检索的字符串 2、beg -- 开始索引，默认为0 3、end -- 结束索引，默认为字符串的长度 返回值： 如果包含子字符串，返回开始的索引值，否则返回-1	str1.find('lan') str1.find('lan' , 10 , 30) str1.find('com' , 0 , len(str1))
index(str, beg=0, end=len(string))	index() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，该方法与 python find()方法一样，只不过如果str不在 string中会报一个异常 语法：  str.index(str, beg=0, end=len(string)) 参数： 1、str -- 指定检索的字符串 2、beg -- 开始索引，默认为0。 3、end -- 结束索引，默认为字符串的长度 返回值： 如果包含子字符串返回开始的索引值，否则抛出异常	str1.index('lan') str1.index('lan' , 10 , 30) str1.index('com' , 0 , len(str1))
isalnum()	isalnum() 方法检测字符串是否由字母和数字组成 语法：str.isalnum() 返回：如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
isalpha()	Python isalpha() 方法检测字符串是否只由字母或文字组成 语法： str.isalpha() 返回值： 如果字符串至少有一个字符并且所有字符都是字母或文字则返回 True，否则返回 False	str1.isalpha()
isdigit()	isdigit() 方法检测字符串是否只由数字组成 语法： str.isdigit() 返回值： 如果字符串只包含数字则返回 True ，否则返回 False	str1.isdigit()
islower()	islower() 方法检测字符串是否由小写字母组成 语法： str.islower() 返回值： 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False	str2.islower()
isnumeric()	isnumeric() 方法检测字符串是否只由数字组成，数字可以是： Unicode 数字，全角数字（双字节），罗马数字，汉字数字，指数类似 ² 与分数类似 ½ 也属于数字 语法： str.isnumeric() 返回： 如果字符串中只包含数字字符，则返回 True，否则返回 False	str2.isnumeric()
isdecimal()	isdecimal() 方法检查字符串是否只包含十进制字符，这种方法只存在于unicode对象 注意:定义一个十进制字符串，只需要在字符串前添加 'u' 前缀即可 语法： str.isdecimal() 返回： 如果字符串只包含十进制字符返回True，否则返回False	str3.isdecimal()
isspace()	isspace() 方法检测字符串是否只由空白字符组成 语法： str.isspace() 返回值： 如果字符串中只包含空格，则返回 True，否则返回 False	str2.isspace()
istitle()	istitle() 方法检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写 语法： str.istitle() 返回值： 如果字符串中所有的单词拼写首字母为大写，且其他字母为小写则返回 True，否则返回 False	str2.istitle()
isupper()	isupper() 方法检测字符串中所有的字母是否都为大写 语法： str.isupper() 返回值： 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False	str2.isupper()
join(seq)	join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串 语法： str.join(sequence) 参数： sequence -- 要连接的元素序列 返回值： 返回通过指定字符连接序列中元素后生成的新字符串	s1 = '-' s1.join(str2)
len(string)	len() 方法返回对象（字符、列表、元组等）长度或项目个数 语法： len( s ) 参数： s -- 对象 返回值： 返回对象长度	len(str1)
ljust(width[, fillchar])	ljust() 方法返回一个原字符串左对齐,并使用fillchar填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串 语法： str.ljust(width[, fillchar]) 参数： 1、width -- 指定字符串长度。 2、fillchar -- 填充字符，默认为空格 返回值： 返回一个原字符串左对齐,并使用fillchar填充至指定长度的新字符串，如果指定的长度小于原字符串的长度则返回原字符串	str1.ljust(50 , "&") str1.ljust(20 , "&")
lower()	lower() 方法转换字符串中所有大写字符为小写 语法： str.lower() 返回值： 返回将字符串中所有大写字符转换为小写后生成的字符串	str2.lower()
lstrip()	lstrip() 方法用于截掉字符串左边的空格或指定字符 语法： str.lstrip([chars]) 参数： chars --指定截取的字符 返回值： 返回截掉字符串左边的空格或指定字符后生成的新字符串 注意：从左到右移除字符串的指定字符chars，无指定chars或为 None 时移除空格，str 是移除所有属于指定字符chars子串的字符，一旦不属于则停止移除，并返回剩余的字符串	例子： str5 = 'www.example.com' str6 = 'awww.example.com' print(str5.lstrip('cmowz.')) print(str6.lstrip('cmowz.')) 返回： example.com awww.example.com 分析： 只要字符串('cmowz.')中包含的字符，均会被移除，如果第一个字符不包含在'cmowz.'中，就停止移除操作 1、str5中第一个字符是w，包含在'cmowz.'中，所以会被移除，以此类推，直至e不包含在'cmowz.'中，则停止移除，所以结果返回example.com 2、str6中第一个字符是a，不包含在'cmowz.'中，即停止移除，所以结果返回awww.example.com
maketrans(instr , outstr)	maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。 两个字符串的长度必须相同，为一一对应的关系。 注：Python3.4 已经没有 string.maketrans() 了，取而代之的是内建函数: bytearray.maketrans()、bytes.maketrans()、str.maketrans()  语法： str.maketrans(intab, outtab) 参数： 1、intab -- 字符串中要替代的字符组成的字符串 2、outtab -- 相应的映射字符的字符串 返回值： 返回字符串转换后生成的新字符串	1、例子：两个参数 x 和 y，x、y 必须是长度相等的字符串，并且 x 中每个字符映射到 y 中相同位置的字符 instr = 'abcd' #需要替代的字符组成的字符串 outstr = '1234' #替代的字符组成的字符串 transt = str.maketrans(instr , outstr) # 使用maketrans(instr , outstr)函数将'abcd'替换为'1234'，创建字符映射 dict(字典) str7 = 'abcdefg' print("str7替换后的字符串为：" , str7.translate(transt)) 输出： str7替换后的字符串为： 1234ef 2、str.maketrans(x[, y[, z]]) 静态方法 maketrans(instr , outstr)给方法 str.translate() 创建字符映射 dict(字典)： 1)、一个参数，该参数必须为字典 2)、两个参数 x 和 y，x、y 必须是长度相等的字符串，并且 x 中每个字符映射到 y 中相同位置的字符 3)、三个参数 x、y、z，第三个参数 z 必须是字符串，其字符将被映射为 None，即删除该字符； 如果 z 中字符与 x 中字符重复，该重复的字符在最终结果中还是会被删除。也就是无论是否重复，只要有第三个参数 z，z 中的字符都会被删除 例子： # 一个参数，该参数必须为字典 str7 = 'abcdefg' # str8是一个字典 str8 = {'a':'1' , 'b':'2' , 'c':'3' , 'd':'4', 'e':'5'} # 使用maketrans(instr , outstr)函数将'abcde'替换为'12345'，创建字符映射 dict(字典) transt1 = str.maketrans(str8) print("maketrans()仅有一个参数时，该参数必须为字典，str7替换后的字符串为：" , str7.translate(transt1)) 输出： maketrans()仅有一个参数时，该参数必须为字典，str7替换后的字符串为： 12345fg #三个参数时，第三个参数会被删除 str7 = 'abcdefgh' instr = 'abc' outstr = '123' thirdstr = 'd' transt2 = str.maketrans(instr , outstr , thirdstr) print("maketrans()有三个参数时，第三个参数会被删除，str7替换后的字符串为：" , str7.translate(transt2)) 输出： maketrans()有三个参数时，第三个参数会被删除，str7替换后的字符串为： 123efgh
translate(table, deletechars="")	translate() 方法根据参数table给出的表(包含 256 个字符)转换字符串的字符,要过滤掉的字符放到 deletechars 参数中 语法： bytearray.translate(table, delete=b'') bytes.translate(table, delete=b'') str.translate(table) 参数：  1、table -- 翻译表，翻译表是通过 maketrans() 方法转换而来 2、deletechars -- 字符串中要过滤的字符列表 返回值： 返回翻译后的字符串,若给出了 delete 参数，则将原来的bytes中的属于delete的字符删除，剩下的字符要按照table中给出的映射来进行映射	str9 = b'abcdefghijk' instr_1 = b'abcd' #需要替代的字符组成的字符串 outstr_1 = b'1234' #替代的字符组成的字符串 bytes_tabtrans = bytes.maketrans(instr_1 , outstr_1) # 使用maketrans(instr , outstr)函数将'abcd'替换为'1234'，创建字符映射 dict(字典) print("str9过滤掉'd'并替换后的字符串为：" , str9.translate(bytes_tabtrans , b'd')) 输出： str9过滤掉'd'并替换后的字符串为： b'123efghijk'
max(str)	max() 方法返回字符串中最大的字母 语法： max(str) 参数： str -- 字符串 返回值： 返回字符串中最大的字母	max(str2)
min(str)	min() 方法返回字符串中最小的字母 语法： ma小(str) 参数： str -- 字符串 返回值： 返回字符串中最小的字母	min(str2)
replace(old, new [, max])	replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次 语法： str.replace(old, new[, max]) 参数： 1、old -- 将被替换的子字符串。 2、new -- 新字符串，用于替换old子字符串。 3、max -- 可选字符串, 替换不超过 max 次 返回值： 返回字符串中的 old（旧字符串） 替换成 new(新字符串)后生成的新字符串，如果指定第三个参数max，则替换不超过 max 次	str2.replace('a' , 'A' , 5)
rfind(str, beg=0,end=len(string))	rfind() 返回字符串最后一次出现的位置，如果没有匹配项则返回-1，类似于 find()函数，不过是从右边开始查找 语法： str.rfind(str, beg=0 end=len(string)) 参数： 1、str -- 查找的字符串 2、beg -- 开始查找的位置，默认为0 3、end -- 结束查找位置，默认为字符串的长度 返回值： 返回字符串最后一次出现的位置，如果没有匹配项则返回-1	str2.rfind('b' , 0 , len(str2))
rindex( str, beg=0, end=len(string))	rindex() 返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常，可以指定可选参数[beg:end]设置查找的区间 语法：str.rindex(str, beg=0 end=len(string)) 参数： str -- 查找的字符串 beg -- 开始查找的位置，默认为0 end -- 结束查找位置，默认为字符串的长度 返回值： 返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常	str1.rindex('lan') str1.rindex('lan' , 10 , 30) str1.rindex('com' , 0 , len(str1))
rjust(width[,fillchar])	rjust() 返回一个原字符串右对齐，并使用空格填充至长度 width 的新字符串，如果指定的长度小于字符串的长度则返回原字符串 语法： str.rjust(width[, fillchar]) 参数： width -- 指定填充指定字符后中字符串的总长度 fillchar -- 填充的字符，默认为空格 返回值： 返回一个原字符串右对齐，并使用空格填充至长度 width 的新字符串，如果指定的长度小于字符串的长度则返回原字符串	str1.rjust(50 , "&") str1.rjust(20 , "&")
rstrip()	rstrip() 删除 string 字符串末尾的指定字符（默认为空格） 语法： str.rstrip([chars]) 参数： chars -- 指定删除的字符（默认为空格） 返回值： 返回删除 string 字符串末尾的指定字符后生成的新字符串	例子： str5 = 'www.example.com' str6 = 'awww.example.com.cn' print(str5.lstrip('cmowz.')) print(str6.lstrip('cmowz.')) 返回： www.example awww.example.com.cn 分析： 只要字符串('cmowz.')中包含的字符，均会被移除，如果第一个字符不包含在'cmowz.'中，就停止移除操作 1、str5中最后一个字符是m，包含在'cmowz.'中，所以会被移除，以此类推，直至e不包含在'cmowz.'中，则停止移除，所以结果返回www.example 2、str6中最后一个字符是n，不包含在'cmowz.'中，即停止移除，所以结果返回awww.example.com.cn
strip([chars])	strip() 方法用于移除字符串头尾指定的字符（默认为空格）或字符序列 注意：该方法只能删除开头或结尾的字符，不能删除中间部分的字符 语法：str.strip([chars]) 参数： chars -- 移除字符串头尾指定的字符序列 返回值： 返回移除字符串头尾指定的字符序列生成的新字符串	例子： str5 = 'www.example.com' str6 = 'awww.example.com.cn' print(str5.strip('wmco.')) print(str6.strip('cmowz.')) 返回： example.co awww.example.com.cn 分析： 只要字符串('wmco.')中包含的字符，均会被移除，如果第一个字符不包含在'wmco.'中，就停止移除操作 1、str5中第一个字符是w，最后一个字符是m，包含在'wmco.'中，所以会被移除，以此类推，直至e不包含在'wmco.'中，则停止移除，所以结果返回example 2、str6中第一个字符是a，最后一个字符是n，不包含在'wmco.'中，即停止移除，所以结果返回awww.example.com.cn
split(str="", num=string.count(str))	split() 通过指定分隔符对字符串进行切片，如果第二个参数 num 有指定值，则分割为 num+1 个子字符串 语法： str.split(str="", num=string.count(str)) 参数： str -- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等 num -- 分割次数。默认为 -1, 即分隔所有 返回值： 返回分割后的字符串列表	str_10 = 'Apple#Google#Tencent#Ali#Baidu#Bytes' print("以#分割字符串并输出为：" , str_10.split('#' , str_10.count('#'))) 以#分割字符串并输出为： ['Apple', 'Google', 'Tencent', 'Ali', 'Baidu', 'Bytes']
splitlines([keepends])	splitlines() 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符 语法： str.splitlines([keepends]) 参数： keepends -- 在输出结果里是否去掉换行符('\r', '\r\n', \n')，默认为 False，不包含换行符，如果为 True，则保留换行符 返回值： 返回一个包含各行作为元素的列表	str_11 = 'ab c\n\nde fgh\rkl\r\nmyq\tpgfs' print('splitlines()函数keepends参数为空：' , str_11.splitlines()) print('splitlines()函数keepends参数为False：' , str_11.splitlines(False)) print('splitlines()函数keepends参数为True：' , str_11.splitlines(True)) splitlines()函数keepends参数为空： ['ab c', '', 'de fgh', 'kl', 'myq\tpgfs'] splitlines()函数keepends参数为False： ['ab c', '', 'de fgh', 'kl', 'myq\tpgfs'] splitlines()函数keepends参数为True： ['ab c\n', '\n', 'de fgh\r', 'kl\r\n', 'myq\tpgfs']
startswith(substr, beg=0,end=len(string))	startswith() 方法用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查 语法： str.startswith(substr, beg=0,end=len(string)) 语法： str -- 检测的字符串。 substr -- 指定的子字符串。 strbeg -- 可选参数用于设置字符串检测的起始位置。 strend -- 可选参数用于设置字符串检测的结束位置。 返回值： 如果检测到字符串则返回True，否则返回False	str1.startswith("python") str1.startswith("python" , 6) str1.startswith("python" , 1 , len(str1))
swapcase()	swapcase() 方法用于对字符串的大小写字母进行转换 语法： str.swapcase() 返回值： 返回大小写字母转换后生成的新字符串	str2.swapcase()
title()	title() 方法返回"标题化"的字符串,就是说所有单词的首个字母转化为大写，其余字母均为小写 语法： str.title() 返回值： 返回"标题化"的字符串,就是说所有单词的首个字母转化为大写，其余字母均为小写	str2.title()
upper()	upper() 方法将字符串中的小写字母转为大写字母 语法： str.upper() 返回值： 返回小写字母转为大写字母的字符串	str2.upper()
zfill (width)	zfill() 方法返回指定长度的字符串，原字符串右对齐，前面填充0 语法： str.zfill(width) 参数： width -- 指定字符串的长度。原字符串右对齐，前面填充0 返回值： 返回指定长度的字符串	str2.zfill(50)