1. 循环结构类型

常见的循环结构有三种：

for循环 while循环 do while循环	  	

2. for循环

for循环的常用格式为：
 for(初始条件;判断条件;循环控制){
 	  循环体；
 	  }

for循环的执行顺序是：首先执行初始条件语句，执行判断条件语句，如果判断结果为false则不进入循环体，如果为true则执行循环体语句，执行完循环体语句之后会执行循环控制语句，反复循环直到判断为false为止。

==  注意：初始条件语句只会执行一次！==
3.while循环

while循环的常用格式为：

初始条件语句；
while(条件判断表达式){
	 	   	循环体；
	 	   	控制语句；
	 	   	}

执行的顺序也是先执行初始条件语句，进入判断语句，如果为false则不进入循环，否则进入循环顺序执行。直到判断为false为止。
4. do while循环

do while循环的常用格式为：
do{
 	循环体；
 	条件控制语句；
 	}while（条件判断语句）

do while循环语句是先执行一次循环体之后再执行判断的，所以do while 循环语句的循环体至少执行了一次！

Python.<习题四> 循环结构
1.编写程序，计算1×2×3×…×10.
s=1
i=1
while i<=10:
    s=s*i
    i=i+1
print("s=",s)



2.编写程序，计算1+3+5+…+99.
sum=0
for i in range(1,100,2):
    sum=sum+i
print("sum=",sum)




3.编写程序，输出1~100之间所有能被3整除，但是不能被5整除的数。
for i in range(1,100):
    if i%3==0:
        continue
    print(i,end=" ")




4.编写程序，输出1000~2000年之间所有闰年，要求每行输出5个年份。
n=0
for i in range(1000,2000+1):
    if (i%4==0 and i%100!=0) or (i%400==0):
        n+=1
        print("{}".format(i),end=" ")
        if n%5==0:
            print("")




5.编写程序，输出斐波那契数列的前20项，要求每行输出5项。
Fib1=1
Fib2=1
print(Fib1,Fib2,end=" ")
n=2
for i in range(3,20+1):
    Fibi=Fib1+Fib2
    Fib1=Fib2
    Fib2=Fibi
    n+=1
    print("{}".format(Fibi),end=" ")
    if n%5==0:
        print("")




6.编写程序，从键盘上输入10个整数，输出这10个数中所有奇数之和，偶数之和及所有数的平均值。
sum1=sum2=0
for i in range(10):
    num=eval(input("请输入一个整数："))
    if num%2==1:
        sum1=sum1+num
    else:
        sum2=sum2+num
avg=(sum1+sum2)/10
print("所有奇数之和：{}，所有偶数之和：{}，平均值:{}".format(sum1,sum2,avg))



7.编写程序，从键盘上输入若干个整数，求出这些整数中所有奇数之和、偶数之和及所有数的平均值，当从键盘输入字符"A"时，程序输出计算结果。
sum1=sum2=k=0
num=input("请输入一个整数（输入字符A时结束处理）：")
while num!='A':
    k=k+1
    num=int(num)
    if num%2==1:
        sum1=sum1+num
    else:
        sum2=sum2+num
    num=input("请输入一个整数（输入字符A时结束处理）：")
avg=(sum1+sum2)/k
print("所有奇数之和：{}，所有偶数之和：{}，平均值:{}".format(sum1,sum2,avg))




8.编写程序，输出1×2×3+3×4×5+5×6×7+…+99×100×101的值。
sum=0
for i in range(1,100,2):
    sum=i*(i+1)*(i+2)
print("结果为：",sum)
    



9.编写程序，计算s=a+aa+aaa+…+aaa…aaa的值，其中a是1~9之间的某个数字，n是一个正整数。例如，当a=2，n=5时，s=2+22+222+2222+22222=24690.
#方法一
a,n=eval(input("请输入a，n的值"))
s=0
item=0
for i in range(1,n+1):
     item=item*10+a
     s=s+item
print("值为：",s)


