在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。也就是说程序的流程对运行结果有直接的影响。所以，我们必须清楚每条语句的执行流程。而且，很多时候我们要通过控制语句的执行顺序来实现我们要完成的功能。
 
流程控制语句分类：
    -顺序结构
    -选择结构
    -循环结构
 
1.顺序结构
    1.1 顺序结构的概述
        是程序中最简单的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。
    1.2 顺序结构语句的执行流程
        开始-->语句A-->语句B-->语句C-->结束
package com.denniscui_01;
/*
 * 顺序结构：从上往下依次执行
 */
public class OrderDemo {
     public static void main(String[] args) {
           System.out.println("开始");
           System.out.println("语句A");
           System.out.println("语句B");
           System.out.println("语句C");
           System.out.println("结束");
     }
}
 
2.选择结构
    2.1 选择结构的概述
        选择结构也被称为分支结构。有特定的语法格式，我们必须按照他的基本格式来编写代码。
            Java语言提供了两种选择结构语句：
                if语句
                switch语句
 
    2.2 if语句的第一种格式
        if(关系表达式){
                语句体；
         }
            执行流程：判断关系表达式看其结果是true还是false，如果是true就执行语句体，如果是false就不执行语句体。
package com.denniscui_02;
public class IfDemo {
     public static void main(String[] args) {
           System.out.println("开始");
           
           //定义两个变量
           int a = 10;
           int b = 20;
           
           if(a == b) {
                System.out.println("a等于b");   //不执行
           }
           
           //定义变量
           int c = 10;
           
           if(a == c) {
                System.out.println("a等于c");   //执行
           }
           System.out.println("结束");
     }
}
 
    2.3 if语句的第二种格式
        if(关系表达式){
            语句体1；
        }else{
            语句体2；
        }
        执行流程：判断关系表达式看其结果是true还是false，如果是true就执行语句体1，如果是false就执行语句体2.
package com.denniscui_02;
public class IfDemo2 {
     public static void main(String[] args) {
           System.out.println("开始");
           
           //定义两个变量
           int a = 10;
           int b = 20;
           
           if(a == b) {
                System.out.println("a等于b");
           }else {
                System.out.println("a不等于b");
           }
           
           System.out.println("结束");
  
//判断一个数据是奇数还是偶数
           //定义变量
           int c = 100;
           
           if(c%2 == 0) {
                System.out.println("c是偶数");
           }else{
                System.out.println("c是奇数");
           }
     }
}
 
    2.4 if语句的第三种格式
        if(关系表达式1){
            语句体1；
        }else if(关系表达式2){
            语句体2；
        }
        ...
        else{
            语句体n+1；
        }
        执行流程：判断关系表达式1看其是true还是false，如果是true就执行语句体1，如果是false就继续执行判断关系表达式2看其结果是true还是false，如果是true就执行语句2，如果是false就继续判断关系表达式...看其结果是true还是false，...,如果没有任何关系表达式为true，就执行语句体n+1。
package com.denniscui_02;
public class IfDemo3 {
     public static void main(String[] args) {
           System.out.println("开始");
           
//         x和y的关系满足如下：
//         x>=3 y = 2x + 1;
//         -1<=x<3    y = 2x;
//         x<=-1y = 2x - 1;
//         根据给定的x的值，计算出y的值并输出。
           
           //定义变量
           int x = 5;
           int y;
           
           if(x>=3) {
                y = 2*x + 1;
           }else if(x>=-1 && x<3) {
                y = 2*x;
           }else if(x<-1) {
                y = 2*x - 1;
           }else {
                y = 0;     //if语句是判断语句，是判断就有可能是false，则如果没有else这条语句，这个程序会报错，y可能没有被初始化。
                System.out.println("不存在这样的x");
           }
           System.out.println("y:"+y);
           System.out.println("结束");
     }
}
 
    2.5 if语句的练习之获取两个数据的较大值
package com.denniscui_02;
import java.util.Scanner;
/*
 * 键盘录入两个数据，获取两个数据中的较大值
 *
 * 分析：
 *         A：看到键盘录入就应该想到键盘录入的三个步骤
 *              导包，创建键盘录入对象，接收数据
 *         B：获取两个数据的最大值，其实就是比较看哪个数据大
 *         C：把大的数据输出即可
 *
 * 导包：
 *         A：手动输入
 *         B:点击鼠标自动生成
 *         C:快捷键(推荐)
 *              ctrl+shift+o
 */
