『Python基础』组合数据类型

Python中的组合数据类型

列表 list

定义：

列表，在一个变量中用于存储 有顺序 不同类型 可以重复的 多个 数据

操作：

列表是一个容器，可以用于存储数据
列表的操作方式：增加、删除、查询、修改

列表的操作分类：

1、声明初始化
2、增加数据
3、删除数据
4、查询数据
5、修改数据

（1）声明列表

# 声明空列表
num = []        # 声明空列表的标准语法
num = list()    # 声明空列表的标准语法，项目规范推荐，可读性更高

# 声明非空列表
num = ['1', '2', '3', '4']			# 声明非空列表	项目规范推荐，简洁
num = list(['1', '2', '3', '4'])	# 声明非空列表

# 拓展：其他数据转换成列表
num = "123456"
n = list(num)	# 数据类型转换方法：list(数据)

（2）增加数据

在列表中增加数据

• append(数据)：列表末尾追加数据
• insert(数据)：列表中插入数据
• extends(数据)：列表末尾追加多个数据

# 声明列表：已经存在三个数据
num = ['1', '2', '3']

# 末尾追加一个数据
num.append("4")
print(num)
- ['1', '2', '3', '4']

# 指定位置 插入一个数据
num.insert(0, '0')
print(num)
- ['0', '1', '2', '3', '4']

# 末尾追加多个数据
num.extends(['5', '6'])
print(num)
- ['0', '1', '2', '3', '4', '5', '6']

（3）删除数据

• pop()：删除列表末尾的一个数据
• remove(object)：删除列表中指定的一个数据
• clear()：清空列表，列表中的所有数据全部删除

num = ['1', '2', '3', '4']

# 删除列表末尾的一个数据
num.pop()
print(num)
- ['1', '2', '3']

# 删除列表中指定的一个数据
num.remove('3')
print(num)
- ['1', '2', '4']

# 清空列表，列表中的所有数据全部删除
num.clear()
print(num)
- []

（4）查询数据

将列表中的数据获取到程序中使用
获取单个数据：可以通过列表的下标/索引/编号获取对应位置的数据
【编号是从0开始的】

num = ['0', '1', '2', '3']
print(num[1])
- 1

获取所有数据

num = ['0', '1', '2', '3']

# 直接使用列表
print(num)
- ['0', '1', '2', '3']

# 循环
for n in num:
	print(n)
- 0
- 1
- 2
- 3

for循环基本语法
for循环主要是针对多个数据进行依次遍历查询的循环结构
for 变量 in 多个数据:
将多个数据依次获取到变量中
优点：多个数据可以依次遍历查看
缺点：不能针对某个数据直接获取

（5）修改数据

通过下标/编号/索引，直接使用新的数据覆盖原有的数据就是修改！和变量的数据覆盖一样！

# 声明列表：已经存在的三个数据
num = ['1', '2', '3']

# 修改位置为1的数据
num[1] = '5'
print(num)
- ['1', '5', '3']

（6）其他方法

count(数据)：查看某个数据在列表中出现了多少次
index(数据)：查看某个数据在列表中出现的索引位置
reverse()：翻转列表
sort()：对保存了相同数据类型的列表中所有数据进行简单排序
copy()：复制一个列表

（7）列表的切片

列表中包含多个数据，截取其中的一部分数据？
截取列表中的一部分数据：切片

（1）切片的基本语法

names = ['tom', 'jerry', 'shuke', 'beita']
		   0	   1		2		 3
# 切片，将列表中的数据，截取一部分		列表名称[开始位置:结束位置]【包含开始位置，不包含结束位置】
x1 = names[0:2]
print(x1)
['tom', 'jerry']

（2）切片截取数据

# 切片，将列表中数据，隔一段截取一个	项目名称[开始位置:结束位置:间隔数量]
names = ['tom', 'jerry', 'shuke', 'beita']
		  [0]			   [2]
x2 = names[0:4]
x2 = names[:]
x2 = names[::]
x2 = names[::1]
print(x2)
-  ['tom', 'jerry', 'shuke', 'beita']

x3 = names[::2]
['tom', 'shuke']

（3）切片-负数

names = ['tom', 'jerry', 'shuke', 'beita']

