---

前言

本文将介绍Python中的集合与字典以及控制流程。集合是一种无序且不重复的数据类型，它可以用于存储一组元素，并提供了一些强大的操作方法。字典是Python中的一种映射类型，它以键-值对的形式存储数据，可以快速查找和访问数据。控制流程是程序中的逻辑控制部分，用于决定哪些代码要被执行或重复执行。

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、集合与字典

1、集合

组合数据类型

• 集合类型是一个元素集合，元素之间无序，相同元素在集合中唯一存在。
• 序列类型是一个元素向量，元素之间存在先后关系，通过序号访问，元素之间不排他。序列类型的典型代表是字符串类型和列表类型。
• 映射类型是”键-值“数据项的组合，每个元素是一个键值对，表示为（key,value）。映射类型的典型代表是字典类型

集合类型概述

• Pyrthon语言中的集合类型与数学中的集合概念一致，即包含0个或多个数据项的无序组合。
• 集合是无序组合，用大括号({})表示，它没有索引和位置的概念，集合中元素可以动态增加或删除。
• 集合中元素不可重复，元素类型只能是固定数据类型。
  例如：整数、浮点数、字符串、元组等。
  列表、字典和集合类型本身都是可变数据类型，不能作为集合的元素出现。
  嵌套也不可
  集合类型本身 是不能作为集合元素出现的。
• 需要注意，由于集合元素是无序的，集合的打印效果与定义顺序可以不一致。由于集合元素独一无二，使用集合类型能够过滤掉重复元素

s = {1,2,3,'x','y'}
type(s)
len(s)

# 错误示范
s = {1,2,3,4,['x','y']}

a = {1,2,3,4,'x','y'}
print(a)

a = {1,2,3,3,2,1}
a

集合类型有4个操作符，交集（&）、并集（|）、差集（-）、补集（^）,操作逻辑与数学定义相同。

a = {1,2,3,4}
b = {'x','y','z',1,2,3}
b-a # 差集
b&a # 交集
b^a # 补集
a|b # 并集

集合裂隙有些常用的操作函数或方法

集合（set）是一个无序的不重复元素的集体
创建：

1. 使用大括号{}或set()函数创建集合；set()函数可以接收list为参数
2. **注意：**创建一个空集合必须用set()而不是{}，{}是用来创建一个空字典。

看看是否都可以成功定义集合？
s1 = {}字典dict
s2 = {1,2,3} 集合
s3 = {1,2,3,'hello',(1,2,3,).[1,2,3]} 错误
basket = {'one','two','three','four','five','six'} 集合
s4 = set('ashdiawhue') 集合
s4 = frozenset((3,2,1)) 集合，fronzenset()返回一个冻结的集合，冻结后集合不能再添加或删除任何元素

思考一下
存在一个列表：
a = ['192.168.245.2','192.168.245.20','192.168.245.2','192.168.245.20','192. 168.245.20','192.168.245.1','192.168.245.1']
如何去除里面重复的元素？

a =
['192.168.245.2','192.168.245.20','192.168.245.2','192.168.245.20','192. 168.245.20','192.168.245.1','192.168.245.1']
# 方法：通过set方法进行处理
a = list(set(a))
a

集合内置方法

明明的随机数
明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数（N≤1000），对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。然后再把这些数从小到大排序，按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作。
初始文件SetExecDemo.py

2、字典

映射类型概述

• 映射类型是”键-值“数据项的组合，每个元素是一个键值对，即元素是（key,value）,元素之间是无序的。键值对是一种二元关系，源于属性和值的映射关系

字典

• 什么是字典？-------- 一种映射类型
• 键（key）
• 值（value）
• key-value对
  
• 映射类型是由用户来定义序号，即键，用其去寻找具体的值
• 键（key）表示一个属性，也可以理解为一个类别或项目，值（value）是属性的内容，键值对刻画了一个属性和它的值。键值对将映射关系结构化，用于存储和表达。
• 字典是另外一种可变容器模型，且可存储任意类型对象。键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。
  d = {key1:value1,key2:value2}
