复合语句是包含其它语句（语句组）的语句；它们会以某种方式影响或控制所包含其它语句的执行。 通常，复合语句会跨越多行，虽然在某些简单形式下整个复合语句也可能包含于一行之内。

if, while 和 for 语句用来实现传统的控制流程构造。 try 语句为一组语句指定异常处理和/和清理代码，而 with 语句允许在一个代码块周围执行初始化和终结化代码。 函数和类定义在语法上也属于复合语句。

一条复合语句由一个或多个‘子句’组成。 一个子句则包含一个句头和一个‘句体’。 特定复合语句的子句头都处于相同的缩进层级。 每个子句头以一个作为唯一标识的关键字开始并以一个冒号结束。 子句体是由一个子句控制的一组语句。 子句体可以是在子句头的冒号之后与其同处一行的一条或由分号分隔的多条简单语句，或者也可以是在其之后缩进的一行或多行语句。 只有后一种形式的子句体才能包含嵌套的复合语句；以下形式是不合法的，这主要是因为无法分清某个后续的 else 子句应该属于哪个 if 子句:
if test1: if test2: print(x)
还要注意的是在这种情形下分号的绑定比冒号更紧密，因此在以下示例中，所有 print() 调用或者都不执行，或者都执行:
if x < y < z: print(x); print(y); print(z)
总结:

compound_stmt ::=  if_stmt
                   | while_stmt
                   | for_stmt
                   | try_stmt
                   | with_stmt
                   | funcdef
                   | classdef
                   | async_with_stmt
                   | async_for_stmt
                   | async_funcdef
suite         ::=  stmt_list NEWLINE | NEWLINE INDENT statement+ DEDENT
statement     ::=  stmt_list NEWLINE | compound_stmt
stmt_list     ::=  simple_stmt (";" simple_stmt)* [";"]

请注意语句总是以 NEWLINE 结束，之后可能跟随一个 DEDENT。 还要注意可选的后续子句总是以一个不能作为语句开头的关键字作为开头，因此不会产生歧义（‘悬空的 else’问题在 Python 中是通过要求嵌套的 if 语句必须缩进来解决的)。

为了保证清晰，以下各节中语法规则采用将每个子句都放在单独行中的格式。

if 语句

if 语句用于有条件的执行

if_stmt ::=  "if" assignment_expression ":" suite
             ("elif" assignment_expression ":" suite)*
             ["else" ":" suite]

它通过对表达式逐个求值直至找到一个真值（请参阅 布尔运算 了解真值与假值的定义）在子句体中选择唯一匹配的一个；然后执行该子句体（而且 if 语句的其他部分不会被执行或求值）。 如果所有表达式均为假值，则如果 else 子句体如果存在就会被执行。

while 语句

while 语句用于在表达式保持为真的情况下重复地执行:

while_stmt ::=  "while" assignment_expression ":" suite
                ["else" ":" suite]

这将重复地检验表达式，并且如果其值为真就执行第一个子句体；如果表达式值为假（这可能在第一次检验时就发生）则如果 else 子句体存在就会被执行并终止循环。

第一个子句体中的 break 语句在执行时将终止循环且不执行 else 子句体。 第一个子句体中的 continue 语句在执行时将跳过子句体中的剩余部分并返回检验表达式。

for 语句

for 语句用于对序列（例如字符串、元组或列表）或其他可迭代对象中的元素进行迭代:

for_stmt ::=  "for" target_list "in" expression_list ":" suite
              ["else" ":" suite]

表达式列表会被求值一次；它应该产生一个可迭代对象。 系统将为 expression_list 的结果创建一个迭代器，然后将为迭代器所提供的每一项执行一次子句体，具体次序与迭代器的返回顺序一致。 每一项会按标准赋值规则 (参见 赋值语句) 被依次赋值给目标列表，然后子句体将被执行。 当所有项被耗尽时 (这会在序列为空或迭代器引发 StopIteration 异常时立刻发生)，else 子句的子句体如果存在将会被执行，并终止循环。

第一个子句体中的 break 语句在执行时将终止循环且不执行 else 子句体。 第一个子句体中的 continue 语句在执行时将跳过子句体中的剩余部分并转往下一项继续执行，或者在没有下一项时转往 else 子句执行。