names[::-1]		# 列表翻转
['beita', 'shuke', 'jerry', 'tom']
	-1		-2		 -3		 -4

names[-1:-3:-1]
['beita', 'shuke']

（8）列表基础案列

用户信息登记，将输入的信息存放至列表中

"""
用户姓名登记系统
"""
person = list()

# 首页界面
while True:
	print("\t\t姓名登记系统")
	print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
	print("\t\t1、姓名登记")
	print("\t\t2、查看登记")
	print("\t\t3、退出系统")
	print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
	
	choice = input("请输入您的选项：")
	if choice == "1":
		# 姓名登记
		names = input("请输入姓名：")
		person.append(names)
		input("登记完成，按任意键返回！")
	
	elif choice == "2":
		# 查看登记
		for name in person:
			print(f"登记的人员有：{name}")
		print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
		input("按任意键返回首页！！！")
	elif choice == "3":
		# 退出系统
		exit(1)
	else:
		input("您输入有误，按任意键继续！")

元组 tuple

元组是什么？

元组 是一个可以存放 有顺序的、可以重复的、可以是不同数据类型的、多个数据；但是元组中的数据一旦确定就不允许修改！

元组怎么声明？

声明空元组:无意义
t = tuple()
t =()

声明非空元组
season = ("春", "夏", "秋", "冬") # 推荐
season = tuple(["春", "夏", "秋", "冬"]) # 不推荐

元组都有哪些操作？

• count：查询某个数据出现的次数
• index：查询某个数据出现的位置

元组用在什么地方？

元组用在项目中固定数据声明，如果一年四季，管理员账号等等等…

为什么要用元组？

为了让某些数据在程序运行过程中不能修改，提升程序的稳定性

集合 set

集合是什么？

集合是一种可以存放 没有顺序的、不可以重复的、可以是不同数据类型的、多个数据的组合数据类型
python中使用set类型表示集合

集合的声明

空集合
s = set()
非空集合
s = {'1', '2', '3'}# 推荐
s = set(['1', '2', '3'])# 不推荐

集合的操作方式

dir(set)
['add', 'clear', 'copy', 'difference', 'difference_update',
'discard', 'intersection', 'intersection_update', 'isdisjoint',
'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference',
'symmetric_difference_update', 'union', 'update']

操作单个集合

• add：添加一个数据
• clear：清空集合
• copy：复制一个集合
• discard：从集合中删除指定的数据，如果数据不存在则声明都不做
• pop：随机删除一个数据
• remove：删除指定一个数据

s = set()		# 声明集合
s2 = s			# 两个变量指向同一个集合
s3 = s.copy()	# 复制了一个集合交给s3

s.add("紫薇") # s中增加了数据；s2中增加了数据[s2和s 是同一个集合]；s3中没有增加数据

s.remove("永琪") 	# 删除 出现错误，数据不存在【KeyError】
s.discard("永琪") 	# 删除，没有错误，数据不存在 什么都不做

s.pop() 	# 随机删除一个数据
s.clear() 	# 清空集合

两个集合的操作：

>>> s1 = {1,2,3,4,5}
>>> s2 = {4,5,6,7,8}
>>>
>>> s1.difference(s2)
{1, 2, 3}
>>>
>>> s1.intersection(s2)
{4, 5}
>>>
>>> s1.union(s2)
{1, 2, 3, 4, 5, 6, 7, 8}
>>>
>>> s1.difference_update(s2)
>>> s1
{1, 2, 3}
>>>
>>> s1 = {1,2,3,4,5}
>>> s1.intersection_update(s2)
>>> s1
{4, 5}
>>>
>>> s1 = {1,2,3,4,5}
>>> s1.update(s2)
>>> s1
{1, 2, 3, 4, 5, 6, 7, 8}

为什么要使用集合？

集合中不能存储重复数据，集合能剔除重复数据

>>> names = ["tom", "jerry", "shuke", "beita", "tom", "shuke"]
>>> names
['tom', 'jerry', 'shuke', 'beita', 'tom', 'shuke']
>>> temp = set(names) # 将列表转化成集合，剔除重复的数据
>>> names = list(temp) # 将集合转换回列表，最终得到剔除重复数据之后的列表
>>> names
['jerry', 'shuke', 'tom', 'beita']