d = {'z':'字','D':‘典’,'Z':'中'}

字典的创建
1）简单字典创建
2）内建方法：fromkeys（字典中的key有相同的value值，默认为None）
3）是由内置函数dict(key1 = value1,key2 = value2,…)，另外dict也可以接受可迭代对象作为参数
4）zip间接创建：zip()函数用于将可迭代的对象作为参数，将对象中对于的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。

# 方法1
mydic = {'name':'xiaoming','age':'11'}
type(mydic)
mydic

# 方法2
y = {}.fromkeys(('a','b','c','d'),'默认值')
y

y = {},fromkeys(('a','b','c','d').[1,2,3,4])
y

x = {}.fromkeys(('a','b','c','d'))
x

# 方法3
dict(x='1',y='2',z='3')
dict(([1,2],[3,4]))
dict([('one',1),('two',2),('three',3)])

# 方法4
a = ['name','age'.'sex']
b = ['xiaoming','11','boy']
a
b
x = dict(zip(a,b))
x 

思考
存在一个模板列表 a = ['name','age','sex'] 存储了一个格式，
现在存在几组数据
x = ['xiaoming','11','boy'] y = ['xiaohong','11','girl'] z = ['xiaojun','12','boy']
如何处理这些数据，使其以字典形式{‘name’:‘xxx’,‘age’:‘yyy’,‘sex’:‘zzz’}的形式存在到一个列表中
输出结果如下
[{'name':'xiaoming','age':'11','sex':'boy'},{'name':'xiaohong','age':'11','sex':'girl'},{'name':'xiaoju n','age':'12','sex':'boy'}]

# 初学者 版本
a = ['name','age','sex']
x = ['xiaoming','11','boy']
y = ['xiaohong','11','girl']
z = ['xiaohong','11','girl']
array = [x, y, z]
dictArray = []
for i in range(len(array)):
    dic = dict(zip(a, array[i]))
    dictArray.append(dic)
print(dictArray)

# 使用列表推导式
# 列表推导式 [dict(zip(a, item)) for item in data] 遍历 data 中的每个子列表 item，并将 a 和 item 使用 zip 函数组合成键值对，然后使用 dict 函数转换为字典。
data = [
	['xiaoming','11','boy'],
	['xiaohong','11','girl'],
	['xiaohong','11','girl']
]

result = [dict(zip(a,item)) for item in data]
print(result)

# 使用map函数
# map 函数使用 lambda 函数作为参数，将 data 中的每个子列表 item 和模板列表 a 通过 zip 函数组合成键值对，并转换为字典。最终使用 list 函数将 map 对象转换为列表。
data = [
	['xiaoming','11','boy'],
	['xiaohong','11','girl'],
	['xiaohong','11','girl']
]

result = list(map(lambda item: dict(zip(a,item)),data))
print(result)

访问字典数据
访问字典中的指定键的值，可直接通过：
字典名称 [‘键名’]或者 字典名称get(‘键名’)

a = {'name':'xiaoming','age':'11','sex':'boy'}
a['name']
a.get('name')
a['name1']
a.get('name','no such key')

修改字典数据
修改字典的指定键的值，可直接通过：
字典名称 [‘键名’] = value

a = {'x':1,'y':2,'z':3}
a 
a['x'] = 'qwe'
a

删除字典数据
删除字典中的指定key-value对，可直接通过：
del 字典名称 [‘键名’]

a = {'x':'qwe','y':2,'z':3}
del a['x']
a

添加字典数据
字典是一种动态结构，可随时在其中添加键-值对。要添加键-值对，可依次指定字典名、用方括号起的键和相关联的值：
字典名称 [‘新键名’] = value

a = {‘y’:2,'z':3}
a['x'] = 1
a

格式化输出字典值
字典也可以进行格式化输出，格式化输出的内容，为字典中指定键名的值
print("This is Test：%(键名)s" %字典名字)