public class IfTest {
     public static void main(String[] args) {
           //创建键盘录入对象
           Scanner sc = new Scanner(System.in);
           
           //接收数据
           System.out.println("请输入第一个数据：");
           int a = sc.nextInt();
           
           System.out.println("请输入第二个数据：");
           int b = sc.nextInt();
           
           if(a>b) {
                System.out.println("较大的数为："+a);
           }else {
                System.out.println("较大的数为："+b);
           }
           
           //两个数据比较完成后，我拿最大值可能需要做其他的操作
           //定义一个变量，用于接收较大的值
           int max;
           if(a>b) {
                max = a;
           }else {
                max = b;
           }
           System.out.println("max:"+max);
     }
}
 
    2.6 if语句练习之根据分数输出对应级别
package com.denniscui_02;
import java.util.Scanner;
/*
 * 键盘录入学生考试成绩，请根据成绩判断该学生属于哪个级别
 * 90-100  优秀
 * 80-90   好
 * 70-80   良
 * 60-70   及格
 * 60以下        不及格
 *
 * 分析：
 *         A：键盘录入学生成绩，想到键盘录入的步骤
 *         B：通过简单的分析，我们决定使用if语句格式3
 *           每一次判断完成后，我们直接输出对应的级别即可
 */
public class IfTest2 {
     public static void main(String[] args) {
           //创建键盘录入对象
           Scanner sc = new Scanner(System.in);
           
           //接收数据
           System.out.println("请输入学生成绩：");
           int score = sc.nextInt();
           
           //if语句格式3
           /*if(score>=90 && score<=100) {
                System.out.println("优秀");
           }else if(score>=80 && score<90) {
                System.out.println("好");
           }else if(score>=70 && score<80) {
                System.out.println("良");
           }else if(score>=60 && score<70) {
                System.out.println("及格");
           }else {
                System.out.println("不及格");
           }
           */
           //通过测试数据，我们发现程序不够完善，所以我们加入了非法数据的判定
           if(score>100 || score<0) {
                System.out.println("你输入的成绩有误");
           }else if(score>=90 && score<=100) {
                System.out.println("优秀");
           }else if(score>=80 && score<90) {
                System.out.println("好");
           }else if(score>=70 && score<80) {
                System.out.println("良");
           }else if(score>=60 && score<70) {
                System.out.println("及格");
           }else {
                System.out.println("不及格");
           }
     }
}
 
    2.7 switch语句的用法
package com.denniscui_03;
import java.util.Scanner;
/*
 * switch语句格式：
 * switch(表达式) {
 *         case 值1:
 *              语句体1;
 *              break;
 *         case 值2:
 *              语句体2;
 *              break;
 *         ...
 *         default:
 *              语句体n+1;
 *              break;
 * }
 * 格式解释：
 *         表达式:byte,short,int,char
 *              JDK5以后可以是枚举
 *              JDK7以后可以是字符串
 *         case:就是要和表达式进行比较的值
 *         break:表示中断,结束的意思。
 *         default:表示所有的情况都不匹配的时候，就执行语句体n+1。和if语句的else相似。
 * 执行流程：
 *         A:计算出表达式的值
 *         B:拿计算出来的值和case后面的值依次比较，一旦有对应的值，就执行该处的语句，在执行过程中，遇到 break，就结束。
 *         C:如果所有的case都不匹配，就会执行default控制的语句，然后结束。
 * 需求：
 *         根据键盘录入的数值1，2，3，…7输出对应的星期一，星期二，星期三…星期日。
 */
public class SwitchDemo {
     public static void main(String[] args) {
           //创建键盘录入对象
           Scanner sc = new Scanner(System.in);
           
           //接收数据
           System.out.println("请输入一个数字(1-7)：");
           int weekday = sc.nextInt();
           
           //switch语句实现选择
           switch(weekday) {
           case 1:
                System.out.println("星期一");
                break;
           case 2:
                System.out.println("星期二");
                break;
           case 3:
                System.out.println("星期三");
                break;
           case 4:
                System.out.println("星期四");
                break;
           case 5:
                System.out.println("星期五");
                break;
           case 6:
                System.out.println("星期六");
                break;
           case 7:
                System.out.println("星期日");
                break;
           default:
                System.out.println("你输入的数字有误");
                break;
           }
     }
}
 
