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

         java的复合语句是以整个块为单位的语句，所以又称为块语句，复合语句由“{”开始，以“}”结束。复合语句中的每个语句都是从上到下执行的，并且在复合语句中可以嵌套复合语句。
public class Compound {
	 
	public static void main(String[] args) {
		int a = 21;
		{ //复合语句1 start
			int b = 3;
			System.out.println("b= "+b); //3
			{ //复合语句2 start
				int c = 5;
				System.out.println("c>b: " + (c>b)); //true
				System.out.println("a= "+a); //21
				System.out.println("b= "+b); //3
			} //复合语句2 end
			System.out.println("c= "+c); //编译错误
			System.out.println("b= "+b); //3
		} //复合语句1 end
		System.out.println("b= "+b);//编译错误
		System.out.println("a= "+a); //21
	}

}
      上述代码中写了两个复合语句，可以看到，c在复合语句块2中，当在复合语句1中使用时，会出现编译错误，因为c为局部变量，它的作用域就是在复合语句2中，同样b也是一样，在该变量的作用域之外使用的话，会出现编译错误。

　　由第1章已知，一个程序包含一个或多个程序单位(每个程序单位构成一个程序文件)。每一个程序单位由以下几个部分组成：
 
　　预处理命令。如#include命令和#define命令。
 
　　声明部分。例如对数据类型和函数的声明，以及对变量的定义。
 
　　函数。包括函数首部和函数体，在函数体中可以包含若干声明语句和执行语句。
 
　　如下面是一个完整的C++程序：
 
　　复制纯文本新窗口
 
　　#include //预处理命令 using namespace std; //在函数之外的声明部分 int a=3; //在函数之外的声明部分 int main( )//函数首部 { float b;//函数内的声明部分 b=4.5; //执行语句 cout<<a<<b; p="" }<="" 0;="" return="" 执行语句="">
 
　　#include //预处理命令
 
　　using namespace std; //在函数之外的声明部分
 
　　int a=3; //在函数之外的声明部分
 
　　int main( )//函数首部
 
　　{
 
　　float b;//函数内的声明部分
 
　　b=4.5; //执行语句
 
　　cout<<a<<b; p="" 执行语句<=""> 
 
　　return 0; //执行语句
 
　　}
 
　　如果一个变量在函数之外进行声明，此变量是全局变量，它的有效范围是从该行开始到本程序单位结束。如果一个变量在函数内声明，此变量是局部变量，它的有效范围是从该行开始到本函数结束。C++程序结构可以用图3.1表示。
 
　　
 

 
 
 
　　图3.1
 
　　程序应该包括数据描述(由声明语句来实现)和数据操作(由执行语句来实现)。数据描述主要包括数据类型的声明、函数和变量的定义、变量的初始化等。数据操作的任务是对已提供的数据进行加工。
 
　　C++程序中最小的独立单位是语句(statement)。它相当于一篇文章中的一个句子。句子是用句号结束的。语句一般是用分号结束的(复合语句是以右花括号结束的)。
 
　　C++语句可以分为以下4种。
 
　　1. 声明语句
 
　　如int a, b;在C语言中，只有产生实际操作的才称为语句，对变量的定义不作为语句，而且要求对变量的定义必须出现在本块中所有程序语句之前。因此C程序员已经养成了一个习惯: 在函数或块的开头位置定义全部变量。在C++中，对变量(以及其他对象)的定义被认为是一条语句，并且可以出现在函数中的任何行，即可以放在其他程序语句可以出现的地方，也可以放在函数之外。这样更加灵活，可以很方便地实现变量的局部化(变量的作用范围从声明语句开始到本函数或本块结束)。
 
　　2. 执行语句
 
　　通知计算机完成一定的操作。执行语句包括以下几种。
 
　　1) 控制语句，完成一定的控制功能。C++有9种控制语句，即：
 
　　if( )~else~ (条件语句)
 
　　for( )~ (循环语句)
 
　　while( )~ (循环语句)
 
