for循环和可迭代对象遍历

for循环通常用于可迭代对象的遍历。for 循环的语法格式如下:

for变量in 可迭代对象 :

循环体语句

[操作]遍历一个元组或列表

for x in (20,30,40):
print(x*3)

可迭代对象

Python包含以下几种可迭代对象:

1.序列。包含:字符串、列表、元组

2.字典

3.迭代器对象( iterator )

4.生成器函数( generator )

5.文件对象

range对象

range对象是一个迭代器对象,用来产生指定范围的数字序列。格式为:

range(start, end [step])

生成的数值序列从start开始到end结束(不包含end )。若没有填写start ,则默认从0开始。step 是可选的步长,默认为1。如下是几种典型示例:

for i in range(10)          产生序列:0123456789

for i in range(3,10)          产生序列:3456789

for i in range(3,10,2) 产生序列:3579

嵌套循环

一个循环体可以嵌入另一个循环体，一般称为嵌套循环，或者多重循环

操作利用嵌套循环打印九九乘法表

for m in range(1,10):
    s = " "
    for n in range(1,m+ 1): 
        s += str.format("{0}*{1}= {2}\t",m,n,m*n)
    print(s)

break语句

break语句可用于while和for循环,用来结束整个循环。当有嵌套循环时, break语句只能跳出最近一层的循环。

continue语句

continue语句用于结束本次循环,继续下一次。多个循环嵌套时, continue也是应用于最近的一层循环。

else语句

while. for 循环可以附带一个 else语句(可选)。如果for. while 语句没有被break语句结束,则会执行else子句,否则不执行。语法格式如下:

while条件表达式 :                           for变量in 可迭代对象 :

        循环体                                             循环体

else:                                               else:

        语句块                                             语句块

循环代码优化

虽然计算机越来越快,空间也越来越大,我们仍然要在性能问题上“斤斤计较”。编写循环时,遵守下面三个原则可以大大提高运行效率,避免不必要的低效计算:

1.尽量减少循环内部不必要的计算

2.嵌套循环中,尽量减少内层循环的计算,尽可能向外提。

3.局部变量查询较快,尽量使用局部变量

使用zip()并行迭代

我们可以通过zip0函数对多个序列进行并行迭代, zip0函数在最短序列"用完”时就会停止

[操作]测试zip0并行迭代

