第5章程序控制结构

在传统的面向过程程序设计中有3种经典的控制结构，即顺序结构、选择结构和循环结构,再加上一些方便程序编写的其他语句，一个实际工程项目的编程问题就有了语句基础了。即使是在面向对象程序设计语言以及事件驱动或消息驱动应用开发中，也无法脱离这3种基本的程序结构。可以说，不管是用哪种程序设计语言，在实际开发中，为了实现特定的业务逻辑或算法，都不可避免地要用到大量的选择结构和循环结构，并且经常需要将选择结构和循环结构嵌套使用。
5.1条件表达式

在选择结构和循环结构中，都要使用条件表达式来确定下一步的执行流程。在Python中，单个常量、变量或者任意合法表达式都可以作为条件表达式。在条件表达式中可以使用的运算符包括： 
(1) 算术运算符： +、-、*、/、//、%、**。
(2) 关系运算符： >、<、==、<=、>=、!=。
(3) 测试运算符： in、not in、is、is not。
(4) 逻辑运算符： and、or、not。
(5) 矩阵运算符： ~、&、|、^、<<、>>。
(6) 位运算符： @。
在选择和循环结构中，条件表达式的值只要不是False、0(或0.0、0j等)、空值None、空列表、空元组、空集合、空字符串、空range对象或其他空迭代对象，Python解释器均认为与True等价。从这个意义上讲，几乎所有的Python合法表达式都可以作为条件表达式，包括含有函数调用的表达式。例如： 
例51条件表达式示例。

>>> if 3: #使用整数作为条件表达式

print 5

5

>>> a = ［1,2,3］#使用列表作为条件表达式

>>> if a:

print a

［1, 2, 3］

>>> a = ［］

>>> if a:

print a

else:

print 'empty'

empty

>>> s = t = 0

>>> while s< = 10:#使用关系表达式作为条件表达式

t+= s

s+= 1

>>> s = t = 0

>>> while True: #使用常量True作为条件表达式

t+= s

s+= 1

if s>10:

break

>>> t = 0

>>> for s in range(0,11,1):

t+= s

>>> s

10

>>> t

55


注意： 在Python中，条件表达式不允许使用赋值运算符“=”，避免误将关系运算符“==”写作赋值运算符“=”带来的麻烦，例如下面的代码，在条件表达式中使用赋值运算符“=”将抛出异常，提示语法错误。

>>> if a = 3:

SyntaxError: invalid syntax

5.2顺序结构


顺序结构是所有程序设计语言中执行流程的默认结构。在一个没有选择结构和循环结构的程序中，程序是按照语句书写的先后顺序依次执行的。图51是一个顺序结构的流程图，它有一个入口、一个出口，依次执行语句1和语句2。实现程序顺序结构的语句主要是赋值语句和内置的输入函数(input())和输出函数(print())。
5.2.1赋值语句
1. 赋值语句的格式

基本赋值语句的格式： 

<变量1>, <变量2>, ..., <变量n> = <表达式1>, <表达式2>, ..., <表达式n>

赋值语句的功能是分别将<表达式1>,<表达式2>,...,<表达式n>的值赋给<变量1>,<变量2>,...,<变量n>。
赋值语句还有增量赋值的形式： 

<变量> += <表达式>

这种增量赋值语句等价于： 

<变量> = <变量> + <表达式>

增量赋值语句不可以对多个变量增量赋值。可以用于增量赋值语句的运算符有+=、-=、*=、/=、//=、**=、%=、&=、|=、^=、>>=、<<=。
赋值语句还可以写成下面的形式： 

x = y = z = 1

该语句是将三个变量x、y、z都赋值为1。
注意： Python系统定义的对象是有类型的，变量没有类型。虽然通过赋值语句让某个变量得到表达式的值，但只是引用了这个对象的值(表达式的值)。所以，对于同一个变量，第一次通过赋值语句得到一个整数值，之后又可以通过赋值语句得到一个浮点类型的值。这就是变量没有类型，只是引用值的原因。
2. 赋值语句的应用
应用赋值语句的一个最经典的例子是交换两个变量的值。因为交换两个变量的值在后续内容中会经常用到，大量的实际问题中也需要交换两个变量的值。在其他程序设计语言中，这一段代码的经典写法是(使用第三方变量t暂存数据)： 

