第六章：python数据容器

一、数据容器

• 什么是数据容器？

一种可以存储多个元素的Python数据类型

• Python有哪些数据容器？

list(列表)、tuple(元组)、str(字符串)、set(集合)、dict(字典)，它们各有特点，但都满足可容纳多个元素的特性。

二、数据容器：list(列表)

1. • 列表的定义

列表的定义语法：[元素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))

2. • 列表的下标索引

• 下标索引：列表的每一个元素，都有编号称之为下标索引，有从前往后和从后向前

从前向后的方向，编号从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])

• 嵌套的索引

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)

4. • 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}")

• 字典的嵌套

• 注意点

1. key不可以为字典，而value可以，所以字典可以支持嵌套

2. key是不允许重复，重复添加等于覆盖原有的数据

3. 字典不可以用下标索引，通过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码表，确定字符对应的码值数字来确定大小