names = ("老大",' 老二","老三","老四")
ages = (18,16,20,25)
jobs = ("老师","程序员","公务员")

for name,age.job in zip(names,ages,jobs):
    print("{0}-{1}-{2}".format(name,age,job))

推导式创建序列

推导式是从一个或者多个迭代器快速创建序列的一种方法。它可以将循环和条件判断结合，从而避免冗长的代码。推导式是典型的Python风格。

列表推导式

列表推导式生成列表对象,语法如下:

                                [表达式      for item in 可迭代对象]

        或者: {表达式      for  item  in  可迭代对象   if   条件判断}

>>> [x for x in range(1,5)]

[1, 2,3, 4]

字典推导式

字典的推导式生成字典对象,格式如下:

{key_ expression : value_ expression        for表达式in 可迭代对象}

类似于列表推导式,字典推导也可以增加if条件判断、多个for循环。

集合推导式

集合推导式生成集合,和列表推导式的语法格式类似:

                                {表达式        for item in 可迭代对象}

                      或者: {表达式        for item in 可迭代对象if 条件判断}

生成器推导式（生成元组）

提示是一个生成器对象，显然元组是没有推导式的

>>> (x forx in range(1,100) if x%9==0)
< generator object < genexpr> at 0x0000000002BD3048>

一个生成器只能运行一次。 第一次迭代可以得到数据,第二次迭代发现数据已经没有了.

>>> gnt = (x for x in range(1,100) if x%9==0)
>>> for X in gnt:
    print(x,end='')
9 18 27 36 45 54 63 72 81 90 99
>>> for X in gnt:
    print(x,end=' ')
>>>

函数

函数基本概念

1.一个程序由一个个任务组成;函数就是代表一个任务或者一个功能。

2.函数是代码复用的通用机制。

python函数分类

1.内置函数

        我们前面使用的str(). list()、 len(等这些都是内置函数,我们可以拿来直接使用。

2.标准库函数

        我们可以通过import语句导入军,然后使用其中定义的函数

3.第三方库函数

        Python社区也提供了很多高质量的库。下载安装这些库后,也是通过import语句导入，然后可以使用这些第三方库的函数

4.用户自定义函数

用户自己定义的函数,显然也是开发中适应用户自身需求定义的函数。

函数定义和调用

核心要点

Python中,定义函数的语法如下:

        def函数名([参 数列表]) :

        "文档字符串"

        函数体/若干语句

要点:

1.我们使用def来定义函数,然后就是一个空格和函数名称：

        (1) Python 执行def时,会创建一个函数对象 ,并绑定到函数名变量上。

2.参数列表

        (1)圆括号内是形式参数列表,有多个参数则使用逗号隔开

        (2)形式参数不需要声明类型,也不需要指定函数返回值类型

        (3)无参数,也必须保留空的圆括号

        (4)实参列表必须与形参列表一对应

3. return 返回值

4.调用函数之前,必须要先定义函数,即先调用def创建函数对象

        (1)内置函数对象会自动创建

        (2)标准库和第三方库函数,通过import导入模块时,会执行模块中的def语句

形参和实参

[操作]定义一个函数.实现两个数的比较,并返回较大的值。

def printMax(a,b):
   '''实现两个数的比较,并返回较大的值'''
    if a>b:
        print(a,"较大值")
    else:
        print(b,"较大值")


printMax(10,20)
printMax(30,5)

        上面的printMax函数中,在定义时写的printMax(a,b)。a和b称为“形式参数”，简称“形参" .也就是说,形式参数是在定义函数时使用的。形式参数的命名只要符合“标识符”命名规则即可。

        在调用函数时,传递的参数称为“实际参数”,简称“实参”。上面代码中 .printMax(10,20) , 10和20就是实际参数。

返回值

return返回值要点:

        1.如果函数体中包含return语句,则结束函数执行并返回值;

        2.如果函数体中不包含return语句,则返回None值。

        3.要返回多个返回值,使用列表、元组、字典、集合将多个值“存起来”即可。

[操作]定义一个返回两个数平均值的函数

def my_avg(a,b):
    return (a+b)/2
    
#如下是函数的调用
c = my_avg(20,30)
print(c)

        

for 循环语句的一般形式为：

for (表达式1; 表达式2; 表达式3)
{
        语句;
}

首先要强调两点：
1) 表达式1、表达式2和表达式3之间是用分号;隔开的，千万不要写成逗号。

2) for(表达式1；表达式2；表达式3)的后面千万不要加分号，很多新手都会犯这种错误——会情不自禁地在后面加分号。

因为 for 循环只能控制到其后的一条语句，而在C语言中分号也是一个语句——空语句。所以如果在后面加个分号，那么 for 循环就只能控制到这个分号，下面大括号里面的语句就不属于 for 循环了。

下面来看看它的执行过程：

求解表达式1。
求解表达式2。若其值为真，则执行 for 语句中指定的内嵌语句，然后执行第3步；若表达式2值为假，则结束循环，转到第5步。
求解表达式3。
转回上面第2步继续执行。
循环结束，执行 for 语句下面的语句。

从这个执行过程中可以看出，“表达式1”只执行一次，循环是在“表达式2”“表达式3”和“内嵌语句”之间进行的。

for语句最简单的形式是：

for (循环变量赋初值; 循环条件; 循环变量增值)
{
    语句;
}

下面给大家写一个程序，求 1+2+3+4+…+100 的总和。

# include <stdio.h>
int main(void)
{
    int i;
    int sum = 0;  //sum的英文意思是“总和”
    for (i=1; i<=100; ++i)  //++是自加的意思, ++i相当于i = i + 1
    {
        sum = sum + i;  /*等价于sum += i;但是不建议这么写, 因为sum = sum + i看起来更清楚、更舒服*/
    }
    printf("sum = %d\n", sum);
    return 0;
}

输出结果是：
sum = 5050

这个程序的功能是实现求 1+2+3+4+…+100 的和，如果不用循环，加一次就要一条语句，加 100 次就要 100 条语句。这里是从 1 加到 100，要是从 1 加到 10000 那就要 10000 条语句。但有了循环就很方便了，你想加到多少就加到多少，只要改一个参数就可以了。所以循环很重要。