a = {'x':'qwe','y':'123','z':4,'j':'k'}
print("This is Test: %(x)s"%a)

字典通用的函数

• 字典类型有一些通用的操作函数

按指定顺序获取字典数据
字典总是明确地记录键和值之间的关联关系，但获取字典的元素时，获取顺序时不可能预测的。
这不是问题，因为通常你想要的只是获取与键相关联的正确的值。
要以特定的顺序返回元素，一种办法是在for循环中对返回的键进行排序。为此，可使用函数sorted()来获取按特定顺序排列的键列表的副本：

a = {'x':1,'y':2,'z':6,'k':4,'j':5}
# 遍历值
for i in sorted(a.values()):
	print(i,end='  ')
# 遍历键-值
for i in sorted(a.keys()):
	print("key:{} --> value:{}".format(i,a[i]))

3、字典内置方法

方法	描述
dict.clear()	删除字典内所有元素
dict.copy()	返回一个字典的浅复制
dict.fromkeys(seq[,val])	创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
dict.get(key,default=None)	返回指定键的值，如果值不在字典中返回default值
dict.has_key(key)	如果键在字典dict里返回true,否则返回false
dict.items()	以列表返回可遍历的（键，值）元组数组
dict.keys()	以列表返回一个字典所有的键
dict.setdefault(key,default=None)	和get()类似，如果键不存在于字典中，将会添加键并将值设为default
dict.update(dict2)	把字典dict2的键/值对更新到dict里
dict.values()	以列表返回字典中所有值
pop(key[,default])	删除字段给定键key所对应的值，返回值为被删除的值。key值必须给出。否则，返回default值。
popitem()	返回并删除字典中的最后一对键和值。

字典内建方法：keys、values

• a.keys() 返回字典中所有键信息，返回结果是Python的一种内部数据结构dict_keys，专用于表示字典的键。如果希望更好的使用返回结果，可以将起转换为列表类型。
• a.values()返回字典中所有值信息，返回结果是Python的一种内部数据类型dict_values。如果希望更好的使用返回结果，可以将其转换为列表类型。

a = {'x':'123','y':'qwe','z':4,'j':'k'}
list(a.keys())
list(a.values())

字典内建方法：items

• d.items()返回字典中的所有键值对信息，反结果是Python的一种内部数据类型dict_items

a = {'x':123,'y':'qwe','z':'k','j':4}
list(a.items())

字典内建方法：get、setdefault

• d.get(键名，default)返回字典中指定键名的键值，若该键名不存在于字典中，则返回default的值。
• d.setdefault(键名,default)返回字典中指定键名的键值，若该键名不存在于字典中，在字典中添加一个键值对，键名则为索引的键名，值为default

a = {'x':123,'y':'qwe','z':'k','j':4}
a.get('x')
a.get('adc','不存在')

a.setdefault('x')
a.setdefault('adc','不存在')
a

遍历字典

• 与其他组合类型一样，字典可以遍历循环对其元素进行遍历，基本语法结构如下：
  for <变量名> in <字典名>: <语句块>
• 同样可以利用items()方法来获取键名和键值

# 默认获取的字典的键名
a = {'x':123,'y':'qwe','z':'k','j':4}
for i in a:
	print(i,end=' / ')
	
# 使用get() 方法来获取键值
for i in a:
	print("key:{} value:{}".format(i,a.get(i)))

# 使用items()方法来获取键名和键值
for s1,s2 in a.items():
	print(s1,s2)

print(list(a.items()))
print(list(zip(a.keys(),a.values())))

字典应用案例——列表去重方法三
方法三：通过字典的方式去重，因为字典的key值是不能重复的。

orgList=[1,0,3,7,7,5]
# list()方法是把字符串str或元组转成数组
formatList = list({}.fromkeys(orgList).keys())
print(formatList)

4、内置数据结构总结

