Python+大数据学习笔记|Day 8:数据容器：序列、集合与字典-CSDN博客

本文链接：https://blog.csdn.net/yifang_0112/article/details/133654089

序列

前面我们学习过了列表、元祖和字符串，这三类数据容器都有一些共同点，那就是内容连续，有序，能使用下标索引且元素可以重复。这类内容连续、有序，能使用下标索引的数据容器，我们称之为序列。

序列含义:

有下标索引,元素有序,可重复的一类数据容器

序列分类:

列表元组字符串

序列特点:

1.有下标索引

2.有序

3.可以重复

4.支持while循环,

5.最大的特点是支持切片操作

列表、元祖和字符串同为序列，因此它们都能进行序列才有的操作——切片。

切片：

从一个序列中，取出一个子序列

语法：

序列[起始下标:结束下标:步长]

起始下标：表示从何处开始，可以留空，留空视作从0开始

结束下标：表示何处结束，可以留空，留空视作截取到结尾（因为从0开始，所以结束下标不含其本身）

步长：依次取元素的间隔

切片示例：

# 列表切片操作
list1 = ['a', 'b', 'c', 'd', 'e']
print(list1[:3])  # 从下标0开始，一直到下标为3的元素结束(不包括下标为3的元素），结果为['a','b','c']
print(list1[1:3])  # 从下标1开始，一直到下标为3的元素结束(不包括下标为3的元素)，结果为['b','c']
print(list1[0:3:2])  # 从下标0开始，一直到下标为3的元素结束(不包括下标为3的元素)，步长为2，结果为['a','c']
print(list1[-1:-3:-1])  # 从下标-1开始，一直到下标为-3的元素结束(不包括下标为-3的元素)， 步长为-1，负数倒转来切片，结果为[’e','d']
print(list1[::-1])  # 反转列表['e', 'd', 'c', 'b', 'a']

# 元祖切片操作
tuple1 = ('a', 'b', 'c', 'd', 'e')
print(tuple1[:3])  # 从下标0开始，一直到下标为3的元素结束(不包括下标为3的元素），结果为('a','b','c')
print(tuple1[1:3])  # 从下标1开始，一直到下标为3的元素结束(不包括下标为3的元素)，结果为('b','c')
print(tuple1[0:3:2])  # 从下标0开始，一直到下标为3的元素结束(不包括下标为3的元素)，步长为2，结果为('a','c')
print(tuple1[-1:-3:-1])  # 从下标-1开始，一直到下标为-3的元素结束(不包括下标为-3的元素)， 步长为-1，负数倒转来切片，结果为(’e','d')
print(tuple1[::-1])  # 反转列表('e', 'd', 'c', 'b', 'a')

# 字符串切片操作
str1 = 'abcde'
print(str1[:3])  # 从下标0开始，一直到下标为3的元素结束(不包括下标为3的元素），结果为'abc'
print(str1[1:3])  # 从下标1开始，一直到下标为3的元素结束(不包括下标为3的元素)，结果为'bc'
print(str1[0:3:2])  # 从下标0开始，一直到下标为3的元素结束(不包括下标为3的元素)，步长为2，结果为'ac'
print(str1[-1:-3:-1])  # 从下标-1开始，一直到下标为-3的元素结束(不包括下标为-3的元素)， 步长为-1，负数倒转来切片，结果为’ed'
print(str1[::-1])  # 反转列表'edcba'

综合案例：

# 需求: 定义列表存储多个手机号
phone_list = ['15861626162', '15812344321', '13861123456', '15866667788']

# 需求: 已知多个手机号,要求把中间4位隐藏为****
# 方式1:
for phone in phone_list:
    # 依次获取到每个手机号phone
    # print(phone)
    new_phone = phone[:3] + "****" + phone[-4::]
    print(new_phone)

print('------------------------------------')
# 方式2:
for phone in phone_list:
    # 依次获取到每个手机号phone
    # print(phone)
    # 注：结尾的1表示只有第一次出现的会被替换，默认值为-1，-1表示替换所有
    new_phone = phone.replace(phone[3:7], "****", 1)
    print(new_phone)

集合

跟序列不同，我们接下来要学习的集合和字典是没有下标索引的，它们无序，不连续，如果出现相同元素很难定位，因此它们不能重复。

定义空集合:

        集合名 = set()

        注意: 不要使用空的{}来进行定义，因为它代表空的字典