下面按照执行过程看看上面这个程序是怎样执行的。

1) 首先定义一个循环变量 i。定义的时候可以不给它赋初值，在 for 循环里面再给它赋初值也行。但前面说过，最好在定义变量的时候就对它进行初始化，如果值不确定就初始化为 0。所以程序中也可以在定义 i 的时候就给它赋初值，那么 for 循环里的“表达式1”就可以省略了，但分号不可以省略。

这样的话，执行的时候就跳过第1步，直接进入第2步，其他的不变。所以程序也可以像下面这样写：

# include <stdio.h>
int main(void)
{
    int i = 1;
    int sum = 0;
    for (; i<=100; ++i)
    {
        sum = sum + i;
    }
    printf("sum = %d\n", sum);
    return 0;
}

当然表达式1加上也行，大不了再重新赋一次值。

2) 然后定义一个用来存放“和”的变量 sum，并给它赋初值 0，然后进入 for 循环：

首先求解表达式1，即给变量i赋初值，i=1;表达式1只执行这一次，下面都不会再执行了。
然后求解表达式2，若 1<=100 成立，则执行 for 循环中的内嵌语句，即 sum=0+1。
然后执行第3步，变量 i 自加 1，即变量 i 由 1 变为 2。
然后再求解表达式2，2<=100 成立，则执行 for 循环中的内嵌语句，sum=0+1+2。
然后再执行第3步，变量 i 自加 1，即变量 i 由 2 变为 3。
然后再求解表达式2，即 3<=100 成立，则执行 for 循环中的内嵌语句，sum=0+1+2+3。
……

就这样一直循环下去，直到 ++i 等于 100 的时候，求解表达式2，即 100<=100 成立，则执行 for 循环中的内嵌语句，sum=0+1+2+3+…+100。

然后再执行第3步，变量 i 自加 1，即变量 i 由 100 变为 101。然后再求解表达式2，即 101<=100 不成立，则结束循环，执行 for 循环下面的语句即 printf。

以上就是这个程序的执行过程。关于 for 语句的代码规范化问题，有两点要再跟大家强调一下：
1）if、else、for、while、do 都只能控制到其后的一条语句，如果要控制多条语句必须加大括号{}。但基于代码规范化，if、else、for、while、do 后面的执行语句不论有多少行，就算只有一行也要加{}。

2) 像 if、for、while 等关键字之后应留一个空格再跟左括号(，以突出关键字。

此外上面的程序还有一个知识点要跟大家说一下：从功能上讲，for(i=1; i<=100;++i)完全可以写成for(i=1; i<101; ++i)，而且建议大家尽量使用这种写法。也就是说，循环语句的循环条件尽量写成半开半闭的，不管是 for 循环还是 while 循环。

for(i=1; i<101; ++i)实际上是 1≤i<101，是半开半闭的；而for(i=1; i<=100; ++i)实际上是 1≤i≤100，是全闭的。那么为什么建议使用半开半闭的呢？因为如果写成 i<=100 的话，那么每次判断的时候都要判断两次，即 i<100 和 i==100，而写成 i<101 的话每次只需要判断一次。

也许有人说：程序在执行 i<=100 的时候不是将它转换成 i<100||i==100 吗？这样由“短路或”的知识可知，如果前面的为真那么后面的不就不会执行了吗？这样不也是判断一次吗？不是这样的，系统是不会将 i<=100 转换成 i<100||i==100 的，每次判断的时候 i<100 和 i==100 都要判断。

但是写成半开半闭也有一个问题，就是会影响对代码的理解。有时候写成全闭的区间理解起来才顺畅，而写成半开半闭反而不易理解，比如<=右边是变量或表达式的时候。这时候要以可读性为第一要素，即哪种好理解就使用哪种。现在 CPU 速度那么快，也不在乎那点效率。所以前面说“尽量”，没有要求一定要那样写。

下面再给大家写一个程序，求 1 到 100 之间所有奇数的和。

# include <stdio.h>
int main(void)
{
    int i;
    int sum = 0 ;
    for (i=1; i<100; i+=2)  //i+=2;等价于i = i + 2;
    {
        sum = sum + i;
    }
    printf("sum = %d\n", sum);
    return 0;
}

输出结果是：
sum = 2500

关于自增和自减

一直以来，++ 和 –– 语法浪费了太多人的时间。说句实在话，++ 和 –– 在C语言中根本就不重要，除了表达简练外，真的没有什么其他好处了。

简单地说：++i 和 i++ 在单独使用时，都表示 i=i+1；––i 和 i–– 在单独使用时，都表示 i=i–1。

而 a=++i 就相当于 i=i+1，a=i；a=i++ 就相当于 a=i，i=i+1。
同理，a=––i 就相当于 i=i–1，a=i；a=i–– 就相当于 a=i，i=i–1。

如果实在搞不明白 ++ 和 –– 是怎么回事，那也不是什么天塌下来的事情。因为a=++i;完全可以写成i++; a=i;。而a=i++;也完全可以写成a=i; i++;。而且，这也是一种很好的程序风格。

作为一个优秀的程序员，在你的程序中就不应该体现出 ++i 和 i++ 的区别，要么都用 ++i，要么都用 i++，不要一会儿用 ++i 一会儿用 i++。

对于自增和自减还有一点需要强调的是：只有“变量”才能进行自增和自减！你认为 3++ 等于多少？C语言中没有这种写法，常量是不能进行自增和自减的。

for循环练习

1) 求 1! + 2! + 3! + ... + n!

