py语法05-可迭代与推导式

# 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, uniquelst = ['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 = 1GREEN = 2BLUE = 3BLACK = 4color = 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 = 1GREEN = 2BLUE = 3BLACK = 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 = nameself.gender = gender
@unique
class Gender(Enum):Male = 0Female = 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:  # 条件 字符串的长度 < 4num = 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)breakelse: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)] = password3print("密码修改成功，即将跳转登录界面")print("跳转中，请稍等。。。")time.sleep(1)print("跳转中，请稍等。。。")time.sleep(1)print("跳转中，请稍等。。。")time.sleep(1)breakbreakelif number == 3:print("完善服务正在紧急扩张中，请下次再来。。。")input("任意键返回菜单页面")elif number == 4:print("~~~~~~~~~~~~当前已有游戏列表~~~~~~~~~")print("    1      猜拳游戏(剪刀石头布)")print("    2      猜数字(猜数字大小)")print("    3      退出休闲娱乐中心")game_choice = int(input("请输入您要选择的功能编号："))if game_choice == 1:import randomprint("~~~~~~~~~~~~剪刀石头布游戏~~~~~~~~~~~~~~")a = b = c = 0while 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 += 1elif (com == 0 and player == 1) or (com == 1 and player == 2) or (com == 2 and player == 0):print("电脑赢了，你输了")a += 1else:print("电脑输了，你赢了")b += 1tip = "你赢了" + 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)breakelif game_choice == 2:print("亲，你好，我是智能宝宝，猜猜我多大了~")num = random.randint(18, 26)a = 3while True:age = int(input("亲输入您猜测的年龄（18-25）："))if 18 <= age < 26:if num == age:print("你好棒啊，一猜就中~我", num, "碎了")print("送你一个聪明的夸奖，再见！！！")breakelse:a -= 1if a == 0:print("踩了这么多次，还没猜中，不理你了~~")breakprint("亲，猜错了，你还有", 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)breakelse: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 = Nonewhile True:# 提醒用户输入账号、密码username = input("请输入您的通行证账号：").strip()password = input("请输入您的通行证密码：")# 判断账号是否存在if username in users:# 获取当前用户user = users.get(username)# 判断密码是否正确if password == user.get("password"):# 登陆成功，记录登陆用户login_user = userlogin_result = Truebreakres = input("账号或者密码有误，按任意键重新登陆(输入Q返回初始传送阵)")if res.upper() == "Q":input("即将返回初始传送阵，按任意键继续")login_result = Falsebreak# 根据登陆结果，展示不同的菜单# 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] = heroelse: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":passelif index_c == "2":passelif index_c == "3":passelif index_c == "4":input("即将返回初始传送阵，保存好个人数据，按任意键继续")login_user = Nonebreakelif index_c == "5":input("系统即将退出，保存好个人数据，按任意键继续")exit()else:input("主城中没有这个传送阵，请重新核查..")continueelif 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_userinput("通信证注册成功，按任意键返回初始传送阵")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 = 0time.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)continueelif choose == "2":print("作者去听大木老师的直播了，等待更新中~")print("即将返回菜单界面")time.sleep(3)continueelif choose == "3":print("作者去听大木老师的直播了，等待更新中~")print("即将返回菜单界面")time.sleep(3)continueelif choose == "4":print("即将返回菜单界面")time.sleep(3)continueelif choose == "5":print("即将退出系统")time.sleep(3)exit(1)else:print("您的输入非法，请重新登录")time.sleep(3)count += 1continueelse:input("密码错误，请重新登录")count += 1continueelse:input("账号不存在，请重新登录")count += 1continue# 登录次数达到最大执行的程序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("两次密码不一致，请检查后重新输入")continuewhile True:gender = input("请输入您的性别(男|女）：").strip()if len(gender) == 1 and (gender.startswith("男") or gender.startswith("女")):breakelse:print("您的输入非法，请检查后重新输入")continuewhile True:email = input("请输入QQ邮箱(号码不得少于3位)：").strip()if len(email) >= 10 and email.endswith("@qq.com"):breakelse:print("非法邮箱格式，请核查后重新输入")continue# print(infos.keys())for msg in infos.keys():# print(msg)if account == msg:print("此账号已存在，请重新注册")print("即将返回，请稍等")time.sleep(3)breakelse:# 将输入的信息组合成字典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)breakcontinueelif 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)# Noneif ret:# 购物车中已经存在了此商品，只需添加数量# 获取购物车中原有的数量amount = cart[name]# 总共的数量cart[name] = amount + accountprint(cart)else:# 添加商品和数量cart[name] = accountprint(cart)# 去购物车进行查询如果有就添加数量如果没有就添加商品和数量# 输出用户剩余的钱remain = money - totalprint('用户剩余的钱：', remain)else:# 商品总价格超过了用户的钱print('亲，余额不足...')breakelse:# 输入的数量不是数字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)
py语法05-可迭代与推导式相关推荐

（MAX第八篇）Python列表迭代及推导式（初级）
目录 1. 迭代 for 循环 1.1 遍历`range()` 1.2 遍历列表 1.3 遍历字符串 2. 列表推导式我们很多时候需要遍历整个列表,也就是说要使用列表中的每一个元素,则可以使用迭代f ...
Python学习笔记 —— 独步天下推导式语法糖
Python学习笔记 -- 独步天下推导式语法糖前言介绍列表推导式获取当月天数字典推导式模拟三条用户数据结束语前言最近心血来潮,学习了一下Python,其中关于推导式语法糖感觉功 ...
【技能树共建】Python 列表推导式
Python 列表推导式是什么列表推导式是 Python 语言特有的一种语法结构,也可以看成是 Python 中一种独特的数据处理方式, 它在 Python 中用于转换和过滤数据. 其语法格 ...
python之推导式
1. 列表推导式推导式是最常应用迭代协议的环境之一.推导式是另外一种将for循环,if表达式以及赋值语句放在一个单一语句中的一种方法. 举个例子,我们需要将一个输入列表中所有偶数元素除以2生成一个新 ...
Python笔记_13_推导式_集合推导式_字典推导式_生成器
文章目录推导式基本语法带有条件判断的推导式多循环推导式带有判断条件的多循环推导式测试题集合推导式字典推导式 enumerate zip 生成器 generator 生成器表达式生成器 ...
python中几种推导式的特殊用法
字典推导式 >>> dic = {x: x**2 for x in (2, 4, 6)} >>> dic {2: 4, 4: 16, 6: 36} >> ...
迭代列表不要For循环，这是Python列表推导式最基本的概念
如果你还在使用 For 循环迭代列表,那么你需要了解了解列表推导式,看看它的基本概念都是什么. 列表解析式(List comprehension)或者称为列表推导式,是 Python 中非常强大和优雅 ...
【Python学习】 - - 链表推导式[ 2*x for x in X ]、匿名函数、并行迭代
列表推导式[x for x in range(n)] 问题:请计算出1~9间的整数的平方常规方法 for i in range(1,10):print(i*i) 链表推导式: print([x*x ...
Python基础学习笔记-05字符串、列表、推导式；老师工位随机分配random.shuffle()、算术运算打分例题；
字符串.列表.推导式 python数据类型: #可变数据: 列表List.字典Dictionary.集合Set . #不可变数据:数值Number(int.float.bool.complex).字符 ...
py语法05-可迭代与推导式

py语法05-可迭代与推导式相关推荐

最新文章

热门文章
