python循环语句

循环语句：

有两条循环语句：
    while 语句
    for  语句

while语句：

作用：
        根据一定条件，重复的执行一条语句或多条语句
    语法：
        while 真值表达式：
                语句块1
        else：
                语句块2

说明：

1.  先判断真值表达式，为True或false
2.  如果为true，则执行语句块1，再回到第一步
3.  如果为fasle 则执行语句块2，然后结束此while的执行
4.  else子句部可以省略 (同if语句可有可无)

示例：
#打印20行hello：

        i = 1                            #变量i用于控制变量
        while i <= 20:
            print("hello")
                i +=1                   #改变循环条件以便于循环终止
        else:
            print ("结束循环的值"，i)

结果：hello
hello
hello
hello
hello
hello
hello
hello
hello
hello
hello
hello
hello
hello

示例2 打印1到20整数

        i = 1                    #变量i用于控制变量
        while i <= 20:
                print(i)
                 i +=1               #改变循环条件以便于循环终止
        else:
                print ("结束循环的值",i)

练习：

1. 打印1到20的整数，打印在一行内：1 2 3 4 5 6 7 8……………….. print（i，end=“ “）
   答案：

i = 1                   #变量i用于控制变量
while i <= 20:
    print(i,end=" ")
    i +=1               #改变循环条件以便于循环终止

1. 打印1到20整数，每行打印5个，打印四行: 12345
   678910 提示：可用if语句嵌套到while语句中

        i = 1                   #变量i用于控制变量
        while i <= 20:
            if  i %5 ==0:       #当i除于5等于0时输出5然后得到12345换行
                print (i)         #换行作用
            else:
            print (i,end="")   
            i += 1




3.  用while语句打印10到1的整数   10 9 8 7 6 5 4..........
答案：             i= 10       
                    while  i >=10:
                        print (i)
                        i -=1



4.  打印从0开始的浮点数，每个数增加0.5，打印出10以内的这样的数
0.0
0.5
......  
答案：                      i = 0.0
                            while i<10:
                                print (i,end = "  ")
                                i+=0.5



``

`5. 写程序计算
1+2+3+4++。。。。。。。。。。。+100的和  
答案:   ```
s = 0        #用来记录和
i = 1
while i<=100:    
    s +=i                        #把i放在s内执行
    i += 1
print (s)

6．写一个程序开始的整数，用变量begin绑定
输入一个结束的整数，用变量end绑定
打印从begin到end的每个整数
如：
请输入开始：0

输入结束100打印8 9 10 11.。。。99

答案：

begin = int (input ("输入"))
end=int (input ("结束"))  
i = begin
while i<end:                    #只要循环中的数小于结束的数就一直循环直到终值为止
    print (i,end = " ")
    i +=1                   #改变循环条件以便于循环终止
else:
    print ()


思考:如何实现每五个数打印在一行内
a = int (input ("输入"))
b =int (input ("结束"))
i  = a 
while  i < b:
    print (i,end = " ")
    if  (i - a+1) % 5 == 0:
        print ()                        #默认换行
    i +=1
else:
    print ()

while的注意事项：

        要控制循环真至表达式的值来防止死循环
        通常用真值表达式内的循环变量来控制循环条件
        通常在循环语句块内改变循环变量来控制循环次数和变量走向

while语句 的嵌套

while语句本身是语句，和其他语句一样，可以嵌套到任何复合语句中

示意：

while 真值表达式：    
    。。。
    while  真值表达式2
    else：
        。。。。
else：
    。。。。。

示例：
打印1~20的整数，打印10行

j = 1
while  j<= 10:
    i= 1
    while i<=20:
        print (i，end=””)
        i += 1
    else:   
        print（）   #当i<=20执行完后换行由于j<=10还没执行完，所以换行执行
    j += 1

练习：输入一个整数代表正方形的宽度，用变量n绑定，打印指定宽的正方形

    如：
        输入5
    打印如下：
            12345
            12345
            12345
            12345
            12345

答案：

    n = int (input ("输入"))
    a  = 1
    while  a<=n:                              # 当a小于输入的数n是满足循环条件进行
        i = 1
        while i <= n:                             内部循环  #当i小于输入的书n满足条件
            print (i,end =" ")                
            i +=1                         
        else：
            print ()                #当内部循环循环一次外部循环执行一次换一次行行
        a +=1
                                内部循环当i小于输入的数n满足条件
并且直到 i<=n这一循环完成后再执行下一次a<=n的循环，然后内部循环i的值继续从i=1再次循环到i<=n完成为止
练习：
编写9*9乘法表
        a = 1
        while a <=9:                         # 循环9次123456789     
            b = 1
            while b<=a:                   内部循环
                print (a,"*",b,"=",a*b,"",end = " ")
                b +=1    
            print ()   #换行
            a+=1

#内部循环while b<=a:当b<=a 满足条件时执行循环第一次循环a = 1 则b<=1:然后开始循环循环完后，执行a+=1然后a=2开始内部循环这时b恢复初始值=1，然后b<=2,内部循环两次结束，再执行外部的循环，直到外部循环结束位置 





break语句;

    终止当前循环
作用

        用于循环语句（while，for语句）中用来终止当前循环语句的执行
语法：

        1.  当break语句执行后，此循环语句break之后的语句将不再执行
        2.  break语句通常和if语句组合使用
        3.  brank语句终止循环时else子句的语句将不会在执行
        4.  break语句只能终止当前循环语句的执行，如果有循环嵌套时不会跳出嵌套的外重循环