# include <stdio.h>
int main(void)
{
    int n = 0;
    int i = 0;
    int m = 1;
    int sum=0;
    printf("请输入n的值:");
    scanf("%d", &n);
    for (i=1; i<=n; ++i)
    {
        m = m * i;
        sum = sum +m;
    }
    printf ("sum = %d\n", sum);
    return 0;
}

这个程序虽然短，但逻辑性很强，算法很好，所以建议读者记住。因为逻辑性强，所以只看是很难明白的，自己在纸上试一下，将自己当成计算机一步步地计算就明白了。
 

假如 n=4：

当 i=1 时，m=1，sum=1。
当 i=2 时，m=1×2，sum=1+1×2。
当 i=3 时，m=1×2×3，sum=1+1×2+1×2×3。
当 i=4 时，m=1×2×3×4，sum=1+1×2+1×2×3+1×2×3×4。

看出规律来了吗？m 的值是一直往下乘，乘以 i 之前 m 的值是（i–1）的阶乘，乘以 i 之后 m 的值就是 i 的阶乘了。这样 i 循环到多少，m*i 就立刻将这个数的阶乘计算出来，然后加到 sum 中。

2) for 和 if 的嵌套使用。求 1 到 100 之间所有能被 3 整除的数之和。

# include <stdio.h>
int main(void)
{
    int i;
    int sum = 0;
    for (i=3; i<100; ++i)
    {
        if (0 == i%3)
        {
            sum = sum +i;
        }
    }
    printf("sum = %d\n", sum);
    return 0;
}

输出结果是：
sum = 1683

大家想想如果不用 if，这个程序能不能写出来？当然能，能被 3 整除的数肯定是 3 的倍数，只要 i 每次自加 3 就行了。我们将这个程序写一下：

# include <stdio.h>
int main(void)
{
    int i;
    int sum = 0;
    for (i=3; i<100; i+=3)
    {
        sum = sum +i;
    }
    printf("sum = %d\n", sum);
    return 0;
}

因为 ++i 每次只加 1，而 i+=3 每次加 3，所以这种写法与第一种写法比较起来计算机少执行很多步，所以执行起来更快。由此可知，完成相同的功能，算法不一样则效果就不一样。对计算机而言当然是执行得越快越好。

3) 编写程序，输出 1~1000 之间所有的完全平方数。

# include <stdio.h>
# include <math.h>  //要用sqrt()
int main(void)
{
    int i;  //循环变量
    int x;  //存储每个数的二次方根
    for (i=1; i<1000; ++i)
    {
        x = sqrt(i);  /*如果i不是完全平方数, 那么sqrt(i)肯定是小数, 而i是int型, 所以x是sqrt(i)取整后的值, 这样x*x肯定不等于i*/
        if (x*x == i)
        {
            printf("%d\t", i);  // \t是跳到下一个Tab位置
        }
    }
    printf("\n");
    return 0;
}

输出结果是：