数据结构	基础结构	元素唯一性	元素类型
List	可变序列	元素可重复	元素可以是任何类型的对象
Tuple	不可变序列	元素可重复	元素可以是任何类型的对象
Set	可变集合	元素不可重复	元素必须是不可变类型的对象
Dict	可变映射	键不可重复，值可以重复	键必须是不可变类型的对象，值可以是任何类型的对象

数据结构	基本操作	使用场景	常用函数
List	yuan支持索引、切片、增删改查等操作	适用于需要有序存储一组数据，并且需要对其中的元素进行增删改查操作的场景	append(),extend(),insert(),remove(),pop(),clear(),index(),count(),sort(),reverse()
Tuple	支持索引、切片，不支持增删改操作	适用于需要创建不可变序列、作为字典键或者需要返回多个值时的场景	count(),index()
Set	支持去重、交集、并集、差集等操作，不支持索引和切片操作	适用于需要存储一组元素，并且需要对其中的元素进行去重、交集、并集、差集等操作的场景	add(),update(),remove(),discard(),pop(),clear(),union(),intersection(),difference(),symmetric_difference()
Dict	支持通过键查找、修改对应的值，增加、删除键值对	适用于需要使用键值对存储数据，并且需要根据键快速查找对应的值的场景	get(),setdefault(),update(),pop(),clear(),keys(),values(),items()

二、控制流程

1、结构流程概述

流程控制概述

• 程序流程图用一系列图形、流程线和文字说明描述程序的基本操作和控制i流程，它是程序分析和过程描述的最基本方式。
• 流程图的基本元素包括7种

流程控制概述

• 起止框：表示程序逻辑的开始或结束；
• 判断框：表示一个判断条件，并根据判断结构选择不同的执行路径；
• 处理框：表示一组处理过程，对应于顺序执行的程序逻辑；
• 输入输出框：表示程序中的数据输入或结果输出
• 注释框：表示程序的注释
• 流向线：表示程序的控制流，以带箭头直线或曲线表达程序的执行路径；
• 连接点：表示多个流程图的连接方式，常用于将多个较小流程图组织成较大流程图。

程序的基本结构

• 顺序结构是程序按照线性顺序依次执行的一种运行方式，其中语句块1S1和语句块2S2表示一个或一组顺序执行的语句

• 分支结构是程序根据条件判断结果而选择不同向前执行路径的一种运行方式，基础的分支结构是二分支结构。由二分支结构会组合形成多分支结构。

• 循环结构是程序根据条件判断结果向反复执行的一种运行方式，根据循环体触发条件不同，包括条件循环和遍历循环结构

• 在循环结构原理的基础上，Python提供两个循环控制符break和continue,对循环的执行过程进行控制，break控制符用来结束当前循环，continue控制符用来结束当前循环的当次循环过程。

2、分支结构

单分支结构：if语句

• Python的单分支结构使用if保留字对条件进行判断，使用方式如下：
  if<条件>：语句块
• 其中if:和<语句块>前的缩进都是语法的一部分。<语句块>是if条件满足后执行的一个或多个语句序列，缩进表达<语句块>与if的包含关系。<条件>是一个产生True或False结果的语句，当结果为True时，执行<语句块>，否则跳过<语句块>。
• <条件>是一个或多个条件，多个条件采用and或or进行逻辑组合。and表示多个条件“与”的关系，or表示多个条件“或”的关系

# 判断用户输入数字的奇偶性
xnum = int(input("输入一个整数："))
if xnum % 2 == 0:
	print("这个是偶数")

# 判断用户输入数字的特点
xnum = int(input("输入一个整数："))
if xnum % 3 == 0 and xnum % 5 == 0:
	print("这个数字既能被3整除，又能被5整除")
print("输入的数字是：",s)

双分支结构：if-else语句

• Python的二分支结构使用if-else保留字对条件进行判断，语法格式如下：
  if <条件>: <语句块1> else: <语句块2>