字典 dict

字典是什么？

字典是一种组合数据类型，可以存储key:value形式的键值对，在存储过程中key不能重复，value是可以重复的，并且每个key只对应一个value，在存储过程中可以存放多个没有顺序的key:value键值对

字典怎么声明？

• 声明空字典

d = dict()		# 推荐
d = {}			# 不推荐

• 声明非空字典

d = {"username":"admin", "password": "123"}				# 推荐
d = dict([["username", "admin"], ["password", "123"]])	# 不推荐

字典都有哪些操作？

dir(dict)
['clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop',
'popitem', 'setdefault', 'update', 'values']

clear：清空字典
copy：复制字典
get：根据key获取value
items：获取所有的entry
keys：获取所有的key组成的like set
pop：根据key删除指定的一个entry
popitem：随机删除一个entry
setdefault：设置一个数据，如果数据不存在/增加
update：更新一组数据
values：获取所有的value组成的like list

1、字典中增加数据

# 增加一个数据： d[key] = value
users[username] = "zhang san"

# 直接增加一个键值对 setdefault(key, value)
users.setdefault("username", "zhang san")

# 直接增加一个字典数据 update({key: value})
users.update({"password": "123456"})

2、字典中获取数据

# 根据key获取value数据：方括号获取
username = users['username']
print(username)

# 根据key获取value数据：get获取
passwd = users.get("password") # -> 123456
print(passwd)

# 查看所有的entry键值对
entry = users.items()
for e in entry:
print(e)

# 查看所有的keys
ks = users.keys()
for k in ks:
print(f"key: {k}")

# 查看所有的values
vs = users.values()
for v in vs:
print(f"value: {v}")

3、字典中修改数据

# 修改数据：最常用
users["nickname"] = "张三"
print(users)
# 数据不存在~增加；存在~不做任何处理
# users.setdefault("username", "zhangsan ")
# print(users)
# 数据不存在~增加，存在~更新/修改：了解
users.update({"username": "zhangsan"})
print(users)

4、字典中删除数据

# 删除数据
# 1.根据key删除指定一个entry数据
users.pop("nickname")
print(users)

# 2.删除任意的一个entry数据
users.popitem()
print(users)

# 3.根据key删除一个entry
del users["password"]
print(users)

# None 空值，空值也是值~所以下面的方式是给`password`设置了一个`None`数据，不是删除
# users["password"] = None
# print(users)

# 4.清空字典
users.clear()
print(users)

5、字典中数据遍历

# 遍历数据：重要 ~
# 商城系统--字典记录商品--展示商品信息
# 学生管理系统-- 字典记录学员--展示学员信息
# 任何系统-- 字典记录用户-- 用户注册登录
# 1. 直接遍历所有的 key - value
print(users)

# 变量连续赋值：key, value in （"username","admin"）
for key, value in users.items():
print(f"key:{key}, value:{value}")
print("-------------------------------")

# 2. 遍历所有的key，通过key获取对应的value
for key in users.keys():
print(f"---> key: {key}, value:{users.get(key)}")

为什么要用字典？

字典能在项目中非常便捷的通过key 检索value 数据，在业务流程中使用字典对少量多个数据进行临时存储和数据检索比较简单和快捷，多个数据的检索处理效率较高。参考案例
【字典多用户登录】

字典用在什么地方？

字典主要针对多个数据存储情况下，单个数据的快速检索上，所以程序中如果有对于多个数据存储和检索的话，优先考虑使用字典简化操作过程。
参考案例【字典多用户登录】

多用户登录实现

多用户登录使用多种组合类型进行实现，梳理不同组合数据类型的特点，整理他们的应用场景。

（1）列表实现

列表中可以存储多个数据，底层是通过顺序表实现的，如果多个数据是用于遍历展示或者遍历批量操作的话，使用列表是较好的选择，如果批量数据是用于个别数据频繁查询的话，列表中存储的数据越复杂它的效率越低。

"""
列表实现多用户登录
    注册
    登录
"""
# 记录系统用户
users_list = list()
# 定义变量，标注用户注册是否成功
is_reg = False