t = x

x = y

y = t

Python赋值语句的设计可以极其简单地完成交换两个变量的值的工作，只要一条语句即可解决： 

>>> x, y = y, x

5.2.2基本输入输出
数据的输入输出是应用程序不可缺少的功能。在Python 3.x中，数据的输入输出是通过调用函数来实现的，主要有input()函数、print()函数。而在Python 2.x中，输入通过input()函数，输出通过print语句。
1.  input()函数
在Python语言中，使用input()函数实现数据输入，input()函数的一般格式： 

x = input('提示串')

例52input()函数示例。

>>> x = input('x =')

x = #直接输入12.5，x是一个数字的字符串

>>> x

12.5

>>> x = input('x')

x = 'abcd' #直接输入'abcd'，x是字符串'abcd'

>>> x

'abcd'

>>> x = float(input('x = '))

x =#直接输入3.1415926，并转换为浮点型

>>> x

3.1415926


2.  print语句
print语句可以采用格式化输出形式： 

print '格式串'%(对象1, 对象2, ...)

其中，格式串用于指定后面输出对象的格式，格式串中可以包含随格式输出的字符，当然主要是对每个输出对象定义的输出格式。对于不同类型的对象采用不同的格式： 

输出字符串:%s
输出整数:%d
输出浮点数:%f
指定占位宽度:%10s, %10d, %-10f(都是指定10位宽度)
指定小数位数:%10.3f
指定左对齐:%-10s, %-10d, %-10f, %-10.3f
例如： 
例53print语句示例。

>>> print '%10d%10d%10.2f'%(1234568, 87655, 12.34567890123)

1234568 87655 12.35

>>> print '%-10d%-10d%-10.2f'%(1234568, 87655, 12.34567890123)

1234568 87655 12.35


5.2.3案例精选
案例51已知三角形三条边的边长，求三角形的面积。
提示： 三角形面积=p(p-a)(p-b)(p-c)，其中，a、b、c是三角形三边的边长，p是三角形周长的一半。
相关代码如下： 

import math

a = float(input("请输入三角形的边长a: "))

b = float(input("请输入三角形的边长b: "))

c = float(input("请输入三角形的边长c:"))

p = (a + b + c)/2#三角形周长的一半

area = math.sqrt(p * (p - a) * (p - b) * (p - c))

print str.format("三角形三边分别为:a = {0}, b = {1}, c = {2}", a, b, c)

print str.format("三角形的面积={0}", area)


案例51运行结果如下： 

请输入三角形的边长a: 3

请输入三角形的边长b: 4

请输入三角形的边长c: 5

三角形三边分别为:a = 3.0, b = 4.0, c = 5.0

三角形的面积=6.0


5.3选择结构

在顺序结构中，程序只能机械地从头运行到尾，要想使计算机变得更“智能”，就需要应用选择结构。所谓选择结构，就是按照给定条件有选择地执行程序中的语句。在Python语言中，程序选择结构有： 单分支选择结构(if语句)、双分支选择结构(if…else语句)和多分支选择结构(if…elif语句)。
5.3.1单分支选择结构
单分支选择结构是最简单的一种选择形式，其语法如下所示： 

if <表达式>:

<语句块>

其中： 


图51if语句的流程图

(1) 表达式是任意的数值、字符、关系或逻辑表达式，或用其他数据类型表示的表达式。它表示条件，以True(1)表示真，False(0)表示假。
(2) 语句块称为if语句的内嵌语句或字句，内嵌语句严格地以缩进方式表达，编辑器也会提示程序员开始书写内嵌语句的位置，如果不再缩进，表示内嵌语句在上一行已经完成。
执行顺序： 首先计算<表达式>的值，若<表达式>的值为True，则执行内嵌语句，否则不做任何操作。if语句的流程图如图51所示。
当表达式值为True或其他等价值时，表示条件满足，语句块将被执行，否则该语句块将不被执行。

