1.序列:
序列的含义:有下标索引,元素有序,可重复的一类数据容器
序列分类:列表 元组 字符串
序列特点:除了有下标,有序,可以重复,支持while循环外,还有再大的特点是支持切片操作
切片格式:序列[开始索引:结束索引:步长]
切片解释:
开始索引(可以留空,代表从头开始)
结束索引(可以留空,代表到末尾结束)
步长(默认为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])
元组切片示例:
# 元组的切片操作
# 需求: 定义非空元组
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])
字符串切片示例:
# 字符串的切片操作
# 需求: 定义非空字符串
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])
综合练习:
# 需求: 定义列表存储多个手机号
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)
2.集合:
集合的定义:
定义空集合:集合名 = 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循环
因为for循环又叫遍历循环,最大的特点就是遍历容器,所以集合支持for循环
# 定义集合
name_set = {'张三', '李四', '张三', '王五'}
# for循环遍历集合
for name in name_set:
print(name)
集合的特点:
集合的特点总结:
可以存储多个元素
支持for循环
不能存储可变类型
不支持下表索引
不支持while循环
不支持重复
支持修改
3.字典:
字典的定义:
定义空字典:字典名 = {} 或者 字典名 = 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))
字典根据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('数学')}")
字典的增删改查:
增:
添加元素: 字典名[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())
字典的遍历:
字典是不支持下标索引,不支持重复元素,所以字典是无序的,也不支持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])
字典的特点:
字典特点总结:
可以存储多个元素
支持for循环
key不支持可变类型(value可以是任意类型)
不支持下标索引
不支持while循环
key不支持重复(value支持重复)
支持修改