第四节 字符串综合

掌握内容

• 了解什么是序列
• 掌握字符串的输入
• 字符串格式化
• 字符串索引
• 会使用切片 (掌握3种即可)
• 了解常见函数 (熟悉)

1. 序列概述

1. 序列是存放 多个值的连续内存空间、 并且按一定顺序排序, 每个值(称为元素)、每个元素的位置、都会分配一个数字,称为索引,

2. 通过索引可以取出相应的值、

   • 例如： 把酒店看作一个序列, 那么酒店里的 每个房间 都可以看作这个 序列的元素。
   • 而其中的房间号就 相当于索引、可以通过房间号找到对应的房间。

3. 在Python中、 序列结构主要有 列表、元组、集合、字典、字符串。

2 字符串的定义

1. 定义字符串的格式有三种形式：

   • 单引号

   	# 格式1: 单引号
   		name = '王一博'
   

   • 双引号

   	# 双引号
   		name = "王一博"
   

   • 扩展: 三引号, 可以自由变化输出格式

   	#三引号
   		name = '''王一博'''
   	 
   	# 三引号的定义什么样,输出就什么样? 是一种有格式的.
   		name_2 = '''
   					i ma 
   					王一博
   				'''
   

2.1 转义字符

1. 在Python中，转义字符用反斜杠（\）表示。 以下是一些常用的转义字符：

   • 换行符 \n
   • 制表符 \t
   • 单引号 \'
   • 双引号 \"

2. 转义字符的使用

   • 如何输出单引号

   	# 想输出的带上字符串格式的, 只需要使用双引号,里面包含单引号即可.
   		name= " 我是'王一博' "
   		print(name) # 输出格式为: 我是'王一博'.
   		name_1 ='是我 "王一博" '
   		print(name_1) #只要不一样都可以.
   

   • 如果在双引号中输出单引号是可以的，但是如果在单引号中输出单引号呢？
   • 这就需要使用转义字符 \

   # c = '你好我是  '王一博'' 这样的形式是错误的?
   	c = '你好,我是  \'王一博\' '
   	c_1 = "你好,我是  \"王一博\" "
   	print(f"转义字符输出格式:{c}和 {c_1}")
   

3. 其他字符使用

   print("Hello\nWorld") #回车
   print("Name:\tJohn") #制表符
   

3. 字符串的输入和输出

1. 从控制台接收一个 输入，它的类型就是字符串。
   • 使用的函数是 input()
   • 注意: 如果想使用其他类型的需要转换格式. 如: 将输入的 字符串类型转换为int()

   """
   1. 字符串的输入和输出
       输入需要是使用 input的函数
           注意输入的类型是 string 类型.
   """
   
   # 1. 从控制台输入姓名,输入类型是 string 类型
   	name = input("请输入姓名: ")
   	print(type(name)) # 查看数据类型 type()
   	print(name)
   
   #2. 从控制台输入一个年龄,(需要注意年龄的数据类型应该是整形)
   	age = int(input("请输入年龄 : ")) # 通过使用int()数据类型转换将str类型转为int类型
   	print(type(age)) # 查看数据类型 type()
   	print(age)
   

3.1 格式化字符串

1. 格式化的意思是先制定一个模板, 在模板上预留一些空位, 然后在上面填写相应的内容

   • 这些内容需要使用 占位符的方式
   • %s 字符串占位符
   • %d 整数占位符
   • %f 浮点 占位符

   name = "王一博 "
   age = 18
   
   #第一种输出方式
   	print(name,age)
   # 第二种 单个占位符输出
   	print("名字%s"%name)
   #第三种  多个占位符输出
   	print("我的名字%s,我的年龄%d"%(name,age))
   

2. 字符串格式化方法 format() 的简化版

   • f"{}" 基本语法格式如下

   # 字符串格式化 f"{},{}"
   #第二种输出方式 字符串格式化 保留位数{age:.2f}两位
   	print(f"我是,{name},我的年龄,{age}")
   

4. 字符串索引 和 切片

4.1 字符串的索引

1. 字符串中的每个字符都有 、可以使用正索引（从0开始）或负索引（从字符串末尾开始，-1表示最后一个字符）。
   