x = input('Input two numbers:')

a,b = map(int,x.split())

if a>b:

a,b = b,a

print a,b


注意： 表达式后面的冒号“:”是不可缺少的，表示一个语句块的开始，后面几种其他形式的选择结构和循环结构中的冒号也是必须有的。

5.3.2双分支选择结构


图52if…else语句的流程图


双分支选择结构的语法为： 

if <表达式>:

<语句块1>

else:

<语句块2>


执行顺序： 首先计算<表达式>的值，若<表达式>的值为True或其他等价值时，执行<语句块1>，否则执行<语句块2>。if…else语句的流程图如图52所示。

>>> a = ［'1','2','3','4','5'］

>>> if a:

print a

else:

print 'Empty'

［'1', '2', '3', '4', '5'］


例54输入一个年份year，判断是否为闰年。
分析： 闰年的条件是： ①能被4整除但不能被100整除； ②能被400整除。
用逻辑表达式表示为： 

(year%4 == 0 and year%100!= 0) or (year%400 == 0)

程序代码如下： 

year = input("输入年份:")#可用int()函数

if (year%4 == 0 and year%100 != 0) or (year%400 == 0):

print year,":闰年"

else:

print year,": 平年"


两次运行程序，程序运行结果如下： 

输入年份:'2008'

2008 :闰年

输入年份:'2017'

2017 : 平年

Python还支持如下形式的表达式： 

value1 if condition else value2

当条件表达式condition的值与True等价时，表达式的值为value1，否则表达式的值为value2。另外，在value1和value2中还可以使用复杂表达式，包括函数调用和基本输出语句。下面代码演示了上述表达式的用法。

>>> a = 10

>>> b = 1 if a>5 else 0

>>> b

1

5.3.3多分支选择结构
多分支选择结构为用户提供了更多的选择，可以实现复杂的业务逻辑，多分支选择结构的语法为： 

if <表达式1>:

<语句块1>

elif <表达式2>:

<语句块2>

......

elif <表达式n>:

<语句块n>

else:

<语句块n+1>

其中，关键字elif是else if的缩写。
执行顺序： 首先计算<表达式1>的值，若其值为True或其他等价值时，执行<语句块1>； 否则，继续计算<表达式2>的值，若其值为True或其他等价值时，执行<语句块2>； 以此类推，如果所有表达式的值都为False，则执行<语句块n+1>。if…elif语句的流程图如图53所示。


图53if…elif语句的流程图


注意： 
(1) 不管有几个分支，程序执行了一个分支以后，其余分支不再执行。
(2) 当多分支中有多个表达式同时满足条件时，则只执行第一条与之匹配的语句。
例55多分支选择if…elif语句实例。

score = int(input("please input your score:"))



if score >=90:

print "Grade A"

elif score >=80:

print "Grade B"

elif score >=70:

print "Grade C"

elif score >=60:

print "Grade D"

else:

print "You fail in the test!"


运行本程序三次，运行结果如下： 

please input your score:78

Grade C

please input your score:99

Grade A

please input your score:59

You fail in the test!


5.3.4if语句和if…else语句的嵌套形式
如果if语句和if…else语句的内嵌语句又是一个if语句或if…else语句，则称这种形式为if语句(或if…else语句)的嵌套形式。例如： 

if <表达式1>:

if <表达式2>:

 <语句块1>

else:

 <语句块2>

［else:

if <表达式3>:

 <语句块3>

else:

 <语句块4>］


如果上面的一般格式中没有方括号中的内容，就会出现else与哪个if匹配的问题，有可能导致语义错误，就是所谓的else悬挂问题。对于其他语言程序，如C++，就要强制else与最近的if匹配。好在Python以严格的缩进方式表达匹配，不需要指定。
实际上，用if语句(或if…else语句)的嵌套形式完全可以替代if…elif语句。但从程序结构上讲，后者更清晰。
对于例55，完全可用嵌套形式表达如下： 

