字符串的切片以及操作（Python基础！新手，如有错误，请留言告知）

1.字符串索引切片

• 1.1索引：

s = 'ABCDLSESRF'
s1 = s[0]
print(s1)	# 输出结果为‘A'
s2 = s[2]
print(s2)	# 输出结果为‘C'
s3 = s[-1]
print(s3) 	# 输出结果为'F'
# 字符串的索引0开始，最后一个字符的索引为字符串的长度-1
# 求字符串的长度可以使用len()方法，使用如下：
length = len(s)
print(length)		# 输出结果为10

• 1.2切片一（正着切片）：

[开始索引：结束索引]

s = 'ABCDLSESRF'

s3 = s[0:4]	# 此表达式表示从索引0开始，知道索引4为止，但是不包括索引4，即索引0,1,2,3
print(s3) 	# 输出结果为‘ABCD’

s4 = s[:4]		# 注意，切片前面的0可以省略，与s[0:4] 效果相同
print(s4)	# 输出结果为‘ABCD’

s5 = s[:]	# 当切面的前后都省略不写时，表示索引从0开始，到最后一个元素截止
print(s5)	# 输出结果为‘ABCDLSESRF’

s6 = s[0:]	
print(s6)	# 输出结果为‘ABCDLSESRF’


# 注意：切片的规则为顾头不顾尾

• 1.3切片二（倒着切）

• 切片既然可以正着切，那么也就可以倒着切，在有特殊需要的时候，倒着切也是很关键的。

# 字符串的最后一个元素的索引为-1，倒着数，分别为-1，-2，-3......，与正着切片相同，同样是顾头不顾尾
s = 'ABCDLSESRF'

s1 = s[-3:]
print(s1)	# 输出结果为‘SRF’

s2 = s[-4:-3]
print(s2)	# 输出结果为‘E’

s3 = s[:-4]
print(s3)	# 输出结果为‘ABCDLS’

• 1.4跳着切

#[首：尾：步长]
s = 'ABCDLSESRF'

s1 = s[0:5:2]
print(s1)	# 输出结果为‘ACL’

s2 = s[4:0:-1]	# 此操作表示从0到4，倒着切片
print(s2)	# 输出结果为‘LDCB’

s3 = s[3::-1]
print(s3)	# 输出结果为‘DCBA’

s4 = s[3::-2]
print(s4)	# 输出结果为‘DB’

s5 = s[::-1]
print(s5)	# 输出结果为‘FRSESLDCBA’

s6 = s[-1::-1]
print(s6)	# 输出结果为‘FRSESLDCBA’

