# encoding=utf-8
"""
一、列表操作
1、应用场景
（1）多个值需要用到多个变量，且多个变量之间没有直接关系，使用不方便
（2）需要使用一个变量记录全班所有人的名字
（3）列表一般用于存放同种类型的数据，记录多个对象的同一个信息
2、列表定义
（1）是一个可修改的，元素以逗号分割，以中括号包围的有序序列
（2）是内置的基础数据类型存储容器，用于存储一组数据的有序序列
（3）列表中的元素更加具有灵活性，可以是任意的对象类型
（4）可以通过list方法将其他类型转换为列表
（5）特点：可变的，中括号包围 ,有序，序列【序列一定是可迭代对象】
（6）使用：一般用于存放同种类型的数据，记录多个对象的同一个信息
（7）格式：变量名=[元素1，元素2，元素3]
3、特点
（1）列表是有序的
（2）列表中可以存储重复的数据
（3）列表中可以存储不同数据类型的数据
（4）列表是一个可变的数据类型，可以修改的
（5）强调整体，记录整体的某一个特征
4、增加操作
（1）列表名.append(obj)：列表末尾(列表最后位置)追加一个元素
（2）列表名.insert(index,obj)：在指定位置添加一个元素；超过最大索引，插入到最后位置；小于最小索引，插入到最开始位置
（3）列表名.extend(iterable)：可迭代对象(序列), 将序列中的元素一次性的追加在列表的末尾
5、删除操作
（1）列表名.pop(index)：删除指定位置的元素, 返回被删除的元素
（2）列表名.pop()：默认删除列表最后一个元素
（3）列表名.remove(obj)：删除第一次满足条件的指定元素，不存在会报错
（4）列表名.clear()：清空列表, ---> 空列表
（5）del内置的关键字，删除
A、del 列表名[index]：删除列表中的某个指定索引值的元素
B、del 列表：来删除整个列表
C、del str：删除一个字符串
6、修改操作：取出数据，重新赋值
（1）列表名[索引值]=新值：通过索引值进行更改
（2）列表名.reverse()：反转列表，将列表中的元素倒序排序
（3）列表名.sort(key,reverse=False)：按照Unicode编码排序，对原列表进行修改
A、key：排序的规则
B、reverse：默认为False正序，可以修改为True-倒序
（4）sorted(列表)：对列表进行排序，返回新的列表
（5）sort()与sorted()的区别
A、区别：sort()没有返回值，对对象本身进行操作；sorted()有返回值，返回新对象
B、sort()对对象本身进行操作，没有返回值
C、sorted()生产出了一个新的对象，需要将生成的对象进行返回
D、sorted()不会操作原对象，原始数据不会丢失，适合多地方使用
E、sorted()的缺点：增加了内存的存储空间
7、查询操作
（1）len(列表名)：查看列表内部的元素个数
（2）通过索引查询索引对应的元素：列表名[index]
（3）列表名.count(obj)：查询元素在列表中出现的次数
（4）列表名.index(obj)：查询元素从左开始第一次出现在列表中的索引值,查询不到报错
8、列表嵌套
（1）列表嵌套是指在列表中的元素有列表类型的元素
（2）查询嵌套列表中的元素需要使用多次索引或切片
9、列表推导式
（1）形式1：变量名(列表)=[表达式 for 变量 in 可迭代对象]
（2）形式2：变量名(列表)=[表达式 for 变量 in 可迭代对象 if 条件]
（3）形式3：变量名=[表达式(变量2) for 变量1 in 列表1 for 变量2 in 变量1]
10、推导式执行流程
（1）遍历出列表中的内容给变量，表达式根据变量值进行逻辑运算
（2）遍历列表中的内容给变量，然后进行判断，符合的值在给表达式
（3）列表推导式就是将for循环得到的元素直接组合封装到一个列表中，简化了代码
（4）适当使用列表推导式可以提高代码层次，但过度使用反而会降低代码的可读性，因此使用需谨慎！！
11、推导式好处和不足
（1）优点：简化代码，提高代码的简洁性
（2）不足：降低代码的可读性
（3）建议：偶尔出来拉拉代码的档次，但是不要太影响形象
12、深浅拷贝
（1）列表在内存中的数据存储：整个列表有个内存地址，列表中的每个元素(变量), 每个变量存储对应数据的内存地址
（2）赋值
A、将列表中的所有数据及本身的内存地址交付
B、只要变动，赋值结果也随之变动
C、修改原列表会影响赋值列表
（3）浅拷贝：只拷贝列表的最外层，内部全部引用
A、内层嵌套列表与被拷贝对象指向同一块地址
B、通过浅拷贝出来的列表, 一旦内层嵌套列表发生改变, 拷贝对象和被拷贝对象的内层嵌套列表都会发生改变
C、修改最外层列表，不会影响浅拷贝对象，修改列表内层对象会影响浅拷贝对象
D、第一层创建的是新的内存地址
E、从第二层开始, 指向的都是同一个内存地址
F、格式：list对象.copy()
（4）深拷贝：嵌套的可变数据类型重新开辟一块内存空间
A、需要使用copy模块中的deepcopy()方法
B、拷贝对象与被拷贝对象, 拥有独立的内存空间, 一方发生改变,另一方不受影响
C、拷贝所有可变类型，原列表改变不影响深拷贝对象
13、拷贝方法
（1）copy方法-浅拷贝
A、拷贝当前列表，通常赋值给另外的变量
B、浅拷贝过程中，只是独立生产了最外层，而对于嵌套层是公用的
（2）deepcopy方法-深拷贝
14、深浅拷贝区别
（1）浅拷贝描述
A、第一层的属性值是基本数据类型时，新的对象和原对象互不影响
B、第一层的属性值是引用数据类型时，新对象和原对象的属性值其指向的是同一块内存地址
（2）深拷贝描述
A、会另外创造一个一模一样的对象，新对象跟原对象不共享内存
B、修改新对象不会改到原对象
二、元组操作
1、定义
（1）元组是一个不可修改的,元素以逗号分隔的，以小括号包围的有序序列
（2）用于存储一组数据的有序序列, 一旦创建, 元组中的各个元素不允许修改
（3）是基础数据类型之一，可看成一个不可修改的列表
（4）格式：变量名=(元素1，元素2，元素3)
（5）单元素元组必须在元素后面加逗号，否则返回元素类型
2、特点
（1）元组有序
（2）元组是不可变的数据类型，不可修改
（3）元组中可以存储重复的数据
（4）元组中可以同时存储不同数据类型的数据
3、创建
（1）空元组：元组名=tuple() | 元组名=()
（2）单个元素的元组：tuple(数据1,)
（3）多个元素的元组：元组名=(数据1,,数据2,数据3...)
4、多维元组
（1）元组内部的元素的类型是元组
（2）获取元组的一个元素需要两次索引或切片
5、增加操作
多维元组的中二级可变元素可以改变--与内部元组类型操作相同
6、删除操作
（1）格式：del 元组名
（2）只能删除整个元组, 不能单独删除元组中的个别元素
7、修改操作
一维元组不支持元素的修改，多维元组的中二级可变元素可以改变--与内部元素类型操作相同
8、查询操作
（1）元组名.index(数据,start,end)：在指定范围内，查找指定元素在元组中的索引值（start取到，end取不到）
（2）元组名.count(数据)：计算指定元素在元组中出现的次数
（3）元组名[index]：根据索引从指定元组中获取指定数据
9、元组嵌套和类型转换
（1）元组内部的数据可以是任意类型，也包括元组本身
（2）嵌套元组获取元素需要使用两次索引或切片
（3）嵌套元组操作由内部包含的元素类型方法决定
（4）通过关键字tuple()可将可迭代数据转换成元组类型数据
（5）元组是不可迭代对象，内置枚举方法enumerate(iter,[start=0])返回一个元组(index,value)，遍历该对象，一个变量接收是元组类型。两个变量接收，第一个是编号，第二个为元素本身
10、应用场景
（1）用户自定义元组：需要保存的数据为不能改变的内容。用元组保存全班人的姓名
（2）某些函数返回值是元组类型
（3）程序中不可变的固定数据(如身份)
三、集合操作
1、集合(set)
（1）集合是盛放多个数据的一种类型，是基础数据类型之一
（2）用于存储一组无序的，唯一的、不重复的，不可修改类型的数据
2、创建
（1）创建空集合：集合名=set()
（2）创建非空集合：集合名={元素1，元素2...} | 集合名=set(元素1，元素2...)
3、特点
（1）集合是无序的
（2）集合中的元素是不重复的，唯一的
（3）集合中存储的数据必须是不可变的数据类型
（4）集合是可变的数据类型
4、增加操作
（1）集合名.add(数据)：添加不可变类型数据，若添加可变类型数据会报错
（2）集合名.update(可迭代数据)：将可迭代对象中和集合中不重复的元素添加到集合中
5、删除操作
（1）集合名.pop()：将集合中的元素随机删除，返回删除的值
（2）集合名.remove(元素)：删除指定的元素，元素不存在会报错
（3）集合名.discard(元素)：删除指定的元素，元素不存在会报错
（4）集合名.clear()：将集合清空，剩余空集合
（5）del 集合名：删除整个集合变量
6、应用场景：去重
（1）元素在集合中只能存储一次，可以用来把重复项从其他数据类型中过滤掉，只要把其他类型转换为一个集合(set)，再转换回来即可去重
（2）在处理较大的数据集合的时候，两个集合的交集包含了两个领域中共有的对象，并集包含了两个集合中的所有项目
7、数学计算
（1）集合1.difference(集合2)：获取两个集合的差集 == 集合1-集合2-->第一个集合有，第二个集合没有
（2）集合1.difference_update(集合2)：获取两个集合的差集并将结果更新到前面集合中 == 集合1-=集合2
（3）集合1.symmetric_difference(集合2)：获取两个集合共同的差集/反交集 == 集合1^集合2-->取非公共部分
（4）集合1.symmetric_difference_update(集合2)：获取两个集合共同的差集并更新到前面集合中 == 集合1^=集合2
（5）集合1.isdisjoint(集合2)：判断两个集合是否没有交集
（6）集合1.intersection(集合2)：获取两个集合的交集 == 集合1&集合2-->取公共部分
（7）集合1.intersection_update(集合2)：获取两个集合的交集并将结果更新到前面集合中 == 集合1&集合2
（8）集合1.union(集合2)：获取两个集合的并集 == 集合1|集合2-->取所有部分，不包括重复数据
（9）集合1.update(集合2)：获取两个集合的并集，并将数据更新到前面集合中 == 集合1|=集合2
（10）集合1.issubset(集合2)：子集-判断前面集合中的数据是不是包含在后面集合中 == 集合1<集合2-->判断集合是不是另一集合的子集
（11）集合1.issuperset(集合2)：超集-判断后面集合中的数据是不是包含在前面集合中 == 集合1>集合2
四、字典操作
1、定义：是一个元素以大括号包围，呈键值对格式，以逗号分隔的，无序的，可以修改的序列
（1）以键值对格式的数据保存的数据类型是字典（dict），是唯一内建的映射类型
（2）变量值的数据结构成为映射（mapping），可以通过变量名引用变量值
（3）一般变量名称为键（key），变量值称为值（value），整体称之为键值对
（4）字典的key不能是可修改数据类型，不可以重复；value可以是任意数据类型，可以重复
（5）将数据的类型和数据的值一同存放映射在一个容器中，使之按照一定的对应的规则建立关系
（6）可以通过一边的数据唯一确定另一边的数据（哈希算法）的容器
2、键值对
（1）字典以键值对的方式存放数据key-value
（2）字典的键只能是不可变数据类型，是惟一的，多个键不能重复，否则只会保留最后的键值
（3）字典的值可以是任意数据类型，可以重复
（4）字典不是序列，但是可以进行赋值和遍历--注意，只会拿到键，拿不到值
3、字典（dict）
（1）是内置的基础数据结构之一
（2）是一组无序的键值对的组合
（3）容器中存储的是成对的数据
（4）是唯一一种映射关系的数据类型
（5）强调个体，记录个体的多个特征
4、创建
（1）创建空字典：dct={} | dct=dict()
（2）创建多个数值的字典：dct={"键1":"值1","键2":"值2"}
5、特点
（1）字典是无序的，没有索引，只能以键取值
（2）字典的key(键)必须是不可变的数据类型
（3）字典的value(值)可以是任意的数据类型
（4）字典是可变的数据类型
6、应用场景：保存一些事物的多个信息
7、增加操作
（1）字典名[key]=value：键不存在，则增加键值对；key存在，则更新数据
（2）字典名.setdefault(key,value)：键不存在，则增加键值对；key存在，则不操作
（3）字典名.copy()：浅拷贝，拷贝字典给新变量
8、修改操作
（1）字典名[key]=value：通过key添加value值，如果key存在则覆盖
（2）字典名.update(dict)将后面的字典合并到前面字典中，相同键覆盖，不同键增添
9、查询操作
（1）通过键查值：字典名[key]查询指定key对应的值
（2）字典名.keys()：获取字典所有的键，返回的是字典键类型，可迭代，可通过list强制转换成列表类型
（3）字典名.values()：获取字典所有的值，可迭代
（4）字典名.items()：获取字典中的所有键值对，可迭代，遍历以元组的形式展示
（5）字典名.get(key,设置无键返回值)：获取指定键的value，若无键，则返回None，可设置无键返回值
（6）字典名.update(dict)：以字典格式更新指定键的内容，键不存在，创建键和值
（7）len(字典名)：获取自定中字典的个数
（8）in：判断指定的键在字典中【数据 in 字典名】
（9）not in：判断指定的键不在字典中【数据 not in 字典名】
（10）for循环遍历：通过循环的方式可以在字典中、keys方法、values方法、items方法中获取各个值
10、删除操作
（1）字典名.pop(key)：删除key对应的键值对，返回对应的值（弹出key对应的字典值）
（2）字典名.popitem()：删除字典中的最后一个键值对，以元组形式返回对应的键值对
（3）clear()清空字典，只剩空字典
（4）del会删除字典变量
"""
import copy
import os
import random
print("------------列表的声明操作------------")
lst1 = list()
print("list()声明空列表：",lst1)
lst2 = []
print("[]声明空列表：",lst2)
lst3 = ["tom"]
print("['tom']声明列表：",lst3)
lst4 = ([3.14,False])
print("([3.14,False])声明列表：",lst4)
# 定义列表：包含数字和字符串
lst5 = ['zs','ls','ww','ml','hello',True,1.5,3+2j]
print(f"定义包含内容的列表：{lst5}")
print("------------列表的增加操作------------")
# 列表名.append(数据)：追加，在列表的尾部加入指定的元素
lst6= ["张国荣","梁朝伟","张学友","梁家辉"]
print(f"原列表：{lst6}")
# 将一个列表的数据复制到另一个列表中
lst7 = lst6
print(f"为变量赋值列表：{lst7}")
lst8 = lst6.copy()
print("copy()复制列表：",lst8)
lst9 = lst6[:]
print(f"全切片获取整个列表：{lst9}")
# 列表名.append(obj)：列表末尾追加一个元素
print("列表名.append(数据)：向列表末尾增加指定的元素")
lst6.append("张学友")
print(f"列表末尾追加元素：{lst6}")
lst6.append(2020)
print("列表末尾追加整数：",lst6)
lst6.append(["青云门","陆雪琪"])
print("列表末尾追加列表：",lst6)
# 列表名.insert(index,obj)：在指定位置添加一个元素；超过最大索引，插入最后位置；小于最小索引，插入到最开始位置
print("列表名.insert(位置数,数据)：向列表指定位置插入元素，超过最大索引值-默认末尾插入，小于最小索引值，默认开头插入：")
lst6.insert(2,"张学友")
print(f"列表索引2位置插入元素：{lst6}")
lst6.insert(-2,"张学友")
print(f"列表索引-2位置插入元素：{lst6}")
lst6.insert(200,"杨超越")
print(f"列表最后位置插入元素：{lst6}")
lst6.insert(-200,"杨超越")
print(f"列表开始位置插入元素：{lst6}")
# 列表名.extend(iterable)：可迭代对象(序列), 将序列中的元素一次性的追加在列表的末尾
print("列表名.extend(可迭代数据)：将可迭代对象的多个元素拆分，分别插入列表尾部")
lst6.extend("天音寺")
print("列表末尾增加数据：",lst6)
lst6.extend(["12","hello","lst008"])
print(f"列表末尾添加可迭代元素：{lst6}")
print("------------列表的修改操作------------")
# 列表元素重新赋值
# 列表名[索引值]=新值：通过索引值进行更改
print("列表名[索引]=新赋值：修改指定索引位置的元素")
lst6[-1] = "张学友"
print(f"修改列表末尾的数据后的列表：{lst6}")
# 列表倒序
print("列表名[::-1]：步长值-1时倒序列表中的各个元素")
lst6 = lst6[::-1]
print(f"列表倒序后的列表：{lst6}")
# 列表排序：列表名.sort(key,reverse=False)：按照Unicode编码将列表中的元素从小到大排序
print("列表名.sort()将列表中的元素从小到大排序（所有元素同一类型）")
lst6.sort()
print(f"列表元素从小到大排序：{lst6}")
# 更改排序方式：默认从小到大，加reverse=True参数从大到小
# 列表名.sort(key,reverse=True)：按照Unicode编码将列表中的元素从大到小排序
lst6.sort(reverse=True)
print(f"列表元素从大到小排序：{lst6}")
print("内置方法sorted(可迭代数据)将元素排序，返回原类型的新数据")
# 内置方法sorted(可迭代数据)将元素排序，返回迭代器对象
lst6 = sorted(lst6)
print(f"内置方法将列表排序：{lst6}")
print("列表名.reverse()将列表中所有元素倒序")
# 列表名.reverse()：反转列表，将列表中的元素倒序排序
lst6.reverse()
print(f"列表再次倒序的列表：{lst6}")
# 内置方法倒序：内置方法reversed(可迭代数据)将元素倒序，返回迭代器对象
print("内置方法reversed(可迭代数据)将元素倒序，返回迭代器对象")
reversed(lst6)
print(f"内置方法将列表倒序：{lst6}")
print("------------列表的查找操作------------")
print("列表中数据的个数：",len(lst6))
print("列表中最大的数据：",max(lst6))
print("列表中最小的数据：",min(lst6))
print("for循环遍历列表数据：")
for name in lst6:
print(name," | ",end="")
# 列表名[索引]：通过索引查找元素，返回索引对应的元素
print("列表名[索引]：通过索引查找元素，返回索引对应的元素")
print(f"查找索引为3的元素：{lst6[3]}")
# 列表名.index(obj)：查询元素从左开始第一次出现在列表中的索引值,查询不到报错
print("列表名.index('数据')：通过元素查索引，返回元素对应的位置，只会查找到第一个符合的元素")
print(f"查找指定元素‘张学友’的索引：{lst6.index('张学友')}")
# 列表名.count(obj)：查询元素在列表中出现的次数
print("列表名.count('元素')：查找指定的元素在列表中出现的次数")
print(f"查找指定元素'张学友'在列表出现的次数：{lst6.count(2)}")
print("------------列表的删除操作------------")
# 列表名.pop()：删除列表中的末尾元素
print("列表名.pop()：删除列表中的末尾元素")
lst6.pop()
print(f"删除列表末尾的元素：{lst6}")
# 列表名.pop(索引)：删除并返回指定位置的元素，不在索引范围内会报错
print("列表名.pop(索引)：删除并返回指定位置的元素，不在索引范围内会报错")
print(f"删除的指定位置：{lst6.pop(6)}，删除之后的列表：{lst6}")
# 列表名.remove(元素)直接删除指定列表中的元素，若不在，则报错
print("列表名.remove(元素)直接删除指定列表中的元素，若不在，则报错")
lst6.remove("hello")
print(f"删除指定位置后的列表：{lst6}")
# del 列表[索引]：删除列表指定索引位置的元素
print("del 列表索引：删除列表指定索引位置的元素")
del lst6[-1]
print(f"删除末尾的元素后的列表：{lst6}")
# del 列表[切片]：删除列表指定切片的元素
print("del 列表切片：删除列表指定切片的元素")
del lst6[-3:-1]
print(f"删除指定切片后的列表：{lst6}")
# 列表名.clear()清空列表所有元素
print("列表名.clear()清空列表所有元素")
lst6.clear()
print("请空列表后的列表")
print("del 列表名：删除指定的列表")
del lst6
# print(lst6)
# 深浅拷贝
# 原列表
lst5 = [1, 2, 3, 4, 5, 6]
# 赋值
lst6 = lst5
# 浅拷贝
lst7 = lst5.copy()
lst = copy.copy(lst5)
# 深拷贝
lst8 = copy.deepcopy(lst5)
print("赋值 ：记录了列表和内部数据的地址，但是地址都没有发生改变")
print("浅拷贝：列表的存储地址发生了改变，内部存储的不可变类型数据地址发生了改变，可变类型数据的地址没有改变")
print("深拷贝：列表的存储地址发生了改变，内部存储的数据地址也发生了改变")
print("原列表增加元素")
lst5.extend([8])
print("原列表数据：", lst5, id(lst5[0]))
print("赋值改变：", lst6, id(lst6[0]))
print("浅拷贝未变：", lst7, id(lst7[0]))
print("深拷贝未变：", lst8, id(lst8[0]))
lt5 = [1, 2, [3, 4]]
lt6 = lt5
lt7 = lt5.copy()
lt8 = copy.deepcopy(lt5)
print("原列表内部可变数据增加元素")
lt5[2].insert(2, 5)
print("原列表不可变数据：", lt5[0], id(lt5[0]))
print("赋值改变：", lt6[0], id(lt6[0]))
print("浅拷贝改变：", lt7[0], id(lt7[0]))
print("深拷贝未变：", lt8[0], id(lt8[0]))
print("==================")
print("原列表可变数据：", lt5[2], id(lt5[2]))
print("赋值改变：", lt6[2], id(lt6[2]))
print("浅拷贝改变：", lt7[2], id(lt7[2]))
print("深拷贝未变：", lt8[2], id(lt8[2]))
print("==================")
print("原列表可变数据内部数据：", lt5[2][0], id(lt5[2][0]))
print("赋值改变：", lt6[2][0], id(lt6[2][0]))
print("浅拷贝改变：", lt7[2][0], id(lt7[2][0]))
print("深拷贝未变：", lt8[2][0], id(lt8[2][0]))
# 反向输出一个列表
print("请输入9个数字：")
lst1 = [int(input()) for _ in range(5)]
lst2 = lst1
print(f"生成列表：{lst1}")
lst1.sort()
print(f"列表从小到大排序：{lst1}")
# 排列10个数字
for i in range(len(lst2),-1):
min = i
for j in range(i + 1, 10):
if lst2[min] > lst2[j]: min = j
lst2[i], lst2[min] = lst2[min], lst2[i]
print(f'自定义方法排列列表：{lst2}')
lst1.reverse()
print(f"列表反向输出：{lst1}")
# 求一个3*3矩阵主对角线元素之和，利用双重for循环控制输入二维数组，再将aii累加后输出。
a = []
sum = 0.0
print("\n请输入9个数字：")
for i in range(3):
a.append([])
for j in range(3):
a[i].append(float(input()))
print("您得到的3*3矩阵列表是：", a)
for i in range(3):
sum += a[i][i]
print("这个3*3矩阵个元素和是：", sum)
# 比较两个列表中的元素, 找出不相同的元素并保存在列表3中
lst1 = ["Sun", "Mon", "Tue", "Wed", "Fri", "Sat"]
lst2 = ["Sun", "Tue", "Thu", "Sat", "Tom"]
lst3 = []
for l1 in lst1:
if l1 not in lst2:
lst3.append(l1)
for l2 in lst2:
if l2 not in lst1:
lst3.append(l2)
print(lst3)
# 使用列表嵌套，完成8名老师随机分配3个办公室, 办公室人数无要求，输出哪个办公室有哪些老师？老师可用a, b, c, d, e, f, g, h代替
office = [[], [], []]
teachers = ["a", "b", "c", "d", "e", "f", "g", "h"]
for i in teachers:
a = random.randint(0, 2)
office[a].append(i)
print(office)
# 打印出杨辉三角形（要求打印出10行）
print("打印出杨辉三角形：")
a = []
for i in range(10):
a.append([])
for j in range(10):
a[i].append(0)
for i in range(10):
a[i][0] = 1
a[i][i] = 1
for i in range(2, 10):
for j in range(1, i):
a[i][j] = a[i - 1][j - 1] + a[i - 1][j]
from sys import stdout
for i in range(10):
for j in range(i + 1):
stdout.write(str(a[i][j]))
stdout.write(' ')
print()
# 去除列表空值，并倒叙排列
lst = ["", "苹果", "香蕉", "橘子"]
result = [i for i in lst if i != ''][::-1]
print("列表去空，倒叙排列:", result)
# 编写input()和output()函数输入，输出5个学生的数据记录
N = int(input("请输入学生数量："))
stu = []
subject = ["语文", "数学", "英语"]
for i in range(N):
stu.append(['', '', []])
for i in range(N):
stu[i][0] = input('请输入学生姓名:')
stu[i][1] = input('请输入学生学号:')
for j in range(3):
stu[i][2].append(int(input("请输入" + subject[j] + "成绩:")))
print("您输入的学生记录是：", stu)
for i in range(N):
print('学生：%-4s，学号：%-10s，' % (stu[i][0], stu[i][1]), end=" ")
for j in range(3):
print(subject[j] + '成绩:%-4d，' % stu[i][2][j], end=" ")
# 有一个已经排好序的数组。现输入一个数，要求按原来的规律将它插入数组中： 首先判断此数是否大于最后一个数，然后再考虑插入中间的数的情况，插入后此元素之后的数，依次后移一个位置： 0 作为加入数字的占位符
a = [1, 4, 6, 9, 13, 16, 19, 28, 40, 100, 0]
print('原始列表：', end=" ")
for i in range(len(a)):
print(a[i], end=" ")
number = int(input("\n插入一个数字："))
end = a[9]
if number > end:
a[10] = number
else:
for i in range(10):
if a[i] > number:
temp1 = a[i]
a[i] = number
for j in range(i + 1, 11):
temp2 = a[j]
a[j] = temp1
temp1 = temp2
break
print('排序后列表:', end=" ")
for i in range(11):
print(a[i], end=" ")
# 输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。
p = 0
max = 0
min = 0
array = []
# 输入 6 个数字并放入数组
print("\n请输入6个数字：")
for i in range(6):
array.append(int(input()))
# 获取最大元素并与第一个元素交换
for i in range(1, len(array) - 1):
p = i
if array[p] > array[max]: max = p
k = max
array[0], array[k] = array[k], array[0]
# 获取最小元素并与最后一个元素交换
for i in range(1, len(array) - 1):
p = i
if array[p] < array[min]: min = p
l = min
array[5], array[l] = array[l], array[5]
print('最大的与第一个元素交换，最小的与最后一个元素交换结果：', end=" ")
for i in range(len(array)):
print(array[i], end=" ")
# 给定一个整型列表，如果元素出现的次数为奇数次，就输出：求每个元素出现的次数，判断是否是奇数次
num2 = [1, 2, 4, 1, 4, 2, 1, 3, 1, 4, 5, 3]
for x in set(num2):
if num2.count(x) % 2 != 0:
print(x)
print("请输入7位评委的分数：")
s = [input() for i in range(10)]
print("七位评委的打分：{}".format(s))
print("最高分为：{}".format(max(s)))
print("最低分为：{}".format(min(s)))
# 去掉最低分，最高分，最后计算平均分
print("最后得分：{}".format((sum(s) - max(s) - min(s)) / 8))
# 猴子游戏，报3出局
# 约瑟夫环
monkey = []
n = 3
m = 41
i = 0
t = 1 # t<n
# 最后一只猴子要留下
for x in range(1, m + 1):
monkey.append(x)
print(monkey)
print("共有{}只猴子".format(m))
while len(monkey) > 1:
i = (i + 1) % len(monkey)
t = t + 1
if t == n:
del monkey[i] # 删除指定下标的元素
t = 1 # 数到3，重新归1，循环数数，123,123,123，数到3的猴子出局
print(monkey)
# 数据去重，将列表中重复的数据删除
# 不建议用for循环去做
# 成绩添加
# 列表数据的处理（计算平均值、找出最高分，最低分）：60以下 60-69 70-79 80-89 90-100
# len(list),返回列表元素的个数
# max(list），返回列表元素最大值
# min(list），返回列表元素最小值
# sun(list),返回列表元素总和
scores = [15, 46, 58, 96, 73, 82, 49, 67]
print("直接输出列表：", scores) # 或者for循环打印输出
print("循环遍历输出：", end="")
for x in scores:
# 比较两种方法的不同,多个输出，逗号隔开
print(x, " ", end="")
input("原有成绩已显示，任意键继续")
os.system("cls")
value = input("请输入成绩值(1~100的整数),输入q结束:")
while (type(value) == int) and (value != "q"):
if int(value) >= 0 and int(value) <= 100:
scores.append(value)
print("您新添了成绩：", value)
print(scores)
else:
print("您的输入不合法，请重新输入")
# 列表嵌套
print("列表嵌套指的是列表中可以多层次的嵌套列表（矩阵）")
lst1 = [['a', 'b'], ['abc', 100], 'abc', 100, [0.9, 0.7]]
print("嵌套实例1：", lst1)
lst2 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print("嵌套实例2：", lst2)
lst3 = [
['a', 'b'],
['abc', 100],
[0.9, 0.7]
]
print("嵌套实例3：", lst3)
# 循环遍历出列表的每一个元素：
lst4 = [['a', 'b'], ['abc', 100], "abc", 100, [0.9, 0.7]]
for x in lst4:
# type(x) == list || isinstance(x, list)
if isinstance(x, list): # x 是列表:
print(x, "是列表")
else:
print(x, "是元素")
# 列表推导式
# 将列表中的每个元素平方后放在一个新的列表中
num_list = [x ** 2 for x in list(range(10))]
print("列表推导式将列表中的每个元素平方：", num_list)
# 练习1：将lst中每一个元素进行平方后放入到一个新列表中
lst = list(range(1, 11))
lst2 = [i * i for i in lst]
print(lst2)
# 练习2：将lst中的奇数放到一个新列表中
lst = [1, 2, 3, 4, 5, 6, 7, 8]
lst2 = [i for i in lst if i % 2 == 1]
print(lst2)
# 将一个嵌套列表数据转换成一个一维列表
lst2 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
new_list = [y for x in lst2 for y in x]
print("列表推导式将一个嵌套列表数据转换成一个一维列表：", new_list)
# 获取列表中小列表的第一个元素
lst3 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
elements = [i[0] for i in lst3]
print("列表推导式获取列表中小列表的第一个元素：", elements)
# 获取列表中小列表的第一、第二、第三个元素
elements = [lst3[i][i] for i in range(len(lst3))]
print("列表推导式获取列表中小列表的第一、第二、第三个元素：", elements)
# 获取列表中小列表的中间元素
col = [row[1] for row in lst3]
print("列表推导式获取列表中小列表的中间元素：", col)
# 有n个人围成一圈，顺序排号。从第一个人开始报数（从1到3报数），凡报到3的人退出圈子，问最后留下的是原来第几号的那位
n = int(input('请输入总人数:'))
num = []
for i in range(n):
num.append(i + 1)
i = k = m = 0
while m < n - 1:
if num[i] != 0: k += 1
if k == 3:
num[i] = 0
k = 0
m += 1
i += 1
if i == n: i = 0
i = 0
while num[i] == 0: i += 1
print("最后留下的那位的原始编号是：", num[i])
# 深浅拷贝
# 原列表
lst5 = [1, 2, 3, 4, 5, 6]
# 赋值
lst6 = lst5
# 浅拷贝
lst7 = lst5.copy()
lst = copy.copy(lst5)
# 深拷贝
lst8 = copy.deepcopy(lst5)
print("赋值 ：记录了列表和内部数据的地址，但是地址都没有发生改变")
print("浅拷贝：列表的存储地址发生了改变，内部存储的不可变类型数据地址发生了改变，可变类型数据的地址没有改变")
print("深拷贝：列表的存储地址发生了改变，内部存储的数据地址也发生了改变")
print("原列表增加元素")
lst5.extend([8])
print("原列表数据：", lst5, id(lst5[0]))
print("赋值改变：", lst6, id(lst6[0]))
print("浅拷贝未变：", lst7, id(lst7[0]))
print("深拷贝未变：", lst8, id(lst8[0]))
lst6 = [[1, 2, 3], [2, 3, 4], [5, 6, 7], 8, 9, 0]
# 赋值
lst7 = lst6
# 浅拷贝
lst8 = copy.copy(lst6)
# 深拷贝
lst9 = copy.deepcopy(lst6)
print(f"嵌套列表：{lst6}")
print(f"索引获取列表中的一个元素：{lst6[1][1]}")
print(f"切片获取列表中的序列元素：{lst6[0:1][0:1]}")
# 列表的深浅拷贝
# 简单数据类型: bool、int、float、str
# 复杂数据类型:list、tuple、set、dict
# 列表中保存的是数据的内存地址而不是数据本身
print(f"赋值操作改变的是变量的内存地址：{lst7}")
print(f"浅拷贝改变的是变量的外层数据：{lst8}")
print(f"深拷贝不改变改变变量的数据：{lst9}")
"""
名称：用户注册+用户登录升级
描述：系统原有用户账号、密码和昵称，用户输入账号和密码，自动判断是否匹配（能匹配登录；不能匹配返回输入处）；系统注册页面，用户输入账号、密码和昵称，会保存到系统中，与原有账户有同样的功能
"""
import os
import time
# 系统中存在两个用户
users = [
["admin", "123", "大牧"],
["laoliu", "111", "老刘"]
]
ok = False
while True:
# 登录菜单
os.system("cls")
print("#########中公游戏~展示页面#########")
print(" 1、用户登录")
print(" 2、用户注册")
print(" 3、退出系统")
print("###########################")
# 用户输入选项
choice = input("请输入您的选项：")
if choice == "1":
# 用户登录:直接使用登录代码
while True:
# 用户登录
os.system("cls")
print("#########中公游戏~用户登录#########")
# 提示用户输入
username = input("请输入账号：")
password = input("请输入密码：")
# 判断登录是否成功:遍历所有用户
for user in users:
# 第一次循环
print(user)
if username == user[0] and password == user[1]:
print("登录成功，即将进入首页，请稍等")
time.sleep(3)
os.system("cls")
print("#########中公游戏~首页界面#########")
print(" 1、进入英雄皮肤商城")
print(" 2、进入英雄装备商城")
print(" 3、进入休闲游戏商城")
print(" 4、返回登录菜单")
print(" 5、返回展示页面")
print(" 6、退出系统")
print("################################")
ok = True
num = input("任意键返回用户登录")
break
else:
input("账号或者密码有误，请重新登录")
ok = False
# ok 的目的：根据用户登录是否成功，判断要不要展示首页
break
elif choice == "2":
while True:
# 简易版用户注册
# 提示用户输入账号，输入密码
username = input("请输入注册账号：")
password = input("请输入注册密码：")
nickname = input("请输入注册昵称：")
for user_list in users:
print(user_list)
if username == user_list[0]:
print("账号已存在，请重新注册")
break
else:
# 将用户输入的数据，组装成一个列表
user = [username, password, nickname]
if user[0] != "" and user[1] != "" and user[2] != "":
# 将用户数据，添加到系统用户中：末尾追加一个新用户
users.append(user)
input(f"注册用户{user[2]}成功，按任意键返回展示页面")
break
else:
print("您输入的信息不全，请重新输入")
continue
elif choice == "3":
input("系统将退出，保存好个人数据，按任意键结束")
exit(1)
else:
input("没有这个选项，按任意键继续.")
# 创建空元组
tuple1 = tuple()
print("声明空元组：",tuple1)
tuple2 = ()
print("声明空元组：",tuple2)
# 创建一个元素的元组
tuple3 = ("1",)
print("声明一元素元组：",tuple3)
tuple4 = (["元组"])
print("声明一元素元组：",tuple4)
# 创建多个元素的元组
tuple4 = tuple(["春","夏","秋","冬"])
print("声明多元素元组：",tuple4)
tuple5 = ("李庚希","宣墨","朱致灵","易海蓝","昌隆","陆宇辰","梁宝羚","田晶晶")
print(f"多个元素的元组：{tuple5}")
# 元组的查询操作
print("\nlen查询元组中元素的个数：",len(tuple5))
print("查询坐标为2的位置的元素：",tuple5[2])
print("元组名.index(数据，开始索引，结束索引)：从左往右返回指定索引范围遇到的指定元素的索引，如果没有，报错")
print(f"获取'小晶晶'在元组中的索引：{tuple5.index('宣墨',1,3)}")
print("元组名.count('数据')：获取元组中指定元素的个数")
print(f"获取元组中'宣墨'出现的次数：{tuple5.count('宣墨')}")
# 获取多维元组数据
tuple6 = (("李庚希","宣墨","朱致灵"),("易海蓝","昌隆","陆宇辰"),["梁宝羚","田晶晶","安若雪"])
print(f"索引获取多维元组中的元素：{tuple6[1][1]}")
print(f"切片获取多维元组中的元素：{tuple6[1:][1:]}")
# 遍历多维元组数据
print("遍历多维元组数据：",end=" ")
tuple7 = ((100, 200),"鱿小鱼",("a", 18))
for x in tuple7:
if isinstance(x, tuple):
for i in x:
print(i,end=" ")
else:
print(x,end=" ")
# 元组的增加操作：多维元组的中二级可变元素可以改变--与内部元组类型操作相同
tuple6[2].append("张若晴")
print(f"内部列表增加一个数据：{tuple6}")
# 元组的修改操作--与内部元素类型操作相同
tuple6[2][2]="小晶晶"
print(f"内部列表修改一个数据：{tuple6}")
# 遍历二维元组
print("遍历二维元组：")
for key,value in tuple6:
print(f"{key} ----> {value}")
set1=set()
print("声明空集合：",set1)
# 普通集合
set2 = {1,2,3,4,5,6,7,8,9,1,2,3,1,2,3,1,2,3}
print("集合是可变类型数据，可以存放不可重复的、无序的、不可变类型数据的多个数据")
set3 = set(["a","b","c","d","e"])
print("声明非空集合：",set3)
print("--------单个集合增加数据--------")
set4 = set3.copy()
print("copy()复制集合：",set4)
# 增加操作
st1 = {"1","2","3","3","4","5","6"}
# add()添加不可变类型数据，若添加可变类型数据会报错
print("add()添加不可变类型数据，若添加可变类型数据会报错")
st1.add(1)
print("添加数据：",st1)
# update将后面的集合添加到前面集合中
print("update将后面的集合添加到前面集合中")
st2 = {"9","8","7"}
st1.update(st2)
print("添加集合到前面集合中：",st1)
# 删除操作
print("--------单个集合删除数据--------")
# pop()将集合中的元素随机删除，返回删除的值
print("pop()将集合中的元素随机删除，返回删除的值")
print("随机删除元素：",st1.pop(),"删除元素后的结合：",st1)
# remove(元素)删除指定的元素，元素不存在会报错
print("remove(object)删除指定的元素，元素不存在会报错")
st1.remove("3")
print("删除指定的元素3",st1)
# st1.remove("X")
# print("remove指定删除一个数据(不存在)：",st1)
# discard(元素)删除指定的元素，元素不存在会报错
print("discard(object)删除指定的元素，元素不存在不会报错")
st1.discard("3")
print("删除指定的元素3：",st1)
# clear()将集合清空，剩余空集合
st1.clear()
print("清空集合：",st1)
print("遍历所有的集合：",end=" ")
for i in st1:
print(i,end=" ")
# 创建一个包含一万个元素的从1~9的数字，统计各个数字出现的次数
lst = [random.randint(1,10) for i in range(100000)]
for i in list(set(lst)):
print(f"数值{i}，有{lst.count(i)}个")
print("~~~~~~~~~~~~~~~~获取差集~~~~~~~~~~~~~~~")
s1 = {1,2,3,4,5,6}
s2 = {4,5,6,7,8,9}
print("集合s1：",s1," | 集合s2：",s2)
print("difference：获取两个集合的差集",s1.difference(s2))
print("s1-s2：获取两个集合的差集",s1-s2)
print("~~~~~~~~~~~~~~更新差集~~~~~~~~~~~~~~~~")
s1.difference_update(s2)
print("difference_update获取两个集合的差集并将结果更新到前面集合中",s1)
s1 = {1,2,3,4,5,6}
s2 = {4,5,6,7,8,9}
s1-=s2
print("s1-=s2获取两个集合的差集并将结果更新到前面集合中",s1)
print("~~~~~~~~~~~~~~获取共同差集~~~~~~~~~~~~~")
s1 = {1,2,3,4,5,6}
s2 = {4,5,6,7,8,9}
print("symmetric_difference获取两个集合共同的差集",s1.symmetric_difference(s2))
print("s1^s2获取两个集合共同的差集",s1^s2)
print("~~~~~~~~~~~~~更新共同差集~~~~~~~~~~~~~")
s1.symmetric_difference_update(s2)
print("symmetric_difference_update获取两个集合共同的差集并更新到前面集合中",s1)
s1 = {1,2,3,4,5,6}
s2 = {4,5,6,7,8,9}
s1^=s2
print("s1^=s2获取两个集合共同的差集并更新到前面集合中",s1)
print("~~~~~~~~~~~~~~~~判断交集~~~~~~~~~~~~~~~")
s1 = {1,2,3,4,5,6}
s2 = {4,5,6,7,8,9}
print("isdisjoint判断两个集合是否没有交集",s1.isdisjoint(s2))
print("~~~~~~~~~~~~~~~~获取交集~~~~~~~~~~~~~~~")
print("intersection获取两个集合的交集",s1.intersection(s2))
print("s1&s2获取两个集合的交集",s1&s2)
print("~~~~~~~~~~~~~~~~更新交集~~~~~~~~~~~~~~~")
s1.intersection_update(s2)
print("intersection_update获取两个集合的交集并将结果更新到前面集合中",s1)
s1 = {1,2,3,4,5,6}
s2 = {4,5,6,7,8,9}
s1&=s2
print("s1&=s2获取两个集合的交集并将结果更新到前面集合中",s1)
print("~~~~~~~~~~~~~~~~获取并集~~~~~~~~~~~~~~~")
s1 = {1,2,3,4,5,6}
s2 = {4,5,6,7,8,9}
print("union获取两个集合的并集",s1.union(s2))
print("s1|s2获取两个集合的并集",s1|s2)
print("~~~~~~~~~~~~~~~~更新并集~~~~~~~~~~~~~~~")
s1.update(s2)
print("update获取两个集合的并集，并将数据更新到前面集合中",s1)
s1 = {1,2,3,4,5,6}
s2 = {4,5,6,7,8,9}
s1|=s2
print("s1|=s2获取两个集合的并集，并将数据更新到前面集合中",s1)
print("~~~~~~~~~~~~~~~~后包含前~~~~~~~~~~~~~~~")
s1 = {1,2,3,4,5,6}
s2 = {4,5,6,7,8,9}
print("issubset判断前面集合中的数据是不是包含在后面集合中",s1.issubset(s2))
print("s1<s2判断前面集合中的数据是不是包含在后面集合中",s1<s2)
print("~~~~~~~~~~~~~~~~前包含后~~~~~~~~~~~~~~~")
print("issuperset判断后面集合中的数据是不是包含在前面集合中",s1.issuperset(s2))
print("s1>s2判断后面集合中的数据是不是包含在前面集合中",s1>s2)
# del 删除集合变量
del st1
print("------------声明空字典------------")
dict1 = {}
print("创建空字典：",dict1,type(dict1))
dict2 = dict()
print("创建空字典：",dict2,type(dict2))
print("------------声明非空字典------------")
dict3 = {"name": "宣墨", "age": 24, "gender": "女", "password": "111"}
print("创建非空字典：",dict3,type(dict3))
dict4 = dict3.copy()
print("创建非空字典：",dict4,type(dict4))
# 接收一个字典作为参数
dict5 = dict({"姓名": "李小花", "年龄": 18})
print("接收字典作为参数，创建字典：",dict5)
# 接收列表套元组的数据结构--一个元组就是一个键值对
dict6 = dict([("姓名", "李小花"),("年龄", 18)])
print("接收元组数据作为参数，创建字典：",dict6)
# 接收关键字参数
dict7 = dict(name="李小花", age=18)
print("接收关键字作为参数，创建字典：",dict7)
print("------------增加数据------------")
print("原字典：",dict7)
dict8 = dict7.copy()
print("copy复制字典：",dict8)
print("字典名[key]=value：键不存在，则增加键值对；key存在，则更新数据")
dict8["status"] = "在售"
print(f"增加一个status-在售键值对：{dict8}")
print("字典名.setdefault(key,value)：键不存在，则增加键值对；key存在，则不操作")
dict8.setdefault("date", 10)
print(f"增加一个date-10键值对：{dict8}")
dict8.setdefault("status", "售罄")
print(f"修改一个status-售罄键值对：{dict8}")
dict8.update({"nickname":"杜迅","sex":"male"})
print("update在key不存在时增加键值对：",dict8)
print("------------修改数据------------")
print("字典名[key]=value：通过key添加value值，如果key存在则覆盖")
dict8["nickname"] = "xunxun"
print("D[key]在key存在时修改键值对：",dict8)
print("字典名.update(dict)将后面的字典合并到前面字典中，相同键覆盖，不同键增添")
dict8.update({"sex":"男"})
print("update在key存在时修改键值对：",dict8)
print("字典名.setdefault(key,value)：键不存在，则增加键值对；key存在，则不操作")
dict8.setdefault("name","杜迅")
print("setdefault在key存在时不做修改：",dict8)
print("------------查询数据------------")
print("字典名.items()：获取字典中的所有键值对，可迭代，遍历以元组的形式展示")
print("items获取所有键值对：",dict8.items())
print("遍历items获取各个键值对：")
for key, value in dict8.items():
print(f"{key}>>>>>>{value}")
print("字典名.keys()：获取字典所有的键，返回的是字典键类型，可迭代，可通过list强制转换成列表类型")
print("keys获取所有的keys数据：",dict8.keys(),"dct.keys()的类型：",type(dict8.keys()))
print("字典名.values()：获取字典所有的值，可迭代")
print("values获取所有的values数据：",dict8.values(),"dct.values()的类型：",type(dict8.values()))
print("字典名.get(key,设置无键返回值)获取指定键的value，若无键，则返回None，可设置无键返回值")
print("get获取key对应的value数据：",dict8.get("name"))
print("get获取key对应的value数据，无key时：",dict8.get("myName","没有此键值对"))
print("通过键查值：字典名[key]查询指定key对应的值")
print("D['key']：获取key对应的value数据：",dict8["nickname"])
print("------------删除数据------------")
# pop(key)删除key对应的键值对，返回对应的值
print("字典名.pop(key)：删除key对应的键值对，返回对应的值")
print(f"弹出key对应的字典值：{dict8.pop('status')}，弹出key对应的键值对：{dict8}")
print("pop删除key对应的键值对：",dict8)
del dict8["nickname"]
print("D[key]删除key对应的键值对：",dict8)
# dct.popitem()从后往前删除字典中的一个键值对，返回对应的键值对
print("字典名.popitem()：删除字典中的最后一个键值对，以元组形式返回对应的键值对")
print(f"删除最后一个键值对：{dict8.popitem()}，删除键值对后的字典：{dict8}")
print("clear清空字典，只剩空字典：",dict8)
print("del会删除字典变量")
del dict8
# 字典的遍历
# 创建用户字典
users = {"name": "杜迅", "age": "24", "nickname": "duxun", "password": "111"}
# 通过keys遍历
print(users.keys())
for key in users.keys():
print("key:", key, "-->value:", users.get(key))
print("------------------------")
# 通过items遍历
print(users.items())
for key, value in users.items():
print("key:", key, "-->value:", value)
# 字典的get方法
users = {
'admin': {'name': '用户', 'password': '123'},
'duxun': {'name': '杜迅', 'password': '111'},
'yuxian': {'name': '雨仙', 'password': '222'}
}
print("获取一个用户的全部信息：", users.get("admin"))
print("获取一个用户的某一项信息：", users.get("duxun").get("name"))
account = "yuxian"
print("分开获取用户全部信息：", users.get(account))
print("分开获取用户某一项信息：", users.get(account).get("name"))
# 水果信息的枚举
fruit_list = [
{'name': '苹果', 'price': 3.0, 'count': 50, 'place': '日本'},
{'name': '香蕉', 'price': 7.0, 'count': 60, 'place': '巴西'},
{'name': '大枣', 'price': 5.0, 'count': 90, 'place': '新疆'},
{'name': '蜜桃', 'price': 6.0, 'count': 80, 'place': '河北'},
{'name': '草莓', 'price': 11.0, 'count': 20, 'place': '美国'}
]
for k, v in enumerate(fruit_list, start=1):
print("水果编号：", k, "水果信息：", v)
# 找到年龄最大的人，并输出
person = {"li": 18, "wang": 50, "zhang": 20, "sun": 22}
m = "li"
for key in person.keys():
if person[m] < person[key]:
m = key
print("年龄最大的人是：", m, "最大的年龄是：", person[m])
# 输出字典003的所有key,value
info = {
'001': {'name': '张三', 'age': 20, 'address': '北京', 'score': 88},
'002': {'name': '李四', 'age': 20, 'address': '北京', 'score': 78},
'003': {'name': '王五', 'age': 20, 'address': '北京', 'score': 95},
'004': {'name': '小明', 'age': 20, 'address': '北京', 'score': 90}
}
print("输出字典003的所有key,value：")
for k, v in info['003'].items():
print("字典的key值是：", k, " ----> 字典的value值是：", v)
# 给所有北京人加100000住房补贴
print("\n给所有北京人加100000住房补贴：")
for k, v in info.items():
if v['address'] == '北京':
v['house'] = 100000
for k, v in info.items():
print("字典的key值是：", k, " ----> 字典的value值是：", v)
print("\n给所有北京人加100000住房补贴：")
for k in info.keys():
if info[k]['address'] == '北京':
info[k]['house'] = 100000
for k, v in info.items():
print("字典的key值是：", k, " ----> 字典的value值是：", v)
# 输出二维字典最大age和最小age
print("\n输出二维字典最大age和最小age")
max_age = min_age = info['001']['age']
max_key = min_key = '001'
for k, v in info.items():
if v['age'] > max_age:
max_age = v['age']
max_key = k
elif v['age'] < min_age:
min_age = v['age']
min_key = k
print('最大年龄是', max_age, max_key, info[max_key]['address'])
print('最小年龄是%d，对应的key是%s，地址是%s' % (min_age, min_key, info[min_key]['address']))
if 'a' in 'abc':
print("字符在字符串里")
if 'a' in ["a", "b", "c"]:
print("元素在列表里")
if "a" in ("a", "b", "c"):
print("元素在元组里")
if "name" in {"name": "小星星"}:
print("key在字典里")
if "小星星" in {"name": "小星星"}:
print('小星星在字典里')
# 创建字典（姓名：范冰冰、身高：168、身份：女神、爱好：打黑牛）
dict1 = {
"姓名": "范冰冰",
"身高": 168,
"身份": "女神",
"爱好": "大黑牛"
}
# 循环遍历出所有的key
print("输出字典中所有的键：", end=" ")
for k in dict1.keys():
print(k, end=" ")
print("\n输出字典中所有的值：", end=" ")
# 循环遍历出所有的value
for v in dict1.values():
print(v, end=" ")
# 循环遍历出所有的key和value
print("\n输出字典中所有的键和值：", end=" ")
for k, v in dict1.items():
print(f"键：{k}，值：{v}", end=" ")
# 在字典中添加一个键值对（男友：李晨），输出添加后的字典
# dict1["兴趣"] = "李晨"
dict1.update(兴趣="李晨")
print("字典中添加键值对：", dict1)
# 删除字典中键值对（身高：168），输出删除后的字典
dict1.pop('身高')
print("删除字典中的一个键值对：", dict1)
# 请删除字典中键“范丞丞”对应的键值对，不存在，则返回none
if dict1.get('范丞丞'): # 如果 范丞丞这个键存在
print("删除指定的键值对：", dict1["范丞丞"])
else: # 如果 范丞丞这个键不存在
print("指定的键不存在：", None)
# 获取字典中“身份”对应的值
# print("获取指定键对应的值：",dict1["身份"])
print("获取指定键对应的值：", dict1.get('身份'))
# 获取字典中“弟弟”对应的值，不存在，则返回None
print("获取字典指定键对应的值：", dict1.get('弟弟'))
# 动态给字典输入五个姓名与手机号
dict2 = {}
for x in range(5):
name = input("请输入您的姓名:")
tel = input("请输入您的电话")
# 给字典中添加键值对
dict2[name] = tel
print("您输入的5个姓名电话：", dict2)
# 统计字符串中每个字母出现的次数：获取字符串中包含的字母，对这些字母进行计数，将结果存储到字典中
s = "ECALIYHWEQAEFSZCVZTWEYXCPIURVCSWTDBCIOYXGTEGDTUMJHUMBJKHFGUKNKN"
dict3 = {}
# 遍历获取每一个字符元素
for c in s:
# 计算变量字符c在字符串中出现的次数
c_count = s.count(c)
# 字典里，相同的key值会进行覆盖
dict3[c] = c_count
print("统计字符串中每个字母出现的次数：", dict3)
# 学生信息管理系统原有信息：增删改查，显示全部，退出，姓名不能重复，可根据姓名进行查找
# 一个列表存储所有的学生：有序，元素可以是任意的数据类型
# （1）不能用元组：元组不可变，无法进行增删改的操作
# （2）不能用集合：集合中的元素类型要求不可变，无法存储字典类型数据
# 装着所有学生的列表
all_stu_list = [
{"姓名": "李小花", "年龄": 18, "年级": "高三", "班级": "2班"},
{"姓名": "王二狗", "年龄": 17, "年级": "高二", "班级": "2班"},
{"姓名": "刘三胖", "年龄": 16, "年级": "高一", "班级": "1班"}
]
# 装着所有学生姓名的列表
all_name_list = ["李小花", "王二狗", "刘三胖"]
while True:
print("*" * 60)
print("欢迎来到学生信息管理系统".center(50))
print("1. 增加学生".center(50))
print("2. 删除学生".center(50))
print("3. 修改学生".center(50))
print("4. 查找学生".center(50))
print("5. 退出系统".center(50))
print("6. 显示全部学生".center(50))
print("*" * 60)
chose = input("请输入您的选择:")
if chose == "1": # 增加学生
name = input("请输入姓名:")
# 判断姓名是否存在, 不能出现重复姓名的同学
if name in all_name_list:
print("该生已存在, 不能重复录入系统")
continue # 结束当前循环, 继续下一次循环
age = int(input("请输入年龄:")) # 将用户输入的年龄转换为整型数据
grade = input("请输入年级:")
cls = input("请输入班级:")
stu_dict = {"姓名": name, "年龄": age, "年级": grade, "班级": cls} # 新学生的信息字典
all_stu_list.append(stu_dict) # 将新学生添加到所有学生列表中
print("添加成功!")
all_name_list.append(name)
elif chose == "2": # 删除学生
name = input("请输入要删除的学生姓名:")
for stu in all_stu_list:
if name == stu["姓名"]:
all_stu_list.remove(stu)
print("删除成功")
all_name_list.remove(name)
break
else:
print("该生不存在,无法删除")
# for..in..else
# 如果执行了for..in..中的break,则不会执行else语句
# 如果遍历结束之后都没有执行for..in..中的break,则会执行else语句
elif chose == "3": # 修改学生信息
name = input("请输入修改学生的姓名:")
for stu in all_stu_list:
if name == stu["姓名"]: # 遍历获取每一个学生字典
after_name = input("请输入修改后的姓名:")
if after_name in all_name_list and after_name != stu["姓名"]: # 修改之后的姓名可以和原名字一样,但不可以和已存在的其他姓名一样
print("该生已存在, 不能重复录入系统")
after_age = int(input("请输入修改后的年龄:"))
after_grade = input("请输入修改后的年级:")
after_cls = input("请输入修改后的班级:")
after_stu = {"姓名": after_name, "年龄": after_age, "年级": after_grade, "班级": after_cls}
# 将修改前的字典替换为修改后的字典,
index = all_stu_list.index(stu) # 获取修改前字典的索引值
all_stu_list.remove(stu) # 删除旧信息字典
all_stu_list.insert(index, after_stu) # 增加新信息字典
print("修改成功!")
if after_name != stu["姓名"]: # 如果修改之后的姓名和修改之前的姓名不一致,则更新all_name_list:
# 获取旧姓名的索引值
old_name_index = all_name_list.index(stu["姓名"])
# 删除旧姓名
all_name_list.remove(stu["姓名"])
# 插入增加新姓名
all_name_list.insert(old_name_index, after_name)
break
else:
print("该生不存在,无法进行修改")
elif chose == "4": # 查找学生
name = input("请输入想要查找的学生姓名:")
if name in all_name_list:
for stu in all_stu_list:
if name == stu["姓名"]:
print("您要查找的学生信息是:", stu)
else:
print("该生不存在...")
elif chose == "5": # 退出系统
break # 结束循环
elif chose == "6": # 显示全部学生
for stu in all_stu_list:
print("学生姓名:{}\t学生年龄:{}\t学生班级:{}\t学生年级:{}".format(stu["姓名"], stu["年龄"], stu["班级"], stu["年级"]))
else:
print("输入有误, 请重新输入")
continue # 结束当前循环, 继续下一次循环
# 多重字典输出
stu = {
"1011": {
"name": "jcke",
"phone": "110",
"age": 21
},
"1012": {
"name": "lili",
"phone": "120",
"age": 22
},
"1013": {
"name": "zare",
"phone": "130",
"age": 33
}
}
# 多重字典项输出
print(stu["1011"])
# 多重字典项内容输出
print(stu["1011"]["phone"])
# 字典键名输出
phonebook = {
"benth": "10111",
"alice": "10112",
"zare": "10113"
}
print("benth number is %(benth)s" % phonebook)
# 猴子信息--字典处理
# 字典：键值对，键是唯一的，值可以不唯一,一个键可以有多个值
userInfo = {"monkey": "Hoho", "age": 50}
print("我是一只猴子，名字叫{}，已经{}岁了。".format(userInfo["monkey"], userInfo["age"]))
print(userInfo)
userInfo["monkey"] = "Jojo" # 修改键的值
userInfo["color"] = "yellow" # 增加键值对
print("我是一只猴子，名字叫{},我的毛色是{}。".format(userInfo["monkey"], userInfo["color"]))
print(userInfo)
# 创建电子通讯录，实现增删改查功能
teleDict = {}
while True:
print("请输入姓名，以#号返回……")
name = input("姓名：")
if name == "#":
break
if name in teleDict:
print(name, "已存在，电话是：", teleDict[name])
if teleDict:
for k, v in teleDict.items():
print("\t姓名：", k, "\t电话：", v)
# 行政区增添
# 键盘输入，增加字典内容
province = {}
while True:
fullname = input("请输入省级行政区全名。以#号结束输入：")
if (fullname == "#"):
break
shortname = input("请输入该省级行政区对应的简称：")
province[fullname] = shortname
print("\n省级行政区\t简称")
for k, v in province.items():
print("{}\t\t{}\n".format(k, v))
# 学生信息添加
stu = {}
while True:
xuehao = input("请输入你的学号，以#号结束输入：")
if xuehao == "#":
break
if xuehao in stu: # 学号已存在
print("学号已存在，请重新输入！")
else:
name = input("请输入该生姓名：")
score = input("请输入该生成绩：")
stu[xuehao] = {name, score}
print(stu)
print("学号\t\t姓名\t\t成绩")
for k, v, in stu.items():
# k-键名，v-键的值。键有多个值时，v[0],v[1]
print("{}\t\t{}\t\t{}\n".format(k, v[0], v[1]))
扫一扫
11-05
333
333
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