score = int(input("please input your score:"))

if score >=60:



if score >=90:

print "Grade A"

elif score >=80:

print "Grade B"

elif score >=70:

print "Grade C"

elif score >=60:

print "Grade D"

else:

print "You fail in the test!"


同样运行本程序三次，运行结果如下： 

please input your score:78

Grade C

please input your score:99

Grade A

please input your score:59

You fail in the test!

由上可见，程序语言中的某些语句只是为了方便程序员写程序，不一定是必要的，但是程序中判断语句的层越多，程序的可读性就越差。如果在设计的时候出现了太多层，还是要想办法再重新构想一下比较简单的流程。
5.3.5案例精选
案例52面试资格确认。
某公司招聘，要求至少满足以下条件中的两项： 
(1) 不超过25岁； 
(2) 计算机专业； 
(3) 硕士研究生学历。
编写程序，判断24岁的计算机学士是否能获得面试机会。
参考代码如下： 

age = 24

subject = "计算机"

degree = "学士"

if (age > 25 and degree == "硕士") or (degree == "硕士" and subject == "计算机") or (age <= 25 and subject == "计算机"):

print '恭喜,您已获得我公司的面试机会!'

else:

print '抱歉,您未达到面试要求'


案例52运行结果如下： 

恭喜,您已获得我公司的面试机会！

案例53已知坐标点(x,y)，判断其所在的象限。
相关代码如下： 

x = int(input("请输入x坐标:"))

y = int(input("请输入y坐标:"))

if(x == 0 and y == 0):print "位于原点"

elif(x == 0):print "位于y轴"

elif(y == 0):print "位于x轴"

elif(x > 0 and y > 0):print "位于第一象限"

elif(x < 0 and y > 0):print "位于第二象限"

elif(x < 0 and y < 0):print "位于第三象限"

else:print "位于第四象限"


案例53运行结果如下： 

请输入x坐标: -2

请输入y坐标: 5

位于第二象限

案例54输入三个数，按照从大到小的顺序排序。
假设有三个数a、b和c，先让a和b比较，使得a>b； 然后比较a和c，使得a>c，此时a最大； 最后b和c比较，使得b>c。

a = int(input("请输入整数a:"))

b = int(input("请输入整数b:"))

c = int(input("请输入整数c:"))

if(a<b): t=a; a=b; b=t

if(a<c): t=a; a=c; c=t

if(b<c): t=b; b=c; c=t

print "排序结果(降序):", a, b, c

案例54运行结果如下： 

请输入整数a: 5

请输入整数b: 4

请输入整数c: 6

排序结果(降序): 6 5 4

案例55判断某一年是否为闰年(例54的多种解决方法)。
判断闰年的条件是： 年份能被4整除但不能被100整除，或者能被400整除，其判断流程参见图53。


图53是否为闰年的判断条件



year = 2017

方法一： 使用一个逻辑表达式包含所有的闰年条件。相关语句如下： 

if(year%4 == 0 and year%100 != 0) or (year%400 == 0):

print "是闰年"

else:print("不是闰年")

方法二： 使用嵌套的if语句。相关语句如下： 

if(year%400 == 0):print("是闰年")

else:

if(year%4 == 0):

if(year%100 == 0):print "不是闰年"

else:print "是闰年"

else:print "不是闰年"


方法三： 使用if…elif语句。相关语句如下： 

if(year%400 == 0):print "是闰年"

elif(year%4 != 0):print "不是闰年"

elif(year%100 == 0):print "不是闰年"

else:print "是闰年"


方法四： 使用calendar模块的isleap函数来判断闰年。相关语句如下： 

import calendar

if(calendar.isleap(year)):print "是闰年"

else:print "不是闰年"


5.4循环结构