2. 字符串[索引] 来获该索引位置的字符.

   • 正数索、引从0开始 从前往后
   • 负数索引、从 -1 开始 从后往前 、为了防止与第一个元素重合。

   str = "hello,world!"
   #查看索引长度
   	print(len(str)) #12
   
   #1.正数索引0开始, 从前往后
   #print(str[0])
   	for i in range(0,12):
   	    print(str[i])
   
   print("-"*18)
   #2.负数索引-1开始,从后往前
   #print(str[-1]) # !
   	for x in range(-1, -13,-1):
   	    print(str[x])
   
   

3. len()方法 使用

   • len(字符串)方法是 获取字符串的长度

   """
   1. 字符串的下标是从零开始的.
       为什么会有脚标,下标,索引 ,index这么多称呼
       主要是翻译问题, 翻译文献导致每个翻译词汇不同,但指的是一个意思
   
       常用格式
           字符串[索引]  # 根据字符串索引, 来获取该字符.
           len(字符串)  获取字符串的长度
   """
   
   s = "helo "
   a= s[0] # 从零开始,通过索引获取字符.
   b= len(s) # 空格也算位置.
   print(a,b)
   
   

4. 扩展知识 ：

   • 字符串最大长度

	s = "helo "
	# 可以得知一个字符串最大索引是?
		print(int(len(s)-1))   #相当于字符串的最大长度-1

4.2 切片语法结构

1. 切片操作 是访问序列中元素 的另一种方法, 它可以访问一定范围内的元素、通过切片操作可以 生成一个新的序列。
   2.字符串切片指的是从一个字符串中选取一部分子串的操作.
   • 可以理解为 截取字符串.
   • 需要通过 索引 实现
2. 注意事项： 包左不包右。 中间使用 : 冒号隔开.

   	name[start:end:step]
   

   • 其中 name 表示要进行切片的字符串名称，start 表示起始索引（默认为 0），end 表示结束索引（默认为字符串的长度），step 表示步长（默认为 1）。
3. 举例来说， 假设有一个字符串 s = "Hello, world!"，如果我们想要选取其中的子串 "Hello"，可以这样操作：

   	s[0:5]
   

   • 这里的 0 表示起始索引，5 表示结束索引，注意结束索引是不包含在选取的子串中的,即包左不包右。运行结果为 "Hello"。

4.3 切片几种用法

1. 字符串切片，操作还支持快捷语法，如果不指定起始索引和步长，

   • 可以直接写成 string[:end]
   • 或string[start:]
   • 或者string[:]

2. 字符串 [start : end]

   • 字符串的切片 就是使用 索引实现.
   • len()方法,计算字符串的长度.

   # 第一种写法
   	s = "hello,world" #字符串索引下标从0开始.
   # s[start:end]
   a = s[0:5] # 相当于 [1:5) 包左不包右
   	print(a) # 输出结果: ello
   #2. 字符串的长度 len()方法的使用.
   	print(len(s)) #从1开始计算.
   

3. 字符串 [start : end : step]

   • step 就是计算间隔.

   #2. 第二种写法 s[start:end:step] 其中step 是 计算间隔
   	s = "hello,world"
   	a = s[0:8:2] #从0开始到8结束(不包含8 ) [0:8),中间间隔为2
   #相当于 0 2 4 6.
   	print(a)# hlow
   
   

4. 可以将切片语法结构中部分省略.

   • s[ :end] 即: 从0开始
   • s[start: ] 即: 从start开始到索引长度结束 len(s)-1

   #3. 种写法可以省略
   # 切片,以某个索引结尾.
   	print(f"输出的是什么{s[:5]}") #相当于 [0:5)  相当于从零开始.
   # 切片 ,从头开始...
   	print(f"输出的是什么{s[3:]}")# 相当于 [3:end)  相当于从3开始 len(s)-1 结束.
   

5. 将切片中语法结构都省略不写

   • s[ : : ] 省略了start end step 相当于全部输出.

   #第4种 省略语法结构 
   	s = "hello,world"
   	a = s[::] #相当于全部输出
   	
   	print(a) #hello,world
   

6. 反转字符串输出

   • s[: : -1] 倒着输出

   	#5. 反转写法
   		s = "hello,world"
   		print(f"反转格式 {s[::-1]}")  # dlrow,olleh ,相当于从后面开始取.
   

