精华内容
下载资源
问答
  • 【c++教程】4.2-复合语句
    2021-10-12 22:05:44

    复合语句

    写在花括号{}中的内容组成的语句,就是复合语句。特别的,如果你只写了一个花括号,里面什么内容都没有,这也是一种空语句,相当于只有一个分号。

    复合语句有三个主要特点:

    1,整个花括号中虽然可能包括了多条语句,但是算作一个复合语句。

    2,复合语句有自己的作用域,因此在离开复合语句以后,其中定义的变量会销毁。

    3,复合语句的结束不需要分号,当然也许从这是一个语句的角度来说,应该要写分号才对,但是不写分号可以算作是一种福利。也就是既然已经知道它在哪里结束了,就不用再额外写结束标志了。

    复合语句的作用

    1,当只需要一条语句,但是一条语句无法满足实际需要的时候,需要使用复合语句。经常会发生于选择或者循环语句使用的时候。

    #include <iostream>
    
    using namespace std;
    
    int main()
    {
    	int a = 500;
    	if (a > 0)
    	{
    		a += 20;
    		cout << "a: " << a << endl;
    	}
    }

    2,由于复合语句有自己独立的作用域,因此,可以通过复合语句来定义重名变量。

    这个在很多情况下,可能是很有用的。因为很多时候,给变量起一个好的名字也是很困难的,尤其在反复使用相同的功能的情况下,如果必须保证变量不重名的话,很可能就要加数字表示了。因此,如果可以将定义重名变量的部分写入复合语句之中,就可以让变量名可以重复使用。

    #include <iostream>
    
    using namespace std;
    
    int main()
    {
    	{
    		int a = 520;
    		cout << a << endl;
    	}
    
    	// 这两个a所在的作用域不同,不会互相影响
    	int a = 1314;
    	cout << a << endl;
    }

    思考:是否应该总是使用复合语句

    之前,我们说到在条件或者循环语句中,可以使用复合语句,那么,如果不使用复合语句也可以完成,是否应该总是使用复合语句呢?

    #include <iostream>
    
    using namespace std;
    
    int main()
    {
    	int a = 520;
    
    	// 不使用复合语句
    	if (a > 0)
    		cout << a << endl;
    
    	// 使用复合语句
    	if (a > 0)
    	{
    		cout << a << endl;
    	}
    }

    最终的运行结果自然是没有差别的,但是像这样只需要一个简单语句就可以完成的工作,到底是否应该使用复合语句呢?

    使用复合语句的坏处是什么,很显然是不美观。第一种没使用复合语句的写法很简洁,一句话就解决了。第二种使用了复合语句的写法很多余,就是花括号没有发挥作用。那么在这种情况下,到底使用复合语句好不好呢?似乎答案已经明确了,不使用复合语句更好。

    但是真的是这样吗?如果从长远角度来说的话,这个程序如果以后还需要更新和维护,那么很可能发生这样一种情况,以前在这个if语句中,只需要一句就能解决的问题,现在解决不了了,必须要增加更多的语句。在这种情况下,如果我们使用的是不使用复合语句的版本,那么我们还要先为其添加花括号,然后才能开始写新的需求,比较麻烦。而如果使用的是有复合语句的版本,那么我们直接换行以后,继续添加语句即可。那这样来看的话,似乎又是总是使用复合语句更好了。

    因此,如果我们非要得到一个结论的话,那就是:在能不用复合语句的情况下,如果这段代码是不会改变的(至少在可以预见的未来,你认为它应该不会被改变),那么,不使用复合语句更好。如果这段代码,后续随时都可能改变,那么应该总是使用复合语句。

    当然,这是一个建议,最终要如何决定代码风格自然还是取决于你自己。

    顺便一提,如果你决定要能不使用复合语句就不使用复合语句的话,我的建议是,如果你还不明确代码要怎么写,你可以先把复合语句的花括号写上。如果发现没用到,那再删掉就是了。这样可以有效避免,你认为这里不需要复合语句,等到第一句写完了,才发现需要复合语句的情况。毕竟,删掉括号要比添加括号更加容易。

    点击查看全部c++教程

    更多相关内容
  • 复合语句

    千次阅读 2020-11-29 19:34:47
    复合语句是包含其它语句(语句组)的语句;它们会以某种方式影响或控制所包含其它语句...一条复合语句由一个或个‘子句’组成。 一个子句则包含一个句头和一个‘句体’。 特定复合语句的子句头都处于相同的缩进层级。

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

    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 语句 一节找到。

    展开全文
  • 对Python中for复合语句的使用示例讲解当Python中用到双重for循环设计的时候我一般会使用循环的嵌套,但是在Python中其实还存在另一种技巧——for复合语句。简单写一个小程序,用于延时循环嵌套功能如下:#!/usr/bin/...

    对Python中for复合语句的使用示例讲解

    当Python中用到双重for循环设计的时候我一般会使用循环的嵌套,但是在Python中其实还存在另一种技巧——for复合语句。

    简单写一个小程序,用于延时循环嵌套功能如下:

    #!/usr/bin/python

    defFunc1(ten_num,one_num):

    for i in range(ten_num):

    for j in range(one_num):

    print(10 * i + j)

    Func1(2,5)的执行结果如下:

    0

    1

    2

    3

    4

    10

    11

    12

    13

    14

    以上是一个数字组合运算的结果清单。接下来使用for的复合语句实现类似功能,增加扩充代码如下:

    #!/usr/bin/python

    defFunc1(ten_num,one_num):

    for i in range(ten_num):

    for j in range(one_num):

    print(10 * i + j)

    defFunc2(ten_num,one_num):

    print([(10 * i + j)

    for i in range(ten_num)

    for j in range(one_num)])

    #Func1(2,5)

    Func2(2,5)

    程序的执行结果如下:

    [0, 1, 2, 3, 4,10, 11, 12, 13, 14]

    这里以列表的形式存储了生成的各种数字组合结果并进行了打印。程序实现的功能类似,但是从上面的代码以及结果来看,for复合语句还是有其自己的特点的。

    具体如下:

    1,从代码上看,复合语句的形式代码更为凝练;

    2,从阅读上看,复合语句其实在表述上更加贴近于英语语法;

    3,在实现结果的矩阵化上,复合语句更有优势。

    以上这篇对Python中for复合语句的使用示例讲解就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持我们。

    时间: 2018-10-31

    一.简介 Python的条件和循环语句,决定了程序的控制流程,体现结构的多样性.须重要理解,if.while.for以及与它们相搭配的 else. elif.break.continue和pass语句. 二.详解 1.if语句 Python中的if子句由三部分组成:关键字本身.用于判断结果真假的条件表达式以及当表达式为真或者非零时执行的代码块.if 语句的语法如下: if expression: expr_true_suite if 语句的expr_true_suite代码块只有在条件表达式的结

    for 循环 本系列前面 "探索 Python,第 5 部分:用 Python 编程" 一文讨论了 if 语句和 while 循环,讨论了复合语句以及适当缩进 Python 语句来指示相关 Python 代码块.该文的结尾介绍了 Python for 循环.但就其使用和功能来说,for 循环更值得关注,所以本文单独讲述该循环. for 循环有一个简单的语法,使您可以从容器对象中提取单个项目并对其进行某些操作.简单地说,使用 for 循环,可以迭代中对象集合的项目.对象集合可以是任何 P

    6b5aa0751a6f1e6a9d0b665a02cc1f46.gif

    本文实例讲述了Python中for循环控制语句用法.分享给大家供大家参考.具体分析如下: 第一个:求 50 - 100 之间的质数 import math for i in range(50, 100 + 1): for j in range(2, int(math.sqrt(i)) + 1): if i % j == 0: break else: print i 输出如下: 53 59 61 67 71 73 79 83 89 97 第二个:把else的位置与if处于同一缩进. import

    循环语句(有两种): while 语句 for   语句 while 语句: 问题:输入一个整数n,让程序输出n行的: hello 1 hello 2 ....... hell n while 语句: 作用:根据一定条件,重复的执行一条语句或多条语句 语法: while 真值表达式: 语句块1...... else: 语句块2...... 说明: 1,先执行真值表达式,测试布尔值为True或False 2,如果真值表达式的测试值为True,侧执行语句1,然后再返回到第一步重复进行测试 3,如果真

    6b5aa0751a6f1e6a9d0b665a02cc1f46.gif

    下面的代码中python2与python3的print使用区别,大家注意一下.python3需要加()才行. 语法: for循环的语法格式如下: for iterating_var in sequence: statements(s) 流程图: 实例: #!/usr/bin/python # -*- coding: UTF-8 -*- for letter in 'jb51.net': # 第一个实例 print '当前字母 :', letter fruits = ['banana', 'app

    与其它大多数语言一样,Python 也拥有 for 循环.你到现在还未曾看到它们的唯一原因就是,Python 在其它太多的方面表现出色,通常你不需要它们. 其它大多数语言没有像 Python 一样的强大的 list 数据类型,所以你需要亲自做很多事情,指定开始,结束和步长,来定义一定范围的整数或字符或其它可重复的实体.但是在 Python 中,for 循环简单地在一个列表上循环,与 list 解析的工作方式相同. 1. for  循环介绍 复制代码 代码如下: >>> li = ['a'

    6b5aa0751a6f1e6a9d0b665a02cc1f46.gif

    for循环在Python中有遍历所有序列的项目,如列表或一个字符串. 语法: for循环语法如下: for iterating_var in sequence: statements(s) 如果一个序列包含一个表达式列表,计算第一个.然后,在序列中的第一项被分配给迭代变量iterating_var.接着,语句块被执行.列表中的每个项目分配给iterating_var,并且statement块被执行,直到整个序列完成(到尾部). 流程图: 例子: #!/usr/bin/python for let

    5b7a069c72f446e270dd412b861f2e4d.png

    前言 for...in 是Python程序员使用最多的语句,for 循环用于迭代容器对象中的元素,这些对象可以是列表.元组.字典.集合.文件,甚至可以是自定义类或者函数,例如: 作用于列表 >>> for elem in [1,2,3]: ... print(elem) ... 1 2 3 作用于元组 >>> for i in ("zhang", "san", 30): ... print(i) ... zhang san 30

    一直对asyncio这个库比较感兴趣,毕竟这是官网也非常推荐的一个实现高并发的一个模块,python也是在python 3.4中引入了协程的概念.也通过这次整理更加深刻理解这个模块的使用 asyncio 是干什么的? 异步网络操作并发协程 python3.0时代,标准库里的异步网络模块:select(非常底层) python3.0时代,第三方异步网络库:Tornado python3.4时代,asyncio:支持TCP,子进程 现在的asyncio,有了很多的模块已经在支持:aiohttp,ai

    在使用Python做脚本的话,有两个库可以使用,一个为PyUserInput库,另一个为pyautogui库.就本人而言,我更喜欢使用pyautogui库,该库功能多,使用便利.下面给大家介绍一下pyautogui库的使用方法.在cmd命令框中输入pip3 install pyautogui即可安装该库! 常用操作 我们在pyautogui库中常常使用的方法,如下: import pyautogui pyautogui.PAUSE = 1 # 调用在执行动作后暂停的秒数,只能在执行一些pyaut

    详解python中executemany和序列的使用方法 一 代码 import sqlite3 persons=[ ("Jim","Green"), ("Hu","jie") ] conn=sqlite3.connect(":memory:") conn.execute("CREATE TABLE person(firstname,lastname)") conn.executeman

    详解python中 os._exit() 和 sys.exit(), exit(0)和exit(1) 的用法和区别 os._exit() 和 sys.exit() os._exit() vs sys.exit() 概述 Python的程序有两中退出方式:os._exit(), sys.exit().本文介绍这两种方式的区别和选择. os._exit()会直接将python程序终止,之后的所有代码都不会继续执行. sys.exit()会引发一个异常:SystemExit,如果这个异常没有被捕获,那

    详解 Python中LEGB和闭包及装饰器 LEGB L>E>G?B L:local函数内部作用域 E:enclosing函数内部与内嵌函数之间 G:global全局作用域 B:build-in内置作用域 python 闭包 1.Closure:内部函数中对enclosing作用域变量的引用 2.函数实质与属性 函数是一个对象 函数执行完成后内部变量回收 函数属性 函数返回值 passline = 60 def func(val): if val >= passline: print (

    详解python中的文件与目录操作 一 获得当前路径 1.代码1 >>>import os >>>print('Current directory is ',os.getcwd()) Current directory is D:\Python36 2.代码2 如果将上面的脚本写入到文件再运行 Current directory is E:\python\work 二 获得目录的内容 Python代码 >>> os.listdir (os.getcwd

    展开全文
  • 7. 复合语句复合语句包含有其它语句 (组) . 它们以某种方式影响或控制其它语句的执行.一般地, 复合语句会跨越多行, 但一个完整的复合语句也可以简化在一行中.if, while 和 for语句实现了传统的控制结构. try语句为...

    7. 复合语句¶

    复合语句包含有其它语句 (组) . 它们以某种方式影响或控制其它语句的执行.

    一般地, 复合语句会跨越多行, 但一个完整的复合语句也可以简化在一行中.

    if, while 和 for

    语句实现了传统的控制结构. try

    语句为一组语句指定了异常处理器和/或清理 (cleanup) 代码.

    with 语句允许为其内的代码提供初始化的清理 (finalization) 代码.

    函数定义和类定义在语法上也被看作复合语句.

    复合语句由一个或多个” 子句” (clause) 组成. 一个子句由一个头和一个

    “语句序列”(suite) 组成. 一个具体复合语句内的所有子句头都具有相同的缩进层次.

    每个子句 “头” 以一个唯一性标识关键字开始并以一个冒号结束.

    “语句序列”, 是该子句所控制的一组语句, 一个语句序列可以是与子句头处于同一行的,

    在子句头冒号之后以分号分隔的多条简单语句, 或者也可以是在后面连续行中缩进的语句.

    只有第二种情况下,子句序列才允许包括嵌套复合语句. 下面这样是非法的,

    这样处理大部分原因是不易判断 else 子句与前面的 if

    子句的配对关系:

    if test1: if test2: print(x)

    也要注意在这样的上下文中分号的优先级比冒号高, 所以在下面的例子中, 要么执行全部的

    print() 调用, 要么一个也不执行:

    if x < y < z: print(x); print(y); print(z)

    总结:

    注意语句结尾的 NEWLINE 之后可能还有一个 DEDENT,

    注意可选的续行子句都是以不能开始另一个语句的关键字开头的,

    因此这里不存在歧义 (“悬挂 else 问题”已经因为 Python

    要求缩进嵌套语句而解决掉了).

    为了叙述清楚, 以下章节中每个子句的语法规则格式都会分行列出.

    7.1. if 语句¶

    if 语句用于条件执行:

    if_stmt ::= "if" expression ":" suite

    ( "elif" expression ":" suite )*

    ["else" ":" suite]

    它对表达式逐个求值, 直到其中一个为真时, 准确地选择相应的一个语句序列

    (对于真和假的定义参见 Boolean operations 节),

    然后该执行语句序列 (if 语句的其它部分不会被执行和计算).

    如果所有表达式都为假, 并且给出了 else 子句,

    那么将执行它包括的语句序列.

    7.2. while 语句¶

    while 用于重复执行, 前提是条件表达式为真:

    while_stmt ::= "while" expression ":" suite

    ["else" ":" suite]

    while 会重复地计算表达式的值, 并且如果为真, 就执行第一个语句序列;

    如果为假 (可能在第一次比较时), 就执行else子句 (如果给出) 并退出循环.

    在第一个语句序列中执行 break 语句就可以做到不执行

    else 子句而退出循环. 在第一个语句序列执行 continue

    语句可以跳过该子句的其余部分直接进入下次的表达式测试.

    7.3. for 语句¶

    for 语句用于迭代有序类型 (像串, 元组或列表) 或其它可迭代对象的元素:

    for_stmt ::= "for" target_list "in" expression_list ":" suite

    ["else" ":" suite]

    只计算一次 expression_list , 它应该生成一个迭代器对象.

    然后在迭代器每次提供一个元素时就会执行语句序列 (suite) 一次,

    元素按索引升序循环给出. 每个元素使用标准的赋值规则 (见 Assignment statements)

    依次赋给循环的 target_list, 然后执行语句序列.

    当迭代完毕后(当有序类型对象为空, 或者迭代器抛出异常 StopIteration

    时立即结束循环), 就执行 else 子句 (如果给出) 中的语句序列,

    最后结束循环.

    在第一个语句序列中执行 break 语句可以不执行 else

    子句就退出循环. 在第一个语句序列中执行 continue

    语句可以跳过该子句的其余部分, 直接处理下个元素, 或者如果没有下个元素了,

    就进入 else 子句.

    语句序列可以对 target_list 中的变量赋值, 这不影响 for

    语句赋下一项元素给它.

    在循环结束后, 这个 target_list 并不会删除, 但如果有序类型对象为空,

    它根本就不会在循环中赋值. 小技巧:内置函数 range() 返回一个整数列表,

    可以用于模拟Pascal语言中的 for i := a to b 的行为,

    例如 list(range(3)) 返回列表 [0, 1, 2].

    Note

    如果在循环中要修改有序类型对象 (仅对可变类型而言, 即列表),

    这里有一些要注意的地方. 有一个内部计数器用于跟踪下一轮循环使用哪一个元素,

    并且每次迭代就增加一次. 当这个计数器到达有序类型对象的长度时该循环就结束了.

    这意味着如果语句序列删除了当前元素 (或一个之前的元素) 时,

    下一个元素就会被跳过去 (因为当前索引值的元素已经处理过了).

    类似地, 如果在当前元素前插入了一个元素, 则当前元素会在下一轮循环再次得到处理.

    这可能会导致难以觉察的错误,

    但可以通过使用含有整个有序类型对象的片断而生成的临时拷贝避免这个问题,

    例如:

    for x in a[:]:

    if x < 0: a.remove(x)

    7.4. try 语句¶

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

    try_stmt ::= try1_stmt | try2_stmt

    try1_stmt ::= "try" ":" suite

    ("except" [expression ["as" target]] ":" suite)+

    ["else" ":" suite]

    ["finally" ":" suite]

    try2_stmt ::= "try" ":" suite

    "finally" ":" suite

    except 子句指定了一个或多个异常处理器. 当在 try

    子句中没有异常发生时, 异常处理器将不被执行. 当在 try

    子句中有异常发生时, 就会开始搜索异常处理器. 它会按书写顺序搜索每个子句,

    直到有一个匹配的处理器找到为止. 如果存在一个没有指定异常的 except

    子句, 它必须放在最后, 它会匹配任何异常. 当一个 except

    子句携带了一个表达式时, 这个表达式会被求值, 如果结果与该异常” 兼容”,

    那么该子句就匹配上了这个异常. 对象与异常兼容是指, 对象与这个异常的类或者基类相同,

    或者对象是一个元组, 它的某个项包括与该异常兼容的对象.

    如果没有 except 子句匹配异常,

    异常处理器的搜索工作将继续在外层代码和调用栈上进行. [1]

    如果在 except 子句头部计算表达式时引发了异常,

    那么就会中断原异常处理器的搜索工作, 而在外层代码和调用栈上搜索新的异常处理器

    (就好像是整个 try 语句发生了异常一样).

    当找到了一个匹配的 except 子句时, 异常对象就被赋给

    except 子句中关键字 as 指定的目标对象 (如果给出),

    并且执行其后的语句序列. 每个 except 子句必须一个可执行代码块.

    当执行到该代码块末尾时, 会跳转到整个 try 语句之后继续正常执行

    (这意味着, 如果有两个嵌套的异常处理器要处理同一个异常的话,

    那么如果异常已经在内层处理了, 外层处理器就不会响应这个异常了).

    在使用 as target 形式将异常赋值时, 它会在 except

    子句结束时自动清除掉:

    except E as N:

    foo

    被转换为:

    except E as N:

    try:

    foo

    finally:

    del N

    这意味着如果你想在 except 子句之后访问这个异常,

    就必须在处理它时把它赋给另一个变量. 这么设计的原因在于回溯跟踪对象与这个异常关联,

    而它们与栈桢会构成了一个引用循环,

    从而使栈桢上所有局部变量直到下次垃圾回收时才被回收.

    在某个 except 子句的语句序列被执行前,

    异常的详细情况记录在 sys 模块中, 可以通过函数

    sys.exc_info() 访问. sys.exc_info() 返回一个元组,

    包括 exc_type, 异常类; exc_value, 异常实例;

    exc_traceback, 记录异常发生点的回溯对象 (见 标准类型层次

    ). sys.exc_info() 值会在处理异常的函数返回时会恢复它们之前的值

    (调用之前).

    当控制从 try 子句的尾部结束时 (即没有异常发生时),

    就执行可选的 else 子句. [2] 在 else

    子句中引发的异常不会在前面的 except 子句里得到处理.

    如果给出了 finally, 它就指定一个”清理”处理器 (cleanup

    handler). 这种语法下, try 子句会得到执行,

    也包括任何 except 和 else 子句.

    如果在任何子句中发生了异常, 并且这个异常没有得到处理, 该异常就会被临时保存起来.

    之后, finally 子句就会得以执行. 然后暂存的异常在

    finally 子句末尾被重新引发. 如果执行 finally

    子句时引发了另一个异常或执行了:keyword:return 或 break 语句,

    就会抛弃保存的异常. 在执行 finally 子句时异常信息是无效的.

    当在 try ...finally 语句中的 try

    语句序列中执行 return , break

    或 continue 时, finally 子句也会 “在退出的路上”

    被执行. 在 finally 子句中的 continue

    语句是非法的 (这缘于因为当前实现中的一个问题——以后可能会去掉这个限制).

    关于异常的更多信息可以在 Exceptions 中找到,

    关于如何使用 raise 语句产生异常的信息,

    可以在 The raise statement 中找到.

    7.5. with 语句¶

    with 语句用于封装上下文管理器 (见 With 语句的上下文管理器)

    定义的方法的代码块的执行. 这允许我们方便地复用常见的

    try...except...finally

    使用模式.

    with_stmt ::= "with" with_item ("," with_item)* ":" suite

    with_item ::= expression ["as" target]

    with 语句对一个 “item” 的执行按如下方式进行:

    对上下文表达式求值得到一个上下文管理器.

    调用上下文管理器的 __enter__() 方法.

    如果 with 语句包括有 target,

    就将 __enter__() 的返回值赋给它.

    Note

    with 语句保证了如果 __enter__() 是无错返回的,

    就一定会调用 __exit__() 方法. 如果在给 target list

    赋值时发生错误, 就按在语句序列里发生错误同样对待, 参见下面的步骤6.

    执行语句序列.

    调用上下文管理器的 __exit__() 方法. 如果语句序列导致了一个异常,

    那么异常的异常的类型,值和回溯对象都作为参数传递给 __exit__() 方法.

    否则, 使用 None 作为参数.

    如果语句序列因为异常退出, 且 __exit__() 方法返回假,

    那么异常就会重新抛出. 如果返回值为真, 异常就会被 “吃掉”,

    并且执行会在 with 语句之后继续.

    如果语句序列不是因为异常的原因退出的, 那么 __exit__()

    的返回值会被忽略掉, 并且在退出点后继续运行程序.

    使用多个项时, 上下文管理器就按多个嵌套 with 语句处理:

    with A() as a, B() as b:

    suite

    等价于:

    with A() as a:

    with B() as b:

    suite

    Changed in version 3.1:

    Changed in version 3.1:Support for multiple context expressions.

    See also

    PEP 0343 - The “with” statement

    Python with 语句的规范, 背景和例子.

    展开全文
  • 可以一行放一个表达式形成表达式语句,也可以一行放个表达式形成表达式语句,这时每个表达式后面都必须带“;”号,另外,还可以仅—个分号“;”占一行形成一个表达式语句,这种语句称为空语句。 空语句在程序...
  • 先上代码,对于基于f-statck协议栈改进项目时候,看到一段代码,内核里面的很宏也经常使用这种复合语句,看了相关的资料和博客,写下来自己的理解:static int (*real_clock_gettime) (clockid_t , struct ...
  • 作用,它能用于组合若干条语句形成功能块,能用做数组的下标等,而在 C 中括号的分 工较为明显,{}号是用于将若干条语句组合在一起形成一种功能块,这种若干条语句组合 而成的语句就叫复合语句复合语句之间用{}...
  • 55-C++复合语句(语句块)

    千次阅读 2018-09-07 23:46:24
    如果要在循环体中包含多条语句,这将很不方便。所幸的是,C++提供了避开这种限制的方式,通过这种方式可以在循环体中包含任意多条语句。方法是用两个花括号来构造一条复合语句(代码块)。代码块一对花括号和它们...
  • 作用,它能用于组合若干条语句形成功能块,能用做数组的下标等,而在 C 中括号的分 工较为明显,{}号是用于将若干条语句组合在一起形成一种功能块,这种若干条语句组合 而成的语句就叫复合语句复合语句之间用{}...
  • Java教程按照语句的组成部分,可以将顺序结构中的语句分为表达式语句、空语句和复合语句3 大类。下面首先介绍 Java 中语句的编写方式,然后对这 3 类语句进行详细介绍。 语句编写方式 在 Java 中,语句是最小的...
  • 所以我明白:The end of a logical line is represented by the token NEWLINE这意味着Python语法的定义方式结束逻辑行...在一条逻辑线可以等价于一条或多条物理线,也可以不等价于一条或多条物理线,但通常是一条,...
  • ​ 满足条件1:条件表达式1~条件表达式n:必要参数,可以多个表达式组成,但最后返回的结果一定要boolean类型 满足条件2:语句序列:可以是一条或者多条语句,当条件表达式1的值为true时,执行语句序列1;...
  • 按照语句的组成部分,可以将顺序结构中的语句分为表达式语句、空语句和复合语句3 大类。下面首先介绍Java中语句的编写方式,然后对这 3 类语句进行详细介绍。语句编写方式在 Java 中,语句是最小的组成单位,每个...
  • 按照语句的组成部分,可以将顺序结构中的语句分为表达式语句、空语句和复合语句 3 大类。 语句编写方式 在 Java 中,语句是最小的组成单位,每个语句必须使用分号作为结束符。除此之外,Java 对语句无任何其他限制,...
  • 只有分号“;...复合语句从形式上看是个语句的组合,但在语法意义上它是一个整体,相当于一条语句,所以凡是可以用简单语句的地方都可以用复合语句来实现。在程序设计中复合语句被看成是一条语句,而不...
  • 前言 ...本期是关于C语言输入输出语句相关的格式与复合语句,如有错误迎您提出您的看法。 目录 什么是赋值、什么是赋值语句? 数据的输入语句 例1:字符串原样输出 例2.指定宽度输出 数据的.
  • 复合语句以整个块为单位,能够用在任何一个单独语句可以用到的地方,并且在复合语句中还可以嵌套复合语句 在使用复合语句时要注意,复合语句为局部变量创造了一个作用域,该作用域为程序的一部分,在该作用域中的某...
  • 是构成程序的基本单位,通常一个c程序若干个函数(系统、用户)组成,每一函数若干条语句组成。每条语句总是以‘;’结束。2、c语句的分类(1)简单语句【1】表达式语句:一个表达式后跟“;”组成1—>赋值语句...
  • C程序的执行部分是由语句组成的。 程序的功能也是由执行语句实现的。C语句可分为以下五类:1.表达式语句2.标签语句3.循环语句4.复合语句5.跳转语句6.选择语句下面分别作详细说明:表达式语句表达式语句由表达式加上...
  • C语言:复合语句

    2022-03-30 22:46:21
    在程序中应把复合语句看成是单条语句,而不是多条语句,例如: { x=y+z; a=b+c; printf(“%d%d”,x,a); } 就是一条复合语句复合语句的作用: 1、作为分支和循环的块; 2、作为标识符的作用域。 C语言中可以...
  • Java语言基础(四)-复合语句

    千次阅读 2017-03-09 23:43:44
    复合语句、条件语句、循环语句、循环控制
  • 本着尽可能全跟简单的原则,总结了一些知识点,希望对大家... 复合语句:是由一对花括号括起来的一组语句。二、赋值运算符:=三、类型转换四、格式输出函数printf函数五、常见格式说明符六、格式输入scanf函数(类比prin
  • 作用,它能用于组合若干条语句形成功能块,能用做数组的下标等,而在 C 中括号的分 工较为明显,{}号是用于将若干条语句组合在一起形成一种功能块,这种若干条语句组合 而成的语句就叫复合语句...
  • 复合语句相关

    2022-01-07 15:05:47
    有对复合语句感到迷糊吗?

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 33,658
精华内容 13,463
关键字:

复合语句是由多条语句组成的