所谓循环结构，就是按照给定规则重复地执行程序中的语句。实现程序循环结构的语句称为循环语句。Python提供了两种基本的循环结构： while循环和for循环。其中，while循环一般用于循环次数难以提前确定的情况，当然也可以用于循环次数确定的情况； for循环一般用于循环次数可以提前知道的情况，尤其适用于枚举或遍历序列或迭代对象中元素的场合，编程时一般建议优先考虑使用for循环。相同或不同的循环结构之间可以互相嵌套，也可以与选择结构嵌套使用，用来实现更为复杂的逻辑。
5.4.1while语句
while语句用于实现当型循环结构，其特点是： 先判断、后执行。
语法格式： 

while <条件表达式>:

<循环体>


其中： 
(1) <条件表达式>称为循环条件，可以是任何合法的表达式，其值为True或False，它用于控制循环是否继续进行。


图54while语句流程图


(2) <循环体>是要被重复执行的代码行。
执行顺序： 首先判断条件<表达式>的值，若为True，则执行<循环体>，继而再判断<条件表达式>，直至条件<表达式>值为False时退出循环，如图54所示。
例56while语句示例： 求自然数1~100之和。
分析： 这是一个累加求和的问题，循环结构的算法是，定义两个int变量，i表示加数，其初值为1； sum表示和，其初值为0。首先将sum和i相加，然后i增1，再与sum相加并存入sum，直到i大于100为止。
程序代码如下： 

i = 1

sum = 0

while i <= 100:

sum += i

i += 1



print "sum = ", sum


程序运行结果如下： 

sum =  5050

当应用while语句时，要注意以下几点： 
(1) 在循环体中应该有改变循环条件表达式值的语句，否则将会造成无限循环。例如在例56中，如果没有语句i+=1，那么i的值始终不发生变化，循环也就永远不会终止。
(2) 该循环结构是先判断后执行循环体，因此，若<条件表达式>的值一开始就是False，则循环体一次也不执行，直接退出循环。
(3) 在设置循环条件时，要留心边界值，以免多执行一次或少执行一次。
例57while语句示例： 求出满足不等式1+2+3+…+n≤100的最大n值。
此不等式的左边是一个和式，该和式中的数据项个数是未知的，也正是要求出的。对于和式中的每个数据项，对应的通式为i(i = 1,2,3,…,n)，所以可以采用循环累加的方法计算出和式的和。设循环变量为i，它应从1开始取值，每次增加1，直到和式的值不大于100为止，此时的i值就是所求的n。设累加变量为s，在循环体内应把i的值累加到s。
程序代码如下： 

i = 0

s = 0

while s<100:

i += 1

s += i



print "n = ",i


程序运行结果如下： 

n =  14


5.4.2for语句
for语句的语法格式为： 

for <变量> in <可迭代容器>:

<语句块>


其中，<变量>可以扩展为变量表，变量与变量之间用“,”分开，<可迭代容器>可以是序列、迭代器或其他支持迭代的对象。
执行顺序： <变量>取遍<可迭代容器>中的每一个值。每取一个值，如果这个值在<可迭代容器>中，执行<语句块>，返回，再取下一个值，再判断，再执行，...，直到遍历完成或发生异常退出循环。
for语句是Python语言提供的最强大的循环结构。for语句主要用于访问序列和迭代器(iterator)。迭代器是一个可以标识序列中元素的对象。序列与迭代器的区别为： for语句的语法格式中的<可迭代容器>可以直接是一个字符串、列表、元组等，还可以用一些函数产生序列或迭代器。如果函数产生的是序列，如range()、sorted()函数，那么，for语句访问的是序列。如果函数产生的是迭代器，如enumerate()、reversed()、zip()函数，for语句访问的是迭代器，例如： 

>>> s = ［0, 1, 2, 3, 100, 'ABC'］

>>> s

［0, 1, 2, 3, 100, 'ABC'］

>>> enumerate(s)

<enumerate at 0xa31d048>

>>> type(enumerate(s))

enumerate

>>> zip(s)

