Python中的容器

容器（字符串, 列表 ,元组 ，字典 ）

1.字符串

定义：使用引号(单引号,双引号,三引号)引起来的内容就是字符串

# 列子
my_str = 'hello'
print(type(my_str), my_str)

字符串本身包含单引号,在定义的时候,我就是想使用单引号

使用 \ 转义字符,将字符串本身的引号进行转义 \' --> ' \" --> "

my_str6 = 'I\'m 小明'
print(my_str6)
# 5.2 字符串  I\'m 小明  \\ --> \
my_str7 = 'I\\\'m 小明'
print(my_str7)

在字符串前边加上 r"" 原生字符串, 字符串中 的\不会作为转义字符

my_str8 = r'I\'m 小明'
print(my_str8)  # I\'m  小明

下标

下标（索引）：就是指字符在字符串中的位置编号，这个编号就是下标
这个编号一般来说都是从左到右进行编号，从0开始的（python可以从右到左进行编号，从-1开始）
作用：可以使用下标获取字符串中某个位置的字符
语法：
字符串[下标] # 获取指定位置的字符
获取字符串的长度 len(字符串)

# 定义字符串
str1 = 'abcdefg'
# 1. 打印输出字符串中第一个字符, 下标为 0
print(str1[0])  # a
# 2. 打印输出字符串中 最后一个位置的字符, 下标是 -1
print(str1[-1])  # g

# len(容器)  获得容器中数据的长度(元素数据的个数)
num = len(str1)   # 7
print(num)
# 要求: 使用正数下标表示字符串中最后一个元素
print(str1[num-1])   # g

切片

切片：可以获取字符串中多个字符（多个字符的下标是有规律的）
语法：
字符串[start:end:step]
start是开始位置的下标，end是结束位置的下标（不能取到这个位置的字符）
step步长，等差数列的差值，所取的相邻字符下标之间的差值，默认是1，可不写
例：[1:5:1] # 1 2 3 4
[1:5:2] #1 3
[1:5:3] #1 4
[1:5:4] #1

# 定义字符串
my_str = 'abcdefg'
# 获取字符串中 abc 这三个字符, 0 1 2  开始 0, 结束 3, 步长 1
print(my_str[0:3:1])  # abc
# 步长是 1, 可以不写
print(my_str[0:3])  # abc
# 开始位置是 0, 可以不写,但是冒号需要
print(my_str[:3])  # abc

# 获取字符串中 efg 这三个字符, 4 5 6 . 开始 4 结束 7, 步长 1
print(my_str[4:7])  # efg
# 如果要取到字符串中最后一个字符,则结束位置可以不写
print(my_str[4:])   # efg

# 获取字符串中 ace 这三个字符, 024 开始 0, 结束 5, 步长 2
print(my_str[0:5:2])   # ace
print(my_str[:5:2])   # ace

# 开始 0, 结束取到最后 步长 3 , 0 3 6
print(my_str[::3])  # adg

# 补充, 步长可以是负数,但一般不用,步长为负数时,只有一种需求
# 反转字符串,倒序逆置字符串
print(my_str[::-1])  # gfedcba

find查找方法

用法：
字符串.find(sub_str,start,end)
作用：在字符串中查找是否存在sub_str这样的字符串
sub_str :要查找的字符串
返回（代码执行之后会得到什么，如果有返回，就可以使用变量保存）：
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替换方法

字符串.replace(old_str,new_str,count) # 将字符串中old_str替换为new_str
count:替换的次数，一般不写默认全部替换
返回：替换之后的完整的字符串，注意：原来的字符串没有发生改变

my_str = 'good good study'
# 将 good 全部替换为 GOOD
my_str1 = my_str.replace('good', "GOOD")
print('my_str :', my_str)
print('my_str1:', my_str1)

split拆分方法