示例：1

        i = 1
        while i <=6:
            print ("循环开始时",i)
            if i == 3:
                break                  #当满足i==3时内部循环终止且break之后的语句将不再循环
            print ("循环结束后",i)
            i+=1                       #满足if  i==3后while循环终止
        print ("此时i的值:",i)    
        print ("结束")

        结果：循环开始时 1
        循环结束后 1
        循环开始时 2
        循环结束后 2
        循环开始时 3
        此时i的值: 3
        结束

死循环：

    死循环是指条件不

直接成立的循环
    死循环通常用break语句终止循环
    死循环的else子句永远不会执行



练习：

    任意输入一些正整数，当输入负数时结束输入
    当输入完后，打印您输入的这些数的和
    如：
    输入：1
    输入：2
    输入：3
    输入：4
    输入：-1
    . 
    打印：
    您刚才输入这些数的和10

答案：   s = 0                    #用于求和的
        while  True:
        a = int (input ("输入:"))
            if a <0 :
               break     #如果输入的数小于0则执行break，终止内部循环
            s +=a 

        print ("结束",s)

练习：
输入一个整数n，打印宽度为n个字符的正方式
如：
输入：4
打印：
####
# #
# #
####

        答案： 
        a = int (input ("输入"))
        i = 1
        n = a * "#"
        print (n)
        while  i<=(a-2):              #这块是中间有空格地方的循环

            print ("#"+"  "*(a-2)+"#")
            i += 1
        if a !=1:     #不满足则只输出上边的print(n)
            print (n)

练习; 1. 求下列多项式的和 1+1/2+1/4 +1/8+……….+1/2**1000的和

        答案：
        s = 0
        i = 1
        while  i >= 1/2**1000:
            s += i
            i *= 1/2 
        print (s)

2．1-1/3+1/5-1/7+1/9+………+1/(2*n-1)的和
1)求当n等于10000时，此公式的和
答案：

    n = 1
    sum = 0
    m = 0
    while   n <= 10000:
        if n % 2 ==0:
            sum += -(1/(2*n-1))      #如果if语句满足条件执行这一条
        else:
            m += 1/(2*n-1)             #不满足则执行这一条语句
        s = sum +m
        n +=1                   #循环终止条件
        print (s)                     #循环结束后执行输出

3.用while语句实现打印三角形，输入一个整数，表示三角行的宽度和高度，打印出相应的直角三角
如：请输入三角形宽度：4

    图案：                 ****
    *                      ***
    **                      **   
    ***                      *
    ****                     
    图案： 
    *                    ****   
    **                    ***
    ***                    ** 
    ****                    *         
    图案：

“`

            a = int (input ("输入一个整数："))
            b = 1
            e = 1
            f = a
            g = a
            c ="*" 
            d = " "
            while  b<=a:     #当b小于输入的整数a时循环

                print (b*c+d*(a-b))     #*后边加上距离最长字符的空格如输入4，*后边+4个空格
                b +=1

            print ()                         #循环完上一个while语句后换行
            while  e <=a:               #e小于等于输入的值当开始循环
                print (d*(a-e)+e*c)    
                e = e+1

            print ()
            while   f >=1:
                print (f*c+d*(a-f))s
                f -=1

            print ()
            while   g >=1:
                print (d*(a-g)+g*c)
                g -=1
            ```

for 语句：

做用’: 
    用来遍历可迭代对象的数据元素  遍历：如有六节车厢找一个人需要每节车厢找一边
        可迭代对象是指能依次获取数据元素的对象

迭代对象包括：

字符串：str
列表 list 
元组  tuple   

for语法：

for 变量列表 in可迭代对象：
语句块1
else：
    语块2

示例：

    s = "ABCD"
    for ch in s:
    print ("ch---->>"，ch)


    结果：
    ch---->> A
    ch---->> B
    ch---->> C
    ch---->> D

练习：
1. 任意输入一段字符串
a) 计算出输入字符的“a”个数，并打印出
b) 计算出空格的个数，打印个数
思考：
用while语句能否实现

a) 答案：

    a =  input ("输入字符串:")
    c = 0                               #用于求和的
    for  b  in  a :             #循环输入字符串中a的每一个元素
        if  b =="a":    #如果b中有“a”则执行下边语句
            c += 1
            print (b)     #打印出字符串a
    print (c)               #输出输入字符串中“a”的个数

b）答案：

    a =  input ("输入字符串:")
    c = 0
    for  b in a :
            if  b == " ":
            c += 1
    print ("空格个数",c)

for语句说明：

else  子句部分可以忽略
当在循环内部用break终止循环时，else子句部分不会执行

示例：

输入一段字符串，判断这个字符串内是否有“h”这个字符，并打印出来
“
答案：

        s =  input ("输入字符串:")
        for ch  in s :
            if ch == "h":
                print (s,"中含有字符“h”")
                break                   #结束循环
            else:
                print (s,"中不含有“h”")



    用while执行：
        答案：

        s =  input ("输入字符串:")
        i = 0
        while i<len(s):          #当i小于输入字符串长度不断循环直到条件不满足为止

            ch = s [i]          #判断s字符串中第几位中含有“h”字符并把h索引出来赋值给ch#

            if ch == "h":
                print (s,"中含有字符“h”")
                break 
            i +=1

            else:
                 print (s,"中不含有“h”")