• 其中，if、和语句块前的缩进都是语法的一部分。
• <语句块1>在if中<条件>满足即为True时执行，<语句块2>在if中<条件>不满足即为False时执行。简单说，二分支结构根据条件的True或False结构产生两条路径。
• 二分支结构还有一种跟简洁的表达方式，适合<语句块1>和<语句块2>都只包含简单表达式的情况，这样可以理解一种三元表达式，语法格式如下：
  <表达式1> if <条件> else <表达式2>
  一般的三元表达式：<条件表达式>?<表达式2>:<表达式3>
  有三个表达式，当条件表达式为真，执行表达式2，否则执行表达式3，但是Python中不是这样：
  value_if_true if condition else value_if_false

# 判断用户输入数字和属性
xnum = int(input("输入一个整数："))
if(xnum % 3 == 0 and xnum % 5==0):
	print("这个数字既能被3整除，又能被5整除")
else:
	print("这个数字不能够同时被3和5整除")
print("输入的数字是:",xnum)


# 判断用户输入数字的属性
xnum = int(input("输入一个整数："))
info = "" if xnum % 3 == 0 and xnum %5 == 0 else "不"
print("这个数字{}能够同时被3和被5整除".format(info))

x = 4
if x>3 :
	y = 99
else:
	y = 999
print(y)

多分支结构：if-elif-else语句

• Python的if-elif-else描述多分支结构，语句格式：
  if<条件1>: <语句块1> elif <条件>: <语句块2> ... else: <语句块N>
  

• 多分支结构通常用于判断同一个条件或一类条件的多个执行路径。要注意，Python会按照多分支结构的代码顺序依次评估判断条件，寻找并执行第一个结果为True条件对应的语句块，当前语句块执行后跳过整个if-elif-else结构。

• 利用多分支结构编写代码时要注意多个逻辑条件的先后关系。

# 获取用户输入的一个百分制成绩，转换成五分制，给出对应的A、B、C、D、E等级

score = float(input("输入一个百分制成绩："))
if score >= 90.0:
	grade = "A"
elif score >= 80.0:
	grade = "B"
elif score >= 70.0:
	grade = "c"
elif score >= 60.0:
	grade = "D"
else:
	grade = "E"

print("对应的五分制成绩时：{}".format(grade))

判断条件及组合

• 分支结构中的判断条件可以使用任何能够产生True或False的语句或函数。形成判断条件最常见的方式是采用关系操作符
  
• Python语言中，任何非零的数值、非空的数据类型都等价于True，0或空类型等价于False,可以直接用作判断条件
• Python语言使用保留字not、and和or对条件进行逻辑运算或组织。
• 保留字not表示单个条件的“否”关系，and表示多个条件之间的“与”关系，保留字or表示多个条件之间的“或”关系。

3、循环结构

程序的循环结构

• Python语言的循环结构包括两种：遍历循环和无限循环
• 遍历循环使用保留字for依次提取遍历结构各元素进行处理
• 条件循环使用保留字while根据执行程序

条件循环：while

• Python通过保留字while实现无限循环
  while <条件>: <语句块>
• 当程序执行到while语句时，判断条件如果为True，执行循环体语句，语句结束后返回再次判断while语句的条件；当条件为False时，循环终止，执行与while同级别缩进的后续语句。
• while循环有一种使用保留字else的扩展模式，，使用方式如下：
  while <条件>:<语句块1> else:<语句块2>
• 这种扩展模式中，while条件为false时，else子句才会被执行

无限循环：while

xnum,xstr = 0,'Python'
while xnum < len(xstr):
	print("循环输出中："+xstr[xnum])
	xnum += 1
else:
	print("循环结束")

思考

1. 一个列表中保存了一个动物列表数据 pets = [‘dog’, ‘cat’, ‘dog’, ‘goldfish’, ‘cat’, ‘rabbit’, ‘cat’]
   如何删除所有值为cat的元素