for 循环会对目标列表中的变量进行赋值。 这将覆盖之前对这些变量的所有赋值，包括在 for 循环体中的赋值:

for i in range(10):
    print(i)
    i = 5             # this will not affect the for-loop
                      # because i will be overwritten with the next
                      # index in the range

目标列表中的名称在循环结束时不会被删除，但如果序列为空，则它们根本不会被循环所赋值。 提示：内置函数 range() 会返回一个可迭代的整数序列，适用于模拟 Pascal 中的 for i := a to b do 这种效果；例如 list(range(3)) 会返回列表 [0, 1, 2]。

注解 当序列在循环中被修改时会有一个微妙的问题（这只可能发生于可变序列例如列表中）。 会有一个内部计数器被用来跟踪下一个要使用的项，每次迭代都会使计数器递增。 当计数器值达到序列长度时循环就会终止。 这意味着如果语句体从序列中删除了当前（或之前）的一项，下一项就会被跳过（因为其标号将变成已被处理的当前项的标号）。 类似地，如果语句体在序列当前项的前面插入一个新项，当前项会在循环的下一轮中再次被处理。 这会导致麻烦的程序错误，避免此问题的办法是对整个序列使用切片来创建一个临时副本，例如
for x in a[:]:
    if x < 0: a.remove(x)

try 语句

try 语句可为一组语句指定异常处理器和/或清理代码:

try_stmt  ::=  try1_stmt | try2_stmt
try1_stmt ::=  "try" ":" suite
               ("except" [expression ["as" identifier]] ":" suite)+
               ["else" ":" suite]
               ["finally" ":" suite]
try2_stmt ::=  "try" ":" suite
               "finally" ":" suite

except 子句指定一个或多个异常处理器。 当 try 子句中没有发生异常时，没有异常处理器会被执行。 当 try 子句中发生异常时，将启动对异常处理器的搜索。 此搜索会依次检查 except 子句，直至找到与该异常相匹配的子句。 如果存在无表达式的 except 子句，它必须是最后一个；它将匹配任何异常。 对于带有表达式的 except 子句，该表达式会被求值，如果结果对象与发生的异常“兼容”则该子句将匹配该异常。 一个对象如果是异常对象所属的类或基类，或者是包含有兼容该异常的项的元组则两者就是兼容的。

如果没有 except 子句与异常相匹配，则会在周边代码和发起调用栈上继续搜索异常处理器。 1

如果在对 except 子句头中的表达式求值时引发了异常，则原来对处理器的搜索会被取消，并在周边代码和调用栈上启动对新异常的搜索（它会被视作是整个 try 语句所引发的异常）。

当找到一个匹配的 except 子句时，该异常将被赋值给该 except 子句在 as 关键字之后指定的目标，如果存在此关键字的话，并且该 except 子句体将被执行。 所有 except 子句都必须有可执行的子句体。 当到达子句体的末尾时，通常会转向整个 try 语句之后继续执行。 （这意味着如果对于同一异常存在有嵌套的两个处理器，而异常发生于内层处理器的 try 子句中，则外层处理器将不会处理该异常。）

当使用 as 将目标赋值为一个异常时，它将在 except 子句结束时被清除。 这就相当于

except E as N:
    foo

被转写为

except E as N:
    try:
        foo
    finally:
        del N

这意味着异常必须赋值给一个不同的名称才能在 except 子句之后引用它。 异常会被清除是因为在附加了回溯信息的情况下，它们会形成堆栈帧的循环引用，使得所有局部变量保持存活直到发生下一次垃圾回收。

在一个 except 子句体被执行之前，有关异常的详细信息存放在 sys 模块中，可通过 sys.exc_info() 来访问。 sys.exc_info() 返回一个 3 元组，由异常类、异常实例和回溯对象组成（参见 标准类型层级结构 一节），用于在程序中标识异常发生点。 当从处理异常的函数返回时 sys.exc_info() 的值会恢复为（调用前的）原值。

如果控制流离开 try 子句体时没有引发异常，并且没有执行 return, continue 或 break 语句，可选的 else 子句将被执行。 else 语句中的异常不会由之前的 except 子句处理。

