精华内容
下载资源
问答
  • 循环结构概念
    千次阅读
    2017-08-04 17:34:34

    三种基本程序结构

    顺序结构

    表达式语句

    空语句

    函数调用语句

    符合语句

    实例1,发工资根据每个人的工资额(以元作为单位)计算出各种面值的钞票的张数,且要求总张数最少。

    例如 某职工工资为3863元 发工资的方案为 100元38张50元一张10元一张1元三张。

    参考程序

    #include <stdio.h>
    int main()
    {
       int m100;
       int m50;
       int m10;
       int m1;
       int money;
       scanf ("%d", &money);
       m100 = money / 100;
       money = money % 100;
       m50 = money / 50;
       money = money % 50;
     
       m10 = money / 10;
       money = money % 10;
       m5 = money / 1;
       money = money % 1;
       printf ("m100 = %d\nm50 = %d\nm10 = %d\nm1 = %d\n",
           m100, m50, m10, m1, money);
       return 0;
    }

    选择语句

    if语句

    if  (表达式) 
    {
            语句
    }
    else
    {
        语句
    }

    if 语句可以省略else部分,变为如下格式:
    if  (表达式) 
    {
        语句
    }

    写程序,判某一年是否闰年。
    输入:年(year)
    计算:判是否闰年
    输出:闰年或非闰年(leap)
    闰年条件:
    能被4整除,但不能被100整除。
    能被4整除,又能被400整除。

    参考程序

    #include <stdio.h>
    int main()
    {
        int year;
        int leap;
        scanf ("%d", &year);
        if (year % 4 == 0)
        {
            if (year % 100 == 0)
     {
         if (year % 400 == 0)
         { 
             leap =1;
         }
         else
         {
             leap = 0;
         }
     }
     else
     {
         leap = 1;
     }
        }
        else
        {
            leap = 0;
        }
        if (1 == leap)
        {
            printf ("%d is leap!\n", year);
        }
        else
        {
            printf ("%d is not leap!\n", year);
        }
        return 0;
    }


    多分支语句

    格式:switch(表达式)
                           {case  常量表达式1:语句序列1
                             case  常量表达式2:语句序列2                        
                                        M
                             case  常量表达式i:语句序列i
                                        M
                             case  常量表达式n:语句序列n
                             default: 语句序列n+1
                             }
             执行过程为:当表达式的值等于常量表达式i的值,则从语句序列i开始执行到语句序列n+1为止 。若表达式的值不等于任何一个常量表达式的值,则只执行default后面的语句。
       一般在每个语句序列之后加一个break语句,这样在执行语句序列i之后,使流程跳出switch结构,实现多分支选择结构。

     实例 :给出一百分制成绩,要求输出成绩等级‘A’、’B’、‘C’、‘D’、‘E’。90分以上为‘A’ ,80~89分为’B’ ,70~79分为‘C’...


    参考程序

    #include <stdio.h>
    int main()
    {
        int grade;
        scanf ("%d", &grade);
        grade = grade / 10;
        switch (grade)
        {
            case 9:
     {
         printf ("A\n");
         break;
     }
     case 8:
     {
         printf ("B\n");
         break;
     }
     case 7:
     {
         printf ("C\n");
         break;
     }
     case 6:
     {
         printf ("D\n");
         break;
     }
     default:
     {
         printf ("E\n");
     }
        }
        return 0;
    }





    循环结构


    循环控制结构在程序中是指对某段程序或某条语句根据条件重复执行。C语言提供了while、do-while和for三种支持循环控制结构的语句。

    while语句是支持“当型”循环控制结构的语句。
    一般格式为: 
    while  (表达式) 
    {
        语句;
     }




    do_while语句是支持“直到型”循环控制结构的语句。
     一般格式为: 
    do
    {
        语句;
    } while (表达式);
    这个分号不能丢



    for语句是一种使用比while语句更加灵活的循环控制语句。
    一般格式为: 
    for (表达式1; 表达式2; 表达式3) 
    {
      语句
    }
     
    先求解表达式1;
    再解表达式2,若为真(非0)值,则
     执行语句,然后求解表达式3,再
     转到求解表达式2。若为假(0)值,
        则结束for语句的执行。




    循环语句嵌套

    一个循环语句内又包含另一个完整的循环语句,称为循环语句的嵌套。内嵌的循环语句一般称为内循环,包含内循环的循环语句称为外循环。内循环再嵌套内层循环,就够成了多重循环。


    循环语句要注意的几点:

    1.在多重循环中,如果有可能,应当将最长的循环放在最内层,最短的循环放在最外层,以减少CPU跨切循环层的次数。

    2.建议for语句的循环控制变量的取值采用"半开半闭区间"写法。半开半闭区间写法和闭区间写法虽然功能相同,但相比之下,半开半闭区间写法更加直观。

    3.不能在for循环体内修改循环变量,防止循环失控

    4.循环要尽可能短,要使代码清晰,一目了然。一般来说循环内的代码不要超过20行。

    5.把循环嵌套控制在3层以内

    6.for语句的控制表达式不能包含任何浮点类型的对象


    实例:计算一条语句中的空格、字母、数字的个数。

    #include <stdio.h>
    int main()
    {
        int int_count = 0;
        int letter_count = 0;
        int space_count = 0;
        char ch;
        scanf ("%c", &ch);
        while (ch != '\n')
        {
            if (ch == ' ')
     {
         space_count++;
     }
     else if (ch >= '0' && ch <= '9')
     {
         int_count++;
     }
     else if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'))
     {
                letter_count++;
     }
            scanf ("%c", &ch);
        }
        printf ("int_count = %d\nletter_count = %d\nspace_count = %d\n",
         int_count, letter_count, space_count);
        return 0;
    }



    大部分基础理论写完了,后面的博客大部分是代码和注释多一些,如果有更简便的写法或者注释有错欢迎大家评论。







    更多相关内容
  • 实验四 循环结构程序设计 (解答 ) 1改错题 1下列程序的功能为求 1 100 之和和值为 5050 并输出请纠正程序中存在 错误使程序实现其功能程序以文件名 sy4_1.c 存盘 #include <stdio.h> main) { int i,sum=0;...
  • 一实验目的 1进一步掌握关系表达式和逻辑表达式 2掌握循环控制条件的描述掌握三种循环结构的特征及相互之间的等价转换掌握DODO WHILE语句的语法规则和使用要求 3掌握循环结构概念和循环结构程序设计方法;精品资料; ...
  • 授课题目 算法基本逻辑结构循环结构 授课... 教学目标 通过对具体实例的分析和解决使学生体验算法的思想在生活中的应用并由此实例出发使学生理解循环结构概念通过分析两种循环结构的结构差异准确区分两种循环结构
  • Python循环结构

    千次阅读 2021-10-09 11:13:27
    今天我们讲一下python的循环结构,习题比较多,大家多联系,有问题可以给我留言。 目录一、Python中循环的介绍1、什么是循环?2、循环的作用3、循环的种类二、while循环基本语法及其应用1、while循环的基本语法2、...

    今天我们讲一下python的循环结构,习题比较多,大家多联系,有问题可以给我留言。

    一、Python中循环的介绍

    1、什么是循环?

    现实生活中,也有很多循环的应用场景:

    (1)食堂阿姨打菜:接过顾客的餐盘→询问菜品→打菜→递回餐盘,重复以上过程,直到所有顾客的菜都打完了

    (2)快递员送快递:查看送件地址→赶往目的地→电话告知收件人→收件人签收→交快递件,重复以上过程,直到所有需要送的快递都处理完了。

    (3)公交司机……

    (4)作业流程……

    ……

    以上场景都有一个共同的特点:条件重复地做一件事,每一次做的事情不同但类似。

    程序是为了解决实际问题的,实际问题中存在着重复动作,那么程序中也应该有相应的描述,这就是循环

    2、循环的作用

    思考:假如我有个女朋友,有一天我们闹矛盾生气了,女朋友说:道歉,说100遍“老婆大人,我错了”。这个时候程序员会怎么做?

    答:100遍print(‘老婆大人,我错了’)

    太麻烦了,有没有更好的办法呢?我们难道print输出语句要复制粘贴100次嘛?

    答:其实不用这么麻烦,以上输出代码中有很多重复的地方,我们只要重复执行100次相同的代码即可,这就是循环!

    循环的作用是什么?

    答:让代码高效的重复执行

    3、循环的种类

    在Python中,循环一共分为两大类:while循环与for循环

    思考问题:while循环和for循环如何选择呢?

    ① 对于循环次数已知的情况,建议使用while循环

    ② 对于循环次数未知的情况,建议使用for循环

    二、while循环基本语法及其应用

    1、while循环的基本语法

    # ① 定义一个计数器(初始化一个计数器)
    i = 0或1
    # ② 编写while循环结构
    while 循环条件(判断 计数器 是否达到了目标位置):
    	循环体1
    	循环体2
    	...
    	# ③ 在循环内部更新计数器
    	i = i + 1 或 i += 1
    

    普及小知识:在计算机程序中,计数器大部分都是从0开始的。

    总结:while循环三步走

    ① 初始化计数器

    ② 编写循环条件(判断计数器是否达到了目标位置)

    ③ 在循环内部更新计数器

    while循环入门案例:使用while循环,循环输出100遍“老婆大人,我错了”

    # ① 初始化计数器
    i = 0
    # ② 编写循环条件(判断计数器是否达到了100)
    while i < 100:
        print('老婆大人,我错了')
        # ③ 在循环体内部更新计数器
        i += 1
    

    2、while循环的执行流程

    建议大家使用Debug调试工具,查看while循环的运行流程。

    # ① 初始化计数器
    i = 0
    # ② 编写循环条件(判断计数器是否达到了100)
    while i < 100:
        print('老婆大人,我错了')
        # ③ 在循环体内部更新计数器
        i += 1
    

    下断点,开始Debug调试:

    在这里插入图片描述

    ① 代码都是顺序执行,首先执行到第2行,对变量i进行赋值操作,初始值为0

    ② 当程序遇到while循环时,首先要把我们的计数器与循环条件进行比较i < 100,如果条件成立,则进入循环内部,执行内部代码。

    ③ 在循环体内部,针对本次循环进行计数器更新操作 i = i + 1或 i += 1

    ④ 更新完毕后,把更新后的计数器与循环条件再次进行比较i < 100,如果条件成立,继续进入循环内部,执行内部代码。

    ⑤ 直到,i更新后结果为100时,再次进行循环条件判断,发现不满足,则整个while循环结束。

    while循环流程图:
    在这里插入图片描述

    3、while循环案例

    案例1:使用while循环求1…100的和

    分析:定义一个while循环,让其可以帮助我们计算 1 + 2 + 3 + 4 + 5 … + 100,结果:5050

    大问题拆解为小问题:

    ① 使用while循环,循环100次

    # 第一步:初始化计数器
    i = 1
    # 第二步:编写循环条件
    while i <= 100:
        print(i)		#  1 2 3 4 5 6 7 8 9 10...
        # 第三步:更新计数器的值
        i += 1
    

    ② 在循环体内部,累计求和

    # 第四步:定义一个变量,用于得到最终的运算结果
    result = 0
    # 第五步:想办法,让result = 变量i累加后的结果
    

    ③ 最终代码

    # 第一步:初始化计数器
    i = 1
    # 第四步:定义一个result变量,用于接收累加后的结果
    result = 0
    # 第二步:编写循环条件
    while i <= 100:
        # 第五步:循环累加变量i
        result += i
        # 第三步:更新计数器的值
        i += 1
    print(f'1~100累加后的结果:{result}')
    

    ☆ 首先定义变量i和变量result,进行初始化赋值

    ☆ 判断变量i是否满足循环条件,如果满足循环条件,则进入到循环体内部,执行内部代码

    思考:如何让变量i进行累加,然后赋予给result

    result = i
    

    第一次循环式,i = 1,result = 0,如果想获取累加的结构,则result = result + i

    result = 0 + 1
    

    计数器更新,i += 1,i变成2,然后i <= 100,继续执行循环内部代码

    result = result + i  换成数值  result = 1 + 2
    

    依次类推

    result = result + i
    

    简写

    result += i
    

    案例2:求1~100之间,所有偶数的和

    什么是偶数:所谓的偶数,就是能被2整除的数字就是偶数,数学中可以使用2n来表示偶数。(Python代码 => if 数值 % 2 == 0 代表它是一个偶数)

    知识点:在while循环中,我们还可以结合if进行判断。

    第一步:求出1~100之间,所有的偶数

    # 初始化计数器
    i = 1
    # 编写循环条件
    while i <= 100:
        # 将来写代码的位置
        # 更新计数器
        i += 1
    

    第二步:在循环体中,引入if条件判断,判断变量i是否为一个偶数

    # 初始化计数器
    i = 1
    # 编写循环条件
    while i <= 100:
        # 将来写代码的位置
        if i % 2 == 0:
            # 代表变量i是一个偶数
            print(i)
        # 更新计数器
        i += 1
    

    第三步:引入result变量,初始值为0,然后对第二步中得到的所有偶数进行累加

    # 初始化计数器
    i = 1
    # 定义result,用于接收所有偶数的和
    result = 0
    # 编写循环条件
    while i <= 100:
        # 将来写代码的位置
        if i % 2 == 0:
            # 代表变量i是一个偶数
            result += i
        # 更新计数器
        i += 1
    print(f'1~100之间所有偶数的和:{result}')
    

    4、编写循环式常见问题

    i = 1
    result = 0
    while i <= 100:
        if i % 2 == 0:
            result += i
            i += 1
    print(f'1~100之间所有偶数的和:{result}')
    

    问题的原因:在于i += 1缩进了2次,导致其和if形成了一个整体。while循环中计数器无法更新,最终导致以上代码出现了死循环。

    三、循环中的两大关键词

    1、两大关键词

    在Python循环中,经常会遇到两个常见的关键词:break 与 continue

    break:代表终止整个循环结构

    continue:代表中止当前本次循环,继续下一次循环

    2、举个栗子

    举例:一共吃5个苹果,吃完第一个,吃第二个…,这里"吃苹果"的动作是不是重复执行?

    情况一:如果吃的过程中,吃完第三个吃饱了,则不需要再吃第4个和第5个苹果,即是吃苹果的动作停止,这里就是break控制循环流程,即终止此循环。

    情况二:如果吃的过程中,吃到第三个吃出一个大虫子…,是不是这个苹果就不吃了,开始吃第四个苹果,这里就是continue控制循环流程,即退出当前一次循环继而执行下一次循环代码。

    3、break关键字

    情况一:如果吃的过程中,吃完第三个吃饱了,则不需要再吃第4个和第5个苹果,即是吃苹果的动作停止,这里就是break控制循环流程,即终止此循环。

    # 初始化计数器
    i = 1
    # 编写循环条件
    while i <= 5:
        # 当变量i == 4的时候,终止循环
        if i == 4:
            print('我已经吃饱了,实在吃不下了...')
            break
            
        # 正在吃第几个苹果
        print(f'正在吃第{i}个苹果')
        
        # 更新计数器
        i += 1
    

    4、continue关键字

    情况二:如果吃的过程中,吃到第三个吃出一个大虫子…,是不是这个苹果就不吃了,开始吃第四个苹果,这里就是continue控制循环流程,即退出当前一次循环继而执行下一次循环代码。

    # 初始化计数器
    i = 1
    # 编写循环条件
    while i <= 5:
        # 当变量i == 3的时候,中止当前循环,继续下一次循环
        if i == 3:
            # 手工更新计数器(非常重要)
            i += 1
            print('吃到了一只大虫子,这个苹果不吃了...')
            continue
            
        print(f'正在吃第{i}个苹果')
        # 更新计数器
        i += 1
    

    如果在使用continue的时候,不手工更新计数器会有什么后果呢?

    答:会出现死循环,建议使用Debug调试工具观看

    5、死循环概念

    在编程中一个靠自身控制无法终止的程序称为“死循环”。

    在Python中,我们也可以使用while True来模拟死循环:

    while True:
        print('你是风儿我是沙,缠缠绵绵到天涯')
    

    6、while循环案例:猜数字

    需求:计算机从1 ~ 10之间随机生成一个数字,然后提示输入数字,如果我们输入的数字与随机数相等,则提示恭喜你,答对了。如果输入的数字比随机数大,则提示,猜大了。反之,则提示猜小了,一共有3次机会。

    分析:① 编写一个循环,循环3次。② 要从1 ~ 10之间选择一个随机数 ③ if分支判断

    import random
    # 第一步:定义一个计数器
    i = 0
    # 第四步:生成1 ~ 10之间的随机数
    secretNum = random.randint(1, 10)
    # 第二步:编写循环条件
    while i < 3:
        # 第五步:提示用户输入一个数字
        userNum = int(input('请输入您猜的数字(范围1~10之间):'))
        # 第六步:判断用户输入的数字是否与随机数相等
        if secretNum == userNum:
            print('恭喜你,才对了')
            break
        elif secretNum < userNum:
            print('猜大了')
        elif secretNum > userNum:
            print('猜小了')
        # 第三步:更新计数器
        i += 1
    

    四、while循环嵌套

    1、循环嵌套的引入

    故事梗概:有天女朋友又生气了,惩罚:说3遍“老婆大人, 我错了”,这个程序是不是循环即可?但如果女朋友说:还要刷今天晚饭的碗,这个程序怎么书写?

    # 初始化计数器
    i = 1
    # 编写循环条件
    while i <= 3:
        print('老婆大人,我错了')
        # 更新计数器
        i += 1
    print('刷今天的碗')
    

    但如果女朋友还是生气,把这套惩罚要连续3天都执行,有如何书写程序?

    # 初始化外层计数器
    j = 1
    # 编写外层循环条件
    while j <= 3:
        # 初始化计数器
        i = 1
        # 编写循环条件
        while i <= 3:
            print('老婆大人,我错了')
            # 更新计数器
            i += 1
        print('刷今天的碗')
        # 更新外层计数器
        j += 1
    

    2、循环嵌套的基本语法

    编写一个简单的while循环结构

    # 初始化计数器
    i = 0 或 i = 1
    # 编写循环条件
    while i < 边界值:
        循环体代码
        # 更新计数器
        i += 1
    

    所谓的while嵌套循环就是在while循环的基础上,把循环体代码更换为一层while循环,就组成了while嵌套循环。

    # 第一步:初始化外层循环计数器
    i = 1
    # 第二步:编写外层循环的条件
    while i <= 3:
        # 第四步:初始化内层循环计数器
        j = 1
        # 第五步:编写内层循环的条件
        while j <= 3:
            循环体代码
        	# 第六步:更新内层循环计数器
        	j += 1
        # 第三步:更新外层循环计数器
        i += 1
    

    结构如下:
    在这里插入图片描述

    3、循环嵌套的执行流程

    while循环嵌套执行流程口诀:在while循环嵌套的执行过程中,外层循环1次,内层循环N次。(时钟 => 分针和秒针,分针就相当于外层循环,秒针就相当于内层循环)

    想具体了解while嵌套循环的执行流程,建议使用Debug调试。

    循环嵌套的总次数 = 外层循环次数 * 内层循环次数

    4、循环嵌套的几个案例

    案例1:打印5行5列的正方形,单元格中使用*号进行填充

    在这里插入图片描述

    示例代码:

    # 方法一:直接print打印
    # print("*  *  *  *  *")
    # print("*  *  *  *  *")
    # print("*  *  *  *  *")
    # print("*  *  *  *  *")
    # print("*  *  *  *  *")
    
    # 方法二:使用单层while循环
    # i = 1
    # while i <= 5:
    #     print("*  *  *  *  *")
    #     i += 1
    
    # 方法三:使用单层while循环 + 运算符
    # i = 1
    # while i <= 5:
    #     print("*  " * 5)
    #     i += 1
    
    # 方法四:使用while循环嵌套
    i = 1
    while i <= 5:
        # print("*  *  *  *  *")
        j = 1
        while j <= 5:
            print("*  ", end='')
            j += 1
        # 换行
        print('')
        i += 1
    

    使用Debug工具对while嵌套循环进行调试可知,在正方形案例中,外层的while主要用于控制行row信息,内层的wihle循环主要用于控制列信息col。

    案例2:打印直角三角形,特征:一共有5行,第1行,有1列。第2行,有2列,第3,有3列。
    在这里插入图片描述

    分析:如果采用wihle循环嵌套,外层应该循环5次,内层循环次数有一定的规则

    1 循环1次

    2 循环2次

    3 循环3次

    4 循环4次

    5 循环5次

    # 定义外层循环计数器
    i = 1
    # 编写外层循环的循环条件
    while i <= 5:
        # 定义内层循环计数器
        j = 1
        # 编写内层循环的循环条件
        while j <= i:
            print('*  ', end='')
            j += 1
        print('')
        # 更新外层循环计数器
        i += 1
    

    案例3:使用while嵌套循环打印 9 x 9乘法表

    在这里插入图片描述

    第一步:使用while嵌套循环打印9行的直角三角形

    # 初始化外层循环计数器
    i = 1
    # 编写外层的循环条件
    while i <= 9:
        # 初始化内层循环计数器
        j = 1
        # 编写内层的循环条件
        while j <= i:
            print('*', end='  ')
            # 更新内层循环的计数器
            j += 1
        print('')
        # 更新外层循环计数器
        i += 1
    

    第二步:把小星星换成具体的数值

    # 初始化外层循环计数器
    i = 1
    # 编写外层的循环条件
    while i <= 9:
        # 初始化内层循环计数器
        j = 1
        # 编写内层的循环条件
        while j <= i:
            print(f'{j} x {i} = {i * j}', end='  ')
            # 更新内层循环的计数器
            j += 1
        print('')
        # 更新外层循环计数器
        i += 1
    

    五、for循环基本语法及其应用

    1、for循环基本语法

    for循环结构主要用于(序列 => 字符串、列表、元组、集合以及字典)类型数据的遍历(循环)操作。

    另外当循环次数未知的情况,建议使用for循环。

    for 临时变量 in 序列:
        重复执行的代码1
        重复执行的代码2
    

    案例:使用for循环遍历字符串"itheima"

    str1 = 'itheima'
    for i in str1:
        print(i)
    

    使用Debug调试以上代码可知:for循环功能非常强大,可以自动判断序列的长度,长度为多少,则for循环就循环多少次。每次循环时,系统会自动将序列中的每个元素赋值给变量i,赋值完成后,for循环内部会自动更新计数器,向后移动一位,继续循环,直至元素全部循环结束。

    2、range方法(函数)

    Python2 range() 函数返回的是列表,而在Python3中 range() 函数返回的是一个可迭代对象(类型是对象),而不是列表类型, 所以打印的时候不会打印列表。(由于我们还未学习面向对象,为了方便大家理解,你可以简单的将其理解为一个序列结构)

    主要作用:用于生成一段连续的内容,从0到9

    基本语法:

    range(stop)
    range(start, stop[, step])
    
    start: 计数从 start 开始。默认是从 0 开始。例如range5)等价于range05;
    stop: 计数到 stop 结束,但不包括 stop。例如:range05) 是 [0, 1, 2, 3, 4] 没有 5
    step:步长,默认为1。例如:range05) 等价于 range(0, 5, 1)
    

    range有一个口诀:顾头不顾尾,包含头部信息,但是不包含尾部信息,如range(10),则返回0~9之间的序列,又比如range(0, 5)代表返回0 ~ 4之间的序列。

    案例:for循环与range方法,使用for循环,循环5次

    for i in range(5):
        print(i)
    

    3、for循环案例

    案例1:使用for循环,求1 ~ 100的和

    # 定义一个变量,用于接收1~100的和
    result = 0
    # 从1开始循环,循环100次
    for i in range(1, 101):
        result += i
    print(f'1~100的和为{result}')
    

    案例2:使用for循环,求1 ~ 100之间所有偶数的和

    # 定义一个变量,用于接收1~100之间所有偶数的和
    result = 0
    # 从1开始循环,循环100次
    for i in range(1, 101):
        if i % 2 == 0:
            result += i
    print(f'1~100之间所有偶数的和为{result}')
    

    4、循环中的两大关键字

    在循环结构中存在两个关键字:break和continue

    break:主要功能是终止整个循环

    案例:遇到字符’e’,则终止整个循环

    str1 = 'itheima'
    for i in str1:
        if i == 'e':
            break
        print(i)
    

    continue:主要功能是中止当前循环,继续下一次循环

    案例:遇到字符’e’,跳过循环,继续下一次循环

    str1 = 'itheima'
    for i in str1:
        if i == 'e':
            continue
        print(i)
    

    5、综合案例:使用for循环实现用户名+密码认证

    案例:用for循环实现用户登录

    ① 输入用户名和密码

    ② 判断用户名和密码是否正确(username=‘admin’,password=‘admin888’)

    ③ 登录仅有三次机会,超过3次会报错

    分析:用户登陆情况有3种:

    ① 用户名错误(此时便无需判断密码是否正确) – 登陆失败

    ② 用户名正确 密码错误 --登陆失败

    ③ 用户名正确 密码正确 --登陆成功

    # 定义变量,用于记录登录次数
    trycount = 0
    # 循环3次,因为超过3次就会报错
    for i in range(3):
        # 更新登录次数
        trycount += 1
        # 提示用户输入账号与密码
        username = input('请输入您的登录账号:')
        password = input('请输入您的登录密码:')
        
        # 判断用户名是否正确
        if username == 'admin':
        	# 判断密码是否正确
            if password == 'admin888':
                print('恭喜你,登录成功')
                break
            else:
                print('密码错误')
                print(f'您还有{3 - trycount}次输入机会')
        else:
            print('用户名错误')
            print(f'您还有{3 - trycount}次输入机会')
    

    6、for循环嵌套

    所谓for循环嵌套,就是一个for循环里面嵌套另外一个for循环的写法。

    当循环结构相互嵌套时,位于外层的循环结构常简称为外层循环或外循环,位于内层的循环结构常简称为内层循环或内循环。

    基本语法:

    # 外层循环
    for i in 序列1:
        # 内层循环
        for j in 序列2:
            循环体
    

    案例:使用for循环嵌套实现打印九九乘法表

    分析:外层循环主要用于控制循环的行数,内层循环用于控制列数

    for i in range(1, 10):
        for j in range(1, i+1):
            print(f'{j} x {i} = {i * j}', end='  ')
        # 打印换行符
        print('')
    

    六、while循环与for循环中的else结构

    1、为什么需要在while循环中添加else结构

    循环可以和else配合使用,else下方缩进的代码指的是当循环正常结束之后要执行的代码。

    强调:‘正常结束’,非正常结束,其else中的代码时不会执行的。(如遇到break的情况)

    2、while循环中else的基本语法

    需求:女朋友生气了,要惩罚:连续说5遍“老婆大人,我错了”,如果道歉正常完毕后女朋友就原谅我了,这个程序怎么写?

    # 初始化计数器
    i = 0
    # 编写循环条件
    while i < 5:
        print('老婆大人,我错了')
    	# 更新计数器
        i += 1
    # 循环结束后,女朋友就原谅我了
    print('好开森,女朋友原谅我了...')
    

    思考: 这个print是不是没有循环也能执行?那我们应该如何解决呢?

    答:使用while…else结构

    # 初始化计数器
    i = 0
    # 编写循环条件
    while i < 5:
        print('老婆大人,我错了')
    	# 更新计数器
        i += 1
    # 循环结束后,女朋友就原谅我了
    else:
        print('好开森,女朋友原谅我了...')
    

    3、break关键字对while…else结构的影响

    需求:女朋友生气,要求道歉5遍:老婆大人,我错了。道歉到第三遍的时候,媳妇埋怨这一遍说的不真诚,是不是就是要退出循环了?这个退出有两种可能性:

    ① 更生气,不打算原谅,也不需要道歉了,程序如何书写?

    ② 只一遍不真诚,可以忍受,继续下一遍道歉,程序如何书写?

    # 初始化计数器
    i = 0
    # 编写循环条件
    while i < 5:
        if i == 2:
            print('这遍说的不够真诚')
            break
        print('老婆大人,我错了')
    	# 更新计数器
        i += 1
    # 循环结束后,女朋友就原谅我了
    else:
        print('好开森,女朋友原谅我了...')
    

    由运行结果可知,如果我们在while循环中,使用了break,一旦break语句执行了,则else语句则不会输出。

    4、continue关键字对while…else结构的影响

    # 初始化计数器
    i = 0
    # 编写循环条件
    while i < 5:
        if i == 2:
            i += 1
            print('这遍说的不够真诚')
            continue
        print('老婆大人,我错了')
    	# 更新计数器
        i += 1
    # 循环结束后,女朋友就原谅我了
    else:
        print('好开森,女朋友原谅我了...')
    

    5、for循环结构中的else结构

    基本语法:

    for 临时变量 in 序列:
        循环体
    else:for循环正常结束后,返回的代码
    

    6、break关键字对for…else结构的影响

    str1 = 'itheima'
    for i in str1:
        if i == 'e':
            print('遇e不打印')
            break
        print(i)
    else:
        print('循环正常结束之后执行的代码')
    

    7、continue关键字对for…else结构的影响

    str1 = 'itheima'
    for i in str1:
        if i == 'e':
            print('遇e不打印')
            continue
        print(i)
    else:
        print('循环正常结束之后执行的代码')
    

    七、小海龟会画画

    1、小海龟模块

    在Python3版本中,新增加了一个模块叫做turtle(海龟),专门用于绘制图形图像

    2、模块如何使用

    ① 导入模块
    import turtle
    
    ② 使用turtle模块中已经定义好的方法
    turtle.forward(数值)  # 从左向右,绘制一条指定长度的横线(像素) 1980 * 1024
    

    3、手绘一条直线

    import turtle
    import time
    
    # 绘制一条100像素的横线
    turtle.forward(100)
    
    # 休眠10s
    time.sleep(10)
    

    4、使用turtle模块+for循环绘制五角星

    import turtle
    import time
    
    # 循环5次
    turtle.pencolor('red')
    for i in range(5):
        turtle.forward(100)
        turtle.right(144)
    
    time.sleep(10)
    
    展开全文
  • 实验3 循环结构程序设计1 一实验目的 1 掌握DODO WHILE语句的语法规则和使用要求 2 掌握循环结构概念和循环结构程序设计方法 二实验内容 启动Fortran PowerStation 4.0的Microsoft Developer Studio,进入Fortran ...
  • 实验 3 循环结构程序设计 1 一实验目的 1 掌握 DODO WHILE语句的语法规则和使用要求 2 掌握循环结构概念和循环结构程序设计方法 二实验内容 启动 Fortran PowerStation 4.0 的 Microsoft Developer Studio, 进入 ...
  • C语言 循环结构(5).ppt

    2020-06-16 01:38:18
    第六章 循环结构的程序设计 6.1 循环的基本概念 6.2 while 6.3 do while 6.4 for 6.5 break和continue 6.6 循环的嵌套 6.1 循环的基本概念 求n个数之和 s=1+2+3++n 6.1 循环的基本概念 循环结构是结构化程序设计的三...
  • 掌握算法的三种结构顺序结构条件结构 循环结构 ? 掌握画程序框图的基本规则 图形符号 名称 功能 终端框 ( 起止框 ) 输入输出框 处理框 ( 执行框 ) 判断框 表示一个算法的起始和结束 表示一个算法输入和输出的信息 ...
  • 最常见的执行架构即为While循环、For循环、以及条件结构。通过这些架构,即可多次执行代码的某些区段,或根据条件执行代码的不同区段。该模块将说明结构的功能,以及何时应该在NI LabVIEW软件中使用。
  • While循环结构

    千次阅读 2020-09-08 22:15:32
    1.1循环概念 循环是程序设计语言中反复执行某些代码的一种计算机处理过程 1.2 while循环的作用 重复执行某些代码 1.3 while循环的基本语法 while 条件: ____反复执行的代码 …… while及while中的代码块就是...

    1.while循环语句

    1.1循环概念
    循环是程序设计语言中反复执行某些代码的一种计算机处理过程
    1.2 while循环的作用
    重复执行某些代码
    1.3 while循环的基本语法
    while 条件:
    ____反复执行的代码
    ……

    while及while中的代码块就是while循环代码块。看以下示例:

    # 通常使用循环变量来控制循环的执行次数
    i = 0
    # 循环从while开始,后面添加条件
    while i<3:
        # while下面添加要反复执行的语句
        print("hello python")
        i += 1
    print("结束")
    

    1.4 循环变量
    循环变量是用于控制循环执行次数的变量,通常从0开始计数。以下示例中的“i=0”就叫做循环变量。
    在这里插入图片描述

    1.5 死循环
    如果循环语句未设置合理的退出条件,则循环语句将构成死循环,程序将永久执行下去。

    2.循环的终止与跳出

    2.1break
    break可以用于终止循环的执行,当执行到break语句后,程序将跳出循环,执行循环语句后面的代码

    i = 0
    while i<=10:
        print(f"现在输出的数字是{i}")
        # 如果i == 5 终止循环
        if i==5:
            break
        i = i+1
    print("结束")
    

    2.2continue
    continue可以用于提前结束本轮循环的执行,当执行到continue语句后,程序将跳到判定循环是否向下执行的条件处,进行下一轮循环是否执行的判定与后续代码执行

    i = 0
    while i <= 10:
        i += 1
        # 如果查到了5,直接跳过,
        # 本次循环结束,进入下一次循环
        if i == 5 :
            continue
        print(i)
    print("结束")
    

    2.3注意事项
    break与continue只能出现在循环体中,不能出现在其他地方

    3.循环嵌套

    3.1循环嵌套概念
    while循环中重复执行的代码又包含了另一个while循环。
    3.2 循环嵌套的基本语法
    while 条件:
    ____while 条件:
    ________反复执行的代码
    ……
    ……
    示例如下:外循环一次,内循环3次

    j = 1
    while j <= 5:
        i = 1
        while i <= 3:
            print(i,end = "") #end=""意思是末尾不换行
            i += 1
        print()#作用是换行
        j += 1
    

    输出结果为:
    在这里插入图片描述

    3.3注意事项
    break与continue仅能控制其所在的循环结构,不能控制其他循环结构

    展开全文
  • 2从高位到低位求每一位 * 精品PPT | 实用可编辑 3从低位到高位求每一位 * 精品PPT | 实用可编辑 循环结构程序设计 循环的概念 用while语句和do-while语句实现循环 用for 语句实现循环 循环的嵌套 break语句和...
  • 循环经济概念上市公司聚类判别分析——基于多元统计方法.pdf
  • 第5章 循环结构程序设计 ; 循环的基本概念 不同形式的循环控制 多重循环问题;什么是循环 为什么要使用循环;5.1 循环的基本概念;5.1循环的基本概念续;5.1 循环的基本概念续;5.1循环的基本概念完;5.2 while循环控制 ;...
  • 2从高位到低位求每一位 演示课件 3从低位到高位求每一位 演示课件 循环结构程序设计 循环的概念 用while语句和do-while语句实现循环 用for 语句实现循环 循环的嵌套 break语句和continue语句 几种循环的比较 程 序 ...
  • 1循环结构---在一些算法中,也经常会出现从某处开始,按照一定条件,反复执行某一步骤的情况,这就是循环结构;循环结构用程序框图可表示为;2循环结构分为两种------当型和直到型;2当型循环在每次执行循环体前对
  • C语言_04 三种程序结构 顺序, 选择(分支), 循环结构

    万次阅读 多人点赞 2018-02-06 18:31:49
    概念 在C语言程序中,一共有三种程序...循环结构循环结构有一个循环体,循环体里是一段代码。对于循环结构来说,关键在于根据判断的结果,来决定循环体执行多少次。C语言循环控制语句是一个基于C语言的编程语句,...

    概念

    在C语言程序中,一共有三种程序结构:顺序结构、选择结构(分支结构)、循环结构

    顺序结构,从头到尾一句接着一句的执行下来,直到执行完最后一句;

    选择结构,到某个节点后,会根据一次判断的结果来决定之后向哪一个分支方向执行;

    循环结构,循环结构有一个循环体,循环体里是一段代码。对于循环结构来说,关键在于根据判断的结果,来决定循环体执行多少次。C语言循环控制语句是一个基于C语言的编程语句,该语句主要有while循环语句、do-while循环语句和for循环语句来实现循环结构。

     

    但是三种结构并不是彼此孤立 循环中可以有顺序, 选择(分支).  顺序中可以有选择,可以有循环. 选择中也可以有顺序有循环. 一段程序代码往往是这三者相互结合组成的.

     

    1.顺序结构

     C语言的顺序结构顾名思义, 就是程序自上而下执行, 没有分支,也没有循环.

     

    #include <stdio.h>
    
    int main(){
        int a = 3, b = 2;
        int sum = a+b;
        printf("a+b=%d\n", sum);    //输出a+b的和
        return 0;
    }
    

    像上述代码, 程序顺序执行求和a+b并输出, 没有循环也没有分支, 所以上述代码就是一个顺序结构.

     

    2.选择(分支)结构

    C语言选择结构用于判断给定的条件,根据判断的结果来控制程序的流程。

    在C语言中, 选择结构有两种: 1. if-else语句,  2. switch-case语句;

    1) if-else 语句

    写法:

     

    if(条件1){
        //满足条件1执行此代码块
        ...
    }else if(条件2){
        //不满足条件1, 满足条件2执行此代码块
        ...
    }else{
        //即不满足条件1也不满足条件2 执行此代码块
        ...
    }

    举个栗子, 成绩评级.

     

    #include <stdio.h>
    
    int main(){
        int score = 78; //模拟输入成绩
    
        if (score >= 90){  //成绩 大于90 A
            printf("A");
        }else if(score >= 80 && score < 90){ // 80-89 B
            printf("B");
        }else if(score >= 70 && score < 80){ // 70-79 C
            printf("C");
        }else if(score >= 60 && score < 70){ // 60-69 D
            printf("D");
        }else{  //小于60 E
            printf("E");
        }
    
        return 0;
    }
    

     

    else if 可以有0个或多个,  else 只能有0个或1个.

    如果我们只需判断学生是否及各, 那么我们就可以这样写:

     

    if (score >= 60){
        printf("及格");
    }else{
        printf("不及格");
    }
    

    当然也可以只有if() 没有else ,  只有if() 和 else if ()没有else.

    2)switch-case 语句

    在C语言中, 第二种分支结构就是switch-case, 只是用的地方不太多, 因为if语句可以轻松替代switch语句, 只是结构上没switch那么清晰.

    语法:

     

    switch (变量或表达式){
        case 常量表达式1: 语句块1; break;
        case 常量表达式2: 语句块2; break;
        ......
        case 常量表达式n: 语句块n; break;
        default: 语句块n+1; break;
    }

    还是成绩评级的栗子:

     

    #include <stdio.h>
    
    int main(){
        int score = 78;  //模拟输入
        
        switch(score / 10){ //case匹配的数据就是score/10的结果  
            case 10: 
            case 9: printf("A"); break;
            case 8: printf("B"); break;
            case 7: printf("C"); break;
            case 6: printf("D"); break;
            default: printf("E"); break;
        }
    
        return 0;
    }

    score/10 得到的整数就是那个阶段的成绩, 我们会发现case 10: 也就是100分匹配后面没有任何的操作, 最主要的是, 没有break;

    在switch语句中, 如果case匹配到了语句, 那么后面的语句都会执行知道出现第一个break, 或者执行完成.

    如果我们将上面代码中的break全部去掉.score还是78, 那么输出就会变成 CDE, 也就是匹配到7 然后输出7之后的所有语句,知道碰到break;

    default相当于else, 其他所有不匹配的情况, 因为一般是放在最下面, 所以default后面的break可以不写.

     

    重点:switch的条件只能是整型和字符型(其实就是字符的ascii码)或者这些类型的表达式,case匹配的只能是整型或常量者这两个类型的常量表式, 也是case能匹配.

     

    3.循环结构

    循环结构是指在程序中需要反复执行某个功能而设置的一种程序结构。它由循环体中的条件,判断继续执行某个功能还是退出循环。

    在C语言中有三种循环结构: for循环, while循环, do-while循环.

    1) for循环

    写法:

     

    for(表达式1; 表达式2; 表达式3){
        循环体;
    }

    语句1:初值表达式,常用于在循环开始前为循环变量赋初值
    语句2:循环控制逻辑表达式,控制循环执行和结束的条件
    语句3:循环变量修改表达式,常用于修改循环变量,使得结果趋向于循环结束条件.

    举个栗子:

    循环输出10个"hello world!!!"

     

    #include <stdio.h>
    
    int main(){
        int i;
        for (i = 1; i <= 10; i++){ //循环10次, i++为 i自增长1
            printf("hello world!!!\n");
        }
        return 0;
    }
    

    上诉for循环的执行过程:

    1.执行表达式1, i = 1, 只执行一遍.

    2. 执行表达式2, 判断 i <=10

    3.如果表达式2成立, 执行循环体  { printf("hello world!!!\n"); } 否则执行退出循环, 后续步骤都不执行.

    4.执行完成循环体后,执行表达式3, i++, i的值自动增长1. 回到步骤2去判断.

     

    for循环中的三个表达式都可以为空, 但是一定要写两个分号也就是 for( ; ; ) 这样就代表无限循环, 也就是死循环.不过一般不会这样用.

     

    而for循环常用的是对数组的操作,所以初始值一般是0.

     

    int i;
    int Stu[10] = {99, 87, 76, 59, 73, 45, 99, 39, 88, 19}; //班级10个学生的成绩
    
    for(i = 0; i < 10; i++){    //循环10次, 0~9
        printf("学号为:%d, 成绩为: %d\n", i+1, Stu[i]);   //数组下标从0开始
    }

    其实可以发现, 正常的for循环可以很清晰的明白for循环的循环次数.

     

    所以在你很清晰明白这次循环需要循环多少次的时候推荐使用for循环.

     

    2)  while 循环

    while循环的语法简单易懂

     

     while(表达式){
            语句块
        }

    执行过程: 执行表达式, 如果成立执行语句块, 否则退出循环.

     

    while循环也可以和for循环互换.

     

    //for -> while
    int i = 0;
    while (i < 10){
        //循环体
        i++;
    }
    //while -> for
    for (;l < r;){
    }
    

    for->while: 没有for循环那么清晰明了的知道循环次数.

    while->for: 没有while循环那么简单易懂了.

    所以while循环的一般用法是我们不太清楚循环在什么时候结束, 并且我们也不关心具体的循环次数的时候使用.

    举个例子: 二分查找

     

    #include <stdio.h> 
     
    int main(){  
        int a[10] = {12, 32, 34, 55, 76, 89, 99, 123, 345, 1234}; //递增的数组 
        int l = 0, r = 9, mid; 
        int res = 345;  //查找的目标 
        //二分查找位置 
        while(l <= r){ 
            mid = (l+r)/2; 
            if (res == a[mid]){  //找到了输出位置, 并退出循环. 
                printf("位置: %d\n", mid+1); break; 
            }else if(res < a[mid]){  
                r = mid-1; 
            }else{   
                l = mid+1; 
            } 
        } 
        return 0; 
    } 
    

    我们只看while循环的内容, while(l<=r)  也就是当l>r时循环退出.

     

     

     

    和for循环不同的是, 我们并不清楚程序在什么时候会退出, l和r在循环中是在不断变换的.这种情况使用while循环是个不错的选择.

     

    3) do-while循环

     

    do{
        循环体
    }while(表达式);
    

    和while循环不同的是,do-while循环是先执行一遍循环体,再判断是否满足表达式.

     

    注意: do-while循环最后是有一个分号结尾的.

    do-while循环的用处也就在先执行一遍循环体再判断, 那么如果我们需要判断的内容必须要执行一遍循环体才能知道的话,那么就可以使用do-while循环.

    举个例子:

     

    #include <stdio.h>
    
    int main(){
        int t;
        int res = 89;
        do{
            printf("请输入一个数字,输入0退出游戏:");
            scanf("%d", &t);
            if(t == res){
                printf("猜对了!\n");
            }else if (t > res){
                printf("太大\n");
            }else{
                printf("太小\n");
            }
    
        }while(t != 0);
        return 0;
    }
    

    虽然这个例子bug很多, 但是我们可以清晰的理解do-while循环的不同, 我们一开始并不清楚t的值, 当我们执行完循环体后才知道t的值,然后做判断.

     

     

    三大循环总结:

    for 循环: 在你很清晰明白这次循环需要循环多少次的时候推荐使用.

    while循环: 在我们不太清楚循环在什么时候结束, 并且我们也不关心具体的循环次数的时候推荐使用.

    do-while循环: 如果我们需要判断的内容必须要执行一遍循环体才能知道的话推荐使用.

     

     

     

    展开全文
  • 顺序结构、选择结构、循环结构

    千次阅读 2017-01-12 17:22:56
    三种基本结构:顺序结构、选择结构和循环结构 1、选择结构  计算机执行程序的步骤是从上到下依次执行 2、选择结构(条件控制语句)  1)if语句  2)if…else语句  3)条件表达式(a>b)?a : b;(C语言中唯一的...
  • 循环结构概念 (1)循环结构:从某处开始,按照一定的 反复执行某些步骤的情况. (2)循环体: 执行的步骤. 条件 反复 2.循环结构的分类及特征 名称 直到型循环 当型循环 结构 特征 先执行循环体,后判断条
  • 分类(1)顺序结构(2)分支结构(3)循环结构二、分支结构1.if语句2.switch三、循环结构1.概述2.分类3.for循环4.多重循环5.while循环6.do...while循环 流程控制 一、流程控制概念 1.什么是流程控制 使用不同的...
  • 在VB程序设计中的循环语句模块采用问题驱动的教学方法,通过问题引发学生对循环语句的基本概念、执行机制和控制原理进行思考,培养学生分析问题、解决问题的能力,改善教学效果,提高教学质量。
  • 能进行两种循环结构程序框图间的转化 3能正确设计程序框图解决实际问题 1循环结构概念及相关内容 (1)循环结构按照一定的条件重复执行某些步骤的结构 (2)循环体反复执行的步骤 2循环结构的分类及特征 名称 直到型...
  • 结构概念分析 (13).pdf

    2020-08-19 07:37:25
    第06讲 认识材料非线性 算例Ex06a 单轴拉压 某钢圆棒承受轴心力已知长度L=10m 截面半径 r=0.1...BKIN 双线性随动强化 BISO 双线性各向同性强化 KINH 多线性随动强化 MISO 多线性各向同性强化 结构概念分析及ANSYS程序实
  • 循环结构程序设计

    2011-12-20 21:18:14
    循环的概念及循环的设计步骤 实现循环的语句 goto语句 while语句 do-while语句 for语句 break和continue语句 循环嵌套 循环结构程序举例
  • 图8循环结构的NS流程图.ppt

    千次阅读 2020-12-24 07:34:38
    不能预览其他用户文档第1章 算法与程序设计 1.1 程序设计的基本概念 1.2 算法和流程图 1.3 结构化程序设计 1.1 程序设计的基本概念 1.1.1 什么是程序 1.1.2 计算机如何运行程序 1.1.3 如何实现程序设计 1.2 算法和...
  • 为研究冻融循环结构性黄土构度指标的影响,以山西阳曲一号隧道黄土为研究对象,基于综合结构势和构度概念为理论基础,对不同含水率黄土进行了不同冻融循环次数的无侧限抗压试验。试验表明:原状土样和重塑土样在含水率...
  • PAGE 1 - 第3课时 循环结构 学 习 目 标 核 心 素 养 1掌握两种循环结构程序框图的画法能进行两种循环... 1循环结构概念及相关内容 (1)循环结构按照一定的条件反复执行某些步骤的结构 (2)循环体反复执行的步骤 2循环
  • Java的循环结构及嵌套循环

    千次阅读 2020-01-12 17:18:38
    Java的循环结构及嵌套循环Java的循环结构while 循环结构do...while 循环结构for 循环结构Java的嵌套循环概念循环控制语句breakcontinuereturnforeach 循环 Java的循环结构 Java 总共有三种循环结构,分别是while、do...
  • Python编程基础08:循环结构

    千次阅读 多人点赞 2020-11-12 15:50:25
    文章目录一、为什么要用循环(一)老老实实的笨方法(二)采用循环结构的巧方法1、采用计数循环(for循环)(2)采用条件循环(while循环)二、条件循环 - while循环三、计数循环 - for循环 跑道是一圈一圈的,...
  • 第一章绪论王道考研——数据结构本章总览需要具备的知识:C/C++语言 (408只能用C/C++答题,可参加王道C语言督学营来学习)1. 什么是分支、循环?2.

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 360,641
精华内容 144,256
热门标签
关键字:

循环结构概念

友情链接: 1.rar