2. 一个列表中保存了一个动物列表数据pets = [‘dog’, ‘cat’, ‘dog’, ‘goldfish’, ‘cat’, ‘rabbit’, ‘cat’]，
   如何依次弹出列表的最后一个元素，输出示例
   
3. 字符串x = ‘spam’，如何依次删除字符串的第一个字符，并且输出字符串
   输出示例：
   

# 思考1
pets = ['dog', 'cat', 'dog', 'goldfish', 'cat', 'rabbit', 'cat']
while 'cat' in pets:
	pets.remove('cat')
pets
 
# 思考2
pets = ['dog', 'cat', 'dog', 'goldfish', 'cat', 'rabbit', 'cat']
while pets:
	print("This is {}".format(pets.pop()))

# 思考3
x = 'spam'
while x:
	x = x[1:] # 使用列表的切片
	print(x)

循环控制: break和continue

• break语句用于控制程序流程，可使用它来控制哪些代码行将执行，哪些代码行不执行，从而让程序按你的要求执行你要执行的代码。
• continue语句会返回到循环开头，并根据条件测试结构是否继续执行循环，可使用continue语句，它不像break语句那样不再执行余下的代码并退出整个循环。
• 如果有2层或多层循环，break退出最内层循环。
• continue用来结束本次循环，即跳出循环体中下面尚未执行的语句，但不跳出当前循环。

遍历循环: for

• 遍历循环可以理解为从遍历结构中逐一提取元素，放在循环变量中，对于每个所提取的元素执行一次语句块。for语句的循环执行次数是根据遍历结构中元素个数确定的。
• for循环在python中一个通用的序列迭代器：它可以遍历任何有序序列或者其它可嗲到对象内的元素。for语句可用于字符串、列表、元组或其它内置可迭代对象
  for <循环变量> in <遍历结构>: <语句块>
• 遍历结构可以是字符串、文件、range()函数或组合数

遍历循环: for 遍历不同数据类型

• 对于字符串，可以逐一遍历字符串的每个字符，基本使用方法如下：for <循环变量> in <字符串变量>:
• 对于列表和元组，可以逐一遍历列表和元素中每个元素，基本使用方法如下：
  for <循环变量> in <列表变量>: <语句块>
for <循环变量> in <元组变量>: <语句块>
• 对于集合可以逐一遍历列表集合每个元素，基本使用方法如下：for <循环变量> in <集合变量>: <语句块>
• 与其它组合类型一样，字典可以遍历循环对其元素进行遍历，基本语法结构如下：for <变量名> in <字典名>: <语句块>

a = "Python !"
for i in a:
	print(i)

a = ['This','is','test']
for i in a:
	print(i,end='#')

b = ('This', 'is','python')
for i in b:
	print(i,end=' ')

x = {1,2,3,4,6,'y','q','c'}
for i in x:
	print(i,end=' ')

a = {'x':1,'y':2,'z':5,'k':4,'j':5}
# 默认获取的为字典的键名，items方法遍历key和value
for i in a:
	print(i,end='/')
# 使用get()方法来获取键值
for i in a:
	print("key:{} value:{}".format(i,a.get(i)))

遍历循环: for 多数据遍历

• 使用for语句，来遍历多个数据时，使用zip()函数，函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
• 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同for <变量名1>，<变量名2>,.. in zip(数据1,数据2,...)

x = [1,2,3,4,5,6]
y = 'qwertyuiop'
for a,b in zip(x,y):
	print(a,b)

z = ('aa','bb','cc','dd','ee','ff')
for a,b,c in zip(x,y,z):
	print(a,b,c)

遍历循环: for

• 遍历循环还有一种扩展模式，使用方法如下：
  for <循环遍历> in <遍历结构>: <语句块1> else: <语句块2>
• 当for循环正常执行之后，程序会继续执行else语句中内容。else语句只在循环正常执行之后才执行并结束，因此，可以在<语句块2>中放置判断循环执行情况的语句。

for i in "Python":
	print(i)
else:
	print("循环正常结束")