字符串.split(sep,maxsplit) #将字符串按照sep进行分割（拆分）
sep：字符串按照什么进行拆分，默认是空白字符（空格 ，换行\n,tab键\t）
max_split,分割次数，一般不写就是全部分割
返回：将一个字符串拆分为多个，存在列表中
注意：如果sep不写，想要指定分割次数则需要按照如下方式使用
字符串.split(maxsplit=n) #n是次数

my_str = 'good good study day day up'
# 将字符串中的每个单词拆开
result = my_str.split()
print(result)  # ['good', 'good', 'study', 'day', 'day', 'up']

my_str1 = "hello world and itcast and itheima and Python"
# 按照 and 字符串 进行切割
result2 = my_str1.split('and')
print(result2)   # ['hello world ', ' itcast ', ' itheima ', ' Python']

join连接方法

字符串.join(列表) #括号中的内容主要是列表，可以是其他容器
#作用：将字符串插入到列表中每相邻的两个数据之间，组成一个新的字符串
-列表中的数据使用逗号隔开
-注意：列表中的数据必须都是字符串，否则会报错

my_list1 = ['good', 'good', 'study', 'day', 'day', 'up']
# 将列表中每个数据(单词)使用 _ 连接成一个字符串
str2 = '_'.join(my_list1)
print(str2)

2.列表

列表list是使用最多的一种容器（数据类型），列表中可以存储多个数据，每个数据之间使用逗号隔开，列表中可以存放任意类型的数据

# 列表的定义
# 方式一:  使用类实例化的方式
my_list1 = list('hello')  # 将字符串 hello 中的每个字符作为一个数据存储到列表中
print(my_list1)  # ['h', 'e', 'l', 'l', 'o']
# 方式二 直接使用 [] 进行定义
# 变量 = [数据, 数据, 数据, ...]
list2 = [18, '小明', 3.14, True]
print(list2)

列表的下标和切片

列表支持下标和切片操作,使用方法和字符串中的使用方法一致
区别:列表的切片得到的是列表

# 定义列表
my_list = ['小明', 18, 170.8, 3.14, True]
# 打印 '小明', 即 取 下标为 0 的数据
print(my_list[0])
# 打印 18
print(my_list[1])
# 打印 '小明' 和 18
print(my_list[0:2])   # ['小明', 18]
# 获取 列表中数据的个数, 长度
num = len(my_list)
print(num)  # 5

列表的查找

• 查找列表中数据下标

在字符串中使用的find方法查找下标的,不存在返回的是-1.
在列表中没有find方法,想要查找数据的下标,使用的index()方法
​
列表.index(数据,start,end) 使用和find方法一样
区别:返回,index()方法,找到返回第一次出现的下标,没有找到代码直接报错

my_list = ['小明', 18, 170.8, 3.14, True]
# index() 查找下标
# 查找 18 所在的下标
num = my_list.index(18)
print(num)  # 1

# 统计出现的次数  count()
num3 = my_list.count(18)
print(num3)  # 1
num4 = my_list.count(19)
print(num4)  # 0

数据添加

• 尾部添加

列表.append(数据) #将数据添加到列表的尾部
返回:返回的None(关键字,空),一般就不再使用变量来保存返回的内容
想要查看添加后的列表,需要打印的是列表

• 指定下标位置添加

列表.insert(下标,数据) #在指定的下标位置添加数据,如果指定的下标位置本来有数据,原数据会后移
返回:返回的None(关键字,空),一般就不再使用变量来保存返回的内容
想要查看添加后的列表,需要打印的是列表

• 列表合并

列表1.extend(列表2) # 将列表2中的所有数据逐个添加的列表1的尾部
返回:返回的None(关键字,空),一般就不再使用变量来保存返回的内容
想要查看添加后的列表,需要打印的是列表

# 列表的添加
my_list = []
print(my_list)
# 1.向列表中添加数据
my_list.append('软件测试')
print(my_list)
# 2.在下标为1的位置添加数据
my_list.insert(1,'软件管理')
print(my_list)
# 3.定义新列表
list1 = ['软件工程导论','SSM']
# 4.将list1中的数据逐个加入到my_list表中
my_list.extend(list1)
print(my_list)  # ['软件测试', '软件管理', '软件工程导论', 'SSM']