如果存在 finally，它将指定一个‘清理’处理程序。 try 子句会被执行，包括任何 except 和 else 子句。 如果在这些子句中发生任何未处理的异常，该异常会被临时保存。 finally 子句将被执行。 如果存在被保存的异常，它会在 finally 子句的末尾被重新引发。 如果 finally 子句引发了另一个异常，被保存的异常会被设为新异常的上下文。 如果 finally 子句执行了 return, break 或 continue 语句，则被保存的异常会被丢弃:

>>> def f():
...     try:
...         1/0
...     finally:
...         return 42
...
>>> f()
42

在 finally 子句执行期间，程序不能获取异常信息。

当 return, break 或 continue 语句在一个 try…finally 语句的 try 子语句体中被执行时，finally 子语句也会‘在离开时’被执行。

函数的返回值是由最后被执行的 return 语句所决定的。 由于 finally 子句总是被执行，因此在 finally 子句中被执行的 return 语句总是最后被执行的:

>>> def foo():
...     try:
...         return 'try'
...     finally:
...         return 'finally'
...
>>> foo()
'finally'

有关异常的更多信息可以在 异常 一节找到，有关使用 raise 语句生成异常的信息可以在 raise 语句 一节找到。

1.  表达式语句

在表达式的后边加一个分号“；”就构成了表达式语句 ,如:

a=++b*9；

x=8；y=7；

++k；

可以一行放一个表达式形成表达式语句，也可以一行放多个表达式形成表达式语句，这时每个表达式后面都必须带“；”号，另外，还可以仅由—个分号“；”占一行形成一个表达式语句，这种语句称为空语句。

空语句在程序设计中通常用于两种情况：

（1）在程序中为有关语句提供标号，用以标记程序执行的位置。例如采用下面的语句可以构成一个循环。

repeat：；

     :

     goto  repeat；

（2）在用while语句构成的循环语句后面加一个分号，形成一个不执行其它操作的空循环体。这种结构通常用于对某位进行判断，当不满足条件则等待，满足条件则执行。

【例】下面这段子程序用于读取8051单片机的串行口的数据，当没有接收到则等待，当接收到，接收数据后返回，返回值为接收的数据。

#include  <reg51.h>

char  getchar()

{

char  c;

while(!RI);             //当接收中断标志位RI为0则等待，当接收中断标志位为1则;等待结束

c=SBUF;

RI=0;

return(c);

}

2.  复合语句

复合语句是由若干条语句组合而成的一种语句，在C51中，用一个大括号“{  }”将若干条语句括在一起就形成了一个复合语句，复合语句最后不需要以分号“；”结束，但它内部的各条语句仍需以分号“；”结束。复合语句的一般形式为：

{

局部变量定义；

语句l；

语句2；

}

复合语句在执行时，其中的各条单语句按顺序依次执行，整个复合语句在语法上等价于一条单语句，因此在C51中可以将复合语句视为一条单语句。通常复合语句出现在函数中，实际上，函数的执行部分（即函数体）就是一个复合语句；复合语句中的单语句一般是可执行语句，此外还可以是变量的定义语句（说明变量的数据类型）。在复合语句内部语句所定义的变量，称为该复合语句中的局部变量，它仅在当前这个复合语句中有效。利用复合语句将多条单语句组合在—起，以及在复合语句中进行局部变量定义是C51语言的一个重要特征。

前言

博主：Super大雄   （萌新博主一枚）

C语言专栏：https://blog.csdn.net/m0_64857213/category_11678637.html

LeetCode专栏：https://blog.csdn.net/m0_64857213/category_11691019.html

本期是关于C语言输入输出语句相关的格式与复合语句，如有错误迎您提出您的看法。

  🌷给小伙伴们推荐个学习、刷题的网站？
🍓🍓各种面试题应有尽有，刷题刷到你手软！
🥂🥂🥂各种互联网学习资料，各个大厂面试真题从 零基础开始学习，帮你轻松应对各类面试题目，快来充实一下自己吧！

点击我🐱‍🏍开始注册🐂 学习、刷题

目录

什么是赋值、什么是赋值语句？