1       4       9       16      25      36      49      64      81    100
121     144     169     196     225     256     289     324     361   400
441     484     529     576     625     676     729     784     841   900
961

其实这个程序还有更简单的算法，不需要使用 sqrt()。下面将这个程序也写下来：

# include <stdio.h>
int main(void)
{
    int i;  //循环变量
    for (i=1; i*i<1000; ++i)
    {
        printf("%d\t", i * i);  // \t是跳到下一个Tab位置
    }
    printf("\n");
    return 0;
}

输出结果是：

1       4       9       16      25      36      49      64      81    100
121     144     169     196     225     256     289     324     361   400
441     484     529     576     625     676     729     784     841   900
961

 

 写这篇文章，我深有感触，在写代码的过程中，我们经常会出现最后的结果达不到我们预期的效果的情况，我们一定一定要耐下心来，一步一步地去思考，是哪里出了问题，怎么能解决问题，这样的一个过程是十分重要的，是能让我们越来越接近真相的过程。学习编程的路肯定不是一帆风顺的，但我们要有能够克服任何苦难的决心，这是最重要的。 

---

在这篇文章中，我们将会对循环语句有一个更加深入的了解

并且我们还能了解到getchar与putchar的相关知识

  让我们开始吧！

目录

一.while循环 

1.while循环语法 

2.break和continue 在while循环中

(1).break

(2).continue 

3.两个代码的练习

第一个代码

第二个代码

 二.for循环

1.for循环语法 

2. break和continue在for循环中

(1).break

(2).continue 

 continue在for循环和在while循环中有所不同 

三.do...while()循环 

1.do...while()循环的语法

2.break和continue在do...while循环中

(1).break 

(2).continue 

---

---

一.while循环 

1.while循环语法 

while语句又称当型循环语句，其语法为：

while （表达式） 

 循环语句；

其具体执行过程如下：

   （1）计算表达式的值。若为真，则转步骤（2），否则退出循环，执行while的下一条语句

   （2）执行循环语句（即循环体），并返回步骤（1） 

 

 这里试着使用while循环打印1~10的数

#include <stdio.h>
int main()
{
 int i = 1;
 while(i<=10)
 {
    printf("%d ", i);
    i++；
 }
 return 0;
}

2.break和continue 在while循环中

(1).break

#i#include <stdio.h>
int main()
{
   int i = 1;
   while(i<=10)
   {
      if(5 == i)
        break；
      printf("%d ", i);
      i ++;
    }
 return 0;
}

 

运行的结果如图 

总结：

break在while循环中的作用：

其实在循环中只要遇到break，就停止后期的所有的循环，直接终止循环。

所以：while中的break是用于永久终止循环的。 

(2).continue 

如果将刚刚的break换成continue

那么运行的结果又会发生什么变化呢？

#include <stdio.h>
int main()
{
   int i = 1;
   while(i<=10)
   {
      if(5 == i)
        continue；
      printf("%d ", i);
      i ++;
    }
 return 0;
}

4后面的光标在闪动，说明此时程序进入了死循环 

 原因是，与break语句不同，

continue是用于终止本次循环的，也就是本次循环中continue后边的代码不会再执行，而是直接 跳转到while语句的判断部分。进行下一次循环的入口判断

如图中红色框框内的代码在continue的作用下会被跳过，i++不会被执行，所以i就一直为5，进去死循环

3.两个代码的练习

让我们再看两个跟while循环有关的代码，再看之前，我们需要先了解一下getchar和putchar

getchar

在msdn中，我们查找到getchar的解释

int ch = getchar（) ;   //获取字符

printf("%c\n",ch) ;       //打印获取的字符

这里我们会有这样的疑问：我们的 ch 获取的是一个字符，为什么放到int整型里去?

原因有两个：

1. 虽然getchar返回的是个字符，但是字符的存储值是它的 ASCII码值，如 ’a‘对应的ASCII码值就是97
2. getchar读取失败的时候返回EOF，而EOF是-1，是个整数

  

getchar - 获取（输入一个字符）

putchar - 输出一个字符 

 putchar

在msdn中的定义

 int ch = getchar（) ;   //获取字符

putchar （ch）；//输出一个字符

 getchar 和 putchar 可以用scanf 和printf代替，且scanf和printf的功能更全，getchar和putchar只能操作字符 