3.循环结构语句
    3.1 循环语句格式
package com.denniscui_04;
/*
 * for循环语句格式：
 *         for(初始化语句;判断条件语句;控制条件语句) {
 *              循环体语句;
 *         }
 *
 *         执行流程：
 *              A:执行初始化语句
 *              B:执行判断条件语句，看结果是true还是false
 *                   如果是true，就继续执行
 *                   如果是false，就结束循环
 *              C:执行循环体语句
 *              D:执行控制条件语句
 *              E:回到B继续
 *
 * 需求：
 *         在控制台输出10次”HelloWorld”的案例。
 */
public class ForDemo {
     public static void main(String[] args) {
           //原始写法
           System.out.println("HelloWorld");
           System.out.println("HelloWorld");
           System.out.println("HelloWorld");
           System.out.println("HelloWorld");
           System.out.println("HelloWorld");
           System.out.println("HelloWorld");
           System.out.println("HelloWorld");
           System.out.println("HelloWorld");
           System.out.println("HelloWorld");
           System.out.println("HelloWorld");
           System.out.println("-------------------------");
           
           //用循环改进
           for(int x=1; x<=10; x++) {
                System.out.println("HelloWorld");
           }
     }
}
 
    3.2 for循环的练习之获取1-5和5-1的数据
package com.denniscui_04;
/*
 * 需求：获取数据1-5和5-1
 */
public class ForTest {
     public static void main(String[] args) {
           //原始做法
           System.out.println(1);
           System.out.println(2);
           System.out.println(3);
           System.out.println(4);
           System.out.println(5);
           System.out.println("-------------");
           
           //用循环改进
           for(int x=1; x<=5; x++) {
                System.out.println(x);
           }
           System.out.println("-------------");
           
           //1-5的数据我们获取到了，如何获取5-1呢?
           for(int x=5; x>=1; x--){
                System.out.println(x);
           }
     }
}
 
    3.3 for循环练习之1-5数据求和
package com.denniscui_04;
/*
 * 需求：求出1-5之间数据之和
 *
 * 分析：
 *         A:定义求和变量，初始化值是0
 *         B:获取1-5之间的数据，用for循环实现
 *         C:把每一次获取到的数据，累加起来就可以了
 *         D:输出求和变量即可
 */
public class ForTest2 {
     public static void main(String[] args) {
           //定义求和变量，初始化值是0
           int sum = 0;
           
           //获取1-5之间的数据，用for循环实现
           for(int x=1; x<=5; x++) {
                //把每一次获取到的数据，累加起来就可以了
                //sum = sum + x;
                /*
                 * 第一次：sum = 0 + 1 = 1
                 * 第二次：sum = 1 + 2 = 3
                 * 第三次：sum = 3 + 3 = 6
                 * 第四次：sum = 6 + 4 = 10
                 * 第五次：sum = 10 + 5 = 15
                 */
                sum += x;
           }
           
           //输出求和结果
           System.out.println("sum:"+sum);
     }
}
 
3.4 for循环之1-100之间偶数和
package com.denniscui_04;
/*
 * 需求：求出1-100之间偶数和
 *
 * 分析：
 *         A:定义求和变量，初始化值是0
 *         B:获取1-100之间的数据，用for循环实现
 *         C:把获取到的数据进行判断，看是否是偶数
 *              如果是，就累加
 *         D:输出求和结果
 */
public class ForTest3 {
     public static void main(String[] args) {
           //定义求和变量，初始化值是0
           int sum = 0;
           
           //获取1-100之间的数据，用for循环实现
           for(int x=1; x<=100; x++) {
                //把获取到的数据进行判断，看是否是偶数
                if(x%2 ==0) {
                     sum += x;
                }
           }
           
           //输出求和结果
           System.out.println("sum:"+sum);
     }
}
 
    3.5 for循环之在控制台打印水仙花数
