循环控制语句
循环控制语句描述：在程序中，用于重复执行一段代码逻辑的语法结构称为循环控制语句
解释：
循环就是重复的意思，在程序设计中往往将一个重复执行的代码用于循环体，以保证以最少的代码达到多次执行的目的，减少代码的冗余。
1、 for 循环
Python中的for语句接收可迭代对象，如序列和迭代器作为参数，每次循环可以调取其中一个元素,执行相同的操作。
语法格式为:
for 临时变量 in 循环变量(如字符串|列表|元组|字典|集合)∶
循环执行的代码块
临时变量与循环变量：
1).临时变量是循环变量的元素，比如循环变量是一个字符串，临时变量就是循环变量的每一个字符
2).for循环也称为遍历或迭代，要求循环变量是一个“可迭代对象”。
代码执行特点：
可迭代对象里面有几个元素，就重复执行几次for循环的代码块
for循环适用场景
1.遍历出循环变量的元素做出指定的操作
2.控制循环次数重复执行同一段代码
for循环语句的执行流程图:
for…else…语法
1.语法：
for 临时变量 in 循环变量
代码块
else：
代码块
2.代码执行：
else这里的代码块是在我们执行完for循环以后再去执行的
3.注意：做理解即可，不常用
1.1 for循环遍历列表
使用for循环打印班级学生名单列表中所有名字:
names =["王玉梅","张勇","王杰","胡平","陈康"]
for name in names:
print (name)
运行结果为：
1.2 for循环遍历字典
for循环遍历字典用到和字典相关的方法:
items ( )、keys( ) 、 values( )
如果使用for循环直接遍历字典，则迭代变量会被先后赋值为每个键值对中的键。
循环输出字典中的value的代码:
my_dic = {'王海': "32",'杨梅': "36",'龙元': "12"}
for dic in my_dic.keys():
print (dic)
print("******************************")
for dic in my_dic:
print (dic)
运行结果如下：
由上述可知，直接遍历字典，和遍历字典keys(方法的返回值是相同的。
遍历字典values( )、items()方法的返回值。
遍历字典的items(和values()返回值的代码:
my_dic = {'王海': "32",'杨梅': "36",'龙元': "12"}
# 遍历字典的 items() 值
for ele in my_dic.items():
print (ele)
print("******************************")
# 遍历字典的 values()值
for ele in my_dic.values():
print (ele)
运行结果为：
1.3 for循环遍历元组
my_tuple = ('王海','杨梅','龙云')
for value in my_tuple:
print (value)
运行结果为：
1.4 for循环遍历集合
for循环遍历集合与元组类似,只是把圆括号换成了大括号。
使用for循环对集合进行了遍历:
my_tuple = {'王海','杨梅','龙云'}
for value in my_tuple:
print (value)
运行结果为：
用for循环打印星星
# hs= 10
# for i in range(1,hs+1):
# xgeshu = 2*i-1 #*个数
# kggeshu =hs -i# 空格的个数
# print(kggeshu * " " + xgeshu * "*")
运行结果为：
2、while 循环
while循环和if条件分支语句相同:
即在条件为真的情况下，会执行相应的代码块。
while循环和if条件分支语句不同:
只要条件为True，while会一直重复执行那段代码块，直到指定的条件不满足为止。
语法格式如下:
while 条件（表达式）:
代码块条件成立时执行的代码
代码块:
指缩进格式相同的多行代码,在循环结构中,又称为循环体。
代码执行特点：
条件为True时 会执行while缩进下的代码
while语句执行的具体流程为:
判断表达式的值,其值为真时，则执行while后面的代码块,当执行完毕后,再重新判断表达式的值是否为真,若仍为真，则继续重新执行代码块,如此循环,直到表达式的值为假,终止循环。
while循环结构的执行流程如下图所示:
Python 提供了 for 循环和 while 循环（在 Python 中没有 do…while 循环）:
while循环可以用于有限循环和死循环，多用于死循环，有限循环多用于for循环
**使用while循环来数数:**
current_number = 1
while current_number <=5:
print (current_number)
current_number += 1
运行结果为：
#1
#2
#3
#4
#5
由于1小于5，因此打印1，并将current_number的值加1，使其为2;由于2小于5，因此打印出2,并将current_number加1，使其为3，以此类推，一旦current_number大于5，循环将终止，整个程序也将结束。
注意:
在使用while 循环时,一定要保证循环条件有变成False的时候,否则这将成为死循环。
死循环指无法结束循环的循环结构。
2.1 基础数据类型的布尔属性
想要判断一个数的布尔属性值 bool()
1.字符串：
True:非空字符串
False:空字符串
2.整型：
True:非0
False:0
3.列表：
True:非空列表
False:空列表
4.元组：
True:非空元组
False:空元组
5.字典：
True:非空字典
False:空字典
6.集合：
True:非空集合
False:空集合
2.1 while循环遍历字符串
while循环常用来遍历列表、字典、元组和字符串，因为它们支持通过下标索引获取指定位置的元素。
如何使用while循环遍历一个字符串变量:
my_char= "学习Python，我是认真的"
# print(len(my_char)) #14
i = 0
#定义变量i作为列表的下标,通过下标的方式获取元素
while i < len(my_char):#len函数返回列表元素个数
print (my_char[i],end="")
i = i +1
运行效果:
学习Python,我是认真的
2.2 while循环遍历列表
while遍历列表与遍历字符串类似，需要定义一个下标变量，通过下标方式访问列表的元素。
while 循环遍历列表的示例:
names =["王玉梅","张勇","王杰","胡平","陈康"]
i=0
# 定义变量i 作为列表的下标，通过下标的方式获取元素
while i < len(names): #len函数返回列表元素个数
print(names[i])
i+=1
运行结果为：
2.3 while循环遍历字典
while循环遍历字典，通过字典的popitem( )方法删除并返回最后一个元素的方式实现。
示例代码如下:
my_dic ={'王海':"32",'杨梅':"36",'龙云':"12"}
while my_dic:
#popitem() 随机返回并删除字典中的最后一对键和值。
print (my_dic.popitem())
运行结果为：
补充：
Python 字典 popitem() 方法返回并删除字典中的最后一对键和值。
如果字典已经为空，却调用了此方法，就报出 KeyError 异常。
语法
popitem()
参数
无
返回值
返回一个键值对(key,value)形式。
代码示例
site= {'语文': '99', '数学': 100, '英语': '89'}
pop_obj=site.popitem()
print(pop_obj)
print(site)
运行结果为：
使用while循环获取字典的value值时，使用list函数把字典的keys转换为列表,通过遍历列表的方式来获取字典的value值。
my_dic = {'王海':"32",'杨梅':"36",'龙云':"12"}
# #使用list函数把字典的 keys转换为列表
key_list = list(my_dic.keys())
i = 0
while i < len(key_list):
print (my_dic[key_list[i]])
i +=1
#运行结果为：
#32
#36
#12
2.3 while循环遍历元组
while遍历元组与遍历集合方法类似。
示例代码如下：
names = ("王玉梅","张勇","王杰")
i=0
while i < len(names):
print(names[i])
i +=1
3、循环结构中else用法
无论是while循环还是for循环，其后都可以紧跟着一个else 代码块,作用是当循环条件为False跳出循环时，程序会最先执行else代码块中的代码。
以while 循环为例:
str ="学习Python,我是认真的"
i = 0
while i < len(str) :
print(str[i], end="") #end意思就是以给定字符串或制表符结尾,但是不默认换行。
i = i + 1
else:
print("\n执行else代码块")
运行结果为：
注意:
当i等于str字符串长度结束循环时，解释器会执行while循环后的else代码块。
4、range函数
Python中range函数可以轻松的生成一系列的数字。
使用语法如下: range(start,stop[，step])
参数说明:
start ——: 计数从start开始。默认是从0开始。
例如range (5）等价于range (0,5）;
stop ——: 计数到stop 结束，但不包括stop。(左闭右开）
例如:range (0,5）是[0， 1，2，3，4]没有5
step ——:步长，默认为1。例如:range (0,5) 等价于range(0,5,1)
for i in range(10,0,-1):
print(i)
#运行结果为：10，9，8，7，6，5，4，3，2，1
for循环道歉20次
# for循环道歉20次
for i in range(20):
print("对不起，我错了，这是我第%d次道歉了"%(i+1))
#%d用于在需要输出的长字符串中占位置 整型（表示格式化一个对象为十进制整数）
#"里面的%是个识别语句，会在"后面寻找%这个关键符号，寻找到了就会进行赋值，这里就是"里面的%d ="外面的 %x
用while循环打印星星
i = 0
while i < 10:
i += 1
xhgs = 2*i - 1
kegs = 10 - i
print(kegs * " " + xhgs * "*")
运行结果为：
练习：
str0 = “ahgajkndgehiuuasdnvmklsjghyeuisdfsdbfqwegsdbsdqdfnguwerihwekfnasd”
使用while遍历str0，统计每个字符出现的次数，要求将结果保存到字典中，例如：{“a”: 8, “g”: 6}
最后将结果打印输出
str0 = "ahgajkndgehiuuasdnvmklsjghyeuisdfsdbfqwegsdbsdqdfnguwerihwekfnasd"
dict0 = {}
list01=list(set(str0)) #转换成集合后再转换成列表，转换成集合可以去掉重复的元素
i= 0
while i < len(list01):
char0 = list01[i] #遍历list01里面的字符串存到char0中
cishu = str0.count(char0) #统计列表str0中char0里面字符串出现的次数，存到cishu中
dict0[char0] = cishu #改变dict0字典里面的char0这个属性的值为cishu
i += 1
print(dict0)
运行结果为：
#{'i': 3, 'r': 1, 'h': 4, 'v': 1, 'u': 4, 'l': 1, 'k': 3, 'g': 5, 'a': 4, 'q': 2, 'd': 8, 'j': 2, 'y': 1, 'm': 1, 'w': 3, 's': 7, 'b': 2, 'e': 5, 'f': 4, 'n': 4}
dict01 = {'a':1,'b':2,}
dict01['c'] = 3 #给dict01这个属性一个值，若字典中没有这个属性，会自动创建这个属性和值
dict01['a'] = 4 #若字典中有这个属性，就会改变这个属性的值
print(dict01)
#运行结果为：
#{'a': 4, 'b': 2, 'c': 3}
5、推导式
推导式又称解析式，是Python的一种独有特性。
推导式是可以从一个数据序列构建另一个新的数据序列的方式。
推导式包括列表推导式、字典推导式和集合推导式。
5.1 列表推导式
语法:
变量名=[表达式for变量in列表]
变量名=[表达式for变量in列表if 条件]
语法说明:
遍历出列表中的内容给变量,表达式根据变量值进行逻辑运算，或者遍历列表中的内容给变量，然后进行逻辑判断，把符合条件的值赋给变量。
用法：
list1 = [i for i in range (1,11)]
list2 = [i for i in range(1,11) if i % 2==0]
print(list1)
print(list2)
运行结果为：
5.2 字典推导式
列表推导式思想的延伸,语法相似，只不过产生的是字典而已。
将字典中的key和value 进行对换示例:
mydict = {"a": 1,"b":2,"c": 3}
mydict_new= {v: k for k,v in mydict. items()}
print (mydict_new)
运行效果:
{1: ‘a’, 2: ‘b’, 3: ‘c’}
names =["张三","李四"]
yingyu= [35,87]
dict = {k:v for k,v in zip(names,yingyu)}
print (dict)
newList = zip(names,yingyu,[18,17])
print (list(newList))
# zip()方法是将多个序列压缩（合并）成一个序列
#运行结果为：
#{'张三': 35, '李四': 87}
#[('张三', 35, 18), ('李四', 87, 17)]
5.3 集合推导式
跟列表推导式非常相似,区别在于用{ }代替[ ]。
示例:
set = {x for x in range(10) if x % 2==0}
squared = {x ** 2 for x in range(1,11)}
print(set)
print(squared)
运行效果:
{0，2，4，6，8}
{64，1，4，36，100，9,16，49，81，25}
6、多变量迭代
多变量迭代通过多个变量同时迭代列表中的数据。
示例:
tuple_list = [(1,5),(2,6),(3,7),(4,8)]
for x, y in tuple_list:
print (x, y)
print("两个元素之和:",x +y)
运行结果为：
names =["张三","李四","吴用"]
yingyu= [35,87,90]
age01= [18,17,19]
for n,y,a in zip(names,yingyu,age01):
#zip()方法是将多个序列压缩成一个，实际上就是合并成一个序列
print ("{0}的年龄为{2}岁,英语的成绩为{1}分".format(n,y,a))
#运行结果为：
#张三的年龄为18岁,英语的成绩为35分
#李四的年龄为17岁,英语的成绩为87分
#吴用的年龄为19岁,英语的成绩为90分
补充： zip() 函数
zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
zip 语法：
zip([iterable, …])
示例：
a = [1,2,3]
b = [2,3,4]
c = [4,5,6,7,8]
zipped = zip(a,b)
print(zipped) # 返回一个对象
print(list(zipped)) # list() 转换为列表
print(list(zip(b,c))) # 元素个数与最短的列表一致
运行结果如下：
a = [1,2,3]
b = [2,3,4]
a1, a2 = zip(*zip(a,b)) # 与 zip 相反，zip(*) 可理解为解压，返回二维矩阵式
print(list(a1))
print(list(a2))
运行结果为：
[1, 2, 3]
[2, 3, 4]
案例：分析班级的BMI值
任务实现步骤
1.输入班级学生的姓名、身养高、体重信息
2.创建name、weight和height变量分别存储姓名、体重和身高信息
3.编写循环语句
4.根据if…elif…else分支控制语句和BMI分类信息表定义的BMI值分别输出不同的体质分类
5.输出个人BMII体质分类信息
代码如下：
print("---------------for循环---------------")
classesBMI = [('王玉梅',1.6,50),('张勇',1.75,57),('王杰',1.56,68),('王胡平',1.67,87),('陈康',1.78,73)]
for names,height,weight in classesBMI:
bmi = weight/pow(height,2)
who,nat = '','' #国际国内
if bmi < 18.5:
who,nat = '偏瘦','偏瘦'
elif 18.5 <= bmi <=24:
who,nat = '正常','正常'
elif 24 <= bmi <= 25:
who, nat = '正常', '偏胖'
elif 25 <= bmi <= 28:
who,nat = '偏胖', '偏胖'
elif 28 <= bmi <= 30:
who, nat = '偏胖', '肥胖'
else:
who,nat = '肥胖','肥胖'
print('{0}的BMI值为{1}：国际{2},国内{3}'.format(names,format(bmi,'2f'),who,nat))
print("---------------while循环---------------")
classesBMI = [('王玉梅', 1.6, 50), ('张勇', 1.75, 57), ('王杰', 1.56, 68), ('王胡平', 1.67, 87), ('陈康', 1.78, 73)]
while classesBMI:
person = classesBMI.pop()
names, height, weight = person[0], person[1], person[2]
bmi = weight / pow(height, 2)
who, nat = '', '' # 国际国内
if bmi < 18.5:
who,nat = '偏瘦','偏瘦'
elif 18.5 <= bmi <=24:
who,nat = '正常','正常'
elif 24 <= bmi <= 25:
who, nat = '正常', '偏胖'
elif 25 <= bmi <= 28:
who,nat = '偏胖', '偏胖'
elif 28 <= bmi <= 30:
who, nat = '偏胖', '肥胖'
else:
who,nat = '肥胖','肥胖'
print('{0}的BMI值为{1}：国际{2},国内{3}'.format(names,format(bmi,'2f'),who,nat))
运行结果为：
7、循环嵌套
执行流程为：
1. 当外层循环条件为True时则
执行外层循环结构中的循环体。
2. 外层循环体中包含了普通程序和内循环,当内层循环的循环条件为True时会执行此循环中的循环体,直到内层循环条件为False,跳出内循环。
3. 如果此时外层循环的条件仍为True则返回第2步，继续执行外层循环体直到外层循环的循环条件为False。
4. 当内层循环的循环条件为False且外层循环的循环条件也为False,则整个嵌套循环才算执行完毕。
7.1 for嵌套循环
定义：指for循环里面还包含for循环。
语法格式：
for 迭代变量 in 序列：
for 迭代变量 in 序列：
代码块1
代码块2
实例：使用嵌套循环输出2—50之间的素数（指除了1和它本身以外，不能被任何整数整除的数）。
num = []
i = 2
# 利用for循环遍历2-51之间的整数
for i in range(2,51): #range计数到51 结束，但不包括51。(左闭右开）
j = 2
# 遍历2到当前第一层遍历的整数
for j in range(2,i): #2-50之间的数
if i % j == 0: #因为要判断是否能被自身和1以外的正数整除，所以就要从2到这个数，不包括这个数的数字全部都要除一遍，看看是否能被整除
break #被整除就退出循坏
else:
num.append(i)
print("2-50包含的素数有：",num)
#运行结果为：2-50包含的素数有： [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]
7.2 while嵌套循环
语法格式：
while 表达式1
while 表达式2：
代码块1
代码块2
实例：使用嵌套循环输出2—50之间的素数
i = 2
num = []
while i < 50:
j = 2
while j <= (i / j):
if not (i % j): #判断是否整除，有整除和不整除两种情况 如果整除就停止循环 not true==false，not false==true
break
j = j + 1
if j > i / j:
num.append(i)
i = i + 1
print("2-50包含的素数有：",num)
#执行结果为：2-50包含的素数有： [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]
正三角形
i = 1
while i <= 5: #第一层的while循环是行
j = 1
while j <= i:
print("*",end=" ")
j += 1
print() #没有end=" "修改 都是换行效果。输出了就换行，相当于打印一个空，然后换行
i += 1
倒三角形
# 倒三角形
i = 1
while i <= 5: #第一层的while循环是行
j = 5
while j >= i:
print("*",end=" ")
j -= 1
print() #没有end=" "修改 都是换行效果。输出了就换行，相当于打印一个空，然后换行
i += 1
九九乘法表
#九九乘法表
# i = 1
# while i <= 9:
# j = 1
# while j <= i:
# print("%d*%d=%d" %(i,j,i*j),end=" ")
#print(str(j)+"X"+str(i)+"="+str(i*j),end=" ")
# j += 1
# print()
# i += 1
i=1
while i<=9:
str0=" "
j=1
while j<=i:
# str1 = str(j)+"X"+str(i)+"="+str(j*i)+" "
str1 = "{0}X{1}={2}".format(j,i,i*j)+" "
str0+=str1
j+=1
print(str0)
i+=1
#for循环九九乘法表
for i in range(1,10):
for j in range(1,i+1):
# print("%d*%d=%d"%(i,j,i*j),end="")
# print(str(j)+"X"+str(i)+"="+str(i*j),end=" ")
print("{0}X{1}={2}".format(j,i,i*j),end=" ")
print()
在执行while循环或者for循环时,只要循环条件满足，程序将会`一直执行循环体`。
7.3 跳出循环
Python中强制离开当前循环体的方法:
1.使用break语句，完全终止当前循环;
2.使用continue语句,跳过执行本次循环体中剩余的代码,转而执行下一次的循环。
break语句
用来终止循环语句，即循环条件没有False条件或者序列还没被完全递归完,也会停止执行循环语句。
如果使用嵌套循环，break语句将停止执行最深层的循环，并开始执行下一行代码，而不会作用于所有的循环体。
示例：
for letter in 'Python':
#当letter 参数值为 h 时，跳出当前循环
if letter == 'h': #与if语句配合使用，表示在某种条件下跳出循环体
break
print("当前字母：",letter)
运行结果为：
continue语句
会终止执行本次循环中剩下的代码，直接从下一次循环继续执行。
continue语句的用法:
只要 while或for语句中的相应位置加入即可。
示例：
for letter in 'Python':
if letter == 'h':
#此处跳出for语句，'h'的那一次循环
continue #在本次循环内，遇见了contine，那么continue后面的代码print不会执行，h不会被打印出来，会直接进行下一次循环 o
print("当前字母：", letter)
运行结果为：
计算1-100以内10的倍数相加的和
sum=0
for i in range(100):
if(i%10): #为真,if才执行 所以i没有被整除时,余数不为0,才执行continue
continue
sum=sum+i #执行了continue,这句代码就不会被执行
print(sum)
#执行结果为：450
8、pass语句
pass是Python中的关键字，用来让解释器跳过此处,什么都不做,使用pass语句比使用注释更加优雅。
例子：
for letter in 'Python':
if letter == 'h':
pass
print("这是pass块")
print("当前字母：", letter)
print("Good bye！")
运行结果为：
9、技能拓展
1.同时遍历多个容器
借助zip()函数可将多个容器集中在一起同时遍历，zip()是Python的内建函数,可以直接使用。
x = [1,2,3,4]
y = {'a','b','c','d'}
for i, j in zip(x,y):
print(i,j)
执行结果为：
2.循环技巧
利用Python内建函数包括reversed( )、sorted( )、set( )、enumerate()函数实现一些实用的技巧。
示例代码:
for i in reversed(range(10)):
#输出结果为10 9 8 7 6 5 4 3 2 1
print(i + 1,end='') #end意思就是以给定字符串或制表符结尾,但是不默认换行。
for c in sorted('hello world'):
#输出结果为d e h l l l o o r w
print(c,end='')
for x in {1,1,2,2,2,3,3}:
#输出结果为:1 2 3
print(x,end='')
# 示例:
# 一年365天,按照每天比前1天进步或者退步1%，第1天按照能力
# 值为1计算，一年之后每天进步1%的人能力将达37.78，每天退步1%的人,能力值只剩0.03。
dayfactor = 0.01 #每天进步或退步参数
dayup = 1.0 #第一天能力值基数
daydown = 1.0 #第一天能力值基数
for i in range(365):
dayup *= 1 + dayfactor #每天比前1天进步1%
daydown *= 1 - dayfactor #每天比前1天退步1%
print("按照一年365天计算，每天提升1%，一年后能力值为:{:.2f} ".format(dayup))
print("按照一年365天计算，每天退步1%，一年后能力值为:{:.2f}".format(daydown))
案例：分年级的MIB指数
具体实现步骤如下：
1.输入年级和班级的学生姓名、身高、体重信息;
⒉创建className、name，weight和height变量分别存储班级名称、姓名、体重和身高信息;
3.编写嵌套循环语句，分别遍历年级里的班级信息和学生信息;
4.根据if…elif…else分支控制语句和BMI分类信息表定义的BMI值分别赋值不同的体质分类;
5.输出班级BMI体质分类信息;
gradsBims = [
[('19大数据1班', '王玉梅', 1.6, 50), ('19大数据1班', '张勇', 1.75, 57), ('19大数据1班', '王杰', 1.56, 68),
('19大数据1班', '胡平', 1.67, 87), ('19大数据1班', '陈康', 1.78, 73)],
[('19大数据2班', '杨子', 1.73, 86), ('19大数据2班', '常博', 1.56, 78), ('19大数据2班', '张宇', 1.75, 73),
('19大数据2班', '唐梦', 1.86, 76), ('19大数据2班', '王硕', 1.8, 73)]
]
while gradsBims: # 当列表里面的值不为空
classes = gradsBims.pop() # pop()方法用于删除列表中的最后一个元素,并返回该元素本身
# for classes in gradsBims:
print('\n-------------班级分割线--------------')
while classes:
person = classes.pop() #
# for person in classes:
className, name, height, weight = person[0], person[1], person[2], person[3]
bmi = weight / pow(height, 2)
who, nat = '', ''
if bmi < 18.5:
who, nat = '偏瘦', '偏瘦'
elif 18.5 <= bmi <= 24:
who, nat = '正常', '正常'
elif 24 <= bmi <= 25:
who, nat = '正常', '偏胖'
elif 25 <= bmi <= 28:
who, nat = '偏胖', '偏胖'
elif 28 <= bmi <= 30:
who, nat = '偏胖', '肥胖'
else:
who, nat = '肥胖', '肥胖'
print('{0}{1}的BMI数值是{2},BMI指标为:国际{3}', '国内:{4}'.format(className, name,format(bmi, '.2f'), who, nat))
运行结果为：
6480
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