修改操作

语法:
列表[下标]=数据
#字符串中字符不能使用下标修改

# 定义列表
my_list = [1,2,3,4]
# 将下标为1的数据进行修改
my_list[1] = 20
print(my_list)  # [1, 20, 3, 4]
# 如果指定的下标不存在, 会报错的
# my_list[10] = 10  # 代码会报错

删除操作

• 根据下标删除

列表.pop(下标) # 删除指定下标位置对应的数据
1.下标不写，默认删除最后一个数据
2.书写存在的下标，删除对应下标位置的数据
返回：返回删除的数据

• 根据数据值删除

列表.remove（数据值）
返回：None
注意：如果删除的数据不存在，会报错

• 清空数据

列表.clear()

# 列表的删除
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# 删除最后一个数据
num = my_list.pop()
print('删除的数据是：', num)
print(my_list)
# 删除下标为1的数据
num1 = my_list.pop(1)
print('删除的数据是：', num1)
print(my_list)
# 删除数据7 如果数据存在多个则删除第一个数据，不存在则报错
my_list.remove(7)
print(my_list)
# 清空列表
my_list.clear()
print(my_list)

列表的反转

字符串中反转倒置: 字符串[::-1]
列表中反转和倒置:
1.列表[::-1] #使用切片的方法,会得到一个新列表,原列表不会发生改变
2.列表.reverse() #直接修改原列表,返回None

# 列表的反转和倒置
my_list = [1,2,3,4,5,6]
# 使用切片法
list1 = my_list[::-1]
print(list1)  # [6, 5, 4, 3, 2, 1]
print(my_list)  # [1, 2, 3, 4, 5, 6]
# 使用reverse方法
my_list.reverse()
print(my_list)  # [6, 5, 4, 3, 2, 1]

列表的复制

将列表中的数据复制一份，给到一个新的列表
#适用场景：有一个列表，需要修改操作列表中的数据，修改之后，需要和元数据进行对比，即原数据不能改变
1.使用切片
变量 = 列表[:]
2.使用copy方法
变量 = 列表.copy

# 列表的复制
# 切片法
my_list = [1, 2, 3]
list1 = my_list[:]
print('my_list', my_list)
print('list1:', list1)
# copy方法
list2 = my_list.copy()
print('my_list:', my_list)
print('list2:', list2)

列表的排序

一般来说都是对数字进行排序
列表.sort() #按照升序排序，从小到大
列表.sort(reverse=True) #降序排序，从大到小

# 列表的排序
my_list = [1,5,8,9,2,4,6]
# 升序
my_list.sort()
print('my_list:', my_list)  # my_list: [1, 2, 4, 5, 6, 8, 9]
print('*' * 30)
# 降序
my_list.sort(reverse=True)
print('my_list:', my_list)  # my_list: [9, 8, 6, 5, 4, 2, 1]

3.元组

元组:tuple,元组的特点和列表非常相似

1.元组中可以存放任意类型的数据

2.元组可以存放任意多个数据

区别：

1.元组中的数据内容不能改变，列表可以

2.元组使用（），列表使用[]

应用：在函数的传参或者返回值中使用，保证数据不会被修改

语法：

1.使用类实例化的方式

2.直接使用()方式

常用的方法：
由于元组中的数据不能修改,所以只有查看的方法
1.在元组中也可以使用下标和切片获取数据
2.在元组中存在index方法,查找下标,如果不存在,会报错
3.在元组中存在count方法,统计数据出现的次数
4.在元组中可以使用in操作,判断数据是否存在
5.len()统计个数
以上方法的使用和列表中一样的

# 1. 可以定义空元祖, 但是一般不定义, 因为元组中的数据不能改
# 2. 使用 (数据, 数据, ...) 定义元组
my_tuple = (18, 3.14, 'hello', True)
print(type(my_tuple),my_tuple)  # <class 'tuple'>
# 3. 定义只有一个数据的元组, 数据后边必须有一个逗号
# 变量 = (数据,)
a = (12,)
print(type(a), a)  # <class 'tuple'> (12,)
for i in my_tuple:
    print(i)