package com.denniscui_04;
/*
 * 需求：在控制台输出所有的”水仙花数”
 *
 * 分析：
 *         什么是水仙花数呢?
 *              所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。
 *              举例：153就是一个水仙花数。
 *              153 = 1*1*1 + 5*5*5 + 3*3*3
 *
 *         A:三位数其实就告诉了我们水仙花数的范围
 *              100-999
 *         B:如何获取一个数据的每一个位上的数呢?
 *              举例：我有一个数据153，请问如何获取到个位，十位，百位
 *              个位：153%10 = 3;
 *              十位：153/10%10 = 5;
 *              百位：153/10/10%10 = 1;
 *              千位：...
 *              万位：...
 *         C:让每个位上的立方和相加，并和该数据进行比较，如果相等，就说明该数据是水仙花数，在控制台输出
 */
public class ForTest4 {
     public static void main(String[] args) {
           //通过循环获取到每一个三位数
           for(int x=100; x<1000; x++) {
                //获取个位，十位，百位
                int ge = x%10;
                int shi = x/10%10;
                int bai = x/10/10%10;
                
                //让每个位上的立方和相加，并和该数据进行比较，如果相等，就说明该数据是水仙花数，在控制台输出
                if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) {
                     System.out.println(x);
                }
           }
     }
}
 
    3.6 for循环练习之统计水仙花个数
package com.denniscui_04;
/*
 * 需求：统计”水仙花数”共有多少个
 *
 * 分析：
 *         A:定义统计变量，初始化值是0
 *         B:获取三位数，用for循环实现
 *         C:获取三位数的个位，十位，百位
 *         D:判断这个三位数是否是水仙花数，如果是，统计变量++
 *         E:输出统计结果就可以了
 */
public class ForTest5 {
     public static void main(String[] args) {
           //定义统计变量，初始化值是0
           int count = 0;
           
           //获取三位数，用for循环实现
           for(int x=100; x<1000; x++) {
                //获取三位数的个位，十位，百位
                int ge = x%10;
                int shi = x/10%10;
                int bai = x/10/10%10;
                
                //判断这个三位数是否是水仙花数，如果是，统计变量++
                if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) {
                     count++;
                }
           }
           
           //输出统计结果就可以了
           System.out.println("水仙花数共有："+count+"个");
     }
}
 
    3.7 while循环语句
package com.denniscui_05;
/*
 * while循环语句的基本格式：
 *         while(判断条件语句) {
 *              循环体语句;
 *         }
 * 扩展格式：
 *         初始化语句;
 *         while(判断条件语句) {
 *              循环体语句;
 *              控制条件语句;
 *         }
 *
 * 回顾for循环的语句格式：
 *         for(初始化语句;判断条件语句;控制条件语句) {
 *              循环体语句;
 *         }
 */
public class WhileDemo {
     public static void main(String[] args) {
           //输出10次HelloWorld
           /*
           for(int x=1; x<=10; x++) {
                System.out.println("HellloWorld");
           }
           */
           
           //while循环实现
           int x=1;
           while(x<=10) {
                System.out.println("HellloWorld");
                x++;
           }
     }
}
 
    3.8 while循环练习之实现1-100数据的求和
package com.denniscui_05;
/*
 * 求1-100之和。
 */
public class WhileTest {
     public static void main(String[] args) {
           //回顾for循环实现
           
           /*
           //定义求和变量
           int sum = 0;
           //获取1-100之间的数据
           for(int x=1; x<=100; x++) {
                //累加
                sum += x;
           }
           System.out.println("1-100的和是："+sum);
           */
           
           //while循环实现
           //定义求和变量
           int sum = 0;
           int x = 1;
           while(x<=100) {
                sum += x;
                x++;
           }
           System.out.println("1-100的和是："+sum);
     }
}
 
    3.9 do...while循环语句的格式
package com.denniscui_06;
/*
 * do...while循环的基本格式：
 *         do {
 *              循环体语句;
 *         }while(判断条件语句);
 * 扩展格式：
 *         初始化语句;
 *         do {
 *              循环体语句;
 *              控制条件语句;
 *         }while(判断条件语句);
 * 执行流程：
 *         A:执行初始化语句;
 *         B:执行循环体语句;
 *         C:执行控制条件语句;
 *         D:执行判断条件语句，看是true还是false
 *              如果是true，回到B继续
 *              如果是false，就结束
 *
 * 练习：
 *         求和案例
 *         统计水仙花个数
 */