• 举个栗子(参考自廖雪峰的官方网站）

# 我们先创建一个A-Z的字符串：
str1 = ‘ABCDEFGHIJKLMNOPQRSTUVWXYZ’

# 取出前10个字母：
print(str1[0:10]	# 输出为‘ABCDEFGHIJ’

# 取出后10个字母:
print(str1[-10:])	# 输出为‘QRSTUVWXYZ’

# 取出前11-20个字母：
print(str1[10:20])	# 输出为‘KLMNOPQRST’

# 前10个数，每两个取一个：
print(str1[:10:2])	# 输出为‘ACEGI’

# 所有数，每5个取一个：
print(str1[::5])	# 输出为‘AFKPUZ’

2.字符串的操作

• 2.1 字符串概念

  字符串是一个容器，包含若干个字符并按照一定的顺序组织成一个整体。字符串支持索引操作。

• 2.2 字符串基本语法

  变量名 = “字符串信息”
  变量名 = ‘字符串信息’
  变量名 = “”“字符串信息”""
  变量名 = ‘’‘字符串信息’’’

• 2.3 字符串操作

  • 2.3.1 in

    格式：str1 in str2
    含义：判断字符串str2是否包含另一个字符串str1，结果是True或False
    举例如下：

    str1 = 'pyt'
    str2 = 'python'
    print(str1 in str2)		# 输出结果为True
    

  • 2.3.2 not in

    格式：str1 not in str2
    含义：判断一个字符串str2是否不包含另一个字符串str1，结果是True或False
    举例如下：

    str1 = 'pyt'
    str2 = 'python'
    print(str1 not in str2)	# 输出结果为False
    

  • 2.3.3 len()

    格式：len(str)
    含义：这是一个python的内置函数，用于获取一个字符串中所包含的字符数量
    举例如下：

    s = 'abcdghf'
    print(len(s))	# 输出结果为7
    

  • 2.3.4 max()/min()

    格式：max(str)/min(str)
    含义：这是python的内置函数，用于获取字符串中排序最大/小的字符
    举例如下：

    s = 'abcdABCD'
    print(max(s))		# 输出结果为'd'
    print(min(s))		# 输出结果为'A'
    

  • 2.3.5 islower()/isupper()

    格式：字符换.islower()/isupper()
    含义：判断字符串是否是全小/大写字母组成，结果是True或False
    举例如下：

    # 判断是否全大写(isupper())：
    str1 = "oK"
    print(str1.isupper())		#输出结果为False
    
    str2 = "OK"
    print(str2.isupper())		#输出结果为True
    
    # 判断是否全小写(islower())
    str3 = "yes"
    print(str3.islower())		#输出结果为True
    
    str4 = "Yes"
    print(str4.islower())		#输出结果为False
    

  • 2.3.6 isdigit()/isalpha()/isalnum()

    格式：字符换.isdigit()/isalpha()/isalnum()
    含义：判断字符串是否是全数字/全字母/全数字字母，结果是True或False
    举例如下：

    # 判断是否是全数字(isdigit())
    str1 = "122abc"
    print(str1.isdigit())   # 输出结果为False
    
    str2 = "12356"
    print(str2.isdigit())   # 输出结果为True
    
    # 判断是否是全字母(isalpha())
    str3 = "@#abc"
    print(str3.isalpha())   # 输出结果为False
    
    str4 = "abcdh"
    print(str4.isalpha())   # 输出结果为True
    
    # 判断是否是全数字字母(isalnum())
    str5 = "()dsds4545"
    print(str5.isalnum())   # 输出结果为False
    
    str6 = "abcdh12145"
    print(str6.isalnum())   # 输出结果为True
    

  • 2.3.7 istitle()

    格式：字符串.istitle()
    含义：检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写
    举例如下：

    str1 = "You are so beautiful"
    print(str1.istitle())   # 输出结果为False
    
    str2 = "You Are So Beautiful"
    print(str2.istitle())   # 输出结果为True
    
    str3 = "you Are So Beautiful"
    print(str3.istitle())   # 输出结果为False
    

  • 2.3.8 startswith()/endswith()

    格式：startswith(字符串)/endswith(字符串)
    含义：判断字符串是否以指定字符串开始/结尾，结果是True或False
    举例如下：

    # 判断字符串是否以指定字符串开始
    str1 = 'beautiful'
    ret = str1.startswith('al')
    print(ret)  	# 输出结果为False
    
    str2 = "yuanhaha"
    ret = str2.startswith("yuan")
    print(ret)		# 输出结果为True
    
    # 对了，startswith()也支持切片判断
    str3 = "bangehouzi"
    ret = str3.startswith('ng',2,5) #从字符串的第2个索引到底5个索引，是否用ng开头
    print(ret)		# 输出结果为True
    
    # 判断字符串是否以指定字符串结尾
    str1 = 'beautiful'
    ret = str1.endswith('fl')
    print(ret)  # 输出结果为False
    
    str2 = "yuanhaha"
    ret = str2.endswith("ha")
    print(ret)  # 输出结果为True
    
    # endswith()同样也支持切片判断
    str3 = "bangehouzi"
    ret = str3.endswith('e',2,5) #从字符串的第2个索引到底5个索引，是否用e结尾
    print(ret)  # 输出结果为True
    

  • 2.3.9 lower()/upper()

    格式：字符串.lower()/upper()
    含义：字符串中所有字母转小写/大写字母，返回一个新的字符串
    举例如下：

    # 全部大写
    str1 = 'pyThOn'
    str2 = str1.upper() 
    print(str1,str2)    # 输出为"pyThOn" "PYTHON"
    
    # 全部小写
    str3 = 'pyThOn'
    str4 = str3.lower() 
    print(str3,str4)    # 输出为"pyThOn" "python"
    

  • 2.3.10 swapcase()

    格式：字符串.swapcase()
    含义：字符串中字母大写转小写，小写转大写
    举例如下：

    str1 = "PytHoN"
    str2 = str1.swapcase()
    print(str2) 	# 输出结果为"pYThOn"
    

  • 2.3.10 title()

    格式：字符串.title()
    含义：字符串中每个单词首字母大写，其余字母小写（区分特殊字符或者数字）
    举例如下：

    str1 = 'yOU ARE sO BEAUtiful'
    str2 = str1.title()
    print(str2)     # 输出结果为"You Are So Beautiful"
    
    str3 = 'fade,cDSazy*w4rDSi0r soDSgDSong node 3'
    str4 = str3.title()
    print(str4)     # 输出结果为"Fade,Cdsazy*W4Rdsi0R Sodsgdsong Node 3"
    

  • 2.3.11 capitalize()

    格式：字符串.capitalize()
    含义：字符串首个字母大写，其余字母小写
    举例如下：

    str1 = 'ban ge hou zi'
    str2 = str1.capitalize() #首字母大写，s1跟s 无关
    print(str2)     # 输出结果"Ban ge hou zi"
    
    str3 = "wa Ha Ha"
    str4 = str3.capitalize()
    print(str4)     # 输出结果"Wa ha ha"
    

  • 2.3.11 strip(str)

    格式：字符串.strip(参数)
    含义：去掉字符串左右两侧在参数字符串中包含的所有字符
    参数的含义：包含了若干个字符的字符串，如果不写参数的话是去空格，默认只能去前后空格
    注意：该方法只能删除开头或是结尾的字符，不能删除中间部分的字符
    举例如下：

    str1 = 'bangehouzi  '
    ret1 = str1.strip()
    print(ret1)		# 输出结果"bangehouzi"
    
    str2 = 'bangehouzi%'
    ret2 = str2.strip('%')
    print(ret2)		# 输出结果"bangehouzi"
    
    str3 = ' %%…………%*bangehouzi%'
    ret3 = str3.strip(' %*')
    print(ret3)		# 输出结果"…………%*bangehouzi"
    
    str4 = "yuanhaha"
    ret4 = str4.strip("a")
    print(ret4)		# 输出结果"yuanhah"
    
    补充：rstrip从右删除，左边不动； lstrip，与rstrip相反
    

  • 2.3.12 ljust (len,str)/rjust (len,str)

    格式：字符串.ljust(len,str)/字符串.rjust(len,str)
    含义：使用指定字符在原始字符串右侧/左侧补充到长度为指定值
    参数：len:补充字符后的字符串长度
    参数：str:补充的字符，如果使用多个字符组成的字符串将报错
    举例如下：

    # 右侧补字符串
    str1 = "houzi"
    ret1 = str1.ljust(10,"6")
    print(ret1)     # 输出结果为"houzi66666"
    
    str2 = "houzi"
    ret2 = str2.ljust(12,"sgs")
    print(ret2)     # 输出结果为报错
    
    str3 = "houzi"
    ret3 = str3.ljust(4,"6")
    print(ret3)     #输出结果为"itcast"
    
    # rjust(len,str)与ljust(len,str)操作相同，结果相反
    

  • 2.3.13 center (len,str)

    格式：字符串.center(len,str)
    含义：使用指定字符在原始字符串两侧补充到长度为指定值，左侧补充数量≥右侧补充数量
    参数：len:补充字符后的字符串长度
    参数：str:补充的字符，如果使用多个字符组成的字符串将报错
    举例如下：

    str1 = "houzi"
    ret1 = str1.center(10,"6")
    print(ret1)     # 输出结果"66houzi666"
    
    str2 = "woaini"
    ret2 = str2.center(11,"6")
    print(ret2)     # 输出结果"666woaini66"
    
    str3 = "houzi"
    ret3 = str3.center(5,"6")
    print(ret3)     # 输出结果"houzi"
    
    str4 = "houzi"
    ret4 = str1.center(10,"66")
    print(ret4)     # 输出结果报错
    

  • 2.3.14 split(str)

    格式：字符串.split(str)
    含义：使用参数作为分割线将原始字符串拆分成若干个字符串并组织成列表返回
    参数：比对字符串
    举例如下：

    str1 = ';ban;ge;hou;zi'
    ret1 = str1.split(';')
    print(ret1)     # 输出结果['', 'ban', 'ge', 'hou', 'zi']
    
    str2 = ' ban ge hou zi'
    ret2 = str2.split()
    print(ret2)     # 输出结果['ban', 'ge', 'hou', 'zi']
    
    str3 = "hello python"
    ret3 = str3.split('0')
    print(ret3)     # 输出结果['hello python']
    注意：空格是默认不需要填写参数,分割时被分割的与元素会取消
    

  • 2.3.15 join(str)

    格式：字符串.join(str)
    含义：将原始字符串填充到参数的每个字符之间组成新的字符串返回
    参数：待填充的字符串
    举例如下：

    str1 = "yuan"
    ret1 = "66".join(str1)
    print(ret1)     # 输出结果"y66u66a66n"
    

  • 2.3.16 find(str,begin,end)

    格式：字符串.find(str,begin,end)
    含义：从左侧查找字符串从指定开始位置到指定结束位置间第一次出现的索引位置
    参数：str:要查找的字符串
    参数：begin:开始索引，整数,该值要小于end，否则结果为-1
    参数：end:结束索引，整数,改制要小于begin，否则结果为-1
    返回值：结果是一个int整数，如没有查找到返回-1
    举例如下：

    str1 = 'bangehouzi'
    ret1 = str1.find('zi')
    print(ret1)     # 输出结果为8
    
    str2 = 'bangehouzi'
    ret2 = str2.find('W')
    print(ret2)     # 输出结果为-1
    
    str3 = "bangehouzi"
    ret3 = str3.find("ge",2,6)
    print(ret3)     # 输出结果为3
    # rfind(str,begin,end) 从右侧查找字符串从指定开始位置到指定结束位置间第一次出现的索引位置，用法与find()相同
    

  • 2.3.17 index(str,begin,end)

    格式：字符串.index(str,begin,end)
    含义：从左侧查找字符串从指定开始位置到指定结束位置间第一次出现的索引位置
    参数：str:要查找的字符串
    参数：begin:开始索引，整数,该值要小于end，否则结果报错
    参数：end:结束索引，整数,改制要小于begin，否则结果报错
    返回值：结果是一个int整数，如没有查找到报错
    举例如下：

    str1 = 'bangehouzi'
    ret1 = str1.index('W')
    print(ret1)     # 输出结果 报错
    
    str2 = "bangehouzi"
    ret2 = str2.index('g')
    print(ret2)     # 输出结果3
    
    str3 = "bangehouzi"
    ret3 = str3.index("g",2,8)
    print(ret3)     # 输出结果3
    # rindex(str,begin,end) 从右侧查找字符串从指定开始位置到指定结束位置间第一次出现的索引位置，用法与index()相同
    

  • 2.3.18 count(str)

    格式：字符串.count(str)
    含义：查询指定字符串在原始字符串中出现的次数
    参数：被查询的字符串
    返回值：结果是一个int整数
    举例如下：

    str1 = 'hello python'
    ret1 = str1.count('o')
    print(ret1)     # 输出结果2
    

  • 2.3.19 replace(old_str,new_str,num)

    格式：字符串.replace(old_str,new_str,num)
    含义：使用新字符串替换原始字符串中的指定字符串信息
    参数：old_str:被替换的字符串
    参数：new_str:新字符串
    参数：num：替换数量
    返回值：结果是一个字符串
    举例如下：

    str1 = "hello python"
    ret1 = str1.replace('o','H',1)
    print(ret1)     # 输出结果"hellH python"
    
    str2 = "hello python"
    ret2 = str2.replace('o','H',2)
    print(ret2)     # 输出结果"hellH pythHn"
    

• 2.4 总结

  • 以上所述的字符串的操作的方法，基本上都是常用的。因本人也是初学python，还有一些没有列举在上 ，在以后的学习中，会慢慢的补充博客，争取做到将大部分可以见到的都一一举例，新手猴子，望大家多多包涵！

• 3 练习题

转载自https://www.cnblogs.com/kateli/p/8612978.html

	# 1. name = 'aleX leNb'
	(1)移除name变量对应的值得两边的空格，并输出处理结果
	(2)移除name变量左边的'al'，并输出处理结果
	(3)移除name变量右边的'Nb'，并输出处理结果
	(4)移除name变量开头的a与最后的b，并输出处理结果
	(5)判断name变量是否已'al'开头，并输出结果
	(6)判断name变量是否已'Nb'结尾，并输出结果
	(7)将name变量对应的值中的所有的'l'替换成‘p’,并输出结果
	(8)将name变量对应的值中第一个的'l'替换成‘p’,并输出结果
	(9)将name变量对应的值根据所有的'l'分割,并输出结果
	(10)将name变量对应的值根据第一个'l'分割,并输出结果
	(11)将name变量对应的值变成大写,并输出结果
	(12)将name变量对应的值变成小写,并输出结果
	(13)将name变量对应的值首字母'a'大写,并输出结果
	(14)判断name变量对应的值得字母'l'出现几次，并输出结果
	(15)判断name变量对应的值前四位字母'l'出现几次，并输出结果
	(16)从name变量对应的值前找到'N'对应的索引，并输出结果
	(17)从name变量对应的值前找到'N'对应的索引(如果找不到则返回-1)，并输出结果
	(18)从name变量对应的值前找到'X le'对应的索引，并输出结果
	(19)请输出name变量对应的值的第二个字符
	(20)请输出name变量对应的值的前3个字符
	(21)请输出name变量对应的值的后2个字符
	(22)请输出name变量对应的值中‘e'坐在索引位置字符
	(23)获取子序列，去掉最后一个字符

	# 2. s = '132a4b5c'
	(1)通过对s的切片形成新的字符串s1,s1 = '132'
	(2)通过对s的切片形成新的字符串s2,s2 = 'a4b'
	(3)通过对s的切片形成新的字符串s3,s3 = '1245'
	(4)通过对s的切片形成新的字符串s4,s4 = '3ab'
	(5)通过对s的切片形成新的字符串s5,s5 = 'c'
	(6)通过对s的切片形成新的字符串s6,s6 = 'ba3'

  	# 3.实现一个整数加法计数器
  		# 如：content = input('请输入内容：') #如用户输入5+9或者5+9或者5+9，然后进行分割在进行计算
  	
  	# 4.计算用户输入的内容中有几个整数，
  		# 如content = input('请输入内容') #如"fhdal234slfh98769fjdla",统计数字的个数
  

• 4答案在此（请做完查看）

# 1.有变量name = "aleX leNb"完成如下操作
# (1)移除name变量对应的值得两边的空格，并输出处理结果
name = 'aleX leNb'
s1 = name.strip()
print(s1)

# (2)移除name变量左边的'al'，并输出处理结果
name = 'aleX leNb'
s2 = name.lstrip('al')
print(s2)

# (3)移除name变量右边的'Nb'，并输出处理结果
name = 'aleX leNb'
s3 = name.rstrip('Nb')
print(s3)

# (4)移除name变量开头的a与最后的b，并输出处理结果
name = 'aleX leNb'
s4 = name.strip('ab')
print(s4)

# (5)判断name变量是否已'al'开头，并输出结果
name = 'aleX leNb'
s5 = name.startswith('al')
print(s5)

# (6)判断name变量是否已'Nb'结尾，并输出结果
name = 'aleX leNb'
s6 = name.endswith('Nb')
print(s6)

# (7)将name变量对应的值中的所有的'l'替换成‘p’,并输出结果
name = 'aleX leNb'
s7 =  name.replace('l','p')
print(s7)

# (8)将name变量对应的值中第一个的'l'替换成‘p’,并输出结果
name = 'aleX leNb'
s8 = name.replace('l','p',1)
print(s8)

# (9)将name变量对应的值根据所有的'l'分割,并输出结果
name = 'aleX leNb'
s9 = name.split('l')
print(s9)

# (10)将name变量对应的值根据第一个'l'分割,并输出结果
name = 'aleX leNb'
s10 = name.split('l',1)
print(s10)

# (11)将name变量对应的值变成大写,并输出结果
name = 'aleX leNb'
s11 = name.upper()
print(s11)

# (12)将name变量对应的值变成小写,并输出结果
name = 'aleX leNb'
s12 = name.lower()
print(s12)

# (13)将name变量对应的值首字母'a'大写,并输出结果
name = 'aleX leNb'
s13 = name.capitalize()
print(s13)

# (14)判断name变量对应的值得字母'l'出现几次，并输出结果
name = 'aleX leNb'
s14 = name.count('l')
print(s14)

# (15)判断name变量对应的值前四位字母'l'出现几次，并输出结果
name = 'aleX leNb'
s15 = name.count('l',0,5)
print(s15)

# (16)从name变量对应的值前找到'N'对应的索引，并输出结果
name = 'aleX leNb'
s16 = name.index('N')
print(s16)

# (17)从name变量对应的值前找到'N'对应的索引(如果找不到则返回-1)，并输出结果'''
name = 'aleX leNb'
s17 = name.find('N')
print(s17)

# (18)从name变量对应的值前找到'X le'对应的索引，并输出结果
name = 'aleX leNb'
s18 = name.find('X le')
print(s18)

# (19)请输出name变量对应的值的第二个字符
name = 'aleX leNb'
s19 = name[1]
print(s19)

# (20)请输出name变量对应的值的前3个字符
name = 'aleX leNb'
s20 = name[0:3]
print(s20)

# (21)请输出name变量对应的值的后2个字符
name = 'aleX leNb'
s21 = name[-2:]
print(s21)

# (22)请输出name变量对应的值中‘e'坐在索引位置字符
name = 'aleX leNb'
s22 = name.index('e')
print(s22)

# (23)获取子序列，去掉最后一个字符
name = 'aleX leNb'
s23 = name[0:-1]
print(s23)

# 2.有字符串s = '132a4b5c'
# (1)通过对s的切片形成新的字符串s1,s1 = '132'
s = '132a4b5c'
s1 = s[0:3]
print(s1)

# (2)通过对s的切片形成新的字符串s2,s2 = 'a4b'
s = '132a4b5c'
s2 = s[3:6]
print(s2)

# (3)通过对s的切片形成新的字符串s3,s3 = '1245'
s = '132a4b5c'
s3 = s[::2]
print(s3)

# (4)通过对s的切片形成新的字符串s4,s4 = '3ab'
s = '132a4b5c'
s4 = s[1:-2:2]
print(s4)

# (5)通过对s的切片形成新的字符串s5,s5 = 'c'
s = '132a4b5c'
s5 = s[-1]
print(s5)

# (6)通过对s的切片形成新的字符串s6,s6 = 'ba3'
s = '132a4b5c'
s6 = s[-3::-2]
print(s6)

# 3.实现一个整数加法计数器
# 如：content = input('请输入内容：') #如用户输入5+9或者5+9或者5+9，然后进行分割在进行计算
content=input('>>>').strip()
index = content.find("+")
a = int(content[0:index])
b = int(content[index+1:])
print(a+b)
# 或者
content=input('>>>').strip()
con1=content.split('+')
num=0
for i in con1:
    num+=int(i)
print(num)

# 4.计算用户输入的内容中有几个整数，如content = input('请输入内容') #如fhdal234slfh98769fjdla,统计数字的个数
s = input('>>>')
count = 0
for i in s:
    if i.isdigit():
        count +=  1
print(count)