#方法二
a,n=eval(input("请输入a，n的值"))
s=0
for i in range(1,n+1):
    s=s+int(str(a)*i)
print("值为：",s)




10.编写程序，实现猜数游戏。在程序中随机生成一个0~9之间（包含0和9）的随机整数T，让用户通过键盘输入所猜的数。如果输入的数大于T，显示“遗憾，太大了”；如果小于T，显示“遗憾，太小了”；如此循环，直至猜中该数，显示“预测N次，你猜中了”，其中N是指用户在这次游戏中猜中该随机数一共尝试的次数。
import random
rnd=random.randint(0,9)
print("系统刚随机产生了一个0~9之间的一个整数")
user=int(input("请输入你猜的数"))
k=0
while 1:
    k=k+1
    if user>rnd:
        print("遗憾，太大了")
        user=int(input("请继续输入你猜的数"))
    elif user<rnd:
        print("遗憾，太小了")
        user=int(input("请继续输入你猜的数"))
    else:
        print("预测{}次，你猜中了".format(k))
        break




11.编写程序，产生两个0~100之间（包含0和100）的随机整数RND1和RND2，求这两个整数的最大公约数和最小公倍数。
import math
import random
RND1=random.randint(0,100)
RND2=random.randint(0,100)
gys=math.gcd(RND1,RND2)
gbs=RND1*RND2/gys
print("{}和{}的最大公约数为:{},最小公倍数为:{}".format(RND1,RND2,gys,gbs))



12.编写程序模拟硬币的投掷。假设0表示硬币反面，1表示硬币正面。在程序中让计算机产生若干次（建议大于100次）随机数，统计0和1分别出现的次数，并观察0和1出现的次数是否相同。
import random
num0=0
n=eval(input("请输入你要模拟投掷硬币的次数："))
for i in range(n):
    rnd=random.randint(0,1)
    if rnd==0:
        num0=num0+1
num1=n-num0
print("硬币反面{}次,硬币正面面{}次".format(num0,num1))
    




13.编写程序，计算“天天向上”和“天天向下”两种情况下的武力值。假设一年有365天，郭大侠第一天的武力值为1.如果郭大侠每天勤于练功，每天武力值相比前一天会增加1%；如果郭大侠每天不练功，每天武力值相比前一天会减少1%。郭大侠制定了一年的练功计划：从第一天开始，前五天每天练功，然后休息两天；接下来又练功五天，休息两天；如此往复，请计算一年后，郭大侠的最终武力值（结果保留2位小数）。
gdxwlz=1
for i in range(1,366):
    if i%6==0 or i%7==0:
        gdxwlz=gdxwlz*(1-0.01)
    else:
        gdxwlz=gdxwlz*(1+0.01)
print("郭大侠的最终武力值为:{:.2f}".format(gdxwlz))




14.编写程序，计算糖果总数。假设有一盒糖果，按照如下方式从中取糖果：

一个一个地取，正好取完

两个两个地取，还剩一个

三个三个地取，正好取完

四个四个地取，还剩一个

五个五个地取，还差一个

六个六个地取，还剩三个

七个七个地取，正好取完

八个八个地取，还剩一个

九个九个地取，正好取完

请问：这个盒子里至少有多少个糖果？
n=1
while 1:
    if n%2==1 and n%3==0 and n%4==1 and n%5==4 and n%6==3 and n%7==0 and n%8==1 and n%9==0:
        print("这个盒子里一共有{}个糖果".format(n))
        break
    else:
        n=n+1



如果我整理的对你有用，就关注我吧。嘻嘻

所谓循环，就是重复执行一段代码，计算机的判断能力和人相比差的很远，计算机更擅长一件事情——不停的重复。而我们在JavaScript中把这叫做循环。下面让我们来了解了解JavaScript里的循环。
js循环结构有哪些
js循环结构有三种

for循环 ==> 用来多次遍历代码块
while循环 ==> 当指定条件为true时，循环代码块
do while ==> 当指定条件伪true时，循环代码块