public class DoWhileDemo {
     public static void main(String[] args) {
           //输出10次 HelloWorld
           /*
           for(int x=1; x<=10; x++) {
                System.out.println("HelloWorld");
           }
           */
           
           //do...while改写
           int x=1;
           do {
                System.out.println("HelloWorld");
                x++;
           }while(x<=10);
     }
}
 
    3.10 三种循环的区别
            虽然可以完成同样的功能，但是还是有小区别：
                do…while循环至少会执行一次循环体。
                for循环和while循环只有在条件成立的时候才会去执行循环体
                for循环语句和while循环语句的小区别：
                使用区别：控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消失，能够提高内存的使用效率。
package com.denniscui_06;
/*
 * 三种循环的区别：
 *         A:do...while至少执行一次循环体
 *         B:for,while循环先判断条件是否成立，然后决定是否执行循环体
 *
 * for和while的小区别：
 *         for循环的初始化变量，在循环结束后，不可以被访问。而while循环的初始化变量，是可以被继续使用的。
 *         如果初始化变量，后面还要继续访问，就使用while，否则，推荐使用for。
 *
 * 循环的使用推荐：
 *         for -- while -- do...while
 */
public class DoWhileDemo2 {
     public static void main(String[] args) {
           /*
           int x = 3;
           while(x<3) {
                System.out.println("我爱林青霞");
                x++;
           }
           System.out.println("--------------");
           int y = 3;
           do {
                System.out.println("我爱林青霞");
                y++;
           }while(y<3);
           */
           
           
           for(int x=1; x<=10; x++){
                System.out.println("爱生活，爱Java");
           }
           //这里的x无法继续访问
           //System.out.println(x);
           System.out.println("-----------------");
           
           int y = 1;
           while(y<=10) {
                System.out.println("爱生活，爱Java");
                y++;
           }
           System.out.println(y);
     }
}
 
3.跳转控制语句
    3.1 break语句的使用
package com.denniscui_07;
/*
 * break:中断的意思
 * 使用场景：
 *         A:switch语句中
 *         B:循环中
 * 注意：
 *         离开使用场景是没有意义的。
 * 作用：
 *         跳出循环，让循环提前结束
 */
public class BreakDemo {
     public static void main(String[] args) {
           //break;
           
           for(int x=1; x<=10; x++) {
                if(x == 3) {
                     break;
                }
                System.out.println("HelloWorld");
           }
     }
}
 
3.2 continue语句的使用
package com.denniscui_07;
/*
 * continue:继续的意思
 * 使用场景：
 *         循环中
 * 注意：
 *         离开使用场景是没有意义的
 * 作用：
 *         结束一次循环，继续下一次的循环
 * 区别：
 *         break:退出循环
 *         continue:结束一次循环，继续下一次的循环
 */
public class ContinueDemo {
     public static void main(String[] args) {
           //continue;
           
           for(int x=1; x<=10; x++) {
                if(x == 3) {
                     //break;
                     continue;
                }
                System.out.println("HelloWorld");
           }
     }
}
 
    3.3 练习
            按要求分析结果，并验证
            for(int x=1; x<=10; x++) {
            if(x%3==0) {
            //分别写break，continue，说说输出几次
            }
            System.out.println(“我爱Java”);
            }
            
            答案：
package com.denniscui_07;
/*
 * 按要求分析结果，并验证
 *
 * break：输出2次
 * continue:输出7次
 */
public class BreakAndContinueDemo {
     public static void main(String[] args) {
           for (int x = 1; x <= 10; x++) {
                if (x % 3 == 0) {
                     // 分别写break，continue，说说输出几次
                     //break;
                     continue;
                }
                System.out.println("我爱Java");
           }
     }
}
 
 
 

