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. 追加,在原列表中尾部追加值

Python---容器(列表 字典 元组 集合)_第1张图片

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

图例

Python---容器(列表 字典 元组 集合)_第2张图片

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

图例

Python---容器(列表 字典 元组 集合)_第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)

Python---容器(列表 字典 元组 集合)_第4张图片

获取长度: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---容器(列表 字典 元组 集合)_第5张图片

应用场景

  • 尽管 Python 的 列表 中可以 存储不同类型的数据
  • 但是在开发中,更多的应用场景是
    1. 列表 存储相同类型的数据
    2. 通过 迭代遍历,在循环体内部,针对列表中的每一项元素,执行相同的操作

总结

Python---容器(列表 字典 元组 集合)_第6张图片

练习题

# 写代码,有如下列表,按照要求实现每一个功能。
#
# 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)

Python---容器(列表 字典 元组 集合)_第7张图片

元组

元组的定义

  • 通过 () 创建元组
  • 元组是有序的、不可变类型
  • 与列表类似,作用于列表的操作,绝大数也可以作用于元组
  • 一般用于存储一些在程序中不应该被修改的一系列值

常见操作

由于元组不可变的特性,所有没有 增、删、改 操作

# 元组: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))

Python---容器(列表 字典 元组 集合)_第8张图片

 总结

Python---容器(列表 字典 元组 集合)_第9张图片

字典

字典的定义

  • 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","姓名不详"))

Python---容器(列表 字典 元组 集合)_第10张图片

获取所有的键

通过 字典对象.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)

 Python---容器(列表 字典 元组 集合)_第11张图片

更新键值

通过 字典对象.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)

Python---容器(列表 字典 元组 集合)_第12张图片

其他

字典相关函数

  • len():返回字典中元素的数目

  • hash():不是为字典设计,可以判断对象是否可以作为字典的键

    • hash() 可以判断对象是否可以作为字典的键:
      • 可变对象不能作为字典的key,例如:列表和字典;
      • 不可变对象可以作为字典的键,例如:数值,字符串,和元组;

总结:

Python---容器(列表 字典 元组 集合)_第13张图片

判断元素是否可变,能被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:模拟用户登录信息系统

需求

  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()

Python---容器(列表 字典 元组 集合)_第14张图片

集合

  • 集合与元组和列表相似都用于做容器,在内部可以放一些子元素
  • 集合有三特殊特点: 子元素不重复 、 子元素必须可哈希无序

提示:目前可哈希的数据类型 int/str/tuple;不可哈希的类型 dict/list/set 。

# 集合
set01 = {1,2,"hello",1}
print(set01)

 

集合类型操作符

  • 集合支持用 in 和 not in 操作符检查成员

  • 能够通过 len() 检查集合大小

  • 能够使用 for 迭代集合成员

  • 不能取切片,没有键

常用操作

添加元素 add()

删除元素

discard()

  • 从集合中移除一个元素 (如果它是成员)。
  • 如果元素不是成员,则不做任何操作。

remove()

  • 从集合中移除一个元素;它 必须 是一个成员。
  • 如果元素不是成员,则引发 KeyError

 

交集

图例

Python---容器(列表 字典 元组 集合)_第15张图片

并集

图例

Python---容器(列表 字典 元组 集合)_第16张图片

 

差集

图例

Python---容器(列表 字典 元组 集合)_第17张图片

Python---容器(列表 字典 元组 集合)_第18张图片

 

 

其他

  • 其他类型如果想要转换为集合类型,可以通过 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)))  # 列表

Python---容器(列表 字典 元组 集合)_第19张图片

 

你可能感兴趣的:(python)