第一个代码

这个代码会将你输入的字符打印出来，如果想停止：ctrl+z 可以让getchar返回一个EOF

我们写这样的代码有什么意义呢？实际上是有意义的，我们这里再举一个例子

#include <stdio.h>
int main()
{
   char input[20] = { 0 };//创建一个数组
	printf("请输入密码：>");
	scanf("%s", input);
	printf("请确认密码(Y/N):>");
	int ch = getchar();
	if (ch == 'Y')
	{
		printf("确认成功\n");
	}
	else
    {
		printf("确认失败\n");
	 }

	return 0;
}

看这个代码时，可能会有疑问，为什么scanf函数里的input没有取地址，

               是因为数组名本身就是一个地址，所以不需要再取地址

---

   这样一个程序，我们的本意是输入密码后需要用户确认密码是否正确，可当程序走起来后我们发现，在我们还没有输入时，已经打印出了“确认失败”

下面我们就来分析一下程序出问题的原因 ，全部在这张图上了

解决方法 ：把输入缓冲区里scanf没有拿走的\n拿走 ，改进如下

#include <stdio.h>
int main()
{
   char input[20] = { 0 };//创建一个数组
	printf("请输入密码：>");
	scanf("%s", input);
	getchar();   //拿走\n
	printf("请确认密码(Y/N):>");
	int ch = getchar();
	if (ch == 'Y')
	{
		printf("确认成功\n");
	}
	else
    {
		printf("确认失败\n");
	 }

	return 0;
}

 

我们成功了！！！ 

下面是还可能出现的错误的情况：如果密码当中有“ ”（空格)

当用户输入的密码中含有空格时，又出现了刚刚的错误的情况，我们再来分析

我们可以发现这时需要拿走更多的字符，所以我们使用while循环 

while ((tmp = getchar()) != '\n')  //只要不是/n，就说明没拿完，就进入循环
    {
        ;                                             //空语句（什么也不干）
    } 