Java基础学习-流程控制语句的更多相关文章

  1. java基础(5):流程控制语句（switch）、数组

    1. 流程控制语句(续) 1.1 选择结构switch switch 条件语句也是一种很常用的选择语句,它和if条件语句不同,它只能针对某个表达式的值作出判断,从而决定程序执行哪一段代码.例如,在程序 ...

  2. java基础3_流程控制语句

    一 条件判断 1. 条件运算符(三元表达式) ,其形式为: type d = a ? b : c; 具体化形式为:int d = 2 < 1 ? 3 : 4; 2. 轻量级的文本编辑器:Ultr ...

  3. Java基础语法—流程控制语句

    在一个程序执行的过程中,各条语句的执行顺序对程序的结果是有直接影响的.所以,我们必须清楚每条语句的执行流程.而且,很多时候要通过控制语句的执行顺序来实现我们想要的功能. 3.1 流程控制语句分类 ​ ...

  4. 再回首，Java温故知新（九）：Java基础之流程控制语句

    流程控制语句分为条件语句.循环语句和中断语句. 中断语句包括break和continue,两者的区别在于break会跳出整个循环,而continue则是跳出此次循环,之后还会继续下一次循环. 条件语句 ...

  5. java基础，流程控制语句

                                流程控制语句 条件语句:              if语句:                        *if(条件 boolean类型) ...

  6. java基础之流程控制语句

    一.     分支 1.      三元运算符 ?: 注意:三元运算符虽然简洁但是语法乱,而且必须要有接受者或者直接打印 1.     if else语句 另一种不带括号的写法: if(条件) 语句1 ...

  7. Java基础学习笔记总结

    Java基础学习笔记一 Java介绍 Java基础学习笔记二 Java基础语法之变量.数据类型 Java基础学习笔记三 Java基础语法之流程控制语句.循环 Java基础学习笔记四 Java基础语法之 ...

  8. Java基础-程序流程控制第二弹（循环结构）

    Java基础-程序流程控制第二弹(循环结构) 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 流程控制有三种基本结构:顺序结构,选择结构和循环结构.一个脚本就是顺序结构执行的,选择结 ...

  9. 尚学堂JAVA基础学习笔记

    目录 尚学堂JAVA基础学习笔记 写在前面 第1章 JAVA入门 第2章 数据类型和运算符 第3章 控制语句 第4章 Java面向对象基础 1. 面向对象基础 2. 面向对象的内存分析 3. 构造方法 ...

随机推荐

  1. CSCI 1100 — Computer Science 1 Homework

    CSCI 1100 — Computer Science 1 Homework 8CS1 Multiverse: ClassesOverviewThis homework is worth 100 p ...

  2. Spring AOP功能和目标

    1.AOP的作用 在OOP中,正是这种分散在各处且与对象核心功能无关的代码(横切代码)的存在,使得模块复用难度增加.AOP则将封装好的对象剖开,找出其中对多个对象产生影响的公共行为,并将其封装为一个可 ...

  3. 《Redis 命令操作》

    一:Redis 的启动与关闭 - 关闭指定端口的 Redis - redis-cli -p 9200 shutdown - 开启 Redis - redis-server redis.config 二 ...

  4. Django ORM中datetiem数据类型字段无法对比处理办法

    在做商城项目中浏览足迹时,我利用浏览商品的ID和浏览的时间保存到browse表中,然后在我的足迹页面根据最近日期进行展示 条件:每天/个商品只能如一次表 后台代码如下: #存储浏览足迹到browse表 ...

  5. Linux（CentOs 7）系统重装笔记(二)---完全删除用户账号和root用户登录

    参考网址:https://jingyan.baidu.com/article/046a7b3ede1c38f9c27fa91b.html 一.完全删除用户 1.查看要删除的用户账号信息 find / ...

  6. 在linux系统中出现u盘问题 的相关解决方法

    1.显示unknown filesystem type .exfat 可以通过该方法解决: 安装exfat-fuse: 在终端中以管理员身份运行 sudo apt-get install exfat- ...

  7. 20190422 8个小时的T-SQL基础视频课件-分享

    链接:https://pan.baidu.com/s/1YLjtU0Ymn0rI-KMF0DFehw 提取码:yeuw 我最近缺钱..... SQLSERVER 2016视频T-SQL(一) 路径:h ...

  8. 正则表达式-----re库

    1.正则表达式的概念 a.为什么要用正则? 用字符串匹配也是可以的: startswith() 方法用于检查字符串是否是以指定子字符串开头,如果是则返回 True,否则返回 False.如果参数 be ...

  9. 解决：启用多线程调用webBrowsers函数报错：指定的转换无效

    这里就需要委托. 定义一个 委托.加载之后给他绑定一个方法Callback,也就是所说的回掉函数. 然后写一个线程,线程需要一个object 的参数.将你定义的委托当作参数传进线程中的方法. 在线程中 ...

  10. python模块之re模块

    # 正则表达式是用来匹配字符串的方法 # 字符串本身就有匹配方式,为什么要引入正则表达式? 因为原有的字符串匹配不出来原始的方法 # 正则匹配是用来进行模糊匹配的 s = "alex wan ...