［(0,), (1,), (2,), (3,), (100,), ('ABC',)］

>>> type(zip(s))

list

>>> reversed(s)

<listreverseiterator at 0xa1f5fd0>

>>> type(reversed(s))

listreverseiterator

>>> s = ［"XYZ", "Hello", "ABC", "Python"］

>>> sorted(s)

［'ABC', 'Hello', 'Python', 'XYZ'］

>>> range(10)

［0, 1, 2, 3, 4, 5, 6, 7, 8, 9］

>>> x = sorted(s)

>>> x

［'ABC', 'Hello', 'Python', 'XYZ'］

>>> x［3］

'XYZ'

>>> y = range(10)

>>> y［8］

8


例58for语句应用示例。

>>> s = ［"XYZ", "Hello", "ABC", "Python"］ #使用序列迭代

>>> for i in s:

print i

XYZ

Hello

ABC

Python

>>> s = ［"XYZ", "Hello", "ABC", "Python"］ #使用序列索引迭代

>>> for i in range(len(s)):

print i, s［i］

0 XYZ

1 Hello

2 ABC

3 Python

>>> x = range(5)

>>> for i in x:#使用数字对象迭代

print i,x［i］

0 0

1 1

2 2

3 3

4 4

>>> s = ［"XYZ", "Hello", "ABC", "Python"］

>>> s1 = ［200, 300, 1000, 500, 800］

>>> for x, y in zip(s, s1):#使用迭代器迭代

print "%8s%8s"%(x,y)

XYZ200

Hello 300

ABC1000

Python 500


5.4.3多重循环
多重循环又称为循环嵌套，是指在某个循环语句的循环体内还可以包含有循环语句。在实际应用中，两种循环语句不仅可以自身嵌套，还可以相互嵌套，嵌套的层数没有限制，呈现出多种复杂形式。在嵌套时，要注意在一个循环体内包含另一个完整的循环体。例如： 

while <表达式1>:

...

while <表达式2>:

<循环体>

...

for <变量> in <可迭代容器>:

<循环体>

...


例59编程输出“9×9乘法表”。

>>> for i in range(1, 10):

>>> for j in range(1,i+1):

>>> print i, '*', j, '=', i*j

1 * 1 = 1 

2 * 1 = 2 

2 * 2 = 4 

…… 

9 * 1 = 9 

9 * 2 = 18

9 * 3 = 27

9 * 4 = 36

9 * 5 = 45

9 * 6 = 54

9 * 7 = 63

9 * 8 = 72

9 * 9 = 81


5.4.4break、continue、pass、else语句
1.  break语句



break语句用在循环语句(迭代)中，结束当前的循环(迭代)跳转到循环语句的下一条。break语句常常与if语句联合，满足某条件时退出循环(迭代)。
例510break语句示例。

#输入一个数，判断是否为质数。

from math import *

x = input("输入一个数:")

i = 2

while i< = int(sqrt(x)):

if x%i == 0:

break

i = i+1



if i>int(sqrt(x)):

print x,":质数"

else:

print x,":非质数"


运行程序两次，运行结果如下： 

输入一个数:'4'

4 :非质数

输入一个数:'5'

5 :质数

2.  continue语句
continue语句用在循环语句(迭代)中，忽略循环体内continue语句后面的语句，回到下一次循环(迭代)。
图55是以while循环结构为例，说明执行含有break语句或continue语句的循环时流程变化的示意图。


图55break和continue语句的区别


例511continue语句应用示例。

s = 0

for i in range(1,11):

if i%2 == 0:

continue

if i%10 == 7:

break

s = s + i

print "s = ", s


程序运行结果如下： 

s = 9

3. pass语句
pass语句可以用在任何地方，不做任何事情，只起到占位的作用，例如： 

>>> pass

>>> if True:

pass

>>> while 1:

pass


4. else语句
在Python语句中，else语句还可以在while语句或for语句中使用。else语句(块)写在while语句或for语句尾部，当循环语句或迭代语句正常退出(达到循环重点，或迭代完所有元素)时，执行else语句下面的语句块。这意味着break语句也会跳出else语句。
例512输入一个数，判断是否为质数。