#include <stdio.h>
int main()
{
   char input[20] = { 0 };//创建一个数组
	printf("请输入密码：>");
	scanf("%s", input);
	int tmp = 0;
	while ((tmp = getchar()) != '\n')//只要不是/n，就说明没拿完，就进入循环
	{
		;//空语句（什么也不干）
	}
     printf("请确认密码(Y/N):>");
	int ch = getchar();
	if (ch == 'Y')
	{
		printf("确认成功\n");
	}
	else
    {
		printf("确认失败\n");
	 }

	return 0;

 我们惊喜地发现，我们又通过改变代码使这个程序执行成功了！

第二个代码

#include <stdio.h>
int main()
{
 int ch=0;
 while ((ch = getchar()) != EOF)
 {
     if (ch < ‘0’ || ch > ‘9’)
        continue;
     putchar(ch);
 }
 return 0;
}

这个代码就比较简单了 就是只打印0~9的数字

但有一点需要说明

这个括号不能少((ch=getchar())!=EOF) 如果少了 ，就不是把获取的字符放进ch和EOF比较了，而是字符直接与EOF比较，不相等就为假，就为0，这时就把0赋给了ch 

 二.for循环

1.for循环语法 

 for循环的语法：

for (表达式1；表达式2；表达式3)

     循环语句；

 表达式1

表达式1为初始化部分，用于初始化循环变量的。

 表达式2

表达式2为条件判断部分，用于判断循环时候终止。

 表达式3

表达式3为调整部分，用于循环条件的调整。

---

这里我们同样也使用for循环来打印一下1~10的数来熟悉一下for循环

#include <stdio.h>
int main()
{
 int i = 0;

 for(i=1; i<=10; i++)
 {
 printf("%d ", i);
 }
 return 0;
}

并且，我们用这个代码为例，来帮助我们理解for循环的流程图

现在我们对比一下for循环和while循环

int i = 0;
//实现相同的功能，使用while
i=1;//初始化部分
while(i<=10)//判断部分
{
 printf("hehe\n");
 i = i++;//调整部分
}
//实现相同的功能，使用while
for(i=1; i<=10; i++)
{
 printf("hehe\n");
}

可以发现在while循环中依然存在循环的三个必须条件，但是由于风格的问题使得三个部分很可能偏离 较远，这样查找修改就不够集中和方便。所以，for循环的风格更胜一筹。 for循环使用的频率也最高。 

2. break和continue在for循环中

我们发现在for循环中也可以出现break和continue，他们的意义和在while循环中是一样的。

但是还是有些差异：

(1).break

可见，break在for循环中与在while循环中类似，都是直接终止循环 

(2).continue 

#include <stdio.h>
int main()
{
 int i = 0;
 for(i=1; i<=10; i++)
 {
 if(i == 5)
 continue;
 printf("%d ",i);
 }
 return 0;
}

 continue在for循环和在while循环中有所不同 

这里执行起来并不是死循环了，而是跳过5打印了1 2 3 4 6 7 8 9 10

          当i==5时，执行continue语句，跳过printf语句 ，执行 i++,之后 i为6，i==5为假，continue语句不再执行 

---

for语句的循环控制变量 （作为补充）

一些建议：

1.  不可在for 循环体内修改循环变量，防止 for 循环失去控制。
2.  建议for语句的循环控制变量的取值采用“前闭后开区间”写法。 

int i = 0;
//前闭后开的写法
for(i=0; i<10; i++)
{}
//两边都是闭区间
for(i=0; i<=9; i++)
{}

第一种也就是前闭后开的写法很直观，这个循环要循环10次（但不是总是如此） 

一些for循环的变种 

#include <stdio.h>
int main()
{
 //变种1
 for(;;)
 {
 printf("hehe\n");
 }
 //变种2
 int x, y;
    for (x = 0, y = 0; x<2 && y<5; ++x, y++)
   {
        printf("hehe\n");
   }
 return 0;
}

变种1

 for的初始化，判断，调整三个部分都可以省略

 中间的判断部分如果省略，意味着判断恒为真，就构成死循环

如果条件允许，不建议省略for循环的3个表达式 

这里看一个嵌套的for循环 ，来比较一下

#include <stdio.h>
int main()
{
	int i = 0;
	int j = 0;
	for (i = 0;i < 3;i++)
	{
		for (j = 0;j < 3;j++)
		{
			printf("hehe\n");
		}
	}
  return 0;
}

在正常情况下，这个程序会3次外循环，3次内循环，共9次 打印9次hehe 

我们现在试一下省略for的第一个初始化语句 

#include <stdio.h>
int main()
{
	int i = 0;
	int j = 0;
	for (;i < 3;i++)
	{
		for (;j < 3;j++)
		{
			printf("hehe\n");
		}
	}
  return 0;
}

结果只打印了三次， 原因是 虽然外循环还是3次，但内循环由于 j 没有初始化，在内循环第3次后，j就变成了4，内循环不再执行

变种2 

使用多于一个变量控制循环，这是允许的 

for (x=0,y=0;x<2&&y<5,++x,y++)

---

 这里，我们再拓展一道笔试题：

请问循环要循环多少次？

//请问循环要循环多少次？
#include <stdio.h>
int main()
{
 int i = 0;
 int k = 0;
 for(i =0,k=0; k=0; i++,k++)
        k++;
 return 0;
}

答案是0次  

原因是这里的红色框中的 k=0是赋值，k被赋值为0，0为假，循环不执行

三.do...while()循环 

1.do...while()循环的语法

do

         循环语句；

while  (表达式);

我们再用do...while循环来试着打印1~10的数

#include <stdio.h>
int main()
{
	int i = 1;
	do
	{
		printf("%d ", i);
		i++;
	} while (i <= 10);
}

do..while的特点是：循环至少执行一次，使用的场景有限，所以不是经常使用。 

流程图 

 

 

 

2.break和continue在do...while循环中

(1).break 

#include <stdio.h>
int main()
{
	int i = 1;
	do
	{
		if (5 == i)
			break;
		printf("%d ", i);
		i++;
	} while (i <=10);
	return 0;
}

 

可见，break在三个循环中较为类似，都是直接终止循环，但是值得注意的是： break只能终止一层循环，如果有刚刚那种嵌套式的循环，只能终止一层

(2).continue 

 

#include <stdio.h>
int main()
{
	int i = 1;
	do
	{
		if (5 == i)
			continue;
		printf("%d ", i);
		i++;
	} while (i <=10);
	return 0;
}

运行的结果是1 2 3 4死循环