精华内容
下载资源
问答
  • for循环和while循环相同点与不同点。 相同点: 同为循环结构,用for语句可以操作的用while大部分也可以操作。 不同点: for循环格式: for(条件语句1;条件语句2;条件语句3){ //执行操作语句 } while循环格式:...

    for循环和while循环的相同点与不同点。
    相同点:
    同为循环结构,用for语句可以操作的用while大部分也可以操作。

    不同点:
    for循环格式:
    for(条件语句1;条件语句2;条件语句3){
    //执行操作语句
    }
    while循环格式:
    while(条件语句){
    //若条件为真,执行操作语句
    }

    除格式不同外,两者循环结构也有所不同。
    比如:计算1~10的累计相加。

    //for循环
    int sum = 0; 
    for(int i =1;i<=10;i++){
         sum  = sum + i;
         }
     //while循环
     int sum = 0;
     int i = 1;
     while(i<=10){
         sum = sum + i;
         i++;
     }
     如果只有这样的一个代码块那么两者没有什么区别,但如果变成这样:
     
    
    ```java
    //for循环
    int sum = 0; 
    for(int i =1;i<=10;i++){
         sum  = sum + i;
         }
         System.out.pirntln(sum +i );
         
    //while循环
     int sum = 0;
     int i = 1;
     while(i<=10){
         sum = sum + i;
         i++;
     }
       System.out.pirntln(sum +i );
    

    输出的结果就会出现差异。前者报错找不到符号,后者输出sum+i的值。
    如果不考虑内存并且之后不再使用int i 那么while和for可以随意使用。
    否则,for和while就必须选择性使用,具体看需求而定。

    还有一个就是无限循环。

    //for无限循环
    for(; ;){
      //语句
      //判断条件
      //break;
      }
    //while无限循环
    while(true){
      //语句
      //判断条件
      //break;
     }
    
    
    
    展开全文
  • day for循环for循环与do-while 循环do - while循环 do …while循环的语法 do{ 循环体; }while(); //此处有一个分号!!! 注意 do - while循环最后面必须有一个分号 do - while 循环结构while结构的最大区别是...

    day for循环

    for循环与do-while 循环

    do - while循环

    1. do …while循环的语法
    do{
        循环体;
        }while(); //此处有一个分号!!!
        注意  do - while循环最后面必须有一个分号
    1. do - while 循环结构和while结构的最大区别是什么?
      while : 当型循环
      do - while: 直到型循环,傻瓜式循环
      无论如何,do- while 一定比while循环多执行一次

      练习

          *while 型循环*
           int num = 5;
            while(num >0)
            {
             printf("吃饭啦\n");
                 num--;
            }
      
          *do - while 型循环*
      
           int num = 5;
           do
           {
             printf("吃饭啦\n");
               num--;
           }while(num > 0);
      
    2. * do - while 循环一般应用在循环至少执行一次的时候*

      * do-while 和while循环的区别 *

      1. 相同点: 都是循环结构,目的是将一段代码反复的执行指定的次数
        2.不同点:
        2.1 do while 循环是先执行后判断
        while循环是结构是 先判断 在执行
        2.2 在第一次判断天剑都不成立的情况下
        do- while 循环会执行一次
        while 循环 不会执行
        结论: do - while 循环至少执行一次

    for循环的使用

    * 格式*

    for (初始化表达式; 判断条件; 增量语句)
    {
        循环体;
    }
    

    ** while循环和for循环之间的额转换

     1>用for循环打印10次hello world
        int main()
        {
            for (int i = 0; i<10; i++) {
                printf("hello world\n");
            }
            return 0;]]
        }
    
    
        2>while循环打印10次hello world
        int main()
        {
            int i = 0;
            while (i < 10) {
                printf("hello world!\n");
                i++;
            }
    
    
            return 0;
        }
    
        3>for循环转换成while循环
        int main()
        {
            int i = 0
            for (;i<10;) {
                printf("hello world\n");
                i++
            }
            return 0;
        }

    for循环练习

    1.利用for循环求1-100之间的偶数的累加和

    
            int sum = 0;//求和的变量
            for (int i = 1; i < 101; i++) {
    
                if (i % 2 == 0) {//判断这个数 是不是偶数
    
                    //            printf("%d ",i);
                    //把打印去掉 直接加到某一个容器
                    sum+=i;
                }
            }
    
            printf("sum = %d\n",sum);

    2.利用for循环求100-999之间的水仙花数

        for (int i = 100; i < 1000; i++) {
            //水仙花数: 各个位上的立方和 等于本身的数
    
            /*
             456:
             个位:456%10 -->6
             十位:456/10%10--->5
             百位:456/100 --->4
    
             */
            int ge = i % 10;
            int shi = i / 10 % 10;
            int bai = i / 100;
    
            if ( (ge*ge*ge + shi*shi*shi + bai*bai*bai) == i) {
                printf("%d ",i);
            }
        }

    for循环的额注意事项

    • 如果在三个表达式中已经修改了循环增量的值 那么就不在循环体内修改循环增量的值了
    • 第三个表达式后面没有分号
    • 三个表达是的位置是固定的
      • 第一个是初始化表达式
      • 第二个是循环条件
      • 第三个是 新欢后改变增量的表达式
    • 三个表达式都可以省略,但是分号不能省略
      • 如果第二个表达式省略,那么循环条件默认是成立的
    • 这个表达式可以写任意的c语句

    关于省略大括号
    1. 不建议省略,这里我一代而过吧
    2. 如果语句后面只有一句代码, 那么这个大括号可以省略
    3. 单独一个分号也是一个语

    嵌套循环

    • 什么是嵌套循环
      • 一个循环的循环体中 含有另外一个循环
        1. 嵌套循环的特点
      • 外层循环执行一次,内存循环执行所有次
        1. 嵌套循环的使用场景
      • 一件事要完成一次 必须完成另外一件事n次

    下面是我写的关于各种三角形的例子大家能看懂就好

    //
    //  main.c
    //  打印三角形
    //
    //  Created by 李典 on 16/7/27.
    //  Copyright © 2016年 李典. All rights reserved.
    /*
    
     打印三角形 各种三角形
    
    
     */
    
    #include <stdio.h>
    void zuoZhiJiao();
    void youZhiJiao();
    void sanJiaoXing();
    void dunJiaoSanJiaoXing();
    void shuZi();
    void shuZi1();
    int main(int argc, const char * argv[])
    {
        printf("直角三角形\n");
        zuoZhiJiao();
        printf("右直角三角形\n");
        youZhiJiao();
        printf("三角形\n");
        sanJiaoXing();
        printf("钝角三角形\n");
        dunJiaoSanJiaoXing();
        printf("数字每列一样\n");
        shuZi();
        printf("数字叠加\n");
        shuZi1();
        return 0;
    }
    
    
    /**
    
     *
     **
     ***
     ****
    
     */
    void zuoZhiJiao()
    {
    
        for (int i = 1; i < 5; i++)
        {
            for (int j = 0; j < i; j++) {
                printf("* ");
            }
            printf("\n");
        }
    }
    /**
    
    ----*
    ---**
    --***
    -****
    
     */
    void youZhiJiao()
    {
        for (int i = 1; i < 5; i++)
        {
            for (int j = 5; j > i; j--)
            {
    //            printf("-");
                 printf("  ");
    
            }
            for (int q = 0; q < i; q++) {
                printf("* ");
            }
            printf("\n");
        }
    }
    
    /**
    
    ---*        1
    --***       3
    -*****      5
    *******     7
    
     */
    void sanJiaoXing()
    {
        for (int i = 1; i < 5; i++)
        {
            for (int j = 5; j > i; j--) {
    //            printf("-");
                 printf("  ");
            }
            for (int q = 0; q < 2*i - 1 ; q++) {
                printf("* ");
            }
            printf("\n");
        }
    
    }
    /**
    ------*
    ----**
    --***
    ****
    
     */
    void dunJiaoSanJiaoXing()
    {
        for (int i = 1; i < 5 ; i++)
        {
            for (int j = 8; j > 2*i - 1; j--)
            {
    //            printf("-");
                printf("  ");
            }
            for (int q = 0; q < i; q++) {
                printf("* ");
            }
            printf("\n");
        }
    }
    
     /*
      1
      2 2
      3 3 3
      4 4 4 4
      5 5 5 5 5
    
      */
    void shuZi()
    {
        for(int i = 1; i < 6; i++)
        {
            for(int j = 1; j < i + 1; j++)
            {
    
                printf("%d ",i);
            }
            printf("\n");
        }
    }
    
    /*
     1
     1 2
     1 2 3
     1 2 3 4
     1 2 3 4 5
     1 2 3 4 5 6
     */
     void shuZi1()
    {
        for(int i = 1; i < 7;i++)
        {
            for(int j = 1; j < i+1; j++)
            {
                printf("%d ",j);
            }
            printf("\n");
        }
    }
    
    

    跟大家分享一道今天在网上看到的面试题

    int main()
        {
    
            for (int i = 0; i < 10; i++) {
    
                for (int j = 0; j < 10; j++) {
                    //这里写一段代码,结束外层循环
                }
            }
    
            return 0;
        }

    ### 哈哈 思考一下吧 答案明天 为大家揭晓

    展开全文
  • for循环与while循环的区别联系

    千次阅读 2016-02-24 15:39:56
    C/C++中的for循环代码和while循环代码在GCC中生成的汇编代码在经过优化之后是相同的。即,两者在表达能力上是等价的。 (二)不同 1.循环条件 for循环的循环条件一般是循环变量(i、j、k)。 while循环的循环条件...

    (一)相同点:

    C/C++中的for循环代码和while循环代码分别在GCC中生成的汇编代码是相同的。即两者在表达能力上是等价的。

    (二)不同点:

    1.循环条件

    for循环的循环条件一般是循环变量(i、j、k)。

    while循环的循环条件可以是循环变量(i、j、k),也可以是表达式。

    2.循环条件的设定位置

    for循环的循环变量可以在for循环的内部设定,在for循环结束之后就释放掉了;同样,也可以在for循环的前面设定,在for循环结束之后并没有释放掉。

    while循环的循环变量或者表达式必须在while循环的前面设定,在while循环结束之后并没有释放掉。

    3.适用场合

    for循环适用于循环的开始和结束已知,循环次数确定的场合。

    while循环适用于循环次数不确定的场合。

    展开全文
  • python:while循环for循环

    千次阅读 多人点赞 2018-03-17 22:59:56
    在python编程中,python提供了for循环和while循环 while循环: 基本语法为: while 判断条件: 执行语句...... 1、while循环用于循环执行程序,以处理需要重复处理的任务。 2、while循环用于多次判断同一个...

    循环

    1、在一般情况下,语句是按顺序执行的:在一个函数的第一条语句,首先执行,然后是第二条,第三条...等等
        ⑴可能有一种情况,当你需要执行代码块几次或多数,循环语句可以让我们执行语句声明或组多次

    2、循环三大条件
        ⑴定义循环的起始值
        ⑵循环结束的条件
        ⑶起始值递增或递减

    3、在python编程中,python提供了for循环while循环

    Python中的循环

    Python编程语言提供了以下类型的循环

    循环类型描述
    while循环当指定的条件为True时:重复执行while语句块下的语句或组。它在执行循环体之前测试条件
    for循环执行一系列语句多次或循环遍历某一可迭代对象
    嵌套循环可以在while循环或for循环内嵌套任意类型的循环

    Python中的循环控制语句

    1、循环控制语句改变其正常的顺序执行。当执行离开了循环范围,在该范围内创建的所有自动对象被销毁

    2、Python支持以下控制语句

    控制语句描述
    break语句 终止循环语句并立刻转移执行循环后面的语句:跳出整个循环
    continue语句结束本次循环,进行下次循环
    pass语句pass是空语句,为了保持程序结构的完整性。它不做任何事情,相当于占位语句

    while循环

    1、Python编程语言中的while循环语句只要给定条件为真,则会重复执行while代码块下的语句

    2、基本语法为:

    while 判断条件:
            执行语句......

    注:
    1、while循环用于循环执行程序,以处理需要重复处理的任务:当while关键字后的判断条件为真时,执行while代码块

    2、while语句和if语句都有判断的作用
        ⑴while循环用于多次判断同一个条件,条件满足时重复执行语句块
        ⑵if语句只能判断一个条件一次,无循环作用    

    3、执行语句可以是单个语句或语句块。判断条件可以是任何表达式(参考if的判断表达式)
        ⑴所有非空(null)、非零的值都为真(True):执行while代码块
        ⑵当判断条件为假(False)时:循环结束

    4、while循环的执行流程图如下,该流程图的意思为:
        ⑴首先对while条件进行判定,当条件为ture时,执行while语句块。执行完while语句块后再次对条件进行判定,若为仍为true,则继续执行while语句块,直到条件为false时结束循环

    例1:

    count = 0
    while count < 5:
       print ('The count is:', count)
       count = count + 1
    
    print ("Good bye!") #while循环结束后,继续执行下面其他语句块
    
    """
    The count is: 0
    The count is: 1
    The count is: 2
    The count is: 3
    The count is: 4
    Good bye!
    """

    无限循环

    1、在while循环中:如果条件永远不会变为False,那么一个循环就会变成无限循环(死循环)

    2、进入了一个无限循环时,需要使用CTRL+C才能退出程序

    3、所以在使用while循环时一定需要注意循环的判断条件:保证一定会有跳出循环的条件

    例2:

    count = 1
    while count ==True:
       print ('The count is:', count)
    
    print ("Good bye!") #上面为一个死循环,因此永远都不会跳出循环来执行这条语句

    while循环中使用else语句

    Python支持循环语句相关的else语句。也就是说整个语句中可以不出现if关键字
        ⑴如果else语句在一个for循环中使用,当循环已经完成(用尽时)迭代列表执行else语句
        ⑵如果else语句用在while循环中,当条件变为false,则执行else语句

    例3:

    # 这种场景应该遇不到,知道即可
    number = 1
    while number < 5:
        print(number)
        number += 1
    # else语句用在while循环中,当条件变为false,则执行else语句
    else:    #else与while为同一缩进
        print("number的值为5")
     
    """
    2
    3
    4
    number的值为5
    """

     注:

    1、上面代码之所以能这样写是因为:whiel关键字的级别比if关键字高,else又是一个攀附权贵的家伙,根本不在乎是否有if,以及是否执行了满足if条件的语句。else的眼里只有关键字,只要while关键字顺利执行完毕,else就会屁颠儿屁颠儿地跑一遍

    2、不管是在while循环或for循环中一定要注意else关键字出现的位置。比如下面这个例子

     例4:

    """
    需求:判断一个列表中是否有元素大于3
        存在元素大于3,则输出任意一个
        不存在元素大于3,在输出"列表中没有数大于3"
    """
    list = [1,2,3,4,5,1,2]
    
    while len(list) > 0:
        number = list.pop()
        # 如果元素大于3,则输出并跳出循环不在继续往下找了
        if number > 3:
            print("列表中至少有一个数大于3,该数为:",number)
            break
        # 否则输出"列表中没有数大于3"
        else:
            print("列表中没有数大于3")
    
    print("===end===")
    """
    列表中没有数大于3
    列表中没有数大于3
    列表中至少有一个数大于3,该数为: 5
    ===end===
    """

    注:

    1、可以看到,列表中实际是存在大于3的元素的,但是实际输出结果中,先是打印了两次"列表中没有数大于3",最后在打印的大于3的元素"5"。这与我们的预期结果是不一样的(预计结果:只打印一次大于3的元素或打印一次"列表中没有数大于3")。那为什么结果是这样的呢?

    2、上面代码的执行顺序是:
        ⑴弹出第一个元素"2",此时经过if...else判断,执行else语句块,因此打印"列表中没有数大于3"
        ⑵弹出第二个元素"1",此时经过if...else判断,执行else语句块,因此打印"列表中没有数大于3"
        ⑶弹出第三个元素"5",此时经过if...else判断,执行if语句块,因此打印"表中至少有一个数大于3,该数为: 5"
        
    3、根据需求,我们预期的执行顺序应该是:
        ⑴依次判断列表中的所有元素,在判断过程中,如果有元素大于3,那么就直接输出"表中至少有一个数大于3,该数为: x",并跳出循环
         ⑵如果判断完全部元素后,依旧没有元素大于3,那么才输出"列表中没有数大于3"

    例4_1:

    list = [1,2,3,4,5,1,2]
    
    while len(list) > 0:
        number = list.pop()
        # 如果元素大于3,则输出并跳出循环不在继续往下找了
        if number > 3:
            print("列表中至少有一个数大于3,该数为:",number)
            break
    # 所有元素经if判断后,依旧没有大于3的元素时执行else
    else:
        print("列表中没有数大于3")
    
    print("===end===")
    
    """
    列表中至少有一个数大于3,该数为: 5
    ===end===
    """

    例4_2:

    list = [1,2,3,3,3,1,2]
    
    while len(list) > 0:
        number = list.pop()
        # 如果元素大于3,则输出并跳出循环不在继续往下找了
        if number > 3:
            print("列表中至少有一个数大于3,该数为:",number)
            break
    # 所有元素经if判断后,依旧没有大于3的元素时执行else
    else:
        print("列表中没有数大于3")
    
    print("===end===")
    
    """
    列表中没有数大于3
    ===end===
    """

     注:上面代码中:在执行break关键字后,并没有执行else语句块
        ⑴正常的break语句的作用是跳出整个循环:跳出整个循环,不会执行break语句下面的语句(与break属于同一个循环语句块的语句)。但还会执行break语句下面其他语句块的代码
        ⑵但是在上面例子中else语句实际上算是其他语句块了,但使用break后还是没有执行else语句,这就是在这种特殊场景中break关键字的作用,会跳过else语句块(正常的应该是像后面的print语句一样照常执行,print语句就属于break下面的其他语句块了)

    while循环中使用if语句

    同样在while循环和for循环中也可以使用if...else语句:在循环中对某些条件进行判断,用来执行不同的语句块

    例5:

    import random
    
    number = random.randint(0,10)
    print("正确结果为:",number)
    
    guess = int(input("请输入你认为正确的数字:"))
    while guess != number:
        if guess > number:
            print("稍微大了一点,需要再小一点")
            guess = int(input("您猜错了,请输入你认为正确的数字:"))
        elif guess < number:
            print("稍微小了一点,需要再大一点")
            guess = int(input("您猜错了,请输入你认为正确的数字:"))
        else:
            pass
    
    print("正确")
    
    """
    正确结果为: 10
    请输入你认为正确的数字:2
    稍微小了一点,需要再大一点
    您猜错了,请输入你认为正确的数字:11
    稍微大了一点,需要再小一点
    您猜错了,请输入你认为正确的数字:10
    正确

    例5_1:

    list = [12,37,5,42,8,3]
    list_1 = []
    list_2 = []
    while len(list) > 0:
        number = list.pop()
        if number % 2 == 0:
            list_1.append(number)
        else:
            list_2.append(number)
    print(list_1)
    print(list_2)
    
    """
    [8, 42, 12]
    [3, 5, 37]
    """

    注:
    1、感觉在while中直接写else的场景应该会比较少,可能有些特殊场景下回用到这种写法。在循环中使用if...else语句应该会比较多

    2、在上面的第二个例子中先是通过while、if 条件的判断,分别得到list_1、list_2,在最后一次判断中while为False,则不执行循环执行输出(空列表表示False)

    for循环

    1、在python中,for关键字叫做for循环,for循环可以遍历任何一个可迭代对象
        ⑴可迭代对象:可以使用for...in...语句进行循环的对象,比如字符串、列表、元组、字典以及迭代器、生成器都是可迭代对象
        ⑵迭代:就是从某个容器对象中逐个地读取元素,直到容器中没有更多元素为止
        ⑶序列:一个列表、字符串等
        ⑷非序列:字典、TXT文件等

    2、Python中,for循环用于遍历一个可迭代对象中的所有元素
        ⑴循环内的语句段会针对可迭代对象中的每一个元素项目都执行一次。暂且可以将迭代对象想象成一个对象集合,我们可以一个个遍历里面的元素
        ⑵即:将可迭代对象中的元素依次一个一个的拿出来执行一遍for循环下的语句,直到执行完最后一个元素后,整个循环结束

    3、for循环的基本语法格式如下:

        for iterating_var in sequence:
            statements(s)
        
        """    
        sequence是需要迭代的任意序列
        iterating_var是序列中需要遍历的元素(即序列中元素的变量名)
        statements(s)是待执行的语句块
        """

    例5:使用while遍历序列中的元素

    list = [12, 37, 5, 42, 8, 3]
    n = 0
    while n < len(list):
        print("当前字母是 %s" % list[n])
        n += 1
    
    """
    当前字母是 12
    当前字母是 37
    当前字母是 5
    当前字母是 42
    当前字母是 8
    当前字母是 3
    """

    例5_1:使用for循环遍历

    list = [12, 37, 5, 42, 8, 3]
    for i in list:
        print("当前字母是 %s" % i)
    
    """
    当前字母是 12
    当前字母是 37
    当前字母是 5
    当前字母是 42
    当前字母是 8
    当前字母是 3
    """

    注:
    1、如果一个序列中包含一个表达式列表时,它需要首先计算,然后再进行遍历

    2、可以看到,在循环遍历一个可迭代对象时,使用for循环比使用while循环简便得多
        ⑴Python中的for循环更适合用于遍历一个可迭代对象,比如遍历一个序列等
        ⑵Python中的while循环更适合针对某一条件进行循环

    例6:遍历字典

    tups = {"小明":"001","小红":"002"}
    for name in tups:
        print("字典的键名为:" ,name)
    
    """
    字典的键名为: 小明
    字典的键名为: 小红
    """

    例6_1:遍历字典(序列解包)

    tups = {"小明":"001","小红":"002"}
    for name,number in tups.items():  #使用序列解包
        print("%s : %s" % (name,number))
    
    print("----------")
    
    tups1 = {"小明":"001","小红":"002"}
    for name in tups1:         #先遍历出字典的键,然后根据"字典[键名]"来索引出键对应的值
        print("%s : %s" % (name,tups1[name]))
    
    """
    小红 : 002
    小明 : 001
    ----------
    小红 : 002
    小明 : 001
    """

    注:
    1、单纯的对字典进行循环迭代时,只能对键进行迭代,若同时想得到键对应的值时只能通过字典索引的方式得到

    2、第二个例子中先是通过items()函数得到由键值对组成元组,在对返回的元组利用序列解包的方式同时对键值对进行迭代

    同时迭代两个序列(并行迭代)

    例7:

    name = ["小红","小张","小强"]
    number = ["001","002","003"]
    for student_ID in range(len(name)):
        print("学生的名字:%s,学号为: %s" % (name[student_ID],number[student_ID]))
    
    """
    学生的名字:小红,学号为: 001
    学生的名字:小张,学号为: 002
    学生的名字:小强,学号为: 003
    """

    例7_1:

    name = ["小红","小张","小强"]
    number = ["001","002","003"]
    for student_name,student_ID in zip(name,number):
        print(student_name,"的学号是",student_ID)
    
    """
    小红 的学号是 001
    小张 的学号是 002
    小强 的学号是 003
    """

    注:
    1、例例7_1中先通过函数zip()将两个序列打包成一个元组列表,再通过序列解包和迭代的方法得到对应学生的学号和名字

    2、zip()函数可以作用于任意数量的序列,并且可以应付不等长的序列,当短序列用完时,就会停止

    range()函数

    1、Python3中range()函数用于返回一个可迭代对象(类型是对象、序列)

    2、python2中range()函数用于返回一个整数列表

    3、range()函数的返回值为一个序列(Python2中返回的是一个列表)且生成的序列(列表)包含star参数但不会包含stop参数(包左不包右)

    4、不管是在python2中还是python3中,range()函数一般用在for循环中
        ⑴生成一个序列(列表)后,对这个序列(列表)进行遍历

    5、语法:

    for number in range(star,stop,step):
        print(number)
     
    """
    range(star,stop,step) : 用于生成一个指定序列
    参数star:可选参数,表示生成的序列的开始数字,无此参数时,表示序列从0开始
    参数stop:必填参数,表示生成序列的结束数字
    参数step:可选参数,表示生成序列的递增数(该参数不能是浮点数,可以为正数或负数),无此参数时,表示默认递增数为1
    """

    例8:

    #单独使用
    sequence = range(5)
    
    print(sequence)
    print(type(sequence))
    
    """
    range(0, 5)
    <class 'range'>  #Python中range()返回的是一个序列对象
    """
    
    #只有结束参数
    for i in range(5):
        print(i)
    """
    0
    1
    2
    3
    4
    """
    
    #有开始、结束参数,无步长参数
    for i in range(1,5):
        print(i)
    """
    1
    2
    3
    4
    """
    
    #有开始、结束参数、步长参数
    for i in range(1,10,2):
        print(i)
    """
    1
    3
    5
    7
    9
    """
    
    
    #开始参数大于结束参数,且步长为负数时
    for i in range(5,1,-1):
        print(i)
    
    """
    5
    4
    3
    2
    """
    
    #均为负数
    for i in range(-1,-5,-1):
        print(i)
    
    """
    -1
    -2
    -3
    -4
    """
    
    
    #开始参数大于结束参数,且步长为正数时
    for i in range(5,1):
        print(i)
    
    """
    开始数字为5,步长默认为1,5+正数-->永远也到不了1,因此无返回结果(不会报错)
    """

    for循环中使用else语句

    1、在for循环中正常使用if...else语句:将if...else语句整个嵌套在for循环中来达到判断的作用,进而进行不同的处理

    例9:

    list = [1,2,3,4,5,6]
    for i in list:
        if i > 3:
            print("当前数字大于3:",i)
        elif i == 3:
            print("当前数字等于3:",i)
        else:
            print("当前数字小于3:",i)
            
    """
    当前数字小于3: 1
    当前数字小于3: 2
    当前数字等于3: 3
    当前数字大于3: 4
    当前数字大于3: 5
    当前数字大于3: 6
    """

    例9_1:for循环中也可以直接使用else语句(跟前面例子4一样)

    """
    需求:判断一个列表中是否有元素大于3
        存在元素大于3,则输出任意一个
        不存在元素大于3,在输出"列表中没有数大于3"
    """
    list = [1,2,3,3,3,1,2]
    
    for number in list:
        # 如果元素大于3,则输出并跳出循环不在继续往下找了
        if number > 3:
            print("列表中至少有一个数大于3,该数为:",number)
            break
    # 所有元素经if判断后,依旧没有大于3的元素时执行else
    else:
        print("列表中没有数大于3")
    
    print("===end===")
    
    """
    列表中没有数大于3
    ===end===
    """

    注:

    1、for的级别比if高,else不在乎是否有if,以及是否执行了满足if条件的语句。一般情况下只要for执行完毕,else也会执行。只有当for循环被break语句中断之后,才会跳过else语句

    3、上面这个例子中还有一点需要注意:就是上面break语句的使用
        ⑴正常的break语句的作用是跳出整个循环:跳出整个循环,不会执行break语句下面的语句(与break属于同一个循环语句块的语句)。但还会执行break语句下面其他语句块的代码
        ⑵但是在上面例子中else语句实际上算是其他语句块了,但使用break后还是没有执行else语句,这种算是这种写法的特例吧(正常的应该是像后面的print语句一样照常执行,print语句就属于break下面的其他语句了)

    break

    1、break:终止当前循环并跳出整个循环

    2、break语句用在while和for循环中

    3、break语句用于跳出当前循环,并且不会再执行break下面的代码:只是不会执行该循环下的语句,会继续执行下面不属于循环的代码

    4、break语句通过if语句来对条件进行判定,当if语句为True时,执行break语句

    5、在使用while循环时,如果判断条件一直为True,那么一定需要在代码中写入break:避免称为死循环

    例10:

    str = ("hello")
    for letter in str:
        if letter == "l": #判断是否满足某一条件,满足条件时跳出循环,不会执行break语句下面的语句(同以循环内的)
            break
        print(letter)
    
    """
    h
    e
    """

    例10_2:

    number = 10
    while number > 2:
        if number == 6:
            break   #跳出整个循环,不会再执行下面的代码
        print(number)  #该条语句在循环内,跳出循环后,就不会再执行了
        number -= 1
    
    print("跳出循环,继续执行循环外的代码")#该条语句不在循环内,因此跳出循环后,也会继续执行下面循环外的代码
    
    """
    10
    9
    8
    7
    跳出循环,继续执行循环外的代码
    """

    例10_3:

    import random
    
    number = random.randint(0,10)
    print("正确结果为:",number)
    
    guess = int(input("请输入你认为正确的数字:"))
    while True:
        if guess == number:
            print("正确")
            break
        elif guess > number:
            print("稍微大了一点,需要再小一点")
            guess = int(input("您猜错了,请输入你认为正确的数字:"))
        else :
            print("稍微小了一点,需要再大一点")
            guess = int(input("您猜错了,请输入你认为正确的数字:"))
    
    """
    正确结果为: 10
    请输入你认为正确的数字:22
    稍微大了一点,需要再小一点
    您猜错了,请输入你认为正确的数字:3
    稍微小了一点,需要再大一点
    您猜错了,请输入你认为正确的数字:10
    正确
    """

    continue

    1、continue:终止当前的循环,继续下一循环

    2、continue语句用来告诉python跳过当前循环的剩余语句,然后继续进行下一轮循环

    3、continue语句用在while和for循环中

    4、continue语句通过if语句来对条件进行判定,当if语句为True时,执行continue语句

    5、continue语句的作用为终止当前循环(不会执行continue下面的代码),并开始下一轮循环(重新开始)

    例11:

    number = 1
    while number < 10:
        if number == 5:
            number += 1
            continue
        if number == 7:
            break
        print(number)
        number += 1
    
    """
    1
    2
    3
    4
    6
    """

    例11_2:

    str = ("hello")
    for letter in str:
        if letter == "l":
            continue
        print(letter)
    
    """
    h
    e
    o
    注:由输出结果来看,相比与break,使用continue语句只是跳过了某次循环 ,不会跳出整个循环
    """

    备注

    1、while循环和for循环两者的相同点在于都能循环做一件重复的事情。不同的是for循环是在序列穷尽时停止;while循环是在条件不成立时停止。

    2、for 循环提供了python中最强大的循环结构(for循环是一种迭代循环机制,而while循环是条件循环迭代即重复相同的逻辑操作,每次操作都是基于上一次的结果,而进行的)

    3、Python for循环可以遍历任何序列的项目,如一个列表或者一个字符串。

    4、for循环可以用来遍历某一对象(遍历:通俗点说,就是把这个循环中的第一个元素到最后一个元素依次访问一次

    5、一般来说for循环的执行过程为:迭代出一个元素后,继续执行for所属代码块,后面的代码块执行完后,在进行下一个迭代

    例12:

    list = [1,2,3,4]
    list_1 = []
    for num in list:
        list_1.append(num)
        print(list_1) 
    
    """
    这段代码表示:遍历出一个元素后执行append()和prine(),然后继续遍历下一个元素...
    [1]
    [1, 2]
    [1, 2, 3]
    [1, 2, 3, 4]
    """
    

    例13:

    list = [1,2,3,4]
    list_1 = []
    for num in list:
        list_1.append(num)
    print(list_1)  #print()的位置不同:执行完全部for后,再输出
    
    
    """
    这段代码表示:遍历出一个元素后,执行append(),然后继续遍历下一个元素...直到遍历出最后一个元素
    并执行append()后,循环结束,继续执行循环后的代码print()。因此此时打印的结果就是最后一次遍历并执行完append()后的结果
    
    [1, 2, 3, 4]
    """

    拓展

    1、Python提供的另外一个循环结构就是for循环语句,Python提供的for循环语句和Java、C++等编程语言提供的for语句不同,Python中的for循环更像是shell或是脚本语言中的foreach循环。它可以遍历如列表、元组、字符串等序列成员(列表、元组、字符串也称为序列),也可以用在列表解析和生成器表达式中

    2、for循环常用于遍历字符串、列表、元组、字典、集合等序列类型,逐个获取序列中的各个元素(用于遍历可迭代对象)

    3、可迭代就是指任意可以使用 for 循环遍历的东西,可迭代意味着可以遍历,任何可以遍历的东西都是可迭代的。序列是一种常见的可迭代类型,如列表、元组、字符串等

    4、Python 中的大部分东西都是可以迭代的,但是可以迭代并不意味着它是序列。如集合、字典、文件和生成器都是可迭代的,但是它们都不是序列

    5、迭代器就是可以驱动可迭代对象的东西。你可以从任何可迭代对象中获得迭代器,你也可以使用迭代器来手动对它的迭代进行遍历

    6、Python中,for循环用于遍历一个迭代对象的所有元素。循环内的语句段会针对迭代对象的每一个元素项目都执行一次。暂且可以将迭代对象想象成一个对象集合,我们可以一个个遍历(访问)里面的元素(将序列中的每个元素都拿出来执行一次)

    7、while语句执行的具体流程为:首先判断条件表达式的值,其值为真(True)时,则执行代码块中的语句,当执行完毕后,再回过头来重新判断条件表达式的值是否为真,若仍为真,则继续重新执行代码块...如此循环,直到条件表达式的值为假(False),才终止循环

    例14:有时使用for循环或while循环,会达到同样的目标

    num = 0
    while num < 5:
        print("hello")
        num += 1
    
    for i in range(5):
        print("word")
    
    """
    hello
    hello
    hello
    hello
    hello
    word
    word
    word
    word
    word
    """

    注:上面例子中分别使用了for循环和while循环打印一个字符串5次,但是个人感觉这种循环还是使用while来写好点

    1、for循环用于遍历一个迭代对象的所有元素,即依次一个一个的访问可迭代对象中的元素:如果使用了for循环,但是又没有用到可迭代对象中的元素,所以感觉有点别扭且有点违背for循环的意义(自己理解的)

    2、while循环用于判断一个条件是否成立,成立的话执行while循环语句,不成立就跳出循环:这个例子中使用while循环就很合适了

    return语句与for循环、while循环一起使用

    在实际场景中有很多时候我们需要遍历一些序列,然后将序列中满足条件的一些元素作为返回值返回。此时就会在for循环、while循环中使用return了

    例15:

    list = [1,2,3,4,5]
    
    def func(data):
        for i in data:
            return i #return语句在for语句下面(属于for循环代码块)
    
    print("return语句在for语句下面:",func(list))
    
    #return语句在for语句下面: 1

    注:从上面例子可看出
    1、我们实际的需要的是返回所有遍历后的元素,但是实际上值返回了序列中的第一个元素(只遍历了一次)

    2、之所以会出现这种情况是因为:当遍历出第一个元素后,执行"return i"语句,return语句的作用是结束函数调用(结束for循环:这里就跟break语句差不多了)。因此这里就只会执行一次遍历

    例15_1:

    #经过上面的例子,那换一种写法:将return语句放来跟for循环同一层级
    list = [1,2,3,4,5]
    def func1(data):
        for n in data:
            pass
        return n  #这种写编辑器不会报错但是有提示:return语句与for语句属于同一缩进
    
    
    print("return语句与for语句属于同一缩进:",func1(list))
    
    #return语句与for语句属于同一缩进: 5

    注:从上面例子可看出
    1、实际的数据还是与我们的预期不一样,并且在编辑器中会提示这种写法不合规矩

    2、之所以会出现这种情况是因为:for循环与return是同一层级(属于相同的代码块:在执行逻辑上它们是并列关系)

    3、因此上面例子实际流程是:执行完for循环后在执行return语句,for循环最后一次遍历出来的元素是5,当把元素5遍历出来后,执行for循环下面的语句(这里是pass),然后在从上到下执行与for循环同一层级的代码(这里的return语句),此时n=5,因此就只会返回5了
     

    例15_2:解决办法

    list = [1,2,3,4,5]
    
    def func(data):
        dataList = []
        for i in data:
            dataList.append(i)
        return dataList
    
    print(func(list))
    
    #[1, 2, 3, 4, 5]

    注:
    1、可以在for循环前面定义一个空列表,用来装for循环遍历出来的元素,等for循环执行完成后,再将整个列表返回

    2、上面例子的执行流程就是:for循环遍历出来一个元素后,执行"dataList.append(i)",在进行下一次遍历....直到for循环完成后,执行与for循环同一层级的代码"return dataList"(将整个列表一次性返回)
        ⑴注:用来装遍历出来的元素的容器,必须定义在for循环之前,如果在循环内则会被初始化(进行下一次循环时被初始化)

    3、Python for循环可以遍历任何序列的项目,如一个列表或者一个字符串
        ⑴for循环可以用来遍历某一对象(遍历:通俗点说,就是把这个循环中的第一个元素到最后一个元素依次访问一次)
        ⑵一般来说for循环的执行过程为:迭代出一个元素后,继续执行for所属代码块,后面的代码块(属于for循环代码块的代码)执行完后,在进行下一个迭代。直到所有元素遍历完成后,再执行下面与for循环同一层级的代码

    4、虽然说这里输入和输出的列表都是一样的,感觉没什么实际意义。当然我这里只是举一个例子,实际中的场景应该也差不多,只是说属于for循环的代码块会比这复杂多(这里的dataList.append(i))

    5、以后遇到了循环(for、while)与return一起使用时,就一定要想到使用一个容器来装遍历(处理)后的数据,不管符合条件的数据有几个,都要有容器

    例15_3:

    data = [{'CODE': '1005', 'VALUE': '测试1'}, {'CODE': '10051', 'VALUE': '测试2'}, {'CODE': None, 'VALUE': '测试3'}]
    
    
    def func(data):
        # 因为会有多个字典,因此定义一个列表来装所有的字典。外层列表必须定义在这里
        data_list = []
        for each_data in data:
            # 这个空字典必须定义在这里
            data_dict = {}
            for key, value in each_data.items():
                # 将字典的键变为小写后添加到新字典中去
                data_dict[key.lower()] = value
            # 将新生成的字典添加到列表中去
            data_list.append(data_dict)
        # 最后统一返回大列表
        return data_list
    
    
    res = func(data)
    print(res)
    print(data)
    
    """
    [{'value': '测试1', 'code': '1005'}, {'value': '测试2', 'code': '10051'}, {'value': '测试3', 'code': None}]
    [{'VALUE': '测试1', 'CODE': '1005'}, {'VALUE': '测试2', 'CODE': '10051'}, {'VALUE': '测试3', 'CODE': None}]
    """
    """
    外循环:
        遍历出data中的第一个字典:dict1
            内循环:
                遍历出第一个字典中的第一组键值对:key1、value1
                    内循环将第一个字典的第一组键值对中的key变为小写,并加入到新字典中
                遍历出第一个字典中的第二组键值对:key2、value2
                    内循环将第一个字典的第一组键值对中的key变为小写,并加入到新字典中
                ...
                内循环结束
            将新字典加入到列表中
    外循环:
        遍历出data中的第二个字典:dict2
            内循环:
                遍历出第二个字典中的第一组键值对:key1、value1
                    内循环将第二个字典的第一组键值对中的key变为小写,并加入到新字典中
                遍历出第二个字典中的第二组键值对:key2、value2
                    内循环将第二个字典的第一组键值对中的key变为小写,并加入到新字典中
                ...
                内循环结束
            将新字典加入到列表中
    ...
    外循环结束
    继续执行与外循环同层级的代码:这里是返回列表  
    """
    

    注:

    1、"data_list.append(data_dict)"表示将整理后的完整字典(包含所有键值对的字典)加入到列表中

    2、"data_list.append(data_dict)"语句与内循环为同一层级代码,都属于外循环。且"data_list.append(data_dict)"是外循环的最后一条语句。内循环全部执行完成后代码继续往下执行,即执行"data_list.append(data_dict)",append()执行完成后继续下一次外循环

    3、不管是嵌套for循环还是嵌套while循环:每执行外循环一次,都要等待内循环和其他属于外循环的语句全部完成或中止,才继续接着外循环,如此反复,直到外循环完成

    例15_4:

    data = [{'CODE': '1005', 'VALUE': '测试1'}, {'CODE': '10051', 'VALUE': '测试2'}, {'CODE': None, 'VALUE': '测试3'}]
    
    def func(data):
        # 因为会有多个字典,因此定义一个列表来装所有的字典
        data_list = []
        # 切记不能将字典定义在这里,不仅是字典,列表之类的也不能!!!
        data_dict = {}
        for each_data in data:
            # data_dict = {} 只能将空字典定义在这里
            for key, value in each_data.items():
            # 将字典的键变为小写后添加到新字典中去
                data_dict[key.lower()] = value
            # 将新生成的字典添加到列表中去
            data_list.append(data_dict)
        # 最后统一返回大列表
        return data_list
    
    res = func(data)
    print(res)
    
    #字典在循环内不能改变其本身的键,如果要改变其键,那只能在改变后将其添加到一个新字典中
    #可以看到列表里面的所有字典,都是最后一个字典处理后的结果
    #[{'code': None, 'value': '测试3'}, {'code': None, 'value': '测试3'}, {'code': None, 'value': '测试3'}]

    注:这个新字典必须定义在第一层for循环内,第二层for循环外
    1、不能定义在第一层for循环外:因为字典为可变对象
           ⑴ 当第一次遍历并处理完第一个字典后,此时新字典里面是有键值对(元素)的
            ⑵此时继续遍历出第二个字典,在处理第二个字典中的元素,更新到新字典中时是在已有元素的新字典基础上更新(把已处理了的第一个字典值更新为第二个字典处理后的值)
            ⑶ 由于字典为可变对象,因此第二步操作会影响到已经加入到了列表中的第一个字典(将前面已处理的字典覆盖掉:字典键名是一样的)
            ⑷将字典定义在内循环外:在每次外循环时,初始化空字典(将新字典置空),再处理遍历出来的旧字典元素,并添加到新列表中去。字典间互不影响

    2、不能定义在第二层for循环内:不然就无法进行append操作了

    3、同理,空列表也不能定义在第一个for循环内,不然每次外循环时会初始化这个列表(置空):前面已经添加到列表中的新字典就不存在了

    例15_5:

    data = [("a","b"),("c","d"),("e","f")]
    
    def func(data):
        # 外层大列表必须定义在这里
        new_big_list = []
        for each_tuple in data:
            # 内层小列表必须定义在这里
            new_list = []
            for each_data in each_tuple:
                each_data = each_data.upper()
                new_list.append(each_data)
            new_big_list.append(new_list)
        return new_big_list
    
    print(func(data))
    #[['A', 'B'], ['C', 'D'], ['E', 'F']]

    例15_6:

    data = [{'CODE': 'aaa', 'VALUE': 'bbb'}, {'CODE': 'ccc', 'VALUE': 'ddd'}, {'CODE': "eee", 'VALUE': 'fff'}]
    
    def func(data):
        data_list = []
        for each_data in data:
            data_dict = {}
            # 打印当前新字典的内存地址
            print(id(data_dict))
            for key, value in each_data.items():
                # 将字典的键变为小写后添加到新字典中去
                data_dict[key.lower()] = value.upper()
            # 将新生成的字典添加到列表中去
            data_list.append(data_dict)
        # 最后统一返回大列表
        return data_list
    
    res = func(data)
    print(res)
    
    """
    2881584482568
    2881584510024
    2881580481480
    [{'VALUE': 'bbb', 'CODE': 'aaa'}, {'VALUE': 'ddd', 'CODE': 'ccc'}, {'VALUE': 'fff', 'CODE': 'eee'}]
    """

    注:
    1、字典在遍历过程中是不能改变其键的,如果需要在循环中修改字典的键,那只能将修改了键的键值对加入到新字典中

    2、从上面代码的输出可以看出:新字典data_dict定义在第一层for循环内,第二层for循环外
        ⑴每次外循环时会新生成一个新的字典data_dict,每次生成的新字典不是同一个字典(id值不一致,只是id指向的值一致)
        ⑵因此,每次在内循环中更新新字典时是操作的不同的字典,进而新字典之间是不会相互影响的

    例15_7:

    data = [{'CODE': 'aaa', 'VALUE': 'bbb'}, {'CODE': 'ccc', 'VALUE': 'ddd'}, {'CODE': "eee", 'VALUE': 'fff'}]
    
    def func(data):
        data_list = []
        data_dict = {}
        for each_data in data:
            # 打印当前新字典的内存地址
            print(id(data_dict))
            for key, value in each_data.items():
                # 将字典的键变为小写后添加到新字典中去
                data_dict[key.lower()] = value.upper()
            # 将新生成的字典添加到列表中去
            data_list.append(data_dict)
        # 最后统一返回大列表
        return data_list
    
    res = func(data)
    print(res)
    
    """
    2282257959176
    2282257959176
    2282257959176
    [{'code': 'EEE', 'value': 'FFF'}, {'code': 'EEE', 'value': 'FFF'}, {'code': 'EEE', 'value': 'FFF'}]
    """

    注:
    1、从上面代码的输出可以看出:新字典data_dict定义在第一层for循环外
        ⑴首次外循环时会新生成一个新的字典data_dict:在整个代码执行过程中只会有一个新字典data_dict
        ⑵因此,每次在内循环中更新新字典时都是操作的同一个字典
        ⑶将第一个新字典添加到列表中后。再操作第二个新字典时是在第一个新字典的基础上更新的
        ⑶由于是在同一个字典上操作的且字典为可变对象,因此在操作第二个字典时,会同步影响到已添加到新列表中的字典,以此类推。因此最后都会显示为最后一个字典的处理结果(字典的键名一致,就是会更新值)

    2、前面例子中是将处理后的键值对添加到新字典(列表)中,如果在处理字典时不需要处理字典的键,那么其实可以直接在原字典上进行处理,就不用了定义新字典、列表了

    例15_8:

    data1 = [{'CODE': 'aaa', 'VALUE': 'bbb'}, {'CODE': 'ccc', 'VALUE': 'ddd'}, {'CODE': "eee", 'VALUE': 'fff'}]
    data2 = {'CODE': 'aaa', 'VALUE': 'bbb'}
    
    def func(data):
        if isinstance(data,list):
            pass
        elif isinstance(data,dict):
            data = [data]
        else:
            raise TypeError("传入数据类型错误")
        for each_data in data:
            print(id(each_data))
            for key, value in each_data.items():
                each_data[key] = value.upper()
        return data
    
    res1 = func(data1)
    print(res1)
    
    res2 = func(data2)
    print(res2)
    
    """
    1747022494216
    1747022494472
    1747022494344
    [{'CODE': 'AAA', 'VALUE': 'BBB'}, {'CODE': 'CCC', 'VALUE': 'DDD'}, {'CODE': 'EEE', 'VALUE': 'FFF'}]
    
    1747027151112
    [{'CODE': 'AAA', 'VALUE': 'BBB'}]
    """

    注:
    列表中的每个字典依次经遍历出来后,然后进行处理,都是同一个字典(id值一致)。由于字典是可变对象,因此在单独处理字典后,也会影响到列表中对应的字典。因此最后只需要返回原字典会列表即可

    return语句与for循环、if语句一起使用

    需求

    遍历传入的列表(嵌套了字典的列表)
        ⑴如果列表中的某个字典的"C"键值符合要求(这里是dict["C"] == "6"),则返回对应字典(前提:只有单个字典符合条件)
        ⑵如果列表中的所有字典的"C"键值都不符合要求(这里是dict["C"] == "6"),则返回False

    例16:

    dict = [{"A":"1","B":"2","C":"3"},{"A":"4","B":"5","C":"6"}]
    
    def func(data):
        for eachDict in data:
            print("---",eachDict)
            if eachDict["C"] == "6":
                return eachDict
            else:
                return False
    
    result = func(dict)
    print(result)
    
    """
    输出结果:
    --- {'A': '1', 'B': '2', 'C': '3'}
    False
    """

    注:

    1、可以看到这里实际的输出结果跟我们预期的结果是不一样的:列表中的第二个字典是满足要求的,但是返回的是False(走的else)

    2、这个是因为:遍历出第一个字典时,此时这个字典时不满足要求的(不满足 if dict["C"] == "6"),因此它走的是else,并执行了"return False",执行return后for循环结束,不再继续遍历。因此根本就不会走到第二个字典那里了

    3、因此正确代码流程是:遍历完整个列表中的所有字典后,都没有满足要求的字典,这个时候才return False

    例16_1:

    dict = [{"A":"1","B":"2","C":"3"},{"A":"4","B":"5","C":"6"}]
    
    def func1(data):
        for eachDict in data:
            print("---",eachDict)
            if eachDict["C"] == "6":
                return eachDict
        else:
            return False
    
    result1 = func1(dict)
    print(result1)
    
    """
    --- {'A': '1', 'B': '2', 'C': '3'}
    --- {'A': '4', 'B': '5', 'C': '6'}
    {'A': '4', 'B': '5', 'C': '6'}
    """

    注:
    1、所以啊,在for循环或者while循环中使用return一定要注意return的使用位置以及分清楚具体的数据、场景是什么样的啊,想清楚所需要的代码流程是什么

    2、当然这种写法的话就必须满足:列表里面只有一个字典满足条件(dict["C"] == "6"),如果有多个字典满足条件那么就又有问题了

    例17:

    dict = [{"A":"1","B":"2","C":"3"},{"A":"4","B":"5","C":"6"},{"A":"7","B":"8","C":"6"}]
    
    def func(data):
        for eachDict in data:
            print("---",eachDict)
            if eachDict["C"] == "6":
                return eachDict
        else:
            return False
    
    result = func(dict)
    print(result)
    
    """
    --- {'B': '2', 'C': '3', 'A': '1'}
    --- {'B': '5', 'C': '6', 'A': '4'}
    {'B': '5', 'C': '6', 'A': '4'}
    字典中有两个符合条件,但只返回了一个
    """


    例17_1:

    """
    需求:
    遍历传入的列表(嵌套了字典的列表)
        ⑴如果列表中的某些字典的"C"键值符合要求(这里是dict["C"] == "6"),则将其加到一个列表中并返回这个列表
        ⑵如果列表中的所有字典的"C"键值都不符合要求(这里是dict["C"] == "6"),则返回False
    
    """
    dict = [{"A":"1","B":"2","C":"3"},{"A":"4","B":"5","C":"6"},{"A":"7","B":"8","C":"6"}]
    
    resultList = []
    def func(data):
        for eachDict in data:
            print("---",eachDict)
            if eachDict["C"] == "6":
                resultList.append(eachDict)
        #else:    #这个时候else就不能在这里写else了,这样写的话return resultList就没意义了(因为不管怎么都会执行else)
            #return False
        return resultList
    
    result = func(dict)
    print(result)
    """
    --- {'C': '3', 'B': '2', 'A': '1'}
    --- {'C': '6', 'B': '5', 'A': '4'}
    --- {'C': '6', 'B': '8', 'A': '7'}
    [{'C': '6', 'B': '5', 'A': '4'}, {'C': '6', 'B': '8', 'A': '7'}]
    """

    注:
    1、如果要实现这个需求的话,肯定就不能按照上面这里例子这样来写了,因为这些写的话是不能同时满足需求1和需求2的,因此只能换一个思路来实现

    2、思路:因为要把满足条件的字典添加到列表中,如果for循环全部完成之后,对列表进行判断,如果列表还是空列表的话,说明所有字典都不满足条件,这个时候就可以返回False了

    例17_2:

    """
    需求:
    遍历传入的列表(嵌套了字典的列表)
        ⑴如果列表中的某个字典的"C"键值符合要求(这里是dict["C"] == "6"),则将其加到一个列表中并返回这个列表
        ⑵如果列表中的所有字典的"C"键值都不符合要求(这里是dict["C"] == "6"),则返回False
    
    """
    dict = [{"A":"1","B":"2","C":"3"},{"A":"4","B":"5","C":"6"},{"A":"7","B":"8","C":"6"}]
    
    
    def func(data):
        resultList = []
        for eachDict in data:
            print("---",eachDict)
            if "C" in eachDict and eachDict["C"] == "6": #判断"C"键在字典中并且"C"键值为6
                resultList.append(eachDict)
        if resultList:
            return resultList
        else:
            return False
    result = func(dict)
    print(result)
    
    """
    --- {'C': '3', 'B': '2', 'A': '1'}
    --- {'C': '6', 'B': '5', 'A': '4'}
    --- {'C': '6', 'B': '8', 'A': '7'}
    [{'C': '6', 'B': '5', 'A': '4'}, {'C': '6', 'B': '8', 'A': '7'}]
    """

    例11_3:

    dict = [{"A":"1","B":"2","C":"3"},{"A":"4","B":"5","C":"1"},{"A":"7","B":"8","C":"1"}]
    
    
    def func(data):
        resultList = []
        for eachDict in data:
            print("---",eachDict)
            if "C" in eachDict and eachDict["C"] == "6": #判断"C"键在字典中并且"C"键值为6
                resultList.append(eachDict)
        if resultList:
            return resultList
        else:
            return False
    result = func(dict)
    print(result)
    
    """
    --- {'B': '2', 'A': '1', 'C': '3'}
    --- {'B': '5', 'A': '4', 'C': '1'}
    --- {'B': '8', 'A': '7', 'C': '1'}
    False
    """

    注:
    1、Python中的for循环提供了python中最强大的循环结构(for循环是一种迭代循环机制,而while循环是条件循环,迭代即重复相同的逻辑操作,每次操作都是基于上一次的结果,而进行的)

    2、Python for循环可以遍历任何序列的项目,如一个列表或者一个字符串
        ⑴for循环可以用来遍历某一对象(遍历:通俗点说,就是把这个循环中的第一个元素到最后一个元素依次访问一次)
        ⑵一般来说for循环的执行过程为:迭代出一个元素后,继续执行for循环所属代码块,后面的代码块(属于for循环代码块的代码)执行完后,在进行下一个迭代。所有元素遍历完成后,再执行与for循环同一层级的代码
        ⑶比如这个例子中的for循环与if...else处于相同缩进的,是并列关系的(同一代码块),因此会执行完for循环后再执行if...else

    3、当return语句用在for循环、while循环中时,一定要注意return的使用位置啊!!!

    例12:

    infos= [{'code': '1005', 'value': '测试1'}, {'code': '10051', 'value': '测试2'},{ 'code': None,'value': '测试3'}]
    
    def Parse(data):
        DataCodeList = []
        for info in data:
            if info["code"] == None:
                print("===数据中无code属性,直接返回value值===:",info["value"])
                DataCode = info["value"]
                #DelyCodeList.append(DelyCode)
            else:
                if info["code"] == '1005':
                    print("===数据中code属性且其值为1005,返回指定值:Success")
                    DataCode = "Success"
                    #DelyCodeList.append(DelyCode)
                else:
                    print("===数据中code属性且其值不为1005,返回指定值:Fail")
                    DataCode = "Fail"
                    #DelyCodeList.append(DelyCode)
            #这里主要是想说明下:DelyCodeList.append(DelyCode)放在这里(if...else...语句结束后)跟放在每个判断条件里面是一样的
            #不管输入的info满足那个条件,在判断完后继续往下执行,都会执行这步(都在for循环内)。当然如果上面判断结果有不需要加入到列表中的,就不能写在这里了
            DataCodeList.append(DataCode)
        #for循环结束后,根据前面输出的DelyCodeList中元素个数来确定是否需要拼接列表里面的元素
        if len(DataCodeList) > 1:
            DelyCode = {"info":",".join(DataCodeList)}
            return DelyCode
        else:
            DelyCode = {"info":DataCodeList[0]}
            return DelyCode
    
    DelyCode = Parse(infos)
    print(DelyCode)
    
    """
    ===数据中code属性且其值为1005,返回指定值:Success
    ===数据中code属性且其值不为1005,返回指定值:Fail
    ===数据中无code属性,直接返回value值===: 测试3
    {'info': 'Success,Fail,测试3'}
    """

    例12_1:

    data = [{"A":"1","B":"2","C":"hello"},{"A":"4","B":"5","C":"world"}]
    
    def func(data):
        new_list = []
        for each_dict in data:
            if isinstance(each_dict,dict):
                new_dict = {}
                for key,value in each_dict.items():
                    if key == "C":
                        new_dict[key] = value.upper()
                    else:
                        new_dict[key] = value
                new_list.append(new_dict)
            else:
                raise TypeError("传入数据类型错误")
        # 必须在这里return
        return new_list
    
    print(func(data))
    
    #[{'C': 'HELLO', 'A': '1', 'B': '2'}, {'C': 'WORLD', 'A': '4', 'B': '5'}]
    

    例12_2:

    import datetime
    
    
    def DealSelectData(selectDatas):
        # 定义一个大列表来装所有子数据列表:是一个嵌套了列表的列表
        selectDataLists = []
        for selectData in selectDatas:
            # 定义一个小列表来装该条数据
            selectDataList = []
            for eachData in selectData:
                # 如果字段值为整形、浮点型、字符串:那么不需要整理,直接加入到该条数据列表中
                if isinstance(eachData, int) == True or isinstance(eachData, str) == True or isinstance(eachData,float) == True:
                    pass
                    # selectDataList.append(eachData)
                # 如果字段值为datetime类型:那么就将其转为字符串型的时间值
                elif isinstance(eachData, datetime.datetime):
                    eachData = eachData.strftime('%Y-%m-%d %H:%M:%S')
                    # selectDataList.append(eachData)
                # 如果字段值为None:那么就添加null,毕竟数据库中空值表示为null
                elif eachData is None:
                    eachData = "null"
                    # selectDataList.append("null")
                else:
                    print("该类型的值未整理:请添加相应代码")
                # 这里想说明下append()语句放在这里与放在每个判断条件中是一样的:都是内循环语句块内(前提条件是每个判断后都会有添加到列表的操作)
                # 将处理后的元素加到小列表中
                selectDataList.append(eachData)
            # 将小列表添加到大列表中
            selectDataLists.append(selectDataList)
        print("整理后的查询数据为:", selectDataLists)
        return selectDataLists
    
    
    data = [(1, '张三', 'China', datetime.datetime(2020, 9, 10, 20, 34, 23),
             datetime.datetime(2020, 7, 20, 20, 34, 25, 269000), 1, 4, 2, 2424),
            (
            2, '李四', 'China', datetime.datetime(2022, 7, 5, 20, 34, 58), datetime.datetime(2020, 7, 19, 12, 35, 1), 2, 2, 3,
            7747),
            (3, '王五', 'China', datetime.datetime(2020, 7, 20, 21, 18, 16), datetime.datetime(2020, 7, 20, 21, 18, 16), 2, 3,
             4, 4242)]
    
    DealSelectData(data)
    """
    整理后的查询数据为: [[1, '张三', 'China', '2020-09-10 20:34:23', '2020-07-20 20:34:25', 1, 4, 2, 2424], 
    [2, '李四', 'China', '2022-07-05 20:34:58', '2020-07-19 12:35:01', 2, 2, 3, 7747], 
    [3, '王五', 'China', '2020-07-20 21:18:16', '2020-07-20 21:18:16', 2, 3, 4, 4242]]
    """

    注:
    经for循环遍历出来一个元素后,使用该元素将该for循环下所属全部语句都执行完后才会继续遍历出下一个元素,下一个元素遍历出来后继续将该for循环下所属全部代码执行一次
        ⑴selectDataList.append(eachData):这条语句是属于内循环且是内循环的最后一条语句。因此,每个遍历出来的元素经过if语句判断后,都会执行这条语句,这条语句执行完成后才会遍历下一个元素
        ⑵selectDataLists.append(selectDataList):这条语句与内循环一样,都是属于外循环的(与内循环同一缩进)。在内循环执行完成后,继续执行这条语句。这条语句执行完成后才会遍历下一个元素
        ⑶外循环执行一次,内循环要全部执行完成:外循环遍历出来一个元素,这个元素经内循环继续遍历。需要内循环将这个元素全部遍历完成后,才会开始下一个外循环
        ⑷不管是什么循环,在循环执行完成后,代码继续往下执行:(除了特殊逻辑,代码都是由上往下执行的:注意缩进)

    python嵌套字典中, 通过key值获取所有的对应的value值

    1、有时候面对一些需要处理的数据, 会是一种字典中嵌套字典的数据, 然后里面可能有多个key相同的value都是需要获取的, 比如json中的部分值

    2、key对应的value的类型有很多, 比如有可能是str的‘abc’, 也有可能是int的123, 也有可能是dict的{‘1’: 123}还有可能是list的[1, 2, 3]

    3、大概思路是迭代当前dict的所有元素, 对元素挨个依次比较key与所需要的key, 如果相同就保存在输出的list中。然后如果遇到value是属于又一个dict, 则进行一个回归, 再次对这个子dict进行相同操作. 最后循环结束后输出list

    例13:

    data = {
        "2": {
            "a": [
                11111,
                22222
            ]
        },
        "3": ["2",2,3],
        "b": 1,
        "a": "ok1"
    }
    def get_json_value_by_key(in_json, target_key, results=None):
        """
        results这个列表不能定义在函数内:不然每次回调时,会重置
        因此只能定义为默认参数,但是默认参数为可变对象时,前面的调用结果会影响后面的结果,因此采用这种写法
        """
        if results == None:
            results = []
        if isinstance(in_json, dict):  # 如果输入数据的格式为dict
            for key in in_json.keys():  # 循环获取key
                # 如果当前key与目标key相同就将当前key的value添加到输出列表
                if key == target_key:
                    results.append(in_json[key])
                # 不管当前key与目标key是否相同:都要继续回调(继续获取里面的值)
                    get_json_value_by_key(in_json[key], target_key, results=results)  # 回归当前key对于的value
                else:
                    get_json_value_by_key(in_json[key], target_key, results=results)
    
        elif isinstance(in_json, list):  # 如果输入数据格式为list
            for data1 in in_json:  # 循环当前列表
                get_json_value_by_key(data1, target_key, results=results)  # 回归列表的当前的元素
    
        return results
    a = get_json_value_by_key(data, '2')
    print(a)
    b = get_json_value_by_key(data, '3')
    print(b)
    c = get_json_value_by_key(data, 'a')
    print(c)
    d = get_json_value_by_key(data, 'b')
    print(d)
    
    """
    [{'a': [11111, 22222]}]
    [['2', 2, 3]]
    ['ok1', [11111, 22222]]
    [1]
    """

    展开全文
  • python中while循环和for循环的用法

    千次阅读 2014-12-26 16:01:16
    一、while循环 1、一般格式 格式:首行以及测试表达式,有一列或多列缩进语句的主体以及一个选用的else部分(控制权离开循环时而没有碰到break语句时会执行) python会一直计算开投的测试,然后执
  • for循环和while循环 一、两者的相同点在于都能循环做⼀件重复的事情。 二、不同点在于for循环是在序列穷尽时停⽌,while循环是在条件不成⽴时停⽌,while循环之前,先判断⼀次,如果满⾜条件的话,再循环,for...
  • for循环与while循环的不同

    千次阅读 2020-02-11 20:16:36
    这里写自定义目录标题for循环的一般结构for循环的一般结构为:它的执行过程如下:若上述代码用while循环来等效,则代码为:请看如下两例代码:输出结果为:输出结果为:总结 for循环的一般结构 for循环的一般结构为...
  • 相同的食物从不同的角度理解,九可以得到不同的结论。循环结构还可以理解为:在给定的条件成立时,反复地执行相应的程序,直到给定的条件不成立为止。  循环语句也可以分为两大类:一类是入口循环语句,一类是结束...
  • Python——while和for循环

    万次阅读 2015-11-18 18:05:26
    本文介绍了while和for循环,介绍了循环语句中break、continue、pass和循环else语句的用法,重点介绍了for循环的细节,包括在循环中进行元祖赋值、扩展解包赋值。最后介绍了几种常用的工具:range、zip、map...
  • Kotlin编程:if语句,while循环,when表达式,for循环
  • for循环与while循环的区别

    万次阅读 2017-10-17 21:21:11
     * 一个需求:使用for循环和while循环都可以去实现,那么到底两者之间有什么区别?  * 从内存角度考虑:  * 局部变量在栈内存中存在,当for循环语句结束,那么变量会及时被gc(垃圾回收器)及时的释放掉,不浪费空间 ...
  • 也就是其初值是什么(2)循环的控制条件是什么(题目中给出的条件往往是反的)(3)需要反复做什么(4)如何过渡到下一次循环如:求100以内的各位数之for(int i=1;i&lt;=100;i++){sum+=i;}但是for循环的优势...
  • python的while和for循环

    千次阅读 2015-02-22 11:31:41
    一、while循环 1、一般格式 格式:首行以及测试表达式,有一列或多列缩进语句的主体以及一个选用的else部分(控制权离开循环时而没有碰到break语句时会执行) python会一直计算开投的测试,然后执
  • 在循环次数已知的情况下使用for循环,且所有for循环均可用while循环实现。 while循环 在给定的条件为true时执行循环体,否则退出循环体。在循环次数未知是使用while循环。 嵌套循环 循环体中嵌套...
  • Java循环for, while和do...while

    万次阅读 2016-08-21 11:39:11
    可能存在一种情况,当我们需要执行的代码块数次,并且通常被称为一个循环。 Java有非常灵活的三循环机制。可以使用以下三种循环之一: while 循环 ...for 循环 ...从Java5,增强的for循环中进行了...while循环的语法是
  • python(for循环,while循环及字符串的使用)

    万次阅读 多人点赞 2019-06-23 17:40:43
    for循环 for i in range(10): 求阶乘 #输出 a = int(input('请输入一个值:')) #阶乘控制单位 total = 1 #求阶乘 for i in range(1,a+1,1): ##起始值为1,终止符为a+1,间隔为1求阶乘 total *= i print...
  • while(){}结构 #include "stdio.h" void main() { int i=1,sum=0; while (i<=5) { sum+=1; i++; } printf("结果为%d",sum); } do {}while();结构 #include "stdio.h" void main()...
  • Python for-in循环与while循环效率比较

    千次阅读 2019-05-12 08:27:53
    在一个群里与大家学习python,群里讨论起了for循环和while循环的效率问题。当时有点好奇,因为从接触编程以来就没有考虑过这个问题,所以自己亲自进行了测试,并找了一些网上的资料。但是本文主要还是娱乐向为主,...
  • C语言循环语句:while、do...whilefor

    千次阅读 2018-07-04 20:47:29
    1)简单介绍一下C语言的三个循环语句:while循环有两种while循环使用:一种是不带{}(语句块),一种的带{}(语句块)不带语句块的: while(表达式) 执行语句带语句块的: while(表达式) { 执行语句 } do...while循环...
  • 首先你要确定for和while里面的各个字段分别表示什么含义: Python 中的循环语句有 2 种,分别是 while 循环和 for 循环 for 循环语句的执行流程如图 1 所示。 for 循环语句的执行流程图 图 1 for 循环语句的执行...
  • IOS学习第7天do-while循环 ...注意:do-while循环最后面必须有一个分号2.do-while循环结构while结构的最大区别:while:当型循环do-while:直到型循环,傻瓜式循环无论如何,do-while 至少会执行一次//while int main()
  • 文章目录1. 无限循环while(1)和for(;;)区别1.1 结论:性能相同1.2 验证1.2.1 编写两个文件for.c和while.c1.2.2 生成汇编...while(1),每循环一次都要判断常量1是不是等于零,在这里whilefor多做了这事。 gcc ver
  • C++ whiledo while循环

    万次阅读 2017-02-07 12:43:33
    顺序结构、选择结构和循环结构是结构化程序设计的3种基本结构,是各种复杂程序的基本构造单元。因此程序设计者必须熟练掌握选择结构和循环结构的概念及使用方法。 用while语句构成循环 while语句的一般形式如下: ...
  • 循环 While与for循环 2.1while 循环 2.1.1 while循环的语法(又称之为条件循环) while 条件: 代码1 代码2 代码3 。。。。 2.1.2 while+break,break的意思是结束本层循环 2.1.2 while+continue,continue的意思...
  • 第五章 while循环与do-while循环的异同

    千次阅读 2017-04-09 16:06:00
    相同点: while与do-while都是循环结构,使用"while(循环条件)"表示循环条件,使用大括号将循环操作括起来. 不同点: 1. 语法不同; do{  循环体 }while(循环条件); while(循环条件){  循环体 } 2. 执行次序...
  • forwhile循环的区别

    2017-03-21 11:54:13
    假设将一个球从100m高度自由落下,每次落地后反弹回原高度的一半,再落下,再反弹,求该球一共被弹起几次。
  • 范型for循环: -- print all values of array 'a' a={1,2,3,4,5,6,7}; for i,v in ipairs(a) do print(v) end 范型for遍历迭代子函数返回的每一个值。 再看一个遍历表key的例子: -- print all keys of table ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 208,932
精华内容 83,572
关键字:

while循环和for循环的相同点