# 展示登录界面
while True:
    print("\t\t列表多用户登录")
    print("~~~~~~~~~~~~~~~~~~~~~~~~~~~")
    print("\t\t1.用户登录")
    print("\t\t2.用户注册")
    print("\t\t3.退出系统")
    print("~~~~~~~~~~~~~~~~~~~~~~~~~~~")

    choice = input("请输入您的选项：")
    if choice == "1":
        # 登录
        login_username = input("请输入账号：")
        login_password = input("请输入密码：")
        # 遍历判断 是否登录成功
        for c_user in users_list:
            if login_username == c_user[0] and login_password ==c_user[1]:
                # 登录成功
                input("登录成功，按任意键继续...")
                exit(1)
        else:
            input("账号或者密码有误，按任意键继续...")
            continue
    elif choice == "2":
        # 注册
        while True:
            reg_username = input("请输入账号：")
            reg_password = input("请输入密码：")

            # 判断账号是否已经存在
            for user in users_list:
                if reg_username == user[0]:
                    print("您注册的账号已经存在，请使用其他账号注册")
                    is_reg = False
                    break
            else:
                print("账号可用，开始将用户信息添加到系统中。。。")
                is_reg = True

            if not is_reg:
                continue

            # 添加用户
            users_list.append([reg_username, reg_password])
            input("账号注册成功，按任意键返回登录菜单")
            break
    elif choice == "3":
        # 退出系统
        exit(1)
    else:
        input("您输入有误，按任意键继续。。。")
        continue

（2）元组实现？

思考？元组中存储的数据一旦确定是不允许修改的，所以元组不能用于项目中数据增加/删除/修改的操作，但是元组可以规范项目中的一些固定数据，如项目中的产品类型、用户登记、首页菜单等等；甚至都可以用于在程序中存储唯一的管理员信息如(“admin”, [“123456”]) ，账号不允许修改，密码是一个列表~可以通过修改列表中的数据来修改密码。

（3）集合实现？

思考？集合中可以用于存储多个数据，但是集合中的数据没有顺序，这就导致了如果单纯使用集合存储用户信息的话，是没有办法规范和规定每个数据的特征的，所以集合不能用于将多个带有特征的数据直接存储，如账号、密码如果直接存储在一个集合中后就没有办法进行区分了。

（4）字典实现

"""
字典实现多用户登录
    注册
    登录
"""
# 记录系统用户
users_dict = dict()
# 定义变量，标注用户注册是否成功
is_reg = False

# 展示登录界面
while True:
    print("\t\t字典实现多用户登录")
    print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
    print("\t\t1.用户注册")
    print("\t\t2.用户登录")
    print("\t\t3.退出系统")
    print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")

    choice = input("请输入您的选项：")
    if choice == "1":
        # 注册
        reg_username = input("请输入注册账号：")
        reg_password = input("请输入注册密码：")

        # 判断账号是否存在
        if reg_username in users_dict:
            input("您输入的账号存在，按任意返回重新注册")
            continue

        # 添加信息到字典中
        users_dict[reg_username] = {"username": reg_username, "password": reg_password}
        input("注册成功，按任意键返回重新登录")

    elif choice == "2":
        # 登录
        login_username = input("请输入您的账号：")
        login_password = input("请输入您的密码：")

        # 判断登录是否成功
        if login_username in users_dict:
            # 账号存在，判断对应的密码
            if login_password == users_dict.get(login_username).get("password"):
                # 登录成功
                input("按任意键继续")
                exit(1)
            else:
                input("您输入账号或者密码有误，请重新登录")
        else:
            input("账号不存在，请先去注册")
    elif choice == "3":
        # 退出系统
        exit(1)
    else:
        input("您输入有误，按任意键返回重新输入")

四种组合数据类型

• 列表：存储的数据有顺序、可以重复，经常用于临时存储批量数据【在使用的时候需要遍历的数据】；列表中不适合存储大量数据【严重浪费内存空间】
• 元组：一个简化的列表，数据一旦确定不允许修改，经常用于项目中固定数据的声明
• 集合：存储数据没有顺序，不可以重复， 经常用于数据剔重
• 字典：结合了列表和集合的所有优势，并且字典的操作方式非常灵活，所以在项目中只要是设计到多个数据的操作，优先考虑字典；【注意：如果数据有且只有遍历一种操作方式时，优先使用列表或者集合】