学习大数据第七课-学习数据的容器之序列和集合和字典

前言：详细解答了各个常用容器的使用方法

一 序列

        1.序列含义: 有下标索引,元素有序,可重复的一类数据容器

        2.序列分类: 列表list  元组tuple  字符串str

        3.序列特点: 除了有下标索引,有序,可以重复,支持while循环外,还有最大的特点是支持切片操作

        4.切片格式: 序列[开始索引:结束索引:步长]
                切片解释: 
                    开始索引(可以留空,代表从头开始) 
                    结束索引(可以留空,代表带末尾结束) 注意：没有带空的时候结束索引不包含
                    步长(默认1,正数代表从左往右,负数代表从右往左)

1.列表切片示例

# 列表的切片操作
# 需求: 定义非空列表
my_list = ['a', 'b', 'c', 'd', 'e']
# 需求: 打印大列表
print(my_list)
print(my_list[:])
print(my_list[::])
# 需求: 从大列表中截取abc列表
print(my_list[0:3:1])
print(my_list[0:3:])
print(my_list[:3:])
# 需求: 从大列表中截取cde列表
print(my_list[2:5:1])
print(my_list[2:5])
print(my_list[2:])
# 需求: 反转列表
print(my_list[::-1])
# 需求:从大列表中截取dcb列表
print(my_list[3:0:-1])
print(my_list[-2:-5:-1])

2.元组切片示例

# 需求: 定义非空元组
my_tuple = ('a', 'b', 'c', 'd', 'e')
# 需求: 打印大元组
print(my_tuple)
print(my_tuple[:])
print(my_tuple[::])
# 需求: 从大元组中截取abc元组
print(my_tuple[0:3:1])
print(my_tuple[0:3:])
print(my_tuple[:3:])
# 需求: 从大元组中截取cde元组
print(my_tuple[2:5:1])
print(my_tuple[2:5])
print(my_tuple[2:])
# 需求: 反转元组
print(my_tuple[::-1])
# 需求:从大元组中截取dcb元组
print(my_tuple[3:0:-1])
print(my_tuple[-2:-5:-1])

3.字符串切片示例

# 需求: 定义非空字符串
my_str = 'abcde'
# 需求: 打印大字符串
print(my_str)
print(my_str[:])
print(my_str[::])
# 需求: 从大字符串中截取abc字符串
print(my_str[0:3:1])
print(my_str[0:3:])
print(my_str[:3:])
# 需求: 从大字符串中截取cde字符串
print(my_str[2:5:1])
print(my_str[2:5])
print(my_str[2:])
# 需求: 反转字符串
print(my_str[::-1])
# 需求:从大字符串中截取dcb字符串
print(my_str[3:0:-1])
print(my_str[-2:-5:-1])

二 集合

1.集合的定义

        定义空集合：集合名 = set()   注意: 千万不要使用空的{},因为它代表字典

        定义非空集合：集合名 = {元素1,元素2,元素3,...}   注意: 集合中不要嵌套可变类型

示例：

# 定义空集合
set1 = set()
print(set1, type(set1))
# 定义非空集合
my_set = {'a', 'b', 'a', 'b', 'e'}
print(my_set, type(my_set))
# 注意: 集合内不能存储可变类型(列表,集合等)

2.集合的增删改查

（1）增:
            添加指定元素: 集合名.add(元素)
（2）删:
            删除指定元素: 集合名.remove(元素)
            删除任意元素: 集合名.pop()
            清空所有元素: 集合名.clear()
（3）改:
            修改集合A的内容为它和集合B的差集: 集合A.difference_update(集合B)
           修改集合A的内容为它和集合B的并集: 集合A.update(集合B)
（4）查:
            查看集合中元素个数: len(集合名)

示例：

# 定义空集合
name_set = set()
# 1.演示集合的添加操作
name_set.add('张三')
name_set.add('李四')
name_set.add('张三')
name_set.add('王五')
print(name_set)
# 2.演示集合删除操作
name_set.remove('李四')
print(name_set)
name_set.pop()
print(name_set)
name_set.clear()
print(name_set)
# 3.演示集合修改操作
s1 = {1, 2, 3}
s2 = {1, 5, 6}
# 需求: 修改s2: 只保留和s1的差集
s2.difference_update(s1)
print(s1)  # {1,2,3}
print(s2)  # {5,6}
# 需求: 修改s2: 保留和s1的并集
s2.update(s1)
print(s1)  # {1,2,3}
print(s2)  # {1,2,3,5,6}
# 4.演示集合的查询操作
print(len(s1))
print(len(s2))

3.集合的遍历

        （1）集合是不支持下标索引,不支持重复元素,所以集合是无序的,也不支持while循环

        （2）因为for循环又叫遍历循环,最大特点就是遍历容器,所以集合容器支持for循环

