# encoding=utf-8
"""
1、可迭代对象：通过for...in...这类语句迭代读取一条数据供我们使用的对象
2、索引（下标）
（1）索引：下标，给序列中每个元素编号
（2）作用：通过索引方式查看元素
（3）格式：可迭代对象名[索引值]
（4）编号
A、从左到右(正向)：从0开始，逐渐递增，最大索引值：长度-1【0,1,2,...】
B、从右到左：从-1开始，逐渐递减，最小索引值是：-长度【-1,-2,-3,...】
（5）可迭代对象的每个数据都是有索引值得，通过索引可以获取指定的数据
（6）长度：内置函数len(可迭代对象)，获取变量的长度
3、切片
（1）格式：可迭代对象名[start : stop : step]
A、start：起始位置，包含在内，可省略，默认为第一个元素
B、stop：结束位置，不包含在内，可省略，默认为最后一个元素
C、step：步长，可省略，默认为1,正数表示从左到右顺序，负数从右到左顺序
（2）结果：切片将序列拷贝，操作的是拷贝对象，不是原序列；生成一个新的可迭代对象，原可迭代对象不发生改变
（3）作用：一次获取多个元素
（4）正向索引：：从左向右查找数据-->数据变量名[起始索引,终止索引+1,步长为正]；默认步长值为1，可以省略；截取到末尾，结束值可以省略
（5）负向索引：：从右向左查找数据-->数据变量名[起始索引,终止索引-1,步长为负]；注意开始值对应位置必须在结束值左侧，否则取得的是空
（6）步长为负数：开始、末尾、步长全省略，取整个数据；只有-1步长值时，倒序输出；步长为负，开始值对应位置必须在结束值右侧
4、拼接
（1）+与可迭代对象相加：将两个可迭代对象拼接，生成一个新的可迭代对象【将两个可迭代对象合并成一个新的可迭代对象】
（2）*与整数相乘：将一个可迭代对象自拼，生成一个新的可迭代对象【将一个可迭代对象进行连续拼接】
5、解包
（1）一次性将可迭代对象中的每个对象赋值给不同的变量
（2）保证可迭代对象的长度和解包的变量相匹配
（3）变量和可迭代对象元素个数相比，两者个数一致：将元素按照对应位置依次赋值
（4）变量和可迭代对象元素个数相比，变量个数较多：先给没星号的按照位置依次赋值，星号元素得空可迭代对象
（5）变量和可迭代对象元素个数相比，变量个数较少：先给没星号的按照位置依次赋值，星号元素得多元素
6、遍历
（1）结构
for 字符元素 in 可迭代对象:
处理字符元素的代码
（2）通过for循环，将可迭代对象内的元素一个一个地依次取出操作
（3）查看可迭代对象的长度(元素个数)：len(可迭代对象名)
7、enumerate是枚举
（1）将编号(自动添加)和元素以元组的形式组合，主要用于为元素编号
（2）通常与for循环联合操作
8、推导式：独有特性，可以从一个数据序列构建另一个新的数据序列的结构体
9、列表推导式
（1）提供了简单的生成列表的方法
（2）语法结构
A、列表名=[表达式 for 临时变量 in 可迭代数据]
B、列表名=[表达式 for 临时变量 in 可迭代数据 if 条件]
C、列表名=[表达式 for 临时变量1 in 可迭代数据1 for 临时变量2 in 可迭代数据2]
（3）执行流程
A、循环遍历出容器中的每个元素，应用到前边的表达式中，产生的结果为最终列表中的元素
B、循环遍历出容器中的每个元素，使用if判断是否满足条件，应用表达式产生新列表中的元素
C、通过两个for循环遍历出容器的元素，将元素应用到表达式中，组成新列表中的元素
10、字典推导式
（1）是列表推导式思想的延续, 语法结构差不多, 只不过最终产生的是字典而已
（2）语法结构
A、字典名={key表达式:value表达式 for 临时变量 in 可迭代数据}
B、字典名={key表达式:value表达式 for 临时变量 in 可迭代数据 if 条件}
C、字典名={key表达式:value表达式 for 临时变量1 in 可迭代数据1 for 临时变量2 in 可迭代数据2}
11、集合推导式
（1）集合推导式和列表推导式很相似, 唯一的区别就是用{}代替[]
（2）语法结构
A、集合名={表达式 for 临时变量 in 可迭代数据}
B、集合名={表达式 for 临时变量 in 可迭代数据 if 条件}
C、集合名={表达式 for 临时变量1 in 可迭代数据1 for 临时变量2 in 可迭代数据2}
（3）特点：自动去重功能
（4）集合是可变数据类型, 集合中的元素是不可变数据类型
12、列表和字典区别
（1）列表：强调整体，记录整体的某一个特征
（2）字典：强调个体，记录个体的多个特征
13、推导式好处和不足
（1）优点：简化代码，提高代码的简洁性
（2）不足：降低代码的可读性
14、三元表达式（简化代码的一种形式）
（1）变量=条件成立返回的值 if 条件 else 条件不成立时返回的值
（2）z = 真 if 条件 else 假
（3）等价分支结构
if 条件:
条件为True执行的代码
else:
条件为False执行的代码
"""
# 列表的可迭代操作
# 定义列表：包含数字和字符串
from enum import Enum, unique
lst = ['zs','ls','ww','ml','hello',True,1.5,3+2j]
print(f"定义包含内容的列表：{lst}")
# 索引
# 根据索引获取元素
print(f"获取列表的类型：{type(lst)}，取出索引3的元素：{lst[3]}")
# 切片：序列名[start:stop:step]
# 正向索引
print(f"开始1末尾3的索引切片，步长值为1：{lst[1:3:1]}")
print(f"开始1末尾省略的索引切片：{lst[1::1]}")
# 负向索引
print(f"开始-1末尾5的索引切片：{lst[-1:5]}")
# 步长为负数
print(f"开始-1末尾-5步长值-2的索引切片：{lst[-1:-5:-2]}")
# 拼接(+)
print(f"两个列表+拼接：{lst+lst}")
# 重复(*)--只能和整数相乘
print(f"列表和整数相乘，列表重复(3次)：{lst*3}")
# 赋值
# 变量和列表元素个数相比，变量和列表一致
a,b,c,d,e,f,g,h = lst
print(f"变量与列表元素个数一致的赋值：{a,b,c,d,e,f,g,h}")
# 变量和列表元素个数相比，变量和列表一致，内部使用解包形式
a,b,*c,d,e,f,g,h = lst
print(f"变量与列表元素个数一致，内部使用解包的赋值：{a,b,c,d,e,f,g,h}")
# 变量和列表元素个数相比，变量不够
# a,b,c,d,e,f,g,h,m = lst
# print(f"变量比列表元素个数较多(错误)：{a,b,c,d,e,f,g,h,m}")
a,b,c,d,e,f,g,h,*m = lst
print(f"变量比列表元素个数较多的赋值(空)：{a,b,c,d,e,f,g,h,m}")
# 元素过多
a,b,c,d,*m = lst
print(f"变量比列表元素个数较少，解包最后的赋值(多)：{a,b,c,d,m}")
# 元素过多
*a,b,c,d,m = lst
print(f"变量比列表元素个数较少，解包开始的赋值(多)：{a,b,c,d,m}")
# 遍历列表各个元素
print("for循环遍历列表各个元素：",end=" ")
for i in lst:
print(i,end=" ")
# 元组的可迭代操作
# 定义元组：包含数字和字符串
# 创建一个元素的元组
tup1 = (None,)
print("声明一元素元组：",tup1)
tup2 = ("1",["元组"],"2","3","杜迅")
print("声明多元素元组：",tup2)
# 索引
print(f"索引获取一个数据：{tup2[0]}")
# 切片
print(f"切片获取子元组：{tup2[2:]}")
# 拼接
print(f"拼接两个元组：{tup1+tup2}")
# 重复
print(f"元组与整数相乘，元组重复：{tup2*2}")
# 赋值
a,b,c,d,*e = tup2
print(f"变量与元组元素个数一致的赋值：{a,b,c,d,e}")
# 遍历
print("遍历各个元组元素：",end=" ")
for i in tup2:
print(i,end=" ")
# 集合的可迭代操作
# 定义集合：包含数字和字符串
st = set(["a","b","c","d","e"])
print("声明非空集合：",st)
print("集合不是序列，但是可以赋值、遍历：",end="")
for s in st:
print(s,end=",")
# 赋值
a,b,c,*e = st
print(f"变量与集合元素个数一致的赋值：{a,b,c,d,e}")
# 字典的可迭代操作
dct = {"name": "宣墨", "age": 24, "gender": "女", "password": "111"}
print("创建非空字典：",dct,type(dct))
print("len(字典名)：获取自定中字典的个数")
print(f"获取字典中字典的个数：{len(dct)}")
print("in判断指定的键在字典中")
print(f"判断键'name'在字典中：{'name' in dct}")
print("not in判断指定的键不在字典中")
print(f"判断键'name'不在字典中：{'name' not in dct}")
# 字符串的可迭代操作
# 使用引号包含的数据就是字符串
sr1 = "我是一个字符串"
sr2 = "我由程序员编写"
# 索引
# 正序索引，从0开始：字符串[索引值]
print("正序索引1：",sr1[1])
# 倒序索引，从-1开始：字符串[索引值]
print("倒序索引-1：",sr1[-1])
# 切片
# 普通切片：字符串[开始索引：结束索引：步长值]
print("从0到5，步长为2切片：",sr1[0:5:2])
# 步长值为1时，可以省略
print("从0到5，步长为1切片：",sr1[0:5])
# 结束索引不写时，默认到结尾
print("从0到默认结束切片：",sr1[0:])
# 起始索引不写时，默认从开始
print("默认开始到索引6切片：",sr1[:6])
# 起始值和结尾都省略时，默认整个字符串
print("默认整个字符串：",sr1[:])
# 只有步长值为-1时，字符串倒序输出
print("步长值-1，倒序输出：",sr1[::-1])
# 步长值为-1，从开始索引向左截取
print("步长值为负数截取：",sr1[8:0:-2])
# 拼接
print("字符串可以通过符号+拼接：",sr1+sr2)
# 重复
print("字符串和整数相乘，可以重复：",sr1*2)
# 赋值
a,b,c,d= sr1[0:4]
print("字符串可以按照对应位置给变量赋值：",a,b,c,d)
# 遍历
print("字符串通过for遍历：",end="")
for i in sr1:
print(i,end=" ")
# 计算字符串长度
print("len(str)可以得到字符串的长度：",len(sr1))
# 字符串的切片：字符串是有顺序的，切取一段
path = r"C:\Users\Administrator\Desktop\笔记\005_组合数据类型\006_01_代码.py"
# 顺序编号切片：从前面向后面倒序编号进行字符串的获取，第一个字符编号是0
# 获取指定索引位置的字符 S[编号]
print("获取指定索引位置：",path[0])
# 获取指定索引范围的字符 S[开始编号:结束编号]
# 获取盘符
print("获取盘符：",path[0:3])
# 获取在哪个文件夹下的位置
print("获取文件夹：",path[0:23])
# 倒序编号切片：从后面向前面倒序编号进行字符串的获取，最后一个字符编号是-1
print("获取指定索引位置：",path[-1])
# 位置相反时，会切取数据为空
print("索引开始结束位置相反：",path[-1:-2])
# 倒序切取数据，长度是后面编号减去前面编号
print("倒序切取一段字符：",path[-4:-1])
# 切取数据~ 开始切到末尾
print("开始索引到末尾：",path[-4:])
# 步长：间隔字符数，间隔多少个字符(包含当前字符自己)切一个数据
# 以间隔获取范围的字符：s[开始位置:结束位置:步长]
print("切取指定范围字符，默认步长",path[0:9])
print("切取指定范围字符，步长值为1",path[0:9:1])
print("切取指定范围字符，步长值为2",path[0:9:2])
# 字符串倒序[只设置步长为-1，字符串出现翻转]
print("步长值为-1，字符串倒序：",path[::-1])
# 获取当前路径的文件名称(不包含文件夹路径)
print("当前文件名称：",path[-22:])
# 网页上填写的/选择的/任意输入的数据，都是字符串
# 顺序编号切片：s[:] == s[25::]
# 倒序编号切片：s[-13:] == s[-13::]
# 枚举操作
num_lst = ["a", "b", "c", "d", "e"]
num_tuple = tuple()
for i in enumerate(num_lst, start=1):
print("元素：", i, "----> 01_数据类型：", type(i))
# 卖水果：展示商品和编号（苹果、香蕉、梨子、草莓、桃子、西瓜）
fruits = ["苹果", "香蕉", "梨子", "草莓", "桃子", "西瓜"]
price = [3, 5, 3, 8, 3, 4]
fruit_list = []
for i in range(len(fruits)):
fruit_list.append("商品：" + fruits[i] + " 价格：" + str(price[i]) + "元")
show_list = []
for i in enumerate(fruit_list, start=1):
print("编号-" + str(i[0]), "", i[1])
show_list.append("编号-" + str(i[0]) + " " + i[1])
print(show_list)
num = int(input("请输入您大要购买的编号："))
print(show_list[num - 1])
# 枚举遍历
tuple = ("a", "b", "c", "d", "e", "f", "g", "h")
for k, v in enumerate(tuple):
print(k, ">>>>>>>", v)
# unique禁止枚举项有相同的枚举值
@unique
# 枚举类继承Enum
class Color(Enum):
RED = 1
GREEN = 2
BLUE = 3
BLACK = 4
color = Color.BLUE
print("按照对象获取枚举项：", color)
print("获取枚举项：", Color.GREEN)
print("获取枚举项：", Color["GREEN"])
print("获取枚举标签值：", Color.GREEN.value)
print("获取枚举标签名：", Color.GREEN.name)
print("枚举间项值比较：", Color.RED == Color.GREEN)
print("枚举is身份比较：", Color.RED is Color.BLACK)
print("按数字1获取对应枚举项：", Color(1))
print("比较Color.BLUE与第一枚举项：", color == Color(1))
print("枚举间不支持大小比较")
# 对枚举进行遍历
print("枚举遍历：", end=" ")
for v in Color:
print(v, end=" ")
# 变量转换枚举类：
Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))
print("\n将变量转换为枚举类：", Month)
print("枚举类的类型：", type(Month))
# 直接引用常量，枚举所有成员：
print("遍历枚举类中的所有成员：")
for name, member in Month.__members__.items():
print(name, '=>', member, ',', member.value)
# 对于有相同value值的枚举类进行遍历
class Color(Enum):
RED = 1
GREEN = 2
BLUE = 3
BLACK = 1
# 相同值的标签名称不会直接被输出，输出使用__members__方法遍历
print("相同值枚举遍历，使用__members__：")
for k, v in Color.__members__.items():
print(k, "---->", v)
# 把Student的gender属性改造为枚举类型：
class Student(object):
def __init__(self, name, gender):
self.name = name
self.gender = gender
@unique
class Gender(Enum):
Male = 0
Female = 1
bart = Student('Bart', Gender.Male)
if bart.gender == Gender.Male:
print('把Student的gender属性改造为枚举类型，改造成功！！！')
else:
print('把Student的gender属性改造为枚举类型，改造失败!')
# 列表推导式
# 使用列表推导，产生1-10的数组成的列表
list1 = [x for x in range(1, 11, 1)]
print("使用列表推导，产生1-10的数组成的列表：",list1)
# 使用列表推导，产生列表中每个元素的2倍组成的列表
list2 = [x * 2 for x in range(1, 11, 1)]
print("使用列表推导，产生列表中每个元素的2倍组成的列表：",list2)
# 使用列表推导，产生一个0-10的数的平方列表
list3 = [x ** 2 for x in range(0, 11)]
print("使用列表推导，产生一个0-10的数的平方列表：",list3)
# 使用列表推导，产生一个1-9的平方列表
list4 = [x ** 2 for x in range(1, 10)]
print("使用列表推导，产生一个1-9的平方列表：",list4)
# 使用列表推导，产生一个1-9的2倍的列表
list5 = [x * 2 for x in range(1, 10)]
print("使用列表推导，产生一个1-9的2倍的列表：",list5)
# 使用列表推导，求1-10内奇数的2倍组成的列表
list6 = [x * 2 for x in range(1, 11, 2)]
print("使用列表推导，求1-10内奇数的2倍组成的列表：",list6)
# 使用列表推导，求1-10内奇数的2倍组成的列表
list7 = [x * 2 for x in range(1, 11) if x % 2 == 1]
print("使用列表推导，求1-10内奇数的2倍组成的列表：",list7)
# 使用列表推导，获取99乘法表的结果组成的列表
list8 = [x * y for x in range(1, 10) for y in range(1, x+1)]
print("使用列表推导，获取99乘法表的结果组成的列表：",list8)
# 使用列表推导，将一个嵌套列表转成一个一维列表
list9 = [x for lst in [[1,2,3], [4,5,6], [7,8,9]] for x in lst]
print("使用列表推导，将一个嵌套列表转成一个一维列表：",list9)
# 使用列表推导，使用列表[[1,2,3],[4,5,6],[7,8,9]]生成一个新列表[1,4,7]
list10 = [lst[0] for lst in [[1,2,3], [4,5,6], [7,8,9]]]
print("使用列表推导，使用列表[[1,2,3],[4,5,6],[7,8,9]]生成一个新列表[1,4,7]：",list10)
# 使用列表推导，使用列表[[1,2,3],[4,5,6],[7,8,9]]生成一个新列表[2,5,8]
list11 = [lst[1] for lst in [[1,2,3], [4,5,6], [7,8,9]]]
print("使用列表推导，使用列表[[1,2,3],[4,5,6],[7,8,9]]生成一个新列表[2,5,8]：",list11)
# 使用列表推导，使用列表[[1,2,3],[4,5,6],[7,8,9]]生成一个新列表[1,5,9]
list12 = [[[1,2,3], [4,5,6], [7,8,9]][i][i] for i in range(len([[1,2,3], [4,5,6], [7,8,9]]))]
print("使用列表推导，使用列表[[1,2,3],[4,5,6],[7,8,9]]生成一个新列表[1,5,9]：",list12)
# 字典推导式
# 使用字典推导，将字典中的key,value进行互换
dict1 = {"name": "rose", "age": 17, "sex": "女"}
dict2 = {v: k for k, v in dict1.items()}
print("使用字典推导，将字典中的key,value进行互换：",dict2)
# 使用字典推导，将一个列表的元素作为key，将另一个列表的元素作为value，产生一个字典
list1 = ["施耐庵", "吴承恩", "曹雪芹", "罗贯中"]
list2 = ["水浒传", "西游记", "红楼梦", "三国演义"]
dict3 = {x: list2[list1.index(x)] for x in list1 }
print("使用字典推导，将一个列表的元素作为key，将另一个列表的元素作为value，产生一个字典1：",dict3)
dict4 = {list1[x]: list2[x] for x in range(len(list1))}
print("使用字典推导，将一个列表的元素作为key，将另一个列表的元素作为value，产生一个字典2：",dict4)
# zip() 打包, 将多个可迭代对象(序列)中的相同索引值的元素, 放在一个元组里, 最终将所有的元组组成一个新的可迭代对象
dict5 = {k: v for k, v in zip(list1, list2)}
print("使用字典推导(zip打包)，将一个列表的元素作为key，将另一个列表的元素作为value，产生一个字典3：",dict5)
# 集合推导式
# 使用集合推导式 推导出一个集合 集合中的元素是list1中元素的平方
lst = [9, 8, 7, -2, 2, -3, -7, 9]
st = {x ** 2 for x in lst}
print("使用集合推导，推导出一个集合中的元素是列表中元素的平方：",st)
# 输入一个大于1的整数，返回一个包含所有能够整除该整数的因子（不包含1和它本身），并且从小到大排序的列表；若是素数，则返回“这是一个素数”
num = 250
# 列表推导式
res = [x for x in range(2, num) if num % x == 0]
print(f"这个数{num}的因子有：{res}" if res else f"这个数{num}是素数")
# 创建一个长度为10的数据是1-100的随机数的列表
num_lst = [random.uniform(1, 100) for x in range(10)]
print("创建一个长度为10的数据是1-100的随机数的列表：", num_lst)
# 创建一个长度为10的数据是1-100内的随机偶数列表
num_lst = [random.randrange(2, 101, 2) for x in range(10)]
print("创建一个长度为10的数据是1-100内的随机偶数列表：", num_lst)
# 拼接一个字符串，生成长度为4的随机验证码
res_str = ""
for x in range(4):
s = random.choice("1234567890qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM")
res_str += s
print("生成长度为4的随机验证码：", res_str)
# chr(), ord() 字符 <--> 编码 (utf-8)
res_str = "" # 验证码的字符串
while len(res_str) < 4: # 条件 字符串的长度 < 4
num = random.randrange(48, 123)
if (num >= 48 and num <= 57) or (num >= 65 and num <= 90) or (num >= 97 and num <= 122):
res_str += chr(num) # 整数 --> 字符
print("生成长度为4的随机验证码：", res_str)
list_num = [x for x in range(48, 58)] # 48~57 --> 0-9
big_alpha = [x for x in range(65, 91)] # 65~90 ---> A-Z
small_alpha = [x for x in range(97, 123)] # 97~122 --> a~z
res_list = list_num + big_alpha + small_alpha # 满足验证码规则的所有字符对应的编码
res_str = "" # 验证码字符串
for x in range(4):
num = random.choice(res_list) # 随机产生一个编码
res_str += chr(num) # 将编码转换成字符
print("生成长度为4的随机验证码：", res_str)
# 创建一个列表，长度为10，数据是1-10的随机数，去重复
res_list = [random.randint(1, 10) for x in range(10)]
print("创建一个列表，长度为10，数据是1-10的随机数，去重复：", set(res_list))
# 完成商城用户注册，登录和密码修改功能
# 展示菜单
username_list = ["1", "2"]
userpass_list = ["1", "1"]
print("正在进入商城系统，请等待......")
for i in range(11):
if i != 10:
print("==", end="")
else:
print("\n" + "加载完成，进入商城中。。。")
time.sleep(0.5)
os.system("cls")
while True:
print("~~~~~~~~~~~~欢迎来到仙仙商城~~~~~~~~~~~~")
print("本系统现有以下功能")
print("1 注册")
print("2 登录")
print("3 退出")
print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
num = input("请选择输入标号：")
# 注册页面
if num == "1":
print("~~~~~~~~~~~~~~商城注册界面~~~~~~~~~~~~~~")
while True:
username = input("请输入您的账号名：")
password1 = input("请输入您的密码：")
password2 = input("请确认您的密码：")
if password1 == password2:
print("两次密码一致，可注册")
username_list.append(username)
userpass_list.append(password1)
print("您注册的用户是：", username, "已注册完成")
print("正在跳转，请等待。。。")
for i in range(10):
print("*", end="")
time.sleep(0.2)
break
else:
print("两次密码不一致，请重新注册")
# 登录页面
elif num == "2":
while True:
print("~~~~~~~~~~~~~~商城登录界面~~~~~~~~~~~~~~")
name = input("请输入您的用户名：")
psd = input("请输入您的密码：")
if name in username_list:
print("查询到用户", name)
print("验证中，请稍等。。。")
time.sleep(0.5)
if psd == userpass_list[username_list.index(name)]:
print("登录成功")
while True:
print("~~~~~~~~~~~~~~商城菜单界面~~~~~~~~~~~~~~")
print("欢迎您", name)
print("本商城现在有以下功能")
print("1 炫酷商城首页")
print("2 修改登录密码")
print("3 完善用户资料")
print("4 休闲娱乐中心")
print("5 退出炫酷商城")
number = int(input("请输入您的选择编号："))
if number == 1:
print("商城首页正在紧急扩张中，请下次再来。。。")
input("任意键返回菜单页面")
elif number == 2:
pas = input("请输入您的登录密码：")
if pas != userpass_list[username_list.index(name)]:
print("密码错误，请检查重新输入，即将跳转")
time.sleep(1)
else:
while True:
password3 = input("请输入新密码：")
password4 = input("请确认新密码：")
if password3 != password4:
print("密码不一致，请检查重新输入")
else:
userpass_list[username_list.index(name)] = password3
print("密码修改成功，即将跳转登录界面")
print("跳转中，请稍等。。。")
time.sleep(1)
print("跳转中，请稍等。。。")
time.sleep(1)
print("跳转中，请稍等。。。")
time.sleep(1)
break
break
elif number == 3:
print("完善服务正在紧急扩张中，请下次再来。。。")
input("任意键返回菜单页面")
elif number == 4:
print("~~~~~~~~~~~~当前已有游戏列表~~~~~~~~~")
print(" 1 猜拳游戏(剪刀石头布)")
print(" 2 猜数字(猜数字大小)")
print(" 3 退出休闲娱乐中心")
game_choice = int(input("请输入您要选择的功能编号："))
if game_choice == 1:
import random
print("~~~~~~~~~~~~剪刀石头布游戏~~~~~~~~~~~~~~")
a = b = c = 0
while True:
# 电脑出招
print("电脑正在出招中，请稍等")
com = random.randint(0, 2)
print(com)
# 玩家出招
print("电脑出招完成，请你出招")
player = int(input("请出招（0-石头、1-剪刀、2-布）："))
# 将电脑出招的数字转换成文字，提示怎么比较的
if com == 0:
print("电脑出招：石头")
elif com == 1:
print("电脑出招：剪刀")
else:
print("电脑出招：布")
# 判断输赢，输出结果
print("判断中，请稍等")
if com == player:
print("平局")
c += 1
elif (com == 0 and player == 1) or (com == 1 and player == 2) or (
com == 2 and player == 0):
print("电脑赢了，你输了")
a += 1
else:
print("电脑输了，你赢了")
b += 1
tip = "你赢了" + str(b) + "次，电脑赢了" + str(a) + "次，平局" + str(c) + "次"
print(tip)
if (a - b > 2) or (b - a > 2):
if a - b > 2:
print("电脑赢了，你输了~~游戏结束！！！")
else:
print("你赢了，电脑输了~~游戏结束！！！")
print("即将退出，请稍等~~")
time.sleep(2)
break
elif game_choice == 2:
print("亲，你好，我是智能宝宝，猜猜我多大了~")
num = random.randint(18, 26)
a = 3
while True:
age = int(input("亲输入您猜测的年龄（18-25）："))
if 18 <= age < 26:
if num == age:
print("你好棒啊，一猜就中~我", num, "碎了")
print("送你一个聪明的夸奖，再见！！！")
break
else:
a -= 1
if a == 0:
print("踩了这么多次，还没猜中，不理你了~~")
break
print("亲，猜错了，你还有", a, "次机会，青虫菜~~")
else:
print("qin，您的输入有无哦~请检查重新输入！")
elif game_choice == 3:
input("任意键返回菜单页面")
else:
print("功能正在紧急扩张中，请下次再来。。。")
input("任意键返回")
else:
print("还有3秒退出系统，请稍等。。。")
time.sleep(1)
print("还有2秒退出系统，请稍等。。。")
time.sleep(1)
print("还有1秒退出系统，请稍等。。。")
time.sleep(1)
exit()
else:
print("密码错误，请检查输入")
else:
print("没有该用户，请先注册再登录！")
print("跳转中，请稍等。。。")
time.sleep(1)
print("跳转中，请稍等。。。")
time.sleep(1)
print("跳转中，请稍等。。。")
time.sleep(1)
break
# 退出系统
elif num == "3":
print("~~~~~~~~~~~~~~商城退出界面~~~~~~~~~~~~~~")
print("还有3秒退出系统，请稍等。。。")
time.sleep(1)
print("还有2秒退出系统，请稍等。。。")
time.sleep(1)
print("还有1秒退出系统，请稍等。。。")
time.sleep(1)
break
else:
print("~~~~~~~~~~~~~~警告：异常出现！~~~~~~~~~~~~~~")
print("没有该选项，请检查后重新输入选项。。。")
"""
英雄联盟-世纪之城
STEP1： 开发项目中需要的数据【登陆用户变量、系统内所有用户、系统内的所有英雄】
STEP2： 开发一级菜单【完善菜单展示、选择结构】
STEP3： 开发-用户登陆功能，实现基本用户的登陆操作
STEP4： 开发首页菜单-选择结构-输入选项，进入不同功能[测试已有功能是否可用]
STEP5： 开发用户注册功能。
STEP6： 完善细节功能
1、勇士登陆时，输入账号、密码环节，没有正确的账号密码，就不能退出！
用户可以选择在输入账号、密码时 随时返回登陆菜单
2、解决方案：添加一个判断的变量，用户是继续访问首页，还是返回登陆菜单
STEP7： 英雄/勇士第一次登陆，领取/雇佣属于自己的英雄
用户登陆成功 之后，需要判断用户是否有属于自己的英雄
如果没有--> 领取英雄
如果有--> 直接进入首页
"""
# 1、声明变量，存储项目中需要的数据
# 存储登陆的用户
login_user = None
# 存储系统中的所有用户的字典(添加一个默认的内测用户)
users = {
"admin": {"username": "admin", "password": "admin", "nickname": "管理员",
"email": "待完善", "phone": "待完善", "heroes": dict()}
}
# 存储系统中的所有内置英雄的字典
heroes = {
"剑魔": {"name": "剑魔", "blood": 800, "armor": 20, "attack": 1000, "skill": ["天神下凡", "霸灭"]},
"牛头": {"name": "牛头", "blood": 1500, "armor": 60, "attack": 300, "skill": ["震荡八方", "势不可挡"]},
"安妮": {"name": "安妮", "blood": 600, "armor": 45, "attack": 1200, "skill": ["九层火镰", "提伯斯之怒"]},
}
# 2、从程序开始的地方-编写一级菜单
while True:
print("\t\t英雄联盟-世纪之城：初始传送阵")
print("~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~")
print("\t\t1、用户登陆")
print("\t\t2、用户注册")
print("\t\t3、退出系统")
print("~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~")
# 提示用户输入选项
login_c = input("请输入您的传送阵编号：")
# 3、选择结构中，完善二级菜单
if login_c == "1":
print("用户登陆")
# 声明一个变量，表示登陆结果，开始的时候没有用户登陆~没有结果
login_result = None
while True:
# 提醒用户输入账号、密码
username = input("请输入您的通行证账号：").strip()
password = input("请输入您的通行证密码：")
# 判断账号是否存在
if username in users:
# 获取当前用户
user = users.get(username)
# 判断密码是否正确
if password == user.get("password"):
# 登陆成功，记录登陆用户
login_user = user
login_result = True
break
res = input("账号或者密码有误，按任意键重新登陆(输入Q返回初始传送阵)")
if res.upper() == "Q":
input("即将返回初始传送阵，按任意键继续")
login_result = False
break
# 根据登陆结果，展示不同的菜单
# if login_result == False:
if not login_result:
# 没有登陆成功，返回登陆菜单
continue
# （1）登陆成功，（2）即将进入首页之前：判断用户是否已经领取过英雄？
# 判断用户heroes字典中的数据长度为0，表示没有雇佣英雄
while len(login_user["heroes"]) <= 0:
input("用户第一次登陆系统，准备雇佣英雄")
# 展示系统中的所有英雄
for hero in heroes.values():
print(hero)
print("----------------------------------")
# 提示用户输入选择的英雄
hero_name = input("请输入您要雇佣的英雄(免费)：")
# 判断雇佣的英雄是否存在
if heroes.get(hero_name):
print("准备雇佣仪式....")
# 给用户的heroes这个key设置一个存储英雄的字典:怎么拷贝过来呢？
# 思考：引用复制？浅拷贝？深拷贝？
# 引用赋值：导致任何一个用户修改英雄属性数据，影响系统中的英雄数据
# 浅拷贝：导致任何一个用户修改英雄的技能列表，影响系统中的英雄数据
# 深拷贝：任何一个用户修改自己的英雄数据，不会影响任何其他数据！
# 领取英雄：使用什么拷贝方式？
# ① 英雄的技能都是固定的~每个人领取的都是一样的，浅拷贝【模拟】
# ② 养成类游戏，英雄的属性和技能都可以自主学习，深拷贝
hero = heroes.get(hero_name).copy()
login_user["heroes"][hero_name] = hero
else:
input("没有要雇佣的英雄，请重新输入")
# 登陆成功，展示首页
while True:
print(login_user)
print("\t\t英雄联盟-世纪之城：主城")
print("~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~")
print("\t\t1、进入世纪战场")
print("\t\t2、进入英雄雇佣营")
print("\t\t3、进入杂货铺")
print("\t\t4、返回上一级")
print("\t\t5、退出系统")
print("~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~")
# 提醒用户输入选项
index_c = input("主城提示，请输入传送阵编号：")
# 选择不同的传送阵进入不同的功能区
if index_c == "1":
pass
elif index_c == "2":
pass
elif index_c == "3":
pass
elif index_c == "4":
input("即将返回初始传送阵，保存好个人数据，按任意键继续")
login_user = None
break
elif index_c == "5":
input("系统即将退出，保存好个人数据，按任意键继续")
exit()
else:
input("主城中没有这个传送阵，请重新核查..")
continue
elif login_c == "2":
# 提醒用户输入账号
username = input("请输入您要注册的账号：").strip()
if username in users:
input("该通信证账号已经被占用，请检查后重新操作，按任意键返回初始传送阵")
continue
# 提醒用户输入密码
password = input("请输入您的密码：")
confirm = input("请确认您的密码：")
if password != confirm:
input("通信证密码初始化失败，两次密码输入不一致，按任意建返回初始传送阵")
continue
# 创建一个新用户
new_user = {"username": username, "password": password, "nickname": "待完善",
"email": "待完善", "phone": "待完善", "heroes": dict()}
# 保存到系统用户字典中
users[username] = new_user
input("通信证注册成功，按任意键返回初始传送阵")
elif login_c == "3":
input("尊敬的勇士，系统即将退出，保存好个人数据，按任意键继续")
exit()
else:
input("尊敬的勇士，没有这个传送阵，请重新选项.")
continue
# 名称：实现游戏商城-注册登录
# 定义系统中的用户信息：测试用户
infos = {
"admin": {"name": "用户", "psd": "111", "email": "111@qq.com"},
"duxun": {"name": "杜迅", "psd": "222", "email": "222@qq.com"},
"yuxian": {"name": "雨仙", "psd": "333", "email": "333@qq.com"}
}
# 登录出错上限
total = 3
# 登录次数记录
count = 0
# 定义变量保存登录的用户：刚开始没有用户登录~值为空None
# None是一种数，表示login变量中什么数据都不存在
login = None
while True:
# 菜单界面
os.system("cls")
print("#########仙仙游戏商城欢迎您###########")
print(" 1、用户登录")
print(" 2、用户注册")
print(" 3、退出系统")
print("##################################")
# 提示输入
choice = input("请输入您的选项：")
if choice == "1":
while count < total:
# 用户登录
os.system("cls")
# 用户提示次数
print(f'用户登录共有{total}次机会，现在还有{total - count}次机会')
print("#########仙仙游戏商城登录###########")
account = input("请输入账号：").strip()
psd = input("请输入密码：").strip()
# 判断输入的账号是否正确
if account in infos:
info = infos.get(account)
# print(info)
if psd == info.get("psd"):
login = info.get("name")
for i in range(10):
print("\r" + "■" * i, sep="", end="")
time.sleep(0.5)
print("\n登录成功")
count = 0
time.sleep(0.5)
os.system("cls")
print("欢迎您：", login)
print("#########仙仙游戏商城首页###########")
print(" 1、进入皮肤商城")
print(" 2、进入装备商城")
print(" 3、休闲小游戏")
print(" 4、返回菜单界面")
print(" 5、退出系统")
print("##################################")
choose = input("请输入您的选择")
if choose == "1":
print("作者去听大木老师的直播了，等待更新中~")
print("即将返回菜单界面")
time.sleep(3)
continue
elif choose == "2":
print("作者去听大木老师的直播了，等待更新中~")
print("即将返回菜单界面")
time.sleep(3)
continue
elif choose == "3":
print("作者去听大木老师的直播了，等待更新中~")
print("即将返回菜单界面")
time.sleep(3)
continue
elif choose == "4":
print("即将返回菜单界面")
time.sleep(3)
continue
elif choose == "5":
print("即将退出系统")
time.sleep(3)
exit(1)
else:
print("您的输入非法，请重新登录")
time.sleep(3)
count += 1
continue
else:
input("密码错误，请重新登录")
count += 1
continue
else:
input("账号不存在，请重新登录")
count += 1
continue
# 登录次数达到最大执行的程序
else:
input('用户登录次数已达最大上限，强制退出')
exit()
elif choice == "2":
while True:
os.system("cls")
print("#########仙仙游戏商城注册###########")
account = input("请输入账号：").strip()
name = input("请输入姓名：").strip()
psd = input("请输入密码：").strip()
confirm = input("请确认密码：").strip()
if psd == confirm:
print("两次密码一致，继续创建")
else:
input("两次密码不一致，请检查后重新输入")
continue
while True:
gender = input("请输入您的性别(男|女）：").strip()
if len(gender) == 1 and (gender.startswith("男") or gender.startswith("女")):
break
else:
print("您的输入非法，请检查后重新输入")
continue
while True:
email = input("请输入QQ邮箱(号码不得少于3位)：").strip()
if len(email) >= 10 and email.endswith("@qq.com"):
break
else:
print("非法邮箱格式，请核查后重新输入")
continue
# print(infos.keys())
for msg in infos.keys():
# print(msg)
if account == msg:
print("此账号已存在，请重新注册")
print("即将返回，请稍等")
time.sleep(3)
break
else:
# 将输入的信息组合成字典
info = {
account: {
"name": name,
"psd": psd,
"gender": gender,
"email": email,
}
}
# 添加新建姓名到infos中
infos.update(info)
# print(infos)
print("验证中，请稍等")
for i in range(10):
print("\r" + "■" * i, sep="", end="")
time.sleep(0.5)
print("\n账号创建完成，即将返回首页")
time.sleep(3)
break
continue
elif choice == "3":
os.system("cls")
print("5秒后退出系统，请保存好个人数据")
time.sleep(2)
print("3秒后退出系统，请保存好个人数据")
time.sleep(2)
print("1秒后退出系统，请保存好个人数据")
time.sleep(1)
print("退出系统，欢迎下次使用")
exit(1)
else:
os.system("cls")
print("您的输入非法，即将返回菜单界面")
time.sleep(3)
continue
"""
超市买水果功能分析
(1)输入自己所有的钱
(2)展示商品的序号，名称及其价格
(3)输入要买商品的序号
(4)输入要买商品的数量
(5)购物车中显示购买的水果名称及其对应的数量和剩余钱
(6)如果序号输入有误就提示用户重新输入
(7)如果钱不够了提示用户钱不够，并且退出程序
"""
product = [
{'name': '苹果', 'price': 10},
{'name': '榴莲', 'price': 30},
{'name': '草莓', 'price': 20},
{'name': '菠萝', 'price': 15},
]
# 创建一个购物车来盛放水果
cart = {}
# 提示用户输入钱
money = input('请展示一下你的钱:')
# 输入的是一个数字
if money.isdigit():
# 类型转换
money = int(money)
# 展示商品
for i, shop in enumerate(product, start=1):
print("水果的序号:{},名称:{},价格:{}".format(i, shop['name'], shop['price']))
while True:
# 输入序号
num = input("请输入序号:")
# 输入的是一个数字
if num.isdigit():
# 类型转换
num = int(num)
# 判断商品序号的范围
if num > 0 and num <= len(product):
# 输入的序号范围在产品列表范围内
# 提示用户输入数量
account = input('请输入数量:')
if account.isdigit():
# 输入的数量是数字
# 类型转换
account = int(account)
# 判断买的商品的总价格是否超过了用户的所有钱：没有超出，可以添加到购物车中，超出了就退出
# 根据序号找到水果的价格，注意索引的获取：求商品的总价格 数量*价钱
index = product[num - 1]['price']
# 购买某一种水果的总价钱
total = index * account
# 水果总价钱和用户的钱进行比较：商品总价钱是否小于用户输入的钱
if total <= money:
# 将商品添加到购物车
# 获取序号对应的商品名称
name = product[num - 1]['name']
# 去购物车查找对于的商品名称
ret = cart.get(name)
# None
if ret:
# 购物车中已经存在了此商品，只需添加数量
# 获取购物车中原有的数量
amount = cart[name]
# 总共的数量
cart[name] = amount + account
print(cart)
else:
# 添加商品和数量
cart[name] = account
print(cart)
# 去购物车进行查询如果有就添加数量如果没有就添加商品和数量
# 输出用户剩余的钱
remain = money - total
print('用户剩余的钱：', remain)
else:
# 商品总价格超过了用户的钱
print('亲，余额不足...')
break
else:
# 输入的数量不是数字
print('数量不是数字，请输入数字哦。。。')
else:
# 输入的序号超出了范围
print('商品范围不正确，看清了在输入亲!!!')
else:
# 输入的序号不是一个数字
print('序号是由数字组成，请输入数字')
else:
# 输入的不是数字
print('你的钱怎么不是数字呢，输入的钱不合法')
# 三元表达式
# 用户输入两个整数，请输出较大值
num1 = int(input("请输入一个整数："))
num2 = int(input("请输入一个整数："))
print("两个数中的最大值是：", end=" ")
if num1 > num2:
print(num1)
else:
print(num2)
# 三元表达式
# 变量=条件成立返回的值 if 条件 else 条件不成立时返回的值
num = num1 if num1 > num2 else num2
print("两个数中的较大值是：", num)
03-24
1540
1540
07-25
2万+
2万+
07-04
6415
6415
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