1、for循环
for是由两个部分组成，条件控制和循环体

语法：
for(初始化表达式;循环条件表达式;循环后的操作表达式){
	需要重复的代码块;
}

for语句结构如图：



for循环的执行顺序
1.初始化表达式

2. 循环条件表达式

3. 需要重复的代码块

4. 循环后的操作表达式
简单的for循环，循环执行一次会改变一个变量的值

举例：输出1到100的值
for(var i=1; i <= 100; i++){
//在循环开始时设置一个变量i；//定义运行循环的条件i<=100;//每个循环执行后，变量增加1
console.log(i);
}

2、while循环
while循环会重复执行一段代码，直到某个条件不再满足。

语法：
while(条件表达式语句){
	执行的代码块;
}

while循环结构如图：



while执行顺序

当我们的使用条件条件返回值是true，就会执行大括号里面的代码块，执行完大括号的语句之后，会重复大括号里的语句，直到判定条件返回值为false，才会结束循环。
案例：
var i = 0;
while (i < 10){
	console.log(i);
	i++;
}
//while循环会先判定条件，再根据条件是否成立达成决定是否进入循环
//如果条件一开始就是false ，则不会进入循环

缺点：

使用while语句的时候，一定要写大括号
如果没有条件的话，会无限的运行下去，造成死循环。

3、do while循环的结构
do while 结构的基本原理和while结构是基本相同的，但是它保证循环体至少被执行一次。因为它是先执行代码，后判断条件

语法：
do {
	执行语句块;
}
while(条件表达式语句);

do while 执行顺序：

先执行一次code，再做判断。与while循环不同，do while无论条件如何 都会执行一次代码

案例：
var i = 0;
do{
	console.log(i);
	i++;
}while(i<10);

while 和 do while的不同

while:   先判断 再执行   条件不成立   循环体 一遍都不执行
do…while: 先执行 再判断  条件不成立  循环体 至少执行一遍

1.6 Python循环结构
1.6 Python循环结构
1.6.1 while型循环
1.6.2 for ... in 循环
1.6.3 range()函数:
1.6.4 break和continue语句及循环中的else子句：

1.6 Python循环结构


循环结构就是为了将相似或者相同的代码操作变得更见简洁，使得代码可以重复利用


循环结构分为2类：while循环 和 for…in循环


1.6.1 while型循环
格式1：
    while 条件表达式：
        循环的内容
        [变量的变化]

格式2：

    while 条件表达式：
        循环的内容
        [变量的变化]
    else:
        python语句..


注意:while循环中的else是在while条件表达式为假的情况下执行的代码内容,一般用于判断起始条件是否为假等相关操作。

实例使用了 while 来计算 1 到 100 的总和：
#!/usr/bin/env python3

n = 100
sum = 0
counter = 1
while counter <= n:
    sum = sum + counter
    counter += 1

print("1 到 %d 之和为: %d" % (n,sum))


执行结果如下：

1 到 100 之和为: 5050

死循环：

死循环就是循环不会终止的循环类型，通过将用于判断的条件表达式设置为永远为True来实现。

    while True:
        python代码...
        python代码...
        ...

#!/usr/bin/python3

var = 1
while var == 1 :  # 表达式永远为 true
   num = int(input("输入一个数字  :"))
   print ("你输入的数字是: ", num)

print ("Good bye!")


你可以使用 CTRL+C 来退出当前的无限循环
执行以上脚本，输出结果如下：


输入一个数字  :5

你输入的数字是:  5

输入一个数字  :

1.6.2 for … in 循环

for…in 循环用于遍历容器类的数据（字符串，列表，元组，字典，集合）

格式：

    for  变量  in  容器：
        python代码,可以在此使用变量

格式2：

    for 变量1,变量2 in 容器：
        python代码,可以在此使用变量1和变量2


要求遍历的容器必须是一下几种格式：

[(),(),()] 列表中有元组
[[],[],[]] 列表中有列表
((),(),()) 元组中有元组
{(),(),()} 集合中有元组
字典的特殊使用