# 可以将列表转换为元组
my_tuple2 = tuple([1,2,3])
print(my_tuple2)
print(my_tuple2[1])

4.字典

1.字典dict,字典中的数据是由键(key)值(value)对组成的(键表示数据的名字,值就是具体的数据)

2.在字典中一组键值对是一个数据,多个键值对之间使用逗号隔开

变量={key:value,key:value,...}

3.一个字典中的键是唯一的,不能重复的,值可以是任意数据

4.字典中的键一般都是字符串,可以是数字,不能是列表

# 定义字典
# 1. 使用 类实例化的方法
my_dict = dict()
print(type(my_dict), my_dict)  # <class 'dict'> {}
# dict() 不能转列表和元组,字符串
# 2. 直接使用{} 定义
my_dict1 = {}
print(type(my_dict1), my_dict1)  # <class 'dict'> {}

增加和修改

语法：
字典[键]=数据值
1.键存在，就是修改
2.键不存在，就是添加

# 增加和修改
my_dict1 = {"name": '小明', "age": 18}
# 添加
my_dict1['gender'] = '男'
print(my_dict1)
# 修改
my_dict1['age'] = '20'
print(my_dict1)

删除

del字典[键] or 字典.pop(键)#键必须书写
清空：字典.clear()

my_dict1 = {"name": '小明', "age": 18,"gender": '男', "爱好": ['唱歌', '跳舞']}
# 删除键值对
del my_dict1['gender']
print(my_dict1)
# 删除一个爱好
my_dict1['爱好'].pop(0)
print(my_dict1)
# pop删除 pop('键')
my_dict1.pop('age')
print(my_dict1)
# 清空
my_dict1.clear()
print(my_dict1)

查询

• 使用字典[键]

1.如果键存在，返回键对应的数据值

2.不存在，会报错

• 使用字典.get(键)

字典.get(键，数据值)

1.数据值一般不写，默认是None

返回：

1.键存在，返回键对应的数据值

2.键不存则，返回的是括号中的数据值（None）

my_dict = {'name': '小明', 'age': 18,'爱好':['唱歌', '跳舞']}
# 获取 name 对应的值
print(my_dict['name'])
print(my_dict.get('name'))
# 获取第二个爱好
print(my_dict.get('爱好')[1])

字典的遍历

• 对字典的键遍历

for 变量 in 字典：

print(变量) # 变量就是字典的键

for 变量 in 字典.keys(): # 字典.keys()可以获取字典中所有的键

print(变量)

my_dict = {'name': '小王', 'age': 18, 'sex': '男'}
# 遍历字典的键
for k in my_dict:
    print(k)
for t in my_dict.keys():
    print(t)

• 对字典的值进行遍历

for 变量 in 字典.values(): # 获取所有的值

print(变量)

# 遍历字典的值
for v in my_dict.values():
    print(v)

对字典的键值对进行遍历

for 变量1，变量2 in 字典.items(): # 获取所有的键值对

print（变量1，变量2）#变量1就是键，变量2就是键对应的值

# 遍历键值对
for k, v in my_dict.items():
    print(k, v)

总结

1.字符串，列表，元组支持加法运算

str1 = 'hello'+'world' # ===>helloworld

list1 = [1,2]+[3,4] #===> [1, 2, 3, 4]

tuple1 = (1,2)+(3.4) #===> (1, 2, 3, 4)

2.字符串，列表，元组支持乘一个数字

'hello' * 3 #===>'hellohellohello'

[1,2] * 3 #===> [1, 2, 1, 2, 1, 2]

(1,2) * 3 #===> (1, 2, 1, 2, 1, 2)

3. len()在容器中都可以使用

4. in关键字在容器中都可以使用，注意在字典中判断的是字典的键是否存在