定义非空集合:

        集合名 = {元素1,元素2,元素3,...}

        注意: 集合中不要嵌套可变类型

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

集合的常用操作
增加元素
添加指定元素	集合名.add(元素)
删除元素
删除指定元素	集合名.remove(元素)
删除任意元素	集合名.pop()
清空所有元素	集合名.clear()
修改元素
修改集合A的内容为它和集合B的差集	集合A.difference_update(集合B)
修改集合A的内容为它和集合B的并集	集合A.update(集合B)
查看元素
查看集合中元素个数	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))

集合的遍历：

前面学过的数据容器用while遍历元素时，都是基于下标索引进行的遍历，由于集合和字典都没有下标索引，因此两者都不支持直接用while循环进行遍历。for循环又叫遍历循环，它可以把数据容器中的元素一个个取出，因此无论该数据容器是否支持下标索引，都可以用for循环进行遍历。

for循环遍历集合示例：

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

集合特点:

可以存储多个元素
支持for循环
不能存储可变类型
不支持下标索引(无序)
不支持while循环
不支持重复
支持修改

字典

当我们需要将一对相互关联的内容储存在一起时，用其他元素很容易混乱。比如我们开家长会，需要对应的母亲坐在自己孩子的座位上，我们只要根据孩子的名字，安排母亲入座即可，使用前面所学的数据容器很难根据孩子的姓名关联到其母亲，这个时候我们就需要引入字典的概念。

字典存储的每一个元素是成对显示的，左边的叫“key”,右边的叫“value”，根据左边的“key”，我们很容易就能找到右边的“value”。比如，王小明的妈妈就叫王蕾蕾，我们只要知道王小明的名字，就能在班级里的家长中很快找到王蕾蕾。这里王小明为“key”，王蕾蕾就为“value”。如果班级里同时存在两个王小明，我们则无法精准用“王小明”匹配到我们想找的王小明的母亲，为了防止这种情况发生，我们会尽量避免“王小明”三个字重复。因此字典里也一样，如果key值重复了，会影响到我们关联对应的value，因此字典中的的key是不允许重复的。

定义空字典:

        字典名 = {} 或者字典名 = dict()

定义非空字典:

        字典名 = {k1:v1 , k2:v2 , ...}

        注意: 字典的每个元素是一个键值对

根据键找值方式1:

         value = 字典名[key]

根据键找值方式2:

        value = 字典名.get(key)

# 定义空字典
d1 = {}
print(d1, type(d1))
d2 = dict()
print(d2, type(d2))

# 定义非空字典
d3 = {'郭靖': '黄蓉', '杨康': '穆念慈'}
print(d3, type(d3))

# 字典的嵌套
d4 = {
    '韦小宝': {'师傅': '陈近南', '娘亲': '韦春花'},
    '杨过': {'娘亲': '穆念慈', '父亲': '杨康'},
    '张无忌': {'娘亲': '殷素素', '父亲': '张翠山'},
}
print(d4, type(d4))

# 根据Key找值
# 找郭靖的妻子
print(f"郭靖的妻子是{d3['郭靖']}")
print(f"郭靖的妻子是{d3.get('郭靖')}")
# 找杨过的所有家人
print(f"杨过的家人是{d4['杨过']}")
print(f"杨过的家人是{d4.get('杨过')}")
# 找杨过的父亲
print(f"杨过的父亲是{d4['杨过']['父亲']}")
print(f"杨过的父亲是{d4.get('杨过').get('父亲')}")

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

字典的增删改查：

#定义非空字典
d1={'张三':89,'李四':78,'王五':99}

#演示shanc
# 字典名.key(key):删除’李四‘对应的键值对
d1.pop('李四')
print(d1)

# 字典名.clear():清空键值对
d1.clear()
print(d1)

# 增加元素
# 字典名[key]=value:增加’里生‘：99,周生：88
d1['里生']=99
print(d1)
d1['周生']=88
print(d1)

# 修改元素
# 字典名[key]=value :修改里生的成绩
d1['里生']=76
print(d1)

# 查询元素
# 查询字典中元素个数：len(字典名)
print(len(d1))
# 查询d1中所有key
print(d1.keys())
# 查询d1中所有value
print(d1.values())
# 查询d1中所有键值对
print(d1.items())

for循环遍历字典：

"""
字典的核心就是key,主要操作的就是key
字典是不支持下标索引,key不支持重复元素,所以字典不支持while循环
"""
# 定义字典
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])