格式3：
    for  变量  in  容器：
        python代码,可以在此使用变量
    else:
        循环结束是执行的代码！

>>>languages = ["C", "C++", "Perl", "Python"] 
>>> for x in languages:
...     print (x)
... 
C
C++
Perl
Python
>>>

1.6.3 range()函数:

如果你需要遍历数字序列，可以使用内置range()函数。它会生成数列，例如:

>>>for i in range(5):
...     print(i)
...
0
1
2
3
4

>>>for i in range(5,9) :
    print(i)


5
6
7
8
>>>

>>>for i in range(0, 10, 3) :
    print(i)


0
3
6
9
>>>

>>>for i in range(-10, -100, -30) :
    print(i)

-10
-40
-70
>>>


您可以结合range()和len()函数以遍历一个序列的索引,如下所示:

>>>a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
>>> for i in range(len(a)):
...     print(i, a[i])
... 
0 Google
1 Baidu
2 Runoob
3 Taobao
4 QQ
>>>

输出乘法口诀：
for i in range(1,10):
    for j in range(1,i+1):
        print(str(i)+'*'+str(j)+"="+str(i*j),end="")
    print()

1.3.7 作业：逆向输出乘法口诀：
for i in range(9,0,-1):
    for j in range(i,0,-1):
        print(str(i)+'*'+str(j)+"="+str(i*j),end="")
    print()

1.6.4 break和continue语句及循环中的else子句：
break语句：

break作用:在循环中break的作用是终止当前循环结构的后续操作，一旦程序运行了break，循环也就终止了！
break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。 实例如下：

#!/usr/bin/python3

for letter in 'Runoob':     # 第一个实例
   if letter == 'b':
      break
   print ('当前字母为 :', letter)

var = 10                    # 第二个实例
while var > 0:              
   print ('当期变量值为 :', var)
   var = var -1
   if var == 5:
      break

print ("Good bye!")


执行以上脚本输出结果为：


当前字母为 : R

当前字母为 : u

当前字母为 : n

当前字母为 : o

当前字母为 : o

当期变量值为 : 10

当期变量值为 : 9

当期变量值为 : 8

当期变量值为 : 7

当期变量值为 : 6

Good bye!

continue语句：

continue语句被用来告诉Python跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

#!/usr/bin/python3

for letter in 'Runoob':     # 第一个实例
   if letter == 'o':        # 字母为 o 时跳过输出
      continue
   print ('当前字母 :', letter)

var = 10                    # 第二个实例
while var > 0:              
   var = var -1
   if var == 5:             # 变量为 5 时跳过输出
      continue
   print ('当前变量值 :', var)
print ("Good bye!")


执行以上脚本输出结果为：


当前字母 : R

当前字母 : u

当前字母 : n

当前字母 : b

当前变量值 : 9

当前变量值 : 8

当前变量值 : 7

当前变量值 : 6

当前变量值 : 4

当前变量值 : 3

当前变量值 : 2

当前变量值 : 1

当前变量值 : 0

Good bye!


循环语句可以有 else 子句，它在穷尽列表(以for循环)或条件变为 false (以while循环)导致循环终止时被执行,但循环被break终止时不执行。
如下实例用于查询质数的循环例子:

#!/usr/bin/python3

for n in range(2, 10):
    for x in range(2, n):
        if n % x == 0:
            print(n, '等于', x, '*', n//x)
            break
    else:
        # 循环中没有找到元素
        print(n, ' 是质数')


执行以上脚本输出结果为：

2  是质数
3  是质数
4 等于 2 * 2
5  是质数
6 等于 2 * 3
7  是质数
8 等于 2 * 4
9 等于 3 * 3

pass 语句:


Python pass是空语句，是为了保持程序结构的完整性。


pass 不做任何事情，一般用做占位语句，如下实例


>>>while True:
...     pass  # 等待键盘中断 (Ctrl+C)
最小的类:


>>>class MyEmptyClass:
...     pass