数据的输入语句

例1：字符串原样输出

例2.指定宽度输出

数据的输入

例1：字符串原样输出

例2.指定宽度输出

例4：实型数据输入

字符的输入与输出

数字和字符赋值

字符输入函数：getchar

字符输出函数：putchar

复合语句与空语句

空语句

什么是赋值、什么是赋值语句？

在生活中我们把水倒进杯子里边就是赋值，杯子是一个容器用来存放东西的。在C语言中变量相当于一个容器用来存放值的，变量类型的不同存放的东西也不同。例如：杯子是装水的、相框是放照片的、手枪的弹夹是用来装子弹的，不同事物用着不同的容器来装。

C语言中用=来表示赋值。两个等于号==在C语言中表示判断。

例如：

int a=10

C语言一套语句结束必须加上; 

赋值语句的构成：在赋值表达式的后边加上；就是赋值语句了。

例如：

int a=10;

C语言中;表示是一条语句。

数据的输入语句

printf(“ 字符 格式说明 转义字符”，输出项)；

例1：字符串原样输出

 int x = 123;
	float y = 12.12;
	printf("x=%d,y=%f\n",x,y);
	printf("%d,%f", x, y);

结果：

x=123,y=12.120000
123,12.120000
 

例2.指定宽度输出

 int x = 123;
	printf("x=%4d\n",x);
	printf("x=%2d\n",x);

结果：

x= 123
x=123
注意：第一行x= 123这里是有一个空格的。

总结：如果指定长度>实际长度补空格,正数：前边补，负数：后边补。

 float t=23.12345678;
	printf("f=%7.2f\n",t);
   printf("f=%10.6f\n",t);

 结果：

f=  23.12        两个空格
f= 23.123457 一个空格
%n.mf：m代表数据总长度，n代表小数位数  

实际>n   四舍五入

实际<n   不变

数据的输入

scanf（“字符 格式说明”，地址）；

int a, b, c;
//假如输入2 3 4
	scanf("%d%d%d",&a, &b, &c );
	printf("%d,%d,%d" ,a, b, c);

 结果：2,3,4

&为取地址符

整型数据输入如果没有其他符号分隔，用空格或回车

例1：字符串原样输出

int a, b;
	scanf("a=%d,b=%d",&a, &b );
	printf("%d,%d\n" ,a, b);

 输入格式：a=1，b=2

否则出现异常

例2.指定宽度输出

int a, b, c;
	scanf("%1d%2d%3d",&a,&b,&c);
	printf("%d,%d,%d",a,b,c);

输入格式： 987654321

 结果：9,87,654

我们可以看到有了指定宽度就不用输入的时候空格了

例4：实型数据输入

float t;
scanf("%2.5f",&t);

切记：实型数据不能指定小数位数。

字符的输入与输出

char a, b;
	scanf("%c%c",&a,&b);
	printf("%c,%c",a,b);

输入格式： b

 结果： ,b

空格也算作字符串

数字和字符赋值

char a;
	int b;
	scanf("%d%c",&a,&b);
	printf("%d,%c",a,b);

输入格式： 3a

 结果：3,a 

输入格式： 3 a

 结果：3, 

输入格式： 10a

 结果：10,a

注意：%c前不能有空格，字符指一个

字符输入函数：getchar()

char a;
	a=getchar();
	printf("%c",a);

输入格式： a

 结果：a

字符输出函数：putchar()

char a;
	a=getchar();
	putchar(a);

复合语句与空语句

复合语句就是有多个语句符合而成的语句{ }

{ }称为语句块，在{}里边的成为语句。

一个语句块包含了多个语句。

{
int a;
	int b;
	int c;
	int d;
}

空语句

;

只有分号“；”组成的语句称为空语句，执行到这里系统什么也不做，然后往下执行！

空语句是合法的。

   🌷给小伙伴们推荐个学习、刷题的网站？
🍓🍓各种面试题应有尽有，刷题刷到你手软！
🥂🥂🥂各种互联网学习资料，各个大厂面试真题从 零基础开始学习，帮你轻松应对各类面试题目，快来充实一下自己吧！

点击我🐱‍🏍开始注册🐂 学习、刷题