示例：

# 定义集合
name_set = {'张三', '李四', '张三', '王五'}
# for循环遍历集合et:
    print(name)
for name in name_s

4.集合的特点  

通过上述所有的详细代码操作可以得出集合的特点为：

    （1）可以存储多个元素
    （2）支持for循环
    （3）不能存储可变类型
    （4）不支持下标索引(无序)
    （5）不支持while循环
    （6）不支持重复
    （7）支持修改

三 字典

1.字典的定义

        （1）定义空字典:  字典名 = {}   或者  字典名 = dict()

        （2）定义非空字典:  字典名 = {k1:v1 , k2:v2 , ...}    注意: 字典的每个元素是一个键值对

实例：

# 定义空字典
d1 = {}
print(d1, type(d1))
d2 = dict()
print(d2, type(d2))
# 定义非空字典
d3 = {'大王': '小王', '梅花': '方块', '红心': '黑桃'}
print(d3, type(d3))
# 字典的嵌套
d4 = {
    '小明': {'语文': 88, '数学': 99},
    '小王': {'语文': 100, '数学': 88},
    '小李': {'语文': 98, '数学': 89}
}
print(d4, type(d4))

2.字典根据key找值

（1）根据键key找值value方式1: value =  字典名[key]

（2）根据键key找值value方式2: value =  字典名.get(key)

实例：

# 定义非空字典
d3 = { '郭靖': '黄蓉', '杨过': '小龙女', '小明': '小美'}
# 字典的嵌套
d4 = {
    '张三': {'语文': 88, '数学': 99},
    '李四': {'语文': 100, '数学': 88},
    '王五': {'语文': 98, '数学': 89}
}

# 需求: 查找杨过的另一半?
print(f"杨过的另一半是:{d3['杨过']}")
print(f"杨过的另一半是:{d3.get('杨过')}")
# 需求: 查找张三的所有考试成绩?
print(f"张三的所有成绩为:{d4['张三']}")
print(f"张三的所有成绩为:{d4.get('张三')}")
# 需求: 查找王五的数学成绩?
print(f"王五的数学成绩为:{d4['王五']['数学']}")
print(f"王五的数学成绩为:{d4.get('王五').get('数学')}")

3.字典的增删改查

（1）增
            添加元素: 字典名[new_key] = value 
（2）删
            删除元素: 字典名.pop(key)
            清空元素: 字典名.clear()
（3）改
            修改元素: 字典名[old_key] = value 
（4）查
            根据键找值方式1: 字典名[key]
            根据键找值方式2: 字典名.get(key)
            查询元数据的个数: len(字典名)
            查询所有的键: 字典名.keys()
            查询所有的值: 字典名.values()
            查询所有的键值对: 字典名.items()

实例：

# 定义非空字典
score_dict = {'张三': 88, '李四': 88, '王五': 100}
# 1.演示删除操作
# pop(key): 根据key删除对应的整个键值对
score_dict.pop('李四')
print(score_dict)
# clear(): 清空所有的键值对
score_dict.clear()
print(score_dict)
# 2.增加元素
# 字典名[new_key]=value
score_dict['赵六'] = 90
score_dict['田七'] = 100
print(score_dict)
# 3.修改田七的成绩为99
# 字典名[old_key]=value
score_dict['田七'] = 99
print(score_dict)
# 4.查找元素
# 需求: 查找字典中元素个数
print(len(score_dict))
# 需求: 查找所有的键key
print(score_dict.keys())
# 需求: 查找所有的值value
print(score_dict.values())
# 需求: 查找所有的键值对items
print(score_dict.items())

4.字典的遍历

（1）字典是不支持下标索引,不支持重复元素,所以字典也不支持while循环

（2）因为for循环又叫遍历循环,最大特点就是遍历容器,所以字典容器支持for循环

实例：

# 定义字典
name_age_dict = {'张三': 18, '李四': 18, '张三': 28, '王五': 38}
# for循环遍历字典
# 方式1  默认遍历获取的就是key,再根据key找值
for name in name_age_dict:
    # 根据key找value
    age = name_age_dict[name]
    print(name, age)
print('-----------------------------------')
# 方式2  先获取所有的key,再根据key找值
for name in name_age_dict.keys():
    # 根据key找value
    age = name_age_dict.get(name)
    print(name, age)

print('-----------------------------------')
# 方式3 先获取所有的键值对items(默认放到元组中),然后再根据索引找
for item in name_age_dict.items():
    print(item[0], item[1])

5.字典的特点

通过上述代码可知，字典的特点有：
    （1）可以存储多个元素
    （2）支持for循环
    （3）key不支持可变类型(value可以是任意类型)
    （4）不支持下标索引
    （5）不支持while循环
    （6）key不支持重复(value支持重复)
    （7）支持修改