　　do~while( ) (循环语句)
 
　　continue(结束本次循环语句)
 
　　break(中止执行switch或循环语句)
 
　　switch (多分支选择语句)
 
　　goto (转向语句)
 
　　return (从函数返回语句)
 
　　2) 函数和流对象调用语句。函数调用语句由一次函数调用加一个分号构成一个语句，例如：
 
　　sort(x, y,z); //假设已定义了sort函数，它有3个参数
 
　　cout<<x<<endl; p="" 流对象调用语句<=""> 
 
　　3) 表达式语句。由一个表达式加一个分号构成一个语句。最典型的是：由赋值表达式构成一个赋值语句。
 
　　i=i+1 //是一个赋值表达式
 
　　i=i+1; //是一个赋值语句
 
　　任何一个表达式的最后加一个分号都可以成为一个语句。一个语句必须在最后出现分号。
 
　　表达式能构成语句是C和C++语言的一个重要特色。C++程序中大多数语句是表达式语句(包括函数调用语句)。
 
　　3. 空语句
 
　　下面是一个空语句：
 
　　; // 该语句只有一个分号
 
　　即只有一个分号的语句，它什么也不做。有时用来做被转向点，或循环语句中的循环体。
 
　　4. 复合语句
 
　　可以用 { }把一些语句括起来成为复合语句。如下面是一个复合语句。
 
　　复制纯文本新窗口
 
　　{ z=x+y; if(z>100) z=z-100; cout<<z; p="" }<=""> 
 
　　{
 
　　z=x+y;
 
　　if(z>100) z=z-100;
 
　　cout<<z;< p=""> 
 
　　}

复合语句，又叫 代码块。
 
实质上很简单，就是几行连续的语句，被一个大括号括起来。
 
这个时候，会被认为是一体的。
 
 
 
比如使用for循环的时候，在小括号后的第一行语句，是循环体，
 
如果没有符合语句，那么只循环执行小括号后的第一行语句。
 
有了复合语句之后，那么就会执行这个大括号里的所有语句。
 
 
 
例如：{cin>>a;cout<<a;}这就是一个复合语句，由语句cin>>a;和语句cout<<a;组成。
 
 
 
复合语句的特性：
 
①复合语句被括在一起的时候，会整体一起执行。例如
 
for (i=1;i<5;i++){cout<<i<<endl;cout<<i+1<<endl;}
 
两行代码都会执行4遍
 
 
 
②复合语句内部声明和定义的变量，在离开复合语句后失效。
 
例如：
 

	int a = 1;
	{
		int b = 1;
		a = a + b;
	}
	cout << a << endl;
	cout << b << endl;

 
 
在输出b的时候，会被提示 未定义的标识符b 。
 
 
 
③复合语句内外都声明同一个变量名。例如：
 

 

int a=1;
{int a=2;
a=a+3;
}
cout<<a<<endl;

 
 
这个时候，在复合语句内部，a为2，a=a+3后a为5。
 
然而，在离开复合语句后，a没有被操作，但输出a为1
 
上代码：
 

 

#include<iostream>

int main()
{
	using namespace std;
	int a = 1;
	{
		cout << a << endl;
		a = a + 3;
		cout << a << endl;
		int a = 5;
		int b = 1;
		a = a + b;
		cout << a << endl;
	}
	cout << a << endl;

	system("pause");
	return 0;
}

 
 
输出：
 

 

1
4
6
4
请按任意键继续. . .

 
 
 
 
即：
 
 
 
 
复合语句外部
 
 
复合语句内部
 
 
结果
 
 
变量声明情况
 
 
声明
 
 
未声明
 
 
内部可使用
 
 
未声明
 
 
声明
 
 
外部不可使用
 
 
声明
 
 
声明和外部同一个变量
 
 
①外部变量在遇见内部声明语句前有效。
 
 
 
②遇见内部声明语句后隐藏，
 
 
 
③退出复合语句后恢复到隐藏时的状态