序列和集合和字典

一、序列

1、知识点:

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

序列分类: 列表  元组  字符串

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

切片格式: 序列[开始索引:结束索引:步长]
		切片解释: 
            开始索引(可以留空,代表从头开始) 
            结束索引(可以留空,代表带末尾结束) 
            步长(默认1,正数代表从左往右,负数代表从右往左)

2、列表切片示例:

# 序列: 列表  元组  字符串
# 列表的切片操作
# 需求: 定义非空列表
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])

3、元组切片示例:

# 序列: 元组  元组  字符串
# 元组的切片操作
# 需求: 定义非空元组
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])

4、字符串切片示例:

# 序列: 字符串  字符串  字符串
# 字符串的切片操作
# 需求: 定义非空字符串
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])

5、综合练习:

# 需求: 定义列表存储多个手机号
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)
    new_phone = phone.replace(phone[3:7], "****", 1)
    print(new_phone)

二、集合

点击查看相关函数方法的用法和含义

1、集合的定义

知识点:

定义空集合: 集合名 = 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))
# 注意: 集合内不能存储可变类型(列表,集合等)

2、集合的增删改查

知识点:

增:
	添加指定元素: 集合名.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))

3、集合的遍历

知识点:

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

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

示例:

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

4、集合的特点

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

三、字典

点击查看相关函数方法的用法和含义

1、字典的定义

知识点:

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

定义非空字典:  字典名 = {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: value =  字典名[key]

根据键找值方式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、字典的增删改查

知识点:

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

添加和修改注意事项:

"""
注意:
key是不能重复的,如果重复了不报错,只是变成了修改对应值

字典的添加和修改是一个格式: 字典名[key]=value
如果key是已经存在的,就是修改操作
如果key是不存在的,就是添加操作
"""
# 演示定义字典的时候出现key重复情况,直接报黄警告,有重复key
score_dict = {'张三': 88, '李四': 88, '张三': 77}
print(score_dict)
# 需求: 添加元素
# 演示添加元素的时候出现key重复情况,不会报黄警告,直接修改对应值
score_dict['李四'] = 100
print(score_dict)
# 演示正常添加元素
score_dict['王五'] = 100
print(score_dict)

增删改查示例:

# 定义非空字典
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、字典的遍历

知识点:

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

因为for循环又叫遍历循环,最大特点就是遍历容器,所以集合容器支持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])

5、字典的特点

字典特点总结:
    可以存储多个元素
    支持for循环
     key不支持可变类型(value可以是任意类型)
    不支持下标索引
    不支持while循环
     key不支持重复(value支持重复)
    支持修改