Python---容器（列表 字典 元组 集合）
容器详解
列表
- 列表是 有序、可变 的数据类型
- 列表中可以包含 不同类型 的对象
- 列表可以由 [] 创建
- 支持 下标 及 切片 操作
常用方法（功能：增删改查）
为了方便我们操作列表，Python中对所有列表提供了一些的功能。
| 序号 | 分类 | 关键字 / 函数 / 方法 | 说明 |
|---|---|---|---|
| 1 | 增加 | 列表.insert(索引, 数据) | 在指定位置插入数据 |
| 列表.append(数据) | 在末尾追加数据 | ||
| 列表.extend(列表2) | 将列表2 的数据追加到列表 | ||
| 2 | 修改 | 列表[索引] = 数据 | 修改指定索引的数据 |
| 3 | 删除 | del 列表[索引] | 删除指定索引的数据 |
| 列表.remove[数据] | 删除第一个出现的指定数据 | ||
| 列表.pop | 删除末尾数据 | ||
| 列表.pop(索引) | 删除指定索引数据 | ||
| 列表.clear | 清空列表 |
| 4 | 统计 | len(列表) | 列表长度 |
| 列表.count(数据) | 数据在列表中出现的次数 | ||
| 5 | 排序 | 列表.sort() | 升序排序 |
| 列表.sort(reverse=True) | 降序排序 | ||
| 列表.reverse() | 逆序、反转 |
增
-
追加，在原列表中尾部追加值
2.插入，在原列表的指定索引位置插入值
图例
3.扩展，将一个列表中的元素逐一添加另外一个列表
图例
删除
-
删除
- 根据值，remove(data)
- 从左向右找，找到了就删除，然后停止搜索
- 没有返回值
user_list = ["詹姆斯", "韦德", "波什"]
user_list.remove("波什")
print(user_list)弹出
- 根据 索引
- 从左向右找，找到了就弹出，然后停止搜索，默认弹出 尾部元素
- 有返回值
user_list = ["詹姆斯", "韦德", "波什"]
player = user_list.pop() # 弹出列表尾部元素
print(user_list, player)
user_list.pop(1) # 弹出索引为 1 的元素
print(user_list, player)del 关键字
- 使用
del关键字(delete) 同样可以删除列表中元素 del关键字本质上是用来 将一个变量从内存中删除的- 如果使用
del关键字将变量从内存中删除，后续的代码就不能再使用这个变量了
user_list = ["詹姆斯", "韦德", "波什"]
del user_list[2]
print(user_list)清空 原列表
user_list = ["詹姆斯", "韦德", "波什"]
user_list.clear()
print(user_list)改
- 修改动作一般是 先查，后改
- 查：索引，切片
user_list = ["詹姆斯", "韦德", "波什"]
print(user_list[0]) # 查询，詹姆斯
user_list[0] = "杜兰特" # 改
print(user_list)查
- 通过索引查询
- 通过切片查询
tedu_team = ["nfx"]
#添加
# 1. 列表。append(元素):在原列表中尾部添加
tedu_team.append("benben")
print(tedu_team)
# 2. 列表.insert("索引位置，元素")：在原列表的指定索引位置插入值
tedu_team.insert(1,"ddd")
print(tedu_team)
# 3. 列表.extend(列表) 将一个列表中的元素逐一添加另外一个列表
tedu_team.extend(["zz","kg"])
print(tedu_team)
#修改
#列表[索引] = 新值
tedu_team[1] = "lsj" #将索引为1的元素进行修改
print(tedu_team)
#删除
# 1.列表.remove(元素)
tedu_team.remove("benben")
# 2.列表.pop(索引)： 会将删除的元素返回
dc = tedu_team.pop(2)
print("此次删除的元素是：",dc)
print(tedu_team)
# 3.列表.pop()：删除列表最后一个元素，会将删除的元素返回
dc1 = tedu_team.pop()
print("此次删除的元素是：",dc1)
# 4. del删除的元素
del tedu_team[0]
print(tedu_team)
# 5.列表.clear(): 清空列表中的元素
tedu_team.clear()
print(tedu_team)
获取长度：
len()反转：
reverse()排序：
sort()，给列表中的元素排序，默认按从小到大的顺序统计元素出现次数：
count()转化：其他类型的元素转换成列表
list01 = [10, 15, -10, 0, 3]
# 1.获取长度 len(列表)
print(len(list01))
# 2.反转 列表.reverse()
list01.reverse()
print("1 reverse:",list01)
# 3.1 排序： 列表.sort(),生序排列
list01.sort()
print("2 sort:",list01)
# 3.2 排序： 列表.sort(reverse=True),降序排列
list01.sort(reverse=True)
print("3 sort(降序排列):",list01)
# 4. 列表.count(元素): 统计列表中元素出现的次数
print("4:",list01.count(10))
# 5. list(元素): 其他类型的元素转换成列表 *并不是所有类型的数据都可以转换*
str01 = "hello world"
print("5:",list(str01))
应用场景
- 尽管
Python的 列表 中可以 存储不同类型的数据 - 但是在开发中，更多的应用场景是
- 列表 存储相同类型的数据
- 通过 迭代遍历，在循环体内部，针对列表中的每一项元素，执行相同的操作
总结
练习题
# 写代码，有如下列表，按照要求实现每一个功能。
#
# li = ["alex", "jerry", "tom", "barry", "wall"]
# 计算列表的 长度 并输出
li = ["alex","jerry","tom","barry","wall"]
print(len(li))
# 请通过步长获取索引为 偶数 的所有值，并打印出获取后的列表
print(li[::2])
# 列表中追加元素 mike，并输出添加后的列表
li.append("mike")
print(li)
# 请在列表的第 1个位置插入元素 Tony ，并输出添加后的列表
li.insert(1,"Tony")
print(li)
# 请修改列表第 2 个位置的元素为 Kelly，并输出修改后的列表
li[2]="Kelly"
print(li)
# 请将列表 l2 = [1,”a”,3,4,”heart”] 的每一个元素追加到列表 li 中，并输出添加后的列表
li.extend([1,"a",3,4,"heart"])
print(li)
# 请删除列表中的元素 ”barry”，并输出删除后的列表
li.remove("barry")
print(li)
# 请删除列表中的第 2 个元素，并 输出 删除元素后的列表
li.pop(2)
print(li)
元组
元组的定义
- 通过
()创建元组 - 元组是有序的、不可变类型
- 与列表类似，作用于列表的操作，绝大数也可以作用于元组
- 一般用于存储一些在程序中不应该被修改的一系列值
常见操作
由于元组不可变的特性，所有没有 增、删、改 操作
# 元组：tuple
tuple01 = (10,20,"hello",10,True)
print(tuple01)
print(tuple01[2]) #通过索引获取单值
print(tuple01[1:4]) #通过切片方式获取元素
print(tuple01.count(10)) #统计元素出现的次数
#元组.index(元素) 返回元组中某个元素第一次出现的索引位置
print(tuple01.index(10)) # 0
# 如果一个元祖中只有一个元素，那么在创建该元组时，需要加一个逗号
tuple02 = ("hello")
print(type(tuple02))
tuple03 = ("hello",)
print(type(tuple03))
总结
字典
字典的定义
dictionary（字典） 是 除列表以外Python之中 最灵活 的数据类型- 字典同样可以用来 存储多个数据
- 通常用于存储 描述一个
物体的相关信息- 和列表的区别
- 列表 是 有序 的对象集合
- 字典 是 无序 的对象集合
- 字典用
{}定义- 字典使用 键值对 存储数据，键值对之间使用
,分隔
- 键
key是索引- 值
value是数据- 键 和 值 之间使用
:分隔- 键必须是唯一的
- 值 可以取任何数据类型，但 键 只能使用 字符串、数字或 元组
基本操作
创建字典
- 通过
{}操作符创建字典
dict01 = {"name": "zhangsan", "age": 18}常见方法
访问字典：查询
字典是映射类型，意味着它没有下标，访问字典中的值需要使用相应的键
通过键 (key)，访问字典
# 字典： dict {}
# key(键)：value(值)
info = {"name":"zs","age":18} #创建字典
# 查询
#字 典[键]： 通过key查value，key不存在会报错
#print(info["name"],info["age"],info["gender"])# 字典 [键]
#print(info["gender"]) #KeyError(Key在字典中不存在):'gender'
# 2.字典.get（键）：通过key查value，key不存在也不会报错
print(info.get("name"),info.get("age"))
print(info.get("gender")) #None
# 从字典中查询gender对应的value，如果key不存在，则返回默认的值“男”
print(info.get("gender","男"))
# 从字典中查询name对应的value,因为key存在，所以返回zs,否则返回“姓名不详”
print(info.get("name","姓名不详"))
获取所有的键
通过
字典对象.keys()获取
获取所有的值
通过
字典对象.values()获取
获取所有键值对
通过
字典对象.items()获取
# 3 字典.keys(),字典.values(): 获取字典中所有的key,value
# 字典.items():获取字典中所有的键值对
for item in info.keys():
print("key:",item)
for item in info.values():
print("value:",item)
for item in info.items():
print("kv:",item) 
更新键值
通过
字典对象.update()修改或添加或者通过
字典对象[key]修改或添加
# 更新添加
#info = {"name":"zs","age":18}
# key在原字典中存在，是数据的更新
# key在原字典中不存在，是数据的添加
info["age"] = 19
info["gender"] = "男"
print(info)
# 字典.update({...}): 批量更新或添加
info.update({"age": 28, "height":180})
print(info)
dict.setdefault(key, default=None)：如果字典中不存在 key 键，由 dict[key]=default 为它赋值
# 字典.setdefault()
info2 = {"name": "lisi", "age":18}
info2.setdefault("gender","nv")
info2.setdefault("age",30)
print(info2) 
删除操作
pop()，弹出指定键对应的元素并将弹出的元素返回del：删除指定的键值对，不返回数据
清空字典：clear()
# 删除
info3 = {"name":"zs","age": 18, "score":100}
print(len(info3)) #返回字典键值对的个数
# 1.字典.pop(key) 根据key删除元素，会将删除的数据进行返回
cd = info3.pop("name")
print("删除的数据：", cd)
print(info3)
# 2.del 删除数据
del info3["age"]
print(info3)
# 3. 字典.clear():清空字典数据
info3.clear()
print(info3)
其他
字典相关函数
len()：返回字典中元素的数目
hash()：不是为字典设计，可以判断对象是否可以作为字典的键
- hash() 可以判断对象是否可以作为字典的键：
- 可变对象不能作为字典的key，例如：列表和字典；
- 不可变对象可以作为字典的键，例如：数值，字符串，和元组；
总结：
判断元素是否可变，能被hash（）函数执行的是不可变元素，否则就是可变的
>>> hash("hello") #不可变
-8649874728194412832
>>> hash([1,2,3]) #可变
Traceback (most recent call last):
File "", line 1, in
TypeError: unhashable type: 'list'
>>> hash({"name":"zs"}) #可变
Traceback (most recent call last):
File "", line 1, in
TypeError: unhashable type: 'dict'
练习 2：模拟用户登录信息系统
需求
-
支持新用户注册，新用户名和密码注册到字典中
-
支持老用户登陆，用户名和密码正确提示登陆成功
-
主程序通过循环询问，进行何种操作，根据用户的选择，执行注册或是登陆操作
# 需求
#
# 支持新用户注册，新用户名和密码注册到字典中
#
# 支持老用户登陆，用户名和密码正确提示登陆成功
#
# 主程序通过循环询问，进行何种操作，根据用户的选择，执行注册或是登陆操作
userdb = {} #定义一个字典，用于存储用户名和密码
def register():
username = input("用户名:")
if username not in userdb.keys(): #用户名没注册过可以被创建
password = input("密 码：")
userdb[username] = password #字典添加数据
# suerdb["zs"] = "123456"
else:
print("用户名已被注册")
def login():
username = input("用户名:")
password = input("密 码：")
if userdb.get(username) == password:
print("登陆成功 ")
else:
print("登陆失败")
def show_menu():
while True:
xuanze = input("(0)register (1)login (2)exit,请您选择（0/1/2）:")
if xuanze not in ["0","1","2"]:
print("请正确输入!!")
continue #结束此次循环，直接开始下次循环，让用户重新登陆
elif xuanze == "0":
register() #执行注册功能
elif xuanze == "1":
login() #执行登录功能
else:
print("Byebye~")
break
if __name__ == '__main__':
show_menu()
集合
- 集合与元组和列表相似都用于做容器，在内部可以放一些子元素
- 集合有三特殊特点：
子元素不重复、子元素必须可哈希、无序。
提示：目前可哈希的数据类型 int/str/tuple；不可哈希的类型 dict/list/set 。
# 集合
set01 = {1,2,"hello",1}
print(set01)
集合类型操作符
-
集合支持用
in和not in操作符检查成员 -
能够通过
len()检查集合大小 -
能够使用
for迭代集合成员 -
不能取切片，没有键
常用操作
添加元素 add()
删除元素
discard()
- 从集合中移除一个元素 (如果它是成员)。
- 如果元素不是成员，则不做任何操作。
remove()
- 从集合中移除一个元素；它 必须 是一个成员。
- 如果元素不是成员，则引发 KeyError。
交集
图例
并集
图例
差集
图例
其他
-
其他类型如果想要转换为集合类型，可以通过
set进行转换，并且如果数据有重复则 自动去重。 -
提示：
int/list/tuple/dict都可以转换为集合。
# 集合 set: 没有value的字典
set01 = {1, 2, "Hello", 1}
print(set01) # {1, 2, 'Hello'}
print(len(set01)) # 3
# 添加 集合.add(元素)
set01.add("world")
print(set01)
# 删除 集合.discard(元素): 删除的元素不存在，不会报错
# 删除 集合.remove(元素): 删除的元素不存在，会报错
set01.discard("hahaha")
# set01.remove("hahaha") # KeyError: 'hahaha'
# 集合操作
s1 = {"zs", "ls", "ww"}
s2 = {"ww", "zl", "tq"}
print(s1 & s2) # {"ww"} 交集
print(s1 | s2) # {'zs', 'tq', 'ls', 'ww', 'zl'} 并集
print(s1 - s2) # {'zs', 'ls'} 差集
print(s2 - s1) # {'zl', 'tq'} 差集
# 对列表元素去重
list01 = [1, 1, 2, 2, 3, 3]
print(set(list01)) # 集合
print(list(set(list01))) # 列表