7. 负数取值法

   • 最后一位就是 -1 ,相当于从后往前找

   #6. 负数取值法
   # 分析一波, s = "hello,world" 相当于从后往前寻找.  从-4开始: 从后面开始数d, 然后到-1结束
   # 相当于从后面数,  -1 就是最后一位,  -4 就是往前面数位数. [-4,-1)  也是一样的道理
   	s = "hello,world"
   	print(f"反转格式{s[-4:-1]}") #orl
   

5. 字符串函数的常用操作

5.1 拼接字符串

1. 使用 + 号将两个字符串进行拼接
   • 字符串和字符串拼接
   • 字符串和数字类型拼接
   • str()函数使用

   '''
   1. 拼接字符串、+号使用
       1.1 字符串和字符串拼接
       1.2 字符串和数字类型拼接
   '''
   # 1.字符串拼接字符串
   	str_info = "good good study,day day up"
   	str_1 = "好好学习,天天向上"
   
   # 1.1. 拼接字符串
   # str_2 = str + str_1
   	str_2 = str_info + "\t" + str_1  # 使用转义字符
   	print(str_2) # good good study,day day up	好好学习,天天向上
   
   # 1.2. 字符串拼接其他类型
   	str1 = "我今天走了"
   	num1 = 10000
   	str2 = "步!"
   
   #TypeError: can only concatenate str (not "int") to str
   #say = str1 + num1 + str2
   #print(say)  # 会抛出异常
   
   #1.2.1 需要转换类型  str()函数
   	say_1 = str1 + str(num1)+ str2
   	print(say_1)#我今天走了10000步!
   
   

5.2 查找字符串

5.2.1 find()函数

1. find()函数用于检测字符串中 是否包含子字符串。

   • 如果包含子字符串 则返回 第一个字符开始 的索引值。
   • 如果 没有查询到 则返回 -1

   #1.语法格式 
   	str_1.find(sub_str,start,end)
   

   • sub_str :要查找的内容, 类型str (必选参数)
   • start : 从开始位置, 默认是 0 (可选参数)
   • end : 结束的位置, 查找到哪里结束 (可选参数)

2. 查找函数的使用。

   #1.find 函数 
   	s = "12345678"
   	a = s.find("456")
   	print(a) # 如果包含则返回开始的索引值 3
   
   #第二种写法
   	b = s.find("345",1,6)
   	print(b) # 开始索引 2
   
   #如果没有查到则返回  -1 
   	c = s.find("134")
   	print(c)
   

5.2.2 index() 函数

1. index函数,检测字符串中 是否包含子字符串,

   • 如果有则、返回开始索引。
   • 如果没有、则抛出异常。

   #1. 语法格式 
   	str_1.index(sub_str,start,end)
   

   • sub_str :要查找的内容, 类型str (必选参数)
   • start : 从开始位置, 默认是 0 (可选参数)
   • end : 结束的位置, 查找到哪里结束 (可选参数)

2. index()函数 方法的使用 、其实同 find()函数 方法一样。

   • 不同的则是在返回值上 、没有找到是 抛出异常。

   #创建字符串
   s = "12345678"
   #第1种,写法直接查找 
   	a = s.index("234")
   	print(a) # 返回从1开始
   
   #第2种,写法使用起始位置 、结束位置。
   	b = s.index("234",0,7)
   	print(b)
   
   # 如果没有找到的话,则报错,通find()函数的区别
   	c = s.index("789")
   	print(c) # ValueError: substring not found
   

5.2.3 扩展知识: rfind()和rindex()

1. 相当于从后往前找, 从后面第一次出现的.

   • 二者用法几乎一致.
   • 思考一下: find()函数用的多, 还是 index()用的多 ?

   s = "123456789876"
   print(s.rfind("8")) #9 从后面找第一个出现的
   print(s.find("8")) # 7 从前面找第一个出现的.
   
   print("-"*20) #做一个华丽的分割线
   
   print(s.rindex("8")) #9
   print(s.index("8"))  #7 
   

5.2.4 统计字符串 count()

1. count() 函数是, 用于统计 字符串中某个子字符串出现的次数。

   • 它的语法格式如下：

   # 其中  satrt ,end 属于可选参数.
   	str_1.count(sub,start,end)
   

   • sub： 要查找的子字符串。
   • start：可选参数、查找的起始位置、默认为 0。
   • end：可选参数、查找的结束位置、默认为字符串的长度。

