精华内容
下载资源
问答
  • 众所周知,所有的计算机程序语言都有三种控制结构:顺序结构、选择(分支)结构、循环结构,当然Python也不例外,今天就写写有关Python的流程控制结构。 首先我们来看看顺序结构(笔者使用了中英双语哦!): # 这是...

    众所周知,所有的计算机程序语言都有三种控制结构:顺序结构、选择(分支)结构、循环结构,当然Python也不例外,今天就写写有关Python的流程控制结构。

    首先我们来看看顺序结构(笔者使用了中英双语哦!):

    # 这是顺序结构
    width = input("请输入矩形的宽:")
    height = input("Please height of the rectangular:")
    area = float(width) * float(height)
    # 由于键盘输入的只能是字符串,所以需要强制类型转换
    print("矩形面积:", area)
    

    输出结果如下:

    请输入矩形的宽:3.4
    Please height of the rectangular:4.5
    矩形面积: 15.299999999999999
    

    我们首先定义了width、height两个变量,之后通过乘积运算求出相应的矩形面积,这种最简单的结构就是顺序结构。当然,由于浮点数本身的不精确性,计算结果有一定的偏差。

    接着我们看一看分支(选择)结构:

    # 这是分支(选择)结构
    weight = input("输入体重(kg):")
    if float(weight) >= 100 :
        print("Too fat!!!")
    else:
        print("OK")
    my_weight = input("Please input your weight:")
    if float(my_weight) >= 100 :
        print("Too fat!")
    elif float(my_weight) >=50 :
        print("OK")
    else :
        print("Too thin")
    

    Python中的分支结构有两种语法:

    if judge_statement:  # 判断语句
    	statements       # 为真,则执行这一串语句
    else:
    	statements       # 为假,则执行这一串语句
    
    if judge_statement:    # 判断语句
    	statements         # 为真,则执行这一串语句
    elif judge_statement:  # 为假,则再次判断
    	statements         # 第二次判断为真,则执行这一串语句
    else:
    	statements         # 两次判断均为假,则执行这一串语句
    

    当然,分支是可以嵌套的,例如:

    num = input('请输入一个整数:')
    if int(num) >= 1000:
    	print('num是一个大数')
    	if int(num) >= 10000:
    		print('num是一个特大数')
    else:
    	if int(num) >= 100:
    		print('num是一个较大数')
    	else:
    	print('num是一个普通数')
    

    最后,我们看一看循环结构:

    # 循环结构 while
    happy = 0
    while happy < 10 :
        print("学习使我快乐,当前快乐值:", happy)
        happy += 1
    print("物极必反,不快乐了")
    '''
    while True :
        print("完了完了")
    '''
    # 上面这一段是用注释写的,不要尝试运行哦!
    print("\n")
    # 循环结构 for
    '''语法:
    for <varible> in <sequence>:
        <statements>
    else:
        <statements>
    '''
    for index in "学习使我快乐" :
        print(index)
    else :
        print("END")
    # 上面这四行可以依次输出字符串中的每个元素,最后输出END
    # 同理如下,可以输出 0 1 2 3 4
    for index in range(5):
        print(index)
    '''
    range的语法:
    range(start,stop[,step])
    # 表示从start开始计数,到stop为止(不包括stop),间距为step
    # 省略start时,默认为0   省略step时,默认为1
    '''
    # 循环中断
    '''
    break : 结束本次循环,跳出所在循环
    continue : 结束本次循环,开始新一次循环
    '''
    

    代码中注释写得比较详细了,笔者不再赘述。

    展开全文
  • 八、python基础:三种程序控制结构

    千次阅读 2020-03-10 20:27:42
    八、python基础:三种程序控制结构 一、程序的分支结构 1、单分支结构: 单独一个if进行条件判断 a = 1 if a == 1: print('正确') 2、二分支结构: if…else进行条件判断 a = 1 if a == 1: print('正确') else: ...

    八、python基础:三种程序控制结构

    一、程序的分支结构

    1、单分支结构:
    单独一个if进行条件判断

    a = 1
    if a == 1:
        print('正确')
    

    2、二分支结构:
    if…else进行条件判断

    a = 1
    if a == 1:
        print('正确')
    else:
        print('错误')
    

    3、多分支结构:
    if…elif…else

    a = 1
    if a == 0:
        print('小于1')
    elif a == 1:
        print('等于1')
    elif a == 2:
        print('等于2')
    else:
        print('看不懂了')
    

    二、程序的循环结构

    1、遍历循环:for
    一次遍历循环就是把str的元素都扫描一遍

    str = 'abcd'
    for s in str:
        print(s)
    

    输出结果:
    在这里插入图片描述
    2、无限循环

    i = 1
    while True:
        print(i)
        i += 1
        if i == 3:
            break
    

    输出结果:
    在这里插入图片描述
    代码意思:先让i等于1,接着无限循环打印i的值,并且每打印一次,就给i加1,最后当i的值等于3的时候,使用break跳出当前的无限循环,程序结束。

    while True代表一个无限循环,注意在使用的时候需要给它设置跳出循环的条件,不然程序就会一直运行下去,占用你的cpu资源。

    3、break和continue循环控制
    break和continue的作用都是用来结束循环的,不同的是,每一个循环程序一般是会有多轮循环的。
    break就是用来跳出整个循环的,而continue是用来跳过这个循环的某一轮。

    就好比如让一个陀螺转圈,扔一次它会转很多圈,break指令的作用就是让它转到某一圈时,遇到了break就停下来了,不再继续转圈了。而continue的作用,就是告诉它,这次转圈,在转到某一圈时,你可以停下来不转了,但是停了一次后还是要继续转圈的。

    4、for循环和break循环的区别:
    for循环是遍历一个结构,这个结构可以是字符串或者列表。但前提是你这个结构必须是有意义的,也就是要先给它赋值,即使你赋值为空的,程序也不会报错,但是遍历的时候不会得到什么结果,遍历一个空字符串或空列表的时候,程序不会执行for循环下面的代码。

    如果字符串和列表不是空的,那就会把它里面的元素一个一个扫描一遍。
    如果里面的元素都已经扫描一遍了,就自动结束循环了。

    while True是一个无限循环,即使你什么东西都没有,它也可以一直运行下去不停的,除非有个指令让它停下来。

    它们的区别是一个有限一个无限,一个先要给它东西才干活,一个不用给它东西就能干活。共同点是都能通过break或者continue来控制它的结束。

    三、程序的异常处理

    有时候我们可以预计到在某些位置可能会出现报错,但报错会导致程序停止运行,后面的处理就不会继续执行了,这时候我们可以使用异常捕获,当捕获到程序报错时,根据我们的需要对异常进行处理,你可以选择pass跳过,也可以对异常进行处理,或者收集错误信息,反馈给你。

    1、使用try: … except: …可以对异常进行处理:

    如以下代码
    先输入一个英雄名,接着使用try尝试进行数据库查询,但是有可能会查不到,查询不到它会抛出一个异常,如果我们没有使用try…except来进行处理的话,遇到异常这里程序就结束了。
    但是我们使用了except Exception as ret,就是告诉程序,遇到了你可以识别的错误,你就把这错误收集起来,用ret来命名,接下来用print(ret),就能把它输出在控制台了。

    执行的顺序:当try下方的某一行报错了,它就立即停止,跳到except下方的代码。

    hname = input("请输入您要恢复的英雄名:")
    try:
        hero = self.model.objects.get(hname=name)
    except Exception as ret:
        print(ret)
        pass
    

    try…finally…跟try…except…有什么区别呢?

    finally是无论try下方的代码是否会出现异常,最终都会执行finally下方代码的。
    而except是只有当try下方的代码报错了,才会去执行。不报错就不执行。

    try:
        hero = self.model.objects.get(hname=name)
    finally:
        print('无论有没有异常我都会执行')
        pass
    
    展开全文
  • 顺序、选择和循环语句(程序三种基本控制结构) 复合语句 1、在了解程序三种基本控制结构之前,我们先了解以下什么是复合语句,即块语句。 2、与C语言及其他语言不同,Java语言的复合语句是以整个块区为单位的...

    顺序、选择和循环语句(程序的三种基本控制结构)

    复合语句

    1、在了解程序的三种基本控制结构之前,我们先了解以下什么是复合语句,即块语句。

    2、与C语言及其他语言不同,Java语言的复合语句是以整个块区为单位的语句,所以又称为块语句。复合语句由开括号“ { ”开始,闭括号“ } ”结束。

    3、在前面的学习中我们已经接触到了这种复合语句,例如:在定义一个类或方法时,类体就是以“ { ”作为开始,“ } ”作为结束的标记的,方法体同样也是以“ { ”作为开始,“ } ”作为结束的标记的。复合语句中的每个语句都是从上到下被执行。复合语句都是以整个块区为单位,能够用在任何一个单独语句可以用到的地方,并且在复合语句中还可以嵌套复合语句,例如:在类体里面嵌套方法体或内部类。

    4、在使用复合语句时要注意,复合语句为局部变量创建了一个作用域,该作用域为程序的一部分,在该作用域中某个变量被创建并能够被使用。如果在某个变量的作用域外使用该变量,则会出现错误。

    package com.zyt.lesson01;
    
    public class Demo {
    	public static void main(String args[]) {
    		int num = 0;
    		for (int i = 1; i <= 10; i++) {
    			num += i;
    		}
    		System.out.println(num);
    	}
    }
    //  输出结果:55  
    
    package com.zyt.lesson01;
    
    public class Demo {
    	public static void main(String args[]) {
    		for (int i = 1, num = 0; i <= 10; i++) {
    			num += i;
    		}
    		System.out.println(num);
    	}
    }
    //  报错
    /*  Exception in thread "main" java.lang.Error: 无法解析的编译问题:
    	num cannot be resolved to a variable
    
    	at com.zyt.lesson01.Demo.main(Demo.java:9)  */
    //  在for循环语句中声明的局部变量num,其作用域在for循环体中。在循环体之外使用num将会报错。
    

    选择语句(条件语句)

    我们都知道,计算机的主要功能是提供用户计算的功能,但在计算的过程中会遇到各种各样的情况,针对不同的情况会有不同的处理方法,这就要求程序开发语言要具有处理决策的能力。

    一、if 条件语句

    1、决策分支

    决策:就是人们为某件事拿主意,下决心做出合理的选择的过程

    2、if 语句

    Java中处理决策的方法之一:if 语句

    1. 第一种形式的判断语句
    //  语法一:
    if(布尔表达式){
        语句;
    }
    //如果这个布尔表达式的结果是true,则执行大括号内的语句;如果这个布尔表达式的结果是false,则跳过大括号内的语句,而继续执行大括号外的语句。
    
    
    //  语法二:
    if(布尔表达式)
        语句;
    //如果布尔表达式的结果是true,则执行圆括号后面的第一个分号内的语句;如果布尔表达式的结果为false,则跳过第一个分号内的语句,继续执行后面的语句。
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-92EQ0HeE-1607846568787)(D:\新建文件夹\MarkDown学习\顺序、循环和选择语句\images\流程图1.jpg)]

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eLVwTbCs-1607846568790)(D:\新建文件夹\MarkDown学习\顺序、循环和选择语句\images\流程图2.jpg)]

    常见的错误:

    • if(表达式)的后面多加了一个分号

      if(表达式); { }

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

      这样的写法编辑器不会报错,但是是错误的,这时候 if 只会控制分号前的语句,不会控制分号后面花括号内的语句。

    • 没加大括号{ }

      if(表达式)
         语句;
         语句;
      

      这样的写法编辑器不会报错,但也是错误的。这时候 if 只能控制第一个分号前的语句,而控制不到第二个分号前的语句。

    • 在花括号后面加分号

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

      这样的写法编辑器会报错,这样的语法是错误的

    1. 第二种形式的判断语句
    //  语法
    if(布尔表达式){
        语句一;
    }else{
        语句二;
    }
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nTfsOqjg-1607846568791)(D:\新建文件夹\MarkDown学习\顺序、循环和选择语句\images\流程图3.jpg)]

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Y65b5x5Q-1607846568793)(D:\新建文件夹\MarkDown学习\顺序、循环和选择语句\images\流程图4.jpg)]

    实例:(流程图如上)

    public class Demo{
        public static void main(String args[]){
            int balance = 500;
            if(balance==500){
                System.out.println("买豪车");
            }else{
                System.out.println("买自行车");
            }
            System.out.println("吃饭睡觉");
        }
    }
    //  输出结果:吃饭睡觉
    

    常见的错误:

    • 未加大括号{ }

      else 之前若有两个 if 且都没加大括号,则这个 else 会匹配离它最近的那个 if

      if()
          if()
              else{
      		
              }
      
    • else 不能单独使用,必须和关键字 if 一起使用

    1. 第三种形式的判断语句
    //  语法
    if(表达式 1){
    	语句 1;
        ......
        
    }else if(表达式 2){
    	语句 2;
        ......
    
    }else if(表达式 m){
    	语句 m;
        ......
    
    }else{
    	语句 n;
        ......        
    }
    

    3、在书写判断语句时要遵循一定的书写规范,否则容易出现错误

    布尔表达式书写规范

    boolean flag = flase;
    if(flag==true)		
    //这样书写没有错误,但如果不注意漏写一个"="就会出现错误,但不会报错。
    //因此更规范的写法应该为:if(flag) 和 if(!flag)
    

    4、if 判断语句的总结

    1. 表达式:关系表达式或逻辑表达式

    2. 表达式的运算结果应该是真或者假

      真:执行该语句

      假:跳过该语句,执行下一条语句

    3. ” 语句 “可以是单语句也可以是复合语句。

    4. else if 可以有多条。

    5. if 和 else if 都需要判断表达式真假,else 不需要,else if 和 else 必须配合 if 一起使用,不能单独使用。

    二、Switch 多分支语句

    在编程中经常会碰到这样一种问题,就是我们需要判断一个变量是否等于某一个值,如果不等于,再用另一个值来与它做对比,比如我们要实现给某一个同学打评语的功能

    char grade = 'B';
    if(grade=='A'){
        System.out.println("真棒");
    }
    if(grade=='B'){
        System.out.println("做的不错");
    }
    if(grade=='C'){
        System.out.println("再接再厉");
    }
    /*
    进行多次判断实现多选一
    代码过于繁杂
    每一个判断语句都要测试
    容易混乱
    */
    

    如果需要写几十个 if 语句,维护起来将会非常的困难,为了简化这种多层判断的开发效率,Java提供了Switch语句

    1、

    Switch中用于判断的参数,可以是byte、short、int、String、枚举

    ! String和枚举是在 Java 7 之后才允许的,现在很多的公司做项目都用的是 JDK 1.6 ,所以不是很推荐使用字符串作为switch的参数

    long、float、double 类型的参数是不能放在 Switch 中的

    2、

    default 的位置不固定,可以放在 switch 语句块中的任何一个位置,只有在所有的 case 都无法匹配的情况下,才会执行 default 之后的语句

    default 在 switch 语句块是可写可不写的

    String name = "张三";
    switch(name){
        default :
            System.out.println("查无此人");      
        case "张三" :
            System.out.println("张三报道!"); break;
        case "李四" :
            System.out.println("李四报道!"); break;
        case "王五" :
            System.out.println("王五报道!"); break;
    }
    //输出结果:张三报道!
    
    String name = "张三";
    		switch (name) {
    		default:
    			System.out.println("查无此人");
    		case "张三":
    			System.out.println("张三报道!");
    		case "李四":
    			System.out.println("李四报道!");
    		case "王五":
    			System.out.println("王五报道!");
    /*
    输出结果:
    张三报道!
    李四报道!
    王五报道!
    */
    String name = "张三";
    		switch (name) {
    		case "张三":
    			System.out.println("张三报道!");
    		case "李四":
    			System.out.println("李四报道!");
    		case "王五":
    			System.out.println("王五报道!");
    		default:
    			System.out.println("查无此人");
    		}    
    /*
    输出结果:
    张三报道!
    李四报道!
    王五报道!
    查无此人
    */                
    

    3、

    break 用于跳出 switch 语句,也是是可写可不写的

    //语法
    Switch(用于判断的参数){
        case 常量表达式 1 :  语句 1;   break; 		//break是用于跳出语句的,可以不写
        case 常量表达式 2 :  语句 2;   break;
        ......
        case 常量表达式 n :  语句 n;   break;
        default :  语句 n+1;   break;		//default也是可不写的
    }
    

    4、

    switch 语句的执行顺序:

    从表达式值等于某个 case 语句后的值开始,它下方的所有语句都会被运行,直到遇见一个 break 为止

    实例:

    public class Demo{
        public static void main(String args[]){
            int score = 10;
            switch(score){
                case 10: 
                case 9: System.out.println("成绩为优");  break;
                case 8: System.out.println("成绩为良");  break;
                case 7:
                case 6: System.out.println("成绩为中");  break;
                case 5:
                case 4:
                case 3:
                case 2:
                case 1:
                case 0: System.out.println("成绩为差");  break;
                default : System.out.println("成绩无效");  break;
            }
        }
    }
    //输出结果:成绩为优
    
    int i;
    for (i = 0; i < 3; i++) {
        switch (i) {
            case 0:
                printf("%d", i);
            case 2:
                printf("%d", i);
            default:
                printf("%d", i);
        }
    }
    //输出结果:000122
    

    循环语句

    do while 语句的执行效率比 while 语句高

    一、While循环语句

    1、while语句也称条件判断语句,它的循环方式为利用一个条件来控制是否继续反复执行这个语句

    2、语法

    while(条件表达式){		//返回布尔值,判断是否继续执行语句
        执行语句;		//可被循环执行的语句
    }
    

    实例:

    //用计算机循环计算从1加到100的累加
    public class Demo{
        public static void main(String args[]){
            int sum = 0;
            int i = 1;
            while(i<=100){
                sum+=i;
                i++;
            }
            System.out.println(sum);
        }
    }
    //输出结果:5050
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jUHIdheF-1607846568795)(D:\新建文件夹\MarkDown学习\顺序、循环和选择语句\images\流程图6.jpg)]

    3、三个注意!

    • 表达式不允许为空
    • 表达式不应该是常数(true 或 false),这样会进入死循环
    • 循环体中必须要有改变条件表达式值的语句,否则将成为死循环

    二、do while循环语句

    1、do while 循环语句与 while 循环语句类似,它们之间的区别是 while 语句为先判断再执行,do while 语句为先执行,再判断。也就是说,do while 语句中,{ }的程序段至少要被执行一次。

    2、语法

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

    3、do while 语句与 while 语句的一个明显区别是,do while 语句在结尾处多加了一个分号

    根据do while 循环语句的语法特点总结出的do while 循环语句的执行过程

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Oa7uXbB0-1607846568796)(D:\新建文件夹\MarkDown学习\顺序、循环和选择语句\images\流程图5.jpg)]

    4、当我们想使用某个社交网站时,都会要求我们登录或注册新账户,为了防止用户手误,都会要求我们输入两次密码。如果两次密码不一致,则会提示用户,两次输入的密码不一致,请重新输入,用户就会重新输入密码了。要实现这个功能,需要先让用户输入密码,然后系统再做判断。如果条件不符合,就要求用户重复执行输入密码的操作,我们可以发现,注册的过程中有两个特点:

    • 先输入密码,再做判断
    • 如果判断一直假,则循环执行同一逻辑

    此时,如果使用 while 循环语句来书写代码,不仅需要在循环外对输入的信息做判断,还要在循环内也对输入的信息做判断,这样重复的代码,会使程序笨重有余,不过我们可以使用 do while 语句完美的解决这个问题。

    //密码输入
    public class Demo{
        public static void main(String args[]){
            Scanner sc = new Scanner(System.in);		//创建一个扫描器
            String pwd1 = "0";
            String pwd2 = "-1";
            
            do{
                System.out.println("请输入密码:");
                pwd1 = sc.nextLine();
                System.out.println("请再次输入密码:");
                pwd2 = sc.nextLine();
                if(!pwd1.equals(pwd2)){
                    System.out.println("您两次输入的密码不一致,请重新输入!");
                }while(!pwd1.equals(pwd2));
                System.put.println("设置密码成功!");
            }
        }
    }
    

    5、while 和 do while 的比较

    do while 的执行效率比 while 要高


    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Dk260RHg-1607846568797)(D:\新建文件夹\MarkDown学习\顺序、循环和选择语句\images\比较.jpg)]

    public class Demo{
    	public static void main(String args[]){
            int i=0,j=0;
            System.out.println("j="+j);
            while(i>1){
                j++;
            }
            System.out.println("j="+j);
        }
    }
    /*
    输出结果:j=0
        	j=0
    */
    public class Demo{
    	public static void main(String args[]){
            int i=0,j=0;
            System.out.println("before while j="+j);
            do{
                j++;
            }while(i>1);
            System.out.println("after while j="+j);
        }
    }
    /*
    输出结果:before while j=0
        	after while j=1
    */    
    

    三、for循环语句

    for 循环是 Java 程序设计中最有用的循环语句之一。一个 for 循环可以用来重复执行某条(或多条)语句,直到某个条件得到满足。在 Java 5以后增加了 foreach 语法。

    1、语法

    for(初始化表达式1;布尔表达式2;表达式3){
        语句;
    }
    

    初始化表达式:只在循环开始前运行一次,常用来做赋值操作,最常用的就是给循环变量赋值

    布尔表达式:返回布尔值,控制循环是否继续执行

    表达式:通常是赋值表达式,在完成一次循环之后执行

    每循环一次,布尔表达式和表达式就会交替执行一次

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SGnMpocu-1607846568798)(D:\新建文件夹\MarkDown学习\顺序、循环和选择语句\images\流程图7.jpg)]

    2、使用 for 循环,计算从 1 加至 100 的和

    public class demo{
        public static void main(String args[]){
            int sum = 0;
            for(int i=1;i<100;i++){
                sum+=i;	//即sum=sum+i;
            }
            System.out.println("sum="+sum);
        }
    }
    //输出结果:sum=5050
    

    四、foreach循环语句

    1、语法

    for(type x:obj){
        引用了x的java语句;
    }
    

    循环变量 type x,其中 type 为变量类型,x 为变量名,依次将 obj 中的值赋给 x

    obj : 是一个可以被遍历的集合,例如数组

    2、

    遍历:我们可以简单理解为,对数组或集合中的所有元素,逐一访问,依次读取一遍

    数组:就是相同数据类型的元素按一定顺序排列的集合

    int arr[] = {7,10,1};
    for(int x:arr){
        System.out.print(x);
    }
    //输出结果:7101
    
    int sum = 0;
    int arr[] = {1,2,3,4,...,49,50};
    for(int x:arr){
        sum+=x;
    }
    System.out.println("sum="+sum);
    //输出结果:sum=5050
    

    3、百钱买百鸡问题

    鸡翁一,值钱五,鸡母一,值钱三,鸡雏三,值钱一,百钱买百鸡,问翁、母、雏各几何

    public class Demo{
    	public static void main(String args[]){
            int cock,hen,chick;
            for(cock=1;cock<=20;cock++){
                for(hen=1;hen<=33;hen++){
                    for(chick=3;chick<=99;chick+=3)
                        if(cock*5+hen*3+chick/3==100){		//百钱
                            if(cock+hen+chick==100){		//百鸡
                                System.out.println("公鸡:"+cock+"母鸡:"+hen+"小鸡:"+chick);
                            }
                        }
                }
            }
        }
    }
    

    循环控制

    循环控制包含两方面的内容,一方面是控制循环变量的变化方式,另一方面是控制循环的跳转。控制循环的跳转需要用到 break 和 continue 这两个关键字,这两条跳转语句的跳转效果不一样,break 是中断跳出循环,continue 是结束当前循环。

    1、在我们编写复杂代码时,通常会碰到一些特殊的情况,要求我们立即中断循环或忽略某次的循环,这就要求要对循环进行控制,循环控制有两个关键字, break 和 continue

    2、break 关键字的使用场景

    while(  ){
        ......
        break;
    }
    
    do{
        ......
        break;
    }while(  );
    
    for(......){
        ......
        break;
    }
    
    switch(  ){
        case 1 :break;
        case 2 :break;
            .....        
    }
    

    break的作用:中断跳出循环

    int i = 1;
    while(i>0){
        i++;
        System.out.println(i);
        if(i==10)
            break;
    }
    System.out.println("循环结束");
    

    3、Loop 标签

    可能有的人会有疑惑:break 控制的是内层循环还是外层循环?

    想要控制这个,我们就要用到 Loop 标签Loop 标签使 break 具有了指向性,将跳出被 Loop 标记的这个循环

    未使用 Loop 标签的场景

    for(int i=0;i<3;i++){
        for(int j=0;j<6;j++){
            if(j==4)
                break;		//跳出内层循环
        }
    }
    

    使用了 Loop 标签的场景

    Loop:for(int i=0;i<3;i++){
        for(int j=0;j<6;j++){
            if(j==4)
                break Loop;		//跳出外层循环
        }
    }
    

    4、continue 关键字的使用场景

    continue 关键字的使用场景与 break 类似,但不适用于 switch

    while(...){
        ...
        continue;    
    }
    
    do{
        ...
        continue;    
    }while(...);
    
    for(...){
        ...
        continue;    
    }
    

    continue 关键字的作用:结束当前循环,执行下一次循环

    for(int i=1;i<=10;i++){
        if(i%2==0)
            continue;
        System.out.println("i="+i);
    }
    

    continue也可以使用 Loop 标签

    for(int i=0;i<3;i++){
        for(int j=0;j<6;j++){
            if(j==4)
                continue;
        }
    }
    
    Loop:for(int i=0;i<3;i++){
        for(j=0;j<6;j++){
            if(j==4)
                continue Loop;
        }
    }
    
    展开全文
  • Java的三种程序基本结构

    千次阅读 2019-11-27 20:12:02
    Java三种程序基本结构 今天我们了解下Java的三种程序基本结构 理解什么是基本结构 主要分为 :1. 顺序结构 2. 选择结构 3. 循环结构 一丶顺序结构 顺序结构就是程序从上到下一行一行的执行代码,没有判断和中转。...

    Java三种程序基本结构

    今天我们了解下Java的三种程序基本结构

    理解什么是基本结构

    主要分为 :1. 顺序结构 2. 选择结构 3. 循环结构
    

    一丶顺序结构

    顺序结构就是程序从上到下一行一行的执行代码,没有判断和中转。(如下图:)
    在这里插入图片描述
    我们最常见的程序如:

    	
    	我们输出两行语句分别是:Hello World 和 Hello Java 他们都是从上到下顺序执行。
    	没有任何分叉选择和循环,也就是我们最常见的顺序执行结构。
    1.  Public class HelloWorld{
    2.  public static void main(String[] args){
    3.
    3.  	System.out.println("Hello,World");
    5.
    4.  	System.out.println("Hello,Java")
    5.	
    6.	}
    7.	}
    
    

    二丶选择结构

    有选择性的执行或者跳过指定代码 (如下图)
    在这里插入图片描述

    Java的选择结构使用选择语句来实现:

    1 if语句

    	if 选择语句的四种形式:
    
    	有选择性的执行或者跳过指定代码
    1.	if(条件){}
    	判断是否为真如果不为真则直接执行else语句
    2.	if(条件){}else{}
    	先判断是否为真如果不为真则执行else if 再次判断是否为真 如果都不为真则执行else语句
    3.	if(条件){}else if(条件){}else{}
    	if中嵌套一个if 如果外层if为真则运行内层的if 如果外层不为真则运行else
    4.	if(条件){ if(条件){...} } else {...}
    
    

    运行顺序如下图:
    在这里插入图片描述

      	简单的if语句,java成绩如果大于60,奖励一颗糖
    1. 	//简单的if语句:
    2. 	//成绩如果大于60  给奖励
    3. 	int score = 10;
    4. 	if(score>60){
    5. 	System.out.println("给颗糖");
    }
    	因为10不大于60所以不打印任何东西。如果大于60则打印:给颗糖
    

    2 switch语句

    1. 表达式expr的值必须是下述几种类型之一:
      byte、short、int、char、enum(枚举);java7之后可以是String。
    2. case子句中的值const 必须是常量值(或final的变量),case中的值不能是一个范围。
    3. 所有case子句中的值应是不同的,否则会编译出错。
    4. default子句是可选的(不是必须的)。
    5. break语句用来在执行完一个case分支后使程序跳出switch语句块;否则会继续执行下去。

    语法结构:

    	//switch只适合做等值判断。
    	//语法结构:
    	switch(表达式){
    		case 常量1:		代码块1;		break;
    		case 常量2 :	代码块2;		break;
    		case 常量3 :	代码块3;		break;
    					...
    		default:		默认代码块;	break;
    }
    

    简单的switch语句:

    1.	int count = 1;
    2.	switch(count){ 
    3.		case 1:
    4.		System.out.println("奖励iphonexs");
    5.		break;
    6.		case 2:
    7.		System.out.println("奖励xiaomi");
    8.		break;
    9.		case 3:
    10.		System.out.println("奖励200元");
    11.		break;
    12.		default:
    13.		System.out.println("给个彩票");
    14.		break;
    15.	}
    	最后输出结果为:奖励iphonexs
    

    3丶循环语句

    循环就是在循环条件满足的情况下,反复执行特定代码。

    如果当我们要打印100次helloworld?
    或者我们想实现1-100的和?
    1+2+3+4+5…
    int sum = 0;
    sum = sum + 1;
    sum = sum + 2;
    sum = sum + 3;
    sum = sum + 4;
    sum = sum + 5;
    可以发现有一些是相同的内容。这些相同的内容我们就可以采用循环的方式来实现。

    1.循环的分类

    1. while 循环
    2. do/while 循环
    3. for循环

    2.循环的组成部分
    4. 初始化部分:对循环变量赋初值
    5. 循环条件部分:判断循环变量是否超出某个界限
    6. 循环体部分:要循环执行的具体逻辑.
    7. 更新循环变量部分:修改循环变量的值

    while循环
    while (循环条件) {语句块(循环体)}

    先判断循环条件表达式的值。若为true.则执行循环体,然后再次判断条件并反复执行,直到条件不成立为止。特点:先判断再执行。

    	打印输出5次helloworld
    1.// 初始化部分
    8.	int count = 0;
    9.	// 2循环条件
    10.	while(count<5){// 1 2 3
    11.  //3循环体
    12.	System.out.println("hello world");
    13.  //4更新循环变量
    14.	count++;
    15.	}
    16.	最后输出五次Helloworld	
    

    do-while循环
    do {语句块} while(条件表达式) ;

    先执行语句,再判表达式的值,若为true,再执行语句,否则结束循环。
    特点:先执行,再判断。

    1. 打印三次Hello World!
    2. // 1 初始化部分
    3. int i = 0;
    4. do{
    5. // 2 循环体
    6. System.out.println("Hello World!");
    7. // 4 循环变量变化部分
    8. i++;
    9. }while(i<3);// 3 循环条件
    10. 最后打印出三次Hello World! 
    

    while 和 do-while的区别
    while 和 do/while 的区别:
    1 执行过程不同
    while 先执行循环条件,然后再执行循环体,一句话:先判断,再执行
    do/while 先执行循环体 然后再执行循环条件,一句话:先执行,再判断
    2 当第一次不满足循环条件的情况下 while循环不能执行循环体, do while 可以执行一次

    for循环
    for (表达式1 [循环变量初始化]; 表达式2 [循环条件判断]; 表达式3 [更新循环变量]){
    循环体

    首先计算表达式1,接着计算表达式2,若表达式2的值为true,则执行循环体,接着计算表达式3,再判断表达式2的值.
    依此重复下去,直到表达式2的值为false。
    特点:先判断,再执行。

    1.	打印100以内 能被4整除不到能被7整除的数据,每行打印62.	int count = 0;
    3.	for(int i = 1; i<=100; i++){
    4.	if(i%4==0 && i%7!=0){
    5.	System.out.print(i+"\t");
    6.	count++;// 6
    7.	if(count%6==0){
    8.	System.out.print("\n");
    9.	}
    10.	}
    11.	}
    12.	最后打印出100以内所有能被4整出但是不能被7整除的数但是每行只打印6

    在这里我只写了几个简单的代码展示效果,想要加深学习还是要去网上找对应的题去反复练习才能加深印象熟练的运用。

    还是那句话:每一个成功者都有一个开始。勇于开始,才能找到成功的路。
    让我们一起努力,明天才会更好! 加油!

    展开全文
  • 【Python】 流程控制结构

    千次阅读 2020-05-21 17:02:05
    流程控制结构) 1、顺序结构 从左到右,从上而下依次执行。 在python中,一个语句的结束是以换行符为标志的。 2、选择结构 (1)单分支:if if 条件 # 当条件成立时,执行的代码 print ('当条件...
  • 常见流程控制语句

    千次阅读 2017-09-11 22:13:41
    程序三种常见结构:顺序结构 – 代码从上到下,顺序执行。代码默认就是顺序结构。 选择结构 – 代码按照条件选择一个分支执行,条件的结果决定了执行哪段代码。 循环结构 – 代码按照条件反复多次执行,直到...
  • Matlab 程序控制结构

    千次阅读 2018-09-03 13:07:35
    一、分支结构  if 条件 语句组 end if 条件 语句组1 else ...另有if …… elseif……else……end形式不做赘述。...二、循环结构 ...continue用于控制for循环或while循环跳过某些执行语句  ...、开关结构 sw...
  • 程序流程结构:①顺序结构:即语句从上到下按顺序执行②分支结构:一条大路,会有很多分支路口。在python常用if..elif..else判断语句③循环结构:例如像放歌一样,歌单循环播放。在python常用while循环或是for循环...
  • 流程控制--顺序结构

    2016-05-10 16:05:33
    不论哪一种编程语言,都会...Java同样提供了这两种流程控制结构的语法,Java提供了if和switch两种分支语句,并提供了while,do while和for三种循环语句。 除此之外,JDK5还提供了一种新的循环,foreach循环,能以更简
  • C语言程序三种基本结构

    千次阅读 2017-02-26 17:54:00
    1、程序结构:在C语言程序中,一共有三种程序结构:顺序结构、选择结构(分支结构)、循环结构;  顺序结构:从头到尾一句接着一句的执行下来,直到执行完最后一句;  选择结构:到某个节点后,会根据一次判断的...
  • 程序控制结构 在本章的开头送给大家一句话:生活不会突变,你要做的只是耐心和积累。人这一辈子没法做太多的事情,所以每一件事情都要做得精彩绝伦。— 史蒂夫·乔布斯(苹果公司联合创始人) 1. Python 语言基础 ...
  • 【Java】]Java的控制结构

    万次阅读 2016-03-05 21:13:17
    无论我们学习什么专业,无论我们学习什么语言,都会遵循着控制结构,今天我们就说一下Java的控制结构。  一、顺序  总觉得顺序这一方面没什么可说的,一个程序,从main方法开始,一步一步的执行,都有...
  • 一、顺序 二、选择 1、if语句 if 条件1: 满足条件1执行语句 2、if…else语句 if 条件1: 满足条件1执行语句 else: 其他情况执行的语句 ...、循环 1、while语句 2、pass关键字 3、continue关键字 4、break关键...
  • 这是最简单的情况,为了更好的控制语句的运行,程序设计语言提供了多种控制结构支持更为复杂的语句执行。我们就来看看C++ 提供的控制方式。 一、 while 语句 while 语句提供了循环执行功能。可以用 while ...
  • 第十七章,不常见控制结构前言谨慎的使用这些控制结构,将会获得更多的帮助。17.1 子程序中有多处返回1、 如果能够增强可读性,那么就是用return。2、 用防卫子句来简化复杂的错误处理。3、 减少子程序中return...
  • 计算机程序在解决某个具体问题时,包括三种情形,即顺序执行所有的语句、选择执行部分的语句和循环执行部分语句,这正好对应着程序设计中的三种程序执行结构流程:顺序结构、选择结构和循环结构。 事实证明,任何...
  • Python基础之控制结构

    千次阅读 2018-07-24 21:31:33
    Python基础之控制结构 Python中控制结构分为分支结构与循环结构。 1.分支结构 (1) if 结构 适用于只有一选择的时候 语法结构 if 条件 : 代码操作 例: # 定义一个变量,存储一个数据,判断该数据是否...
  • 一、Python程序控制结构 顺序结构 分支结构(单分支、二分支及紧凑形式、多分支) 循环结构(遍历循环、无限循环) 对比一下,分支结构是根据条件结果向程序运行前方跳转的结构;循环结构是根据条件向程序运行...
  • Python控制结构总结

    2020-08-16 06:49:15
    -程序控制结构三种 顺序结构:程序按照线性顺序逐渐执行 分支结构:程序根据条件有选择的向程序运行方向执行 循环结构:程序根据一定条件在运行之后返回执行 一、分支结构 单分支结构 if <条件>: <...
  • 通过使用软件体系结构,可以有效地分析用户需求,方便系统的修改,以及减小程序构造风险。 随着软件规模不断地增大和复杂程度日益增高,系统框架架构的设计变得越来越关键。软件框架设计的核心问题是能否复用已经...
  • 程序流程程序的基本结构 2、程序的分支结构 单分支结构: if语句 二分支结构: if-else语句 多分支结构: if-elif-else语句 判断条件及组合 3、程序的循环结构 程序的循环结构 遍历循环: for 无限循环: ...
  • Scala语言中控制结构和Java语言中的控制结构基本相同,在不考虑特殊应用场景的情况下,代码书写方式以及理解方式都没有太大的区别 1.顺序控制 (1)顺序控制介绍 程序从上到下逐行地执行,中间没有任何判断和...
  • 应用程序除了使用上述七类控制结构方式,来改变程序执行流程使之能够按照开发者的意图去正确的执行程序,开发者还可以使用break、continue和return等控制结构的跳转语句来控制程序按照既定的意图去执行。
  • windows下三种常见的文件系统

    千次阅读 2017-11-15 16:46:00
    windows下常见的有三种文件系统格式,FAT 、FAT32和NTFS,简单说明一下它们的区别. 一:FAT与FAT32 基于MS-DOS,Win 95等系统都采用了FAT16文件系统。在Win 9X下,FAT16支持的分区最大为2GB。计算机将信息保存在硬盘...
  • 单片机系统程序常见的算法与结构

    千次阅读 2018-05-22 21:21:25
    1.1 时间片轮询架构1.2 单片机的非OS的事件驱动1.3 单片机基于状态机和任务队列的程序设计1.4 基于消息的单片机多任务编程1.5 单片机的FIFO(先入先出)循环队列实现1.6 利用时间触发式系统开发嵌入式产品1.7 ...
  • 一般来说很少直接在控制台输入相关内容,用MATLAB语言编写的程序,称为M文件。 M文件可以根据调用方式的不同分为两类:命令文件(Script File)和函数文件(Function File)。 区别: 命令文件没有输入,没有返回; ...
  • 三种常见的API设计错误及解决方案

    千次阅读 2018-01-17 10:48:45
    原文:Three common API design mistakes and how to overcome them 作者:Jennifer Riggins ...作者在本文介绍了三种,也给出了相应的解决方案,不妨一起来看一下吧!以下为译文。 作为表单工具Typeform
  • Java运算符 算术运算符 赋值运算符 比较运算符 逻辑运算符 位运算符 三目运算符 算术运算符 流程控制语句 顺序结构 选择结构
  • C语言的四种程序结构

    万次阅读 多人点赞 2018-01-02 12:13:59
    a = 3,b = 5,现交换a,b的值,这个问题就好像交换两个杯子水,这当然要用到第个杯子,假如第个杯子是c,那么正确的程序为: c = a; a = b; b = c; 执行结果是a = 5,b = c = 3。如果改变其顺序,写成:a = ...
  • LabVIEW学习笔记()——程序结构

    万次阅读 多人点赞 2018-08-21 22:35:05
     任何计算机语言都离不开程序结构,LabVIEW 作为一图形化的高级程序幵发语言也不例外。LabVIEW 中的程序结构包括if-else循环,while循环结构,使能结构,公式节点和数学脚本节点等, 因此通过LabVIEW可以非常...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 371,221
精华内容 148,488
关键字:

常见的三种流程控制结构