Python---容器（列表 字典 元组 集合）

容器详解

列表

• 列表是 有序、可变 的数据类型
• 列表中可以包含 不同类型 的对象
• 列表可以由 [] 创建
• 支持 下标 及 切片 操作

常用方法（功能：增删改查）

为了方便我们操作列表，Python中对所有列表提供了一些的功能。

序号	分类	关键字 / 函数 / 方法	说明
1	增加	列表.insert(索引, 数据)	在指定位置插入数据
		列表.append(数据)	在末尾追加数据
		列表.extend(列表2)	将列表2 的数据追加到列表
2	修改	列表[索引] = 数据	修改指定索引的数据
3	删除	del 列表[索引]	删除指定索引的数据
		列表.remove[数据]	删除第一个出现的指定数据
		列表.pop	删除末尾数据
		列表.pop(索引)	删除指定索引数据
		列表.clear	清空列表

4	统计	len(列表)	列表长度
		列表.count(数据)	数据在列表中出现的次数
5	排序	列表.sort()	升序排序
		列表.sort(reverse=True)	降序排序
		列表.reverse()	逆序、反转

 

增

1. 追加，在原列表中尾部追加值

2.插入，在原列表的指定索引位置插入值

图例

3.扩展，将一个列表中的元素逐一添加另外一个列表

图例

删除

1. 删除

   • 根据值，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 的 列表 中可以 存储不同类型的数据
• 但是在开发中，更多的应用场景是
  1. 列表 存储相同类型的数据
  2. 通过 迭代遍历，在循环体内部，针对列表中的每一项元素，执行相同的操作

总结

练习题

# 写代码，有如下列表，按照要求实现每一个功能。
#
# 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 "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>> hash({"name":"zs"})   #可变
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'dict'

练习 2：模拟用户登录信息系统

需求

1. 支持新用户注册，新用户名和密码注册到字典中

2. 支持老用户登陆，用户名和密码正确提示登陆成功

3. 主程序通过循环询问，进行何种操作，根据用户的选择，执行注册或是登陆操作

# 需求
#
# 支持新用户注册，新用户名和密码注册到字典中
#
# 支持老用户登陆，用户名和密码正确提示登陆成功
#
# 主程序通过循环询问，进行何种操作，根据用户的选择，执行注册或是登陆操作
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)))  # 列表