一、数据容器
什么是数据容器？
一种可以存储多个元素的Python数据类型
Python有哪些数据容器？
list(列表)、tuple(元组)、str(字符串)、set(集合)、dict(字典)，它们各有特点，但都满足可容纳多个元素的特性。
二、数据容器：list(列表)
- 列表的定义
列表的定义语法：[元素1, 元素2, 元素3, ......]
元素：数据容器内的每一份数据，都称之为元素
（元素的数据类型没有任何限制，甚至元素也可以是列表，这样就定义了嵌套列表）
# 定义一个列表 list 输出的class类型是list
my_list = ["itheima", "itcast", "python"]
print(my_list)
print(type(my_list))
my_list = ["itheima", 666, True]
print(my_list)
print(type(my_list))
# 定义一个嵌套的列表
my_list = [ [1, 2, 3], [4, 5, 6]]
print(my_list)
print(type(my_list))- 列表的下标索引
下标索引：列表的每一个元素，都有编号称之为下标索引，有从前往后和从后向前
从前向后的方向，编号从0开始递增，从后向前的方向，编号从-1开始递减
语法：列表[下标]，即可取出
注意事项：要注意下标索引的取值范围，超出范围无法取出元素，并且会报错
# 通过下标索引取出对应位置的数据
my_list = ['a', 'b', 'c']
# 列表[下标索引] 从前往后从0开始 从后往前从-1开始
print(my_list[0]) # 输出a
print(my_list[1])
print(my_list[2])
# 从后往前
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])嵌套的索引
- 列表的常用操作
列表的特点：
补充：方法和函数的区别
上面除了len是函数，其他都是list方法
mylist = ['itcast', 'itheima', 'python']
# 1.1 查找某元素在列表内的下表索引(正向)
index = mylist.index('itheima')
print(f'itheima在列表中的下标索引值是：{index}')
# 1.2如果被查找的不存在，则报错功能：查找指定元素在列表的下标，如果找不到，报错ValueError
# index = mylist.index('hello')
# print(f'hello在列表中的下标索引值是：{index}')
# 2.修改特定下标索引的值
mylist[0] = '传智教育'
print(f'列表被修改元素值后，结果是：{mylist}')
# 3.在指定的位置插入新元素
mylist.insert(1, 'best')
print(f'列表插入元素后，结果是：{mylist}')
# 4.在列表的尾部追加单个元素
mylist.append('黑马程序员')
print(f'列表追加元素后，结果是：{mylist}')
# 5.在列表的尾部追加一批新元素（就是新的容器中元素放入到这个mylist当中去）
mylist2 = [1, 2, 3]
mylist.extend(mylist2)
print(f'列表追加一批元素后，结果是：{mylist}')
# 6.删除指定下标索引的元素
mylist = ['itcast', 'itheima', 'python']
# 方式1：del 列表[下标]
del mylist[2]
print(f'列表删除元素后，结果是：{mylist}')
# 方式2：列表.pop(下标) 但是其可以接收出取出的参数
mylist = ['itcast', 'itheima', 'python']
element = mylist.pop(2)
print(f'通过pop方法取出元素后列表内容：{mylist},取出的元素是：{element}')
# 7.删除某元素在列表中的第一个匹配项
mylist = [1, 2, 3, 2]
mylist.remove(2)
# 输出[1,3,2]
print(f'remove后结果是：{mylist}')
# 8.清空列表
mylist.clear()
print(mylist)
# 9.统计列表内某元素的数量
mylist = [1, 2, 3, 2, 2, 2]
count = mylist.count(2)
# 输出的count=4
print(count)
# 10.统计列表中全部的元素数量（函数）
mylist = [1, 2, 3, 2, 2, 2]
count = len(mylist)
# 输出的元素个数为6
print(count)案例练习
# 定义这个列表，并用变量接收它
mylist = [21, 25, 21, 23, 22, 20]
# 追加一个数字31，到列表的尾部
mylist.append(31)
print(mylist)
# 追加一个新列表[29, 33, 30]，到列表的尾部
mylist2 = [29, 33, 30]
mylist.extend(mylist2)
print(mylist)
# 取出第一个元素（应是：21）
num1 = mylist[0]
print(num1)
# 取出最后一个元素（应是：30）
num2 = mylist[-1]
print(num2)
# 查找元素31，在列表中的下标位置
index = mylist.index(31)
print(index)
print(mylist)- list列表的遍历（while和for）
遍历：将容器内的元素依次取出，并处理，称之为遍历操作
如何遍历列表中的元素：可以使用while或for循环
列表的遍历--while循环
列表的遍历--for循环 list就是一种数据容器
while和for循环的对比
代码
def list_while_func():
"""
使用while循环遍历列表的演示函数
:return: None
"""
mylist = ["传智教育", "黑马程序员", "Python"]
# 循环控制变量：通过下标索引来控制，默认是0
# 每一次循环，将下标索引变量+1
# 循环条件：下标索引变量 < 列表的元素数量
# 定义一个变量，用来标记列表的下标
index = 0 # 初始下标为0
while index < len(mylist):
# 通过index变量取出对应下标的元素
element = mylist[index]
print(f"列表的元素：{element}")
# 至关重要：将循环变量（index）每一次循环都+1
index += 1
def list_for_func():
"""
使用for循环遍历列表的演示函数
:return:
"""
mylist = [1, 2, 3, 4, 5]
# for 临时变量 in 数据容器:
for element in mylist:
print(f"列表的元素有：{element}")
if __name__ == '__main__':
# list_while_func()
list_for_func()
案例
mylist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
mylist2 = []
mylist3 = []
# 用while循环
index = 0
while index < len(mylist):
num = mylist[index]
if num % 2 == 0:
mylist2.append(num)
index += 1
print(mylist2)
# 用for循环 输出的是内容
for num in mylist:
if num % 2 == 0:
mylist3.append(num)
print(mylist3)三、数据容器：tuple(元组)
元组的定义：元组定义：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。（元组一旦定义完成，就不可修改）
元组也支持嵌套：
一个元素后面还必须带有括号才是元组
元组的相关操作
元组由于不可修改的特性，所以其操作方法非常少。
但是元组可以修改内部list的内部元素
# 元组的操作：index查找方法
t6 = ("传智教育", "黑马程序员", "Python")
index = t6.index("黑马程序员")
print(f"在元组t6中查找黑马程序员，的下标是：{index}")
# 元组的操作：count统计方法
t7 = ("传智教育", "黑马程序员", "黑马程序员", "黑马程序员", "Python")
num = t7.count("黑马程序员")
print(f"在元组t7中统计黑马程序员的数量有：{num}个")
# 元组的操作：len函数统计元组元素数量
t8 = ("传智教育", "黑马程序员", "黑马程序员", "黑马程序员", "Python")
num = len(t8)
print(f"t8元组中的元素有：{num}个")
元组的遍历
# 元组的遍历：while
index = 0
while index < len(t8):
print(f"元组的元素有：{t8[index]}")
# 至关重要
index += 1
# 元组的遍历：for
for element in t8:
print(f"2元组的元素有：{element}")
# 修改元组内容 不可以修改
# t8[0] = "itcast"元组的特点
案例
请注意”t1[2].append("coding") # 增加：爱好coding到list中 必须t1[2]才是list才可以append
t1 = ("周杰轮", 11, ["football", "music"])
num = t1.index(11)
print(f"年龄所在的位置是{num}")
name = t1[0]
print(f"姓名为：{name}")
del t1[2][0]
print(f"删除后的内容为：{t1}")
t1[2].append("coding") # 增加：爱好coding到list中
print(f"增加后内容为：{t1}")四、数据容器:str字符串
字符串也是一种数据容器：字符串可以看做是字符的容器，支持下标索引等特性
字符串常用的操作
索引：
my_str = "itheima and itcast"
# index方法
value = my_str.index("and")
print(f"在字符串{my_str}中查找and，其起始下标是：{value}") #结果为8
# replace方法
# 语法：字符串.replace(字符串1，字符串2）
# 功能：将字符串内的全部：字符串1，替换为字符串2
# 注意：不是修改字符串本身，而是得到了一个新字符串哦
new_my_str = my_str.replace("it", "程序")
# my_str不会变化，new那个输出变化的
print(f"将字符串{my_str}，进行替换后得到：{new_my_str}")
# split方法
# 语法：字符串.split(分隔符字符串）
# 功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中
# 注意：字符串本身不变，而是得到了一个列表对象
my_str = "hello python itheima itcast"
my_str_list = my_str.split(" ")
#得到['hello', 'python', 'itheima', 'itcast']
print(f"将字符串{my_str}进行split切分后得到：{my_str_list}, 类型是：{type(my_str_list)}")
# strip方法
my_str = " itheima and itcast "
new_my_str = my_str.strip() # 不传入参数，去除首尾空格
print(f"字符串{my_str}被strip后，结果：{new_my_str}")
my_str = "12itheima and itcast21"
new_my_str = my_str.strip("12")
# 注意，传入的是“12” 其实就是：”1”和”2”都会移除，是按照单个字符。
print(f"字符串{my_str}被strip('12')后，结果：{new_my_str}")
# 统计字符串中某字符串的出现次数, count
my_str = "itheima and itcast"
count = my_str.count("it")
print(f"字符串{my_str}中it出现的次数是：{count}")
# 统计字符串的长度, len()
num = len(my_str)
print(f"字符串{my_str}的长度是：{num}")
字符串的遍历
字符串的特点
案例
mystr = 'itheima itcast boxuegu'
num = mystr.count('it')
print(f'字符串itheima itcast boxuegu中有：{num}个it字符')
new_str = mystr.replace(' ', '|')
# 其中mystr不变化
print(f'字符串itheima itcast boxuegu,被替换空格后，结果：{new_str}')
# 其中mystr不变化
new_str1 = new_str.split('|')
print(f'字符串itheima itcast boxuegu,按照|分割后，得到：{new_str1}')五、数据容器(序列)的切片
序列：内容连续、有序，可使用下标索引的一类数据容器
（列表、元组、字符串，均可以可以视为序列。）
切片：从一个序列中，取出一个子序列
语法：序列[起始下标:结束下标:步长]
表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列（原始的序列不会发生变化）：
注意：结束下标是不包含的。
# 对list进行切片，从1开始，4结束，步长1
my_list = [0, 1, 2, 3, 4, 5, 6]
result1 = my_list[1:4] # 步长默认是1，所以可以省略不写
print(f"结果1：{result1}")
# 结果1：[1, 2, 3]
# 对tuple进行切片，从头开始，到最后结束，步长1
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result2 = my_tuple[:] # 起始和结束不写表示从头到尾，步长为1可以省略
print(f"结果2：{result2}")
# 结果2：(0, 1, 2, 3, 4, 5, 6)
# 对str进行切片，从头开始，到最后结束，步长2
my_str = "01234567"
result3 = my_str[::2]
print(f"结果3：{result3}")
# 结果3：0246
# 对str进行切片，从头开始，到最后结束，步长-1
my_str = "01234567"
result4 = my_str[::-1] # 等同于将序列反转了
print(f"结果4：{result4}")
# 结果4：76543210
# 对列表进行切片，从3开始，到1结束，步长-1
my_list = [0, 1, 2, 3, 4, 5, 6]
result5 = my_list[3:1:-1]
print(f"结果5：{result5}")
# 结果5：[3, 2] 请注意结束是不包含的
# 对元组进行切片，从头开始，到尾结束，步长-2
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result6 = my_tuple[::-2]
print(f"结果6：{result6}")
# 结果6：(6, 4, 2, 0)案例练习
# 方法1
mystr = '万过薪月，员序程马黑来，nohtyP学'
mystr1 = mystr[::-1]
mystr2 = mystr1[9:14]
print(mystr2)
# 方法2
mystr3 = mystr[5:10][::-1]
print(mystr3)
# 方法3
mystr4 = mystr.split('，')[1].replace('来', '')[::-1]
print(mystr4)
a = mystr.split('，')
# 得到['万过薪月', '员序程马黑来', 'nohtyP学'] 列表
print(a)
# 列表索引
b = a[1]
# 得到员序程马黑来
print(b)
# 类型为<class 'str'> 字符串
print(type(b))
# 字符串有replace六、数据容器：set（集合）
元组、列表、字符串都是序列（可以用下标进行索引，可以有重复元素）
集合则自带去重效果，无序，不可以用下标索引
基本语法
集合的常用操作
集合的特点
案例练习
# 定义一个序列
my_list = ['黑马程序员', '传智播客', '黑马程序员', '传智播客',
'itheima', 'itcast', 'itheima', 'itcast', 'best']
# 定义一个空集合
my_set = set()
# 通过for循环遍历列表
for element in my_list:
my_set.add(element)
print(my_set)
# 原始有重复的，相当于去重七、数据容器：dict(字典、映射)
字典的含义
可以实现用key取出Value的操作，就像查字典一样
# 定义字典
my_dict1 = {"王力鸿": 99, "周杰轮": 88, "林俊节": 77}
# 定义空字典
my_dict2 = {}
my_dict3 = dict()
print(f"字典1的内容是：{my_dict1}, 类型：{type(my_dict1)}")
print(f"字典2的内容是：{my_dict2}, 类型：{type(my_dict2)}")
print(f"字典3的内容是：{my_dict3}, 类型：{type(my_dict3)}")
# 定义重复Key的字典
my_dict1 = {"王力鸿": 99, "王力鸿": 88, "林俊节": 77}
print(f"重复key的字典的内容是：{my_dict1}")
# 字典1的内容是：{'王力鸿': 99, '周杰轮': 88, '林俊节': 77}, 类型：<class 'dict'>
# 字典2的内容是：{}, 类型：<class 'dict'>
# 字典3的内容是：{}, 类型：<class 'dict'>
# 重复key的字典的内容是：{'王力鸿': 88, '林俊节': 77}字典数据的获取
# 从字典中基于Key获取Value
my_dict1 = {"王力鸿": 99, "周杰轮": 88, "林俊节": 77}
score = my_dict1["王力鸿"]
print(f"王力鸿的考试分数是：{score}")
score = my_dict1["周杰轮"]
print(f"周杰轮的考试分数是：{score}")字典的嵌套
注意点
key不可以为字典，而value可以，所以字典可以支持嵌套
key是不允许重复，重复添加等于覆盖原有的数据
字典不可以用下标索引，通过key来检索Value
字典的常用操作
新增和更新元素的语法一致，如果Key不存在即新增，如果Key存在即更新（Key不可重复）
# 遍历字典
# 方式1：通过获取到全部的key来完成遍历
for key in keys:
print(f"字典的key是:{key}")
print(f"字典的value是：{my_dict[key]}")
# 方式2：直接对字典进行for循环，每一次循环都是直接得到key
for key in my_dict:
print(f"2字典的key是:{key}")
print(f"2字典的value是：{my_dict[key]}")
字典的特点
案例练习
my_dict = {
'王力鸿': {'部门': '科技部', '工资': 3000, '级别': 1},
'周杰轮': {'部门': '市场部', '工资': 5000, '级别': 2},
'林俊节': {'部门': '市场部', '工资': 7000, '级别': 3},
'张学油': {'部门': '科技部', '工资': 4000, '级别': 1},
'刘德滑': {'部门': '市场部', '工资': 6000, '级别': 2}
}
for key in my_dict:
rank = my_dict[key]['级别']
if rank == 1:
my_dict[key]['级别'] += 1
my_dict[key]['工资'] += 1000
print(my_dict)八、数据容器对比总结
九、数据容器的通用操作
遍历：
# 类型转换: 容器转列表
print(f"列表转列表的结果是：{list(my_list)}")
print(f"元组转列表的结果是：{list(my_tuple)}")
print(f"字符串转列表结果是：{list(my_str)}")
print(f"集合转列表的结果是：{list(my_set)}")
print(f"字典转列表的结果是：{list(my_dict)}")字典转列表中value值丢失
# 类型转换: 容器转元组
print(f"列表转元组的结果是：{tuple(my_list)}")
print(f"元组转元组的结果是：{tuple(my_tuple)}")
print(f"字符串转元组结果是：{tuple(my_str)}")
print(f"集合转元组的结果是：{tuple(my_set)}")
print(f"字典转元组的结果是：{tuple(my_dict)}")
# 类型转换: 容器转字符串
print(f"列表转字符串的结果是：{str(my_list)}")
print(f"元组转字符串的结果是：{str(my_tuple)}")
print(f"字符串转字符串结果是：{str(my_str)}")
print(f"集合转字符串的结果是：{str(my_set)}")
print(f"字典转字符串的结果是：{str(my_dict)}")虽然看过去不变，但是类型都变为字符串了
# 类型转换: 容器转集合
print(f"列表转集合的结果是：{set(my_list)}")
print(f"元组转集合的结果是：{set(my_tuple)}")
print(f"字符串转集合结果是：{set(my_str)}")
print(f"集合转集合的结果是：{set(my_set)}")
print(f"字典转集合的结果是：{set(my_dict)}")
注意，没有转换成字典的
print(f"列表对象的排序结果：{sorted(my_list)}")
print(f"元组对象的排序结果：{sorted(my_tuple)}")
print(f"字符串对象的排序结果：{sorted(my_str)}")
print(f"集合对象的排序结果：{sorted(my_set)}")
print(f"字典对象的排序结果：{sorted(my_dict)}")
print(f"列表对象的反向排序结果：{sorted(my_list, reverse=True)}")
print(f"元组对象的反向排序结果：{sorted(my_tuple, reverse=True)}")
print(f"字符串对象反向的排序结果：{sorted(my_str, reverse=True)}")
print(f"集合对象的反向排序结果：{sorted(my_set, reverse=True)}")
print(f"字典对象的反向排序结果：{sorted(my_dict, reverse=True)}")
注意：结果都都变成列表（list）
补充：字符串大小比较
1.字符串如何比较
从头到尾，一位位进行比较，其中一位大，后面就无需比较了。
2.单个字符之间如何确定大小？
通过ASCII码表，确定字符对应的码值数字来确定大小
2926
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