遍历循环: for，len()
for语句中，配合range()和len()，来实现对变量索引值的遍历

• 使用len(变量名)来获取变量的长度L，使用range(L)来获取变量的索引值列表
  for <循环变量> in range(len(变量名)): <语句块>

a = 'qwerty'
for i in range(len(a)):
	print("索引值：{}，值：{}".format(i,a[i]))

遍历循环: for，enumerate()
enumerate()函数会返回一个生成器对象，使用list进行包装，可以得知，返回数据为一个个元组组成的列表，每个元组的第一个值为索引值，第二个值为索引值对应的数据
for 循环变量1，循环变量2 in enumerate(变量名):<语句块>

a = 'qwertyuiop'
list(enumerate(a))
for x,y in enumerate(a):
	print("key:{} value:{}".format(x,y))

列表推导式
列表推导式（list comprehension） 是利用其它数据创建新列表（类似于数学术语中的集合推导式）的一种方法。
列表名 = [表达式 for 循环变量 in 其它数据 [条件 循环2]]
列表推导式的执行顺序：各语句之间是嵌套关系，左边第二语句是最外层，依次往右进一层，右边第一条语句是最后一层。

a = [x*x for x in range(10)]
a

b = [x for x in range(10) if x%2==0]
b

c = [(x,y) for x in range(3) for y in range(3)]
c

xlist = [x*y for x in range(1,5) if x>2 for y in range (1,4) if y<3)]
xlist

xlist2 = []
for x in range(1,5):
	if x>2:
		for y in range(1,4):
			if y<3:
				xlist2.append(x*y)
xl
xlist2

字典导式
字典名 = [表达式 for 循环变量 in 其它列表]

a = [1,2,3,4,5]
b = ['x','y','z','1','w']
GG = (j:k for j,k in zip(a,b))
GG
type(GG)

集合推导式
集合名 = {表达式 for in 循环变量 in 其它列表}

xset = (x for x in range(20) if x%3 == 0)
xset
type(xset)

练习

# 根据用于指定月份，打印该月份所属的季节。
# 提示: 3,4,5 春季 6,7,8 夏季 9,10,11 秋季 12,1, 2 冬季

month = int(input("请输入月份："))
if month in [3,4,5]:
	print("春季")
elif month in [6,7,8]:
	print("夏季")
elif month in [9,10,11]:
	print("秋季")
elif month in [12, 1, 2]:
    print("冬季")
else:
    print("请输入有效的月份（1-12）")

# 一、四位玫瑰数
# 四位玫瑰数是4位数的自幂数。自幂数是指一个 n 位数，的每个位上的数字的 n 次幂之和等于它本身。
# 例如：当n为3时，有1^3 + 5^3 + 3^3 = 153，153即是n为3时的一个自幂数，3位数的自幂数被称为水仙花数。
# 请输出所有4位数的四位玫瑰数，按照从小到大顺序，每个数字一行

for i in range(1000,10000):
	# 将数字转换为字符串，方便对每位数进行操作
	str_num = str(num)
	# 计算每个位上数字的四次方和
	digit_sum = sum(int(rose_num**4) for rose_num in str_num)
	 # 如果等于原数，则为四位玫瑰数
	if (digit_sum == num):
		print(num)

# 使用列表推导式
rose_numbers = [num for num in range(1000,10000) if sum(int(digit**4) for digit in str(num)) == num]
for num in rose_numbers:
	print(num)
	

# 二、100以内素数之和
# 求100以内所有素数之和并输出。
# 素数指从大于1，且仅能被1和自己整除的整数。
# 提示：可以逐一判断100以内每个数是否为素数，然后求和。
# 使用函数
# 判断是否素数
def is_prime(num):
    if num < 2:
        return False
    for i in range(2, int(num**0.5) + 1):
        if num % i == 0:
            return False
    return True
sum_of_primes = 0
for number in range(2, 101):
    if is_prime(number):
        sum_of_primes += number