from math import *

x = input("输入一个数:")

i = 2

while i <=int(sqrt(x)):

if x%i==0:

print x," :非质数"

break

i = i + 1

else:

printx," :质数"


运行程序两次，运行结果如下： 

输入一个数:'4'

4 :非质数

输入一个数:'5'

5 :质数

break语句和continue语句在while循环和for循环中都可以使用，并且一般常与选择结构结合使用，以达到在特定条件得到满足时跳出循环的目的。一旦break语句被执行，将使得整个循环提前结束。continue语句的作用是终止本次循环，并忽略continue之后的所有语句，直接回到循环的顶端，提前进入下一次循环。需要注意的是，过多的break和continue语句会严重降低程序的可读性。除非break和continue语句可以让代码更简单或更清晰，否则不要轻易使用。
5.4.5案例精选
案例56求1~100能被5整除，但不能同时被6整除的所有整数。

t = ［］

for i in range(1, 101):

if i % 5 ==0 and i % 6 != 0:

t.append(i)

print t


案例56运行结果如下： 

［5, 10, 15, 20, 25, 35, 40, 45, 50, 55, 65, 70, 75, 80, 85, 95, 100］


习题5

一、 单选题
1. 执行下列Python语句将产生的结果是()。

x = 2; y = 2.0

if(x == y): print "Equal"

else: print "Not Equal"


A. EqualB. Not EqualC. 编译错误D. 运行时错误
2. 执行下列Python语句将产生的结果是()。

i = 1

if(i):print True

else:print False

A. TrueB. FalseC. 1D. 运行时错误
3. 下面if语句统计满足“性别(gender)为男、职称(duty)为副教授、年龄(age)不大于40岁”条件的人数，正确的语句为()。
A.  if (gender=="男" or age<=40 and duty=="副教授")： n+=1
B.  if (gender=="男" and age<=40 and duty=="副教授")： n+=1
C.  if (gender=="男" and age<=40 or duty=="副教授")： n+=1
D.  if (gender=="男" or age<=40 or duty=="副教授")： n+=1
4.  Python语句x=True； y=False； z=False； print( x or y and z)的运行结果是()。
A. TrueB. False
C. 1D. 运行时错误
5. 循环语句for i in range(3,21,4)的循环次数为()。
A.  5B. 6C. 7D. 8
6. 若k为整型，下述while循环执行的次数为()。

k=1000

while k>1:

print k

k = k/2

A.  9B. 10C. 11D. 1000
7. 下列语句不符合语法要求的表达式为()。

for var in :

print var

A. range(0,10)B. “Hello”
C. (1,2,3)D. {1,2,3,4,5}
二、 多项选择题
1. 以下for语句结构中，()能完成1~10的累加功能。
A. sum=0； for i in range(10,0)： sum+=i
B. sum=0； for i in range(1,11)： sum+=i
C. sum=0； for i in range(10,0,-1)： sum+=i
D. sum=0； for i in (10,9,8,7,6,5,4,3,2,1)： sum+=i
E. sum=0； for i in (1,2,3,4,5,6,7,8,9,10)： sum+=i
2. Python提供了两种基本的循环结构为()。
A. for循环
B. while循环
C. if循环
D. if…elif循环
E. continue循环
三、 判断题
1.  Python语句x=True； y=False； z=False； print x or y and z的运行结果是True。()
2. 假设有表达式“表达式1 or表达式2”，如果表达式1的值等价于True，那么无论表达式2的值是什么，整个表达式的值总是等价于True。()

3. 已知a=3； b=5； c=6； d=True，则表达式not d or a>=0 and a+c>b+3的值是False。()
四、 上机实践
1. 编写程序，计算10+9+8+…+1。
2. 编写程序，计算2+4+6+…+100。
3. 编写程序，输出2000—3000年之间的所有闰年。请思考有哪几种实现方法。