2. count() 函数使用。

   • 起始位置 和 结束位置。

   # 1.count函数的使用方法
   	s = "hello and world and you"
   	print(s.count("and"))  # 出现 2次
   
   #2. 根据起始位置 和 结束位置进行统计.
   	print(s.count("and", 7, 19))  # 出现1次
   #3种写法 只有起始位置
   	print(s.count("and",6))  # 出现2次, 相当于从6开始到结束
   

5.2.5 替换字符串 replace()

1. replace() 方法用来替换字符串中指定子字符串的函数。

   • 替换之后对原始字符串没有影响,会重新生成一个新的字符串.

   #1,语法格式如下 
   # 其中count表示替换的次数 , 1 就是只替换一次,2 就是替换2次
   	str.replace(old, new,count)
   	
   

   • 其中，old 参数表示要被替换的子字符串，new 参数表示替换后的新字符串，count 参数表示 最多替换的次数(如果省略该参数，则表示全部替换。)

2. 两种替换情况 根据可选参数 count 确定

   • 全部替换, count不使用
   • 确定替换次数 , count 使用

   s = "hello and world and you"
   
   # #1. 相当于将 and 全部替换成了 or
   	print(s.replace("and", "or"))
   #2. 部分替换 只替换1次
   	print(s.replace("and","or",1))
   #3.输出查看原来的字符串是否发生改变
   	print(s)
   

5.2.6 分割字符串

5.2.6.1 split() 函数

1. split() 方法, 用来将字符串按照某个分隔符进行分割，

   • 并返回一个分割后的字符串列表。

2. split() 方法有一个可选参数 sep 用来指定分割符

   • 如果不传入任何参数、则默认按照空格分割。
   • 分割后 得到的每一个字符串元素 可以通过索引访问。

   str.split(sep) # 按照格式进行切割 
   str.sprlit() #默认不写就是按照空格切分
   

3. split() 函数方法使用案例。

   # 1.split() 方法使用
   	s = "123,456,789 101112 123 456"
   #1.1 我可以按照逗号切分,返回一个list容器
   	print(s.split(","))
   #1.2 我可以按照空格切分,返回一个list容器
   	print(s.split(" "))
   #1.3 不传递参数 ,按照默(空格)切分
   	print(s.split())
   
   # 2. count可选参数 默认切割几次,
   	print(s.split(",",1)) #对比发现,只对第一个逗号进行切割.
   #2.1 可以按照出现的字符进行切分,了解即可.
   	print(s.split("123"))
   

5.2.6.2 join()函数

1. join() 它可以将一个列表或元组中的多个字符串元素,按照 指定的分隔符 连接成一个 单独的字符串。

   • 可以理解为: 将分隔符与要切割的字符串组成一个新的字符串.

2. join() 方法的语法格式如下：

   str.join(iterable) # 也可以放入 list 列表
   

   • 其中，str 是指定的分隔符，iterable 可以是一个包含多个字符串元素的列表或元组。

3. 练习如下:

   • str.join(列表), 也可以放列表. 然后根据分割符,进行遍历输出, 生成新的字符串.

   # 1.join使用方法介绍
   s = "hello"
   # 1.将原有的字符串进行了遍历.并添加了分隔符.
   new_s = "-".join(s)
   print(new_s)  # h-e-l-l-o
   
   #2.使用空格进行分割了.
   new_s1 = " ".join(s)
   print(new_s1) # h e l l o
   
   #3. 定义一个list列表.,可以切割list->str
   a = ["a","b","c","d"]
   print(a)
   
   #生成了字符串
   #print(type(" * ".join(a)))
   print(" * ".join(a)) # a * b * c * d
   

6 扩展知识

1. capitalize()

   • 把字符串的第一个字符大写,其余首字母小写
   • mystr.capitalize()

   # mystr.capitalize()
   	
   s = "hello,world,Python" 
   print(s.capitalize()) #Hello,world,python 
   

2. title()

   • 把字符串的每个单词首字母大写
   • a.title()

   
    a = "hello world"
    print(a.title())	
    'Hello,World'
   