# 使用列表推导式
prime = [num for num in range(2,101) if is_prime(num)]
sum_of_primes = sum(prime)

# 将是否为素数的判断条件也加入列表推导式中
prime = [num for num in range(2,101) if all(num % i != 0 for i in range(2,int(num**0.5)+1))]
sum_of_primes = sum(prime)
print("100以内所有素数之和为:", sum_of_primes)

# 三、求一个整数的阶乘
n = int(input("请输入一个整数："))

# 检查输入是否为非负整数
if n < 0:
    print("请输入一个非负整数。")
else:
    factorial = 1
    for i in range(1, n + 1):
        factorial *= i
    print(f"{n} 的阶乘是：{factorial}")

# 最大公约数和最小公倍数.
# 输入两个数值, 求两个数的最大公约数和最小公倍数. 
# 1. 最大公约数就是A和B能整除的最大的数;
# 2. 求最大公约数(gys)算法:
# 方法2： 穷举法(一个一个除)
# 	1). A,B两个数的最大公约数肯定小于等于相对更小的那个数;
# 	2). 从两个数中较小数开始由大到小列举;
# 	3). 直到找到公约数立即中断列举，得到的公约数便是最大公约数;
# 3. (40, 60) = 20

def find_gcd(x,y):
    if (x>y):
        x,y = y,x
    for i in range(x,0,-1):
        if x % i == 0 and y % i == 0:
            return i
def find_lcm(x,y):
    # 最小公倍数等于两数之积除以最大公约数
    lcm = (x*y) // find_gcd(x,y)
    return lcm

# 输入两个数值
num1 = int(input("请输入第一个数："))
num2 = int(input("请输入第二个数："))

# 计算最大公约数和最小公倍数
gcd = find_gcd(num1, num2)
lcm = find_lcm(num1, num2)

print(f"{num1} 和 {num2} 的最大公约数是：{gcd}")
print(f"{num1} 和 {num2} 的最小公倍数是：{lcm}")

# 猜数字游戏作业题目
'''
有猜数字游戏，其游戏规则为：
1). 程序内置一个 1 到 100 之间的数字作为猜测的结
果，由用户猜测此数字(仅5次机会)。
2). 用户每猜测一次，由系统提示猜测结果：大了、小
了或者猜对了；
3). 直到用户猜对结果，则提示游戏胜利。用户可以提
前退出游戏，即，游戏过程中，如果用户录入数字0，
或者超过5次机会，则游戏失败
'''

import random

def guess_number_game():
    print("欢迎来到猜数字游戏！我已经想好了一个1到100之间的数字，你有5次机会来猜测它。")
    
    # 生成要猜测的随机数字
    secret_number = random.randint(1, 100)
    
    for attempt in range(1, 6):
        guess = int(input(f"这是你的第 {attempt} 次猜测，请输入一个数字："))
        
        if guess == 0:
            print("你选择了退出游戏。")
            return
        
        if guess < secret_number:
            print("你猜的数字太小了。")
        elif guess > secret_number:
            print("你猜的数字太大了。")
        else:
            print(f"恭喜你，你猜对了！答案就是 {secret_number}。")
            return
    
    print(f"很遗憾，你没有在5次机会内猜对数字。游戏结束，正确答案是 {secret_number}。")

guess_number_game()

---

总结

Python的集合与字典是非常有用的数据类型，能够帮助我们更高效地处理数据。集合的无序性和不重复性为数据处理提供了很大的便利，而字典的键-值对的存储方式则可以快速地进行数据查找和访问。同时，我们还学习了Python中的控制流程，如条件判断和循环结构，它们可以根据不同的情况执行不同的代码块，从而实现更复杂的逻辑控制。

通过学习本文的内容，读者可以深入了解Python中集合、字典和控制流程的使用方法，进一步提升自己的编程能力和效率。无论是在数据分析、Web开发还是其他领域，掌握这些知识都将为我们带来更多的可能性和创造力。所以，让我们开始学习吧！