字符串：
字符串是容器，因为字符串中可以包含多个字符
定义
使用引号（单引号，双引号，三引号）引起来的内容就是字符串
例如
# 1.使用单引号
my_str1 = 'hello'
print(my_str1,type(my_str1))
# 2.使用双引号
my_str2 = "hello"
print(my_str2,type(my_str2))
# 3.使用三引号
my_str3 = """hello"""
print(my_str3,type(my_str3))
my_str4 = '''hello'''
print(my_str4,type(my_ste4))
# 4.字符串本身包含引号 I`m 小明
# 4.1 字符串本身包含单引号，则在定义的时候不能使用单引号
# 4.2 字符串本身包含双引号，则在定义的时候不能使用双引号
my_str5 = "I`m 小明"
print(my_str5)
# 5. 字符串本身包含单引号，在定义的时候我就是想使用单引号
# 5.1 使用 \ 转义字符，将字符串本身的引号尽心那个 “\”转义
my_str6 = 'I\`m 小明'
print(my_str6)
# 5.2 字符串 I\'m 小明 \\ --> \
my_str7 = 'i\\\'m 小明'
print(my_str7)
# 5.3 字符串前边加上R"" 原生字符串，字符串中的 \ 不会作为转义字符，文件操作会用一下
my_str8 = r'i\'m 小明'
print(my_str8)
my_str9 = r'I\\\'m 小明'
print(my_str9)下标
下标（索引）:就是指字符串中的位置编号，这个编号就是下标
这个编号一般来说都是从左到右进行编号的，从0开始的
（python中支持负数下标，从右到左进行编号的，从-1开始）
下标作用：可以使用下标获取字符串中某个位置的字符
语法：
字符串[下标] # 获取指定位置的字符
str1 = 'abcdefg'
# 1. 打印字符串中最开始位置的字符
print(str1[0]) # a
# 2. 打印最后一个位置的数据
print(str1[-1]) # g
# 3. 打印倒数第二个位置的字符
print(str1[-2]) # f
# 打印下标为 2 的数据
print(str1[2]) # c
# 获取字符串中字符的个数(获取字符串的长度)
# len(字符串) # length(长度)
num = len(str1)
print(num)
# 长度-1 的下标位置是最后一个字符
print(str1[num-1]) # g 最后一个字符,倒数第一个
print(str1[len(str1)-1]) # g 最后一个字符,倒数第一个
切片
切片：可以获取字符串中多个字符（多个字符的下标是由规律的，等差数列）
语法：
字符串[start:end:step]
start 是开始位置的下标，end 是结束位置的下标（注意，不能取到这个位置的字符），step 步长，就像是你每次跳跃的步长，告诉你每次应该跳过多少个元素来取下一个元素。等差数列的差值，所取的相邻下标之间的差值，默认是 1 ，所以不写
例如：
0 1 2 3 4 5
[1:5:1] # 1 2 3 4
[1:5:2] # 1 3
[1:5:3] # 1 4
[1:5:4] # 1
案例：
# 切片会得到一个字符串，即可以获取字符串中的多个字符
str1 = 'abcdefg'
# 1.获取abc字符
print(str1[0:3:1]) # abc
# 1.1 如果步长是1 可以不写，最后一个冒号也不需要写
print(str1[0:3]) # abc
# 1.2 如果开始位置是 0 ，可以不写,但是冒号必须有
print(str1[:3]) # abc
# 获取efg 字符
print(str1[4:7:1]) # efg
print(str1[-3:7:1]) # efg
# 2.1 如果最后一个字符也要取，可以不写,但是冒号必须有
print(str1[4:]) # efg
# 2.2 如果开始和结束都不写,获取全部内容,但是冒号必须有
print(str1[:]) # abcdefg
# 3. 获取 aceg # 0 2 4 6,所以步长为2
print(str1[0:7:2]) # aceg
print(str1[::2]) # aceg
# 4.特殊应用，步长为负数，开始和结束不写,意思全变,一般不用管，只有一种使用场景
# 反转（逆置）字符串， 字符串 [：：-1]
print(str1[::-1]) # gfedcba字符串的查找方法 find
字符串.find(sub_str,start,end)
作用：在字符串中查找是否存在 sub_str这样的字符串
sub_str：要查找的小的字符串
start：开始位置，从哪个下边位置开始查找，一般不写，默认是0
end：结束位置，查找到哪个下标结束，一般不写，默认是len（）
返回：（代码执行之后会得到什么，如果有返回，就可以使用变量保存）
1.如果在字符串中找到了sub_str，返回sub_str第一次出现的正数下边（sub_str中第一个字符在大字符串中的下标）
2.如果没有找到，返回-1
案例：
str1 = "and itcast and itheima and python"
# 在字符串中查找and
num = str1.find("and")
print(num) # 0
# 在字符串中查找第二个and出现的下标，从第一次出现的后一位开始找
num1 = str1.find('and',num+1)
print(num1) # 11
# 在字符串中查找第三个and出现的下标，从第二次出现的后一位开始找
num2 = str1.find('and',num1+1)
print(num2) # 23
# 在字符串中查找第四个and出现的下标，从第三次出现的后一位开始找
num3 = str1.find('and',num2+1)
print(num3) # -1字符串的替换方法：
字符串.replace(old_str,new_str,count)
# 将字符串中 old_str 替换为 new_str
- old_str : 被替换的内容
- new_str ： 被换为的内容
- count : 替换的次数，一般不写，默认是全部替换
- 返回 ： 替换之后的完整字符串
注意：原来的字符串没有发生改变
案例
str1 = 'good good study'
# 1, 将 str1 中 所有的 g 改为 G
str2 = str1.replace('g', 'G')
print('str1:', str1) # str1: good good study
print('str2:', str2) # str2: Good Good study
# 2. 将 str1 中第一个 good 改为 GOOD
str3 = str1.replace('good', 'GOOD', 1)
print('str3:', str3) # str3: GOOD good study
# 3. 将 str1 中第二个 good 改为 GOOD
# 3.1 先将全部的 good --> GOOD
str4 = str1.replace('good', "GOOD")
# 3.2 再将第一个 GOOD --> good
str4 = str4.replace('GOOD', 'good', 1)
print('str4:', str4) # str4: good GOOD study字符串的拆分split
字符串.split(sep,maxsplit)
# 将字符串按照 sep 进行分割（拆分）
- sep：字符串按照什么进行拆分，默认是空白字符（空格，换行\n，tap键\t）
- max_split：分割次数，一般不写
- 返回：将一个字符串拆分为多个，存到列表中
- 注意：如果sep不写，想要指定分割次数，则需要按照如下方式使用
字符串.split(maxsplit=n) # n 是次数
案例：
str1 = "hello world and itcast and itheima and python"
# 1.将str1按照and字符进行拆分
result1 = str1.split('and')
print(result1) # ['hello world','itcast','itheima','python']
# 2.将str1 按照and 字符进行拆分，拆分一次
result2 = str1.split('and',1)
print(result2) # ['hello world ', ' itcast and itheima and python']
# 3.按照空白字符进行分割
result3 = str1.split()
print(result3) # ['hello', 'world', 'and', 'itcast', 'and', 'itheima', 'and', 'python']
# 4.按照空白字符进行切割，拆分一次
result4 = str1.split(maxsplit=1)
print(result4) # ['hello', 'world and itcast and itheima and python']字符串的链接join
字符串.join（列表) # 括号中的内容主要是列表，也可以是其他容器
# 作用：将字符串插入到列表中每相邻的两个数据之间，组成一个新的字符串
- 列表中的数据使用逗号隔开
- 列表中的数据必须是字符串，否则会报错
案例
list1 = ['good','good','study']
# 1.将列表中的字符串使用空格连接起来
str1 = ' '.join(list1)
print(str1) # good good study
# 2.将列表中的字符串使用and连接起来
str2 = ' and '.join(list1)
print(str2) # good and good and study列表
列表list,是使用最多的一种容器（数据类型）
列表中可以存储多个数据，每个数据之间使用逗号隔开
列表中可以存放任意类型的数据
定义
- 类实例化的方式（不常用）
- 定义空列表（没有任何数据的列表）
- 变量 = list()
list1 = list()
print(type(list1),list) # <class 'list'> [ ]- 类型数据转换list(容器)将其他的容器转换为列表
- 转换字符串会将字符串中的每个字符作为一个数据存入到列表中
list2 = list('hello')
print(type(list2),list2)
# <class 'list'> ['h', 'e', 'l', 'l', 'o']- 直接使用[]进行定义（常用）
- 定义空列表
my_list = []
print(my_list)
# []- 定义非空列表
my_list1 = [1,'小明',3.14,false]
print(my_list1)
# [1, '小明', 3.14, False]列表支持下标和切片，长度
列表支持下标和切片操作，使用方法和字符串中的使用方法一直
区别：列表中的切片得到的是列表
示例：
list1 = ['小明',18,1.71,True]
# 1.获取第一个数据，名字
print(list1[0])
# 2.获取最后一个数据
print(list1[-1])
# 3.获取第一第二个数据
print(list1[0:2]) # ['小明', 18]
# 解释：从索引0开始取，直到索引2为止，但不包括索引2。即索引0，1，正好是2个数据。
# 4.列表页支持len()求长度的，求数据元素个数
print(len(list1)) # 4查找-查找列表中数据下标的方法
在字符串中使用find()方法查找下标，不存在返回的是-1.
在列表中没有find()方法，想要查找数据的下标，使用的是index()方法。
列表.index(数据，start，end) 使用方法和find一样，同时在字符串中也有index方法。
区别：返回，index()方法，找到返回第一次出现的下标，没有找到代码直接报错
查找-判断是否存在
判断容器中某个数据是否存在，可以使用in关键字
数据in容器 # 如果存在返回true，如果不存在，返回false
查找-统计出现的次数
统计出现的次数，使用的是count()方法
列表.count(数据) # 返回 数据出现的次数
案例：
my_list = [1,3,5,7,2,3]
# 找数据3出现的下标
num = my_list.index(3)
print(num) # 1
# 找数据4出现的下标
# num1 = my_list.index(4) # 报错
if 4 in my_list:
num1 = my_list.index(4)
print(num1)
else:
print('不存在数据 4')
# my_list.count(4)统计 数据 4 出现的次数
if my_list.count(4) > 0:
num1 = my_list.index(4)
print(num1)
else:
print('不存在数据 4')添加数据的方法：
- 尾部添加（最常用）
列表.append（数据） # 将数据添加到列表的尾部
返回：返回的none(关键字，空)，一般就不再使用变量来保存返回的内容
想要查看添加后的列表，需要打印的是列表
- 指定下标位置添加
列表.insert(下标，数据) # 在指定的下标位置添加数据，如果指定的下标位置本来有数据，原数据会后移。
返回：返回的none（关键字，空），一般就不再使用变量来保存返回的内容
想要查看添加后的列表，需要打印的是列表
- 列表合并
列表1.extend(列表2) # 将列表 2 中的所有数据逐个添加到列表1的尾部
返回：
返回的none（关键字，空），一般就不再使用变量来保存返回的内容
想要查看添加后的列表，需要打印的是列表
案例：
my_list = []
print(my_list) # []
# 1.向列表中添加数据，郭德纲
my_list.append('郭德纲')
print(my_list) # 郭德纲
# 2.向列表的尾部添加郭麒麟
my_list.append('郭麒麟')
print(my_list) # ['郭德纲', '郭麒麟']
# 3.在下标位置为 1 的位置添加数据 月月
my_list.insert(1,"月月")
print(my_list) # ['郭德纲', '月月', '郭麒麟']
# 4.在下标位置为1 的位置添加数据 于谦
my_list.insert(1,"于谦")
print(my_list) # ['郭德纲', '于谦', '月月', '郭麒麟']
# 5.定义新的列表 list1
list1 = ['孙悦','烧饼']
# 将list1 中数据逐个添加到My_list中
my_list.extend(list1)
print(my_list) # ['郭德纲', '于谦', '月月', '郭麒麟', '孙悦', '烧饼']
# 6. 将list1 作为一个整体添加到my_list
my_list.append(list1)
print(my_list) # ['郭德纲', '于谦', '月月', '郭麒麟', '孙悦', '烧饼', ['孙悦', '烧饼']]