3. startswith() 是则返回 True，否则返回 False.

   • 检查字符串是否是以 hello 开头
   • 也可以检测 是否以单词开头 h

   	# mystr.startswith(hello)
   	
   	s = "hello,world"
   	print(s.startswith("h"))
   	#也可以使用 单词开头 
   	print(s.startswith("hello"))
   

4. endswith 判断字符串是否以指定后缀结尾.

   • 如果是返回True,否则返回 False.

   str_1 = "hello,world"
   #判断字符串以什么后缀结尾
   print(str_1.endswith("ld")) # True
   

5. lower() 和 upper()

   • 转换 mystr 中,大小写.

   #1.大写变小写
   str_2 ="HELLO,WORLD"
   print(str_2.lower())
   
   #2.小写变大写
   str_1 ="hello,world"
   print(str_1.upper())
   

6. isdigit()字符串中是否有数字,

   • 只有字符串是纯数字时才会返回 True。
   • 字符串中只要包含了其他就会返回 False

   #第一种使用情况
   s = "a1b2c3d4"
   for i in s:
       # s.isdigit() 如果有就输出
       if i.isdigit():
           print(i)
   
   #2第二种，如果包含字母和数字混合
   	print('12345'.isdigit())  # True
   	print('123abc'.isdigit())  # False
   	print('12 34'.isdigit())   # False
   	print(''.isdigit())        # False
   

7. strip()方法是去除字符串首位的空格

   • 注意，只能去除首位，不能去除中间的。

   # 去除首位的空格
   	words = " great! "
   	res = words.strip()
   	print(res)
   

6.1 字符串运算符

1. python中提供了一些适用于字符串运算的符号。

运算符	描述
+	字符串连接
*	重复输出字符串
in	成员运算符。如果字符串中包含给定的字符、返回为True
not in	成员运算符。如果字符串中不包含给定的字符、返回为True

2. in 的使用方法，not 方法相同。

   #in 就是判断子字符串,或者子字符串是否在字符串中.
   string = "banana  Apple  orange"
   if "Apl" in string: #Apple
       print("我喜欢这个水果")
   else:
       print("里面没有我喜欢的")
   

6.2 API 方法总结

7 字符串综合练习

7.1 练习1：常用方法测试

1. 判断单词 great是否在字符串words中，如果在，则将每一个great后面加一个s， 如果不在则输出 great不在该字符串中

2. 将整个字符串的每一个单词都变成小写，并使每一个单词的首字母变成大写

3. 去除首尾的空白，并输出处理过后的字符串

   words = " great craTes Create great craters, But great craters Create great craters "
   
   # 判断单词great是否在这个字符串中
   if 'great' in words:
   	# 将每一个great替换成greats
       words = words.replace("great", "greats")
       # 将单词变成小写
       words = words.lower()
       # 将每一个单词的首字母都大写
       words = words.title()
       # 去除首尾的空白
       words = words.strip()
       # 最后进行输出
       print(words)
   
   else:
       print("great不在该字符串中")
   

7.2 练习2：统计字符串中数字出现次数

1. 接收输入的一行字符， 统计出字符串中包含数字的个数。

   str_1 = input("请输入带数字的字符串： ")
   
   #定义统计变量
   count=0
   #遍历整个输入的字符串
   for i in str_1:
       #判断是否包含数字
       if i.isdigit():
           count+=1
           print(f"出现的数字是{i}")
   
   print(count)#输出数字出现次数
   

7.3 练习3：复制文件名

1. 在日常程序设计中，需要操作文件的复制，将老文件的名称，复制到新文件的名称。
   • 文件类型的获取，和 文件名的拼接，如何解决？

   string = "你好.txt"
   a = string.rfind(".")
   file_name=""
   if a>0:
       new_file= string[a:] # 获取文件类型
       print(new_file)#打印文件类型
       #拼接文件名称
       file_name="复制_"+string[:a]+new_file
   print(file_name)
   

7.4 练习4：计算100以内带3数字和

1. 使用字符串运算符 in 结合循环和分支使用，如何判断含3的数字，这是思考的关键。

   • 注意，类型的转换。

   '''
   求100以内的带3数字的和!
       提示: 带3就算  13  3  31 32...
   '''
   #累计计数
   count=0
   for i in range(1,101):
       #print(i)
       if "3" in str(i):
           #print(i) #输出带3的.
           #累计求和
           count+=i
   #输出结果
   print(count) #792