字符串

• 掌握字符串的输入和输出
• 会使用切片的方式访问字符串中的值
• 了解常见函数

1.1 字符串介绍

1. 什么是字符串?
   • 其实说到字符串，这个概念没有具体的说法，但是我们根据平时的归纳总结，相当于文本类型，
   • 字符串就是把字符连在一直，串成一串又一串；字符串内可以包含数字、字母、特殊符号等所有内容；
   • 在Python中只要对一些内容加上对双引号或一对单引号，就默认为是字符串；

1.2 字符串的定义

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

   • 单引号

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

   • 双引号

   # 双引号
   name = "王一博"
   

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

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

   • 如何输出单引号

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

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

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

1.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)
   

2. 字符串的输出
   • 使用的函数是 print()

   """
   1.字符串的输出有几种形式
       使用的函数是 input()
           直接输出
           字符串格式化 f"{},{}"
           占位符方式   %s 字符串
                      %d  数字
                      %f 小数
               print("我的名字%s"%name)
               print("%s,%d"%(name,age))
   
   """
   
   name = "王一博 "
   age = 18
   
   #第一种输出方式
   print(name,age)
   
   #第二种输出方式 字符串格式化
   print(f"我是,{name},我的年龄,{age}")
   
   
   # 单个占位符输出
   print("名字%s"%name)
   #多个占位符输出
   print("我的名字%s,我的年龄%d"%(name,age))
   

1.3.1 字符串的索引

1. 字符串的每一个字符都是有编号的.

   • 索引, 下标,脚标,index ,为什么有这么多的名称 ?
   • 字符串的索引是从0 开始的.
   • 正数索引从0开始 和 负数索引,从 -1 开始
     

2. len()方法 和 字符串[索引]

   • 字符串[索引] # 根据字符串索引, 来获该索引位置的字符.
     • 正数索引 ,从前往后数
     • 负数索引,从后往前数负数开始时-1.
   • len(字符串)方法是 获取字符串的长度

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

3. 扩展知识 ：

   • 字符串最大长度

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

1.4 字符串切片

1. 在 Python 中，字符串切片指的是从一个字符串中选取一部分子串的操作.

   • 可以理解为 截取字符串.
   • 需要通过 索引 实现

2. 注意事项： 包左不包右。 中间使用 : 冒号隔开.

   	string[start:end:step]
   

   • 其中 string 表示要进行切片的字符串，start 表示起始索引（默认为 0），end 表示结束索引（默认为字符串的长度），step 表示步长（默认为 1）。

3. 字符串切片，操作还支持快捷语法，如果不指定起始索引和步长，可以直接写成 string[:end] 或 string[start:]或者string[:]。

4. 举例来说， 假设有一个字符串 s = "Hello, world!"，如果我们想要选取其中的子串 "Hello"，可以这样操作：

   s[0:5]
   

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

1.4.1 切片几种写法

1. 字符串 [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开始计算.
   

2. 字符串 [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
   
   

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

   • 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 结束.
   

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

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

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

5. 反转输出

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

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

6. 负数取值法

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

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

1.5 字符串常用函数

1.5.1 find()

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

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

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

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

2. find( ) 方法的使用.

   #1.find 函数和 rfind函数的使用
   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)
   

1.5.2 index()

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

   • 如果有则返回开始索引,否则则抛出异常.

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

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

2. index方法的使用

   • 其实同find方法一样.

   s = "12345678"
   a = s.index("234")
   print(a) # 返回从1开始
   
   #第2中写法
   b = s.index("234",0,7)
   print(b)
   
   # 如果没有找到的话,则报错
   c = s.index("789")
   print(c) # ValueError: substring not found
   

1.5.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 
   

1.5.4 count()

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

   • 它的语法格式如下：

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

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

2. count() 语法练习

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

1.5.5 replace()

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

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

   • 它的语法格式如下：

   #1,语法格式如下 
   str.replace(old, new,count])
   

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

3. 两种替换情况 根据可选参数 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)
   

1.5.6 split()

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

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

2. split() 方法有一个可选参数 sep 用来指定分割符，如果不传入任何参数，则默认按照空格分割。

   • 分割后 得到的每一个字符串元素 可以通过索引访问。

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

3. split() ,有两个可选参数
   • count 如果不写,默认全部切分,
   • sep ,按照什么格式进行切分
   • 也可以按照出现重复次数多的字符进行切分.(了解即可)

   # 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"))
   

1.5.7 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
   

1.6 字符串Api 扩展知识

1. capitalize()

   • 把字符串的第一个字符大写
   • mystr.capitalize()

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

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())
   

1.7 练习: 字符串综合练习

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不在该字符串中")